Struct CellularSheaf 

pub struct CellularSheaf {
    pub n_nodes: usize,
    pub n_edges: usize,
    pub node_stalks: Vec<usize>,
    pub edge_stalks: Vec<usize>,
    pub edges: Vec<(usize, usize)>,
    pub restriction_maps: HashMap<(usize, usize), Vec<Vec<f64>>>,
}

A cellular sheaf on an undirected graph.

A sheaf assigns:

• A vector space ℝ^{d_v} to each vertex v (vertex stalk).
• A vector space ℝ^{d_e} to each edge e (edge stalk).
• Restriction maps F_{v ◁ e} : ℝ^{d_e} → ℝ^{d_v} for each vertex-edge incidence.

The coboundary operator δ : C^0 → C^1 and the resulting Hodge-0 sheaf Laplacian L = δ^T δ capture the sheaf’s cohomology.

Reference: Hansen & Ghrist (2019).

Fields

n_nodes: usize

Number of nodes

n_edges: usize

Number of edges (oriented pairs (u,v) with u < v)

node_stalks: Vec<usize>

Stalks at nodes: node_stalks[v] = dimension of the stalk at v

edge_stalks: Vec<usize>

Stalks at edges: edge_stalks[e] = dimension of the stalk at edge e

edges: Vec<(usize, usize)>

Oriented edge list: edges[e] = (tail, head) with tail < head

restriction_maps: HashMap<(usize, usize), Vec<Vec<f64>>>

Restriction maps: maps[(v, e)] = the matrix F_{v◁e} : ℝ^{d_e} → ℝ^{d_v} stored row-major as Vec<Vec> of shape (d_v, d_e)

Implementations

impl CellularSheaf

pub fn trivial(n_nodes: usize, edges: Vec<(usize, usize)>) -> Result<Self>

Create a trivial sheaf on a graph where all stalks have dimension 1.

The restriction maps are initialised to the identity (or ±1 depending on orientation).

Arguments

• n_nodes – number of nodes
• edges – oriented edge list (tail, head), both < n_nodes

pub fn new( n_nodes: usize, node_dim: usize, edges: Vec<(usize, usize)>, edge_dim: usize, maps: HashMap<(usize, usize), Vec<Vec<f64>>>, ) -> Result<Self>

Create a sheaf with user-specified stalk dimensions and restriction maps.

node_dim and edge_dim give the stalk dimensions. maps is a map from (node_id, edge_id) to a matrix of shape (node_dim, edge_dim).

pub fn set_restriction( &mut self, v: usize, e: usize, map: Vec<Vec<f64>>, ) -> Result<()>

Set the restriction map for vertex v and edge e.

The matrix map should have shape (stalk_dim[v], edge_stalk[e]).

pub fn coboundary_operator(&self) -> Array2<f64>

Compute the coboundary matrix δ : C^0 → C^1.

The full coboundary operator has shape (sum_e d_e) × (sum_v d_v).

For a section x = (x_v)_{v}, the coboundary δ(x) at edge e = (u,v) is: δ(x)_e = F_{v◁e} x_v − F_{u◁e} x_u

Returns the matrix as Array2<f64>.

pub fn hodge_laplacian_0(&self) -> Array2<f64>

Compute the Hodge-0 sheaf Laplacian L_0 = δ^T δ.

Shape: (sum_v d_v) × (sum_v d_v).

pub fn cohomology_h0(&self) -> usize

Compute the dimension of the 0th sheaf cohomology H^0(G; F).

dim H^0 = dim ker(δ) = total_node_dim − rank(δ).

A dimension of 1 corresponds to a “consistent” global section (like a constant function on a constant sheaf).

pub fn cohomology_h1(&self) -> usize

Compute the dimension of the 1st sheaf cohomology H^1(G; F).

dim H^1 = dim ker(δ^T) restricted to the image complement = total_edge_dim − rank(δ).

Trait Implementations

impl Clone for CellularSheaf

fn clone(&self) -> CellularSheaf

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CellularSheaf

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

Formats the value using the given formatter.