Equilibrium Reasoners: Learning Attractors Enables Scalable Reasoning — part 6/7

Cleaned-text code points [74575, 89652). Bibliography omitted here; source.md includes it.
In the main text, for simplicity, Sudoku denotes Sudoku-Extreme and Maze denotes Maze-Unique, matching the shorthand introduced in Sec. 6 . Sudoku-Extreme is the full HRM benchmark used for the main Sudoku results, Sudoku-Lite is our 2048-example evaluation subset sampled from Sudoku-Extreme, Maze-1k is the original ambiguous shortest-path benchmark used by HRM/TRM, and Maze-Unique is our uniquely solvable maze benchmark used for the main Maze results.

### C.2 Datasets and Task Definitions Shape Attractor Landscapes

We find that when the dataset is ill-defined with respect to the training target, attractor dynamics cannot be learned reliably. On the original Maze-1k dataset used in the HRM and TRM papers, iterative models fail to exhibit stable test-time scaling, and training remains unstable even after extensive hyperparameter tuning.

The root cause is label ambiguity rather than model capacity or optimization. The Maze-1k task is defined as finding a shortest path from start to goal, yet for most of the mazes in this dataset the shortest path is not unique (see Fig. 14(a) ). Despite this, the dataset provides only a single target trajectory per maze, effectively casting a one-to-many task as a one-to-one supervised learning problem. According to the HRM paper, this dataset is generated using the codebase of Lehnert et al. (2024) . That work explicitly distinguishes two variants of maze-style planning data. In the deterministic variant, the search procedure is fixed and produces a unique trace and solution for each maze. In the non-deterministic variant, randomized tie-breaking during search yields multiple equally valid shortest paths for the same maze input. For the non-deterministic variant, Lehnert et al. (2024) therefore report any-correct or any-optimal metrics, acknowledging that multiple outputs should be considered correct.

In contrast, HRM and TRM are trained on non-unique Maze-1k data using token-level cross entropy against a single provided trajectory, creating a mismatch between the training objective and the task. From a landscape perspective, the task admits multiple correct attractors, yet the loss artificially designates one arbitrary attractor as the sole target and penalizes all others. Consequently, the learned attractor landscape is misaligned with correctness: nearby trajectories may converge to alternative valid paths that nonetheless incur non-negligible loss, yielding multiple shallow and competing attractors. This destroys stable depth scaling, and randomized state initialization or noise injection becomes counterproductive, as improving coverage or stability of one attractor can degrade performance when there are actually multiple valid attractors.

To isolate this effect, we construct Maze-Unique, where each maze admits a unique shortest path. Under this setting, supervision aligns with the task structure, and iterative models recover stable attractor dynamics and meaningful test-time scaling behavior. When scaling up depth at test time, we found that models trained on Maze-Unique improve as NFE increases, whereas models trained on the original Maze-1k dataset stay flat or slightly degrade. While direct metric comparisons across datasets are not meaningful due to differences in model size and setup, the qualitative difference in stability and scaling behavior is clear.

The dataset fundamentally determines the geometry of both the optimization objective and the learned attractor landscape. When a task admits multiple valid solutions, imposing single-solution supervision makes learning ill-posed. This misspecification prevents stable attractor landscapes from forming and, as a result, breaks test-time scaling.

## Appendix D Method and Experimental Details

This section collects the implementation, hyperparameter, baseline-tuning, and evaluation details needed to reproduce and interpret the experimental results.

### D.1 Architecture and Hyperparameters

Here we introduce the hyperparameters used in the experiments. For Sudoku-Extreme, we follow the architecture used in the TRM paper, keeping the model components and training procedure identical unless otherwise specified.

For Maze-Unique, we deliberately reduce model capacity by decreasing the number of layers from 2 to 1 and the hidden dimension from 512 to 128. We find that larger models can reach near-perfect performance on this task, which makes the effects of different test-time-scaling variants difficult to observe. By constraining model capacity, we encourage the model to rely on iterative refinement, making the attractor dynamics easier to study. Detailed configurations are shown in Tab. 17 .

### D.2 Learning-Rate Control for Feedforward Baselines

To rule out the possibility that feedforward baselines underperform due to suboptimal learning-rate choices, we sweep three learning rates { 5 × 10 − 4 , 5 × 10 − 5 , 1 × 10 − 4 } \{5\times 10^{-4},\,5\times 10^{-5},\,1\times 10^{-4}\} and inspect the resulting training and evaluation trajectories. Across this sweep, learning-rate tuning does not remove the feedforward generalization gap: the feedforward models can fit the training set, but evaluation accuracy remains extremely low. In particular, the 4-layer MLP moves from underfitting at the smallest learning rate to high training accuracy at larger learning rates, whereas the 16-layer MLP fits the training set across all three learning rates. This indicates that the feedforward baselines mainly memorize the Sudoku-Extreme training distribution rather than learning a structure that generalizes.

### D.3 Evaluation Metrics

This subsection collects the formal definitions of the evaluation metrics used in Sec. 6 .

#### Averaged exact acc.

We report averaged exact acc. under B B independent restarts: AccAvg ( B ; 𝐱 ) ≔ 1 B ∑ i = 1 B 𝟏 { y ^ ( i ) ( 𝐱 ) = 𝐲 } . \mathrm{AccAvg}(B;\mathbf{x})\;\coloneqq\;\frac{1}{B}\sum_{i=1}^{B}\mathbf{1}\{\hat{y}^{(i)}(\mathbf{x})=\mathbf{y}\}. (19) When B = 1 B=1 , this reduces to standard single-run accuracy.

#### Top-1 convergence accuracy.

Given B B independent restarts and T T iteration steps, we select the trajectory whose final states exhibit the strongest convergence, measured by the mean residual over the last L L iterations, r T , L ( i )  ( 𝐱 ) = 1 L  ∑ t = T − L + 1 T ‖ f θ  ( 𝐳 t ( i ) , 𝐱 ) − 𝐳 t ( i ) ‖ . r_{T,L}^{(i)}(\mathbf{x})=\frac{1}{L}\sum_{t=T-L+1}^{T}\bigl\|f_{\theta}(\mathbf{z}_{t}^{(i)};\mathbf{x})-\mathbf{z}_{t}^{(i)}\bigr\|. We then report whether the corresponding prediction is correct: Top1Conv ( B ; 𝐱 ) ≔ { 𝐲 ^ ( i ⋆ ) ( 𝐱 ) = 𝐲 } , \mathrm{Top1Conv}(B;\mathbf{x})\;\coloneqq\;\mathbf{1}\!\left\{\hat{\mathbf{y}}^{(i^{\star})}(\mathbf{x})=\mathbf{y}\right\}, (20) where i ⋆ ∈ arg ⁡ min i ∈ { 1 , … , B }  r T , L ( i )  ( 𝐱 ) i^{\star}\in\arg\min_{i\in\{1,\dots,B\}}r_{T,L}^{(i)}(\mathbf{x}) . Unless otherwise stated, we use a convergence window of L = 3 L=3 iterations.

#### Majority vote accuracy.

As a complementary baseline under breadth scaling, we report majority vote accuracy over the B B independent restarts, MajVote ( B ; 𝐱 ) ≔ { mode ( { ^ 𝐲 ( i ) ( 𝐱 ) } i = 1 B ) = 𝐲 } . \mathrm{MajVote}(B;\mathbf{x})\;\coloneqq\;\mathbf{1}\!\left\{\mathrm{mode}\big(\{\hat{}\mathbf{y}^{(i)}(\mathbf{x})\}_{i=1}^{B}\big)=\mathbf{y}\right\}. (21)

#### Path independence across restarts.

We quantify inference stability by measuring how sensitive accuracy is to restart randomness. For an input 𝐱 \mathbf{x} , let Acc ¯ B  ( 𝐱 ) \bar{\mathrm{Acc}}_{B}(\mathbf{x}) denote the mean exact accuracy over B B independent restarts. We define Δ PI  ( B ) ≔ 𝔼 𝐱  [ | Acc ¯ B  ( 𝐱 ) − Acc ¯ 1  ( 𝐱 ) | ] . \Delta_{\mathrm{PI}}(B)\;\coloneqq\;\mathbb{E}_{\mathbf{x}}\!\left[\left|\bar{\mathrm{Acc}}_{B}(\mathbf{x})-\bar{\mathrm{Acc}}_{1}(\mathbf{x})\right|\right]. (22) Smaller Δ PI  ( B ) \Delta_{\mathrm{PI}}(B) indicates stronger path independence.

### D.4 Compute Accounting for Iterative Inference

We count iterations at the outer-loop level unless noted otherwise. We use D D for the number of outer iterations in one trajectory and B B for the number of independent restarts. We use the number of function evaluations, NFE = D ⋅ B \mathrm{NFE}=D\cdot B , to describe inference budgets; each function evaluation corresponds to one outer-loop iteration.

One outer-loop iteration can contain several real layer applications. For Sudoku-Extreme, the update function applies two real layers over 21 inner loops, so one outer iteration corresponds to N eq = 2 ⋅ 21 = 42 N_{\mathrm{eq}}=2\cdot 21=42 equivalent layers. A single trajectory with D = 1024 D=1024 therefore reaches D ⋅ N eq = 1024 ⋅ 42 = 43,008 D\cdot N_{\mathrm{eq}}=1024\cdot 42=43{,}008 equivalent layer evaluations. This is the source of the “over 40,000 layers” statement in the main text.

Breadth scaling multiplies the total budget, but it does not change the depth of any individual trajectory. For total equivalent-layer accounting, NLE = D ⋅ B ⋅ N eq \mathrm{NLE}=D\cdot B\cdot N_{\mathrm{eq}} . The best Sudoku-Extreme result in Tab. 4 uses D = 64 D=64 and B = 128 B=128 , i.e., 8192 8192 function evaluations and 64 ⋅ 128 ⋅ 42 = 344,064 64\cdot 128\cdot 42=344{,}064 total equivalent layer evaluations. We describe this setting as two-axis scaled inference rather than a 344k-depth unroll, since each trajectory still has depth D = 64 D=64 .

## Appendix E Extended Related Work and Discussion

This appendix expands the related work discussion in the main text.

#### Deep Equilibrium Models.

Our framework is closely related to implicit models, especially Deep Equilibrium Models (DEQs) ( Bai et al., 2019 ) . Related work extends this implicit view through path-independent equilibria for exploiting test-time computation ( Anil et al., 2022 ) and practical training methods for implicit models ( Geng et al., 2021a ; Geng et al., 2021b ; Fung et al., 2022 ; Gu et al., 2020 ) . Rather than stacking a fixed number of explicit layers, a DEQ defines the representation as the fixed point of a weight-tied nonlinear transformation. Concretely, a DEQ solves for an equilibrium 𝐳 ⋆ \mathbf{z}^{\star} satisfying 𝐳 ⋆ = f θ  ( 𝐳 ⋆ , 𝐱 ) \mathbf{z}^{\star}=f_{\theta}(\mathbf{z}^{\star};\mathbf{x}) . Under convergence, this can be viewed as the implicit limit of an infinitely deep weight-tied network.

We borrow the same fixed-point vocabulary, but study a different question. DEQ work primarily uses convergence to an equilibrium as a representation-learning and training device; our goal is to understand when the learned latent space dynamics make convergence reliable for solving a task. In our setting, reaching some fixed point is not enough: the model must shape a landscape whose large, stable basins correspond to correct solutions rather than spurious or unstable attractors. Thus attractor coverage, stability, and basin size provide a language for explaining why iterative reasoning succeeds, fails, or benefits from additional inference-time updates.

#### Latent reasoning models.

We use latent reasoning models to refer to methods that spend additional computation in latent space before emitting externally visible tokens or final predictions. This latent computation can be organized along two axes. The vertical axis increases computation by repeatedly updating a latent state with weight-tied iterations, as in weight-tied language models ( Geiping et al., 2025 ; Zhu et al., 2025 ) , PonderLM ( Zeng et al., 2026 ) , Parcae ( Prairie et al., 2026 ) , LoopViT ( Shu et al., 2026 ) , and the HRM/TRM/URM line of structured reasoners ( Wang et al., 2025 ; Jolicoeur-Martineau, 2025 ; Gao et al., 2025 ) . The horizontal axis inserts additional latent positions before a visible output: pause tokens delay answer extraction while the decoder processes extra hidden vectors ( Goyal et al., 2024 ) , Coconut feeds the last hidden state back as a continuous thought ( Hao et al., 2025 ) , SoftCoT and SoftCoT++ construct soft thought tokens for efficient or diverse continuous-space reasoning ( Xu et al., 2025b ; Xu et al., 2025a ) , and PonderLM-2 pretrains latent thoughts before actual token prediction ( Zeng et al., 2025 ) . Recent implicit-CoT variants further supervise, align, or score these latent tokens to reduce collapse and improve interpretability or parallel test-time scaling ( Wei et al., 2026 ; Chu et al., 2026 ; You et al., 2025 ) . These horizontal methods internalize or compress chain-of-thought-like computation into latent tokens, whereas our work focuses on the vertical fixed-state dynamics of iterative reasoners: we ask when extra updates help by studying whether training shapes a solution-aligned attractor landscape, rather than treating iteration count or hierarchy alone as the source of generalization.

#### Theoretical and mechanistic analyses of weight-tied iteration.

A useful way to organize this line of work is as a progression from what weight-tied iteration can compute, to what one more iteration is worth, and finally to what hidden-state mechanisms make iteration succeed or fail. The first question is computational: programmable-computer constructions show that a shallow weight-tied Transformer can emulate counters, branches, function calls, and small instruction-set programs when the sequence supplies both instructions and memory ( Giannou et al., 2023 ) . Learning-algorithm experiments show that adding iteration lets a Transformer fit data with accuracy comparable to a much larger standard Transformer ( Yang et al., 2024 ) . Expressivity analysis then identifies limits that are specific to repeated shared blocks and shows that timestep encodings recover additional iteration-dependent behavior ( Xu and Sato, 2025 ) . Latent-thought theory makes the same point from the reasoning side: on synthetic tasks where effective depth is the scarce resource, iterating a small block can approximate a much deeper non-weight-tied model ( Saunshi et al., 2025 ) . Together, these results justify treating iterations as real computation, but they do not yet say which trajectories through state space are reliable.

The second question is resource accounting: how much does an iteration buy, and what state must be preserved across iterations? Iso-depth scaling estimates that one extra iteration is only partially equivalent to adding a fresh layer ( Schwethelm et al., 2026 ) , while inverse-depth scaling argues that ordinary LLM depth can look like many similar layers averaging errors rather than composing qualitatively different transformations ( Liu et al., 2026 ) . Circuit-complexity analyses make the analogous point for horizontal token-space computation: intermediate decoding steps can serve as recurrent state, giving decoder-only Transformers more formal power as the chain-of-thought budget grows ( Merrill and Sabharwal, 2024 ) . This line makes iteration a measurable compute resource, but it still mostly reasons about capacity, scaling, memory, or stopping rules instead of the geometry of correct and incorrect solution states.