Sheaf Theory

Overview & Motivation

Across the six topics in this track, a single idea has appeared over and over: local information assembled into global structure. Simplicial complexes glue simplices into spaces. Persistent homology tracks how local connectivity merges into global topology across scales. The Mapper algorithm patches local clusters into a global nerve. Barcodes and bottleneck distance give us stable metrics on these global summaries.

Sheaf theory is the mathematical framework that makes this local-to-global pattern precise.

A sheaf assigns data to the open sets of a topological space (or the cells of a complex) and specifies how local pieces restrict to overlaps and glue into global sections. When data is consistent across overlaps, it glues into a global section. When it isn’t, the obstruction to gluing is measured by sheaf cohomology — a sequence of vector spaces $H^0, H^1, \ldots$ that generalize the Betti numbers of ordinary homology.

Here is a concrete motivating example. Suppose three temperature sensors are placed around a room. Each sensor reports a local measurement, and on every pair of nearby sensors we have a calibration function that relates their readings. If all calibrations are consistent — sensor A agrees with sensor B, B agrees with C, and A agrees with C through the chain — the local readings glue into a single global temperature field. If they don’t agree, the size of the inconsistency is a meaningful quantity. Sheaf theory gives us the exact algebraic machinery to define, measure, and minimize this inconsistency.

This capstone topic covers the full sheaf-theoretic toolkit:

1. Presheaves and Sheaves on topological spaces — the classical definitions.
2. Cellular Sheaves on Graphs — where the theory becomes computational.
3. Sheaf Cohomology — $H^0$ (global consistency) and $H^1$ (obstruction to gluing).
4. The Sheaf Laplacian — a spectral operator that generalizes the graph Laplacian.
5. Cosheaves and Duality — the dual perspective.
6. Applications — sensor networks, opinion dynamics, multi-modal fusion.

---

Presheaves and Sheaves

The Idea: Data Organized by Open Sets

The starting point is deceptively simple: we want to assign data to regions of a space, in a way that is compatible when regions overlap.

Let $X$ be a topological space with open sets $\mathcal{O}(X)$.

In the language of category theory, a presheaf is a contravariant functor from the category of open sets (with inclusions as morphisms) to the category of sets (or vector spaces). The “contravariant” means that restriction maps go in the opposite direction of inclusions: a smaller open set receives data from a larger one.

The Sheaf Condition

A presheaf becomes a sheaf when local data can be glued uniquely.

Stalks and Germs

The stalk construction is elegant but abstract. For computational purposes, we need a more concrete framework — and that is exactly what cellular sheaves on graphs provide.

---

Cellular Sheaves on Graphs

The leap from classical sheaves to data science happens when we replace “topological space with open sets” by “graph with vertices and edges.” The result is a cellular sheaf, where all the abstract machinery collapses to concrete linear algebra.

Definition

Let $G = (V, E)$ be a graph with vertex set $V$ and edge set $E$. For each edge $e$, fix an orientation (choose a source vertex $u$ and a target vertex $v$, written $e = (u, v)$).

The vertex stalks are the “data spaces” at each node, the edge stalks are the “comparison spaces” on each edge, and the restriction maps specify how data at a vertex should transform when compared along an edge.

Global Sections

Examples

The interactive explorer below lets you switch between these sheaf types and adjust the vertex vectors to see when global consistency holds:

Sheaf typeConstant (identity maps)Rotation (angle θ)

Vector at A(1.00, 0.00)

Vector at B(1.00, 0.00)

Vector at C(1.00, 0.00)

Total inconsistency x^TL_Fx = 0.0000Global section (in ker δ₀)

All restriction maps are the identity. A global section exists when all node vectors agree.

What to notice: With the constant sheaf, set all three vectors to the same direction — the inconsistency drops to zero. With the rotation sheaf, try to find a consistent assignment. For most rotation angles, it is impossible.

Python Implementation

The CellularSheaf class encapsulates the core data structure. Each instance manages vertex and edge stalks, restriction maps, and computes the sheaf Laplacian and cohomology:

import numpy as np
from scipy import linalg

class CellularSheaf:
    """A cellular sheaf on a graph with vector-space stalks."""

    def __init__(self, vertices, edges):
        self.vertices = list(vertices)
        self.edges = list(edges)          # list of (u, v) pairs
        self.vertex_to_idx = {v: i for i, v in enumerate(self.vertices)}
        self.vertex_stalks = {}           # v -> dimension
        self.edge_stalks = {}             # (u,v) -> dimension
        self.restriction_maps = {}        # (v, (u,v)) -> matrix

    def set_vertex_stalk(self, v, dim):
        self.vertex_stalks[v] = dim

    def set_edge_stalk(self, e, dim):
        self.edge_stalks[e] = dim

    def set_restriction_map(self, vertex, edge, matrix):
        self.restriction_maps[(vertex, edge)] = np.array(matrix)

    def coboundary_matrix(self):
        """Build the coboundary map δ₀: C⁰(F) → C¹(F)."""
        row_dims = [self.edge_stalks[e] for e in self.edges]
        col_dims = [self.vertex_stalks[v] for v in self.vertices]
        total_rows = sum(row_dims)
        total_cols = sum(col_dims)
        delta = np.zeros((total_rows, total_cols))

        row_offset = 0
        for e_idx, (u, v) in enumerate(self.edges):
            col_u = sum(col_dims[:self.vertex_to_idx[u]])
            col_v = sum(col_dims[:self.vertex_to_idx[v]])
            d_e = row_dims[e_idx]
            # δ₀(x)_e = ρ_{v,e}(x_v) − ρ_{u,e}(x_u)
            delta[row_offset:row_offset+d_e, col_v:col_v+self.vertex_stalks[v]] = \
                self.restriction_maps[(v, (u, v))]
            delta[row_offset:row_offset+d_e, col_u:col_u+self.vertex_stalks[u]] = \
                -self.restriction_maps[(u, (u, v))]
            row_offset += d_e

        return delta

    def sheaf_laplacian(self):
        """L_F = δ₀ᵀ δ₀."""
        delta = self.coboundary_matrix()
        return delta.T @ delta

    def sheaf_cohomology(self):
        """Compute dim H⁰ and dim H¹."""
        delta = self.coboundary_matrix()
        rank = np.linalg.matrix_rank(delta, tol=1e-10)
        dim_C0 = delta.shape[1]
        dim_C1 = delta.shape[0]
        H0 = dim_C0 - rank       # dim ker(δ₀)
        H1 = dim_C1 - rank       # dim coker(δ₀)
        return H0, H1

---

Sheaf Cohomology

The Cochain Complex

The algebraic core of sheaf theory on graphs is a short exact-ish sequence built from the vertex and edge stalks.

The coboundary map $\delta_0$ is a matrix. For a graph with $|V|$ vertices of stalk dimension $d_v$ and $|E|$ edges of stalk dimension $d_e$, it is a $(\sum d_e) \times (\sum d_v)$ matrix assembled from the restriction maps with appropriate signs.

Interpretation

---

The Sheaf Laplacian

Construction

The sheaf Laplacian is the quadratic form that measures total inconsistency.

The Quadratic Form

The sheaf Laplacian has a beautiful interpretation as a sum of local inconsistencies:

$x^T L_{\mathcal{F}} x = \|\delta_0 x\|^2 = \sum_{e = (u,v) \in E} \|\mathcal{F}_{v \trianglelefteq e}(x_v) - \mathcal{F}_{u \trianglelefteq e}(x_u)\|^2$

Each term measures how much the vertex data at the endpoints of an edge disagrees after being mapped into the edge stalk. The total is the Laplacian energy — a scalar measuring the global inconsistency of the vertex assignment $x$.

Spectral Properties

The eigenvalues of $L_{\mathcal{F}}$ reveal more than the graph Laplacian alone. Because the restriction maps introduce structure beyond simple connectivity, the sheaf Laplacian spectrum is generally richer — more eigenvalues, more information. (The Spectral Theorem on the Linear Algebra track guarantees that $L_{\mathcal{F}}$, being symmetric positive semidefinite, admits a full orthogonal eigendecomposition with real non-negative eigenvalues — the foundation on which all of the spectral analysis in this section rests.)

The smallest eigenvalue $\lambda_1 > 0$ (the spectral gap) of $L_{\mathcal{F}}$ restricted to the complement of $H^0$ controls the rate of convergence of sheaf diffusion and the robustness of global consistency to perturbation.

Sheaf Diffusion

In words: sheaf diffusion drives every node’s data toward the nearest globally consistent assignment. The Laplacian energy decays monotonically to zero (or to the minimum achievable with the given sheaf structure).

The simulator below lets you watch sheaf diffusion in real time. Press Play and observe how the node vectors (shown as arrows) align as the energy drops:

Constant sheafRotation sheaf

PlayStepReset

α0.080

Energy 6.4356Steps 0Diffusing...

Sheaf diffusion drives each node's vector toward consistency with its neighbors via the restriction maps. The energy x^TL_Fx measures total inconsistency and decays monotonically to zero.

What to notice: With the constant sheaf, all vectors converge to their average — the same consensus behavior as the heat equation on a graph. With the rotation sheaf, the convergence target depends on the rotation angle: the system finds the best compromise given the twisted compatibility conditions.

---

Cosheaves and Duality

A cosheaf reverses the direction of the structure maps. Where a sheaf has restriction maps from vertices to edges (projecting data down), a cosheaf has extension maps from edges to vertices (pushing data up).

The chain complex of a cosheaf runs in the opposite direction: $0 \leftarrow C_0(\mathcal{G}) \xleftarrow{\partial_1} C_1(\mathcal{G}) \leftarrow 0$, and we get cosheaf homology $H_0(\mathcal{G})$ and $H_1(\mathcal{G})$.

---

Applications

Sensor Network Consistency

A sensor network is a graph where each vertex is a sensor and each edge represents a communication link. Each sensor measures a local quantity (temperature, position, signal strength), and the restriction maps encode the expected relationship between neighboring sensors — for instance, a rotation matrix relating two sensors’ coordinate frames.

Sheaf cohomology provides a principled consistency check:

• $\dim H^0$ = number of independent consistent readings. If this equals the stalk dimension, the network is fully consistent.
• Laplacian energy = total inconsistency, interpretable as a “calibration error” across the network.
• Spectral gap = robustness of the consistency to noise. A large spectral gap means the network will recover quickly from perturbations via sheaf diffusion.

# Build a sensor network sheaf with rotation restriction maps
def build_sensor_sheaf(G, noise_level=0.0):
    """Construct a sheaf on a sensor graph with noisy rotation maps."""
    sheaf = CellularSheaf(G.nodes(), G.edges())
    for v in G.nodes():
        sheaf.set_vertex_stalk(v, 2)
    for e in G.edges():
        sheaf.set_edge_stalk(e, 2)
        theta = G.edges[e].get('angle', 0.0)
        theta_noisy = theta + noise_level * np.random.randn()
        R = np.array([[np.cos(theta_noisy), -np.sin(theta_noisy)],
                       [np.sin(theta_noisy),  np.cos(theta_noisy)]])
        sheaf.set_restriction_map(e[0], e, np.eye(2))
        sheaf.set_restriction_map(e[1], e, R)
    return sheaf

Opinion Dynamics on a Social Graph

Hansen and Ghrist (2021) model opinion dynamics as sheaf diffusion. Each person (vertex) holds an opinion vector in $\mathbb{R}^d$ — not just a scalar “agree/disagree” but a rich vector encoding positions on multiple issues. The restriction maps encode how people relate to each other: identity maps for people who share a frame of reference, rotation or projection maps for people who interpret the same issue differently.

Sheaf diffusion on this model drives opinions toward structured consensus — not the uniform agreement of the standard DeGroot model, but agreement modulo the restriction maps. Two people can reach “consistency” while holding different opinion vectors, as long as their opinions are related by the restriction map on the edge connecting them.

# Sheaf diffusion for opinion dynamics
def sheaf_opinion_diffusion(sheaf, x0, n_steps=100, alpha=0.1):
    """Run sheaf diffusion: x_{t+1} = x_t - α L_F x_t."""
    L = sheaf.sheaf_laplacian()
    x = x0.copy()
    trajectory = [x.copy()]
    for _ in range(n_steps):
        x = x - alpha * L @ x
        trajectory.append(x.copy())
    return np.array(trajectory)

Multi-Modal Data Fusion

When data arrives from multiple modalities — images, text, sensor readings — each modality lives in a different vector space. A cellular sheaf provides a natural framework for fusion: each modality is a vertex stalk, the relationships between modalities are restriction maps, and sheaf diffusion finds the maximally consistent joint representation.

Compared to naive fusion (e.g., concatenation or averaging), sheaf-based fusion exploits the structure of inter-modal relationships. If the restriction maps are learned from data (as in Bodnar et al., 2022), the framework becomes a sheaf neural network — a graph neural network where the message-passing rule is sheaf diffusion.

---

The Topology & TDA Track: A Capstone View

This is the payoff of the entire track. Each topic introduced a tool; sheaf theory reveals that they are all aspects of a single idea — local data, organized by combinatorial structure, with restriction maps governing consistency.

Where to go from here. Three frontiers extend the ideas in this track:

• Multi-parameter persistence: when the filtration parameter is two-dimensional, barcode decomposition no longer holds. The resulting persistence modules are sheaves on $\mathbb{R}^2$, and their theory is an active area of algebraic topology.
• Sheaf neural networks (Bodnar et al., 2022): replacing the graph Laplacian in a GNN with the sheaf Laplacian yields architectures that handle heterophily and avoid oversmoothing.
• Persistent sheaves: combining persistence and sheaf structure leads to sheaves parameterized by a filtration, unifying the spectral and homological perspectives.

---

Exercises

Foundational

Exercise 1. Let $T$ be a tree (connected graph with no cycles) and $\mathcal{F}$ the constant sheaf with all stalks $\mathbb{R}^d$ and all restriction maps $= I_d$. Prove that $H^1(\mathcal{F}) = 0$. Hint: What is the rank of the coboundary matrix $\delta_0$ for a tree with $n$ vertices?

Exercise 2. Consider a cycle graph $C_4$ (four vertices, four edges) with the signed sheaf: all stalks $\mathbb{R}^1$, restriction maps $= +1$ on three edges and $= -1$ on one edge. Compute $\dim H^0$ and $\dim H^1$. What happens if you flip the sign on a second edge?

Exercise 3. For the complete graph $K_4$ with the constant sheaf ($\mathbb{R}^2$ stalks, identity maps), compute the sheaf Laplacian $L_{\mathcal{F}}$ as an $8 \times 8$ matrix. Verify that its kernel has dimension 2.

Intermediate

Exercise 4. Let $G$ be a path graph $v_1 - v_2 - v_3$ with vertex stalks $\mathcal{F}(v_i) = \mathbb{R}^3$ and edge stalks $\mathcal{F}(e) = \mathbb{R}^2$. The restriction maps are $2 \times 3$ matrices. Construct a specific example where $\dim H^0 = 1$ (a one-dimensional space of global sections). What constraint does this impose on the restriction maps?

Exercise 5. Prove that the convergence rate of sheaf diffusion is exactly $e^{-\lambda_1 t}$, where $\lambda_1$ is the smallest positive eigenvalue of $L_{\mathcal{F}}$. Show that for the constant sheaf on a graph, $\lambda_1$ equals the algebraic connectivity (second-smallest eigenvalue of the graph Laplacian).

Exercise 6. Implement the CellularSheaf class from Section 2 and verify numerically that $\dim \ker(L_{\mathcal{F}}) = \dim H^0(\mathcal{F})$ for three different sheaves of your choice. Report the sheaf parameters and numerical results.

Advanced

Exercise 7. Sensor localization as a sheaf problem. Consider a network of 20 sensors in $\mathbb{R}^2$ where each sensor knows its position relative to its neighbors (with Gaussian noise of standard deviation $\sigma$). Model this as a cellular sheaf where the restriction maps are noisy rotations. Implement sheaf diffusion to estimate the global positions from local measurements. Plot the localization error as a function of $\sigma$ and the spectral gap of $L_{\mathcal{F}}$.

Exercise 8. Neural sheaf diffusion. Implement a simple sheaf neural network following Bodnar et al. (2022): parameterize the restriction maps as learnable linear maps and train via gradient descent on a node classification task. Use a small graph (e.g., Karate Club) and compare accuracy with a standard GCN. Does the sheaf Laplacian improve performance on heterophilic class boundaries?