Pith. sign in

REVIEW 4 major objections 5 minor 2 cited by

A Practical Two-Stage Recipe for Mathematical LLMs: Maximizing Accuracy with SFT and Efficiency with Reinforcement Learning

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

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

Pith's one-line read A two-stage training recipe—extended supervised fine-tuning followed by a short GRPO phase—produces mathematical LLMs that are both more accurate and more token-efficient, with SFT carrying the accuracy gains and reinforcement learning…

desk verdict Useful empirical recipe with a credible AIMO result, but the '10 epochs is crucial' claim is oversold at smaller scales and unguarded against contamination. read the letter →

arxiv 2507.08267 v1 pith:NVLQ2IZZ submitted 2025-07-11 cs.LG cs.AI

Hiroshi Yoshihara , Taiki Yamaguchi , Yuichi Inoue This is my paper
classification cs.LGcs.AI
keywords mathematicalreasoningsupervisedfine-tuningGRPOtokenefficiencyreinforcementlearningAIMOchain-of-thoughtrewarddesign
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 proposes and defends a practical training recipe for mathematical reasoning LLMs: first fine-tune on high-quality solved problems for as many as 10 epochs, then apply a short GRPO reinforcement learning stage. The central claim is that these stages play complementary roles—the long SFT phase is what pushes accuracy upward, while GRPO's main contribution is cutting the length of generated solutions without giving back that accuracy. If correct, this separates accuracy and inference efficiency into two independently optimizable objectives rather than a trade-off. The authors support the recipe with results on AIME 2024/2025 and MATH-500 across three model scales, and with a top-8 private-set finish among 2,212 teams on the leak-free AIMO competition.

What carries the argument

The load-bearing mechanism is the two-stage recipe itself. Stage 1 is full-parameter SFT for 10 epochs on 7,900 high-difficulty problem-solution-answer triplets assembled from OpenR1 Math, the openr1 hard subset, and Light-R1-SFT data, selecting correct solutions with short token lengths and substituting ground-truth answers from R1 traces where missing. Stage 2 is GRPO for 50 steps on Light-R1 second-stage data, with a reward function combining a format regular-expression check, a cosine-similarity reward that scores generated traces against reference correct traces (scaled 0.1 to 1.0 for correct, -1.0 to -0.1 for incorrect), and a length penalty. The empirical pattern of accuracy rising across SFT epochs while GRPO compresses output length is what carries the argument that the two methods are complementary.

What would settle it

Search the curated 7,900-example SFT corpus, along with the OpenR1 and Light-R1 sources, for near-duplicates of AIME 2024/2025 and MATH-500 test problems; if a substantial fraction of test items appear with their solution traces, the reported accuracy gains from 10-epoch SFT would be explained by memorization. Re-running the recipe on a deduplicated corpus would settle whether the gains persist.

Watch

Extended reading notes

Core claim

The paper's central discovery is that accuracy and inference efficiency in math LLMs can be decoupled across two training stages. Starting from DeepSeek-R1-Distill-Qwen models, the authors find that supervised fine-tuning pushed to 10 epochs—longer than typical cold-start SFT—improves pass@1 on AIME and MATH-500, whereas a single epoch can even hurt accuracy while lengthening outputs. A subsequent short GRPO phase, using a reward that combines format adherence, cosine similarity to reference correct traces, and an explicit length penalty, preserves or slightly improves that accuracy while substantially reducing mean output tokens. The paper interprets this as SFT setting the performance ceiling and GRPO optimizing solution length, and reports that the recipe transfers across 1.5B, 7B, and 14B models, with the largest gains at 14B. The strongest validation claim is 29/50 on the AIMO public set and 28/50 on the private set, equivalent to 4th and 8th place among 2,212 teams.

Load-bearing premise

The evaluation numbers reflect genuine generalization rather than overlap between the public test sets and the SFT training data; the paper reports no deduplication or contamination check against AIME 2024/2025 and trusts the AIMO private set to be leak-free.

Editorial extensions

If this is right

  • Practitioners building specialized math models should expect peak accuracy only after many SFT epochs, contrary to the common one-to-three epoch cold-start practice.
  • GRPO can be deployed primarily as a token-compression stage rather than an accuracy booster, enabling models that are both accurate and cheap to run at inference.
  • The recipe's benefit grows with model scale: 14B models gain both accuracy and efficiency, while 1.5B models show little accuracy improvement, suggesting a capacity threshold for the effect.
  • The reward design matters: a cosine-similarity reward tied to reference traces plus an explicit length penalty beats a binary accuracy reward on the accuracy-efficiency frontier.
  • Success on the leak-free AIMO private set supports the claim that the recipe generalizes beyond public benchmarks, though the single competition result is a limited sample.

Reading between the lines

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

  • If the decoupling is real, the same two-stage scheme—long supervised training for competence, then RL for brevity—may transfer to other reasoning domains such as code generation or theorem proving, where over-long outputs are also costly.
  • The cosine reward's dependence on reference correct traces from a strong teacher (DeepSeek-R1) means the recipe's efficiency gains may not reproduce when only weaker teachers are available; a testable extension is to run Stage 2 with a self-generated reference set.
  • Because the paper reports no contamination check, the AIME/MATH-500 gains are vulnerable to training/test overlap; comparing accuracy on a freshly written, non-public problem set would be a stronger test of the recipe than any existing benchmark.
  • The finding that one SFT epoch sharply drops accuracy while many epochs recover suggests a non-monotonic learning curve worth characterizing mechanistically, for instance through loss landscape or representation analysis across epochs.
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 proposes a two-stage post-training recipe for mathematical LLMs: an extended full-parameter SFT stage (10 epochs) on a curated dataset of 7,900 high-difficulty problem-solution-answer triplets, followed by a GRPO stage with a composite reward (format, cosine similarity against reference traces, and length penalty). The central claims are that prolonged SFT is crucial for accuracy breakthroughs and that, in this framework, GRPO mainly improves token efficiency while preserving the SFT peak accuracy. The authors evaluate on AIME 2024, AIME 2025, and MATH-500 across 1.5B, 7B, and 14B DeepSeek-R1-Distill-Qwen models, and report a private-set score of 28/50 (8th of 2,212 teams) on the AIMO 2 competition. The paper also reports a per-problem analysis and ablation of reward functions.

Significance. If the claims hold, the recipe is practically valuable: it decouples accuracy maximization (SFT) from inference-efficiency optimization (GRPO) and is validated in a competitive, genuinely leak-free setting. The strongest evidence is the AIMO private-set result, which is external and not subject to public-benchmark contamination concerns. The commitment to release code, checkpoints, and datasets also supports reproducibility. However, the paper's central '10 epochs is crucial' claim is not uniformly supported by its own tables, and the absence of a contamination check leaves the headline accuracy gains on public benchmarks uncertain. As submitted, the evidence supports a scale-dependent, more cautiously worded version of the recipe rather than the broad claim in the abstract.

major comments (4)
  1. [§3.1, §4.1, Tables 1-2] The SFT data are curated from public corpora (OpenR1 Math, Light-R1-SFT Data) and evaluated on AIME 2024/2025 and MATH-500, but no deduplication, n-gram overlap analysis, or exclusion of test-set problems is reported. If any AIME/MATH-500 problems or near-duplicates are present in the 7,900 training triplets, the accuracy gains in Tables 1 and 2, and the subsequent claim that RL preserves accuracy, are inflated. The authors should add a contamination check (e.g., normalized n-gram overlap, embedding similarity, and manual review of top matches) and report results with matched items removed.
  2. [Abstract, §4.3, Table 1] The abstract states that extending SFT to 10 epochs is 'crucial for performance breakthroughs' without conditioning on model scale. Table 1 shows the opposite for the 1.5B model: +SFT(10 epochs) decreases AIME 2024 accuracy from 27.8 to 26.0 and AIME 2025 accuracy from 22.3 to 22.1. The paper acknowledges this in §4.3 but does not reconcile it with the abstract-level claim. The claim should be restricted to 7B/14B or explicitly framed as scale-dependent.
  3. [§4.1, Tables 1-2] Pass@1 is reported as the mean over 64 sampling runs, but no standard deviations, confidence intervals, or bootstrap estimates are provided. AIME 2024 and AIME 2025 each contain only 30 problems, so differences of a few percentage points (e.g., 65.2 vs 63.3 for 14B on AIME 2024) are within sampling noise. This is load-bearing for several comparisons, including the claim that RL preserves accuracy after SFT. The authors should report CIs or bootstrap intervals for the headline numbers.
  4. [§3.2, §4.6, Figure 2] The GRPO reward combines format, cosine-similarity, and length-penalty terms with multiple hand-set scaling choices (e.g., reward ranges 0.1-1.0 for correct and -1.0 to -0.1 for incorrect, a 30,000-token maximum, and a length penalty whose coefficient is not stated). The conclusion that GRPO's primary role is token-efficiency optimization could be an artifact of these particular weights. The authors should give the full reward formula and coefficients, and include at least a small sensitivity analysis over penalty strengths.
minor comments (5)
  1. [§4.6] The sentence 'To test this, For this analysis, we evaluated three distinct reward configurations' contains a duplicated phrase and should be rewritten.
  2. [§3.2] The format-reward regular expression is printed as r"^.*?oxed\{(.*?)\}.*?</think>.*?$", which appears to be missing the backslash before 'oxed' and should read r"^.*?\boxed\{(.*?)\}.*?</think>.*?$"; as typeset it is not a valid way to match \boxed.
  3. [§4.1] The evaluation protocol says pass@1 is averaged over 64 sampling runs but does not report sampling temperature or top-p; these are needed for reproducibility and for interpreting the token-length comparisons.
  4. [§1, §5] The phrase 'consistently and significantly boosts' in the introduction is stronger than the data support, especially given the 1.5B results and the lack of statistical significance testing; 'significantly' should either be removed or backed by tests.
  5. [References] The Wei et al. reference contains a malformed author segment ('brian ichter, Xia, F.,') and should be corrected to the standard ACL anthology author list.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper is an empirical benchmark study whose claims are validated on external, leak-controlled test sets, with no load-bearing self-citation or derivation-from-assumption.

full rationale

This is an empirical training-recipe paper, not a mathematical derivation. The central claims—that 10-epoch SFT improves accuracy and that GRPO primarily improves token efficiency—are supported by measured pass@1 and token-length numbers on external benchmarks (AIME 2024/2025, MATH-500, and the AIMO competition private set). No equation in the paper defines a predicted quantity in terms of the fitted quantity, and no parameter is fitted to a benchmark and then reported as a prediction of that same benchmark. The SFT dataset is curated from public corpora, and the evaluation sets are external; even if a contamination concern existed, that would be a correctness or generalization risk, not circularity. The paper's only self-citation (Misaki et al., 2025, in the related-work discussion of test-time scaling) is not load-bearing for the recipe's claims. The AIMO result is externally adjudicated and explicitly described as leak-free. The reward design is hand-tuned, but tuning hyperparameters against benchmark outcomes is standard experimental practice and does not make the measured results equivalent to the method's inputs by construction. Therefore, no circular step can be exhibited, and the appropriate finding is no significant circularity.

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

The recipe introduces no new model or entity; it combines known components. Its load-bearing freedom is in hyperparameters and data-selection thresholds, plus assumptions that benchmarks are uncontaminated and reward signals are reliable.

free parameters (10)
  • SFT training epochs = 10
    Chosen by hand as the key recipe component; Figure 1 shows accuracy varies by epoch, and the 1.5B model does not benefit.
  • SFT learning rate = 1e-5
    Standard cosine schedule; no sensitivity study reported.
  • Maximum sequence length (SFT) = 24,000
    Chosen to fit long R1 traces; affects which samples are usable.
  • GRPO steps = 50
    Stopping point chosen by authors, with no convergence or length analysis reported.
  • GRPO beta = 0.04
    KL penalty coefficient chosen by hand.
  • GRPO num_generations = 8
    Standard GRPO group size chosen by authors.
  • GRPO learning rate = 4e-6
    Hand-selected; no sweep reported.
  • Reward scaling ranges for cosine reward = correct 0.1 to 1.0, incorrect -1.0 to -0.1
    Ad hoc scaling to penalize short incorrect and long correct traces; no principled derivation.
  • Data selection thresholds = trace length >12,800 tokens; accuracy >50% and 50-75%; 2,500 hard problems
    Hand-picked cutoffs used to build the 7,900-sample SFT set.
  • Pass@1 sampling temperature and top-p = unspecified
    64 sampling runs are reported but the sampling parameters are not stated, so the token/accuracy numbers are not exactly reproducible.
assumptions (5)
  • domain assumption AIMO private set is leak-free and official ranking reflects method quality.
    Section 4.8 relies on competition integrity; no independent verification is provided.
  • domain assumption AIME and MATH-500 are valid generalization tests without overlap with SFT training data.
    Sections 4.1 and 3.1; no contamination analysis is provided.
  • domain assumption DeepSeek-R1-Distill-Qwen traces provide reliable ground-truth answers for SFT targets.
    Section 3.1 uses R1 model solution traces to extract answers; errors in the trace would propagate.
  • ad hoc to paper Cosine similarity between generated and reference traces is a useful reward signal.
    Section 3.2; no evidence that embedding similarity correlates with solution quality, and scaling is chosen by hand.
  • domain assumption Pass@1 over 64 samples is a stable performance estimate.
    Section 4.1; no confidence intervals or significance tests are reported.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Practical Two-Stage Recipe for Mathematical LLMs: Maximizing Accuracy with SFT and Efficiency with Reinforcement Learning." pith.science (2026). https://pith.science/paper/NVLQ2IZZ

@misc{pith2026250708267,
  author       = {Pith},
  title        = {Pith review of: A Practical Two-Stage Recipe for Mathematical LLMs: Maximizing Accuracy with SFT and Efficiency with Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NVLQ2IZZ}},
  note         = {Machine review of arXiv:2507.08267}
}
read the original abstract

Enhancing the mathematical reasoning of Large Language Models (LLMs) is a pivotal challenge in advancing AI capabilities. While Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL) are the dominant training paradigms, a systematic methodology for combining them to maximize both accuracy and efficiency remains largely unexplored. This paper introduces a practical and effective training recipe that strategically integrates extended SFT with RL from online inference (GRPO). We posit that these methods play complementary, not competing, roles: a prolonged SFT phase first pushes the model's accuracy to its limits, after which a GRPO phase dramatically improves token efficiency while preserving this peak performance. Our experiments reveal that extending SFT for as many as 10 epochs is crucial for performance breakthroughs, and that the primary role of GRPO in this framework is to optimize solution length. The efficacy of our recipe is rigorously validated through top-tier performance on challenging benchmarks, including a high rank among over 2,200 teams in the strictly leak-free AI Mathematical Olympiad (AIMO). This work provides the community with a battle-tested blueprint for developing state-of-the-art mathematical reasoners that are both exceptionally accurate and practically efficient. To ensure full reproducibility and empower future research, we will open-source our entire framework, including all code, model checkpoints, and training configurations at https://github.com/analokmaus/kaggle-aimo2-fast-math-r1.

Figures

Figures reproduced from arXiv: 2507.08267 by the authors.

Figure 1
Figure 1. Performance comparison SFT on AIME 2024 and 2025. Mean Pass@1 accuracy and mean token length per training epoch. cused on maximizing the performance of a model of this size. To investigate how our training recipe generalizes to other model scales, we also experimented with 1.5B and 7B parameter models. For our base models, we used the DeepSeek-R1-Distill-Qwen models (DeepSeek-AI, 2025), which were also a popular cho… view at source ↗
Figure 3
Figure 3. Per-problem changes in mean pass@1 and token length from the original model to our proposed recipe. This plot illustrates the shift in performance and ef￾ficiency for each problem after applying our training recipe. 4.6. Ablation on Reward Functions We investigated how the combination of the reward func￾tions for RL affects our model’s performance. To test this, For this analysis, we evaluated three distinct reward … view at source ↗

Discussion (0). Sign in to comment.

Forward citations

Cited by 2 Pith papers

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

  1. Reasoning to Regulate: Chain-of-Thought for Traffic Rule Understanding

    cs.CV 2026-07 conditional novelty 5.0 of 10

    CoT data curated by two-round LLM prompting and VLM verification, then SFT+GRPO with fine-grained rewards, improves MapDR rule–lane association F1 from 0.642 to 0.723.

  2. CRAFT: Learn the Schema, Execute the Plan

    cs.AI 2026-06 conditional novelty 5.0 of 10

    CRAFT, a two-stage post-training recipe that strips schema documentation from prompts and uses execution-grounded reinforcement learning, reports improved enterprise coding-agent quality at roughly 9x lower input-token cost.

Reference graph

Works this paper leans on

31 extracted references · 9 canonical work pages · cited by 2 Pith papers

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  2. [2]

    and Welleck, S

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

    arXiv 2025

  3. [3]

    V., R \'e , C., and Mirhoseini, A

    Brown, B., Juravsky, J., Ehrlich, R., Clark, R., Le, Q. V., R \'e , C., and Mirhoseini, A. Large language monkeys: Scaling inference compute with repeated sampling. arXiv preprint arXiv:2407.21787, 2024

    arXiv 2024

  4. [4]

    Alphamath almost zero: Process supervision without process

    Chen, G., Liao, M., Li, C., and Fan, K. Alphamath almost zero: Process supervision without process. In Advances in Neural Information Processing Systems, 2024

    work page 2024

  5. [5]

    and Ngo, C

    Dang, Q.-A. and Ngo, C. Reinforcement learning for reasoning in small llms: What works and what doesn't. arXiv preprint arXiv:2503.16219, 2025

    arXiv 2025

  6. [6]

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

    DeepSeek-AI. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025

    arXiv 2025

  7. [7]

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

    Face, H. Open r1: A fully open reproduction of deepseek-r1, January 2025. URL https://github.com/huggingface/open-r1

    2025

  8. [8]

    C., Buzzard, K., Gowers, T., Liu, P

    Frieder, S., Bealing, S., Nikolaiev, A., Smith, G. C., Buzzard, K., Gowers, T., Liu, P. J., Loh, P.-S., Mackey, L., de Moura, L., Roberts, D., Sculley, D., Tao, T., Balduzzi, D., Coyle, S., Gerko, A., Holbrook, R., Howard, A., and Markets, X. Ai mathematical olympiad - progress prize 2. https://kaggle.com/competitions/ai-mathematical-olympiad-progress-pri...

    work page 2024

Show all 31 references
  1. [9]

    Measuring mathematical problem solving with the MATH dataset

    Hendrycks, D., Burns, C., Kadavath, S., Arora, A., Basart, S., Tang, E., Song, D., and Steinhardt, J. Measuring mathematical problem solving with the MATH dataset. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), 2021...

    2021

  2. [10]

    A., Welbl, J., Clark, A., Hennigan, T., Noland, E., Millican, K., van den Driessche, G., Damoc, B., Guy, A., Osindero, S., Simonyan, K., Elsen, E., Rae, J

    Hoffmann, J., Borgeaud, S., Mensch, A., Buchatskaya, E., Cai, T., Rutherford, E., de Las Casas, D., Hendricks, L. A., Welbl, J., Clark, A., Hennigan, T., Noland, E., Millican, K., van den Driessche, G., Damoc, B., Guy, A., Osindero, S., Simonyan, K., Elsen, E., Rae, J. W., Vin...

    2022 arXiv

  3. [11]

    C3ot: Generating shorter chain-of-thought without compromising effectiveness

    Kang, Y., Sun, X., Chen, L., and Zou, W. C3ot: Generating shorter chain-of-thought without compromising effectiveness. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp.\ 24312--24320, 2025

    2025

  4. [12]

    B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., and Amodei, D

    Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., and Amodei, D. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020

    2001 arXiv

  5. [13]

    Solving quantitative reasoning problems with language models

    Lewkowycz, A., Andreassen, A., Dohan, D., Dyer, E., Michalewski, H., Ramasesh, V., Slone, A., Anil, C., Schlag, I., Gutman-Solo, T., et al. Solving quantitative reasoning problems with language models. Advances in Neural Information Processing Systems, 2022

    2022

  6. [14]

    Competition-level code generation with alphacode

    Li, Y., Choi, D., Chung, J., Kushman, N., Schrittwieser, J., Leblond, R., Eccles, T., Keeling, J., Gimeno, F., Dal Lago, A., et al. Competition-level code generation with alphacode. Science, 378 0 (6624): 0 1092--1097, 2022

    2022

  7. [15]

    Can language models learn to skip steps? In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024

    Liu, T., Guo, Q., Hu, X., Jiayang, C., Zhang, Y., Qiu, X., and Zhang, Z. Can language models learn to skip steps? In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. URL https://openreview.net/forum?id=w4AnTVxAO9

    2024

  8. [16]

    O1-pruner: Length-harmonizing fine-tuning for o1-like reasoning pruning

    Luo, H., Shen, L., He, H., Wang, Y., Liu, S., Li, W., Tan, N., Cao, X., and Tao, D. O1-pruner: Length-harmonizing fine-tuning for o1-like reasoning pruning. arXiv preprint arXiv:2501.12570, 2025

    2025 arXiv

  9. [17]

    Wider or deeper? scaling llm inference-time compute with adaptive branching tree search

    Misaki, K., Inoue, Y., Imajuku, Y., Kuroki, S., Nakamura, T., and Akiba, T. Wider or deeper? scaling llm inference-time compute with adaptive branching tree search. arXiv preprint arXiv:2503.04412, 2025

    2025

  10. [18]

    L., Fei-Fei, L., Hajishirzi, H., Zettlemoyer, L., Liang, P., Candès, E., and Hashimoto, T

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

    2025 arXiv

  11. [19]

    H., Yang, Y., Kim, Y., and Yun, S.-Y

    Munkhbat, T., Ho, N., Kim, S. H., Yang, Y., Kim, Y., and Yun, S.-Y. Self-training elicits concise reasoning in large language models. arXiv preprint arXiv:2502.20122, 2025

    2025 arXiv

  12. [20]

    Openai o1 system card

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

    2024 arXiv

  13. [21]

    Competitive programming with large reasoning models

    OpenAI. Competitive programming with large reasoning models. arXiv preprint arXiv:2502.06807, 2025

    2025 arXiv

  14. [22]

    Qwq: Reflect deeply on the boundaries of the unknown, November 2024

    Qwen-Team. Qwq: Reflect deeply on the boundaries of the unknown, November 2024. URL https://qwenlm.github.io/blog/qwq-32b-preview/

    2024

  15. [23]

    Deepseekmath: Pushing the limits of mathematical reasoning in open language models

    Shao, Z., Wang, P., Zhu, Q., Xu, R., Song, J., Bi, X., Zhang, H., Zhang, M., Li, Y., Wu, Y., et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024

    2024 arXiv

  16. [24]

    Kimi k1.5: Scaling reinforcement learning with llms

    Team, K. Kimi k1.5: Scaling reinforcement learning with llms. arXiv preprint arXiv:2501.12599, 2025

    2025 arXiv

  17. [25]

    H., Le, Q

    Wei, J., Wang, X., Schuurmans, D., Bosma, M., brian ichter, Xia, F., Chi, E. H., Le, Q. V., and Zhou, D. Chain of thought prompting elicits reasoning in large language models. In Oh, A. H., Agarwal, A., Belgrave, D., and Cho, K. (eds.), Advances in Neural Information Processin...

    2022

  18. [26]

    Light-r1: Curriculum sft, dpo and rl for long cot from scratch and beyond, 2025

    Wen, L., Cai, Y., Xiao, F., He, X., An, Q., Duan, Z., Du, Y., Liu, J., Tang, L., Lv, X., Zou, H., Deng, Y., Jia, S., and Zhang, X. Light-r1: Curriculum sft, dpo and rl for long cot from scratch and beyond, 2025. URL https://arxiv.org/abs/2503.10460

    2025 arXiv

  19. [27]

    Inference scaling laws: An empirical analysis of compute-optimal inference for LLM problem-solving

    Wu, Y., Sun, Z., Li, S., Welleck, S., and Yang, Y. Inference scaling laws: An empirical analysis of compute-optimal inference for LLM problem-solving. In International Conference on Learning Representations, 2025

    2025

  20. [28]

    T., Wang, W., and Li, W

    Xia, H., Li, Y., Leong, C. T., Wang, W., and Li, W. Tokenskip: Controllable chain-of-thought compression in llms. arXiv preprint arXiv:2502.12067, 2025

    2025

  21. [29]

    Limo: Less is more for reasoning

    Ye, Y., Huang, Z., Xiao, Y., Chern, E., Xia, S., and Liu, P. Limo: Less is more for reasoning. arXiv preprint arXiv:2502.03387, 2025

    2025 arXiv

  22. [30]

    Demystifying long chain-of-thought reasoning in LLM s

    Yeo, E., Tong, Y., Niu, X., Neubig, G., and Yue, X. Demystifying long chain-of-thought reasoning in LLM s. In ICLR 2025 Workshop on Navigating and Addressing Data Problems for Foundation Models, 2025. URL https://openreview.net/forum?id=AgtQlhMQ0V

    2025

  23. [31]

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

    Zeng, W., Huang, Y., Liu, Q., Liu, W., He, K., Ma, Z., and He, J. Simplerl-zoo: Investigating and taming zero reinforcement learning for open base models in the wild. arXiv preprint arXiv:2503.18892, 2025

    2025 arXiv

Pith tools

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