PaperlayerView exact revision on arXiv

Source-linked AI summary

Think Shallow, Solve Deep: Controlling Recurrent Dynamics for Reliable Test-Time Depth

Ivan Viakhirev, Kirill Borodin, Amirah Almutairi, Serguei Barannikov, Maxim Abramov, Grach Mkrtchian

arXiv:2608.18222v1cs.LGcs.CL

TL;DR

The paper asks when extra test-time iterations preserve or improve performance rather than degrade it. It measures recurrent operators’ finite-time dynamical regimes and shows that settling operators are depth-safe, with some converting additional depth into higher accuracy on harder instances.

  • Problem

    The paper studies when increasing a recurrent reasoner’s test-time iteration budget preserves competence or converts it into accuracy on harder, out-of-distribution instances.

  • Method

    It measures whether trained operators settle, remain marginal, or drift, and analyzes fixed-point training as a mechanism for controlling these regimes and depth safety.

  • Results

    Settling operators are depth-safe and can convert added depth into accuracy, including Sudoku performance rising from 0.19 to 0.34, while marginal and drifting operators may remain flat, collapse, or decay.

  • Takeaways & Limitations

    Whether additional test-time depth helps is a measurable property of the learned dynamics, with depth-safety provable at small displacement but conversion remaining empirical and task-dependent.

  • Takeaways & Limitations

    The study uses tiny models and synthetic tasks, and producing a settling operator is not guaranteed across tasks.

Abstract

from arXiv · show

Recurrent-depth reasoners aim to solve harder problems by iterating their update longer at test time, but additional iterations can improve, preserve, or degrade an answer. We show that a measurable property of the trained operator, its finite-time dynamical regime (estimated as settling, marginal, or drifting), indicates which of these occurs. We give a sufficient condition for depth-safety: once an operator's per-step displacement is small relative to the decoder margin, the decoded answer cannot change under further iterations. Empirically, on algorithmic tasks trained from $800$ unaugmented examples per difficulty tier, settling operators do not degrade with added depth, and on some tasks convert it into higher accuracy on harder unseen instances (Sudoku, $0.19$ to $0.34$ past the training horizon). A single terminal fixed-point objective moves the regime and the depth behavior together: removing it induces drift and removes the gains, and adding it to a generic recurrence yields depth-safe extrapolation on carry propagation. We give four operational criteria for useful test-time depth, use them to catalogue failure modes, and, as a consistency check, apply the same measurements to Huginn-3.5B, which falls in the non-settling family.

1 Introduction

The paper makes finite-time dynamical regime the basis for understanding and controlling recurrent-depth reasoning. Settling operators predict safe or beneficial extra iterations, while marginal or drifting operators can fail, and a terminal fixed-point objective changes both regime and depth behavior.

  • 1 Introduction: Finite-time dynamics—settling, marginal, or drifting—predict whether iterating a recurrent reasoner longer helps, preserves, or harms its answer.The study measures the regime of every trained operator and intervenes on it directly.
  • 1 Introduction: 800 unaugmented examples per tier expose regime-dependent depth behavior: settling operators convert Sudoku from 0.19 to 0.34 or hold reachability at 0.92, while marginal and drifting operators can decay.Which architecture settles is task-dependent, and a terminal objective switches the regime in both directions.
  • 1 Introduction: Depth-safety follows when a settling operator’s per-step displacement is small relative to the decoder margin, while adaptive-stabilization time remains bounded by a proposition.The paper operationalizes useful test-time depth through four measurable criteria and logs spectral, dynamical, information-flow, and topological signals.
  • 1 Introduction: Across the campaign, settling operators are depth-safe and sometimes convert additional depth, whereas marginal and drifting operators fail one or both through four measurable failure modes.Spectral and topological signatures agree run-by-run.
  • 1 Introduction: Removing the terminal fixed-point objective turns settling into drift and removes conversion or safety; adding it to an alternative recurrence produces both, while Huginn-3.5B is non-settling.A label-free objective derived from the same taxonomy repairs Huginn’s depth behavior.

2 Related Work

The paper situates recurrent-depth reasoning within work on tiny recurrent cores, latent recurrence, iterated-map dynamics, adaptive halting, delayed generalization, and topology of latent trajectories. It distinguishes its inference-map criteria from related approaches that stabilize dynamics or study training-loss geometry.

  • Recurrent-depth reasoners: TRM and HRM solve hard puzzles with tiny recurrent cores but rely on approximately 1000× augmentation, while Huginn-3.5B scales latent recurrence to 3.5B.Input recall, easy-to-hard iteration, and constraint-graph message passing provide additional recipe components.
  • Dynamics of iterated maps in deep learning: Dynamical-isometry, deep-equilibrium, and non-normal-transient theories provide map-level foundations for analyzing iterated dynamics in deep learning.Path independence correlates with upward generalization in equilibrium models and requires weight tying and input injection.
  • Delayed generalization and progress measures: Delayed-generalization studies track gradual circuit formation with hidden progress measures and competition from cheaper memorizing circuits, motivating the paper’s algorithm-versus-coverage question for inference maps.The paper reports which quantities behave as progress measures in Sec. 6.2.
  • Trajectory topology and task difficulty: Persistent-homology and topology-divergence work asks whether latent trajectories loop, drift, or settle; this paper tests three hypotheses at campaign scale.Figure 1 contrasts larger graphs, where transfer fails, with deeper same-size instances, where settling models generalize and plateau.

3 Setup and Methodology

The methodology studies weight-tied recurrent reasoners on fixed-input-size difficulty ladders, separating extra algorithmic rounds from input-size extrapolation. It evaluates exact-match or validity-based correctness across test-time depths and characterizes trained operators using spectral, dynamical, information-flow, and topological signals.

  • Research question: The study asks whether increasing test-time iterations beyond training preserves competence and improves accuracy on harder unseen instances.Reasoners are trained as weight-tied iterated maps z_t+1 = f_θ(z_t, x) for T_train steps, then evaluated with h_c > T_train.
  • Experimental design: All extrapolation claims use fixed-input-size ladders, where harder instances require more algorithmic rounds rather than invariance to changing input size.The ladders vary difficulty through oracle-round counts while holding input size fixed; size/length ladders serve a separate purpose.
  • Experimental design: The primary tasks are Sudoku, 16-node reachability, and interleaved 2×32-bit addition, with maze and sorting as boundary probes.Difficulty spans Sudoku hole fraction 0.2 → 0.7, BFS depth 2 → 12, and longest carry run 2 → 28; training uses 800 unique unaugmented examples per tier.
  • Evaluation protocol: Evaluation reports exact-match accuracy on the first unseen tier at training depth and best test-time depth, while Sudoku additionally uses validity-based correctness and reference match.For Sudoku, the uniquely-solvable fraction is 1.00/0.91/0.50/0.06/0.00, and unseen-hard validity versus reference accuracy is 0.34 vs. 0.062.
  • Evaluation protocol: Models train for 16 recurrent steps and are evaluated at h_c ∈ {3, 16, 32, 64, 128} to measure the effect of thinking longer.Training uses deep supervision, AdamW, gradient clipping 0.5, batch 64, 4–8k steps, and d=256; the study compares mechanisms rather than checkpoints.
  • Operator diagnostics: Held-out runs measure spectral, dynamical, information-flow, and topological signals of the trained operator.Signals include step-Jacobian σmax and ρ, finite-time Lyapunov quantities, fixed-point residual and settle ratio, correct-answer logit-lens rank, and topological summaries.

4 The Recipe, Mechanistically

The recipe makes recurrent updates algorithmic by preserving input information, matching computation to the constraint graph, and training answers as fixed points. Additional stabilizers target solution-family selection and seed stability, with each component justified by measured ablations.

  • Input recall: Input reinjection prevents an input-insensitive identity solution and makes the fixed point strongly input-dependent.Removing extra injection yields σmax = 1.0000 and EM 0.00.
  • Structured message passing: Structured message passing aligns computation with task constraints, but settling alone is insufficient: the no-structure arm contracts hardest and still scores 0.00.The step mixes states along rows, columns, boxes, or task-appropriate neighborhoods.
  • Fixed-point objective: The fixed-point objective penalizes final-update displacement at the supervised horizon, teaching the map to make its answer a fixed point.The residual is ∥zT − zT−1∥ = aT∥f(zT−1, x) − zT−1∥, scaled by the learned update gate.
  • Remaining stabilizers: Orthogonal initialization leaves accuracy unchanged (0.34 vs. 0.34) while selecting a different solution family, with weight stable rank ≈70–89 vs. 20–30.The passage reports these effects as measured scope for remaining stabilizers.
  • Remaining stabilizers: Adaptive update magnitude and gradient clipping buy seed stability, reducing extrapolation s.d. from 0.023 to 0.001 and variation from ±0.13 to ±0.01.These stabilizers are claimed only for what they measurably buy.

5 Why Some Networks Learn Recursion, and Some Do Not

Useful test-time recursion is identified behaviorally by passing four criteria: extrapolation, adaptive computation, incremental answer formation, and depth-safety. Across tasks, these behaviors coincide with settling dynamics, while fixed-point training causally preserves safe depth and its removal produces drift or other measurable failures.

  • Operational criteria: A model must satisfy four behavioral criteria: extrapolate by iteration, adapt computation to difficulty, form answers incrementally, and remain correct under further iterations.The criteria are behavioral diagnostics, not proof that a particular algorithm was learned.
  • Sudoku evidence: 0.34/0.11 accuracy on unseen Sudoku tiers 3/4 follows 0.00 shallow and 0.19 training-depth accuracy, while solve steps rise 2.8 →19.6 and all eight leading exponents are negative.Rank decreases 0.33→0.05, supporting incremental computation and strong-form depth-safety.
  • Failure modes: Failure modes are measurable: no-recall identity has σmax=1.0000 and EM 0.00, generic marginal dynamics yield flat or declining curves, drift has λmax=+0.10, and settle-but-wrong reaches an incorrect fixed point.The paper concludes that learning recursion means passing R1–R4, typically with settling but strongly non-normal dynamics.
  • Causal intervention: Removing the terminal fixed-point objective changes both regime and depth behavior: Sudoku conversion falls 0.34→0.03, while reachability safety drops by up to 0.37 EM despite a 0.97 peak.The settling recipe maintains reachability at 0.92→0.92.
  • Depth-safety: Among 164 competent runs, none of 17 settling runs loses more than 0.004 EM with depth, versus losses above 0.1 for 30% of marginal and 22% of drifting runs.Observed losses reach 0.98 for Neural GPU on mazes.

6 The Shape of Learned Recursion

Learned recursive algorithms are distinguished by structured spectral anisotropy and within-settle separation, not convergence alone. Topology supports settle/drift classes and contraction limits counting, while winding is unsupported and transient amplification is not the controlling lever.

  • Topology: Topology supports ubiquitous, causally separable settle/drift classes and the claim that purely contracting maps cannot count, but finds no loops or winding-depth tracking.Solvers move radially, with 99th-percentile winding of 0.71 turn.
  • Spectral control: Successful operators are strongly non-normal, with σmax/ρ ≈4–5.4, but σmax reflects transient amplification rather than asymptotic rate.Forcing typical gain to expand (τ≥2) drives σmax to 14–33 and destroys training; regularizing ρ helps at scale.
  • Spectral anisotropy: CoRe on Sudoku has Lyapunov spread λ1−λ8=0.41, whereas failure modes have eight nearly identical exponents, distinguishing algorithms from mere convergence.Failures include spectra pinned at zero, +0.02, or −0.17.
  • Spectral anisotropy: 0.846 AUC: Lyapunov-spectrum spread predicts extrapolation across 304 runs, while within-settle separation—not a universal threshold—provides the useful signal.Training accuracy is comparable at 0.851, and reachability extrapolators settle at spreads 0.07–0.14.
  • Diagnostic regularities: 0.872 AUC (p=10−3): within settling, spread separates algorithmic learners from merely settled runs, including settled, flat, wrong TRM-trained ARC models.All eight estimated leading exponents are negative in a recursion learner; live spectra and post-hoc geometry correlate at r=0.75.

7 Recurrence at Scale

At scale, Huginn-3.5B exhibits marginal, guess-freezing recurrence that gains nothing from added depth and can catastrophically degrade accuracy. A label-free latent-anchoring LoRA repair targets depth-safety without labels, while open chain-of-thought models show analogous overthinking failures.

  • Taxonomy at scale: Huginn-3.5B is normalized-marginal: none of 2,585 per-token trajectories across 7 task categories settles, and answer freezing does not track difficulty.The measured regime is σeff=1.000±0.003; freezing is classified as guess-freezing rather than computation completing.
  • Taxonomy at scale: By R1–R4, Huginn-3.5B gains nothing from added depth, with answer freezing failing to indicate completed computation.Layer normalization pins only the radial direction, not the read displacement, while the answer freezes independently of difficulty.
  • Depth pathology: 0.69 at r=8 versus 0.00 for r≥32 on carry probes shows Huginn-3.5B’s depth is unsafe, with every input freezing onto the same wrong token.A settling event evades answer-stability halting; a 30-example depth calibration recovers the shallow peak but requires labels and task-specific depth.
  • Label-free repair: A rank-16 LoRA adapter uses a label-free objective to pull states sampled at r∼U[16, 128] toward the frozen base’s shallow state at r=8.Training uses two synthetic anchor domains for 2,000 steps; the fixed-point term does not transfer directly, only its latent-anchoring form.
  • Comparison with chain-of-thought: 0.82 →0.00 for a distilled reasoner and 1.0 →0.47 for a non-reasoning model show that open chain-of-thought models can degrade when given more thinking depth.The shared failure shape is overthinking, not identical mechanism, and latent recurrence uniquely exposes a state handle for depth control.

8 Limitations

The study’s extrapolation evidence is limited by synthetic task generation, controlled but non-guaranteed regime discovery, and tiny models. Its conclusions therefore apply most directly to the tested generators and operators obtained under this protocol.

  • Synthetic generators: Sudoku extrapolation is demonstrated on boards from one construction’s symmetry orbit, limiting the headline claim to that generator.A matching reachability plateau indicates the claim does not depend solely on Sudoku’s scoring.
  • Controlled protocol: Budget-matched re-implementations estimate no ceiling, helping isolate dynamical regime effects from tuning confounds.However, producing a settling operator is not guaranteed; on mazes, it occurs through a seed lottery.
  • Small scale: The models are tiny, limiting the scale at which these findings have been evaluated.

9 Conclusion

Learned recursion is a dynamical property: operators can settle in task-aligned attractors, and added depth is useful when those dynamics support it. Depth-safety is provable at small displacement, while conversion remains empirical and task-dependent, including at 3.5B scale.

  • Dynamics: Learned recursion is a dynamical property: non-normal operators settle in attractors shaped by the objective and aligned with the task.The conclusion characterizes failures as four measurable modes.
  • Depth-safety: Depth-safety is provable when per-step displacement is small, but conversion to better performance remains empirical and task-dependent.The passage explicitly distinguishes the provable safety result from the empirical conversion result.
  • Transfer: At 3.5B scale, the same measurements and prescribed repair indicate that whether added depth helps is a measurable property of the dynamics.The conclusion states that these measurements and the repair carry to 3.5B.

Supplementary Material … G Huginn-3.5B: measurement details

The supplementary material formalizes when recurrent trajectories become answer-safe, distinguishes transient computation from asymptotic contraction, and documents regime, topology, estimator, ablation, and Huginn-3.5B measurements. Across these analyses, settling dynamics support depth conversion without overthinking, while drift and non-normality explain distinct failure modes and measurement limits.

  • A Propositions and proofs: Geometric decay yields an explicit freeze time: if δ_u≤Cγ^u with γ<1, the decoded answer is frozen once the remaining path falls below the decision margin.The freeze time increases with transient scale and inverse margin, with leading heuristic t⋆∼|λ|^-1 log(1/(|λ|µ)).
  • A Propositions and proofs: Trajectory statistics are regime-conditional: settling freeze times reflect instance geometry, whereas level-set entry times in the other branch do not, and neither guarantees correctness.The supplementary remark explicitly separates informativeness from success.
  • B Analysis populations (run-flow): The analyses use distinct corpora and treat each trained checkpoint as one run, while tiers, depths, and trajectory files are repeated observations; the aggregate regime figure contains 164 competent original-ladder runs.This accounting explains why depth-safety counts can differ across campaigns without implying inconsistency.
  • B.1 Regime-to-outcome aggregate view: Settling runs have higher median depth conversion and no overthinking tail, while marginal and drifting runs show overthinking damage; pooled conversion remains task-dependent and not cluster-significant.The figure is descriptive of the corpus rather than a pooled significance claim.
  • C The Sudoku ablation landscape in two instruments: Across Sudoku ablations, learners are anisotropic and failure families are flat; CoRe crystallizes the correct-answer rank near 0, generic recurrences bounce, and the identity ablation is frozen.These observations come from Lyapunov spectra and hardest-tier logit-lens measurements.
  • D Trajectory-topology hypotheses: full statements: Topology tests find settling and drifting but no loops, reject winding as a depth signature, and support computation in a thin expanding subspace within an operator that contracts on average.Loops have median total H1 persistence 0.000, while |winding|>1 occurs in only 0.08% of 2,585 Huginn-3.5B token trajectories.
  • E Non-normality account and estimator scope: full statements: Successful operators are strongly non-normal: σmax/ρ≈4–5.4 and σmax≈4–5, so clamping transient amplification removes computation, whereas constraining ρ leaves asymptotic contraction intact.The account concerns transient feedforward amplification from one linearization, not asymptotic growth.

H Repairing depth-safety at scale: protocol, transfer laws, negative arms · I Weak-form R4: the full natural experiment · J The fixed-point objective’s gate does not cheat

Depth-contract repair can prevent recurrent models from collapsing at greater test-time depth, but transfer depends on valid, semantically aligned anchors and does not create new peak competence. The natural experiment further distinguishes weak latent convergence from strict settling, while the fixed-point objective does not achieve its effect by simply closing the update gate.

  • H Repairing depth-safety at scale: protocol, transfer laws, negative arms: The base model peaks at task-dependent shallow recurrence and then collapses to one input-independent wrong token, making answer-agreement halting ineffective.Carry changes from 0.31 at r=4 to 0.00 at r≥32, while copy is dead from r=4 and letter-repeat falls from 0.56 to 0.00.
  • H Repairing depth-safety at scale: protocol, transfer laws, negative arms: A single answer-position depth-contract loss repairs held-out depth behavior without task labels: digit-copy reaches 1.00±0.00 at r=128, while letter-repeat reaches 0.51±0.13.The adapter is trained over r∼U[16, 128] against a teacher at t∗=8.
  • H Repairing depth-safety at scale: protocol, transfer laws, negative arms: Transfer follows the anchor’s operation across symbol alphabets: pluralization restores digit copying to 0.98±0.00 and letter copying to 0.89±0.08, whereas carrier cross-tests are diagonal.Input dependence appears in 6/6 seeds for the pluralization anchor.
  • H Repairing depth-safety at scale: protocol, transfer laws, negative arms: Two measurable failure laws constrain repair: invalid anchors poison the mix, and near-duplicate anchors with contrary semantics cause mirror interference.A 30-example base scan of each candidate anchor gates anchor validity before training.
  • H Repairing depth-safety at scale: protocol, transfer laws, negative arms: Repair never exceeds the base model’s peak competence, and the depth-hard pointer-chase task remains at chance under both adapter and full-core tuning.The fixed-point loss also fails to transfer to this scale, merely freezing an already-frozen loop when trained alongside the task.
  • H Repairing depth-safety at scale: protocol, transfer laws, negative arms: Prediction entropy provides a label-free seed selector: the 11-domain variant keeps 9/10 seeds on copy with mean 0.90, while the two-anchor recipe needs no selection.The selector removes the degenerate seed using a top-class fraction threshold of ≥0.85.
  • I Weak-form R4: the full natural experiment: Strict R2 halting tracks deterministic carry length nearly one-to-one, while fixed-point recipes retain nonzero terminal updates and difficulty-adaptive solve steps rather than closing the gate.For 16-round carry chains, halting occurs at 14.5–15.1 solve steps; identity mode has flat-at-2.0 solve steps.

K Objective interventions: dose, matched control, beyond-horizon … R Reproducibility details

The paper shows that fixed-point objectives can move recurrent operators into settling regimes, but useful depth still depends on avoiding over-contraction and task-specific failure modes. It supplements these interventions with dynamical diagnostics, confidence prediction, deterministic data generation, and reproducibility protocols.

  • K Objective interventions: dose, matched control, beyond-horizon: The matched answer-stabilization control fails to reproduce the latent objective’s payoff: Sudoku extrapolates to 0.00, while reachability suffers 0.99–1.00 overthinking damage.The latent never settles in the control; on reachability, its unseen-tier peak matches the recipe before additional depth destroys performance.
  • K Objective interventions: dose, matched control, beyond-horizon: 0.005 eliminates depth damage in carry propagation, while weights 0.05–0.2 saturate conversion near 0.88.At weight 0 the operator drifts, with damage 0.87–0.93 and conversion 0.09–0.14; conversion appears at 0.02 and saturates at 0.05–0.2.
  • K Objective interventions: dose, matched control, beyond-horizon: 0.32–0.41 Sudoku extrapolation occurs at weights 0.01 and 0.05, but weight 1.0 produces zero extrapolation despite perfect training accuracy.The paper identifies settling as necessary but insufficient: the useful target is the slowest rate that still settles.
  • L Failure-mode portraits: The failure portraits distinguish identity, marginal, drift, and settle-but-wrong modes, including 0.00 identity accuracy and drift damage from 0.33 to 0.04.Identity converges to “do nothing”; marginal operators wander; drift harms extra-depth performance; and some strongly contracting systems settle on incorrect computations.
  • M Practitioner’s dashboard: A practitioner dashboard maps diagnostics to interventions: recall addresses identity, fixed-point objectives structure steps, and negative leading exponents with monotone rank decline signal depth-safe improvement.The dashboard also warns that drift will hurt at test time and that inductive bias or limited augmentation is not a substitute for dynamics control.
  • N Corpus regularities: full statements: Settling correlates with trajectory geometry (r=0.75; Spearman ρ=0.69), while extrapolating runs have λmax median −0.047 versus +0.009 and Kaplan–Yorke dimension 0 versus 8.Topology and formation analyses support these regularities but caution that stable-rank prediction has AUC 0.774 with arm confounding, and anisotropy is not a per-run guarantee.
  • P Per-instance confidence read-out: The per-instance logistic read-out predicts correctness with cross-validated AUC 0.80 on Sudoku, 0.91 on reachability, and 0.98 on size-Sudoku.It uses settling ratio, effective dimension, path length, winding, and Koopman magnitude, with grouped cross-validation over runs.
  • Q Data generation: The experiments use deterministic, oracle-verified fixed-size ladders, 800 unique unaugmented examples per tier, three seeds, and test-time depths hc ∈{3, 16, 32, 64, 128}.The reproducibility package includes generators, materialized splits, exact configurations, measurement code, logs, and table/figure regeneration scripts; protocols were committed before runs.
Loading 2608.18222v1…