Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

CoRT: Code-integrated Reasoning within Thinking

T0 review · 4 major / 5 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 Teaching reasoning models to call Python at strategic moments yields large math gains with far fewer tokens.

desk verdict Practical, mostly sound recipe for teaching LRMs to use code at the right moments; the 30-sample framing oversells it and the training/test overlap question needs an explicit answer. read the letter →

arxiv 2506.09820 v2 pith:C47ZSD3U submitted 2025-06-11 cs.CL cs.AIcs.LG

Chengpeng Li , Zhengyang Tang , Ziniu Li , Mingfeng Xue , Keqin Bao , Tian Ding , Ruoyu Sun , Benyou Wang
show 3 more authors
Xiang Wang Junyang Lin Dayiheng Liu
This is my paper
classification cs.CLcs.AIcs.LG
keywords codeinterpreterhint-engineeringlargereasoningmodelsmathematicaltokenefficiencyreinforcementlearningrejectionfine-tuningchain-of-thought
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

This paper claims that large reasoning models (LRMs) can be taught to use a code interpreter accurately and efficiently by inserting short strategic hints at specific points in their chain-of-thought, rather than by letting them freely decide when to code. The authors manually craft only 30 high-quality hint-engineered examples, then post-train models with supervised fine-tuning, rejection fine-tuning, and reinforcement learning. On five challenging mathematical reasoning benchmarks, the resulting models improve absolute accuracy by 4% on a 32B model and 8% on a 1.5B model while using roughly 30% to 50% fewer tokens than natural-language reasoning baselines. If true, this means the bottleneck in tool-augmented reasoning is not data volume but the placement and content of guidance about when to compute externally.

What carries the argument

The central mechanism is the hint-engineering data-synthesis procedure coupled with a post-training pipeline. Concretely, the authors insert (1) a general prompt-hint immediately after <think> to encourage code use, (2) a hint like 'It looks tedious, and we can use python code to simplify the reasoning' when the model starts manual calculation of complex operations, and (3) a hint like 'We don't need to doubt the accuracy of python calculations' when the model distrusts code output. These 30 hand-annotated examples form the seed dataset, which is then expanded via rejection fine-tuning on 820 STILL3 problems and, for 1.5B models, enhanced by reinforcement learning with a dual reward combining answer accuracy and a code-execution penalty. The persistent Jupyter-like execution environment and output masking are also part of the machinery, enabling multi-step code interaction and stable RL training.

What would settle it

Compute the exact set overlap between STILL3's 820 problems and each of AIME24, AIME25, AMC23, MATH500, and OlympiadBench; also check whether any AIME25 problems appear in STILL3. If even a handful of test problems appear in the training pool, rerun the evaluation on a contamination-free subset: the 4% and 8% accuracy gains and the 30-50% token savings should persist on the clean subset. A second falsifying observation would be to replace the hint-engineering hints with semantically empty placeholders at the same positions and show that the gains disappear, which would confirm the hints themselves, not mere formatting, carry the effect.

Watch

Extended reading notes

Core claim

The central claim is that hint-engineering, defined as strategically inserting brief textual hints at key decision points during a model's reasoning trace, transforms how LRMs interact with a code interpreter. A single general hint after the <think> token raises code-triggering rates from 50% to 90%, while two targeted hints fix the two main inefficiencies: delayed code computation and code-result distrust. With just 30 manually verified examples, followed by SFT, RFT, and (for smaller models) GRPO-style RL with a code-execution reward, the paper reports 4% and 8% absolute accuracy gains over the base DeepSeek-R1-Distill models, and token reductions of about 30% for the 32B model and 50% for the 1.5B model. The behavior analysis shows that hint-engineering shifts code usage from a verification-dominated pattern (about 82% verification) to a balanced calculation/verification split (about 50/50), which the authors identify as the mechanism behind both accuracy and efficiency gains.

Load-bearing premise

The 820-problem STILL3 training set used for prompt-hint SFT and RFT never overlaps with the AIME24, AIME25, AMC23, MATH500, or OlympiadBench test problems, so the reported accuracy gains and token-efficiency curves reflect learned behavior rather than memorized answers.

Editorial extensions

If this is right

  • If the 4% and 8% gains are real, tool-augmented reasoning can be improved without massive data collection: 30 curated examples plus filtering may suffice to induce lasting code-use habits.
  • The 30-50% token reductions imply that code-integrated reasoning need not be more expensive than natural-language CoT, potentially making tool-using reasoning viable on smaller models and constrained inference budgets.
  • The balanced calculation/verification split suggests that teaching models when to calculate externally is a transferable skill that could generalize to other tools, such as symbolic solvers or search APIs.
  • The authors' finding that RL, not SFT, substantially raises the Pass@k ceiling for 1.5B models implies that, at small scale, reinforcement learning is the stage that converts tool-use competence into reliable problem-solving ability.

Reading between the lines

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

  • An obvious testable extension is to check whether the same 30-sample hint-engineering recipe transfers to non-competition math, to science problems, or to code-generation tasks where delayed computation and output distrust also occur.
  • The specific hints are so short that an ablation with randomized hint positions or with hints appended at the end of the thinking trace would isolate whether the gain comes from content or placement; the paper argues for placement but does not run this control.
  • The authors deliberately chose AIME problems before 2024 for their 30 seed examples to avoid leakage into AIME24/25, which suggests they were aware of contamination risk; the same caution should be applied to the larger STILL3-derived RFT dataset, which draws from public math problems and may overlap with the evaluation sets.
  • If the token-efficiency curves generalize, a practical implication is that serving costs for math-capable assistants could drop substantially by adding a few hint-style system prompts, without retraining the base model.
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 CoRT, a post-training recipe for teaching DeepSeek-R1-Distill reasoning models (32B and 1.5B) to interleave natural-language chain-of-thought with Python code execution. The data-synthesis component is Hint-Engineering: 30 hand-annotated problems in which hints are inserted at two specific failure points (the onset of tedious manual computation, and the onset of distrust of code output). These examples seed SFT; for the 32B model the authors then run rejection fine-tuning over trajectories generated from the 820-problem STILL3 dataset, filtering out incorrect or inefficient trajectories; for the 1.5B model they distill the 32B checkpoints and fine-tune with GRPO, adding an execution-failure penalty weighted by omega. Evaluation covers AIME24, AIME25, AMC23, MATH500, and OlympiadBench. The headline empirical claims are roughly 4% (32B) and 8% (1.5B) average absolute accuracy gains over the DeepSeek-R1-Distill baselines, together with 30-50% token reductions, plus a qualitative analysis of code-usage patterns (calculation vs verification).

Significance. If the empirical claims hold, the paper makes a useful contribution to tool-integrated reasoning: it demonstrates that a small number of strategically hinted traces can shift a reasoning model's code-usage behavior, that the behavior transfers through strong-to-weak distillation, and that a modest code penalty improves RL stability and accuracy at the 1.5B scale. Concrete strengths: the authors release models and code; the evaluation is extensive (five benchmarks, pass@k curves, token-budget curves); the RL infrastructure choices (persistent execution environment, output masking, tool-call limits) are clearly described and are sensible engineering contributions; the main accuracy numbers are internally consistent with Table 1. The main risk is that the headline gains rest on empirical comparisons that lack (a) a reported overlap check between the STILL3/NuminaMath-derived training data and the test sets, and (b) variance estimates; either issue, if material, would change the interpretation of the central claim, but both are checkable and fixable within revision.

major comments (4)
  1. [Sections 2.2.1, 2.2.2, B.1, 3.1] Training/test overlap is not checked, and this is load-bearing for every headline number. Prompt-Hint-SFT-32B is trained on 800 instances generated from the 820-problem STILL3 dataset (Section 2.2.1); Hint-Engineering-RFT-32B is trained on 830 instances composed of 800 STILL3-derived trajectories plus the 30 hand-written ones (Section 2.2.2); and the 1.5B RL models are trained on problems selected from NuminaMath-1.5 (Appendix B.1). The evaluation sets are AIME24, AIME25, AMC23, MATH500, and OlympiadBench (Section 3.1). The authors restricted the 30 hand-written examples to pre-2024 AIME problems precisely to avoid AIME24/25 contamination (Section 2.2.2), but no analogous exact-match or near-duplicate (e.g., 10-gram) analysis is reported for STILL3 or NuminaMath-1.5, and Appendix J's limitation discussion does not mention this risk. If STILL3 or the NuminaMath subset contains even a fraction of the evaluation problems, the 4%/8% accuracy gains and the token-efficiency curves would be inflated by memorization rather than by hint-engineering. The revision should report overlap statistics for each training source against each test set and re-report the headline results on the deduplicated subsets.
  2. [Section 3.3, Figure 5(a)] The code-behavior analysis reports contradictory numbers. The first bullet states that Prompt-Hint uses code "for verification purposes (68.2%)", while the paragraph immediately below states that "Prompt-Hint demonstrates a strong preference for verification (82.4%)"; Figure 5(a) plots 82.4% verification and 17.6% calculation for Prompt-Hint, consistent only with the latter figure. Because this section is the paper's central qualitative evidence that hint-engineering changes code-usage patterns, the discrepancy must be resolved, and the classification methodology (number of code snippets classified per model, and reliability of the DeepSeek-V3 classifier) should be reported.
  3. [Table 1, Section 3.4, Eq. (3), Appendix D.2] The headline gains are reported without uncertainty quantification, while key design choices are tuned on a headline test set. With the stated protocol (16 samples per problem for AIME24/AIME25/AMC23, 4 for MATH500 and OlympiadBench), a 4-point average gap is within roughly two standard errors of sampling noise on several individual benchmarks, so the "4%" and "8%" claims require confidence intervals or a significance test to be evaluable; the absence of error bars also makes the ordering of closely ranked models (e.g., Prompt-Hint-SFT-32B at 81.8 vs Hint-Engineering-RFT-32B at 81.3) uninterpretable. In addition, the code-reward weight omega=0.1 in Eq. (3) and the hard-query threshold avg@8=1/8 (Appendix D.2) are selected via ablations measured on AIME24, which is itself one of the five reported test sets; either the selection should be justified on a development split, or the AIME24 column should be flagged as tuned.
  4. [Abstract, Section 2.2.2, Table 1] The "30 samples" narrative overstates what the 32B experiments demonstrate. The abstract and introduction present the 30 manually created samples as the basis of the gains, and Section 3.1 credits Hint-Engineering-RFT-32B "despite being trained on just 30 manually annotated examples initially"; however, that model is trained on 830 trajectories (800 from STILL3 plus the 30), while the 30-example-only model Hint-Engineering-SFT-32B is numerically worse than the DeepSeek-R1-32B baseline on AIME24 (72.1 vs 72.9) and essentially tied on average (77.8 vs 77.5, Table 1). The "less is more" claim should be re-scoped: state explicitly that the 32B accuracy gain comes from RFT over 830 curated trajectories seeded by 30 hand-written hints, and present the token-efficiency result of Hint-Engineering-SFT-32B as the standalone 30-sample evidence.
minor comments (5)
  1. [Section 2] The cross-reference "as illustrated in Figure 2.1" should be "Figure 2".
  2. [Sections 2.2.2, 3.5, Appendix G] There are several typos: "30 probelms" (Section 2.2.2), "Stron-to-Weak Distillation" (Appendix G heading), and "effectively amplifying the benefits" (Section 3.5) should read "amplifies".
  3. [Section 3.2] The claim that "Hint-Engineering-RFT-32B achieves the same performance as QwQ-32B while using 50% fewer tokens (7K vs 14K)" is imprecise: Table 1 shows 76.7 vs 79.5 on AIME24, so "comparable performance" would be accurate.
  4. [Figure 4(b)] The mapping between the numeric labels and the correct/incorrect bars in Figure 4(b) is unclear; add a legend or axis annotation so the reader can verify the 30%/50% token-saving claims.
  5. [Section 2.2.2] The RFT filter explicitly discards trajectories exhibiting delayed code computation or code-result distrust, so the token-efficiency advantage of Hint-Engineering-RFT-32B is partly introduced by the training-data filter; state this as the mechanism (the filter is disclosed in Section 2.2.2) rather than implying it is purely an emergent property, and note that the test-set token measurements are the appropriate place to look for generalization.

Circularity Check

1 steps flagged · score 3.0 of 10

Mostly self-contained empirical claim; one AIME24-tuned reward coefficient makes part of the AIME24 comparison selected, but the central result survives on other benchmarks.

  1. fitted input called prediction [Section 3.4 / Eq. (3) / Figure 6 caption; Section D.3 / Figure 10 caption]
    ""We set the code reward ratio ω= 0.1 here. The results demonstrate that incorporating this code reward consistently improves performance for both approaches" (Sec. 3.4); "Ablation study on the impact of code execution reward during RL training on AIME24" (Fig. 6 caption); "Code reward penalty ablation study on AIME24" (Fig. 10 caption)."

    The final RL runs use ω=0.1, and the only reported ablation that varies the penalty strength is run on AIME24 (Fig. 10). The same benchmark is then used to demonstrate the reward's benefit (Fig. 6, '43.1% versus 37.9%'). Thus the AIME24 portion of the claimed RL improvement is not an independent prediction of the method with a fixed, pre-specified coefficient; it is a test-set-selected hyperparameter presented as evidence. The non-AIME benchmarks and the 32B table provide independent content, so the circularity is partial rather than total.

full rationale

The paper is an empirical post-training study, not a derivation, so most claimed improvements rest on held-out benchmarks and are not circular by construction. The one quasi-circular element is the code-reward coefficient ω: the only reported penalty-strength ablation is performed on AIME24 (Fig. 10), and the main text then fixes ω=0.1 and reports AIME24 gains for the same reward (Fig. 6), so that particular AIME24 comparison is in part a test-set-selected result rather than an independent prediction. Other benchmarks (AIME25, AMC23, MATH500, OlympiadBench) and the 32B results are not governed by this choice, so the central hint-engineering claim retains independent content. The possible overlap between STILL3 training data and the evaluation sets (Sections 2.2.1, B.1, 3.1) is a data-contamination risk, not a circularity: nothing in the paper's equations makes the reported accuracy or token savings equal to the training filter by construction. Self-citations ([15], [20], etc.) are to standard techniques or prior tool-prompting work and are not load-bearing here: the prompt-hint effect is also measured directly (code triggering rates from 50% to 90%), so the citation does not substitute for the empirical claim.

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

The empirical claims rest on data-quality and filter-reliability assumptions plus standard assumptions about the RL pipeline and answer checking. Two hyperparameters (omega and the hard-query threshold) are selected using dev sets, and omega's selection set (AIME24) is also a headline evaluation set.

free parameters (2)
  • Code execution reward penalty weight omega = 0.1
    Chosen by ablation on AIME24 (Section 3.4 and Appendix D.3); penalties of 0.5 degraded performance. Since AIME24 is also a headline test set, this is partly test-set tuning.
  • RL hard-query selection threshold = avg@8 = 1/8
    Section B.1 selects 1k training problems by requiring average accuracy over 8 rollouts to be exactly 1/8; the threshold is motivated by the difficulty ablation in Appendix D.2.
assumptions (7)
  • domain assumption GRPO with the described rollout, masking, and reward modifications trains the models as claimed.
    Section 2.4 assumes the modified GRPO algorithm converges and improves reasoning; no convergence analysis is provided.
  • domain assumption DeepSeek-R1-Distill-Qwen-32B and 1.5B possess latent code-integrated reasoning ability that hints can unlock.
    Section 2.2.1 infers latent capability from the code-triggering rate rising from 50% to 90% after a prompt hint.
  • ad hoc to paper The 30 manually curated hint-engineered examples teach generalizable behavior rather than memorization.
    Section 2.2.2 uses 30 hand-written AIME examples; the paper reports 5 of them in Appendix F.1 and provides no evidence about transfer beyond AIME-style problems.
  • ad hoc to paper The RFT filter reliably identifies delayed code computation and code result distrust.
    Section 2.2.2 filters 820 STILL3 trajectories on these behaviors without specifying the detection procedure or its accuracy.
  • domain assumption The STILL3 training problems are disjoint from the evaluation benchmarks.
    Section 2.2 trains on STILL3's 820 problems and Section 3.1 evaluates on AIME24, AIME25, AMC23, MATH500 and OlympiadBench with no reported overlap check.
  • domain assumption Math-Verify correctly determines answer equivalence for all test sets.
    Section B.2 relies on Math-Verify as the correctness oracle; errors in equivalence checking would shift reported accuracies.
  • domain assumption DeepSeek-V3 correctly classifies Python code as calculation or verification.
    Section 3.3 builds the code-behavior analysis on DeepSeek-V3 labels without reporting classification accuracy.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CoRT: Code-integrated Reasoning within Thinking." pith.science (2026). https://pith.science/paper/C47ZSD3U

@misc{pith2026250609820,
  author       = {Pith},
  title        = {Pith review of: CoRT: Code-integrated Reasoning within Thinking},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/C47ZSD3U}},
  note         = {Machine review of arXiv:2506.09820}
}
read the original abstract

Large Reasoning Models (LRMs) like o1 and DeepSeek-R1 have shown remarkable progress in natural language reasoning with long chain-of-thought (CoT), yet they remain inefficient or inaccurate when handling complex mathematical operations. Addressing these limitations through computational tools (e.g., computation libraries and symbolic solvers) is promising, but it introduces a technical challenge: Code Interpreter (CI) brings external knowledge beyond the model's internal text representations, thus the direct combination is not efficient. This paper introduces CoRT, a post-training framework for teaching LRMs to leverage CI effectively and efficiently. As a first step, we address the data scarcity issue by synthesizing code-integrated reasoning data through Hint-Engineering, which strategically inserts different hints at appropriate positions to optimize LRM-CI interaction. We manually create 30 high-quality samples, upon which we post-train models ranging from 1.5B to 32B parameters, with supervised fine-tuning, rejection fine-tuning and reinforcement learning. Our experimental results demonstrate that Hint-Engineering models achieve 4\% and 8\% absolute improvements on DeepSeek-R1-Distill-Qwen-32B and DeepSeek-R1-Distill-Qwen-1.5B respectively, across five challenging mathematical reasoning datasets. Furthermore, Hint-Engineering models use about 30\% fewer tokens for the 32B model and 50\% fewer tokens for the 1.5B model compared with the natural language models. The models and code are available at https://github.com/ChengpengLi1003/CoRT.

Figures

Figures reproduced from arXiv: 2506.09820 by the authors.

Figure 1
Figure 1. Performance vs. token efficiency on AIME24. The x-axis represents average token usage [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The training framework of CoRT. R1-Distill-Qwen-1.5B. Moreover, on the most challenging AIME benchmarks, our approach reduces token consumption by 30% for the 32B model and 50% for the 1.5B model. To summarize, our key contributions include: • A new data synthesis framework specifically engineered for code-integrated reasoning that effec￾tively addresses the critical data scarcity challenge in this emerging domain. … view at source ↗
Figure 3
Figure 3. Comparison between prompt-hint and hint-engineering approaches using Problem 13 from [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: Token efficiency analysis on AIME24. (a): Token efficiency comparison showing Hint [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Analysis of Python code usage patterns. (a) Distribution of code usage types: Hint [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Ablation study on the impact of code execution reward during RL training on AIME24. [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]
Figure 7
Figure 7. Figure 7: Pass@k performance on AIME24 (top) and MATH500-Level5 (bottom) for both Prompt [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Evolution of code behavior metrics during RL training on AIME24. [PITH_FULL_IMAGE:figures/full_fig_p018_8.png]
Figure 9
Figure 9. Figure 9: RL training data ablation studies on AIME24. [PITH_FULL_IMAGE:figures/full_fig_p019_9.png]
Figure 10
Figure 10. Figure 10: Code reward penalty ablation study on AIME24. [PITH_FULL_IMAGE:figures/full_fig_p020_10.png]
Figure 11
Figure 11. Figure 11: Token efficiency analysis for 1.5B parameter models on AIME24. [PITH_FULL_IMAGE:figures/full_fig_p021_11.png]
Figure 12
Figure 12. Figure 12: Pass@k analysis for 32B parameter models. [PITH_FULL_IMAGE:figures/full_fig_p022_12.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

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

  1. Contrastive Reinforced Policy Optimization via Privileged Self-Distillation

    cs.LG 2026-07 conditional novelty 5.0 of 10

    CRPO turns on-policy self-distillation into group-wise contrastive learning gated by student–teacher entropy gaps, improving multi-turn agentic LLM post-training over GRPO, ARPO, and OPSD.

Reference graph

Works this paper leans on

83 extracted references · 29 canonical work pages · cited by 1 Pith paper

  1. [1]

    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

    arXiv 2017

  2. [2]

    Remax: A simple, effective, and efficient reinforcement learning method for aligning large language models

    Ziniu Li, Tian Xu, Yushun Zhang, Zhihang Lin, Yang Yu, Ruoyu Sun, and Zhi-Quan Luo. Remax: A simple, effective, and efficient reinforcement learning method for aligning large language models. InForty-first International Conference on Machine Learning, 2024

    2024

  3. [3]

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

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, 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

    arXiv 2024

  4. [4]

    T\" ulu 3: Pushing frontiers in open language model post-training.arXiv preprint arXiv:2411.15124, 2024

    Nathan Lambert, Jacob Morrison, Valentina Pyatkin, Shengyi Huang, Hamish Ivison, Faeze Brahman, Lester James V Miranda, Alisa Liu, Nouha Dziri, Shane Lyu, et al. T\" ulu 3: Pushing frontiers in open language model post-training.arXiv preprint arXiv:2411.15124, 2024

    arXiv 2024

  5. [5]

    Learning to reason with llms.https://openai.com/index/learnin g-to-reason-with-llms/, 2024

    OpenAI. Learning to reason with llms.https://openai.com/index/learnin g-to-reason-with-llms/, 2024

    2024

  6. [6]

    Qwq-32b: Embracing the power of reinforcement learning, March 2025

    Qwen Team. Qwq-32b: Embracing the power of reinforcement learning, March 2025. URL https://qwenlm.github.io/blog/qwq-32b/

    2025

  7. [7]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.CoRR, abs/2501.12948, 2025

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.CoRR, abs/2501.12948, 2025

    arXiv 2025

  8. [8]

    Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao, et al. Kimi k1. 5: Scaling reinforcement learning with llms.arXiv preprint arXiv:2501.12599, 2025

    arXiv 2025

Show all 83 references
  1. [9]

    Chain-of-thought prompting elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824–24837, 2022

    2022

  2. [10]

    A comparative study on reasoning patterns of openai’s o1 model.arXiv preprint arXiv:2410.13639, 2024

    Siwei Wu, Zhongyuan Peng, Xinrun Du, Tuney Zheng, Minghao Liu, Jialong Wu, Jiachen Ma, Yizhi Li, Jian Yang, Wangchunshu Zhou, et al. A comparative study on reasoning patterns of openai’s o1 model.arXiv preprint arXiv:2410.13639, 2024. 10

    arXiv

  3. [11]

    Tora: A tool-integrated reasoning agent for mathematical problem solving

    Zhibin Gou, Zhihong Shao, Yeyun Gong, Yelong Shen, Yujiu Yang, Minlie Huang, Nan Duan, and Weizhu Chen. Tora: A tool-integrated reasoning agent for mathematical problem solving. arXiv preprint arXiv:2309.17452, 2023

    2023 arXiv

  4. [12]

    Can large language models detect errors in long chain-of-thought reasoning?arXiv preprint arXiv:2502.19361, 2025

    Yancheng He, Shilong Li, Jiaheng Liu, Weixun Wang, Xingyuan Bu, Ge Zhang, Zhongyuan Peng, Zhaoxiang Zhang, Zhicheng Zheng, Wenbo Su, et al. Can large language models detect errors in long chain-of-thought reasoning?arXiv preprint arXiv:2502.19361, 2025

    2025 arXiv

  5. [13]

    Introducing openai o3 and o4-mini, 2025

    OpenAI. Introducing openai o3 and o4-mini, 2025. URL https://openai.com/index/int roducing-o3-and-o4-mini/

    2025

  6. [14]

    Preserving diversity in supervised fine-tuning of large language models

    Ziniu Li, Congliang Chen, Tian Xu, Zeyu Qin, Jiancong Xiao, Zhi-Quan Luo, and Ruoyu Sun. Preserving diversity in supervised fine-tuning of large language models. InThe Thirteenth International Conference on Learning Representations, 2025

    2025

  7. [15]

    Scaling relationship on learning mathematical reasoning with large language models, 2023

    Zheng Yuan, Hongyi Yuan, Chengpeng Li, Guanting Dong, Keming Lu, Chuanqi Tan, Chang Zhou, and Jingren Zhou. Scaling relationship on learning mathematical reasoning with large language models, 2023. URLhttps://arxiv.org/abs/2308.01825

    2023 arXiv

  8. [16]

    An empirical study on eliciting and improving r1-like reasoning models.arXiv preprint arXiv:2503.04548, 2025

    Zhipeng Chen, Yingqian Min, Beichen Zhang, Jie Chen, Jinhao Jiang, Daixuan Cheng, Wayne Xin Zhao, Zheng Liu, Xu Miao, Yang Lu, et al. An empirical study on eliciting and improving r1-like reasoning models.arXiv preprint arXiv:2503.04548, 2025

    2025 arXiv

  9. [17]

    Lima: Less is more for alignment.Advances in Neural Information Processing Systems, 36:55006–55021, 2023

    Chunting Zhou, Pengfei Liu, Puxin Xu, Srinivasan Iyer, Jiao Sun, Yuning Mao, Xuezhe Ma, Avia Efrat, Ping Yu, Lili Yu, et al. Lima: Less is more for alignment.Advances in Neural Information Processing Systems, 36:55006–55021, 2023

    2023

  10. [20]

    Start: Self-taught reasoner with tools.arXiv preprint arXiv:2503.04625, 2025

    Chengpeng Li, Mingfeng Xue, Zhenru Zhang, Jiaxi Yang, Beichen Zhang, Xiang Wang, Bowen Yu, Binyuan Hui, Junyang Lin, and Dayiheng Liu. Start: Self-taught reasoner with tools.arXiv preprint arXiv:2503.04625, 2025

    2025 arXiv

  11. [21]

    An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, et al. Qwen2. 5-math technical report: Toward mathematical expert model via self-improvement.arXiv preprint arXiv:2409.12122, 2024

    2024 arXiv

  12. [22]

    Zhang, Han Bao, Hanwei Xu, Haocheng Wang, Haowei Zhang, Honghui Ding, Huajian Xin, Huazuo Gao, Hui Li, Hui Qu, J

    DeepSeek-AI, Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai Dai, Daya Guo, Dejian Yang, Deli Chen, Dongjie Ji, Erhang Li, Fangyun Lin, Fucong Dai, Fuli Luo, Guangbo Hao, Guanting Chen, Guowei L...

  13. [23]

    Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168, 2021

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168, 2021

    arXiv

  14. [24]

    Measuring mathematical problem solving with the math dataset

    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. arXiv preprint arXiv:2103.03874, 2021

    2021 arXiv

  15. [25]

    Let’s verify step by step

    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. InThe Twelfth International Conference on Learning Representations, 2023

    2023

  16. [26]

    Towards reasoning in large language models: A survey.arXiv preprint arXiv:2212.10403, 2022

    Jie Huang and Kevin Chen-Chuan Chang. Towards reasoning in large language models: A survey.arXiv preprint arXiv:2212.10403, 2022

    2022 arXiv

  17. [27]

    Reasoning with large language models, a survey.arXiv preprint arXiv:2407.11511, 2024

    Aske Plaat, Annie Wong, Suzan Verberne, Joost Broekens, Niki van Stein, and Thomas Back. Reasoning with large language models, a survey.arXiv preprint arXiv:2407.11511, 2024

    2024

  18. [28]

    Towards large reasoning models: A survey of reinforced reasoning with large language models.arXiv preprint arXiv:2501.09686, 2025

    Fengli Xu, Qianyue Hao, Zefang Zong, Jingwei Wang, Yunke Zhang, Jingyi Wang, Xiaochong Lan, Jiahui Gong, Tianjian Ouyang, Fanjin Meng, et al. Towards large reasoning models: A survey of reinforced reasoning with large language models.arXiv preprint arXiv:2501.09686, 2025

    2025 arXiv

  19. [29]

    Attention is all you need.Advances in neural information processing systems, 30, 2017

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need.Advances in neural information processing systems, 30, 2017

    2017

  20. [30]

    Towards revealing the mystery behind chain of thought: a theoretical perspective.Advances in Neural Information Processing Systems, 36:70757–70798, 2023

    Guhao Feng, Bohang Zhang, Yuntian Gu, Haotian Ye, Di He, and Liwei Wang. Towards revealing the mystery behind chain of thought: a theoretical perspective.Advances in Neural Information Processing Systems, 36:70757–70798, 2023

    2023

  21. [31]

    Wizardmath: Empowering mathematical rea- soning for large language models via reinforced evol-instruct.arXiv preprint arXiv:2308.09583, 2023

    Haipeng Luo, Qingfeng Sun, Can Xu, Pu Zhao, Jianguang Lou, Chongyang Tao, Xiubo Geng, Qingwei Lin, Shifeng Chen, and Dongmei Zhang. Wizardmath: Empowering mathematical rea- soning for large language models via reinforced evol-instruct.arXiv preprint arXiv:2308.09583, 2023

    2023 arXiv

  22. [32]

    Llemma: An open language model for mathematics.arXiv preprint arXiv:2310.10631, 2023

    Zhangir Azerbayev, Hailey Schoelkopf, Keiran Paster, Marco Dos Santos, Stephen McAleer, Albert Q Jiang, Jia Deng, Stella Biderman, and Sean Welleck. Llemma: An open language model for mathematics.arXiv preprint arXiv:2310.10631, 2023

    arXiv

  23. [33]

    Kwok, Zhenguo Li, Adrian Weller, and Weiyang Liu

    Longhui Yu, Weisen Jiang, Han Shi, Jincheng Yu, Zhengying Liu, Yu Zhang, James T. Kwok, Zhenguo Li, Adrian Weller, and Weiyang Liu. Metamath: Bootstrap your own mathematical questions for large language models, 2023

    2023

  24. [34]

    Simplerl-zoo: Investigating and taming zero reinforcement learning for open base models in the wild.arXiv preprint arXiv:2503.18892, 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.arXiv preprint arXiv:2503.18892, 2025

    2025 arXiv

  25. [35]

    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. 12

    2025 arXiv

  26. [36]

    Iterative reasoning preference optimization.Advances in Neural Information Processing Systems, 37:116617–116637, 2024

    Richard Yuanzhe Pang, Weizhe Yuan, He He, Kyunghyun Cho, Sainbayar Sukhbaatar, and Jason Weston. Iterative reasoning preference optimization.Advances in Neural Information Processing Systems, 37:116617–116637, 2024

    2024

  27. [37]

    Math-shepherd: Verify and reinforce llms step-by-step without human annotations.arXiv preprint arXiv:2312.08935, 2023

    Peiyi Wang, Lei Li, Zhihong Shao, RX Xu, Damai Dai, Yifei Li, Deli Chen, Yu Wu, and Zhifang Sui. Math-shepherd: Verify and reinforce llms step-by-step without human annotations.arXiv preprint arXiv:2312.08935, 2023

    2023 arXiv

  28. [38]

    Openai o1 system card.arXiv preprint arXiv:2412.16720, 2024

    Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. Openai o1 system card.arXiv preprint arXiv:2412.16720, 2024

    2024 arXiv

  29. [39]

    s1: Simple test-time scaling, 2025

    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, 2025. URLhttps://arxiv.org/abs/2501.19393

    2025 arXiv

  30. [40]

    Limo: Less is more for reasoning, 2025

    Yixin Ye, Zhen Huang, Yang Xiao, Ethan Chern, Shijie Xia, and Pengfei Liu. Limo: Less is more for reasoning, 2025. URLhttps://arxiv.org/abs/2502.03387

    2025 arXiv

  31. [41]

    Open r1, 2025

    Huggingface. Open r1, 2025. URLhttps://github.com/huggingface/open-r1

    2025

  32. [42]

    o1-coder: an o1 replication for coding, 2024

    Yuxiang Zhang, Shangxi Wu, Yuqi Yang, Jiangming Shu, Jinlin Xiao, Chao Kong, and Jitao Sang. o1-coder: an o1 replication for coding, 2024. URL https://arxiv.org/abs/2412.0 0154

    2024

  33. [43]

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

    Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Weinan Dai, Tiantian Fan, Gaohong Liu, Lingjun Liu, Xin Liu, Haibin Lin, Zhiqi Lin, Bole Ma, Guangming Sheng, Yuxuan Tong, Chi Zhang, Mofan Zhang, Wang Zhang, Hang Zhu, Jinhua Zhu, Jiaze Chen, Jiangjie Chen...

    2025 arXiv

  34. [44]

    Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks.arXiv preprint arXiv:2211.12588, 2022

    Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W Cohen. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks.arXiv preprint arXiv:2211.12588, 2022

    2022 arXiv

  35. [45]

    Pal: Program-aided language models

    Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. Pal: Program-aided language models. InInternational Conference on Machine Learning, pages 10764–10799. PMLR, 2023

    2023

  36. [46]

    Theoremllama: Transforming general-purpose llms into lean4 experts.arXiv preprint arXiv:2407.03203, 2024

    Ruida Wang, Jipeng Zhang, Yizhen Jia, Rui Pan, Shizhe Diao, Renjie Pi, and Tong Zhang. Theoremllama: Transforming general-purpose llms into lean4 experts.arXiv preprint arXiv:2407.03203, 2024

    2024 arXiv

  37. [47]

    Deepseek-prover: Advancing theorem proving in llms through large-scale synthetic data.arXiv preprint arXiv:2405.14333, 2024

    Huajian Xin, Daya Guo, Zhihong Shao, Zhizhou Ren, Qihao Zhu, Bo Liu, Chong Ruan, Wenda Li, and Xiaodan Liang. Deepseek-prover: Advancing theorem proving in llms through large-scale synthetic data.arXiv preprint arXiv:2405.14333, 2024

    2024 arXiv

  38. [48]

    Beyond limited data: Self-play llm theorem provers with iterative conjecturing and proving.arXiv preprint arXiv:2502.00212, 2025

    Kefan Dong and Tengyu Ma. Beyond limited data: Self-play llm theorem provers with iterative conjecturing and proving.arXiv preprint arXiv:2502.00212, 2025

    2025 arXiv

  39. [49]

    Critic: Large language models can self-correct with tool-interactive critiquing.arXiv preprint arXiv:2305.11738, 2023

    Zhibin Gou, Zhihong Shao, Yeyun Gong, Yelong Shen, Yujiu Yang, Nan Duan, and Weizhu Chen. Critic: Large language models can self-correct with tool-interactive critiquing.arXiv preprint arXiv:2305.11738, 2023

    2023 arXiv

  40. [50]

    Apigen: Automated pipeline for generating verifiable and diverse function-calling datasets.Advances in Neural Information Processing Systems, 37: 54463–54482, 2024

    Zuxin Liu, Thai Hoang, Jianguo Zhang, Ming Zhu, Tian Lan, Juntao Tan, Weiran Yao, Zhiwei Liu, Yihao Feng, Rithesh RN, et al. Apigen: Automated pipeline for generating verifiable and diverse function-calling datasets.Advances in Neural Information Processing Systems, 37: 54463–...

    2024

  41. [51]

    Tool learning with large language models: A survey.Frontiers of Computer Science, 19(8):198343, 2025

    Changle Qu, Sunhao Dai, Xiaochi Wei, Hengyi Cai, Shuaiqiang Wang, Dawei Yin, Jun Xu, and Ji-Rong Wen. Tool learning with large language models: A survey.Frontiers of Computer Science, 19(8):198343, 2025. 13

    2025

  42. [52]

    R1-searcher: Incentivizing the search capability in llms via reinforcement learning, 2025

    Huatong Song, Jinhao Jiang, Yingqian Min, Jie Chen, Zhipeng Chen, Wayne Xin Zhao, Lei Fang, and Ji-Rong Wen. R1-searcher: Incentivizing the search capability in llms via reinforcement learning, 2025. URLhttps://arxiv.org/abs/2503.05592

    2025 arXiv

  43. [53]

    Search-o1: Agentic search-enhanced large reasoning models, 2025

    Xiaoxi Li, Guanting Dong, Jiajie Jin, Yuyao Zhang, Yujia Zhou, Yutao Zhu, Peitian Zhang, and Zhicheng Dou. Search-o1: Agentic search-enhanced large reasoning models, 2025. URL https://arxiv.org/abs/2501.05366

    2025 arXiv

  44. [54]

    Toolformer: Language models can teach themselves to use tools, 2023

    Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettle- moyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools, 2023. URLhttps://arxiv.org/abs/2302.04761

    2023 arXiv

  45. [55]

    Chain of agents: Large language models collaborating on long-context tasks.Advances in Neural Information Processing Systems, 37:132208–132237, 2024

    Yusen Zhang, Ruoxi Sun, Yanfei Chen, Tomas Pfister, Rui Zhang, and Sercan Arik. Chain of agents: Large language models collaborating on long-context tasks.Advances in Neural Information Processing Systems, 37:132208–132237, 2024

    2024

  46. [56]

    rStar-Math: Small LLMs can master math reasoning with self-evolved deep thinking.arXiv preprint arXiv:2403.01707, 2024

    Yao Zhang, Hongxiao Zhang, Jiacheng Zhang, Jingcheng Zhao, Rui Yan, Xiaoqing Liu, Jiahuan Wang, Min Zhang, Houfeng Wang, and Zhengguang Guo. rStar-Math: Small LLMs can master math reasoning with self-evolved deep thinking.arXiv preprint arXiv:2403.01707, 2024

    2024 arXiv

  47. [57]

    Learning autonomous code integration for math language models, 2025

    Haozhe Wang, Long Li, Chao Qu, Fengming Zhu, Weidi Xu, Wei Chu, and Fangzhen Lin. Learning autonomous code integration for math language models, 2025. URL https://arxi v.org/abs/2502.00691

    2025 arXiv

  48. [58]

    Agent rl scaling law: Agent rl with spontaneous code execution for mathematical problem solving,

    Xinji Mai, Haotian Xu, Xing W, Weinong Wang, Yingying Zhang, and Wenqiang Zhang. Agent rl scaling law: Agent rl with spontaneous code execution for mathematical problem solving,

  49. [59]

    ToRL: Scaling tool-integrated RL for LLMs.arXiv preprint arXiv:2312.10372, 2023

    Kezhou Wang, Ruijie Wu, Qinlin Zeng, Huao Lu, Hanye Wu, Qingfeng Cui, Haichao Lin, Yujia Liu, Xiaoyan Huang, Qingpeng Guo, Songtao Jian, Kaiyuan Lu, Shiyu Li, Hao Tian, Yongqin Sun, Xue Yang, Libin Song, Zejun Ou, and Guoqing Wang. ToRL: Scaling tool-integrated RL for LLMs.arX...

    2023 arXiv

  50. [60]

    URLhttps://arxiv.org/abs/2505.07773

    arXiv

  51. [61]

    Retool: Reinforcement learning for strategic tool use in llms, 2025

    Jiazhan Feng, Shijue Huang, Xingwei Qu, Ge Zhang, Yujia Qin, Baoquan Zhong, Chengquan Jiang, Jinxin Chi, and Wanjun Zhong. Retool: Reinforcement learning for strategic tool use in llms, 2025. URLhttps://arxiv.org/abs/2504.11536

    2025 arXiv

  52. [62]

    Otc: Optimal tool calls via reinforcement learning

    Hongru Wang, Cheng Qian, Wanjun Zhong, Xiusi Chen, Jiahao Qiu, Shijue Huang, Bowen Jin, Mengdi Wang, Kam-Fai Wong, and Heng Ji. Otc: Optimal tool calls via reinforcement learning. arXiv preprint arXiv:2504.14870, 2025

    2025 arXiv

  53. [63]

    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

  54. [64]

    RAFT: reward ranked finetuning for generative foundation model alignment.Trans

    Hanze Dong, Wei Xiong, Deepanshu Goyal, Yihan Zhang, Winnie Chow, Rui Pan, Shizhe Diao, Jipeng Zhang, Kashun Shum, and Tong Zhang. RAFT: reward ranked finetuning for generative foundation model alignment.Trans. Mach. Learn. Res., 2023

    2023

  55. [65]

    Math-verify: Math verification library, 2024

    Hynek Kydlíˇcek. Math-verify: Math verification library, 2024. URL https://github.com/h uggingface/math-verify

    2024

  56. [66]

    Numinamath

    Jia LI, Edward Beeching, Lewis Tunstall, Ben Lipkin, Roman Soletskyi, Shengyi Costa Huang, Kashif Rasul, Longhui Yu, Albert Jiang, Ziju Shen, Zihan Qin, Bin Dong, Li Zhou, Yann Fleureau, Guillaume Lample, and Stanislas Polu. Numinamath. [https://huggingface. co/AI-MO/NuminaMat...

    2024

  57. [67]

    Olympiadbench: A challenging benchmark for promoting agi with olympiad-level bilingual multimodal scientific problems, 2024

    Chaoqun He, Renjie Luo, Yuzhuo Bai, Shengding Hu, Zhen Leng Thai, Junhao Shen, Jinyi Hu, Xu Han, Yujie Huang, Yuxiang Zhang, Jie Liu, Lei Qi, Zhiyuan Liu, and Maosong Sun. Olympiadbench: A challenging benchmark for promoting agi with olympiad-level bilingual multimodal scienti...

    2024

  58. [68]

    Tang, Manan Roongta, Colin Cai, Jeffrey Luo, 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, Li Erran Li, Raluca Ada Popa, and Ion Stoica. Deepscaler: Surpassing o1-preview with a 1.5b model by scaling rl. https://pretty-radio-b75.notion.site/D eepScaleR-Surpas...

    2025

  59. [69]

    Numinamath

    Jia LI, Edward Beeching, Lewis Tunstall, Ben Lipkin, Roman Soletskyi, Shengyi Costa Huang, Kashif Rasul, Longhui Yu, Albert Jiang, Ziju Shen, Zihan Qin, Bin Dong, Li Zhou, Yann Fleureau, Guillaume Lample, and Stanislas Polu. Numinamath. [https://github.com/pro ject-numina/aimo...

    2024

  60. [70]

    Measuring mathematical problem solving with the MATH dataset

    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. InNeurIPS Datasets and Benchmarks, 2021

    2021

  61. [72]

    While OTC

    attempts to bootstrap training data by rewriting long Chain-of-Thought reasoning, yet shows limited performance improvements when based on DeepSeek-R1-Distill-Qwen-32B. While OTC

  62. [73]

    less is more

    considers efficiency from the perspective of tool call frequency, it does not explore methods for enhancement building upon existing LRMs. CoRT proposed a highly sample-efficient approach that achieved both performance breakthroughs and significant improvements in reasoning ef...

  63. [74]

    Find m+n

    The ratio of the volume of the larger of the two polyhedra to the volume of the smaller is m n , where m and n are relatively prime positive integers. Find m+n . A parallelepiped is a solid with six parallelogram faces such as the one shown below. Solution: Let’s try to solve ...

  64. [75]

    Volume 1:

    We need to find the ratio of their volumes (larger to smaller) and then compute m+n where the ratio is m n in simplest terms. [...detailed analysis omitted...] Therefore, the two possible rhombohedrons would have all angles equal to arccos(5/26) or arccos(−5/26). Thus, these a...

  65. [76]

    Therefore, m n = 63

    Since 63 2 = 31.5>31, 63 √ 2 2 is larger than31 √ 2. Therefore, m n = 63

  66. [77]

    So m= 63, n= 62, andm+n= 125

    Since 63 = 7 × 9 and 62 = 2 × 31, they are coprime. So m= 63, n= 62, andm+n= 125. Therefore, the answer is125 . Sample 4 Problem: Let △ABC be an equilateral triangle with side length 55. Points D, E,and F lie on BC, CA, and AB, respectively, with BD= 7, CE= 30,and AF= 40. Poin...

  67. [78]

    For∠AEP: tan(θ) = y− 25 √ 3 2 x− 25 2 − √ 3 1 + √ 3· y− 25 √ 3 2 x− 25 2

  68. [79]

    For∠BF P: tan(θ) = y x−40

  69. [80]

    Solutions for x and y:

    For∠CDP: tan(θ) = y− 7 √ 3 2 x− 103 2 + √ 3 1− √ 3· y− 7 √ 3 2 x− 103 2 Let’s solve this system using Python: 31 Python Code import sympy as sp # Define variables x, y = sp.symbols(’x y’) # Coordinates of points E_x = sp.Rational(25, 2) E_y = sp.Rational(25, 2) * sp.sqrt(3) F_...

  70. [81]

    First, let’s assign coordinates to the points on the line, placing A at origin: - A: 0 (origin) - AF = 73, so F: 73 - AC = 26, so C: 26 - CE = 31, so E: 26 + 31 = 57 - DF = 33, so D: 73 - 33 = 40 - BD = 22, so B: 40 - 22 = 18 [...detailed analysis omitted...]

  71. [82]

    G coordinates: ({x_G_val}, {y_G_val})

    Next, let’s find coordinates of G using distances CG = 40 and DG = 30: - From C(26,0): (xG −26) 2 +y 2 G = 1600...(1) - From D(40,0):(x G −40) 2 +y 2 G = 900...(2) 37 Let’s verify this using Python: Python Code from sympy import symbols, Eq, solve x_G, y_G = symbols(’x_G y_G’)...

  72. [83]

    F.3 Test case of Hint-Engineering-RFT-32B A Case form AIME24 Problem: Let B be the set of rectangular boxes with surface area 54 and volume 23

    Calculate the area using the shoelace formula: Area= 1 2 |x1(y2 −y 3) +x2(y3 −y 1) + x3(y1 −y 2)| Where: -(x 1, y1) = (18,0)-(x 2, y2) = (58,24)-(x 3, y3) = (57,0) Substituting: Area= 1 2 |18(24−0) + 58(0−0) + 57(0−24)| = 1 2 |432 + 0−1368| = 1 2 |−936| = 468 Therefore, the ar...

  73. [84]

    Solutions:

    Space diagonal = √ a2 +b 2 +c 2 2. Surface area: 2(ab+bc+ac) = 54 3. V olume: abc= 23 Our goal is to maximize a2 +b 2 +c 2 subject to these constraints, then r2 = max(a2+b2+c2) 4 . 38 Let’s try assuming a=b to simplify the problem: - Surface area becomes: 2(a2 + 2ac) = 54→a 2 ...

  74. [85]

    G coordinates: ({x_G_val}, {y_G_val})

    From C (26,0) : (xG −26) 2 +y 2 G = 1600...(1) 2) From D (40,0) : (xG −40) 2 +y 2 G = 900 ...(2) Let’s solve this system using Python: Python Code 1 from sympy import symbols, Eq, solve x_G, y_G = symbols(’x_G y_G’) # Equations based on CG = 40 and DG = 30 eq1 = Eq((x_G - 26)*...

    2024

  75. [2025]

    URLhttps://arxiv.org/abs/2412.19437

    arXiv

Pith tools

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