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

> Test-time depth in recurrent networks only helps when the trained operator settles toward a fixed point, a regime controllable via a single fixed-point training objective.

- **Source:** [arXiv](https://arxiv.org/abs/2608.18222)
- **Published:** 2026-10-24
- **Permalink:** https://picx.dev/p/mfcn0D
- **Whiteboard:** https://picx.dev/p/mfcn0D/image

## Summary

# Summary of "Think Shallow, Solve Deep: Controlling Recurrent Dynamics for Reliable Test-Time Depth"

## Summary (Overview)

- **Core finding**: The paper demonstrates that the usefulness of test-time depth in recurrent neural networks is determined by the *finite-time dynamical regime* of the trained operator—whether it settles toward a fixed point, remains marginal, or drifts. This regime can be measured and controlled.

- **Key contribution**: The authors provide four operational criteria (R1–R4) for "useful test-time depth" and prove a sufficient condition for depth-safety: when per-step displacement is small relative to the decoder margin, the decoded answer cannot change under further iterations (Proposition 1).

- **Causal intervention**: A single training objective term—the terminal fixed-point objective—switches the dynamical regime and depth behavior together. Removing it turns settling operators into drifting ones (destroying conversion or safety), while adding it to a generic recurrence produces depth-safe extrapolation.

- **Empirical results**: On algorithmic tasks trained from only 800 unaugmented examples per difficulty tier, settling operators convert added depth into higher accuracy on harder unseen instances (Sudoku: 0.19→0.34), while marginal and drifting operators fail to do so.

- **Scale transfer**: The same measurements applied to Huginn-3.5B place it in the non-settling family, and a label-free latent-anchoring objective repairs its depth-safety (digit copying 0.00→1.00) without installing conversion.

---

## Introduction and Theoretical Foundation

### Background and Motivation

Recurrent-depth reasoners—networks that apply the same block repeatedly to "think longer" on harder inputs—are an increasingly popular approach for enabling small models to reason. However, the paper identifies a critical gap: **architectures with loops are trained without ensuring the loop behaves like an algorithm**. Added iterations do not reliably improve accuracy on harder instances.

Key motivating examples:
- **Tiny Recursive Model (TRM)**: Solves Sudoku only after ~1000-fold augmentation (without it, scores 0.00)
- **HRM**: Similarly depends on heavy augmentation
- **Huginn-3.5B**: Extra recurrence yields only marginal gains that quickly plateau

### Theoretical Foundation

A recurrent reasoner is formalized as an iterated map:

$$z_{t+1} = f(z_t, x)$$

Whether iterating longer helps is a property of the map's finite-time dynamics: whether the state settles toward an input-dependent fixed point, stays marginal, or diverges. The paper makes this dynamical regime the object of study.

### Key Theoretical Result: Proposition 1 (Stabilization Dichotomy)

Let $\delta_t = \|z_{t+1} - z_t\|$ be the per-step displacement, let the decision margin $\mu(z_t)$ be the largest $r$ with the decoder $g$ constant on the open ball $B(z_t, r)$, and let $R_t = \sum_{u>t} \delta_u$ be the remaining path length.

**(a)** If $R_t < \mu(z_t)$, then $g(z_s) = g(z_t)$ for all $s \geq t$.

*Proof sketch*: For any $s \geq t$, the triangle inequality gives:

$$\|z_s - z_t\| \leq \sum_{u=t}^{s-1} \delta_u \leq R_t < \mu(z_t)$$

so $z_s$ lies in the margin ball of $z_t$ and $g(z_s) = g(z_t)$ uniformly in $s$.

**(b)** If $R_t = \infty$, no finite window of answer-constancy certifies the next step; this can occur even when $\delta_u \to 0$.

*Proof*: The map $f(z) = z - (c, 0, \ldots)$ with $g = \text{sign}(z^{(1)})$ and generic $c, D$ has $\delta_t = c > 0$, so $R_t = \infty$, yet the answer holds for $\lfloor D/c \rfloor$ steps and then flips, with $D$ arbitrary.

---

## Methodology

### Problem Setup

A weight-tied reasoner is an iterated map $z_{t+1} = f_\theta(z_t, x)$ trained for $T_{\text{train}}$ iterations on a fixed distribution of easier instances. The paper asks: when does increasing test-time iteration budget $h_c > T_{\text{train}}$ (i) preserve acquired competence and (ii) convert into accuracy on harder, out-of-distribution instances?

### Tasks and Difficulty Ladders

Three fixed-input-size ladders with deterministic oracle-round counts:

| Task | Input Size | Difficulty Axis | Training Tiers |
|------|-----------|-----------------|----------------|
| Sudoku | 9×9 | Hole fraction 0.2–0.7 | 0.2/0.35/0.5 |
| Reachability | 16 nodes | BFS depth 2–12 | Easy depths only |
| Addition | 2×32 bits | Longest carry run 2→28 | Short carries only |

### Training Protocol

- 16 recurrent steps with deep supervision (4 supervised unrolls)
- AdamW, gradient clipping 0.5, batch 64, 4–8k steps, $d = 256$
- 800 unique unaugmented examples per tier
- Test-time depth sweep: $h_c \in \{3, 16, 32, 64, 128\}$

### Architectures Compared

Seven architectures re-implemented at matched size and budget: TRM-style, UT/URM, FPRM, EqR, DEQ, Neural GPU, SE-RRM. Plus the controlled-recurrence recipe (CoRe).

### The Measurement Toolkit

Five families of signals logged for every run:

1. **Spectral**: step-Jacobian $\sigma_{\text{max}}$, $\rho$, Henrici non-normality, random-probe gain
2. **Dynamical**: top-8 finite-time Lyapunov spectrum via Benettin QR, $\sigma_{\text{eff}} = \exp(\lambda_{\text{max}})$, Kaplan–Yorke dimension, fixed-point residual, settle ratio
3. **Information-flow**: logit-lens rank of the correct answer
4. **Topological**: Ripser Betti bars, winding, effective dimension
5. **Training-time ranks**

**Regime labels**: settle ($\lambda_{\text{max}} < -0.05$), marginal ($|\lambda_{\text{max}}| \leq 0.05$), drift ($\lambda_{\text{max}} > 0.05$)

### The CoRe Recipe Components

1. **Input recall**: Reinject the input before each update (removal collapses to identity: $\sigma_{\text{max}} = 1.0000$, EM 0.00)
2. **Structured message passing**: Computation graph matches constraint graph
3. **Fixed-point objective**: Penalize displacement of final update:

$$\|\bar{z}_T - z_{T-1}\| = a_T \|f(z_{T-1}, x) - z_{T-1}\|$$

4. **Stabilizers**: Orthogonal initialization, adaptive update magnitude, gradient clipping, deep supervision

---

## Empirical Validation / Results

### Four Operational Criteria for Learned Recursion

- **R1**: Extrapolation by iteration—accuracy increases with test-time iterations on harder instances
- **R2**: Difficulty-adaptive stabilization that converts—stabilization step tracks instance difficulty and answer is correct
- **R3**: Incremental computation—correct answer forms gradually (monotone descent of logit-lens rank)
- **R4**: Convergent answer—further iterations neither change nor degrade the answer

### Table 1: Primary Results Across Three Ladders

| Model | Sudoku learn | Sudoku extrapolate | Reach learn | Reach extrapolate | Add learn | Add extrapolate |
|-------|-------------|-------------------|-------------|-------------------|-----------|-----------------|
| CoRe (full) | 1.00 | $0.19 \to 0.34 \pm 0.04$ | 0.98 | $0.92 \to 0.92 \pm 0.10$ | 0.99 | $0.13 \to 0.17 \pm 0.15$ |
| – fixed-point obj | 1.00 | $0.01 \to 0.03 \pm 0.01$ | 1.00 | $0.97 \to 0.97 \pm 0.02$ | 1.00 | $0.14 \to 0.15 \pm 0.02$ |
| TRM-style | $0.94 \pm 0.18$ | $0.14 \to 0.21 \pm 0.11$ | $0.70 \pm 0.17$ | $0.55 \to 0.56 \pm 0.22$ | 1.00 | $0.80 \to 0.82 \pm 0.15$ |
| UT/URM | $0.97 \pm 0.06$ | $0.00 \to 0.00$ | $0.43 \pm 0.09$ | $0.28 \to 0.28 \pm 0.07$ | $0.99 \pm 0.02$ | $0.66 \to 0.72 \pm 0.21$ |
| EqR | 1.00 | $0.01 \to 0.01 \pm 0.01$ | $0.99 \pm 0.01$ | $0.88 \to 0.89 \pm 0.03$ | 1.00 | $0.12 \to 0.12 \pm 0.03$ |
| DEQ | 1.00 | $0.00 \to 0.00$ | $0.26 \pm 0.04$ | — | $0.99 \pm 0.01$ | $0.19 \to 0.47 \pm 0.19$ |

### Key Findings

**Conversion tracks the regime, not the architecture**:
- On Sudoku: settling recipe family reaches 0.34±0.04 (variants up to 0.42)
- On reachability: settling family generalizes to never-trained depths (0.92±0.10) on a flat plateau
- On carry: settling run is TRM-style (0.82±0.16), while marginal runs rise then collapse (UT/URM: 0.95@32 → 0.05@128)

**The fixed-point objective is causal**:
- Removing it: Sudoku conversion dies (0.34→0.03), reachability safety dies (loses up to 0.37 EM by $h_c=128$)
- Adding it to generic recurrence on carry: 0.12→0.88, damage 0.91→0

**Spectral anisotropy separates algorithms from mere convergence**:
- Algorithm-learners develop a structured Lyapunov spectrum (CoRe on Sudoku: spread $\lambda_1 - \lambda_8 = 0.41$)
- Failure modes are spectrally degenerate (eight nearly identical exponents)
- Spectrum spread predicts extrapolation with AUC 0.846 across 304 runs

**Safety statistics**: Among 164 competent runs, not one of 17 settling runs loses more than 0.004 EM to depth, while 30% marginal and 22% drifting lose more than 0.1, up to 0.98.

---

## Theoretical and Practical Implications

### Theoretical Implications

1. **Depth-safety is provable**: Proposition 1(a) establishes that when measured settling occurs (remaining path length less than decoder margin), the decoded answer is guaranteed stable under further iterations.

2. **Settling is necessary, not sufficient**: The paper distinguishes "settled into an algorithm" from "merely settled" via spectral anisotropy—the spread of Lyapunov exponents.

3. **Non-normality is essential**: Successful operators are strongly non-normal ($\sigma_{\text{max}}/\rho \approx 4$–5.4). The top singular value represents transient amplification, not asymptotic rate ($\rho < 1$). Computation lives in a thin amplifying cone inside a globally contracting map.

4. **σ_max control specifically fails**: Regularizing the typical gain blows $\sigma_{\text{max}}$ to 14–33 and destroys training; regularizing ρ (asymptotics only) is the control that helps.

### Practical Implications

1. **Diagnostic toolkit**: The measurement suite (spectral, dynamical, information-flow, topological signals) can be applied to any recurrent model to predict whether test-time depth will help.

2. **Training intervention**: The terminal fixed-point objective is a single, effective training term that creates settling dynamics and enables depth-safety.

3. **Scale repair**: A label-free latent-anchoring objective (pull deep states toward the base's own shallow state) restores depth-safety in Huginn-3.5B: digit copying reaches 1.00±0.00 at r=128 with input-dependent answers.

4. **Failure mode taxonomy**: All failures fall into four measurable modes: identity, marginal, drift, and settle-but-wrong.

---

## Conclusion

The paper establishes that **learned recursion is a dynamical property**: a non-normal operator settling in an attractor that the objective creates and structure aligns with the task. Key takeaways:

- **Depth-safety is provable** at small displacement (Proposition 1), while **conversion stays empirical** and task-dependent.
- **The dynamical regime predicts the fate of test-time depth**: settling operators are depth-safe and sometimes convert depth into accuracy; marginal and drifting operators fail one or both.
- **One training term controls both**: the terminal fixed-point objective switches the regime and depth behavior together.
- **The measurements carry to scale**: Huginn-3.5B falls in the non-settling family, and the taxonomy prescribes a repair that works without labels.

### Future Directions

- Producing settling operators is not guaranteed (seed lottery on mazes); robust methods for ensuring settling are needed
- The scale repair is operation-family-scoped and tested on one checkpoint; broader validation is needed
- Conversion (R1) remains empirical and task-dependent; understanding when settling converts to extrapolation is open
- The paper's controlled protocol estimates no ceiling; the relationship between regime and scaling behavior warrants further study

---

_Markdown view of https://picx.dev/p/mfcn0D, served by PicX — AI-generated visual whiteboard summaries of research papers._