Pith. sign in

REVIEW 4 major objections 4 minor 1 cited by

A program-assisted pipeline can synthesize 12.3 million math training triples whose answers are verified against program execution, and fine-tuning on them improves LLM math reasoning beyond existing synthesis methods.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

A program-assisted pipeline generates 12.3 million math problem-solution pairs with execution-based verification, and fine-tuning on a 50k sample improves model scores on GSM8K, MATH, Minerva, and SVAMP.

T0 review reviewed 2026-08-05 challenge →

load-bearing objection Useful program-assisted data synthesis pipeline buried under an unsupported 'correctness guarantee' and one broken baseline. the 4 major comments →

arxiv 2508.18824 v1 pith:52VQHBYQ submitted 2025-08-26 cs.CL

Arrows of Math Reasoning Data Synthesis for Large Language Models: Diversity, Complexity and Correctness

Sirui Chen , Changxin Tian , Binbin Hu , Kunlong Chen , Ziqi Liu , Zhiqiang Zhang , Jun Zhou This is my paper
classification cs.CL
keywords mathematical reasoningsynthetic dataprogram-assisted generationbilateral verificationknowledge systemLLM fine-tuningexecution-verified corpusmath benchmarks
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

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 the bottleneck in synthetic math training data—juggling diversity, complexity, and correctness—can be broken by making executable programs the backbone of generation. The authors build a three-tier math knowledge system covering more than 250 topics, map each topic to reusable APIs, combine those tools into programs, mutate the programs for added complexity, and translate them into natural-language question–solution pairs. A bilateral verification step keeps only triples where the LLM's extracted answer numerically matches the program's execution output, yielding 12.3 million verified triples. Fine-tuning LLaMA-3, Mistral-7B, and DeepSeek-Math-7B on this data improves accuracy on GSM8K, MATH, Minerva, and SVAMP, with the largest gains on the weaker base model. If this holds, synthetic math corpora can be produced at scale with execution-anchored correctness, without costly manual annotation.

Core claim

This paper discovers a synthesis geometry: by making executable programs the intermediate representation, all three axes of data quality can be managed at once. Topic-to-tool mappings from a 250-topic knowledge system produce diverse programs; four mutation operators add complexity; and a bilateral verification step filters for correctness by keeping only triples where the LLM's extracted answer matches the interpreter's output. The resulting 12.3M-triple corpus, called AMD, is shown to improve fine-tuned models' accuracy on GSM8K, MATH, Minerva, and SVAMP, often exceeding the MathGenie baseline. The claim is not that the model learns to call tools, but that training on execution-verified na

What carries the argument

The load-bearing mechanism is bilateral verification: for each program c, an interpreter produces output o_c, an LLM back-translates c into question q_c, solves it into solution s_c, and a regex extracts answer a_c; the triple survives only if a_c ≡ o_c. This equality converts program-execution results into a filter for natural-language correctness, which is what lets the authors call the corpus correctness-guaranteed. The rest of the machinery—the three-tier knowledge system, the 100+ API toolkit, and the four mutation operators—exists to make the program set diverse and complex before that filter is applied.

Load-bearing premise

That matching the final numeric answer is enough to guarantee the back-translated question truly asks for what the program computes; if question and program diverge while producing the same number, the 'correctness-guaranteed' corpus is partly mislabeled.

What would settle it

Take a random sample of the accepted triples and have independent human annotators judge whether the natural-language question q_c faithfully asks for what program c computes, ignoring the numeric answer. If a substantial share (say, over 5%) are inconsistent despite a_c equaling o_c, the bilateral verification's correctness guarantee is incomplete.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • Math training data can be generated at scale without manual annotation or dependence on stronger teacher models for the final answer; the interpreter is the ground truth.
  • Models trained on the corpus gain intrinsic reasoning ability rather than tool-calling skill, so downstream deployment does not require a code interpreter at inference time.
  • The knowledge-system pathway gives curriculum-style coverage of 250+ topics, while the seed-corpus pathway keeps the data grounded in real problem distributions; combining both gives the best benchmark scores.
  • The corpus supports roughly 6.8 solutions per program-question pair, so the same problems can support preference tuning, verifier training, or answer-ensemble methods.
  • Bilingual (English/Chinese) synthesis works without hurting performance, so the pipeline can address non-English math education data needs.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • An extension left implicit is that the verification only checks final-answer equality, so the corpus may silently admit samples where the back-translated question diverges from the program as long as the numeric answer matches; a direct question-to-program consistency check would close that gap.
  • Because program execution is the anchor, the quality ceiling is set by the toolkit's 100+ APIs; broadening tool coverage across topics may matter more than simply scaling the number of generated programs.
  • The same mutate-execute-backtranslate-verify loop could be exported to other executable domains (e.g., symbolic physics, graph algorithms, spreadsheet reasoning) where an interpreter can supply ground truth.
  • The comparison uses 50,000-sample fine-tuning for fairness; whether training on the full 12.3M corpus keeps improving or saturates is not demonstrated and is a natural next test.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper introduces AMD, a program-assisted synthetic data pipeline for mathematical reasoning. It builds a three-tier knowledge system and a math toolkit, generates executable programs from knowledge-topic combinations and a seed corpus, mutates these programs for diversity/complexity, back-translates them into natural-language question/solution pairs with GPT-4, and then filters the corpus by checking that a regex-extracted answer from the LLM solution equals the program's execution output. The authors claim the resulting 12.3M triples form a 'correctness-guaranteed' corpus, and that fine-tuning open LLMs (LLaMA3-8B, Mistral-7B, Deepseek-Math-7B) with a 50k subsample improves accuracy on GSM8K, MATH, Minerva, and SVAMP, often surpassing the MathGenie baseline.

Significance. If the central claims were supported, the paper would make a useful contribution: it proposes a scalable, program-anchored alternative to purely LLM-based math data synthesis, with potential advantages in diversity through knowledge-system coverage and in answer verification through program execution. The external execution check is a genuine strength that avoids the circularity of pure LLM self-verification for answer arithmetic. The knowledge-system/toolkit organization is also a reasonable engineering contribution, and the authors include ablation studies across two data sources and two languages. However, the paper's headline claims—'correctness-guaranteed' corpus and 'state-of-the-art' performance—are not supported by the evidence as presented. The verification condition is too weak for the guarantee, the evaluation depends on the same model used for generation, and the only baseline exhibits implausible scores in a key configuration. These issues are load-bearing for the paper's central contribution.

major comments (4)
  1. [§2.2] The definition D = {(c, q_c, s_c) | c ∈ Ĉ ∧ a_c ≡ o_c}, with a_c = regex_extract(s_c) and o_c = Interpreter(c), only ensures that the extracted final number from the LLM solution equals the program output. It does not verify that the back-translated question q_c faithfully represents the program c, nor that s_c is a valid solution to q_c. The text says 'errors at any step ... can lead to inconsistencies between a_c and o_c', but this is true only when the error changes the final numeric answer. Errors that change the semantics of q_c—for example, a constraint or variable mutation that alters the computed quantity yet preserves the output on the specific instance—are invisible to the filter. The paper itself acknowledges 'program-problem consistency' as a challenge that 'cannot be fully resolved' by LLMs, but the proposed bilateral mechanism does not actually check it. No human audit or m
  2. [Appendix A / §3.1] GPT-4 is used to generate the questions, solutions, and program mutations, and is also used as the evaluator that judges final benchmark correctness through 'semantic equivalence rather than exact string matching' (Appendix A). This creates a same-model evaluation risk: reported accuracies may partly reflect GPT-4's alignment with its own generated text and answer style rather than independent mathematical correctness. The program-execution check anchors the data-generation filter, which mitigates circularity for answer values, but it does not remove the bias in final benchmark evaluation. Independent evaluation (e.g., exact match with normalized answers, or a judge from a different model family) should be reported to support the claimed improvements.
  3. [Table 1] In the LLaMA3-8B block, the MathGenie baseline achieves 23.7 on GSM8K and 30.5 on SVAMP, far below the base model's 55.5 and 69.1. Fine-tuning on a math-synthetic dataset is not expected to degrade these benchmarks so drastically; this suggests a baseline misconfiguration, an unrepresentative 50k subsample, or an evaluation inconsistency. Because MathGenie is the only comparison method and the paper claims 'consistent superior performance' and 'often surpassing state-of-the-art', these anomalous cells undermine the experimental support for the central performance claim. The authors should rerun the baseline with proper configuration and report full training/evaluation details.
  4. [Abstract / §5] The paper claims the method 'achieves state-of-the-art performance on several benchmark datasets' and 'surpasses state-of-the-art methods', but the experiments include only a single baseline, MathGenie. Other synthesis methods discussed in §4 (e.g., MetaMath, Jiuzhang, Neuro-Symbolic Data Generation) are not compared. At minimum, the claims should be restricted to 'outperforms MathGenie under the reported settings', and additional baselines or a clear explanation of omitted comparisons should be provided.
minor comments (4)
  1. [§2.3] The paper reports 12.3M triples but all fine-tuning experiments use only a random 50k subsample. No experiments study whether the full corpus or the sample size affects performance, so the advantage of the large-scale corpus is not demonstrated.
  2. [Table 2 / Table 3] The checkmark columns in the ablation tables are not self-explanatory; please add explicit column headers such as 'Knowledge System' and 'Seed Corpus' (Table 2) and 'EN'/'CN' (Table 3) consistently, or state in the caption which checkmark combinations correspond to which configuration.
  3. [§3.1] Some hyperparameters are missing: LoRA rank/alpha, learning rate, batch size, number of epochs, and the exact filtering criterion for the '10-gram overlap' are not specified. Including these would improve reproducibility.
  4. [General] The paper says 'Minerva_Math' in §3.1 but 'Minerva' in the tables; please standardize the benchmark name. Also, Figure 1's label 'Math Knowledge SystemGradeMiddleHighCollege' is visually unclear and should be formatted.

Circularity Check

1 steps flagged

The 'correctness guarantee' is the filter itself (a_c ≡ o_c); q_c never enters the acceptance condition, so the claimed bilateral program-problem consistency is not actually verified.

specific steps
  1. self definitional [Section 2.2, 'Guaranteeing Correctness via Bilateral Verification']
    "To address this, we adopt a bilateral verification mechanism to ensure the correctness of the synthesized data, i.e., execute the programs and compare the outputs with the LLM-generated solutions. ... (3) Cross-Verification: construct verified corpus: D ={(𝑐, 𝑞𝑐, 𝑠𝑐)| 𝑐 ∈ bC∧ 𝑎𝑐 ≡ 𝑜𝑐}. Note that errors at any step from “𝑐→ 𝑞𝑐→ 𝑠𝑐→ 𝑎𝑐” can lead to inconsistencies between 𝑎𝑐 and 𝑜𝑐. Thus, our two-sided verification mechanism not only ensures the correctness of semantic translation (code→question) and logical derivation (question→solution). This process ultimately results in a correctness-guarant"

    The claimed 'correctness guarantee' is nothing more than the acceptance predicate a_c ≡ o_c restated as an output property. The filter condition involves only the program output and the answer string extracted from the LLM solution; the natural-language question q_c does not appear in the predicate. Therefore the asserted 'bilateral' check of code→question semantic translation is not implemented: any triple whose extracted numeric answer equals the interpreter output is admitted, regardless of whether q_c actually asks for what c computes. The guarantee is true by construction only for the narrow numeric-equality criterion, while the paper presents it as a guarantee of program-problem consistency. This is a definitional reduction: D is defined as the set satisfying the equality, and the 'c

full rationale

The paper's core data-synthesis pipeline is anchored to an external check—Python program execution—so it is not a purely self-referential derivation. There are no fitted parameters being renamed as predictions, and the self-citations present (e.g., Ref. [16], which includes an author) are not load-bearing. The central weakness is that the 'bilateral validation' is, by construction, a single numerical equality check (a_c ≡ o_c); q_c is absent from the formal corpus definition, so the paper's claim that this 'ensures program-problem consistency' is an overstatement rather than a derived result. Additionally, Appendix A reveals that GPT-4—the same model family used to generate the synthetic questions, solutions, and programs—also serves as the evaluator judging final benchmark correctness; this introduces a self-evaluation confound, though benchmark ground truths are external. Because the main data-generation loop uses an external program interpreter, the circularity is partial: the 'correctness guarantee' reduces to the filter definition, but the reported fine-tuning improvements are not logically forced by that definition alone.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 0 invented entities

No new physical or mathematical entities are introduced. The knowledge system, toolkit, and validation mechanism are software artifacts composed of standard components (SymPy, numpy, GPT-4), so no speculative entities require evidence.

free parameters (4)
  • fine-tuning sample size = 50,000
    The paper randomly samples 50k instances from each method's training data for fine-tuning. This number is chosen without justification and the results may depend on it (Section 3.1).
  • 10-gram overlap threshold = 10
    Used to filter synthetic data against test sets to prevent leakage. The threshold is fixed by hand and not ablated (Section 2.3).
  • average solutions per program = 6.8
    The pipeline samples multiple solutions per question to scale data; the count is reported only as an average and is not a controlled parameter (Section 2.3).
  • number of mutation rounds k
    Equation for C_M sums over m=1..k iterative refinements, but k is never assigned a value in the text (Section 2.2).
axioms (5)
  • domain assumption The three-tier knowledge system (education stage, subject, topic) is a valid and comprehensive taxonomy of school and college mathematics.
    Used for topic sampling in Section 2.1; if the taxonomy is incomplete or noisy, the diversity and coverage claims fail.
  • domain assumption GPT-4 can reliably generate executable programs and faithful natural-language back-translations from those programs.
    Both LLM_P (program generator) and LLM_G (question generator) are GPT-4; the pipeline's output quality depends on these generations (Sections 2.1, 2.2).
  • domain assumption Program execution output is the correct answer to the back-translated question.
    The bilateral validation treats Interpreter(c) as ground truth; this assumes the program semantics match the intended math problem (Section 2.2).
  • domain assumption A random 50,000-sample subset represents the quality of the full 12.3M corpus.
    All fine-tuning results are on a 50k sample; the 12.3M corpus's benefits are inferred, not measured (Section 3.1).
  • domain assumption GPT-4 semantic-equivalence grading is a valid substitute for exact-answer benchmark evaluation.
    Benchmark scores are produced by GPT-4 comparing solutions to ground truth (Appendix A); if GPT-4 is biased or lenient, the reported gains are inflated.

reviewed 2026-08-05 · how reviews work

0 comments
Cite this review

Pith. "Pith review of Arrows of Math Reasoning Data Synthesis for Large Language Models: Diversity, Complexity and Correctness." pith.science (2026). https://pith.science/paper/52VQHBYQ

@misc{pith2026250818824,
  author       = {Pith},
  title        = {Pith review of: Arrows of Math Reasoning Data Synthesis for Large Language Models: Diversity, Complexity and Correctness},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/52VQHBYQ}},
  note         = {Machine review of arXiv:2508.18824}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Enhancing the mathematical reasoning of large language models (LLMs) demands high-quality training data, yet conventional methods face critical challenges in scalability, cost, and data reliability. To address these limitations, we propose a novel program-assisted synthesis framework that systematically generates a high-quality mathematical corpus with guaranteed diversity, complexity, and correctness. This framework integrates mathematical knowledge systems and domain-specific tools to create executable programs. These programs are then translated into natural language problem-solution pairs and vetted by a bilateral validation mechanism that verifies solution correctness against program outputs and ensures program-problem consistency. We have generated 12.3 million such problem-solving triples. Experiments demonstrate that models fine-tuned on our data significantly improve their inference capabilities, achieving state-of-the-art performance on several benchmark datasets and showcasing the effectiveness of our synthesis approach.

Figures

Figures reproduced from arXiv: 2508.18824 by BinBin Hu, Changxin Tian, Jun Zhou, Kunlong Chen, Sirui Chen, Zhiqiang Zhang, Ziqi Liu.

Figure 1
Figure 1. Figure 1: The pipeline of our approach. We first develop a mathematical knowledge system mapping concepts to tools, then [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 1 Pith paper

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

  1. Ling and Ring 2.6 Technical Report: Efficient and Instant Agentic Intelligence at Trillion-Parameter Scale

    cs.CL 2026-06 unverdicted novelty 4.0

    Technical report announcing Ling-2.6 and Ring-2.6 models with hybrid linear attention, evolutionary CoT, and KPop RL for efficient agentic intelligence at scale.

Reference graph

Works this paper leans on

24 extracted references · 7 canonical work pages · cited by 1 Pith paper

  1. [1]

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Floren- cia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

    Pith/arXiv arXiv 2023

  2. [2]

    Janice Ahn, Rishu Verma, Renze Lou, Di Liu, Rui Zhang, and Wenpeng Yin. 2024. Large language models for mathematical reasoning: Progresses and challenges. arXiv preprint arXiv:2402.00157 (2024)

    Pith/arXiv arXiv 2024

  3. [3]

    Zhangir Azerbayev, Hailey Schoelkopf, Keiran Paster, Marco Dos Santos, Stephen McAleer, Albert Q Jiang, Jia Deng, Stella Biderman, and Sean Welleck

    work page

  4. [4]

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

    Pith/arXiv arXiv 2021

  5. [5]

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

    Pith/arXiv arXiv 2023

  6. [6]

    Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783 (2024)

    Pith/arXiv arXiv 2024

  7. [7]

    Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. 2021. Measuring Mathematical Problem Solving With the MATH Dataset. InProceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks, J. Vanschoren and S. Yeung (Eds.), Vol. 1

    work page 2021

  8. [8]

    Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, De- vendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, Lélio Renard Lavaud, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, and William El Sayed. 2023. Mistral 7B. arXiv:2310.068...

    Pith/arXiv arXiv 2023

  9. [9]

    Aitor Lewkowycz, Anders Andreassen, David Dohan, Ethan Dyer, Henryk Michalewski, Vinay Ramasesh, Ambrose Slone, Cem Anil, Imanol Schlag, Theo Gutman-Solo, et al. 2022. Solving quantitative reasoning problems with language models. Advances in Neural Information Processing Systems 35 (2022), 3843–3857

    2022

  10. [10]

    Zenan Li, Zhi Zhou, Yuan Yao, Yu-Feng Li, Chun Cao, Fan Yang, Xian Zhang, and Xiaoxing Ma. 2025. Neuro-symbolic data generation for math reasoning (NIPS ’24). Curran Associates Inc., Red Hook, NY, USA, Article 740, 28 pages

    work page 2025

  11. [11]

    Pan Lu, Liang Qiu, Wenhao Yu, Sean Welleck, and Kai-Wei Chang. 2022. A survey of deep learning for mathematical reasoning. arXiv preprint arXiv:2212.10535 (2022)

    Pith/arXiv arXiv 2022

  12. [12]

    Zimu Lu, Aojun Zhou, Houxing Ren, Ke Wang, Weikang Shi, Junting Pan, Mingjie Zhan, and Hongsheng Li. 2024. MathGenie: Generating Synthetic Data with Question Back-translation for Enhancing Mathematical Reasoning of LLMs. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) . Bangkok, Thailand

    work page 2024

  13. [13]

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

    Pith/arXiv arXiv 2023

  14. [14]

    Arkil Patel, Satwik Bhattamishra, and Navin Goyal. 2021. Are NLP Models really able to Solve Simple Math Word Problems?. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. Association for Computational Linguistics, On- line

    work page 2021

  15. [15]

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al . 2024. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300 (2024)

    Pith/arXiv arXiv 2024

  16. [16]

    Ling Team, Binwei Zeng, Chao Huang, Chao Zhang, Changxin Tian, Cong Chen, Dingnan Jin, Feng Yu, Feng Zhu, Feng Yuan, et al . 2025. Every FLOP Counts: Scaling a 300B Mixture-of-Experts LING LLM without Premium GPUs. arXiv preprint arXiv:2503.05139 (2025)

    Pith/arXiv arXiv 2025

  17. [17]

    Ke Wang, Houxing Ren, Aojun Zhou, Zimu Lu, Sichun Luo, Weikang Shi, Renrui Zhang, Linqi Song, Mingjie Zhan, and Hongsheng Li. 2023. Mathcoder: Seamless code integration in llms for enhanced mathematical reasoning. arXiv preprint arXiv:2310.03731 (2023)

    Pith/arXiv arXiv 2023

  18. [18]

    Peijie Wang, Zhong-Zhi Li, Fei Yin, Dekang Ran, and Cheng-Lin Liu. 2025. Mv- math: Evaluating multimodal math reasoning in multi-visual contexts. In Pro- ceedings of the Computer Vision and Pattern Recognition Conference . 19541–19551

    work page 2025

  19. [19]

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

    2022

  20. [20]

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

    Pith/arXiv arXiv 2023

  21. [21]

    Xiang Yue, Xingwei Qu, Ge Zhang, Yao Fu, Wenhao Huang, Huan Sun, Yu Su, and Wenhu Chen. 2023. Mammoth: Building math generalist models through hybrid instruction tuning. arXiv preprint arXiv:2309.05653 (2023)

    Pith/arXiv arXiv 2023

  22. [22]

    Wayne Xin Zhao, Kun Zhou, Junyi Li, Tianyi Tang, Xiaolei Wang, Yupeng Hou, Yingqian Min, Beichen Zhang, Junjie Zhang, Zican Dong, et al. 2023. A survey of large language models. arXiv preprint arXiv:2303.18223 1, 2 (2023)

    Pith/arXiv arXiv 2023

  23. [23]

    Kun Zhou, Beichen Zhang, Jiapeng Wang, Zhipeng Chen, Wayne Xin Zhao, Jing Sha, Zhichao Sheng, Shijin Wang, and Ji-Rong Wen. 2024. JiuZhang3.0: Efficiently Improving Mathematical Reasoning by Training Small Data Synthesis Models. In Advances in Neural Information Processing Systems , A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and ...

    work page 2024

  24. [2023]

    arXiv preprint arXiv:2310.10631 (2023)

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

    Pith/arXiv arXiv 2023

This paper was first reviewed by deepseek-v4-flash on August 5, 2026.