SIGMA: Refining Large Language Model Reasoning via Sibling-Guided Monte Carlo Augmentation

We appreciate the reviewer for the thoughtful feedback，recognizing (i) The proposed method is intuitive and well motivated, automated and scalable (ii) contribution in improving sample efficiency.We've addressed your concerns below.

The synthesis cost of SIGMA is not discussed...

We appreciate the reviewer’s concern regarding the synthesis cost of SIGMA. As a data-efficient method, maintaining low synthesis cost and computation cost is central to its practicality and effectiveness.

SIGMA does not require any additional model training during the data synthesis phase. We use Qwen-2.5-Math-7B for original MCTS generation,which is a publicly available pretrained models from HuggingFace. Following the MCTS data generation procedure of AlphaMath [6], using Qwen-2.5-Math-7B to generate full MCTS trees for a 15K dataset requires ~42 GPU hours on RTX 4090.

For the refinement phase, we use GPT-4o-mini to process the 15K MCTS trees.The total prompt token count is 33.6M and the total completion token count is 11.42M, resulting in a total cost of 11.7 USD.Processing 60K MCTS on GPT-4o-mini costs 47.6 USD.Detailed comparison for synthesis cost are listed below. The GPU price data are from vast​.​ai.

Compared to alternative data generation pipelines, SIGMA offers a competitive balance of low computational cost, high data efficiency, and improved overall accuracy. We will include detailed computational cost analysis in the camera-ready version.Moreover, thanks to the flexibility of the SIGMA framework, we can also substitute the proprietary GPT‑4o‑mini with an open‑source 7B model, reducing costs by over 30% while incurring only a 4.6% drop in performance.

The total tokens in the SIGMA dataset is unclear...

We appreciate the reviewer’s detailed concern for computational cost for training that dives into token-level.

To support the claim of SIGMA’s data efficiency, we report the total number of tokens used in SIGMA-15K, SIGMA-60K, and other baseline datasets, all measured using the LLaMA3-8B tokenizer. SIGMA-15K contains 11.5M tokens,It is worth noting that, with a comparable number of tokens per question, DeepSeek-7B-SIGMA (15K) outperforms MathFusion trained on 30K examples. while SIGMA-60K contains 44M tokens, which is roughly comparable to the token count of MathFusion’s 60K dataset, SIGMA achieves state-of-the-art performance, highlighting its efficiency in data usage.

Moreover, the low cost of data synthesis in SIGMA makes it scalable to larger datasets without prohibitive resource demands. We will include detailed token statistics in the camera-ready version.

Only GPT-4o-mini is explored as $C_{LLM}$ and $R_{LLM}$.

Thank you for the insightful question. For the $C_{LLM}$ and $R_{LLM}$, GPT-4o-mini was chosen as a cost-effective option. However, our method does not fully rely on closed-source models. To support this, we have included additional results using Qwen2.5-72B-Instruct, and Qwen2.5-Math-7B-Instruct as $C_{LLM}$ and $R_{LLM}$ to synthesise 3 new 15K datasets, and SFT on models in our main experiment.Switching $C_{LLM}$ and $R_{LLM}$ to weaker open-source LLMs resultd in a comparable performance compared with closed-source model as $C_{LLM}$ and $R_{LLM}$.Under Qwen-2.5-72B-instruct，the results achieves 34.3 on Llama3-8B，which is still comparable；31 on mistral，and 46.5 on deepseekMath-7B,which remains state-of-the-art with other methods.

We are deeply grateful for your insightful comments on self-distillation. Taking your suggestion to heart, we used Qwen2.5-7B-Instruct — a model with the same parameter size and comparable performance to Qwen2.5-Math-7B — as both the critique and revision model to synthesize 15K data points. To our delight, we found that despite Qwen2.5-7B-Instruct being less capable than GPT4o-mini, the fine-tuned model exhibited only a very minimal performance drop on this dataset (from 65.6 to 62.6).

Qwen-2.5-Math-7B is used as the candidate generator to construct search trees. One particularly interesting analysis, which was not included...

Thank you for suggesting exlporation on self-distillation setting. In the main experiments, we did not finetune Qwen2.5-Math-7B because existing strong baselines such as DART and MathFusion and other baselines have not reported results on this model. To ensure fair and verifiable comparisons, we focused on base models with publicly available results.

To further assess the self-distillation ability of our method, we additionally conducted finetuning experiments on Qwen2.5-Math-7B.SIGMA remains state-of-the-art performace on Qwen2.5-Math-7B, reaching 79.92 for MATH, 89.23 for GSM8K and 65.6 on all datasets average,surpassing other methods such as Eurus and OpenMath.The results are shown in the following table.

Some outputs from $C_{LLM}$ do not actually appear to contain a critique.$C_{LLM}$ appears to simply be describing the sibling node approaches but doesn’t offer any specific critiques. Could the authors speculate on whether the more robust critiques could be extracted from $C_{LLM}$ and if so, how?

This is an important question and directly relates to the effectiveness of the SIGMA method.

In most mathematical problems, there exists a distinction between critical step（logical steps that directly determine correctness) and non-critical steps(routine computations or definition lookups). To ensure that all potentially critical reasoning steps are considered, SIGMA applies step-level refinement throughout the entire MCTS trajectory. This full-chain processing inevitably includes some non-critical steps that may not benefit significantly from refinement. Occasionally, LLMs may fail to generate meaningful critiques for these simpler steps.That's why even if the refinement of simple steps may not directly improve final accuracy, including them is necessary to ensure robustness across the entire reasoning paths.

The processing of entire reasoning paths does not compromise the overall effectiveness of SIGMA. Because our refinement operates at the step level, and each selected step $T_p$ shares the same parent as its sibling steps $T_s$, any critical step will be refined using other steps that are equally critical. This guarantees that when refinement matters most, the available sibling signals are relevant and high quality.

We will clarify this point in the camera-ready version.

Final Notes: We appreciate for recognizing the motivation and efficiency of our method. We've added clarifications on synthesis cost, token usage, and open-source/self-distillation results. We hope these updates address your concerns and highlight SIGMA's practicality.

Dear Reviewer UihT,

Thank you for your thoughtful and supportive feedback. Your suggestions were very helpful in improving the quality and clarity of our work, and they helped us better appreciate the potential of SIGMA. We will incorporate the additional results and corresponding revisions into the final version of the paper. We truly appreciate your time and effort in reviewing our work.

Best regards, Authors

We appreciate the reviewer for the thoughtful feedback，recognizing (i) our methods are well motivated and can be easily applied (ii) experiments and evaluations are comprehensive. We've addressed your concerns below.

There is work in that direction I find not adressed in this submission, such as [2], that in a similar manner use generations for each token in a prompt for supervised training. While the authors add a trick with the critique- and refinement LLMs, this shows some overlap.

We appreciate the reviewer for highlighting related work such as Self-RAG [2]. While both methods leverage partial generations for supervision, there are key differences that distinguish SIGMA.

(i) Self-RAG evaluates token-wise fragments and discards suboptimal completions, selecting only one high-quality continuation. In contrast, SIGMA explicitly retains and reuses sibling answers that are typically discarded, using them as the basis for critique generation. This reuse of suboptimal trajectories is a central motivation of SIGMA and contributes to its data efficiency.

(ii) In Self-RAG, the selected fragments are sequential and share a context-dependent relationship. In SIGMA, by contrast, the selected node $T_p$ and its sibling nodes $T_s$ are parallel completions generated from the same parent node during MCTS. This structural alignment ensures that the critique model can extract meaningful comparative signals from $T_s$ to revise $T_p$, rather than introducing unrelated information.

We will include a discussion of this distinction in the camera-ready version.

The approach is limited to the math domain, so I am unsure how well it generalizes to more open domains such as commonsense reasoning.

We appreciate the reviewer for the helpful suggestion.We agree that evaluating the generalizability of SIGMA beyond mathematical reasoning is important. Owing to its design that relies entirely on textual signals for refining reasoning paths, SIGMA holds strong potential in non-mathematical domains as well.

Following the experimental setup of RevThink[1], we applied SIGMA to CommonsenseQA, StrategyQA, and ARC-Challenge. We conducted LoRA finetuning on Mistral-7B-Instruct-v0.3 and Gemma-7B-Instruct to assess SIGMA’s cross-domain generalization ability. SIGMA outperformed RevThink and other baselines, achieving state-of-the-art performance(75.74 AVG on Mistral-7B-Instruct-v0.3 and 73.63 AVG on Gemma-7B-Instruct) on these benchmarks.

Detailed results are provided in the table below.

We will include the discussion on generalization and the corresponding experimental results in the camera-ready version.

While it is evaluated across model families, the evaluation is limited to similar sizes and doesn't use specialized models, as [1] does.How would SIGMA’s performance degrade when you change the critique and revision LLMs to weaker open-source models? Have you measured how the number of sibling nodes affects SIGMA's performance?

We appreciate the reviewer for the valuable suggestions regarding evaluation across model strengths and sibling node configurations.

To further assess the self-improvement ability of our method, we additionally conducted finetuning experiments on Qwen2.5-Math-7B.SIGMA remains state-of-the-art performace on Qwen2.5-Math-7B, reaching 79.92 for MATH, 89.23 for GSM8K and 65.59 on all datasets average,surpassing other methods such as Eurus and OpenMath.The results are shown in the following table.

For the critique and revision LLMs, GPT-4o-mini was chosen as a cost-effective option. However, our method does not depend on closed-source models. To support this, we have included additional results using, Qwen2.5-72B-Instruct, and Qwen2.5-Math-7B-Instruct as critique and revision LLMs to synthesise 3 new 15K datasets, and SFT on models in our main experiment.Switching refinement model to weaker open-source LLMs resultd in a comparable performance compared with closed-source model as refinment models.Under Qwen-2.5-72B-instruct，the results achieves 34.3 on Llama3-8B，which is still comparable；31 on mistral，and 46.5 on deepseekMath-7B,which remains state-of-the-art with other methods.

For the influence of the number of sibling nodes, We have conducted additional experiments to study the effect of varying the number of sibling nodes used during refinement.We choose DeepSeekMath-7B and Llama3-8B as Math-Specialized Base Model and General Base model.Lines with suffix MCTS are extracted from Table 2 in Section 4.4, page 9 of our paper.The results shows clearly monotonic increase trend when raising numbers of siblings(33.6->46.5->47.0 for DeepSeekMath and 23.6->35.0->36.1 for Llama3-8B)

[1]Chen, J. C. Y., Wang, Z., Palangi, H., Han, R., Ebrahimi, S., Le, L., ... & Pfister, T. (2024). Reverse thinking makes llms stronger reasoners. arXiv preprint arXiv:2411.19865.

Final Note： We thank the reviewer for recognizing the motivation and completeness of our method and experiments. We have added comparisons with Self-RAG, evaluated generalization to commonsense domains, and analyzed the effects of model strength and sibling count. We hope these additions fully address your concerns.

We appreciate the reviewer for the thoughtful feedback，We've addressed your concerns below.

1.The core idea of leveraging sibling information for refinement is not entirely novel. Similar concepts have been explored in other domains, such as symbolic supervision via LLM-generated feedback [43]. The paper does not provide a clear distinction or significant advancement over these existing methods.

Our primary motivation is to improve data efficiency by reusing sibling trajectories from the MCTS process, which are typically discarded in prior work. TextGrad [43] serves as a key component in realizing this goal, but our contribution lies in how we apply it to exploit the structure of MCTS reasoning trees. Unlike previous methods that focus solely on the best trajectory, our approach systematically leverages feedback from suboptimal siblings to revise and improve selected steps. This enables more effective utilization of existing data, addressing the trade-off between accuracy and test-time scaling cost. Our experiments demonstrate that this strategy leads to consistent performance gains across multiple models and settings, validating its effectiveness.

2.The paper lacks a formal theoretical analysis of why the proposed method works and its potential limitations. A deeper understanding of the underlying mechanisms and potential failure modes would strengthen the paper

We appreciate the reviewer’s comment regarding the need for a deeper understanding of SIGMA's underlying mechanisms and its potential limitations.

SIGMA builds on the structural alignment of MCTS-generated reasoning trees, where each selected step $T_p$ and its sibling steps $T_s$ originate from the same parent and thus represent semantically parallel alternatives. This setting enables meaningful counterfactual supervision: by applying a critique model to $T_s$ and using its output to guide the revision of $T_p$, SIGMA transforms discarded reasoning attempts into constructive feedback. This aligns with principles of contrastive learning and error-based refinement, contributing to SIGMA’s high data efficiency.

However, a potential failure mode arises when the input problems are too simple or formulaic, such that the resulting reasoning trajectories are dominated by non-critical steps (e.g., routine calculations or definition lookups). In such cases, SIGMA still performs step-level refinement uniformly, which may lead to unnecessary processing of low-impact steps. Moreover, language models may fail to produce substantive critiques for these trivial steps, making the refinement less effective and reducing the marginal utility per token. This can weaken SIGMA’s data-efficiency advantage in low-complexity settings.

Nevertheless, because SIGMA refines each step individually and siblings share local context, critical steps are still improved using relevant sibling information. Thus, when refinement truly matters (i.e., on non-trivial reasoning segments), the method remains robust and effective.

We will include this discussion of SIGMA’s underlying mechanism and its potential failure modes in the camera-ready version.

3.The performance of SIGMA is highly dependent on the quality of the sibling nodes generated during MCTS. If the sibling nodes are not well-formed or fail to capture robust reasoning behaviors, the transferred feedback may not provide significant benefits.

The central contribution of our work lies in how to extract constructive revision signals for the selected step $T_p$ from its suboptimal siblings $T_s$. Our method does not refine the content of $T_p$ to be closer to the content of $T_s$. Instead, we first apply a critique model to analyze $T_s$, and then use a revision model to improve $T_p$ based on the critique outcomes.

This design enables two key benefits: – Alternative reasoning paths in $T_s$ are leveraged to enrich the revision of $T_p$ without copying them directly. – Mistakes in $T_s$ are explicitly identified and used to detect and correct similar issues in $T_p$, rather than introducing the same errors into $T_p$.

We will clarify these mechanisms in the camera-ready version.

4. While SIGMA avoids full MCTS fine-tuning on large models, it still requires access to a reasonably strong small expert model trained with MCTS, which can be computationally expensive to obtain. The paper does not provide a detailed analysis of the trade-offs between the computational cost of training the small expert models and the benefits gained from using SIGMA.

We appreciate the reviewer’s concern regarding the computational cost of SIGMA. As a data-efficient method, maintaining low computation cost is central to its practicality and effectiveness.

We clarify that SIGMA does not require any additional model training during the data synthesis phase. We use Qwen-2.5-Math-7B for original MCTS generation,which is a publicly available pretrained models from HuggingFace. Following the MCTS data generation procedure of AlphaMath [6], using Qwen-2.5-Math-7B to generate full MCTS trees for a 15K dataset requires ~42 GPU hours on RTX 4090.Generating MCTS for 60K dataset requires ~168 RTX 4009 GPU hours.

For the refinement phase, we use GPT-4o-mini to process the 15K MCTS trees.The total prompt token count is 33.6M and the total completion token count is 11.42M, resulting in a total cost of 11.7 USD.Processing 60K MCTS on GPT-4o-mini costs 47.6 USD.Detailed comparison for synthesis cost are listed below. The GPU price data are from vast​.​ai.

Compared to alternative data generation pipelines, SIGMA offers a competitive balance of low computational cost, high data efficiency, and improved overall accuracy. We will include detailed computational cost analysis in the camera-ready version. Final Note： We sincerely thank the reviewer for the thoughtful and constructive comments. We have revised the paper to clarify the novelty, mechanisms, and cost-efficiency of SIGMA, and hope the additional discussions address your concerns. If our responses have addressed your concerns, please kindly consider raising the score.

Dear Reviewer 5rCb,

Thank you very much for your detailed and critical feedback. We sincerely appreciate the time and effort you put into reviewing our submission. Your comments have raised important points that prompted us to re-express and improve several aspects of our work.

We have carefully considered your suggestions and made corresponding revisions and clarifications during the rebuttal phase. These changes will also be reflected in the final version of the paper. We believe your input has significantly contributed to enhancing the quality and clarity of our work.

If you have any further questions or concerns, we would be grateful for the opportunity to continue the discussion during the remainder of the rebuttal period.

Best regards,

Authors

We appreciate the reviewer for the thoughtful feedback，recognizing (i) data-efficiency for dataset construction (ii) well-structured methodology.We've addressed your concerns below.

The key point about refining the selected step $T_p$ based on the unselected siblings $T_s$ feels a little counterintuitive. If the siblings were not selected because they were expected to yield inferior results by the MCTS process then why would refining the content of $T_p$ to be closer to the content of $T_s$ be beneficial?

The central contribution of our work lies in how to extract constructive revision signals for the selected step $T_p$ from its suboptimal siblings $T_s$. Our method does not refine the content of $T_p$ to be closer to the content of $T_s$. Instead, we first apply a critique model to analyze $T_s$, and then use a revision model to improve $T_p$ based on the critique outcomes.

This design enables two key benefits: – Alternative reasoning paths in $T_s$ are leveraged to enrich the revision of $T_p$ without copying them directly. – Mistakes in $T_s$ are explicitly identified and used to detect and correct similar issues in $T_p$, rather than introducing the same errors into $T_p$.

We will clarify these mechanisms in the camera-ready version.

The experiments are restricted to mathematical reasoning tasks. While the authors claim generalizability, this is not empirically validated.

We appreciate the reviewer for the helpful suggestion.We agree that evaluating the generalizability of SIGMA beyond mathematical reasoning is important. Owing to its design—which relies entirely on textual signals for refining reasoning paths—SIGMA holds strong potential in non-mathematical domains as well.

Following the experimental setup of RevThink[1], we applied SIGMA to CommonsenseQA, StrategyQA, and ARC-Challenge. We conducted LoRA finetuning on Mistral-7B-Instruct-v0.3 and Gemma-7B-Instruct to assess SIGMA’s cross-domain generalization ability. SIGMA outperformed RevThink and other baselines, achieving state-of-the-art performance(75.74 AVG on Mistral-7B-Instruct-v0.3 and 73.63 AVG on Gemma-7B-Instruct) on these benchmarks.

Detailed results are provided in the table below.

We will include the discussion on generalization and the corresponding experimental results in the camera-ready version.

Given the extra effort involved in preparing the data using SIGMA and the fact that MathFusion-60K gives better results for two (LLaMA3 & Mistral) out of the three models considered, it isn't clear if we should go with SIGMA or just use a larger dataset.

The scalability of SIGMA to larger datasets is essential to its general applicability. In the main text, we emphasized its data efficiency by demonstrating that SIGMA achieves comparable or even superior performance with only half or fewer training samples compared to other methods, and in Table 1 we present results comparing the SIGMA-30K series against the 60K MathFusion dataset to further illustrate this point.

To further address this concern, we include in Appendix A.2 additional results of SIGMA trained on the full 60K dataset. SIGMA continues to outperform all baselines under this setting, achieving state-of-the-art results. This provides important empirical evidence of its effectiveness at scale.

We will incorporate this finding into the camera-ready version. We appreciate the reviewer for the valuable suggestion.

What is $n$ & $k$ as mentioned in Section 4.1 in the context of the algorithm given in Section 3? There seems to be some notation abuse here since in Section 3 $n$ is used to denote node and in Section 4.1 it is used to denote candidate completions.

In Section 4.1, the setting of $k = 5$ and $n = 3$ refers to the sampling of 5 candidate outputs for each non-terminal MCTS node, from which the top 3 are selected as its child nodes. This is consistent with the use of $n$ in Section 3, where it denotes a node in the MCTS tree. The term "candidates" in Section 4.1 refers to possible nodes considered for inclusion in the best trajectory.

We appreciate the reviewer for pointing out this ambiguity. We will revise the notation and clarify the explanation in the camera-ready version to avoid confusion.

In line 280 you say, "Despite sharing the same generator model...". How is the generator model the same for black-box CoT generation and fine-tuning using SIGMA when the former uses GPT-4o-mini (line 279) and the latter uses Qwen2.5-Math-7B?

In Section 4.4, we conducted ablation studies that mesures the contribution of refinement by testing models fine-tuned by datasets with same problems sets but different answer synthesis methods.The results are shown in Table 2.

• Lines with suffix "SIGMA":Qwen2.5-Math-7B is used to generate the original MCTS.GPT-4o-mini is used to conduct the refinement.
• Lines with suffix "MCTS":Qwen2.5-Math-7B is used to generate the original MCTS.For each question,extract best tracjectroy based on Q-value and discard all other nodes.
• Lines with suffix "Blackbox":For each question,generate step-by-step answer with standard COT prompt by GPT-4o-mini-2024-07-18.

The results proves that (i)Improvement of refinement(SIGMA vs MCTS) (ii)Refine from siblings outperforms oracle model(SIGMA vs Blackbox)

The statement “Despite sharing the same generator model...” was intended to highlight the contrast between SIGMA and the Blackbox variant, where SIGMA achieves superior performance despite refining from sibling traces instead of using an oracle CoT generated directly by the same backbone used for refinement.

We appreciate the reviewer’s correction and will revise the wording in the camera-ready version to improve clarity.

[1]Chen, J. C. Y., Wang, Z., Palangi, H., Han, R., Ebrahimi, S., Le, L., ... & Pfister, T. (2024). Reverse thinking makes llms stronger reasoners. arXiv preprint arXiv:2411.19865.

Final Note: Thank you for your detailed feedback on sibling-based refinement, generalization beyond math, and scalability. We hope our empirical results and clarifications have addressed your concerns and kindly invite you to consider raising your score.

Dear Reviewer Aiin,

Thank you again for your time and thoughtful review. Your feedback has been very helpful in improving the quality and clarity of our paper, and we are grateful for the points you raised during the review phase.

In the revised version, we will carefully incorporate your suggestions along with the relevant clarifications and results discussed during the rebuttal period. These updates have helped us present our ideas more clearly and rigorously.

Please feel free to reach out if you have any further questions or thoughts. We remain fully engaged and open to additional discussion throughout the remainder of the rebuttal phase.

Best regards,

Authors

We appreciate the reviewer for the thoughtful feedback，recognizing (i) novelty of incorporates more information from sibling nodes (ii) inspring attempt that formulating critique model and refine model based on textual gradient descent. We've addressed your concerns below.

The other existing datasets for comparison were generated with different models (e.g., MathFusion was generated using GPT-4o-mini only?).I believe that the base model makes a considerable difference here, and it's not clear to me how the proposed refinement contributed to the final improvement.

Thank you for your attention to the impact of the generation model and the effectiveness of the proposed refinement. I address this concern below.

Switching refinement model to weaker open-source LLMs resultd in a comparable performance compared with closed-source model as refinment models.Under Qwen-2.5-72B-instruct，the results achieves 34.3 on Llama3-8B，which is still comparable；31 on mistral，and 46.5 on deepseekMath-7B,which remains state-of-the-art with other methods.

In Section 4.4, we conducted ablation studies that mesures the contribution of refinement by testing models fine-tuned by datasets with same problems sets but different answer synthesis methods.The results are shown in Table 2 at page 9 of our paper.

• Lines with suffix "SIGMA":Qwen2.5-Math-7B is used to generate the original MCTS.GPT-4o-mini is used to conduct the refinement.
• Lines with suffix "MCTS":Qwen2.5-Math-7B is used to generate the original MCTS.For each question,extract best tracjectroy based on Q-value and discard all other nodes.
• Lines with suffix "Blackbox":For each question,generate step-by-step answer with standard COT prompt by GPT-4o-mini-2024-07-18.

The results proves that (i)Improvement of refinement(SIGMA vs MCTS) (ii)Refine from siblings outperforms oracle model(SIGMA vs Blackbox)

What is the reasoning behind choosing Qwen2.5-math for generating the original CoT and GPT-4o-mini for the refinement?

Thank you for the insightful question. Our method is not restricted to specific choices of generation or refinement models. A core focus of our work is data efficiency. In early-stage testing, we experimented with several math-specialized models including Mathstral and DeepSeek-Math. We ultimately selected Qwen2.5-Math-7B for CoT generation due to its strong MCTS generation speed and token efficiency,that it produces fewer tokens per problem on average,reducing the overall computational cost of both generation and refinement.

For the refinement model, GPT-4o-mini was chosen as a cost-effective option. However, our method does not depend on closed-source models. We have shown performance on different critique models above.

We will clarify these design choices and their implications in the camera-ready version.

For the training experiments, why not finetune Qwen2.5 model using the resulting data? It might be intriguing to see the model's self-improvement using this framework.

Thank you for your valuable suggestion. In the main experiments, we did not finetune Qwen2.5-Math-7B because existing strong baselines such as DART and MathFusion and other baselines have not reported results on this model. To ensure fair and verifiable comparisons, we focused on base models with publicly available results.

To further assess the self-improvement ability of our method, we additionally conducted finetuning experiments on Qwen2.5-Math-7B.SIGMA remains state-of-the-art performace on Qwen2.5-Math-7B, reaching 79.92 for MATH, 89.23 for GSM8K and 65.59 on all datasets average,surpassing other methods such as Eurus and OpenMath.The results are shown in the following table.

Final Note: Thank you for your thoughtful feedback on refinement effectiveness, model variation, and self-improvement on Qwen2.5. We hope our clarifications and results have addressed your concerns, and would appreciate your consideration in raising the score.