acceptodds
Under review as a conference paper at ICLR 2027

Differentiable Higher-Order Graph Learning via Sheaf-Inspired Local Inconsistency

Abstract

Topological neural networks (TNNs) extend graph neural networks by modeling higher-order interactions beyond pairwise relations, but their effectiveness critically depends on how higher-order structures are constructed. Existing graph lifting methods typically rely on connectivity or feature similarity, which often fail to capture meaningful relationships, particularly in heterophilous graphs where connected nodes exhibit dissimilar features or labels. To address this issue, we propose a graph lifting framework based on local inconsistency, inspired by cellular sheaf theory, where edge-dependent transformations compare node representations in shared spaces to capture relational patterns beyond similarity. We further introduce a differentiable framework that aggregates edge-level inconsistencies over cycles and employs a soft gating mechanism to construct weighted higher-order structures in an end-to-end manner. The proposed framework is applicable across various topological domains, e.g., simplicial and cellular complexes, and can be integrated with diverse TNN architectures. Extensive experiments demonstrate consistent performance improvements across diverse TNN backbones and a wide range of graph lifting baselines, with particularly strong gains on heterophilous graph datasets. Code will be released upon acceptance.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Topological Deep Learning, Graph Lifting, Cellular Sheaves, Higher-order Graph Learning

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_v3zhOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The authors of the paper propose a differentiable graph lifting framework for constructing higher-order structures based on sheaf-inspired local relational inconsistency. The method introduces learnable edge-dependent transformations to compare node representations in shared spaces, moving beyond conventional connectivity- and similarity-based lifting criteria. Edge-level inconsistencies are aggregated over candidate cycles, which are subsequently weighted through a differentiable gating mechanism to construct higher-order structures. The framework is evaluated on homophilic and heterophilic graphs using several topological neural network architectures and graph lifting baselines.

Critical strengths
  • The authors address a limitation of existing graph lifting approaches, which often rely on connectivity or feature similarity to construct higher-order structures. The proposed use of sheaf-inspired local relational inconsistency, modeled through edge-dependent transformations, provides an alternative criterion for identifying meaningful higher-order interactions, particularly in heterophilic settings
  • The proposed framework achieves consistent performance improvements across different topological neural network architectures, with particularly strong results on heterophilic datasets. These findings provide empirical evidence of the effectiveness of the proposed lifting strategy across different backbones
Critical weaknesses
  • Although the authors provide a theoretical complexity analysis, the paper lacks an empirical comparison of computational costs with existing lifting approaches. In particular, the additional training time and memory consumption introduced by the proposed framework are not evaluated. This limitation is particularly relevant given that the experiments focus on relatively small graphs, leaving the scalability of the proposed approach to larger graphs unclear and making it difficult to assess whether the reported performance improvements justify the additional computational overhead
  • The proposed cycle-level inconsistency is computed as the average of edge-level disagreement scores. However, different cycles with distinct relational patterns may have the same average inconsistency, resulting in identical gating weights. This may limit the ability of the proposed lifting criterion to distinguish different higher-order structures
Questions for authors
  • What is the computational cost of the proposed framework compared with other lifting approaches? It would be useful to provide a comparison of training time and memory requirements
  • Since the proposed inconsistency measure averages edge-level scores, different cycles with distinct relational patterns may receive identical gating weights. How does this limitation affect the ability of the framework to distinguish different higher-order structures?
  • The experimental evaluation focuses on established undirected graph learning approaches. Recent methods, such as [1], have explored directional higher-order representations. How do the authors position their framework with respect to these approaches? Could the proposed lifting mechanism be extended to directed higher-order structures?

[1] Lecha, Manuel, et al. "Directed semi-simplicial learning with applications to brain activity decoding." International Conference on Learning Representations. Vol. 2026. 2026.

5 comments

W1 & Q1) Empirical computational cost and scalability.

A) We thank the reviewer for highlighting the need to evaluate computational overhead beyond theoretical complexity. To address this concern, we conducted additional runtime and memory profiling across six datasets and four TNN backbones (EDGNN, SCN, CWN, and CCXN), comparing SheafLifting against static cycle lifting and the official ∂lift implementation.

Importantly, static cycle lifting uses exactly the same candidate structures and backbone architecture as SheafLifting, with uniform cycle weights (wc=1w_c=1). This controlled comparison directly isolates the additional computational cost of our restriction-map-based scoring and adaptive cycle weighting. We measured complete training steps, including forward computation, loss, backward computation, and optimizer updates. All measurements were performed sequentially with GPU-process monitoring, warm-up, and repeated synchronized trials.

Table 1. Training-step latency (ms) and peak CUDA allocated memory (MB).

DatasetBackboneStatic (ms)Ours (ms)∂lift (ms)Static (MB)Ours (MB)∂lift (MB)
TexasEDGNN14.621.425.6303130
TexasSCN12.618.544.7282936
TexasCWN13.820.545.4313130
TexasCCXN12.519.534.2292930
ActorEDGNN15.826.3982.62676503,094
ActorSCN13.321.24,461.825160131,707
ActorCWN15.523.22,052.134260319,201
ActorCCXN13.321.21,837.927160110,247
The ∂lift results use its official implementation and native dynamic candidate construction, including different backbone mappings where required.

Across all 24 dataset–backbone configurations, SheafLifting incurs approximately 1.42–1.66× training-step overhead relative to static cycle lifting. On smaller graphs such as Texas, the additional GPU memory is negligible (at most 1 MB across the four backbones). On Actor, the memory overhead is more pronounced; for example, CWN increases from 342 MB to 603 MB. These results quantify the practical cost of differentiable relational scoring rather than assuming negligible overhead.

CPU candidate preprocessing was profiled separately. On Actor, the NetworkX cycle_basis alternative yields 3,596 candidates in 0.466 s, whereas the main minimum_cycle_basis construction yields 19,004 candidates in 175.4 s. These differ in candidate pool and should not be interpreted as a matched-candidate timing comparison.

Our shared-basis parameterization avoids learning independent dense restriction maps for individual edges, reducing the number of learnable transformation parameters. Nevertheless, we agree that this parameter efficiency does not establish end-to-end scalability. While the present profiling provides empirical evidence of the computational trade-offs across the evaluated datasets, performance and efficiency on substantially larger graphs remain to be established.

We will include the complete results for all six datasets and four backbones, including inference latency, preprocessing time, and peak GPU memory, in the revised Appendix. For the full profiling comparison, refer to Q4 of Reviewer 7RUG.

W2 & Q2) Expressivity of cycle-level inconsistency aggregation

A) Mean aggregation is not injective: cycles with different distributions or orders of edge inconsistencies may have the same mean and therefore the same gate. It summarizes length-normalized disagreement; it is not a complete description of within-cycle relational patterns.

Importantly, identical gating weights do not necessarily imply identical higher-order representations. As defined in Eqs. (9)–(10), each candidate retains its own edge–cell incidence structure and aggregated edge features. Consequently, cycles assigned the same scalar weight can still contribute differently to higher-order message passing through their distinct constituent edges and cell representations. Nevertheless, the gating criterion itself cannot distinguish cycles based solely on differences in the distribution or ordering of edge inconsistencies when their means coincide.

Aggregation ablation. We compared mean, max, and mean + std on Cora, Texas, Cornell, and Actor using CWN and EDGNN:

\delta_c^{\mathrm{max}} &= \max_{e\in c}\delta_e,\\\\ \delta_c^{\mathrm{mean+std}} &= \operatorname{mean}_{e\in c}\delta_e + \operatorname{std}_{e\in c}\delta_e. \end{aligned}$$ All variants were retrained using identical candidate structures, backbone architectures, model capacities, data splits, and optimization settings. **Table 1. Corrected node classification accuracy (%) for cycle aggregation variants.** | Backbone | Dataset | Mean | Max | Mean + Std | |:---|:---|---:|---:|---:| | CWN | Cora | **87.50** | 86.72 | 86.36 | | CWN | Texas | **80.80** | 78.72 | 76.41 | | CWN | Cornell | **73.70** | 73.21 | 73.15 | | CWN | Actor | **38.30** | 37.91 | 38.01 | | CWN | Avg. | **70.08** | 69.14 | 68.48 | | EDGNN | Cora | 87.50 | **88.09** | 87.46 | | EDGNN | Texas | 78.60 | **79.71** | 79.15 | | EDGNN | Cornell | **71.60** | 66.60 | 68.86 | | EDGNN | Actor | 37.80 | **38.39** | 38.07 | | EDGNN | Avg. | **68.88** | 68.20 | 68.39 | *Avg. denotes the unweighted average across Cora, Texas, Cornell, and Actor. Full results will be reported in the revised Appendix.* **Distributional analysis.** On Actor/CWN, 8,555 of 12,278 cycle pairs (70%) with mean inconsistencies differing by less than $10^{-3}$ have a standard-deviation difference greater than 0.05. Thus mean aggregation loses distributional detail, even though distinct cycles still retain different incidence and feature information. Incorporating standard deviation did not consistently improve downstream accuracy in the evaluated settings. **Interpretation.** Mean aggregation provides a simple, differentiable, and length-normalized summary of relational disagreement, achieving the highest average accuracy across the evaluated aggregation rules for both backbones. --- **Q3) Relationship to directed semi-simplicial learning and applicability to directed graphs.** **A)** Lecha et al. [4] study directed higher-order representation through semi-simplicial structures and face-map-based message passing. Our focus is complementary: learning relation-aware weights for candidate higher-order structures. **Distinction.** SSNs specify direction-aware higher-order cells and message-passing operators; SheafLifting specifies a learnable edge-conditioned criterion for candidate weighting. A full integration would require suitable directed candidates, incidence/face maps, and a direction-aware backbone rather than assuming our current undirected construction is already semi-simplicial. **Directional information.** Our two endpoint restriction maps depend on oppositely ordered inputs $[h_u\|h_v]$ and $[h_v\|h_u]$, allowing distinct endpoint-conditioned transformations. The ordered edge-feature concatenation $h_e=\psi_\theta([h_u\|h_v\|\lvert h_u-h_v\rvert])$ can preserve source/target roles in a directed extension, together with direction-aware candidate construction and message passing. **Revision plan.** We will clarify in the revised discussion how the learned relational criterion could complement directed semi-simplicial representations and specify the directed candidates, face maps, and backbone operators required for such an extension. The present experiments focus on undirected graphs.

I thank the authors for their detailed responses and additional experiments, which address several of my concerns and help clarify the proposed approach. However, my concern regarding scalability remains unresolved. The evaluation is still limited to six relatively small datasets (the largest being Actor, with only 7,600 nodes), and the substantial preprocessing time reported for Actor raises concerns about applicability to larger graphs. I would encourage a more extensive evaluation on larger datasets, potentially including Yelp and Trivago from DHG-Bench [1], to better assess both the scalability and the benefits of the proposed method in more challenging settings. While I appreciate the improvements made during the rebuttal, I maintain my original rating.

[1] DHG-Bench: A Comprehensive Benchmark for Deep Hypergraph Learning.

Reviewer_7RUGOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes a sheaf-inspired, task-driven graph-lifting module. Nodes are mapped to latent stalk representations, and edge-conditioned restriction maps are formed from shared basis matrices. Cosine disagreement between transformed endpoints defines local inconsistency. Averaged candidate-cycle scores are passed through sigmoid gates to produce weighted edge–cycle incidence matrices and cell features. The module is trained jointly with a TNN, using gate sparsity, basis orthogonality, and coefficient-entropy regularization.

Experiments compare four backbones—EDGNN, SCN, CWN, and CCXN—and several lifting methods, including ∂lift. Beyond the five main node-classification datasets, the appendices add Wisconsin, candidate-structure analyses, regularization and basis-count ablations, and ten-fold means and standard deviations in B.5.

Critical strengths
  1. The module has a plausible practical design. Shared-basis relation maps avoid storing a separate dense matrix for every edge. Equations (8)–(10) allow task gradients to reach candidate-structure weights and support integration with several backbones. This is a reasonable route toward learning structure relative to completely fixed lifting.

  2. Improvements appear across backbones within the evaluated scope, and the appendix evidence is more complete than the main text alone suggests. In Table 1, CWN accuracy rises from the best non-proposed method's 0.757 to 0.808 on Texas and from 0.660 to 0.737 on Cornell. Appendices A/B contain candidate-structure and component analyses, and B.5 reports ten-fold standard deviations. Page 8 also states that baselines are reproduced under a common protocol using official implementations or TopoBench. They should not be criticized as incompatible published numbers simply pasted together. The issues are baseline strength and tuning transparency, not a complete absence of controlled experiments.

Critical weaknesses
  1. Adaptation across topological domains is underspecified, and some structural interpretations exceed the evidence. Equation (7) on page 5 averages edge scores along a cycle. Together with cycle membership, this does create a higher-order entity that can participate in higher-order message passing. However, the score itself is fully determined by pairwise scalars and has not been shown to identify additional cycle-consistency constraints. The descriptions of discrepancies undetectable from pairwise relations and of fillability should therefore be framed as task-related heuristics rather than established topological criteria. A complete sheaf-extension theory is unnecessary; an accurate account of what the score measures is required.

    The concrete implementation gap is in Appendix A. Paths and ego subgraphs are converted to the main text's edge–cell incidence representation, and page 13 states that cycles directly correspond to simplicial/cellular 2-cells. A cycle longer than three edges can bound a cellular 2-cell but is not one simplicial 2-simplex. If triangulation, subdivision, or another adaptation is used, the additional entities and features must be specified. If the directed edges of an open path directly form one boundary column bpb_p, then B1bp≠0B_1b_p\neq0. Conversely, a combinatorial-complex or set-incidence implementation need not be erroneous, but cannot inherit the same boundary interpretation without qualification. Actual operators should be specified for each backbone, beyond a common schematic.

  2. The independent value of the relational criterion and the claimed heterophily advantage need targeted experiments. Candidate-structure, R-value, and regularization ablations are present, but do not sufficiently distinguish additional learnable capacity, generic edge-conditioned gating, and the proposed relational criterion. One simplified relational scorer with fixed candidates and matched capacity, together with an all-one cycle-weight control, would be more informative than further regularizer tables. Tables 2/5 evaluate structures using the model's learned δc\delta_c, while its top-k selection follows weights monotonically decreasing in that same score. These results describe internal preferences, not independent structural-quality validation. Since candidate pools differ across methods, however, the entire comparison should not be dismissed as a strict tautology.

    The inclusion of ∂lift deserves credit. Nevertheless, ordinary graph baselines are limited to GCN/GAT despite the emphasis on heterophily, leaving no strong reference from tuned simple models, representative heterophily GNNs, or relevant sheaf methods. A small number of the most relevant controls would suffice; every method need not be reproduced. Ten-fold standard deviations are provided, but paired contrasts are needed to interpret smaller gains. For example, Texas/EDGNN is 0.786±0.136 versus 0.757±0.104 for ∂lift: overlapping standard deviations do not prove nonsignificance, and the mean difference alone does not establish stable improvement. Appendix D does not adequately specify within-fold validation, optimizer, learning rate, hidden width, early stopping, or tuning budgets, impeding fair reproduction.

Questions for authors
  1. Primary; affects reliability: Please provide the actual incidence/boundary operators for each backbone, especially SCN's treatment of 4–6-edge cycles and whether path/ego experiments use combinatorial incidence rather than cellular boundaries. A small example and a B1B2B_1B_2 check where applicable could resolve this directly. If TopoBench conversions are reused, please identify the implementation.
  2. Primary; affects the contribution assessment: With candidates, parameter count, and training budget fixed, what does the proposed scorer add over an ordinary learnable edge-conditioned scorer and over all-one cycle weights? Please report same-fold paired differences for the main results and specify baseline tuning budgets.
  3. Implementation clarification: How are the two endpoint maps generated, and is α\alpha normalized? How are endpoint exchange and node relabeling handled? Which cycle-basis algorithm is used, and how many candidates are produced? Please complete the principal training settings. Maximizing coefficient entropy encourages each edge to distribute weight across bases, but does not automatically establish greater diversity of relational patterns across edges; these should be distinguished.
  4. Comparison scope and cost: Can one highly relevant strong heterophily or sheaf baseline clarify competitiveness on the current tasks? A larger modern graph benchmark would provide additional evidence. At minimum, report candidate counts, preprocessing time, and runtime for the existing settings; linear scoring complexity for fixed R, p, and bounded candidates does not by itself establish the complete pipeline's practical efficiency.
5 comments

W1) Topological interpretation and structural validity.

A) We thank the reviewer for the careful assessment. An important distinction is that topological structure and relational scoring play different roles in our framework. The cycle basis determines structurally admissible candidates through graph connectivity and closure, while the learned inconsistency evaluates their task-dependent relational compatibility. Accordingly, the cycle score is not intended to certify formal sheaf-theoretic consistency or topological fillability. Rather, our contribution is to learn how strongly these structurally defined candidates should participate in downstream message passing. We will revise the statements about discrepancies beyond pairwise relations and fillability to reflect this distinction.

Importantly, the scoring and gating formulation does not depend on cycles specifically. Appendix A evaluates the same formulation with clique, path, and ego-network candidates. For example, on EDGNN, ego candidates achieve 79.8% versus 78.6% with cycles on Texas, while paths achieve 73.3% versus 71.6% with cycles on Cornell. These results illustrate the applicability of our relational criterion across different candidate families, without implying formal topological guarantees.

Regarding structural validity, cycles of length 4–6 are represented as polygonal rank-2 candidates without triangulation. Closed cycles admit cellular boundary operators when coherently oriented, whereas paths and ego candidates use general edge–candidate incidence rather than cellular boundaries. Revised Appendix A will label these constructions separately and explain when B1B2=0B_1B_2=0 applies. For the signed-cycle example and backbone-specific conventions, please refer to our response to Q1.


W2) Independent contribution of relational scoring and experimental reliability.

A) We evaluated two controls that directly test the proposed relational criterion: a closely matched edge-conditioned MLP scorer and an all-one cycle-weight ablation. Across 24 dataset–backbone configurations, our method outperforms the matched MLP in 23/24 settings and the all-one control in all 24 settings, with mean gains of +4.02 pp and +9.64 pp, respectively. For full same-fold paired differences and p-values, please refer to our response to Q2.

Controlled design. Both controls use the same candidate sets, downstream backbones, evaluation splits, and training budgets and are trained from scratch. The matched MLP compares restriction-map scoring with generic edge-conditioned scoring; the all-one control isolates the effect of adaptive weighting in the proposed framework.

Matched scorer: 11,592 scorer parameters in SheafLifting and 11,565 in the MLP alternative; cycle aggregation and gating are retained.

All-one weights: wc≡1w_c\equiv1 with the candidate/backbone setup held fixed. This is a targeted ablation of our pipeline, not necessarily identical to the separately configured cyc. lifting baseline in the submitted manuscript.

Statistical summary. Positive improvements are significant at p<0.05p<0.05 in 19/24 comparisons against the matched MLP and 20/24 against all-one weighting. After Benjamini–Hochberg correction at 5% FDR, 16/24 and 19/24 positive improvements remain significant, respectively. These results support the contribution of relational scoring and adaptive weighting across both homophilic and heterophilic datasets. For the added validation-tuned MLP, NSD [3], and DCM [1] comparisons and their tuning budgets, please refer to our response to Q4.

Revision plan. We will label the selection statistics as internal diagnostics and place control definitions, individual fold-level paired results, checkpoint selection, and tuning budgets in Appendix D. For the full control-comparison table and test details, please refer to our response to Q2.

Q1) Backbone-specific operators and structural validity.

A) Our lifting uses each backbone’s incidence conventions: EDGNN and CWN use unsigned incidence in their respective implementations, while CCXN uses TopoBench signed incidence. For SCN, we use the TopoBench-style formulation with signed cellular boundaries and the operators specified below. The lifting supplies learned candidate weights without replacing each downstream architecture.

For SCN, we employ a cellular-domain adaptation of the original simplicial formulation. Specifically, cycles of length 4–6 are represented as polygonal 2-cells rather than simplicial 2-simplices, without triangulation or introducing additional vertices or edges. Since the underlying Hodge operators are constructed from signed boundary matrices, this adaptation preserves the chain-complex identity B1B2=0B_1B_2=0 and the corresponding Hodge-Laplacian structure. For example, an oriented four-cycle 1→2→3→4→11\to2\to3\to4\to1 has boundary column bc=(1,1,1,1)⊤b_c=(1,1,1,1)^\top, satisfying B1bc=0B_1b_c=0. Furthermore, learned cycle weighting preserves this identity: B1B~2=(B1B2)diag⁡(w)=0B_1\widetilde B_2=(B_1B_2)\operatorname{diag}(w)=0.

SCN signed operators. With B1∈R∣V∣×∣E∣B_1\in\mathbb R^{|V|\times|E|} and B2∈R∣E∣×∣C∣B_2\in\mathbb R^{|E|\times|C|} as signed boundaries, let B~2=B2diag⁡(w)\widetilde B_2=B_2\operatorname{diag}(w). We implement the rank-wise Hodge operators as:

L_0 &= B_1B_1^\top,\\ L_1 &= B_1^\top B_1+\widetilde B_2\widetilde B_2^\top,\\ L_2 &= \widetilde B_2^\top\widetilde B_2,\\ \widetilde L_k &= D_k^{-1/2} L_kD_k^{-1/2}, \end{aligned}$$ Here $D_k=\operatorname{diag}(\operatorname{rowsum}(|L_k^{(w=1)}|))$ is computed on the unweighted complex and held fixed. Each cell contributes $w_c^2b_cb_c^\top$ to the upper term of $L_1$; interactions between cells $c,c^\prime$ in $L_2$ scale with $w_cw_{c^\prime}$. Thus fixed normalization does not cancel the learned weight scaling. **SCN layer and readout.** At each rank, the layer is $x_k\leftarrow\operatorname{ReLU}((2I+\widetilde L_k)x_kW_k)$; the ranks do not mix *within* the layer. The SCN wrapper uses an unsigned gated-mean readout $h_2\to h_1\to h_0$. Operators are computed with sparse–dense products without materializing gradient-bearing Laplacians. As $w_c\to0$, that cell’s weighted Hodge coupling vanishes, but the candidate is not discretely deleted and its self-representation can remain through the $2I$ term and readout. We additionally verified the signed cellular construction numerically across six datasets using both standard and minimum cycle bases, obtaining $\max|B_1B_2|=0$ in every case. For the path and ego-network ablations in Appendix A, we use general edge–candidate incidence, with signed entries for SCN/CCXN and unsigned entries for EDGNN/CWN. These candidates are not assumed to define closed cellular boundaries; thus, we do not claim $B_1B_2=0$ for these settings. Their purpose is to evaluate the applicability of our relational lifting criterion to broader higher-order incidence structures, rather than to establish cellular-complex validity for every candidate family. **Revision plan.** Appendix A will explicitly distinguish polygonal closed-cell boundaries from path/ego edge–candidate incidence, and Appendix D will describe the SCN implementation, its fixed unweighted normalization, the wrapper readout, and the remaining EDGNN/CWN/CCXN implementation-specific operator details and TopoBench conversions.

Q2) Independent contribution of the relational scorer, paired statistical comparisons, and baseline tuning budgets.

A) We directly compared our scorer with a parameter-matched edge-conditioned MLP and evaluated all-one cycle weights using identical candidate sets, backbones, data splits, and training budgets, with the controls retrained from scratch. The results isolate structured relational scoring from generic edge-conditioned learning and adaptive gating from static candidate inclusion.

1. Contribution of the restriction-map-based scorer. We replaced our sheaf-inspired inconsistency measure with an ordinary edge-conditioned MLP that directly predicts scalar edge inconsistency. Both scorers use the same output range, and their parameter counts are closely matched (11,592 for ours versus 11,565 for the MLP). All other components, including cycle aggregation and differentiable gating, remain unchanged. This comparison directly tests whether the structured restriction-map parameterization offers benefits beyond generic edge-conditioned learning.

2. Contribution of adaptive relational lifting. We additionally evaluated a control with uniform cycle weights (wc≡1w_c\equiv1), retaining the same candidate structures and downstream TNN backbone. Unlike the matched-MLP experiment, this control evaluates the complete adaptive relational-lifting mechanism against static incorporation of the same candidate cycles.

Table 1. Summary of paired controlled comparisons across 24 dataset–backbone configurations.

ComparisonMean Δ (pp)Ours > ControlSignificant gains (p<0.05p<0.05)FDR-adjusted gains
Ours vs. matched MLP+4.0223/2419/2416/24
Ours vs. all-one weights+9.6424/2420/2419/24
Δ = Ours − Control (percentage points). All tests are two-sided same-fold paired t-tests; positive uncorrected gains use p<0.05p<0.05. Benjamini–Hochberg FDR correction at 5% is applied separately to the 24 comparisons against each control. The full dataset–backbone results appear immediately below.

Table 2. Detailed same-fold paired accuracy differences (pp) and p-values for the two controls.

DatasetBackboneΔ vs MLP (pp)Paired t-test (pp)Δ vs All-one (pp)Paired t-test (pp)
CoraEDGNN+5.300.0046+12.150.0040
CoraSCN+4.700.0060+1.100.0314
CoraCWN+3.550.0089+2.150.0156
CoraCCXN+5.030.0029+3.140.0064
CiteSeerEDGNN+2.050.0015+4.360.0444
CiteSeerSCN+2.860.0075+4.750.0029
CiteSeerCWN+4.420.0141+3.970.0193
CiteSeerCCXN+4.270.0073+3.040.0380
TexasEDGNN+6.140.0164+12.190.0137
TexasSCN+8.820.0044+24.340.0014
TexasCWN+5.620.0289+14.970.0045
TexasCCXN+4.940.0409+20.210.0016
WisconsinEDGNN+1.630.0525+2.840.0843
WisconsinSCN+1.630.1130+21.600.0077
WisconsinCWN+4.340.0409+7.520.0012
WisconsinCCXN+5.570.0191+31.040.0002
CornellEDGNN+6.550.0277+8.950.0030
CornellSCN+7.970.0276+16.330.0032
CornellCWN+6.130.0330+8.180.0117
CornellCCXN−1.420.5950+23.100.0014
ActorEDGNN+1.480.1125+1.250.0265
ActorSCN+1.060.0255+0.630.0682
ActorCWN+1.460.0382+1.370.0675
ActorCCXN+2.270.1665+2.200.1120
Δ = Ours − Control (percentage points). P-values are from two-sided, same-fold paired t-tests.

Interpretation. The matched-MLP comparison evaluates the benefit of restriction-map-based scoring at nearly equal parameter count, while the all-one control isolates the contribution of adaptive cycle weighting. SheafLifting outperforms the matched MLP in 23/24 configurations (average +4.02 pp) and the all-one control in all 24 configurations (average +9.64 pp). After Benjamini–Hochberg correction at 5% FDR, 16/24 and 19/24 positive improvements remain significant, respectively. The all-one control measures learned weighting within our framework and is distinct from the original cyc. baseline, which uses a different lifting configuration.

Baseline tuning. The tuned MLP uses 29 validation-selected configurations; NSD [3] and DCM [1] use available defaults without additional search. The same-fold controls use the proposed model’s training budget without test-guided tuning. For the broader baseline comparison, please refer to our response to Q4; shared protocol details appear in the General Comment.

Revision plan. Appendix D will include the control definitions (including treatment of scorer-specific regularization), all fold-wise differences, statistical corrections, and baseline-specific model-selection and tuning rules.

Reviewer_YRyGOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a differentiable graph lifting framework based on sheaf-inspired local inconsistency. The method learns edge-dependent restriction maps to compare node representations, aggregates the resulting inconsistency scores over candidate cycles, and assigns learnable weights to these cycles. The resulting structures are used with different TNN architectures. Experiments show promising improvements, particularly on heterophilous datasets.

Critical strengths

The paper addresses an important problem in topological deep learning by investigating graph lifting under heterophily, where similarity-based criteria may be insufficient.

The authors properly acknowledge previous differentiable lifting approaches and provide direct experimental comparisons. This is particularly important for establishing the contribution of the proposed method.

The experiments cover multiple TNN architectures and lifting strategies, with promising improvements. The authors also provide ablations on regularization, candidate structures, and the number of basis matrices.

Critical weaknesses
  1. Limited structural expressivity and unclear methodological distinction. Unlike previous learnable liftings which can learn the underlying 1-skeleton and select cells, the proposed method only weights candidates extracted from a fixed cycle basis. Since the sigmoid weights remain positive, it does not actually remove cells. The paper provides no clear mathematical or methodological justification of how this approach compares in structural expressivity with previous differentiable liftings.

  2. Limited sheaf-based modeling. The restriction maps and inconsistency scores are defined only at the edge level, while simply averaging these scores over cycles. It is unclear what additional relational information is captured by this aggregation or why it provides a meaningful measure of cycle consistency. Is it just up to rank-2 higher topological complexes?

  3. Unclear mathematical formulation. Equation (4) does not explicitly define the restriction map for the second endpoint, leaving the treatment of edge direction and the expressivity of the learned transformations unclear. Moreover, the construction of valid simplicial complexes from cycles longer than three needs clarification. Are the orientation chosen arbitrarly?

  4. The evaluation is also restricted to node classification, without graph classification experiments to assess its generalization to graph-level tasks.

Questions for authors
    1. What is the mathematical or methodological advantage of the proposed weighted cycle selection over previous learnable liftings particularly regarding structural expressivity and the ability to construct new cells?
    1. How is the second restriction map in Equation (5) parameterized, and how are valid simplicial structures constructed from the selected cycles? Can it create new cycles or just select it from the original cycle basis? Is it up to rank 2 or it can go to higher ranks?
    1. Why were no graph classification experiments conducted? Can the authors evaluate whether the proposed lifting approach also improves graph-level prediction tasks?
5 comments

W1 & Q1) Structural expressivity and methodological distinction.

A) We thank the reviewer for the constructive feedback. Importantly, prior methods also employ candidate-based cell selection: DCM [1] learns a 1-skeleton before extracting candidate cycles, while ∂lift [2] learns edge inclusion before constructing higher-order candidates. Their greater structural flexibility thus arises from adaptive candidate construction, whereas ours uses a fixed cycle basis. Our scoring and gating are independent of candidate generation, making this a design choice rather than an inherent limitation. Our contribution lies in the relation-aware lifting criterion, not greater structural expressivity. Specifically, our edge-dependent restriction maps measure relational agreement after transformation, rather than relying on direct embedding-space proximity, which is particularly beneficial under heterophily. We acknowledge that sigmoid gates provide soft weighting rather than exact removal.


W2) Sheaf-inspired modeling and cycle-level consistency

A) Mean aggregation is a length-normalized summary of relational compatibility, not a formal sheaf-theoretic cycle-consistency test. Higher-order information enters through the weighted edge–cell incidence and TNN message passing: distinct cycles may receive identical weights yet produce different representations because their incidences and edge features differ. We will revise the interpretation of Eq. (7) in Section 4.2 to remove formal fillability and beyond-pairwise-consistency claims.

While our current implementation focuses on rank-2 candidates, the proposed relational lifting principle is not inherently restricted to rank 2. Given appropriately defined higher-rank candidates and their incidence operators, together with informative cell-level representations, which are not readily available in most conventional graph benchmarks, our framework can be naturally extended to higher-rank structures by applying the same relation-aware scoring and differentiable weighting principles across successive ranks.

Aggregation ablation. We compared mean, max, and mean + std on Cora, Texas, Cornell, and Actor. Their unweighted average accuracies were 70.08/69.14/68.48% for CWN and 68.88/68.20/68.39% for EDGNN, respectively. Among these three aggregation rules, mean has the highest four-dataset average for both backbones. Neither alternative showed a statistically significant paired improvement over mean on matching evaluation folds (Wilcoxon signed-rank tests; all p≥0.062p\geq0.062). Thus, mean remains a simple and competitive default. For additional aggregation variants, refer to W2 & Q2 of Reviewer v3zh.

Cycle-level inconsistency aggregation ablation.
Accuracy (%) over the 10-fold evaluation. The best result in each row is bolded.

BackboneDatasetMeanMaxMean + Std
CWNCora87.5086.7286.36
CWNTexas80.8078.7276.41
CWNCornell73.7073.2173.15
CWNActor38.3037.9138.01
CWNAvg.70.0869.1468.48
EDGNNCora87.5088.0987.46
EDGNNTexas78.6079.7179.15
EDGNNCornell71.6066.6068.86
EDGNNActor37.8038.3938.07
EDGNNAvg.68.8868.2068.39
Avg. denotes the unweighted mean across Cora, Texas, Cornell, and Actor.

W3 & Q2) Restriction maps, edge orientation, and simplicial construction.

A) Both endpoints receive separately conditioned restriction maps constructed from shared basis matrices, with αu=softmax⁡(gϕ([hu∥hv]))\alpha^u=\operatorname{softmax}(g_\phi([h_u\|h_v])) and αv=softmax⁡(gϕ([hv∥hu]))\alpha^v=\operatorname{softmax}(g_\phi([h_v\|h_u])). The ordered inputs allow generally distinct endpoint transformations and thus encode endpoint-specific relational information. For the undirected graphs evaluated here, swapping endpoints exchanges the two maps and leaves their cosine-based scalar inconsistency unchanged; notably this avoids dependence on an arbitrary orientation. A directed extension retains source–target information in ordered edge features and direction-aware incidence/message passing, although the current scalar inconsistency alone does not distinguish a directed edge from its reversal. We will state both endpoint formulas explicitly in revised Eq. (4).

Cycles of length 4–6 are treated as polygonal rank-2 cellular candidates, not simplicial 2-simplices. The current method weights a fixed candidate set; it does not generate new edges or cycles beyond that set. We will distinguish polygonal cellular boundaries from path/ego edge–candidate incidence in Appendix A. For the signed-boundary check and backbone-specific details, please refer to Q1 of Reviewer 7RUG.

W4 & Q3) Generalization to graph-level prediction tasks.

A) We evaluated graph-level generalization using CWN and CCXN, extending our assessment beyond node classification. Across the four graph classification benchmarks reported below (MUTAG, PROTEINS, ENZYMES, and NCI1), SheafLifting achieves statistically significant positive gains in all eight dataset–backbone comparisons (two-sided, same-fold paired t-tests).

Experimental setup. We used default SheafLifting configurations without additional hyperparameter search and compared them with the official ∂lift PropagateSignalDown variants under shared splits and a maximum training budget of 200 epochs. These variants propagate higher-order information to graph-level readout. As the respective default encoder and optimization settings differ, the comparison controls splits and budget rather than architecture or parameter count.

Table 1. Graph classification improvements over ∂lift (percentage points).

DatasetCWN Δ (pp)Paired t-test (p)CCXN Δ (pp)Paired t-test (p)
MUTAG+2.660.0136+5.880.0070
PROTEINS+0.900.0284+2.510.0180
ENZYMES+15.50<0.001<0.001+10.670.0040
NCI1+2.260.0052+1.290.0237
Δ = SheafLifting − ∂lift, in percentage points. Results use corresponding ∂lift-CWN-prop and ∂lift-CXN-prop variants. P-values are from same-fold paired t-tests. Bold indicates significant positive improvement (uncorrected p<0.05p<0.05).

Results. Both backbones improve significantly on MUTAG (+2.66/+5.88 pp), PROTEINS (+0.90/+2.51 pp), ENZYMES (+15.50/+10.67 pp), and NCI1 (+2.26/+1.29 pp), for CWN/CCXN respectively. ENZYMES shows the largest improvement in the displayed comparisons.

Revision plan. The revised Appendix will provide complete graph-level accuracies for all evaluated datasets, fold-level tests, and the configurations of both compared implementations.

I thank the authors for their detailed responses and additional experiments, particularly the graph classification results.

I really liked the paper and its motivation. Although I still have some concerns regarding the structural expressivity of the proposed lifting and the limited extension of the sheaf formulation, I appreciate the authors’ efforts to address my concerns.

Considering the additional experimental evidence and methodological clarifications, I will keep my score to 2 because I think there are still some TNN baselines missing for a better comparison. I sincerely encourage the authors to continue working on this research direction, particularly towards more expressive learnable lifting mechanisms.

Comments on the paper

1 comment

Dear Reviewers,

As the discussion period draws to a close, please read and acknowledge the authors’ rebuttal within the next 24 hours. I also encourage you to engage in the discussion and share any remaining questions or concerns.

Thank you for your time and thoughtful reviews.

Best,

Your AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.