Metrics and Analysis 

Returns:

List of (node_id, topsis_score) tuples, sorted by score descending.

get_top_nodes(hypernetwork, percentage)[source]

Get top percentage of nodes by TOPSIS ranking.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
percentage (float) – Percentage of top nodes to return (0-100).

Return type:

Returns:

List of top node IDs.

get_bottom_nodes(hypernetwork, percentage)[source]

Get bottom percentage of nodes by TOPSIS ranking.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
percentage (float) – Percentage of bottom nodes to return (0-100).

Return type:

Returns:

List of bottom node IDs.

hiper.metrics.hyperedge_topsis

hyperedge_topsis.py

TOPSIS-based ranking system for hyperedges using specialized criteria.

Evaluates hyperedges based on size, number of intersections with other hyperedges, and encapsulation relationships for targeted removal experiments.

class hiper.metrics.hyperedge_topsis.HyperedgeTopsisRanker[source]

Bases: object

TOPSIS-based ranking system for hyperedges using specialized criteria.

Evaluates hyperedges based on size, number of intersections with other hyperedges, and encapsulation relationships.

__init__()[source]: Initialize the TOPSIS ranker for hyperedges.

rank_hyperedges(hypernetwork, weights=None)[source]

Rank hyperedges using TOPSIS method with specialized criteria.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph for analysis.
weights (Optional[Dict[str, float]]) – Optional weights for criteria. Default: equal weights. Expected keys: ‘size’, ‘intersections’, ‘encapsulation’

Return type:

Returns:

List of (hyperedge_id, topsis_score) tuples, sorted by score descending.

hiper.metrics.wsm

wsm.py

Implements WSM (Weighted Sum Model) method for ranking hypergraph nodes based on multiple criteria.

WSM is a simpler MCDM method that uses weighted normalization and summation to rank alternatives. It is expected to provide comparable but potentially less sophisticated results compared to TOPSIS.

class hiper.metrics.wsm.WSMNodeRanker[source]

Bases: object

Ranks hypergraph nodes using WSM (Weighted Sum Model) multi-criteria decision method.

Criteria used (same as TOPSIS for comparability): 1. Number of hyperedges containing the node (hyperdegree) 2. Number of nodes in the neighborhood 3. Average clustering coefficient of the neighborhood 4. Degree centrality of the node 5. Binary indicator for participation in closed triads

__init__()[source]: Initialize WSM ranker.

rank_nodes(hypernetwork, weights=None)[source]

Rank nodes using WSM method.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
weights (List[float]) – Weights for criteria (default: equal weights).

Return type:

Returns:

List of (node_id, wsm_score) tuples, sorted by score descending.

get_top_nodes(hypernetwork, percentage)[source]

Get top percentage of nodes by WSM ranking.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
percentage (float) – Percentage of top nodes to return (0-100).

Return type:

Returns:

List of top node IDs.

get_bottom_nodes(hypernetwork, percentage)[source]

Get bottom percentage of nodes by WSM ranking.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
percentage (float) – Percentage of bottom nodes to return (0-100).

Return type:

Returns:

List of bottom node IDs.

hiper.metrics.moora

moora.py

Implements MOORA (Multi-Objective Optimization on basis of Ratio Analysis) method for ranking hypergraph nodes based on multiple criteria.

MOORA is a simple MCDM method that uses vector normalization and weighted summation. It is simpler than TOPSIS and expected to provide comparable but potentially less sophisticated results.

class hiper.metrics.moora.MOORANodeRanker[source]

Bases: object

Ranks hypergraph nodes using MOORA (Multi-Objective Optimization on basis of Ratio Analysis) multi-criteria decision method.

Criteria used (same as TOPSIS for comparability): 1. Number of hyperedges containing the node (hyperdegree) 2. Number of nodes in the neighborhood 3. Average clustering coefficient of the neighborhood 4. Degree centrality of the node 5. Binary indicator for participation in closed triads

__init__()[source]: Initialize MOORA ranker.

rank_nodes(hypernetwork, weights=None)[source]

Rank nodes using MOORA method.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
weights (List[float]) – Weights for criteria (default: equal weights).

Return type:

Returns:

List of (node_id, moora_score) tuples, sorted by score descending.

get_top_nodes(hypernetwork, percentage)[source]

Get top percentage of nodes by MOORA ranking.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
percentage (float) – Percentage of top nodes to return (0-100).

Return type:

Returns:

List of top node IDs.

get_bottom_nodes(hypernetwork, percentage)[source]

Get bottom percentage of nodes by MOORA ranking.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
percentage (float) – Percentage of bottom nodes to return (0-100).

Return type:

Returns:

List of bottom node IDs.

Structural Metrics

hiper.metrics.connectivity

connectivity.py

Implements hypergraph and hyperedge connectivity metrics.

class hiper.metrics.connectivity.HypergraphConnectivity(s=1)[source]

Bases: object

Computes hypergraph connectivity κ(H).

The connectivity κ(H) is the minimum number of nodes that must be removed to disconnect the hypergraph or reduce it to a single isolated node.

__init__(s=1)[source]

Initialize with s-walk parameter.

Parameters:: s (int) – Parameter for s-walk connectivity computation.

compute(hypernetwork)[source]

Compute hypergraph connectivity.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: int
Returns:: Connectivity value κ(H).

class hiper.metrics.connectivity.HyperedgeConnectivity(s=1)[source]

Bases: object

Computes hyperedge connectivity λ(H).

The hyperedge connectivity λ(H) is the minimum number of hyperedges that must be removed to disconnect the hypergraph.

__init__(s=1)[source]

Initialize with s-walk parameter.

Parameters:: s (int) – Parameter for s-walk connectivity computation.

compute(hypernetwork)[source]

Compute hyperedge connectivity.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: int
Returns:: Hyperedge connectivity value λ(H).

hiper.metrics.distance

distance.py

Implements hypergraph distance computations and path finding algorithms. Provides s-walk and hyperpath functionality.

class hiper.metrics.distance.HypergraphDistance(s=1)[source]

Bases: object

Computes distances and paths in hypergraphs using s-walk semantics.

An s-walk is a sequence of alternating nodes and hyperedges where each hyperedge intersects at least s previously visited nodes in the walk.

__init__(s=1)[source]

Initialize with parameter s for s-walk computation.

Parameters:: s (int) – Minimum intersection requirement for s-walks.

is_valid_s_walk(hypernetwork, walk)[source]

Check if a walk is a valid s-walk.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
walk (List[Tuple[int, int]]) – List of (node_id, edge_id) pairs representing the walk.

Return type:

bool

Returns:

True if the walk satisfies s-walk conditions.

find_shortest_s_walk(hypernetwork, source, target)[source]

Find shortest s-walk between two nodes using BFS.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
source (int) – Source node ID.
target (int) – Target node ID.

Return type:

Optional[List[int]]

Returns:

List of edge IDs forming shortest s-walk, or None if no path.

compute_distance(hypernetwork, source, target)[source]

Compute s-walk distance between two nodes.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
source (int) – Source node ID.
target (int) – Target node ID.

Return type:

Returns:

Length of shortest s-walk, or infinity if no path exists.

compute_all_distances(hypernetwork)[source]

Compute all pairwise s-walk distances.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: Dict[Tuple[int, int], float]
Returns:: Dictionary mapping (source, target) pairs to distances.

is_connected(hypernetwork)[source]

Check if hypergraph is connected using s-walk semantics.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: bool
Returns:: True if all node pairs are connected by s-walks.

hiper.metrics.redundancy

redundancy.py

Implements the redundancy coefficient ρ(H) for hypergraphs.

class hiper.metrics.redundancy.RedundancyCoefficient[source]

Bases: object

Computes the redundancy coefficient ρ(H).

The redundancy coefficient measures the average degree of normalized overlap between pairs of hyperedges in the hypergraph.

Formula: \(\rho(H) = \frac{2}{|E|(|E|-1)} \sum_{\substack{e_1, e_2 \in E \\ e_1 \neq e_2 \\ e_1 < e_2}} \frac{|e_1 \cap e_2|}{\sqrt{|e_1| \cdot |e_2|}}\)

The sum is over all unordered pairs of distinct hyperedges.

static compute(hypernetwork)[source]

Compute the redundancy coefficient.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: float
Returns:: Redundancy coefficient value ρ(H) in range [0, 1].

static compute_pairwise_overlaps(hypernetwork)[source]

Compute detailed pairwise overlap information.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: List[tuple]
Returns:: List of tuples (edge1_id, edge2_id, intersection_size, normalized_overlap).

get_most_overlapping_pairs(hypernetwork, top_k=5)[source]

Get the k most overlapping hyperedge pairs.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
top_k (int) – Number of top pairs to return.

Return type:

List[tuple]

Returns:

List of top k overlapping pairs sorted by normalized overlap.

hiper.metrics.swalk

swalk.py

Implements s-walk efficiency metrics for hypergraphs.

class hiper.metrics.swalk.SwalkEfficiency(s=1)[source]

Bases: object

Computes average s-walk efficiency ℰs(H).

The s-walk efficiency measures how efficiently nodes can reach each other via s-walks, computed as the average of inverse distances.

Formula: \(\mathcal{E}_s(H) = \frac{1}{|V|(|V|-1)} \sum \frac{1}{d_H^s(u,v)}\) for all pairs \(u,v \in V\) with \(u \neq v\).

__init__(s=1)[source]

Initialize with s-walk parameter.

Parameters:: s (int) – Parameter for s-walk computation.

compute(hypernetwork)[source]

Compute average s-walk efficiency.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: float
Returns:: S-walk efficiency value ℰs(H) in range [0, 1].

compute_detailed(hypernetwork)[source]

Compute detailed s-walk efficiency statistics.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: Dict[str, float]
Returns:: Dictionary with efficiency statistics including average, min, max.

compute_node_efficiencies(hypernetwork)[source]

Compute individual node efficiency scores.

Parameters:: hypernetwork (Hypernetwork) – Target hypergraph.
Return type:: Dict[int, float]
Returns:: Dictionary mapping node IDs to their efficiency scores.

find_critical_nodes(hypernetwork, top_k=5)[source]

Find nodes whose removal would most impact s-walk efficiency.

Parameters:

hypernetwork (Hypernetwork) – Target hypergraph.
top_k (int) – Number of critical nodes to return.

Return type:

list

Returns:

List of (node_id, efficiency_impact) tuples.

Higher-Order Metrics

hiper.metrics.higher_order_cohesion

higher_order_cohesion.py

Implements Higher-Order Cohesion Resilience (HOCR) and Largest Higher-Order Component (LHC) metrics for analyzing hypergraph resilience based on m-th order components.

The m-th higher-order component is defined as a set of hyperedges where each hyperedge shares at least m nodes with another hyperedge in the same component.

class hiper.metrics.higher_order_cohesion.HigherOrderCohesionMetrics(m=2)[source]

Bases: object

Computes Higher-Order Cohesion Resilience (HOCR) and Largest Higher-Order Component (LHC) metrics for hypergraph resilience analysis.

These metrics evaluate how perturbations affect the higher-order structure of hypergraphs by analyzing components where hyperedges share at least m nodes.

__init__(m=2)[source]

Initialize the higher-order cohesion metrics calculator.

Parameters:: m (int) – Minimum number of shared nodes required between hyperedges in the same m-th order component. Must be >= 2.
Raises:: ValueError – If m < 2.

compute_mth_order_components(hypernetwork)[source]

Compute the m-th higher-order components of the hypernetwork.

An m-th higher-order component is a set of hyperedges where each hyperedge shares at least m nodes with another hyperedge in the same component.

Parameters:: hypernetwork (Hypernetwork) – The input hypergraph.
Return type:: List[List[int]]
Returns:: List of components, where each component is a list of hyperedge indices.

compute_hocr_m(original_hypernetwork, perturbed_hypernetwork)[source]

Compute Higher-Order Cohesion Resilience (HOCR_m).

HOCR_m measures the normalized preservation of higher-order structure after perturbation by comparing the total number of hyperedges in m-th order components before and after perturbation.

Parameters:

original_hypernetwork (Hypernetwork) – The original hypergraph.
perturbed_hypernetwork (Hypernetwork) – The hypergraph after perturbation.

Return type:

Returns:

HOCR_m value in [0, 1], where 1 indicates perfect preservation.

compute_lhc_m(original_hypernetwork, perturbed_hypernetwork)[source]

Compute Largest Higher-Order Component (LHC_m) resilience.

LHC_m measures how well the largest m-th order component is preserved after perturbation.

Parameters:

original_hypernetwork (Hypernetwork) – The original hypergraph.
perturbed_hypernetwork (Hypernetwork) – The hypergraph after perturbation.

Return type:

Returns:

LHC_m value in [0, 1], where 1 indicates perfect preservation.

compute_all_metrics(original_hypernetwork, perturbed_hypernetwork)[source]

Compute both HOCR_m and LHC_m metrics.

Parameters:

original_hypernetwork (Hypernetwork) – The original hypergraph.
perturbed_hypernetwork (Hypernetwork) – The hypergraph after perturbation.

Return type:

Dict[str, float]

Returns:

Dictionary containing both metrics.

analyze_component_distribution(hypernetwork)[source]

Analyze the distribution of m-th order components in the hypergraph.

Parameters:: hypernetwork (Hypernetwork) – The input hypergraph.
Return type:: Dict[str, Any]
Returns:: Dictionary with detailed component analysis.

hiper.metrics.hyperedge_fragmentation

hyperedge_fragmentation.py

This module implements the Hyperedge Fragmentation Index (HFI) metric for measuring how much hyperedges have been fragmented by perturbations.

class hiper.metrics.hyperedge_fragmentation.HyperedgeFragmentationIndex[source]

Bases: object

Computes the Hyperedge Fragmentation Index (HFI) metric.

The Hyperedge Fragmentation Index measures how much the original hyperedges have been fragmented by a perturbation:

\(\text{HFI} = 1 - \frac{1}{|E|} \sum_{e \in E} \frac{|e \cap V'|}{|e|}\)

where: - E is the original set of hyperedges - V’ is the set of nodes after perturbation - \(e \cap V'\) is the intersection of original hyperedge e with remaining nodes - \(|e|\) is the original size of hyperedge e

A value of 0.0 indicates no fragmentation (all hyperedges intact), while 1.0 indicates complete fragmentation (all hyperedges destroyed).

__init__()[source]: Initialize the Hyperedge Fragmentation Index metric.

static compute(perturbed_hypergraph, original_hypergraph)[source]

Compute the Hyperedge Fragmentation Index metric.

Parameters:

perturbed_hypergraph (Hypernetwork) – The hypergraph after perturbation.
original_hypergraph (Hypernetwork) – The original hypergraph before perturbation.

Return type:

Returns:

The hyperedge fragmentation index value in [0, 1].

Raises:

ValueError – If original_hypergraph has no hyperedges.

static compute_detailed(perturbed_hypergraph, original_hypergraph)[source]

Compute detailed fragmentation statistics.

Parameters:

perturbed_hypergraph (Hypernetwork) – The hypergraph after perturbation.
original_hypergraph (Hypernetwork) – The original hypergraph before perturbation.

Return type:

Returns:

Dictionary containing detailed fragmentation analysis.

static get_hyperedge_fragmentation_map(perturbed_hypergraph, original_hypergraph)[source]

Get fragmentation status for each individual hyperedge.

Parameters:

perturbed_hypergraph (Hypernetwork) – The hypergraph after perturbation.
original_hypergraph (Hypernetwork) – The original hypergraph before perturbation.

Return type:

Returns:

Dictionary mapping hyperedge IDs to their fragmentation status.

__str__()[source]

String representation of the metric.

Return type:: str

__repr__()[source]

Detailed string representation.

Return type:: str

hiper.metrics.hyperedge_integrity

hyperedge_integrity.py

This module implements the Hyperedge Integrity (HI) metric for measuring the resilience of hypergraphs by calculating the ratio of hyperedges preserved after perturbation.

class hiper.metrics.hyperedge_integrity.HyperedgeIntegrity[source]

Bases: object

Computes the Hyperedge Integrity (HI) metric.

The Hyperedge Integrity measures the fraction of hyperedges that remain in the hypergraph after a perturbation:

\(\text{HI} = \frac{|E'|}{|E|}\)

where E is the original set of hyperedges and E’ is the set of hyperedges after perturbation.

A value of 1.0 indicates perfect integrity (no hyperedges lost), while 0.0 indicates complete loss of all hyperedges.

__init__()[source]: Initialize the Hyperedge Integrity metric.

static compute(perturbed_hypergraph, original_hypergraph=None)[source]

Compute the Hyperedge Integrity metric.

Parameters:

perturbed_hypergraph (Hypernetwork) – The hypergraph after perturbation.
original_hypergraph (Optional[Hypernetwork]) – The original hypergraph before perturbation. If None, assumes the metric is computed on the current state only.

Return type:

Returns:

The hyperedge integrity value in [0, 1].

Raises:

ValueError – If original_hypergraph is None when required.
ZeroDivisionError – If the original hypergraph has no hyperedges.

compute_change(before_hypergraph, after_hypergraph)[source]

Compute the change in hyperedge integrity.

Parameters:

before_hypergraph (Hypernetwork) – Hypergraph state before perturbation.
after_hypergraph (Hypernetwork) – Hypergraph state after perturbation.

Return type:

Returns:

The change in integrity (negative values indicate loss).

__str__()[source]

String representation of the metric.

Return type:: str

__repr__()[source]

Detailed string representation.

Return type:: str

Additional Metrics

hiper.metrics.average_hyperedge_cardinality

average_hyperedge_cardinality.py

This module implements the Average Hyperedge Cardinality (AHC) metric for measuring the average size of hyperedges in a hypergraph after perturbation.

class hiper.metrics.average_hyperedge_cardinality.AverageHyperedgeCardinality[source]

Bases: object

Computes the Average Hyperedge Cardinality (AHC) metric.

The Average Hyperedge Cardinality measures the mean size of hyperedges in the hypergraph after perturbation:

\(\text{AHC} = \frac{1}{|E'|} \sum_{e \in E'} |e|\)

where E’ is the set of hyperedges after perturbation and \(|e|\) is the cardinality (size) of hyperedge e.

This metric provides insight into how perturbations affect the size distribution of hyperedges, which can impact the hypergraph’s functional properties.

__init__()[source]: Initialize the Average Hyperedge Cardinality metric.

static compute(hypergraph)[source]

Compute the Average Hyperedge Cardinality metric.

Parameters:: hypergraph (Hypernetwork) – The hypergraph to analyze.
Return type:: float
Returns:: The average hyperedge cardinality.
Raises:: ValueError – If the hypergraph has no hyperedges.

compute_change(before_hypergraph, after_hypergraph)[source]

Compute the change in average hyperedge cardinality.

Parameters:

before_hypergraph (Hypernetwork) – Hypergraph state before perturbation.
after_hypergraph (Hypernetwork) – Hypergraph state after perturbation.

Return type:

Returns:

The change in average cardinality (can be positive or negative).

static get_cardinality_distribution(hypergraph)[source]

Get the distribution of hyperedge cardinalities.

Parameters:: hypergraph (Hypernetwork) – The hypergraph to analyze.
Return type:: dict
Returns:: Dictionary mapping cardinality values to their frequencies.

static get_statistics(hypergraph)[source]

Get comprehensive cardinality statistics.

Parameters:: hypergraph (Hypernetwork) – The hypergraph to analyze.
Return type:: dict
Returns:: Dictionary containing mean, median, std, min, max cardinalities.

__str__()[source]

String representation of the metric.

Return type:: str

__repr__()[source]

Detailed string representation.

Return type:: str

hiper.metrics.centrality_disruption

centrality_disruption.py

This module implements the Centrality Disruption Index (CDI) metric for measuring how perturbations affect the centrality distribution of nodes in a hypergraph.

class hiper.metrics.centrality_disruption.CentralityDisruptionIndex(centrality_type='degree')[source]

Bases: object

Computes the Centrality Disruption Index (CDI) metric.

The Centrality Disruption Index measures how much a perturbation affects the centrality distribution of nodes using the Kolmogorov-Smirnov test:

\(\text{CDI} = \text{KS}(\{C^{\text{pre}}_v\}, \{C^{\text{post}}_v\})\)

where: - \(C^{\text{pre}}_v\) are centrality values before perturbation - \(C^{\text{post}}_v\) are centrality values after perturbation - KS is the Kolmogorov-Smirnov distance between distributions

The metric returns a value in [0, 1] where: - 0.0 indicates no disruption (identical distributions) - 1.0 indicates maximum disruption (completely different distributions)

__init__(centrality_type='degree')[source]

Initialize the Centrality Disruption Index metric.

Parameters:: centrality_type (str) – Type of centrality to use (‘degree’, ‘closeness’, ‘betweenness’, or custom function).

compute(before_hypergraph, after_hypergraph, centrality_function=None)[source]

Compute the Centrality Disruption Index metric.

Parameters:

before_hypergraph (Hypernetwork) – The hypergraph before perturbation.
after_hypergraph (Hypernetwork) – The hypergraph after perturbation.
centrality_function (Optional[Callable]) – Custom centrality function. If None, uses built-in centrality based on centrality_type.

Return type:

Returns:

The centrality disruption index value in [0, 1].

compute_detailed(before_hypergraph, after_hypergraph, centrality_function=None)[source]

Compute detailed centrality disruption analysis.

Parameters:

before_hypergraph (Hypernetwork) – The hypergraph before perturbation.
after_hypergraph (Hypernetwork) – The hypergraph after perturbation.
centrality_function (Optional[Callable]) – Custom centrality function.

Return type:

Returns:

Dictionary containing detailed analysis results.

__str__()[source]

String representation of the metric.

Return type:: str

__repr__()[source]

Detailed string representation.

Return type:: str

hiper.metrics.entropy_loss

entropy_loss.py

This module implements the Entropy Loss (EL) metric for measuring how perturbations affect the entropy of various distributions in a hypergraph.

class hiper.metrics.entropy_loss.EntropyLoss(distribution_type='node_degree', log_base=2.0)[source]

Bases: object

Computes the Entropy Loss (EL) metric.

The Entropy Loss measures how much entropy is lost in a distribution after a perturbation:

\(\text{EL} = H(P^{\text{pre}}) - H(P^{\text{post}})\)

where: - \(H(P) = -\sum p_i \log(p_i)\) is the Shannon entropy - \(P^{\text{pre}}\) is the distribution before perturbation - \(P^{\text{post}}\) is the distribution after perturbation

Positive values indicate entropy loss (reduced diversity), negative values indicate entropy gain (increased diversity), and zero indicates no change in entropy.

The metric can be applied to various distributions such as: - Node degree distribution - Hyperedge size distribution - Hyperedge degree distribution

__init__(distribution_type='node_degree', log_base=2.0)[source]

Initialize the Entropy Loss metric.

Parameters:

distribution_type (str) – Type of distribution to analyze
log_base (float) – Base for logarithm in entropy calculation

compute(before_hypergraph, after_hypergraph)[source]

Compute the Entropy Loss metric.

Parameters:

before_hypergraph (Hypernetwork) – The hypergraph before perturbation.
after_hypergraph (Hypernetwork) – The hypergraph after perturbation.

Return type:

Returns:

The entropy loss value (positive = loss, negative = gain).

compute_detailed(before_hypergraph, after_hypergraph)[source]

Compute detailed entropy analysis.

Parameters:

before_hypergraph (Hypernetwork) – The hypergraph before perturbation.
after_hypergraph (Hypernetwork) – The hypergraph after perturbation.

Return type:

Returns:

Dictionary containing detailed entropy analysis.

compute_multiple_distributions(before_hypergraph, after_hypergraph)[source]

Compute entropy loss for multiple distribution types.

Parameters:

before_hypergraph (Hypernetwork) – The hypergraph before perturbation.
after_hypergraph (Hypernetwork) – The hypergraph after perturbation.

Return type:

Returns:

Dictionary containing entropy loss for each distribution type.

compute_relative_entropy_loss(before_hypergraph, after_hypergraph)[source]

Compute relative entropy loss (normalized by initial entropy).

Parameters:

before_hypergraph (Hypernetwork) – The hypergraph before perturbation.
after_hypergraph (Hypernetwork) – The hypergraph after perturbation.

Return type: