Learning to Compute Is Not Learning to Retain or Reuse in Looped Transformers
Looped transformers apply one shared block repeatedly, letting inference depth exceed training depth. This paper asks whether computing an answer at the recurrent frontier guarantees that the model will retain it or that its hidden state can be frozen and reused. Using in-context Mealy-machine execution with exact symbolic targets, the authors show that exact computation, strong retention, and state reusability are three distinct properties: training on a single randomly sampled position per example yields near-perfect retention, yet freezing states when answers first appear collapses accuracy until a short delay passes.
The paper makes a sharp conceptual point with well-designed causal interventions, but its scope is deliberately narrow. The evidence cleanly dissociates exact symbolic computation at the frontier $r=k$ from later retention and from state reusability, though the authors acknowledge that the synthetic Mealy-machine setup, small model size, and limited external validation leave open how these properties interact in larger recurrent language models. The central thesis—that learning to compute is not learning to retain or reuse—is convincingly demonstrated within the studied regime.
The hidden-state swap experiments are the strongest evidence: replacing one frontier vector $h_c^r$ with the vector from a different input prefix causes every later position to follow the source's exact symbolic continuation in all 237/237 eligible pairs across ten models. This establishes causal sufficiency, not just correlation. Equally striking, sampling one supervised position per example achieves 99.8% endpoint accuracy at loop 64, showing that a simple change in supervision coverage can solve retention without dense per-position labels.
The primary concern is limited external validity. The task is a synthetic Mealy-machine simulation with horizon $H \leq 32$ and no positional or loop embeddings, which may produce dynamics unlike natural tasks. The progressive-training negative result is explicitly an adaptation, not a reproduction of the original convolutional architecture, so it should not be read as a broad critique of gradient truncation. The freezing failures admit multiple interpretations: the authors note that evolving hidden states may carry timing or order information, and their tests do not separate these possibilities from pure symbolic state encoding. Replication is thin in places—three seeds for the main training comparisons and overlapping checkpoints that are not independent. Finally, full-vector interventions do not reveal whether the state is a unique symbolic code or merely sufficient in context.
Within the paper's controlled setting, the evidence supports the causal claims. The comparison of final-only, all-prefix, and sampled-prefix holds architecture, optimizer, and exit constant, isolating supervision coverage as the driver of retention. The gradient-truncation experiment is less controlled: matched random exit and progressive share forward work but differ in backward work, and the authors note that neither comparison matches measured total FLOPs. References to overthinking and path-independence literature are accurate and appropriately modest—the authors frame their contribution as measurement rather than new training algorithms. A single external maze check from Bansal et al. is included, but related work in language-model recurrence is cited without direct experimental comparison.
The experimental protocol is documented in unusual depth. Appendix A gives machine generation rules, the exact 35-stage curriculum, network dimensions, and optimization hyperparameters. Appendix B reports every per-seed score for the main comparisons, and Appendix B.8 records checkpoint hashes, evaluation stream seeds, and pair identities. Independent reproduction would still face hurdles: the procedural generator state must be reproduced exactly, intervention pairings are protocol-intensive, and no public code repository is mentioned in the main text. The architecture is small—two layers, width 128—so compute requirements are modest, but exact replication depends on following the specific pairing and cohort structures described across multiple appendices.
Looped transformers compute by applying one block repeatedly, so they can run for more loops than they were trained with. Recurrent reasoners are known to overthink: iterating past the trained depth can turn a correct answer into a wrong one. Such a late error can reflect failed computation, loss of retention, or a state that later computation cannot reuse. We separate these cases in in-context Mealy-machine execution, where a simulator supplies intermediate targets and exact counterfactuals for hidden-state interventions. Models trained to answer at loop 32 are fully correct there but keep only 22% of these answers at loop 64. Retention depends on what training asks for: supervising one randomly chosen position per example, instead of always the last, keeps 99.8%, and randomizing the number of training loops also helps; truncating gradients, as in progressive training against overthinking, does not. The computation itself is exact: position $k$ is computed at loop $k$, and swapping its loop-$k$ hidden vector for the one from another input redirects every later position to that input's exact continuation (237/237 pairs in each of ten models). Retention, however, is not reuse. Even in models that keep nearly all answers, holding each position $k$ fixed from loop $k$ drops accuracy to 4--6%, whereas holding it from loop $k+4$ is harmless. A released recurrent maze network trained to avoid overthinking behaves the same way. Learning to compute is thus not learning to retain, and avoiding overthinking does not make a state reusable when its answer first appears.
Pick a starting point or write your own. Challenges run in the background, so you can keep reading while the AI investigates.
No challenges yet. Disagree with the review? Ask the AI to revisit a specific claim.