WorksComputer Science
Sheaf-MPNN: A Library for Sheaf Neural Networks as Message Passing
Abstract
Standard Graph Neural Networks (GNNs) implicitly assume that neighboring nodes share the same feature space, which contributes to oversmoothing and poor performance on heterophilic graphs. Sheaf Neural Networks (SNNs) remove this assumption by giving each node and edge its own vector space and learning restriction maps that transform features as they move between neighbors. These maps define a sheaf Laplacian that drives diffusion over the graph, but existing implementations often assemble it explicitly as a global sparse block matrix, which adds memory and computational overhead and can hinder scalability. In this paper, we introduce Sheaf-MPNN, a PyTorch Geometric library that reformulates sheaf diffusion as local incidence-wise transport and aggregation, eliminating the need to construct the global Laplacian. Sheaf-MPNN implements fifteen families of SNNs under a unified message-passing framework, each supporting both homogeneous and heterogeneous graphs, and directed and undirected settings, with diagonal, general, orthogonal, and low-rank restriction maps and attention-based predictors. We further provide a unified benchmarking suite covering node- and graph-level tasks, heterogeneous graph learning, and computational efficiency, enabling systematic and reproducible comparisons across architectures. We establish theoretical equivalence between these message-passing formulations and their original counterparts and identify the architectural mechanisms needed to preserve their propagation dynamics. This unified perspective provides a principled foundation for implementing, comparing, and extending sheaf-based architectures within standard graph learning frameworks. Source code is available at https://github.com/alessioborgi/sheaf-mpnn.
Corresponding Author.
License: CC-BY 4.0, see https://creativecommons.org/licenses/by/4.0/.
Introduction
Graph Neural Networks (GNNs) typically learn graph-structured representations through the message-passing paradigm, in which nodes update their representations by aggregating information from their neighbours (Gilmer et al., 2017). Sheaf Neural Networks (SNNs) enrich graph learning with cellular sheaves, which assign local vector spaces, or stalks, to nodes and edges, together with linear restriction maps for each node–edge incidence. These maps transport node representations into a shared edge stalk, where neighbouring signals can be compared. SNNs use this structure to define propagation operators, commonly based on the sheaf Laplacian, that allow neighbouring representations to remain consistent after transport even when their original features differ [35, 9]. Subsequent research has explored how sheaves are constructed [6, 16, 30], how information propagates through them [52, 7, 54, 5, 11, 12], and extensions to different graph structures and feature spaces [14, 27, 25, 42, 10, 48, 2] (Van Looy et al. 2026). Despite their common foundations, these models differ in their restriction maps, propagation operators, normalization schemes, and update rules. Appendix A surveys these developments.
A common computational challenge arises from the explicit construction of sheaf operators. Existing SNN implementations assemble the global sheaf Laplacian as a sparse block matrix and apply it to the stacked node representations. For a graph with nodes and -dimensional stalks, this produces an operator whose nonzero blocks may contain dense matrices. Constructing and storing this operator introduces additional memory and computational overhead, particularly for large graphs or higher-dimensional stalks. Yet the action of the sheaf Laplacian is inherently local: each edge compares its endpoint representations after transport into a shared stalk, and the resulting contributions are mapped back to the incident nodes and aggregated. This suggests that sheaf propagation can be implemented directly through local message passing, without explicitly assembling the global Laplacian. Such a formulation removes the need for operator assembly, although its practical efficiency depends on the implementation and must be evaluated empirically.
Motivated by this observation, we introduce Sheaf-MPNN, a PyTorch Geometric library that implements sheaf propagation through local incidence-wise transport and aggregation. By expressing different SNN architectures within a common computational interface, Sheaf-MPNN facilitates their implementation, reuse, and comparison while integrating them with established graph learning tools. The library provides 15 families of SNNs, each with homogeneous and heterogeneous variants, and supports directed and undirected graph settings. It includes diagonal, general, orthogonal, and low-rank restriction maps, together with attention-based map predictors where applicable. To enable systematic evaluation, we also provide a unified benchmarking suite, covering more than 20 datasets, including node- and graph-level learning, heterogeneous graph benchmarks, and computational efficiency, with shared experimental configurations and reproducible evaluation protocols. Beyond the library itself, we also develop the unified Sheaf Message Passing Neural Network (Sheaf-MPNN) theoretical framework that characterises how existing sheaf architectures can be expressed through local message passing. We derive explicit message-passing formulations for 15 architecture configurations and establish their theoretical equivalence to the original models, identifying the mechanisms required to preserve their propagation dynamics. These include augmented node states, type-conditioned restriction maps, and directed aggregation rules. We further show that the SheafPool graph-level readout [14] can be formulated within the same framework by aggregating locally aligned node representations into a receive-only virtual node. Together, our contribution provides a common theoretical and computational foundation for implementing, comparing, and extending sheaf-based graph learning. Appendix C details the supported architectures, implementation choices, and normalization conventions.
Sheaf Message Passing in a Nutshell
Let be a finite undirected graph without self-loops, and let be a cellular sheaf assigning finite-dimensional inner-product spaces and to nodes and edges, with linear restriction maps for each incidence [21, 35]. Node signals belong to . In orthonormal stalk bases, the sheaf Laplacian acts on as:
Here, each term measures disagreement in the shared edge stalk and transports it back to the receiving node, revealing the Laplacian as a local aggregation operator. We generalise this observation into a Sheaf Message Passing Neural Network (Sheaf-MPNN). Assuming stalks of dimension and feature channels, each node has state at layer . A SheafMPNN transforms node states, computes interactions in edge stalks, aggregates the resulting messages, and updates node representations as:
Here, and mix stalk coordinates and feature channels, respectively. The function computes interactions between transported representations, optionally incorporating edge features . Each message is weighted by , pulled back through , aggregated by , and combined with the current state through . Restriction maps may be learned at each layer, with their layer index omitted for clarity. The construction is equivariant to node relabelling when aggregation is permutation invariant, and the map predictors and update functions are shared and independent of node ordering. Figure 1 illustrates the distinction from standard message passing. Sheaf diffusion is recovered by setting , , and using sum aggregation, yielding Equation (1) on the transformed features. Normalization is incorporated through and its transpose, where the implementation uses with (Appendix C.§ 3). Conversely, identity restrictions and identity pre-transformations recover standard MPNNs. The framework also accommodates heterogeneous graphs through type-conditioned restriction-map predictors (Appendix § 5.0.2.§ 3) and directed graphs through incoming-arc aggregation (Appendix § 5.0.2.§ 4). Explicit directed propagation is necessary because an undirected edge yields cross-edge blocks and that are transposes, rather than independent directional operators. We formalise the recovery of existing architectures below.

Figure 1. Sheaf Message Passing Neural Network (SheafMPNN). Neighbourhood update at node 0 (red), with neighbouring nodes in blue. (Left) A standard MPNN computes messages (green) from neighbouring node states and aggregates them at node 0. (Right) A SheafMPNN transports both endpoint representations into the shared edge stalk (boxes) through restriction maps (dashed grey arrows). The function computes their interaction, and the resulting message is pulled back through and aggregated at node 0 (solid black arrows).
Theorem 1 The following architectures admit the SheafMPNN representation in Equations (2)–(5), with matching normalization and updates: (i) Neural Sheaf Diffusion; (ii) standard MPNNs, via identity restrictions and identity pre-transform; (iii) SheafAN, Res-SheafAN, and sheaf adjacency propagation; and (iv) Neural Sheaf Propagation, on an augmented sheaf with node stalks and edge stalks .
Appendix § 5.0.2 proves Theorem 1 and extends the framework to diagonal, general, orthogonal, low-rank, and attention-generated NSD restrictions, as well as to all the sheaf-variants (Theorems 6, 10, 13, 15, and 19–23).
The computational cost of SheafMPNN reflects the locality of its propagation operator: the transport and aggregation require operations, with memory for restriction maps, edge messages, and node states when messages are materialised. These bounds exclude map prediction, channel mixing, and block normalization. So, at the end, we evaluate the sheaf Laplacian entirely through local operations, without assembling its global matrix representation (Remark 9).
Library Design and Usage
Built on PyTorch ([44]) and PyTorch Geometric ([26]), Sheaf-MPNN provides reusable sheaf message-passing layers and end-to-end model wrappers through a unified interface (Appendix C.§ 2). The following example illustrates node classification using orthogonal Neural Sheaf Diffusion:
from torch_geometric.datasets import HeterophilousGraphDataset
from sheaf_mpnn.nsd import NSDModel, NSDVariant
data = HeterophilousGraphDataset("data", name="Roman-empire")[0]
model = NSDModel(in_channels=data.num_features, out_channels=18,
hidden_dim=16, num_layers=4, stalk_dim=4,
variant=NSDVariant.ORTHOGONAL)
out = model(data.x, data.edge_index) # [num_nodes, 18]
The accompanying sheaf command-line interface supports reproducible experiments across more than 20 datasets, Optuna-based hyperparameter optimization ([1]), and computational efficiency comparisons against reference implementations. Appendix C details the package structure, model interfaces, and experimental tooling.
Related Software
General-purpose frameworks such as PyTorch Geometric ([26]) and DGL ([53]) provide message-passing abstractions without native support for cellular sheaves. TopoX ((Hajij et al., 2024)) supports higher-order topological domains, including operator-based sheaf models, while existing SNN implementations ([9, 7, 14]) primarily target individual architectures and often rely on explicit sheaf-Laplacian assembly. In contrast, Sheaf-MPNN provides a reusable, Laplacian-free message-passing implementation across a broad family of SNNs, complemented by unified benchmarking tools and theoretical equivalence results.
Availability
Sheaf-MPNN is publicly available at https://github.com/alessioborgi/sheaf-mpnn under the CC-BY 4.0 license, together with documentation and tutorial notebooks. Appendix C provides implementation details, supported architectures, and experimental configurations.
Primer on Cellular Sheaves and Sheaf Neural Networks
This appendix introduces in a deeper way the Sheaf Neural Networks (SNNs) and places the Sheaf-MPNN library within the literature. It first explains how a cellular sheaf generalizes the graph Laplacian and why diffusion on a sheaf avoids the classical failure modes of message passing, and then reviews how the field has developed. For fuller treatments we refer to [21, 49] for cellular sheaf theory, to [37] for the spectral theory of the sheaf Laplacian, and to the survey of Ayzenberg et al. [4] for sheaf theory in machine learning more broadly.
From Message Passing to Sheaves
Message Passing Neural Networks. A message passing neural network (Gilmer et al., 2017) updates the representation of each node of a graph by aggregating the states of its neighbours :
This update assumes that all node features live in one shared vector space, so that neighbouring features can be compared and averaged directly. The assumption is harmless when connected nodes tend to be similar, but it underlies two well-known failures. Repeated low-pass averaging drives features towards a constant signal as depth grows, a phenomenon known as oversmoothing [15, 50]; and on heterophilic graphs, where neighbours tend to belong to different classes, averaging erases the very signal that separates them. Cellular sheaves remove the assumption at its source: every node and every edge receives its own vector space, and learnable linear maps decide how signals are compared across each edge.
Cellular Sheaves. A sheaf attaches data to the pieces of a space, together with rules stating how the data on overlapping pieces must agree. It therefore describes when local information can be glued into a consistent global picture. Cellular sheaves make this idea discrete by attaching vector spaces to the cells of a cell complex and linear maps to the relations between them. On a graph, the cells are the vertices and the edges, and each incidence , read as “ is a face of ”, carries a linear map that moves data from the vertex to the edge where it is compared with data from the other endpoint.
Definition 2 (Cellular Sheaf on a Graph). A cellular sheaf [51, 21] on an undirected graph assigns a finite-dimensional inner-product space (the stalk) to each vertex and to each edge , together with linear restriction maps for each incident node–edge pair . Stacking vertex and edge values yields the - and -cochain spaces and , respectively.
An intuitive reading comes from opinion dynamics [38]. Each node stalk is a private opinion space, each edge stalk is a shared space for the conversation along that edge, and describes how expresses its opinion in that conversation. This means that two neighbours, instead of agreeing when their raw features do, they agree along when their expressed opinions coincide, , Disagreement is therefore measured only after both signals have been aligned in a common space, which is exactly what a heterophilic edge requires.
Orienting each edge as , the coboundary is , and the records this disagreement edge by edge. Resulting from this, the 0-cochain with is a global section: a configuration that is consistent across the whole graph. The sheaf Laplacian [37] acts node-wise as:
It is symmetric positive semi-definite, with diagonal blocks and off-diagonal blocks , and its kernel is exactly the space of global sections. Its normalized form is , where is the block diagonal of . We take all stalks to be , so that for a graph with nodes. When every restriction map is the identity, Equation (7) reduces to the graph Laplacian and the global sections are the constant signals. Classical graph learning is thus the special case of the constant sheaf, which is how the blueprint of § 2 recovers standard MPNNs (Theorem 1).
Sheaf Diffusion and Neural Sheaf Diffusion. The sheaf Laplacian generates the diffusion , which decreases the sheaf Dirichlet energy and converges to the projection of the initial signal onto the global sections. For the constant sheaf these are the constant signals, so deep diffusion oversmooths. For a general sheaf they are shaped by the restriction maps, and may assign different features to neighbouring nodes as long as these agree after transport. Bodnar et al. [9] turned this observation into Neural Sheaf Diffusion (NSD). They proved that suitable sheaves let diffusion linearly separate classes in settings, including heterophilic ones, where graph diffusion provably cannot, and they made the sheaf learnable. NSD stacks the stalk signals into with feature channels, predicts the map of every incidence from the features of its two endpoints, , as a diagonal, orthogonal, or general matrix, and performs the step:
where and act on the stalk and channel dimensions, respectively. This is the update that Sheaf-MPNN evaluates without materializing (Theorem 1 and Appendix C.§ 3).
Sheaf Neural Network Literature
Sheaf-based learning grew out of applied topology. Hansen and Ghrist [37] developed the spectral theory of the sheaf Laplacian, Hansen and Ghrist [36] showed how to learn it from smooth signals, and Hansen and Ghrist [38] interpreted sheaf diffusion as opinion dynamics. Hansen and Gebhart [35] then proposed the first sheaf neural networks, with hand-crafted sheaves, and Gebhart et al. [29] recast knowledge-graph embedding as learning an approximate global section of a knowledge sheaf, an idea later used to embed new entities by harmonic extension [20]. NSD [9] made the sheaf itself learnable and supplied the theory on which most subsequent work builds.
A first line of work asks how the sheaf should be obtained. Connection-Laplacian networks [6] compute orthogonal maps in preprocessing by aligning local tangent spaces, and tangent-bundle networks [8] show that discretizing convolution on a manifold’s tangent bundle yields a principled sheaf model. Signal-processing methods learn restriction maps, or entire connection graphs, directly from data [22, 23]. Bayesian SNNs [30] place a variational distribution over sheaves, PAC-Bayes bounds guide the spectral optimization of the learned operator [19], and eigenvectors of a learned sheaf Laplacian serve as positional encodings for ordinary GNNs (He et al., 2023). To interpret what a learned sheaf encodes, the Bochner–Weitzenböck decomposition of [31] splits the sheaf Laplacian into a positive semi-definite part and a block-diagonal curvature term, which describes the learned geometry locally rather than through the global spectrum. However, two recent studies temper the enthusiasm: Caralt et al. [17] find that the fixed identity sheaf is competitive on the standard heterophily benchmarks, and the inductive benchmark of Fiorini et al. [28] finds that the choice of restriction maps matters most, yet that SNNs do not surpass the strongest baselines. Both suggest that the value of a learned sheaf depends strongly on the task.
A second line changes how signals move on the sheaf. Continous NSD models the dynamics of Eq. (8) as continuous time diffusion [9], Sheaf attention networks weight the transported neighbours [7], Neural Sheaf Propagation adopts a second-order recurrence [52], and nonlinear [54] and joint [16] diffusion modify the interaction law itself. Polynomial filters of the sheaf Laplacian enlarge the receptive field of a single layer [11], while Deep NSD replaces the Laplacian with a sheaf adjacency operator, complemented with per-stalk gating, odd activation and layer normalization, to keep signals informative across many layers [12]. Long-range communication has become a central theme. Cooperative SNNs let each node decide independently whether to send or receive information [47]; SheafDEQ formulate sheaf propagation as an equilibrium with convergence guarantees [13]; oscillatory dynamics over sheaves propagate information through second-order, wave-like updates (Van Looy et al., 2026); and sheaf effective resistance shows that over-squashing can be reduced by changing the sheaf rather than rewiring the graph [32]. Bundle neural networks [5] restrict the sheaf to flat vector bundles and replace message passing with heat-kernel diffusion, and topological attention [2] reinterprets multi-head attention as transport through quiver representations, whose off-diagonal routes mix heads before aggregation.
Sheaves also offer a natural place to encode richer relational structure. Heterogeneous SNNs condition the restriction maps on node and edge types and introduce the gauge-invariant SHEAFPOOL readout for graph classification [14]. Directed SNNs generalize the cellular sheaf to account for edge orientation [27], temporal SNNs give each node a time-varying orthogonal frame for link prediction on dynamic graphs [3], and hierarchical sheaf pooling coarsens graphs using low-frequency modes of cluster-internal sheaf Laplacians [43]. Further work leaves graphs or Euclidean stalks behind. Sheaf hypergraph networks [24] extend incidence-based transport to group interactions; follow-ups construct hypergraph sheaf Laplacians from symmetric simplicial lifts ([18]), add directed hyperedges ([42]), and bring sheaves to higher-order message passing in topological deep learning ([40]). Copresheaf networks ((Hajij et al., 2025)) place sheaf models within a broader framework that also covers other deep learning architectures. Other models change the stalks themselves, carrying Gaussian distributions ([48]), symmetric positive-definite matrices with manifold-compatible operators ([45]), Clifford-algebra multivectors ([41]), or Euclidean-equivariant vector features ([10]). In each case the restriction maps, and not only the aggregation, must respect the structure of the stalks.
The SheafMPNN Blueprint Recovers Existing Sheaf Architectures
This appendix proves Theorem 1: each architecture listed there is an instance of the blueprint in Equations (2)–(5), so its layers can be evaluated by local message passing without materializing the sheaf Laplacian. It then extends the construction to polynomial, graph-level, heterogeneous, directed, cooperative, joint, bundle, and Bayesian models.
Throughout, denotes a pointwise nonlinearity, the block degree of node , and the normalized sheaf Laplacian. As in § 2, normalization is absorbed into the restriction maps by writing , so that:
The release instead normalizes with (Appendix C.§ 3). Since is positive definite, this needs no invertible restriction map, and every construction below holds verbatim with in place of .
Theorem 1 The following architectures admit the SheafMPNN representation in Equations (2)–(5), with matching normalization and updates: (i) Neural Sheaf Diffusion; (ii) standard MPNNs, via identity restrictions and identity pre-transform; (iii) SheafAN, Res-SheafAN, and sheaf adjacency propagation; and (iv) Neural Sheaf Propagation, on an augmented sheaf with node stalks and edge stalks .
In the following, we proof each part of Theorem 1 in turn, showing that the layer update of each architecture can be expressed in the form of Equation (5) with a suitable choice of message , aggregation , and update .
Proof of Theorem 1, Parts (i)–(ii): Neural Sheaf Diffusion. A layer of Neural Sheaf Diffusion (NSD) ([9]) computes:
where rescales each stalk dimension, broadcast across nodes and channels, and is the diffusion step size. By Equation (9), the update at node is:
with . This is the blueprint with the normalized maps , the message function in Equation (3), unit weights and sum aggregation in Equation (4), and the update in Equation (5). For part (ii), take every restriction map and both weight matrices to be identities. The transported states are then the raw node states, the message and the aggregation are arbitrary, and the pullback is the identity, so the blueprint reduces to the general MPNN of Gilmer et al. (2017).
Proof of Theorem 1, part (iii): Sheaf Attention. Let be the block matrix whose block is for every edge and zero otherwise, and let collect the attention coefficients , normalized over the neighbours of . A SheafAN layer ([7]) computes:
which at node reads . This is the blueprint with the message , so that , the weights , sum aggregation, and the update . When the attention coefficients are normalized by a softmax over the neighbourhood, the normalization is itself local: each edge also sends its unnormalized score, both quantities are summed, and the update divides one by the other, as in graph attention.
Res-SheafAN adds a residual connection and a skip rescaling to the SheafAN update, so that the layer computes:
so that . The messages and the aggregation are those of SheafAN. The term depends only on the state of , so it belongs to the node-local update .
Proof of Theorem 1, part (iii): Sheaf Adjacency. Sheaf adjacency propagation ([12]) replaces the Laplacian with the normalized sheaf adjacency , whose block is :
At node the argument of is . This is the blueprint with the normalized maps , the message , sum aggregation, and the update .
Proof of Theorem 1, part (iv): Neural Sheaf Propagation. Neural Sheaf Propagation (NSP) [52] follows the second-order recurrence:
with as in Equation (10). Because the update depends on , it is not directly of the form of Equation (5), where receives only the current state and the aggregated message. We remove this dependence by augmenting the state.
Define , with , and let project onto the current and history blocks. The augmented sheaf has node stalks , edge stalks , and restriction maps , which read the current block and apply the normalized original map. The transform uses , so that . With the message and sum aggregation:
by Equation (9), since embeds into the current block. The update then reads:
and it is a deterministic function of the augmented state and the aggregated message. By induction on , for all : the base case holds by the initialization, and if it holds at step , then by Equation (13) and . The current block therefore reproduces NSP exactly.
Remark 3 The augmented restriction maps are not square, which the blueprint allows but which places NSP in a different sheaf regime from NSD, whose maps are endomorphisms. The degree of the augmented sheaf vanishes on the history block, so its own normalization is undefined; this is why the normalization of the original sheaf is folded into .
Remark 4 (Learnable Skip Rescaling). Any update that keeps a residual connection to the current state can be extended with learnable per-dimension rescalings, since these are constants shared by all nodes and leave a deterministic function of the state and the aggregated message. For NSP, the library’s add_eps option uses two rescalings , one for each block:
which recovers (14) at .
Polynomial Neural Sheaf Diffusion
Polynomial Neural Sheaf Diffusion (PolyNSD) [11] replaces the single Laplacian application of NSD with a degree- polynomial filter, evaluated through the Chebyshev recurrence without eigendecomposition. We show that a PolyNSD layer is a sequence of SheafMPNN steps followed by a node-wise readout.
Setting. The spectrum of lies in with for the symmetric normalization. The rescaled Laplacian:
maps the spectrum onto the interval on which the Chebyshev polynomials , , and satisfy .
PolyNSD Update Rule. At layer , let and define the Chebyshev iterates over the rescaled Laplacian:
The layer combines them with a high-pass skip term and a learnable convex combination:
where , so that and , with shared by all nodes, and is learnable. Since , the skip term equals for any , a combination of the first two iterates.
Definition 5 (Augmented PolyNSD State). For , the augmented state of node is:
where the accumulator already contains the skip term. The augmented sheaf has node stalks , edge stalks , and restriction maps , where project onto the three blocks.
Theorem 6 (PolyNSD is a SheafMPNN). A PolyNSD layer of degree (Equation (18)) equals SheafMPNN steps on the augmented sheaf , which compute from , followed by the node-wise readout . Every step uses identity weight matrices, the message , and sum aggregation; the steps differ only in their node-local updates.
Proof Messages and Aggregation. At every step, the first block of the state holds the current iterate . Since reads only that block, Equation (9) gives the aggregated message:
one message per incidence and one propagation per step. The node can then form locally.
Updates. The first step maps to with . Each later step applies the Chebyshev recurrence to the first two blocks and adds to the accumulator:
Both updates are deterministic functions of the current augmented state and the aggregated message, as Equation (5) requires.
Correctness. By Equation (16), the first component of Equation (21) is , the second is , and the third adds to the accumulator. Since is generated by the Chebyshev recurrence in the matrix , induction gives , and after steps , the argument of in Equation (18). The readout uses only and the state of , so it is node-wise and requires no further propagation. ■
Remark 7 (Reduction to NSD). For and , the argument of is . Choosing cancels the first term and leaves , because . Doubling absorbs the factor , so the layer computes : the NSD update of Equation (10) with unit step size, which is the original update of Bodnar et al. [9]. Every such NSD layer is therefore a degree-one PolyNSD layer.
Remark 8 (Restriction-map Variants). The proof uses only the linearity of the restriction maps, so Theorem 6 holds for all six NSD map variants (Table 3). For orthogonal maps , so and the normalization reduces to a scalar per node.
| Variant | Restriction parameterization | Outputs |
| DIAGONAL | , with | |
| GENERAL | Dense matrix with entries in | |
| GENERAL_ATTENTION | , with row-wise softmax | |
| ORTHOGONAL | Cayley or Householder construction | or |
| ORTHOGONAL_ATTENTION | Cayley transform of the skew part of | |
| LOW_RANK | , with |
Table 3. NSD Restriction-map Variants. The last column gives the number of predictor outputs per restriction map, excluding fixed channels and edge weights. Low-rank maps need fewer outputs, but their products and are still stored as dense blocks.
Remark 9 (Laplacian-free Filter Evaluation). Each product is evaluated through Equation (20), which needs only the state of , the states of its neighbours, and the maps on its incidences, so the operator is never assembled. Per layer, the library stores the restriction-map products, of total size , computed once by the map predictor and reused in all steps; the half-degree matrices , of size ; and three stalk tensors of size , namely the two live iterates and the accumulator. A degree- layer therefore costs operations and memory, excluding map prediction. By contrast, the original NSD implementation of Bodnar et al. [9] assembles a sparse Laplacian with non-zeros and multiplies it with the features, and spectral filters based on eigendecomposition additionally pay for the factorization. Both message passing and sparse multiplication perform the same arithmetic per step; the difference lies in avoiding the assembly and storage of the global operator.
SheafPool as Graph-Level Sheaf Message Passing
SheafPool ([14]) produces a graph-level representation from the node stalks of a sheaf backbone. We show that it is a single SheafMPNN layer in which every graph sends its aligned node stalks to a receive-only virtual node.
Setting. Let be a batch of graphs, , and let be the stalk embedding of node produced by the backbone. The pooling graph adds one virtual node per graph and the arcs:
and the pooling sheaf uses the stalk at every node and edge, with identity restriction maps:
Messages are aggregated only along incoming arcs, as in the directed extension of Appendix § 5.0.2.§ 4, so the real nodes receive nothing and each virtual node is receive-only. Before pooling, SheafPool canonicalizes each node stalk. It whitens the stalk and aligns it to a learnable anchor by orthogonal Procrustes:
and scores it through the channel energies , which are invariant under orthogonal changes of stalk basis:
The pooled stalk, the update of a learnable graph token , and the invariant readout are of the form:
where is a channel-wise MLP. As Braithwaite et al. [14] stress, the token only receives information: it does not take part in the node-level diffusion and cannot act as a shortcut between nodes.
Proposition 10 (SheafPool is a Graph-level SheafMPNN). SheafPool is a single SheafMPNN layer on the pooling graph with the sheaf of Equation (23), followed by the node-wise readout at the virtual nodes.
Proof. The canonicalization in Equation (24) and the scores depend only on , so they are node-local and can be computed by the update of the preceding layer; we take the pre-pooling state of node to be . On each arc , the identity map transports unchanged, and the message function sends the pair , which depends only on the source. Sum aggregation over the incoming arcs gives, at , the pair . The update at divides the first component by the second, which yields of Equation (26) with the softmax weights of Equation (25), and then applies Equation (27). Real nodes have no incoming arcs and keep their states. Applying at each virtual node gives Equation (28). ■
Remark 11. The readout is permutation invariant when all node-wise choices are shared and deterministic. Invariance to general linear changes of stalk basis is not guaranteed by the regularized whitening: already for , gives , whose magnitude changes under , and exact unregularized whitening requires full row rank. Orthogonal invariance additionally requires a unique Procrustes solution or an equivariant tie-breaking rule, which arbitrary SVD choices at degeneracies do not provide. Proposition therefore establishes locality, not unconditional gauge invariance.
Heterogeneous NSD and NSP as SheafMPNNs
Heterogeneous extensions of NSD and NSP (Braithwaite et al. [14]) condition the restriction-map predictor on the type structure of the graph. Since the blueprint is parameterized by the restriction maps themselves and not by the mechanism that predicts them, any type-conditioned predictor yields a valid SheafMPNN.
Heterogeneous Graph Structure. Let be a graph with a node-type map and an edge-relation map into finite sets of types. Every node and edge carries the stalk .
Definition 12 (Type-conditioned Restriction-map Predictor). A type-conditioned predictor at layer produces, for each incidence with , a map , where the context combines any non-empty subset of the node features , the node-type one-hot encodings , and the
relation one-hot encoding . The predictor is either a single MLP shared by all edges, which may receive the relation encoding as input, or an ensemble with one MLP per relation type. Its output parameterizes a diagonal, general, attention-based, orthogonal, or low-rank map as in the homogeneous case.
The type-conditioned Laplacian and its normalization are defined as in the homogeneous case, with the type-conditioned maps in place of the original ones.
Het-NSD update rule. At layer , Het-NSD computes the next state from the current state and the normalized Laplacian of the transformed state as:
with a learnable step size and restriction maps from a type-conditioned predictor.
Theorem 13 (Het-NSD is a SheafMPNN). Het-NSD (Equation (29)) is a SheafMPNN on the type-conditioned sheaf , with the stalk transform , the normalized maps , the message , sum aggregation, and the update . Equivalently, after pullback, each edge contributes:
which is how the library evaluates it from precomputed products.
Proof By Equation (9) applied to the type-conditioned maps, we have:
which is the message on the transported states, pulled back and summed; expanding the pullback gives Equation (30). The update is a deterministic function of the state and the aggregated message. The argument uses only that each is a linear map , which Definition 12 guarantees for every context and map family. ■
Het-NSP Update Rule. Het-NSP keeps the second-order recurrence of NSP with type-conditioned maps:
and stores the augmented state as a single tensor of shape .
Definition 14 (Augmented Het-NSP Sheaf). The augmented sheaf has node stalks , edge stalks , and restriction maps , where
extracts the current block. The map predictor receives only the current block, so the history is never exposed to it.
Theorem 15 (Het-NSP is a SheafMPNN). Het-NSP (Equation (32)) is a SheafMPNN on the augmented sheaf , with the transform , the message , sum aggregation, and the update:
Proof. The proof of Theorem 1, part (iv), applies verbatim with the type-conditioned maps: the aggregated message is by Equation (31), and the same induction shows that the current block of Equation (33) reproduces Equation (32) while the second block stores the history. As for Het-NSD, only the linearity of the type-conditioned maps is used.
Remark 16 (Reduction to the Homogeneous Models). With a single node type and a single relation type, the context reduces to the node features and the ensemble to one MLP, so the type-conditioned maps become the NSD maps of Bodnar et al. [9]. Het-NSD then coincides with NSD without skip rescaling ( in Equation (10)), and Het-NSP with NSP.
Remark 17 (Type Conditioning preserves the Structure). All context strategies of Definition 12, and their combinations, produce restriction maps that are deterministic functions of the current node features and the graph structure. The theorems therefore hold for every map family and for every combination of the library options use_features, use_node_types, use_edge_types, and ensemble.
Remark 18 (Stalk Geometry of Het-NSP). As in Remark 3, the augmented maps are not square, and the degree of the augmented sheaf, , vanishes on the history block. Only the current block takes part in the Laplacian action, and the normalization is taken from the original type-conditioned sheaf.
Directed Extension
For a directed edge , the source and target incidences may carry different predictors, and , and both the predictors and the message function may depend on the order of the endpoints.
Theorem 19 (Directed SheafMPNN). Any directed sheaf layer whose messages are computed independently on each arc and whose node update aggregates the incoming messages with a permutation-invariant operator is an instance of the SheafMPNN blueprint, including layers with asymmetric source and target predictors and an asymmetric message function.
Proof. For each arc , set . Pulling it back through and aggregating over the incoming arcs of gives Equation (4), and the node-local update gives Equation (5). Neither equation requires the maps, the messages, or the neighbourhood relation to be symmetric.
Cooperative Sheaf Neural Networks
Cooperative Sheaf Neural Networks (CSNNs) ([47]) use directed cellular sheaves to separate sending from receiving. On a directed graph, their out- and in-degree sheaf Laplacians act as:
and learned gates select and combine these directed transports locally.
Theorem 20 (Cooperative SNNs are SheafMPNNs). A layer built from and , with arbitrary node-local gates and update, is a directed SheafMPNN.
Proof. Each summand of either Laplacian is a message on one directed incidence: the difference between a self transport and a neighbour transport, pulled back to the receiving stalk. Each operator is therefore realized by the message and sum-aggregation stages of Theorem 19. A gate computed from the state of a node and its aggregated messages can enter the weights or the update , and combining the two aggregated messages in that update is again a SheafMPNN layer. The independently parameterized in- and out-maps are what allow a node to control sending and receiving separately.
Joint Sheaf Neural Networks
Joint Sheaf Neural Networks (JSNNs) ([16]) infer the restriction maps through a joint diffusion process inspired by opinion dynamics, rather than through an unrestricted map learner. We model the map-generating process abstractly by an edge state , updated as , from which the maps are read as .
Theorem 21 (JSNNs are SheafMPNNs). Every layer whose joint process yields linear incidence maps and whose feature update is sheaf diffusion is a SheafMPNN; if the joint process has memory, the result holds on the augmented state .
Proof. At a fixed layer, the state determines linear maps , and the feature update is the local transport, difference, pullback, and sum of part (i) of Theorem 1. The state update is edge-local and only determines the maps of the next layer, so it does not change this computation. When the state is recurrent, keeping as an auxiliary edge state gives an augmented local transition, as for NSP.
Bundle Neural Networks
Bundle Neural Networks (BuNNs) [5] diffuse features on a flat orthogonal vector bundle. In a local trivialization, each node carries an orthogonal frame , and parallel transport along is , which is path-independent by flatness.
Theorem 22 (BuNN Message Diffusion is a SheafMPNN). When the heat kernel is evaluated by a truncated Taylor series, a BuNN layer is a sequence of SheafMPNN steps on the flat orthogonal sheaf with restriction-map products , followed by a node-wise update.
Proof. Choose the restriction maps in the frame of each edge so that their products equal ; for instance, . The bundle Laplacian then acts at as , which is the coboundary message of Equation (3), pulled back and summed as in Equation (4). The truncated Taylor series of the heat kernel is a polynomial in this Laplacian, so it is evaluated by repeated propagation with a running accumulator, exactly as in Theorem 6. Orthogonality and flatness restrict the map family and enable the factorization of BuNNs, but do not change the local form of the computation. The exact spectral evaluation of the heat kernel instead eigendecomposes the graph Laplacian and is not a local computation.
Bayesian Sheaf Neural Networks
Bayesian Sheaf Neural Networks (BSNNs) [30] treat the sheaf as a latent random variable with a learned variational distribution . At each layer, a sampled sheaf supplies the maps of an otherwise standard sheaf diffusion layer.
Theorem 23 (BSNNs are Conditionally SheafMPNNs). Conditional on every draw of its latent sheaf, a BSNN layer is a SheafMPNN, and its posterior-predictive output is the Monte Carlo average of these SheafMPNN evaluations.
Proof. Fix a draw . Its restriction maps are ordinary linear maps on the incidences, so part (i) of Theorem 1 applies verbatim. Reparameterized sampling changes how the maps are learned and how gradients are estimated, not the local computation once the maps are drawn. For draws, the posterior-predictive estimate averages the conditional SheafMPNN outputs, which amounts to a final permutation-invariant aggregation over samples.
Library Design and Usage: Additional Details
This appendix complements § 3. Sheaf-MPNN separates three concerns: predicting the restriction maps, propagating stalk-valued states by local message passing, and training models on specific tasks. We describe the package layout, the implemented model families, the anatomy of an NSD layer in terms of the blueprint of Equations (2)–(5), the end-to-end models, the experiment tooling, and the development workflow.
Package Layout
The source tree contains three packages (Table 1): sheaf_mpnn implements the homogeneous models and their convolutions, hetsheaf_mpnn their type-conditioned counterparts, and exp the data loading, model construction, training, and evaluation. Because the experiment code is kept apart, a convolution can be used in any PyTorch Geometric model without adopting the supplied training loop.
| Module | Responsibility |
sheaf_mpnn.base_conv | Shared stalk transforms, map-predictor inputs, and propagation interfaces. |
sheaf_mpnn.<family> | Architecture-specific convolutions and end-to-end models. |
sheaf_mpnn.utils | Normalization, orthogonal parameterizations, connection maps, and training utilities. |
sheaf_mpnn.sheaf_pool | Graph-level pooling of stalk-valued representations. |
hetsheaf_mpnn | Type-conditioned layers and model wrappers. |
exp.config, exp.registries | Typed experiment settings and factories for models, datasets, and presets. |
exp.run, exp.het_run, exp.gc_run | Runners for homogeneous node classification, heterogeneous node classification, and graph classification. |
exp.sweeps, exp.benchmark | Hyperparameter search and benchmarks against reference implementations. |
Table 1. Sheaf-MPNN Main Modules.
Each architecture family pairs a layer module, which defines propagation on stalk-valued states, with a model module, which adds the feature encoder and the prediction head. Most homogeneous convolutions derive from BaseSheafConv, itself a subclass of PyTorch Geometric’s MessagePassing. Directed convolutions derive from BaseDirectedSheafConv, and heterogeneous layers add type-aware restriction predictors. The base classes share the stalk transforms and common utilities, but leave each family free to define its own propagation rule.
Model Families and Restriction Maps
The model registry contains 15 homogeneous families, each with its heterogeneous counterpart, for 29 selectable model types (Table 2). Following Braithwaite et al. [14], the heterogeneous models condition their restriction-map predictors on type information (Appendix § 5.0.2.§ 3). Their registry keys prefix the homogeneous name with het_, except for polynomial diffusion, whose key is poly_het_nsd. NSD, PolyNSD, Deep NSD, NSP, sheaf adjacency, and directed NSD share the six restriction-map variants of NSD: diagonal, general, orthogonal, low-rank, general-attention, and orthogonal-attention (Appendix C.§ 3). The two attention variants change only how the maps are generated and are unrelated to the SheafAN and Res-SheafAN architectures. Bayesian and nonlinear diffusion support the four variants without attention; for nonlinear diffusion, the general and low-rank maps extend the diagonal and orthogonal maps of the reference model. The remaining families define their own parameterizations, such as the fixed maps of connection-Laplacian NSD, the flat bundle transports of BuNN, and the joint update of joint diffusion.
| Family | Model type | Map and model options |
| Neural Sheaf Diffusion | nsd | Six |
| Polynomial NSD | poly_nsd | Six |
| Connection-Laplacian NSD | conn_nsd | Precomputed maps |
| Deep NSD | dnsd | Six |
| Neural Sheaf Propagation | nsp | Six |
| Sheaf adjacency | sheaf_adj | Six |
| Sheaf attention | sheaf_attn | SheafAN, Res-SheafAN |
| Bayesian sheaf networks | bsnn | Four |
| Nonlinear sheaf diffusion | nlsd | Four |
| Bundle neural networks | bunn | Taylor or spectral solver |
| Directed NSD | directed_nsd | Six |
| Cooperative sheaf networks | csnn | Conformal or non-conformal |
| Identity sheaf | id_sheaf | Identity restrictions |
| Joint diffusion | joint_diff | Joint update |
| Rotation-invariant sheaf | rot_inv | Rotation-invariant update |
Table 2. Homogeneous Architecture Families. The table lists the 15 homogeneous families and their corresponding model types and restriction-map options. In the last column, “six” denotes the six NSD restriction-map variants of Table 3, and “four” the diagonal, general, orthogonal, and low-rank maps.
The directed families modify the propagation rule as well as the map predictor (Appendix § 5.0.2.§ 4). Also, every family propagates information through local messages and never assembles a global sheaf Laplacian. Only the optional spectral solver of BuNN departs from this, since it computes eigenpairs of the graph Laplacian with a full or truncated eigendecomposition, depending on the graph size and the configuration. The default BuNN solver stays local and evaluates a truncated Taylor expansion of the heat kernel instead (Appendix § 5.0.2.7).
Anatomy of an NSD Layer
An NSD convolution is called as layer(x_feat, x_stalk, edge_index). The tensor x_stalk holds the node states and has shape , while x_feat holds the context vectors from which the restriction maps are predicted and has shape , where is context_dim. The end-to-end model flattens the current state, so that , but any context can be supplied. When the fixed channels of Table 4 are enabled, the stalk dimension grows to , which replaces in all tensor shapes. Following PyTorch Geometric, an entry of edge_index sends a message from the source to the receiver , so an undirected graph must list both orientations of every edge. The predictor evaluates the two endpoint contexts in both orders to obtain the two restriction maps of each edge. It is a bias-free linear layer followed by tanh, except in the attention variants, which pass its output through a softmax-based construction (Table 3).
| Option | Effect |
| variant, rank, orth_strategy | Select the restriction-map variant and its parameterization. |
| alpha, learn_alpha, add_eps | Set the diffusion step and enable the learnable skip scaling. |
| use_edge_weights | Enable learned symmetric edge weights for orthogonal maps. |
| add_lp, add_hp | Append a fixed channel with signless or standard graph-Laplacian blocks, respectively. |
| sparse_learner | Sum the paired contexts over the stalk axis, reducing the predictor width from to for flattened stalk inputs. |
| second_linear | Add a second encoder layer. |
| input_dropout, dropout | Set the input and internal dropout rates. |
| normalize_output, jknet | Normalize the output representations, and concatenate the representations of all diffusion layers. |
| add_self_loops | Insert self-loops; off by default, since already includes the identity term. |
Table 4. Options of NSDModel beyond the core dimensions in_channels, out_channels, stalk_dim, hidden_dim, and num_layers.
The forward pass first applies the transform of Equation (2), , where dropout acts on the diffusion input but not on the residual state; at initialization, is the identity and a random orthogonal matrix. Instead of applying the restriction maps separately in every message, the layer precomputes the per-edge products:
With the block degree and , the pulled-back message of Equations (3)–(4), with and normalized maps , becomes:
Summing these messages at yields the action of the augmented normalized sheaf Laplacian without forming the operator, and the identity term keeps well defined even when the restriction maps are singular. Two numerical safeguards, adapted from the reference implementation of Bodnar et al. [9], modify these products: for general and low-rank maps, the identity term receives a small jitter during training, and the normalized products of general maps are clipped entrywise to . Equation (34) is therefore exact at evaluation time whenever the clipping is inactive.
With the default residual connection, the layer then instantiates Equation (5) as:
where is a learnable skip scaling, initialized at zero and broadcast across channels, and the step size is learned by default in NSDModel. When the residual is disabled, the layer returns only the diffusion term , so that the caller can supply its own update. The orthogonal class offers four strategies through orth_strategy. The cayley strategy uses a clamped half-Cayley transform, and fasth composes Householder reflections given by free reflector vectors. The fasthpp and householder strategies use compact reflector parameters; householder calls torch_householder when it is installed and otherwise falls back to a native implementation. For unweighted orthogonal maps, and the normalization reduces to ; learned edge weights replace by a weighted degree. Connection-Laplacian NSD uses a separate convolution whose orthogonal transports are precomputed from local geometric estimates rather than learned.
End-to-End Models and Direct Layer Use
NSDModel applies input dropout, a linear encoder, an ELU, and dropout, and then reshapes the representation into stalks; an optional second encoder layer acts before the reshape. Each diffusion layer receives the current stalk state together with its flattened context, and from the second layer onwards the context also receives dropout. A linear decoder maps the final flattened state to the predictions, or the concatenation of all layer outputs when jumping knowledge is enabled. Table 4 lists the remaining options. The other families keep their own states and update rules, and hence their own options.
Convolutions can also be used on their own. In the following example, the caller supplies the encoder and the context, and no fixed channels are used:
from torch import nn
from sheaf_mpnn.nsd import GeneralNSDConv
d, f = 4, 16
encoder = nn.Linear(x.size(-1), d * f)
layer = GeneralNSDConv(stalk_dim=d, in_channels=f,
hidden_dim=f, context_dim=d * f)
x_stalk = encoder(x).reshape(-1, d, f)
x_feat = x_stalk.reshape(x_stalk.size(0), d * f)
x_stalk = layer(x_feat, x_stalk, edge_index)
Here x and edge_index are the node features and edges of the input graph. The hidden_dim argument is kept for interface compatibility and adds no hidden layer to the linear restriction predictor of NSD.
Experiment Tooling
The sheaf command provides four tools: run, splits, sweep, and benchmark. sheaf run trains homogeneous node-classification models, while heterogeneous node classification and graph classification have their own entry points, exp.het_run and exp.gc_run, which share the same configuration components:
sheaf run --preset texas --model.variant orthogonal --model.stalk-dim 5
sheaf splits --datasets cora texas
sheaf sweep --yaml-path configs/cora/nsd/general.yaml --preset cora_nsd_general
python -m exp.het_run --help
python -m exp.gc_run --help
sheaf benchmark report --manifest configs/benchmark/nsd_vs_original.yaml
Typed configurations describe the data, model, training procedure, hardware, and logging, and presets supply defaults that can be overridden from the command line. Training uses Adam, with a separate weight decay for the restriction-map predictors, and early stopping on a validation criterion. Results are summarized over the folds or seeds of each dataset’s split protocol; for example, the OGB node datasets have a single official split, whereas Pokec has five.
The homogeneous runner covers the citation and heterophily benchmarks, the filtered Chameleon and Squirrel graphs, the five datasets of Platonov et al. [46], the OGB node-property datasets, Pokec, Telegram, and a grid of synthetic directed graphs. Edges are symmetrized by default, and the --directed flag preserves the loaded orientation where one is available, so an experiment must state which of the two settings it uses. The heterogeneous runner supports the HGB datasets IMDB, DBLP, ACM, and Freebase, and the graph-classification runner supports the TU datasets with mean, sum, max, SAG, and SheafPool readouts. Data modules and a training module for link prediction are also included, although no runner exposes them yet.
Search spaces are stored as YAML files under configs/. The sweep tool uses the TPE sampler and median pruner of Optuna, supports shared study storage and optional Weights & Biases logging, and re-evaluates the best configuration over ten seeds or folds. Each file fixes its own search space and number of trials, so comparisons across models should report both.
The benchmark manifest configs/benchmark/nsd_vs_original.yaml compares diagonal, orthogonal, and general NSD with the original implementation of Bodnar et al. [9], which is included as a git submodule. The benchmark tool submits the runs as SLURM jobs, collects their outputs, and generates tables and plots of convergence, epoch time, peak GPU memory, and inference latency.
Development and Reproducibility
The environment is managed with uv and pins Python 3.13, PyTorch 2.8.0, and Lightning 2.6.0, with CUDA 12.8 wheels on Linux and Windows and CPU wheels on macOS. Linting and formatting use ruff, and type checking uses ty. GitHub Actions runs the unit tests with coverage on pushes and pull requests, the integration tests daily, and the benchmark integration tests weekly.
Ten tutorial notebooks accompany the code, from the basics of GNNs to the principal sheaf model families; two of them cover hypergraph and directed hypergraph sheaves, which are not yet registered model types. Reproducing an experiment requires the code version, environment, dataset and preprocessing, model and map variant, splits and seeds, tuning budget, and checkpoint-selection rule. Numerical comparisons with a reference implementation additionally require matched weights, normalization, random choices, and error tolerances. As noted in § 3, this paper reports neither test coverage nor numerical parity with reference implementations.
Acknowledgements
We thank Gabriele Onorato, Dario Loi, Ferran Hernandez Caralt, and James Rowbottom for their help in developing Sheaf-MPNN. Their contributions range from implementing and testing model families to preparing experiment configurations and maintaining the continuous-integration workflows, and we are grateful for their feedback and discussions throughout the project.
References
- [1]Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A next-generation hyperparameter optimization framework. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2019.arxiv.org/abs/1907.10902
- [2]Riccardo Ali, Alessio Borgi, Mario Severino, Alessio Gravina, Davide Bacciu, Pietro Liò, and Christopher Irwin. Let the heads talk: Beyond diagonal graph attention, 2026. URL https://arxiv.org/abs/2610.01494.
- [3]Md Sadek Hossain Asif, Tanzila Khan, and Md. Mosaddek Khan. Temporal sheaf neural networks with dynamic orthogonal transport, 2026. URL https://arxiv.org/abs/2606.10071.
- [4]Anton Ayzenberg, Thomas Gebhart, German Magai, and Grigory Solomadin. Sheaf theory: from deep geometry to deep learning, 2025. URL https://arxiv.org/abs/2502.15476.
- [5]Jacob Bamberger, Federico Barbero, Xiaowen Dong, and Michael M. Bronstein. Bundle neural network for message diffusion on graphs. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum?id=scI9307PLG.arxiv.org/abs/2405.15540
- [6]Federico Barbero, Cristian Bodnar, Haitz Sáez de Ocáriz Borde, Michael Bronstein, Petar Veličković, and Pietro Liò. Sheaf Neural Networks with Connection Laplacians. In Proceedings of Topological, Algebraic, and Geometric Learning Workshops 2022, pages 28–36. PMLR, 2022a.arxiv.org/abs/2206.08702
- [7]Federico Barbero, Cristian Bodnar, Haitz Sáez de Ocáriz Borde, and Pietro Liò. Sheaf attention networks. In NeurIPS 2022 Workshop on Symmetry and Geometry in Neural Representations, 2022b. URL https://openreview.net/forum?id=LIDvgVjpkZr.
- [8]Claudio Battiloro, Zhiyang Wang, Hans Riess, Paolo Di Lorenzo, and Alejandro Ribeiro. Tangent bundle convolutional learning: From manifolds to cellular sheaves and back. IEEE Transactions on Signal Processing, 72:1892–1909, 2024. doi: 10.1109/TSP.2024.3379862.DOI
- [9]Cristian Bodnar, Francesco Di Giovanni, Benjamin Paul Chamberlain, Pietro Liò, and Michael M. Bronstein. Neural sheaf diffusion: A topological perspective on heterophily and oversmoothing in gnns. In Advances in Neural Information Processing Systems, 2022.
- [10]Alessio Borgi, Mario Severino, Fabrizio Silvestri, and Pietro Liò. Equivariant sheaf neural networks: Learning geometric transport on graphs, 2026a. URL https://arxiv.org/abs/2608.28853.
- [11]Alessio Borgi, Fabrizio Silvestri, and Pietro Liò. Polynomial neural sheaf diffusion: A spectral filtering approach on cellular sheaves, 2026b. URL https://arxiv.org/abs/2512.00242.
- [12]Rémi Bourgerie, Šarūnas Girdzijauskas, and Viktoria Fodor. Deep neural sheaf diffusion. In ICML 2026 Workshop on Graph Foundation Models, 2026a. URL https://arxiv.org/abs/2605.19021.
- [13]Rémi Bourgerie, Šarūnas Girdzijauskas, and Viktoria Fodor. Fixed points without fixed diffusion: Implicit neural sheaves for convergent test-time computation. In Learning on Graphs Conference, 2026b. URL https://arxiv.org/abs/2609.30277.
- [14]Luke Braithwaite, Alessio Borgi, Gabriele Onorato, Kristjan Tarantelli, Iulia Duta, Francesco Restuccia, Fabrizio Silvestri, and Pietro Liò. Heterogeneous sheaf neural networks, 2026. URL https://arxiv.org/abs/2409.08036.
- [15]Chen Cai and Yusu Wang. A note on over-smoothing for graph neural networks. arXiv preprint arXiv:2006.13318, 2020.arxiv.org/abs/2006.13318
- [16]Ferran Hernandez Caralt, Guillermo Bernardez, Iulia Duta, Eduard Alarcon, and Pietro Liò. Joint diffusion processes as an inductive bias in sheaf neural networks. In ICML 2024 Workshop on Geometry-grounded Representation Learning and Generative Modeling, 2024. URL https://openreview.net/forum?id=OxkPQvpXIS.arxiv.org/abs/2407.20597
- [17]Ferran Hernandez Caralt, Mar González I Català, Adrián Bazaga, and Pietro Liò. On the necessity of learnable sheaf laplacians. In ICLR 2026 Workshop on Geometry-grounded Representation Learning and Generative Modeling, 2026. URL https://openreview.net/forum?id=IuXTY05ggp.arxiv.org/abs/2603.05395
- [18]Seongjin Choi, Gahee Kim, and Yong-Geun Oh. Hypergraph neural sheaf diffusion: A symmetric simplicial set framework for higher-order learning. IEEE Access, 13:131823–131838, 2025.DOI
- [19]Yoonhyuk Choi, Jiho Choi, Taewook Ko, JongWook Kim, and Chong-Kwon Kim. Sheaf graph neural networks via pac-bayes spectral optimization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 40, pages 20570–20578, 2026.
- [20]John Cobb and Thomas Gebhart. Feature propagation on knowledge graphs using cellular sheaves, 2023. URL https://arxiv.org/abs/2309.03773.
- [21]Justin Michael Curry. Sheaves, Cosheaves and Applications. PhD thesis, University of Pennsylvania, 2014.arxiv.org/abs/1303.3255
- [22]Leonardo Di Nino, Sergio Barbarossa, and Paolo Di Lorenzo. Learning sheaf laplacian optimizing restriction maps. In 2024 58th Asilomar Conference on Signals, Systems, and Computers, pages 59–63, 2024. doi: 10.1109/IEEECONF60004.2024.10942997.DOI
- [23]Leonardo Di Nino, Gabriele D’Acunto, Sergio Barbarossa, and Paolo Di Lorenzo. Structured sheaf learning of consistent connection graphs, 2026. URL https://arxiv.org/abs/2608.08710.
- [24]Iulia Duta, Giulia Cassarà, Fabrizio Silvestri, and Pietro Lio. Sheaf Hypergraph Networks. In Thirty-seventh Conference on Neural Information Processing Systems, NeurIPS 2023, 2023a.arxiv.org/abs/2309.17116
- [25]Iulia Duta, Giulia Cassarà, Fabrizio Silvestri, and Pietro Liò. Sheaf hypergraph networks. In Thirty-seventh Conference on Neural Information Processing Systems, 2023b. URL https://openreview.net/forum?id=NvcVXzJvhX.arxiv.org/abs/2309.17116
- [26]Matthias Fey, Jinu Sunil, Akihiro Nitta, Rishi Puri, Manan Shah, Blaž Stojanović, Ramona Bendias, Alexandria Barghi, Vid Kocijan, Zecheng Zhang, et al. Pyg 2.0: Scalable learning on real world graphs. arXiv preprint arXiv:2507.16991, 2025.arxiv.org/abs/2507.16991
- [27]Stefano Fiorini, Hakan Aktas, Iulia Duta, Pietro Morerio, Alessio Del Bue, Pietro Liò, and Stefano Coniglio. Sheaves reloaded: A direction awakening. In The Fourteenth International Conference on Learning Representations, 2026a. URL https://openreview.net/forum?id=iDiIETHQv.arxiv.org/abs/2506.02842
- [28]Stefano Fiorini, Edoardo Coppola, and Pietro Liò. Benchmarking sheaf neural networks for inductive tasks, 2026b. URL https://arxiv.org/abs/2608.02558.
- [29]Thomas Gebhart, Jakob Hansen, and Paul Schrater. Knowledge sheaves: A sheaf-theoretic framework for knowledge graph embedding. In Proceedings of the 26th International Conference on Artificial Intelligence and Statistics, volume 206 of Proceedings of Machine Learning Research, pages 9094–9116, 2023.
- [30]Patrick Gillespie, Layal Bou Hamdan, Ioannis Schizas, David L. Boothe, and Vasileios Maroulas. Bayesian sheaf neural networks. arXiv preprint arXiv:2410.09590, 2024. Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, page 1263–1272. JMLR.org, 2017.
- [31]Francesco Maria Guadagnuolo, Alessio Borgi, Dorina Thanou, and Pietro Liò. A bochner weitzenböck decomposition for cellular sheaf laplacians, curvature and neural sheaf diffusion, 2026. URL https://arxiv.org/abs/2610.28455.
- [32]André Ribeiro Guimarães, Germano Barcelos, Amauri Souza, Diego Mesquita, and Ana Luiza Tenório. Mitigating over-squashing without rewiring: A sheaf effective resistance perspective. In The Fortieth Annual Conference on Neural Information Processing Systems, 2026.
- [35]Jakob Hansen and Thomas Gebhart. Sheaf neural networks. In NeurIPS Workshop on TDA & Beyond, 2020. URL https://openreview.net/forum?id=GgcgIJST8HD.arxiv.org/abs/2012.06333
- [36]Jakob Hansen and Robert Ghrist. Learning sheaf laplacians from smooth signals. In ICASSP 2019 - 2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 5446–5450, 2019a. doi: 10.1109/ICASSP.2019.8683709.DOI
- [37]Jakob Hansen and Robert Ghrist. Toward a spectral theory of cellular sheaves. Journal of Applied and Computational Topology, 3(4):315–358, 2019b.DOI
- [38]Jakob Hansen and Robert Ghrist. Opinion dynamics on discourse sheaves. SIAM Journal on Applied Mathematics, 81(5):2033–2060, 2021.arxiv.org/abs/2005.12798
- [40]Jacob Hume and Pietro Liò. On the sheafification of higher-order message passing, 2025. URL https://arxiv.org/abs/2509.23020.
- [41]Kotaro Kamiya and Joel Nicholls. Clifford sheaf neural networks, 2026. URL https://arxiv.org/abs/2610.01322.
- [42]Emanuele Mule, Stefano Fiorini, Antonio Purificato, Federico Siciliano, Stefano Coniglio, and Fabrizio Silvestri. Directional sheaf hypergraph networks: Unifying learning on directed and undirected hypergraphs. In The Fourteenth International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=d1hQkCdy7c.
- [43]Dionisia Naddeo, Carlo Abate, Pietro Liò, Nicola Toschi, and Filippo Maria Bianchi. Hierarchical pooling for sheaf neural networks, 2026. URL https://arxiv.org/abs/2606.20932.
- [44]Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Yang, Zachary DeVito, Martin Raison, AlyKhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. PyTorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems, volume 32, 2019.arxiv.org/abs/1912.01703
- [45]Yuhan Peng, Junwen Dong, Yuzhi Zeng, Hao Li, Ce Ju, Huitao Feng, Dicaeldin Taha, Anna Wienhard, and Kelin Xia. Sheaf neural networks on spd manifolds: Second-order geometric representation learning, 2026. URL https://arxiv.org/abs/2604.20308.
- [46]Oleg Platonov, Denis Kuznedelev, Michael Diskin, Artem Babenko, and Liudmila Prokhorenkova. A critical look at the evaluation of GNNs under heterophily: Are we really making progress? In The Eleventh International Conference on Learning Representations, 2023. URL https://openreview.net/forum?id=JbbQfW-5wv.arxiv.org/abs/2302.11640
- [47]André Ribeiro, Ana Luiza Tenorio, Juan Belieni, Amauri H. Souza, and Diego Mesquita. Co-operative sheaf neural networks. In International Conference on Learning Representations, 2026a.
- [48]André Ribeiro, Ana Luiza Tenório, Tiago da Silva, and Diego Mesquita. Gaussian sheaf neural networks, 2026b. URL https://arxiv.org/abs/2605.21435.
- [49]Daniel Rosiak. Sheaf Theory through Examples. The MIT Press, 10 2022. ISBN 9780262370424. doi: 10.7551/mitpress/12581.001.0001. URL https://doi.org/10.7551/mitpress/12581.001.0001.
- [50]T Konstantin Rusch, Michael M Bronstein, and Siddhartha Mishra. A survey on oversmoothing in graph neural networks. arXiv preprint arXiv:2303.10993, 2023.arxiv.org/abs/2303.10993
- [51]Allen D. Shepard. A Cellular Description of the Derived Category of a Stratified Space. PhD thesis, Brown University, 1985.
- [52]Julian Suk, Lorenzo Giusti, Tamir Hemo, Miguel Lopez, Konstantinos Barmpas, and Cristian Bodnar. Surfing on the neural sheaf. In NeurIPS 2022 Workshop on Symmetry and Geometry in Neural Representations, 2022. URL https://openreview.net/forum?id=xOXFkyRzTlu.
- [53]Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, Tianjun Xiao, Tong He, George Karypis, Jinyang Li, and Zheng Zhang. Deep graph library: A graph-centric, highly-performant package for graph neural networks, 2019.arxiv.org/abs/1909.01315
- [54]Olga Zaghen, Antonio Longa, Steve Azzolin, Lev Telyatnikov, Andrea Passerini, and Pietro Liò. Sheaf diffusion goes nonlinear: Enhancing GNNs with adaptive sheaf laplacians. In ICML 2024 Workshop on Geometry-grounded Representation Learning and Generative Modeling, 2024. URL https://openreview.net/forum?id=MGQtGV5gPO.