Pith. sign in

REVIEW 5 major objections 5 minor 3 cited by

Towards Effective Code-Integrated Reasoning

T0 review · 5 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 Code-writing RL lifts a 7B math model’s average accuracy to 52.4 percent

desk verdict A useful code-integrated RL recipe with plausible headline numbers, but missing ablations, seed variance, and a decontamination report make the reported gains under-supported. read the letter →

arxiv 2505.24480 v1 pith:AKZMNMFY submitted 2025-05-30 cs.CL cs.AIcs.LG

Fei Bai , Yingqian Min , Beichen Zhang , Zhipeng Chen , Wayne Xin Zhao , Lei Fang , Zheng Liu , Zhongyuan Wang
show 1 more author
Ji-Rong Wen
This is my paper
classification cs.CLcs.AIcs.LG
keywords code-integratedreasoningtool-augmentedreinforcementlearningcodeinterpretertrainingstabilityexploration-stabilitytrade-offmathematicalLLM
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 is trying to establish that code-integrated reasoning—where a model writes and executes Python during problem solving—can be trained reliably with reinforcement learning, and that doing so yields large accuracy gains over text-only reasoning. The authors identify that tool-augmented RL is unstable because interaction boundaries are noisy, external feedback shifts the model’s distribution, and fixed interaction budgets homogenize responses. They respond with six training strategies, including exact code-block matching, masking tool feedback from the loss, disabling the entropy bonus, progressively raising the interaction budget from two to four, removing the KL term, and asymmetric clipping. With these, their 7B model reaches 42.3% on AIME2024 and a 52.4% average across five math benchmarks, surpassing text-only RL and prior tool-augmented RL baselines.

What carries the argument

The load-bearing mechanism is the tool-augmented reinforcement-learning loop with a code interpreter: the model generates a code block, the interpreter executes it, the output is appended to the reasoning context, and the policy is updated from the full trajectory. Around that loop the paper wraps six training strategies—exact-match detection of complete Python code blocks, masking of interpreter feedback in the loss, entropy bonus disabled, a progressive interaction budget from two to four rounds, no KL term, and asymmetric clipping in the surrogate objective. These strategies do the work of keeping rollouts clean and preventing tool feedback from destabilizing the policy, while preserving enough exploration for the model to discover code use.

What would settle it

Run the identical pipeline on a base model with no code in its pretraining data: if exact-match detection rarely triggers or training collapses in the early steps, the reported gains depend on the assumption rather than on the six strategies. A second check is an ablation that replaces exact-match detection with stop-token detection under equal compute; if accuracy and training reward do not drop, the boundary-matching claim is not the active ingredient.

Watch

Extended reading notes

Core claim

The central claim is that code-integrated reasoning is not just an inference-time trick but a trainable capability, and that its RL training can be stabilized by deliberately balancing exploration against stability. On the paper's own account, the model learns when to invoke a code interpreter, generates code that participates in the reasoning, and incorporates execution results back into its context. The evidence is a consistent margin over baselines on math benchmarks, a steady training reward, and a sharp drop in response length as the model switches from verbose text reasoning to concise code-assisted reasoning. The paper further argues that code integration expands the model's capability boundary, measured by PASS@K, and that the benefits are uneven: algebra, number theory, and combinatorics gain most, while geometry gains little.

Load-bearing premise

The load-bearing premise is that the base model can already produce well-formed, executable Python code blocks from the start of training, so the exact-match boundary detector fires reliably and the interpreter feedback is useful rather than mostly syntax errors.

Editorial extensions

If this is right

  • Code-integrated RL outperforms text-only RL and prior tool-augmented RL on all five benchmarks, with the largest gains on the hardest sets such as AIME and OlymMATH.
  • Models trained this way produce much shorter responses than long-CoT reasoning while keeping comparable accuracy on the tested sets.
  • RL-trained code-integrated models rely on the interpreter: removing execution at inference time causes a large accuracy drop.
  • Non-executable code can still help by producing errors that push the model to revise, while executable but logically wrong code can mislead it into premature answers.
  • Geometry problems benefit least from code integration, so the approach is not uniformly applicable across problem types.

Reading between the lines

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

  • The paper leaves implicit that the six-strategy recipe should transfer to other base models only if those models can already emit well-formed code blocks; testing on a code-poor backbone would isolate that dependency.
  • The same exploration-stability split could apply to other tool-augmented RL targets, such as search or calculator use, where boundary detection and feedback noise are analogous.
  • The finding that plausible execution output can stop reasoning early suggests a concrete extension: reward the model for verifying execution results rather than accepting them, or penalize premature termination when the execution output does not match the intended plan.
  • A testable extension is to make the interaction budget adaptive to the model's pass rate, rather than fixed at two to four, which would directly test whether the progressive schedule is the active ingredient.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 5 minor

Summary. The paper proposes a set of reinforcement-learning training strategies for code-integrated reasoning, where a language model generates Python code during mathematical reasoning and receives execution feedback from an interpreter. The six proposed strategies are precise code-block boundary matching, masking of external-tool feedback in the loss, disabling the entropy bonus, progressively increasing the interaction budget from 2 to 4, removing the KL divergence term, and using an asymmetric clipping upper bound. The method is trained with REINFORCE++ on a 38k-sample subset of STILL-3, starting from Qwen2.5-Math-7B and Qwen3-8B, and evaluated on MATH500, AMC23, AIME2024, AIME2025, and OlymMATH. The central claim is that the full strategy set yields stable training and large accuracy gains over text-only and tool-augmented RL baselines, including 42.3% on AIME2024 and a 52.4% average across the five benchmarks. The paper also includes mechanistic analyses of capacity boundaries, response-length efficiency, non-executable code, and per-category gains.

Significance. If the reported gains are real and not artifacts of data contamination, the paper makes a useful contribution to tool-augmented RL, an area where training instability is a recognized problem. The release of data, code, and checkpoints is a concrete reproducibility asset, and the paper identifies several design choices that could transfer to other tool-augmented settings. However, the central quantitative claim currently rests on a single unablated training run, without decontamination evidence or uncertainty quantification. The mechanistic sections are thought-provoking but are largely correlational. The paper therefore has genuine potential, but its current evidence base is not yet sufficient to support the strength of the stated conclusions.

major comments (5)
  1. [§3.1, Table 1] No decontamination analysis is reported between the 38k STILL-3 training subset and the five evaluation benchmarks. This is load-bearing because AIME and AMC problems are widely present in public math corpora, and OlymMATH (Ref. [18]) and STILL-3 (Ref. [4]) come from the same research group. Without an exact and near-duplicate overlap analysis, the gains in Table 1 could reflect memorization rather than the proposed RL strategies. Please report the overlap statistics, the filtering procedure, and a fixed commit hash for the released data and code.
  2. [§2.3.2, §3.1] The six training strategies are presented as a joint recipe, but no ablation study isolates their individual contributions or justifies the necessity of each. The paper states that the model is trained with 'the strategies detailed in Section 2.3.2' but never shows a configuration without, say, feedback masking or without the progressive budget. Since the central claim is that 'with these improvements' the model achieves the reported numbers, an ablation table is required to attribute the gain to the proposed mechanism rather than to some other component of the training setup.
  3. [Table 1, Figures 2–3] No uncertainty estimates are provided for any evaluation result. AVG@16 is a sampling-based estimate, yet no bootstrap confidence intervals or standard deviations are reported; MATH500 is a single greedy run. The difference between CIR and TORL-7B on AIME25 is zero (29.2 vs. 29.2) and on average is only 1.9 points, so without sampling error bars the claim of 'consistent and superior performance' is not statistically supported. Similarly, the learning curves in Figures 2–4 come from a single run and need either multiple seeds or at least a statement of variance across runs.
  4. [§4.3, Table 4] The mechanistic conclusions about non-executable code are based on correlational statistics. The observation that 39.4% of correct responses contain non-executable code does not establish that such code 'contributes' to correctness, because correct responses may simply be longer and contain more code attempts. Likewise, the 36.0% of incorrect responses with fully executable code does not establish that executable-but-flawed code 'misleads' the model. A controlled comparison—for example, forcing or suppressing code revision, or matching on response length—is needed before these causal-sounding claims can be supported.
  5. [§4.1] The claim that 'removing the execution of the code interpreter results in a significant performance drop' conflates two different training conditions. The comparison is between RLcode (trained with tool-augmented RL and evaluated with code) and RLtext (trained with text-based RL), not between a single model with and without interpreter execution at inference time. The observed drop could be due to different training objectives or prompt distributions rather than to the model's dependence on execution. Please either directly ablate execution at inference time on the same trained model or soften the causal interpretation.
minor comments (5)
  1. [§3.2.2, Figure 3] The text says the trend is shown on 'AIME2025 and MATH500', but the figure caption and panel labels refer to AIME2024. Please correct the mismatch.
  2. [§2.3.2, §3.1] The precise hyperparameters of the proposed strategies are not specified: the schedule for the progressive interaction budget (when and how the budget changes from 2 to 3 to 4), the entropy coefficient setting, the clip-higher upper bound, and the KL divergence coefficient are not given. These details are necessary for reproduction and for interpreting the ablation-free results.
  3. [§4 opening] There is a typo: 'code ingetration' should be 'code integration'.
  4. [§3.1] The paper says training is conducted within the 'veRL framework [15]', but reference [15] is the HybridFlow paper. Please clarify the relationship or update the citation.
  5. [§3.2.2] The claim that the Qwen2.5-Math backbone adapts well 'because mainstream math models are typically exposed to significant amounts of code data' is presented without evidence. It is a reasonable hypothesis but should be labeled as such, or supported with a small experiment or citation.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the training claims are evaluated on held-out benchmarks, and no load-bearing derivation step reduces to its inputs by construction or self-citation chain.

full rationale

The paper's central claim is that a set of tool-augmented RL strategies improves code-integrated reasoning accuracy. The supporting evidence is Table 1, obtained by training on a fixed subset of STILL-3 and evaluating on MATH500, AMC23, AIME2024, AIME2025, and OlymMATH. No parameter is fitted to these benchmarks and then reported as a prediction: the training data and evaluation sets are distinct, and the reported AVG@16 numbers are measured, not derived from the training objective. The training data (STILL-3, Ref. [4]) and the OlymMATH benchmark (Ref. [18]) come from the same research group, but these citations are sources of data and evaluation material, not load-bearing mathematical results; they do not by themselves define the performance metric or force the outcome. The paper does not invoke a uniqueness theorem from prior self-authored work, does not smuggle in an ansatz via self-citation, and does not rename a known result as an organization. The mechanistic analyses (PASS@k, code pass rate, problem-type gains) are observations about the trained model, not components of the derivation. Accordingly, no equation reduces to another by construction, and no fitted input is relabeled as a prediction. The absence of a decontamination report raises evaluation-validity risk, which is a correctness concern, not circularity under the stated criteria.

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

The paper's claim rests mainly on training design choices (budget schedule, entropy coefficient, clipping asymmetry, KL removal) and on the domain assumption that the base model writes executable code. No new physical or architectural entities are introduced.

free parameters (4)
  • Progressive interaction budget schedule = 2 -> 3 -> 4 rounds
    Chosen by hand in Sections 3.1 and 3.2.2 to balance exploration and stability; no sensitivity analysis is provided.
  • Entropy coefficient = 0
    Entropy bonus is disabled in Section 2.3.2 to prevent entropy growth in tool-augmented RL; no ablation supports this choice.
  • Asymmetric clipping upper bound (clip-higher) = not reported
    Adopted from DAPO (Ref [12]); the exact epsilon value is not given in the manuscript.
  • KL divergence coefficient = removed (0)
    The KL term is removed in Section 2.3.2 to encourage exploration; no value is reported for any retained KL.
assumptions (4)
  • domain assumption Base Qwen2.5-Math-7B can generate well-formed Python code blocks early in training, so exact-match boundary detection yields reliable interpreter interactions.
    Invoked in Sections 2.3.2 and 3.2.2; if false, training would be dominated by syntax failures and the proposed stability gains would not materialize.
  • domain assumption A binary final-answer reward (+1 for correct, -1 otherwise) is a sufficient learning signal for acquiring code-integrated reasoning.
    Section 3.1 states the reward scheme; no process reward or tool-use reward is used, so the model must discover tool use from outcome alone.
  • domain assumption The STILL-3 38k sample subset provides a balanced difficulty distribution that transfers to all five evaluation benchmarks.
    Section 3.1 uses this subset without analyzing benchmark overlap, difficulty coverage, or potential contamination.
  • standard math REINFORCE++ and the PPO-style surrogate objective are valid optimizers for autoregressive LLMs in this interactive setting.
    Background math used in Sections 2.2 and 3.1; treated as standard and not proved in the paper.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Towards Effective Code-Integrated Reasoning." pith.science (2026). https://pith.science/paper/AKZMNMFY

@misc{pith2026250524480,
  author       = {Pith},
  title        = {Pith review of: Towards Effective Code-Integrated Reasoning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AKZMNMFY}},
  note         = {Machine review of arXiv:2505.24480}
}
read the original abstract

In this paper, we investigate code-integrated reasoning, where models generate code when necessary and integrate feedback by executing it through a code interpreter. To acquire this capability, models must learn when and how to use external code tools effectively, which is supported by tool-augmented reinforcement learning (RL) through interactive learning. Despite its benefits, tool-augmented RL can still suffer from potential instability in the learning dynamics. In light of this challenge, we present a systematic approach to improving the training effectiveness and stability of tool-augmented RL for code-integrated reasoning. Specifically, we develop enhanced training strategies that balance exploration and stability, progressively building tool-use capabilities while improving reasoning performance. Through extensive experiments on five mainstream mathematical reasoning benchmarks, our model demonstrates significant performance improvements over multiple competitive baselines. Furthermore, we conduct an in-depth analysis of the mechanism and effect of code-integrated reasoning, revealing several key insights, such as the extension of model's capability boundaries and the simultaneous improvement of reasoning efficiency through code integration. All data and code for reproducing this work are available at: https://github.com/RUCAIBox/CIR.

Figures

Figures reproduced from arXiv: 2505.24480 by the authors.

Figure 1
Figure 1. Illustration of interaction boundary based on stop tokens and precise matching. (a) The [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Training reward and average response length during the training process. [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. The test accuracy on AIME2024 and MATH500. [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: The average code generation number, code generation ratio and code pass rate during the [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: The prompt triggering the model to utilize code-integrated reasoning. [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: PASS@k Accuracy on AIME2024, AIME2025, OlymMATH-Easy and OlymMATH-Hard. Evaluation settings. To investigate the impact of code-integrated reasoning on the model’s capability boundaries, we test four baseline models, which are all derived from Qwen2.5-Math-7B, on the AI…
Figure 7
Figure 7. Figure 7: Accuracy of different categories on AIME2024 and OlymMATH. [PITH_FULL_IMAGE:figures/full_fig_p013_7.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 3 Pith papers

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

  1. SimpleTIR: End-to-End Reinforcement Learning for Multi-Turn Tool-Integrated Reasoning

    cs.LG 2025-09 conditional novelty 6.0 of 10

    Filtering out trajectories with 'void turns' (no code, no answer) stabilizes multi-turn tool-integrated RL and substantially improves math reasoning benchmarks.

  2. Chain-of-Agents: End-to-End Agent Foundation Models via Multi-Agent Distillation and Agentic RL

    cs.AI 2025-08 conditional novelty 6.0 of 10

    A single LLM is trained with multi-agent distilled trajectories plus agentic RL, and the resulting Chain-of-Agents models set state-of-the-art Pass@1 scores among tool-integrated reasoning methods on GAIA, BrowseComp,...

  3. From Trial-and-Error to Improvement: A Systematic Analysis of LLM Exploration Mechanisms in RLVR

    cs.CL 2025-08 unverdicted novelty 4.0 of 10

    A systematic analysis of LLM exploration in RLVR, introducing capability-boundary metrics and examining entropy-performance exchange across training stages and token levels.

Reference graph

Works this paper leans on

23 extracted references · 1 canonical work pages · cited by 3 Pith papers

  1. [18]

    Challenging the boundaries of reasoning: An olympiad-level math benchmark for large language models

    Haoxiang Sun, Yingqian Min, Zhipeng Chen, Wayne Xin Zhao, Zheng Liu, Zhongyuan Wang, Lei Fang, and Ji-Rong Wen. Challenging the boundaries of reasoning: An olympiad-level math benchmark for large language models. arXiv preprint arXiv:2503.21380, 2025

    arXiv 2025

  2. [4]

    An empirical study on eliciting and improving r1-like reasoning models

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

    arXiv 2025

  3. [1]

    DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao, Aixin Liu, Bing Xue, Bingxuan Wang, Bochao Wu, Bei Feng, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai D...

    arXiv 2025

  4. [2]

    A survey of large language models

    Wayne Xin Zhao, Kun Zhou, Junyi Li, Tianyi Tang, Xiaolei Wang, Yupeng Hou, Yingqian Min, Beichen Zhang, Junjie Zhang, Zican Dong, Yifan Du, Chen Yang, Yushuo Chen, Zhipeng Chen, Jinhao Jiang, Ruiyang Ren, Yifan Li, Xinyu Tang, Zikang Liu, Peiyu Liu, Jian-Yun Nie, and Ji-Rong Wen. A survey of large language models. CoRR, abs/2303.18223, 2023

    arXiv 2023

  5. [3]

    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

    arXiv 2025

  6. [5]

    Torl: Scaling tool-integrated rl

    Xuefeng Li, Haoyang Zou, and Pengfei Liu. Torl: Scaling tool-integrated rl. arXiv preprint arXiv:2503.23383, 2025

    arXiv 2025

  7. [6]

    Retool: Reinforcement learning for strategic tool use in llms

    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. arXiv preprint arXiv:2504.11536, 2025

    arXiv 2025

  8. [7]

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

    Xinji Mai, Haotian Xu, Weinong Wang, Yingying Zhang, Wenqiang Zhang, et al. Agent rl scaling law: Agent rl with spontaneous code execution for mathematical problem solving. arXiv preprint arXiv:2505.07773, 2025

    arXiv 2025

Show all 23 references
  1. [8]

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

    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. arXiv preprint arXiv:2503.05592, 2025

    2025 arXiv

  2. [9]

    Simpledeepsearcher: Deep information seeking via web-powered reasoning trajectory synthesis

    Shuang Sun, Huatong Song, Yuhao Wang, Ruiyang Ren, Jinhao Jiang, Junjie Zhang, Fei Bai, Jia Deng, Wayne Xin Zhao, Zheng Liu, et al. Simpledeepsearcher: Deep information seeking via web-powered reasoning trajectory synthesis. arXiv preprint arXiv:2505.16834, 2025

    2025

  3. [10]

    Ragen: Understanding self-evolution in llm agents via multi-turn reinforcement learning

    Zihan Wang, Kangrui Wang, Qineng Wang, Pingyue Zhang, Linjie Li, Zhengyuan Yang, Kefan Yu, Minh Nhat Nguyen, Licheng Liu, Eli Gottlieb, et al. Ragen: Understanding self-evolution in llm agents via multi-turn reinforcement learning. arXiv preprint arXiv:2504.20073, 2025

    2025 arXiv

  4. [11]

    R1-searcher++: Incentivizing the dynamic knowledge acquisition of llms via reinforcement learning

    Huatong Song, Jinhao Jiang, Wenqing Tian, Zhipeng Chen, Yuhuan Wu, Jiahao Zhao, Yingqian Min, Wayne Xin Zhao, Lei Fang, and Ji-Rong Wen. R1-searcher++: Incentivizing the dynamic knowledge acquisition of llms via reinforcement learning. arXiv preprint arXiv:2505.17005, 2025

    2025 arXiv

  5. [12]

    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

  6. [13]

    Qwen2.5-math technical report: Toward mathematical expert model via self-improvement

    An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, Keming Lu, Mingfeng Xue, Runji Lin, Tianyu Liu, Xingzhang Ren, and Zhenru Zhang. Qwen2.5-math technical report: Toward mathematical expert model via se...

    2024 arXiv

  7. [14]

    Qwen3 technical report

    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

  8. [15]

    Hybridflow: A flexible and efficient rlhf framework

    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

  9. [16]

    Reinforce++: A simple and efficient approach for aligning large language models

    Jian Hu. Reinforce++: A simple and efficient approach for aligning large language models. arXiv preprint arXiv:2501.03262, 2025

    2025 arXiv

  10. [17]

    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. In Joaquin Vanschoren and Sai-Kit Yeung, editors, Proceedings of the Neural Information Processing...

    2021

  11. [19]

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

    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

  12. [20]

    Process reinforcement through implicit rewards

    Ganqu Cui, Lifan Yuan, Zefan Wang, Hanbin Wang, Wendi Li, Bingxiang He, Yuchen Fan, Tianyu Yu, Qixin Xu, Weize Chen, et al. Process reinforcement through implicit rewards. arXiv preprint arXiv:2502.01456, 2025

    2025 arXiv

  13. [21]

    Understanding r1-zero-like training: A critical perspective

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

    2025 arXiv

  14. [22]

    Cognitive behaviors that enable self-improving reasoners, or, four habits of highly effective stars

    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. arXiv preprint arXiv:2503.01307, 2025. 15 Problem Let ABCD be a tetrahedron such that AB = C...

    2025 arXiv

  15. [89]

    This distance can be written in the form m√n p , where m, n, and p are positive integers, m and p are relatively prime, and n is not divisible by the square of any prime

    There exists a point I inside the tetrahedron such that the distances from I to each of the faces of the tetrahedron are all equal. This distance can be written in the form m√n p , where m, n, and p are positive integers, m and p are relatively prime, and n is not divisible by...

Pith tools

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