Generative Recursive Reasoning | Summary

This article explains the key points of Generative Recursive Reasoning.

• 2026-05-19 (arXiv), 40th Conference on Neural Information Processing Systems (NeurIPS 2026)
• Baek, Junyeob, Jo, Mingyu, Kim, Minsu, Ren, Mengye, Bengio, Yoshua, Ahn, Sungjin.
• KAIST, Mila – Québec AI Institute, New York University, Université de Montréal
• Paper
• Project Page

Read this article in Korean

Summary

• Generative Recursive Reasoning addresses how a compact neural network can explore alternative solutions while repeatedly refining an internal state. Its Generative Recursive reAsoning Models (GRAM), which sample internal reasoning paths, achieve 96.1% accuracy on Sudoku-Extreme, a benchmark of minimally clued 9×9 puzzles, using 20 parallel paths and 16 refinement iterations, compared with 92.1% for TRM, a deterministic recursive baseline, using 320 iterations at nearly matched computation.
• GRAM adds a learned Gaussian perturbation, random noise with a state-dependent mean and variance, to each deterministic state update and trains with variational inference, which approximates otherwise intractable inference over internal paths. Single-path results improve over TRM: 86.6% versus 83.6% on Sudoku-Extreme, 50.3% versus 44.6% on ARC-AGI-1, and 9.5% versus 7.8% on ARC-AGI-2; ARC-AGI tests abstract visual transformations from a few examples, with these results using voting over 1,000 transformed inputs and allowing two submitted answers.
• GRAM also reaches 100.0% accuracy with 20 samples on both tested N-Queens board sizes, where queens must be placed without attacking one another, and generates 99.05% valid Sudoku boards over 100K samples from empty inputs. The evidence covers controlled puzzles and handwritten digits converted to binary pixels; sequential training and a biased approximation to the full training objective constrain the demonstrated approach.

1 Introduction

Recursive Reasoning Models (RRMs), networks that repeatedly update a persistent internal state using shared parameters, increase computation without extending the output sequence or increasing parameter count. Existing deterministic models follow the same path for a fixed input and initialization, limiting their ability to explore alternative solutions across repeated runs.

• GRAM treats the reasoning trajectory, the sequence of internal states, as a random variable. This adds parallel trajectory sampling to the option of increasing recursive depth.
• The paper tests structured reasoning, tasks with multiple valid solutions, and unconditional generation, meaning generation without an informative input. Compact recurrent baselines address the architectural comparison; general-purpose large language model results serve as external reference points.
• The project URL provided by the paper is https://ahn-ml.github.io/gram-website/.

The schematic connects multiple valid outputs to the proposed computation: repeated deterministic runs coincide for fixed input and initialization, while sampled paths can reach different completions. It presents the intended mechanism rather than measured coverage.

2 Generative Recursive Reasoning Models

GRAM defines recursive reasoning as a latent-variable generative process: unobserved internal trajectories determine the output distribution. The method comprises an architecture for stochastic state transitions, a training procedure, and inference procedures that allocate computation across recursive depth and parallel paths.

2.1 Architecture

The encoder computes an input embedding, a numerical representation of the input, once and reuses it throughout recursion. Starting from a fixed state, each transition computes a deterministic proposal and adds learnable stochastic guidance: \(\epsilon_t\sim\mathcal{N}\!\left(\mu_\theta(u_t),\sigma_\theta^2(u_t)I\right),\qquad z_t=u_t+\epsilon_t\).

• Here u_t is the proposal, ε_t is the perturbation, and z_t is the resulting state. The learned mean controls the perturbation’s direction, while its variance controls exploration.
• In the hierarchical implementation, z = (h, l): the high-level state h carries slower abstract computation, and the low-level state l undergoes K deterministic refinements before each high-level update. Guidance is added only to the high-level update, and the decoder, which maps internal states to outputs, reads h.
• A supervision step contains T transitions and ends with decoding and application of a training objective. Its final state initializes the next of N_sup supervision steps; empty conditioning enables unconditional generation.

The diagram places stochastic guidance after the deterministic high-level proposal and distinguishes the target-conditioned training posterior from the inference prior. Its loss connections show output cross-entropy, a prediction-error objective, and the KL penalty aligning the two transition distributions.

2.2 Training

The conditional model integrates over trajectories: p_θ(y | x) = ∫ p_θ(y | τ, x)p_θ(τ | x)dτ, where x is the input, y the target, and τ the internal trajectory. Training samples from a variational posterior q_ϕ(τ | x, y), an approximate trajectory distribution that observes the target; inference samples from the learned prior p_θ(τ | x), which has no target access.

• The evidence lower bound (ELBO), a tractable lower bound on log likelihood, combines an output reconstruction term with Kullback–Leibler (KL) divergence, a discrepancy penalty between posterior and prior transitions. The prior and posterior heads, modules predicting perturbation distributions, have identical architectures and separate weights.
• The full trajectory objective includes KL contributions at every transition. Practical training applies deep supervision, an objective at successive refinement stages, and propagates gradients only through the final transition of each supervision step.
• This produces a biased, memory-efficient surrogate for the full ELBO. Earlier states are detached from gradient computation, and an auxiliary head learns when computation can halt.

2.3 Inference-Time Scaling

Inference computation scales through depth, the number of recursive transitions, and width, the number N of independently sampled trajectories. Each trajectory uses the learned prior and produces a candidate prediction; majority voting selects the most frequent complete prediction without additional selector training.

• Increasing width adds computation while preserving the sequential recursion length. Independent paths can execute together in a batch.
• Appendix A.4 describes an optional learned candidate selector, but the reported experiments use majority voting.

3 Related Work

The related work connects latent reasoning, intermediate computation in internal representations, with recurrent architectures and probabilistic state-space models, which describe stochastic evolution of hidden states. GRAM uses these stochastic transitions for reasoning computation rather than for modeling temporal observations. For latent reasoning, see Dynamic Large Concept Models: Latent Reasoning in an Adaptive Semantic Space | Summary.

• Recurrent Transformers reuse network parameters across refinement steps. GRAM extends this computation with a distribution over paths.
• Probabilistic recurrent models supply the variational modeling framework. GRAM applies it to recursive reasoning, parallel exploration, and generation.

4 Experiments

The experiments distinguish single-sample performance, N=1, from performance with 20 sampled trajectories, N=20. Single-sample evaluation excludes selection among multiple inference paths, while multi-sample evaluation measures the additional benefit of exploration and voting.

• Tasks cover Sudoku-Extreme and ARC-AGI, multiple-solution N-Queens and Graph Coloring, and unconditional Sudoku and binarized MNIST, a handwritten-digit dataset converted to binary pixels.
• Baselines include direct prediction in one forward pass, deterministic recursive computation, and generative sampling. The experiments probe the proposed computation on controlled tasks.

4.1 Challenging Puzzle Tasks

On Sudoku-Extreme, GRAM obtains 86.6±2.2% accuracy with one sample and 96.1±0.9% with 20 samples at 16 supervision steps, versus TRM’s 83.6±1.3% at 16 steps. On ARC-AGI-1 and ARC-AGI-2, GRAM obtains 50.3±2.3% and 9.5±2.5%, compared with TRM’s reported 44.6% and 7.8%.

• Sudoku recursive baselines are reproduced using official code and configurations and averaged over three seeds, or independent training runs. Table 8 specifies that the ARC-AGI baseline scores come from the original papers.
• ARC-AGI uses pass@2, counting a task as solved when either of two submitted predictions is correct. Predictions are aggregated over 1,000 rotations, reflections, and color permutations, with one GRAM trajectory per transformed input.
• Looped Transformer, a baseline that repeatedly applies shared Transformer blocks, is omitted from ARC-AGI because of its estimated training cost. External large reasoning model scores use different evaluation conditions.

GRAM leads the plotted deterministic recursive baselines with a single trajectory on all three benchmarks. The additional Sudoku segment shows the gain from 20 samples, while ARC-AGI already aggregates transformed inputs; the external language-model bars use different evaluation conditions.

At 16 Sudoku iterations, increasing GRAM’s sample count from 1 to 5 to 20 raises accuracy from 86.6% to 93.6% to 96.1%; each iteration is one supervision step. At nearly matched computation, GRAM uses 8.48 TFLOPs, trillions of floating-point operations, per puzzle and 184 ms with 20 samples, while TRM uses 8.19 TFLOPs and 2,755 ms with 320 sequential iterations.

• The latency experiment uses identical hardware with one puzzle in flight and batches GRAM’s parallel samples.
• Table 10 reports the more precise accuracies as 96.06% and 92.15%, a +3.9 percentage-point difference and 15.0× latency advantage with +3.5% computation.
• These latency measurements apply to the reported single-request batching regime; saturated multi-request serving is not evaluated.

The left panel separates gains from longer recursion and more sampled paths; the right compares their computation costs. The nearly matched-compute configurations favor GRAM's parallel exploration, with curves reporting three-seed means and standard deviations.

4.2 Multi-solution Puzzle Tasks

N-Queens requires completing a board so that no queens share a row, column, or diagonal; Graph Coloring assigns colors so that adjacent vertices differ. The experiments use 8×8 and 10×10 boards and graphs with 8 or 10 vertices, reporting valid-output accuracy for N-Queens, conflicting-edge counts for Graph Coloring, and coverage, the fraction of valid solutions recovered with 20 samples.

• On 8×8 N-Queens, single-sample GRAM reaches 99.5±0.3% accuracy, versus at most 78.7% among deterministic recursive baselines. With 20 samples, GRAM reaches 100.0% on both board sizes and coverage of 89.7±1.7% and 57.5±3.4%.
• Generative comparisons include an autoregressive Transformer, which predicts tokens sequentially, and MDLM, a masked diffusion language model that iteratively fills masked tokens. GRAM has the highest coverage on all four tasks; the autoregressive baseline has slightly higher single-sample 10×10 N-Queens accuracy, 90.0% versus 89.7%.
• For 10-vertex Graph Coloring with 20 samples, GRAM reports 3.3±1.5 conflicts and 51.3±2.8% coverage, versus MDLM’s 12.0±7.0 and 48.2±1.4%. On 8-vertex graphs, both report a mean conflict value of 2.7.

The table distinguishes producing a valid answer from recovering alternative solutions. GRAM has the highest reported coverage across all four settings, but the autoregressive baseline has slightly higher single-sample 10×10 N-Queens accuracy, and MDLM ties GRAM's mean 8-vertex conflict value at 20 samples.

4.3 Exploring GRAM as an Unconditional Generator

With empty conditioning, GRAM generates complete outputs from its learned prior. On Sudoku generation it produces 99.05% valid boards over 100K samples using 10.9M parameters and 16 inference steps, versus 79.18% for a 55.1M-parameter D3PM, a discrete-state denoising diffusion model, using 1,000 steps; all valid boards are unique under exact matching.

• On binarized MNIST, Inception Score (IS), an image-generation score for which higher values are preferred, rises from 1.89 to 2.04 as GRAM increases inference steps from 16 to 256. Fréchet Inception Distance (FID), an image-distribution discrepancy score for which lower values are preferred, falls from 77.79 to 73.34; the paper calculates FID against real images with original pixel values of 0–255.
• At 256 steps, GRAM exceeds D3PM’s IS of 1.86 and improves on its FID of 74.03 at 1,000 steps. At 16 steps, GRAM has better IS but worse FID than D3PM, while outperforming the variational autoencoder (VAE), a latent-variable encoder–decoder baseline, on both metrics.
• TRM produces nearly constant digit outputs, with IS 1.00 and FID 303.29. Figures 6 and 7 illustrate GRAM revising complete candidates, including early mistakes, during recursive refinement.
• GRAM trains with 16 supervision steps. Additional inference steps improve both reported MNIST metrics, but a supervision step and a diffusion denoising step perform different computations.

Increasing GRAM's inference steps improves both digit-generation metrics beyond its training depth. GRAM surpasses D3PM on both metrics at 256 steps, whereas at 16 steps its FID remains worse; the different meanings of a model step prevent equating step counts with computation.

The validity comparison favors GRAM despite its smaller parameter count. The plotted values are rounded; the detailed results give 99.05% for GRAM and 79.18% for the larger D3PM baseline.

The examples show GRAM revising an initially ambiguous digit through recurrent updates, while deterministic TRM produces nearly identical outputs across samples. These selected trajectories illustrate behavior consistent with the quantitative generation results.

4.4 Ablation Study

The architecture ablation, which compares variants with selected components added or removed, adds deep supervision, hierarchical recursion, and stochastic guidance to a Looped Transformer baseline. Guidance improves the flat baseline, while the full combination yields 96.1% Sudoku accuracy and 100.0% 8×8 N-Queens accuracy with 20 samples.

• Removing the learned mean while retaining stochasticity preserves Sudoku performance at 96.0% but reduces N-Queens accuracy to 62.1%. Removing stochasticity while retaining the learned mean yields 0.0% on both tasks in this ablation.
• Sampling the next state directly instead of adding a residual perturbation gives 70.7% on Sudoku and 98.8% on N-Queens. The residual design performs more consistently across these two tasks.
• Randomizing TRM’s initialization reaches 91.2% Sudoku and 71.4% N-Queens accuracy with 20 samples, below GRAM’s 96.1% and 100.0%. Sampling decoder outputs also falls short, supporting learned stochastic transitions over these tested randomization strategies.

The architecture comparison supports combining supervision, hierarchy, and stochastic guidance. Removing the guidance mean largely preserves Sudoku performance but substantially harms N-Queens, while retaining the mean without stochasticity fails in both tested settings.

GRAM proposes a full board early and revises conflicting entries, whereas D3PM progressively fills cells. This example illustrates different refinement behavior; the aggregate validity experiment supplies the comparative reliability evidence.

5 Conclusions and Limitations

The paper concludes that probabilistic recursion supports conditional reasoning, multiple-solution discovery, and unconditional generation while adding width as an inference scaling option. Its explicit scaling limitation is the sequential nature of deep supervision, which reduces training efficiency relative to Transformers and obstructs expansion to larger foundation models.

• The experiments establish these properties on controlled tasks; general language reasoning and foundation-model-scale training are not evaluated.
• The implemented gradient updates optimize a truncated surrogate of the full trajectory-level variational objective.

Broader Impacts

The authors identify constraint satisfaction and scientific problem solving as possible applications where uncertainty and multiple solutions matter. They also identify risks from treating plausible invalid outputs as verified solutions and from the computation and energy costs of multi-sample inference; real-world deployment would require validation, uncertainty calibration, meaning checks that confidence reflects correctness, and domain-specific safeguards.

Appendix

• A Additional Method Details and A.1 Algorithms give training and inference pseudocode using the same transition function. Training draws guidance from the target-conditioned posterior, updates parameters after supervision steps, and detaches carried states; inference draws from the prior, disables halting for fixed-depth comparisons, and selects by majority voting. A.2 Empirical Validation of the Surrogate Objective compares the practical surrogate with the full trajectory ELBO on Sudoku-Extreme and 8×8 N-Queens during training. Both improve overall, supporting the surrogate’s usefulness in these experiments. Their numerical values differ because the full ELBO accumulates KL terms across all transitions, while the surrogate includes only the final-transition KL of each supervision step. A.3 Adaptive Computation Time describes learned stopping through an auxiliary head that estimates the value of halting or continuing. The released implementation uses the simpler condition σ(q_halt)>0.5, where σ is the sigmoid function mapping the halt score to a value between 0 and 1. A.4 Latent Process Reward Model (LPRM) describes an optional value head predicting final-output correctness for best-of-N selection, which chooses the highest-scoring candidate; the reported experiments use majority voting.
• B Training and Architecture Details, including B.1 Architecture Details, specifies a shared recursive network, separate prior and posterior guidance heads, 16 puzzle embedding tokens, hidden dimension 512, and 8 attention heads for the Transformer backbone. Each supervision step contains T=3 transitions, with K=6 low-level refinements for Sudoku-Extreme and K=4 for other tasks. The initial state is sampled once and saved in the checkpoint; Sudoku uses a different recursive-core block following TRM, and binarized MNIST uses a convolutional patch encoder that converts local image regions into sequence representations. B.2 Training Details reports AdamW, an adaptive optimizer with decoupled weight decay, using learning rate 10⁻⁴, weight decay 1.0, global batch size 768, exponential moving average decay 0.999 for smoothing model parameters, KL balancing coefficient 0.8, and 16 supervision steps. The KL weights are 0.1 for Sudoku, 0.04/0.1 for ARC-AGI-1/2, 0.07/0.045 for N-Queens 8×8/10×10, 0.5/0.45 for Graph Coloring with 8/10 nodes, and 0.015 for binarized MNIST. Table 7 reports training on NVIDIA RTX 4090 GPUs, including 5 days on 8 GPUs for ARC-AGI. For unconditional Sudoku, B.2 Training Details uses 50K complete training solutions with clue patterns discarded, no augmentation, 200 training epochs, KL weight 0.05, and 16 inference steps. Both D3PM sizes train on the same derived dataset. The binarized-MNIST models contain 15.81M parameters for VAE, 18.07M for D3PM, 15.82M for GRAM, and 10.90M for TRM, giving comparable but unequal parameter counts.
• C Additional Details of Experiment Setup and C.1 Challenging Puzzle Tasks specify ARC-AGI’s 1,000 transformed inputs, inverse mapping, voting, and pass@2 evaluation. A full Looped Transformer ARC-AGI training run is estimated at approximately 97 days, or ≈776 GPU-days, explaining its omission. This estimate extrapolates measured step time to the training budget; the appendix also identifies the baseline’s lack of deep supervision and adaptive halting as sources of training cost. C.2 Multi-solution Puzzle Tasks constructs N-Queens inputs by removing k∈{5,6,7} queens from 8×8 solutions and k∈{7,8,9} from 10×10 solutions. An 85:15 split groups unique input configurations to avoid identical partial boards crossing splits, yielding 7,224/1,240 training/test instances for 8×8 and 108,234/18,466 for 10×10. Mean target multiplicity is 1.65 and 2.93, respectively, without augmentation or rebalancing. For Graph Coloring, C.2 retains generated graphs whose chromatic number, the minimum number of required colors, is exactly 3 and canonicalizes solutions by relabeling colors in order of first appearance. It reports 7,002 training and 255 test instances for 8 vertices and 13,465 training and 192 test instances for 10 vertices, with mean training target counts of 3.40 and 8.73. The provided dataset URL is https://huggingface.co/datasets/CUN-bjy/graph-coloring.
• D Additional Experimental Results and D.1 Additional Results on Challenging Puzzle Benchmarks provide the complete comparison table. Recursive-model ARC-AGI scores use the public evaluation set, while external large reasoning model scores use the semi-private set, so the rows do not form a controlled ranking. Direct prediction scores 0% on Sudoku-Extreme and ARC-AGI-2 in the reported setup; this supports recursion within that comparison without establishing failure for every possible single-pass architecture. D.2 Computational Cost of Inference-Time Scaling counts operations with torch.utils.flop_counter and measures latency with one puzzle in flight. GRAM costs 0.0265 TFLOPs per iteration versus TRM’s 0.0256; Tables 10–12 provide matched-compute results, target-accuracy estimates, and the depth/width sweep. The reported 1.6×, 2.6×, and 3.7× computation savings at 85%, 88%, and 90% accuracy use log-linear interpolation between measured points. D.3 Scaling with Parallel Sampling on ARC-AGI Challenge removes test-time augmentation, transformations of evaluation inputs, to isolate internal sampling. More samples generally improve performance across the tested KL weights, with plateaus and small fluctuations. At augmentation level Aug=50, additional sampling provides little benefit, showing diminishing returns when both procedures supply predictions for voting. D.4 Analysis of Model Performance by Number of Valid Solutions groups N-Queens inputs by their valid completion count. GRAM’s single-sample 8×8 accuracy remains near 100% across the plotted groups, while deterministic baselines deteriorate; increasing sampled paths improves coverage on both board sizes. Coverage nevertheless decreases as the number of available solutions grows, so accurate solving does not imply exhaustive solution recovery. D.5 Additional Generated Samples shows eight GRAM digit-generation trajectories and VAE samples, illustrating correction of initially ambiguous outputs. D.6 Additional Results on Unconditional Sudoku Generation reports 99.05% validity for GRAM, 79.18% for D3PM-Big, and 21.88% for D3PM-Small over 100K samples. All valid boards are unique under exact matching, which excludes identical valid outputs within this evaluation but does not establish uniform sampling over valid boards. D.7 Stochasticity and Guidance Ablation without Parallel Sampling extends the mechanism comparison to N=1 and N=20, separating single-path behavior from sampling gains. D.8 Placement of the Stochastic Transition finds that one low-level injection reaches 99.2±0.6% N-Queens accuracy and 90.2±0.4% coverage, comparable to the default high-level injection, while injection at every low-level refinement yields 0.0% for both tested KL variants. The authors attribute the latter failure to repeated target information causing overfitting; the experiment does not separately isolate that explanation. D.9 Reinforcement Learning Fine-Tuning of GRAM updates only the stochastic transition prior using proximal policy optimization, a policy-gradient learning method, while freezing the remaining pretrained parameters. It uses binary validity rewards, up to 16 trajectory steps, 1,000 updates, batches of 512 trajectories, and eight trajectories per problem. On 10×10 N-Queens, single-sample accuracy rises from 89.7% to 99.1% and 20-sample coverage from 57.5% to 61.8%, while 20-sample majority-vote accuracy remains 100.0%. D.10 Visualizing Latent Recursion Process projects high-level states into two dimensions with principal component analysis, a linear dimensionality-reduction method, and interpolates a loss landscape using a K-D tree, a spatial indexing structure. The plots show one TRM path and 50 GRAM paths for the same Sudoku input, illustrating trajectory diversity and differing endpoints. The projected, interpolated landscapes provide qualitative evidence rather than direct measurements of the full high-dimensional geometry.
• Licenses lists external datasets and reference implementations with their reported terms and source links. The paper reports Apache License 2.0 for ARC-AGI and several baseline repositories, MIT License for TRM and Looped Transformer, and Creative Commons Attribution-Share Alike 3.0 for MNIST. It identifies the authors’ synthetic N-Queens and Graph Coloring instances as generated assets rather than external assets.

Brief Thoughts

The single-path improvements, multiple-solution coverage, and nearly matched-compute Sudoku comparison jointly support benefits from the learned stochastic recursion. The random-initialization and decoder-sampling ablations strengthen this interpretation by testing simpler ways to introduce randomness.

The latency result depends on parallel batching, while the broader evidence remains confined to controlled tasks. Sequential training, the truncated objective, diminishing sampling gains with extensive ARC-AGI augmentation, and incomplete solution coverage define practical limits of the demonstrated method.