acceptodds
Under review as a conference paper at ICLR 2027

Analytic-Walk Rotary Positional Encodings for Graphs

Abstract

Rotary position encodings make attention sensitive to relative position, but extending them to graphs requires choosing how graph structure enters the rotation. Previous works assign each node a rotation from spectral coordinates, so the rotary factor between two nodes depends only on their endpoints and cannot distinguish the routes connecting them. We introduce Analytic-Walk Rotary Positional Encodings (AW-RoPE), which place the rotations on edges and sum the transported features over all walks, so contributions along different routes can reinforce or cancel. An exact variant evaluates the complete sum by a differentiable linear solve, and a sparse variant truncates it at a finite depth. We prove forward and parameter-derivative truncation bounds at fixed inputs and parameters. Both variants act on projected queries and keys, and the sparse recurrence also augments message-passing networks. Across five synthetic tasks both variants reduce nRMSE by – relative to the strongest baseline, and on real superpixel, peptide and OGB benchmarks the sparse recurrence attains the best mean on every dataset with Performer kernels and on twelve of thirteen datasets with GIN. Analysis shows that AW-RoPE can distinguish routes whose only cue is how two endpoints are connected, while node-wise rotary encodings cannot.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
graph positional encoding, rotary positional encoding, graph neural networks, graph transformer

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_2VNJOpenReview ↗
Rating
2(+1)
Confidence
4
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

In this work, the authors propose AW-RoPE, which learns a rotation angle on each edge from the features of its two endpoints. Queries and keys are then propagated along walks in the graph and are rotated at every edge they cross, and walks of all lengths are summed with decaying weights. An exact variant computes the full sum, and a cheaper sparse variant stops at a fixed walk length. The paper proves approximation bounds for the truncation. The method is evaluated on synthetic graph tasks and on standard graph benchmarks, using AW-RoPE inside a linear-attention (Performer) graph GPS and also in a message-passing GNN (GIN).

Critical strengths
  • The core idea is elegant : WIRE rotates each node's query and key by an angle from its position, AW-RoPE adds in neighbours' queries and keys, rotating each by a learned angle for every edge it travels along, so different paths between the same two nodes can give different total rotations.
  • The method acts on Q/K before the attention kernel, so it works with linear attention and also as a standalone propagation layer in GIN.
  • The empirical results show advantage of the method over the baseline WIRE.
Critical weaknesses
  • The rotations do not seem to drive the gains. Turning the edge rotations off while keeping the multi-hop mixing gives the same results (Table I.4), and rotation free version is quite strong (Fig H1).
  • It is hard to understand the significance of the results as the baseline and WIRE do not have the standard deviations. Its also unclear why on PascalVOC/COCO, AW also uses a different kernel (FAVOR+) . Moreover, the GIN numbers are far below standard results (e.g. MNIST 75.6% vs 96.5%) (see [1]).
  • The writing is extremely hard to understand and it is not clear why different tables use different kernels (for ex in H1, Favor+ was used in the ablation whereas the main paper mixes ReLU and Favor+).
  • The results seem incremental given the speed and the memory overhead.
  • The paper argues that node-based RoPE cannot tell apart different paths between two nodes, because the rotation between them depends only on the two endpoints. But WIRE's attention between two nodes decays on average with their effective resistance (Reid et al., 2026, Thm. 3), which is lower when the nodes are joined by more and shorter paths. The synthetic tasks used to show the limitation depend on node features, which no positional encoding sees, so they show the value of feature-dependent mixing rather than a gap in positional information. Finally, AW only sees paths between nodes at most L hops apart; for farther pairs it gives no path information, whereas WIRE still gives a relative position.

[1] Recipe for a General, Powerful, Scalable Graph Transformer Rampášek et al. Neurips 2022

[2] Rotary Position Encodings for Graphs Reid et al. ICML 2026


Post rebuttal : The authors ran additional evaluations to answer the above concerns so I improved the score to a 2.

Questions for authors
  • Why were the published MalNet-Tiny and Pascal VOC numbers replaced?
  • What WIRE configuration produced 0.073 in Table I.4? The numbers seem lower than what was reported by the original authors.
  • Why is accuracy used for GIN for Pattern/Cluster? And how many seeds are the results in Table 4 run?
  • The paper introduces two techniques and the ablation is only carried out for two datasets where it is showing that Mixing is quite strong so an ablation over more datasets can help us understand the significance of the method.
  • Since Sparse AW costs O(L(N+M)d), how does it scale on dense graphs, where the number of edges M grows quadratically with the number of nodes N?

Not questions per se but the paper could benefit from some presentation improvements.

  • Use standard GNN terms instead of physics ones: "propagation" for "transport", "edge angle" for "displacement" etc.
  • State the update rule (a decaying sum of neighbours' rotated queries and keys) plainly in the introduction.
  • Give the ablation variants in Table 2 descriptive names (e.g. instead of "Dynamic nonlocal Flat").
  • Please give proper numbering to figures and tables.
2 comments
AuthorsOpenReview ↗

Response to 2VNJ

Thank you for the thorough review; your comments shaped the new experiments and the revision.

Why were the MalNet-Tiny and PascalVOC-SP numbers replaced?

  • MalNet-Tiny: an indexing error in our earlier data loader let validation/test overlap with training graphs, inflating our earlier local means (99.1%). All three methods were rerun on the corrected split. Over five seeds: AW 92.300 ± 0.731%, NoPE 92.020 ± 0.342%, WIRE 92.040 ± 0.445%. This concerns our pipeline only, not WIRE's published experiments. Split audit; paired results.
  • PascalVOC-SP: the submitted AW cell used FAVOR+, while the published WIRE reference uses ReLU. To compare like with like, we ran a new matched FAVOR+ cohort with all seeds reported:
DatasetNoPEWIREAWAW − NoPE (paired)AW − WIRE (paired)
PascalVOC-SP.3446 ± .0080.3415 ± .0273.3729 ± .0092+.0283 ± .0129 (3/3)+.0314 ± .0345 (2/3)
COCO-SP.3080 ± .0033.3067 ± .0022.2915 ± .0011−.0165 ± .0032 (0/3)−.0152 ± .0030 (0/3)

The revision reports both datasets from this matched cohort, with baseline SDs. Per-seed values and protocols are in our reply to 1xPx.

What WIRE configuration produced 0.073 in Table I.4? It is a local matched run, not a published mean. The setup is four width-32, single-head dense-softmax layers with the common input/spectral scaffold, 250 epochs, lr 10−410^{-4}, batch 16, seeds 0/1/2. Test nRMSE is 0.0773692, 0.0775564 and 0.0643272, giving 0.0730843 ± 0.0075844. Backbone initialization is shared within each seed. "WIRE + mixing" applies depth-8, decay-0.8 phase-free propagation before WIRE rotation. Protocol.

Why accuracy for GIN on PATTERN/CLUSTER, and how many seeds? You are right that the benchmark uses class-balanced accuracy. We re-evaluated the saved checkpoints on the full splits with that metric:

DatasetAWNoPE
PATTERN61.977 ± 1.677%70.368 ± 8.194%
CLUSTER64.773 ± 0.041%48.541 ± 0.324%

The revision uses balanced accuracy. Table 4 uses seeds 0/1 for both methods: 12 datasets, 48 runs. Per-seed results.

GIN MNIST baseline. We agree the original baseline was too weak: width 32, and it did not use node coordinates. We built a stronger GIN: width 110, learned ε, BatchNorm, pooled heads, intensity plus coordinates, 105,434 parameters. We trained NoPE, zero angle and AW on it for 250 epochs, seeds 0/1. Test accuracy:

MethodSeed 0Seed 1Mean ± sample SD
NoPE96.75%96.66%96.705 ± 0.064%
Zero angle95.79%96.58%96.185 ± 0.559%
AW95.32%95.56%95.440 ± 0.170%

The stronger backbone reaches the ~96.5% level you cite, and AW does not add to it on MNIST. The revision replaces the MNIST row with this comparison.

Ablation over more datasets. Beyond the two submitted datasets, zero-angle and gradient-field controls are now matched on PascalVOC-SP, Peptides-func, corrected MalNet-Tiny, MolHIV, Peptides-struct and MNIST. Learned edge angles help on Peptides-struct (I.4), PascalVOC-SP against the gradient field, and MalNet-Tiny; phase-free propagation is as strong or stronger elsewhere. The paired table is in our reply to 1xPx.

Constructed tasks and WIRE. You are right that WIRE's Theorem 3 links its expected Q/K similarity to effective resistance, which encodes path multiplicity and length. Our distinction is narrower: node-wise phase differences telescope along any route, while learned edge angles need not. The constructed tasks isolate exactly this, using opposite-label pairs with identical topology but different feature arrangements. With a full attention block or a global gradient field, simpler controls also solve them. The revision presents them as a demonstration of feature-conditioned propagation under stated assumptions. WIRE v5; constructed-task protocols.

Sparse depth and distant pairs. At one layer, Sparse AW propagates along walks of length ≤ LL. Global attention then compares the propagated summaries for any pair, and stacking layers extends the reach.

Cost and dense graphs. Sparse AW costs O(L(N+M)d)O(L(N+M)d). On dense graphs, M=Θ(N2)M=\Theta(N^2), so it becomes O(LN2d)O(LN^2d): the order of dense attention, times the depth LL. Measured costs:

  • Single layer, 128 nodes, batch 8, width 64, depth 16: forward+backward takes 10.12 ms for AW vs 3.16 ms for WIRE, with peak memory 266 vs 102 MiB. Measurements.
  • Superpixel training: per-epoch time is about 3× NoPE.

The revision reports these costs next to accuracy.

Presentation. We use "propagation" and "edge angle" throughout, describe the update plainly (rotate neighboring Q/K features by learned edge angles, aggregate, sum the propagated states with decaying weights), rename "Dynamic nonlocal Flat" to "global gradient-projected edge field", and renumber all figures and tables.

Thank you for the detailed reply and re-running the evaluations. They answer my questions. I will revise my score to a 2 but I am still a little concerned by the novelty of the method over existing techniques and the results are not as competitive given the additional cost.

Reviewer_1xPxOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes AW-RoPE, which learns antisymmetric edge displacements from endpoint features and uses them to rotate features during graph propagation. A discounted sum over walks transports projected queries and keys before attention. The complete sum is evaluated by a linear solve, while a finite-depth recurrence provides a sparse implementation and can also be added to GIN. The paper establishes same-parameter forward and derivative truncation bounds, studies route-sensitive behavior on constructed tasks, and evaluates prediction and computational cost on synthetic and standard graph benchmarks.

Critical strengths

The method has a clear mathematical interpretation and a practical sparse implementation. Learning antisymmetric edge phases permits distinct routes to contribute different rotations, while sharing a scalar displacement across channel frequencies keeps the parameterization relatively simple. The exact and truncated versions are two evaluations of the same operator. The convergence analysis and trained-checkpoint diagnostics clarify this relationship; they do not imply agreement between separately trained networks. The design is coherent and works in both attention and message passing.

The mechanism experiments include phase-free propagation, local-gradient fields, a nonlocal flat field, and fitted-model phase interventions. The constructed tasks demonstrate capabilities that the specified static and pointwise-potential controls lack. The authors also report contrary evidence: a full attention block solves the first task with simpler controls, and a nonlocal flat field solves the second. These results help clarify what the mechanism does and does not require.

Critical weaknesses

The advance over existing learned transport is incremental, and its practical significance remains uncertain. Vector Diffusion Maps already sums edge transformations along paths and discusses cancellation between them [1], while Neural Sheaf Diffusion learns transport from endpoint features [2]. AW's scalar antisymmetric parameterization and use on Q/K are a specific technical contribution, but the underlying transport mechanism is largely established. Both predecessors are cited; the question is how much AW adds. The strongest matched mixing study covers two tasks: in Table I.4, Monochromatic-0 improves from 0.073 with WIRE to 0.044 with phase-free mixing and 0.043 with AW; Peptides-struct improves from 0.257 to 0.255 and 0.253. Much of the gain in this study is therefore attainable without learned phases. A separate FAVOR+ field study in H.1 finds unrestricted phases better than zero phases in only one of three Peptides runs and worse in all three MolHIV runs; this is a different setting from the ReLU Peptides study in I.4. The phase contribution appears task- and setting-dependent. The constructed tasks support feature-conditioned phase transport: learned flat fields succeed, and removing phases from fitted models reduces accuracy. The practical advantage on the benchmark tasks is less convincing.

The headline benchmark comparisons are not consistently controlled. Tables 1 and 4 largely compare local AW runs against published reference means, although some local matched comparisons are provided. In COCO-SP, AW uses FAVOR+ while its local NoPE and WIRE controls use ReLU, so this row cannot isolate the effect of AW. The paper has substantial experimental coverage, including useful ablations, but the matched studies support only a subset of the broad benchmark claims. I'm not convinced that the highest reported means establish a reliable advantage attributable to AW. The conclusions should distinguish results obtained with matched kernels, training settings, and propagation controls from comparisons with external references.

[1] Singer and Wu. Vector Diffusion Maps and the Connection Laplacian.

[2] Bodnar et al. Neural Sheaf Diffusion: A Topological Perspective on Heterophily and Oversmoothing in GNNs.

Questions for authors

Which existing matched results best show a useful benefit from learned connection phases over phase-free transport? Paired per-run differences and the kernel/training protocol for each field comparison would help, including PascalVOC-SP in H.1. I'd focus on the existing results; a larger benchmark suite or a demonstration that nonzero circulation is always necessary is not needed.

Are same-kernel NoPE/WIRE results available for COCO-SP, and which dataset or runs account for the discrepancy between Table 4 and the thirteen-dataset/52-run statement?

1 comment
AuthorsOpenReview ↗

Response to 1xPx

Thank you for the detailed review. We agree with your distinction between a modeling capability and a reliable benchmark advantage, and the revision reports them separately.

Which matched results best show a benefit from learned edge angles? The clearest cases:

  • New PascalVOC-SP cohort (FAVOR+, shared initialization): AW beats NoPE on 3/3 paired seeds (+.0283 ± .0129 Macro-F1) and WIRE on 2/3 (+.0314 ± .0345); table below.
  • I.4 Peptides-struct vs zero angle: AW wins 3/3, mean MAE improvement 0.002750.
  • PascalVOC-SP vs the local-gradient field: AW wins 3/3 (+.003400 ± .001089).
  • Corrected MalNet-Tiny: +.004000 vs zero, +.005333 vs gradient, 2/3 seeds each.

On MolHIV, Peptides-func and the new Peptides-struct study, phase-free controls perform as well or better, so the revision presents the benefit as dataset-dependent.

All paired differences follow: control minus AW for nRMSE/MAE, AW minus control for accuracy/AP/AUROC/F1; seeds 0/1/2 (0–4 for Peptides-func); "±" is the sample SD of paired differences.

Cohort, dataset, kernelControlPer-seed improvementMean ± SD
I.4, Peptides-struct, ReLUZero+.001540, +.006190, +.000520+.002750 ± .003022
H.1, Peptides-struct, FAVOR+Gradient+.000900, +.001190, +.003900+.001997 ± .001655
H.1, Peptides-struct, FAVOR+Zero+.002260, −.001240, −.000160+.000287 ± .001792
Pascal field, FAVOR+Gradient+.003090, +.004610, +.002500+.003400 ± .001089
Pascal field, FAVOR+Zero+.007050, −.023460, +.021220+.001603 ± .022833
Corrected MalNet, ReLUGradient+.002000, +.016000, −.002000+.005333 ± .009452
Corrected MalNet, ReLUZero+.011000, +.005000, −.004000+.004000 ± .007550
H.1, Monochromatic-0, denseZero+.002392, +.000550, +.002017+.001653 ± .000973
I.4, Monochromatic-0, denseZero−.000294, +.001366, +.000757+.000610 ± .000839
H.1, Monochromatic-0, denseGradient−.001076, +.000080, −.008597−.003198 ± .004712
Peptides-func field, ReLUZero−.023010, −.000050, +.002950, −.000650, +.002400−.003672 ± .010919
Peptides-func field, ReLUGradient−.030120, +.002120, −.021570, +.000270, +.008670−.008126 ± .016749
I.4, MolHIV, ReLUZero−.007360, −.020490, −.005320−.011057 ± .008233
H.1, MolHIV, FAVOR+Zero−.019920, −.006560, −.023080−.016520 ± .008769
H.1, MolHIV, FAVOR+Gradient−.020680, −.007130, −.006110−.011307 ± .008134

On I.4 MolHIV, mean AUROC is AW 0.75921, WIRE 0.77006, zero 0.77026 and WIRE + mixing 0.77347. All twelve runs will appear in the revised table. Complete audit; paired-field figure.

Protocols (epochs/lr/batch). H.1 and I.4: Monochromatic 250/10−410^{-4}/16; Peptides-struct 200/3×10−43\times10^{-4}/128; MolHIV 100/10−410^{-4}/32, all at depth 8, decay 0.8; H.1 uses FAVOR+, I.4 generalized ReLU. Pascal: FAVOR+, 300/5×10−45\times10^{-4}/32, depth 8, decay 0.8. Peptides-func: ReLU, 150/5.25×10−45.25\times10^{-4}/128, depth 4, decay 0.55. MalNet: ReLU, 150/2×10−42\times10^{-4}/16.

Same-kernel COCO-SP and PascalVOC-SP. NoPE, WIRE and AW, all FAVOR+, both datasets, seeds 0/1/2. COCO: 200 epochs, lr 10−310^{-3}; Pascal: 300 epochs, lr 5×10−45\times10^{-4}; batch 32; AW depth 8, decay 0.8. Per seed, backbone initialization, input graphs and random projections are shared across methods; the highest-validation-Macro-F1 checkpoint is used. Test Macro-F1:

DatasetMethodSeed 0Seed 1Seed 2Mean ± sample SD
PascalVOC-SPNoPE.352896.344031.336944.344624 ± .007993
PascalVOC-SPWIRE.372237.320137.332017.341464 ± .027304
PascalVOC-SPAW.367091.383498.368106.372898 ± .009194
COCO-SPNoPE.311775.306300.306002.308025 ± .003250
COCO-SPWIRE.308583.304214.307197.306665 ± .002232
COCO-SPAW.291708.292551.290280.291513 ± .001148

On PascalVOC-SP, AW improves on NoPE by +.014195/+.039467/+.031162 and on WIRE by −.005146/+.063361/+.036089. On COCO-SP it does not improve over the controls: −.016512 ± .003233 vs NoPE and −.015152 ± .003021 vs WIRE. The revised table reports both datasets under this matched kernel. The final 9–22 epochs of the three COCO AW runs were resumed on H200 from H100 checkpoints, and all selected checkpoints come from the H100 epochs. Complete formal export.

Table count. The audited GIN cohort has 12 datasets × 2 methods × 2 seeds = 48 runs. The earlier 13/52 inventory had included ModelNet40 and ShapeNet and omitted COCO: 52 − 8 + 4 = 48. The revision states this explicitly. GIN ledger.

Novelty and interpretation. We accept the VDM/NSD lineage and position the contribution as the specific rotary Q/K construction with exact and sparse realizations. The constructed tasks demonstrate a capability under their stated assumptions, not that nonzero circulation is always required.

Reviewer_xMu3OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Rotary encodings typically assign each node a phase. Differences telescope along a walk, so the accumulated phase depends only on the walk’s endpoints. This limits how well routes can be distinguished, and therefore what global structure is captured. The paper proposes instead to encode learned rotations at the edge level, allowing contributions from different walks to reinforce or cancel.

Critical strengths
  • The scope of the experiments is relatively broad, covering different synthetic tasks, graph benchmarks, and message-passing backbones.
  • The theoretical analysis gives approximation and expressivity guarantees.
Critical weaknesses
  • Experiments that compare against existing positional encodings are limited. The current experiments consider WIRE and NoPE. WIRE results are often cited from published references, and only some comparisons are rerun locally. Consider expanding the comparisons to strengthen the empirical results.
  • The theoretical results have somewhat modest mathematical novelty. In particular, the approximation result uses standard tools.
Questions for authors

Can the authors give a heuristic for choosing the truncation depth from the learned decay and an error target?

2 comments
AuthorsOpenReview ↗

Response to xMu3

Thank you for the review and for the concrete question on depth selection, which we answer with a ready-to-use rule below.

Baseline coverage. We agree that published reference means cannot replace matched controls. All new studies therefore train every control locally under the same protocol, seeds and initialization. The controls are NoPE, WIRE, zero-angle propagation and NoPE with LapPE, RWSE or SignNet input encodings. The datasets are Peptides-struct, PascalVOC-SP, COCO-SP and MNIST (GIN). The full Peptides-struct study follows. Superpixel and GIN tables are in our replies to 1xPx and 2VNJ.

The Peptides-struct study comprises 18 trials: six methods, seeds 0/1/2, 200 epochs each. All use generalized-ReLU attention and four layers of width 96 with four heads, AdamW lr 0.0003 and batch 128. Each seed shares backbone initialization across methods, and the checkpoint with the lowest validation MAE is used. AW and zero-angle propagation use depth 8 and decay 0.8. NoPE adds no Q/K operation and keeps the listed input encoding. Test MAE (lower is better):

MethodSeed 0Seed 1Seed 2Mean ± sample SD
NoPE + RWSE0.2621200.2635040.2656910.263772 ± 0.001801
NoPE + SignNet0.2593160.2583930.2593860.259031 ± 0.000554
WIRE + LapPE0.2544560.2573850.2566830.256175 ± 0.001529
NoPE + LapPE0.2539170.2572780.2546530.255283 ± 0.001767
AW + LapPE0.2562610.2566630.2536390.255521 ± 0.001642
Zero angle + LapPE0.2571220.2537490.2517160.254196 ± 0.002730

AW improves on RWSE and SignNet on every seed (mean −0.008251 and −0.003511 MAE). It is within 0.0013 of the best mean, achieved by zero-angle propagation. Here most of the benefit comes from the propagation itself, and we describe it this way in the revision. All paired contrasts and parameter counts.

On corrected MalNet-Tiny, AW is also comparable to magnetic Q/K adapters: within 0.001 and 0.004 accuracy of fixed- and learnable-charge MagNet on common seeds. Complete paired table.

Novelty. We agree that composing edge transformations along paths (Vector Diffusion Maps) and learning endpoint-conditioned maps (Neural Sheaf Diffusion) are established ideas, and we will cite them prominently. Our contribution is a specific rotary construction built from these ingredients:

  • a shared antisymmetric edge-angle field acting on frequency-paired Q/K channels;
  • inserted before attention, so it remains compatible with linear attention and message passing;
  • exact and truncated evaluations of the same discounted operator, with explicit truncation bounds.

VDM; NSD.

Choosing depth from decay and tolerance. Let B=zTB=zT with ∥B∥∞≤r<1\|B\|_\infty\le r<1, using the maximum complex modulus over node/channel pairs. Let YL=∑k=0LBkXY_L=\sum_{k=0}^{L}B^kX. The input-relative error ∥Y∞−YL∥∞≤ϵ∥X∥∞\|Y_\infty-Y_L\|_\infty\le\epsilon\|X\|_\infty is guaranteed by

Lsafe=max⁡{0,⌈log⁡[ϵ(1−r)]log⁡r⌉−1}.L_{\rm safe}=\max\left\{0,\left\lceil\frac{\log[\epsilon(1-r)]}{\log r}\right\rceil-1\right\}.

With row-normalized unit-modulus phases, r=zr=z. Throughout training, use the declared upper bound on decay. For ϵ=10−3\epsilon=10^{-3} and decays 0.5/0.8/0.9/0.95/0.99, this gives L=L= 10/38/87/193/1145.

A CPU calibration compares the production recurrence against an independent complex128 solve. All 30 prescribed cases meet the requested tolerance at these depths. The zero-field constant-input case attains the bound, so the rule is tight.

An adaptive alternative stops on the residual R=X−(I−B)YR=X-(I-B)Y, using

∥Y∞−Y∥∞≤∥R∥∞/(1−r).\|Y_\infty-Y\|_\infty\le\|R\|_\infty/(1-r).

It also meets the tolerance in all 30 cases and can stop earlier on easy inputs.

The parameter-derivative bound gives the analogous rule for gradients, which needs a larger LL for the same ϵ\epsilon. Our training default L=8L=8 is chosen by validation as an accuracy–cost trade-off rather than as a 10−310^{-3} certificate. The revision will state both readings.

Thanks to the authors for the detailed response and for running additional experiments. My concerns regarding novelty at the level expected for an ICLR paper remain. Therefore, I will keep my score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank all three reviewers for careful and constructive reviews. They raised three shared points: controlled baselines, attribution of the gains to learned edge angles, and clarity. In response, we ran 42 new trials and are revising the paper as follows.

New controlled experiments. Every control is trained locally with the same kernel, protocol, seeds and per-seed backbone initialization as AW. Every seed is reported.

  • PascalVOC-SP and COCO-SP, FAVOR+, NoPE/WIRE/AW, three seeds each. AW gives the best PascalVOC-SP result: 0.3729 vs 0.3446 (NoPE) and 0.3415 (WIRE). It improves on NoPE in all three paired seeds. On COCO-SP it does not improve over NoPE/WIRE (0.2915 vs 0.3080/0.3067).
  • Peptides-struct, six methods including NoPE with LapPE, RWSE or SignNet, WIRE and zero-angle propagation. AW is within 0.0013 MAE of the best method. It clearly improves on RWSE (−0.0083) and SignNet (−0.0035).
  • MNIST with a stronger GIN backbone that reaches the 96.5% level reported in the literature. AW does not improve over this backbone.

Calibrated claims. The revision states gains per dataset rather than as a uniform ranking. It reports propagation and learned edge angles as separate contributions. It replaces the "best on every dataset" summary with these controlled results.

Reporting. Every cell now reports all completed runs as mean ± SD, with published reference values explicitly labeled. Several submitted cells summarized a subset of completed runs. The revision uses every run instead: for example, PascalVOC-SP over all six seeds is 0.3769 ± 0.0147, compared with the submitted 0.3848 ± 0.0040. We also correct the GIN inventory to 12 datasets and 48 runs. MalNet-Tiny is now reported on the corrected split over five seeds. PATTERN/CLUSTER are reported with the benchmark's class-balanced accuracy.

Presentation. We will use standard GNN terminology and explain the update plainly in the introduction. We will give a depth-selection rule and repair all figure/table numbering.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.