Pith. sign in

REVIEW 3 major objections 7 minor 4 cited by

e3: Learning to Explore Enables Extrapolation of Test-Time Compute for LLMs

T0 review · 3 major / 7 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read A post-training recipe called e3 teaches a 1.7B LLM to explore in-context—chaining verification with generation—so accuracy keeps climbing when test-time compute doubles beyond the training budget, reaching the best known sub-2B scores on…

desk verdict Mechanism analysis worth reading, but the extrapolation headline rests on a truncation evaluation that likely manufactures the effect. read the letter →

arxiv 2506.09026 v2 pith:2JLTHYKD submitted 2025-06-10 cs.LG cs.CL

Amrith Setlur , Matthew Y. R. Yang , Charlie Snell , Jeremy Greer , Ian Wu , Virginia Smith , Max Simchowitz , Aviral Kumar This is my paper
classification cs.LGcs.CL
keywords test-timescalingextrapolationin-contextexplorationchainedasymmetriesverification-generationgapnegativegradientsreinforcementlearningcurriculum
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 tries to establish that the real payoff of test-time scaling—continued gains on hard problems as a model thinks for longer—requires training the model to explore in-context, not just to answer. It introduces a recipe called e3 that chains a base model's asymmetric skills, most notably a verification-generation gap where verifying an answer is easier than generating one, and uses the negative gradients of reinforcement learning to shift probability mass from short failed traces onto longer traces that chain new asymmetries. A coupled curriculum pairs easy problems with shorter training budgets and hard problems with longer ones, choosing the smallest budget that still rewards further chaining. The result is e3-1.7B, a Qwen3-1.7B model that the paper reports as the best sub-2B model on AIME 2025 and HMMT 2025 and that keeps improving when the test-time budget is doubled from 16k to 32k tokens. If the recipe is correct, small models can buy accuracy with extra inference compute, and outcome-reward RL can teach structured search rather than mere sharpening.

What carries the argument

The load-bearing object is the chained asymmetry: composing two skills $p$ and $q$ (say generation and verification) so that $q(p(\cdot))$ improves expected reward over $p(\cdot)$ alone, even though an optimal policy would never call $q$. The paper formalizes this with the verification-generation gap and analyzes it in a didactic $\mathrm{p}_k$-model, a Markov decision process where the policy draws up to $k$ guesses each failing with probability $p$ and uses perfect verification to stop on the correct one; the model shows that negative gradients increase $k$ and entropy until the optimal action is discovered. The coupled curriculum is the other central device: at each stage, given a dataset $D_i$, the training budget $B_{tr,i}$ is chosen as the smallest budget $B$ such that performance at $2B$ is at most $\kappa$ times performance at $B$ (with $\kappa = 1.2$), balancing room for chained exploration against reinforcement-learning stability.

What would settle it

Sample the e3 model directly with max_new_tokens set to each budget B (true early stopping) instead of truncating stored responses from the right, and compare the accuracy-vs-budget curves; if the extrapolation gains shrink or vanish after this change, then the reported extrapolation is partly an artifact of where final answers sit in long traces rather than a learned ability to use extra compute.

Watch

Extended reading notes

Core claim

The central claim is that extrapolation of test-time compute is achievable by teaching an LLM to perform in-context exploration: generating attempts, verifying them, and revising within a single trace, so that more tokens translate into more chained operations rather than longer monologue. The paper demonstrates three necessary ingredients. First, the base model must admit asymmetric competence—typically that self-verification is easier than generation (the verification-generation gap)—so that chaining verification after generation improves reward even though an optimal policy would never verify. Second, reinforcement learning must retain the negative gradient on incorrect traces, because this is what moves probability mass from short failed responses to longer responses that chain additional asymmetries; masking the negative gradient collapses entropy and stalls exploration. Third, training must use a coupled curriculum over data difficulty and token budget, selecting the smallest budget at which extending to twice the budget gives negligible gain, so that exploration is neither choked by short budgets nor destabilized by long-horizon variance. Applied to Qwen3-1.7B on the DeepScaleR dataset, this yields the best reported sub-2B model on AIME 2025 and HMMT 2025, with accuracy still rising when test-time budget is doubled to 32k.

Load-bearing premise

The load-bearing evaluation assumption is that measuring a model at budget B by generating a full 32k-token trace and then cutting tokens off the end is the same as letting the model decide to stop at B tokens; if final answers tend to appear near the end of long traces, the extrapolation curves would overstate the gains of thinking longer.

Editorial extensions

If this is right

  • A 1.7B model trained with e3 reaches state-of-the-art AIME 2025 and HMMT 2025 scores among sub-2B models and beats several 7B and 32B models at larger test budgets, implying inference compute can substitute for parameter count in math reasoning.
  • The e3 model improves pass@k up to k=32, so the training gains come from discovering new solutions, not just sharpening the base model's distribution around already-found answers.
  • Extrapolation from e3 exceeds prompting-based budget forcing like appending "Wait", so learning in-context exploration is a stronger way to spend extra compute than external interventions.
  • The didactic $\mathrm{p}_k$-model predicts a two-phase dynamic—exploration-driven length increase followed by sharpening—that explains why long-budget RL training is unstable and why a coupled curriculum is needed.

Reading between the lines

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

  • A testable extension is to evaluate e3 with genuinely early-stopped budgets (sampling with max_new_tokens equal to the budget) rather than right-truncating stored 32k traces; if the gains persist, extrapolation is robust, and if not, the curves partly reflect where final answers sit in long traces.
  • The verification-generation gap suggests an inexpensive pre-step for other base models: fine-tune on traces rich in verification steps to create the asymmetry that negative gradients can then chain.
  • Since the paper notes the connection to dense progress rewards, the coupled curriculum could likely be reparameterized as a single RL run with dense rewards, potentially removing stage-wise scheduling for larger models.
  • The repetition bias that limits the base model at long lengths points to explicit exploration bonuses as a direct next lever for pushing extrapolation further.
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

3 major / 7 minor

Summary. The paper proposes e3, a post-training recipe for making small LLMs extrapolate test-time compute beyond the training token budget. The recipe combines chaining of asymmetric skills (e.g., verification vs. generation), use of negative policy-gradient updates during RL, and a coupled curriculum over data difficulty and training token budget. The authors evaluate on Countdown, multiplication, DMath, AIME'25, and HMMT'25, reporting that e3-1.7B achieves the best known <2B results and improves with test-time budget up to 32k tokens, twice the final training budget. They also present a didactic pk-model and a formal entropy-increase result for a bigram softmax policy to explain why negative gradients promote exploration.

Significance. If the extrapolation result holds, e3 would be an important practical contribution: it shows that a 1.7B model can continue improving with more inference compute, and that outcome-reward RL can teach structured in-context search rather than merely sharpening the base distribution. The separation of the three ingredients and the controlled Countdown/Multiply ablations are valuable, and the paper is careful to report pass@k and to compare with several open baselines. However, two central evaluation choices—right-truncation for budget experiments and using AIME'25 to select training budgets—currently threaten the headline extrapolation claim, so the empirical claim needs strengthening before acceptance.

major comments (3)
  1. [Appendix A] The budget-curve evaluation protocol is defined by right-truncation: 'After inference, the model responses were truncated from the right side until the number of remaining tokens present was equal to the specified test-time budget' (Appendix A, Experiment setup). This does not measure performance under a hard token limit B; a rollout longer than B simply loses its final tokens, and any final answer placed after B is discarded. Because e3 is trained to produce long exploratory traces, its answers are likely to appear later than baselines' answers, so this protocol systematically deflates e3's short-budget scores and steepens its accuracy-vs-budget curve. All extrapolation plots in Fig. 2, Fig. 8, Fig. 9, and Fig. 10 are built on this protocol, so the central claim that e3 extrapolates to 2x its training budget is load-bearing on an artifact-prone measurement. Please provide an answer-position analysis (e.g., the distribution of the token index of the final boxed answer for e3 and baselines) and re-run at least one headline comparison with a true budget-constrained decoding (forcing EOS at budget B), to show the extrapolation advantage is not an artifact of answer placement.
  2. [Sec. 6.2, Eq. (6.1), Fig. 8(a)] The training budgets in the final e3 recipe are selected by inspecting extrapolation curves on the same AIME'25 benchmark used for the headline result. The text states 'we find 8k to be the best choice for training on easy problems (observe that the trained model satisfies the condition in Eq. 6.1 at κ=1.2 in Fig. 8(a))', and 16k is then chosen for the second stage. Since AIME'25 appears both in the selection criterion (Eq. 6.1 evaluated on AIME'25 curves) and in the final evaluation (Fig. 10a, Table 1), part of the reported AIME'25 extrapolation gain may be a selection effect. Please either re-run the budget selection on a separate validation set (e.g., a subset of DMath not used for training) and use AIME'25 only as a final test, or report the HMMT'25 results as the primary pre-registered evidence. As written, the AIME'25 extrapolation claim is partially circular.
  3. [Sec. 5, Theorem 5.1 / App. E] The formal statement that 'negative gradient increases entropy when a* is unlikely' (Theorem 5.1, detailed as Theorem E.3) is proved for a bigram softmax policy with perfect verification, and the proof only concerns a single gradient step. This is a useful didactic model, but it does not by itself establish that RL on LLMs will produce sustained length growth or extrapolation; the empirical Countdown/DMath results are doing that work. The paper's language in Sec. 5 ('we formalize the intuitions...') and in the Introduction ('we formalize their role and show they are essential') overstates the reach of the theorem. Please soften the formal claims or add a discussion of the gap between the bigram model and the LLM setting.
minor comments (7)
  1. [Sec. 8] The last paragraph of Sec. 8 contains a typo: 'currciulum' should be 'curriculum'.
  2. [App. C.1, App. C.3] There are typos in the appendices: 'immidiately' should be 'immediately' (App. C.1) and 'connetn' should be 'connect' (App. C.3).
  3. [Fig. 8(c)-(d)] The x-axis of Fig. 8(c) and (d) is labeled 'Length' while the other panels use 'Test-time compute (tokens)'; please unify the labeling or clarify in the caption.
  4. [Eq. (6.1), Fig. 9(c)] The notation in Eq. (6.1) and Fig. 9(c) is confusing: the ratio in Fig. 9(c) is not clearly connected to the condition in Eq. (6.1). Please define J(π1) and J(π2) in the caption and explain how the plotted ratio relates to the budget selection rule.
  5. [Sec. 6.3] In Sec. 6.3, the claim 'we outperform the best model in this class by >8% on AIME'25 in terms of peak performance' should specify which model is the reference and at which budget the comparison is made.
  6. [Table 1] The pass@k values in Table 1 are reported without confidence intervals, and for k=16 and k=32 with only 128 rollouts the estimates may be noisy; please report intervals or validate with a larger number of rollouts for at least the final model.
  7. [General] The manuscript states a project website but does not include code or model weights; releasing the training code, prompts, and evaluation scripts would substantially improve reproducibility.

Circularity Check

2 steps flagged · score 6.0 of 10

Budget selection via Eq. 6.1 and right-truncation-based evaluation together make the headline AIME'25 extrapolation partly constructed rather than independently predicted.

  1. fitted input called prediction [Section 6.2, Eq. (6.1), Fig. 8(a); Abstract]
    "E.g., setting κ = 1.2, we find 8k to be the best choice for training on easy problems (observe that the trained model satisfies the condition in Eq. 6.1 at κ = 1.2 in Fig. 8(a)). ... Our recipe e3 produces the best known 1.7B model according to AIME'25 and HMMT'25 scores, and extrapolates to 2× the training token budget."

    The training budget Btr is selected by Eq. (6.1) using J(pi; D, 2B) relative to J(pi; D, B), i.e., using the same AIME'25 extrapolation curve that the paper later reports as evidence of extrapolation. The authors explicitly state that 8k is 'the best choice' by inspecting Fig. 8(a), which plots accuracy on AIME'25 at test budgets 4k-32k. The headline claim 'extrapolates to 2× the training token budget' is then evaluated on AIME'25 for a model trained with that selected budget. This is selection on the test metric: the recipe's key budget hyperparameter was chosen to optimize the very curve that is presented as the central empirical finding, so the AIME'25 extrapolation result is a fitted best-case rather than an independent prediction.

  2. other [Appendix A; Section 4 (Negative Gradients)]
    "After inference, the model responses were truncated from the right side until the number of remaining tokens present was equal to the specified test-time budget. ... Negative gradients drive exploration by moving the probability mass from shorter failed traces onto longer traces that “chain” new asymmetries (e.g., LLM verifying a calculation one more time)."

    Under the Appendix A protocol, 'accuracy at budget B' is not solve probability when the model is actually constrained to B tokens; it is the probability that the final answer appears within the first B tokens of a full 32k trace. The paper's own analysis shows that e3's training explicitly increases response length by chaining asymmetries and suppressing EOS probability, so e3's answers are systematically later in the trace. Right-truncation therefore removes final answers from e3's short-budget traces, deflating its 4k/8k scores while leaving 32k scores intact.

full rationale

The paper is not definitionally circular in its didactic pk-model or its Countdown/Multiplication analyses: the negative-gradient entropy theorem (Thm. 5.1) is a genuine mathematical result, and the Countdown/Mult-V comparisons are empirical controls that do not reduce to their inputs. The self-citations to prior work on VG gaps and dense progress rewards are contextual and not load-bearing. However, two choices undermine the central extrapolation claim. First, the training budget Btr is selected via Eq. (6.1) from the AIME'25 extrapolation curve, and the same benchmark is then used to report the headline 'extrapolates to 2× the training token budget'; this is test-set selection, making the AIME'25 extrapolation result partly a fit. Second, Appendix A defines accuracy at a test budget by right-truncating full 32k responses, so the measured budget-vs-accuracy curve conflates genuine budget-constrained solving with the position of the final answer in a long trace. Since e3 is explicitly trained to lengthen traces, this protocol mechanically penalizes e3 at short budgets and rewards it at the full budget, steepening its extrapolation curve. The HMMT'25 results and the didactic analyses provide independent content, so the paper is not wholly circular, but the primary AIME'25 extrapolation claim is substantially constructed by these two choices. Score 6 reflects partial circularity: the central 'prediction' reduces in part to a fitted hyperparameter and a metric that aligns with the training objective.

Assumptions & free parameters 5 free parameters · 7 assumptions · 0 invented entities

The main result is an empirical recipe. The core assumptions are the presence of a verification-generation gap in the base model on math problems, the validity of right-truncation as a budget evaluation, and the usefulness of the hand-chosen curriculum rule in Eq. 6.1. No new physical entities are postulated; the pk-model is a theoretical construct, not an entity.

free parameters (5)
  • kappa in Eq. 6.1 = 1.2
    Hand-chosen threshold that determines the 8k budget for the first e3 stage; changing kappa changes which budget is picked.
  • Training budgets for e3 stages = 8k then 16k tokens
    Selected using AIME'25 extrapolation curves (Fig. 8a, Sec. 6.2), so the headline benchmark is used to choose training constants.
  • DMath difficulty splits = easy/medium/hard by Qwen-R1-Distilled-32B accuracy
    The thresholds defining the curriculum stages are ad hoc and affect which problems appear in each stage.
  • B0 anchor in Eq. 6.1 = average response length of current policy
    The lower bound of the budget search is policy-dependent and not specified as a fixed constant.
  • RL hyperparameters for 8k/16k stages = LR 1e-6; entropy_coeff 0.002/0.001; clip ratios 0.2/0.5 then 0.2/0.35; rollout.n 16 then 32
    These hand-set values stabilize training and affect the final model; no sensitivity analysis is reported.
assumptions (7)
  • domain assumption Qwen3-1.7B exhibits a verification-generation gap on DMath and AIME-style problems.
    Section 3 defines VG gap and validates it on Countdown/Mult, then Section 6 builds e3 assuming it transfers to DMath/AIME.
  • domain assumption Right-truncating a 32k-token completion to a shorter budget measures performance at that budget.
    Appendix A: 'After inference, the model responses were truncated from the right side...' This is unvalidated; it conflates answer placement with budget use.
  • ad hoc to paper The curriculum selection rule Eq. 6.1 with kappa=1.2 identifies an RL-friendly budget that enables extrapolation.
    kappa is a hand-chosen threshold, and the rule is a heuristic that is checked post hoc on AIME'25 curves in Fig. 8a.
  • ad hoc to paper The didactic pk-model with perfect verification and independent attempts captures the mechanism of negative gradients in LLMs.
    Section 5 relies on this simplified model to explain length increase; transfer to real LLMs is not proven.
  • standard math GRPO with token-level normalization and clipping approximates the policy gradient in Eq. 2.1.
    The analysis of negative gradients in Section 4 uses this approximation.
  • domain assumption AIME 2025 and HMMT 2025 benchmarks are free of contamination that would wash out training differences.
    Headline comparisons assume the observed gaps reflect generalization rather than memorization; the paper notes AIME 2025 was chosen to mitigate contamination but does not test for it.
  • standard math The softmax bigram policy class and small-learning-rate Taylor expansion in Theorem E.3 support the entropy-increase claim.
    Theorem 5.1 and Appendix E; proof uses convexity of x(H+log x) and requires support conditions on the policy.

how reviews work

0 comments
Cite this review

Pith. "Pith review of e3: Learning to Explore Enables Extrapolation of Test-Time Compute for LLMs." pith.science (2026). https://pith.science/paper/2JLTHYKD

@misc{pith2026250609026,
  author       = {Pith},
  title        = {Pith review of: e3: Learning to Explore Enables Extrapolation of Test-Time Compute for LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2JLTHYKD}},
  note         = {Machine review of arXiv:2506.09026}
}
read the original abstract

Test-time scaling offers a promising path to improve LLM reasoning by utilizing more compute at inference time; however, the true promise of this paradigm lies in extrapolation (i.e., improvement in performance on hard problems as LLMs keep "thinking" for longer, beyond the maximum token budget they were trained on). Surprisingly, we find that most existing reasoning models do not extrapolate well. We show that one way to enable extrapolation is by training the LLM to perform in-context exploration: training the LLM to effectively spend its test time budget by chaining operations (such as generation, verification, refinement, etc.), or testing multiple hypotheses before it commits to an answer. To enable in-context exploration, we identify three key ingredients as part of our recipe e3: (1) chaining skills that the base LLM has asymmetric competence in, e.g., chaining verification (easy) with generation (hard), as a way to implement in-context search; (2) leveraging "negative" gradients from incorrect traces to amplify exploration during RL, resulting in longer search traces that chains additional asymmetries; and (3) coupling task difficulty with training token budget during training via a specifically-designed curriculum to structure in-context exploration. Our recipe e3 produces the best known 1.7B model according to AIME'25 and HMMT'25 scores, and extrapolates to 2x the training token budget. Our e3-1.7B model not only attains high pass@1 scores, but also improves pass@k over the base model.

Discussion (0). Sign in to comment.

Forward citations

Cited by 4 Pith papers

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

  1. Representation-Based Exploration for Language Models: From Test-Time to Post-Training

    cs.LG 2025-10 conditional novelty 6.0 of 10

    Representation-based elliptical bonuses improve inference-time and post-training pass@k for LLM reasoning, but the headline AIME result is tainted by validation/test overlap.

  2. Outcome-based Exploration for LLM Reasoning

    cs.LG 2025-09 conditional novelty 6.0 of 10

    Outcome-based exploration bonuses (UCB-Con and Batch) improve pass@1 and pass@32 for LLM math reasoning while slowing diversity collapse, supported by a bandit model with a strong generalization assumption.

  3. Pass@k Training for Adaptively Balancing Exploration and Exploitation of Large Reasoning Models

    cs.LG 2025-08 conditional novelty 5.0 of 10

    Using Pass@k as an RLVR reward, with bootstrap sampling and an analytical advantage formula, improves exploration and later Pass@1 performance of reasoning LLMs.

  4. ASTRO: Teaching Language Models to Reason by Reflecting and Backtracking In-Context

    cs.AI 2025-07 conditional novelty 5.0 of 10

    ASTRO converts MCTS search trees into chain-of-thoughts with explicit self-reflection and backtracking, trains Llama-3.1-70B on them with SFT, then improves with RL, reaching 81.8% on MATH-500, 64.4% on AMC 2023, and ...

Reference graph

Works this paper leans on

92 extracted references · 29 canonical work pages · cited by 4 Pith papers

  1. [1]

    On the theory of policy gradient methods: Optimality, approximation, and distribution shift.Journal of Machine Learning Research, 22(98):1–76, 2021

    Alekh Agarwal, Sham M Kakade, Jason D Lee, and Gaurav Mahajan. On the theory of policy gradient methods: Optimality, approximation, and distribution shift.Journal of Machine Learning Research, 22(98):1–76, 2021

    2021

  2. [2]

    L1: Controlling how long a reasoning model thinks with reinforcement learning.arXiv preprint arXiv:2503.04697, 2025

    Pranjal Aggarwal and Sean Welleck. L1: Controlling how long a reasoning model thinks with reinforcement learning.arXiv preprint arXiv:2503.04697, 2025

    arXiv 2025

  3. [3]

    Back to basics: Revisiting reinforce style optimization for learning from human feedback in llms.arXiv preprint arXiv:2402.14740, 2024

    Arash Ahmadian, Chris Cremer, Matthias Gallé, Marzieh Fadaee, Julia Kreutzer, Olivier Pietquin, Ahmet Üstün, and Sara Hooker. Back to basics: Revisiting reinforce style optimization for learning from human feedback in llms.arXiv preprint arXiv:2402.14740, 2024

    arXiv 2024

  4. [4]

    Evaluating large language models trained on code.arXiv preprint arXiv:2107.03374, 2021

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code.arXiv preprint arXiv:2107.03374, 2021

    arXiv 2021

  5. [5]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning,

    DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Zhipeng Xu, Zhongyu Zhang, and Zhen Zhang. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning,

  6. [6]

    Rl2: Fast reinforcement learning via slow reinforcement learning.arXiv preprint arXiv:1611.02779, 2016

    Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning.arXiv preprint arXiv:1611.02779, 2016

    arXiv 2016

  7. [7]

    Open r1: A fully open reproduction of deepseek-r1, January 2025

    Hugging Face. Open r1: A fully open reproduction of deepseek-r1, January 2025. URLhttps: //github.com/huggingface/open-r1. 16 e3: Learning to Explore Enables Extrapolation of Test-Time Compute for LLMs

    2025

  8. [8]

    Stream of search (sos): Learning to search in language.arXiv preprint arXiv:2404.03683, 2024

    Kanishk Gandhi, Denise Lee, Gabriel Grand, Muxin Liu, Winson Cheng, Archit Sharma, and Noah D Goodman. Stream of search (sos): Learning to search in language.arXiv preprint arXiv:2404.03683, 2024

    arXiv 2024

Show all 92 references
  1. [9]

    Kanishk Gandhi, Ayush Chakravarthy, Anikait Singh, Nathan Lile, and Noah D. Goodman. Cognitive behaviors that enable self-improving reasoners, or, four habits of highly effective stars, 2025. URL https://arxiv.org/abs/2503.01307

    2025 arXiv

  2. [10]

    Reward learning for efficient reinforcement learning in extractive document summarisation.arXiv preprint arXiv:1907.12894, 2019

    Yang Gao, Christian M Meyer, Mohsen Mesgar, and Iryna Gurevych. Reward learning for efficient reinforcement learning in extractive document summarisation.arXiv preprint arXiv:1907.12894, 2019

    1907 arXiv

  3. [11]

    Adams, and Sergey Levine

    Dibya Ghosh, Jad Rahme, Aviral Kumar, Amy Zhang, Ryan P. Adams, and Sergey Levine. Why generalization in RL is difficult: Epistemic pomdps and implicit partial observability. CoRR, abs/2107.06277, 2021. URLhttps://arxiv.org/abs/2107.06277

    2021 arXiv

  4. [12]

    Unsupervised meta- learning for reinforcement learning.CoRR, abs/1806.04640, 2018

    Abhishek Gupta, Benjamin Eysenbach, Chelsea Finn, and Sergey Levine. Unsupervised meta- learning for reinforcement learning.CoRR, abs/1806.04640, 2018. URLhttp://arxiv.org/abs/ 1806.04640

    2018 arXiv

  5. [13]

    Provably efficient maximum entropy exploration

    Elad Hazan, Sham Kakade, Karan Singh, and Abby Van Soest. Provably efficient maximum entropy exploration. InICML, 2019. URLhttps://arxiv.org/pdf/1812.02690.pdf

    2019 arXiv

  6. [14]

    A sober look at progress in language model reasoning: Pitfalls and paths to reproducibility

    Andreas Hochlehnert, Hardik Bhatnagar, Vishaal Udandarao, Samuel Albanie, Ameya Prabhu, and Matthias Bethge. A sober look at progress in language model reasoning: Pitfalls and paths to reproducibility. arXiv preprint arXiv:2504.07086, 2025

    2025

  7. [15]

    Self-improvement in language models: The sharpening mechanism

    Audrey Huang, Adam Block, Dylan J Foster, Dhruv Rohatgi, Cyril Zhang, Max Simchowitz, Jordan T Ash, and Akshay Krishnamurthy. Self-improvement in language models: The sharpening mechanism. arXiv preprint arXiv:2412.01951, 2024

    2024 arXiv

  8. [16]

    Scaling evaluation-time compute with reasoning models as process evaluators.arXiv preprint arXiv:2503.19877, 2025

    Seungone Kim, Ian Wu, Jinu Lee, Xiang Yue, Seongyun Lee, Mingyeong Moon, Kiril Gashteovski, Carolin Lawrence, Julia Hockenmaier, Graham Neubig, et al. Scaling evaluation-time compute with reasoning models as process evaluators.arXiv preprint arXiv:2503.19877, 2025

    2025 arXiv

  9. [17]

    Can large language models explore in-context?arXiv preprint arXiv:2403.15371, 2024

    Akshay Krishnamurthy, Keegan Harris, Dylan J Foster, Cyril Zhang, and Aleksandrs Slivkins. Can large language models explore in-context?arXiv preprint arXiv:2403.15371, 2024

    2024 arXiv

  10. [18]

    Training language models to self-correct via reinforcement learning.arXiv preprint arXiv:2409.12917, 2024

    Aviral Kumar, Vincent Zhuang, Rishabh Agarwal, Yi Su, John D Co-Reyes, Avi Singh, Kate Baumli, Shariq Iqbal, Colton Bishop, Rebecca Roelofs, et al. Training language models to self-correct via reinforcement learning.arXiv preprint arXiv:2409.12917, 2024

    2024 arXiv

  11. [19]

    Understanding the complexity gains of single-task rl with a curriculum.arXiv preprint arXiv:2212.12809, 2022

    Qiyang Li, Yuexiang Zhai, Yi Ma, and Sergey Levine. Understanding the complexity gains of single-task rl with a curriculum.arXiv preprint arXiv:2212.12809, 2022

    2022 arXiv

  12. [20]

    Long-context llms struggle with long in-context learning.arXiv preprint arXiv:2404.02060, 2024

    Tianle Li, Ge Zhang, Quy Duc Do, Xiang Yue, and Wenhu Chen. Long-context llms struggle with long in-context learning.arXiv preprint arXiv:2404.02060, 2024

    2024 arXiv

  13. [21]

    Learning abstract models for strategic exploration and fast reward transfer

    Evan Zheran Liu, Ramtin Keramati, Sudarshan Seshadri, Kelvin Guu, Panupong Pasupat, Emma Brunskill, and Percy Liang. Learning abstract models for strategic exploration and fast reward transfer. arXiv preprint arXiv:2007.05896, 2020. 17 e3: Learning to Explore Enables Extrapola...

    2007 arXiv

  14. [22]

    Prorl: Prolonged reinforcement learning expands reasoning boundaries in large language models.arXiv preprint arXiv:2505.24864, 2025

    Mingjie Liu, Shizhe Diao, Ximing Lu, Jian Hu, Xin Dong, Yejin Choi, Jan Kautz, and Yi Dong. Prorl: Prolonged reinforcement learning expands reasoning boundaries in large language models.arXiv preprint arXiv:2505.24864, 2025

    2025 arXiv

  15. [23]

    Understanding r1-zero-like training: A critical perspective.arXiv preprint arXiv:2503.20783, 2025

    Zichen Liu, Changyu Chen, Wenjun Li, Penghui Qi, Tianyu Pang, Chao Du, Wee Sun Lee, and Min Lin. Understanding r1-zero-like training: A critical perspective.arXiv preprint arXiv:2503.20783, 2025

    2025 arXiv

  16. [24]

    Acemath: Advancing frontier math reasoning with post-training and reward modeling.arXiv preprint, 2024

    Zihan Liu, Yang Chen, Mohammad Shoeybi, Bryan Catanzaro, and Wei Ping. Acemath: Advancing frontier math reasoning with post-training and reward modeling.arXiv preprint, 2024

    2024

  17. [25]

    Deepcoder: A fully open-source 14b coder at o3-mini level, 2025

    Michael Luo, Sijun Tan, Roy Huang, Ameen Patel, Alpay Ariyak, Qingyang Wu, Xiaoxiang Shi, Rachel Xin, Colin Cai, Maurice Weber, Ce Zhang, Li Erran Li, Raluca Ada Popa, and Ion Stoica. Deepcoder: A fully open-source 14b coder at o3-mini level, 2025. Notion Blog

    2025

  18. [26]

    Tang, Manan Roongta, Colin Cai, Jeffrey Luo, Tianjun Zhang, Li Erran Li, Raluca Ada Popa, and Ion Stoica

    Michael Luo, Sijun Tan, Justin Wong, Xiaoxiang Shi, William Y. Tang, Manan Roongta, Colin Cai, Jeffrey Luo, Tianjun Zhang, Li Erran Li, Raluca Ada Popa, and Ion Stoica. DeepScaleR: Surpassing O1-Preview with a 1.5B Model by Scaling RL, 2025. Notion Blog

    2025

  19. [27]

    s1: Simple test-time scaling,

    Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori Hashimoto. s1: Simple test-time scaling,

  20. [28]

    Evolve: Evaluating and optimizing llms for exploration.arXiv preprint arXiv:2410.06238, 2024

    Allen Nie, Yi Su, Bo Chang, Jonathan N Lee, Ed H Chi, Quoc V Le, and Minmin Chen. Evolve: Evaluating and optimizing llms for exploration.arXiv preprint arXiv:2410.06238, 2024

    2024 arXiv

  21. [29]

    URLhttps://arxiv.org/abs/2501.19393

    arXiv

  22. [30]

    Maximizing confidence alone improves reasoning.arXiv preprint arXiv:2505.22660, 2025

    Mihir Prabhudesai, Lili Chen, Alex Ippoliti, Katerina Fragkiadaki, Hao Liu, and Deepak Pathak. Maximizing confidence alone improves reasoning.arXiv preprint arXiv:2505.22660, 2025

    2025 arXiv

  23. [31]

    Openai o1 system card, 2024

    OpenAI, :, Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Yuchen Zhang, Yunyun Wang, Zheng Shao, and Zhuohan Li. Openai o1 system card, 2024. URLhttps://arxiv.org/abs/2412.16720

    2024 arXiv

  24. [32]

    Optimizing anytime reasoning via budget relative policy optimization.arXiv preprint arXiv:2505.13438, 2025

    Penghui Qi, Zichen Liu, Tianyu Pang, Chao Du, Wee Sun Lee, and Min Lin. Optimizing anytime reasoning via budget relative policy optimization.arXiv preprint arXiv:2505.13438, 2025

    2025

  25. [33]

    John Wiley & Sons, Inc., 1994

    Martin L Puterman.Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, Inc., 1994

    1994

  26. [34]

    Optimizing test-time compute via meta reinforcement fine-tuning

    Yuxiao Qu, Matthew YR Yang, Amrith Setlur, Lewis Tunstall, Edward Emanuel Beeching, Ruslan Salakhutdinov, and Aviral Kumar. Optimizing test-time compute via meta reinforcement fine-tuning. arXiv preprint arXiv:2503.07572, 2025

    2025 arXiv

  27. [35]

    Recursive introspection: Teaching language model agents how to self-improve.arXiv preprint arXiv:2407.18219, 2024

    Yuxiao Qu, Tianjun Zhang, Naman Garg, and Aviral Kumar. Recursive introspection: Teaching language model agents how to self-improve.arXiv preprint arXiv:2407.18219, 2024

    2024 arXiv

  28. [36]

    Rewarding progress: Scaling automated process verifiers for llm reasoning.arXiv preprint arXiv:2410.08146, 2024

    Amrith Setlur, Chirag Nagpal, Adam Fisch, Xinyang Geng, Jacob Eisenstein, Rishabh Agarwal, Alekh Agarwal, Jonathan Berant, and Aviral Kumar. Rewarding progress: Scaling automated process verifiers for llm reasoning.arXiv preprint arXiv:2410.08146, 2024. 18 e3: Learning to Expl...

    arXiv

  29. [37]

    Proximal policy optimization algorithms.arXiv preprint arXiv:1707.06347, 2017

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms.arXiv preprint arXiv:1707.06347, 2017

    2017 arXiv

  30. [38]

    Scaling test-time compute without verification or rl is suboptimal.arXiv preprint arXiv:2502.12118, 2025

    Amrith Setlur, Nived Rajaraman, Sergey Levine, and Aviral Kumar. Scaling test-time compute without verification or rl is suboptimal.arXiv preprint arXiv:2502.12118, 2025

    2025 arXiv

  31. [39]

    Opti- mizing llm test-time compute involves solving a meta-rl problem.https://blog.ml.cmu.edu/,

    Amrith Setlur, Yuxiao Qu, Matthew Yang, Lunjun Zhang, Virginia Smith, and Aviral Kumar. Opti- mizing llm test-time compute involves solving a meta-rl problem.https://blog.ml.cmu.edu/,

  32. [40]

    Spurious rewards: Rethinking training signals in rlvr, 2025

    Rulin Shao, Shuyue Stella Li, Rui Xin, Scott Geng, Yiping Wang, Sewoong Oh, Simon Shaolei Du, Nathan Lambert, Sewon Min, Ranjay Krishna, Yulia Tsvetkov, Hannaneh Hajishirzi, Pang Wei Koh, and Luke Zettlemoyer. Spurious rewards: Rethinking training signals in rlvr, 2025. Notion Blog

    2025

  33. [41]

    Can large reasoning models self-train?, 2025

    Sheikh Shafayat, Fahim Tajwar, Ruslan Salakhutdinov, Jeff Schneider, and Andrea Zanette. Can large reasoning models self-train?, 2025. URLhttps://arxiv.org/abs/2505.21444

    2025

  34. [42]

    Hybridflow: A flexible and efficient rlhf framework.arXiv preprint arXiv: 2409.19256, 2024

    Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework.arXiv preprint arXiv: 2409.19256, 2024

    2024 arXiv

  35. [43]

    Deepseekmath: Pushing the limits of mathematical reasoning in open language models.arXiv preprint arXiv:2402.03300, 2024

    ZhihongShao,PeiyiWang,QihaoZhu,RunxinXu,JunxiaoSong,XiaoBi,HaoweiZhang,Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models.arXiv preprint arXiv:2402.03300, 2024

    2024 arXiv

  36. [44]

    Scaling llm test-time compute optimally can be more effective than scaling model parameters.arXiv preprint arXiv:2408.03314, 2024

    Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters.arXiv preprint arXiv:2408.03314, 2024

    2024 arXiv

  37. [45]

    Efficient reinforcement finetuning via adaptive curriculum learning, 2025

    Taiwei Shi, Yiyang Wu, Linxin Song, Tianyi Zhou, and Jieyu Zhao. Efficient reinforcement finetuning via adaptive curriculum learning, 2025. URLhttps://arxiv.org/abs/2504.05520

    2025 arXiv

  38. [46]

    A minimax- imalist approach to reinforcement learning from human feedback.arXiv:2401.04056, 2024

    Gokul Swamy, Christoph Dann, Rahul Kidambi, Zhiwei Steven Wu, and Alekh Agarwal. A minimax- imalist approach to reinforcement learning from human feedback.arXiv:2401.04056, 2024

    2024 arXiv

  39. [47]

    Mind the gap: Examining the self-improvement capabilities of large language models.arXiv preprint arXiv:2412.02674, 2024

    Yuda Song, Hanlin Zhang, Carson Eisenach, Sham Kakade, Dean Foster, and Udaya Ghai. Mind the gap: Examining the self-improvement capabilities of large language models.arXiv preprint arXiv:2412.02674, 2024

    2024 arXiv

  40. [48]

    Preference Fine-Tuning of LLMs Should Leverage Suboptimal, On-Policy Data, ICML 2024

    Fahim Tajwar, Anikait Singh, Archit Sharma, Rafael Rafailov, Jeff Schneider, Tengyang Xie, Ste- fano Ermon, Chelsea Finn, and Aviral Kumar. Preference Fine-Tuning of LLMs Should Leverage Suboptimal, On-Policy Data, ICML 2024

    2024

  41. [49]

    All roads lead to likelihood: The value of reinforcement learning in fine-tuning

    Gokul Swamy, Sanjiban Choudhury, Wen Sun, Zhiwei Steven Wu, and J Andrew Bagnell. All roads lead to likelihood: The value of reinforcement learning in fine-tuning. arXiv preprint arXiv:2503.01067, 2025

    2025

  42. [50]

    Open Thoughts

    OpenThoughts Team. Open Thoughts. https://open-thoughts.ai, February 2025

    2025

  43. [51]

    Kimi k1.5: Scaling reinforcement learning with llms, 2025

    Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Zhexu Wang, Zhilin Yang, Zhiqi Huang, Zihao Huang, Ziyao Xu, and Zonghan Yang. Kimi k1.5: Scaling reinforcement learning with llms, 2025. URLhttps://arxiv.org/abs/2501.12599

    2025 arXiv

  44. [52]

    Self-consistency improves chain of thought reasoning in language models.arXiv preprint arXiv:2203.11171, 2022

    XuezhiWang, JasonWei, DaleSchuurmans, QuocLe, EdChi, SharanNarang, AakankshaChowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models.arXiv preprint arXiv:2203.11171, 2022

    2022 arXiv

  45. [53]

    Beyond the 80/20 rule: High-entropy minority tokens drive effective reinforcement learning for llm reasoning.arXiv preprint arXiv:2506.01939, 2025

    Shenzhi Wang, Le Yu, Chang Gao, Chujie Zheng, Shixuan Liu, Rui Lu, Kai Dang, Xionghui Chen, Jianxin Yang, Zhenru Zhang, et al. Beyond the 80/20 rule: High-entropy minority tokens drive effective reinforcement learning for llm reasoning.arXiv preprint arXiv:2506.01939, 2025. 19...

    2025 arXiv

  46. [54]

    Logic-rl: Unleashing llm reasoning with rule-based reinforcement learning

    Tian Xie, Zitian Gao, Qingnan Ren, Haoming Luo, Yuqian Hong, Bryan Dai, Joey Zhou, Kai Qiu, Zhirong Wu, and Chong Luo. Logic-rl: Unleashing llm reasoning with rule-based reinforcement learning. arXiv preprint arXiv:2502.14768, 2025

    2025 arXiv

  47. [55]

    Reinforcement learning for reasoning in large language models with one training example.arXiv preprint arXiv:2504.20571, 2025

    Yiping Wang, Qing Yang, Zhiyuan Zeng, Liliang Ren, Lucas Liu, Baolin Peng, Hao Cheng, Xuehai He, Kuan Wang, Jianfeng Gao, et al. Reinforcement learning for reasoning in large language models with one training example.arXiv preprint arXiv:2504.20571, 2025

    2025 arXiv

  48. [56]

    Tree of thoughts: Deliberate problem solving with large language models.arXiv preprint arXiv:2305.10601, 2023

    Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models.arXiv preprint arXiv:2305.10601, 2023

    2023 arXiv

  49. [57]

    Qwen3 technical report.arXiv preprint arXiv:2505.09388, 2025

    An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al. Qwen3 technical report.arXiv preprint arXiv:2505.09388, 2025

    2025 arXiv

  50. [58]

    Dapo: An open-source llm reinforcement learning system at scale

    Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Tiantian Fan, Gaohong Liu, Lingjun Liu, Xin Liu, et al. Dapo: An open-source llm reinforcement learning system at scale. arXiv preprint arXiv:2503.14476, 2025

    2025 arXiv

  51. [59]

    Demystifying long chain- of-thought reasoning in llms, 2025

    Edward Yeo, Yuxuan Tong, Morry Niu, Graham Neubig, and Xiang Yue. Demystifying long chain- of-thought reasoning in llms, 2025. URLhttps://arxiv.org/abs/2502.03373

    2025 arXiv

  52. [60]

    Does reinforcement learning really incentivize reasoning capacity in llms beyond the base model?arXiv preprint arXiv:2504.13837, 2025

    Yang Yue, Zhiqi Chen, Rui Lu, Andrew Zhao, Zhaokai Wang, Shiji Song, and Gao Huang. Does reinforcement learning really incentivize reasoning capacity in llms beyond the base model?arXiv preprint arXiv:2504.13837, 2025

    2025 arXiv

  53. [61]

    Scaling relationship on learning mathematical reasoning with large language models.arXiv preprint arXiv:2308.01825, 2023

    Zheng Yuan, Hongyi Yuan, Chengpeng Li, Guanting Dong, Chuanqi Tan, and Chang Zhou. Scaling relationship on learning mathematical reasoning with large language models.arXiv preprint arXiv:2308.01825, 2023

    2023 arXiv

  54. [63]

    Star: Bootstrapping reasoning with reasoning

    Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah Goodman. Star: Bootstrapping reasoning with reasoning. Advances in Neural Information Processing Systems, 35:15476–15488, 2022

    2022

  55. [64]

    reasoning

    Xuandong Zhao, Zhewei Kang, Aosong Feng, Sergey Levine, and Dawn Song. Learning to reason without external rewards, 2025. URLhttps://arxiv.org/abs/2505.19590. 20 e3: Learning to Explore Enables Extrapolation of Test-Time Compute for LLMs Appendices A. Testing Extrapolation of ...

    2025 arXiv

  56. [65]

    Simplerl- zoo: Investigating and taming zero reinforcement learning for open base models in the wild, 2025

    Weihao Zeng, Yuzhen Huang, Qian Liu, Wei Liu, Keqing He, Zejun Ma, and Junxian He. Simplerl- zoo: Investigating and taming zero reinforcement learning for open base models in the wild, 2025. URL https://arxiv.org/abs/2503.18892

    2025 arXiv

  57. [66]

    Looking at the other numbers: 77 - 70 = 7 97 - 73 = 24 (interesting, we already have

    70 - 4 = 66, so maybe we can create 4 somewhere. Looking at the other numbers: 77 - 70 = 7 97 - 73 = 24 (interesting, we already have

  58. [67]

    First, let’s try to get close to 466 with simple operations: 65 + 56 = 121 (too small) 65 - 56 = 9 (too small) 65 * 56 = way too large 56 * 65 = way too large

  59. [68]

    We need to get from 37 to 466, which means we need to multiply by 12.5

    Let’s try working backwards from 466: 466 is much larger than any of the given numbers, so multiplication will likely be needed. We need to get from 37 to 466, which means we need to multiply by 12.5. But we don’t have 12.5, so we’ll need to create it through division

  60. [69]

    Let’s try: 37 * 14 = 518 (too large) 37 - 14 = 23 (too small) 37 + 14 = 51 (too small)

  61. [70]

    Let’s try a different approach: 65 + 61 = 126 126 + 56 = 182 182 + 37 = 219 (getting closer)

  62. [71]

    Let’s try: 65 + 61 = 126 126 + 56 = 182 182 + 37 = 219 219 + 14 = 233 (still too small)

  63. [72]

    Let’s try one more approach: 65 + 56 = 121 121 + 61 = 182 182 + 37 = 219 219 + 14 = 233 (still not 466)

  64. [73]

    Let’s try: 65 + 56 = 121 121 + 61 = 182 182 + 37 = 219 219 + 14 = 233 (still not 466)

  65. [74]

    One more attempt: 65 + 61 = 126 126 + 37 = 163 163 + 56 = 219 219 + 14 = 233 (still not 466)

  66. [75]

    Final try: 65 + 61 = 126 126 + 56 = 182 182 + 37 = 219 219 - 14 = 205 (not quite there)

  67. [76]

    Let’s try: 65 + 61 = 126 126 + 56 = 182 182 + 37 = 219 219 + 14 = 233 (still not 466)

  68. [77]

    New approach: 65 + 61 = 126 126 + 56 = 182 182 - 37 = 145 145 + 14 = 159 (not quite there)

  69. [78]

    Final attempt: 65 + 61 = 126 126 + 56 = 182 182 + 37 = 219 219 - 14 = 205 (not quite there)

  70. [79]

    Let’s try: 65 + 56 = 121 121 + 61 = 182 182 + 37 = 219 219 - 14 = 205 (not quite there)

  71. [80]

    One last try: 65 + 37 = 102 102 + 61 = 163 163 + 56 = 219 219 + 14 = 233 (not quite there)

  72. [81]

    Final attempt: 56 + 14 = 70 70 + 65 = 135 135 + 37 = 172 172 + 61 = 233 (not quite there)

  73. [82]

    New approach: 37 * 14 = 518 518 - 65 = 453 453 + 61 = 514 514 - 56 = 458 (not quite there)

  74. [83]

    Final try: 61 * 14 = 854 854 - 65 = 789 789 - 56 = 733 733 - 37 = 696 (not quite there)

  75. [84]

    Let’s try: 37 * 14 = 518 518 - 65 = 453 453 + 61 = 514 514 - 56 = 458 (not quite there)

  76. [85]

    31.5 (not helpful)

    New approach: 56 * 37 = 2,052 2,052 / 65 approx. 31.5 (not helpful)

  77. [86]

    Final attempt: 65 * 14 = 910 910 - 61 = 849 849 - 56 = 793 793 + 37 = 830 (not quite there)

  78. [87]

    New approach: 61 * 37 = 2,237 2,237 - 65 = 1,172 1,172 - 56 = 1,116 1,116 + 14 = 1,130 (not quite there)

  79. [88]

    New approach: 37 * 14 = 518 518 + 65 = 583 583 - 61 = 522 522 + 56 = 578 (not quite there) 35 e3: Learning to Explore Enables Extrapolation of Test-Time Compute for LLMs

  80. [89]

    Final attempt: 65 * 14 = 910 910 - 61 = 849 849 + 56 = 905 905 - 37 = 868 (not quite there)

  81. [90]

    Hmm, let me think about how to approach this

    New approach: 37 * 14 = 518 518 - 56 = 462 462 + 65 = 527 527 - 61 = 466 (This works!) </think> <answer> (37 * 14 - 56 + 65) - 61 </answer> Example 2: Multiplication with verification Okay, so I need to multiply 347 by 583. Hmm, let me think about how to approach this. I guess...

  82. [93]

    24 + 24 = 48 (not helpful) 24 * 24 = 576 (too large) Let me try a different approach: 77 - 70 = 7 97 - 73 = 24 24 + 7 = 31 (not helpful) New approach: 97 - 73 = 24 24 + 70 = 94 (too far) Let’s try: 77 - 70 = 7 7 * 24 = 168 (too far) One more attempt: 70 + 24 = 94 94 - 97 = -3 ...

  83. [500]

    Again, multiply 347 by 5 and add two zeros

    So, multiply 347 by 500. Again, multiply 347 by 5 and add two zeros. 5 × 347: 5 × 7 = 35. Write down 5, carry over 3. 5 × 4 = 20, plus the carried over 3 makes 23. Write down 3, carry over 2. 5 × 3 = 15, plus the carried over 2 makes 17. Write down 17. So, 5 × 347 = 1735. Then...

  84. [2025]

    URLhttps://arxiv.org/abs/2501.12948

    arXiv

Pith tools

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