Struct SimplicialComplex 

pub struct SimplicialComplex { /* private fields */ }

A finite simplicial complex represented by its simplices, grouped by dimension.

All simplices are stored as sorted vectors of vertex indices. Adding a simplex automatically adds all its faces (closure property).

Example

use scirs2_graph::hypergraph::SimplicialComplex;

let mut sc = SimplicialComplex::new();
sc.add_simplex(vec![0, 1, 2]);  // adds triangle + all edges + all vertices

let betti = sc.betti_numbers();
assert_eq!(betti[0], 1); // one connected component
assert_eq!(betti[1], 0); // boundary is filled in

Implementations

impl SimplicialComplex

pub fn new() -> Self

Create an empty simplicial complex.

pub fn add_simplex(&mut self, simplex: Vec<usize>)

Add a simplex and all its faces (the closure).

The simplex [v_0, v_1, …, v_k] is stored as a sorted, deduplicated vertex list. All (k-1)-dimensional faces are recursively added.

pub fn max_dim(&self) -> Option<usize>

Return the maximum dimension of the complex, or None if empty.

pub fn simplices_of_dim(&self, dim: usize) -> Vec<Vec<usize>>

Return a slice of all simplices at dimension dim.

pub fn total_simplices(&self) -> usize

Total number of simplices across all dimensions.

pub fn num_simplices(&self, dim: usize) -> usize

Number of simplices at dimension dim.

pub fn boundary_matrix(&self, dim: usize) -> Array2<i8>

Compute the boundary matrix ∂dim : C_dim → C{dim-1}.

Rows are indexed by (dim-1)-simplices; columns by dim-simplices. Entry [i, j] is (-1)^k where k is the position of the omitted vertex in simplex j that gives face i, else 0.

Returns an all-zero (1 × 1) matrix if there are no dim-simplices or no (dim-1)-simplices.

pub fn betti_numbers(&self) -> Vec<usize>

Compute the Betti numbers β_0, β_1, …, β_{max_dim}.

β_k = dim ker(∂k) − dim im(∂{k+1}) = (n_k − rank(∂k)) − rank(∂{k+1})

where n_k is the number of k-simplices.

Rank is computed by Gaussian elimination over ℤ (integer arithmetic, checking for divisibility). Because our coefficient field is effectively ℚ (we use rational row operations), this gives exact Betti numbers over ℤ/2ℤ which coincides with ℤ Betti numbers for these complexes.

pub fn euler_characteristic(&self) -> i64

Compute the Euler characteristic: χ = Σ_k (-1)^k |C_k|.

pub fn vietoris_rips(points: &Array2<f64>, epsilon: f64) -> Self

Build the Vietoris-Rips complex from a point cloud.

Inserts a simplex on every subset of points whose pairwise Euclidean distances are all ≤ epsilon.

Arguments

• points – shape (n_points, n_dims)
• epsilon – edge threshold

Complexity

This is O(2^n) in the worst case; use only on small point sets (< 20).

pub fn cech_complex(points: &Array2<f64>, radius: f64) -> Self

Build the Čech complex from a point cloud.

A simplex σ is included iff the miniball (smallest enclosing ball) of the points in σ has radius ≤ radius.

Arguments

• points – shape (n_points, n_dims)
• radius – ball radius threshold

pub fn nerve_complex(cover: &[Vec<usize>]) -> Self

Build the nerve complex from a cover.

Given a cover cover = [U_0, U_1, …, U_{k-1}] where each U_i is a list of point indices, the nerve has:

• A vertex for each U_i.
• A simplex {i_0, …, i_r} whenever U_{i_0} ∩ … ∩ U_{i_r} ≠ ∅.

Arguments

• cover – a slice of cover sets, each set being a sorted list of indices

Trait Implementations

impl Clone for SimplicialComplex

fn clone(&self) -> SimplicialComplex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SimplicialComplex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SimplicialComplex

fn default() -> Self

Returns the “default value” for a type.