On standard benchmarks for graphs that change over time, a strange result keeps appearing. To predict a node's future properties, such as which products a trading country will trade next or which communities a user will join, a rule that says "tomorrow looks like today" beats the most elaborate neural models by wide margins. On tgbn-trade, Persistent Forecast scores 84.69 NDCG while DyGFormer scores 38.78 (An Empirical Evaluation of Temporal Graph Benchmark). On tgbn-reddit, a Moving Average scores 0.559 NDCG@10 against TGN's 0.315 (Temporal Graph Benchmark for Machine Learning on Temporal Graphs). The usual explanation is that these models were tuned for link prediction. This proposal tests a sharper and more mechanistic hypothesis. Neural dynamic models suffer from temporal over-smoothing: as they repeatedly mix a node's state with its neighbors' states across many events, node representations collapse toward a few shared directions. That collapse erases exactly the node-specific history that the persistence rule exploits.
If the hypothesis holds, the remedy should be cheap and modular rather than a new architecture. We would maintain, under a stream of edge events, a small bank of incrementally updated feature propagations at different smoothing strengths. One end of the bank is the unsmoothed "persistence" state. A per-node gate decides how much smoothing each node can tolerate, guided by a local curvature signal that, like the propagations themselves, is cheap to update on every event. The project has two parts: a diagnosis that measures the collapse directly, and a fix whose value is judged against the strongest simple alternative, a learned correction on top of the persistence heuristic.
Core Claim
We make two linked claims. The diagnostic claim is that the effective rank of node representations in dynamic models falls over stream time and over model depth on node-property tasks. Effective rank is a scale-invariant measure of how many independent directions a feature matrix actually uses, shown by Are we measuring oversmoothing in graph neural networks correctly? to track accuracy loss in static deep networks (Pearson correlation averaging 0.91) where Dirichlet energy does not. We further claim that this collapse predicts the per-dataset gap to persistence heuristics even after controlling for whether the model sees past labels at all. The constructive claim is that a streaming, multi-strength propagation bank with a node-wise gate closes most of that gap. It must do so at a per-event cost local to the changed neighborhood, so it scales to tgbn-token (over 72 million edges) and beyond.
Over-smoothing theory is entirely static today. The feature decay bound in Depth-Adaptive Graph Neural Networks via Learnable Bakry-Émery Curvature, the rank results, and the spectral control in Advection-Diffusion on Graphs: A Bakry-Emery Laplacian for Spectral Graph Neural Networks all assume a fixed graph. Meanwhile the scalable dynamic systems never measure collapse. These include Decoupled Graph Neural Networks for Large Dynamic Graphs and Adapting to Evolving Graphs: A Scalable Framework for Dynamic Coarsening. We bring the measurement into the dynamic setting and use it to explain a known, unexplained benchmark failure.
Research Program
Diagnosis. We first instrument existing models: TGN, DyGFormer, TGAT and GraphMixer through the DyGLib pipeline (An Empirical Evaluation of Temporal Graph Benchmark), and the decoupled propagation model of Zheng et al. At regular points in stream time, we record the effective rank and numerical rank of the node-state matrix, both over all active nodes and within communities. We plot these against prediction quality on tgbn-trade, tgbn-reddit, tgbn-genre and tgbn-token.
The rank paper itself warns that high rank is necessary but not sufficient for usefulness, since random noise has full rank. We therefore pair each rank measurement with a linear probe. The probe asks how well the node state can recover that node's own most recent label vector. "Identity retention" is defined as probe accuracy, not rank alone.
There is an important confound. Persistence heuristics read a node's past labels, and the neural baselines may not receive them as input. We therefore rerun every neural model with the past label vector concatenated to node features. If the gap to persistence survives this, information is being destroyed inside the model, not merely withheld from it. That is the over-smoothing story. If the gap vanishes, the story is wrong, and we report that.
Streaming propagation bank. The decoupled model of Zheng et al. maintains personalized-PageRank-style propagated features with a local "push" procedure. Each edge event touches only nodes whose residual exceeds a threshold $r_{max}$, and downstream sequence models then train without any graph computation. We reuse this method and extend it to maintain $K$ propagations at different retention levels $\alpha_1 > \dots > \alpha_K$, where $\alpha$ is the probability of stopping at the current node rather than continuing to a neighbor. We include $\alpha_1 = 1$, which is the node's own unsmoothed features and label history, the persistence state. Node $u$'s representation is
$$ h_u = \sum_{k=1}^{K} g_k(u)\, \pi_{\alpha_k}(u), \qquad \pi_{\alpha}(u) = \alpha \sum_{t \ge 0} (1-\alpha)^t \,(P^t X)_u , $$
where $P$ is the current random-walk transition matrix, $X$ holds the node features (including past labels), and $g(u)$ is a softmax gate over the $K$ levels. Small $\alpha$ means heavy smoothing. Each $\pi_\alpha$ is updated by local push at cost governed by $1/(\alpha\, r_{max})$, which is the standard push bound. The bank therefore costs roughly $K$ times the base model, and the heavy-smoothing levels dominate.
Curvature-informed gate. The gate is a small network trained end-to-end in the graph-free downstream stage. Its inputs are the node's recent features and a streaming curvature estimate. We use the temporal Forman-Ricci score of Edge Sparsification via Temporal Forman-Ricci Curvature for Dynamic Graph Learning, which combines structural support, recency decay and local competition, averaged over a node's incident edges. That paper uses curvature to prune edges within discrete snapshots, with hand-set thresholds. We use it differently: as a per-node input that is updated on each event, since Forman curvature depends only on endpoint quantities. This gives a continuous-time variant.
The gate is motivated by the feature decay bound of the Bakry-Émery depth paper, which shows that nodes in high-curvature regions lose identity exponentially faster under message passing. That paper turns curvature into a hard depth cutoff through a manually tuned threshold and assumes a static graph. Our gate replaces the cutoff with a learned soft mixture over smoothing levels and requires no retraining when edges change, because only the gate's input changes.
We deliberately do not build on the spectral advection operator of the Bakry-Émery Laplacian paper. Its Chebyshev filters must be recomputed as the spectrum shifts, which conflicts with event-level updates. Instead we treat the retention level as a local, push-compatible analogue of its node potential. Whether this analogue inherits that paper's control over mixing rate is one of our analyses.
Theory. We prove the error guarantee of local push with node-dependent retention, with the bound controlled by the smallest $\alpha$ used. We also characterize how the effective rank of $\pi_\alpha$ can decay under a stream of edge insertions that increase graph conductance. This extends the static rank-collapse results to an evolving transition matrix.
Baselines
The naive reference points are the non-trainable heuristics: Persistent Forecast and Moving Average, run through the official TGB evaluators. On tgbn-trade, Persistent Forecast reports 84.69 NDCG (An Empirical Evaluation of Temporal Graph Benchmark). On tgbn-reddit, Moving Average reports 0.559 NDCG@10 (Temporal Graph Benchmark for Machine Learning on Temporal Graphs). For tgbn-genre, the file states only that Moving Average beat TGN; we found no reported result on Lacuna for the exact numbers on tgbn-genre or tgbn-token, so we will produce them ourselves. These are the numbers to beat, and failing to beat them would be a negative result for the whole proposal.
The strongest neural competitor is DyGFormer under the standardized DyGLib pipeline, reported at 38.78 NDCG on tgbn-trade, and TGN at 0.315 NDCG@10 on tgbn-reddit. We rerun them with identical splits, the DyGLib optimizer and early-stopping rules, and the same hyperparameter search budget as our method. We run them both with and without past labels as input, so that our method's label access is never an unfair advantage.
The strongest scalable dynamic method is the decoupled model of Zheng et al., run with a single PageRank-style propagation and the same downstream sequence model as ours. It reports large link and node gains elsewhere, a 41% MRR gain on Bitcoin-OTC and 13.6% F1-Micro on GDELT. We found no reported result on Lacuna for it on tgbn node affinity tasks. This is the baseline that isolates our contribution, since our method is this model plus the bank and the gate.
The most dangerous baseline is a persistence-plus-residual model. Here the prediction is the Persistent Forecast or Moving Average output plus a correction learned by the same downstream network from single-level propagated features. Beating it is the real bar.
Two ablations complete the picture. The first concatenates all $K$ bank levels and feeds them to the downstream network with no gate. The second keeps the gate but removes the curvature input. Beating a baseline means a gain in mean NDCG over five seeds that exceeds two standard errors, at matched training budget and with per-event update cost reported alongside.
Why not just…?
Why not just predict a learned correction on top of Persistent Forecast? This is the most serious threat. It directly encodes the "tomorrow looks like today" signal, and it could close the gap without any representation-level idea. We take it seriously by making it a primary baseline rather than a straw man. The heuristic has a known failure regime: TGB documents that persistence breaks under high structural drift and for nodes with little history. We therefore stratify results by node history length and by a per-node surprise measure. If the residual model matches us everywhere, including on drifting and short-history nodes, we will conclude that the bank adds nothing beyond its $\alpha=1$ level, and the contribution reduces to the diagnosis. We will report that plainly.
Why not just concatenate several propagation depths and let a network sort them out? Multi-hop concatenation is a familiar trick in static decoupled models, and it may work as well as a gate. The concatenation ablation answers this directly. We expect the gate to matter mainly on heterogeneous graphs, where curvature varies widely across nodes. If it does not, we drop the gate and keep the simpler concatenated bank. That still answers the scalability and over-smoothing questions, because the persistence level remains in the bank either way.
Why not just add residual connections to TGN or DyGFormer? Residual connections provably mitigate oversmoothing in graph neural networks shows that skip connections prevent collapse with depth in static networks. But temporal smoothing in memory-based models accumulates over events, not layers, and a residual over layers does not protect a memory state that is overwritten event after event. We test this by adding layer and memory skip connections to TGN and tracking whether effective rank over stream time still falls. Residual-augmented TGN also remains subject to the memory and runtime costs reported for attention models: TGAT takes 147 seconds per epoch on Wikipedia against 2 seconds for decoupled propagation (Zheng et al.).
Why not just sparsify with TRicci? Pruning edges reduces cost, preserving 97.7% of full-graph ROC-AUC at 80% removal. But it leaves the aggregation unchanged, so it cannot by itself stop identity loss on the remaining edges, and it works on snapshots rather than streams. We include TRicci-sparsified inputs to the decoupled baseline to check whether pruning alone recovers node-level accuracy.
Proposed Experiments
The first decisive check is the confound test on all four tgbn datasets. Does the neural-versus-persistence gap survive giving models their past labels, and does falling identity-retention probe accuracy (not just rank) track the gap across datasets and models? A noise-injection control raises rank without adding information. If such noise raises effective rank without improving the probe or NDCG, that confirms we are measuring useful diversity rather than raw dimensionality.
The second check is the head-to-head on tgbn-trade and tgbn-reddit. Our method must beat 84.69 NDCG and 0.559 NDCG@10 respectively, and must beat the persistence-plus-residual model, with results stratified by history length and drift.
The third check guards against harming link prediction. Running the same propagation bank with a link head on tgbl-wiki, we expect performance near DyGFormer's reported 79.83 MRR from DyGLib.
The fourth check is scalability. We report per-event update time, peak memory and NDCG as $K$ grows, on tgbn-token, and a propagation-only throughput run on MAG (1.2 billion edges) as used by Zheng et al. The theory predicts that cost grows linearly in $K$ and is dominated by the smallest $\alpha$.
Across all checks, the ablation table separating bank, gate and curvature tells us which ingredient carries the gain. A clean negative result on the confound test would also be worth publishing, because it would redirect the field's explanation of the node-prediction gap.
References
- An Empirical Evaluation of Temporal Graph Benchmark
- Temporal Graph Benchmark for Machine Learning on Temporal Graphs
- Are we measuring oversmoothing in graph neural networks correctly?
- Depth-Adaptive Graph Neural Networks via Learnable Bakry-'Emery Curvature
- Advection-Diffusion on Graphs: A Bakry-Emery Laplacian for Spectral Graph Neural Networks
- Decoupled Graph Neural Networks for Large Dynamic Graphs
- Adapting to Evolving Graphs: A Scalable Framework for Dynamic Coarsening
- Edge Sparsification via Temporal Forman-Ricci Curvature for Dynamic Graph Learning
- Residual connections provably mitigate oversmoothing in graph neural networks