acceptodds
Under review as a conference paper at ICLR 2027

Learned Correction Dynamics in Recursive Reasoning Models

Abstract

Recursive reasoning models achieve strong performance on certain reasoning tasks by repeatedly applying a small neural network to an evolving latent state. Yet how recursion contributes to reasoning, what successive iterations accomplish, and when additional computation improves performance remain incompletely understood. We address these questions through trajectory measurements and controlled interventions on Sudoku-Extreme, studying released models alongside our compact solvers. We develop an empirical account of learned correction dynamics. Recursion can revise many cells while making little net progress before abrupt completion. Model-produced and randomly corrupted grids can differ in repairability at equal error counts. Continued communication and retained state support correction. Our controls separate solving capability from access through initialization, and finding correct answers from selecting them. Training comparisons show that useful generation and reliable selection need not be learned together. The repair and state findings also hold in our compact attention models, which achieve 99.48 % with 0.62M parameters and 99.62 % with 1.06M and 1.97M on all 422,786 test puzzles. Using 1,000 training puzzles and one fixed-start trajectory of 64 iterations, all exceed, to our knowledge, the best comparable published score of 98.22 % with less matrix multiplication work. Extending the analysis to ARC-AGI reveals a complementary limit: a released model's fit to training demonstrations does not ensure held-out query success, and tested pools lack correct candidates for most queries. The Sudoku findings motivate a conjecture of learned relaxation with memory: retained or reconstructed context could support coordinated revision of mutually supporting errors; on ARC, revising task representations alongside answers could generate new solutions.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
recursive reasoning, test-time computation, interpretability, physics-informed systems, neurosymbolic reasoning, Sudoku, ARC-AGI

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_jdnkOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper studies what iterations do in TRM-style recursive reasoners on Sudoku-Extreme. The authors build compact solvers by combining TRM’s two-state recurrence, SE-RRM’s digit-field representation and EqR’s training recipe, and report strong full-test accuracy at small parameter counts. Around this they run a series of interventions: matched-error repair comparisons, message removal and replay, slow/fast state resets, alternative initializations, and candidate-pool selection, plus a short analysis of released TRM on ARC-AGI. They frame the results as “learned correction dynamics” and propose a “learned relaxation with memory” conjecture.

Critical strengths
  1. The compact-solver result is strong and verifiable, with released checkpoints and per-puzzle records.
Critical weaknesses
  1. The paper is poorly written and has no central thesis. Almost every paragraph is a list of numbers with no argument connecting the numbers, and each finding is immediately hedged with a statement that the mechanism was not identified. The “relaxation with memory” framing is a metaphor, and the sections do not build toward a claim. A paper that cannot communicate its findings has not done its job, regardless of soundness.

  2. The headline findings are from models the paper itself says are not representative. The dramatic initialization effect appears only at an over-trained checkpoint of a single MLP run, and the authors state it does not occur in any benchmark model; this looks like an artifact of a poorly trained model. The coverage-vs-selection failure appears only in a TRM the authors trained themselves; their own attention models don’t show it and the released TRM is never tested.

  3. The solver is an unmotivated combination of three existing methods. No design rationale is given, there is one seed per size, and the authors acknowledge they cannot say where the gain over SE-RRM comes from. The SOTA claim also holds only under one specific protocol.

Questions for authors

See weaknesses

2 comments

Thank you for encouraging us to connect the findings more clearly. We have clarified the argument and distinguished the benchmark evidence from diagnostic cases (General response, point 4).

W1. Central thesis and presentation. Useful recursion depends on repairing the current state, reaching a successful trajectory, and keeping and selecting correct answers. We now connect the experiments to these requirements, with a closing roadmap in the introduction and a discussion focused on what the findings enable. We also reduced numerical lists, moved procedural detail to the appendix, and collected open questions in Limitations and Future Work so they do not obscure the results.

We treat relaxation with memory as a hypothesis: internally reinforcing errors resist isolated correction, while retained or reconstructed context supports coordinated revision. Exploratory candidate energy functions decreased on average but sometimes rose between iterations, giving us a concrete starting point for developing predictive relaxation models (Appendix A.6). The matched-error tests show that arrangement matters, and replay separates preserving an answer from finding one (§9; Tables 7–9). Following the submission's proposed score-preserving tests, we now construct a transfer operator between trajectories of the same puzzle. It transfers a source-specific component of later correction responses beyond matched controls while keeping current answer scores fixed. Our reply to qqri, W1 gives these controls and the accompanying communication tests.

W2. Representative models and failure cases. The central repair, communication and retained-state results use the benchmark attention models. We highlight the 94k MLP checkpoint because it makes the initialization contrast especially clear: it has the lowest fixed-start accuracy among the 25 checkpoints examined after 50k updates, while Gaussian starts remain reliable (Appendix A.11). The initialization contrast also occurs within the 50k-update training budget: at 22k updates in the studied MLP run, fixed starts return 31 of 128 answers, while both Gaussian starts return at least 125 at unchanged weights and depth (Table 11). The capability is therefore already present in the weights; changing the start exposes it without retraining (see also EqR, Huang et al., ICML 2026, §5.1). Fixed and Gaussian starts both solve reliably at the validation-selected attention checkpoints; the extended training series comes from the MLP run (§5.1; Table 12).

The selection result also extends beyond our own TRM. In released ARC TRM, more starts increase coverage, giving more queries a correct candidate but returning fewer correct answers in one pool; selected correctness improves in another (Appendix A.4.1). Even the benchmark attention models occasionally select a new wrong candidate over an available correct one as their pools grow (Table 16). These are ranking failures, distinct from losing an answer along a trajectory. Moreover, in an earlier Attention 256 training ablation, jointly removing Gaussian starts and the training branch for perturbed solutions increases missed available answers (Table 14).

W3. Design rationale, attribution and seeds. Matched retraining favors two-state recurrence, and three Attention 192 training runs reproduce the strong full-test performance. We credit the inherited components. Digit fields represent competing assignments, shared recurrence reuses parameters, and the slow state supplies context for fast updates (§2). Our contribution is the compact solver and its experimentally characterized dynamics.

Two-state recurrence improves solving with and without dropout at matched parameter count and network applications per iteration, and the advantage persists from the same displayed grids (Tables 21A, 22). Three Attention 192 training runs average 99.5999.59\\% full-test accuracy at 64 iterations. Our reply to YSDB, W3 gives the variation across these training runs and the repeated cooperation result. Other widths and the remaining combinations of state count and dropout have one run each. The matched comparison identifies the recurrence design's contribution within our implementation. With one fixed-start trajectory on the full test, the submitted Attention 192 checkpoint exceeds SE-RRM's published accuracy at each matched depth (Table 5).

I thank the authors for the substantial rewrite and additional experiments; the paper is clearer, but I believe many concerns still remain. The architectural and training choices are still not fully ablated, the strong initialization failures remain specific to their MLP model and not attention model or other released models, and the severe coverage vs selection failure is not shown to generalize to released models. I therefore maintain my score of 1.

Reviewer_cUzHOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper studies how iterations contribute to the answers of recursive reasoning models (HRM/TRM-style), mainly on Sudoku-Extreme. It analyzes released models alongside the authors’ compact solvers, which combine TRM’s shared-network recurrence with SE-RRM’s symbol-indexed representation. This solver reaches 99.48% (0.62M parameters) and 99.62% (1.06M/1.97M) on the full test set, exceeding SE-RRM’s published 98.22%. The analyses use fixed-weight interventions: trajectory measurements, matched-error repair, message replay, state resets, alternative initializations, and candidate selection. Extension analysis to ARC-AGI further reveals the train-test mismatch of recursive models.

Critical strengths
  1. Good motivations on the study of how recursion improve the results of recursive reasoning models.
Critical weaknesses
  1. Unclear focus and structure. The paper states that it studies how recursion contributes to reasoning. However, no experiment directly isolates the contribution of recursion, for example by comparing against depth-matched non-recursive models or by systematically analyzing how answers change with depth across models. The individual analyses (repair, communication, state resets, initialization, selection, ARC) are not organized around a clear set of hypotheses, and the paper does not explain how they jointly answer the research questions in the introduction. The result reads as a collection of observations, many of which are specific to a single checkpoint, rather than a structured study.
  2. Unclear role and novelty of the proposed model. The relation between the trained solvers and the study of recursion is not explained. The solvers are presented both as a benchmark contribution and as an object of analysis, but the analyses do not rely on their specific design. The model itself combines existing components (TRM recurrence, SE-RRM representation and attention operations), and the paper does not identify what accounts for its improvement over SE-RRM. The authors acknowledge that representation, update design and training recipe differ together. The comparison relies on SE-RRM’s published number and on a single training seed per attention model.
Questions for authors
  1. What does “access through initialization” mean in abstract? Why is separating solving capability from its accessibility under a given initialization informative about how recursion contributes to reasoning?
  2. What is the connection between the proposed solvers and the study of recursion? Would the conclusions of Sections 3–6 change if they were drawn only from released models?
  3. What is novel in the proposed model beyond combining TRM’s recurrence with SE-RRM’s representation? Which component (architecture, update schedule, training recipe) explains the improvement over SE-RRM? Can this be shown with controlled ablations and several training seeds?
1 comment

Thank you for encouraging us to clarify the connections between our research questions, experiments and model design. We have presented these connections better in the revision (General response, point 4).

W1. Focus and structure. Useful recursion depends on repairing the current state, reaching a successful trajectory, and keeping and selecting correct answers. Sections 3, 4 and 5–6 respectively examine progress, repair and correct return. Further iterations let the same learned update revise its own intermediate state, improving the benchmark attention models' full-test accuracy at fixed weights, including beyond the training horizon. Yet corrections and new errors largely offset before completion across seven checkpoints, including released EqR and TRM, so accuracy alone hides much of this revision (Tables 5–6). Our depth sweep tests recursive models; the separate nonrecursive comparison comes from EqR (Huang et al., ICML 2026). At matched layer evaluations, EqR reports 32.632.6\\% Sudoku-Extreme accuracy with weight tying versus 2.62.6\\% for a larger feedforward model (Table 2).

W2/Q3. Solver contribution, rationale and attribution. Our message branch between candidate digits at each cell lets us remove, replay and substitute messages while leaving other operations unchanged. Our reply to qqri, W1 details how these controls test the role of evolving messages and retained state in correction. Section 2 explains the inherited components' roles: digit fields represent competing assignments symmetrically, shared recurrence extends computation without adding parameters, and the slow state holds context across fast updates. Gaussian starts and perturbed solutions provide varied states during training. Our contribution is therefore a compact solver and an experimental account of what its repeated updates use.

New matched comparisons show that two-state models solve more with and without dropout at matched parameter count and network applications per iteration. Storage, update frequency and input/feedback paths vary together, and the advantage persists from the same displayed grids (Tables 21A, 22). Earlier training-recipe controls show the largest tested accuracy drop when batch size and learning rate change together (Table 17). Together, these controls identify effects of recurrence design and training choices within our implementation. Other widths and the remaining combinations of state count and dropout have one run each. Three Attention 192 training runs average 99.5999.59\\% full-test accuracy at 64 iterations; each exceeds SE-RRM's published result. Our reply to YSDB, W3 gives the training-run variation and the repeated cooperation test.

Q1. Meaning of access. Changing only the starting state can turn failure into success with the same weights, clues and iteration budget. The abstract now states this finding directly, and the introduction defines access. In the studied MLP run, answer-independent Gaussian starts solve nearly every puzzle at checkpoints where fixed starts fail on many, including within the training budget. State swaps then change whether identical displayed answers survive the next iteration, showing why further iterations depend on the hidden state they continue from (Tables 11, 26).

Q2. Conclusions from released models alone. Released models support several parts of the account. EqR's repair depends on error arrangement and retained state; EqR and Sudoku TRM show offsetting revisions (Tables 6, 8–9). Released ARC TRM also exhibits selection failures and response transfer (Appendix A.4.1; Table 28). Building on these observations, our solvers add matched retraining and direct interventions on messages between digit fields. Repair, replay and state-reset results cover three benchmark attention models; cooperation repeats on a second run.

Reviewer_YSDBOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper introduces a compelling recursive reasoning framework which achieves huge performance with extremely minimal parameter overhead by an effective self-correction mechanism. The authors also suggest a benchmark based on Sudoku, and their empirical analysis of latent state dynamics and initialization has insightful results. Although the work would be strengthened if they address concerns regarding sequential inference latency or task generalization beyond grid based structures (like ARC-AGI), their results build strong contribution to the understanding and design of parameter-efficient RRM architecture.

Critical strengths
  • Overall, the paper is well-written and the motivation is strong. The benchmark design is also sound and justified enough. All codes and benchmark supplement make high reproducibility for deployment and implementation.
  • The SOTA performance of highly compact parameter size model (0.62M to 1.06M) shows significant enhance of computing efficiency relative to model size, which represents a major contribution. The self-correction mechanism additionally serves both flexibility and high effectiveness.
  • Unlocking latent reasoning capacity by substituting state initializations with Gaussian noise provides actionable insights for other research including inference-time scaling as it is not requiring retraining.
Critical weaknesses
  • I think the results raise concerns that the benchmark is already saturated, such as performance increase from 95.45 to 99.48 under depth extrapolation. Critically, the performance bottleneck on held-out queries in ARC-AGI shows potential overfitting to the specific task structure. While Sudoku features explicit structural rules as it has strict rows, columns, and boxes, the transferability should be broader for unconstrained domains, which seems still questionable.
  • Achieving peak accuracy requires hundreds of sequential iterations, which may introduce a severe latency bottleneck in real-world deployment. It would be beneficial if the authors could provide latency comparisons against baseline models to quantify this computational trade-off under realistic deployment setups.
  • Although authors already mentioned it, a single random seed experiment represents a notable limitation in experimental design. It would be helpful to present aggregated results across multiple seeds.
Questions for authors
  1. Is the observed coverage gap (generation failure) primarily attributable to fundamental limits on parameter size itself or architectural constraints in task representation?
  2. Given the abrupt completion dynamics observed during recursion, is it feasible to implement an adaptive early-stopping mechanisms that halts processing once successful state correction occurs prior to reaching the full 64 iteration, as some Large Reasoning Models do?
2 comments

Thank you for highlighting the performance of our compact solvers and the insight that changing initialization can expose solving capability without retraining. To address the practical questions you raise, we have added stopping and training-seed evaluations and clarified what the ARC evidence supports. The training-run summary is in General response, point 1.

W1/Q1. Saturation, broader generalization and the ARC coverage gap. We agree that Sudoku-Extreme accuracy is near ceiling. We use this existing public benchmark as a controlled setting for studying how correction works. At fixed weights, accuracy rises with further iterations, while corrections and new errors can offset before completion (Tables 5–6).

Our ARC analysis concerns a released TRM, not our Sudoku solvers. Its task demonstrations were seen during training; query answers were held out. Even where it reproduces every demonstration correctly, it answers only about a third of queries. Most queries lack a correct candidate in the tested pool, so improving selection alone cannot close this gap (Figure 4). Model size, task representation and training are alternative explanations; controlled comparisons and tests beyond grid-based tasks are directions for extending the work. Alongside this diagnosis, our response-transfer operator also applies to the released model: after solution-supplied corrections, next-iteration score responses at untouched tokens acquire a component specific to the source trajectory beyond matched controls (Table 28).

W2/Q2. Sequential latency and adaptive stopping. Yes: stopping at the first valid Sudoku grid preserves accuracy and substantially reduces computation. Our headline uses 64 iterations; the longer trajectories in Table 5 are separate subset experiments. For unique-solution Sudoku, checking the givens, rows, columns and boxes identifies correct answers from the input alone, so we can stop when an answer is found. On the full test, the rule matches depth-64 correctness at all three submitted attention checkpoints with fewer than five iterations on average; unsolved puzzles receive all 64 (Table 27).

On a separate 128-puzzle sample, early stopping reduces average runtime more than tenfold in Attention 128 and 192, with unchanged correctness. We measure runtime savings within our implementation, processing puzzles individually. Across models, Table 1A compares arithmetic cost: our 1.06M model uses about half of SE-RRM's at equal depth.

W3. Training seeds. Three independent training runs of the Attention 192 training recipe average 99.5999.59\\% full-test accuracy at 64 iterations, with a range of 99.4699.46–99.6999.69\\% (Table 21B). The introduction and Table 1 explicitly report this mean, and each run exceeds SE-RRM's published result. Other attention widths and the remaining combinations of state count and dropout have one run each. In addition, cooperation between corrections repeats on the second run (Table 24), supporting a correction finding as well as the benchmark result.

Reviewer_YSDBOpenReview ↗

Official Comment by Reviewer YSDB

Thank you for the clarification and the additional experiment with various seeds. The authors have addressed most of my concerns, and strengthened their contribution by showing strong performance in the newly introduced Table 1. Also, the comment about released TRMs is interesting, which I hope to be investigated more for the general progress of research in this domain.

Assuming their revisions are incorporated already after checking the updated manuscripts, I would continue to support the acceptance of this paper. I look forward to see the follow-up research to the non-grid domains, which would be more harder cases.

Reviewer_qqriOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper studies how recursive reasoning models correct intermediate answers and when additional computation helps. On Sudoku-Extreme, a 1.06M-parameter attention model solves 99.62% of test puzzles with a single 64-iter trajectory. The authors adapt SE-RRM’s position and symbol attention to a two-state TRM recurrence. The main contribution is the controlled study of how evolving messages and retained state support error correction. The paper also shows that more random restarts can increase the chance of generating a correct answer while reducing the accuracy of the answer selected.

Critical strengths
  • The message-replay experiment distinguishes preserving a correct answer from finding one. On Sudoku puzzles, replaying first-round messages between candidate digits preserved all initially correct answers.
  • The slow-state intervention is a well-designed control. Perturbing the part of the state that leaves current digit scores unchanged reduced the number of puzzles solved. This shows that the slow state carries information used for later correction beyond what is visible in the current prediction.

Liked the intervention and mechanistic study.

Critical weaknesses
  • The interventions establish that evolving messages and retained state matter, but what they encode remains unclear. For example, do the messages identify specific conflicts?
Questions for authors
  • How does a single-state model compare when other designs are matched? This would help isolate the contribution of the two-state recurrence.
  • How sensitive is error correction to message delay?
1 comment

Thank you for highlighting the replay experiment's distinction between preservation and discovery, and the score-preserving state control. The revised paper extends both with new direct tests of information use (General response, point 2).

W1. Conflicts, messages and retained state. Specific conflicts influence correction through attention between cells, and retained state carries transferable information about correction responses. Across the three benchmark attention models, blocking attention to conflicting peers (other cells displaying the same digit in the same row, column or box) reduces next-iteration repair by 13–25 percentage points relative to blocking peers displaying different digits. It also protects correct cells challenged by a wrong peer. These tests use unsolved fixed-start states and target the features associated with the cell's displayed digit. To examine the messages carrying an error's influence, we separately introduce one wrong digit into a supplied solution, then insert the corrupted continuation's messages between candidate digits at one selected peer into the unmodified continuation, with clean messages replayed elsewhere. This reproduces much of the targeted peer's digit-score response, both for conflicting peers and for other peers (Table 25; Appendix A.10, “Remote responses”).

These messages also contribute to cooperation: on Attention 192, combining two correction sets repairs more untouched errors than adding their separate digit-score changes predicts. Replacing their joint messages with uncorrected messages plus each set's separate message change removes most of this benefit, whereas the benefit remains under a same-size random change (Table 24; Appendix A.10, Equation 4).

To test retained state, we transfer hidden features between trajectories of the same puzzle while preserving digit scores and the fast state. Under identical solution-supplied corrections, the receiving trajectory's later response acquires a source-specific component beyond matched controls. This identifies information used for later correction beyond what is visible in the current prediction (Table 19).

Q1. Matched single-state comparison. Two-state recurrence improves solving at matched parameter count and network applications per iteration. We trained width-192 models with one or two states, each with and without dropout, using the same training budget. On a shared test subset at depth 64, the two-state advantage is 2.70 percentage points without dropout and 1.59 with dropout. Storage, update frequency and input and feedback paths vary together. To test continuation from a common starting grid, we also give both models the same displayed grid on shared failures. The two-state model still solves more, locating an advantage in how it continues (Tables 21A, 22).

Q2. Message delay. Correction is highly sensitive to delay during discovery, and less so after answers settle. In Attention 128 and 192, introducing a one- or two-iteration lag at iteration 3 leaves no puzzle correct at iteration 32; replay of iteration-2 messages preserves existing solutions. By contrast, on a separate Attention 192 sample with settled answers, a one-iteration lag preserves them for more than twenty further iterations before losses begin. When current messages are restored after a brief early two-iteration lag or replay, almost all new completions of undelayed continuation are recovered. Together, these tests suggest that continued discovery relies on coordination between evolving messages and state, while a fixed message pattern can sustain an answer already found (Appendix A.10, “Replay and delay”).

Comments on the paper

1 comment

We thank the reviewers for their careful reading and thoughtful feedback, which have helped us strengthen the results and their presentation. We have clarified the submitted findings and added experiments addressing your questions about recurrence design, information use and reliability, while retaining the research questions, section order and figures.

Useful recursion depends on repairing the current state, reaching a successful trajectory, and keeping and selecting correct answers.

1. New matched training comparisons within our implementation favor two-state recurrence at equal parameter count and network applications per iteration. With the additional training seeds, three runs of the 1.06M Attention 192 model average 99.5999.59\\% full-test accuracy at 64 iterations. The introduction and Table 1 explicitly report this mean.

2. New interventions show how conflicts, messages and retained state influence later correction. Blocking attention to conflicting peers (other cells displaying the same digit in the same row, column or box) reduces repair of wrong cells and protects correct cells challenged by a wrong peer, relative to blocking peers displaying different digits. Moreover, on Attention 192, correcting two sets of errors together repairs more untouched errors than their separate score changes predict. Replacing joint messages with uncorrected messages plus each set's separate message change removes most of this benefit.

Studying correction dynamics also led us to construct a response-transfer operator that provides a controlled interpretability test of how hidden state shapes later correction. By copying hidden features between trajectories of the same input, we preserve current answer scores while changing how the receiving trajectory responds to the same solution-supplied corrections. In both Sudoku and released ARC TRM, that response acquires a source-specific component beyond matched controls.

3. Starting states affect discovery and preservation, while early stopping reduces computation. The submitted MLP results show that changing only the start turns failure into success at unchanged weights and depth, including within the training budget. New state-swap experiments change whether the same displayed solution survives the next iteration, despite matching digit scores. Building on the submitted input-only validity check for unique-solution Sudoku, our new early-stopping evaluation preserves full-test accuracy at the three submitted attention checkpoints with much less computation.

4. We revised the presentation throughout the paper to better communicate the argument and connections between experiments. The introduction now connects the research questions to their answers and closes with a short roadmap, while the discussion develops the implications for correction, initialization, candidate generation and selection. We also clarify the design rationale in Section 2, reduce numerical and procedural detail to improve the flow, and collect open questions in Limitations and Future Work.

The marked paper is included in the supplementary ZIP, where red identifies new scientific material and blue identifies writing changes.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.