acceptodds
Under review as a conference paper at ICLR 2027

DG-FDE: Dynamic Graph Representation Learning via Graph Neural Fractional Differential Equations

Abstract

Dynamic graph representation learning learns node embeddings from evolving graphs for node property and temporal link prediction. A core challenge is that node states depend on multi-scale historical interactions, not only instantaneous graph structures. Existing continuous-time dynamic graph models rely on integer-order dynamical systems, which cannot explicitly encode long-range nonlocal history within a unified dynamics. Inspired by the nonlocal memory of fractional calculus, we propose DG-FDE, a continuous-time model that casts node representation evolution as a Caputo fractional differential equation. Its equivalent Volterra integral form uses a GNN to model time-dependent graph responses and a fractional memory kernel to aggregate historical signals. This unifies graph propagation and multi-scale temporal memory in one evolution equation. We prove finite-horizon well-posedness and derive an explicit characterization of how historical graph snapshots shape node representations. Experiments show DG-FDE outperforms its integer-order variant and strong dynamic graph baselines on standard tasks.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Dynamic graph representation learning, Neural fractional differential equations, Volterra integral equations

Reviews

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

The paper proposes DG-FDE, a continuous-time dynamic graph model in which node embeddings follow a Caputo fractional ODE with piecewise-constant adjacency matrices along the observation path.

Critical strengths
  1. Incorporating piecewise-constant graph paths as a measurable forcing term in a Volterra equation with well-posedness result.

  2. The decomposition approach is interpreable with explicit weights depending on snapshot duration and lag.

Critical weaknesses
  1. Well-posedness analysis for Caputo fractional graph dynamics with evolving topologies is a consequence of well-known results on Volterra equations and not cannot be considered to be novel.
Questions for authors
  1. Why is there a significant difference in the numerical results for GNODE and DG-FDE with α=1\alpha=1? What is the difference in implementation? Please run GNODE with the same fixed-step solver, step size and vector field.

  2. SDE based models are not considered as baselines. Why?

  3. Please add FROND, NvoFDE or FADE (static fractional graph models) and at least one strong CTDG baseline (DyGFormer/TGN family), and consider event-based benchmarks.

  4. How are observation times scaled, and how sensitive are results to rescaling of time?

  5. The datasets used for node property prediction are quite small. The test set has around 3 windows only. Larger datasets should be used to verify the performance and statistical significance.

  6. Please provide statistical significance tests for your results.

3 comments
AuthorsOpenReview ↗

Response to Reviewer rCr5 (1/2)

Thank you for reading our paper carefully and sharing your feedback. Your comments helped us improve the manuscript. We respond to each point below and explain what we changed. We’re happy to clarify anything that remains unclear.


W1. Well-posedness analysis for Caputo fractional graph dynamics with evolving topologies is a consequence of well-known results on Volterra equations and not cannot be considered to be novel.

A1. Thank you for pointing this out. We agree that the proof uses standard Volterra theory [1]. To our knowledge, prior work on dynamic graph representation learning has yet to study the well-posedness of differential equations driven by piecewise-constant graph snapshots.

The autoregressive Graph Neural ODE in [2] updates node states at observation times, which can cause jumps in the states. GN-CDE can use cubic splines to connect graph snapshots, which adds preprocessing cost [3]. In DG-FDE, we simply use the observed graph on each interval until the next snapshot arrives.

To our knowledge, prior work on dynamic graph representation learning has not analyzed well-posedness for this specific Caputo model with piecewise-constant graph inputs. Section 4.2 (p. 5) gives sufficient conditions that allow the vector field to jump when the graph changes. Theorem 1 shows that under these conditions, the model still has a unique continuous mild solution over the entire time window.

References

  • [1] Linz, P. (1985). Analytical and Numerical Methods for Volterra Equations. SIAM. Book
  • [2] Poli, M., et al. (2019). Graph Neural Ordinary Differential Equations. arXiv:1911.07532. Section 3.2
  • [3] Qin, T., Walker, B., Lyons, T., Yan, H., and Li, H. (2026). Learning Dynamic Graph Embeddings With Neural Controlled Differential Equations. IEEE Transactions on Pattern Analysis and Machine Intelligence, 48(2), 2096–2103. Paper

Q1. Why is there a significant difference in the numerical results for GNODE and DG-FDE with α=1\alpha=1? What is the difference in implementation? Please run GNODE with the same fixed-step solver, step size and vector field.

A2. The two rows in Table 2 use different setups. GNODE uses the adaptive dopri5 solver, while DG-FDE uses fixed-step ABM. The graph vector fields also differ. Both differences can affect the final embeddings and link prediction scores.

We set α=1\alpha=1 in DG-FDE and used the same solver, vector field, and experimental setup as GNODE. As shown in Table R1, the two models gave identical results.

Table R1. GNODE and DG-FDE at α=1\alpha=1 on Enron, Contact, and RDS.

SettingEnronContactRDS
GNODE, original setup (dopri5)13.38 ± 0.6521.23 ± 0.2920.33 ± 0.34
Matched DG-FDE (α=1\alpha=1)13.38 ± 0.6521.23 ± 0.2920.33 ± 0.34
DG-FDE (α=1\alpha=1), original setup (fixed-step ABM)12.46 ± 1.0829.02 ± 0.5720.30 ± 0.03

Q2. SDE based models are not considered as baselines. Why?

A3. SDE-based baseline. Thank you for pointing this out. We overlooked SDE-based models in our original comparison. Following your suggestion, we added LNJSDE [1], a recent neural jump SDE model, to our real-world experiments on dynamic node property prediction and temporal link prediction.

As shown in Table R2, our fractional differential equation model, DG-FDE, outperformed the SDE-based LNJSDE on all nine datasets in this comparison. We revised the paper and added the results to Sections 5.2 and 5.3 (pp. 8–10, Tables 1 and 2).

Table R2. LNJSDE vs. DG-FDE on real-world datasets.

DatasetTest metricLNJSDEDG-FDE
England-CovidMSE ↓0.731 ± 0.1830.669 ± 0.108
Twitter-TennisMSE ↓0.295 ± 0.0170.196 ± 0.004
EnronMRR@100 (%) ↑13 ± 0.1019.20 ± 0.73
ContactMRR@100 (%) ↑17 ± 0.3732.38 ± 0.51
RDSMRR@100 (%) ↑18 ± 0.5821.60 ± 0.15
UCIMRR@100 (%) ↑34 ± 1.8335.65 ± 0.36
Reddit BodyMRR@100 (%) ↑36 ± 0.3642.29 ± 0.44
Reddit TitleMRR@100 (%) ↑51 ± 0.6356.42 ± 0.04
AS733MRR@100 (%) ↑47 ± 1.0973.24 ± 1.26

Reference

  • [1] Wang, Y., Hou, D., Gao, C., and Li, X. (2025). Learning Neural Jump Stochastic Differential Equations with Latent Graph for Multivariate Temporal Point Processes. IJCAI, 3444–3452. Paper
AuthorsOpenReview ↗

Response to Reviewer rCr5 (2/2)

Q3. Please add FROND, NvoFDE or FADE (static fractional graph models) and at least one strong CTDG baseline (DyGFormer/TGN family), and consider event-based benchmarks.

A4. Thank you for suggesting these baselines. Our original experiments focused on snapshot-based methods because DG-FDE takes a sequence of graph snapshots as input. These comparisons included Hawkes-GCN and Hawkes-GAT, two strong baselines for next-snapshot link prediction (Section 5.3, pp. 9–10). Hawkes-GNN

Following your suggestion, we added DyGFormer, TGN, TGAT, and CTAN to the long-range link prediction task from T-GRAB [1]. We chose this task because it tests whether models can use information from several snapshots ago and several hops away to predict current links. CTDG models such as DyGFormer are good at capturing long-range temporal dependencies. We compared DG-FDE with both CTDG and DTDG baselines on T-GRAB [1], a recent synthetic benchmark that tests whether models can use information from far back in time and many hops away in the graph. We added this comparison to Section 5.1 (pp. 8–9). Figure 3 (p. 9) shows the results, and Table 5 (p. 22) reports the full scores.

The static-graph versions of FROND, NvoFDE, and FADE that you suggested work with a fixed graph topology. They are used for tasks such as node and graph classification, where oversmoothing is a common concern. Using them for our dynamic link prediction task would require us to make a design choice. We could use their continuous depth to represent time, or we could merge the past snapshots into a single graph, as we do for GCN, GAT, and GraphSAGE in Appendix E.2 (pp. 26–27). These two choices would test different things, making a direct comparison with DG-FDE hard to interpret. We discuss this line of work in the Introduction and Related Work.

Reference

  • [1] Dizaji, A., et al. (2026). T-GRAB: A Synthetic Diagnostic Benchmark for Learning on Temporal Graphs. KDD, 2628–2639. Paper

Q4. How are observation times scaled, and how sensitive are results to rescaling of time?

A5. Thank you for pointing out this important issue. In our temporal link prediction experiments, each dataset uses its own interval to build graph snapshots. These intervals range from one hour for Contact to 30 days for Enron. Inside the model, one snapshot interval is one time unit. We assign the snapshots in each input window the times 0,1,2,…0, 1, 2, \ldots, and the solver uses this grid directly. Changing the units of the raw timestamps has no effect on DG-FDE as long as the snapshots stay the same. DG-FDE performed well across datasets with these different snapshot intervals (Section 5.3, Table 2, p. 10). If we convert the raw timestamps from seconds to minutes and convert the snapshot intervals accordingly, we get the same snapshots. The solver receives the same inputs and gives the same result.

Q5. The datasets used for node property prediction are quite small. The test set has around 3 windows only. Larger datasets should be used to verify the performance and statistical significance.

Q6. Please provide statistical significance tests for your results.

A6. Thank you for raising these points. For node property prediction, we used England-Covid and Twitter-Tennis because they were the only datasets we found in the PyTorch Geometric Temporal benchmark where both node features and graph structure change over time (Appendix D.2, pp. 22–23). To test DG-FDE on longer sequences, we added the synthetic T-GRAB experiment, with 4,001 to 4,032 snapshots per setting (Section 5.1 and Table 4, p. 21). Our real-world link prediction experiments also include larger graphs, such as Reddit Title with over 54,000 nodes and AS733 with over one million temporal edges. Some controlled differential equation baselines, including STG-NCDE and PENG-CDE, ran out of GPU memory on some of these datasets (Tables 2 and 7, pp. 10 and 24). We plan to test on larger node property prediction datasets and make the solver more efficient so we can evaluate how well DG-FDE generalizes at that scale.

We also added a permutation-based Friedman test for temporal link prediction. Across seven datasets and 18 methods with results on all seven, the test found an overall difference among methods (p<0.001p<0.001). DG-FDE with fixed and learned fractional orders had the two best average ranks, at 1.71 and 2.00, respectively. For node property prediction, we report average ranks across the two datasets. We revised the paper and added the statistical analysis to Appendix G (pp. 30–31, Figures 8 and 9).

I thank the authors for the detailed clarification and rebuttal. I have no further questions.

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

The paper proposes DG-FDE which is a continuous-time model for learning node representations on snapshot-based dynamic graphs. It replaces the integer-order derivative used in graph neural ODE/CDE models with a Caputo fractional derivative of order α ∈ (0,1). The dynamics are driven by a GCN vector field evaluated on a piecewise-constant adjacency path, with no interpolation between snapshots. Because topology changes create jumps, the model is defined through its equivalent Volterra integral form. On the theory side, the authors show finite-horizon existence and uniqueness of the mild solution using a Banach fixed-point argument with a weighted norm.The model is solved with a fractional Adams–Bashforth–Moulton predictor–corrector, with α either fixed via validation or learned. Experiments cover node regression (England-Covid, Twitter-Tennis) and next-snapshot link prediction on seven datasets, and report gains over the α = 1 variant, graph ODE/CDE baselines and discrete dynamic GNNs, along with lower runtime than the ODE/CDE baselines.

Critical strengths
  1. The paper studies an important area of continuous time modelling for dynamic graphs
  2. The theoretical formulation seems sound and the choice of the Volterra form to handle jumps in a piecewise constant graph seems to be the right mathematical framework
  3. The authors provide broad experimental evaluations of their method showing competitive results
Critical weaknesses

W1. Limited novelty relative to existing fractional graph models:

The core model, a Caputo FDE with a GNN vector field solved by a fractional Adams–Bashforth–Moulton predictor–corrector, is essentially FROND (Kang et al., ICLR 2024) with a piecewise-constant adjacency path. The paper describes FADE (Kang et al., NeurIPS 2025) as "attention kernels" on fixed graphs. However, FADE already (a) establishes (local) existence and uniqueness for a more general fractional neural integral equation via Banach fixed-point arguments, and (b) is evaluated on spatio-temporal traffic forecasting (STG-FADE, built on STG-NCDE), i.e., fractional dynamics on graph signals over time. The claim of "the first rigorous well-posedness analysis for Caputo fractional graph dynamics with evolving topologies" is therefore overstated. Extending this to a global finite horizon with a measurable, piecewise-constant input follows from standard Carathéodory/Volterra theory.

Relevant works that should be discussed:

  • Kang et al. (AAAI 2024): robustness of graph neural FDEs, including to perturbations of graph topology.
  • FTL-GCN (Electronics, 2026): Caputo/Grünwald–Letnikov memory on temporal knowledge graphs.
  • Neural Integral Equations (Zappala et al., Nature MI 2024).
  • DRAGON which already explore distributed and variable fractional orders, the direction listed as future work.

W2. The analysed model and the implemented model differ:

Under Definition 1, A(t_N) affects only a single point in time, which cannot change the integral. So Z(t_N) is independent of the most recent snapshot, as Proposition 3's sum over t_k < t confirms. For next-snapshot prediction, the latest graph is usually the most informative input. The solver, however, evaluates F_K = f(Z_K, A(τ_K)) at τ_K = t_N, which always uses A_{t_N}. When grid points coincide with snapshot times, the product-trapezoidal corrector also assigns part of each interval's weight (exactly half when α = 1) to the next snapshot's graph. The step size for the main experiments is not reported. At h = 1, the final step carries about 74% of the total corrector weight for Contact (α = 0.1) and 63% for England-Covid (α = 0.2); it is still 64% and 48% at h = 1/4. This term has zero weight in the model covered by the theorems. As α → 0, the corrector reduces to Z_K ≈ Z₀ + f(Z_Kᴾ, A_{t_N}). The theory therefore does not describe the trained model. There is also no convergence analysis. The trapezoidal scheme assumes a smooth integrand, while f jumps at every snapshot and the solution behaves like (t − t_k)^α after each jump.

W3. The "long-range memory" interpretation conflicts with the paper's own analysis:

From Proposition 3, α = 1 gives w_k = Δ_k: every past interval is weighted equally, with no decay. α < 1 gives weights that decay with lag. α → 0 is close to memoryless. In this integral form, a smaller α therefore means a stronger recency bias. The selected orders are small on most datasets (α ≤ 0.5 on 8 of 9; α = 0.1–0.3 on Contact, England-Covid, Enron and Twitter-Tennis), which suggests the gains come from emphasising recent snapshots. Together with W2, the improvement may largely be a "last-snapshot" effect. The claimed mechanism is not established.

I would suggest the following ablations to test this:

  • Z₀ plus a GCN on the last snapshot;
  • an exponential-kernel (Hawkes-like) variant;
  • a solver consistent with Definition 1.

W4. The continuous-time formulation adds little beyond a discrete architecture:

Eq. 5 is an implicit equation only because f takes Z as input. The predictor–corrector unrolls into an explicit recurrence: at each step, a GCN is applied to a fixed, α-determined weighted sum of all cached past GCN outputs. That is a recurrent GNN with dense skip connections whose weights follow a power law. The step-size ablation on England-Covid (Fig. 1b) shows no gain from finer discretisation. This suggests the benefit comes from this discrete architecture, not from accurately solving a continuous equation, and the well-posedness results do not bear on it. Requested ablations: (i) The non-recurrent version Z = Z₀ + Σ_k w_k^α · GCN(A_k, X_k), analogous to GCN (Mean) but with fractional instead of uniform weights. (ii) The same dense recurrence with learned weights.

W5. The stability result is vacuous in practice and covers the wrong perturbation:

The constant C = E_α(L(T − t₀)^α) grows roughly like exp((L(T − t₀)^α)^{1/α}). For illustrative values α = 0.1, L = 2 and T − t₀ = 8, it is on the order of 10^3500. L* is not controlled during training (there is no constraint on the weight norms). Calling Proposition 1 a "rigorous robustness guarantee" is an overclaim. The relevant question for evolving graphs is stability with respect to the graph path (and α or θ), not the initial embedding.

W6. The theoretical "memory characterization" is overstated:

Proposition 2 (the restart identity) is an algebraic identity that holds for any Volterra equation. Proposition 3 separates timing weights, rather than graph attribution: F_k = f(Z(s), A_{t_k}) depends on Z, which itself depends on all earlier snapshots. The decomposition is exact only if the field is constant within each interval, which the authors note a piecewise-constant graph does not imply. "Explicit characterization of how historical graph snapshots shape node representations" overstates what is a quadrature identity.

W7. Experimental concerns:

Different node-regression protocol. Twitter-Tennis baseline numbers are 1.5–2× lower than those published by Berndt et al. (NeurIPS 2025) for the same models. The paper does not explain this discrepancy or compare its protocol (1,000 nodes, log target, non-overlapping windows) with theirs, and the baseline rankings change (e.g., DCRNN moves from fourth of seven to the best baseline). Many reported results are within one standard deviation of the baselines (UCI, Body, England-Covid), and the authors should provide statistical significance tests for these. The integer-order variant (α = 1) already beats every baseline on Contact. On this dataset, much of the advantage seems to come from the architecture and training setup rather than from fractional dynamics.

References

[1] Q. Kang, K. Zhao, Q. Ding, F. Ji, X. Li, W. Liang, Y. Song, and W. P. Tay. Unleashing the potential of fractional calculus in graph neural networks with FROND. In International Conference on Learning Representations (ICLR), 2024. arXiv:2404.17099.

[2] Q. Kang, W. Cui, X. Li, Y. Ma, X. Fu, W. P. Tay, Y. Li, and Z.-J. Zha. Neural fractional attention differential equations. In Advances in Neural Information Processing Systems (NeurIPS), vol. 38, 2025.

[3] Q. Kang, K. Zhao, Y. Song, Y. Xie, Y. Zhao, S. Wang, R. She, and W. P. Tay. Coupling graph neural networks with fractional order continuous dynamics: A robustness study. In Proceedings of the AAAI Conference on Artificial Intelligence, 2024. arXiv:2401.04331.

[4] X. Chen, N. Puteh, and M. N. Husen. Fractional–temporal Lorentz graph networks: Integrating physical memory into dynamic knowledge reasoning. Electronics, 15(9):1919, 2026. doi:10.3390/electronics15091919.

[5] E. Zappala, A. H. de Oliveira Fonseca, J. Ortega Caro, A. H. Moberly, M. J. Higley, J. Cardin, and D. van Dijk. Learning integral operators via neural integral equations. Nature Machine Intelligence, 2024. doi:10.1038/s42256-024-00886-8. arXiv:2209.15190.

[6] K. Zhao, X. Li, Q. Kang, F. Ji, Q. Ding, Y. Zhao, W. Liang, and W. P. Tay. Distributed-order fractional graph operating network. In Advances in Neural Information Processing Systems (NeurIPS), vol. 37, 2024. doi:10.52202/079017-3286.

[7] W. Cui, Q. Kang, X. Li, K. Zhao, W. P. Tay, W. Deng, and Y. Li. Neural variable-order fractional differential equation networks. In Proceedings of the AAAI Conference on Artificial Intelligence, 39(15):16109–16117, 2025. arXiv:2503.16207.

[8] T. Berndt, B. Walker, T. Qin, J. Stühmer, and A. Kormilitzin. Permutation equivariant neural controlled differential equations for dynamic graph representation learning. In Advances in Neural Information Processing Systems (NeurIPS), vol. 38, 2025. arXiv:2506.20324.

Questions for authors

Please see the weakness section above

3 comments
AuthorsOpenReview ↗

Response to Reviewer gx5m (1/2)

We appreciate your careful reading of our paper and the questions you raised. Your feedback helped us clarify several points in the manuscript, and we explain the changes in our responses below. We would be grateful if you could let us know whether our responses have adequately addressed your concerns.


W1. Limited novelty relative to existing fractional graph models

A1(W1). Thank you for pointing out the connection to FROND and FADE. FADE uses fixed graph topologies in its graph learning setup, and its theorem establishes local existence and uniqueness for its fractional integral equation. We establish well-posedness in the more complex setting where the observed edges can change at every snapshot. Theorem 1 shows that, under the stated assumptions, DG-FDE has a unique, continuous mild solution over the entire observation window, even when changes in the graph cause the vector field to jump (Section 4.2, p. 5). To our knowledge, DG-FDE is also the first to characterize how past changes in the graph structure affect current node embeddings in this setting (Section 4.3, Proposition 2, p. 6). Thank you also for highlighting these related studies. We discuss them in the Related Work section of the original submission (Section 2).

W2. The analysed model and the implemented model differ

A2(W2). We appreciate your question about how the solver weights the endpoint. In the continuous integral in Definition 1, a single time point has measure zero, so changing A(tN)A(t_N) does not affect the integral. In practice, the ABM solver uses a finite step size hh, and its corrector assigns a positive weight to the endpoint evaluation when approximating the last interval. For a fixed grid, α\alpha controls the relative weights of historical intervals through the fractional kernel. As your ratios illustrate, smaller α\alpha increases the endpoint's relative weight at finite step sizes. We have added the solver step-size settings to the appendix.

Theorem 1 establishes the existence and uniqueness of a continuous embedding trajectory, even under abrupt graph changes. Section 4.4 (p. 7) presents the finite-step ABM update, including the endpoint term, while Algorithms 1 and 2 in Appendix B (pp. 19–20) detail the solution and training procedures.

Regarding convergence as h→0h\to 0, Appendices F.2 and F.3 (pp. 28–30) report numerical errors against fine-grid references for the SIR model and real-world dynamic graphs. Figure 4(b) (p. 9) further examines the effects of step size on prediction performance and computational cost on England-Covid. These results characterize the solver's behavior at the tested step sizes.

W3. The "long-range memory" interpretation conflicts with the paper's own analysis:

A3(W3). Temporal dependencies in real-world data vary by task: some predictions rely mainly on recent snapshots, while others require longer histories. DG-FDE allows α\alpha to be selected or learned for each downstream task, adapting the relative weights assigned to different time scales.

On a fixed grid, smaller α\alpha assigns greater relative kernel weight to recent intervals. However, each snapshot's contribution to node embeddings also depends on the vector field response determined by its graph structure and node states. Thus, a small α\alpha does not necessarily imply that performance gains come mainly from the last snapshot. We have revised the paper and added an illustrative example in Figure 2 (p. 7) to show how α\alpha affects the memory kernel's weighting of historical responses. We hope this clarifies your concern.

AuthorsOpenReview ↗

Response to Reviewer gx5m (2/2)

W4. The continuous-time formulation adds little beyond a discrete architecture.

A4 (W4). The explicit recurrence you describe is what we get when we solve the continuous equation numerically with ABM on a finite grid. The continuous model specifies how the recurrence uses past information and gives us a way to study well-posedness and stability under perturbations to the initial embeddings. During training, we use the resulting discrete updates to approximate the continuous dynamics.

W5. The stability result is vacuous in practice and covers the wrong perturbation.

A5 (W5). Your example shows that the worst-case bound can be large. The size of this bound alone tells us little about how stable training is in practice. Proposition 1 addresses how changes in the initial embeddings affect later representations for a given sequence of evolving graphs. In our experiments, training ran stably across random seeds, including in settings with small α\alpha. We report the mean and standard deviation across runs in the results tables.

W6. The theoretical "memory characterization" is overstated.

A6 (W6). You’re right that the vector field can still change as the node states evolve, even when the graph stays fixed within a snapshot interval. In Proposition 3, we approximate the vector field response by a constant on each interval. This lets us write down the weight the memory kernel assigns to each past interval and see how it enters the current node representations. We state this approximation explicitly in the proof in Appendix A.4 (p. 19).

W7. Experimental concerns.

A7 (W7). Thank you for raising the difference in baseline results on Twitter-Tennis. We split the non-overlapping windows in chronological order, using 60% for training, 20% for validation, and 20% for testing. All methods were evaluated on the same later windows. In the study you cited, Berndt et al. (NeurIPS 2025) shuffled the windows after splitting the data. The choice of split determines which time periods are evaluated. We describe our split in Appendix D.2 (pp. 22–23).

We added a statistical analysis in Appendix G (pp. 30–31). For temporal link prediction, a permutation-based Friedman test across seven datasets found a significant overall difference among the methods (p<0.001p<0.001). DG-FDE with a fixed fractional order ranked first on average, followed by DG-FDE with a learnable order.

The Contact results show that the integer-order variant is competitive in its own right. To assess what fractional dynamics add, we compare the fixed fractional-order and integer-order variants within the same architecture. On Contact, the fixed fractional-order variant improved test MRR@100 from 29.02 to 32.38 on a 0–100 scale (Table 2). This shows that fractional dynamics provide an additional gain on top of the shared architecture.

I appreciate the authors' response which help clarify some concerns and maintain my positive rating.

Best

Reviewer_rvRKOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Dynamic Graph Fractional Differential Equation (DG-FDE), a continuous-time model for Discrete-Time Dynamic Graphs (D-TDGs) in which node embeddings evolve under a Caputo fractional differential equation driven by a GCN vector field on the evolving graph. Its equivalent integral formulation accumulates the updates produced by past graph snapshots with a decaying memory kernel, and is solved with the fractional Adams-Bashforth-Moulton discretization algorithm. The authors prove finite-horizon well-posedness and stability, and derive a decomposition of the state into per-snapshot contributions. Experiments on two node-regression and seven link-prediction datasets show consistent gains over the integer-order variant and competitive or best results against dynamic graph baselines.

Critical strengths
  • The paper has a strong theoretical background, which is leveraged in the creation of a nice methodological approach. The formulation is principled, as the model is well-posed and stable on finite horizons, and it exposes how past snapshots contribute to the current state.
  • DG-FDE achieves state-of-the-art performance on multiple node-property prediction and temporal link prediction datasets while being computationally efficient. Moreover, the model consistently improves upon the integer-order variant, which is coherent with its claimed importance.
Critical weaknesses
  • The authors mention long-range modeling, but they never discuss the comparison between their approach and other effective differential-equation-based GNNs for temporal graphs [1, 2], or other similar approaches [3]. Moreover, the long-rangeness in their experiments is restricted to sliding windows of up to 20 past observations, which, in my opinion, is not really long-range. I suggest carefully revising the claims or providing some experiments on long-range synthetic D-TDGs, such as those proposed in [1, 3, 4].
  • The presentation of the paper is suboptimal. The narrative proposes strong theoretical foundations, but it is hard to follow the overall thread of the paper, especially when relating theoretical results to the actual implementation details of the method (i.e., the discretization). For instance, a figure representing the core components of the model implementation would help in understanding the method better.

[1] Fabrizio De Castelli et al. “Adaptive Memory Retention in Dynamic Graphs.” International Conference on Machine Learning (ICML), 2026.

[2] Alessio Gravina et al. “Long Range Propagation on Continuous-Time Dynamic Graphs.” International Conference on Machine Learning (ICML), 2024.

[3] Ivan Marisca et al. “Over-squashing in Spatiotemporal Graph Neural Networks.” Advances in Neural Information Processing Systems (NeurIPS), 2025.

[4] Alireza Dizaji et al. “T-GRAB: A Synthetic Diagnostic Benchmark for Learning on Temporal Graphs.” ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD), 2026.

Questions for authors
  • Can you isolate of the importance of the GNN depth L and its backbone model (which in the paper is fixed to GCN), to check whether the strengths of your methodology hold?
  • Could you please discuss the applicability of your method to spatio-temporal graphs, which can be viewed as a special case of D-TDGs with Etk=Et0∀tk>0\mathcal{E}_{t_k} = \mathcal{E}_{t_0} \quad \forall t_k > 0 and evolving node signals?
  • It is not clear to me how the method allows encoding multi-scale temporal information. Could you please clarify this?
  • Can you provide convergence/stability insights for the ABM discretization, and discuss alternative discretization methods, such as fractional Euler?
8 comments
AuthorsOpenReview ↗

Response to Reviewer rvRK (1/3)

Thank you for taking the time to review our paper and share your feedback. We have revised the manuscript based on your suggestions and respond to each point below. Please let us know if any questions or concerns remain.


W1. The authors mention long-range modeling, but they never discuss the comparison between their approach and other effective differential-equation-based GNNs for temporal graphs [1, 2], or other similar approaches [3]. Moreover, the long-rangeness in their experiments is restricted to sliding windows of up to 20 past observations, which, in my opinion, is not really long-range. I suggest carefully revising the claims or providing some experiments on long-range synthetic D-TDGs, such as those proposed in [1, 3, 4].

A1. We agree that the original experiments, which used up to 20 past snapshots, provided limited evidence for long-range modeling. Thank you for suggesting these benchmarks [1, 3, 4]., we chose T-GRAB [4] because it directly tests whether a model can predict current links using information from several snapshots ago and several hops away from a source node.

Table R1 shows the results for lags of 16 and 32 snapshots. At the longest lag and path length we tested (32 snapshots and 16 hops), DG-FDE reached a mean test F1 of 0.694. All seven baselines scored 0.058, which is the F1 obtained by predicting every candidate link as positive. These results show that DG-FDE can use information from much earlier snapshots to predict current links. Because it takes full graph snapshots as input, it can use the graph structure in those snapshots to model dependencies between nodes many hops apart. We added this experiment in Section 5.1 (pp. 8) and Figure 3 (pp. 9). The full results are in Table 5 (pp. 22).

Following your suggestion, we added CTAN [2] and LAMP [1] to our real-world experiments (Section 5.2, pp. 8–9, and Section 5.3, pp. 9–10). We also added CTAN to the T-GRAB experiments (Section 5.1, pp. 8–9). We ran initial tests with LAMP on T-GRAB. In these tests, using more Euler steps per snapshot helped LAMP capture information across multiple hops, but also increased training time. We estimated that running LAMP across all 20 settings with multiple seeds would take about 109 GPU hours. With the GPU time available during the rebuttal period, we could only complete the initial tests. The models you suggested in [3] are designed for time-varying node signals on a fixed graph. This setup makes these models a poor fit for the tasks we study in this paper. We also added LNJSDE, a recent model that uses stochastic differential equations for dynamic graphs, and compared it with DG-FDE on real-world datasets.

Table R1. Test F1 on T-GRAB at lags of 16 and 32 snapshots. Columns show the path length in hops. Bold marks the highest mean for each setting.

Temporal lagMethod1 hop2 hops4 hops8 hops16 hops
16 snapshotsDG-FDE1.000 ± 0.0000.972 ± 0.0070.939 ± 0.0390.988 ± 0.0110.936 ± 0.049
DyGFormer0.990 ± 0.0000.865 ± 0.0350.680 ± 0.0300.520 ± 0.0500.295 ± 0.035
TGAT1.000 ± 0.0001.000 ± 0.0000.885 ± 0.0300.890 ± 0.0000.435 ± 0.010
TGN0.990 ± 0.0100.990 ± 0.0100.805 ± 0.0400.820 ± 0.0950.340 ± 0.115
GC-LSTM0.125 ± 0.0450.075 ± 0.0390.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
T-GCN0.150 ± 0.0650.090 ± 0.0150.065 ± 0.0000.059 ± 0.0000.058 ± 0.000
EGCN0.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
CTAN0.048 ± 0.0120.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
32 snapshotsDG-FDE1.000 ± 0.0000.999 ± 0.0010.969 ± 0.0200.849 ± 0.2280.694 ± 0.271
DyGFormer0.985 ± 0.0000.870 ± 0.0100.595 ± 0.0200.225 ± 0.0300.058 ± 0.000
TGAT1.000 ± 0.0001.000 ± 0.0000.920 ± 0.0200.320 ± 0.0000.058 ± 0.000
TGN1.000 ± 0.0001.000 ± 0.0000.830 ± 0.0600.385 ± 0.0700.058 ± 0.000
GC-LSTM0.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
T-GCN0.065 ± 0.0000.065 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
EGCN0.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
CTAN0.000 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.0000.058 ± 0.000
AuthorsOpenReview ↗

Response to Reviewer rvRK (2/3)

W2. The presentation of the paper is suboptimal. The narrative proposes strong theoretical foundations, but it is hard to follow the overall thread of the paper, especially when relating theoretical results to the actual implementation details of the method (i.e., the discretization). For instance, a figure representing the core components of the model implementation would help in understanding the method better.

Q3. It is not clear to me how the method allows encoding multi-scale temporal information. Could you please clarify this?

A2 (W2 and Q3). We added an overview of DG-FDE in Figure 1 (p. 4). The left panel shows how DG-FDE weighs information from past graphs. The right panel shows how the solver uses a sequence of graph snapshots to compute node embeddings for prediction.

Here is how DG-FDE captures long-range dependencies. At each time, the GNN computes a response from the graph and the node states at that time. DG-FDE combines these responses across the input window. The memory kernel gives more weight to recent responses while still letting older ones contribute. The fractional order α\alpha controls how these weights change with the time lag. We added a simple example in Figure 2 (p. 7). With a smaller α\alpha, the state drops faster at first and decays more slowly in the long run. This illustrates how earlier information can have a lasting effect. We can tune α\alpha for the downstream task or learn it during training to control how quickly the influence of past information fades.

To connect the theory to the implementation, Section 4.4 (p. 7) shows how the ABM solver uses the weighted sums in Eqs. (12) and (13) to approximate the history integral in Eq. (5). The solver stores and reuses past GNN responses to predict the next node state and then refine that prediction. We also added pseudocode for the solver and for training with a learnable α\alpha in Appendix B (Algorithms 1 and 2, pp. 19–20).

Q1. Can you isolate of the importance of the GNN depth L and its backbone model (which in the paper is fixed to GCN), to check whether the strengths of your methodology hold?

A3 (Q1). Thank you for your helpful suggestion. We kept the graph operator fixed and tested DG-FDE with one to five layers on four datasets. Adding layers did not consistently improve performance, and the scores stayed fairly stable overall. We revised the paper and added the details of the depth experiment to Appendices E.2, with the results shown in Figure 6 (p. 27).

We used six static graph models as vector fields in DG-FDE and compared each version with the static baseline that uses the same graph operator. As shown in Table R2, applying fractional integration to the outputs of these graph operators improved mean MRR@100 for all datasets. The gains held across a range of graph operators. We revised the paper and added the experimental details and results to Appendices E.2 (pp. 26–27, Table 8).

Table R2. Temporal link prediction with static graph models and their DG-FDE versions. Scores are mean test MRR@100 (%, higher is better). Bold percentages show the relative gain over the matching static baseline.

BackboneSettingEnronContactRDSUCIReddit BodyReddit TitleAS733
GCNStatic baseline11.8012.2212.4110.8422.1836.2741.95
GCNDG-FDE19.2030.6921.4035.6542.1056.1167.23
Relative gain+62.71%+151.15%+72.44%+228.87%+89.81%+54.70%+60.26%
GATStatic baseline15.9918.2718.8121.5722.6236.3953.69
GATDG-FDE24.7850.6640.0842.7554.7360.9990.00
Relative gain+54.97%+177.29%+113.08%+98.19%+141.95%+67.60%+67.63%
GraphSAGEStatic baseline12.6210.609.4034.7022.2332.6639.07
GraphSAGEDG-FDE16.7536.9818.0642.0153.7461.2059.79
Relative gain+32.73%+248.87%+92.13%+21.07%+141.75%+87.39%+53.03%
GINStatic baseline13.8917.8514.5928.6636.0446.9838.82
GINDG-FDE15.0029.6620.3736.1439.9350.1149.89
Relative gain+7.99%+66.16%+39.62%+26.10%+10.79%+6.66%+28.52%
SGCStatic baseline11.7912.2112.4110.8821.7936.2741.95
SGCDG-FDE13.4331.3120.0132.4140.5252.3158.34
Relative gain+13.91%+156.43%+61.24%+197.89%+85.96%+44.22%+39.07%
ChebNetStatic baseline15.2721.0415.3935.8046.3857.6379.69
ChebNetDG-FDE20.7940.8525.7240.2854.3562.0188.81
Relative gain+36.15%+94.15%+67.12%+12.51%+17.18%+7.60%+11.44%
AuthorsOpenReview ↗

Response to Reviewer rvRK (3/3)

Q4. Can you provide convergence/stability insights for the ABM discretization, and discuss alternative discretization methods, such as fractional Euler?

A4 (Q4). For sufficiently smooth fractional systems, the standard ABM method has a global error of order O(hmin⁡(2,1+α))O(h^{\min(2,1+\alpha)}), where hh is the step size (Diethelm et al., 2002, 2004). We tested this on the fractional SIR model. When we reduced the step size from 0.4 to 0.1, the trajectory RMSE fell to about one-twelfth of its original value. This drop is consistent with what the theory predicts as the step size gets smaller. For the continuous DG-FDE model, Proposition 1 (p. 5) shows that a small change in the initial node embeddings leads to a proportionally bounded change in the solution over a fixed time interval. The proof is in Appendix A.2 (p. 17).

Thank you for suggesting that we test other solvers. Alongside the ABM solver used in the main paper, we tested fractional Euler and explicit L1. We ran both methods with direct and adjoint backpropagation. The solver details are in Appendix F.1 (p. 28).

We first compared the solvers on the fractional SIR model. At the same step size, ABM gave the trajectory closest to the reference solution and had the smallest relative gradient error. It was also the fastest in both the forward-only and forward–backward tests, with the largest peak increase in GPU memory (Table R3).

We then compared link prediction performance and computational cost on Enron and UCI. ABM achieved the highest test MRR@100 on both datasets. Fractional Euler and explicit L1 took less time for a forward–backward pass when using direct backpropagation. Adjoint backpropagation reduced peak GPU memory use on SIR. On both dynamic graph datasets, it increased peak GPU memory use compared with direct backpropagation for the same solver (Table R4). We revised the paper and added the experimental details and results to Appendices F (pp. 28–30, Tables 9 and 10).

Table R3. Solver comparison on the fractional SIR model at h=0.1h=0.1.

SolverBackprop.Trajectory RMSE ↓Forward (s/trajectory) ↓Forward + backward (s/batch) ↓Peak memory increase (MiB) ↓Relative gradient error (%) ↓
ABMDirect6.83e−50.651.6920.420.019
Fractional EulerDirect4.56e−311.5428.897.510.71
Fractional EulerAdjoint4.56e−311.5823.722.9673.79
Explicit L1Direct6.61e−311.8528.787.481.01
Explicit L1Adjoint6.61e−311.6123.692.9773.14

Table R4. Solver comparison on Enron and UCI at h=1h=1. Embedding error is the relative error of the final node embeddings against a fine-grid reference.

DatasetSolverBackprop.Test MRR@100 ↑Embedding error (%) ↓Forward (ms) ↓Forward + backward (ms) ↓Peak memory increase (MiB) ↓
EnronABMDirect0.19903.4934.5976.4027.66
EnronFractional EulerDirect0.164812.0619.9345.0916.98
EnronFractional EulerAdjoint0.156612.0619.2064.0619.89
EnronExplicit L1Direct0.179312.9421.4046.6916.98
EnronExplicit L1Adjoint0.183112.9420.6576.6019.90
UCIABMDirect0.35960.5930.9173.93120.89
UCIFractional EulerDirect0.34532.5517.7341.7174.72
UCIFractional EulerAdjoint0.33642.5517.6760.0385.00
UCIExplicit L1Direct0.34832.8420.5741.1974.72
UCIExplicit L1Adjoint0.34252.8419.1263.9885.00

References

  • Diethelm, K., Ford, N. J., and Freed, A. D. (2002). A predictor-corrector approach for the numerical solution of fractional differential equations. Nonlinear Dynamics, 29, 3–22. DOI
  • Diethelm, K., Ford, N. J., and Freed, A. D. (2004). Detailed error analysis for a fractional Adams method. Numerical Algorithms, 36, 31–52. DOI

Q2. Could you please discuss the applicability of your method to spatio-temporal graphs, which can be viewed as a special case of D-TDGs with Etk=Et0∀tk>0\mathcal{E}_{t_k} = \mathcal{E}_{t_0} \quad \forall t_k > 0 and evolving node signals?

A5 (Q2). Spatio-temporal graphs. Yes. We tested this setup on four PeMS traffic datasets. We learned a single graph propagation matrix shared across time and used the past 12 readings to predict the next 12. We revised the paper and added the experimental details and results to Appendix H (p. 32, Table 11).

Comments on the paper

1 comment

We thank all reviewers for taking the time to read our paper carefully and consider our responses. Your questions and suggestions helped us see where clearer explanations and further evaluation were needed. We have learned a great deal from these discussions and sincerely appreciate the time, effort, and care each of you devoted to reviewing our work.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.