Selection, Reflection and Self-Refinement: Revisit Reasoning Tasks via a Causal Lens
Authors: Yunlong Deng
Boyang Sun
Yan Li
Zeyu Tang
Lingjing Kong
Kun Zhang
Guangyi Chen
Venue: ICLR 2026 Poster (2026)
Keywords: Causality
Reasoning Tasks
Selection Mechanism
Primary area: causal reasoning

Abstract: Due to their inherent complexity, reasoning tasks have long been regarded as rigorous benchmarks for assessing the capabilities of machine learning models, especially large language models (LLMs). Although humans can solve these tasks with ease, existing models, even after extensive pre-training and post-training at scale, still fail to perform reasoning reliably. In this paper, we revisit reasoning tasks from a causal perspective, seeking to understand their behavior in latent space and to offer insights for addressing their challenges. Specifically, we cast reasoning tasks as a selection mechanism, in which high-level logical concepts function as selection operators on the given observations, such as, identifying the correct answer in a math problem or filling the appropriate entry in Sudoku. We emphasize two key properties of this formulation that shed light on the difficulty of reasoning tasks. First, the latent space exceeds the observation space in complexity, even when the correct answer is fully determined by the observed input. Second, the latent variables, corresponding to logical thought, are densely structured and exhibit strong dependencies.  Building on this formulation, we introduce a framework, called SR$^2$, that incorporates the estimated latent variables as feedback into the selection mechanism, thereby facilitating the learning of dense dependencies among latent representations. The framework consists of three key modules: reflective representation learning, dependency self-refinement, and periodic intermediate alignment. Experimentally, we show that our approach yields significant gains in reasoning accuracy, for example, attaining over 10% improvement in performance with 8$\times$ fewer parameters on the Sudoku and Maze tasks over the recent advances.

Published as a conference paper at ICLR 2026
SELECTION, REFLECTION AND SELF-REFINEMENT REVISIT REASONING TASKS VIA A CAUSAL LENS
Yunlong Deng
Boyang Sun
Yan Li
Lingjing Kong"
Zeyu Tang 23
Kun Zhang 12
Guangyi Chen
ABSTRACT
Due to their inherent complexity, reasoning tasks have long been regarded as rig- orous benchmarks for assessing the capabilities of machine learning models, es- pecially large language models (LLMs). Although humans can solve these tasks with ease, existing models, even after extensive pre-training and post-training scale, still fail to perform reasoning reliably. In this paper, we revisit reasoning tasks from a causal perspective, seeking to understand their behavior in latent space and to offer insights for addressing their challenges. Specifically, we cast reasoning tasks as a selection mechanism, in which high-level logical concepts function as selection operators the given observations, such as, identifying the correct answer in a math problem or filling the appropriate entry in Sudoku. We emphasize two key properties of this formulation that shed light the difficulty of reasoning tasks. First, the latent space exceeds the observation space in com- plexity, even when the correct answer is fully determined by the observed input. Second, the latent variables, corresponding to logical thought, are densely struc- tured and exhibit strong dependencies. Building on this formulation, we intro- duce framework, called SR², that incorporates the estimated latent variables as feedback into the selection mechanism, thereby facilitating the learning of dense dependencies among latent representations. The framework consists of three key modules: reflective representation learning, dependency self-refinement, and pe- riodic intermediate alignment. Experimentally, we show that our approach yields sigmificant gains in reasoning accuracy, for example, attaining over 10% improve- ment in performance with 8 fewer parameters the Sudoku and Maze tasks over the recent advances. Code available at http:://githb..com// http://ttttuh..ooo//eegg///////
INTRODUCTION
"We do not learn from experience... we learn from reflecting on experience."
-John Dewey, How We Think
Reasoning, the act of deriving conclusions and principles from information by logical inference, lies the heart of human intelligence. From solving arithmetic problems to navigating mazes, humans perform complex reasoning with case and reliability. In contrast, machine learning mod- els continue to struggle with these tasks. Reasoning challenges have therefore become one of the rigorous benchmarks for assessing the true depth of a model's 's capability, particularly for large lan- guage models (LLMs). Unlike tasks driven by pattern recognition, reasoning requires that models infer, generalize, and operate over complex abstract relationships, capabilities that are fundamental to advancing machine intelligence toward human-level performance.
Despite the impressive progress enabled by large-scale pre-training and post-training, current mod- els still fall short of robust reasoning (Guo et al. 2025). Much of the progress to date has come from scaling Kaplann et al. 2020 Brown et al. 2020 Achiam al., 2003)), such as expanding datasets, model size, and optimization steps. They deliver performance gains but do not explain why reason- ing remains intrinsically difficult for machines despite being natural for humans. Another line of
Mohhmeed hin Zayed University of Artificial Intelligence University
"Carnegic Mellon University
Stanford

---

Published as a conference paper at ICLR 2026
((R) Roue
Xof--row
Xoff-block
4
6
9
7
X in-row
X in-block
4
8
Xoff-col
X Xin-col
6
7
9
2
(b) Block
3
9
5
Col
(a) Example Sudoku problem
(b) Single entry in Sudoku
(c) Validity criteria (row, column, block)
Figure I: Illustration of reasoning tasks and the selection mechanism, using Sudoku as an example. (a) A sample 9 x 9 Sudoku puzzle with subset of given clues; the goal is to fill the remaining cells so that each row, column, and 3 3 subgrid contains the digits 1-9 exactly once. (b) A single unfilled cell Yú, with its row (purple), column (hlue), and 3 3 black (orange) highlighted; the digits within these groups impose constraints that determine the admissible values for Yig. (c) Selection mechanism:
valid the validity criteria are
satisfied Boo
s( Black 1.
work introduces chain-of-thought supervision or human reward to guide models through intermedi- ate reasoning steps (Jaech al. 2024 Guo et al., 2025 Wang et al., 2025b). However, they often encourage models to mimic the surface form of human explanations, such as natural language, rather than uncover the underlying structure reasoning in the latent space. As result, the generated rea- soning traces may be verbose, inconsistent, or logically unsound, limiting their value for genuine generalization. This gap highlights the need for a new perspective that goes beyond scaling and imitation, aiming instead to model the structural nature of reasoning itself. The detailed discussion about related work can be found in Appendix A.I
Specifically, formulate reasoning tasks selection mechanism (Zheng et al. 2024 Elwert & Winship 2014). concept from causality that describes how observed variables co-occur under certain selection constraints. In reasoning tasks, high-level logical concepts act as operators that impose constraints on the observed inputs. For example, as illustrated in Figure [ the numbers in Sudoku grid must satisfy the validity criteria, where a given entry that needs to be filled should consider the selection constraints such that each row, column, and subgrid contains all digits exactly once. This formulation captures reasoning as the process of narrowing possible latent assignments to those consistent with the selection mechanism.
Building on the selection mechanism formulation, we propose two fundamental hypotheses that further characterize its structure and clarify the sources of difficulty in reasoning. First, the latent space the selection mechanism more complex than the observation space, even when the correct answer is uniquely determined by the observed input. For example, when solving a math problem, the observed input may consist of few numbers and operations with a fixed solution, but the underlying reasoning process involves exploring vast latent space of intermediate steps, alternative solution paths, and logical transformations before converging to the unique correct answer. Second, densely structured and highly interdependent, making them challenging for
the latent variables current models to disentangle and exploit. This is evident in reasoning processes where a single change in a principle or logical step often necessitates cascade of adjustments other steps in order to maintain overall consistency. These properties make it difficult for current models to disentangle and effectively utilize the latent structure, thereby limiting their reasoning capability.
Inspired by this formulation, we propose new framework SR² to explicitly model the Selection, Reflection, and Self-Refinement enabling iterative refinement of latent space in the reasoning pro- cess. This design encourages the model to explicitly capture the dense dependencies among latent representations, rather than treating them as isolated or independent. This framework consists of three key components, 1) To address the challenge of the intractably large latent space, we propose a reflective representation learning module. This module incorporates the estimated latent variables and maps them back into the input space as feedback injection and iteratively refines the represen- tation. 2) To capture dense dependencies, we propose a dependency self-refinement process that discards observation signals and relies solely on latent variables as inputs to fixed-point solver, en- suring that the resulting solution satisfies the imposed constraints. 3) To mitigate gradient vanishing in the long iterative refinement process, introduce periodic intermediate alignment, which injects supervision (or self-supervision) at selected intervals to provide guidance and preserve consistency across reasoning steps.
2

---

Published as a conference paper at ICLR 2026
We validate approach canonical reasoning benchmarks, including Sudoku and Maze Nav- igation. Our method achieves substantial improvements in reasoning accuracy, outperforming the recent hierarchical reasoning model (HRM (Wang et al.) 2025al) by more than 10% while using up to 8x fewer parameters. These results not only highlight the effectiveness our framework but also demonstrate that reasoning can be advanced through causal modeling of latent structures rather than relying solely on scaling. In addition, we conduct a detailed ablation study to evaluate the contribution of each module, providing insights that may guide future research and development.
In summary, this work contributes:
A causal perspective that formulates reasoning as selection mechanisms, where concepts act as operators constraining observed inputs;
The finding of two key properties, including latent space complexity and dense dependen- cies, that explain the inherent difficulty of reasoning tasks;
A novel framework with reflective representation learning, dependency self-refinement, and adaptive alignment to model reasoning more effectively;
Empirical evidence on reasoning benchmarks showing that our approach achieves state-of- the-art performance with far fewer parameters.
We believe this study takes step toward deeper understanding of reasoning in machine learning and offers new insights for building models that reason more like humans.
METHOD
In this section, we present our framework SR2 (Selection, Reflection, and Refineeefnm which is designed to address the inherent difficulty of reasoning tasks through causal formulation. We begin by revisiting reasoning tasks selection mechanism, then introduce two hypotheses that explain their complexity, and finally describe our framework components that explicitly model selection, reflection, and self-refinement.
2.1 REASONING AS CONSTRAINT-SAATISPACAA VIA SELECTION MECHANISMS
a constraint-satiisaation framing, reasoning is understood as the process of aligning different pieces of information, rules, and procedures so that they cohere with another. Success, then, measured less by whether the final outcome is "correct" some absolute sense, and more by whether the reasoning process maintains internal consistency across the constraints. This makes the characterization of reasoning more about procedural coherence than about reaching a single externally defined answer. Therefore, we revisit reasoning tasks through the lens of causality and formalize them as a selection mechanism. In causal modeling, a selection mechanism describes how observed variables co-occur under certain constraints imposed by latent factors. Analogously, reasoning tasks can be viewed as a process in which high-level logical concepts act as operators that constrain the admissible configurations of the observed inputs.
Pata-generating process as selection mechanism. Let x denote the observed input (e.g., a partially filled Sudoku grid), y the corresponding solution (e.g.. the other entries in Sudoku to be filled), and z the latent variables representing reasoning rules (e.g., logical principles or arithmetic laws). As shown Fig- constrained conditional genera- tion process, where high-level rules z generate observed pairs (x, y) only they satisfy the selection constraints S(z) 1. Formally, the joint distribution is
X
Y
S(2)
Figure 2: Causal graph of the
selection mechanism where (xy) are selected by constrains S(z).
ure 2 we model reasoning
p(x,y) p(z) (g ((() 1) dz.
where p(z) is the prior over latent rules, Pa (x,y z) denotes the base generative distribution pa- rameterized by the function g. and I(S(z) = 1) enforces that the data satisfies the criteria de- noted in the selection variables z. In the deterministic case, Pg (x.y 2) reduces Dirac delta,
3

---

Published as a conference paper at ICLR 2026
(x 2) == -xxx) Formally specifying the data- data-generating process provides the theo-
retical foundation for our subsequent module design; in Section 2.4 we revisit the SR2 architecture through the lens of data generation.
Example: Sudoku. In Sudoku, as illustrated in Figure I x is the initial partially filled grid (La), y is other entries to be completed (Ib), and 2 represents the latent rules which characterizes the relationship between X and Y: each row, column, and block (respectively) must contain all digits exactly once (Tc). The set of selection mechanisms is given by
8 = ( 2 {0,13).
(2)
where S denotes the selection mechanism and the Boolean value S(z) (or Sa) indicates whether the current pair (X, Y) satisfies rule z. Thus, solving Sudoku corresponds to selecting (x.y) y) pairs (which are derived from mapping to the space of numbers) such that the corresponding satisfies (a set of) selection criteria $ E S.
Concretely, consider the purple row in Figure lb Let Y₁ be the number to be filled in the i-th row and j-th column, and let No denote all already-filled numbers in the same row. If Yij is different from every number in in-row. we set S. = 1; otherwise, we set S = 0. Here, = = Row encodes the rule that each row must contain every digit exactly once; that is, the digits in Xmn-row together with Y, must all be distinct.
Implication. This perspective views reasoning selection among latent rules: the task is solved once y) is identified under the governing z. Unlike direct input-output mapping, this requires navigating rule-constrained latent space, highlighting the intrinsic complexity of reasoning tasks.
2.2 TWO FUNDAMENTAL HYPOTHESES
Building on the selection mechanism formulation in Equation mally characterize the sources of difficulty in reasoning tasks.
I we state two hypotheses that for-
Hypothesis (Latent space complexity) Let z denote the latent rules, (x.y) the observed input-
answer pair, and S(z) the selection constraints. Even when the mapping (x. g(z) is determin- istic for all admissible z with S(z) = 1, the effective latent space 2g = (z S(z) = 1} is much larger than the observation space X y. Thuss unique observed pair (x.y) typically corresponds to large set of possible latent assignments z E Zs that must be marginalized. For example, solv- ing a math problem with imput x may yield a unique solution y. yet the reasoning process involves exploring combinatorial number of intermediate derivations in z.
Hypothesis (Dense interdependenee) The admissible latent variables Zs exhibit strong struc- tural dependencies. Formally, for z (Zı...., 7 E Zg. the conditional distribution p(z; z-1, S(z) 1) highly concentrated, indicating that any perturbation in one component 2; typi- cally requires coordinated changes in many other components z-; to preserve validity. For instance, Sudoku, changing one entry in z propagates constraints across multiple rows, columns, and sub- grids to restore consistency.
Implication. Together, Hypotheses I and indicate that reasoning tasks cannot be solved by re- lying solely on shallow correlations in (x, y. While the expressive capacity of deep models allows them to mappings from x to y by learning latent z, such solutions often fail to generalize across tasks. Robust reasoning instead needs the modeling of the complex dependence in the structured latent space z. Hypothesis edly explore over-complex latent space and revise latent assignments with feedback. Hypothesis/ 2 further suggests that even if the mapping from x to z is learned, the dense interdependencies within require iterative refinement to reach consistent solution.
T motivates the need for a reflection mechanism, where models repeat-
2.3 THE 3R2 FRAMEWORK
Based on the implications of our formulation, we propose the SR2 framework, which implements the Selection Mechanism, Reflection, and Self-Refinement modules. Our approach encourages
4

---

Published as a conference paper at ICLR 2026
Reflective Representation Learning
Dependency Self-Refinement
x XM times
X(N 1) times
22M
2 N.M
X
Periodic Alignment
9:2
9
9
y
Figure 3: Overall framework of the SR/ method. The framework consists of three main modules: Reflec- tive Representation Learning (in blue). Dependency Self- Refinement (in orange), Periodic Alignment (in green). f denotes the weight-shared atomic block that updates the latent state, and projects the latent space to the final answers. In the representation learning stage, f recurrently updates the latent state with the observation as injection, (*+1) f(z x). for M steps to obtain refined initialization. Next, the self-refinement stage, the model drops the observation signal, x ((+1) = (x 0), and updates for long M (N- steps resolve dense dependencies and approach a fixed point. Throughout training, the supervision conducted periodically (c.g., every M steps) to stabilize long recurrences and mitigate gradient vanishing. When adding supervision, the gradients from future states are blocked (as the red arrows).
the model to iteratively refine latent variables, capture dense dependencies, and enforce consistency across reasoning steps. The pipeline can be found in Figure which is composed of three modules: Reflective Representation Learning, Dependency Relf-Refinemet, and Periodic Alignment.
Reflective Representation Learning. A key challenge posed by Hypothesis/ Tis the intractability of the large latent space z, which makes direct inference difficult. To address this issue, we propose reflective representation learning module, which explicitly models reasoning as reflection process.
We define reflection fixed-point equation of the form
Z = f(z x);
where f(-) is a parametric function (e.g., Transformer model) that updates the latent representation 2 conditioned on the observed input x. This formulation captures the intuition that reasoning is not a one-shot mapping from x to z, but rather an iterative process in which repeatedly revised until it becomes consistent with both the observed data and the latent constraints. Concretely, equa- tion 3 formalizes reflection by refining the latent solution z through fixed-point updates rather than producing it in one step. This directly addresses Hypothesis [ when the latent space far exceeds the observation space, iterative fixed-point updates provide a practical route to contract toward a constraint-satisffing
Equation equation can be solved by iterative refinement:
z (x+1) = ()) x), n = 0, I,...,
(4)
starting from an initial estimate (0) initialized as zeros. After T iterations, the fixed-point solution z is expected to approximate the reflective latent representation satisfying equation This iterative mechanism enables the model to explore the latent space incrementally, progressively eliminating invalid assignments and converging towards rule-consistent solutions.
In large latent spaces, explicit conditioning on the previous state often essential for guiding in- ference. Although direct mapping from x to z is mathematically equivalent to reflection, it fails to sufficiently constrain the solution space. Appendix B provides motivating example showing that iterative conditioning yields strictly better solutions by progressively reducing the solution space.
Flattened recurrent Transformer. While the reflective update function [(, x) equation 3 can in principle be instantiated by any deep neural network, such standard Transformer, we take particular inspiration from recent advances in Deep Equilibrium Models (DEQ) (Bai et al. 2019). which establish duality between model depth and iterative refinement.
Consider a standard Transformer model with stacked layers, where each layer applies the same structural transformation to its input representation. Formally, let 1(()) denote the hidden state at layer 1, The forward propagation can be expressed as
(1+1) T(h), x), 1 0, 1,
(5)
5

---

Published as a conference paper at ICLR 2026
where T-)) is a Transformer block. Instead of explicitly stacking L distinct layers, we propose to flatten the architecture by reusing a single Transformer block 7 recurrently across iterations:
h (m++1) T(h!m), x), m 0, M,
(6)
This unrolled architecture can be viewed solving fixed- eeintpoint problem, where repeated applica- tions of T iteratively refine the latent state. Equivalently, a depth- Transformer can be reinterpreted depth-one recurrent Transformer unrolled for M = L steps. By replacing M distinct layers with a single shared module, the model reduces parameters while preserving expressiveness through iter- ation. Such aligned iterative refinement allows the model achieve effective depths much greater than its deep explicit architecture.
Unlike DEQ. which seeks an equilibrium state and computes gradients via the implicit function theorem without storing intermediate iterates, we explicitly unroll a fixed number of refinement steps. In this sense, our approach is truncated, explicitly unrolled variant that trains the refinement trajectory itself rather than directly optimizing an implicit fixed point.
Dependency Self- Suff-Refinment. Hypothesis 2 highlights that the latent variables z are densely structured and strongly interdependent. A change in one latent component typically requires cascade of adjustments to other components in order to maintain global consistency. Therefore, a reasoning model needs to capture and refine such interdependencies, rather than relying solely on direct mappings from the observed input x.
To model these dependencies, we propose a self-refinement process in which the input signal x removed, and the latent dynamics evolve autonomously:
z (++ [[(2'))))) 0), 0=
where (0) is initialized from the reflective representation learning stage, and fa(+) is iterative solution of the fixed-point operator defined on the latent space. This formulation forces the model refine z using only its internal structure, ensuring that the converged solution satisfies the logical constraints implied by the selection mechanism. By eliminating direct dependence on x, the model is discouraged from leamnigg spurious shortcuts and instead compelled resolve latent dependencies through iterative updates.
Experimentally, we found that both reflective representation learning and dependency self- refinement can be realized by single atomic module, such as a Transformer block fs() s(), reused across iterations. This design substantially reduces the parameter footprint while maintain- ing competitive performance. Finally, we repeat a Transformer block with T M x N times and re-order them, where the first M iterations inject x for representation learning, and the last (M 1) x N iterations are used for dependency learning.
Periodic Alignment. With the flattened recurrent model, we have T = M x N iterations. Such long iterative refinement processes often suffer from optimization challenges. particular, gra- dients propagated through many iterations tend to vanish, leading to unstable training and poor convergence. To address this challenge, we propose a periodic alignment mechanism. Instead of applying supervision only at the final step T, we inject additional supervision (or self-supervision) signals at regular intervals throughout the iterative refinement process. Formally, for refinement states (z( 37 the training objective is augmented as
C = E((g((()))))
(8)
SEA
where g(-) is prediction head mapping latent variables to task outputs, f(.,-) is task-specific loss function, and A S ,,...,TT specifies the alignment intervals. Typical choices of A include uniform spacing (e.g., every M steps) adaptive spacing based convergence criteria. To ensure stability, we detach the computational graph at each alignment step, so that each iteration only re- ceives near gradients from its own supervision signal rather than from far future steps. This periodic alignment stabilizes optimization by providing intermediate guidance that mitigates gradient van- ishing and enforces consistency, ensuring that latent states (!!) remain progressively aligned with the target throughout the refinement process.

---

Published as a conference paper at ICLR 2026
2.4 CONNECTING SR2 TO THE DATA GENERATING PROCESS
From Eq. equation I to the target. Equation equation I describes the data generating process for our task rather than the model design. In implementation. SR2 learns the conditional distribution ply x) instead of the joint p(x, y), and this conditional is derived from the joint as
ply x) = f p(zz
Py p(z|x)
x, (((()) = dz,
Implementation map in SR2. Latent inference p(z x). A single Transformer layer produces a latent state z. SR2 refines it through reflection updates z f(x, zz). yielding the final state 1m_head is trained to model p(y z) as surrogate. Selection ((5(z) 1). Training pairs (x, y) satisfy the task rules, so SR2 concentrates probability on rule consistent states without an explicit selector.
used for prediction. Prediction head Py 2). Since z summarizes
3 EXPERIMENTS
3.1 BENCHMARKS
Sudoku-Extreme The Sudoku task requires filling a 9x9 grid with the digits 1-9 such that each row, each column, and each 3x3 subgrid contains all digits without repetition. Due the logical complexity of its constraints, Sudoku is a widely used benchmark for evaluating the logical reason- ing ability of machine learning models (Palm al. 2017 Long 2023 Du al. 2024). For fair comparison, we use the same dataset, Sudoku-Extremee, and follow the setup strictly with the recent SOTA method, HRM (Wang et al., 2025a). Specifically, the benchmark comprises limited 1, 1,000 training puzzles and 422,786 test puzzles, with an average difficulty of 22 backtracking steps.
Maze-Hard The maze navigation task asks a model to find the optimal path between desig- nated start and goal within a 30x30 maze. The requirement plan long, intricate paths makes it an effective probe of model's 's reasoning ability (Darlow et al.) 2025 Su et al., 2025 Lehnert et al., 2024b). We use the Maze-Hard dataset released by (Wang et al. 2025a). which follows the restance-generatie
procedure of (Lehnert et al., (024a). The generated mazes are filtered to retain only the hardest cases, i.c., those whose shortest paths are the longest Kapadia et al. 2013). The benchmark comprises 1,000 training instances and 1,000 test instances.
ARC AGI The Abstraction and Reasoning Corpus for Artificial General Intelligence (ARC AGI) evaluates abstract pattern induction and compositional generalization via small grid-trannn transformation tasks that require minimal prior knowledge and probe fluid intelligence (Chollet 2019). Each task provides a few input-output demonstrations; the solver must produce exactly matching outputs for novel inputs. Following the official protocol, use ARC AGI (Chollet (024) and ARC AGI [ARC Prize Foundation 2025): ARC AGI has 400 training and 400 evaluation tasks; ARC AGI 2 has 1,000 public training and 120 public evaluation tasks. We adopt two-trial success criterion and report pass @2 accuracy.
3.2 BASELINE AND IMPLEMENTATION
We compare our SR² framework with several canonical network architectures used for reasoning, as well as the recent HRM (Wang et al. 2025a) model, which are summarized below:
Standard Transformer (Vaswani et 2017). Implements standard multi-laye Trans-
former architecture.
Block Universal Transformer (Dehghani et al. 2018). Replaces a deep stack of Trans- former blocks with a flat recurrent architecture that repeatedly applies a Transformer block (a single Transformer layer in the experiments)
Recurrent Depth (Geiping et al. 2025b). Applies the same Transformer layer iteratively, while additionally mapping each layer's ' latent representation back to the input space. In other words, each unit injected by both inputs and latent states.
7

---

Published as a conference paper at ICLR 2026
Table 1: Main results comparing SR' with baselines on Sudoku-Extreme, Maze-Hard ARC-AGI
benchmarks. We report pass@1 I accuracy (%) and the number of learnable parameters ("Params"), With only
3.4M parameters 1/8 of the 27.3M Transformer), SR² achieves the best accuracy on both tasks (best in bold).
Method
Params
Sudoku-Extreme
Maze-Hard
ARC-1
ARC-2
Transformer
27.3M
1.17
0
21.0
0
Block Universal Transformer
3.4M
0
30.4
Recurrent Depth
3.4M
42.52
48.4
HRM
27.3M
55.0
74.5
40.3
5.0
Reflective Model
27.3M
53.12
70.8
SR²
3.4M
66.63
93.7
44.3
6.7
HRM (Wang al. 2025a). HRM employs an interactive recurrent structure, with a high- level module responsible e for abstract planning and a low-level module dedicated to detailed computation. For implementation, we follow the officially released HRM configurations.
Reflective Model (Our baseline model). In this baseline, we consider only the reflective representation learning stage, excluding the subsequent reff-refinement process. Each unit is implemented as an 8-layer Transformer without flattening, equipped with both input injection and supervision.
For faimess, all methods trained with the same optimizer, learning rate, and batch size. Parameter counts are matched across similar designs: the Transformer, Reflective Model, and HRM uses Transformer layers (4 high-level layers, 4 low-level layers in HRM), while the Block Universal Transformer, Recurrent Depth, and our SR2 model adopt a single Transformer layer as the backbone. More discussions with other recurrent models can be found in Appendix A.l
3.3 EXPERIMENTAL RESULTS
We report the performance and parameter counts of SR² and competing methods on the Sudoku- Extreme and Maze-Hard benchmarks, as summarized in Table [ For ARC-1 and ARC-2, due to computational resource limitations, we did not evaluate all baseline models. Several key observa- tions emerge:
Standard Transformer. Standard Transformer architectures fail to solve these demanding reasoning tasks. Even with extended training, the model does not acquire the necessary reasoning skills, underscoring the importance of reflective mechanisms.
Block Universal Transformer. Flattening the architecture by reusing single Transformer block yields modest gains over the standard Transformer, but overall performance remains unsatisfactory.
Recurrent Depth. Adding input injections to the recurrent architecture leads clear im- provements, demonstrating the benefit of feeding intermediate states back into the model.
Reflective Model. Further improvements are observed when both input injections and su- pervisory signals are balanced. The Reflective Model outperforms Recurrent Depth, high- lighting the importance of combining multiple feedback pathways.
HRM vs. Reflective Model. HRM achieves results comparable to the Reflective Model, suggesting that hierarchical recurrent structures are not strictly necessary for reasoning tasks of this type.
SR2. Compared with Recurrent Depth, SR2 achieves substantial improvements such as over 20% on Sudoku-Fxtreem and nearly 2x on Maze-Hard. This demonstrates the crucial role of self-refinement. Moreover, SR² surpasses HRM by 11 11.6% on Sudoku-Extee Extreme and 19.2% on Maze-Hard, while using only one eighth of HRM's parameters.
3.4 TRAINING & INFERENCE COST ANALYSTS
We evaluate the computational efficiency of SR² against Transformer and HRM baseline on Sudoku Extreme under settings, reporting training speed in batches per second, training memory the
8

---

Published as a conference paper at ICLR 2026
average per GPU across devices, and inference speed as samples processed per second computed from the wall clock runtime on the test set. The Periodic Alignment module makes SR? slower than Transformer baseline during both training and inference, yet SR² remains faster than HRM because uses a single layer without hierarchical structure. SR also consumes somewhat more training memory than the other baselines.
3.5 ABLATION STUDIES
We perform comprehensive set of ablation studies to systematically evaluate the contribu- tion of each component. No Self-Refinement removes Dependency self-Refinement all M x N iterations inject input x and do not explicitly model dependencies among latent z. No Reflection removes Reflective Representa- tion Learning process; x is injected only at the first iteration (no repeated injections across the first M). Mixture (2/4 Reflection) performs multiple self-refinement phases by re-injecting æ at evenly spaced blocks rather than only at the first block. Separate Function uses two distinct parameterized functions for the reflective and self- refinement stages instead of shared one. Flattened Reflective Model replaces the multi-layer stack of the Reflective Model with single recurrent Transformer layer, unrolled across iterations,
Table 2: Training and inference efficiency compari-
son.
Method
Training Speed (Batch/s)
Training Mem (GB)
Inference
Speed
(Sam-
ple/s)
Direct Pred
21.39
3.024
7489.6
HRM SR²
10.57
3.231
1487.7
14.73
3.950
2073.6
Is every component of SR² necessary? Yes.
Table 3: Ablation of the SR² framework.
To assess the roles of the Reflective Rep- resentation Learning and Dependency Self-
Ablations
Accuracy (%)
Refinement modules, conduct ablations that remove each module in turn. In No Self- Refinement, the entire self-refinement loop is replaced by a single feedback injection. In No Reflection, we remove the feedback step from each alignment, i.e., no input injection is per- formed. As reported in Table eliminating the self-refinement loop prevents the model from capturing dependencies and leads to clear drop in accuracy, while removing feedback al- together leaves the model unable to retain input features, causing performance to collapse to zero.
No Self-Refinement
53.11
No Reflection
0
Mixture (2 Reflections)
63.32
Mixture (4 Reflections)
55.25
Separate Function
59.76
Reflective Model
53.12
Flattened Reflective Model SR
53.75
66.63
Does more reflections feedback always help? No. We modify the default SR² design (only one reflective representation learning block in M N iterations) to test using two and four reflections. As reported in Table Mixture (2 Reflections) produces slight decrease in accuracy relative to the default, while Mixture (4 Reflections) suffers a large degradation. These results indicate that injecting input frequently biases the model toward fitting superficial input patterns and distracts it from learning deeper dependencies among latent states. In practice, a single reflection per alignment offers the best trade-off for SR².
How should m and n be chosen under a fixed budget? As Figure shows, accuracy peaks when M RJ N and de- clines as their ratio departs from 1. The decline is asym- metric: settings with M > N degrade more gently than their mirrored N > M counterparts, so if imbalance is unavoidable, favor a larger M. The results indicate that balanced configurations are preferable.
M: N (fixed MxN 256) 8:32 120:2256:1
Accuracy (%)
60
40
20
Does the Reflection and Self- Refi-Refinement modules have to learn two distinct functions? No. We replace the sin- gle shared function in SR² with two Transformer layers that do not share parameters, assigning tion module and the other to the Relf-Refinement mod- ule. As shown in Table 3 the decoupled design Separate
log. (MIN)
to the Reflec-
Figure 4: Choosing N and M under fixed compute budget.

---

Published as a conference paper at ICLR 2026
66,52
70
66.63
.9.00
60.47
42.87
50
Accuracy
Accuracy
44.63
20
Acc
10
oog-lincarff. fit
Iiner fit
0
2
8
16
32
2
16
32
N (M fixed 16)
(N fixed at 16)
(a) Accuracy vs. .V with M-16 fixed.
(b) Accuracy vs. M with - fixed.
Figure 5: Accuracy scaling with the hyperparameter N and M: the left panel varies N M= and the right varies M at -=16
Function even reduces accuracy. These results suggest that single unified function is sufficient to support both representation learning and refinement.
Is the flat architecture effective? Yes. To test whether recurrent single-layer Transformer can replace a stack of distinct layers in our framework, we compare Reflective Model with Flattened Reflective Model, where the former uses eight distinct Transformer layers, whereas the latter applies single Transformer layer recurrently with shared weights. The results show a comparable accuracy between the two, indicating that parameter sharing in depth can serve as a drop-in alternative to a deeper stack without degrading reasoning performance.
How does performance scale with the hyperparameter M and N? Using the results in Figure observe near-monont monotonco improvement as M increases with N fixed at 16, well captured by log-linear trend. Holding M=16 and sweeping N, the precision increases to a rapid peak before dropping, indicating early saturation and eventual regression when N becomes too large. Although larger M and moderately large N yield stronger results, they also inflate training time and slow inference. To balance accuracy with computational cost, we adopt M=N=16 as the default setting for our main experiments.
How many alignment steps should we use at test time? As shown in F6gure reducing the test-time alignment horizon steps monotonically lowers accu- racy but increases throughput (samples / s), trace a clear accuracy-speed Pareto frontier over steps (32, 16, 8, 4, 2}. Notably, for a model trained with M=16, evaluating with larger steps (e.g., 32) does not yield additional accuracy gains, indicating that the training-time horizon effectively caps test-time benefits. In practice, steps can be tuned at deploy- ment to satisfy latency budgets with a predictable ac- curacy cost, whereas pushing steps beyond the train- ing setting offers little return.
step= 16
Pareto optimal
Dominated
Step-32
step=44
Accuracy
20
step=2
10-
2.0k
6.0x
B.0k
Speed (samples/s)
Figure 6: Accuracy trade-off vs. test-time alignment steps.
4 CONCLUSION
We revisited reasoning tasks through the lens of causality and formulated them as a selection mech- anism, identifying latent space complexity and dense interdependence as key sources of difficulty. Building on these insights, we introduced SR². framework that models reasoning as iterative refinement with three components: reflective representation learning, dependency seff-refinement, and periodic intermediate alignment, instantiated by flat recurrent Transformer. Experiments on Sudoku and Maze Navigation benchmarks demonstrate that SR² achieves significant gains in rea- soning accuracy while using up to 8x fewer parameters than recent baselines. Limitations: Despite its insight, the assumption of reasoning as a selection mechanism may oversimplify the richness of human reasoning. Besides, constraints, and we leave more comprehensive evaluations on complex or open-domane tasks, as well as large-scale implementations, to future work.
evaluation is limited to benchmarks with clear and simple logical
10

---

Shaojie Bai, Vladlen Koltun, and J Zico Kolter. Multiscale deep equilibrium models. Advances in Published as a conference paper at ICLR 2026
ACKNOWLEDGMENT
We would also like to acknowledge the support from NSF Award No. 2229881, AI Institute for Societal Decision Making (AI-SDM), the National Institutes of Health (NIH) under Contract 501HL159800 and grants from Quris AI, Florin Court Capital, MBZUAI-WIS Joint Program, and the Al Deira Causal Education project.
REFERENCES
Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Ale- man, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.0874,,0000 2023.
ARC Prize Foundation. Abstraction and reasoning corpus for artificial general intelligence v2. GitHub repository. 2025.
Shaojie Bai, Zico Kolter, and Vladlen Koltun. Deep equilibrium models. Advances neural information processing systems, 32, 2019.
neural information processing systems, 33:5238-5250, 2020.
Yuntao Bai, Saurav Kadavath, Sandipan Kundu, Amanda Askell, Jackson Kernion, Andy Jones, Anna Chen, Anma Goldie, Azalia Mirhoseini, Cameron McKinnon, Carol Chen, Catherine Ols- son, Christopher Olah, Danny Hernandez, Dawn Drain, Deep Ganguli, Dustin Li, Eli Tran- Johnson, Ethan Perez, Jamie Kerr, Jared Mueller, Jeffrey Ladish, Joshua Landau, Kamal Ndousse, Kamile Lukosuite, Liane Lovitt, Michael Sellitto, Nelson Elhage, Nicholas Schiefer, Noemi Mer- cado, Nova DasSarma, Robert Lasenby, Robin Larson, Sam Ringer, Scott Johnston, Shauna Kravec, Sheer El Showk, Stanislav Fort, Tamera Lanham, Timothy Telleen-Lawton, Tom Con- erly, Tom Henighan, Tristan Hume. Samuel R. Bowman, Zac Hatfield Dodds.. Ben Mann, Dario Amodei, Nicholas Joseph, Sam McCandlish, Tom Brown, and Jared Kaplan. Consti- tutional ai: Harmlessness from ai feedback. arXiv preprint arXiv:2212.0800 08073, 2022. doi: 10.485500arxii.2212..552
Bttpsstss///axxi
/t.p//2211 08073
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models few-shot learners. Advances in neural information processing systems, 33:1877-1901, 2020.
François Chollet. On the measure of intelligence. arXiv preprint arXiv: 1ete119911..1.1 2019. URL httapss//aradw.oorr/abb////
François Chollet. Abstraction and reasoning corpus for artificial general intelligence v1. GitHub repository, 2024. URL URL//tttss:///iithu.. http:/hwwww..cccoccoccoocoo let/ARC- AGT
Luke Darlow, Ciaran Regan, Sebastian Risi, Jeffrey Seely, and Llion Jones. Continuous thought machines. arXiv preprint arXiv:2505.05522, 2025.
Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. arXiv preprint arXiv:1807.0388) 2018
Yunlong Deng, Guangyi Chen, Tianpei Gu, Lingjing Kong, Yan Li, Zeyu Tang, and Kun Zhang. Towards self-refinement of vision-language models with triangular consistency. In Advances in Neural Information Processing Systems (NeurIPS), 2025, Poster.
Yilun Du, Jiayuan Mao, and Josh Tenenbaum. Learning iterative reasoning through energy diffusion. ArXiv, abs/2406.11 1199, 2024.
Laurent El Ghaoui, Fangda Gu, Bertrand Travacca, Armin Askari, and Alicia Tsai. Implicit deep learning. SIAM Journal on Mathematics of Data Science, 3(3):930-958, 2021.
Felix Elwert and Christopher Winship. Endogenous selection bias: The problem of conditioning on collider variable. Annual review sociology, 40(1):31-53, 2014.
11

---

Published as a conference paper at ICLR 2026
Yihang Gao, Chuanyang Zheng, Enze Xie, Han Shi, Tianyang Hu, Yu Li, Michael K Ng. Zhen- guo Li, and Zhaoqiang Liu. Algoformer: An efficient transformer framework with algorithmic structures. arXiv preprint arXiv:2402.13572, 2024.
Jonas Geiping, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. Scaling up test-time compute with latent reasoning: A recurrent depth approach. arXiv preprint arXiv:2502.05/71, 2025a
Jonas Geiping, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian R. Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. Scaling up test-time compute with latent reasoning: A recurrent depth approach, 2025b.
URL https:://axiv..
arxiv. www. abs//50s222222
05171
Angeliki Giannou, Shashank Rajput, Jy-yong Sohn, Kangwook Lee, Jason Lee, and Dimitris Papailiopoulos. Looped transformers programmable computers. In International Conference on Machine Learning, pp. 1 11398-11442, PMLR, 2023.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang. Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in Ilms via reinforcement learning, arXiv preprint 1rXiv:2501.1294: 2025.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog- nition. In Proceedings of the IEEE conference on computer vision and pailern recognition, pp- 770-778, 2016.
Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. Openai ol system card. arXiv preprint arXiv:2412.16721 2024.
Mubbasir Kapadia, Francisco Garcia, Cory D. Boatright, and Norman I. Badler. Dynamic search on the gpu. In 2013 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. doi: 10.1 201///RO..01336696666
3332-3337, 2013.
Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08360 2020.
Kenji Kawaguchi. On the theory of implicit deep learning: Global convergence with implicit layers. arXiv preprint arXiv:1102.07346, 2021.
Erwin Kreyszig. Introductory Functional Analysis with Applications. John Wiley & Sons, New York, 1978.
Lucas Lehnert, Sainbayar Sukhbaatar, DiJia Su, Qinqing Zheng, Paul Mevay, Michael Rabbat, and Yuandong Tian. Beyond a#: Better planning with transformers via search dynamics bootstrap- ping. 2024a.
/2tp://www...rp/////2222122111 14083
Lucas Lehnert, Sainbayar Sukhbaatar, DiJia Su, Qinqing Zheng, Paul Mc Michael Rabbat, and Yuandong Tian. Beyond a#: Better planning with transformers via search dynamics bootstrap- ping. In First Conference on Language Modeling, 2024b.
Mingjie Li, Yisen Wang, and Zhouchen Lin. Cerdeq: Certifiable deep equilibrium model. In Inter- national Conference on Machine Learning, pp. 12998-13013, PMLR, 2022.
Jieyi Long. Large language model guided tree-of-thought. ArXiv, abs/2305.082911 2023.
Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, Shashank Gupta, Bodhisattwa Prasad Majumder, Karl Hermann, Sean Welleck, Amir Yazdanbakhssh, and Peter Clark. Self-refine: Iterative refinement with self- feedback arXiv preprint 2rXiv:2303. 17651, 2023. doi: 10.48550/ Sttii2303.1765511
http:/awww....ggbbbaao/aaaa// htspg/abs/23333 17651
John McCarthy. Mathematical logic in artificial intelligence. Daedalus, pp. 297-311, 1988.
12

---

Published as a conference paper at ICLR 2026
Amirkeivan Mohtashami, Matteo Pagliardini, and Martin Jaggi. Cotformer: A chain-of- thought driven architecture with budget-adaptive computation cost at inference. arXiv preprint 2.0.::2310..0845, 2023.
Rasmus Palm, Ulrich Paquet, and Ole Winther. Recurrent relational networks. Advances in neural information processing systems, 31, 2018.
Rasmus Berg Palm, Ulrich Paquet, and Ole Winther. Recurrent relational networks. In Neural Information Processing Systems, 2017.
Judea Pearl. Causality. Cambridge university press, 2009.
Stuart J Russell and Peter Norvig. Artificial intelligence-a modern approach, third international edition. 2010.
Noah Shinn, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. arXiv preprint arXiv:2303. 1366, 2023. doi: 10.48550/arx...333..111 11366. URL httts://arxiv.oot
abs f 2303 11366
DiJia Su, Sainbayar Sukhbaatar, Michael Rabbat, Yuandong Tian, and Qinqing Zheng. Dualformer: Controllable fast and slow thinking by learning with randomized reasoning traces, 2025.
Gemini Team, Rohan Anil, Sebastian Borgeaud, Jean-Baptiste Alayrac. Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M Dai, Anja Hauth, Katie Millican, et al. Gemini: family of highly capable multimodal models. arXiv preprint arXiv:2312. 1805, 2023.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Eukasz Kaiser, and Illia Polosukhin. Attention all you need. Advances in neural informa- fion processing systems, 30, 2017.
Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-ucsd birds-200-2011 dataset. Technical Report CNS-TR-201 1-001, California Institute of Technology, 2011.
Guan Wang, Jin Li, Yuhao Sun, Xing Chen, Changling Liu, Yue Wu, Meng Lu. Sen Song, and Yasin Abbasi Yadkori. Hierarchical reasoning model. arXiv preprint arXiv:2506.21734, 2025a.
Haozhe Wang, Qixin Xu, Che Liu, Junhong Wu, Fangzhen Lin, and Wenhu Chen. Emergent hi- erarchical reasoning in llms through reinforcement learning. arXiv preprint arXiv:2509.03644 03646, 2025b.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe Le, Ed Chi, Sharan Narang, Aakanksha Chowd- hery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint 1cXiv:2203.11171 2022. doi: 10.48550/arxiv.2233.117 bttps://aaxiss attg//////2...11111112
URI
Tian Xie, Zitian Gao, Qingnan Ren, Haoming Luo, Yuqian Hong, Bryan Dai, Joey Zhou, Kai Qiu, Zhirong Wu, and Chong Luo. Logic-rl: Unleashing Ilm reasoning with rule-based reinforcement learning. arXiv preprini 2502 14768, 2025.
Yang Yue, Zhiqi Chen, Rui Lu, Andrew Zhao, Zhaokai Wang, Shiji Song, and Gao Huang. Does inforcement learning really incentivize reasoning capacity in llms beyond the base model? arXiv preprint ar 2rxiv:2504. 138.23334....7 2025.
Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah Goodman. Star: Bootstrapping reasoning with reasoning. arXiv preprint 223. 2022. doi: 00448500/a2Xiv.2203.4444 URL
attps::/aarxx org/ abs 2t.ps//220...2 14465
Yujia Zheng, Zeyu Tang, Yiwen Qiu, Bernhard Schölkopf, and Kun Zhang. Detecting and identify- ing selection structure in sequential data. arXiv preprint 20Xi::2407..0552,
13

---

Published as a conference paper at ICLR 2026
Appendix for "Selection, Reflection and Self-Refinmmen: Revisit Reasoning Tasks via a Causal Lens"
A MORE DETAILS OF PAPER
A.1 RELATED WORK
Reasoning in Machine Learning Reasoning, the process of deriving conclusions from informa- tion through logical inference, has long been viewed central challenge for artificial intelligence. Classical approaches in symbolic Al treated reasoning as explicit rule-based deduction, but these systems struggled with scalability and generalization (McCarthy) 1988] Russell & Norvig 2010). In contrast, recent advances in machine learning have shifted toward data-driven reasoning, where models learn to approximate reasoning behaviors from large-scale corpora. Large language models (LLMS) such as GPT-o1 (Jaech et al. 2024), and Gemini (Team et al. 2023) have demonstrated impressive progress on reasoning tasks, benefiting from advances in scaling post-training. Meth- ods such thain-of-thought supervised finetuning and reinforcement learning optimization provide
improvements (Guo et al. 2025 Wang et al. 2025b Yue et al. 2025 Xie et al. 2025).
Recurrent Latent Reasoning Another line of research relevant our work is recurrent latent reasoning, where reasoning is modeled as an iterative process over hidden states or latent rep- resentations. Unlike single-pass architectures, these methods refine intermediate representations through recurrence or iterative updates, aiming to capture long-range dependencies and structured constraints. Classical instances include recurrent relational networks (Palm al. 2018), which it- eratively propagate messages between entities to perform relational reasoning. More recent work, such as Universal transformers (Dehghani et al., 20118), Algoformer (Gao et al. 2024), and Looped Transformers (Giannou et al.,
2023) Furthermore, CoTFormer (Mohtashami et al.) (023)) and Re- current Depth (Geiping et al. 2025a) enhance dependency modeling by injecting intermediate rep- resentations and original representations into each recurrent unit, respectively. The recent HRM model (Wang et al., 2025a) introduces a hierarchical recurrent structure, where high-level module responsible for slow, abstract planning, while low-level module manages fast, fine-grained com- putations. Our work shares this motivation of recurrent refinement but differs in two key aspects. First, we formulate reasoning as selection mechanism grounded in causality, which provides principled explanation for the difficulty of reasoning tasks. Second, we propose new recurrent refinement framework that incorporates an early reflection module with dense input injection, long dependency self-refinement procedure, and periodic intermediate alignment.
Selection Mechanisms in Causality Within causal inference, selection mechanisms describe how observed variables co-occur under specific constraints (Pearl (2009). This perspective has proven valuable in understanding selection bias and identifiability. Recent work (Deng et al.) 2025 Zheng et al. 2024) extends this concept beyond selection bias and shows that sequential data, such as natural language. music, and poems, inherently follow this mechanism. In this paper, we show that the reasoning task also fits this mechanism, where high-level logical concepts act as operators imposing constraints on observed inputs.
Fixed-Poine Solutions for Structured Prediction Fixed-point methods have been widely applied in optimization and equilibrium modeling, where the solution is defined as a stable point under re-
peated updates (Bai et al. [209 2020; El Ghaoui et al., 2021 Li et al., [2022] Kawaguchi] 2021> This paradigm departs from explicit layer stacking in conventional deep networks (He et al. 2016)
or Transformers (Vaswani et al. 2017) and instead characterizes representations as equilibria of nonlinear transformations. Deep Equilibrium Model (Ba et al.) 2019) (020) directly solves for the equilibrium point of a single-layer transformation using root-finding methods, thereby repre- senting infinitely deep networks with constant memory cost. In parallel, the broader field of implicit deep learning (El Ghaoui et al.] 2021; Kawaguchi (002)) has established theoretical guarantees for convergence and optimization, highlighting the potential of implicit formulations to provide com- pact yet powerful representations. Besides, iterative refinement methods (Geiping et al. 2025a) have also demonstrated effectiveness in reasoning and structured prediction tasks.
14

---

Published as a conference paper at ICLR 2026
Verbal self-correction in LLMs. A growing body of work investigates explicit self-correttion for LLMs via verbal feedback, critique, and planning. Reflexion (Shinn et al. (2023) introduces verbal self-reflection and episodic memory iteratively improve task success; Self-Refine MMddaan et al. (2023) performs critique-and-edit loops using model-generated feedback; Cof-Soonisteency [Wang et al. (2022) reduces reasoning errors by sampling and aggregating multiple chains of thought; STaR Zelikman et al.] (2022) bootstraps rationales through iterative data augmentation and fine-tuning; and Constitutional Al Bai et al. (022) uses set of principles to guide model-written critiques and refine outputs. While related in spirit, our approach differs in that SR² does not explicitly generate token sequences to steer seff-correction. Instead, the correction process is implemented implicitly through iterative updates of the latent variables (z), integrating self-correction into the latent reasoning dynamics without additional verbal overhead.
A.2 COUNTING THE LATENT AND OBSERVATION SPACES IN SUDOKU
Setup and counting argument. Consider a standard x Sudoku. Let C [1.....81] ,81} be the index set of cells and let K C C. be the indices of revealed entries in the initial grid. Define M = C K as the masked cells with |M| = n. full solution is an assignment = E [9]C that satisfies all Sudoku constraints rows, columns, and 3 3 blocks and that agrees with the revealed entries on K. Let Z be the set of full solutions consistent with the given clues and write S = 1Z].
The observation for a fixed instance is the single partially filled grid x², hence the observation space a singleton.
O 1.
We count the latent objects that we call valid solution trajectories. Starting from the initial grid and for each step f = 1,..., n we choose one still empty cell e E M \ {ci,..., c and fill it with the digit 2c², taken from some full solution Z. The partial assignment after every step must satisfy all Sudoku constraints.
Prefix feasibility. Fix any E Z. For any subset S M, the partial assignment f(c, 2(c)) T} satisfies all Sudoku constraints, since already assigns pairwise consistent digits to every row, column, and block, hence any restriction of = remains feasible.
By prefix feasibility, if we commit to one fixed = E Z then every ordering of the masked positions yields a valid trajectory. Therefore for a fixed full solution z the number of valid trajectories equals the number of permutations of M.
[<x)] = n!.
Trajectories coming from different full solutions are disjoint when viewed as ordered sequences of cell and digit pairs. Indeed, if two ordered sequences coincide then the underlying assignments agree on all masked and revealed cells, hence the two full solutions are the same. Summing over all full solutions gives the size of the latent space.
C Sn!.
Asymptotics and comparison. Using Stirling approximation we obtain
n! = 2mn (")" + o(1)) = (xp(9(n logn)). n)).
Thus for fixed board size and any fixed S in particular S = 1 for uniquely solvable puzzles the latent space grows
L
C (z)""
@(Sn!).
o
This formalizes that the latent space is much larger than the observation space for fixed instances.
Remark on stricter move policies. If trajectories are restricted to fill only logically forced cells at each step then the admissible orders are the linear extensions of a problem dependent partial order on M. Exact counting is difficult, but the bounds below always hold, which preserves the factorial upper bound.
1 / Ltoored S n!.
15

---

Published as a conference paper at ICLR 2026
A.3 THEOREM (EXISTENCE OF CONVERGENCE SR
Let f: X + 2 be the shared update function used in both the Reflection and Seff-Refinemet
stages of SR Define the update rules:
Reflection:
2 = f(= .,..,, M
Self-Refinement:
2²+1 = f(z',0), 2
(A1) Completeness The latent space (2, || (I) is complete metric space, and for any fixed input x E E, a() maps to itself.
(A2) Contraction There exists constant L E (0, 1) such that
(1) f(= S ||2| =2|1-
(10)
for all 21,22 E Z and (z.
Then:
(i) Each update function f(-,z) and f(- 0) admits unique fixed point = and zÿ, respectively.
(ii) The iterative sequences defined by Reflection and Self- Reff-Refinement converge to their corre- sponding fixed points:
2 fort < M, and 2' + z for 2 M.
Proof. Step 1. Define the contraction operators. Define two operators on the latent space: (2(2) == f(2,x), To(z) == f(z, 0). By assumption (A1), both Tp and To map into itself.
Step 2. Show that T2 and To are contractions. By (A2).
(2,( - (22) [[f(zz. - f(22, x)1l & L|| - 22ll.
and similarly for To. Hence, both Te and To are contraction mappings on the complete metric space -1-)).
Step 3. Apply the Banach fixed-point theorem Kreyszig 1978). By Banach's 's theorem, every contraction on complete metric space has a unique fixed point, and successive applications of the map converge to it. Thus, there exist unique points 2, 20 E Z such that
= To(z)) = Moreover, for any initialization. 20 E Z,
Tx(21)
+11 Ta(z²) = z¹ + _41 To(z*)
Step 4. Apply the result to SR dynamics. In SR2, the reflection phase iterates T. for a finite number of steps (M). Therefore, after sufficiently many steps, the latent variable .M approaches 2/ The self-refinement phase then iterates Ty starting from ZM, so by Banach's theorem, 2t + 20 as t Co.
Conclusion. Under mild contraction and completeness assumptions (standard implicit and equilibrium formulations) the SR² updates possess unique equilibria for both reflection and self- refinement, and their iterative applications converge these equilibria. The theorem guarantees existence of convergence for the latent representations and therefore for the predictions of SR D
B A MOTIVATING EXAMPLE
We have thoroughly discussed in the main text the necessity of incorporating latent variable recur- rence into the update process. Whether through a selection mechanism that guides the represen- tation, or via fixed-point iterative formulation, the current arguments focus the existence of
16

---

Published as a conference paper at ICLR 2026
latent optimal state 2* such that the iterative update 2(1) f(x, ((=)) converges, in which case the introduction of last latent state g(t-1) into the estimation of 2 matters.
However, one critical question remains unresolved: why insufficient-or fundamentally dif- ficult-to learn a high-quality latent representation using only the observation i.e., through direct mapping 2 = g(x)? Towards this question, we consider a simple yet illustrative example using a linear state-space model:
( E (0, Po),
1 Az why A Rudd
wy N(0, Q),
(11)
(0 = Cz Ut, Ce Rm Ut ~ N(0, R),
with 0, 0, and the observation is under-determined m < d.
Our objective is estimate the hidden state 2(1:2) from the observation (:(:T) only. We compare two formulations: (1) estimating 2(4) using only z(1), and (2) estimating z0() using both (1() and
2(t-1), We demonstrate that modeling the explicit dependence on 2tt-1) constrains the solution space and improves the conditioning of the estimation problem. In contrast, estimating (4) directly from 2(() alone is generally ill-posed.
Specifically, the second formulation by incorporating 2(t-1) a recursive structure that leads to unique maximum a posterior (MAP) estimate under mild assumptions. It leverages both the observation likelihood and the latent dynamics prior, thereby regularizing the solution and re- solving ambiguity. In contrast, the first formulation estimates solution lies affine subspace determined by the null space of C, making it non-unique.
29)) solely from x(*) and thus its
B.1 DIRECT ESTIMATION USING OBSERVATION ONLY
Estimating 2() through (+) without considering the history information amounts to maximize the
likelihood ((=())=(9) at each time step. Since the observation is linear mixing of latent variables and Gaussian noise according to equation 11
2211 (0C2(0,,)
(12)
Consider all time steps, as long as the (0) is conditional independent with all other variables given 20)) for all time steps, the conditional distribution:
T
((
N (x C2(9, R)
(13)
(2tT m// exp -- (x CC21))TTT
11 -((())))))))
Take the log,
log p (1:7) (1:T))
-C(0)) C2(t)) log 2T log [R]. (14)
Our goal is to estimate (1) by maximizing the likelihood above, we further stack the observations and latent variables as:
(1)
(2(1)
X
E RT z =
E Rd
(15)
(1)
(0)
and define the block- diagonal matrices
C
07
R
0
07
0
0
R
C.
E
R
TxdT
R
R Tx
(16)
C
0
0
R
17

---

Published as a conference paper at ICLR 2026
Maximizing equation 14 over z equivalent to minimizing
(z)) = 2 (x - C.z) T R2 (x C2Z),
(17)
where all constant terms are dropped. The first order optimality condition is
C. R (Cbz x)= 0.
(18)
Since rank C.) < mT < df, the matrix B == C² Cs is singular and the solution set is an affine subspace; the obtained 2 is non-unique and ill-posed.
B.2 INCORPORATE HISTORY VIA A DYNAMIC PRIOR
We note that explicitly consider the contribution from last latent state into the estimation of current state is exactly the Bayes rule that maximize the posterior, whose form
12 (2:00) (p((())
p(x11:T)
((x
(1122)) (p(2(11))
(19)
T
T 1(2(0)200)
p(2 (==))=)--)))((11)1
Take the log, we have
p( (2:10 12 (12))) x
Σ log 100000000000 +
Σ 1o log ((g)()
(20)
In this content, maximizing the posterior above is equivalent to minimize the following log terms where all terms not depending on z are dropped:
Initial prior
logp(=(1) = ---1 - mn)² Po -Mo).
(21)
Transition prior
log logr(> ((2 12 ))= -=--(-0-AAA---11-- -00 -10-))))-)))) 12
(22)
Likelihood
-12 14 (z) (z(())
log (220))))(0))
(23)
Similarly, we can stack observations and latents as equation 15 steps is
the negative likelihood over multiple
log (1T)
log (0
Coz)² " R (x- - C..)
z' C R, 'C,z - x" x²R,,"" Cbz + constant (24)
Bz h imaa z + constant,
where we simplify the notation as B = C Ri CC, and hdata := C. 'x. Expand the negative transition prior, we have
llo log (00 ((
= zz 201) 211(())
1 -1(1-1)" -T A-Q-12(1)
(25)
(1) Q- A2(t2( + 20111) A=Q (t(1-1)
18

---

Published as a conference paper at ICLR 2026
Expand the negative initial prior
log (0gp(z()))
1 (1)
Po 1 2200"Ppp'
Po '
constant.
(26)
Expand the prior terms all time steps and collect coefficients of the stacked quadratic z (-)z. The resulting block- triccdigaa weighting matrix is
Po ATQ-'A A -Q-1A
-TTQ-' Q'+A'Q
-ATQ-
Dayn
E IR ITdxd
Q A Q + +A
A
-ATQ-!
-Q-1A
Q
(27)
Similarly, collect coefficients of the stacked linear term (.) 2. There is no linear term from the dynamics 2, ...... . T; only the prior mean contributes, in which define
Po Hd
hinit
(28)
Now collect everything, maximizing the posterior in equation 20 is equivalent minimize
(B++ (haat + h T constant.
(29)
As long as Q and Po is positive definite, and B is positive semi-definite, there summation should also be positive definite. Thus, the Jzz is strictly convex and the solution is unique.
C IMPLEMENTATION DETAILS
Data Preparation. For the Sudoku-Extrent training set, we follow the HRM configuration and apply band and digit permutations to each training instance, generating 1,000 augmented variants per example. No data augmentation used for Maze-Hard. All baselines are trained and evaluated on the same fixed training and test splits.
Model Architecture. To ensure faimess, every baseline uses exactly the same Transformer-layer implementation as its atomic building block: one attention layer, one MLP, and an RMSNorm. The Transformer-layer hyperparameter (e.g., hidden size) and the initialization scheme kept identical across all baselines.
Training Protocol. All baselines adopt common backbone and therefore share the same op- timization settings, including learning rate, batch size, optimizer, and loss function. Concretely, all experiments learning rate of 1 10 batch size of 768, and the AdamAt an2 opti- mizer, with an identical loss function across methods. Each baseline is trained for 60,000 epochs on SUDDOK--ETREMF and, separately, for 60,000 epochs MAZE-HARD.
Hardware and Runtime. All training runs are executed on 8x AMD MI210 (64 GB) GPUs. The and approximately
average wall-clock training time is approximately 1h for 15h for MAZE-HARD.
In training and test cost analysis, all measurements were obtained under identical training hyper- parameters using eight AMD MI210 64 GB GPUs. Speeds are reported as batches per second for training and samples per second for inference, with memory averaged per GPU across the eight de- vices and inference speed computed from total samples divided by wall clock time on the Sudoku Extreme test set.
19

---

Published as a conference paper at ICLR 2026
D PSEUDO CODE
Hyper-parameters and components
5
m
number of inner iterations per block (e.g., 16) number of outer blocks per batch (e.g., 16)
6
n
the ONLY recurrent transformer layer
readout head producing y from 2 Opt optimizer over parameters of I and Head
Head
10
Loss
i criterion, e,g., cross-entropy / 12
14
def init_state (batch)
15
*=*20 - 0 for each batch.
return zeros like_state (batch)
18
19
Training 1oop
20
for epoch in range (num_epochs):
for batch in Dataloader:
23
x, target batch
34
z = init_state ('bachhsiiee # 2.0 0
25
---- Periodic Alignment
27
for block idx range (1, 1):
28
29
opt.cerr__rralsst__toooo-oe-e (set_to_nnne--rrue we update once per block
Flat recurrent Transformer for t range (1, + 1):
32
33
34
if block_idx == 1:
# Only in the 1st block do reflection injection of Inject both and the previous into next 2. Reflective Represent Learning
36
37
38
inn ReflectFuse x)
e1 se:
From the 2nd block on, DO NOT inject anymore use only
41
2
| One layer applied repeatedly (weight sharing) same layer, different
(i_inn) time step
45
46
# End of block: produce y and train inrediately Y_pred Head (z)
t predict from current z
cur_target target it is_scalar label (target) else target block__idx
50
loss Loss (y_pred, cur_target) backprop within this black only loss. basswacckarrd)) ste.
53
54
$ update T and Head now
Detach for the next block Break the graph so gradients from next block cannot # flow back into the current/provicn blocks.
58
2 z.detach ()
20

---

Published as a conference paper at ICLR 2026
Train/Rest Accuracy
100
Test
Trann
Me-2 1-4
M-6
M4-3 Tran
M-n
80
R-4 Tran
Mi-5 Ban
M-4 Test
60
Accursiy
40
Epoch
Figure 7: Analysis of the applicability of SR². M denotes how many times we forward the model within a single alignment (supervision) step.
We provide the pseudo code for SR². This pseudo code serves as high-level description of the algorithm's workflow, outlining its computational steps and logical structure.
E ANALYSIS OF SR2 APPLICABILITY
From another perspective, not all tasks require iterative updates. For relatively simple problems such as image classification where the mapping from input to output more direct and the latent space is less entangled, single forward pass is often sufficient. To probe this, instantiated the SR² architecture on CUB-200-2011 (Caltech-UCSD Birds 200-2011) Wah et al. (2011). fine- grained classification benchmark, using the same backbone and comparable parameter budget standard ViT baseline, identical training data splits, and conventional top-1 accuracy protocol. As summarized in Fig. 7 the ViT baseline attains roughly 75% top-1 accuracy, whereas SR equipped with Reflection and Reif-Refinement reaches under 45%. This gap, together with the learning curves in the figure, supports our claim that iterative refinement especially advantageous in complex constraint-satiifactiooo or reasoning settings, but offers limited benefits and can even be detrimental when the latent structure is comparatively simple and direct, as standard classification.
DISCLOSURE OF LLM USAGE
In accordance with the ICLR 2026 policy on the use of Large Language Models (LLMss), we disclose that LLMs were used solely to assist with grammar refinement and language polishing in this paper. No part of the research ideation, experimental design, implementation, or analysis relied on LLMs. The authors take full responsibility for the technical content and conclusions of the work.
21


Reviews:
[{"review_id": "WSkk4Jw2An", "reviewer": "Reviewer_qWVm", "summary": "This paper proposes a novel causal formulation of reasoning tasks, framing them as selection mechanisms in which logical concepts act as operators that constrain observed inputs. Building on this, the authors identify two key hypotheses—latent space complexity (the reasoning latent space is exponentially larger than the observation space) and dense interdependence (latent variables are strongly coupled)—as root causes of reasoning difficulty. To address these challenges, the authors introduce SR² (Selection, Reflection, and Self-Refinement), a framework that explicitly models iterative latent-space refinement. SR² includes three modules: (1) reflective representation learning that iteratively updates latent variables conditioned on inputs, (2) dependency self-refinement that enforces latent consistency by removing input signals, and (3) periodic alignment to stabilize training. The approach uses a flattened recurrent Transformer architecture and is evaluated on Sudoku-Extreme and Maze-Hard reasoning benchmarks, achieving up to 10% higher accuracy with 8× fewer parameters than prior state-of-the-art models (e.g., HRM).", "questions": "Q1: Authors state that the latent space is “exponentially larger” than the observation space. Is this a theoretical claim that can be formalized (e.g., by counting admissible configurations in Sudoku), or an empirical observation? How could one measure latent complexity in your setup?\n\nQ2: The system is majorly motivated from selection mechanism, however the system is more inherited from DEQ or Implicit Deep Learning frameworks. How does SR² differ theoretically from them? Is there any convergence guarantee for your fixed-point iterations?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "* Novel causal perspective: Formulating reasoning as a selection mechanism is a theoretically original angle connecting causality and reasoning.\n* Well-structured SR² pipeline: The three-module design (reflection, self-refinement, periodic alignment) is coherent and practically motivated by the stated hypotheses.\n* Strong empirical results: Outperforms HRM (ICLR 2025) by 11.6% on Sudoku-Extreme and 19.2% on Maze-Hard, showing competitive reasoning ability with much smaller models.", "weaknesses": "* Limited empirical scope: Evaluations on Sudoku and Maze tasks, while useful, do not establish general reasoning improvement beyond symbolic settings. It would be interested to see if the approach can be applied to more open-ended domains such as math problem with natural language as the interface. How SR² behaves under large-scale LLM reasoning (e.g., text-based chain-of-thought) is not explored.\n* Ablations vs. causality: While the causal “selection mechanism” framing is conceptually appealing, the improvements could be fully explained by iterative refinement and alignment, independent to the causal lens.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "MEw9ddkJBt", "reviewer": "Reviewer_o7wn", "summary": "This paper interprets reasoning tasks such as Sudoku and maze solving as modeling problems governed by latent variables that act as selection constraints. It argues that the latent space underlying reasoning exhibits high complexity and strong interdependencies among variables, which explains why existing models still struggle to reason effectively even after large-scale training. This paper proposes a new reasoning framework SR^2, designed to model these latent dependencies and iteratively refine latent variables. SR^2 outperforms recent baselines such as the Hierarchical Reasoning Model (HRM), achieving higher performance with fewer parameters, which supports the motivation and design of the proposed framework.", "questions": "How does the framework model the process described by Eq. 1? e.g., how are the rule variables z represented, and how do they enforce corresponding constraints within SR^2? Which part of SR^2 corresponds to the function g in Eq. 1?\n\nAre there difficults that prevent SR^2 from handling ARC-style reasoning tasks?\n\nThe paper claims that SR^2 “explicitly integrates Selection, Reflection, and Self-Refinement.” How is the Selection component concretely implemented in the architecture?\n\nCompared to previous SOTA methods, how does the training cost of SR^2 (in time or memory) scale?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 3, "strengths": "The proposed framework redefines reasoning as a latent-variable-based constraint mechanism, explaining the difficulty of reasoning tasks through the perspective of latent complexity and dense dependencies.\n\nThe SR^2 architecture consists of selection, reflection, and self-refinement modules, which directly models and optimizes latent variables, achieving improved performance on Sudoku and Maze tasks with a smaller parameter budget.", "weaknesses": "The connection between Eq. 1 and the proposed framework remains unclear. Eq. 1 defines a generative process from latent rule variables z to observed pairs (x, y) and introduces the notion of selection constraints S derived from z. However, the way these elements are instantiated or represented within SR^2 is not clearly explained.\n\nThe experiments do not include the ARC task, leaving the reasoning ability insufficiently validated.\n\nThis paper lacks discussion of the training cost. If supervision is applied to different hierarchical levels of latent variables z, the model may face risks of gradient instability, potentially increasing computational overhead.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "lxHWcd3F8O", "reviewer": "Reviewer_v12F", "summary": "This paper frames reasoning tasks as causal selection mechanisms, where latent reasoning rules constrain observed space. The authors propose two hypotheses including 1/ latent space complexity exceeding observations and 2/ dense interdependencies among latents. Based on these two hypotheses, the authors propose the SR2 framework to address the challenges involved in reasoning. Specifically, SR2 integrates a reflective representation learning module, a dependency self-refinement module, and a periodic alignment module. Evaluations on Sudoku and Maze show >10% accuracy gains over Hierarchical Reasoning Model (Wang el al., 2025) with 8x fewer parameters.", "questions": "The introduction mentioned scaling-based progress (e.g., Kaplan et al., 2020). With your efficiency gains, do you foresee SR2 scaling to frontier LLMs, or is it better suited for smaller, specialized models?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 2, "contribution": 2, "strengths": "1. The causal lens provides a structured view of reasoning difficulties, potentially useful for latent modeling in ML.\n2. Hypotheses on latent complexity and dependencies are insightful and well-illustrated with examples like Sudoku.\n3. Empirical gains in reasoning efficiency when model size is small.", "weaknesses": "1. As acknowledged by authors, benchmarking of this paper is limited to Sudoku and Maze Navigation with clear and simple logical constraints. This may limit the claims of generality. Suggesting adding additional evaluations on STEM tasks. \n2. Missing discussion of related work. The reflection framework of SR2 is related to the established line of work on self-correction techniques. For example, the Reflexion paper (Shinn el al., 2023) introduced verbal self-reflection.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "PwQgE9x95E", "reviewer": "Reviewer_nGiF", "summary": "This paper formalize reasoning problem as selection mechanisms through a causal perspecitive. Based on this formulization, the paper summarizes two hypothesis in reasoning tasks, which inspires the SR2 framework. The framework define reflection as a fixed-point problem and used a flatten recurrent transformer to solve it. Further, the dependency self-refinement and periodic alignment are proposed to learn dependency and formalize training.", "questions": "1. In Ln. 162 - 169, is there a formal representation of $\\mathcal{S}$ or $z$? E.g. How is $z$ represented by $x, y$? I think as an example it should illustrate how to formalize rules in reasoning problems into selection variables $z$ and constraints $S$, instead of leaving an abstract expression as in Eq. (2).\n2. What is the motivation of formalizing $z$ as the solution a fixed-point equation (3)? How is this related to hypothesis 1? The connection is unclear.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. The idea of formalizing reflection as a fixed-point equation is novel and interesting. \n2. The proposed method achieved good performance on Sudoku-Extreme and Maze-Hard dataset with less number of parameters.", "weaknesses": "1. The paper is a bit hard to follow (See question 1-2).\n2. A general performance comparison with baselines are missing, including training / test cost. \n3. Adding more benchmarks (e.g. ARC-AGI) would be helpful. One of my concern on proposed framework is the fixed-point formulation may only works for problems with specific structure, not all reasoning tasks.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)