Critic-CoT: Boosting the reasoning abilities of large language model via Chain-of-Thought Critic

## Abstract

Abstract Self-critic has become a crucial mechanism for enhancing the reasoning performance of LLMs.
However, current approaches mainly involve basic prompts for intuitive instance-level feedback, which resembles System-1 processes and limits the reasoning capabilities. Moreover, there is a lack of in-depth investigations into the relationship between LLM’s ability to criticize and its task-solving performance.
To address these issues, we propose Critic-CoT, a novel framework that pushes LLMs toward System-2-like critic capability.
Through a step-wise CoT reasoning paradigm and the automatic construction of distant-supervision data without human annotation, Critic-CoT enables LLMs to engage in slow, analytic self-critique and refinement, thereby improving their reasoning abilities.
Experiments on GSM8K and MATH demonstrate that our enhanced model significantly boosts task-solving performance by filtering out invalid solutions or iterative refinement. Furthermore, we investigate the intrinsic correlation between critique and task-solving abilities within LLMs, discovering that these abilities can mutually reinforce each other rather than conflict.

## 1 Introduction

Enhancing the reasoning abilities of large language models is essential for creating more intelligent and reliable AI systems, which has drawn extensive attention from researchers (Chollet, ; Bubeck et al., ; Morris et al., ). From a cognitive perspective, the procedure of human reasoning involves constant reflection and revision (Hegel et al., ; Kierkegaard, ; Popper, ), which has inspired increasing focus on integrating self-critic mechanisms in the reasoning process of large-scale models (Kim et al., ; Shinn et al., ; Madaan et al., ). This involves iteratively allowing the model to generate feedback on its own responses and then refining its reasoning based on the feedback.
Compared with traditional critic methods that depend on feedback from external sources (Saunders et al., ; McAleese et al., ), self-critic relies solely on the model’s internal capabilities, thus reducing the high cost of additional human annotation, and serving as a promising potential solution to scalable oversight (Leike et al., ; Burns et al., ; Cao et al., ).

Figure: Figure 1: Illustration of Critic-CoT: Previous instance-level critic methods attempt to identify errors directly without any prior analysis, and restart from the beginning during refinement. In contrast, our proposed Critic-CoT framework performs a step-wise examination using the Chain-of-Thought approach. When refining, rather than starting from scratch, our method makes the correction from the specific problematic step with the help of the corresponding critique.
Refer to caption: x1.png

However, current studies primarily focus on utilizing LLMs’ critique abilities to enhance their performance. Yet, relatively little attention has been given to the investigation and development of the critique ability itself.
Firstly, existing critique methods are often overly simplistic, typically relying on a basic prompt to directly point out the error, without stepwise Chain-of-Thought examination or training procedure, which leads to relatively poor self-critic accuracy (Luo et al., ; West et al., ).
Specifically, proposing a valid critique is a complicated task that requires a thorough understanding of statements and precise negativity. However, current LLMs are normally not explicitly trained for critic capability.
Therefore, these simple approaches usually tend to “criticize” like System-1, which is more intuitive and likely to make mistakes, rather than more rigorous and deliberate System-2 (Kahneman, ; Yu et al., ), while shifting LLMs from System-1 toward System-2 emerges as a promising approach for improving the reasoning capability (OpenAI, ).
This limitation diminishes the effectiveness of self-critic and, further, self-correct (Huang et al., ).
Secondly, the capabilities of task-solving and self-critic are both dependent on the model’s inherent knowledge, while there is currently a lack of in-depth exploration regarding the correlation between these two capabilities within LLMs. In that case, it’s challenging to balance the task-solving and the self-critic capabilities of the model within the self-critic framework, which poses a significant obstacle to the subsequent development in this direction.

To this end, this paper is devoted to diving into the following critical research questions:

- •
How can we enhance a model’s critique ability, pushing it toward System 2 reasoning?
- •
What is the relationship between a model’s critique ability and its task-solving capability?

To answer the above questions, as shown in Figure 1,
we propose Critic-CoT, a novel framework designed to enhance LLMs’ reasoning abilities. Through step-wise Chain-of-Thought critique format and distant supervision, our method is able to strengthen System-2-like critic ability, without the intensive cost of human annotation.
Specifically, during training, we let LLMs criticize and refine their solutions in a complete CoT way, and collect successful pairs that convert wrong solutions into correct ones, or affirm the validity of original right solutions.
After supervised fine-tuning on the obtained step-wise critic-refine data, we enable the target LLM to analyze and criticize each step of its generated reasoning procedure, so that it can filter out wrong attempts and preserve the correct ones with greater precision.
During inference, to leverage the model’s abilities of CoT-critique and refinement, we employ two strategies: (1) majority vote filtering involves using the critic model to evaluate multiple generated solutions and filter out those incorrect;
and (2) iterative refinement, on the other hand, involves repeatedly critiquing and refining a solution until no further error is detected.

Through a series of experiments on the dataset of GSM8K (Cobbe et al., ) and MATH (Hendrycks et al., ), we found that our trained critic model can fairly distinguish incorrect solutions from correct ones, and improve the reasoning accuracy via iterative refinement or critic filtering. These results demonstrate the helpfulness and effectiveness of our proposed method.
Additionally, we observed that our critic model already exhibits noticeable performance improvements in task-solving,
even in the absence of additional critique steps during the decoding phase. Such findings reveal that strengthening the ability to critique and refinement would not compromise the task-solving performance, but improve it.
This also suggests the presence of an intrinsic mechanism by which critique ability and task-solving capability mutually reinforce one another.

We summarize our main contributions as follows:

- •
We propose Critic-CoT, which pushes the critic paradigm of LLMs from System-1-like incentive “thinking” toward System-2-like deliberate “reasoning”.
- •
Through experiments, we find that Critic-CoT can effectively teach the model to criticize and refine its own output step by step, thus noticeably improving the reasoning performance.
- •
Moreover, we find that for LLMs, the ability of critique and refinement could mutually reinforce, which may shed light on designing more advanced self-critic framework designs in future work.

## 2 Related Works

### 2.1 Discriminative Verifier for Mathematics

To further improve the reasoning ability of Large language models, one applicable approach is through the use of reward models, which can either be used in reinforcement learning during training (Ouyang et al., ) or rejection sampling at test time (Cobbe et al., ). While outcome-supervised reward models (ORMs) allow for the automatic collection of training data based on the signal of the gold answer, process-supervised reward models (PRMs) would be more advantageous for more precise feedback, better interpretability and stronger alignment (Lightman et al., ).

To reduce the considerable human labeling cost and difficulty for dense annotation, a series of works based on automatic approaches have been proposed (Wang et al., ; Chen et al., ; Luo et al., ; Snell et al., ), all under the heuristic that for an incorrect solution, the first error step is where the continuation of previous step would lead to a correct answer. This may bring noise into training data due to false positives and negatives (Luo et al., ). Moreover, annotation based on the implicit solution continuation alone does not leverage LLM’s emerging ability of critic, which is in a more explicit and analytic way and brings better explainability (Saunders et al., ; Yuan et al., ; Luo et al., ; McAleese et al., ). Additionally, binary 0/1 discrimination alone, whether outcome-based or process-based, remains more similar to System-1 reasoning rather than the desirable System-2, thus may not fully leverage the computation power support by empirically successful Chain-of-Thought prompting (Feng et al., ; Li et al., ).

### 2.2 Critic Model

Learning from natural language feedback could be beneficial (Chen et al., ). With the development of LLM, whether it can discriminate and criticize its own output in a text-generation manner becomes an interesting topic (Luo et al., ; Zeng et al., ), with doubts at least on off-the-shelf LLMs that are not specially trained for such task (Huang et al., ; West et al., ). Current applications, such as response evaluation, heavily rely on the reference (Zheng et al., ). Therefore, given the limited critic ability of current LLMs, how to train a robust and applicable critic model is worth investigating. Concurrently, Zhang et al. () trained a generative reward model on the outcome level rather than the process level but did not incorporate refinement into the schema.

From the perspective of recursive reward modeling (Leike et al., ; Saunders et al., ) and scalable oversight (Burns et al., ), McAleese et al. () recently trained “CriticGPT” to assist human labelers, which aims to improve the ability of human rather than the base model, i.e. improve the overall recall of error detection, rather than precision. While in this paper, we try to explore whether improving the reasoning ability of LLM without costly human annotation is applicable.

## 3 Method

To equip LLMs with the ability to criticize and refine themselves step-by-step, we propose Critic CoT. As shown in Figure 2, it consists of two modules, including distant-supervision-based auto-train and self-check at inference-time. First, we introduce the distant-supervision principles in Section 3.1, followed by the training process in Section 3.1, and finally, the inference strategies in 3.3.

Figure: Figure 2: The Process of Critic-CoT during training (a) and inference (b). For training, we collect the critic-refine data on the generator’s samples via distant supervision (Section 3.1). Through fine-tuning, we enable the target model to criticize and refine its own reasoning process. Then, during inference, we can leverage the capabilities via Iterative Refine or Critic As Filter (Section 3.3).
Refer to caption: x2.png

### 3.1 Chain-of-Thought Critique

In this work, we utilize a step-wise chain-of-thought critique, which makes the critique-refine process both controllable and formalizable, thereby facilitating the collection of distant supervision data.
Formally, given the question $Q$ and the corresponding gold answer $Ans$, we have the $n$-step attempt $Att=[s_{1},...,s_{n}]$ with predicted answer $Pred$ sampled by generator $G$.
The corresponding critique $Cri$ then can be represented as $L=[l_{1},...,l_{n}]$, where the step label $l_{i}=+1$ indicates that step $i$ is predicted to be correct, and $l_{i}=-1$ to be incorrect.
Then the refinement $Att^{\prime}=[s^{\prime}_{i},...,s^{\prime}_{n^{\prime}}]$ is start from the first incorrect step $i$ with new answer $Pred^{\prime}$.
To automatically annotate the process label for the attempts, we assume that (1) If the final answer is wrong, then there is one earliest mistake, and by refining from this mistake, we could reach a correct answer; (2) If the final answer is correct, then all the intermediate steps are correct.
Thus, we enumerate the following cases:

- •
$Pred\neq Ans,-1\notin L$:
The attempt is wrong, yet the critique did not discover any error step. Thus the critique itself is problematic, and we need to sample another critique.
- •
$Pred\neq Ans,-1\in L,Pred^{\prime}\neq Ans$:
The attempt is wrong, and the critique found an error, but still, the refinement is not correct. There could be two cases for this situation: (1) the refinement is unsuccessful; (2) the critique did not detect an earlier mistake. We simply sample another critique and corresponding refinement for this situation.
- •
$Pred\neq Ans,-1\in L,Pred^{\prime}=Ans$:
Not only did the critique point out the error, but also the refinement reached the correct answer. We then believe the critique is valid, and collect the critique data instance $C=(Q,Att,Cri)$ and the refinement data $R=(Q,Att,Cri_{-1},Att^{\prime})$, where $Cri_{-1}$ is the critique of last step, since explaining why previous steps are correct may not be helpful for refinement.
- •
$Pred=Ans,-1\notin L$:
The attempt is correct, and the critique believes it is correct. So we can collect the positive critique data instance $C=(Q,Att,Cri)$.
- •
$Pred=Ans,-1\in L$:
The attempt reached the correct answer, yet the critique found an error. Then, the critique could be wrong, and we need to sample another critique.

### 3.2 Auto Train: Two-Stage Training

To enable the model to acquire self-critiquing and refining capabilities, we first need to provide it with basic critiquing abilities, followed by self-critique for further enhancement.
The overall training procedure is divided into two stages.

##### Stage 1

In the first step, we collect high-quality critique data to provide the model’s basic critiquing ability.
Specifically, we first sample both positive and negative solutions from a representative instruction-following model $\mathcal{M}_{G}$ on the dataset $D$.
Then, we utilize SOTA LLMs like GPT4-Turbo to serve as critic model $M_{C}$.
For each generated attempt $Att$, the critic model will retry at most $k$ times to produce a valid critique until it reaches one of the distant supervision constraints.
This will form the critic-refine dataset $D_{1}=\{(Q,Att,Cri)\}\bigcup\{(Q,Att,Cri_{-1},Att^{\prime})\}$ for fine-tuning the initial model $\mathcal{M}_{0}$ into the critic model $\mathcal{M}_{1}$.
Note that in this process, we actually distill Pass1@N of the teacher model $\mathcal{M}_{C}$ into Top1@N of the student model.
So, the theoretical upper bound of the student model is not necessarily limited by the teacher model’s performance.

##### Stage 2

In the second step, we leverage the model’s self-critique to enhance its critiquing and refining capabilities further.
Namely, we let the learned critic model $\mathcal{M}_{1}$ criticize and refine its own output.
We first sample $M$ correct-answer solutions and $M$ incorrect-answer solutions for each question $Q$ in the original dataset $D$.
Then, for each attempt $Att$, we employ $\mathcal{M}_{1}$ to repeatedly criticize and refine at most $k$ times.
In case the model fails to successfully critique even after $k$ times, we fall back on the critique from a stronger yet frozen model $M_{C}$ as the final choice.
Finally, we collect dataset $D_{2}=\{(Q,Att,Cri)\}\bigcup\{(Q,Att,Cri_{-1},Att^{\prime})\}$ and use $D_{1}\bigcup D_{2}$ to train the initial model $\mathcal{M}_{0}$ into the final critic model $\mathcal{M}_{2}$, which is similar to Wang et al. ().
This procedure helps the model to learn to criticize and refine its own reasoning outputs better.

### 3.3 Inference: Self-Check

To leverage our learned abilities of critique and refinement for more precise reasoning, we employ two different inference strategies: “iterative refine” and “critic as filter”.

##### Iterative Refine

One single-turn refinement, which consists of multiple steps, may still contain errors. Therefore, we could iteratively inspect the refined solution, and re-refine once the critique found a mistake, and only output the final solution if it’s convincing for the critic, or if it reached the maximum retry. To avoid de-generation after too many refinements, we set the maximum refine depth $d=8$, and restart from the initial solution after $d$ unsuccessful refinement at most $n=8$ times. Figure 3 presents a single successful round of critique and refinement.

##### Critic As Filter

Self-consistency is an effective way to reduce variance and improve accuracy. With the ability to critique, we can filter out predict-to-be-wrong answers to further boost the performance. Specifically, for the $m$ attempts $S=\{(Att,Pred)\}$, we first let our model $\mathcal{M}$ check each attempt and obtain the stepwise label, which is $S_{c}=\{(Att,Pred,L)\}$.
And then those which detect the error at some step are filtered out and reach $S^{\prime}_{c}=\{(Att,Pred,L)|-1\notin L\}$.
Finally, we perform the majority vote to get the answer.

## 4 Experiment

We apply the Critic-CoT training process on the dataset of GSM8K and MATH (Section 4.1), and observe a noticeable performance improvement in our trained model (Section 4.3), and out-of-domain evaluations on AGIEval and StrategyQA further exhibits the generalization of our trained critic ability (Section 4.4). We also conduct a series of ablation studies to demonstrate the effectiveness of our proposed Critic-CoT method (Section 4.5). For more analysis on the critique and refinement during test time, see Appendix A.1, and the prompt is presented in Appendix A.6.

Figure: Figure 3: Criticize and refine a problem in the MATH test set. In the attempt, the model made a hallucination in Step 3, then through stepwise CoT critique, the model detected this error, and accordingly refined the solution starting from Step 3 successfully.

### 4.1 Setup

#### 4.1.1 Model

We fine-tune the critic-refine model on Llama-3-70B-Instruct (Dubey et al., ), which was pre-trained on more than 15 Trillion tokens and has a context length of 8,192. For critique / refinement sampling, we use GPT4-Turbo (OpenAI, ) of the version gpt-4-0125-preview. We use the Huggingface Transformers (Wolf et al., ), DeepSpeed (Rajbhandari et al., ) and FastChat (Zheng et al., ) libraries for training. We use vLLM library (Kwon et al., ) for model inference, adapting top-p sampling of $p=0.95$, with temperature 0.7 for solution sampling, which follows Cobbe et al. (), and 0.5 for critique and refinement. All inferences are zero-shot.

#### 4.1.2 Dataset

##### Train & In-Domain Eval

Separately, we train our model on the problem of GSM8K (Cobbe et al., ) and MATH (Hendrycks et al., ). GSM8K is a grade-school-level math word problem dataset, with 7,473 training instances and 1,319 test instances. MATH is a challenging high school math competition dataset, which consists of 7,500 training problems and 5,000 test problems. For the MATH dataset, we also follow the data split of Lightman et al. (), which adds 4,500 test problems into a training set and, therefore, contains 12,000 training instances and 500 representative test instances.

### 4.2 Metric

##### Solution

For the evaluation of the solution, we compute the metrics of Top-1 Accuracy Acc and Refine Accuracy Refine-Acc, in which the original Top-1 predict-answer is replaced with a refined one if the critic model found an error and made iterative refinement (Section 3.3). We also compute Majority Vote Accuracy Maj1@N (Wang et al., ) and Majority Vote Accuracy After Critique Critic + Maj1@N (Section 3.3), which is to select the most frequent answer among $N$ samples, i.e. $\arg\max_{a}\sum_{i=1}^{N}\mathds{1}\left(\mathbf{a}_{i}=a\right)$. Following Liu et al. (); Havrilla et al. (), we compute Pass@N, which select the gold answer $g$ among the $N$ predictions if present, i.e. $\arg\max_{a}\mathds{1}\left(g=a\right)$.

##### Critique

For the “evaluation of evaluation”, we compute Precision, Recall and F1 for error detection. Also, we compute Critic Accuracy, where the critique should find the error in wrong answer solutions and pass the correct answer solution:

$$ $P=\frac{\{|Pred_{i}\neq Ans_{i}\land-1\in L_{i}|\}}{|\{-1\in L_{i}\}|},R=\frac {\{|Pred_{i}\neq Ans_{i}\land-1\in L_{i}|\}}{|\{Pred_{i}\neq Ans_{i}\}|},F1= \frac{2*P*R}{P+R}$ $$

$$ $CriticAcc=\frac{\sum_{i=1}^{N}(Pred_{i}=Ans_{i}\land-1\notin L_{i})\lor(Pred_{ i}\neq Ans_{i}\land-1\in L_{i})}{N}$ $$

##### Out-of-Domain Eval

To further evaluate our critic model’s generalization capabilities beyond mathematical tasks, we assess its performance on reasoning tasks using the StrategyQA and AGIEval datasets, which cover different domains.
StrategyQA (Geva et al., ) is a multi-step reasoning task constructed from Wikipedia, with binary answers indicating either true or false.
AGIEval (Zhong et al., ) comprises standardized exam questions from various fields, including college entrance exams, law school admission tests, math competitions, and lawyer qualification tests. Given the overlap with the MATH dataset, we evaluated our model using the original 7,500/5,000 training and validation split from MATH, rather than the extended 12,000/500 split.

#### 4.2.1 Critic Data Construction

##### GSM8K

On GSM8K, since GPT-4 already got 92.0% accuracy on the test set (OpenAI, ), which makes it hard to obtain negative data, we use GPT-3.5-Turbo-0125 instead to sample 10 solutions for each question in the training set. Then, we use GPT-4-Turbo as the critic-refine model to criticize the solutions (Table 7), with $K=16$ retry. We obtain 63,485 cases, with 49,832 positive examples and 13,653 negative examples.

In the second stage of GSM8K critique construction, we use the learned critic model to repeatedly sample until we obtain at most 5 positive and 5 negative solutions. For strong LLMs like LLaMA-3, it’s challenging to get enough negative solutions even among 512 samples, so the size of negative data would be slightly smaller. Then, we use the learned critic model to criticize itself, also with $K=16$ retry. In stage two, we obtain 62,877 instances, with 39,654 positive and 26,001 negative. Among the two stages, we got 126,362 instances, with 86,708 positive and 39,654 negative.

##### MATH

On MATH, in the first stage, we directly use the 90,074 GPT-4 generated solutions of PRM800K Dataset (Lightman et al., ), with 11,665 positive instances which all the step labels are correct, and 78,409 negative instances which one step label is incorrect. Since the MATH dataset is challenging, in order to reduce retry of GPT-4-Turbo and avoid not getting valid critique, for the critique of the negative solution, we additionally append reference solution in the input prompt, and hint it might contain mistakes, as suggested in prior work (Zelikman et al., );
for the positive solution, we simply hint it’s correct.
After obtaining the initial critique, we use GPT-4-Turbo again to remove hint phrases like “According to the reference” or “Given the hint” since we do not have any hint or reference during the test time. In stage one, we obtain 1,606 positive cases and 69,775 negative cases.

Similarly, in the second stage of MATH, we use the learned critic model to sample at most 5 positive and negative solutions. Then, we first use the critic model itself to critic its solutions, and without any hints, under $K=16$ retry, and use GPT-4-Turbo to retry another $K=16$ times with hint if failed. We construct 51,618 positive cases and 65,456 negative cases. Among the two stages, we got 188,455 cases, with 53,224 positive and 135,231 negative.

### 4.3 Main Results

**Table 1: Solution Accuracy of GSM8K. The top-1 accuracy of our trained model improves from 89.6% to 91,7%, while iterative refinement further improves the score to 93.3%, and the critic filter increases the performance from 94.8% to 95.4%.**
| Model | Sampling Method | Acc. |
| --- | --- | --- |
| Llama-3-70B-Instruct (Dubey et al., ) | - | 89.6 |
|  | Maj1@96 | 94.1 |
| Llama-3.1-70B-Instruct (Dubey et al., ) | - | 94.5 |
| GPT4-0314 (OpenAI, ) | - | 92.0 |
| DeepSeek-V2 Chat-236B (DeepSeek-AI et al., ) | - | 92.2 |
| Qwen2-72B (Yang et al., ) | - | 93.2 |
| Mistral-7B: MetaMATH (Gao et al., ) | PRM+Maj1@256 | 87.8 |
| InternLM-MATH-20B (Ying et al., ) | PRM Best-of-100 | 89.3 |
| DART-Math-Llama3-70B (Tong et al., ) | - | 89.6 |
| DeepSeek-67B: MetaMATH (Wang et al., ) | PRM+Maj1@256 | 92.5 |
| Critic-CoT, Llama-3-70B-Instruct (Ours) | - | 91.7 |
|  | Iterative Refine | 93.3 $\uparrow$ 1.6 |
|  | Maj1@96 | 94.8 |
|  | Critic + Maj1@96 | 95.4 $\uparrow$ 0.6 |

##### GSM8K

The results of the GSM8K dataset highlight the effectiveness of the Critic-CoT approach in enhancing the solution accuracy. Initially, our trained model’s top-1 accuracy increases from 89.6% to 91.7%, and the iterative refine strategy further enhances the accuracy to 93.3%. Additionally, the Maj1@96 method combined with the critic’s filter achieves the highest accuracy of 95.4%, which is an improvement of 0.6% over the non-critic-assisted Maj1@96 approach. These results suggest that the Critic-CoT method, under relatively easy task where baseline solving accuracy is already high, can still boost performance, via critic-refine training and filtering out invalid solutions or making corrections at test time. For a concrete example of a single-turn refinement, please refer to Appendix A.5.

**Table 2: Solution Accuracy of MATH. The top-1 accuracy of our method increases from 51.0% to 56.2%, and the effect of iterative refinement is moderate but positive improvement of 0.4%, while the performance gain of the critic filter is larger.**
| Model | Sampling Method | Acc. |
| --- | --- | --- |
| Llama-3-70B-Instruct (Dubey et al., ) | - | 51.0 |
|  | Maj1@96 | 63.5 |
|  | Maj1@512 | 64.3 |
| Llama-3.1-70B-Instruct (Dubey et al., ) | - | 68.0 |
| DeepSeek-V2 Chat-236B (DeepSeek-AI et al., ) | - | 53.9 |
| Qwen2-72B (Yang et al., ) | - | 69.0 |
| GPT4-0314 (OpenAI, ) | - | 42.5 |
| GPT4-Turbo | - | 72.6 |
| Critic-CoT, Llama-3-70B-Instruct (Ours) | - | 56.2 |
|  | Iterative Refine | 56.6 $\uparrow$ 0.4 |
|  | Maj1@96 | 64.2 |
|  | Critic + Maj1@96 | 65.0 $\uparrow$ 0.8 |
|  | Maj1@512 | 64.4 |
|  | Critic + Maj1@512 | 66.4 $\uparrow$ 2.0 |

**Table 3: Solution Accuracy of MATH500. The trend is similar to the result on MATH, with a noticeable increase in top-1 accuracy and critic filtering, and a minor increase in iterative refinement.**
| Model | Sampling Method | Acc. |
| --- | --- | --- |
| Llama-3-70B-Instruct | - | 50.4 |
|  | Maj1@96 | 62.2 |
|  | Maj1@512 | 63.4 |
| Mistral-7B: MetaMATH (Gao et al., ) | PRM+Maj1@256 | 38.6 |
| DeepSeek-67B: MetaMATH (Wang et al., ) | PRM+Maj1@256 | 48.1 |
| InternLM-MATH-20B (Ying et al., ) | PRM Best-of-100 | 50.0 |
| DART-Math-Llama3-70B (Tong et al., ) | - | 56.1 |
| GPT-4-MathMix (Lightman et al., ) | PRM Best-of-100 | 74.5 |
|  | PRM Best-of-1860 | 78.2 |
| Critic-CoT, Llama-3-70B-Instruct (Ours) | - | 57.6 |
|  | Iterative Refine | 57.8 $\uparrow$ 0.2 |
|  | Maj1@96 | 64.6 |
|  | Critic + Maj1@96 | 66.6 $\uparrow$ 2.0 |
|  | Maj1@512 | 65.4 |
|  | Critic + Maj1@512 | 68.4 $\uparrow$ 3.0 |

##### MATH

As presented in Table 3, on the test set of MATH500, the baseline performance of Llama-3-70B-Instruct stands at 50.4% accuracy and Tong et al. () reaches 56.1% with difficulty-aware rejection tuning, while our Critic-CoT approach initially improves the model’s performance to 57.6%, with a slight increase to 57.8% through Iterative Refine. Figure 3 presents a concrete example of step-wise CoT critique, which detects an error in problem understanding in Step 3 and a successful refinement that fixes the error in Step 3 and reaches the correct answer. Compared with GSM8K, gaining from refinement is much harder. However, critic filtering still provides a notable improvement, which could be slightly easier than refinement: the accuracy rises from 64.6% with Maj1@96 to 66.6% when Critic filtering is applied, marking a 2.0% improvement. Furthermore, for Maj1@512, the accuracy rises to 68.4% after Critic filtering, showing an increase of 3.0%. While the close-source model GPT-4-MathMix achieves the highest accuracy of 78.2% with extensive sampling of 1860, the Critic-CoT approach on the open-source model can still significantly enhance the accuracy of the base model, particularly through effective error detection. The trend remains consistent with the original 7,500/5,000 split setting (Table 2). Overall, the result demonstrates the effectiveness of our method in training reasonable-level critic-refine capabilities on the challenging MATH dataset. More detailed analysis on GSM8K and MATH500 is in Appendix A.1.

### 4.4 Out-of-Domain Results

**(a) AGIEval**
| Model | Acc. |
| --- | --- |
| Llama-3-70B-Instruct | 56.6 |
| Llama-3.1-70B-Instruct | 61.8 |
| DeepSeek-V2 Chat-236B | 61.4 |
| GPT4o | 65.2 |
| Critic-CoT, GSM8K | 54.7 |
| - Iterative Refine | 55.6 $\uparrow$ 0.8 |
| - Maj1@96 | 60.7 |
| - Critic + Maj1@96 | 60.3 $\downarrow$ 0.4 |
| Critic-CoT, MATH | 59.8 |
| - Iterative Refine | 63.7 $\uparrow$ 3.9 |
| - Maj1@96 | 61.0 |
| - Critic + Maj1@96 | 61.2 $\uparrow$ 0.2 |

For the StrategyQA dataset, our critic models trained on two datasets show a positive performance increase when applying iterative refine and majority vote with the critic filter. On the more challenging AGIEval dataset, the critic model trained on GSM8K improves with iterative refinement, but slightly hurts the performance when filtering samples, indicating the limitations of the grade-level critic model in handling more complex, multi-domain tasks. Conversely, the Critic-CoT model trained on MATH shows significant improvements in iterative refinement, and the method of majority vote after criticizing does not negatively impact the performance.

Overall, the results illustrate that our critic models generalize to other domains, and achieve performance improvements. This underscores the potential of our proposed critic-refine method in improving reasoning accuracy in diverse and challenging tasks beyond the training domain of math.

### 4.5 Ablation Study

The results of the ablation study are shown in Table 5(a) and 5(b), demonstrating the effectiveness of our Critic-CoT design. At the level of critique output, to assess the necessity of our proposed step-wise CoT critic, we first remove the CoT mechanism, and only train the critic model to directly predict if each step is correct (Process Label), for example, “Step 1 is correct. Step 2 is incorrect.”. Then, we remove further remove the step-wise label, and let the critic model predict if the entire solution is correct, without printing anything else (Outcome Label), for example, “Some step from Step 1 to Step 4 is incorrect.” or “Each step from Step 1 to Step 4 is correct.”. We find that removing the Chain-of-Thought intermediate output and further step-wise labels, which fall back toward System-1 reasoning, negatively impacts the recall metric. Consequently, the critic model fails to detect more errors, resulting in a significantly lower critic accuracy, despite its tendency to more easily pass correct solutions.

At the training data level, to evaluate the effect of different data types, we remove the second-stage data, only use the critique and refinement produced by GPT, or remove the first-stage data and only use the critiques and refinements of self-sampled solutions. In addition, we conducted a vertical ablation by removing either the critic data or the refinement data across both stages. From the results, we find that regarding the roles of critic and refine, it is suggested that refinement contributes more to policy improvement, which echoes the finding of An et al. (). Yet only by combining critique and refinement during training can we enhance the policy while leveraging the critic’s ability for further performance gains. Finally, training on the critique of GPT models proves better at identifying faults, but at the cost of precision. In contrast, using only the critique of itself is less effective than simply utilizing data from both stages.

**(a) GSM8K**
| Model | Critic | Refine | Majority Vote |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| P | R | F1 | Acc. | Init. Acc | Ref. Acc. | Pass1@N | Maj1@N | +Critic |  |
| Outcome Label | 95.5 | 28.9 | 44.4 | 88.0 | 87.7 | 89.7 | 99.0 | 93.6 | 93.7 |
| Process Label | 67.9 | 22.8 | 34.1 | 89.5 | 88.0 | 89.2 | 99.0 | 93.0 | 93.0 |
| Only Refine | 30.0 | 11.4 | 16.6 | 90.8 | 92.0 | 88.2 | 98.9 | 95.2 | 95.2 |
| Only Critic | 57.1 | 31.0 | 40.2 | 91.9 | 91.2 | 91.4 | 98.9 | 94.4 | 94.5 |
| Stage 1 | 42.5 | 41.5 | 42.0 | 89.3 | 90.7 | 91.1 | 98.9 | 93.6 | 94.2 |
| Stage 2 | 50.0 | 25.0 | 33.3 | 85.5 | 90.5 | 91.3 | 99.0 | 94.4 | 94.4 |
| Critic-CoT | 53.3 | 58.2 | 55.7 | 92.3 | 91.7 | 93.3 | 99.1 | 94.8 | 95.4 |

## 5 Conclusion

In this paper, we introduced the Critic-CoT paradigm to enhance the reasoning abilities of Large Language Models, through a more System-2-like, step-by-step Chain-of-Thought critique. Our approach leverages distant supervision to construct training data for critiques and refinements, thereby reducing the reliance on extensive human annotation. We demonstrated the effectiveness of our method through substantial improvements across the dataset of GSM8K and MATH. Additionally, our results present that training on the capabilities of critique and refinement alone improves task-solving performance, which indicates a mutual-reinforce mechanism within the LLMs. We hope our work may inspire further investigations into the advancement of the self-critic framework and the transition toward System-2 reasoning.

## Appendix A Appendix

### A.1 Analysis

### A.2 Critic Performance

For both datasets, the critic model’s accuracy continues to grow as the sample size $N$ increases, ultimately surpassing the performance of the majority vote, which gradually converges. Specifically, in the MATH dataset, the critic model achieves substantially higher accuracy than the solution accuracy, consistently outperforming the naive majority vote due to the critic filter’s superior performance. This stark contrast highlights the critic model’s effectiveness in identifying and promoting correct answers. In the GSM8K dataset, despite having a critic accuracy of only 92.3%, the critic model still manages to deliver higher accuracy gains. This outcome suggests that the critic model successfully filters answers to increase the density of correct answers and decrease the density of wrong answers, compared to the normal answer distribution. The overall results demonstrate the critic model’s robust capability to enhance accuracy across different datasets, validating its practical utility in improving prediction outcomes.

Figure: Figure 4: Performance of majority vote on GSM8K and MATH500 Datasets
Refer to caption: x3.png

### A.3 Inspect on Iterative Refine

**(a) GSM8K**
| Round | Refine Acc. | True $\rightarrow$<br>True | False $\rightarrow$<br>True |
| --- | --- | --- | --- |
| 0 | 91.7 | - | - |
| 1 | 91.7 | 48.2 | 45.3 |
| 2 | 92.6 | 78.6 | 37.5 |
| 3 | 92.7 | 64.3 | 53.1 |
| 4 | 93.0 | 73.2 | 50.0 |
| 5 | 93.2 | 75.0 | 53.1 |
| 6 | 93.2 | 76.8 | 53.1 |
| 7 | 93.3 | 80.4 | 50.0 |
| 8 | 93.3 | 80.4 | 50.0 |

The iterative refinement process for the GSM8K and MATH datasets demonstrates different levels of effectiveness due to their complexity, as shown in Table 6. GSM8K, being simpler, shows a higher success rate in refinement. For effective refinement, the number of false answers corrected (False $\rightarrow$ True) must exceed the number of true answers incorrectly changed (True $\rightarrow$ False). Despite occasional mistakes by the critic, correct answers are not always altered incorrectly.

For GSM8K (Table 6(a)), accuracy improves from 91.7% initially to 93.3% by the seventh round, with significant gains in both true-to-true and false-to-true transformations. In contrast, MATH (Table 6(b)) starts at 57.6% accuracy, reaching 57.8% by the seventh round. The iterative refinement process tends to converge, which is expected.

### A.4 Group By Difficulty Level

Figure: Figure 5: Performance group by difficulty level, on GSM8K and MATH500 Datasets
Refer to caption: x4.png

For the MATH dataset, the difficulty level is given from 1 to 5. For the GSM8K dataset, we set the difficulty level according to the number of expressions $n$ that appeared in the reference solution, i.e., $max(1,min(5,n))$. As illustrated in Figure 5, the performance on the GSM8K dataset shows a gradual decline as the difficulty level increases. This trend is accompanied by the emerging effects of the critic and refine stages, which become more prominent at higher difficulty levels. In contrast, the accuracy on the MATH dataset declines sharply as the problems become more challenging. Generally, the refine stage proves effective across all levels, while the critic stage is beneficial at most levels, with some minor exceptions. These observations suggest potential areas for further improvements in the critic mechanism.

### A.5 An Example of Refinement on GSM8K

As presented in Figure 6, the model forgot to add one year at Step 3; then, through CoT critique, the model found that while Step 1 and Step 2 are correct, Step 3 contains this ignorance error. Finally, guided by the critique of Step 3, the model made a correction and reach the gold answer of 13.

### A.6 Prompts

Table 7, Table 10, and Table 8 presents the prompt for critic-refine data collection using GPT4-Turbo, with Table 9 for removing the hint phrases (Section 3.2). Table 11, Table 12, and Table 13 shows the prompt of trained model for solving, critique, and refinement during stage-2-training (Section 3.2) and inference (Section 3.3). Table 14, Table 15 and Table 16 present the prompts and responses of a single turn critique-refinement, under Critic-CoT, Step-wise Label Critic and Final Label Critic respectively.

Figure: Figure 6: Criticize and refine a problem in the GSM8K test set.

**Table 7: The prompt for the collection of critique and refinement on GSM8K, using GPT4-Turbo.**
| Prompt |
| --- |
| How do you evaluate the following attempt with respect to the problem? |
| <problem> |
| {problem} |
| </problem> |
| <attempt> |
| {attempt} |
| </attempt> |
| ----- |
| *Notes**: |
| - Please think step by step. |
| - Your reasoning should precede any claims or conclusions you make to avoid unwarranted assertions. |
| - At the end of the evaluation for each step, YOU MUST articulate the conclusion using the format ”Conclusion: Step [i] is correct” or ”Conclusion: Step [i] is incorrect”. Words like ”partially correct” are prohibited. |
| - You shall not evaluate multiple steps at a time, so words like ”Step 7 to Step 24:” or ”Step 4 through 6” are forbidden. |
| - Once a mistake is identified and stated, stop the evaluation, and enumerate the corrected steps starting from the step where the mistake was detected, and label this part of your response with <correction> at the start and </correction> at the end. Also, the final answer should be a single number, in the form \boxed{}, at the final step. |

**Table 8: The prompt for the collection of critique and refinement on MATH incorrect attempt, using GPT4-Turbo.**
| Prompt |
| --- |
| How do you evaluate the following attempt with respect to the problem, with the help of reference solution? |
| Hint: There could be a mistake. |
| <problem> |
| {problem} |
| </problem> |
| <reference_solution> |
| {reference_solution} |
| </reference_solution> |
| <attempt> |
| {attempt} |
| </attempt> |
| ----- |
| *Notes**: |
| - Please think step by step. |
| - Your reasoning should precede any claims or conclusions you make to avoid unwarranted assertions. |
| - Please ensure that the output text does not include phrases implying the use of a reference solution or hint, even though these resources are being utilized. |
| - At the end of the evaluation for each step, YOU MUST articulate the conclusion using the format ”Conclusion: Step [i] is correct” or ”Conclusion: Step [i] is incorrect”. Words like ”partially correct” are prohibited. |
| - You shall not evaluate multiple steps at a time, so words like ”Step 7 to Step 24:” or ”Step 4 through 6” are forbidden. |
| - Once a mistake is identified and stated, stop the evaluation, and enumerate the corrected steps starting from the step where the mistake was detected, and label this part of your response with <correction> at the start and </correction> at the end. Also, the final answer should be in the form \boxed{}, at the final step. |

**Table 9: The prompt for removing the hint of critique and refinement on MATH, using GPT4-Turbo.**
| Prompt |
| --- |
| For the following text, remove any phrases like ”reference solution” or ”hint”, and keep all the other content. Do not miss the ”<correction>” and ”</correction>” labels that exist in the text. Do not respond to anything else. |
| ----- |
| {critique_refinement} |

**Table 10: The prompt for the collection of critique on MATH correct attempt, using GPT4-Turbo.**
| Prompt |
| --- |
| How do you evaluate the following attempt with respect to the problem? |
| Hint: All the steps are correct, and the attempt reached a correct answer. |
| <problem> |
| {problem} |
| </problem> |
| <attempt> |
| {attempt} |
| </attempt> |
| ----- |
| *Notes**: |
| - Please think step by step. |
| - Your reasoning should precede any claims or conclusions you make to avoid unwarranted assertions. |
| - Please ensure that the output text does not include phrases implying the use of a reference solution or hint, even though these resources are being utilized. |
| - At the end of the evaluation for each step, YOU MUST articulate the conclusion using the format ”Conclusion: Step [i] is correct” or ”Conclusion: Step [i] is incorrect”. Words like ”partially correct” are prohibited. |
| - You shall not evaluate multiple steps at a time, so words like ”Step 7 to Step 24:” or ”Step 4 through 6” are forbidden. |
| - Once a mistake is identified and stated, stop the evaluation, and enumerate the corrected steps starting from the step where the mistake was detected, and label this part of your response with <correction> at the start and </correction> at the end. Also, the final answer should be in the form \boxed{}, at the final step. |

**Table 11: The prompt for solution sampling.**
| Prompt |
| --- |
| ## Problem |
| {problem} |
| ----- |
| Solve the problem step by step, marking each step as ”Step [i]:”. |
| Your final answer should be in the form \boxed{answer}, at the end of your response. |

**Table 12: The prompt for critique.**
| Prompt |
| --- |
| How do you evaluate the following attempt with respect to the problem? |
| <problem> |
| {problem} |
| </problem> |
| <attempt> |
| {attempt} |
| </attempt> |
| ----- |
| *Notes**: |
| - Please think step by step. |
| - Your reasoning should precede any claims or conclusions you make to avoid unwarranted assertions. |
| - At the end of the evaluation for each step, YOU MUST articulate the conclusion using the format ”Conclusion: Step [i] is correct” or ”Conclusion: Step [i] is incorrect”. Words like ”partially correct” are prohibited. |

**Table 13: The prompt for refinement.**
| Prompt |
| --- |
| How do you refine the following attempt with respect to the problem, given the criticism? |
| <problem> |
| {problem} |
| </problem> |
| <attempt> |
| {attempt} |
| </attempt> |
| <criticism> |
| {wrong_step_criticism} |
| </criticism> |

| Prompt of Critique under Critic-CoT |
| --- |
| How do you evaluate the following attempt with respect to the problem? |
| <problem> |
| Consider the geometric sequence $\frac{125}{9},\frac{25}{3},5,3,\ldots$. What is the eighth term of the sequence? Express your answer as a common fraction. |
| </problem> |
| <attempt> |
| Step 1: Identify the first term of the sequence.<br>The first term $a_{1}$ is:<br>$a_{1}=\frac{125}{9}$<br>Step 2: Calculate the common ratio $r$.<br>The common ratio $r$ can be found by dividing the second term $a_{2}$ by the first term $a_{1}$:<br>$r=\frac{a_{2}}{a_{1}}=\frac{\frac{25}{3}}{\frac{125}{9}}=\frac{25}{3}\times<br>\frac{9}{125}$<br>Calculating the right-hand side:<br>$=\frac{25\cdot 9}{3\cdot 125}=\frac{225}{375}$<br>Now simplify $\frac{225}{375}$:<br>$=\frac{225\div 75}{375\div 75}=\frac{3}{5}$<br>Thus, the common ratio is:<br>$r=\frac{3}{5}$<br>Step 3: Use the formula for the $n$-th term of a geometric sequence.<br>The $n$-th term of a geometric sequence can be calculated using the formula:<br>$a_{n}=a_{1}\cdot r^{n-1}$<br>Step 4: Calculate the eighth term $a_{8}$.<br>Substituting $n=8$ into the formula:<br>$a_{8}=a_{1}\cdot r^{8-1}=\frac{125}{9}\cdot\left(\frac{3}{5}\right)^{7}$<br>Step 5: Calculate $\left(\frac{3}{5}\right)^{7}$.<br>Calculating $\left(\frac{3}{5}\right)^{7}$:<br>$\left(\frac{3}{5}\right)^{7}=\frac{3^{7}}{5^{7}}=\frac{2187}{78125}$<br>Step 6: Substitute back into the expression for $a_{8}$.<br>Now we compute:<br>$a_{8}=\frac{125}{9}\cdot\frac{2187}{78125}$<br>Step 7: Multiply the fractions.<br>To multiply:<br>$a_{8}=\frac{125\cdot 2187}{9\cdot 78125}$<br>Calculating the denominator:<br>$9\cdot 78125=703125$ |

| Prompt of Critique under Critic-CoT |
| --- |
| Calculating the numerator:<br>$125\cdot 2187=273375$<br>Thus:<br>$a_{8}=\frac{273375}{703125}$<br>Step 8: Simplify the fraction $\frac{273375}{703125}$.<br>To simplify:<br>First, calculate the GCD of the numerator and denominator. We can find that both 273375 and 703125 are divisible by 135.<br>Calculating:<br>$\frac{273375\div 135}{703125\div 135}=\frac{2025}{5205}$<br>Continuing to simplify, both 2025 and 5205 are divisible by 15:<br>$\frac{2025\div 15}{5205\div 15}=\frac{135}{347}$<br>This is now fully simplified because 135 and 347 have no common factors.<br>Final Answer:<br>Thus, the eighth term of the sequence is:<br>$\boxed{{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\frac<br>{135}{347}}}$ |
| </attempt> |
| ----- |
| *Notes**: |
| - Please think step by step. |
| - Your reasoning should precede any claims or conclusions you make to avoid unwarranted assertions. |
| - At the end of the evaluation for each step, YOU MUST articulate the conclusion using the format ”Conclusion: Step [i] is correct” or ”Conclusion: Step [i] is incorrect”. Words like ”partially correct” are prohibited. |
| Response of Critique under Critic-CoT |
| Step 1: The first term $a_{1}=\frac{125}{9}$ is identified correctly.<br>Conclusion: Step 1 is correct.<br>Step 2: The common ratio $r$ is calculated as:<br>$r=\frac{a_{2}}{a_{1}}=\frac{\frac{25}{3}}{\frac{125}{9}}=\frac{25}{3}\times<br>\frac{9}{125}=\frac{225}{375}=\frac{3}{5}$<br>This calculation is correct.<br>Conclusion: Step 2 is correct.<br>Step 3: The formula for the $n$-th term is correctly stated as:<br>$a_{n}=a_{1}\cdot r^{n-1}$<br>Conclusion: Step 3 is correct.<br>Step 4: The eighth term is computed as:<br>$a_{8}=\frac{125}{9}\cdot\left(\frac{3}{5}\right)^{7}$<br>This is correct.<br>Conclusion: Step 4 is correct. |

| Response of Critique under Critic-CoT |
| --- |
| Step 5: Calculating $\left(\frac{3}{5}\right)^{7}$:<br>$\left(\frac{3}{5}\right)^{7}=\frac{2187}{78125}$<br>This calculation is correct.<br>Conclusion: Step 5 is correct.<br>Step 6: Substituting back:<br>$a_{8}=\frac{125}{9}\cdot\frac{2187}{78125}$<br>This is correct.<br>Conclusion: Step 6 is correct.<br>Step 7: Multiplying the fractions:<br>$a_{8}=\frac{125\cdot 2187}{9\cdot 78125}$<br>The denominator calculation is correct:<br>$9\cdot 78125=703125$<br>However, for the numerator:<br>$125\cdot 2187=273375$<br>This is also correct.<br>Conclusion: Step 7 is correct.<br>Step 8: The goal is to simplify the fraction $\frac{273375}{703125}$. The attempt made to find the GCD and simplify.<br>To simplify the fraction, we need to find the greatest common divisor (GCD) of 273375 and 703125.<br>The standard approach involves either prime factorization or using the Euclidean algorithm.<br>Prime Factorization: |
| - 273375: |
| - Dividing by 5: $273375\div 5=54675$ |
| - Dividing by 5 again: $54675\div 5=10935$ |
| - Dividing by 5 again: $10935\div 5=2187$ |
| - The number 2187 is $3^{7}$. |
| - Therefore, $273375=5^{3}\cdot 3^{7}$. |
| - 703125: |
| - Dividing by 5: $703125\div 5=140625$ |
| - Dividing by 5 again: $140625\div 5=28125$ |
| - Dividing by 5 again: $28125\div 5=5625$ |
| - Dividing by 5 again: $5625\div 5=1125$ |
| - Dividing by 5 again: $1125\div 5=225$ |
| - Dividing by 5 again: $225\div 5=45$ |
| - Finally, $45=3^{2}\cdot 5^{1}$. |
| - Therefore, $703125=5^{6}\cdot 3^{2}$. |
| The GCD can now be derived from the lowest powers of the common factors: |
| - For 5: $5^{3}$ |
| - For 3: $3^{2}$ |
| Thus, the GCD is:<br>$5^{3}\cdot 3^{2}$<br>Therefore, 273375 and 703125 are not divisible by 135.<br>Conclusion: Step 8 is incorrect. |

| Prompt of Refinement under Critic-CoT |
| --- |
| How do you refine the following attempt with respect to the problem, given the criticism? |
| <problem> |
| Consider the geometric sequence $\frac{125}{9},\frac{25}{3},5,3,\ldots$. What is the eighth term of the sequence? Express your answer as a common fraction. |
| </problem> |
| <attempt> |
| Step 1: Identify the first term of the sequence.<br>The first term $a_{1}$ is:<br>$a_{1}=\frac{125}{9}$<br>Step 2: Calculate the common ratio $r$.<br>The common ratio $r$ can be found by dividing the second term $a_{2}$ by the first term $a_{1}$:<br>$r=\frac{a_{2}}{a_{1}}=\frac{\frac{25}{3}}{\frac{125}{9}}=\frac{25}{3}\times<br>\frac{9}{125}$<br>Calculating the right-hand side:<br>$=\frac{25\cdot 9}{3\cdot 125}=\frac{225}{375}$<br>Now simplify $\frac{225}{375}$:<br>$=\frac{225\div 75}{375\div 75}=\frac{3}{5}$<br>Thus, the common ratio is:<br>$r=\frac{3}{5}$<br>Step 3: Use the formula for the $n$-th term of a geometric sequence.<br>The $n$-th term of a geometric sequence can be calculated using the formula:<br>$a_{n}=a_{1}\cdot r^{n-1}$<br>Step 4: Calculate the eighth term $a_{8}$.<br>Substituting $n=8$ into the formula:<br>$a_{8}=a_{1}\cdot r^{8-1}=\frac{125}{9}\cdot\left(\frac{3}{5}\right)^{7}$<br>Step 5: Calculate $\left(\frac{3}{5}\right)^{7}$.<br>Calculating $\left(\frac{3}{5}\right)^{7}$:<br>$\left(\frac{3}{5}\right)^{7}=\frac{3^{7}}{5^{7}}=\frac{2187}{78125}$<br>Step 6: Substitute back into the expression for $a_{8}$.<br>Now we compute:<br>$a_{8}=\frac{125}{9}\cdot\frac{2187}{78125}$<br>Step 7: Multiply the fractions.<br>To multiply:<br>$a_{8}=\frac{125\cdot 2187}{9\cdot 78125}$<br>Calculating the denominator:<br>$9\cdot 78125=703125$<br>Calculating the numerator: |

| Prompt of Refinement under Critic-CoT |
| --- |
| $125\cdot 2187=273375$<br>Thus:<br>$a_{8}=\frac{273375}{703125}$<br>Step 8: Simplify the fraction $\frac{273375}{703125}$.<br>To simplify:<br>First, calculate the GCD of the numerator and denominator. We can find that both 273375 and 703125 are divisible by 135.<br>Calculating:<br>$\frac{273375\div 135}{703125\div 135}=\frac{2025}{5205}$<br>Continuing to simplify, both 2025 and 5205 are divisible by 15:<br>$\frac{2025\div 15}{5205\div 15}=\frac{135}{347}$<br>This is now fully simplified because 135 and 347 have no common factors.<br>Final Answer:<br>Thus, the eighth term of the sequence is:<br>$\boxed{\frac{135}{347}}$ |
| </attempt> |
| <criticism> |
| Step 8: The goal is to simplify the fraction $\frac{273375}{703125}$. The attempt made to find the GCD and simplify.<br>To simplify the fraction, we need to find the greatest common divisor (GCD) of 273375 and 703125.<br>The standard approach involves either prime factorization or using the Euclidean algorithm.<br>Prime Factorization: |
| - 273375: |
| - Dividing by 5: $273375\div 5=54675$ |
| - Dividing by 5 again: $54675\div 5=10935$ |
| - Dividing by 5 again: $10935\div 5=2187$ |
| - The number 2187 is $3^{7}$. |
| - Therefore, $273375=5^{3}\cdot 3^{7}$. |
| - 703125: |
| - Dividing by 5: $703125\div 5=140625$ |
| - Dividing by 5 again: $140625\div 5=28125$ |
| - Dividing by 5 again: $28125\div 5=5625$ |
| - Dividing by 5 again: $5625\div 5=1125$ |
| - Dividing by 5 again: $1125\div 5=225$ |
| - Dividing by 5 again: $225\div 5=45$ |
| - Finally, $45=3^{2}\cdot 5^{1}$. |
| - Therefore, $703125=5^{6}\cdot 3^{2}$. |
| The GCD can now be derived from the lowest powers of the common factors: |
| - For 5: $5^{3}$ |
| - For 3: $3^{2}$ |
| Thus, the GCD is:<br>$5^{3}\cdot 3^{2}$<br>Therefore, 273375 and 703125 are not divisible by 135.<br>Conclusion: Step 8 is incorrect. |
| </criticism> |

**Table 14: Full example of Critic-CoT. The model got the wrong common factor in Step 8, and through CoT critique, identified this mistake, then took the refinement and reached the correct answer.**
| Prompt of Refinement under Critic-CoT |
| --- |
| <correction> |
| Step 8: Simplify $\frac{273375}{703125}$. First, we divide it by 375.<br>Calculating:<br>$\frac{273375\div 375}{703125\div 375}=\frac{729}{1875}$<br>Step 9: Further simplify $\frac{729}{1875}$. The numerator 729 is $3^{6}$ and the denominator 1875 is $3\cdot 625$. The GCD is 3.<br>Calculating:<br>$\frac{729\div 3}{1875\div 3}=\frac{243}{625}$<br>This fraction is fully simplified.<br>Final Answer:<br>Thus, the eighth term of the sequence is:<br>$\boxed{{\color[rgb]{0.1953125,0.796875,0}\definecolor[named]{pgfstrokecolor}{<br>rgb}{0.1953125,0.796875,0}\frac{243}{625}}}$<br></correction> |

| Prompt of Critique under Step-wise Label Critic |
| --- |
| How do you evaluate the following attempt with respect to the problem? |
| <problem> |
| [...] |
| </problem> |
| <attempt> |
| [...] |
| </attempt> |
| ----- |
| *Notes**: |
| - For each step, you only need to output ”Step [i] is correct” if right, or ”Step [i] is incorrect” if wrong. Do not provide anything else in your output. |
| Response of Critique under Step-wise Label Critic |
| Step 1 is correct. |
| Step 2 is correct. |
| Step 3 is correct. |
| Step 4 is correct. |
| Step 5 is incorrect. |

**Table 15: Full example of Step-wise Label Critic. The problem and the attempt are the same in Table 14, so we skip them. Without CoT critique, the model incorrectly believed that Step 5 is wrong, then made the refinement starting from Step 5, which is unsuccessful.**
| Prompt of Refinement under Step-wise Label Critic |
| --- |
| How do you refine the following attempt with respect to the problem, given the criticism? |
| <problem> |
| [...] |
| </problem> |
| <attempt> |
| [...] |
| </attempt> |
| <criticism> |
| Step 5 is incorrect. |
| </criticism> |
| Response of Refinement under Step-wise Label Critic |
| <correction> |
| Step 5: Calculate $\left(\frac{3}{5}\right)^{7}$.<br>$\left(\frac{3}{5}\right)^{7}=\frac{3^{7}}{5^{7}}=\frac{2187}{78125}\text{ (<br>correct)}$<br>Step 6: Substitute back into the expression for $a_{8}$.<br>$a_{8}=\frac{125}{9}\cdot\frac{2187}{78125}$<br>Step 7: Multiply the fractions.<br>Calculating the numerator:<br>$125\cdot 2187=273375\text{ (correct)}$<br>Calculating the denominator:<br>$9\cdot 78125=703125\text{ (correct)}$<br>Step 8: Simplify the fraction $\frac{273375}{703125}$.<br>To simplify:<br>Calculating the GCD shows that both 273375 and 703125 are divisible by 675, so:<br>$\frac{273375\div 675}{703125\div 675}=\frac{405}{1045}$<br>Continuing to simplify, both 405 and 1045 are divisible by 5:<br>$\frac{405\div 5}{1045\div 5}=\frac{81}{209}$<br>Thus, the final answer is:<br>$\boxed{{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\frac<br>{81}{209}}}$<br></correction> |

| Prompt of Critique under Outcome Label Critic |
| --- |
| How do you evaluate the following attempt with respect to the problem? |
| <problem> |
| [...] |
| </problem> |
| <attempt> |
| [...] |
| </attempt> |
| ----- |
| *Notes**: |
| - For the whole attempt, you only need to output ”Each step from Step 1 to Step 8 is correct.” if right, or ”Some step from Step 1 to Step 8 is incorrect” if wrong. Do not provide anything else in your output. |
| Response of Critique under Outcome Label Critic |
| Some step from Step 1 to Step 8 is incorrect. |
| Prompt of Refinement under Outcome Label Critic |
| How do you refine the following attempt with respect to the problem, given the criticism? |
| <problem> |
| [...] |
| </problem> |
| <attempt> |
| [...] |
| </attempt> |
| <criticism> |
| Some step from Step 1 to Step 8 is incorrect. |
| </criticism> |
| Response of Refinement under Outcome Label Critic |
| <correction> |
| Step 1: Identify the first term of the sequence.<br>The first term $a_{1}$ is:<br>$a_{1}=\frac{125}{9}$<br>Step 2: Calculate the common ratio $r$.<br>The common ratio $r$ can be found by dividing the second term $a_{2}$ by the first term $a_{1}$:<br>$r=\frac{a_{2}}{a_{1}}=\frac{\frac{25}{3}}{\frac{125}{9}}=\frac{25}{3}\times<br>\frac{9}{125}=\frac{225}{375}$<br>Now simplify $\frac{225}{375}$:<br>$=\frac{225\div 75}{375\div 75}=\frac{3}{5}$<br>Thus, the common ratio is:<br>$r=\frac{3}{5}$<br>Step 3: Use the formula for the $n$-th term of a geometric sequence. |

**Table 16: Full example of Final Label Critic. The problem and the attempt are also the same in Table 14. With only the outcome label, the model managed to detect the attempt was incorrect, then made the refinement starting from the first step, which was unsuccessful.**
| Response of Refinement under Outcome Label Critic |
| --- |
| The $n$-th term of a geometric sequence can be calculated using the formula:<br>$a_{n}=a_{1}\cdot r^{n-1}$<br>Step 4: Calculate the eighth term $a_{8}$.<br>Substituting $n=8$ into the formula:<br>$a_{8}=a_{1}\cdot r^{8-1}=\frac{125}{9}\cdot\left(\frac{3}{5}\right)^{7}$<br>Step 5: Calculate $\left(\frac{3}{5}\right)^{7}$.<br>Calculating $\left(\frac{3}{5}\right)^{7}$:<br>$\left(\frac{3}{5}\right)^{7}=\frac{3^{7}}{5^{7}}=\frac{2187}{78125}$<br>Step 6: Substitute back into the expression for $a_{8}$.<br>Now we compute:<br>$a_{8}=\frac{125}{9}\cdot\frac{2187}{78125}$<br>Step 7: Multiply the fractions.<br>To multiply:<br>$a_{8}=\frac{125\cdot 2187}{9\cdot 78125}$<br>Calculating the denominator:<br>$9\cdot 78125=703125$<br>Calculating the numerator:<br>$125\cdot 2187=273375$<br>Thus:<br>$a_{8}=\frac{273375}{703125}$<br>Step 8: Simplify the fraction $\frac{273375}{703125}$.<br>To simplify:<br>Finding the GCD, both 273375 and 703125 are divisible by 675:<br>$\frac{273375\div 675}{703125\div 675}=\frac{405}{1042}$<br>Now we check if $\frac{405}{1042}$ can be simplified further. Both numbers do not have common factors.<br>Final Answer:<br>Thus, the eighth term of the sequence is:<br>$\boxed{{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\frac<br>{405}{1042}}}$<br></correction> |

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: No
soundness: 3
strengths: The paper is clear, the method is well motivated.
summary: This paper proposes a CoT-based critic framework, including training data collections and two different inference methods (reflection or filter).
weaknesses: At least for me, the novelty of the proposed method is limited, as it is pretty similar to existing self-reflection-based approaches.
In particular, the proposed method does not guarantee that the generated critic is reasonable, as long as the refined output (taking the generated critic as additional inputs) contains the correct answer.

Besides, I expect more experiments on broad reasoning tasks beside math, and the improvements are limited for both GSM8K and MATH.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: 1.	The quality of critique data is crucial to train a valid NL critique at step-level. A) the assumption that the final answer is correct, then all intermediate steps are correct. Please evaluate some of those data and report the accuracy. B) All Att and Cri are from sampling, that randomness will also introduce some errors, those generated data should be also evaluated and reported in paper.
2.	The Iterative Refine improvements on MATH task without re-ranking are not significant, thus, I’m not convinced self-critique refinement with single pass is a valid approach. 
3.	It looks like self-critique iterative refine works in the re-ranking setting, this suggests that the self-critique accuracy is not high, we need some analysis in detail.
soundness: 3
strengths: 1.	The data construction for NL critique at step level looks interesting.
2.	The approach of Critic As Filter shows consistent gains over majority voting.
summary: This paper proposes a simple procedure to construct NL critic and refinement data, with those data, this paper tests two ways of using those data: iterative refine (run NL critic on a system output, and then perform refinement to produce a new output) and critic as filter (only use NL critic as re-ranking). Experiments on GSM8k and MATH test sets show some improvements when run with Iterative Refine and Critic As Filter.
weaknesses: 1.	“Self-critique” ability used in this paper is distilled from a stronger model (e.g. GPT4-Turbo).
2.	The basic data construction in Section 3.1 is built on sampling of LLMs, this procedure will inevitably introduce some noise, the overall quality of those data must be evaluated by human and reported in this paper. 
3.	It’s not clear to me where the main improvements in Table 1-3 come from, it probability comes from GPT4-Turbo annotations (supervision).

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: + How to define one step?
+ How to identify pred from the attempt? I can understand for GSM8K and MATH, there may exist answer patterns. Then how can we adapt the proposed method to other tasks, in which the answers cannot be easily extracted? To use the critic-cot for filtering, majority vote is also leveraged, which also assumes that the answers can be easily extracted (or only numbers). 
+ For the 2nd assumption (if the final answer is correct, then all the intermediate steps are correct), could the authors manually check tens of examples and provide the percentage of instances with perfect CoT reasoning? Also for the 1st assumption, it may also depend on the ability of the LLM.
soundness: 3
strengths: + The performance of the critic model is evaluated using F1, which was usually indirectly evaluated by the downstream tasks.
+ The critic-cot model may be used as an additional critic model for filtering purposes.
summary: This paper introduces a new method to train a CoT-style critic model. For a multi-step solution, the proposed Critic-CoT is can be used to refine the multi-step solution with step-level explanations and can also be used to filter response samples. The experiments are conducted on math and reasoning tasks such as GSM8K and StrategyQA.
weaknesses: + Based on the description, it seems that CoT for the critique (e.g., those in Figure 1) is not well used. Also, the formulation is a little bit confusing (e.g., l_i is +1 or -1, however, the cot part is not included in this representation). The refinement ability of the CoT-critic seems to be weak on challenging math tasks such as MATH and MATH500, as the improvements in these tasks are marginal. Though the authors claim the main difference is the CoT ability of the critic model compared with other types of critic models, the advantage of using CoT is not well justified.
+ The role of distillation: the revised step also can be regarded as re-writing answers (the quality may be better than the original human annotation due to factors such as consistency), it is somehow unclear the gains from in-domain data augmentation or from the critic-cot.
Considering the fact that 10 samples are leveraged to form the data per instance, labeled by the gpt-3.5, the process can be regarded as that best-of-10 responses are used for SFT. Using 16 retry gpt-4-Turbo to obtain the refinement data also brings the same issue.
+ The evaluation lacks strong baselines that also use NL critic models or other types of reward models (e.g., deterministic), PRM or ORM.
+ Some details are missing. Please see the question part.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: As I mentioned above. 
The question studied in the paper is very interesting, but some key experiments and analyses need to be further strengthened.
soundness: 3
strengths: First, the motivation of this paper is very interesting. How can we endow LLMs with the ability to self-reflect and self-evaluate? Regarding this point, many works have explored whether LLM can have spontaneous internal reflection ability. The author generates a large amount of step-wise feedback data through a strong LLM model, e.g., GPT4-Turbo. This is very practical.

Besides, this step-wise self-evaluate design is very practical. This type of  dataset is even more valuable than the MATH SFT data itself.

Finally, the author not only provides the main experimental results but also evaluates the self-evaluate ability of the trained model, considering indicators in dimensions such as P, R, F, and Acc. This is also relatively novel.
summary: The paper addresses the limitations of existing self-critique methods for LLMs, which primarily use simple feedback mechanisms that resemble intuitive (System-1) processing. In fact, many works have explored this issue, such as whether large language models (LLMs) can accurately reflect and how to inspire LLMs to reflect. Most works are designed based on prompt engineering.

To bridge this gap, the authors propose Critic-CoT, a framework designed to elevate LLMs' reasoning by developing a stepwise, chain-of-thought (CoT) critique process. The motivation is to enable LLMs to critique and refine their solutions autonomously, thus enhancing task-solving abilities without human annotation costs.  The author generates step-wise feedback by extensive sampling and using a strong LLM. Then based on this self-generated feedback dataset, it trains the model to have the ability of self-criticism.
weaknesses: The main problems of this paper are as follows: 
1. The experimental results seem not very satisfactory. In Table 1 and 2, it seems that the sampling + voting mechanism (self-consistency) is more effective. For example, in Table 1, Critic-CoT + Llama-3-70B-Instruct achieved an accuracy of 91.7, which seems not very advantageous. However, after adding Maj1@96, it is increased to 94.8, surpassing the method Iterative Refine proposed by the author. If the native Llama-3-70B-Instruct + Maj1@96 is used, an effect of 94.1 can also be achieved. Can the author explain this phenomenon?

2. The ability of LLMs for self-reflection and self-evaluation, as well as step-wise feedback, is interesting. However, the paper lacks a more in-depth analysis. For example, does LLM really possess this ability? Does the model trained through CRITIC-COT have this ability? From my perspective, I think LLM is unable to achieve self-reflection by completely relying on oneself. The author's carefully crafted step-wise feedback dataset can improve the mathematical performance of the model. But can it really achieve self-reflection? It seems that the experimental results provided by the author cannot effectively prove this point. I hope the author can provide a more solid analysis.

3. Although the author provides the code, it seems that I don't see the generated feedback dataset.

4. I don't quite understand what specific relationship the term "distant supervision" has with this paper. In the field of information extraction, the meaning of this term is clear. However, in "LLM for math reasoning", I don't quite understand the relationship between this term and this paper. It is recommended that the author modify the corresponding expression.


Miss References:  

Many works have explored whether LLMs really have the ability of self-reflection:   

Huang J, Chen X, Mishra S, et al. Large language models cannot self-correct reasoning yet.  ICLR24   

Zhang W, Shen Y, Wu L, et al. Self-contrast: Better reflection through inconsistent solving perspectives.  ACL24

Meta-review: This paper proposes Critic-CoT, a method designed to improve LLMs' reasoning by developing a stepwise, chain-of-thought (CoT) critique process. The approach improves LLMs to critique and refine their solutions automatically. Specifically, the authors generate step-wise feedback data by extensive sampling and using a strong LLM (gpt-4-turbo), and train LLMs with the data to gain self-critic ability. Experiments on GSM8k and MATH test sets show certain improvements by using the self-critic ability for iterative refinement or for filtering. A common concern of the results is that it’s hard to know if the improved performance is indeed due to distilling from GPT-4-turbo, or really from the proposed Critic-CoT procedure. It’d also be good to study beyond just math (GSM8K and MATH) datasets.

Decision: Reject