Skip to content
Dario Loi
Search
Menu

Implicit Sheaf Operators for Effective and Efficient Cellular Sheaf Learning

  • Gabriele Onorato1,*
  • Dario Loi1
  • Cristian Apostol1
  • Nathaniel D. Bastian2
  • Francesco Restuccia1
  • 1 Northeastern University, United States
  • 2 US Army

* Corresponding author

Preprint, August 2026

Left, a 3 by 3 block sheaf Laplacian with d by d blocks multiplied by a stacked feature matrix X. Right, a triangle of nodes v, u, w with edges e1 and e2, where dashed arrows bring restriction-map terms from u and w, and a self term, into node v.
Figure 2.(Left) The Sheaf Laplacian (SL) LF∈Rnd×ndL_{\mathcal{F}} \in \mathbb{R}^{nd \times nd} is explicitly computed before multiplying it with the sheaf node features X\mathbf{X}. (Right) The proposed ISOs reformulate the computation as a purely local process. By leveraging the topological features of cellular sheaves, ISO computes the exact action of LFXL_{\mathcal{F}}\mathbf{X} independently at each single node vv, bypassing the global matrix completely.

On this page

In short Implicit Sheaf Operators make sheaf neural networks fast. They apply sheaf diffusion and sheaf convolution locally at each node without building the sheaf Laplacian, which cuts time, memory, and energy. Built on them, Sheaf Convolutional Networks can be more accurate than Neural Sheaf Diffusion on node classification benchmarks.

Abstract

While Sheaf Neural Networks (SNNs) enrich nn-node mm-edge diffusion of ff-dimensional node features with dd-dimensional node and edge stalks, they require computing a sparse nd×ndnd \times nd sheaf Laplacian, whose computation is prohibitive on edge devices. This paper addresses this issue with Implicit Sheaf Operators (ISOs), a type of sheaf topological operators that leverage the topological structure of cellular sheaves to decompose the global diffusion process into local operator-vector products. We mathematically prove that ISO eliminates the O(md2log⁡(md2))O(md^2 \log(md^2)) sparse-coalescing term and reduces the space complexity by O(min⁡(d,f))O(\min(d, f)) with respect to traditional Neural Sheaf Diffusion (NSD). Our experiments indicate that ISO-based operators achieve latency reduction of up to 4.87× and save up to 3.92× peak GPU memory. On real graph classification data, ISO uses up to 1.24× less energy and 3.08× less on-device memory as measured on a Jetson Orin Nano. Finally, to bring ISO to practice, we introduce Sheaf Convolutional Networks (SCNs), an ISO-based SNN attaining up to 3.93% higher accuracy compared to NSD-based SNNs on node classification benchmarks.


Graph neural networks (GNNs) that average over neighbors run into trouble in two familiar places: heterophilous graphs, where connected nodes tend to carry different labels, and deep stacks of layers, where node representations collapse toward each other (oversmoothing). Sheaf Neural Networks (SNNs) address both by letting every edge learn how the features of its two endpoints should be translated before they are compared, and Neural Sheaf Diffusion (NSD; Bodnar et al., 2022) is the best-known recipe for doing so. The obstacle is cost. The standard implementation builds a sparse sheaf Laplacian with nd rows and columns, where n is the number of nodes and d the stalk dimension, so a graph of 1,000 nodes with 8-dimensional stalks already yields an 8,000 by 8,000 operator that must be assembled from learned maps. This page is a companion to the paper.

Why sheaf neural networks are expensive

In a GCN the propagation matrix is fixed by the graph, so it is built once. In an SNN each edge carries learned d by d restriction maps, which means the operator depends on the weights and has to be re-assembled at every gradient step, and again for every new input graph in inductive settings such as classifying many small molecules or networks. Assembly ends with sorting and merging the sparse entries, and the operator then sits in memory for the backward pass. In our measurements on random graphs with 1,000 nodes, this made NSD up to 39.2 times slower and 9.27 times more memory than a GCN, a gap that matters most on constrained hardware.

A faster way to compute Neural Sheaf Diffusion and sheaf convolution

Implicit Sheaf Operators (ISOs) are a faster way to compute Neural Sheaf Diffusion. They apply equally to the sheaf convolution we introduce below. They are matrix-free: instead of materializing the sheaf Laplacian, an ISO evaluates its action node by node from the restriction maps, using two batched matrix multiplications per edge and a scatter-add. This is ordinary gather-scatter message passing. The result equals multiplying by the explicit Laplacian. A model keeps the same expressiveness, and only the way the operator is applied changes. The paper works one case end to end: three agents on a path, each holding a 2-dimensional measurement, reaching consensus through a local update at the middle node. Distributed coordination over cellular sheaves (Hanks et al., 2025) is a natural fit for this local formulation, although we did not test it.

Comparison with connection Laplacians and other sheaf neural networks

Every sheaf variant we know of in this line needs the same explicit block matrix. Connection Laplacians (Barbero et al., 2022a) build it once, ahead of training, which helps only when the graph never changes. Neural Sheaf Propagation (Suk et al., 2022), Sheaf Attention Networks (Barbero et al., 2022b) and nonlinear sheaf diffusion (Zaghen et al., 2024) alter what happens inside the diffusion step, yet still assemble that matrix and share its time, memory and power cost. Deep Neural Sheaf Diffusion (Bourgerie et al., 2026) points to the adjacency form for deeper SNNs. ISOs target the shared bottleneck itself, so in our view they complement these designs: maps are still learned end to end, and the graph can differ from one input to the next.

Speed and memory

On random graphs with 1,000 nodes, the best forward-pass speedup against an optimized explicit baseline is 4.87 times (37.78 ms down to 7.76 ms), and peak GPU memory falls up to 3.92 times (1816 MB to 463 MB). The two gains peak in different places. For general and bundle maps, time savings are largest for small stalks (the plot below), whereas memory savings grow with the stalk dimension and reach their maximum at d = 8. In practice, richer stalks, which give a sheaf its modeling power, become cheaper to afford. The gains matter most in inductive workloads, since a transductive model pays the assembly cost only once.

248Stalkdimensiond024Speedup in forward timeDiagonalBundleGeneral
Speedup in inductive forward time of Implicit Sheaf Operators over the optimized explicit implementation, Sheaf Diffusion, on Erdős-Rényi graphs.

Sheaf neural networks on edge devices

We also ran graph classification inference on an NVIDIA Jetson Orin Nano, an embedded GPU board, using the PTC and Proteins datasets. Energy per graph dropped by up to 1.24 times and on-device memory by up to 3.08 times. The energy gain is modest and the memory gain is substantial, so we read this as a first sign that sheaf models can fit the budgets of on-board and low-power deployments.

Sheaf Convolutional Networks for heterophily

Keeping only the adjacency term of the Laplacian, as GCNs do relative to graph diffusion, yields Sheaf Convolutional Networks (SCNs), evaluated by ISOs at the same cost. On the heterophily-oriented node classification benchmark of Pei et al. (2020), SCNs beat NSD variants by up to 3.93 points. On Squirrel, a general-map SCN reaches 60.27 against 56.34 for the best NSD. Open questions remain, including how far deeper SCNs can go (Bourgerie et al., 2026) and whether the matrix-free idea carries over to copresheaf networks (Hajij et al., 2025), which still use explicit block matrices.

References

Cite

BibTeX
@misc{onorato2026implicit,
  title  = {Implicit Sheaf Operators for Effective and Efficient Cellular Sheaf Learning},
  author = {Gabriele Onorato and Dario Loi and Cristian Apostol and Nathaniel D. Bastian and Francesco Restuccia},
  year   = {2026},
  note   = {Preprint},
  url    = {https://mentis.info/wp-content/uploads/2026/08/SheafOperators.pdf}
}