Pith. sign in

REVIEW 4 major objections 5 minor 2 cited by

Iterative Deepening Sampling as Efficient Test-Time Scaling

T0 review · 4 major / 5 minor · reviewed 2026-08-08 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A fixed LLM can be pushed to higher pass rates at the same compute by inserting 'wait' triggers on a geometric schedule during reasoning.

desk verdict A plausible test-time scaling variant whose main claim needs a neutral-continuation control to rule out 'more tokens' as the explanation. read the letter →

arxiv 2502.05449 v2 pith:DYY2RP7C submitted 2025-02-08 cs.CL cs.AIcs.LG

Weizhe Chen , Sven Koenig , Bistra Dilkina This is my paper · ORCID
classification cs.CLcs.AIcs.LG
keywords test-timescalingiterativedeepeningsamplingself-correctionreasoningmodelsBest-of-NmajorityvotingMATH-500AIME
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper proposes Iterative Deepening Sampling (ID-Sampling), a way to spend a fixed test-time compute budget on a frozen large language model that it claims produces more correct answers than ordinary sampling on hard mathematics. The method starts each response with a small generation budget and, whenever the model has not finished, appends a trigger sentence such as 'Wait! Maybe I made some mistakes! I need to rethink from scratch.' and lets generation continue with a budget multiplied by a constant $\gamma$. Repeating this on a geometric schedule pushes self-correction early in the trajectory, when it is most likely to help. On MATH-500, AIME-24, and AIME-25 the authors report higher pass rates than vanilla sampling under Best-of-N, pass@N, and majority voting, while keeping total token usage within a factor of $\gamma/(\gamma-1)$ of the answer's natural length. The practical interest is that a stronger model, or a future one, would inherit the benefit without retraining.

What carries the argument

The load-bearing mechanism is the geometric budget schedule plus trigger-sentence insertion. The algorithm starts with a small budget $B_0$, generates up to that many tokens, inserts 'wait' (or the full trigger sentence) at a step boundary whenever the model is still thinking, then multiplies the allowed budget by $\gamma$ each round ($\gamma=2$ by default), so trigger density is high early and drops off as the trajectory grows; a complete answer ends the loop early. The supporting identity is Theorem 4.1: because the per-round budgets form a geometric series, the total tokens spent on an answer that naturally takes $L$ tokens is at most $\gamma L/(\gamma-1)$, which for $\gamma=2$ is at most $2L$. The budget variable is designed to map onto the 'max tokens' parameter of a serving engine, and the paper's positional analysis of thinking markers ('however', 'wait', 'alternatively', 'hmm') motivates placing the triggers early.

What would settle it

Take a fixed reasoning model and a set of competition-math problems where vanilla pass@1 is strictly positive. For each problem, sample one uninterrupted rollout and one rollout that is stopped at the same token, given a 'wait' trigger, and continued with the same remaining budget. If the triggered rollouts are not correct more often than the uninterrupted ones, the premise that trigger injection biases the distribution toward higher-quality outputs is false, and the pass-rate gains reported under ID-Sampling would not transfer.

Watch

Extended reading notes

Core claim

The central claim is that a fixed model's pass rate on competition-level mathematics can be improved, at comparable compute cost, by replacing vanilla repeated sampling with a schedule of forced self-correction triggers. Concretely, the paper introduces ID-Sampling, which starts each response with a small token budget $B_0$; if the response is not complete, it pads the partial reasoning trace with a trigger sentence and continues generation with a budget multiplied by $\gamma$, repeating until the answer finishes or the maximum budget $B$ is reached. The overhead is bounded by a geometric series: an answer that normally takes $L$ tokens uses no more than $\gamma L/(\gamma-1)$ tokens under the schedule (Theorem 4.1). The paper reports consistent pass-rate gains over vanilla sampling on MATH-500 and AIME-24/AIME-25 across non-reasoning and reasoning models, with larger gains for models that already have built-in self-correction ability, and the gains persist when the comparison is made at equivalent wall-clock cost (equivalent $N$). The authors interpret these results as evidence that current models can self-correct when triggered but are not yet reliably deciding when to trigger themselves.

Load-bearing premise

The argument collapses if appending a trigger sentence to an unfinished reasoning trace does not make the model's continuation more likely to be correct than an untriggered continuation; the authors themselves note that for models without self-correction ability the trigger mainly adds noise.

Editorial extensions

If this is right

  • On MATH-500, AIME-24, and AIME-25, switching a fixed model from vanilla sampling to ID-Sampling raises Best-of-N, pass@N, and majority-voting accuracy without additional training or fine-tuning.
  • With the recommended $\gamma=2$, a solution that naturally uses $L$ tokens costs at most $2L$ tokens, so the worst-case budget overhead is a predictable constant factor before deployment.
  • The gains are larger for models with stronger built-in self-evaluation and self-correction, suggesting the method will become more useful as reasoning models improve.
  • Because ID-Sampling produces several refined trajectories from a common prefix, it can generate higher-quality self-reflection data for training or evaluating the next generation of LLMs without extra annotation.
  • The abstract budget definition in Algorithm 1 lets the same geometric schedule be applied to tree-search methods such as beam search or MCTS by counting nodes or iterations as budget, as the paper's appendix discusses.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper leaves implicit whether the 'wait' trigger works by genuine self-correction or by acting as a soft restart; swapping the trigger for a neutral token under the same geometric schedule would separate the two mechanisms.
  • The equivalent-$N$ comparison assumes the serving stack reuses KV-cache across rounds; without that reuse, wall-clock overhead follows the reported runtime ratios (up to 1.39$\times$ at $\gamma=1.5$) and could erode the advantage in production deployments.
  • A testable extension the authors do not run: the margin over vanilla should grow on problems where the model's first attempt contains a recognizable error and shrink where it does not, if the trigger truly improves error recovery.
  • For code generation the trigger sentence can break syntax, so the schedule would need a grammar-preserving analogue; success there would show the geometric schedule, not the phrase, is the active ingredient.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper introduces Iterative Deepening Sampling (ID-Sampling), a test-time decoding strategy in which an LLM generates a prefix under a small max-token budget; if the response is unfinished, the algorithm appends a trigger sentence (e.g., 'Wait') and continues with a geometrically larger budget until the response finishes or a maximum budget B is reached. The paper proves a token-overhead bound (Theorem 4.1) and presents experiments on MATH-500, AIME-24, and AIME-25 with Llama-3.1-1B-Instruct, Phi-4, DeepSeek-R1-Distill-Qwen-7B/32B, and Qwen3-8B, reporting BoN, Pass@N, and cons@N gains over vanilla sampling. It also includes a gamma ablation and a discussion of limitations, including model dependence and KV-cache overhead.

Significance. If the claimed effect is genuine, the paper offers a simple, training-free test-time scaling method with an elementary but useful budget guarantee, and the comparison across five open models is a strength. The method is easy to implement, and the idea of placing more trigger sentences in the early part of reasoning is clearly motivated by the marker analysis in Section 4.1. However, the current experiments do not isolate the contribution of the trigger from the extra token budget, and the AIME-scale differences lack statistical support; the significance therefore depends on the control experiments and uncertainty quantification requested below.

major comments (4)
  1. [§4.3 and Algorithm 1] The paper's load-bearing assumption—that injecting a trigger sentence biases the response distribution toward higher-quality outputs—is never tested in isolation. In Algorithm 1, each unfinished continuation receives both the trigger sentence and an enlarged token budget, while the vanilla baseline receives neither. Since Section 5.2.1 reports only 1.1–1.3× wall-clock overhead for reasoning models, a strong control is feasible: vanilla sampling with the per-response token budget set to the total tokens used by ID-Sampling, or a continuation control that inserts a non-instructional phrase at the same positions. The 'equivalent N' correction equalizes aggregate wall-clock time but does not separate the semantic effect of the trigger from the effect of receiving more tokens per response; without such a control, the central efficiency claim is not established.
  2. [§5.2.2, Tables 1–2] The AIME results are statistically fragile because each dataset contains only 30 problems and several reported differences correspond to one problem. For example, Table 2's Pass@1 values of 72.6 versus 75.5 differ by roughly one correct response out of 30, and Table 1a shows ID-Sampling at N=16 with BoN 0.00 versus vanilla 3.45, i.e., a reversal on one problem. No confidence intervals, bootstrap estimates, or significance tests are provided for any Pass@N or cons@N value, so the claim that ID-Sampling 'consistently outperforms' vanilla sampling across models is not supported at the reported precision.
  3. [§5.1 and §5.2.2] The trigger sentence and the scaling factor γ are chosen after observing performance on the evaluation benchmarks: a full sentence for non-reasoning models, 'wait' for reasoning models, and γ=2.0 as the default. The γ ablation in Table 3 and Figures 7a–b changes both the trigger frequency and the total token budget simultaneously, so it cannot attribute the observed differences to the schedule independently of compute. A held-out validation split or a clearly disclosed model- and benchmark-specific selection protocol is needed to assess how much of the reported gain is selection rather than a general property of the algorithm.
  4. [§5.1 and Appendix] The text says 'Due to the page limit, we leave other hyperparameters in the appendix,' but the appendix contains only the additional discussions and the linguistic-marker list; sampling temperatures, B0, B, N values per model, and random seeds are not reported. The experiments are therefore not reproducible from the manuscript as written, and this missing documentation is load-bearing for an empirical test-time-scaling claim.
minor comments (5)
  1. [§5.2.1] The equivalent-N description should state explicitly that an ID-Sampling run with N responses that takes 2× wall-clock time is plotted against vanilla N=2N; as written, the phrase 'we report them as equivalent N=16' can be misread as claiming ID-Sampling generates 16 samples.
  2. [Algorithm 1] The cases 'Output is finished' and 'Output finished thinking' are not formally defined; the stopping conditions (EOS token, end-of-think token, or response-complete marker) should be specified for reproducibility.
  3. [§5.1] The text contains the string '¿12K', which appears to be a rendering error for '>12K'.
  4. [Table 3] Relative wall-clock time is reported without variance or the number of repeated runs; add standard deviations or clarify that each entry is a single measurement.
  5. [Figure 2] The text should define how the positional distribution is computed (absolute token position versus relative position) and how marker counts are normalized across responses.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the method is evaluated against external benchmarks and the theoretical bound is a self-contained geometric-series argument.

full rationale

The paper's central claim is that ID-Sampling improves pass rates over vanilla sampling on MATH-500, AIME-24, and AIME-25 at comparable total compute, and Theorem 4.1 bounds token overhead. The theorem is derived directly from the geometric budget schedule and does not assume or restate the quality improvement; the paper explicitly notes that it guarantees no answer quality. The empirical pass-rate comparisons use external benchmarks and vanilla sampling baselines, with the only fitted choices being the schedule parameter gamma and the trigger sentence, which are not fed back into the theorem or into the definition of the pass-rate metrics. The authors' self-citations in the related work section are contextual and not load-bearing. The main validity concerns, such as gamma and trigger-sentence selection on AIME-24 and the absence of a neutral-continuation control, are experimental-design issues rather than definitional circularity. Therefore no step in the derivation chain reduces to its own inputs by construction.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The algorithm introduces no new ontology and no invented physical entities. Its load-bearing inputs are behavioral assumptions about LLM self-correction and response distributions, plus empirically chosen hyperparameters γ, B0, B, and the trigger sentence. The γ and trigger-choice are tuned on the evaluation benchmarks themselves.

free parameters (4)
  • γ (budget scaling factor) = 2.0 default, chosen from ablation
    Controls geometric growth of the per-round token budget; ablation on AIME-24 showed γ=2.0 best for Pass@N but the relationship was non-convex (Section 5.2.2).
  • B0 (initial budget)
    Initial token budget in Algorithm 1; value not reported in the main text.
  • B (maximum budget)
    Maximum budget beyond which no further triggers are inserted; value not reported in the main text.
  • Trigger sentence = 'Wait! Maybe I made some mistakes! I need to rethink from scratch.' for non-reasoning models; 'wait' for reasoning…
    Chosen per model type based on which form elicits self-correction; a full sentence can trigger premature end-of-think in reasoning models (Section 5.1).
assumptions (4)
  • domain assumption LLMs respond to trigger sentences by restarting reasoning and self-correcting.
    Stated in Section 4.2: 'In most cases, LLMs respond to this trigger by restarting their reasoning process and making self-corrections.' Not proven; effectiveness varies by model.
  • ad hoc to paper Injecting a trigger sentence biases the response distribution toward higher-quality outputs.
    Stated in Section 4.3 as the intuition behind observed superiority; no derivation or external validation is provided.
  • domain assumption The position and frequency of thinking markers correlate with answer correctness.
    Used as motivation in Section 4.1 and Figure 2; the marker list is borrowed from Wang et al. (2025) with no new validation.
  • domain assumption Generating a full response from scratch is more reliable than refining an already complete solution.
    Algorithm 1 terminates when output is finished; this choice is asserted in Section 4.2 without supporting evidence.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Iterative Deepening Sampling as Efficient Test-Time Scaling." pith.science (2026). https://pith.science/paper/DYY2RP7C

@misc{pith2026250205449,
  author       = {Pith},
  title        = {Pith review of: Iterative Deepening Sampling as Efficient Test-Time Scaling},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DYY2RP7C}},
  note         = {Machine review of arXiv:2502.05449}
}
read the original abstract

Recent reasoning models, such as OpenAI's O1 series, have demonstrated exceptional performance on complex reasoning tasks and revealed new test-time scaling laws. Inspired by this, many people have been studying how to train models to achieve effective self-evaluation and self-correction to further enable the scaling paradigm. However, less studied is how to efficiently scale test-time compute from a fixed model, and this remains a challenge. In this paper, we address this challenge by focusing on enhancing the quality of self-reflection data generation for complex problem-solving at test time, which can also subsequently improve the training of next-generation large language models (LLMs). Specifically, we explore how systematically triggering a model's self-correction mechanisms can improve performance on challenging reasoning tasks. To this end, we propose a novel iterative deepening sampling algorithm framework designed to enhance self-correction and generate higher-quality samples. Through extensive experiments on Math500 and AIME benchmarks, we demonstrate that our method achieves a higher success rate on difficult tasks and provide detailed ablation studies to analyze its effectiveness across diverse settings.

Figures

Figures reproduced from arXiv: 2502.05449 by the authors.

Figure 1
Figure 1. An illustration of our method, Iterative Deepening Sampling (ID-sampling), where B0 is the initial sampling budget. rithmic framework that iteratively increases the sampling budget following a geometric progression, while incorpo￾rating self-reflection mechanisms at each expansion step. We theoretically demonstrate that ID-Sampling effectively balances computational efficiency and response quality, en￾suring that th… view at source ↗
Figure 2
Figure 2. The frequency of linguistic markers related to thinking appeared in Deepseek-R1 on AIME-2024 dataset. same, and even in mathematical problems, expressions such as √ 1 3 and √ 3 3 are equivalent but must be recognized as such to ensure correct vote counting. A common solution in mathematical domains involves using symbolic-based checkers to compare answer pairs and identify equivalences. However, this process can be … view at source ↗
Figure 3
Figure 3. Math-500 dataset: Pass rate results for different models. The x-axis is the equivalent N after considering the extra time used by ID-sampling [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (2 more)
Figure 5
Figure 5. Figure 5 [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 7
Figure 7. Figure 7: AIME-24 Dataset: Pass rate results for DeepSeek-R1-Distill-Qwen-7B with different γ for ID-sampling, compared to vanilla sampling. The numbers in brackets are the γ used in ID-sampling. As different values of γ result in significantly varying runtimes, as shown in [PI…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Corrector Sampling in Language Models

    cs.LG 2025-06 conditional novelty 6.0 of 10

    A training and sampling method that lets autoregressive LLMs resample earlier tokens in a small window, improving reasoning and coding benchmark scores by about 10% relative after a 100B-token fine-tuning.

  2. Reasoning on a Budget: A Survey of Adaptive and Controllable Test-Time Compute in LLMs

    cs.AI 2025-07 conditional novelty 5.0 of 10

    The survey's L1/L2 taxonomy and benchmark show that current reasoning models waste compute on easy problems and underthink hard ones, motivating more adaptive inference.

Reference graph

Works this paper leans on

28 extracted references · 1 canonical work pages · cited by 2 Pith papers

  1. [1]

    J., Javaheripi, M., Kauffmann, P., et al

    Abdin, M., Aneja, J., Behl, H., Bubeck, S., Eldan, R., Gunasekar, S., Harrison, M., Hewett, R. J., Javaheripi, M., Kauffmann, P., et al. Phi-4 technical report. arXiv preprint arXiv:2412.08905,

    arXiv

  2. [7]

    Critic: Large language models can self- correct with tool-interactive critiquing

    Gou, Z., Shao, Z., Gong, Y ., Shen, Y ., Yang, Y ., Duan, N., and Chen, W. Critic: Large language models can self- correct with tool-interactive critiquing. arXiv preprint arXiv:2305.11738,

    arXiv

  3. [8]

    L., Liu, Y ., Shang, N., Sun, Y ., Zhu, Y ., Yang, F., and Yang, M

    Guan, X., Zhang, L. L., Liu, Y ., Shang, N., Sun, Y ., Zhu, Y ., Yang, F., and Yang, M. rstar-math: Small llms can master math reasoning with self-evolved deep thinking. arXiv preprint arXiv:2501.04519,

    arXiv

  4. [9]

    J., Wang, Z., Wang, D

    Hao, S., Gu, Y ., Ma, H., Hong, J. J., Wang, Z., Wang, D. Z., and Hu, Z. Reasoning with language model is planning with world model. arXiv preprint arXiv:2305.14992 ,

    arXiv

  5. [10]

    S., Yu, A

    Huang, J., Chen, X., Mishra, S., Zheng, H. S., Yu, A. W., Song, X., and Zhou, D. Large language mod- els cannot self-correct reasoning yet. arXiv preprint arXiv:2310.01798,

    arXiv

  6. [11]

    O1 replication journey–part 2: Surpassing o1-preview through simple distillation, big progress or bitter lesson? arXiv preprint arXiv:2411.16489,

    Huang, Z., Zou, H., Li, X., Liu, Y ., Zheng, Y ., Chern, E., Xia, S., Qin, Y ., Yuan, W., and Liu, P. O1 replication journey–part 2: Surpassing o1-preview through simple distillation, big progress or bitter lesson? arXiv preprint arXiv:2411.16489,

    arXiv

  7. [12]

    Openai o1 system card

    Jaech, A., Kalai, A., Lerer, A., Richardson, A., El-Kishky, A., Low, A., Helyar, A., Madry, A., Beutel, A., Car- ney, A., et al. Openai o1 system card. arXiv preprint arXiv:2412.16720,

    arXiv

  8. [13]

    Let’s verify step by step

    Lightman, H., Kosaraju, V ., Burda, Y ., Edwards, H., Baker, B., Lee, T., Leike, J., Schulman, J., Sutskever, I., and Cobbe, K. Let’s verify step by step. arXiv preprint arXiv:2305.20050,

    arXiv

Show all 28 references
  1. [14]

    Making ppo even better: Value- guided monte-carlo tree search decoding

    9 Iterative Deepening Sampling as Efficient Test-Time Scaling Liu, J., Cohen, A., Pasunuru, R., Choi, Y ., Hajishirzi, H., and Celikyilmaz, A. Making ppo even better: Value- guided monte-carlo tree search decoding. arXiv preprint arXiv:2309.15028,

    arXiv

  2. [15]

    V ., Patel, A., Adlakha, V ., Aghajohari, M., BehnamGhader, P., Bhatia, M., Khandelwal, A., Kraft, A., Krojer, B., L`u, X

    Marjanovi´c, S. V ., Patel, A., Adlakha, V ., Aghajohari, M., BehnamGhader, P., Bhatia, M., Khandelwal, A., Kraft, A., Krojer, B., L`u, X. H., et al. Deepseek-r1 thoughtol- ogy: Let’s¡ think¿ about llm reasoning. arXiv preprint arXiv:2504.07128,

  3. [16]

    L., Fei-Fei, L., Hajishirzi, H., Zettlemoyer, L., Liang, P., Cand `es, E., and Hashimoto, T

    Muennighoff, N., Yang, Z., Shi, W., Li, X. L., Fei-Fei, L., Hajishirzi, H., Zettlemoyer, L., Liang, P., Cand `es, E., and Hashimoto, T. s1: Simple test-time scaling. arXiv preprint arXiv:2501.19393,

    arXiv

  4. [17]

    nips.cc/paper_files/paper/2023/file/ 1b44b878bb782e6954cd888628510e90-Paper-Conference

    URL https://papers. nips.cc/paper_files/paper/2023/file/ 1b44b878bb782e6954cd888628510e90-Paper-Conference. pdf. Snell, C., Lee, J., Xu, K., and Kumar, A. Scaling llm test- time compute optimally can be more effective than scal- ing model parameters. arXiv preprint arXiv:2408.03314,

    2023 arXiv

  5. [18]

    Fast best- of-n decoding via speculative rejection

    Sun, H., Haider, M., Zhang, R., Yang, H., Qiu, J., Yin, M., Wang, M., Bartlett, P., and Zanette, A. Fast best- of-n decoding via speculative rejection. arXiv preprint arXiv:2410.20290,

    arXiv

  6. [19]

    On the brittle foundations of react prompting for agentic large language models

    Verma, M., Bhambri, S., and Kambhampati, S. On the brittle foundations of react prompting for agentic large language models. arXiv preprint arXiv:2405.13966,

    arXiv

  7. [20]

    L., Zhang, C., Dhingra, B., and Zou, J

    Wang, J., Zhu, S., Saad-Falcon, J., Athiwaratkun, B., Wu, Q., Wang, J., Song, S. L., Zhang, C., Dhingra, B., and Zou, J. Think deep, think fast: Investigating efficiency of verifier-free inference-time-scaling methods. arXiv preprint arXiv:2504.14047,

    arXiv

  8. [21]

    and Zhou, D

    Wang, X. and Zhou, D. Chain-of-thought reasoning without prompting. arXiv preprint arXiv:2402.10200,

    arXiv

  9. [22]

    Self-consistency im- proves chain of thought reasoning in language models

    Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E., Narang, S., Chowdhery, A., and Zhou, D. Self-consistency im- proves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171,

    arXiv

  10. [24]

    Zeng, Z., Cheng, Q., Yin, Z., Wang, B., Li, S., Zhou, Y ., Guo, Q., Huang, X., and Qiu, X

    URL https: //openreview.net/pdf?id=WE_vluYUL-X. Zeng, Z., Cheng, Q., Yin, Z., Wang, B., Li, S., Zhou, Y ., Guo, Q., Huang, X., and Qiu, X. Scaling of search and learning: A roadmap to reproduce o1 from reinforcement learning perspective. arXiv preprint arXiv:2412.14135,

    arXiv

  11. [25]

    Accessing gpt-4 level mathematical olympiad solutions via monte carlo tree self-refine with llama-3 8b

    Zhang, D., Huang, X., Zhou, D., Li, Y ., and Ouyang, W. Accessing gpt-4 level mathematical olympiad solutions via monte carlo tree self-refine with llama-3 8b. arXiv preprint arXiv:2406.07394, 2024a. Zhang, D., Wu, J., Lei, J., Che, T., Li, J., Xie, T., Huang, X., Zhang, S., P...

    arXiv

  12. [26]

    The lessons of developing process reward models in mathematical reasoning

    Zhang, Z., Zheng, C., Wu, Y ., Zhang, B., Lin, R., Yu, B., Liu, D., Zhou, J., and Lin, J. The lessons of developing process reward models in mathematical reasoning. arXiv preprint arXiv:2501.07301,

    arXiv

  13. [27]

    Language agent tree search unifies reasoning acting and planning in language models

    Zhou, A., Yan, K., Shlapentokh-Rothman, M., Wang, H., and Wang, Y .-X. Language agent tree search unifies reasoning acting and planning in language models. arXiv preprint arXiv:2310.04406,

    arXiv

  14. [28]

    As a re- sult, most standard non-mathematical datasets are not well aligned with the objectives of this study

    are not meaningful, as simply generating diverse final options can trivially improve performance. As a re- sult, most standard non-mathematical datasets are not well aligned with the objectives of this study. We leave the ex- ploration of ID-sampling on less commonly used data...

    2025

  15. [463]

    findings-emnlp.463

    URL https://aclanthology.org/2024. findings-emnlp.463. Chen, G., Liao, M., Li, C., and Fan, K. Alphamath almost zero: process supervision without process, 2024b. URL https://arxiv.org/abs/2405.03553. Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. D. O., Kaplan, J., Edwa...

    2024 arXiv

  16. [2021]

    Reprompt: Plan- ning by automatic prompt engineering for large language models agents

    8 Iterative Deepening Sampling as Efficient Test-Time Scaling Chen, W., Koenig, S., and Dilkina, B. Reprompt: Plan- ning by automatic prompt engineering for large language models agents. arXiv preprint arXiv:2406.11132, 2024c. Chen, W., Koenig, S., and Dilkina, B. Why solving ...

    arXiv

  17. [2022]

    Mmlu-pro: A more robust and challenging multi-task language under- standing benchmark

    Wang, Y ., Ma, X., Zhang, G., Ni, Y ., Chandra, A., Guo, S., Ren, W., Arulraj, A., He, X., Jiang, Z., et al. Mmlu-pro: A more robust and challenging multi-task language under- standing benchmark. arXiv preprint arXiv:2406.01574,

    arXiv

  18. [2023]

    When is tree search useful for llm plan- ning? it depends on the discriminator

    Chen, Z., White, M., Mooney, R., Payani, A., Su, Y ., and Sun, H. When is tree search useful for llm plan- ning? it depends on the discriminator. arXiv preprint arXiv:2402.10890, 2024f. Cobbe, K., Kosaraju, V ., Bavarian, M., Chen, M., Jun, H., Kaiser, L., Plappert, M., Tworek...

    arXiv

  19. [2024]

    Step-level value preference optimization for mathematical reasoning

    Chen, G., Liao, M., Li, C., and Fan, K. Step-level value preference optimization for mathematical reasoning. In Al-Onaizan, Y ., Bansal, M., and Chen, Y .-N. (eds.), Findings of the Association for Computational Linguis- tics: EMNLP 2024 , pp. 7889–7903, Miami, Florida, USA, N...

    2024 doi

  20. [2025]

    Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Yang, A., Fan, A., et al

    URL https://arxiv.org/abs/2501.12948. Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Yang, A., Fan, A., et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783,

    arXiv

Pith tools

Reviewed August 8, 2026 · model on record in the stance chip above.