acceptodds
Under review as a conference paper at ICLR 2027

RECOMATH: Benchmarking and Improving Self-Correction in Mathematical Reasoning

Abstract

Self-reflection has emerged as a promising approach for improving mathematical reasoning in large language models (LLMs). A central capability of self-reflection is self-correction—the ability of models to identify and recover from errors in their own reasoning. However, existing mathematical reasoning benchmarks primarily evaluate whether models can solve problems from a clean starting point, providing limited insight into whether they can recover once an intermediate reasoning error has occurred. To address this gap, we introduce ReCoMath, a step-level benchmark for evaluating self-correction in mathematical reasoning. Each example pairs a problem with a reasoning prefix ending at the first erroneous step and asks the model to continue the reasoning without being told that the prefix contains an error. Our evaluation across several open-weight LLMs reveals that strong mathematical problem-solving performance does not necessarily translate into reliable self-correction. Using ReCoMath, we conduct a controlled study to isolate the effect of training-trajectory construction, showing that retaining intermediate reflection or repair steps consistently improves self-correction compared with trajectories that omit these processes. Moreover, correct-trace reflection yields more stable gains on easier instances whereas error-retaining repair is stronger on harder ones. Motivated by these findings, we propose Calibrated Reflection Training (CRT), which asymmetrically combines correct-trace reflection with a smaller proportion of error-retaining repair. Across three model backbones, CRT achieves a better overall balance between self-correction and mathematical problem-solving performance than either supervision signal alone. Code, data, and benchmark resources are available at https://anonymous.4open.science/r/RecoMath-4323.

Primary area:
datasets and benchmarks
Keywords:
mathematical reasoning, self-correction, self-reflection, large language models, reasoning benchmarks, error recovery, supervised fine-tuning

Reviews

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

RECOMATH evaluates whether language models can recover after receiving a reasoning prefix that contains an unmarked error. The benchmark combines 2,645 newly generated erroneous trajectories with 2,212 examples derived from ProcessBench. A controlled supervised fine-tuning study compares reflection, repair, and related trajectory constructions. Based on these experiments, the paper proposes Calibrated Reflection Training, which uses an 80:20 mixture of reflection and repair trajectories.

The task formulation is useful because it differs from clean-start solving and from settings where the location of the error is revealed. The experiments suggest that retaining the repair process can improve recovery. However, the reliability of the first-error labels, evaluator specification, contamination analysis, and selection of the 80:20 mixture require stronger validation.

Critical strengths
  1. RECOMATH studies recovery from an erroneous reasoning prefix without revealing either the presence or location of the error. This is meaningfully different from clean-start solving and oracle-hinted correction.

  2. The controlled training comparison uses the same data budget and training recipe across trajectory types. The construction pipeline also combines symbolic checks, model-based verification, and independent teacher solving.

Critical weaknesses
  1. The benchmark depends on model-generated first-error labels, but their accuracy is not directly established. Choosing the wrong step can either leave an earlier error in the prefix or incorrectly mark a valid step, changing the task itself.

  2. The Easy/Hard analysis is confounded by source dataset, error generator, error location, and writing style. The observed difference between reflection and repair cannot be attributed cleanly to mathematical difficulty.

  3. The 80:20 mixture appears to be selected using the same benchmark suite on which CRT is reported. This makes it difficult to distinguish a general training principle from a mixture tuned to the evaluation set. The unspecified LLM evaluator adds further uncertainty to small performance differences.

Questions for authors
  1. How many first-error annotations were manually checked, and what counted as a correct localization?
  2. Was the 80:20 ratio fixed before inspecting the reported benchmark results?
  3. Which model and decision rule were used for final-answer evaluation?
Reviewer_bApBOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The paper introduces a benchmark for evaluating whether LLMs can recover from erroneous intermediate reasoning steps and focuses on mathematical reasoning. Given a problem and a reasoning prefix containing an error, the model must continue solving without being explicitly informed that an error has occurred. And the authors use this benchmark to evaluate final answer accuracy compared to when solving the task from scratch. Based on these findings, they propose a training method which combines correct-trace reflection and error-repair trajectories in an 80:20 ratio and show that it helps on the proposed benchmark

Critical strengths
  • Interesting problem. Evaluating a model’s ability to recover from intermediate reasoning errors is an important direction that is not directly captured by existing mathematical reasoning benchmarks.
  • Useful analysis. The controlled comparison of different training trajectory constructions provides useful insights into the effects of reflection and error-repair supervision. I found the observation that combining different types of supervision can have complementary effects across difficulty levels is interesting.
Critical weaknesses
  • Fairly easy benchmark. The benchmark is largely based o datasets such as GSM8K, MATH, OlympiadBench, and OmniMath. Many of these problems are relatively easy for today’s frontier reasoning models. I do not believe the benchmark is sufficiently challenging to meaningfully evaluate self-correction in stronger models than the ones used in the paper.
  • This is my biggest issue: the benchmark does not adequately evaluate recovery from a model’s own mistakes. It primarily measures whether a model can recover from erroneous prefixes generated by other models. However, the more practically relevant question is whether a model can identify and recover from its own mistakes during reasoning.
  • Limited novelty in benchmark construction. A substantial portion of ReCoMath is adapted from ProcessBench, which already provides step-level error annotations.
  • Limited evaluation of model capabilities. The experiments focus on relatively small and weak models (Llama3.1-8B, Qwen3, and Phi4 -- all under 14B). Also, qwen3-8B already achieves 53.3% recovery accuracy without additional training, suggesting that reasonably capable models can be fairly robust to erroneous prefixes. Evaluating stronger contemporary reasoning models is essential to establish the benchmark’s difficulty and relevance.
  • Limited method novelty. CRT is essentially a fixed mixture of two existing supervision strategies, trained using standard SFT. The proposed 80:20 mixture is relatively simple, and the improvements over individual training strategies are quite marginal. The paper does not introduce a fundamentally new approach to learning "self-correction".
Questions for authors

See weaknesses

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

The paper introduces a benchmark that contains mathematical problems and a solution prefix that contains an error to evaluate model's self-correction ability. The paper also studies how different training data construction affect the model's self-correction behaviour.

Critical strengths

The paper studies an interesting problem, how to evaluate a model's self-correction behaviour, by proposing a benchmark with mathematical problems and erroneous solution prefixes.

Critical weaknesses
  • How the first-error annotation is done is not explained clearly. Around line 202 the paper states they use some pipeline to segment the steps given the trace (here I would imagine the results are something like s1, s2, s3, ... that are segments of the original trace), and then uses a teacher model to identify the first erroneous step; but how is the teacher used, what's the prompt format, is not explained. There can be a few plausible alternatives, e.g. give the whole trace to the teacher and ask for annotation; give the problem and individual steps to the teacher and ask for correctness check; give the problem and prefixes ending at each step and ask the teacher to check... This should be made clear in the paper.
  • The paper mentions human quality checks, but didn't report the quality of the first-error annotation.
  • Section 3.3 makes me confused. The paper introduced a pipeline that creates instances that contain a math problem, and a partial solution that ends at the first error. Then the paper augments these generated instances with another dataset, ProcessBench, that already have most information needed to create such instances? If this is the case, it's unclear what additional value those newly generated instances provide beyond the existing ProcessBench examples.
  • I'm concerned about how many of the instances are actually testing self-correction: take the figure 1 example, the erroneous prefix is not necessarily a mathematical mistake, but more of a different way to understand the problem. And the "erroneous" prefix may not be incorrect, but just resolves the ambiguity in the original question in the way that produces the incorrect answer. This raises the concern of what Figure 3 in the paper is really saying, is the model failing to answer correctly because it follows a mathematical error in the prefix, or is it because the prefix resolves ambiguity in a way that's not entirely unreasonable but is not the problem's intended explanation? This ambiguity issue is documented in previous work [1], so I think more investigation is needed here before confirming that the benchmark tests genuine self-correction behaviour.
  • How are training trajectories in different variants in Table 2 generated/collected? What number of training tokens does each variant have? Do the variants contain trajectories on the same set of problems? (Would there be selection bias if not?) Could the improvement come from more training tokens, instead of the behavioural pattern in the training trajectories?

[1] Truong, Sang, et al. "Fantastic bugs and where to find them in AI benchmarks." Advances in Neural Information Processing Systems 38 (2026).

Questions for authors

Using the size of easy and hard split in Table 1, and reported accuracy on easy and hard split in Table 3, doesn't give the exact number in the "All" column in Table 3?

This formula is used: All=(2380Easy+2477Hard)/4857

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.