acceptodds
Under review as a conference paper at ICLR 2027

Quotient-Residual Temporal Memory for Scalable Continuous-Time Graph Learning

Abstract

Continuous-time temporal graph models maintain evolving node states and repeatedly propagate information as timestamped interactions arrive. Their accuracy comes with a persistent cost: the state and propagation domain grow with the original graph. Graph coarsening can reduce this domain, but prior coarse-to-fine pipelines recover accuracy through full-graph fine-tuning and memory reconstruction, which reintroduces the resource that coarsening was intended to remove. We introduce the Quotient-Residual Temporal Network (QRTN), a fine-tuning-free framework that preserves every timestamped event while separating shared quotient dynamics from a small identity-preserving residual. QRTN provides three operating points. QRTN-M processes original-node events throughout training while storing high-dimensional state only on supernodes. QRTN-X trains shared temporal operators on an event-preserving quotient and transfers parameters, but no runtime state, to a fresh original graph. QRTN-X-Gated uses the same quotient training but initialises original-node runtime state through a fixed, attenuated lift of the learned quotient state, without replay or original-graph gradient updates. These modes expose an auditable choice among persistent memory compression, strict parameter-only transfer, and state-initialised transfer. We provide a causal formulation, exact state accounting, and time-complexity bounds that distinguish node compression from event reduction. The accompanying evaluation protocol tests accuracy, inductive prediction, oversmoothing, cold-start behaviour, and end-to-end resource use across coarsening ratios.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
continuous-time dynamic graphs, temporal graph neural networks, graph coarsening, quotient graphs, temporal memory, coarse-to-fine transfer, link prediction, scalable graph learning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_Y98fOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents a Quotient-Residual decoupling of recurrent memory for memory-based Continuous-Time Dynamic Graph (CTDG) models. It proposes assigning a low-dimensional private residual memory to each individual node while storing a high-dimensional quotient memory on supernodes shared across clusters.

Using this design, the authors introduce the QRTN-M architecture. They further propose two transfer variants—QRTN-X and QRTN-X-Gated—designed to evaluate parameter transferability and the effect of initializing original-node states with coarsened quotient memory.

The paper demonstrates that QRTN-M achieves persistent state compression throughout training and deployment while maintaining predictive performance close to full-memory baselines like TGN.

Critical strengths

S1. Decoupled memory: The authors present a novel memory decoupling method that reduces the memory footprint of CTDG models. Instead of maintaining a full high-dimensional memory vector for each individual node, the model factorizes memory into a shared high-dimensional quotient state (dcd_c) and a low-dimensional private residual state (drd_r). The high-dimensional component is shared among nodes within a supernode cluster, while the private component remains node-specific. This paradigm substantially decreases the persistent memory storage required for node states across the graph. Notably, it retains 99.3% of the full-node AP while eliminating 83.0% of the required persistent storage.

S2. Fine-Tuning-Free Transfer and Diagnostic Insights: The proposed transfer variants, QRTN-X and QRTN-X-Gated, provide valuable insights into the distinct roles that accumulated historical memory and learned temporal operators play in predictive modeling. Specifically, they demonstrate how temporal update operators learned on a smaller, coarsened quotient graph can be transferred to operate directly on the full original graph without replaying training streams or performing original-graph fine-tuning.

Critical weaknesses

W1. Outdated Baselines and Limited Evaluation Metrics: The paper omits critical recent memory-based CTDG baselines, such as CTAN and PINT, leading to an incomplete assessment of QRTN's relative performance on the link-prediction task. Furthermore, hard negative sampling strategies such as historical and inductive negatives are reported exclusively for the Wikipedia dataset. These experiments thus do not provide reliable insights into model's predictive performance.

W2. Omission of Temporal Neighborhood Aggregation: The node embedding generation (zuz_u) omits explicit temporal neighborhood aggregation (e.g., GNN or attention layers over 1-hop dynamic neighbors), relying instead on supernode memories to infer structural and dynamic context. This represents a substantial shift in the memory-based CTDG paradigm. Consequently, it requires a thorough analysis of how the choice of clustering technique affects the model's ability to capture long-range dependencies. Specifically, whether deriving context from supernodes enhances or impairs this capability compared to gathering context from explicit temporal neighbors. Because the manuscript lacks both an explanation of how these clusters are maintained/updated for new nodes and comparative experiments evaluating "supernode context gathering" versus "temporal neighbor aggregation," a more rigorous study is needed.

(minor) W3. Readability: Typo in Eq. 5: it should be aj∈Ica_j \in I_c instead of j∈Icj \in I_c.

Questions for authors

Q1. What is the algorithm or mechanism used for clustering and for assigning new nodes to clusters?

Q2 Why does model performance for QRTN-X and gated increase for r→1r \to 1 while that of QRTN-M decrease as r→1r \to 1 for MOOC.

12 comments
AuthorsOpenReview ↗

On Weakness 1

We thank the reviewer for the evaluation and constructive feedback. We appreciate the recognition of our decoupled memory architecture, persistent-state compression, and fine-tuning-free transfer framework. We agree that comparisons with recent temporal graph models, a clearer explanation of temporal-neighborhood information, and further details on clustering and new-node assignment would strengthen the paper. We address these concerns below.

W1. Comparison with recent baselines and hard-negative evaluation

We thank the reviewer for suggesting comparisons with CTAN and PINT. To address this concern, we report results from their official implementations alongside QRTN on Wikipedia, Reddit, and LastFM.

Average Precision (AP, %):

MethodWikipediaRedditLastFM
PINT (Transductive)98.78 ± 0.1099.03 ± 0.0188.06 ± 0.70
PINT (Inductive)98.38 ± 0.0498.25 ± 0.0491.76 ± 0.70
QRTN-M97.41 ± 0.1296.98 ± 0.1976.93 ± 7.29
QRTN-X94.64 ± 0.6990.67 ± 0.3180.70 ± 1.55
QRTN-X-Gated96.32 ± 0.3893.78 ± 0.4778.32 ± 1.15

ROC-AUC (%):

MethodWikipediaRedditLastFM
CTAN97.55 ± 0.0998.61 ± 0.0483.81 ± 0.92
QRTN-M97.18 ± 0.1396.88 ± 0.1777.52 ± 5.83
QRTN-X94.26 ± 0.6091.32 ± 0.2679.31 ± 1.68
QRTN-X-Gated95.89 ± 0.4293.95 ± 0.4676.91 ± 1.39

These results show that CTAN and PINT achieve better predictive performance in several settings, particularly on LastFM, which is expected because QRTN addresses a different operating constraint: reducing the recurrent-state footprint while preserving original-node temporal link prediction without full-graph recovery training. At r=0.15r=0.15, QRTN-M uses only 17.0%–18.9% of the full-node recurrent-state memory on these three datasets. QRTN-X and QRTN-X-Gated further reduce quotient-training state to approximately 8.1%–10.3% of the full-node reference, although they restore original-node state at deployment. Notably, QRTN-M remains within 0.37 AUC percentage points of CTAN on Wikipedia and 1.73 points on Reddit despite computational efficiency.

Extension to historical and inductive negatives.

We agree that reporting hard-negative evaluations only on Wikipedia limits the conclusions. We therefore extended the evaluation to Reddit and MOOC. The following table reports test AP over three seeds, comparing QRTN-M against the 172-dimensional full-node control implemented in the same runtime, using identical chronological splits and stored negative samples.

DatasetNegative ProtocolFull-node APQRTN-M APQRTN-M State Ratio
WikipediaHistorical0.9366 ± 0.00360.9352 ± 0.00150.170
WikipediaInductive0.9789 ± 0.00250.9673 ± 0.00280.170
RedditHistorical0.8300 ± 0.00420.7049 ± 0.00270.189
RedditInductive0.9724 ± 0.00260.9401 ± 0.00530.189
MOOCHistorical0.8744 ± 0.01680.7348 ± 0.05270.192
MOOCInductive0.9395 ± 0.01160.9213 ± 0.01080.192

Under inductive negatives, QRTN-M retains 98.8%, 96.7%, and 98.1% of the full-node AP on Wikipedia, Reddit, and MOOC, respectively, while using only 17.0%–19.2% of its recurrent-state memory. Historical negatives reveal larger performance gaps on Reddit and MOOC, indicating that distinguishing previously observed interaction partners remains more challenging under compressed state ownership. These additional experiments provide a more complete assessment of the predictive information retained by QRTN-M under different negative-sampling protocols.

AuthorsOpenReview ↗

On Weakness 2 and 3

W2. Temporal-neighborhood aggregation and long-range dependencies

We thank the reviewer for this important observation. We agree that QRTN differs from conventional memory-based temporal graph models by not explicitly aggregating one-hop temporal neighbors through attention. Instead, QRTN obtains temporal context through event-driven shared quotient memory and node-specific recurrent residuals.

For each original node uu, the representation is

P_c m_{\pi(u)}(t) +P_r r_u(t) +P_\phi\phi(\Delta t_u) +P_x x_u \right),$$ where $m_{\pi(u)}(t)$ represents shared quotient memory, $r_u(t)$ is the node-specific residual, and $\phi(\Delta t_u)$ encodes elapsed time. Every observed interaction contributes a temporal message to the corresponding supernode. Consequently, the quotient state accumulates information from the interaction histories of multiple related nodes, providing shared structural and temporal context without explicitly retrieving a temporal neighborhood for each prediction. The two memory components serve complementary purposes. The quotient state captures shared temporal dynamics, while the private residual preserves endpoint-specific interaction history that would otherwise be lost through aggregation. This allows QRTN to retain original-node distinctions while keeping high-dimensional recurrent state at quotient resolution. We do not claim that quotient-based context is equivalent to explicit temporal-neighborhood attention or that it always captures the same structural dependencies. Rather, QRTN investigates whether compressed event-driven temporal context can retain competitive predictive performance with substantially lower persistent-state requirements. To evaluate this design choice, we compare QRTN-M against the official TGN implementation, which explicitly uses temporal-neighborhood attention. | Dataset | Official TGN AP | QRTN-M AP | QRTN-M State Ratio | |:---|---:|---:|---:| | Wikipedia | **0.9787 ± 0.0017** | 0.9741 ± 0.0012 | 0.170 | | Reddit | **0.9788 ± 0.0008** | 0.9698 ± 0.0019 | 0.189 | | MOOC | 0.8946 ± 0.0214 | **0.9207 ± 0.0093** | 0.192 | | LastFM | 0.6561 ± 0.0208 | **0.7693 ± 0.0729** | 0.189 | QRTN-M achieves AP within 0.0046 and 0.0090 of official TGN on Wikipedia and Reddit, respectively, and higher mean AP on MOOC and LastFM, while using only 17.0%–19.2% of the recurrent-state memory. These results indicate that explicit temporal-neighborhood attention is not essential for achieving competitive predictive performance on the evaluated datasets, although it may remain advantageous in settings requiring more detailed neighborhood information. **Long-range temporal dependencies.** We further evaluate QRTN-M on interactions whose endpoints are separated by at least three dynamic hops. On Wikipedia, AP decreases by 0.027 relative to direct-repeat interactions. This result indicates that QRTN-M retains predictive information on interactions beyond direct endpoint repetition, despite not using explicit temporal-neighborhood attention. We will clarify this distinction and the role of quotient-based temporal context in the revised manuscript. ### W3. Correction of Equation 5 We thank the reviewer for identifying the notation error in Equation 5. The sum is over event messages indexed by $j$, with weights $a_j$ for $j \in \mathcal{I}_c(B)$. The revision states the index explicitly. This does not affect the implementation or any reported result.
AuthorsOpenReview ↗

Addressing the Reviewer's Questions

Q1. Clustering mechanism and assignment of unseen nodes

We thank the reviewer for asking clarification of the clustering algorithm and the treatment of nodes that appear after training.

Clustering procedure. QRTN constructs the quotient partition using only the chronological training stream to prevent information leakage. The training interactions are divided into temporal windows, and nodes exhibiting related temporal interaction patterns are grouped using normalized interaction frequency and edge-feature similarity. Candidate clusters obtained across windows are subsequently consolidated until the target number of supernodes is reached, with

Nc=⌈rNtrain⌉.N_c=\lceil rN_{\mathrm{train}}\rceil.

For bipartite datasets, a role-preserving step prevents source and destination nodes from being merged into the same supernode. The resulting partition remains fixed throughout validation and test; no held-out interaction, label, or sampled negative is used to reconstruct the partition.

Assignment of unseen nodes. Nodes appearing for the first time during validation or test are assigned causally to existing supernodes. When informative node features are available, the assignment is made to the nearest compatible training-cluster centroid using cosine similarity. When informative features are unavailable, a deterministic hash-based assignment is used. The assignment does not depend on future interactions, and the node's private residual is initialized to zero before its interaction history begins to accumulate.

In QRTN-M, the newly appearing node retains its original identity through its private residual while accessing high-dimensional shared state through the assigned supernode. In contrast, QRTN-X and QRTN-X-Gated instantiate the learned temporal operators directly at original-node resolution after transfer and therefore do not require quotient routing during deployment.

We have clarified the clustering construction, role-preserving partitioning, and causal assignment of unseen nodes in the revised manuscript.

Q2. Different coarsening-ratio trends on MOOC

We thank the reviewer for highlighting the different behavior of QRTN-M and the transfer variants as r→1r\rightarrow1. We agree that this observation requires clarification because the three operating modes use quotient memory differently.

QRTN-M maintains shared quotient memory throughout training and deployment, whereas QRTN-X and QRTN-X-Gated train temporal operators at quotient resolution and subsequently deploy them at original-node resolution. Consequently, increasing rr changes the amount of state sharing in QRTN-M but also changes the training-to-deployment resolution mismatch in the transfer variants.

On MOOC, QRTN-M achieves 0.9207±0.00930.9207\pm0.0093 test AP at r=0.15r=0.15, decreasing to 0.83860.8386 at r=1r=1. In contrast, QRTN-X improves from 0.8030±0.02020.8030\pm0.0202 to 0.8589±0.01960.8589\pm0.0196, while QRTN-X-Gated improves from 0.8222±0.01510.8222\pm0.0151 to 0.8710±0.00780.8710\pm0.0078 over the same endpoints.

For QRTN-M, smaller coarsening ratios allow multiple related nodes to contribute messages to a shared high-dimensional state, while their private residuals are updated at original-event resolution. Increasing rr reduces this sharing, so the quotient channel receives information from fewer nodes while retaining its micro-block update schedule. On a temporally heterogeneous interaction stream such as MOOC, the stronger performance at smaller rr is consistent with shared-state aggregation providing useful contextual information and a possible regularizing effect.

For QRTN-X and QRTN-X-Gated, increasing rr brings the quotient-training resolution closer to the original-node resolution used during deployment. This reduces the degree of structural aggregation encountered during training and may reduce the mismatch between learned temporal operators and their deployment setting. QRTN-X-Gated additionally initializes original-node states through a fixed, attenuated lift of learned quotient memory, providing historical-state information without replay or fine-tuning.

These observations are consistent with the different state-ownership and update mechanisms of the operating modes, although they do not establish a universal causal relationship between rr and predictive performance. In particular, the observed decline of QRTN-M on MOOC should not be interpreted as a general trend across all datasets. We have clarified that the preferred coarsening ratio depends on the operating mode and dataset characteristics.

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

This paper proposes Quotient-Residual Temporal Network (QRTN), a fine-tuning-free framework that addresses the persistent cost of continuous-time dynamic graphs, where persistent node state and repeated temporal computation become bottlenecks. QRTN decouples event observation, recurrent-state ownership, and prediction. QRTN preserves every timestamped event by separating shared quotient dynamics from an identity-preserving residual. Consequently, it compresses the state domain, not the temporal evidence, providing three operating points (QRTN-M, QRTN-X, QRTN-X-Gated). Experiments test accuracy, inductive prediction, oversmoothing, cold-start behaviour, and end-to-end resource use across coarsening ratios.

Critical strengths

This paper gives an interesting perspective on graph coarsening for continuous-time models. It proves that compressing the state domain to save resources without compressing the actual temporal evidence is effective, avoiding the trap of retraining or fine-tuning on the full graph.

This paper conducts extensive experiments includes multiple datasets, coarsening ratios, inductive settings, negative sampling protocols, and resource measurements.

Critical weaknesses

One of the biggest problems is the inconsistencies in the experiments, and the efficiency claims need stronger proof. A few discrepancies in the paper: Tables 2 and 13 show different results for the same setup, and Section 4.3 conflicts with Appendix E regarding memory initialization. More importantly, to prove the efficiency claims, the paper needs baselines with a strict matched memory budget. It's unclear if this complex design is better than simply shrinking the memory size for all nodes, especially since the actual throughput drops in the large-scale experiments.

The paper argues that standard coarsening loses node-specific temporal details, but it doesn't provide concrete examples or explanation showing how this affects predictions. Thus, the proposed quotient-residual split isn't fully justified. While the ablation study shows that node information is important, it doesn't prove that this specific dual-memory architecture is the necessary and best way to handle it.

Questions for authors

For W1, please clarify the differences between Table 2 and Table 13, as well as the different memory setup for validation and test in Section 4.3 and Appendix E.

For W2, what proof shows that graph coarsening causes a harmful loss of node-level temporal info? And why is your proposed decomposition better than simpler alternatives?

How QRTN compares to a standard full-node model under the same memory budget using a smaller memory size.

7 comments
AuthorsOpenReview ↗

On Weakness 1

We thank the reviewer for the detailed and constructive assessment. We have carefully revisited the experimental configurations, evaluation protocol, and evidence supporting the quotient-residual decomposition. We acknowledge the two reporting ambiguities and clarify their causes, including a correction to the description of runtime-state initialization. More importantly, we provide two additional controlled evaluations directly addressing the reviewer's central concerns: (i) a same-supernode counterfactual experiment demonstrating the predictive information lost when node-specific temporal memory is removed, and (ii) a memory-matched comparison with reduced-width TGN across four datasets. Together with the existing five-seed residual ablation, these results provide stronger evidence for the proposed state-allocation mechanism. We address each concern below and will incorporate the corresponding clarifications and results into the revised manuscript.

W1. Clarification of experimental configurations and runtime-state initialization

We thank the reviewer for pointing out these ambiguities. We address both points below.

W1(a). Differences between Tables 2 and 13

We thank the reviewer for highlighting it. The differences arise because Tables 2 and 13 correspond to independently trained experimental configurations designed to investigate different aspects of QRTN.

Table 2 reports the main coarsening-ratio experiments using a fixed micro-block size of q=32q=32 and a learning rate of 10−310^{-3}. In contrast, Table 13 investigates the accuracy–throughput trade-off across micro-block sizes q∈1,8,32,128q\in{1,8,32,128}, with a fixed coarsening ratio of r=0.15r=0.15 and a learning rate of 10−410^{-4}. Therefore, although both tables contain results for r=0.15r=0.15 and q=32q=32, they correspond to independently trained models under different optimization settings, which explains the differences in their reported AP values.

Regarding the choice of learning rate, changing the micro-block size qq changes the frequency of quotient-state updates and the number of temporal interactions contributing to each aggregated update. This alters the optimization dynamics and the sensitivity of training to the learning rate. We therefore adopted a smaller, fixed learning rate of 10−410^{-4} for the micro-block sensitivity experiment, providing a common conservative optimization setting across all values of qq, rather than tuning the learning rate separately for each configuration.

Importantly, the objective of Table 13 is to examine how varying qq affects the accuracy–throughput trade-off under identical optimizer settings, whereas Table 2 evaluates predictive performance across coarsening ratios under the main benchmark configuration. Thus, the results within Table 13 remain comparable, although their absolute AP values need not match those in Table 2.

We acknowledge that this distinction was insufficiently explained in the original submission. We have clarified the learning-rate settings, experimental purposes, and comparison boundaries in the revised manuscript and the corresponding table captions.

W1(b). Validation and test memory initialization in QRTN-X.

We agree that the statement pointed out in Section 4.3 was ambiguous. Section 4.3 states that test continues from the selected validation state. This refers to the parameter checkpoint selected on validation, not to the runtime memory accumulated while processing validation events. The implemented protocol uses independently initialized original-node runtime memories for validation and test, consistent with Appendix E.

Specifically, after quotient training, QRTN-X transfers the learned parameters to a fresh, zero-initialized original-node runtime for validation. Validation is used for parameter checkpoint selection, after which the accumulated validation memory is discarded. Test evaluation then starts with a separately initialized, zero-state original-node runtime using the selected parameters. For QRTN-X-Gated, the same fixed, attenuated lift from the selected quotient training state is applied independently before validation and test. Thus, validation memory is never carried into test. Neither method replays the original training stream or performs original-graph fine-tuning.

We have corrected Section 4.3 and clarified the runtime-state initialization protocol in the revised manuscript to align it with Appendix E and the implementation. These clarifications do not change any reported experimental results.

AuthorsOpenReview ↗

On Weakness 2 (1/2)

W2. Loss of node-specific temporal information and necessity of the residual

W2(a). Why quotient-only coarsening loses node-specific temporal information.

When multiple original nodes are assigned to the same supernode, they share a single recurrent state. Consider two original nodes uu and vv with π(u)=π(v)\pi(u)=\pi(v), identical static features, and identical elapsed-time encodings. Without a private residual, their endpoint representations are identical. Consequently, for any candidate node ww with otherwise identical decoder inputs,

s(u,w,t)=s(v,w,t).s(u,w,t)=s(v,w,t).

This equality holds regardless of decoder capacity because the decoder receives identical representations. However, the two nodes may have different interaction histories. For example, uu may have interacted repeatedly with ww, while vv has never interacted with ww. A quotient-only recurrent state aggregates these histories and cannot separately identify their ownership under the stated conditions. Importantly, preserving every timestamped event does not eliminate this limitation: the events remain available, but their node-specific histories are combined into shared state. This is a representational limitation of quotient-only memory rather than an optimization failure.

W2(b). Why the private residual is necessary.

QRTN addresses this limitation by maintaining a high-dimensional shared quotient state mπ(u)(t)m_{\pi(u)}(t) together with a low-dimensional private residual ru(t)r_u(t), updated causally for each original node. The quotient state captures shared temporal dynamics, while the residual preserves endpoint-specific interaction information that would otherwise be lost through aggregation. Thus, nodes belonging to the same supernode can maintain distinct temporal representations.

Our existing five-seed Wikipedia ablation supports this distinction. Removing the private residual reduces test AP from 0.9700 ± 0.0017 to 0.8544 ± 0.0023, an absolute decrease of 0.1156. This indicates that the shared quotient state alone is insufficient to preserve the predictive information captured by the full decomposition.

To further isolate the information lost through quotient-only state ownership, we conducted an additional same-supernode counterfactual evaluation on Wikipedia. For each eligible positive test interaction (u,v,t)(u,v,t), we select a negative destination v−v^{-} satisfying three conditions: (i) v−v^{-} belongs to the same training-built quotient cluster as vv, (ii) uu has not interacted with v−v^{-} before time tt, and (iii) v−v^{-} is selected to be close to vv in prior activity and causal recency. The model must therefore distinguish

\qquad \pi(v)=\pi(v^{-}).$$ The training procedure, partition construction, and validation-based checkpoint selection remain unchanged, only the held-out negative construction differs. The evaluation covers 7,035 eligible interactions, corresponding to 29.8% of the 23,621 Wikipedia test events. The split boundaries are determined from the original stream of 157,474 interactions, while the smaller reported dataset total of 124,821 reflects the removal of training interactions involving inductive held-out nodes. | Dataset | Method | Seeds | Ordinary Test AP | Counterfactual AP | Counterfactual AUC | Eligible Events | Test Coverage | |:---|:---|---:|---:|---:|---:|---:|---:| | Wikipedia | QRTN-M | 3 | 0.9733 ± 0.0013 | **0.9397 ± 0.0202** | **0.9297 ± 0.0227** | 7,035 | 29.8% | | Wikipedia | Quotient-only | 3 | 0.8409 ± 0.0042 | 0.5000 ± 0.0000 | 0.5000 ± 0.0000 | 7,035 | 29.8% | The quotient-only model achieves chance-level AP and AUC on these counterfactual examples, whereas QRTN-M retains substantially higher predictive performance. Unlike the ordinary residual ablation, this evaluation specifically tests candidate destinations that share the same quotient state. The results therefore provide direct evidence that shared quotient memory alone is insufficient to distinguish their node-specific temporal histories, while the private residual preserves useful endpoint-specific information.
AuthorsOpenReview ↗

On Weakness 2 (2/2) & Comparison with a memory-matched full-node TGN

W2(c). Comparison with simpler alternatives.

A quotient-only model reduces memory but cannot separately represent different interaction histories within a supernode under the conditions described above. Static node identifiers or learned identity embeddings can distinguish nodes, but do not themselves maintain causally updated interaction histories. Conversely, assigning a full high-dimensional recurrent state to every original node restores the O(Nd)O(Nd) memory cost that coarsening aims to reduce. QRTN instead keeps high-dimensional temporal dynamics on supernodes while maintaining only a small, causally updated residual for each original node.

Together, the representational argument, residual ablation, and counterfactual evaluation support a more specific conclusion than simply observing that node information matters. Within the proposed shared-memory architecture, a node-private temporal signal is needed to preserve distinct interaction histories, and QRTN provides this signal through a low-dimensional causal residual without restoring full-dimensional recurrent memory at every node.

Comparison with a memory-matched full-node TGN

We thank the reviewer for suggesting this comparison. We agree that evaluating QRTN-M only against a full-capacity TGN does not establish whether the proposed memory allocation is more effective than simply reducing the per-node memory dimension.

To address this concern, we conducted additional experiments using the official TGN implementation with reduced per-node memory dimensions, matching the total persistent recurrent-state budget of QRTN-M at r=0.15r=0.15. Specifically, TGN uses 28-dimensional memory on Wikipedia and 32-dimensional memory on Reddit, MOOC, and LastFM. All other TGN components, including temporal-neighborhood attention, remain unchanged. Both methods use the same splits and identical stored evaluation negatives. The state ratios are calculated relative to the 172-dimensional full-node TGN reference, and results are reported as mean ± standard deviation over three seeds.

DatasetQRTN-M APQRTN-M State RatioMatched TGNTGN APTGN State Ratio
Wikipedia0.9741 ± 0.00120.170TGN-280.9697 ± 0.00230.168
Reddit0.9698 ± 0.00190.189TGN-320.9733 ± 0.00040.191
MOOC0.9207 ± 0.00930.192TGN-320.8255 ± 0.07320.191
LastFM0.7693 ± 0.07290.189TGN-320.7562 ± 0.00920.191

The results show that QRTN-M achieves higher mean AP on three of the four datasets under nearly identical recurrent-state memory budgets, while memory-matched TGN performs comparable on Reddit.

These results provide additional evidence that the benefit of QRTN-M is not solely due to reducing recurrent-memory dimensions. Rather than uniformly shrinking the state maintained by every node, QRTN-M allocates high-dimensional memory to shared quotient dynamics while retaining a small node-specific residual. At comparable persistent-state budgets, this allocation achieves better mean predictive performance on three datasets and remains competitive on the fourth. Thus, the additional comparison supports the proposed quotient–residual decomposition as a favorable, although dataset-dependent, accuracy–memory trade-off. We will include these memory-matched TGN results and clarify this distinction in the revised manuscript.

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

The paper proposes Quotient-Residual Temporal Networks (QRTN) to reduce the memory required by continuous-time graph models. Instead of maintaining a large independent state for every node, it stores a large shared state for each group of nodes and a small private residual for each individual node. It studies three variants:

  • QRTN-M: maintains compressed shared-plus-private memory throughout training and deployment.
  • QRTN-X: trains on grouped nodes, then transfers parameters to original-node execution without replay or fine-tuning.
  • QRTN-X-Gated: additionally initializes original-node states using the learned group states. The strongest result is QRTN-M: it uses approximately 17–19% of the recurrent-state memory of the 172-dimensional TGN reference, while achieving similar model performance or even better performance.
Critical strengths

A clear and useful architectural idea. Separating shared dynamics from individual history offers a plausible way to reduce redundant storage while retaining node-specific information. QRTN-M achieves substantial state compression without deleting events or requiring full-graph recovery training.

Critical weaknesses

The evaluation does not sufficiently establish the proposed method’s accuracy–memory advantage. It lacks comparisons with TGN using smaller, memory-matched node states, while the large-scale experiment reports memory consumption and processing throughput without predictive accuracy.

Questions for authors

How does QRTN-M compare with TGN using smaller per-node memory dimensions under the same total recurrent-state memory budget? Does QRTN achieve a better accuracy–memory trade-off?

Can you report predictive accuracy on the large tgbl-coin experiment alongside memory consumption and throughput? Do the substantial memory savings preserve prediction quality?

How does the “full-node 172d control” differ architecturally from official TGN?

3 comments

We thank the reviewer for the insightful comments. We respond to the concerns below.

1. Accuracy–memory trade-off: QRTN-M vs. memory-matched TGN

We thank the reviewer for this important suggestion. We agree that comparing QRTN-M only against the full-capacity 172-dimensional TGN does not establish whether its accuracy–memory trade-off arises from the proposed quotient–residual decomposition or simply from using less recurrent memory. To address this concern, we conducted additional experiments with the official TGN implementation under a matched persistent recurrent-state memory budget.

Specifically, we reduce TGN's per-node memory dimension to 28 on Wikipedia and 32 on Reddit, MOOC, and LastFM, matching the total recurrent-state budget of QRTN-M at r=0.5r = 0.5. All other TGN components, including temporal-neighborhood attention, remain unchanged. Both methods use the same data splits and identical stored evaluation negatives. The state ratios are calculated relative to the 172-dimensional full-node TGN reference, following the memory accounting in our paper. Results are reported as mean ±\pm standard deviation over three seeds.

DatasetQRTN-M APState RatioMatched TGNTGN APState Ratio
Wikipedia0.9741 ± 0.00120.170TGN-280.9697 ± 0.00230.168
Reddit0.9698 ± 0.00190.189TGN-320.9733 ± 0.00040.191
MOOC0.9207 ± 0.00930.192TGN-320.8255 ± 0.07320.191
LastFM0.7693 ± 0.07290.189TGN-320.7562 ± 0.00920.191

The results show that QRTN-M achieves higher mean AP on three of the four datasets under nearly identical recurrent-state memory budgets, while memory-matched TGN performs slightly better on Reddit.

These results provide additional evidence that the benefit of QRTN-M is not solely due to reducing memory dimensions. Rather than uniformly shrinking the state maintained by every node, QRTN-M allocates high-dimensional memory to shared quotient dynamics while retaining a small node-specific residual. At comparable persistent-state budgets, this allocation achieves better mean predictive performance on three datasets and remains competitive on the fourth. Thus, this supports the proposed quotient–residual decomposition as a favorable, although dataset-dependent, accuracy–memory trade-off. We will include these memory-matched TGN results and clarify this distinction in the revised manuscript.

2. Predictive accuracy on tgbl-coin

We thank the reviewer for raising this important concern. We report held-out accuracy on the 100,000-event tgbl-coin prefix using the official TGB held-out evaluator and the official TGB negatives, with Test MRR as the official metric. All results are mean ± standard deviation over three seeds, using two epochs and batch size 8,192. All methods use the same prefix, evaluator, and negative protocol.

MethodTest MRRTraining stateState per nodeTrain ev/s per GB state
QRTN-M0.4865 ± 0.011346.1 MB72.3 B/node22,412
QRTN-X-Gated0.4745 ± 0.015846.1 MB72.3 B/node22,123
Full-node 172d0.4397 ± 0.0056441.8 MB692.0 B/node3,278

QRTN-M reaches 0.4865 ± 0.0113 Test MRR, compared with 0.4397 ± 0.0056 for the full-node 172d control. The gain comes with a much smaller training state: 46.1 MB instead of 441.8 MB, and 72.3 B per node instead of 692.0 B, a reduction of about 9.6×.

QRTN-M reaches 22,412 events/s per GB of state, compared with 3,278 for the full-node control, an advantage of about 6.8×. The full-node control carries 9.6× more state; per unit of state, QRTN-M is substantially more efficient. QRTN-X-Gated is close on both measures: 0.4745 ± 0.0158 Test MRR and 22,123 events/s per GB.

These results address the large-scale question directly. On this 100,000-event prefix, reducing persistent state does not cost predictive quality: QRTN-M is more accurate than the full-node 172d control while using about one tenth of the state per node.

3. Architectural distinction between the full-node 172d control and official TGN

We thank the reviewer for pointing out the need to clarify this distinction. The full-node 172d control is not the official TGN implementation. It is an internal baseline implemented within the QRTN framework, where the quotient-based shared memory is disabled and each original node maintains an independent 172-dimensional recurrent state. The time encoder, edge encoder, decoder, event-processing engine, and training procedure remain the same as in QRTN. This control is intended to isolate the effect of recurrent-state allocation while keeping the remaining implementation fixed.

In contrast, official TGN is a separate architecture that maintains recurrent memory for every original node and explicitly incorporates temporal-neighborhood information through attention-based aggregation. We therefore use the full-node 172d control for implementation-matched comparisons and official TGN as an external architectural baseline. To make this distinction clear, we report the comparison with official TGN below, using the same splits and stored evaluation negatives.

DatasetOfficial TGN-172 APQRTN-M APQRTN-M State Ratio
Wikipedia0.9787 ± 0.00170.9741 ± 0.00120.170
Reddit0.9788 ± 0.00080.9698 ± 0.00190.189
MOOC0.8946 ± 0.02140.9207 ± 0.00930.192
LastFM0.6561 ± 0.02080.7693 ± 0.07290.189

The results show that QRTN-M remains competitive with the full-memory official TGN while using only 17.0%–19.2% of its persistent recurrent-state memory. It achieves slightly lower AP on Wikipedia and Reddit, with absolute differences of 0.0046 and 0.0090, respectively, while obtaining higher mean AP on MOOC and LastFM. Together with the memory-matched TGN comparisons discussed above, these results indicate that QRTN-M can substantially reduce persistent recurrent-state requirements while retaining competitive predictive performance. We will clarify the architectural distinction between the two baselines in the revised manuscript.

Thank you for your time and thoughtful consideration. We have provided detailed responses and additional experimental evidence to thoroughly address all the points raised in your review.

Please let us know if any substantive concerns remain, as we would be glad to offer further clarification.

If you feel these concerns have been adequately resolved, we kindly ask that you consider raising your overall rating.

Comments on the paper

3 comments

Summary of discussion and revision

We thank all reviewers for their careful reading, constructive feedback, and engagement throughout the discussion. We added targeted controls, clarified the protocol, and strengthened the empirical evidence for the three QRTN operating points.

Reviewer L4RK

  • Memory-matched comparison: We added an official-TGN control with reduced per-node recurrent memory that matches QRTN-M's persistent-state budget. TGN retains temporal-neighborhood attention and its other components. QRTN-M has higher mean AP on Wikipedia, MOOC, and LastFM at matched state budgets, and remains close on Reddit. This directly tests whether QRTN-M's performance is attributable merely to shrinking all node memories uniformly.

  • Large-scale predictive accuracy: We reported held-out tgbl-coin evaluation using official negatives. QRTN-M obtains 0.4865 ± 0.0113 Test MRR versus 0.4397 ± 0.0056 for the full-node control, while using substantially less training state. QRTN-X-Gated obtains 0.4745 ± 0.0158 Test MRR.

  • Baseline definition: We clarified that the full-node 172d control is an implementation-matched QRTN-runtime control with the quotient channel disabled, whereas official TGN is a separate attention-based architecture. The former isolates state ownership under a shared implementation; the latter is an external full-node baseline.

Reviewer G7dy

  • Table settings and learning rates: We clarified that the primary coarsening-ratio suite and the controlled micro-block suite are independent training suites. The primary suite uses fixed q=32 and learning rate 10^-3; the micro-block suite fixes r=0.15, varies q∈{1,8,32,128}, and uses 10^-4 throughout. Their absolute AP values are therefore not duplicate measurements of the same configuration.

  • Initialization protocol: We clarified the wording in Section 4.3 making it more clear and less ambiguous to the reader. Validation selects a parameter checkpoint only. QRTN-X begins validation and test from independently initialized zero original-node state, while QRTN-X-Gated independently reapplies its fixed lift. Validation runtime state never warm-starts test.

  • Why quotient-only state loses information: We added the structural argument that when two original nodes share a quotient state and have identical non-private inputs, a quotient-only model cannot distinguish their endpoint-specific temporal histories. Retaining every event does not make shared state invertible because different nodes' histories are accumulated in the same recurrent channel.

  • Why the residual is needed: The existing five-seed Wikipedia ablation shows that removing the private residual reduces AP from 0.9700 ± 0.0017 to 0.8544 ± 0.0023. We also added a within-supernode temporal counterfactual evaluation, where the true and alternative endpoint share the same quotient context. Across 7,035 eligible Wikipedia test events, QRTN-M reaches 0.9397 ± 0.0202 counterfactual AP and 0.9297 ± 0.0227 AUC, whereas quotient-only is exactly at chance, 0.5000 AP/AUC.

  • Comparison with simpler alternatives: Static identifiers can distinguish nodes but do not store causally evolving interaction histories. Giving every node high-dimensional recurrent memory restores the full-node cost. QRTN instead combines shared high-dimensional quotient dynamics with a lightweight event-wise private residual.

Reviewer Y98f

  • Recent baseline context: We supplied CTAN and PINT results as external context with their protocol boundaries.

  • Historical and inductive negatives: We extended hard-negative evaluation to Reddit and MOOC. Under inductive negatives, QRTN-M retains 98.8%, 96.7%, and 98.1% of full-node AP on Wikipedia, Reddit, and MOOC, respectively, at 17.0%–19.2% of the full-node recurrent-state footprint. Historical negatives are reported as well, including the more difficult Reddit and MOOC cases.

  • Temporal neighborhood aggregation: We clarified that QRTN does not claim quotient context is equivalent to explicit one-hop temporal attention. It instead combines event-driven shared quotient memory with a private residual. We compare QRTN-M with official TGN, which uses temporal-neighborhood attention, and report a dynamic-hop analysis on Wikipedia. QRTN-M's AP decreases by only 0.027 between direct-repeat interactions and interactions separated by at least three dynamic hops.

  • Clustering and new nodes: We specify the training-only, role-preserving partition construction and the routing rule for nodes absent from training: nearest compatible centroid when informative features are available, otherwise a deterministic hash. The unseen private residual begins at zero. QRTN-X instantiates learned operators directly on original nodes and therefore does not require quotient routing after transfer.

  • MOOC trends near r=1: We explain that QRTN-M retains micro-block quotient updates while its private residual updates after every event. Near r=1, quotient states contain fewer nodes but still update once per block. QRTN-X and QRTN-X-Gated instead deploy event-wise original-node states, so increasing r reduces their training-to-deployment resolution gap. The large variance at r=1 does not support a universal monotone claim.

  • Equation 5: We corrected the index and weight notation.

  • Causality and the deployment setting: QRTN targets historical-training/future-deployment. It learns parameters and one fixed compression structure from a completed historical interaction period, then predicts continually arriving later events without access to future deployment events. The partition is not claimed to be prefix-causal at every timestamp inside the completed historical corpus, because it is a learned historical preprocessing object, analogous to learned model parameters. This stronger requirement is not needed for the intended setting.

    Runtime temporal computation remains causal: each event is scored before it updates private or quotient state, and quotient updates preserve chronological micro-block order. The fixed partition does not preload future event information into runtime state. After the historical cutoff, later deployment events cannot revise the partition or affect earlier deployment predictions. Thus, two alternative future deployment streams that share the same past through time t receive identical QRTN predictions through t.

  • Event-wise causal audit: We audited the exact chronological QRTN-M schedule across all four datasets. Across 4,368,728 checked state reads, the audit found zero timestamp-order violations, dependency-layer violations, private-state future reads, or quotient-state future reads. The reviewer subsequently indicated that the causality clarification resolved the concern and revised the score.

Overall, the added controls, analyses, and protocol clarifications support the intended claim: QRTN reduces expensive recurrent-state ownership while retaining competitive original-node temporal prediction, without deleting events, replaying the original training stream, or requiring original-graph fine-tuning.

AuthorsOpenReview ↗

Changes in the revised manuscript

For clarity, the revised manuscript incorporates the following substantive additions and protocol clarifications, as per the reviewers ' literary and experimental suggestions.

  • QRTN-X validation and test initialization. Section 4.3 and Appendix E now state the same protocol: validation selects the parameter checkpoint only; QRTN-X starts validation and test from independently initialized zero original-node runtimes; and QRTN-X-Gated reapplies its fixed state lift independently before each held-out stream. Validation runtime state never warm-starts test.

  • Primary versus micro-block experimental suites. Table 2 now identifies the primary coarsening-ratio experiment and states that all its runs use learning rate 10^-3. The micro-block paragraph and Appendix J table now identify the controlled micro-block suite as a separate training experiment, with all points using learning rate 10^-4.

  • Definition of the full-node control. The internal baseline is consistently labelled Full-node 172d control. The revised manuscript states that it is implemented in the QRTN runtime with the quotient channel disabled, while official TGN is a separate implementation reported in Appendix F.

  • Memory-matched full-node TGN control. The revised manuscript adds a four-dataset, three-seed comparison with reduced-width official TGN at essentially the same recurrent-state budget as QRTN-M. TGN uses width 28 on Wikipedia and 32 on Reddit, MOOC, and LastFM. QRTN-M has higher mean AP on Wikipedia, MOOC, and LastFM, and is close on Reddit. The complete control is reported in its own appendix section and table.

  • Within-supernode temporal counterfactual. The revised manuscript adds a diagnostic in which the true and alternative endpoint share the same quotient cluster, while the alternative has no earlier source interaction and is matched by activity and causal recency. Across 7,035 eligible Wikipedia test events, QRTN-M obtains 0.9397 ± 0.0202 AP and 0.9297 ± 0.0227 AUC, whereas quotient-only is at chance, 0.5000 AP/AUC. The construction and complete results are reported in a dedicated appendix section and table.

  • Partition routing for nodes absent from training. Section 3.2 and Appendix B now state the complete rule. A node absent from training is assigned to the nearest compatible centroid when informative features are available, otherwise by deterministic hash. Candidate negatives are routed before the corresponding positive is revealed; evaluation data cannot modify the fixed partition; the unseen private residual starts at zero; and QRTN-X does not require quotient routing after transfer.

  • MOOC behavior near r=1. The revised manuscript explains that QRTN-M retains event-wise private-residual updates but aggregates quotient updates by micro-block. Near r=1, each quotient state receives fewer messages per block while remaining block-updated. QRTN-X and QRTN-X-Gated instead deploy event-wise original-node states, so larger r reduces their training-to-deployment resolution gap. The text explicitly states that the large variance at r=1 does not support a universal monotone trend.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.