acceptodds
Under review as a conference paper at ICLR 2027

Thinking with Looped Flows

110 views

Abstract

Humans and machines often solve harder problems by spending more time on computation. In deep learning, looped models implement this idea during inference by recurrently updating a hidden state. In practice, however, their training often backpropagates through only one or a few updates, making it hard to train early updates to support future ones. We propose looped flows, an approach that sidesteps this issue by training the recurrence with local denoising objectives. By imposing temporal association across denoising objectives through progressively decreasing noise levels and shared noise, the model is incentivized to learn recurrent states that transfer useful computation over time, even when gradients cover only a few updates. We then formulate inference as integrating the velocity of a probability flow parameterized by the learned denoiser, coupled with recurrent states. This allows solving harder problems by spending more computation through a finer temporal grid and enables multiple valid predictions from different initial noise samples. Across six reasoning benchmarks including two multi-solution benchmarks, looped flows outperform prior state-of-the-art looped models overall, achieving 58.8% test accuracy on ARC-AGI-1 and 12.2% on ARC-AGI-2.

Primary area:
foundation or frontier models, including LLMs
Keywords:
iterative reasoning, flow models, looped models

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_6txJOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes Looped Flows, a framework that combines flow/diffusion-based generative modeling with stateful recurrent (looped) architectures to solve complex algorithmic and spatial reasoning tasks. Standard looped architectures face optimization difficulties because truncating backpropagation through time (BPTT) leaves early recurrent states without clear alignment or global learning signals for future computation.

Critical strengths

Principled Mitigation of Truncated BPTT Instability in Looped Reasoning: A major failure mode in deep looped architectures trained via local per-step objectives is their tendency to fall into spurious attractors or fail to converge because early steps receive no gradient signals from future steps. By framing recurrence along a probability flow trajectory with monotonically decreasing noise levels, the paper provides a natural temporal curriculum that aligns step-by-step local losses. The empirical analysis convincingly shows that looped flows eliminate 90.9%90.9\% of failure cases observed in TRM on Sudoku-Extreme.

Critical weaknesses

Heuristic Regularization (Pseudotargets) Required for Single-Solution Tasks: For data-scarce single-solution tasks like Sudoku, the model suffers from overfitting unless a task-specific student-forcing regularizer is introduced, where interpolants mix noise with previous model predictions instead of ground-truth solutions. This dependency indicates that the core flow formulation alone is prone to exposure bias / target memorization on small datasets, complicating the framework and adding hyperparameters that require careful tuning per domain.

Questions for authors

Clarification on Noise-Sharing Shortcuts: Have you probed the hidden state ztz_t during inference to verify whether linear combination representations of noise x0x_0 exist? How does performance degrade if independent noise x0(i)x_0^{(i)} is used per step while keeping the decreasing noise schedule (t0<t1<⋯<tk−1)(t_0 < t_1 < \dots < t_{k-1})?

Pseudotarget Generalization: How sensitive are the ARC and Maze results to the pseudotarget regularizer? Did you observe exposure bias or degradation when omitting pseudotargets on ARC-AGI-1/2?

3 comments
AuthorsOpenReview ↗

(1/2) Pseudotargets

We thank the reviewer for the careful review and for finding our motivation clear. Below, we address the raised concerns and questions with new experiments.

W1. Heuristic Regularization (Pseudotargets) Required for Single-Solution Tasks: [...] This dependency indicates that the core flow formulation alone is prone to exposure bias / target memorization on small datasets, complicating the framework and adding hyperparameters that require careful tuning per domain.

Q2. Pseudotarget Generalization: How sensitive are the ARC and Maze results to the pseudotarget regularizer? Did you observe exposure bias or degradation when omitting pseudotargets on ARC-AGI-1/2?

We thank the reviewer for raising this point. We would first like to clarify that six of the eight benchmarks in our paper (Maze-Hard, ARC-AGI-1, and all four multi-solution tasks) are already trained without pseudotargets (Table 6). When pseudotargets are used (only on Sudoku-Extreme and ARC-AGI-2), they do not require per-domain hyperparameter tuning, as both tasks use the same linear schedule from 0 to 1 over the first 20k training steps (Lines 845–846).

To test how sensitive all four single-solution tasks are to pseudotargets, we trained a model with the opposite setting on each task while keeping all other settings fixed.

Table A. Test accuracy (%) on single-solution benchmarks with and without pseudotargets.

TaskWith pseudotargetsWithout pseudotargets
Sudoku-Extreme97.461.3
Maze-Hard86.988.2
ARC-AGI-156.360.9
ARC-AGI-214.213.2

We see that omitting pseudotargets does not hurt performance on Maze-Hard, ARC-AGI-1, or ARC-AGI-2. Maze-Hard and ARC-AGI-1 achieve higher accuracy without pseudotargets. On ARC-AGI-2, the model without pseudotargets is within one point of our best checkpoint (13.2% vs. 14.2%) and actually better than the three-seed mean (12.2%) reported in the paper. Among all eight tasks in the paper, only Sudoku-Extreme requires pseudotargets (97.4% vs. 61.3%).

We agree with the reviewer that the drop on Sudoku-Extreme without pseudotargets comes from target memorization on a small dataset. Because Sudoku-Extreme has only 1,000 training puzzles (Line 808), an interpolant at large tt gives the model an almost clean copy of the unique solution, so the model can fit the training puzzles without learning to correct its own errors. We note that this is a common challenge for flow models on small reasoning datasets. For example, FRM [1] reports 13.1% accuracy for a plain flow model and 32.6% with self-conditioning on Sudoku-Extreme, and addresses this by training on the model's own rollouts. Pseudotargets serve the same role in our framework (Lines 826–828). We will add Table A and this discussion to the next revision.

AuthorsOpenReview ↗

(2/2) Noise-sharing shortcuts

Q1. Clarification on Noise-Sharing Shortcuts: Have you probed the hidden state during inference to verify whether linear combination representations of noise exist? How does performance degrade if independent noise is used per step while keeping the decreasing noise schedule?

We would like to address the two parts of the question, probing the recurrent state and using independent noise per step, in turn.

Probing the recurrent state. The shortcut in Appendix B (Eq. 16) cancels the noise by combining the current input xtx_t with an earlier input. Since the model already takes xtx_t as input, the shortcut is possible only if the recurrent state carries information about the initial noise x0x_0 beyond what xtx_t contains. To check whether this happens at inference, we fit linear (ridge regression) probes at each step that predict x0x_0 and the solution x1x_1, either from xtx_t alone or from xtx_t together with the state hh. Here hh is the part of the recurrent state z=(h,ℓ){\bf z}=(h,\ell) from which the prediction is decoded (Lines 723–724). We use 2,048 Sudoku-Extreme test puzzles, fit on half of them, and report R2R^2 on the other half.

Table B. Held-out R2R^2 of linear probes on Sudoku-Extreme, averaged over three seeds.

TargetProbe inputStep 1248163264128
Initial noise x0x_0xtx_t1.000.920.780.560.280.050.000.00
Initial noise x0x_0xtx_t and hh1.000.930.790.570.280.060.000.00
Solution x1x_1xtx_t0.000.000.000.000.010.080.460.98
Solution x1x_1xtx_t and hh0.410.570.710.810.880.940.960.98

We find that adding hh to the input increases the R2R^2 for x0x_0 by at most 0.01 at any step. The decrease of this R2R^2 over the steps comes from the input itself, which contains less of x0x_0 as tt grows. This shows that the recurrent state does not keep a linear representation of x0x_0 beyond the current input, and thus shortcut exploitation is not happening. The rows for x1x_1 check that the probes can read information held by hh. Adding hh increases the R2R^2 for x1x_1 from 0.00 to 0.41 at step 1 and from 0.01 to 0.88 at step 16, as expected since the prediction is decoded from hh.

Independent noise per step. We tested using independent noise at each step while keeping the decreasing noise schedule during both training and inference.

During training, this corresponds to the "w/o noise sharing" ablation in Table 3. Using independent noise per step reduces accuracy by 2.4 percentage points on ARC-AGI-1 (58.8% to 56.4%) and by 1.4 percentage points on ARC-AGI-2 (12.2% to 10.8%). We also ran this ablation on Sudoku-Extreme, where accuracy drops by 2.2 percentage points (97.9% to 95.7%). Thus, sharing noise during training gives a small but consistent gain by aligning adjacent denoising steps, while the model still works well with independent noise.

During inference, we also tested replacing the integrated flow state at every step with an interpolant formed from fresh independent noise and the current prediction, so that no noise sample is shared across steps (Table C).

Table C. Sudoku-Extreme test accuracy (%) with our stochastic sampler and with fresh noise at every step.

Sampler16 steps32 steps64 steps128 steps
Ours85.392.696.398.0
Fresh noise at every step85.192.596.298.0

We see that using fresh noise at every inference step changes accuracy by at most 0.2 percentage points. Together with the probing results in Table B, this confirms our discussion in Appendix B that the learned models do not rely on the noise-cancellation shortcut. We will add these results to the appendix in the next revision.

We would like to thank the reviewer again for their time and constructive feedback. As the discussion deadline approaches, we welcome any remaining questions. If our responses resolve the remaining concerns, we would be grateful for the re-assessment. Thank you again for your consideration.

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

This paper introduces looped flows, which incorporate recurrent hidden states into flow models and update them at each denoising step. The paper also provides corresponding training and inference algorithms. Results across six reasoning benchmarks show improvements over prior looped models on five.

Critical strengths
  1. The paper is easy to follow. The method is well motivated and clearly formulated. It introduces recurrent hidden states into flow models and trains them through a sequence of local denoising objectives, along with corresponding training and inference algorithms.
  2. The evaluation covers several relevant aspects and provides useful ablations. The experiments examine performance across different reasoning tasks, inference-time scaling, and the ability to generate multiple valid solutions.
Critical weaknesses
  1. The contribution over closely related work is not fully established. Although the paper discusses works like FRM in related work, it does not provide a direct experimental comparison against FRM, which would help clarify the benefits of the proposed method.
  2. The inference cost is not fully evaluated in the paper. Each denoising step contains multiple recurrent network updates, but the paper does not establish how its accuracy compares with relevant baselines under the same inference-compute budget.
Questions for authors
  1. Can the authors provide metrics on inference cost? For example, could they report an accuracy-versus-FLOPs comparison on ARC?
3 comments
AuthorsOpenReview ↗

(1/2) Comparison with FRM

We thank the reviewer for the constructive review, and we are happy that the reviewer found our method well motivated and the evaluation useful. We would like to address the raised concerns and questions below with new experiments.

W1. The contribution over closely related work is not fully established. Although the paper discusses works like FRM in related work, it does not provide a direct experimental comparison against FRM, which would help clarify the benefits of the proposed method.

We would first like to clarify which version of FRM [1] is discussed in our paper. In Section 4 (Lines 294–298), we cited the first version of FRM (June 2026), which uses self-conditioning for recurrence, and we compared against self-conditioned flow variants in Figure 5. The current version of FRM, which introduces fixed-point forcing with a 7M DiT model, appeared on arXiv on August 28, 2026, and its code and checkpoints were released on October 18, 2026 (after the submission deadline). While we view this version as concurrent work, following the official ICLR policy [2], we agree that a direct comparison is helpful.

To separate the training method from the backbone architecture under matched inference compute, we implemented the two-stage training recipe of FRM (self-conditioning followed by fixed-point forcing at t=0.4t=0.4, evaluated with FRM's held-level sampler) in our codebase and tested two backbones: (i) our looped-flow backbone, where one denoiser call costs the same FLOPs for both methods, and (ii) the lighter 7M DiT of the released FRM model (which costs 32x fewer FLOPs per call on Sudoku and 18x fewer on ARC).

Table A. Test accuracy (%) with matched inference compute per puzzle. Numbers of denoiser calls are in parentheses. ∗^*: uses 12% more compute than the row TFLOPs.

TaskTFLOPsFRM (looped-flow backbone)FRM (DiT)Looped flows
Sudoku-Extreme0.877.9 (32)96.3 (1,024)∗^*93.0 (32)
Sudoku-Extreme1.687.2 (64)98.1 (2,048)∗^*96.6 (64)
Sudoku-Extreme3.393.3 (128)98.9 (4,096)∗^*98.2 (128)
ARC-AGI-11.526.0 (8)24.3 (146)60.9 (8)
ARC-AGI-13.026.0 (16)24.1 (293)61.0 (16)
ARC-AGI-21.50.8 (8)0.8 (146)12.5 (8)

With the same backbone, looped flows achieve higher accuracy than FRM across all three tasks and all budgets (e.g., 96.6% vs. 87.2% at 64 calls on Sudoku, where FRM needs 256 calls to reach 96.7%). With its lighter DiT backbone, FRM achieves slightly higher accuracy on Sudoku at matched FLOPs (98.9% vs. 98.2% at 3.3 TFLOPs) by running 32x more calls per puzzle (4,096 vs. 128). However, FRM reaches at most 26.0% on ARC-AGI-1 and 0.8% on ARC-AGI-2 with either backbone and any budget, whereas looped flows reach 60.9% and 12.5% at 1.5 TFLOPs. We observed that FRM reaches 89–91% training accuracy on ARC, so it fits the training tasks well but does not generalize. We will add this comparison to the next revision.

[1] Helbling et al. Flow reasoning models: Scaling reasoning through iterative self-refinement. arXiv:2606.29150, 2026.

[2] ICLR 2027 Reviewer Guidelines, FAQ "Are authors expected to cite and compare with very recent work?" https://iclr.cc/Conferences/2027/ReviewerGuidelines

AuthorsOpenReview ↗

(2/2) Accuracy versus inference FLOPs

W2. The inference cost is not fully evaluated in the paper. Each denoising step contains multiple recurrent network updates, but the paper does not establish how its accuracy compares with relevant baselines under the same inference-compute budget.

Q1. Can the authors provide metrics on inference cost? For example, could they report an accuracy-versus-FLOPs comparison on ARC?

We thank the reviewer for raising this point. First, we would like to clarify that a single denoiser call of looped flows has the same cost as a single supervision step of TRM, since both apply the same shared network (Appendix A, Lines 721–722) and the added input projection and time embedding have negligible cost. Following the reviewer's suggestion, we have added accuracy-versus-FLOPs plots across ARC-AGI-1, ARC-AGI-2, Maze-Hard, and Sudoku-Extreme in Figure 7 (Appendix F) of the revised paper, and we summarize the ARC comparison in Table B below.

Table B. ARC pass@2 (%) and inference compute (TFLOPs).

MethodInference stepsTFLOPsARC-AGI-1ARC-AGI-2
HRM16 (max)2.440.35.0
TRM1 / 8 / 160.19 / 1.5 / 3.042.4 / 44.4 / 44.6– / – / 7.8
FPRM15 / 120 / 1,0000.19 / 1.5 / 12.522.6 / 47.8 / 47.5– / – / 6.2
GRAM163.152.011.1
PTRM16 ×\times 25 trajectories75.1–9.7
Looped flows (Ours)1 / 8 / 320.19 / 1.5 / 6.054.9 / 59.4 / –6.2 / 11.6 / 12.2

We see that on ARC-AGI-1, looped flows with a single denoiser call (0.19 TFLOPs, 1/16 of TRM) already reach 54.9%, outperforming all baselines at any compute budget, and improve to 59.4% at 8 calls (1.5 TFLOPs, half of TRM). At the same 1.5 TFLOPs budget on ARC-AGI-2, looped flows reach 11.6%, surpassing both GRAM at 3.1 TFLOPs (11.1%) and PTRM at 75.1 TFLOPs (9.7%), and reach 12.2% at 32 calls (6.0 TFLOPs). We observe the same pattern on Maze-Hard (86.0% at half of TRM's compute vs. 85.3% for TRM) and on Sudoku-Extreme, where looped flows reach 97.9% at 128 steps (3.3 TFLOPs) compared to 88.6% for TRM and 94.9% for GRAM at the same step count (Figure 7). Thus, the improvements of looped flows do not come from additional inference compute, and the model scales effectively when more compute is used.

Thank you for the detailed responses. The authors have addressed my concerns. I will keep my rating.

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

This paper proposes Looped Flows, a framework that combines flow matching with recurrent reasoning models. By training a stateful denoiser using temporally aligned denoising objectives with decreasing noise levels and shared noise, the method aims to learn useful recurrent representations without backpropagating through multiple recurrent steps. During inference, the model progressively constructs solutions through probability flow integration, allowing additional test-time computation and diverse solution generation. Experiments across six reasoning benchmarks demonstrate strong performance compared to existing looped models.

Critical strengths
  1. The paper is well written and easy to follow. The motivation for combining flow matching with recurrent reasoning is clear, and the overall framework is intuitive.
  2. The proposed framework is interesting and effective. Using temporally aligned denoising objectives to improve recurrent reasoning provides a promising alternative to conventional truncated BPTT training.
  3. The experimental results are strong across different reasoning benchmarks, particularly on ARC-AGI and multi-solution tasks. The ablation studies and recurrent-state analyses further support the effectiveness of the proposed approach.
Critical weaknesses
  1. The inference-time scaling benefits are somewhat task-dependent. As shown in Figure 6, performance saturates relatively early on several benchmarks and even shows a little overthinking problem on ARC-AGI.
  2. The proposed method is built upon the TRM architecture, which maintains separate high-level and low-level recurrent states. However, it is unclear whether the effectiveness of Looped Flows depends on this hierarchical architecture or whether the proposed training paradigm can generalize to other recurrent architectures, such as simpler single-state recurrent models.
  3. The paper provides limited analysis of breadth scaling. Although the authors evaluate multiple independent trajectories and use best-Q selection, the experiments consider only fixed numbers of trajectories (5 or 20). It remains unclear how performance and solution coverage scale with the number of parallel trajectories.
Questions for authors
  1. How sensitive is the proposed method to the underlying recurrent architecture?
  2. Can the authors provide scaling curves with different numbers of parallel trajectories?
4 comments
AuthorsOpenReview ↗

(1/3) Inference-time scaling

We thank the reviewer for the thoughtful review, and we are happy that the reviewer found our framework interesting and our experimental results strong. We would like to address the raised concerns and questions with new experiments.

W1. The inference-time scaling benefits are somewhat task-dependent. As shown in Figure 6, performance saturates relatively early on several benchmarks and even shows a little overthinking problem on ARC-AGI.

Overthinking on ARC-AGI-1. Figure 6 in the paper shows the mean accuracy over the two best training seeds with the best γ∈{0,1,5}\gamma\in\{0,1,5\}. To see where the drop comes from, we report the test accuracy of each seed separately in Table A, both with our default stochastic sampler (SDE, γ=5\gamma=5) and with the deterministic sampler (ODE, γ=0\gamma=0).

Table A. ARC-AGI-1 accuracy (%) of each training seed with different numbers of inference steps.

SamplerSeed1 step8 steps16 steps32 steps64 steps128 steps
SDE (γ=5\gamma=5)054.457.956.854.555.554.6
SDE (γ=5\gamma=5)151.857.553.847.345.543.9
SDE (γ=5\gamma=5)255.560.961.061.060.961.0
SDE (γ=5\gamma=5)Mean53.958.857.254.354.053.2
ODE (γ=0\gamma=0)053.657.557.557.057.657.8
ODE (γ=0\gamma=0)151.554.652.951.449.448.4
ODE (γ=0\gamma=0)255.160.461.861.161.960.9
ODE (γ=0\gamma=0)Mean53.457.557.456.556.355.7

We see that the drop in the three-seed mean comes mostly from a single seed (Seed 1). We also find that the drop is much smaller with the deterministic ODE sampler (γ=0\gamma=0), where Seeds 0 and 2 slightly improve from 8 to 128 steps (57.5% to 57.8% and 60.4% to 60.9%). This indicates that the learned recurrence itself remains stable over many steps, and the drop on Seed 1 is largely caused by accumulating injected noise during SDE sampling.

Early saturation. For the early saturation on Maze and ARC in Figure 6, we conjecture this is partially due to adaptive computation time (ACT) which halts training rollouts on Maze and ARC after 1.2 steps on average, compared to up to 7.4 steps on Sudoku and N-Queens (Lines 908–909). We view further improving the scaling behavior on these benchmarks as an important and immediate next direction.

To understand which problem instances benefit from more steps, we split the Sudoku-Extreme test set into five bins of 4,096 puzzles by the difficulty rating provided in the dataset and evaluated our trained models on each bin.

Table B. Sudoku-Extreme test accuracy (%) for each difficulty rating bin, averaged over three seeds.

Difficulty rating8 steps16 steps32 steps64 steps128 steps
0–1085.492.696.297.998.8
11–2562.479.189.694.697.0
26–5066.482.691.095.397.2
51–10067.082.690.795.497.2
101+71.084.892.195.697.1

We find that harder puzzles benefit much more from additional inference steps than easier ones, as expected, due to an increase in compute depth. On the harder bins (ratings 11 and above), accuracy starts lower at 62.4%–71.0% and improves by 26.1 to 34.6 points from 8 to 128 steps without saturating. We do not observe saturation at any difficulty level on Sudoku.

We will add Tables A and B and this discussion to the next revision.

AuthorsOpenReview ↗

(2/3) Single-state architecture

W2. [...] it is unclear whether the effectiveness of Looped Flows depends on this hierarchical architecture or whether the proposed training paradigm can generalize to other recurrent architectures, such as simpler single-state recurrent models.

Q1. How sensitive is the proposed method to the underlying recurrent architecture?

To test whether looped flows depend on the two-state hierarchy (h,ℓ)(h, \ell) of TRM in Eq. (15), we trained a simpler single-state variant of the architecture. Specifically, we replace (h,ℓ)(h, \ell) with a single state zz updated as z←Fθ(z+et)z \leftarrow F_\theta(z + e_t), from which both the prediction and the halting score are decoded. For comparison, we also train the same single-state model with the looped loss in Eq. (2), without noise interpolant or time conditioning.

Table C. Test results with two-state and single-state recurrent architectures.

Recurrent stateTrainingSudoku-Extreme accuracy (%)N-Queens 10x10 accuracy / coverage (%)
Two states (TRM)Looped loss87.417.5 / 2.0
Two states (paper)Looped flows97.9 ±\pm 0.494.4 / 61.5
Single stateLooped loss78.134.1 / 4.3
Single stateLooped flows95.389.5 / 60.5

We see that looped flows remain effective with a single recurrent state. On Sudoku-Extreme, the single-state model trained with looped flows reaches 95.3% accuracy, improving over the same model trained with the looped loss (78.1%) by 17.2 points. On N-Queens 10x10, looped flows improve the single-state model from 34.1% accuracy and 4.3% coverage to 89.5% accuracy and 60.5% coverage.

In fact, the single-state model trained with looped flows outperforms the two-state TRM baseline on both tasks (95.3% vs. 87.4% on Sudoku, and 89.5% / 60.5% vs. 17.5% / 2.0% on N-Queens). This shows that our training approach is not tied to the two-state hierarchy of TRM and generalizes well to simpler single-state recurrent models. We will add these results to the next revision.

AuthorsOpenReview ↗

(3/3) Breadth scaling

W3. The paper provides limited analysis of breadth scaling. [...] the experiments consider only fixed numbers of trajectories (5 or 20). It remains unclear how performance and solution coverage scale with the number of parallel trajectories.

Q2. Can the authors provide scaling curves with different numbers of parallel trajectories?

To evaluate breadth scaling, we sampled up to N=100N=100 parallel trajectories per test problem (up to N=50N=50 on Sudoku and N=10N=10 on ARC due to evaluation cost). On the multi-solution tasks, we measure solution coverage as NN increases (Table D). On the single-solution tasks, we compare three rules for choosing the final answer from NN trajectories: best-Q ensembling as in the paper, majority voting, and an oracle that counts a problem as solved if any of the NN trajectories is correct (Table E).

Table D. Test coverage (%) of distinct valid solutions across NN parallel trajectories.

BenchmarkN=1N=125102050100
N-Queens 10x1011.819.734.648.061.577.487.7
Graph Coloring (10 vertices)10.516.328.741.154.372.985.0

Table E. Test accuracy (%) across NN parallel trajectories.

Benchmark and selection ruleN=1N=125102050100
Sudoku, best-Q97.798.699.299.499.699.7–
Sudoku, majority97.798.699.299.499.699.7–
Sudoku, oracle97.798.699.299.499.699.7–
Maze, best-Q85.786.285.985.484.582.379.2
Maze, majority85.786.386.887.187.287.287.2
Maze, oracle85.789.091.693.094.295.596.3
ARC-AGI-1, best-Q61.361.661.861.9–––
ARC-AGI-1, majority61.361.161.561.4–––
ARC-AGI-1, oracle75.377.479.879.8–––
ARC-AGI-2, best-Q12.512.512.512.5–––
ARC-AGI-2, majority12.512.512.512.5–––
ARC-AGI-2, oracle19.620.421.521.5–––

On the multi-solution tasks (Table D), coverage grows with NN, reaching 87.7% on N-Queens 10x10 and 85.0% on Graph Coloring at N=100N=100.

On the single-solution tasks (Table E), the oracle accuracy also increases across the full range of NN (from 97.7% to 99.7% on Sudoku, from 85.7% to 96.3% on Maze, from 75.3% to 79.8% on ARC-AGI-1 and from 19.6% to 21.5% on ARC-AGI-2), showing that sampling more trajectories continues to find valid solutions on harder problems.

On Sudoku, best-Q ensembling and majority voting are on par with the oracle across all NN, meaning that both rules almost always select a correct trajectory when one is generated. In contrast, on ARC pass@2 with both rules stays close to that with a single trajectory (at most 61.9% vs. 61.3% on ARC-AGI-1, and 12.5% for all NN on ARC-AGI-2), since the new correct answers rarely receive enough votes to enter the top two. This suggests that a better rule for combining the trajectories can further improve the results on ARC. We leave the investigation of better aggregation methods as future work and will add these breadth-scaling results to the next revision.

The authors have addressed most of my concerns. I think this paper offers an interesting perspective on how we should combine flow-based models and looped model. I decide to maintain my score of weak acceptance.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.