tessl/pypi-hypernetx

Python library for the creation and study of hypergraphs with analysis, visualization, and algorithm capabilities

—

Pending

Overview

Eval results

Files

Analysis and Metrics

Name: tessl/pypi-hypernetx
Author: tessl

Structural analysis including connectivity, distance measures, diameter calculations, and component analysis. Supports s-connected analysis for higher-order connectivity patterns in hypergraphs.

Capabilities

Connectivity Analysis

Analyze hypergraph connectivity patterns using s-connectivity, which generalizes traditional graph connectivity to hypergraphs by considering edges of different sizes.

def is_connected(self, s: int = 1, edges: bool = False) -> bool:
    """
    Check if hypergraph is s-connected.
    
    Parameters:
    - s: Connectivity level (nodes connected through edges of size ≥ s+1)
    - edges: Check edge connectivity instead of node connectivity
    
    Returns:
    True if hypergraph is s-connected
    """

def connected_components(self, edges: bool = False) -> List[set]:
    """
    Get connected components (equivalent to s=1 connectivity).
    
    Parameters:
    - edges: Return edge components instead of node components
    
    Returns:
    List of component sets
    """

def s_connected_components(
    self,
    s: int = 1,
    edges: bool = True,
    return_singletons: bool = False
) -> List[set]:
    """
    Get s-connected components.
    
    Parameters:
    - s: Connectivity level
    - edges: Return edge components (True) or node components (False)
    - return_singletons: Include singleton components
    
    Returns:
    List of s-connected component sets
    """

def connected_component_subgraphs(
    self,
    return_singletons: bool = True,
    name: Optional[str] = None
) -> List["Hypergraph"]:
    """Get connected components as separate hypergraphs."""

def s_component_subgraphs(
    self,
    s: int = 1,
    edges: bool = True,
    return_singletons: bool = False,
    name: Optional[str] = None
) -> List["Hypergraph"]:
    """Get s-connected components as separate hypergraphs."""

Distance and Diameter

Calculate distances and diameters in hypergraphs using s-walks that traverse edges of appropriate sizes.

def distance(
    self,
    source: Union[str, int],
    target: Union[str, int],
    s: int = 1
) -> Union[int, float]:
    """
    Shortest s-walk distance between two nodes.
    
    Parameters:
    - source: Source node identifier
    - target: Target node identifier  
    - s: Walk level (traverse edges of size ≥ s+1)
    
    Returns:
    Distance as number of steps, or infinity if unreachable
    """

def edge_distance(
    self,
    source: Union[str, int],
    target: Union[str, int],
    s: int = 1
) -> Union[int, float]:
    """
    Shortest s-walk distance between two edges.
    
    Parameters:
    - source: Source edge identifier
    - target: Target edge identifier
    - s: Walk level
    
    Returns:
    Distance between edges
    """

def diameter(self, s: int = 1) -> Union[int, float]:
    """
    Hypergraph s-diameter (maximum distance between any two nodes).
    
    Parameters:
    - s: Diameter level
    
    Returns:
    Maximum distance, or infinity if disconnected
    """

def edge_diameter(self, s: int = 1) -> Union[int, float]:
    """
    Edge s-diameter (maximum distance between any two edges).
    
    Parameters:
    - s: Diameter level
    
    Returns:
    Maximum edge distance
    """

def node_diameters(self, s: int = 1) -> List[Union[int, float]]:
    """
    Node diameters of each connected component.
    
    Parameters:
    - s: Diameter level
    
    Returns:
    List of component diameters
    """

def edge_diameters(self, s: int = 1) -> List[Union[int, float]]:
    """Edge diameters of each connected component."""

Equivalence Classes and Collapsing

Identify and work with equivalent structures in hypergraphs.

def equivalence_classes(self, edges: bool = True) -> Dict:
    """
    Get equivalence classes of edges or nodes.
    
    Parameters:
    - edges: Get edge equivalence classes (True) or node equivalence classes (False)
    
    Returns:
    Dictionary mapping representatives to equivalence class members
    """

Linegraph Construction

Create linegraphs and s-linegraphs for hypergraph analysis.

def get_linegraph(
    self,
    s: int = 1,
    edges: bool = True
):
    """
    Create s-linegraph where nodes represent edges/nodes and edges represent s-adjacency.
    
    Parameters:
    - s: Linegraph level
    - edges: Create edge linegraph (True) or node linegraph (False)
    
    Returns:
    NetworkX graph representing the s-linegraph
    """

Install with Tessl CLI