betaFeedback

WorksComputer Science

When Can LLM Reasoning Reliably Reuse Intermediate Results?

Abstract

Sampling complete solutions gives large language models more chances to solve a problem, but each attempt starts again. For tasks with several subproblems, all required answers must be correct in the same attempt. Retaining intermediate results can avoid repeating correct work, but errors in those results may affect later attempts. We study when this reuse is reliable and how much computation it requires. For local retries that stop when no candidate passes within the retry budget, we give conditions for correct completion and bound the average number of attempts. We also show how checking cost and the chance of passing a check affect total computation. Experiments across eight reasoning models examine composite mathematics and arithmetic. Across four DeepSeek models, average success on the second subproblem is 36.2 percent without first-subproblem context, 57.2 percent with its answer, and 58.3 percent with its reasoning and answer. These scores measure second-subproblem coverage and include continuations made when selection fails. Arithmetic experiments show that similar first-attempt accuracies can lead to very different coverage after repeated attempts. Code is available at https://github.com/SempraETY/Intermediate-State-Reuse.

Figure 1. Complete-solution sampling and intermediate-state reuse. Left: Independent sampling requires a successful complete run. The analyzed reuse loop preserves earlier accepted work, retries rejected candidates, and stops when a step’s budget is exhausted. Passing a check does not guarantee correctness. Right: An illustrative two-subproblem candidate-selection example, with SC denoting self-consistency, MM the first-subproblem candidate budget, and BB the continuation cap. Fractions count correct candidates among those shown; the example is not an experimental measurement or the single-state loop used in the proof.

Introduction

Many practical reasoning tasks require several distinct subproblems to be solved together. Solving each subproblem in isolation does not ensure that a model can solve the complete task [41]. With model weights fixed, a system can spend more computation at inference time to improve its chance of finding a solution. A system can generate more complete answers, compare candidates, or check intermediate work [5, 37, 19]. How this computation is allocated matters alongside how much is available [30].

Under complete-solution sampling, all required subproblem answers must be correct in one run. One run may solve the first subproblem and another the second, while neither solves both. The sample pool contains correct answers to both subproblems, but no run has solved the complete task. As tasks get longer, more intermediate work can be lost when an attempt fails near the end. A restart retries the failed subproblem but repeats earlier work that may already be correct. Existing methods already use intermediate work: Least-to-Most prompting solves subproblems in sequence using earlier answers [45], while Tree of Thoughts searches over partial reasoning states [38].

A subproblem may contain several reasoning steps; our analysis uses steps whose intermediate states can be checked and retained. Consider a three-step calculation that derives a formula, substitutes the given values, and computes a final quantity. Suppose the first two steps are correct but the final calculation fails. A complete restart generates all three steps again. If the formula and substitution can be checked and retained, a new attempt can repeat only the final calculation. The retained results become the retry’s input.

The difficulty is deciding what can safely be kept. A check may reject a correct candidate or accept an incorrect one; benchmarks document the difficulty of identifying errors in intermediate reasoning [43, 17]. An error passed forward may then affect later attempts, as studies of self-conditioning illustrate [29]. Even a correct intermediate answer may leave out assumptions or other information needed to continue. Atom of Thoughts constructs self-contained reasoning states [34], while MEM1 learns to retain compact information across interaction steps [46]. Keeping a full reasoning trace instead supplies more context, but may also retain unchecked mistakes and increases the context to process. Checking itself consumes computation, so avoiding a restart does not by itself establish a saving. This report studies the conditions under which intermediate results can be reused reliably and the cost of doing so.

Recent search methods also avoid unnecessary branching: Chain-in-Tree continues routine steps sequentially and reuses generated children when branching is needed [18]. Process supervision evaluates intermediate reasoning [19], and MAKER combines fine-grained decomposition with voting to execute long deterministic tasks [23]. MAKER derives near-linear expected computation under its voting model, including the cost of discarded responses. We consider finite local retries, where the first candidate to pass a check is retained and may carry an error into later steps.

The analyzed procedure checks each new result and retries from the last retained state after a rejection. It stops when every candidate within the local budget is rejected. For fixed generation and checking, retries reduce exhaustion without improving the reliability of accepted states. We give an attainable reliability bound and matching worst-case bounds on expected attempts. The work bound includes paths after an incorrect acceptance, where correct-prefix acceptance guarantees no longer apply. Exhaustion limits the work spent at frequently rejected states. Sufficient precision and acceptance probability yield linear expected attempts; total cost also includes checking and state processing.

We also report sampling experiments across eight reasoning models. Arithmetic tasks let us ask how much repeated attempts add beyond first-attempt accuracy. Pairs of mathematics problems let us compare candidate selection and the context supplied to the second subproblem: no first-subproblem context, its answer alone, or its reasoning and answer. The paired subproblems are mathematically separate. Their continuation prompts differ in both content and instructions, so the comparison concerns entire prompt configurations. Budget sweeps examine how success and generated tokens change when more computation is spent on first-subproblem candidates or subsequent continuations.

Across four DeepSeek models, second-subproblem success is 36.2% without first-subproblem context, 57.2% with its answer, and 58.3% with its reasoning and answer. Paired uncertainty is unavailable for these prompt comparisons. These scores include fallback continuations and measure success on the second subproblem, rather than joint success of both answers. Arithmetic results show that similar first-attempt accuracies can lead to very different coverage after repeated attempts. A separate EdgeBench study compares two curves for predicting later agent scores from early observations and observations of the same agents on other tasks (Zhu et al., [47]).

Report overview.

  • (a) Reliability of reuse. We give an attainable trajectory bound and the exact accepted-state error threshold for a finite cap to guarantee target reliability.

  • (b) Expected work and checking cost. We bound worst-case expected work, including erroneous paths, and connect reliable completion to acceptance probability and attempt cost.

  • (c) Empirical findings. We compare retries, answer selection, retained context, and budget allocation across eight reasoning models, and evaluate two curves for predicting later agent scores.

Preliminaries

We first define complete-task success, the state passed between steps, and the sampling metrics. These definitions distinguish finding a complete answer from continuing successfully after an intermediate result.

Tasks, States, and Sampling Metrics

A composite task x1⊕x2x_1 \mathbin{\oplus} x_2 presents two subproblems in one prompt and is correct only when both returned subproblem answers are correct. Let a⋆(x)a^\star(x) be the target answer to xx, with a⋆(x1⊕x2)=[a⋆(x1),a⋆(x2)]a^\star(x_1 \mathbin{\oplus} x_2) = [a^\star(x_1), a^\star(x_2)]. Let θ\theta denote the model parameters and pθ(⋅∣s)p_\theta(\cdot\mid s) its distribution over generated text under a fixed decoding configuration and input context ss. For a problem xx, fix a decomposition into N≥1N \ge1 steps, where NN counts the steps in this chosen decomposition. Write ztz_t for the text generated at step t∈{1,…,N}t \in\{1,\ldots,N\} and st=[x,z1,…,zt]s_t = [x,z_1,\ldots,z_t] for the resulting state, with s0=xs_0 = x. Each step is sampled from pθ(⋅∣st−1)p_\theta(\cdot\mid s_{t-1}). For reuse, sts_t denotes the state actually passed forward: task information plus retained generated text or extracted intermediate answers. The prompt specifies how this state is presented to the model. Correctness concerns the information carried forward; a correct extracted answer need not imply that discarded reasoning was correct. We call a task stepwise decomposable if it can be split into steps whose intermediate states admit a task-specific accept-or-reject check. A state is accepted if it passes the check; acceptance need not imply correctness. A stage groups steps, such as those used to solve one subproblem. Let yy be the final answer extracted from a completed run and LL its total number of generated tokens. The single-run metrics are:

Aθ,1(x)=P(y=a⋆(x)),Cθ,1(x)=E[L].(1)A_{\theta,1}(x) = P(y = a^\star(x)), \qquad C_{\theta,1}(x) = \mathbb{E}[L]. \tag*{(1)}

For an integer K≥1K \ge1, independent sampling draws KK independent complete runs from the same distribution and counts success if any run returns the correct answer.

Aθ,K(x)=1−(1−Aθ,1(x))K,Cθ,K(x)=KCθ,1(x).(2)A_{\theta,K}(x) = 1 - \left(1 - A_{\theta,1}(x)\right)^K, \qquad C_{\theta,K}(x) = K C_{\theta,1}(x). \tag*{(2)}

Let δ∈(0,1)\delta\in(0,1) denote the target failure probability, so the desired reliability is 1−δ1-\delta.

Complete-Solution Sampling

In a common pool of composite runs, joint success implies that each subproblem is covered, while separately correct subproblem answers may occur in different runs (Prop. 2). If standalone and composite subproblem marginals agree at a1,a2∈(0,1)a_1,a_2 \in(0,1), with independence within and across runs, then for K≥2K \ge2,

1−(1−a1a2)K<[1−(1−a1)K][1−(1−a2)K].(3)1 - \left(1-a_1a_2\right)^K < \left[1-\left(1-a_1\right)^K\right]\left[1-\left(1-a_2\right)^K\right]. \tag*{(3)}

One run must solve both subproblems, whereas separate coverage can use different runs. This sampling constraint also applies to other stochastic solvers; it does not equate token costs across prompt formats. Under the additional assumptions of exponentially declining complete-run accuracy and linear generation cost [41], complete restarts require exponentially growing generation cost at fixed reliability. Appendix § 13.8 gives the product comparison, numerical example, and scaling calculation. We next examine the reliability and cost of retaining intermediate work.

Reliability and Cost of State Reuse

The reuse loop maintains one accepted state at a time. We analyze the probability that every retained state is correct, the number of executed attempts, and the resulting computational cost.

Local Retries and Reliable Completion

At step tt, generate a candidate from the retained state st−1s_{t-1} and check the state to be passed forward. Let Vt\mathcal{V}_t indicate acceptance and Gt\mathcal{G}_t its correctness. Retain the first accepted state; if all RR attempts are rejected, terminate the entire task. Conditional on the complete history at entry to each reached step, attempts are independent and identically distributed, including at incorrect inputs. Rejected candidates do not change the state or retry law; different steps may depend on earlier accepted results. Checking an extracted answer does not establish that a retained reasoning trace is also correct.

At a correct entry history ss, let ρt(s)\rho_t(s) be the rejection probability and wt(s)w_t(s) the probability of incorrect acceptance in one attempt. Assume ρt(s)≤ρ∈[0,1)\rho_t(s) \le\rho\in[0, 1) and accepted-state error αt(s)≤α∈[0,1)\alpha_t(s) \le\alpha\in[0, 1) at every correct entry history. Conditioning on the first acceptance gives

αt(R;s)=wt(s)1−ρt(s)=αt(s).(4)\alpha_t(R; s) = \frac{w_t(s)}{1-\rho_t(s)} = \alpha_t(s). \tag*{(4)}

Accepted-state precision is 1−αt(s)1-\alpha_t(s); it does not improve with RR. The local trajectory fails if the retry budget is exhausted or an incorrect candidate is accepted:

βt(R;s)=ρt(s)R+(1−ρt(s)R)αt(s).(5)\begin{aligned} \beta_t(R; s) &= \rho_t(s)^R \\ &\quad+ \left(1-\rho_t(s)^R\right)\alpha_t(s). \tag*{(5)} \end{aligned}

More retries reduce exhaustion; improving accepted-state precision requires a different generation or checking rule. Let HtH_t mean that the first tt steps complete with every retained state correct, with H0H_0 certain. Assume HNH_N yields the target answer; later repair can also succeed outside HNH_N.

Theorem 1 (Trajectory reliability). Under the preceding assumptions,

Pr⁡(HN)≥[(1−ρR)(1−α)]N.(6)\Pr(H_N) \ge\left[(1-\rho^R)(1-\alpha)\right]^N. \tag*{(6)}

An admissible process attains equality for every NN, RR. For 0<ρ<10 < \rho< 1, a finite common cap guarantees 1−δ1-\delta over this class if and only if

α<1−(1−δ)1/N.(7)\alpha< 1-(1-\delta)^{1/N}. \tag*{(7)}

Each correct prefix advances correctly with conditional probability at least (1−ρR)(1−α)(1-\rho^R)(1-\alpha); the chain rule gives the product without independence between steps. A homogeneous process with irreversible errors after acceptance attains it. At equality in Eq. (7), the target is approached only with unbounded retries; for ρ=0\rho=0, equality is allowed and one attempt suffices. This is a worst-case guarantee, not a necessary precision threshold for every system that can repair errors. Appendix § 13.10.1 gives the proof, exact minimum cap, and the simpler sufficient allocation Nα<δN\alpha< \delta used in Prop. 4.

Expected Work under the Stopping Rule

We measure work by WW, the number of executed candidate attempts. The pathwise cap W≤NRW \le NR reserves the full budget at every step. Actual work can be smaller because a step ends as soon as a candidate passes. Let PN,R\mathcal{P}_{N,R} contain all processes following the preceding retry and stopping rules for at most NN steps, with arbitrary history-dependent rejection probabilities and no correctness requirement. If acceptance were at least h>0h > 0 at every reached state, the geometric waiting-time bound would give E[W]≤N/h\mathbb{E}[W] \le N/h directly. After an incorrect acceptance, the process may reach states where the correct-prefix acceptance bound no longer holds. The next theorem includes work at these states.

Theorem 2 (Worst-case expected attempts). For every pair of integers NN, R≥1R \ge1,

sup⁡P∈PN,REP[W]=Θ(N+NRlog⁡(N+1)),(8)\sup_{P \in\mathcal{P}_{N,R}} \mathbb{E}_{P}[W] = \Theta\left(N + \frac{NR}{\log(N+1)}\right), \tag*{(8)}

with positive implicit constants independent of both the process length NN and the retry cap RR.

Frequently rejected states are expensive to leave but likely to exhaust the cap, ending the run. The proof uses this tradeoff to bound their expected visits; a homogeneous process gives the matching lower bound (Appendix § 13.10.3). That lower bound concerns the unrestricted class, not every reliable process. The stopping pattern is related to classical start-up demonstration tests ([9]. Appendix § 13.10.6 gives the exact dynamic recursion and separates this uniform bound from fixed-law waiting-time calculations. Together with Thm. 1, this yields reliable completion with an O(log⁡N)O(\log N) cap and linear expected work. Here the target failure probability is fixed, acceptance at correct prefixes has a positive constant lower bound, and accepted-state error decreases with chain length as specified in Cor. 1.

Example: reserved budget and executed work. For 100 steps, a cap of 12 attempts reserves at most 1,200 attempts. Suppose every reached state has rejection probability 1/21/2, and every correct prefix has accepted-state error at most 0.0002. The reliability bound exceeds 0.956, while each reached step uses fewer than two attempts in expectation, giving fewer than 200 over the task. The probabilities in this example are hypothetical. The example distinguishes the reserved budget from expected work; Thm. 2 additionally permits arbitrary rejection probabilities after an incorrect acceptance.

Checking Precision and Computation

As a chain grows, the reliability bound requires a smaller error rate among accepted states. Reaching this precision may make checking more expensive or cause it to reject more candidates. Let hNh_N lower-bound acceptance probability at every correct prefix, and let gNg_N uniformly bound per-attempt cost, including generation, checking, and state processing at every reached state.

Corollary 1 (Precision, acceptance, and cost). Fix δ∈(0,1)\delta\in(0,1) and c∈[0,1)c \in[0,1). If correct prefixes have acceptance probability at least hN∈(0,1]h_N \in(0,1] and accepted-state error at most cεδ/Nc\varepsilon\delta/N, choose

RN=⌈1hNlog⁡N(1−c)δ⌉.(9)R_N = \left\lceil\frac{1}{h_N}\log\frac{N}{(1-c)\delta}\right\rceil. \tag*{(9)}

Then Pr⁡(HN)≥1−δ\Pr(H_N) \ge1-\delta and

E[W]=O(N/hN),Cvsr=O(NgN/hN).(10)\mathbb{E}[W] = O(N/h_N), \qquad C_{\mathrm{vsr}} = O(Ng_N/h_N). \tag*{(10)}

The attempt order N/hNN/h_N is attained within this reliable class for this cap.

The cap controls exhaustion; Thm. 2 bounds all executed attempts, including those after an incorrect acceptance (Appendix § 13.10.4). For constant hNh_N, expected attempts are linear, whereas the deterministic cost cap remains O(Nlog⁡N gN)O(N \log N\, g_N). Since W≥N1HNW \ge N\mathbf{1}_{H_N} and E[W∣HN]≤E[W]/(1−δ)\mathbb{E}[W \mid H_N] \le\mathbb{E}[W]/(1-\delta), this conclusion is compatible with reliable completion, rather than relying only on cheap failures.

At a common precision target, the relevant cost scale is gN/hNg_N/h_N. Under independent binary checks, requiring unanimity can make acceptance polynomially rare, yielding Θ(N1+γlog⁡N)\Theta(N^{1+\gamma}\log N) expected cost for some γ>0\gamma> 0 when every check is executed. With an additional separation condition, majority checking keeps acceptance bounded away from zero and gives O(Nlog⁡N)O(N \log N) expected cost (Hoeffding, [12]). Appendix B.10.5 specifies the noise model and derives both cases; these repeatedly check one candidate rather than compare different answers by self-consistency.

The work bound relies on the execution rule: feedback-dependent retries or continuation after exhaustion can each use NRNR attempts. The experiments below use batch selection, multiple continuations, and fallback with different success criteria. They do not directly test these guarantees.

Experiments

We compare coverage across budgets, selection rules, and continuation prompts. The tasks cover composite mathematics, complete-answer arithmetic retries, and agent-score prediction.

Experimental Setup

Models and tasks. We evaluate DeepSeek-R1-Distill (1.5B, 7B, 8B, 14B) (Guo et al., [10]), Qwen3-Thinking (4B, 30B-A3B) (Team, [33]), and GPT-OSS (20B, 120B) (OpenAI, [26]). LoRe-Compo contains 250 pairs of distinct-subject MATH500 problems, using each of the 500 subproblems once (Zhang et al., [41]; Hendrycks et al., [11]). The second subproblem is a separate mathematical problem that does not require the first answer. Arithmetic uses 50 problems for each base (7 or 10), operation (addition or multiplication), and digit count n∈{1,…,10}n \in\{1,\ldots,10\}, with 32 complete-answer attempts per problem.

Procedures and success criteria. Composite Pass@KK requires both correct answers in one of KK complete runs. The two-stage protocol instead generates MM answers to x1x_1, retains at most BB candidates, and continues on x2x_2. Oracle selects reference-matching answers; self-consistency (SC) uses the modal answer when its vote share reaches 0.5. If selection returns none, fallback candidates are retained for continuation. Both procedures generate whole subproblem answers without checking individual reasoning steps.

The reported second-subproblem success rate A2retA_2^{\mathrm{ret}} counts any correct answer to x2x_2 among the retained continuations, including fallbacks and regardless of x1x_1 correctness. Joint retained-path success would require both answers to be correct along one shared path, with all 250 pairs still in the denominator. Thus A2retA_2^{\mathrm{ret}} upper-bounds joint coverage but does not determine it. It measures coverage, not final-answer selection accuracy. The theoretical loop returns one first-accepted state and stops at exhaustion; the experimental protocol uses multiple continuations and fallback. Appendix C.2 defines these events.

Sampling, matching, and cost. All mathematical generations have a 10,240-token cap. A composite run shares this cap across two answers, whereas staged solving grants one cap per subproblem. LoRe-Compo uses family-specific decoding settings and direct prompt strings without model-specific chat templates. Decoding differs between Pass@1 and larger budgets, some Pass@1 values come from prior work, and cross-budget nesting is unspecified for the composite results. Answer matching uses numeric tolerance or normalized strings, with separate extraction rules for single and paired answers (Appendix C.1). We report recorded generated-token counts and success percentage points per thousand tokens. Equal attempt counts allow different generation budgets. The token counts exclude some checking and state processing costs and are not matched for whole-task reliability.

Complete-Solution Sampling on Composite Tasks

Table 2 reports joint composite Pass@KK. The eight-model mean is 8.2% at K=1K = 1 and 33.3% at the largest recorded budget (K=32K = 32 for R1-1.5B and K=128K = 128 otherwise). Coverage improves across these endpoint configurations, but the gains and model ordering vary. Qwen3-4B starts at 4.8%, below R1-8B at 13.2%, and reaches 38.0% compared with 37.2% at K=128K = 128. GPT-OSS-120B has the highest Pass@1 and Pass@128, at 19.6% and 38.4%. Model rankings depend on the sampling budget.

References

  1. [1]Salaheddin Alzu’bi, Baran Nama, Arda Kaz, Anushri Eswaran, Weiyuan Chen, Sarvesh Khetan, Rishab Bala, Tu Vu, and Sewoong Oh. Roma: Recursive open meta-agent framework for long-horizon multi-agent systems. arXiv preprint arXiv:2602.01848, 2026.
  2. [2]N. Balakrishnan, M. V. Koutras, and F. S. Milienos. Start-up demonstration tests: models, methods and applications, with some unifications. Applied Stochastic Models in Business and Industry, 30(4): 373–413, 2014. doi: 10.1002/asmb.2040.DOI
  3. [3]Richard E Barlow and Frank Proschan. Mathematical theory of reliability. SIAM, 1996.
  4. [4]Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Newiadomski, Piotr Nyczyk, et al. Graph of thoughts: Solving elaborate problems with large language models. In AAAI Conference on Artificial Intelligence (AAAI), volume 38, pages 17682–17690, 2024.DOI
  5. [5]Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling. arXiv preprint arXiv:2407.21787, 2024.arxiv.org/abs/2407.21787
  6. [6]Thomas G Dietterich. Hierarchical reinforcement learning with the maxq value function decomposition. Journal of artificial intelligence research, 13:227–303, 2000.DOI
  7. [7]Nouha Dziri, Ximing Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jiang, Bill Yuchen Lin, Sean Welleck, Peter West, Chandra Bhagavatula, Ronan Le Bras, et al. Faith and fate: Limits of transformers on compositionality. Advances in neural information processing systems, 36:70293–70332, 2023.arxiv.org/abs/2305.18654
  8. [8]Ran El-Yaniv and Yair Wiener. On the foundations of noise-free selective classification. Journal of Machine Learning Research, 11(53):1605–1641, 2010. URL https://www.jmlr.org/papers/v11/el-yaniv10a.html.DOI
  9. [9]Amos E. Gera. A start-up demonstration procedure involving dependent tests. Statistics & Probability Letters, 83(10):2191–2196, 2013. doi: 10.1016/j.spl.2013.05.036.DOI
  10. [10]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 llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025.
  11. [11]Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. In Advances in Neural Information Processing Systems (NeurIPS), 2021.
  12. [12]Wassily Hoeffding. Probability inequalities for sums of bounded random variables. Journal of the American Statistical Association, 58(301):13–30, 1963. doi: 10.1080/01621459.1963.10500830.DOI
  13. [13]George Konidaris and Andrew Barto. Skill discovery in continuous reinforcement learning domains using skill chaining. Advances in neural information processing systems, 22, 2009.
  14. [14]Thomas Kwa, Ben West, Joel Becker, Amy Deng, Katharyn Garcia, Max Hasin, Sami Jawhar, Megan Kinniment, Nate Rush, Sydney Von Arx, Ryan Bloom, Thomas Broadley, Haoxing Du, Brian Goodrich, Nikola Jurkovic, Luke Harold Miles, Seraphina Nix, Tao Lin, Neev Parikh, David Rein, Lucas Jun Koba Sato, Jhalak Wijik, Daniel M. Ziegler, Elizabeth Barnes, and Lawrence Chan. Measuring ai ability to complete long tasks. arXiv preprint arXiv:2503.14499, 2025.arxiv.org/abs/2503.14499
  15. [15]Ismail Labiad, Matthieu Kowalski, Marc Schoenauer, Rémi Munos, and Julia Kempe. Beyond repeated sampling: Learning search policies for llm reasoning. arXiv preprint arXiv:2609.26704, 2026.arxiv.org/abs/2609.26704
  16. [16]K. Rustan M. Leino. Dafny: An automatic program verifier for functional correctness. In International Conference on Logic for Programming Artificial Intelligence and Reasoning, pages 348–370. Springer, 2010.
  17. [17]Xiang Li, Haiyang Yu, Xinghua Zhang, Ziyang Huang, Shizhu He, Kang Liu, Jun Zhao, Fei Huang, and Yongbin Li. Socratic-prmbench: Benchmarking process reward models with systematic reasoning patterns. arXiv preprint arXiv:2505.23474, 2025.arxiv.org/abs/2505.23474
  18. [18]Xinze Li. Chain-in-tree: Back to sequential reasoning in llm tree search. In Findings of the Association for Computational Linguistics: ACL 2026, pages 4365–4392, 2026.
  19. [19]Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step. In The Twelfth International Conference on Learning Representations, 2024.arxiv.org/abs/2305.20050
  20. [20]Nelson F Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. Lost in the middle: How language models use long contexts. Transactions of the association for computational linguistics, 12:157–173, 2024.arxiv.org/abs/2307.03172
  21. [21]Michael Luby, Alistair Sinclair, and David Zuckerman. Optimal speedup of Las Vegas algorithms. Information Processing Letters, 47(4):173–180, 1993. doi: 10.1016/0020-0190(93)90029-9.DOI
  22. [23]Elliot Meyerson, Giuseppe Paolo, Roberto Dailey, Hormoz Shahrzad, Olivier Francon, Conor F Hayes, Xin Qiu, Babak Hodjat, and Risto Miikkulainen. Solving a million-step llm task with zero errors. arXiv preprint arXiv:2511.09030, 2025.arxiv.org/abs/2511.09030
  23. [24]Kou Misaki, Yuichi Inoue, Yuki Imaju ku, So Kuroki, Taishi Nakamura, and Takuya Akiba. Wider or deeper? scaling llm inference-time compute with adaptive branching tree search. CoRR, 2025.
  24. [25]Stefan Nielsen, Edoardo Cetin, Peter Schwendeman, Qi Sun, Jinglue Xu, and Yujin Tang. Learning to orchestrate agents in natural language with the conductor. arXiv preprint arXiv:2512.04388, 2025.arxiv.org/abs/2512.04388
  25. [26]OpenAI. gpt-oss-120b & gpt-oss-20b model card, 2025. URL https://arxiv.org/abs/2508.10925.
  26. [27]Amrith Setlur, Matthew Y. R. Yang, Charlie Snell, Jeremy Greer, Ian Wu, Virginia Smith, Max Simchowitz, and Aviral Kumar. e3: Learning to explore enables extrapolation of test-time compute for llms, 2025. URL https://arxiv.org/abs/2506.09026.
  27. [28]Parshin Shojaee, Iman Mirzadeh, Keivan Alizadeh, Maxwell Horton, Samy Bengio, and Mehrdad Farajtabar. The illusion of thinking: Understanding the strengths and limitations of reasoning models via the lens of problem complexity. arXiv preprint arXiv:2506.06941, 2025.arxiv.org/abs/2506.06941
  28. [29]Akshit Sinha, Arvindh Arun, Shashwat Goel, Steffen Staab, and Jonas Geiping. The illusion of diminishing returns: Measuring long horizon execution in llms. arXiv preprint arXiv:2509.09677, 2025.arxiv.org/abs/2509.09677
  29. [30]Charlie Victor Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling parameters for reasoning. In International Conference on Learning Representations (ICLR), 2025.arxiv.org/abs/2408.03314
  30. [31]Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.DOI
  31. [32]Christian Szegedy. A promising path towards autoformalization and general artificial intelligence. In International Conference on Intelligent Computer Mathematics, pages 3–20. Springer, 2020.DOI
  32. [33]Qwen Team. Qwen3 technical report, 2025. URL https://arxiv.org/abs/2505.09388.
  33. [34]Fengwei Teng, Quan Shi, Zhaoyang Yu, Jiayi Zhang, Yuyu Luo, Chenglin Wu, and Zhijiang Guo. Atom of thoughts for Markov LLM test-time scaling. In Advances in Neural Information Processing Systems (NeurIPS), 2025.arxiv.org/abs/2502.12018
  34. [35]Jonathan Uesato, Nate Kushman, Ramana Kumar, Michele Catasta, Johan Legrand, Jelena Luketina, Andrew Lampinen, Aja Brouwsmith, Zoya Bylinskii, Victoria Ellison, et al. Solving math word problems with process-based and outcome-based feedback. CoRR, 2022.
  35. [36]Ke Wang, Zehao Yu, Luwei Wang, and Yongchao Huang. Cache coherent resampling for efficient test time scaling in llm reasoning via adaptive sequential monte carlo. In Forty-third International Conference on Machine Learning, 2026.
  36. [37]Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171, 2022.arxiv.org/abs/2203.11171
  37. [38]Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Advances in Neural Information Processing Systems (NeurIPS), 36:11809–11822, 2023.arxiv.org/abs/2305.10601
  38. [39]Zhaoyang Yu, Jiayi Zhang, Huixue Su, Yufan Zhao, Yifan Wu, Mingyi Deng, Jinyu Xiang, Yizhang Lin, Lingxiao Tang, Yuyu Luo, et al. Recode: Unify plan and action for universal granularity control. arXiv preprint arXiv:2510.23564, 2025.arxiv.org/abs/2510.23564
  39. [40]Alex L Zhang, Tim Kraska, and Omar Khattab. Recursive language models. arXiv preprint arXiv:2512.24601, 2025a.arxiv.org/abs/2512.24601
  40. [41]Junyu Zhang, Yifan Sun, Tianang Leng, Jingyan Shen, Liu Ziyin, Paul Pu Liang, and Huan Zhang. When reasoning meets its laws. arXiv preprint arXiv:2512.17901, 2025b.arxiv.org/abs/2512.17901
  41. [42]Muru Zhang, Ofir Press, William Merrill, Alisa Liu, and Noah A Smith. How language model hallucinations can snowball. arXiv preprint arXiv:2305.13534, 2023.arxiv.org/abs/2305.13534
  42. [43]Chujie Zheng, Zhenru Zhang, Beichen Zhang, Runji Lin, Keming Lu, Bowen Yu, Dayiheng Liu, Jingren Zhou, and Junyang Lin. Processbench: Identifying process errors in mathematical reasoning. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1009–1024, 2025a.arxiv.org/abs/2412.06559
  43. [44]Congming Zheng, Jiachen Zhu, Zhuoying Ou, Yuxiang Chen, Kangning Zhang, Rong Shan, Zeyu Zheng, Mengyue Yang, Jianghao Lin, Yong Yu, et al. A survey of process reward models: From outcome signals to process supervisions for large language models. arXiv preprint arXiv:2510.08049, 2025b.arxiv.org/abs/2510.08049
  44. [45]Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Olivier Bousquet, Quoc Le, and Ed Chi. Least-to-most prompting enables complex reasoning in large language models. In International Conference on Learning Representations (ICLR), 2023.arxiv.org/abs/2205.10625
  45. [46]Zijian Zhou, Ao Qu, Zhaoxuan Wu, Sunghwan Kim, Alok Prakash, Daniela Rus, Jinhua Zhao, Bryan Kian Hsiang Low, and Paul Pu Liang. Mem1: Learning to synergize memory and reasoning for efficient long-horizon agents. arXiv preprint arXiv:2506.15841, 2025.arxiv.org/abs/2506.15841
  46. [47]Deyao Zhu, Xin Zhou, Shengling Qin, Xuekai Zhu, Hangliang Ding, Shu Zhong, et al. Edgebench: Unveiling scaling laws of learning from real-world environments, 2026. URL https://arxiv.org/abs/2607.05155.

Paper details

vlnc:W_pjyzfhmp
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY-SA 4.0
Usage

views · 10

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

generative AI tools

View statement
Looking for related papers…
Contents