Letting Rank Collapse Decide the Geometry of a Dynamic Graph Encoder

Graph neural networks represent each node as a vector and update it by averaging over its neighbours. Stack enough of these averaging steps and every node starts to look the same. This is called over-smoothing, and recent work shows it is best measured as the node-embedding matrix losing rank, not losing "energy." A separate literature embeds graphs in curved spaces. Tree-like regions fit naturally in hyperbolic space, cyclic or clustered regions fit in spherical space, and a product of several such spaces, called a product manifold, can mix them. Choosing how many dimensions go to each curved factor is called choosing the geometric signature, and doing it automatically is expensive. On graphs that change over time, the right signature also drifts, and no existing method re-chooses it as the graph evolves.

This note proposes using the first idea to solve the second. In a product-manifold message-passing encoder, we compute the effective rank of each curved factor's embeddings on a recent time window. That number is a cheap, training-free signal of whether the factor fits the current structure. A factor whose embeddings collapse in rank is wasting its dimensions on the current graph, and those dimensions should move to a factor that is still using its capacity. The system we would build tracks the geometric signature online on a dynamic graph by making small, rank-guided dimension transfers between factors, each checked against a cheap task metric. The empirical question underneath it is whether geometric mismatch shows up as factor-specific rank collapse at all. Nobody has measured this.

Core Claim

Our hypothesis is that over-smoothing in a curved message-passing encoder is not uniform across factors. When a time window becomes more tree-like, the spherical factor's embeddings should collapse in rank first under repeated neighbour averaging, because a bounded space crowds exponentially many descendants together. When the window becomes clustered and cyclic, the hyperbolic factor should collapse first. If this holds, per-factor rank tells you which way to move the signature without training a new model for every candidate. That per-candidate training is what makes offline search costly.

We define the measurement concretely. For factor $i$ with $d_i$ dimensions, let $Z_i$ be the window's node embeddings after $L$ propagation steps, mapped to the tangent space at the origin. The tangent space is the flat space touching the manifold at one point, so ordinary linear algebra applies there. We then compute

$$\mathrm{Erank}(Z_i)=\exp\Big(-\sum_k p_k\ln p_k\Big),\quad p_k=\sigma_k/\textstyle\sum_j\sigma_j,\qquad u_i=\mathrm{Erank}(Z_i)/d_i,$$

where $\sigma_k$ are the singular values of $Z_i$ and $u_i\in(0,1]$ is the factor's utilisation. Dimensions are moved from the factor with the lowest $u_i$ to the factor with the highest.

Where This Sits

Three bodies of work motivate the proposal, and each leaves the same hole.

The rank diagnostic comes from Are we measuring oversmoothing in graph neural networks correctly? and Rethinking Oversmoothing in Graph Neural Networks: A Rank-Based Perspective. Both show that effective rank tracks accuracy, with an average Pearson correlation of about 0.91, while Dirichlet energy does not (correlation −0.7179). Their study is entirely static and Euclidean. We reuse their metric per factor and over time.

The search structure comes from Neural Latent Geometry Search. NLGS places candidate signatures on a graph whose edges connect signatures that differ by one component, then runs Bayesian optimisation over that graph using Gromov–Hausdorff distances between candidates. We keep its move set of one-component edits, but replace "train and evaluate each candidate" with "read the rank of the current model." NLGS is offline, static, and limited to 2D unit-curvature factors.

Curve Your Attention (FPS-T) learns continuous curvatures end-to-end inside a fixed product signature. It argues that curved message passing over-smooths and should be replaced by global attention. We take the opposite bet: keep message passing, as Anti-Symmetric DGN and IDGNN show is viable in Euclidean space, and test whether matching the geometry delays rank collapse.

The closest dynamic work is CurvPrompt and DyGMoCE. Both document curvature drift; for example, MOOC shifts toward negative curvature over 30 days. Both respond by routing nodes among fixed constant-curvature experts. Neither builds product manifolds or measures rank. DyGMoCE also reports that its experts learn redundant, generic features, and our per-factor utilisation is a direct measurement of exactly that redundancy.

TRicci uses temporal Forman–Ricci curvature only as an edge-pruning score. That is a different use of curvature, and it serves us as an optional cheap structural signal to compare against.

Research Program

The first stage is a measurement study, and it stands on its own whether or not the method works. On continuous-time interaction graphs, we track per-layer effective rank and numerical rank of embeddings over time windows for three Euclidean models: TGN (Temporal Graph Networks), an IDGNN-style implicit model, and a deepened message-passing variant. We also track rank of TGN's per-node memory, since repeated memory updates are a second, temporal route to homogenisation that layer-depth studies miss. This fills the dynamic-rank gap the file identifies.

The second stage tests the core hypothesis. We build a product-manifold message-passing encoder with a fixed total budget $D$ and an even split across hyperbolic, spherical and Euclidean factors. On synthetic dynamic graphs whose generator switches between tree-like and clustered regimes, we check whether the mismatched factor's utilisation $u_i$ drops first. The same check runs on MOOC, where drift toward hyperbolic curvature is already documented, and we ask whether spherical utilisation falls as the drift proceeds. If factor-specific collapse does not appear, the method stage is abandoned and the paper reports the negative result.

The third stage is the tracker. At the end of each window, we propose one NLGS-style move that shifts $\delta$ dimensions from the lowest-$u_i$ factor to the highest. New dimensions are initialised at the origin, so existing embeddings are unchanged at the moment of transfer. We accept the move only if next-window validation link-prediction loss on a small slice does not worsen. This guard matters because high rank is necessary for good embeddings but not sufficient: noise has full rank. Curvature magnitudes are learned continuously within each factor, but signs are fixed, which avoids the instability FPS-T reports when curvature passes through zero. The tracker's cost is one singular value decomposition per factor per window, plus one short validation pass.

Baselines

The naive reference is a Euclidean TGN with the same total dimension $D$, trained identically. On TGB node tasks, we also report the Moving Average heuristic. Temporal Graph Benchmark reports Moving Average at NDCG@10 of 0.559 on tgbn-reddit, against 0.315 for TGN. Any learned model that cannot approach the heuristic there has to explain why.

The strongest existing methods are DyGMoCE and CurvPrompt. Both are mixed-curvature and drift-aware, so they answer the same question by routing rather than reallocation. The file reports that DyGMoCE ranks first on MOOC, Reddit, Wikipedia and the UN, LastFM and Enron graphs. It reports CurvPrompt as a +13.9% transductive AUC gain over TGN-DyGPrompt on MOOC few-shot link prediction. I found no reported absolute AUC or AP values on Lacuna for either method, so we will rerun both from their descriptions with matched parameter counts and the same windows. For link ranking on tgbl-wiki, the reported best is NAT at MRR 0.749, which we include as a reference point.

We will run two geometry ablations. The first is a fixed product signature with FPS-T-style learnable curvature and no reallocation. The second runs NLGS once on the first window and then freezes the signature, which isolates whether online tracking matters.

We will also run three ablations that isolate the key ingredient, the rank signal. In the first, reallocation is driven by validation loss alone using random proposed moves. In the second, reallocation is driven by per-factor Dirichlet energy instead of rank. In the third, reallocation is driven by local Gromov δ-hyperbolicity of the window, the structural signal DyGMoCE uses.

Every method gets the same hyperparameter-search budget in GPU-hours and the same chronological splits, and every method is evaluated with TGB's official negative sampling. Beating the field means matching or exceeding DyGMoCE at equal parameters on the drifting datasets, MOOC and Reddit, while using clearly fewer dimensions to reach Euclidean TGN's score. The result must also show that rank-driven moves beat both loss-only and δ-driven moves.

Why not just…?

Why not just learn the curvatures end-to-end, as FPS-T does? Gradient descent on curvature changes how curved each factor is. It cannot change how many dimensions each factor has, and FPS-T notes instability when curvature crosses zero. The fixed-signature, learnable-curvature ablation tests this directly. If it matches the tracker on MOOC and Reddit, then reallocation is unnecessary and we will say so.

Why not just route among mixed-curvature experts, as DyGMoCE and CurvPrompt do? This is the real threat, because routing already adapts to drift. Our case rests on DyGMoCE's own report of expert redundancy: routing can pick a geometry while all experts quietly learn the same generic features. Per-factor utilisation exposes that redundancy, and reallocation removes it. The matched-parameter comparison settles the question. If routing wins, the contribution narrows to the diagnostic, which could then be applied to measure redundancy inside DyGMoCE itself.

Why not just use a large Euclidean space plus normalisation, or a heuristic? FPS-T found that 4 curved dimensions beat 16 flat ones on static graphs. The rank papers show that normalisation layers keep Dirichlet energy high while rank collapses, so normalisation can hide over-smoothing rather than fix it. Heuristics win on tgbn-reddit, but TGB shows they fail on tgbl-review, where many test edges were never seen in training. We report both regimes and plot dimension-versus-accuracy curves against Euclidean TGN, rather than assume the curved model wins.

Why not just rerun NLGS every window? Each NLGS evaluation trains a model. The tracker reads one singular value decomposition. We will report wall-clock time and accuracy for periodic NLGS against the tracker.

Decisive Checks

The first decisive check is stage two. On synthetic regime-switching graphs and on MOOC, the mismatched factor's utilisation must fall before the others' and before accuracy drops. If not, the premise is false.

The second is the ablation result. Rank-driven reallocation must beat loss-only and δ-driven reallocation on MOOC, Reddit and tgbl-review. If it does not, rank adds nothing beyond the validation guard.

The third concerns depth. On IDGNN's Brain10, DBLP5 and Reddit4, the tracked product encoder must keep effective rank and accuracy flat at 16 to 32 message-passing layers, where Euclidean message passing collapses. That would test, in the dynamic setting, FPS-T's claim that curved message passing must over-smooth.

The last is a sanity check on Cora: per-factor rank should reproduce the static correlation of about 0.91 between effective rank and accuracy.