{"id":"9aa65f79-3d5c-4f9d-80cd-4e29e5ae900f","arxiv_id":"2412.21046","paper_version":1,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"low","formal_verification":"none","parameter_count":7,"one_line_summary":"Truncated backpropagation through time prevents graph recurrent networks from learning multi-hop temporal dependencies, causing large performance gaps on dynamic graph benchmarks.","lead":"Graph recurrent neural networks trained on continuous-time dynamic graphs usually truncate backpropagation at batch boundaries, which limits their ability to learn dependencies that span more than one hop. This paper measures this 'truncation gap' on a new synthetic task and on two of three real-world datasets, and argues for new training methods beyond backpropagation.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Real-world truncation gap may be confounded by TGN-style parallel batching; the synthetic task alone isolates truncation.","rationale":"The reader's weakest assumption is exactly the interaction between the TGN parallel-batching approximation and backward-path length. I agree this is the most load-bearing issue. The synthetic task is strong and not affected by this confound; the central mechanism is established there. But the paper's definition of the truncation gap as solely caused by truncation (Section 1) is broader than what the real-world experiment can support, because F-BPTT in Section 4 is full BPTT of an approximate forward model, not of the true sequential GRNN. This does not invalidate the paper's core claim about truncation limiting multi-hop learning; it limits the strength of the real-world attribution. A single control experiment with exact sequential batching would settle the matter. Given the synthetic result and the self-reported Wikipedia caveat, the reader's ACCEPT remains appropriate; no verdict change is needed.","tokens_in":11426,"tokens_out":9652,"duration_ms":101516,"concrete_test":"Re-run the MOOC comparison from Section 4 using exact sequential batching (Deep CoEvolve-style, left panel of Figure 2) instead of TGN parallel batching, keeping the same GRU, optimizer, and random-search protocol; if the F-BPTT-over-T-BPTT MRR gap persists, the concern is resolved, and if it collapses, the real-world truncation gap is an artifact of the parallel-batching approximation interacting with truncated gradients.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The synthetic experiment (Section 3) cleanly isolates truncation because events are processed sequentially and T-BPTT truncates after one edge update. The load-bearing weakness is the real-world comparison (Section 4): both T-BPTT and F-BPTT use the TGN-style parallel batching of Rossi et al. (2020), which ignores within-batch event order and aggregates simultaneous updates (Section 2.2). F-BPTT is therefore exact backpropagation for the approximate parallel-batched forward graph, not for the true sequential GRNN. The paper defines the truncation gap as 'solely caused by the truncated backpropagation' (Section 1), but this attribution requires that the parallel-batching approximation does not interact with backward-path length. It plausibly does: with T-BPTT the memory-aggregation parameters receive gradients only from the current batch, while F-BPTT also trains them on losses from later batches. The Reddit/MOOC improvements (18.1%, 22.2%) could therefore partly reflect better optimization of the approximate aggregation rather than recovery of long temporal dependencies. Because only the synthetic task controls for this interaction, the real-world evidence does not by itself establish that the gap is solely truncation-driven.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper studies the impact of truncated backpropagation-through-time (T-BPTT) on graph recurrent neural networks (GRNNs) trained on continuous-time dynamic graphs. It introduces a synthetic edge-regression task with a memory parameter M, and shows that while full BPTT (F-BPTT) solves the task for all tested M, T-BPTT (with a one-edge truncation horizon) degrades sharply for M > 1. The paper then compares T-BPTT and F-BPTT on the Reddit, Wikipedia, and MOOC benchmarks using the TGN-style parallel batching strategy, reporting a performance gap on Reddit and MOOC. The authors call this gap the 'truncation gap', argue that current training approaches underuse GRNN capacity, and discuss alternatives such as low-rank approximations to real-time recurrent learning.","tokens_in":11675,"tokens_out":18183,"duration_ms":168022,"significance":"The paper addresses a genuinely under-examined issue in training recurrent models on dynamic graphs, and the synthetic task is a valuable controlled benchmark: the forward pass, batching, optimizer, and number of parameter updates are identical across conditions, so the failure of T-BPTT for M > 1 is cleanly attributable to the backward-pass truncation. The real-world results are practically relevant, with F-BPTT improving MRR by 18.1% on Reddit and 22.2% on MOOC over T-BPTT. The manuscript also ships code for the synthetic benchmark, which is a reusable resource. The main weakness is that the real-world comparison uses TGN-style parallel batching, so the measured real-world gap may partly reflect an interaction between truncation and the batching approximation; this limits the strength of the 'solely caused by truncated backpropagation' claim in the real-world setting, although the synthetic experiment stands on its own.","major_comments":[{"comment":"The real-world experiments hold the forward pass fixed between conditions, but that forward pass is itself an approximation because it uses TGN-style parallel batching (Section 2.2), which ignores within-batch event order and aggregates simultaneous updates. Consequently, F-BPTT is exact backpropagation only for the approximate parallel-batched forward graph, not for the true sequential GRNN. The observed improvements on Reddit and MOOC could therefore reflect, at least in part, F-BPTT better optimizing the memory-aggregation parameters under the parallel-batching approximation, rather than recovering true multi-hop temporal dependencies. Because only the synthetic task controls for the interaction between truncation and batching, the real-world evidence does not by itself establish that the gap is solely truncation-driven in the sense of temporal dependency length. Please either qualify the 'solely caused' claim in Section 1, or add a sequential-batching comparison on at least one smaller dataset to show that the gap persists when the forward pass is exact.","section":"Section 4 ('We train the GRNN model with both truncated and full BPTT...') and Section 1"}],"minor_comments":[{"comment":"Reddit results are reported for a single seed and without error bars; the paper should either provide a measure of variance or explicitly state that the Reddit numbers are a single-run observation, so that the 18.1% improvement is not overinterpreted.","section":"Section 4, Table 2"},{"comment":"It is not fully explicit whether the model's prediction for an edge is computed from the pre-update or post-update hidden states; Figure 3 suggests the former, but Equation (1) is written as an update. Please clarify this detail for reproducibility.","section":"Section 3.1"},{"comment":"The text refers to 'Figure 2.2' twice; these references should be to Figure 2.","section":"Section 2.2"},{"comment":"The word 'backpropragation' is a typo for 'backpropagation'.","section":"Section 3, first sentence"},{"comment":"The caption begins with 'T runcated'; this should read 'Truncated'.","section":"Table 2 caption"}],"recommendation":"major_revision","confidential_remarks":null},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"First thing to know: the paper's core claim is true, and the synthetic task is the reason. With a one-hop truncation horizon, a GRU cannot learn dependencies that span more than one edge; full BPTT solves the same task cleanly across all memory sizes tested. That is a controlled, reproducible demonstration, and the synthetic task code is public. The real-world experiments on Reddit, Wikipedia, and MOOC are a reasonable adjunct, but they do not isolate truncation as cleanly as the paper sometimes implies.\n\nWhat is new: the synthetic buffer task is a useful benchmark, and the paper is right that none of the earlier GRNN works (Dai et al., Trivedi et al., Kumar et al., Rossi et al.) discussed the effect of BPTT truncation on learning. The comparison design is careful: same forward pass, batching, optimizer, and number of parameter updates in both conditions, so the difference in the synthetic setting is attributable to the backward pass. Credit also for reporting the Wikipedia MRR null result instead of hiding it.\n\nSoft spots, in proportion. The word 'solely' in the definition of the truncation gap (Section 1) is overreach. In the real-world comparison, both conditions use the TGN-style parallel batching from Rossi et al. (Section 2.2). F-BPTT is exact backpropagation for that approximate parallel-batched forward graph, not for the true sequential GRNN. The measured 18-22% MRR improvements on Reddit and MOOC could therefore partly reflect better training of the approximate aggregation rather than recovery of long temporal dependencies. The synthetic task controls for this; the real-world experiments do not. The single seed on Reddit and the non-significant negative MRR on Wikipedia further weaken the real-world leg, though the authors report these limitations honestly. Missing real-world code is a minor reproducibility gap; only the synthetic code is public.\n\nWho this is for: anyone training GRNNs for temporal link prediction, and people building dynamic-graph benchmarks. The synthetic task is reusable as a stress test for new training methods. The discussion of RTRL-style alternatives is speculative but clearly labeled as such.\n\nRecommendation: this deserves a serious referee. The central argument survives because of the synthetic task. A referee would want the 'solely' attribution toned down and ideally a real-world condition that also controls for the batching interaction, but that is revision material, not a rejection. Engage with it.","headline":"The synthetic task makes the core point convincingly; the real-world gap is real but the attribution to truncation alone is shakier than the paper claims.","tokens_in":12229,"tokens_out":3164,"would_cite":true,"duration_ms":27787,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Full backprop beats truncated training on dynamic graphs by up to 22%.","keywords":["continuous-time dynamic graphs","graph recurrent neural networks","backpropagation through time","truncation gap","temporal dependencies","real-time recurrent learning","dynamic graph benchmarks","recurrent architectures"],"falsifier":"Train T-BPTT on the synthetic task with a truncation horizon equal to $M$ (for example by grouping batches around each node so that $M+1$ of that node's events are in the same batch). If T-BPTT then solves the task for $M>1$, the gap is a matter of insufficient horizon rather than a fundamental gradient-estimation failure; if it does not, the gap involves more than truncation. On the real benchmarks, a comparable check is to vary batch size while holding the forward pass fixed; if MRR does not rise with longer backward paths, the within-batch forward approximation, not the truncation, is the dominant error.","tokens_in":11202,"feed_emoji":"⏳","tokens_out":9875,"duration_ms":85732,"temperature":0.7,"pith_summary":"This paper argues that graph recurrent neural networks (GRNNs), the standard recurrent approach to continuous-time dynamic graphs, are trained with a truncated form of backpropagation-through-time that limits what they can learn about the past. On a new synthetic edge-regression task with a tunable memory parameter $M$, models trained with full BPTT (F-BPTT) reach near-zero error for every $M$, while truncated BPTT (T-BPTT) fails as soon as the task requires memory beyond a single interaction hop. On real-world benchmarks, switching from T-BPTT to F-BPTT improves Mean Reciprocal Rank by 18.1% on Reddit and 22.2% on MOOC, the gap the authors call the 'truncation gap.' Because full BPTT is too memory-hungry for large graphs, the finding implies that current training pipelines leave GRNN capacity on the table and motivates non-backpropagation training schemes.","feed_headline":"Full backprop beats truncated training on dynamic graphs by up to 22%","feed_subtitle":"The truncation gap: when gradients stop at batch boundaries, graph models forget dependencies older than one interaction.","key_machinery":"The central object is the GRNN edge update (Equation 1), where each event updates the hidden states of both endpoints with a recurrent cell. The argument runs through the difference between the forward computational graph and the backward graph: T-BPTT computes gradients only within a time-windowed batch, whereas F-BPTT propagates through the entire history of the epoch. In the synthetic task, each node keeps a FIFO buffer of length $M$, and the target for an edge depends on the buffer's last element from both endpoints, so learning requires backpropagating through at least $M$ interaction events; truncating to a single hop makes the gradient signal vanish once a dependency spans more than one interaction.","core_discovery":"The central discovery is that the truncation horizon of the backward pass, not the recurrent architecture itself, is the binding constraint on learning temporal dependencies in dynamic graphs. With identical forward computation, batching, optimizer, and number of gradient steps, F-BPTT solves the synthetic task at every tested memory value $M\\in\\{1,\\dots,5\\}$ while T-BPTT collapses for $M>1$; on Reddit and MOOC, F-BPTT outperforms T-BPTT by 18.1% and 22.2% in MRR respectively. The authors attribute this 'truncation gap' to the fact that dynamic-graph batching defines batches over global time windows, so gradients cannot cross batch boundaries and each node effectively receives credit only for dependencies within a single event update.","pith_inferences":["The truncation problem should generalize to any recurrent model trained on one global time-ordered sequence that cannot be segmented into independent examples, including continuous-time models for medical records, sensor streams, and financial transaction networks.","A directly testable extension on the real datasets is to vary the backward-pass horizon by changing batch size while holding the forward pass identical; if MRR does not improve monotonically with horizon, then the parallel within-batch approximation, not truncation, causes the gap.","Because the paper strips out time encoding and attention-based embeddings, the results leave open whether those components can mask part of the truncation gap; ablating them on the same benchmarks would clarify how much of the gap is architectural versus purely due to training signal."],"forward_implications":["Published GRNN benchmark results on dynamic graphs likely understate the achievable performance of recurrent architectures when trained with full-history gradients.","Training schemes that approximate real-time recurrent learning, or otherwise lengthen the backward horizon without storing the full history, are a direct route to closing the truncation gap on memory-constrained hardware.","Batch-size choices in GRNN training involve a trade-off between parallelism and truncation depth; the results imply that larger batches do not recover the lost cross-batch gradient signal.","The synthetic task (released as a benchmark) gives future methods a concrete pass/fail: a method that closes the gap must learn the task for $M>1$ without full BPTT."],"supporting_citations":[{"why":"Defines the fixed-size parallel batching strategy and the recurrent-memory update used in the experiments.","marker":"Rossi et al., 2020"},{"why":"Introduces the t-Batching scheme that guarantees single-hop truncation and provides the Reddit, Wikipedia, and MOOC datasets plus the ranking evaluation.","marker":"Kumar et al., 2019"},{"why":"Exemplifies sequential batch training where the computation graph per batch restricts gradient propagation; the paper positions truncation against this baseline.","marker":"Dai et al., 2017"},{"why":"Supplies the adding task used as inspiration for the synthetic edge-regression benchmark and the LSTM cell used as the recurrent unit.","marker":"Hochreiter & Schmidhuber, 1997"},{"why":"Proposes unbiased online recurrent optimization, the approach the paper suggests for learning long-range dependencies without full BPTT.","marker":"Tallec & Ollivier, 2017"}],"fun_headline_variants":["Truncated backprop misses long-range dependencies in dynamic graphs","BPTT truncation gap: dynamic graph models skip multi-hop dependencies","Truncation gap costs up to 22% on dynamic graph tasks","Full backprop beats truncated on dynamic graphs by 22%"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the measured gap is caused solely by the truncated backward pass, because forward computation, batching, optimizer, and gradient-step counts are identical across conditions; if the parallel within-batch approximation of inconsistent histories or the simplified GRU-only architecture interacts with backward-path length, part of the gap would not be attributable to truncation.","fun_headline_variants_meta":{"raw":{"variants":["Truncated backprop misses long-range dependencies in dynamic graphs","BPTT truncation gap: dynamic graph models skip multi-hop dependencies","Truncation gap costs up to 22% on dynamic graph tasks","Full backprop beats truncated on dynamic graphs by 22%"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000752,"raw_usage":{"total_tokens":3341,"prompt_tokens":933,"completion_tokens":2408,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":549,"completion_tokens_details":{"reasoning_tokens":2333}},"tokens_in":549,"tokens_out":2408,"duration_ms":18360,"temperature":1.0,"reasoning_tokens":2333,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T23:06:05.410504+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Train T-BPTT on the synthetic task with a truncation horizon equal to $M$ (for example by grouping batches around each node so that $M+1$ of that node's events are in the same batch). If T-BPTT then solves the task for $M>1$, the gap is a matter of insufficient horizon rather than a fundamental gradient-estimation failure; if it does not, the gap involves more than truncation. On the real benchmarks, a comparable check is to vary batch size while holding the forward pass fixed; if MRR does not rise with longer backward paths, the within-batch forward approximation, not the truncation, is the dominant error.","supporting_citations":[],"review_version":1}