acceptodds
Under review as a conference paper at ICLR 2027

Code2Math: Can Your Code Agent Evolve Math Problems Through Exploration?

Abstract

While large language models have achieved remarkable progress in solving mathematical problems, reaching IMO-level performance and tackling research-level tasks, the ability to formulate new and more challenging mathematical problems remains an important yet underexplored capability. This capability is particularly relevant to recursive self-improvement, where models are expected to autonomously expand the scope and difficulty of the tasks they can engage with. Meanwhile, recent code agents provide executable environments for symbolic computation, systematic search, and empirical verification, making them a natural substrate for autonomous mathematical exploration. To this end, we introduce Code2Math, a multi-agent system that leverages code agents to evolve mathematical problems through executable test-time exploration. Our experiments demonstrate that, given sufficient test-time exploration, code agents can synthesize new, solvable problems that are structurally distinct from and more challenging than the originals. Moreover, augmenting the original training data with the corresponding evolved versions of these problems further improves model performance compared with training on the original data alone, demonstrating the practical value of problem evolution for model training. Together, these results demonstrate the potential of code-driven problem evolution as a scalable mechanism for autonomous mathematical exploration and a building block toward self-evolving reasoning systems.

Primary area:
datasets and benchmarks
Keywords:
code agent, data evolution, math reasoning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_PPAsOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

The paper proposes a multi-agent framework, Code2Math, used in taking math problems and making them more challenging. The framework is based on 3 separate agents, one for proposing a new problem, one for verifying that the proposed problem is logical, and one for rating the difficulty of the proposed problem. The resulting dataset of evolved problems is shown to be harder for models to solve, requiring more reasoning tokens. A human study also supports the claims about difficulty. Lastly, 2500 generated problems are used as extra training data in Qwen3-8B and Qwen3-14B to improve scores on AIME24/25/26.

Critical strengths

The paper is well written and easy to understand. The authors thoroughly analyzed their method using humans, a variety of models, analysis on models' answers, and more. The paper's premise of synthesizing useful training data automatically is of great interest to the community.

Critical weaknesses

As far as I understand, the reason for generating harder problems is to eventually used them to train/finetune models. The paper mainly focuses on the problem generation, and only dedicates one section to the finetuning part. I think the finetuning should have played a bigger role, with potentially longer training and more results. In general, the paper explores question complexity in depth, but I'm not convinced that the best way to finetune a model is to augment its data with very complex problems (wouldn't a uniform range of difficulty also make sense?).

Concretely said:

  1. It's hard for me to see where this work stands in relation to prior work, given that lines 125-126 mention effective prior work that also generates math problems but doesn't contrast them with this work.
  2. For Table 2: I think a better baseline would be to ask to create 2500 additional problems without the pipeline, then train on that. What about just having the evolution agent generate problems? How would that fare? It would also be nice to error bars if possible.
  3. I think the evaluation is somewhat weak: 1) no other data augmentation methods are shown, and, the evaluation set is AIME24/25/26, which somewhat overlaps with the initial seed problem set. Additionally evaluating on Omni-MATH [1] or a similar benchmark would be very helpful.

Minor: Table 1 - the table is too small, with the font being very hard to read even when zoomed in. A re-organization of the table, even at the cost of removing some information, would be helpful to legibility. In Figure 3, is the y axis (density) equal to the number of problems? Figure 4's text is somewhat small and hard to read

[1] Gao, Bofei, et al. "Omni-math: A universal olympiad level mathematic benchmark for large language models." International Conference on Learning Representations. Vol. 2025. 2025.

Questions for authors
  1. How does Math2Code's augmentation compare to previous methods that generate evolutions/pertubations of data? How does using other methods vs Math2Code compare when finetuning a model on the extra data?
  2. How would a baseline of just asking a language model to generate more data (in an agentic setting, where the model can take a few steps, use code) fare against Math2Code?
  3. Would it be possible to show evaluations on math datasets that are disjoint from AIME24/25/26?
9 comments
AuthorsOpenReview ↗

Response 1

We sincerely thank the reviewer for the positive assessment of our work and the thoughtful, constructive feedback. We have carefully considered each of the reviewer's concerns and conducted extensive additional experiments and analyses, including comparisons with existing problem generation methods, an investigation of the role of verification, extended downstream training experiments, and a systematic data contamination audit. We hope these additional results and clarifications will help address the reviewer's concerns and further strengthen the evidence supporting our contributions. We also appreciate the suggestions regarding presentation and readability, and will improve the formatting and legibility of Table 1, Figure 3, and Figure 4 in the revised version.

Note on Reproduced Experiments. Due to an unexpected issue that rendered our original experimental environment unrecoverable, we had to reconstruct the environment and rerun several experiments during the rebuttal period. Consequently, some numerical results in our responses may differ slightly from those reported in the original submission. We have carefully checked the newly obtained results and ensured that comparisons within each additional experiment use consistent experimental settings.

W1: Novelty and Comparison with Prior Work

We thank the reviewer for raising this important concern. We would like to clarify that the key distinction between Code2Math and prior mathematical problem generation methods lies in how new mathematical problems are discovered and constructed.

Rather than relying primarily on direct LLM generation or predefined mutation strategies, Code2Math enables agents to actively explore mathematical structures through executable computation, including symbolic manipulation, combinatorial search, numerical experimentation, and counterexample discovery. The generated problems are further filtered through dedicated solvability and difficulty verification. Our central contribution is therefore to investigate code-driven mathematical exploration as a mechanism for constructing valid and challenging problems.

To further establish the effectiveness of our approach, we conducted additional experiments with two baselines:

  1. Few-shot Generation, which directly generates new mathematical problems from few-shot demonstrations.
  2. DéjàQ-inspired Symbolic Mutation [1], based on the third mutation strategy proposed in DéjàQ. DéjàQ introduces three LLM-guided mutators: Setting Mutation (changing problem contexts), Distractor Mutation (adding irrelevant information), and Symbolic Mutation (modifying the underlying mathematical structure). We adopt the Symbolic Mutator, which prompts an LLM to modify the mathematical reasoning required by an existing problem and regenerate its corresponding step-by-step solution. Unlike the full DéjàQ framework, our baseline isolates this mutation strategy without its online RL training and archive-based selection.

We reran the downstream SFT experiments using Qwen3-14B-Base under identical training configurations and report results at the same checkpoint (epoch 8). Since these are new training runs, the absolute results differ slightly from those reported in the original submission.

Table: Downstream SFT performance (Avg@10, %) on AIME benchmarks.

Training DataAIME24AIME25AIME26Average
Original61.0047.6753.6754.11
+ Few-shot55.6745.3349.6750.22
+ DéjàQ-Symbolic60.0047.3355.3354.22
+ Code2Math65.6755.3356.3359.11

Code2Math consistently outperforms both Few-shot Generation and DéjàQ-inspired Symbolic Mutation across all three AIME benchmarks. This advantage is maintained throughout all eight training epochs, including when comparing the best observed checkpoint of each method. Interestingly, while the two baselines occasionally outperform Original at intermediate epochs, their best observed results offer little or no improvement over Original. In contrast, Code2Math achieves a clear and consistent improvement, suggesting that simply generating more problems, even through structural mutation, does not necessarily provide substantial training benefits. These findings support the effectiveness of Code2Math in generating more valuable mathematical reasoning data through executable exploration and dual verification.

(Continued in the next comment below...)

AuthorsOpenReview ↗

Response 2

(Continued from the previous comment)

W2/Q2: Evolution-Agent-Only Baseline and the Role of Verification

We thank the reviewer for this valuable suggestion. We agree that an Evolution-Agent-only baseline would be useful for further isolating the contribution of our verification components.

While we have not conducted this exact ablation, our existing results in Table 3 and Figure 4 already provide empirical evidence for the importance of verification.

Specifically, Figure 4 analyzes the distribution of generation failures across 100 seed problems for each evolution model. Based on these results, we summarize the first-attempt rejection rates and the frequency of different verification failures below.

Table: Generation failure statistics derived from Figure 4 (% of 100 seed problems).

Evolution ModelFirst-Attempt RejectionAt Least One Solvability FailureAt Least One Difficulty Failure
DeepSeek-Chat67%58%41%
DeepSeek-Reasoner70%58%40%
Gemini-3-Pro-Thinking42%24%34%

Note: The first column measures the proportion of problems whose first generation attempt fails the overall verification process. The other two columns measure whether at least one corresponding verification failure occurs during the entire evolution process; they are not first-attempt failure rates and are not mutually exclusive.

These results reveal that 42–70% of initial generations fail to satisfy our verification criteria, even when using capable evolution models. Moreover, both solvability and difficulty failures occur frequently, indicating that these two verification mechanisms address distinct challenges in mathematical problem evolution.

Table 3 further supports this observation. For example, DeepSeek-Chat encounters an average of 4.11 failed attempts before successful evolution, including 2.65 solvability failures and 1.46 difficulty failures. Other models exhibit similar patterns, although the dominant failure type varies across models.

These findings provide empirical motivation for our dual-verification design. Without the verification components, candidates that fail mathematical validity or difficulty requirements would not be systematically identified and filtered. Therefore, verification plays an important role in controlling the quality of the generated problems.

We acknowledge that these analyses do not fully replace a controlled Evolution-Agent-only downstream SFT experiment. Unfortunately, due to the limited computational resources available to us and the short rebuttal period, we are unable to complete this additional experiment. Nevertheless, we hope that the existing failure analysis, together with our newly added comparisons against Few-shot Generation and DéjàQ-inspired Symbolic Mutation, provides meaningful evidence supporting the motivation and effectiveness of the overall Code2Math framework.

W3/Q3: Evaluation Benchmarks and Data Contamination

We thank the reviewer for these concerns. We clarify the dataset distinction, provide additional contamination analysis, and explain our benchmark selection.

1. Clarification of the Two Datasets.

As described in Section 3.1, Code2Math uses two separate datasets:

  • 100 seed problems are used exclusively to evaluate problem evolution quality, including solvability, difficulty improvement, and exploration efficiency.
  • Approximately 2,500 training problems are independently collected to construct the Original and Original + Evolved datasets for downstream SFT.

Although some evaluation seeds originate from AIME24/25, they are not used for downstream SFT. Thus, their overlap with AIME does not imply contamination of the downstream training experiments.

2. Additional Data Contamination Audit.

During the rebuttal period, we conducted a multi-stage contamination audit comparing 2,560 original training problems against all 90 AIME24/25/26 evaluation problems (230,400 pairs).

The audit included exact matching (raw text, normalized mathematical tokens, and alphanumeric text), similarity retrieval (TF-IDF, character n-grams, and token shingles), number-masked matching, and format-independent retrieval. High-similarity candidates were further inspected for mathematical equivalence, including problem objects, constraints, and objectives.

The results are summarized below.

Table: Data contamination audit against AIME24/25/26.

Audit StageCoverageFindings
Exact matching (3 methods)230,400 problem pairs0 matches
Multi-view similarity retrieval1,167 candidate pairsHigh-similarity candidates identified
Detailed candidate inspection94 selected high-similarity pairs0 confirmed direct duplicates or clear trivial variants
AIME24 / AIME25 / AIME2638 / 33 / 23 inspected pairs0 confirmed duplicates in each year

(Continued in the next comment below...)

AuthorsOpenReview ↗

Response 3

(Continued from the previous comment)

No direct duplicates or clear trivial variants were identified. We also preserved the audit procedures, candidate-level rationales, source-file hashes, and artifacts for reproducibility. While this provides evidence against direct problem-level contamination, it does not establish complete semantic non-overlap or cover evolved problems and model pretraining data.

3. Sufficiency of AIME Evaluation and Omni-MATH.

Our evaluation covers AIME24/25/26 with Avg@10, providing repeated measurements across three competition years. The models also exhibit non-saturated performance, making these benchmarks suitable for assessing downstream improvements.

We appreciate the suggestion to include Omni-MATH. However, its substantially larger size and difficulty would require approximately 49× the evaluation workload under our Avg@10 protocol, exceeding our available rebuttal-period computational budget.

While broader benchmark coverage would strengthen generalization claims, we believe the three-year AIME evaluation, together with the additional contamination audit, provides meaningful evidence of Code2Math's downstream training effectiveness.

W4: Problem Difficulty and Downstream Training

We thank the reviewer for this thoughtful comment. We would like to clarify that the primary objective of Code2Math is not to investigate the optimal difficulty distribution or training strategy for mathematical reasoning models. Rather, our work studies whether code agents can autonomously explore mathematical structures and construct valid, increasingly challenging problems.

We believe that the ability to discover and formulate harder mathematical problems is itself an important capability of mathematical reasoning agents, independently of their downstream training utility. This is why our paper places substantial emphasis on evaluating problem validity, difficulty improvement, and the exploration process. Downstream SFT experiments serve as additional evidence that the evolved problems can provide useful training signals.

Regarding the reviewer's suggestion of using a broader or more uniform difficulty distribution, we agree that training exclusively on highly difficult problems may not be optimal. However, our experiments use Original + Evolved rather than Evolved Only. This setting preserves the original problems while incorporating more challenging evolved versions, thereby expanding the difficulty range of the training data and providing a coarse-grained difficulty spectrum.

Importantly, we do not claim that our approach produces an optimal difficulty distribution, nor that harder problems are universally better for training. Investigating optimal data selection and curriculum learning strategies is an interesting but distinct research direction.

Additional evidence from extended training. To further investigate downstream training utility, we extended our Qwen3-14B experiments to 12 epochs. Under equal training-example exposure (Original at epoch 12 versus Original + Evolved at epoch 6), Code2Math achieves an average accuracy of 57.78%, compared with 56.00% for Original. Furthermore, the best observed average accuracy reaches 59.56% for Original + Evolved (epoch 9), compared with 56.00% for Original (epoch 12).

These additional results suggest that evolved problems provide useful training signals even when controlling for the number of training examples processed, and that their benefits are not restricted to the original six-epoch evaluation.

Overall, our central contribution is to investigate autonomous mathematical problem evolution through executable exploration, rather than to establish an optimal mathematical reasoning training strategy. The downstream training results complement this contribution by demonstrating that the generated problems are not only more challenging but also practically useful for improving mathematical reasoning performance.

[1] Röpke et al., 2026. DéjàQ: Open-Ended Evolution of Diverse, Learnable and Verifiable Problems. https://arxiv.org/abs/2601.01931

Reviewer_RwhPOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The problem setup is as follows:

  • You have a set of training questions and solutions
  • You wish to SFT a model on those questions and solutions to improve performance on a downstream set of held out questions

The authors propose to augment the training dataset by mutating and evolving existing problems.

They do this via a series of prompted agents that can do multiple actions like writing code etc before producing a new problem and solution.

The authors show on a small set of 100 problems that their agents mutate problems that a) empirically remain solvable to larger models and increase in difficulty b) align with human notions of difficulty

They then show that training on these problems increases performance more than training on the original dataset.

Critical strengths
  • The paper is extremely clear, which is rare in the age of AI and the authors should be commended for producing such a well written paper.
  • The problem setting of synthetic data generation is extremely relevant
  • The experiments are well thought out, it is nice to have the human and empirical studies
  • The authors agents do appear to be able to generate new and more difficult problems
  • The analysis of difficulty by response length is interesting and a good empirical alternative to just looking at solve rate
  • The improvements on training are modest but positive, across 2 different model sizes and 3, albeit similar, eval datasets.
Critical weaknesses

To quote the authors there is much prior work on math data evolution and "while effective, these methods make limited use of agentic exploration and may lack systematic evaluation of generated problem quality". I agree with this, however I do not believe that the authors address this point. There is no evidence presented to show that agentic exploration is more beneficial than existing methods. Additionally, whilst the authors do a systematic evaluation of problem quality, it is only for their generated questions. I therefore have concerns about novelty.

I also have concerns about the soundness of their claims. They claim this is useful for Recursive Self Improvement, however for the training examples, they use a larger model (GLM-5.3-Flash) to produce the questions for the smaller Qwen models. Furthermore, there is no comparison to just simple distillation from the larger model to Qwen. Other baselines and existing work are not compared to empirically.

Additionally, they are not clear about the comparison of their datasets being a larger size and whether they run it for more steps. They just say "6 epochs". I would expect both datapoint count normalised and epoch normalised results.

Questions for authors

Thank you writing such a well-written and clear paper. Whilst I do have concerns, these can be addressed via the baselines of comparing to existing, non agentic methods, and either using the Qwen model to mutate the questions for itself, or comparing to distillation from GLM.

Also you should consider putting this in related work as it is relevant and a missed citation https://arxiv.org/abs/2601.01931

5 comments
AuthorsOpenReview ↗

Response 1

We sincerely thank the reviewer for the positive assessment of our work and the thoughtful, constructive feedback. We have carefully considered each of the reviewer's concerns and conducted additional experiments and analyses to address them, including comparisons with existing problem generation methods, an investigation of same-scale self-improvement, and training budget normalization. We hope these additional results and clarifications adequately address the reviewer's concerns and further strengthen the contributions of our work.

Note. Due to an unexpected loss of our original experimental environment, we reran several experiments. Some results may therefore differ slightly from the submission, but all new comparisons use consistent settings.

W1: Novelty and Comparison with Existing Methods

We sincerely thank the reviewer for recognizing the value of our work and for the constructive suggestions. We agree that empirical comparisons with existing non-agentic methods are important for establishing the effectiveness of Code2Math.

To address this concern, we conducted additional experiments with two baselines:

  1. Few-shot Generation, which directly generates new mathematical problems from demonstrations.
  2. DéjàQ-inspired Symbolic Mutation [1] (Röpke et al., 2026, as recommended by the reviewer), which prompts an LLM to modify the underlying mathematical structure of an existing problem and regenerate its corresponding step-by-step solution.

For a fair comparison, we reran the SFT experiments with Qwen3-14B-Base for all four settings, including Original and Code2Math, using identical downstream SFT configurations. We report the same checkpoint (epoch 8) for all methods. Since these are new training runs, the absolute results differ slightly from those reported in the original submission.

Table 1: Downstream SFT performance (Avg@10, %) on AIME benchmarks.

Training DataAIME24AIME25AIME26Average
Original61.0047.6753.6754.11
+ Few-shot55.6745.3349.6750.22
+ DéjàQ-Symbolic60.0047.3355.3354.22
+ Code2Math65.6755.3356.3359.11

Code2Math consistently outperforms both Few-shot Generation and DéjàQ-inspired Symbolic Mutation across all three AIME benchmarks. This advantage is maintained throughout all eight training epochs, including when comparing the best observed checkpoint of each method. Interestingly, while the two baselines occasionally outperform Original at intermediate epochs, their best observed results offer little or no improvement over Original. In contrast, Code2Math achieves a clear and consistent improvement, suggesting that simply generating more problems, even through structural mutation, does not necessarily provide substantial training benefits. These findings support the effectiveness of Code2Math in generating more valuable mathematical reasoning data through executable exploration and dual verification.

We also thank the reviewer for pointing out DéjàQ and will include this work in our Related Work section.

W2: Recursive Self-Improvement

We sincerely thank the reviewer for raising this important concern regarding recursive self-improvement (RSI). We agree that the ultimate goal of RSI is to enable a model to continuously improve its own capabilities without relying on stronger external models.

Meanwhile, recent RSI research has also explored cross-model improvement settings. For example, RSIBench-Data [2] employs frontier LLM agents to design training data and improve a separate target model. DataFoundry [3] investigates the recursive evolution of data-generation pipelines using powerful LLMs, with the resulting data used to train smaller models. Similarly, Recursive Harness Self-Improvement [4] uses frontier models to evolve reasoning-data synthesis procedures and evaluates the generated data through downstream training of smaller student models.

These works suggest that cross-model improvement is a meaningful research setting for studying components of RSI, even though it does not by itself constitute fully autonomous self-improvement.

(Continued in the next comment below...)

AuthorsOpenReview ↗

Response 2

(Continued from the previous comment)

Our research position is consistent with this distinction. We do not claim that Code2Math has achieved RSI. Rather, as stated in our Introduction and Limitations, our work focuses on an important enabling capability for RSI: autonomously generating increasingly challenging, valid mathematical problems that can provide useful training signals. A fully closed-loop RSI system would additionally require models to learn from these problems and use their improved capabilities to drive subsequent rounds of evolution.

Due to computational and resource constraints, we cannot conduct repeated self-improvement cycles involving the training of frontier-scale models. Instead, we study this problem using relatively smaller models for downstream training, as a practical step toward understanding the feasibility of such systems.

Evidence from the original experiments. Importantly, Table 1 already provides an interesting observation relevant to this direction: strong models can generate mathematical problems that they themselves struggle to solve. For example, when DeepSeek-Reasoner serves as the evolution backbone, the resulting problems achieve a 94/98 external solvability certification rate, while DeepSeek-Reasoner itself solves only 36% of these certified evolved problems in a separate solver evaluation. This suggests that code-driven problem construction can produce valid challenges beyond what the same underlying model can reliably solve, highlighting a promising capability for future self-improvement systems.

Additional Same-Scale Evolution Experiment.

Following the reviewer's suggestion, we conducted an additional experiment to investigate whether Code2Math can produce useful training data without relying on a substantially larger evolution backbone.

Specifically, we use an instruction-following variant of Qwen3-14B for problem evolution and Qwen3-14B-Base for downstream SFT. We adopt the instruction-following variant because the Base model is not sufficiently instruction-following to reliably execute the complex agentic workflow required for mathematical problem evolution. This represents a same-parameter-scale setting, although the evolution and training models are not identical checkpoints.

We evaluate the resulting SFT checkpoints on AIME24, AIME25, and AIME26 using Avg@10. The results are summarized below.

Table: Downstream performance with Qwen3-14B-scale problem evolution (Avg@10, %).

Training SettingEpochAIME24AIME25AIME26Average
Original-only (Best)1262.0047.3358.6756.00
Qwen3-14B Evolution130.0030.3331.0030.44
Qwen3-14B Evolution253.0044.6745.6747.78
Qwen3-14B Evolution351.6743.0042.0045.56
Qwen3-14B Evolution (Best)454.6750.0055.6753.44
Qwen3-14B Evolution555.6743.0051.0049.89
Qwen3-14B Evolution657.6744.6754.6752.33
Qwen3-14B Evolution756.3347.6754.0052.67
Qwen3-14B Evolution858.0041.3353.0050.78

Results and observations. The results are mixed. The best average accuracy achieved with Qwen3-14B evolution is 53.44%, compared with 56.00% for Original-only. Therefore, we acknowledge that this experiment does not establish successful self-improvement at this model scale.

Nevertheless, we observe several encouraging findings.

First, on AIME25, the Qwen3-14B evolution setting achieves 50.00% accuracy, exceeding the best observed Original-only performance of 47.33% on this benchmark (+2.67 points). Although AIME24 and AIME26 do not show corresponding improvements over their Original-only best checkpoints, the AIME25 result indicates that useful training signals can still emerge from same-scale problem evolution.

Through further case studies, we identify two recurring limitations of Qwen3-14B: (1) it often fails to effectively leverage code execution for mathematical exploration and the discovery of new problem structures, and (2) it frequently misjudges whether an evolved problem is genuinely more challenging than the original. These observations suggest that both agentic exploration and difficulty assessment remain challenging for models at this scale.

(Continued in the next comment below...)

AuthorsOpenReview ↗

Response 3

(Continued from the previous comment)

W3: Training Budget and Data Size Normalization

We thank the reviewer for highlighting the importance of controlling training budgets. We agree that using the same number of epochs does not necessarily ensure equal optimization steps when the training datasets differ in size.

To address this concern, we extended our Qwen3-14B training experiments to 12 epochs and examined both equal-epoch and equal-sample-exposure comparisons. The equal-epoch results are reported in Table 1 above, while the following table presents the sample-exposure-normalized comparison and the best observed checkpoints during extended training.

Table 2: Downstream performance under different training budgets (Avg@10, %).

ComparisonTraining DataEpochAIME24AIME25AIME26Average
Equal Sample ExposureOriginal1262.0047.3358.6756.00
Original + Evolved665.3352.3355.6757.78
Improvement+3.33+5.00-3.00+1.78
Best Observed CheckpointOriginal1262.0047.3358.6756.00
Original + Evolved969.0051.0058.6759.56
Improvement+7.00+3.67+0.00+3.56

Equal Training Sample Exposure. Since the augmented dataset contains twice as many training examples as the original dataset, training Original for 12 epochs and Original + Evolved for 6 epochs results in the same number of training-example exposures. This controls the total number of examples processed, rather than merely matching the number of epochs.

Under this setting, Code2Math still achieves a higher average accuracy (57.78% vs. 56.00%), with improvements on AIME24 (+3.33) and AIME25 (+5.00), despite a decrease on AIME26 (-3.00). This provides additional evidence that the benefits of Code2Math cannot be explained solely by a larger number of training-example exposures.

Performance with Extended Training. We further examine the best observed checkpoints across 12 training epochs. Code2Math achieves a higher average accuracy of 59.56% (epoch 9), compared with 56.00% (epoch 12) for Original. The improvements are particularly evident on AIME24 (+7.00) and AIME25 (+3.67), while performance on AIME26 is comparable.

These observations suggest that Code2Math-generated problems provide useful additional training signals and can achieve a higher observed downstream performance ceiling, beyond the gains attributable to additional training-example exposure.

[1] Röpke et al., 2026. DéjàQ: Open-Ended Evolution of Diverse, Learnable and Verifiable Problems. https://arxiv.org/abs/2601.01931

[2] Meng et al., 2026. RSIBench-Data: Benchmarking Data-Centric Research for Recursive Self-Improvement. https://arxiv.org/abs/2607.25886

[3] Yang et al., 2026. DataFoundry: Evolving Data Preparators via Recursive Self-Improvement. https://arxiv.org/abs/2608.29966

[4] Zhang et al., 2026. Recursive Harness Self-Improvement for Frontier Reasoning Data Synthesis. https://arxiv.org/abs/2610.03548

Reviewer_piHZOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper expands a set of math problems into a larger set of math problems that are more difficult to solve, using a framework of agents, with an evolution agent proposing new problems, a solvability verification agent making sure the problems are valid, and a difficulty verification agent pruning out easy problems that are not different or more challenging. This larger dataset of math problems is shown to be helpful in finetuning LLMs like Qwen3-8B and Qwen3-14B to solve problems, compared to just using the original set of problems.

Critical strengths

The ability to generate more problem-solving training data to fine tune on is an important & useful task for helping advance the state of the art in LLM reasoning ability. This paper proposes a reasonable approach to do that and shows the additional data helps in fine-tuning models. The Code2Math approach does an innovative and rigorous approach to verify the new problems are more difficult conceptually and valid, and also proposes a robust approach that evaluates the new problems on their difficulty. Human review and downstream finetuning experiments show the problems generated are of high quality and useful.

Critical weaknesses

1> The Code2Math approach is shown to work and is interesting - but does it work better than other approaches, say a simple straw-man approach? In ICLR 2023 https://arxiv.org/abs/2207.14502 "Language Models can teach themselves to program better", very simple additional problem generation approaches like few shot generation were shown to work. For the same computational budget would I be better off to generate a lot more new problem data in a simple manner? 2> Ideally a method like this could push the "frontier" models to do better. But frontier models are used to help generate new problems and decide which problems are solvable - it's not clear if your approach is just channeling knowledge from the bigger smarter LLMs used to the smaller LLMs being finetuned. In the https://arxiv.org/abs/2207.14502 paper they showed their primitive approach "pushed" the frontier of the models reasoning ability by using the smaller model that was being fine-tuned also as the LLM to propose and verify new problems, arguing that showed if their approach was applied to the frontier models - it would advance the frontier (which they could not do due to lack of access and lack of GPU - just like you) - but at least it was a conceptual proof their approach was genuinely pushing the frontier forward, and not just channeling big LLM smarts into small LLMs, not just distilling in some complex manner.

Questions for authors

1> Can you evaluate against a simpler straw-man (like few shot generation) and show this approach wins? Maybe don't worry about GPU usage, but at least in quality of problems generated - same number of new problems from straw-man versus your Code2Math approach, when used downstream for finetuning. 2> Can you do a run just using only Qwen3-8B? And a run using only Qwen3-14B? Choose any model where it is the proposer, verifier, everything so we see this approach advances LLM performance, not just distills/channels smarts from bigger LLM to the smaller LLM? https://arxiv.org/abs/2207.14502 did something like that - which is proof of concept that this could advance the frontier (if you had access to the GPUs and frontier model training code & data to augment with more data your approach generates.

4 comments
AuthorsOpenReview ↗

Response 1

We sincerely thank the reviewer for the positive assessment of our work and the valuable, constructive feedback. We have carefully addressed each of the reviewer's major concerns through additional experiments and analyses, and we hope that these new results will satisfactorily resolve the concerns and further strengthen the evidence supporting our contributions.

W1/Q1: Comparison with Simpler Problem Generation Baselines

Thank you for this valuable suggestion. To better assess the effectiveness of Code2Math, we conducted additional experiments with two baselines:

  1. Few-shot Generation (recommended by you), which directly generates new mathematical problems from demonstrations.
  2. DéjàQ-inspired Symbolic Mutation [1](recommended by another reviewer), which prompts an LLM to modify the underlying mathematical structure of an existing problem and regenerate its corresponding step-by-step solution.

For a fair comparison, we reran the SFT experiments with Qwen3-14B-base model for all four settings, including Original and Code2Math, and evaluated them using the same training configuration and final checkpoint (epoch 8). All methods use identical downstream SFT configurations.

Table: Downstream SFT performance (Avg@10, %) on AIME benchmarks.

Training DataAIME24AIME25AIME26Average
Original61.0047.6753.6754.11
+ Few-shot55.6745.3349.6750.22
+ DéjàQ-Symbolic60.0047.3355.3354.22
+ Code2Math65.6755.3356.3359.11

Code2Math consistently outperforms both Few-shot Generation and DéjàQ-inspired Symbolic Mutation across all three AIME benchmarks. This advantage is maintained throughout all eight training epochs, including when comparing the best observed checkpoint of each method. Interestingly, while the two baselines occasionally outperform Original at intermediate epochs, their best observed results offer little or no improvement over Original. In contrast, Code2Math achieves a clear and consistent improvement, suggesting that simply generating more problems, even through structural mutation, does not necessarily provide substantial training benefits. These findings support the effectiveness of Code2Math in generating more valuable mathematical reasoning data through executable exploration and dual verification.

W2/Q2: Toward Recursive Self-Improvement

We sincerely thank the reviewer for this insightful suggestion regarding recursive self-improvement (RSI). We agree that the ultimate goal of RSI is to enable a model to continuously improve its own capabilities without relying on stronger external models.

Meanwhile, recent RSI research has also explored cross-model improvement settings. For example, RSIBench-Data [2] employs frontier LLM agents to design training data and improve a separate target model. DataFoundry [3] investigates the recursive evolution of data-generation pipelines using powerful LLMs, with the resulting data used to train smaller models. Similarly, Recursive Harness Self-Improvement [4] uses frontier models to evolve reasoning-data synthesis procedures and evaluates the generated data through downstream training of smaller student models.

These works suggest that cross-model improvement is a meaningful research setting for studying components of RSI, even though it does not by itself constitute fully autonomous self-improvement.

Our research position is consistent with this distinction. We do not claim that Code2Math has achieved RSI. Rather, as stated in our Introduction and Limitations, our work focuses on an important enabling capability for RSI: autonomously generating increasingly challenging, valid mathematical problems that can provide useful training signals. A fully closed-loop RSI system would additionally require models to learn from these problems and use their improved capabilities to drive subsequent rounds of evolution.

Due to computational and resource constraints, we cannot conduct repeated self-improvement cycles involving the training of frontier-scale models. Instead, we study this problem using relatively smaller models for downstream training, as a practical step toward understanding the feasibility of such systems.

(Continued in the next comment below...)

AuthorsOpenReview ↗

Response 2

(Continued from the previous comment)

Evidence from the original experiments. Importantly, Table 1 already provides an interesting observation relevant to this direction: strong models can generate mathematical problems that they themselves struggle to solve. For example, when DeepSeek-Reasoner serves as the evolution backbone, the resulting problems achieve a 94/98 external solvability certification rate, while DeepSeek-Reasoner itself solves only 36% of these certified evolved problems in a separate solver evaluation. This suggests that code-driven problem construction can produce valid challenges beyond what the same underlying model can reliably solve, highlighting a promising capability for future self-improvement systems.

Additional Same-Scale Evolution Experiment.

Following the reviewer's suggestion, we conducted an additional experiment to investigate whether Code2Math can produce useful training data without relying on a substantially larger evolution backbone.

Specifically, we use an instruction-following variant of Qwen3-14B for problem evolution and Qwen3-14B-Base for downstream SFT. We adopt the instruction-following variant because the Base model is not sufficiently instruction-following to reliably execute the complex agentic workflow required for mathematical problem evolution. This represents a same-parameter-scale setting, although the evolution and training models are not identical checkpoints.

We evaluate the resulting SFT checkpoints on AIME24, AIME25, and AIME26 using Avg@10. The results are summarized below.

Table: Downstream performance with Qwen3-14B-scale problem evolution (Avg@10, %).

Training SettingEpochAIME24AIME25AIME26Average
Original-only (Best)1262.0047.3358.6756.00
Qwen3-14B Evolution130.0030.3331.0030.44
Qwen3-14B Evolution253.0044.6745.6747.78
Qwen3-14B Evolution351.6743.0042.0045.56
Qwen3-14B Evolution (Best)454.6750.0055.6753.44
Qwen3-14B Evolution555.6743.0051.0049.89
Qwen3-14B Evolution657.6744.6754.6752.33
Qwen3-14B Evolution756.3347.6754.0052.67
Qwen3-14B Evolution858.0041.3353.0050.78

Results and observations. The results are mixed. The best average accuracy achieved with Qwen3-14B evolution is 53.44%, compared with 56.00% for Original-only. Therefore, we acknowledge that this experiment does not establish successful self-improvement at this model scale.

Nevertheless, we observe several encouraging findings.

First, on AIME25, the Qwen3-14B evolution setting achieves 50.00% accuracy, exceeding the best observed Original-only performance of 47.33% on this benchmark (+2.67 points). Although AIME24 and AIME26 do not show corresponding improvements over their Original-only best checkpoints, the AIME25 result indicates that useful training signals can still emerge from same-scale problem evolution.

Through further case studies, we identify two recurring limitations of Qwen3-14B: (1) it often fails to effectively leverage code execution for mathematical exploration and the discovery of new problem structures, and (2) it frequently misjudges whether an evolved problem is genuinely more challenging than the original. These observations suggest that both agentic exploration and difficulty assessment remain challenging for models at this scale.

[1] DéjàQ: Open-Ended Evolution of Diverse, Learnable and Verifiable Problems, arxiv 2601.01931

[2] RSIBench-Data: Benchmarking Data-Centric Research for Recursive Self-Improvement, arxiv 2607.25886

[3] DataFoundry: Evolving Data Preparators via Recursive Self-Improvement, arxiv 2608.29966

[4] Recursive Harness Self-Improvement for Frontier Reasoning Data Synthesis, arxiv 2610.03548

Dear Reviewer piHZ,

As the rebuttal period is approaching its end, we would like to kindly follow up and ask whether our responses have adequately addressed your concerns.

We would greatly appreciate any further feedback, and please feel free to raise any additional questions or concerns. We would be happy to clarify them.

Thank you again for your time and constructive feedback.

Best regards,
Submission 27946 Authors

Thanks for the answers - I think a lot of hard work has been done to produce this paper.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Rebuttal Responses and Manuscript Updates

Dear Reviewers,

We sincerely thank all reviewers for their constructive feedback and valuable suggestions.

We have carefully addressed the reviewers' comments in our rebuttal responses and accordingly revised the manuscript, including both the main text and the appendix, to incorporate additional experiments, analyses, and clarifications.

We warmly welcome the reviewers to examine the updated manuscript and would be happy to engage in further discussion or address any remaining questions.

Thank you again for your time and consideration.

Submission 27946 Authors

Dear Reviewers,

If you have not already done so, please take a moment to review the authors' responses and participate in the discussion, particularly if you have any outstanding questions or concerns. We also encourage you to update your assessments, if appropriate, in light of the authors' responses and the ongoing discussion.

Your feedback is greatly appreciated and will be valuable in helping us reach a fair and well-informed final decision.

Thank you for your time and contributions!

Best regards, AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.