acceptodds
Under review as a conference paper at ICLR 2027

What Limits Recursive Reasoning Models: Optimization, Architecture and Test-Time Scaling

Abstract

Recursive reasoning models apply a small shared Transformer block many times to refine a latent state. This gives them large effective depth with few parameters and makes them strong on algorithmic tasks. Such compact solvers are natural candidates for tools that an LLM can call on narrow algorithmic subproblems. However, existing models such as HRM, TRM and URM differ in architecture, gradient propagation and training procedure simultaneously. This makes it hard to tell what drives their performance, and their optimization is still poorly understood and often unstable. In this work we address both of these gaps. First, we study these questions under a unified experimental pipeline spanning six algorithmic domains. Individual controlled ablations are performed on representative domains, while the resulting recipe is evaluated across the full suite. The study reveals a surprisingly simple recipe for stable and generalizable recursive reasoning: an intermediate gradient horizon, large physical batches and controlled updates of the recurrent state. An explicit hierarchical architecture is not needed. Second, we combine these findings into a stable 13.6M-parameter model that achieves the strongest overall performance among the evaluated recursive baselines, with particularly large gains on out-of-distribution generalization. It raises Arithmetic OOD accuracy to 71.2%, from 36.2% for the strongest baseline, while reaching 98.41% on Sudoku and 59.5% pass@2 on ARC-AGI-1. Our results show that, within the recursive architectures studied here, performance depends strongly on how recurrence is optimized and stabilized. More broadly, it shows how AI systems can be improved by optimizing their components one at a time.

Primary area:
optimization
Keywords:
recursive reasoning, recurrent computation, latent reasoning, algorithmic reasoning, recurrent Transformers, optimization stability, gradient propagation, truncated backpropagation, recurrent state dynamics

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 3 reviews, above 27% of the others.
Reviewer_m76jOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies the optimization and architecture of small recursive reasoning models that repeatedly apply shared Transformer modules to hidden states and predict complete structured outputs. It compares HRM/TRM/URM-style models under a common data and evaluation pipeline across six algorithmic domains, including two additional domains with explicit distribution shifts: Arithmetic and Game of Life. The study examines gradient truncation, physical batch size versus gradient accumulation, parameter sharing, stabilization mechanisms, and additional model or inference-time computation. The resulting 13.6M-parameter model combines these choices into a training recipe and reports improvements on several benchmarks, particularly Arithmetic OOD. The paper's central contribution is an empirical analysis of what makes recursive computation effective and reliable.

Critical strengths
  1. The research question is worthwhile. Understanding which architectural and optimization choices actually contribute to recursive models is useful. A focused study of small algorithmic solvers can provide a meaningful contribution without requiring experiments on large language models, provided its conclusions are well supported.

  2. Several comparisons incorporate useful controls. The gradient-horizon experiment fixes the forward computation and varies the differentiated portion of the trajectory. Its observation that equal numbers of differentiated module applications can produce different outcomes is informative. The batch experiment fixes effective batch size, and the shared-module comparison attempts to control parameter count. These are sensible starting points for separating factors that change together across prior systems.

  3. The complete recipe gives encouraging results, and the paper reports some useful limitations. Reported results include 71.16% Arithmetic OOD accuracy, 98.41% Sudoku accuracy, and 59.50% ARC-AGI-1 pass@2. Table 3 includes three-seed results on two domains, rather than relying exclusively on single runs. The paper also acknowledges that its main comparison is between complete recipes and qualifies the interpretation of its unsuccessful joint-training experiment.

Critical weaknesses

My main concern is the reliability of the empirical conclusions. The limited scope is acceptable; however, for a paper whose primary contribution is a controlled analysis, the experiments need to distinguish the proposed explanations from plausible alternatives. At present, the results establish that a particular recipe performs well more convincingly than they establish why it works or what generally limits recursive computation. These gaps weaken the claimed scientific contribution even within the paper's intended scope.

  1. The physical-batch conclusion does not identify the source of the observed difference. In Figure 5, changing from physical batch 8192 to batch 2048 with four accumulation steps reduces OOD accuracy from 63.16% to 37.71%, while the reported mean gradient norm increases from 0.38 to 65.46. For an additive loss, identical parameters, samples, and per-example recurrent states, correctly weighted accumulation should closely reproduce the full-batch gradient when stochasticity and numerical effects are controlled. Recurrence alone does not invalidate this equivalence. The paper therefore needs to identify which operation changes the computation or training dynamics. Loss normalization, recurrent-state handling, stochastic regularization, and update timing are possible explanations that are not separated by the current experiment. Appendix B.1 explicitly places clipping after accumulation, so per-microbatch clipping is not an explanation supported by the manuscript. Without a controlled gradient/update comparison, this result does not establish physical batch size as an independently understood property of recursive optimization.

  2. The gradient-horizon finding has limited replication and an unclear separation between model selection and evaluation. Section 5.1 and Appendix D study eight settings on Arithmetic with a single seed. Table 8 explicitly selects Best OOD from 40 checkpoints using the OOD split, and Figure 4 reports these best OOD values. The manuscript does not clearly identify a separate OOD validation set and untouched test set. Although the selected configuration also reaches 71.16% at the final checkpoint, the selection procedure still matters when interpreting the comparison as evidence of generalization. Repetition across seeds and another task, together with a fixed selection protocol, is needed to establish a robust intermediate optimum. The lower ID accuracy of the longest gradient setting also leaves open whether its disadvantage reflects optimization under the chosen hyperparameters rather than a general limitation of longer gradient propagation.

  3. The stabilization evidence does not isolate the core mechanisms, and its checkpoint statistics need reconciliation. Table 3 adds components cumulatively, while normalization and EMA remain fixed; it does not independently establish the contribution of the state-update bound or the necessity of each component in the final recipe. Some additions reduce variance while lowering mean accuracy, so these effects should be distinguished. More concretely, Table 3 reports GoL OOD accuracy of 65.80 ± 0.13 for the final configuration, whereas Appendix E describes a seed of that configuration with final OOD mean 63.77. These cannot be statistics of the same final-checkpoint results if that run is among the three seeds. Its peak OOD score of 65.67 may be compatible with a best-checkpoint interpretation, but that protocol must be stated: consistency of peak performance is different from stability of the final trained models. This ambiguity directly affects a central claim of the paper.

  4. The overall gains are not sufficiently attributed to the proposed optimization choices. The main comparison changes model size, physical batch size, and the training recipe together: for example, the evaluated TRM/URM models have 7M parameters, versus 13.6M for the proposed model. Section 4.6 appropriately acknowledges this recipe-level comparison, but it cannot by itself show that optimization choices account for a large fraction of the total improvement. Applying the proposed training changes to the same backbone, alongside the corresponding unchanged-training controls, would make that attribution substantially stronger. The present local ablations do not fully bridge the gap between the overall improvements and the claimed explanation.

  5. The architecture and scaling conclusions exceed the comparisons reported. Section 5.3 changes whether the two recurrent transformations share weights, while retaining nested two-state updates. This tests the need for separate parameters, not the need for hierarchical recurrence as a whole. The exact configurations used to match parameter count should also be specified. Section 5.5 gives conclusions about increased depth, width, and head count without a complete sweep of settings and results. Figure 6b does not clearly specify the starting and ending inference budgets. A controlled evaluation relating task difficulty to training and inference recurrence would be much more informative about scaling limits than the current aggregate gains.

  6. The inference-cost reporting appears inconsistent. Figure 1 places the proposed model at 6× relative inference compute, whereas Table 7 defines its cost per complete answer as 6T relative to the dense control. With the budgets described in Appendix B.3, T is typically 16 and is 8 for ARC-AGI-1, corresponding to 96× or 48× under the paper's own layer-application accounting. The figure appears to omit this multiplier, or to use an unexplained normalization. This should be reconciled before using the figure to support efficiency comparisons. These layer counts should also be distinguished from measured FLOPs or latency.

Questions for authors
  1. Gradient accumulation: With fixed parameters, the same examples and recurrent states, stochastic regularization disabled, and controlled precision, do a full batch and correctly weighted microbatch accumulation produce matching losses, gradients, and one-step updates? If not, which operation introduces the difference? If they do, where do the training trajectories first diverge?

  2. Selection and replication: Which datasets select checkpoints and hyperparameters, and which are reserved for final testing? Can the key gradient-horizon comparison be reported under a fixed selection protocol across multiple seeds and another domain, with a small sensitivity check for the training hyperparameters?

  3. Stability statistics: Which seeds and checkpoints contribute to Table 3? Does it report final or peak accuracy, and how does seed 536 in Appendix E relate to those results? Please provide the per-seed values and clarify the checkpoint and recurrent-output selection rules.

  4. Core components and attribution: Which gains remain when the update bound, gate, and normalization are individually removed from the final recipe? Does applying the training recipe to an otherwise unchanged baseline backbone recover the main improvements? These comparisons would help distinguish component effects from the effectiveness of the complete combination.

  5. Architecture and scaling: What are the exact parameter-matched configurations in Figure 6a and the inference budgets in Figure 6b? Can the depth/width results be reported explicitly? Does the hierarchy conclusion survive a comparison that removes nested updates while controlling parameter count and recurrent computation, or should the claim be narrowed to weight sharing?

  6. Cost accounting: How is the 6× value in Figure 1 reconciled with the 6T cost per answer in Table 7? Please provide a consistent complete-answer cost definition for all plotted systems, including the autoregressive baselines.

1 comment

Thank you for your detailed feedback and questions.

Why do Table 3 and Appendix E report different Game of Life scores? For Table 3, we took the maximum score across checkpoints for each seed (125, 536, and 782), then averaged these per-seed maxima. The value 63.77 in Appendix E is the score at the last checkpoint of seed 536. We have clarified in the manuscript where best-checkpoint and last-checkpoint scores are reported.

Why does Figure 1 show 6× while Table 7 gives 6T? We report compute relative to a single forward pass of the dense baseline (1×), so each value indicates how many times as much computation a model requires as the dense baseline. We have clarified in the figure caption that Figure 1 shows the minimum amount of compute guaranteed to be used for every prediction, corresponding to one ACT step. Table 7 includes the total number of ACT steps, T. The detailed accounting formula is already provided in Appendix C.2.

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

This paper studies what limits the performance and generalization of recursive reasoning models, focusing on optimization, architecture, and test-time computation. Since HRM, TRM, and URM change both architecture and training at once, the authors isolate these factors under a unified training and evaluation setup.

They examine gradient flow through recurrent trajectories, physical batch size versus gradient accumulation, recurrent-state stabilization, hierarchy, and test-time scaling. The proposed 13.6M-parameter model uses a shared Transformer backbone with bounded and gated recurrent-state updates, normalization, truncated backpropagation, recurrence-consistent dropout, and noise regularization.

Beyond Sudoku, Maze, and ARC-AGI, the authors add controlled OOD tests on Arithmetic and Game of Life. Experiments cover six algorithmic domains, with ablations on selected representative tasks. The final model outperforms the evaluated recursive baselines on nearly all reported metrics, reaching 71.16% Arithmetic OOD accuracy, 98.41% Sudoku accuracy, and 59.50% pass@2 on ARC-AGI-1.

Critical strengths
  1. The paper systematically investigates an important and under-explored question: what actually determines recursive reasoning performance. Sections 5.1–5.5 separately examine gradient horizon, batch size, parameter sharing, stabilization, and test-time computation. The gradient-horizon experiments are particularly informative, showing that longer backward paths do not monotonically improve OOD generalization (Table 8).

  2. The model shows strong empirical gains over recursive baselines (Table 2; Arithmetic OOD 36.20%→71.16%, Sudoku 98.41%), and the stabilization recipe improves reproducibility (Table 3; Game of Life OOD std 2.90→0.13). The contributions of individual stabilization components still need further disentanglement.

Critical weaknesses
  1. The physical-batch vs. gradient-accumulation discrepancy is insufficiently explained. At effective batch size 8192, reducing the physical batch to 2048 with 4 accumulation steps lowers Game of Life OOD accuracy from 63.16% to 37.71%, while the pre-clipping gradient norm rises from 0.38 to 65.46. Since clipping occurs after accumulation (App. B.1), the paper should rule out differences in loss normalization, gradient averaging across accumulation steps/workers, optimizer-update semantics, and recurrent-state handling. As written, the experiment shows that the tested implementations behave differently, not that physical batch size is intrinsically an independent optimization variable—an issue because this claim motivates the final training recipe.

  2. The evidence for a generally optimal gradient horizon and improved OOD generalization is not sufficiently robust to model-selection effects. The gradient-horizon study uses Arithmetic with a single seed; the selected configuration reaches 71.16% vs. 65.53% for the next-best (Table 8), with no seed variability reported. Appendix D selects the best OOD checkpoint using the OOD split, while the horizon is also selected based on OOD performance; a separate validation/test protocol is unclear. In addition, the main model and baselines differ in parameter count and full training recipes, so gains cannot be attributed solely to the proposed mechanisms. The stronger claim that an intermediate gradient horizon is generally optimal is therefore not yet established.

Questions for authors
  1. Please clarify the physical-batch vs. gradient-accumulation discrepancy. Are loss normalization, gradient averaging across accumulation steps and distributed workers, optimizer schedule, clipping placement, and recurrent-state handling identical? A direct comparison of gradients on the same parameters and the same fixed batch before any optimizer update would be valuable. If correctly implemented accumulation produces equivalent gradients, another mechanism must explain the gap; if a genuine batch-dependent effect exists, it would substantially strengthen this claim.

  2. Please clarify the robustness of the gradient-horizon choice. Is the same Arithmetic OOD split used for horizon selection, checkpoint selection, and final reporting? Ideally, compare the strongest horizon configurations across multiple seeds and evaluate on an independently held-out OOD set after hyperparameter and checkpoint selection, to distinguish a reproducible optimization principle from seed- or validation-specific behavior.

2 comments

Thank you for your detailed questions. We address them in the common response, alongside the related points raised by the other reviewers.

Thank you for the authors' reply, particularly for clarifying the difference behaviors between physical batches and gradient accumulation. Given the current completeness of the experiments, I am inclined to maintain my score.

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

The paper studies how architecture and optimization affect small recursive reasoning models, then combines its findings into a 13.6M-parameter model with strong results across several puzzle domains. The method looks technically reasonable, and the practical improvements are promising.

Critical strengths
  • The paper deals with a useful experimental question. Separating gradient propagation, recurrent architecture, and stabilization is worthwhile when earlier models change several things together. Keeping forward computation fixed in the gradient-horizon study is particularly helpful.
  • The method shows substantial empirical improvements. Arithmetic OOD accuracy rises from 36.2% to 71.16%. The three-seed stabilization experiments also show a clear reduction in variability, especially on Game of Life.
  • The authors are transparent about about important limitations. The paper explicitly describes ARC’s transductive protocol, acknowledges that few parameters do not imply cheap inference, and treats the unsuccessful joint-training experiment cautiously.
Critical weaknesses
  • The physical-batch versus accumulation result needs a convincing explanation. With identical examples, recurrent states, randomness, and loss normalization, accumulated gradients should closely reproduce a large-batch gradient. The jump in gradient norm from 0.38 to 65.46 suggests that something consequential changes between implementations. ACT/carry handling or loss scaling could matter here. Without checking gradient equivalence directly, the conclusion that physical batch size is intrinsically important feels premature.
  • The strongest generalization claim mixes evaluation with model selection. Appendix D explicitly selects checkpoints using the OOD split, and the preferred gradient horizon is chosen from those same OOD results. The entire horizon sweep also uses one seed. Although 71.16% is also achieved at the final checkpoint, an untouched OOD test set and repeated runs are needed to establish a reliable intermediate optimum rather than a configuration that worked best in this sweep.
  • The stabilization ablations do not isolate several claimed ingredients. Table 3 adds components cumulatively, keeps normalization and EMA fixed, and does not separately ablate update bounding. It also never compares recurrence-consistent dropout against ordinary dropout. This supports the usefulness of the complete recipe, but not the stronger claims that particular mechanisms are necessary or explain its success. Notably, gating alone already matches the final recipe’s mean OOD accuracy within the reported variation.
  • Game of Life needs stronger controls before it demonstrates computational extrapolation. The generator includes trajectories that become empty or periodic, but the paper does not report how common these easy outcomes are in each split. Almost identical accuracy at ID and +10 steps could reflect successful extrapolation, but could also reflect terminal-state shortcuts. An empty-grid baseline and results restricted to nontrivial evolving patterns would make this evidence much more convincing.
  • The literature positioning could be sharper. URM [1] already reports an interior optimum for gradient truncation, while FPRM [2] directly studies recurrent stabilization and depth utilization. A controlled FPRM comparison would be especially relevant here.

[1] Gao, Z., Chen, L., Xiao, Y., Xing, H., Tao, R., Luo, H., Zhou, J. and Dai, B., 2025. Universal reasoning model. arXiv preprint arXiv:2512.14693.

[2] Movahedi, S., Milovanović, V., Feigin, S.L., Theus, A., Hofmann, T., Boeva, V., Rusch, T.K. and Orvieto, A., 2026. Fixed-Point Reasoners: Stable and Adaptive Deep Looped Transformers. arXiv preprint arXiv:2606.18206.

Questions for authors
  • Since sharing parameters still leaves two states and two timescales, does this experiment establish that hierarchy is unnecessary, or only that separate high- and low-level module parameters are unnecessary?
  • Given that arithmetic problems can admit multiple valid operator assignments, does exact accuracy accept any assignment yielding the supplied value, or only the originally sampled sequence?
  • Could you clarify the baselines’ training schedules and tuning budgets, and provide the LLM prompts, generation budgets, and output-parsing details to help interpret their near-zero scores?
  • Could you provide the numerical capacity-scaling results and detailed configurations for Section 5.5 so readers can assess the evidence for the claimed scaling limits?
3 comments

Thank you for your careful reading and detailed questions.

How does recurrence-consistent dropout compare with ordinary dropout? We reuse one mask so that repeated applications of the shared block use a consistent stochastic transformation. This is the rationale for the design; Table 3 does not include a direct comparison with independently resampled dropout.

Could empty or periodic patterns explain the Game of Life results? The current generator saves a step only while the target pattern is nonempty, so an always-empty predictor has zero exact accuracy on examples produced by this loop. Periodic patterns can contribute states before the periodicity-based stopping condition is reached. The task is to predict the exact configuration after the requested number of steps. Stable and periodic patterns are valid instances of this task and are evaluated using the same exact-match criterion as other patterns.

How does the work differ from URM and relate to FPRM? URM already reports an interior optimum for truncation. Our comparison separately varies the extent and placement of gradient flow through nested recurrence: settings with equal numbers of differentiated module applications can produce different OOD outcomes. The recipe also differs from URM through a norm-relative bound on the recurrent-state update, a learned state-write gate followed by normalization, trajectory-consistent dropout, and relative noise. The gate regulates the write to the recurrent state, a different operation from gating inside SwiGLU. Arithmetic and Game of Life provide additional evaluation settings for these choices. We did not conduct a controlled comparison with FPRM.

How are multiple valid Arithmetic assignments handled? The evaluator uses exact matching to the stored operator completion. Ambiguity is handled during generation: the generator enumerates the solutions for a skeleton and target value, then chooses a partial mask that leaves a unique completion. If the fully masked skeleton admits several assignments, some operators remain visible to disambiguate the input.

How were the baselines trained and the LLMs prompted and scored? The recursive baselines were retrained with the common data representation, tokenization, and evaluation pipeline, retaining their method-specific recipes. Detailed training configurations are available in the accompanying code. The LLMs were evaluated from released checkpoints without fine-tuning. The full prompts, including few-shot examples, will be included in the code archive as LLM prompts.md. Generation parameters and output-parsing details are given below.

What generation parameters are specified in the evaluation scripts? The script defaults are:

ParameterSudoku, Maze, Arithmetic, Game of LifeARC-AGI
temperature0.00.9
max_tokens409632768
Attempts12

How were LLM outputs parsed and scored? For non-ARC tasks, the evaluator takes the first case-sensitive <answer>...</answer> block from answer content, strips surrounding whitespace, and exact-matches the reference. Missing or empty answers are incorrect, failed requests remain in the denominator, and there is no fallback to the separate reasoning-content field. For ARC, the evaluator tries answer blocks from last to first, case-insensitively, parses JSON or Python literals, and validates rectangular integer grids with values from 0 to 9. Every test input must be matched by at least one allowed attempt. The LLM scores therefore describe performance under this prompting, generation, and parsing protocol.

Thanks for the detailed responses. Finding the gradient accumulation bug and removing the affected comparison addresses my main concern there. The revised wording around weight sharing and the added details on the scaling experiments also answer my questions on those points.

My main remaining concern is the Arithmetic OOD result. I agree that varying where gradients flow adds something beyond the URM sweep, and the revised wording about (2,2) being the best setting in this particular sweep is fair. Since the same OOD split was used to choose the horizon and checkpoint, I’d also qualify the 71.16% headline result as coming from a split used for tuning. Even evaluating the chosen configuration on a fresh OOD split would make the extrapolation claim easier to assess.

The Table 3 clarification makes sense to me. The full recipe gives more consistent peak accuracy across seeds, and gating alone achieves a similar mean OOD score. I’d make that distinction explicit in the paper. The partial masking explanation also resolves my Arithmetic scoring question and should be included in the dataset description. For Game of Life, the nonempty targets address the empty-grid concern. I’d still be curious how the +10 results look on trajectories that haven’t settled into stable or periodic behavior.

Thank you for the follow-up. We have revised the manuscript to clarify the reporting protocol and the dataset description.

For Arithmetic, checkpoint selection was based on training, ID, and OOD performance together, not on OOD accuracy alone. We selected a checkpoint that performed well across all three. The saved checkpoints come from a single training run for each horizon setting. Separately, Table 8 reports the maximum OOD accuracy observed during training, and Figure 4 reports the maximum EMA exact accuracies. We have made these definitions explicit in both captions.

We have also incorporated the partial-masking explanation into Section 3 and Appendix A.5: visible operators disambiguate the input, each example has a unique completion, and accuracy is evaluated only on hidden operators. Appendix A.5 now clarifies that mm counts masked operators, so the candidate search space is 4m4^{m}, with 474^{7} as an upper bound.

Your interpretation of Table 3 is now explicit in the text: gating alone and the complete recipe have comparable mean OOD accuracy, while the complete recipe achieves higher ID accuracy and lower variation across seeds on both splits. These comparisons concern per-seed peak performance.

We also appreciate your suggestion to examine continuing dynamics separately in the +10 Game of Life evaluation.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Common response to all reviewers

We thank the reviewers. Concerns raised in more than one review are answered here, and each reviewer's reply covers the rest.

Why did physical batches and gradient accumulation behave differently? (URML W1; fFMT Q1; m76j Q1) We identified an error in the gradient accumulation implementation, fixed it in the code, and removed the corresponding comparison and discussion from the manuscript. We also verified that this issue does not affect the other experimental results or the claims based on them

Is the same Arithmetic OOD split used for horizon selection, checkpoint selection, and final reporting? (URML W2; fFMT Q2; m76j Q2) We used the same Arithmetic OOD split for horizon selection, checkpoint selection, and reporting, without separate OOD validation and test sets.

How was the gradient-horizon choice checked across seeds and domains? (URML W2; fFMT Q2; m76j Q2) We tested gradient-horizon choices on other domains using a smaller set of configurations. The full eight-setting Arithmetic sweep presented in the paper uses one seed, with forward computation, data, optimizer, and schedule fixed across settings. We describe (2,2) as the best OOD setting in that sweep under the tested training configuration.

How was the contribution of each stabilization component evaluated? (URML W3; m76j Q4) Our experiment was designed to measure how accuracy and consistency across seeds change as components are added to the recipe. We therefore added components one at a time, keeping normalization and EMA fixed (Table 3), rather than removing components individually from the final configuration.

What does the complete recipe add beyond gating alone? (URML W3; m76j W3) The gate-only configuration and the complete recipe achieve comparable mean OOD accuracy. The complete recipe reduces variation in peak accuracy across seeds, making peak performance more consistent across runs.

Can the overall gains be attributed to training changes alone? (fFMT W2; m76j Q4) Our main comparison evaluates the combined effect of architectural and training choices. The ablations examine changes within our setup; applying the complete recipe to an unchanged baseline backbone was not part of this study.

Does Figure 6a test hierarchy or weight sharing? (URML Q1; m76j Q5) Figure 6a tests parameter sharing: with drop_H_transformer=True, H_level and L_level use the same module, while the two states and nested update schedule remain. We have revised the terminology to make weight sharing the precise scope of this result.

Which capacity results and ACT budgets support Section 5.5? (URML Q4; m76j Q5) We have added numerical Game of Life capacity-scaling results, including depth/width comparisons, to the appendix. Figure 6b increases the evaluation budget to 128 ACT steps, from 8 on ARC-AGI-1 and 16 in the other reported settings, using the already trained model.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.