Technical Summary: Equilibrium Reasoners (EqR)

1. Problem Statement

Modern AI systems increasingly rely on scaling test-time compute to improve reasoning performance, often through iterative updates of a latent state. However, the internal mechanisms that allow these iterative models to generalize beyond memorized patterns remain unclear. While some models show diminishing returns or even performance degradation with increased compute, others achieve significant gains. The central question is: What internal mechanisms enable scalable and generalizable reasoning?

Current iterative reasoning models (e.g., HRM, TRM) apply learned update rules to latent states but often struggle to generalize to tasks requiring deep reasoning or to scale effectively with increased inference budget. The paper posits that the failure to scale often stems from a misalignment between the model's learned internal dynamics and the task's solution space.

2. Methodology: Equilibrium Reasoners (EqR)

The authors propose Equilibrium Reasoners (EqR), a framework that formalizes iterative reasoning as learning a task-conditioned attractor landscape. In this view, valid solutions correspond to stable fixed points (attractors) in the latent dynamical system defined by the update rule $z_{k+1} = f_\theta(z_k; x)$.

Core Hypothesis

Generalizable reasoning arises when the model learns an internal landscape where:

1. Task Alignment: The stable attractors correspond to correct task solutions (low-error basins).
2. Reachability: These correct attractors are reachable from diverse initial states.

Key Components and Interventions

To shape this landscape, the authors introduce a controlled construction path from feedforward models to scalable iterative reasoners, incorporating specific training interventions:

• Weight-Tied Iteration: Reusing parameters across layers to define a recurrent dynamical system, allowing the model to unroll to arbitrary depths (e.g., equivalent to 40,000 layers) without increasing parameter count.
• Randomized State Initialization (RI): Instead of using a fixed initial state $z_0$, the model samples $z_0 \sim \mu_0(\cdot|x)$ (e.g., Gaussian noise) for each trajectory. This aligns training with test-time breadth scaling (multiple restarts) and encourages path independence.
• Path Stochasticity via Noise Injection (NI): Additive noise is injected at each iteration step ($z_{k+1} = z_k + (1-\lambda)r_\theta(z_k; x) + \beta \epsilon_k$). This prevents premature convergence to spurious attractors and broadens exploration of the landscape.
• Segmented Online Training (SOT): A training schedule that splits long trajectories into segments, applying supervision and parameter updates after each segment. This alternates between refining the latent state and reshaping the update operator, preventing the "stale trajectory" mismatch found in offline supervision.
• Adaptive Computation Time (ACT): A learned halting mechanism that allows the model to terminate early on easy instances, allocating more compute to difficult cases.

Inference Scaling

EqR scales test-time compute along two axes:

1. Depth ($D$): Increasing the number of unrolled iterations per trajectory to refine the solution within a basin.
2. Breadth ($B$): Aggregating outputs from multiple independent stochastic trajectories (restarts) to increase coverage of the attractor landscape.

Convergence-based selection (choosing the trajectory with the lowest fixed-point residual $\|f_\theta(z; x) - z\|$) is used to select the best prediction, which becomes reliable only after the landscape is properly shaped.

3. Key Results

The authors evaluate EqR on Sudoku-Extreme (a challenging 9x9 constraint satisfaction task) and Maze-Unique (a uniquely solvable 30x30 pathfinding task).

• Generalization vs. Memorization: Standard feedforward models (even with 64 layers) achieve near-zero accuracy on Sudoku-Extreme (2.6%), while weight-tied iterative models without landscape shaping reach 32.6%.
• Impact of Interventions: Applying Randomized Initialization (RI) and Noise Injection (NI) significantly boosts performance. On Sudoku, the baseline iterative model (TRM-style) achieves 84.8% accuracy; EqR (with RI+NI) reaches 86.4% at the same compute budget.
• Scalability:
  • Depth Scaling: Increasing iterations from 16 to 64 improves Sudoku accuracy from 86.4% to 93.0%.
  • Breadth Scaling: Combining depth (64) with breadth (128 restarts) pushes Sudoku accuracy to 99.8% and Maze accuracy to 93.0%.
  • Fixed-Point Residual: There is a tight coupling between lower fixed-point residuals and higher task accuracy. As depth increases, the residual decreases, and accuracy improves, validating the attractor hypothesis.
• Efficiency: With Adaptive Computation Time (ACT), EqR achieves matched accuracy targets with significantly fewer function evaluations (e.g., 11.34x fewer NFEs than the baseline on Sudoku-Lite) by terminating early on easy instances.

4. Significance and Claims

The paper claims to provide a mechanistic understanding of why iterative reasoning scales. The primary contributions are:

1. The Attractor Perspective: Shifting the view of iterative reasoning from simple convergence to the learning of a task-conditioned attractor landscape. Success depends on aligning the model's internal stable states with the task's correct solutions.
2. Training Interventions for Scalability: Demonstrating that specific, task-agnostic interventions (RI and NI) are critical for shaping this landscape, making correct attractors reachable and stable. Without these, scaling compute often yields diminishing returns or failure.
3. Reliable Convergence Signals: Showing that once the landscape is shaped, the fixed-point residual becomes a reliable proxy for task correctness, enabling efficient selection strategies (Top-1 convergence) that outperform majority voting.
4. Scalable Reasoning without External Verifiers: EqR achieves massive scaling (unrolling equivalent to 40,000 layers) and near-perfect accuracy on difficult tasks without relying on external verifiers or task-specific priors, relying solely on internal dynamics and test-time compute.

The authors conclude that for iterative latent reasoning models to scale, they must be evaluated not just by final accuracy, but by whether their internal dynamics make correct solutions stable, reachable, and selectable. This perspective offers a pathway to understanding and improving the generalization capabilities of iterative models.