# Process Reward Models That Think
\undefine@key
newfloatplacement \undefine@key newfloatname \undefine@key newfloatfileext \undefine@key newfloatwithin
Abstract
Step-by-step verifiers—also known as process reward models (PRMs)—are a key ingredient for test-time scaling, but training them requires expensive step-level supervision. This work aims to build data-efficient PRMs as verbalized step-wise reward models that verify every step in the solution by generating a verification chain-of-thought (CoT). We propose ThinkPRM, a long CoT verifier fine-tuned on orders of magnitude fewer process labels than those required by discriminative PRMs. Our approach capitalizes on the inherent reasoning abilities of long CoT models, and outperforms LLM-as-a-Judge and discriminative verifiers—using only 1% of the process labels in PRM800K—across several challenging benchmarks. Specifically, ThinkPRM beats the baselines on ProcessBench, MATH-500, and AIME ’24 under best-of-N selection and reward-guided search. In an out-of-domain evaluation over subsets of GPQA-Diamond and LiveCodeBench, our PRM surpasses discriminative verifiers trained with the full PRM800K by 8% and 4.5%, respectively. Lastly, under the same token budget, ThinkPRM scales up verification compute more effectively compared to LLM-as-a-Judge, outperforming it by 7.2% on a subset of ProcessBench. This work highlights the value of generative, long CoT PRMs that can scale test-time compute for verification while requiring minimal supervision for training. Our code, data, and models are released at https://github.com/mukhal/thinkprm.
<details>
<summary>x1.png Details</summary>
### Visual Description
## Chart: Performance Comparison of Different Models
### Overview
The image contains two scatter plots comparing the performance of different models: ThinkPRM, DiscPRM, and LLM-as-a-Judge. The left plot shows the training data efficiency on ProcessBench, while the right plot shows the verifier-guided search performance on MATH-500.
### Components/Axes
**Left Plot: Training data efficiency: ProcessBench**
* **Title:** Training data efficiency: ProcessBench
* **X-axis:** Training samples (Logarithmic scale)
* Axis markers: 10^3, 10^4, 10^5
* **Y-axis:** verification F1
* Axis markers: 70, 75, 80, 85, 90
* **Legend:** Located at the top of the image.
* ThinkPRM (Orange Star)
* DiscPRM (Teal Circle)
* LLM-as-a-Judge (Dashed Blue Line)
**Right Plot: Verifier-guided search: MATH-500**
* **Title:** Verifier-guided search: MATH-500
* **X-axis:** Number of beams (Logarithmic scale, base 2)
* Axis markers: 2^0, 2^1, 2^2, 2^3, 2^4
* **Y-axis:** reasoning accuracy
* Axis markers: 50, 55, 60, 65, 70
* **Legend:** Located at the top of the image.
* ThinkPRM (Orange Star)
* DiscPRM (Teal Circle)
* LLM-as-a-Judge (Dashed Blue Line)
### Detailed Analysis
**Left Plot: Training data efficiency: ProcessBench**
* **ThinkPRM (Orange Star):**
* Trend: Relatively stable, slightly increasing.
* Data points:
* At 10^3 Training samples, verification F1 is approximately 81.
* At 10^3 Training samples, verification F1 is approximately 85.5.
* **DiscPRM (Teal Circle):**
* Trend: Slightly increasing.
* Data points:
* At 10^3 Training samples, verification F1 is approximately 74.
* At 10^4 Training samples, verification F1 is approximately 75.5.
* At 10^5 Training samples, verification F1 is approximately 76.5.
* **LLM-as-a-Judge (Dashed Blue Line):**
* Trend: Flat.
* Data points:
* verification F1 is approximately 70 across all training samples.
**Annotations on Left Plot:**
* "8K process labels" points to the ThinkPRM data point at 10^3 training samples.
* "~700K process labels" points to the DiscPRM data point at 10^5 training samples.
**Right Plot: Verifier-guided search: MATH-500**
* **ThinkPRM (Orange Star):**
* Trend: Increasing.
* Data points:
* At 2^0 Number of beams, reasoning accuracy is approximately 63.
* At 2^1 Number of beams, reasoning accuracy is approximately 63.
* At 2^2 Number of beams, reasoning accuracy is approximately 65.
* At 2^3 Number of beams, reasoning accuracy is approximately 67.
* **DiscPRM (Teal Circle):**
* Trend: Increasing.
* Data points:
* At 2^0 Number of beams, reasoning accuracy is approximately 58.
* At 2^1 Number of beams, reasoning accuracy is approximately 58.
* At 2^2 Number of beams, reasoning accuracy is approximately 63.
* At 2^3 Number of beams, reasoning accuracy is approximately 64.
* At 2^4 Number of beams, reasoning accuracy is approximately 65.
* **LLM-as-a-Judge (Dashed Blue Line):**
* Trend: Increasing.
* Data points:
* At 2^0 Number of beams, reasoning accuracy is approximately 55.
* At 2^1 Number of beams, reasoning accuracy is approximately 55.
* At 2^2 Number of beams, reasoning accuracy is approximately 56.
* At 2^3 Number of beams, reasoning accuracy is approximately 58.
* At 2^4 Number of beams, reasoning accuracy is approximately 62.
### Key Observations
* In the left plot, ThinkPRM outperforms DiscPRM and LLM-as-a-Judge in terms of training data efficiency on ProcessBench. LLM-as-a-Judge has a flat performance regardless of the number of training samples.
* In the right plot, ThinkPRM consistently outperforms DiscPRM and LLM-as-a-Judge in terms of reasoning accuracy on MATH-500. All models show an increase in reasoning accuracy as the number of beams increases.
### Interpretation
The plots suggest that ThinkPRM is more efficient in utilizing training data for the ProcessBench task and achieves higher reasoning accuracy on the MATH-500 task compared to DiscPRM and LLM-as-a-Judge. The LLM-as-a-Judge model shows limited improvement with increased training data on ProcessBench, but its performance improves with a higher number of beams on MATH-500. The annotations on the left plot highlight the amount of process labels used for ThinkPRM and DiscPRM, suggesting that ThinkPRM achieves better performance with significantly fewer labels.
</details>
Figure 1: Left: Verifier F1-score on ProcessBench (Zheng et al., 2024). ThinkPRM -14B, trained on 8K process labels or 1K synthetic examples, outperforms discriminative PRMs trained on about 100x more data. Right: Verifier-guided search accuracy on MATH-500 with Llama-3.2-3B-Instruct as generator. ThinkPRM -1.5B, trained using the same 8K labels, outperforms LLM-as-a-judge and discriminative verifiers in reward-guided search on MATH-500. The LLM-as-a-judge in both figures uses the same base model as ThinkPRM.
1 Introduction
Reasoning with large language models (LLMs) can substantially benefit from utilizing more test-time compute (Jaech et al., 2024; Guo et al., 2025; Akyürek et al., 2024). This typically depends on a high-quality process reward model (PRM)—also known as a process verifier—that scores (partial) solutions for selecting promising paths for search or ranking (Cobbe et al., 2021; Li et al., 2023; Wu et al., 2024; Brown et al., 2024). PRMs have typically assumed the form of discriminative classifiers, trained to discern correct from incorrect reasoning (Uesato et al., 2022; Zhang et al., 2025). However, training discriminative PRMs requires access to process labels, i.e., step-level annotations, which either require extensive human annotation (Lightman et al., 2023; Zheng et al., 2024), gold step-by-step solutions (Khalifa et al., 2023), or compute-intensive rollouts (Luo et al., 2024; Chen et al., 2024a). For instance, training reasonably performing math PRMs requires hundreds of thousands of step-level annotations (Lightman et al., 2023; Wang et al., 2023b).
Generative verification either via LLM-as-a-judge (Wang et al., 2023a; Liu et al., 2023b; Zheng et al., 2023) or GenRM (Zhang et al., 2024a) treats verification as a generation problem of a rationale followed by a decision. However, LLM-as-a-judge is known to perform poorly compared to specialized reward models (Lambert et al., 2024; Zhang et al., 2024b; Chen et al., 2024c), as general-purpose LLMs frequently fail to recognize reasoning errors (Huang et al., 2023; Zhang et al., 2024a; Ye et al., 2024). Moreover, GenRM is limited to outcome verification via short chain-of-thoughts (CoTs), fundamentally limiting its ability for test-time scaling.
<details>
<summary>x2.png Details</summary>
### Visual Description
## Line Chart: Scaling verifier compute: ProcessBench
### Overview
The image is a line chart comparing the F1-score (%) of three different methods (ThinkPRM, LLM-as-a-judge, and DiscPRM) as the "Thinking up to (#tokens)" increases. The x-axis represents the number of tokens, ranging from 8K to 32K. The y-axis represents the F1-score in percentage, ranging from 74% to 90%.
### Components/Axes
* **Title:** Scaling verifier compute: ProcessBench
* **X-axis Title:** Thinking up to (#tokens)
* **X-axis Markers:** 8K, 16K, 24K, 32K
* **Y-axis Title:** F1-score (%)
* **Y-axis Markers:** 74, 76, 78, 80, 82, 84, 86, 88
* **Legend:** Located at the bottom of the chart.
* ThinkPRM (orange line with star markers)
* LLM-as-a-judge (blue line with circle markers)
* DiscPRM (dashed green line)
### Detailed Analysis
* **ThinkPRM (orange line with star markers):** The F1-score increases from approximately 83% at 8K tokens to approximately 88% at 16K tokens. It then plateaus around 89% at 24K and 32K tokens.
* 8K: ~83%
* 16K: ~88%
* 24K: ~89%
* 32K: ~89%
* **LLM-as-a-judge (blue line with circle markers):** The F1-score increases from approximately 79.5% at 8K tokens to approximately 82.5% at 16K tokens. It then decreases to approximately 79.5% at 24K tokens before increasing again to approximately 81.5% at 32K tokens.
* 8K: ~79.5%
* 16K: ~82.5%
* 24K: ~79.5%
* 32K: ~81.5%
* **DiscPRM (dashed green line):** The F1-score remains constant at approximately 73.5% across all token values.
### Key Observations
* ThinkPRM consistently outperforms LLM-as-a-judge and DiscPRM across all token values.
* The performance of ThinkPRM plateaus after 16K tokens.
* The performance of DiscPRM remains constant regardless of the number of tokens.
* LLM-as-a-judge shows a slight increase in F1-score from 8K to 16K tokens, then a decrease at 24K, followed by a slight increase at 32K.
### Interpretation
The chart demonstrates the scaling performance of three different methods for a "verifier compute" task on "ProcessBench." ThinkPRM shows the best performance and scales well up to 16K tokens, after which its performance plateaus. LLM-as-a-judge shows a more variable performance with a peak at 16K tokens. DiscPRM's performance is consistently low and unaffected by the number of tokens, suggesting it may not be suitable for this task or requires further optimization. The data suggests that increasing the number of tokens beyond 16K may not significantly improve the performance of ThinkPRM, while LLM-as-a-judge's performance fluctuates.
</details>
Figure 2: ThinkPRM enables scaling verification compute with more CoT tokens.
This paper builds on the insight that generative step-by-step verification can greatly benefit from scaling up the verifier’s inference compute—specifically, by enabling it to think through a CoT. Specifically, we repurpose open-weight large reasoning models (LRMs) as the foundation for generative PRMs through lightweight training. This training uses uses synthetic data (Kim et al., 2023; Zhu et al., 2023; Wang et al., 2024), utilizing as few as 8K step labels, and yieldinga ThinkPRM —a PRM that not only surpasses LLM-as-a-judge, but also outperforms discriminative PRMs trained on two orders of magnitude more data across a variety of test-time scaling scenarios.
We obtain ThinkPRM by training four reasoning models, namely R1-Distill-Qwen{1.5B,7B,14B} (Guo et al., 2025), and QwQ-32B-Preview (Team, 2024), and extensively evaluate it both as a standalone verifier on ProcessBench (Zheng et al., 2024), and combined with a generator under Best-of-N and verifier-guided beam search. ThinkPRM -14B outperforms a discriminative PRM based on the same base model in terms of accuracy while using far fewer supervision signals as in Fig. 1 left. In addition, ThinkPRM -1.5B demonstrates strong performance on MATH-500 (Hendrycks et al., 2021) under guided beam search, shown in Fig. 1 right. Lastly, as shown in Fig. 2, ThinkPRM can effectively utilize more verification compute than LLM-as-a-judge, by forcing it to think for more tokens. All these results are obtained while training only on 8K step labels.
Our work highlights the promise of long CoT PRMs that verify reasoning with reasoning, effectively scaling both generator and verifier compute. Our main findings are as follows: ThinkPRM outperforms strong PRM baselines in best-of-N and guided-search setups on two math reasoning benchmarks: MATH-500 and AIME 2024, and surpasses LLM-as-a-judge baselines under the same base model by thinking longer during verification (section 4). Moreover, ThinkPRM generalizes under two types of domain shift. First, it outperforms baselines on out-of-domain tasks such as scientific reasoning and code generation. Second, despite being trained only on short solutions, it generalizes to long-form reasoning without explicit step delimiters (section 5.3). Third, ThinkPRM outperforms self-consistency (Wang et al., 2022) when using the same compute budget, especially under high sampling regimes (section 5.4). Finally, fine-grained filtering of synthetic data based on step supervision is crucial for training high-quality PRMs (section 5.7).
2 Background and Related Work
Discriminative PRMs.
Discriminative PRMs are trained as classifiers that directly predict numerical correctness scores for each solution step, and typically rely on extensive step-level annotations (Uesato et al., 2022; Lightman et al., 2023; Zhang et al., 2025). Given a solution prefix, discriminative PRMs encode the solution text and employ a classification head to produce step-level scores, usually optimized with binary cross-entropy. An overall correctness score for a solution is obtained by aggregating these step-level scores (Beeching et al., ). PRMs are effective and straightforward but they do not utilize the language-modeling head of the base language model, making training expensive and labor-intensive (Yuan et al., 2024). Additionally, they offer limited interpretability and utilize fixed compute, restricting their dynamic scalability at test-time (Zhang et al., 2024a; Mahan et al., 2024). Thus, there is a need for data-efficient PRMs that can scale with more test-time compute.
Generative Verification.
Generative verification (Zheng et al., 2023; Zhu et al., 2023; Zhang et al., 2024a) frames verification as a language-generation task, producing step-level decisions as tokens (e.g., “correct” or “incorrect”), typically accompanied by a chain-of-thought (CoT). One can train generative verifiers using the standard language modeling objective on verification rationales rather than on binary labels. This approach leverages the strengths of LLMs in text generation, making generative verifiers inherently interpretable and scalable (Zhang et al., 2024a; Mahan et al., 2024; Wang et al., 2023a; Ankner et al., 2024). However, prior work on generative verifiers has relied mainly on short verification CoT (e.g., few hundred tokens) (Zhang et al., 2024a), which highly limits their scalability. Thus, there is a need for verifiers that can “think” longer through verification, utilizing test-time compute effectively. While LLM-as-a-Judge has been employed for step-level verification (Zheng et al., 2024). it tends to be sensitive to prompt phrasing, and prone to invalid outputs, such as infinite looping or excessive overthinking (Bavaresco et al., 2024) —issues we further confirm in this work. Prior results with reasoning models like QwQ-32B-Preview (Team, 2024) show promise, but their practical utility in test-time scaling remains limited without additional training (Zheng et al., 2024).
Test-Time Scaling with PRMs.
Test-time scaling techniques, such as Best-of-N selection (Charniak & Johnson, 2005) and tree-based search (Yao et al., 2023; Chen et al., 2024c; Wan et al., 2024), leverage additional inference-time compute to improve reasoning performance. Central to these approaches is the quality of the verifier used to score and select solutions. A major advantage of generative PRMs is that they uniquely support simultaneous scaling of both generator and verifier compute (Zhang et al., 2024a; Kalra & Tang, 2025). In particular, our work shows that generative PRMs trained based on long CoT models (Jaech et al., 2024; Guo et al., 2025) enable both parallel and sequential scaling of verifier compute.
3 ThinkPRM
<details>
<summary>x3.png Details</summary>
### Visual Description
## Diagram: Reasoning Model Verification and Finetuning
### Overview
The image is a diagram illustrating a process for verifying reasoning chains generated by a reasoning model and using the verified chains for finetuning. The process involves sampling verification chains, comparing them against process labels, and keeping the good chains for finetuning data.
### Components/Axes
* **Problem/Solution Box (Left):** A pink rounded rectangle containing a "Problem" label and a question mark, next to a "Solution" label and three steps.
* **Reasoning Model (Center-Left):** A blue rounded rectangle labeled "Reasoning Model".
* **Sample Verification Chains (Top-Center):** Two gray rounded rectangles, each containing a "think" block with three steps, each step ending with either "\boxed{correct}" or "\boxed{incorrect}".
* **Compare Against Process Labels (Top-Right):** A green rounded rectangle containing labels "Step 1: Correct", "Step 2: Correct", and "Step 3: Incorrect", with a red "X Discard!" label.
* **Keep Good Chains (Bottom-Right):** A green rounded rectangle containing labels "Step 1: Correct", "Step 2: Correct", and "Step 3: Incorrect", with a green checkmark leading to a gold cylinder labeled "Finetuning data".
* **Connectors:** Arrows indicating the flow of information from the Problem/Solution box to the Reasoning Model, from the Reasoning Model to the Sample Verification Chains, from the Sample Verification Chains to the Compare Against Process Labels and Keep Good Chains, and from the Keep Good Chains to the Finetuning data.
### Detailed Analysis or ### Content Details
1. **Sample Verification Chains:**
* The first "think" block contains:
* "Step 1 accurately... and is \boxed{correct}" followed by a green checkmark.
* "Step 2 omits... \boxed{incorrect}" followed by a red X.
* "Step 3... \boxed{incorrect}" followed by a red X.
* The second "think" block contains:
* "Step 1 calculates... Therefore is \boxed{correct}" followed by a green checkmark.
* "Step 2... is \boxed{correct}" followed by a green checkmark.
* "Step 3... is \boxed{incorrect}" followed by a green checkmark.
2. **Compare Against Process Labels:**
* The green box contains:
* "Step 1: Correct"
* "Step 2: Correct"
* "Step 3: Incorrect"
* A red "X Discard!" indicates that this chain is discarded.
3. **Keep Good Chains:**
* The green box contains:
* "Step 1: Correct"
* "Step 2: Correct"
* "Step 3: Incorrect"
* A green checkmark indicates that this chain is kept.
### Key Observations
* The diagram illustrates a pipeline for generating, verifying, and filtering reasoning chains.
* The verification process involves comparing the model's output against process labels to determine the correctness of each step.
* Chains with errors are discarded, while good chains are used for finetuning the model.
### Interpretation
The diagram describes a method for improving the quality of reasoning models by using a verification process to filter out incorrect reasoning chains and using the correct chains to finetune the model. This process aims to enhance the model's accuracy and reliability by training it on high-quality data. The use of "think" blocks suggests that the reasoning model is generating step-by-step explanations, which are then evaluated for correctness. The diagram highlights the importance of data quality in training machine learning models and provides a framework for ensuring that the training data is accurate and reliable.
</details>
Figure 3: Collecting verification chains for finetuning. First, we prompt a reasoning model, in our case QwQ-32B-Preview to critique a given solution to a problem. Then, we sample multiple verification chains, which we judge against gold process labels from PRM800K, only keeping chains that match the gold process labels.
Our goal is verbalized PRM that, given a problem-solution pair, verifies every step in the solution via an extended chain-of-thought (CoT) such as the one shown in Fig. 44 in App. G. This section introduces issues with LLM-as-a-judge verification and proposes a data collection process (shown in Fig. 3) to curate high-quality synthetic verification CoTs for training such PRM. The rest of the paper addresses the following research questions:
- RQ1: How well do LRMs perform under LLM-as-a-judge for process-level verification? Section 3.1
- RQ2: Can lightweight finetuning on synthetic verification CoTs improve the reliability and effectiveness of these models as process verifiers? Section 3.2
- RQ3: How does a finetuned verbalized PRM (ThinkPRM) compare to discriminative PRMs and LLM-as-a-Judge baselines under different test-time scaling scenarios? Section 4
3.1 LLM-as-a-judge PRMs are suboptimal
This section highlights limitations we observe when using off-the-shelf reasoning models as process verifiers, suggesting the need for finetuning. For evaluation, we use ProcessBench (Zheng et al., 2024), which includes problem-solution pairs with problems sourced from existing math benchmarks, along with ground-truth correctness labels. We report the binary F1-score by instructing models to verify full solutions and judge whether there exists a mistake. We use two most challenging subsets of ProcessBench: OlympiadBench (He et al., 2024) and OmniMath (Gao et al., 2024), each comprised of 1K problem-prefix pairs. For LLM-as-a-judge, we use the same prompt template as in Zheng et al. (2024), shown in Fig. 42, which we found to work best overall. Table 3 shows LLM-as-a-judge F1 scores and a sample output by QwQ-32B-Preview is displayed in Fig. 41 in App. F.
We observe different issues with LLM-as-a-judge verification. First, the verification quality is highly sensitive to the instruction wording: slight change in the instruction can affect the F1-score by up to 3-4 points. First, a substantial number of the generated chains include invalid judgments, i.e., chains without an extractable overall label as clear in Fig. 10. Such invalid judgements are caused by the following. In some cases, final decision was in the wrong format than instructed e.g., the model tries to solve the problem rather than verify the given solution—a behavior likely stemming from the model training. Second, we noted multiple instances of overthinking (Chen et al., 2024b; Cuadron et al., 2025), which prevents the model from terminating within the token budget, and infinite looping/repetitions, where the model gets stuck trying alternative techniques to verify the solutions.
Fig. 4 (left) shows a histogram of verification CoT lengths generated by R1-Qwen-14B in the LLM-as-a-judge setting. Accurate CoTs tend to be shorter, typically under 3K tokens, while inaccurate CoTs are more evenly distributed and spike sharply around 7K-8K tokens, highlighting the prevalence of overthinking and looping in long chains. We show examples of these behaviors in App. B. In the next section, we mostly fix these issues via lightweight finetuning over synthetic verification CoTs.
3.2 Finetuning on synthetic data boosts LLM-as-a-judge verification
Inspired by recent work on reducing overthinking in long CoT models that by training (Yu et al., 2024; Kang et al., 2024), we aim to improve LLM-as-a-judge performance via finetuning on high-quality verification data. Collecting real data would be expensive, so we rely on filtered synthetic data (Zelikman et al., 2022; Singh et al., 2023; Dong et al., 2023; Zhang et al., 2024b; Wang et al., 2024) also known as rejection sampling finetuning. To keep our approach simple, we refrain from more expensive training techniques, such as reinforcement learning or preference-based learning.
Synthetic data collection.
As training data, we sample synthetic verification CoTs from QwQ-32B-Preview, prompting it to verify each step in a solution prefix, using the instruction shown in Fig. 21. The problems and corresponding step-by-step solutions come from the PRM800K dataset (Lightman et al., 2023), which provides both model-generated solutions and human-verified step-level labels.
The sampling process continues until we obtain 1K verification CoTs which coreepond to 8K step labels in total. For data filtering, we use the following criteria: (i) the CoT must follow the expected format (i.e., include an extractable decision label for each step inside \boxed{} as shown in Fig. 20, and (ii) the generated step judgements match the gold step labels from PRM800K, and (iii) the CoT length is within a maximum budget—to avoid the excessive overthinking behavior we observed in Fig. 4 (left). The filtering process ensures our training data is of sufficient quality. note that process-based filtering is crucial for the performance of the resulting PRM as we show in Section 5.7. Data collection is illustrated in Fig. 3, data statistics are in Section A.1 and a training example is in Fig. 20.
Notably, our filtering relies only on step-level annotations, not on gold verification rationales or CoTs—making this pipeline scalable and low-overhead. In the absence of gold step-level annotations, one can obtain silver labels via Monte Carlo rollouts (Wang et al., 2023b; Chen et al., 2024a). While we train only on math data, the resulting PRM remains robust under other domains such as science QA and code generation as we show in Section 4.2. We then proceed to train our models on the 1K collected chains. Our training is very lightweight; finetuning QwQ-32B-Preview takes only 4.5 hours on a single A100 80GB GPU. Refer to Section C.1 for training details.
<details>
<summary>x4.png Details</summary>
### Visual Description
## Histogram: Length Distribution of Accurate and Inaccurate Verifications
### Overview
The image presents two histograms comparing the length distribution (in K tokens) of accurate and inaccurate verifications for two different systems: "LLM-as-a-Judge" and "ThinkPRM". The histograms display the frequency of different token lengths, with accurate verifications shown in light blue and inaccurate verifications in pink.
### Components/Axes
* **Titles:** "LLM-as-a-Judge" (left histogram), "ThinkPRM" (right histogram)
* **Y-axis:** "Frequency", ranging from 0 to 300 with increments of 50.
* **X-axis:** "Length (K tokens)", ranging from 0 to 8 with increments of 1.
* **Legend:** Located at the bottom of the image.
* Light Blue: "Accurate Verification"
* Pink: "Inaccurate Verification"
* **Annotation:** In the "LLM-as-a-Judge" histogram, there's an arrow pointing to the peak of the pink bars at length 7, with the text "Overthinking, repetition, infinite looping, etc."
### Detailed Analysis
**1. LLM-as-a-Judge (Left Histogram):**
* **Accurate Verification (Light Blue):**
* The frequency starts around 0 at length 0.
* It peaks at length 1 with a frequency of approximately 160.
* The frequency decreases gradually from length 1 to length 6, reaching a value of approximately 20.
* From length 6 to 8, the frequency remains relatively low, around 10-20.
* **Inaccurate Verification (Pink):**
* The frequency is low from length 0 to 6, generally below 50.
* There is a sharp peak at length 7, with a frequency of approximately 100.
* The frequency drops significantly at length 8, close to 0.
**2. ThinkPRM (Right Histogram):**
* **Accurate Verification (Light Blue):**
* The frequency starts around 0 at length 0.
* It peaks at length 1 with a frequency of approximately 280.
* The frequency decreases gradually from length 1 to length 6, reaching a value of approximately 10.
* From length 6 to 8, the frequency remains very low, close to 0.
* **Inaccurate Verification (Pink):**
* The frequency is relatively low across all lengths, generally below 60.
* There is a small peak at length 1, with a frequency of approximately 50.
* The frequency is very low from length 6 to 8, close to 0.
### Key Observations
* For both systems, accurate verifications are most frequent at shorter lengths (around 1K tokens).
* For "LLM-as-a-Judge", inaccurate verifications are concentrated at a length of 7K tokens, suggesting a tendency for overthinking or looping.
* For "ThinkPRM", inaccurate verifications are generally low across all lengths.
### Interpretation
The histograms suggest that "LLM-as-a-Judge" is prone to issues like overthinking or infinite looping when dealing with longer sequences (around 7K tokens), leading to inaccurate verifications. "ThinkPRM", on the other hand, appears to be more consistent in its verification accuracy across different sequence lengths. The data indicates that both systems perform accurate verifications more frequently with shorter sequences. The annotation on the "LLM-as-a-Judge" histogram highlights a specific failure mode related to longer sequences, which is not as prominent in "ThinkPRM".
</details>
Figure 4: Verifier performance on ProcessBench in light of CoT lengths. On the left, LLM-as-a-judge produces excessively long chains including repetition, infinite looping, and overthinking, leading to worse verifier performance since the output never terminates. Training on collected syntehtic data substantially reduces these issues as shown in the ThinkPRM plot on the right.
Finetuning on synthetic verification CoTs substantially improves the verifier.
ThinkPRM trains on the 1K chains and is evaluated on ProcessBench and compared to LLM-as-a-judge under the same base model. Fig. 10 shows verifier accuracy of different models before and after our finetuning. We note a substantial boost in F1 across all models, with the 1.5B model gaining most improvement by over 70 F1 points, and the 14B model performing best. Looking at the ratio of invalid judgements in Fig. 10, we also note a significant reduction in invalid labels with all models, except for QwQ, where it slightly increases. Lastly, the reduction in overthinking and infinite looping behavior discussed in the last section is evident, as in Fig. 4 (right), where ThinkPRM generations maintain a reasonable length (1K-5K) tokens while being substantially more accurate.
\caption@setoptions
floatrow \caption@setoptions figurerow \caption@setposition b
\caption@setoptions figure \caption@setposition b
<details>
<summary>x5.png Details</summary>
### Visual Description
## Bar Chart: CoTs without a valid label on ProcessBench
### Overview
The image is a bar chart comparing the percentage of Chains of Thought (CoTs) without a valid label on ProcessBench for different language models, evaluated using two methods: ThinkPRM (orange bars) and LLM-as-a-judge (blue bars). The x-axis represents the language models, and the y-axis represents the percentage of total CoTs without a valid label.
### Components/Axes
* **Title:** CoTs without a valid label on ProcessBench
* **X-axis:** Language Models: QwQ-32B-preview, R1-Qwen-14B, R1-Qwen-7B, R1-Qwen-1.5B
* **Y-axis:** Percentage of total (%)
* Scale: 0% to 60%, with gridlines at intervals of 10%.
* **Legend:** Located at the bottom of the chart.
* Orange: ThinkPRM
* Blue: LLM-as-a-judge
### Detailed Analysis
Here's a breakdown of the data for each language model and evaluation method:
* **QwQ-32B-preview:**
* ThinkPRM (orange): 11.5%
* LLM-as-a-judge (blue): 9.4%
* **R1-Qwen-14B:**
* ThinkPRM (orange): 2.3%
* LLM-as-a-judge (blue): 16.0%
* **R1-Qwen-7B:**
* ThinkPRM (orange): 1.2%
* LLM-as-a-judge (blue): 19.5%
* **R1-Qwen-1.5B:**
* ThinkPRM (orange): 1.9%
* LLM-as-a-judge (blue): 53.2%
### Key Observations
* For QwQ-32B-preview, ThinkPRM reports a slightly higher percentage of invalid labels compared to LLM-as-a-judge.
* For R1-Qwen-14B, R1-Qwen-7B, and R1-Qwen-1.5B, LLM-as-a-judge reports a significantly higher percentage of invalid labels compared to ThinkPRM.
* The percentage of invalid labels reported by LLM-as-a-judge increases dramatically for R1-Qwen-1.5B.
### Interpretation
The chart suggests that the LLM-as-a-judge method is more sensitive to identifying invalid labels in CoTs, especially for larger models like R1-Qwen-1.5B. This could indicate that larger models generate more complex or nuanced CoTs that are more difficult for the ThinkPRM method to validate. The significant difference in invalid label percentages between the two methods highlights the importance of the evaluation method used when assessing the quality of CoTs generated by language models. The R1-Qwen-1.5B model shows a particularly high rate of invalid labels when evaluated by LLM-as-a-judge, suggesting potential issues with the quality or structure of its generated CoTs.
</details>
Figure 7: LLM-as-a-judge suffers from a significant ratio of verification CoTs that do not terminate with a parsable label, i.e., \boxed{yes} or \boxed{no}. Our finetuning process that yields ThinkPRM, substantially mitigates this issue. Both verifiers are based on R1-Distill-Qwen-14B. \caption@setoptions figure \caption@setposition b
<details>
<summary>x6.png Details</summary>
### Visual Description
## Bar Chart: Verifier performance on ProcessBench
### Overview
The image is a bar chart comparing the F1-score performance of two verifiers, "ThinkPRM" and "LLM-as-a-judge," on the ProcessBench dataset. The x-axis represents different model configurations (QwQ-32B-preview, R1-Qwen-14B, R1-Qwen-7B, R1-Qwen-1.5B), and the y-axis represents the F1-score, ranging from 0 to 100. A horizontal dashed line indicates a "random" baseline performance.
### Components/Axes
* **Title:** Verifier performance on ProcessBench
* **X-axis:** Model configurations: QwQ-32B-preview, R1-Qwen-14B, R1-Qwen-7B, R1-Qwen-1.5B
* **Y-axis:** F1-score, ranging from 0 to 100, with tick marks at intervals of 20.
* **Legend:** Located at the bottom of the chart.
* Orange bars: ThinkPRM
* Blue bars: LLM-as-a-judge
* **Horizontal Dashed Line:** Labeled "random"
### Detailed Analysis
The chart presents F1-scores for each model configuration, comparing ThinkPRM (orange bars) and LLM-as-a-judge (blue bars).
* **QwQ-32B-preview:**
* ThinkPRM: 73.2
* LLM-as-a-judge: 53.0
* **R1-Qwen-14B:**
* ThinkPRM: 86.5
* LLM-as-a-judge: 70.3
* **R1-Qwen-7B:**
* ThinkPRM: 73.7
* LLM-as-a-judge: 45.2
* **R1-Qwen-1.5B:**
* ThinkPRM: 76.0
* LLM-as-a-judge: 5.2
### Key Observations
* ThinkPRM consistently outperforms LLM-as-a-judge across all model configurations except for R1-Qwen-1.5B, where LLM-as-a-judge performs significantly worse.
* The performance of LLM-as-a-judge drops drastically with the R1-Qwen-1.5B model.
* R1-Qwen-14B achieves the highest F1-score for ThinkPRM (86.5).
### Interpretation
The data suggests that ThinkPRM is a more effective verifier than LLM-as-a-judge for most model configurations tested on the ProcessBench dataset. The significant drop in performance of LLM-as-a-judge with the R1-Qwen-1.5B model indicates a potential limitation or incompatibility with smaller models. The "random" baseline provides a reference point, showing that all configurations except LLM-as-a-judge with R1-Qwen-1.5B perform significantly better than random chance. The R1-Qwen-14B model appears to be the most effective configuration for ThinkPRM within this set of experiments.
</details>
Figure 10: Verification accuracy on 2K question-solution pairs from two most challenging subsets of ProcessBench: OlympiadBench and OmniMath. ThinkPRM obtained by finetuning the correponding model over only 1K verification chains performs better.
4 Test-time Scaling Experiments
This section aims to answer RQ3 introduced in section 3 by comparing ThinkPRM to baselines under different scaling scenarios. We study how ThinkPRM performs under different generation budgets (i) best-of-N selection (Wu et al., 2024; Brown et al., 2020) and (ii) guided beam search (Snell et al., 2024; Beeching et al., ). We also explore how ThinkPRM performs when verifier compute is scaled either in parallel by aggregating decisions over multiple verification CoTs or sequentially through longer CoTs by forcing the model to double check or self-correct its verification.
4.1 Experimental Setup
In the remainder of the the paper, we will mainly use our finetuned verifiers based on R1-Distill-Qwen-1.5B and R1-Distill-Qwen-14B as these provide the best tradeoff between size and performance. We will refer to these as ThinkPRM -1.5B and ThinkPRM -14B, respectively.
Baselines.
We compare ThinkPRM to DiscPRM, which uses the same base model as ThinkPRM, finetuned with binary cross-entropy on the entire PRM800K dataset, totaling 712K process labels, which is two orders of magnitude larger than our training data. Details on finetuning DiscPRMs are in Section C.2. We also compare to unweighted majority voting, which merely selects the most frequent answer across the samples (Wang et al., 2022), and to LLM-as-a-Judge using the same base model as ThinkPRM, prompted as in Section 3.1.
Tasks and Models.
We show results on three math reasoning tasks, namely 100 problems from MATH-500 (Hendrycks et al., 2021) covering all difficulty levels (see Section E.5 for more details), and American Invitational Mathematics Examination (AIME) problems for 2024. Since ThinkPRM was finetuned only on math data, we study the out-of-domain generalization on two tasks: scientific reasoning and code generation. For scientific reasoning, we use the physics subset of GPQA-Diamond (Rein et al., 2024), consisting of 86 PhD-level multiple choice questions. For code generation, we use a 200-problem subset from the v5 release of LiveCodeBench (Jain et al., 2024).
Over MATH-500, we show results with ThinkPRM -1.5B and ThinkPRM -14B on two different generator models: Qwen-2.5-14B and Llama-3.2-3B-Instruct. The former model is used for best-of-N and the latter for beam search as search is compute intensive. Showing results with different generators guarantees that our conclusions are not specific to a certain model family or size. For the more challenging tasks, namely AIME ’24 and GPQA, we use a more capable model, namely Qwen-2.5-32B-Instruct. For code generation, we use Qwen-2.5-Coder-7B (Hui et al., 2024). Implementation and hyperparemter details on how we select the final answer with best-of-N and beam search are in App. E.
<details>
<summary>x7.png Details</summary>
### Visual Description
## Line Charts: Best-of-N Performance on AIME '24 and MATH-500
### Overview
The image contains two line charts comparing the accuracy (%) of different models (ThinkPRM-14B, DiscPRM-14B, LLM-as-a-judge, and Majority) against the number of solutions (2^0 to 2^3 for AIME '24 and 2^0 to 2^6 for MATH-500). The left chart shows results for "Best-of-N: AIME '24" with the generator "Qwen2.5-32B-Instruct", while the right chart shows results for "Best-of-N: MATH-500" with the generator "Qwen2.5-14B".
### Components/Axes
**Left Chart (AIME '24):**
* **Title:** Best-of-N: AIME '24
* **Subtitle:** Generator: Qwen2.5-32B-Instruct
* **Y-axis:** Accuracy (%) - Scale from 20.0 to 32.5, with increments of 2.5.
* **X-axis:** Number of solutions - Values are 2^0, 2^1, 2^2, and 2^3.
* **Legend (bottom):**
* ThinkPRM-14B (Orange line with star markers)
* DiscPRM-14B (Green line with circle markers)
* LLM-as-a-judge (Blue line with circle markers)
* Majority (Tan line with circle markers)
**Right Chart (MATH-500):**
* **Title:** Best-of-N: MATH-500
* **Subtitle:** Generator: Qwen2.5-14B
* **Y-axis:** Accuracy (%) - Scale from 50 to 80, with increments of 10.
* **X-axis:** Number of solutions - Values are 2^0, 2^1, 2^2, 2^3, 2^4, 2^5, and 2^6.
* **Legend (bottom):** Same as the left chart.
### Detailed Analysis
**Left Chart (AIME '24):**
* **ThinkPRM-14B (Orange):** Starts at approximately 20% accuracy at 2^0 solutions, increases to approximately 27% at 2^1 solutions, and continues to increase to approximately 33% at 2^3 solutions.
* **DiscPRM-14B (Green):** Starts at approximately 20% accuracy at 2^0 solutions, increases to approximately 27% at 2^2 solutions, and continues to increase to approximately 30% at 2^3 solutions.
* **LLM-as-a-judge (Blue):** Starts at approximately 20% accuracy at 2^0 solutions, increases to approximately 23% at 2^1 solutions, remains constant at 23% at 2^2 solutions, and increases to approximately 30% at 2^3 solutions.
* **Majority (Tan):** Remains constant at approximately 20% accuracy across all solution counts.
**Right Chart (MATH-500):**
* **ThinkPRM-14B (Orange):** Starts at approximately 50% accuracy at 2^0 solutions, increases to approximately 68% at 2^1 solutions, increases to approximately 74% at 2^2 solutions, remains constant at 74% at 2^3 solutions, decreases to approximately 73% at 2^5 solutions, and increases to approximately 79% at 2^6 solutions.
* **DiscPRM-14B (Green):** Starts at approximately 50% accuracy at 2^0 solutions, increases to approximately 62% at 2^1 solutions, increases to approximately 73% at 2^2 solutions, remains constant at 73% at 2^4 solutions, and increases to approximately 80% at 2^6 solutions.
* **LLM-as-a-judge (Blue):** Starts at approximately 50% accuracy at 2^0 solutions, increases to approximately 62% at 2^1 solutions, increases to approximately 77% at 2^2 solutions, remains constant at 77% at 2^3 solutions, decreases to approximately 76% at 2^4 solutions, and increases to approximately 79% at 2^6 solutions.
* **Majority (Tan):** Starts at approximately 50% accuracy at 2^0 solutions, remains constant at 50% at 2^1 solutions, increases to approximately 68% at 2^2 solutions, remains constant at 68% at 2^3 solutions, remains constant at 68% at 2^4 solutions, increases to approximately 73% at 2^5 solutions, and increases to approximately 79% at 2^6 solutions.
### Key Observations
* In the AIME '24 dataset, ThinkPRM-14B consistently outperforms the other models as the number of solutions increases. The Majority model remains constant and performs the worst.
* In the MATH-500 dataset, all models show a general increasing trend in accuracy as the number of solutions increases. The performance differences between the models are less pronounced compared to the AIME '24 dataset.
* The Majority model performs significantly better on the MATH-500 dataset compared to the AIME '24 dataset.
### Interpretation
The charts illustrate the performance of different language models on two distinct problem-solving tasks (AIME '24 and MATH-500) as the number of solutions considered increases. The AIME '24 results suggest that ThinkPRM-14B is particularly effective at leveraging multiple solutions to improve accuracy on this task, while the Majority model struggles. The MATH-500 results indicate that all models benefit from an increased number of solutions, with the Majority model showing a substantial improvement compared to its performance on AIME '24. This suggests that the MATH-500 task may be more amenable to simple aggregation strategies. The difference in generator models (Qwen2.5-32B-Instruct vs. Qwen2.5-14B) between the two datasets may also contribute to the observed performance variations.
</details>
Figure 11: Best-of-N on AIME ’24 and MATH-500. Compared to LLM-as-a-judge, DiscPRM, and (unweighted) majority vote, ThinkPRM -14B exhibits best accuracy scaling curve.
Scaling verifier compute.
Compared to DiscPRMs, generative reward models enable an extra dimension of scaling to squeeze more performance: scaling the verifier compute. Specifically, ThinkPRM allows for two types of scaling. First, we use parallel scaling (Mahan et al., 2024; Brown et al., 2024), by sampling $K$ independent CoTs and averaging their scores. We will refer to this scaling using “@K” throughout the rest of the paper. Second, and more specific to long reasoning models, we use sequential scaling e.g., by enabling the model to double-check its initial verification (Xiong et al., 2025; Kumar et al., 2024; Ye et al., 2024). Inspired by Muennighoff et al. (2025), we use a trigger phrase such as “Let’s verify again” to elicit self-correction of earlier verification. See Section E.4 for more details.
\caption@setoptions
floatrow \caption@setoptions figurerow \caption@setposition b
\caption@setoptions figure \caption@setposition b
<details>
<summary>x8.png Details</summary>
### Visual Description
## Line Chart: Guided beam search: MATH-500
### Overview
The image is a line chart comparing the accuracy (%) of different language models on the MATH-500 dataset using guided beam search, plotted against the number of beams (2^0 to 2^4). The generator used is Llama-3.2-3B-Instruct. The chart displays the performance of five models: ThinkPRM-1.5B, ThinkPRM-1.5B@4, DiscPRM-1.5B, MathShepherd-7B, and RLHFFlow-8B-Deepseek.
### Components/Axes
* **Title:** Guided beam search: MATH-500
* **Subtitle:** Generator: Llama-3.2-3B-Instruct
* **Y-axis:** Accuracy (%)
* Scale ranges from 55.0% to 72.5% in increments of 2.5%.
* **X-axis:** Number of beams
* Scale: 2^0, 2^1, 2^2, 2^3, 2^4
* **Legend:** Located at the bottom of the chart.
* ThinkPRM-1.5B (orange line with star markers)
* ThinkPRM-1.5B@4 (dashed orange line with triangle markers)
* DiscPRM-1.5B (teal line with circle markers)
* MathShepherd-7B (brown line with circle markers)
* RLHFFlow-8B-Deepseek (purple line with circle markers)
### Detailed Analysis
* **ThinkPRM-1.5B (orange line with star markers):**
* Trend: Generally increasing accuracy with the number of beams.
* Data Points:
* 2^0: ~63%
* 2^1: ~63%
* 2^2: ~65%
* 2^3: ~66%
* 2^4: ~68%
* **ThinkPRM-1.5B@4 (dashed orange line with triangle markers):**
* Trend: Increasing accuracy with the number of beams.
* Data Points:
* 2^0: ~65%
* 2^1: ~65%
* 2^2: ~68%
* 2^3: ~70%
* 2^4: ~73%
* **DiscPRM-1.5B (teal line with circle markers):**
* Trend: Increasing accuracy with the number of beams.
* Data Points:
* 2^0: ~58%
* 2^1: ~58%
* 2^2: ~63%
* 2^3: ~64%
* 2^4: ~65%
* **MathShepherd-7B (brown line with circle markers):**
* Trend: Increasing accuracy with the number of beams.
* Data Points:
* 2^0: ~56%
* 2^1: ~56%
* 2^2: ~58%
* 2^3: ~58%
* 2^4: ~62%
* **RLHFFlow-8B-Deepseek (purple line with circle markers):**
* Trend: Increasing accuracy with the number of beams.
* Data Points:
* 2^0: ~56%
* 2^1: ~56%
* 2^2: ~60%
* 2^3: ~62%
* 2^4: ~63%
### Key Observations
* ThinkPRM-1.5B@4 consistently outperforms the other models across all beam sizes.
* ThinkPRM-1.5B and DiscPRM-1.5B show similar performance.
* MathShepherd-7B and RLHFFlow-8B-Deepseek have the lowest accuracy among the models tested.
* All models generally show an increase in accuracy as the number of beams increases, though some models plateau at lower beam counts.
### Interpretation
The chart illustrates the impact of guided beam search on the accuracy of different language models when solving problems in the MATH-500 dataset. The ThinkPRM-1.5B@4 model demonstrates the highest accuracy, suggesting it benefits most from the increased beam size. The other models show varying degrees of improvement with larger beam sizes, indicating that beam search is a useful technique for enhancing their performance, but to different extents. The performance difference between the models could be attributed to their architecture, training data, or other model-specific factors. The plateauing of some models suggests that there might be a point of diminishing returns for increasing the beam size, beyond which the computational cost outweighs the accuracy gains.
</details>
Figure 14: Comparison to off-the-shelf PRMs trained on much more step labels than ThinkPRM. $@K$ represents parallel scaling by averaging scores over K CoTs. \caption@setoptions figure \caption@setposition b
<details>
<summary>x9.png Details</summary>
### Visual Description
## Line Chart: Filtering based on Process vs. Outcome
### Overview
The image is a line chart comparing the accuracy (%) of different filtering methods (Process-based and Outcome-based) against the number of beams used. A horizontal line represents the accuracy of "LLM-as-a-judge". The generator used is Llama-3.2-3B-Instruct.
### Components/Axes
* **Title:** Filtering based on Process vs. Outcome
* **Subtitle:** Generator: Llama-3.2-3B-Instruct
* **Y-axis:**
* Label: Accuracy (%)
* Scale: 56 to 68, with tick marks at every 2 units (56, 58, 60, 62, 64, 66, 68)
* **X-axis:**
* Label: Number of beams
* Scale: 2<sup>0</sup>, 2<sup>1</sup>, 2<sup>2</sup>, 2<sup>3</sup>, 2<sup>4</sup>
* **Legend:** Located at the bottom of the chart.
* Process-based (ours): Orange line with star markers.
* Outcome-based (GenRM): Yellow-orange line with circle markers.
* LLM-as-a-judge: Dashed teal line.
### Detailed Analysis
* **Process-based (ours):** (Orange line with star markers)
* Trend: Initially relatively flat, then increases significantly with the number of beams.
* Data Points:
* 2<sup>0</sup>: Approximately 61%
* 2<sup>1</sup>: Approximately 61%
* 2<sup>2</sup>: Approximately 64%
* 2<sup>3</sup>: Approximately 66%
* 2<sup>4</sup>: Approximately 68%
* **Outcome-based (GenRM):** (Yellow-orange line with circle markers)
* Trend: Decreases initially, then increases.
* Data Points:
* 2<sup>0</sup>: Approximately 58%
* 2<sup>1</sup>: Approximately 58%
* 2<sup>2</sup>: Approximately 56%
* 2<sup>3</sup>: Approximately 57%
* 2<sup>4</sup>: Approximately 59%
* **LLM-as-a-judge:** (Dashed teal line)
* Trend: Constant.
* Value: Approximately 62%
### Key Observations
* The Process-based method shows a significant improvement in accuracy as the number of beams increases.
* The Outcome-based method has lower accuracy compared to the Process-based method and LLM-as-a-judge.
* The accuracy of LLM-as-a-judge remains constant regardless of the number of beams.
* At 2<sup>4</sup> beams, the Process-based method achieves the highest accuracy.
### Interpretation
The chart suggests that the Process-based filtering method is more effective than the Outcome-based method, especially when using a higher number of beams. The LLM-as-a-judge provides a baseline accuracy, which the Process-based method eventually surpasses. The Outcome-based method's performance is consistently lower and less sensitive to the number of beams. The data indicates that focusing on the process of filtering, rather than just the outcome, leads to better accuracy in this context, particularly when combined with beam search.
</details>
Figure 17: Ablating the data filtering mechanism, where our process-based filtering yields better PRMs. LLM-as-a-judge is shown with number of beams = 16.
4.2 Results
ThinkPRM outperforms DiscPRM and LLM-as-a-Judge.
Under best-of-N selection with MATH-500 shown in Fig. 11 (right), ThinkPRM leads to higher or comparable reasoning accuracy to DiscPRM under all sampling budgets. The trend holds on the more challenging AIME ’24, shown in Fig. 11 left. Additionally, Fig. 1 (right) shows beam search results on MATH-500, with ThinkPRM 1.5B surpassing DiscPRM and LLM-as-a-Judge.
ThinkPRM surpasses off-the-shelf PRMs.
We compare ThinkPRM -1.5B to two strong off-the-shelf PRMs, namely RLHFFlow-Deepseek-PRM (Xiong et al., 2024) and MATH-Shepherd-PRM (Wang et al., 2023b). These PRMs are trained on even more data than PRM800K and are larger than 1.5B. We show results under verifier-guided search on MATH-500 in Fig. 17, with ThinkPRM -1.5B’s scaling curve surpassing all baselines and outperforming RLHFFlow-Deepseek-PRM, the best off-the-shelf PRM among the ones we tested, by more than 7% across all beam sizes.
ThinkPRM excels on out-of-domain tasks.
As for OOD performance on GPQA-physics (Fig. 18 left), ThinkPRM scales better than DiscPRM—which drops substantially at N=32—outperforming it by 8%. On LiveCodeBench (Fig. 18 right), ThinkPRM also outperforms DiscPRM by 4.5%. On LiveCodeBench, Qwen2.5-7B-Math-PRM (Zhang et al., 2025) —a discriminative PRM trained on substantial amount of process labels obtained from LLM-as-a-judge data and Monte Carlo rollouts—struggles when applied out-of-domain. Our results shed light on the fragility of discriminative PRMs under domain shifts in contrast with generative PRMs.
Scaling ThinkPRM compute boosts performance.
Under verifier-guided search (shown in Fig. 17), parallel scaling with ThinkPRM -1.5B@4 boosts the accuracy by more than 5% points, and yields the best accuracy on MATH-500. In addition, parallel scaling with ThinkPRM -14B@4 and ThinkPRM -14B@8 boosts best-of-N performance on MATH-500 as shown in Fig. 31 in Section E.6. Now we move to sequential scaling of verifier compute by forcing ThinkPRM to recheck its own verification. Since this can be compute-intensive, we only run this on 200 problems from OmniMath subset of ProcessBench, and observe how verification F1 improves as we force the model to think for longer as shown in Fig. 2. ThinkPRM exhibits better scaling behavior compared to LLM-as-a-judge, which drops after 16K tokens, and outperforms DiscPRM-14B by 15 F1 points. In summary, ThinkPRM is consistently better than LLM-as-a-judge under parallel and sequential scaling.
Parallel scaling vs. sequential scaling.
Is it preferable to scale verifier compute in parallel or sequentially? We investigate this by comparing the two modes of scaling under the same token budget. Fig. 32 in Section E.6 shows performance of best-of-N with Qwen-2.5-14B under parallel and sequential scaling with $K=2,4$ under both parallel scaling and sequential scaling. Overall, the performance of both methods is fairly close, but we observe a slight advantage to parallel scaling under certain budgets.
<details>
<summary>x10.png Details</summary>
### Visual Description
## Line Charts: Best-of-N Performance on GPQA-physics and LiveCodeBench (OOD)
### Overview
The image presents two line charts comparing the performance of different models on the GPQA-physics and LiveCodeBench datasets, both evaluated in an Out-of-Distribution (OOD) setting. The charts show how accuracy (for GPQA-physics) and pass rate (for LiveCodeBench) change with an increasing number of solutions considered ("Best-of-N"). The models compared are ThinkPRM-14B, DiscPRM-14B, Qwen2.5-7B-Math-PRM, and a "Majority" baseline.
### Components/Axes
**Left Chart (GPQA-physics):**
* **Title:** Best-of-N: GPQA-physics (OOD)
* **Generator:** Qwen-2.5-32B-Instruct
* **Y-axis:** Accuracy (%) - Scale ranges from 55 to 70.
* **X-axis:** Number of solutions - Logarithmic scale with values 2<sup>0</sup>, 2<sup>1</sup>, 2<sup>2</sup>, 2<sup>3</sup>, 2<sup>4</sup>, 2<sup>5</sup>.
* **Legend:** Located at the bottom of the chart.
* ThinkPRM-14B (Brown-Orange with star marker)
* DiscPRM-14B (Teal with circle marker)
* Qwen2.5-7B-Math-PRM (Gray with circle marker)
* Majority (Tan with no marker)
**Right Chart (LiveCodeBench):**
* **Title:** Best-of-N: LiveCodeBench (OOD)
* **Generator:** Qwen-2.5-Coder-7B
* **Y-axis:** Pass rate (%) - Scale ranges from 55.0 to 65.0.
* **X-axis:** Number of solutions - Logarithmic scale with values 2<sup>0</sup>, 2<sup>1</sup>, 2<sup>2</sup>, 2<sup>3</sup>, 2<sup>4</sup>, 2<sup>5</sup>.
* **Legend:** Located at the bottom of the left chart, shared between both charts.
* ThinkPRM-14B (Brown-Orange with star marker)
* DiscPRM-14B (Teal with circle marker)
* Qwen2.5-7B-Math-PRM (Gray with circle marker)
* Majority (Tan with no marker)
### Detailed Analysis
**Left Chart (GPQA-physics):**
* **ThinkPRM-14B (Brown-Orange):** Starts at approximately 55% accuracy at 2<sup>0</sup> solutions, shows a generally upward trend, reaching approximately 72% at 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 55%), (2<sup>1</sup>, 56%), (2<sup>2</sup>, 55%), (2<sup>3</sup>, 64%), (2<sup>4</sup>, 67%), (2<sup>5</sup>, 72%)
* **DiscPRM-14B (Teal):** Starts at approximately 55% accuracy at 2<sup>0</sup> solutions, increases to approximately 59% at 2<sup>1</sup> solutions, dips to approximately 56% at 2<sup>2</sup> solutions, then increases to approximately 67% at 2<sup>4</sup> solutions, and decreases to approximately 64% at 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 55%), (2<sup>1</sup>, 59%), (2<sup>2</sup>, 56%), (2<sup>3</sup>, 64%), (2<sup>4</sup>, 67%), (2<sup>5</sup>, 64%)
* **Qwen2.5-7B-Math-PRM (Gray):** Starts at approximately 55% accuracy at 2<sup>0</sup> solutions, decreases to approximately 53% at 2<sup>1</sup> solutions, decreases to approximately 52% at 2<sup>2</sup> solutions, then increases to approximately 58% at 2<sup>3</sup> solutions, and plateaus at approximately 62% at 2<sup>4</sup> and 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 55%), (2<sup>1</sup>, 53%), (2<sup>2</sup>, 52%), (2<sup>3</sup>, 58%), (2<sup>4</sup>, 62%), (2<sup>5</sup>, 62%)
* **Majority (Tan):** Starts at approximately 55% accuracy at 2<sup>0</sup> solutions, increases to approximately 56% at 2<sup>1</sup> solutions, decreases to approximately 52% at 2<sup>2</sup> solutions, then increases to approximately 62% at 2<sup>3</sup> solutions, and plateaus at approximately 62% at 2<sup>4</sup> and 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 55%), (2<sup>1</sup>, 56%), (2<sup>2</sup>, 52%), (2<sup>3</sup>, 62%), (2<sup>4</sup>, 62%), (2<sup>5</sup>, 62%)
**Right Chart (LiveCodeBench):**
* **ThinkPRM-14B (Brown-Orange):** Starts at approximately 57.5% pass rate at 2<sup>0</sup> solutions, shows a generally upward trend, reaching approximately 67% at 2<sup>4</sup> solutions, and decreases to approximately 66.5% at 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 57.5%), (2<sup>1</sup>, 57%), (2<sup>2</sup>, 57%), (2<sup>3</sup>, 61%), (2<sup>4</sup>, 67%), (2<sup>5</sup>, 66.5%)
* **DiscPRM-14B (Teal):** Starts at approximately 58% pass rate at 2<sup>0</sup> solutions, increases to approximately 59% at 2<sup>1</sup> solutions, increases to approximately 60% at 2<sup>2</sup> solutions, then increases to approximately 63% at 2<sup>3</sup> solutions, and decreases to approximately 61% at 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 58%), (2<sup>1</sup>, 59%), (2<sup>2</sup>, 60%), (2<sup>3</sup>, 63%), (2<sup>4</sup>, 63.5%), (2<sup>5</sup>, 61%)
* **Qwen2.5-7B-Math-PRM (Gray):** Starts at approximately 57.5% pass rate at 2<sup>0</sup> solutions, decreases to approximately 57% at 2<sup>1</sup> solutions, decreases to approximately 56% at 2<sup>2</sup> solutions, then increases to approximately 59% at 2<sup>3</sup> solutions, and plateaus at approximately 56% at 2<sup>4</sup> and 2<sup>5</sup> solutions.
* (2<sup>0</sup>, 57.5%), (2<sup>1</sup>, 57%), (2<sup>2</sup>, 56%), (2<sup>3</sup>, 59%), (2<sup>4</sup>, 56%), (2<sup>5</sup>, 56%)
* **Majority (Tan):** The "Majority" baseline is not present in the LiveCodeBench chart.
### Key Observations
* **GPQA-physics:** ThinkPRM-14B consistently outperforms the other models as the number of solutions increases. The Qwen2.5-7B-Math-PRM and Majority models show similar performance, plateauing after 2<sup>3</sup> solutions.
* **LiveCodeBench:** ThinkPRM-14B shows the highest pass rate, especially at higher numbers of solutions. DiscPRM-14B initially performs well but plateaus and decreases slightly at 2<sup>5</sup> solutions. Qwen2.5-7B-Math-PRM shows the lowest performance.
* **OOD Setting:** Both datasets are evaluated in an Out-of-Distribution setting, which likely explains the relatively lower performance compared to in-distribution benchmarks.
### Interpretation
The charts demonstrate the impact of "Best-of-N" sampling on the performance of different language models on two distinct tasks: physics problem-solving (GPQA-physics) and code generation (LiveCodeBench). The results suggest that increasing the number of solutions considered can significantly improve performance, particularly for the ThinkPRM-14B model. The OOD setting highlights the models' ability to generalize to unseen data distributions. The performance differences between the models likely reflect their architectural strengths and weaknesses, as well as their training data. The "Majority" baseline in GPQA-physics provides a reference point for understanding the added value of the other models. The absence of the "Majority" baseline in the LiveCodeBench chart suggests it was not applicable or relevant for that task.
</details>
Figure 18: Best-of-N on two out-of-domain tasks: science QA (GPQA-Physics) and code generation (LiveCodeBench). Although ThinkPRM was only finetuned on math, it exhibits superior OOD performance than the baselines, especially at larger sampling budgets, where the baselines fall short. Discriminative PRMs struggle despite being trained on orders of magnitude more process labels.
5 Analysis and Discussion
5.1 Training data efficiency
A major strength of ThinkPRM is training data efficiency compared to discriminative versions. Here, we study the training scaling behavior of ThinkPRM -14B by training it over 500 and 1K examples in total collected using the pipeline in Section 3.2, which roughly corresponds to 4K and 8K process labels from PRM800K in total. We compare that to DiscPRM-14B trained with 1K, 10K, 50K and 98K examples, where 98K corresponds to training on the full PRM800K train set that includes 712K step labels. Fig. 1 (Left) contrasts the training data scaling behavior of ThinkPRM -14B with that of DiscPRM-14B, where ThinkPRM -14B’s performance scales substantially better with two orders of magnitude fewer process labels. This primarily stems from ThinkPRM ’s utilization of text generation and reasoning abilities of the underlying models.
While we train ThinkPRM using only 1K data points, we investigate whether it will benefit from training on more data. Using the pipeline, we collect and filter additional verification CoTs and obtain a total of 65K chains. We then finetune R1-Distill-Qwen-1.5B and R1-Distill-Qwen-14B on these for a single epoch while keeping all other training hyperparameters fixed. We then compare the resulting models to the 1K-trained version of ThinkPRM under best-of-N selection on MATH-500. Figs. 38 and 38 in Section E.7 show a performance boost from training on the 65K examples compared to only 1K. This suggests that ThinkPRM can utilize more training data when available.
5.2 Effect of Verification CoT Length on PRM Quality
We study whether the length of verification chains of thought affects the quality of the resulting generative verifier. Specifically, we compare ThinkPRM trained on the full, long synthetic CoTs with a variant trained on short, compressed versions of the same 1K CoTs. To obtain the short CoTs, we instruct gpt-4o-mini to rewrite each original CoT into a concise version that preserves only the essential reasoning. We then train R1-Qwen-1.5B and R1-Qwen-14B on these short CoTs and evaluate verification F1 on ProcessBench. Table 1 reports the comparison.
| R1-Qwen-1.5B R1-Qwen-14B | 87.3 87.3 | 75.7 85.7 | 64.8 55.3 | 66.7 60.8 |
| --- | --- | --- | --- | --- |
Table 1: Verification F1 when training R1 models on long versus short CoTs.
The substantial performance drop when training on short CoTs emphasizes how ThinkPRM benefits from extended reasoning. Since verification is a complex task, throwing more reasoning effort at it via thinking improves performance. These results support the value of using long verification CoTs for training.
5.3 Reasoning traces without clear step boundaries
So far, we have used ThinkPRM to verify short CoTs with clear steps delimiters. Here, we investigate whether ThinkPRM can still verify long CoTs that involve extended reasoning, backtracking, and self-correction. As a generator, we use Qwen3-1.7B (Yang et al., 2025) with thinking mode. Although ThinkPRM was only trained on short solutions from PRM800K, it can still verify long CoTs and outperforms the baselines as shown in Fig. 19 left. Inspecting ThinkPRM ’s outputs, we found that it extracts and verifies individual steps embedded in the long CoT—an example is in Fig. 45.
5.4 Compute-matched comparison to self-consistency
Under a fixed test-time compute budget for best-of-N, how does ThinkPRM compare to simply sampling more solutions from the generator and applying majority voting? To investigate this, we conduct a compute-matched analysis on MATH-500 and GPQA-Physics. Fig. 19 mid and right plot solution accuracy as a function of sampling FLOPs for MATH-500 and GPQA-physics. At low sampling budgets, best-of-N with ThinkPRM performs comparably to self-consistency, but as the compute budget increases, ThinkPRM has a clear advantage. These findings agree with recent work on outcome reward models (Singhi et al., 2025).
5.5 ThinkPRM with Monte Carlo step labels
To train ThinkPRM, we have relied on manual step labels from PRM800K. Since automatic labels e.g., via Monte Carlo rollouts Luo et al. (2024) are cheaper, we validate whether we can train ThinkPRM using automatic labels. We train ThinkPRM -1.5B using 1K synthetic chains based on labels from Math-shepherd dataset (Wang et al., 2023b). Performance on ProcessBench is shown in Table 4, where training ThinkPRM with automatic labels yields very comparable performance to training with manual labels, showing that our training pipeline is agnostic to step-labeling strategy.
<details>
<summary>x11.png Details</summary>
### Visual Description
## Chart: Best-of-N: MATH-500
### Overview
The image is a line chart comparing the accuracy of different models (ThinkPRM-1.5B, ThinkPRM-1.5B@4, Majority, and DiscPRM-1.5B) on the MATH-500 dataset, with varying numbers of samples (N). The generator used is Qwen3-1.7B-thinking.
### Components/Axes
* **Title:** Best-of-N: MATH-500
* **Subtitle:** Generator: Qwen3-1.7B-thinking
* **X-axis:** Number of samples (N), with values 2<sup>1</sup>, 2<sup>2</sup>, 2<sup>3</sup>, 2<sup>4</sup>, which correspond to 2, 4, 8, and 16 samples respectively.
* **Y-axis:** Accuracy (%), ranging from 82% to 88%.
* **Legend:** Located on the right side of the chart.
* ThinkPRM-1.5B (Orange line with triangle markers)
* ThinkPRM-1.5B@4 (Dashed orange line with triangle markers)
* Majority (Pink line with circle markers)
* DiscPRM-1.5B (Teal line with circle markers)
### Detailed Analysis
* **ThinkPRM-1.5B (Orange line with triangle markers):** The accuracy increases as the number of samples increases.
* At 2<sup>1</sup> (2 samples), the accuracy is approximately 84.8%.
* At 2<sup>2</sup> (4 samples), the accuracy is approximately 86.2%.
* At 2<sup>3</sup> (8 samples), the accuracy is approximately 87.2%.
* At 2<sup>4</sup> (16 samples), the accuracy is approximately 89.2%.
* **ThinkPRM-1.5B@4 (Dashed orange line with triangle markers):** The accuracy increases as the number of samples increases.
* At 2<sup>1</sup> (2 samples), the accuracy is approximately 84.8%.
* At 2<sup>2</sup> (4 samples), the accuracy is approximately 85.8%.
* At 2<sup>3</sup> (8 samples), the accuracy is approximately 87.5%.
* At 2<sup>4</sup> (16 samples), the accuracy is approximately 88.8%.
* **Majority (Pink line with circle markers):** The accuracy increases as the number of samples increases.
* At 2<sup>1</sup> (2 samples), the accuracy is approximately 82.0%.
* At 2<sup>2</sup> (4 samples), the accuracy is approximately 85.5%.
* At 2<sup>3</sup> (8 samples), the accuracy is approximately 87.0%.
* At 2<sup>4</sup> (16 samples), the accuracy is approximately 88.5%.
* **DiscPRM-1.5B (Teal line with circle markers):** The accuracy increases as the number of samples increases.
* At 2<sup>1</sup> (2 samples), the accuracy is approximately 81.0%.
* At 2<sup>2</sup> (4 samples), the accuracy is approximately 84.3%.
* At 2<sup>3</sup> (8 samples), the accuracy is approximately 87.0%.
* At 2<sup>4</sup> (16 samples), the accuracy is approximately 88.8%.
### Key Observations
* All models show an increase in accuracy as the number of samples increases.
* ThinkPRM-1.5B and ThinkPRM-1.5B@4 generally outperform the Majority and DiscPRM-1.5B models.
* The ThinkPRM-1.5B model has the highest accuracy at 16 samples.
* The DiscPRM-1.5B model has the lowest accuracy at 2 samples.
### Interpretation
The chart demonstrates the impact of increasing the number of samples (N) on the accuracy of different models when solving math problems from the MATH-500 dataset. The ThinkPRM-1.5B model appears to be the most effective, achieving the highest accuracy with a larger number of samples. The performance difference between the models suggests variations in their problem-solving capabilities and how they leverage multiple samples to improve accuracy. The "Best-of-N" approach generally improves accuracy for all models, indicating that generating multiple solutions and selecting the best one is a beneficial strategy.
</details>
<details>
<summary>x12.png Details</summary>
### Visual Description
## Chart: Compute-matched analysis: MATH-500
### Overview
The image is a line chart comparing the accuracy of two methods, "ThinkPRM-14B" and "Majority voting", against the estimated FLOPs (Floating Point Operations per Second) on a logarithmic scale. The chart is titled "Compute-matched analysis: MATH-500" and indicates the generator used is "Qwen2.5-14B".
### Components/Axes
* **Title:** Compute-matched analysis: MATH-500
* **Subtitle:** Generator: Qwen2.5-14B
* **Y-axis:** Accuracy (%)
* Scale ranges from 50 to 85, with tick marks at intervals of 5.
* **X-axis:** Estimated FLOPs (log scale)
* Scale ranges from 1 x 10^15 to 1 x 10^17.
* **Legend:** Located in the bottom-right corner.
* ThinkPRM-14B (represented by an orange line)
* Majority voting (represented by a tan line)
### Detailed Analysis
* **ThinkPRM-14B (Orange Line):**
* Trend: Generally slopes upward, indicating increasing accuracy with higher FLOPs.
* Data Points:
* At 1 x 10^15 FLOPs, accuracy is approximately 51%.
* At approximately 1.5 x 10^15 FLOPs, accuracy is approximately 62%.
* At approximately 2.5 x 10^15 FLOPs, accuracy is approximately 69%.
* At approximately 5 x 10^15 FLOPs, accuracy is approximately 74%.
* At 1 x 10^16 FLOPs, accuracy is approximately 76%.
* At approximately 3 x 10^16 FLOPs, accuracy is approximately 79%.
* At approximately 6 x 10^16 FLOPs, accuracy is approximately 83%.
* At 1 x 10^17 FLOPs, accuracy is approximately 86%.
* **Majority voting (Tan Line):**
* Trend: Generally slopes upward, but plateaus towards the higher FLOPs.
* Data Points:
* At 1 x 10^15 FLOPs, accuracy is approximately 51%.
* At approximately 1.5 x 10^15 FLOPs, accuracy is approximately 67%.
* At approximately 2.5 x 10^15 FLOPs, accuracy is approximately 74%.
* At approximately 5 x 10^15 FLOPs, accuracy is approximately 74%.
* At 1 x 10^16 FLOPs, accuracy is approximately 73%.
* At approximately 3 x 10^16 FLOPs, accuracy is approximately 78%.
* At approximately 6 x 10^16 FLOPs, accuracy is approximately 79%.
### Key Observations
* Both methods start with similar accuracy at lower FLOPs (around 51% at 1 x 10^15 FLOPs).
* ThinkPRM-14B consistently outperforms Majority voting as FLOPs increase, especially at higher FLOPs.
* Majority voting shows a plateau in accuracy improvement beyond 1 x 10^16 FLOPs.
### Interpretation
The data suggests that ThinkPRM-14B scales more effectively with increased computational resources (FLOPs) compared to Majority voting for the MATH-500 task. The plateau in Majority voting's accuracy indicates a potential limitation in its ability to leverage additional computational power, while ThinkPRM-14B continues to improve. This implies that ThinkPRM-14B is a more efficient or better-suited method for this particular task when computational resources are abundant. The "Compute-matched analysis" title suggests that the comparison is controlled for computational cost, making the accuracy difference more meaningful. The generator "Qwen2.5-14B" likely refers to the model used to generate or evaluate the solutions.
</details>
<details>
<summary>x13.png Details</summary>
### Visual Description
## Chart: Compute-matched analysis: GPQA-Physics
### Overview
The image is a line chart comparing the accuracy of "ThinkPRM-14B" and "Majority voting" methods against the estimated FLOPS (log scale) for a "GPQA-Physics" task. The chart includes a title, axis labels, a legend, and data points for each method. The generator used is "Qwen2.5-32B-Instruct".
### Components/Axes
* **Title:** Compute-matched analysis: GPQA-Physics
* **Subtitle:** Generator: Qwen2.5-32B-Instruct
* **X-axis:** Estimated FLOPS (log scale)
* Axis markers: 2 x 10^15, 5 x 10^15, 1 x 10^16, 2 x 10^16, 5 x 10^16
* **Y-axis:** Accuracy (%)
* Axis markers: 55, 60, 65, 70
* **Legend:** Located in the bottom-right corner.
* ThinkPRM-14B (brown line)
* Majority voting (tan line)
### Detailed Analysis
* **ThinkPRM-14B (brown line):**
* Trend: Generally increasing with some fluctuations.
* Data points:
* At 2 x 10^15 FLOPS, Accuracy ≈ 54.7%
* At 5 x 10^15 FLOPS, Accuracy ≈ 55.9%
* At 1 x 10^16 FLOPS, Accuracy ≈ 54.6%
* At 2 x 10^16 FLOPS, Accuracy ≈ 64.0%
* At 5 x 10^16 FLOPS, Accuracy ≈ 68.7%
* At 5 x 10^16 FLOPS, Accuracy ≈ 72.3%
* **Majority voting (tan line):**
* Trend: Increases, plateaus, then remains relatively constant.
* Data points:
* At 2 x 10^15 FLOPS, Accuracy ≈ 53.7%
* At 5 x 10^15 FLOPS, Accuracy ≈ 58.2%
* At 1 x 10^16 FLOPS, Accuracy ≈ 61.8%
* At 2 x 10^16 FLOPS, Accuracy ≈ 61.8%
* At 5 x 10^16 FLOPS, Accuracy ≈ 61.8%
### Key Observations
* ThinkPRM-14B generally outperforms Majority voting, especially at higher FLOPS.
* Majority voting plateaus in accuracy after 1 x 10^16 FLOPS.
* ThinkPRM-14B shows a more significant increase in accuracy as FLOPS increase.
### Interpretation
The chart demonstrates that for the GPQA-Physics task, the "ThinkPRM-14B" method achieves higher accuracy compared to "Majority voting" as the computational resources (estimated FLOPS) increase. The "Majority voting" method plateaus in performance, suggesting it may have reached its limit in terms of accuracy for this task, while "ThinkPRM-14B" continues to improve with more computational power. This suggests that "ThinkPRM-14B" is more scalable and can better leverage increased computational resources for this specific task. The generator used, "Qwen2.5-32B-Instruct", provides the foundation for both methods, and the comparison highlights the effectiveness of different approaches in utilizing the generator's capabilities.
</details>
Figure 19: Left: Best-of-N with Qwen3-1.7B on the full MATH-500 test set, showing how ThinkPRM generalizes well to verifying long reasoning traces. Mid and Right: Compute-matched comparison between best-of-N with ThinkPRM and self-consistency or majority vote.
5.6 ThinkPRM helps with difficult reasoning problems
ThinkPRM ’s reasoning ability should enable it to tackle verification of hard problems. To check if this is the case, we analyze performance of ThinkPRM vs. DiscPRM in light of problem difficulty over MATH-500 and GPQA-physics (how we estimate difficulty for GPQA-Physics is explained in Section E.9), shown in Fig. 39. The generators here are Qwen-2.5-14B for MATH-500 and Qwen-2.5-32B-Instruct for GPQA-Physics. Primarily, ThinkPRM improves reasoning on the difficult problems (levels 3, 4, 5 in MATH-500 and 2, 3, 4 in GPQA-Physics) substantially more than DiscPRM.
5.7 Filtering based on process vs. outcome labels
In Section 3.2, we describe our process-based filtering strategy, which selects verification CoTs based on agreement between generated step-level decisions and gold process labels. To validate its effectiveness, we compare it to outcome-based filtering, as in GenRM (Zheng et al., 2024), which retains chains solely based on final answer correctness—keeping a CoT if its final answer is correct and the final step is \boxed{correct}, or if the answer is incorrect and the final step is \boxed{incorrect}, thereby ignoring intermediate step labels. We obtain 65K and 128K CoTs using process- and outcome-based filtering, respectively. Fig. 17 shows that finetuning R1-Distill-Qwen-1.5B on process-filtered data yields significantly better verification performance, despite using fewer examples, which reflects the importance of our process-based filtering in training strong PRMs.
5.8 Limitations of Generative PRMs
While generative PRMs are more powerful and data-efficient than their discriminative counterparts, they come with some limitations that we highlight as avenues for future work. First, overconfidence is a known issue in LLMs (Liu et al., 2023a; Stechly et al., 2023; Zhou et al., 2024) and, in the case of PRMs, it can cause the predicted PRM scores to cluster near extremes: close to either 0 or 1. One reason is that we are using probabilities of certain tokens such as “yes” or “no”, which by nature will be either very high or very low. Future work should explore more reliable techniques to extract calibrated scores from generative reward models. Another limitation is due to autoregressive nature of LLMs, leading them to prematurely commit to an earlier judgment. For example, we observe a phenomenon we term step label interference, where verification errors for earlier steps impact verification of later steps. For example, we noted that if the PRM judges a particular step as incorrect, it becomes more likely to label subsequent steps as incorrect even if it is not. Lastly, generating a verification CoT introduces extra overhead compared to discriminative PRMs, but we argue that the performance gains offered by generative PRMs justify this extra cost.
Conclusion
We introduced ThinkPRM, a generative process reward model trained with minimal synthetic supervision for scalable step-by-step verification. With just 8K process labels, ThinkPRM significantly outperforms LLM-as-a-judge and even surpasses discriminative PRMs trained on orders of magnitude more data. These results highlight the benefits of generative PRMs in interpretability, scalability, and data efficiency, and demonstrate their potential to scale verification compute for complex reasoning tasks in math and science.
References
- Akyürek et al. (2024) Ekin Akyürek, Mehul Damani, Linlu Qiu, Han Guo, Yoon Kim, and Jacob Andreas. The surprising effectiveness of test-time training for abstract reasoning. arXiv preprint arXiv:2411.07279, 2024.
- Ankner et al. (2024) Zachary Ankner, Mansheej Paul, Brandon Cui, Jonathan D Chang, and Prithviraj Ammanabrolu. Critique-out-loud reward models. arXiv preprint arXiv:2408.11791, 2024.
- Bavaresco et al. (2024) Anna Bavaresco, Raffaella Bernardi, Leonardo Bertolazzi, Desmond Elliott, Raquel Fernández, Albert Gatt, Esam Ghaleb, Mario Giulianelli, Michael Hanna, Alexander Koller, et al. Llms instead of human judges? a large scale empirical study across 20 nlp evaluation tasks. arXiv preprint arXiv:2406.18403, 2024.
- (4) Edward Beeching, Lewis Tunstall, and Sasha Rush. Scaling test-time compute with open models. URL https://huggingface.co/spaces/HuggingFaceH4/blogpost-scaling-test-time-compute.
- Brown et al. (2024) Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling. arXiv preprint arXiv:2407.21787, 2024.
- Brown et al. (2020) Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.
- Charniak & Johnson (2005) Eugene Charniak and Mark Johnson. Coarse-to-fine n-best parsing and maxent discriminative reranking. In Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics (ACL’05), pp. 173–180, 2005.
- Chen et al. (2024a) Guoxin Chen, Minpeng Liao, Chengxi Li, and Kai Fan. Alphamath almost zero: process supervision without process. arXiv preprint arXiv:2405.03553, 2024a.
- Chen et al. (2024b) Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, et al. Do not think that much for 2+ 3=? on the overthinking of o1-like llms. arXiv preprint arXiv:2412.21187, 2024b.
- Chen et al. (2024c) Ziru Chen, Michael White, Raymond Mooney, Ali Payani, Yu Su, and Huan Sun. When is tree search useful for llm planning? it depends on the discriminator. arXiv preprint arXiv:2402.10890, 2024c.
- Cobbe et al. (2021) Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168, 2021.
- Cuadron et al. (2025) Alejandro Cuadron, Dacheng Li, Wenjie Ma, Xingyao Wang, Yichuan Wang, Siyuan Zhuang, Shu Liu, Luis Gaspar Schroeder, Tian Xia, Huanzhi Mao, et al. The danger of overthinking: Examining the reasoning-action dilemma in agentic tasks. arXiv preprint arXiv:2502.08235, 2025.
- Dong et al. (2023) Hanze Dong, Wei Xiong, Deepanshu Goyal, Yihan Zhang, Winnie Chow, Rui Pan, Shizhe Diao, Jipeng Zhang, Kashun Shum, and Tong Zhang. Raft: Reward ranked finetuning for generative foundation model alignment. arXiv preprint arXiv:2304.06767, 2023.
- Gao et al. (2024) Bofei Gao, Feifan Song, Zhe Yang, Zefan Cai, Yibo Miao, Qingxiu Dong, Lei Li, Chenghao Ma, Liang Chen, Runxin Xu, et al. Omni-math: A universal olympiad level mathematic benchmark for large language models. arXiv preprint arXiv:2410.07985, 2024.
- Guo et al. (2025) Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025.
- He et al. (2024) Chaoqun He, Renjie Luo, Yuzhuo Bai, Shengding Hu, Zhen Leng Thai, Junhao Shen, Jinyi Hu, Xu Han, Yujie Huang, Yuxiang Zhang, et al. Olympiadbench: A challenging benchmark for promoting agi with olympiad-level bilingual multimodal scientific problems. arXiv preprint arXiv:2402.14008, 2024.
- Hendrycks et al. (2021) Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.03874, 2021.
- Hu et al. (2022) Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. Lora: Low-rank adaptation of large language models. ICLR, 1(2):3, 2022.
- Huang et al. (2023) Jie Huang, Xinyun Chen, Swaroop Mishra, Huaixiu Steven Zheng, Adams Wei Yu, Xinying Song, and Denny Zhou. Large language models cannot self-correct reasoning yet. arXiv preprint arXiv:2310.01798, 2023.
- Hui et al. (2024) Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Kai Dang, et al. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186, 2024.
- Jaech et al. (2024) Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. Openai o1 system card. arXiv preprint arXiv:2412.16720, 2024.
- Jain et al. (2024) Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar-Lezama, Koushik Sen, and Ion Stoica. Livecodebench: Holistic and contamination free evaluation of large language models for code. arXiv preprint arXiv:2403.07974, 2024.
- Kalra & Tang (2025) Nimit Kalra and Leonard Tang. Verdict: A library for scaling judge-time compute. arXiv preprint arXiv:2502.18018, 2025.
- Kang et al. (2024) Yu Kang, Xianghui Sun, Liangyu Chen, and Wei Zou. C3ot: Generating shorter chain-of-thought without compromising effectiveness. arXiv preprint arXiv:2412.11664, 2024.
- Khalifa et al. (2023) Muhammad Khalifa, Lajanugen Logeswaran, Moontae Lee, Honglak Lee, and Lu Wang. GRACE: discriminator-guided chain-of-thought reasoning. In Houda Bouamor, Juan Pino, and Kalika Bali (eds.), Findings of the Association for Computational Linguistics: EMNLP 2023, Singapore, December 6-10, 2023, pp. 15299–15328. Association for Computational Linguistics, 2023. doi: 10.18653/V1/2023.FINDINGS-EMNLP.1022. URL https://doi.org/10.18653/v1/2023.findings-emnlp.1022.
- Kim et al. (2023) Seungone Kim, Jamin Shin, Yejin Cho, Joel Jang, Shayne Longpre, Hwaran Lee, Sangdoo Yun, Seongjin Shin, Sungdong Kim, James Thorne, et al. Prometheus: Inducing fine-grained evaluation capability in language models. In The Twelfth International Conference on Learning Representations, 2023.
- Kumar et al. (2024) Aviral Kumar, Vincent Zhuang, Rishabh Agarwal, Yi Su, John D Co-Reyes, Avi Singh, Kate Baumli, Shariq Iqbal, Colton Bishop, Rebecca Roelofs, et al. Training language models to self-correct via reinforcement learning. arXiv preprint arXiv:2409.12917, 2024.
- Lambert et al. (2024) Nathan Lambert, Valentina Pyatkin, Jacob Morrison, LJ Miranda, Bill Yuchen Lin, Khyathi Chandu, Nouha Dziri, Sachin Kumar, Tom Zick, Yejin Choi, et al. Rewardbench: Evaluating reward models for language modeling. arXiv preprint arXiv:2403.13787, 2024.
- Li et al. (2023) Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian-Guang Lou, and Weizhu Chen. Making language models better reasoners with step-aware verifier. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 5315–5333, 2023.
- Lightman et al. (2023) Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step. arXiv preprint arXiv:2305.20050, 2023.
- Liu et al. (2023a) Xin Liu, Muhammad Khalifa, and Lu Wang. Litcab: Lightweight language model calibration over short-and long-form responses. arXiv preprint arXiv:2310.19208, 2023a.
- Liu et al. (2023b) Yang Liu, Dan Iter, Yichong Xu, Shuohang Wang, Ruochen Xu, and Chenguang Zhu. G-eval: Nlg evaluation using gpt-4 with better human alignment. arXiv preprint arXiv:2303.16634, 2023b.
- Luo et al. (2024) Liangchen Luo, Yinxiao Liu, Rosanne Liu, Samrat Phatale, Harsh Lara, Yunxuan Li, Lei Shu, Yun Zhu, Lei Meng, Jiao Sun, et al. Improve mathematical reasoning in language models by automated process supervision. arXiv preprint arXiv:2406.06592, 2, 2024.
- Mahan et al. (2024) Dakota Mahan, Duy Van Phung, Rafael Rafailov, Chase Blagden, Nathan Lile, Louis Castricato, Jan-Philipp Fränken, Chelsea Finn, and Alon Albalak. Generative reward models. arXiv preprint arXiv:2410.12832, 2024.
- Muennighoff et al. (2025) Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori Hashimoto. s1: Simple test-time scaling. arXiv preprint arXiv:2501.19393, 2025.
- Rein et al. (2024) David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R Bowman. Gpqa: A graduate-level google-proof q&a benchmark. In First Conference on Language Modeling, 2024.
- Singh et al. (2023) Avi Singh, John D Co-Reyes, Rishabh Agarwal, Ankesh Anand, Piyush Patil, Xavier Garcia, Peter J Liu, James Harrison, Jaehoon Lee, Kelvin Xu, et al. Beyond human data: Scaling self-training for problem-solving with language models. arXiv preprint arXiv:2312.06585, 2023.
- Singhi et al. (2025) Nishad Singhi, Hritik Bansal, Arian Hosseini, Aditya Grover, Kai-Wei Chang, Marcus Rohrbach, and Anna Rohrbach. When to solve, when to verify: Compute-optimal problem solving and generative verification for llm reasoning. arXiv preprint arXiv:2504.01005, 2025.
- Snell et al. (2024) Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024.
- Stechly et al. (2023) Kaya Stechly, Matthew Marquez, and Subbarao Kambhampati. Gpt-4 doesn’t know it’s wrong: An analysis of iterative prompting for reasoning problems. arXiv preprint arXiv:2310.12397, 2023.
- Sun et al. (2024) Zhiqing Sun, Longhui Yu, Yikang Shen, Weiyang Liu, Yiming Yang, Sean Welleck, and Chuang Gan. Easy-to-hard generalization: Scalable alignment beyond human supervision. arXiv preprint arXiv:2403.09472, 2024.
- Team (2024) Qwen Team. Qwq: Reflect deeply on the boundaries of the unknown, November 2024. URL https://qwenlm.github.io/blog/qwq-32b-preview/.
- Uesato et al. (2022) Jonathan Uesato, Nate Kushman, Ramana Kumar, Francis Song, Noah Siegel, Lisa Wang, Antonia Creswell, Geoffrey Irving, and Irina Higgins. Solving math word problems with process-and outcome-based feedback. arXiv preprint arXiv:2211.14275, 2022.
- Wan et al. (2024) Ziyu Wan, Xidong Feng, Muning Wen, Stephen Marcus McAleer, Ying Wen, Weinan Zhang, and Jun Wang. Alphazero-like tree-search can guide large language model decoding and training. In Forty-first International Conference on Machine Learning, 2024.
- Wang et al. (2023a) Jiaan Wang, Yunlong Liang, Fandong Meng, Haoxiang Shi, Zhixu Li, Jinan Xu, Jianfeng Qu, and Jie Zhou. Is chatgpt a good nlg evaluator? a preliminary study. arXiv preprint arXiv:2303.04048, 2023a.
- Wang et al. (2023b) Peiyi Wang, Lei Li, Zhihong Shao, RX Xu, Damai Dai, Yifei Li, Deli Chen, Y Wu, and Zhifang Sui. Math-shepherd: A label-free step-by-step verifier for llms in mathematical reasoning. arXiv preprint arXiv:2312.08935, 2023b.
- Wang et al. (2024) Tianlu Wang, Ilia Kulikov, Olga Golovneva, Ping Yu, Weizhe Yuan, Jane Dwivedi-Yu, Richard Yuanzhe Pang, Maryam Fazel-Zarandi, Jason Weston, and Xian Li. Self-taught evaluators. arXiv preprint arXiv:2408.02666, 2024.
- Wang et al. (2022) Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171, 2022.
- Wu et al. (2024) Yangzhen Wu, Zhiqing Sun, Shanda Li, Sean Welleck, and Yiming Yang. Inference scaling laws: An empirical analysis of compute-optimal inference for problem-solving with language models. arXiv preprint arXiv:2408.00724, 2024.
- Xiong et al. (2024) Wei Xiong, Hanning Zhang, Nan Jiang, and Tong Zhang. An implementation of generative prm. https://github.com/RLHFlow/RLHF-Reward-Modeling, 2024.
- Xiong et al. (2025) Wei Xiong, Hanning Zhang, Chenlu Ye, Lichang Chen, Nan Jiang, and Tong Zhang. Self-rewarding correction for mathematical reasoning. arXiv preprint arXiv:2502.19613, 2025.
- Yang et al. (2025) An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388, 2025.
- Yao et al. (2023) Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Advances in neural information processing systems, 36:11809–11822, 2023.
- Ye et al. (2024) Tian Ye, Zicheng Xu, Yuanzhi Li, and Zeyuan Allen-Zhu. Physics of language models: Part 2.2, how to learn from mistakes on grade-school math problems. arXiv preprint arXiv:2408.16293, 2024.
- Yu et al. (2024) Ping Yu, Jing Xu, Jason Weston, and Ilia Kulikov. Distilling system 2 into system 1. arXiv preprint arXiv:2407.06023, 2024.
- Yuan et al. (2024) Lifan Yuan, Wendi Li, Huayu Chen, Ganqu Cui, Ning Ding, Kaiyan Zhang, Bowen Zhou, Zhiyuan Liu, and Hao Peng. Free process rewards without process labels. arXiv preprint arXiv:2412.01981, 2024.
- Zelikman et al. (2022) Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah Goodman. Star: Bootstrapping reasoning with reasoning. Advances in Neural Information Processing Systems, 35:15476–15488, 2022.
- Zhang et al. (2024a) Lunjun Zhang, Arian Hosseini, Hritik Bansal, Mehran Kazemi, Aviral Kumar, and Rishabh Agarwal. Generative verifiers: Reward modeling as next-token prediction. arXiv preprint arXiv:2408.15240, 2024a.
- Zhang et al. (2024b) Yunxiang Zhang, Muhammad Khalifa, Lajanugen Logeswaran, Jaekyeom Kim, Moontae Lee, Honglak Lee, and Lu Wang. Small language models need strong verifiers to self-correct reasoning. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Findings of the Association for Computational Linguistics, ACL 2024, Bangkok, Thailand and virtual meeting, August 11-16, 2024, pp. 15637–15653. Association for Computational Linguistics, 2024b. doi: 10.18653/V1/2024.FINDINGS-ACL.924. URL https://doi.org/10.18653/v1/2024.findings-acl.924.
- Zhang et al. (2025) Zhenru Zhang, Chujie Zheng, Yangzhen Wu, Beichen Zhang, Runji Lin, Bowen Yu, Dayiheng Liu, Jingren Zhou, and Junyang Lin. The lessons of developing process reward models in mathematical reasoning. arXiv preprint arXiv:2501.07301, 2025.
- Zheng et al. (2024) Chujie Zheng, Zhenru Zhang, Beichen Zhang, Runji Lin, Keming Lu, Bowen Yu, Dayiheng Liu, Jingren Zhou, and Junyang Lin. Processbench: Identifying process errors in mathematical reasoning. arXiv preprint arXiv:2412.06559, 2024.
- Zheng et al. (2023) Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems, 36:46595–46623, 2023.
- Zhou et al. (2024) Kaitlyn Zhou, Jena D Hwang, Xiang Ren, and Maarten Sap. Relying on the unreliable: The impact of language models’ reluctance to express uncertainty. arXiv preprint arXiv:2401.06730, 2024.
- Zhu et al. (2023) Lianghui Zhu, Xinggang Wang, and Xinlong Wang. Judgelm: Fine-tuned large language models are scalable judges. arXiv preprint arXiv:2310.17631, 2023.
Appendix A Training data
A.1 Sampling
Fig. 3 shows the prompt used with QwQ-32B-Preview to sample verification chains for training. We use the problem-prefix pairs from PRM800K train split (Lightman et al., 2023), which is based on MATH (Hendrycks et al., 2021). We sample 4 verification chains for each prefix in the dataset with temperature $T=0.1$ until we have 1K verification CoTs that (1) follow the desired format i.e., the model generated an extractable label for every step in the prefix and (2) the verbalized step labels match the gold labels in the PRM800K dataset annotation, (3) at most 4096 tokens long, and are (4) roughly balanced with respect to final answer correctness.
Roughly 20% of the initial samples satisfied criteria 1 and 2 in our case, which means that about 5K samples in total are needed to obtain 1K filtered samples. Table 2 shows the statistics of the final dataset. We also show an example from the 1K training CoTs in Fig. 20.
Synthetic training sample
Problem: Find the area in square feet of a square with a perimeter of 32ft. Solution: Step 1: A square has four equal sides, so the perimeter is four times the length of one side. Step 2: I can write an equation to relate the perimeter and the side length: 4s = 32, where s is the side length in feet. Step 3: To solve for s, I can divide both sides by 4: s = 32/4 = 8. Step 4: Now I know the side length of the square is 8 feet. Step 5: The area of a square is the side length squared, so the area is s² = 8² = 64. Step 6: The area is in square feet, so the units are ft². Step 7: The answer is 64 ft² <think> Alright, let’s verify step by step the solution provided for finding the area of a square with a perimeter of 32 feet. Step 1: “A square has four equal sides, so the perimeter is four times the length of one side.” Critique: This statement is accurate. A square indeed has four sides of equal length, and the perimeter is the sum of all sides. Therefore, perimeter (P) equals 4 times the side length (s), or P = 4s. The step is \\boxed{correct} Step 2: “I can write an equation to relate the perimeter and the side length: 4s = 32, where s is the side length in feet.” Critique: Given that the perimeter is 32 feet, setting up the equation 4s = 32 is correct. It properly represents the relationship between the perimeter and the side length of the square. The step is \\boxed{correct} Step 3: “To solve for s, I can divide both sides by 4: s = 32/4 = 8.” Critique: This step correctly solves for s by dividing both sides of the equation by 4. The calculation 32 divided by 4 equals 8 is accurate. The step is \\boxed{correct} Step 4: “Now I know the side length of the square is 8 feet.” Critique: Based on the previous step, s = 8 feet, which is correctly stated here. The step is \\boxed{correct} Step 5: “The area of a square is the side length squared, so the area is s² = 8² = 64.” Critique: The formula for the area of a square is indeed s squared. Calculating 8 squared equals 64 is correct. The step is \\boxed{correct} Step 6: “The area is in square feet, so the units are ft².” Critique: Since the side length is in feet, the area will be in square feet (ft²). This is the correct unit for area. The step is \\boxed{correct} Step 7: “The answer is 64 ft²” Critique: This is the final answer, correctly stating the area as 64 square feet. The step is \\boxed{correct} </think> Is the solution correct? Yes
Figure 20: Training example from our sampled 1K synthetic chains.
A.2 Preprocessing
From the sampled verification CoTs, we extract boxed predictions (e.g., \boxed{correct} or \boxed{incorrect}) for each reasoning step. Then we filter the data as follows:
- CoTs with missing or malformed verification decisions are discarded.
- CoTs where verification decisions don’t match ground truth labels are filtered out. Precisely, we require all step-by-step verification decisions to match the ground truth labels.
Then we clean the data as follows:
- We standardize boxed notation formats.
- Content after the last verification decision is removed.
- Special tokens (e.g., <think> and </think>) are added to designate verification reasoning.
Table 2: Statistics of the 1K finetuning dataset.
| Correctness Distribution | |
| --- | --- |
| # correct | 486 (48.6%) |
| # incorrect | 514 (51.4%) |
| Step label distribution | |
| # correct | 7474 (92.3%) |
| # Incorrect | 625 (7.7%) |
| Prefix statistics | |
| # unique questions | 869 |
| average steps per prefix | 9.5 |
| min # steps | 1 |
| max # steps | 53 |
| Verification Chain Statistics | |
| Average verification chain length (tokens) | 1037.0 |
| Min verification chain length (tokens) | 207 |
| Max verification chain length (tokens) | 3669 |
Data generation prompt
You are given a math problem and a proposed multiple-step solution (with a step on each line): [Math Problem] {problem} [Solution] {solution} Review and critique the proposed solution steps and determine whether each step is correct. If the solution is incomplete, only critique the steps that are provided. Your output must be in the following format: Let’s verify step by step: Step 1: <critique>…The step is \boxed{correct/incorrect} Step 2: <critique>…The step is \boxed{correct/incorrect} … Step n: <critique>…The step is \boxed{correct/incorrect} Once you find an incorrect step, you should stop since you don’t need to analyze the remaining steps.
Figure 21: Prompt used to generate synthetic verification chains as described in Section 3.2.
Appendix B LLM-as-a-Judge Limitations
We show examples of failures from QwQ-32B-Preview and Deepseek-R1-Distill-Qwen-14B when used for LLM-as-judge verification in Figs. 23 and 25.
QwQ-32B-Preview stuck in a loop
Okay, so I need to analyze each step of the proposed solution to the math problem. The problem is: If $f(x)=\frac{3x-2}{x-2}$ , what is the value of $f(-2)+f(-1)+f(0)$ ? The proposed solution is given, and I have to check if each step is correct. First, let me read through the problem and the solution carefully. The function is $f(x)=\frac{3x-2}{x-2}$ . They want the sum of $f(-2)+f(-1)+f(0)$ . Looking at the solution steps: Step 0: They plug in $x=-2$ into the function and calculate $\frac{3(-2)-2}{-2-2}=\frac{-8}{-4}=2$ . Step 1: They mention that plugging $x=-2$ into the denominator gives zero, which would be division by zero. Step 2: They generalize that we should avoid plugging in values that make the denominator zero. Step 3: Similarly, plugging $x=-1$ into the denominator also gives zero. Step 4: Plugging $x=0$ into the denominator also results in division by zero. … Wait no! The original function is given as $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ No! The problem says: If $f(x)=\frac{\text{numerator}}{\text{denominator}}=?$ …
Figure 22: Degeneration behavior from QwQ-32B-Preview with LLM-as-judge verification. Problem and solution are omitted for brevity.
Deepseek-R1-Distill-Qwen-14B stuck in a loop
Okay, so I need to review and critique the solution step by step for the given math problem. The problem is to find the exact value of the continued fraction expression: 1 + 1/(1 + 2/(1 + 1/(1 + 2/(1 + …)))) The solution provided is split into 16 steps, each enclosed in a tag. I need to go through each step, analyze it, and see if there are any errors or if the logic holds. After that, I’ll determine if the solution is correct by outputting ”yes” or ”no” in a box. Let me start by understanding the problem. It’s a continued fraction that alternates between 1 and 2 in the numerators. The expression is: x = 1 + 1/(1 + 2/(1 + 1/(1 + 2/(1 + …)))) So, the pattern repeats every two steps: 1, then 2, then 1, then 2, etc. The solution starts by denoting the expression as x and then tries to find a relationship by substituting the inner expression back into x. Wait, the original expression is x = 1 + 1/(1 + 2/(1 + 1/(1 + 2/(1 + …)))). So, the part after the first 1 is 1 + 2/(1 + 1/(1 + 2/(1 + …))). But that part isn’t x, because x starts with 1 + 1/(…). So, maybe the substitution isn’t directly x. Let me think. Wait, perhaps the inner part is similar but not exactly x. Let me denote the inner part as y. So, y = 1 + 2/(1 + 1/(1 + 2/(1 + …))). But then, the expression for y would involve another similar structure. Hmm, maybe the solution is oversimplifying here. … Wait, actually, when you multiply both sides by (1 + 2/x), the left side is x*(1 + 2/x) = x + 2. The right side is [1 + 1/(1 + 2/x)]*(1 + 2/x) = 1*(1 + 2/x) + [1/(1 + 2/x)]*(1 + 2/x) = (1 + 2/x) + 1 = 2 + 2/x. So, the correct equation after multiplying both sides by (1 + 2/x) is: x + 2 = 2 + 2/x. But in step 6, they have: x + 2 = 1 + 1/(1 + 2/x) + 2/x + 4/x² Which seems to be incorrect. They seem to have distributed the multiplication incorrectly. Wait, let me see. If you have x*(1 + 2/x) = [1 + 1/(1 + 2/x)]*(1 + 2/x) + [2/x*(1 + 2/x)] But that doesn’t make sense because when you multiply both sides by (1 + 2/x), you should only have: Left side: x*(1 + 2/x) Right side: [1 + 1/(1 + 2/x)]*(1 + 2/x) Which simplifies to x + 2 = 2 + 2/x. But in the solution, step 6 says: x*(1 + 2/x) = 1 + 1/(1 + 2/x) + 2/x*(1 + 2/x) Which seems to be adding an extra term, 2/x*(1 + 2/x), which is not correct. So, step 6 is incorrect. Therefore, the solution has an error in step 6. Instead of correctly multiplying both sides, they incorrectly expanded the right-hand side, leading to an incorrect equation. Because of this mistake, the subsequent steps are likely incorrect as well. So, the entire solution is flawed from step 6 onwards. … Wait, let me compute the continued fraction numerically to check. Let me compute the continued fraction up to a certain depth. Let me compute it step by step: Start with the innermost part and work outwards. … So, it seems to converge to approximately 2.414, which is 1 + sqrt(2) $≈$ 2.4142. Wait, but according to my earlier solving, x should be sqrt(2) $≈$ 1.414, but the numerical computation suggests it converges to approximately 2.414, which is 1 + sqrt(2). So, which one is correct? Wait, perhaps I made a mistake in setting up the equation. Wait, let’s re-examine the original expression: … But when I tried to solve it earlier, I set x = 1 + 1/(1 + 2/x), which led to x = sqrt(2). But the numerical computation suggests it converges to 1 + sqrt(2). So, perhaps my initial substitution was incorrect. Wait, perhaps I need to define it differently. Let me try to define the continued fraction properly. Wait, let’s solve the system: From x = 1 + 1/y and y = 1 + 2/x. Substitute y = 1 + 2/x into x = 1 + 1/y: x = 1 + 1/(1 + 2/x) Multiply both sides by (1 + 2/x): … Alternatively, perhaps I need to define y differently. Let me try to define y as the expression starting with 1 + 1/(…): y = 1 + 1/(1 + 2/(1 + 1/(1 + 2/(1 + …)))) But then, y = x, which brings us back to the original substitution. … Which is the same equation as before, leading to x = sqrt(2). But the numerical computation suggests it’s approaching 1 + sqrt(2). So, perhaps my initial substitution is incorrect. Alternatively, perhaps the continued fraction is structured such that after the first 1 + 1/(…), the denominator is another continued fraction similar to x but shifted. …
Figure 23: Degeneration behavior from Deepseek-R1-Distill-Qwen-14B with LLM-as-judge verification. Problem and solution are omitted for brevity.
Problem and solution from ProcessBench
Problem: Let $a,b$ be positive reals with $a>b>\frac{1}{2}a$ . Place two squares of side lengths $a,b$ next to each other, such that the larger square has lower left corner at $(0,0)$ and the smaller square has lower left corner at $(a,0)$ . Draw the line passing through $(0,a)$ and $(a+b,0)$ . The region in the two squares lying above the line has area 2013. If $(a,b)$ is the unique pair maximizing $a+b$ , compute $\frac{a}{b}$ . Solution: We begin by finding the equation of the line through $(0,a)$ and $(a+b,0)$ . The slope is: $m=\frac{0-a}{(a+b)-0}=-\frac{a}{a+b}$ Using point-slope form from $(0,a)$ : $y=a-\frac{a}{a+b}x$ Area above the line in the larger square: At $x=a$ , the height is: $y=a-\frac{a^{2}}{a+b}=\frac{ab}{a+b}$ So the area is a trapezoid: $\text{Area}_{1}=\frac{1}{2}\left(a+\frac{ab}{a+b}\right)a=\frac{a^{3}+2a^{2}b}{2(a+b)}$ Area above the line in the smaller square: This is a triangle with height $\frac{ab}{a+b}$ and base $b$ : $\text{Area}_{2}=\frac{1}{2}·\frac{ab}{a+b}· b=\frac{ab^{2}}{2(a+b)}$ Total Area: $\text{Total}=\text{Area}_{1}+\text{Area}_{2}=\frac{a^{3}+2a^{2}b+ab^{2}}{2(a+b)}=\frac{a(a^{2}+2ab+b^{2})}{2(a+b)}=\frac{a(a+b)^{2}}{2(a+b)}=\frac{a(a+b)}{2}$ We are given: $\frac{a(a+b)}{2}=2013\Rightarrow a(a+b)=4026$ Express $b$ in terms of $a$ : $b=\frac{4026}{a}-a$ Apply the constraints $a>b>\frac{1}{2}a$ : •
$a>b\Rightarrow a>\frac{4026}{a}-a\Rightarrow a^{2}>2013\Rightarrow a>\sqrt{2013}$ •
$b>\frac{1}{2}a\Rightarrow\frac{4026}{a}-a>\frac{1}{2}a\Rightarrow a^{2}<2684\Rightarrow a<\sqrt{2684}$ So $\sqrt{2013}<a<\sqrt{2684}$ . To maximize $a+b=\frac{4026}{a}$ , we minimize $a$ , so let $a=\sqrt{2013}$ . Then $b=\sqrt{2013}$ , satisfying the constraints. $\frac{a}{b}=\boxed{2}$
Figure 24: An example of problem and solution from OmniMath subset of ProcessBench.
Incorrect verification
Okay, so I need to review and critique the given solution step by step. Let me go through each step carefully. Step 0: The solution starts by identifying key points and properties. It mentions that $J$ is the excenter opposite to $A$ , which is correct. $A_{1}$ is where the excircle touches $BC$ , and $B_{1},C_{1}$ are where it touches the extensions of $AC$ and $AB$ . Then, it says $A_{1}B_{1}$ is perpendicular to $AB$ and intersects at $D$ . $E$ is the foot of the perpendicular from $C_{1}$ to $DJ$ . Hmm, this seems okay, but I wonder if they’ve correctly identified all the properties. Maybe they should have mentioned more about the excenter’s properties, like the fact that it’s the intersection of external angle bisectors. But maybe that’s assumed knowledge. Step 1: They note that since $A_{1}B_{1}$ is perpendicular to $AB$ , $D$ is the projection of $A_{1}$ onto $AB$ . So, $D$ lies on $AB$ and $A_{1}D$ is perpendicular to $AB$ . Wait, is that necessarily true? If $A_{1}B_{1}$ is perpendicular to $AB$ , and they intersect at $D$ , then yes, $D$ is the foot of the perpendicular from $A_{1}$ to $AB$ . That seems correct. Step 2: They examine the excircle and the triangle, mentioning that the excircle is tangent to $BC$ at $A_{1}$ , and the tangents from $A_{1}$ to $B_{1}$ and $C_{1}$ form right angles with the radii. Then, $DJ$ is a line through the excenter and the intersection point of the perpendiculars from $A_{1}$ and $B_{1}$ to $AB$ . Hmm, I’m not sure about this part. The line $DJ$ is through the excenter $J$ and point $D$ , which is the foot from $A_{1}$ . But does it involve perpendiculars from $A_{1}$ and $B_{1}$ ? I think the solution might be conflating different properties here. The excenter is equidistant from all sides, but $DJ$ is just a line from $D$ to $J$ , not necessarily involving perpendiculars from both $A_{1}$ and $B_{1}$ . Maybe this is a misstatement. Step 3: They state that since $E$ is the foot of the perpendicular from $C_{1}$ to $DJ$ , angle $C_{1}ED$ is 90 degrees. Then, they argue that angles $BEA_{1}$ and $AEB_{1}$ are equal due to symmetry and properties of the cyclic quadrilateral. Wait, why is $E$ symmetrically placed? The solution says it’s because of the properties of the excircle and right angles, but I’m not entirely convinced. Just because $E$ is a foot of a perpendicular doesn’t automatically make it symmetric with respect to $A_{1}B_{1}$ . Maybe there’s a better reason, like cyclic quadrilaterals or similar triangles, but this step feels a bit hand-wavy. Step 4: They conclude both angles are 45 degrees because of symmetry and right angles, forming a cyclic quadrilateral. But I’m not sure if the cyclic quadrilateral part is clearly established. Also, 45 degrees seems specific—does the problem necessarily lead to that? Wait, maybe I should draw a diagram to visualize. If $A_{1}B_{1}$ is perpendicular to $AB$ , and $E$ is the foot from $C_{1}$ to $DJ$ , which is connected to the excenter. Hmm, maybe the angles are indeed 45 degrees because of the right angles and the properties of the excentral triangle, but I’m not entirely certain. Overall Thoughts: The solution seems to have some correct steps but might be making assumptions without sufficient justification. For example, in Step 3, the symmetry argument isn’t fully explained. Also, in Step 2, the description of $DJ$ might not be accurate. The conclusion of 45 degrees might be correct, but the reasoning feels a bit rushed. Final Answer After considering the steps, I think the solution might have some gaps in justification but arrives at the correct answer. So, I’ll say yes, but with some reservations. $y e s$
Figure 25: Incorrect verification by Deepseek-R1-Distill-Qwen-14B for the problem-solution pair in Fig. 24.
Appendix C Training details
C.1 Training ThinkPRM
We train our models on the filtered 1K chains using LoRA (Hu et al., 2022) with rank $r=32$ and $\alpha=16$ . Specifically, we finetune Qwen-14B-Instruct and R1-Deepseek (14B) for 3 epochs, and QwQ-32B-Preview for 5 epochs using LoRA. We use an effective batch size of 16 and a fixed learning rate of $4× 10^{-4}$ without warmup is used. Training took 1.5 hours for the 14B models and 4.5 hours for QwQ-32B-Preview on a single A100 80GB GPU. Without particularly found QwQ to be hard to train with LoRA and still generates a relatively high percentage of invalid judgments after training. Full training of the model will likely resolve these issues but that would require more compute than we have.
The R1-Distill-Qwen{1.5B,7B} models use full training with the following parameters. The 1.5B model We trained for 3 epochs with an effective batch size of 32, using a constant learning rate of $6× 10^{-5}$ without decay or warmup. We train both models using four RTX A6000 48GB GPU using data parallel. Training the 1.5B model on the 1K chains took about half an hour and the 7B model about two hours.
C.2 Training Discriminative Verifiers
We train R1-Qwen-14B for 1 epoch over the entire PRM800K dataset using two A100 80GB GPUs with a batch size of 8 and a learning rate of $6× 10^{-5}$ . We use a constant learning rate scheduler with no warmup. Following prior work (Wang et al., 2023b; Zhang et al., 2025) We train the model using binary cross-entropy to maximize the probability of the tokens “+” and “-” for correct and incorrect steps, respectively. The R1-Qwen-1.5B model is trained with the same infrastructure with a batch size of 64 and a learning rate of $1× 10^{-4}$ with a warm up ratio of 10%.
Appendix D Results on ProcessBench before and after finetuning
Table 3 shows the performance numbers of LLM-as-a-Judge and ThinkPRM on ProcessBench.
Table 3: Average F1-score on OlympiadBench and OmniMath subsets of ProcessBench (Zheng et al., 2024) comparing LLM-as-a-Judge to ThinkPRM finetuned on 1K examples. Random baseline for OlympiadBench is 39.1% and for OmniMath is 32.7%. Percentage of bad outputs (repetitions, invalid label formatting, overthinking, etc.) are shown in red. LLM-as-a-judge with reasoning models suffer from issues that limits their utility as generative verifiers.
| Model | LLM-as-a-Judge | ThinkPRM | | |
| --- | --- | --- | --- | --- |
| OlympiadBench | OmniMath | OlympiadBench | OmniMath | |
| Random baseline | 39.1 | 32.7 | 39.1 | 32.7 |
| R1-Qwen-1.5B | 5.0 (51.4 %) | 5.4 (55.1 %) | 76.3 (1.4 %) | 75.7 (2.4 %) |
| R1-Qwen-7B | 44.8 (18.2 %) | 45.7 (20.9 %) | 73.4 (1.1 %) | 74.0 (1.4 %) |
| R1-Qwen-14B | 72.8 (13.3 %) | 67.8 (18.6 %) | 87.3 (2.3 %) | 85.7 (2.3 %) |
| QwQ-32B-preview | 50.6 (7.9 %) | 55.5 (10.9 %) | 73.1 (15.1 %) | 73.2 (7.9 %) |
Appendix E Evaluation details
This section includes exact details on the test-time scaling shown in Section 4.2
E.1 Predicting verification labels
Following prior work (Snell et al., 2024; Beeching et al., ), we aggregate scores from DiscPRM by using the score of the last step. For ThinkPRM, we first prompt the model to generate the verification chain up to a maximum of 8192 tokens, then we force decode the string “Is the solution correct?” and use $\frac{P(\text{``yes"})}{P(\text{``yes"})+P(\text{``no"})}$ as the solution score.
E.2 Best-of-N selection
We sample solutions using a temperature of $T=0.8$ for Llama-3.2-3B-Instruct and $T=0.4$ for Qwen-2.5-14B. We instruct all models to think step by step and put the final answer in \boxed{}. All our Best-of-N experiments use weighted majority voting, which scores final answers based on the sum of the verifier scores of their solutions (Uesato et al., 2022; Wu et al., 2024; Sun et al., 2024) except for our experiments on AIME ’24, where we use the verifier score directly to rank the solution, as we found this to perform better for all verifiers.
E.3 Verifier-guided beam search
Under verifier-guided beam search, we sample candidate next steps and score them with the process verifier, then selects top- $K$ out of these to further expand and so on. Our implementation is based on (Snell et al., 2024; Beeching et al., ), which maintains $N$ beams in total, and samples $M$ candidate next steps per beam. We set $M=4$ for all experiments and run search for a maximum of 20 steps per beam. To sample next steps, we use $T=0.6$ and use double newlines as the step delimiter.
E.4 Sequential scaling of verifier compute
We achieve budget forcing (Muennighoff et al., 2025) by triggering the model to think again for $R$ rounds, where each round uses a unique trigger phrase that incites the model to revisit or double-check its earlier verification. We use different trigger phrases for each round since we found that using the same phrase causes the model to repeat what it did in the last round.
We do a maximum of $R=4$ thinking rounds, and use the phrases “Let me double check”, “Let’s verify again”, and “Did I miss something?”, for rounds 2, 3, and 4 respectively. We do not investigate deeply into optimizing the trigger phrase, but we note that performance may depend on these and we use the same phrases for both ThinkPRM and LLM-as-a-judge to ensure fair comparison.
E.5 MATH-500 test examples
As running on all 500 examples from MATH-500 will require a lot of compute, we run all our experiments on 100 randomly sampled subsets from MATH-500 (Hendrycks et al., 2021). We pick the 100 problems such that they cover different difficulty levels, as shown in Fig. 31.
\caption@setoptions
floatrow \caption@setoptions figurerow \caption@setposition b
\caption@setoptions figure \caption@setposition b
<details>
<summary>x14.png Details</summary>
### Visual Description
## Bar Chart: Difficulty Levels in MATH-500 Split
### Overview
The image is a bar chart illustrating the distribution of difficulty levels in the MATH-500 split. The x-axis represents the problem level (ranging from 1 to 5), and the y-axis represents the count of problems at each difficulty level. The bars are all the same color, a shade of orange.
### Components/Axes
* **Title:** "Difficulty levels in the MATH-500 split we use"
* **X-axis:** "Problem Level" with markers at 1, 2, 3, 4, and 5.
* **Y-axis:** "Count" with markers at 0, 5, 10, 15, 20, and 25.
* **Bars:** Represent the count for each problem level. All bars are orange with black outlines.
### Detailed Analysis
* **Problem Level 1:** The bar extends to approximately 11 on the y-axis.
* **Problem Level 2:** The bar extends to approximately 25 on the y-axis.
* **Problem Level 3:** The bar extends to approximately 19 on the y-axis.
* **Problem Level 4:** The bar extends to approximately 22 on the y-axis.
* **Problem Level 5:** The bar extends to approximately 23 on the y-axis.
### Key Observations
* Problem Level 2 has the highest count, significantly higher than the other levels.
* Problem Level 1 has the lowest count.
* Problem Levels 4 and 5 have similar counts.
### Interpretation
The bar chart indicates that in the MATH-500 split, problems with difficulty level 2 are the most frequent, while problems with difficulty level 1 are the least frequent. The distribution suggests a non-uniform spread of difficulty levels, with a concentration around level 2. The data implies that the MATH-500 split may be skewed towards moderately difficult problems.
</details>
Figure 28: Histogram of difficulty levels in our 100-problem subset from MATH-500. \caption@setoptions figure \caption@setposition b
<details>
<summary>x15.png Details</summary>
### Visual Description
## Line Chart: Parallel scaling of verifier compute: MATH-500
### Overview
The image is a line chart comparing the accuracy (%) of different models (ThinkPRM-14B, ThinkPRM-14B@4, ThinkPRM-14B@8, DiscPRM-14B, and Majority) against the number of solutions (2^0 to 2^5) for a verifier compute task on MATH-500. The chart illustrates how the accuracy of each model scales with an increasing number of solutions.
### Components/Axes
* **Title:** Parallel scaling of verifier compute: MATH-500
* **X-axis:** Number of solutions (2^0, 2^1, 2^2, 2^3, 2^4, 2^5)
* **Y-axis:** Accuracy (%) (50, 55, 60, 65, 70, 75, 80, 85)
* **Legend:** Located at the bottom of the chart.
* ThinkPRM-14B (brown line with star markers)
* ThinkPRM-14B@4 (light blue dashed line with triangle markers)
* ThinkPRM-14B@8 (yellow dash-dot line with square markers)
* DiscPRM-14B (green line with circle markers)
* Majority (tan line with circle markers)
### Detailed Analysis
* **X-Axis Values:** The x-axis represents the number of solutions, with values at powers of 2: 2^0 (1), 2^1 (2), 2^2 (4), 2^3 (8), 2^4 (16), and 2^5 (32).
* **Y-Axis Values:** The y-axis represents the accuracy in percentage, ranging from 50% to 85% in increments of 5%.
**Data Series Analysis:**
* **ThinkPRM-14B (brown line with star markers):**
* Trend: Generally increasing.
* Data Points:
* 2^0: ~51%
* 2^1: ~51%
* 2^2: ~69%
* 2^3: ~77%
* 2^4: ~79%
* 2^5: ~83%
* **ThinkPRM-14B@4 (light blue dashed line with triangle markers):**
* Trend: Increasing.
* Data Points:
* 2^0: ~51%
* 2^1: ~62%
* 2^2: ~69%
* 2^3: ~81%
* 2^4: ~82%
* 2^5: ~84%
* **ThinkPRM-14B@8 (yellow dash-dot line with square markers):**
* Trend: Increasing.
* Data Points:
* 2^0: ~51%
* 2^1: ~61%
* 2^2: ~69%
* 2^3: ~77%
* 2^4: ~80%
* 2^5: ~83%
* **DiscPRM-14B (green line with circle markers):**
* Trend: Increasing, then plateaus.
* Data Points:
* 2^0: ~51%
* 2^1: ~62%
* 2^2: ~70%
* 2^3: ~73%
* 2^4: ~73%
* 2^5: ~73%
* **Majority (tan line with circle markers):**
* Trend: Stagnant, then increasing.
* Data Points:
* 2^0: ~51%
* 2^1: ~51%
* 2^2: ~69%
* 2^3: ~73%
* 2^4: ~73%
* 2^5: ~73%
### Key Observations
* ThinkPRM-14B@4 generally achieves the highest accuracy across all solution counts.
* DiscPRM-14B and Majority models plateau in accuracy after 2^3 solutions.
* All models start with similar accuracy at 2^0 solutions.
* The accuracy of all models generally increases with the number of solutions, except for DiscPRM-14B and Majority, which plateau.
### Interpretation
The chart demonstrates the parallel scaling performance of different verifier compute models on the MATH-500 dataset. The ThinkPRM-14B variants, especially ThinkPRM-14B@4, show the best scaling behavior, achieving higher accuracy as the number of solutions increases. The DiscPRM-14B and Majority models, however, reach a performance ceiling, suggesting that increasing the number of solutions beyond a certain point does not improve their accuracy. This indicates that the ThinkPRM-14B models are better suited for tasks where a larger number of solutions can be explored to improve verification accuracy. The "@4" and "@8" likely refer to different configurations or parameters within the ThinkPRM-14B model, with "@4" being the most effective in this scenario.
</details>
Figure 31: Scaling of verifier compute by parallel sampling of multiple verification CoTs and averaging their scores. Parallel scaling (ThinkPRM -14B@4 and ThinkPRM -14B@8) further boosts performance curve compared to scoring based on a single CoT (ThinkPRM -14B).
E.6 Additional results on scaling verifier compute
Fig. 31 shows results of ThinkPRM -14B of parallel scaling verifier compute by sampling $K=4$ and $K=8$ CoTs with temperature $T=0.6$ and aggregating their scores. Parallel scaling indeed lifts up the accuracy curve of ThinkPRM -14B compared to standard $K=1$ with greedy decoding. However, performance plateaus rather quickly and $K=8$ remains comparable to $K=4$ , while slightly better at smaller sampling budgets. Fig. 32 compares parallel to sequential scaling under the same token budget. While there is no clear winner, parallel scaling seems to perform slightly better at best-of-8.
\caption@setoptions
floatrow \caption@setoptions figurerow \caption@setposition b
<details>
<summary>x16.png Details</summary>
### Visual Description
## Line Chart: Parallel vs. Sequential Scaling: MATH-500
### Overview
The image is a line chart comparing the accuracy (%) of different models (ThinkPRM-14B, ThinkPRM-14B@2, and ThinkPRM-14B (2 thinking rounds)) as the number of solutions increases, specifically in the context of MATH-500. The x-axis represents the number of solutions (ranging from 2^0 to 2^4), and the y-axis represents the accuracy in percentage (ranging from 50% to 80%).
### Components/Axes
* **Title:** Parallel vs. Sequential Scaling: MATH-500
* **X-axis Title:** Number of solutions
* **X-axis Scale:** 2^0, 2^1, 2^2, 2^3, 2^4
* **Y-axis Title:** Accuracy (%)
* **Y-axis Scale:** 50, 55, 60, 65, 70, 75, 80
* **Legend:** Located at the bottom of the chart.
* ThinkPRM-14B (Orange line with star markers)
* ThinkPRM-14B@2 (Blue line with triangle markers)
* ThinkPRM-14B (2 thinking rounds) (Gray dashed line with triangle markers)
### Detailed Analysis
* **ThinkPRM-14B (Orange line with star markers):**
* Trend: The accuracy increases as the number of solutions increases.
* Data Points:
* 2^0 solutions: Accuracy ~51%
* 2^1 solutions: Accuracy ~62%
* 2^2 solutions: Accuracy ~69%
* 2^3 solutions: Accuracy ~76%
* 2^4 solutions: Accuracy ~79%
* **ThinkPRM-14B@2 (Blue line with triangle markers):**
* Trend: The accuracy increases as the number of solutions increases.
* Data Points:
* 2^0 solutions: Accuracy ~51%
* 2^1 solutions: Accuracy ~63%
* 2^2 solutions: Accuracy ~69%
* 2^3 solutions: Accuracy ~81%
* 2^4 solutions: Accuracy ~82%
* **ThinkPRM-14B (2 thinking rounds) (Gray dashed line with triangle markers):**
* Trend: The accuracy increases as the number of solutions increases.
* Data Points:
* 2^0 solutions: Accuracy ~51%
* 2^1 solutions: Accuracy ~62%
* 2^2 solutions: Accuracy ~69%
* 2^3 solutions: Accuracy ~79%
* 2^4 solutions: Accuracy ~81%
### Key Observations
* All three models show an increase in accuracy as the number of solutions increases.
* ThinkPRM-14B@2 generally performs better than the other two models, especially at higher numbers of solutions.
* ThinkPRM-14B (2 thinking rounds) performs slightly better than ThinkPRM-14B, but not as well as ThinkPRM-14B@2.
* The performance of all three models converges at a low number of solutions (2^0 and 2^1).
### Interpretation
The chart demonstrates the scaling performance of different models in solving MATH-500 problems. The x-axis represents the number of solutions considered, and the y-axis represents the accuracy achieved. The results suggest that increasing the number of solutions generally improves accuracy for all models. ThinkPRM-14B@2 appears to be the most effective model, achieving the highest accuracy at higher numbers of solutions. The "2 thinking rounds" modification to ThinkPRM-14B provides a modest improvement, but not as significant as the architectural changes in ThinkPRM-14B@2. The convergence of performance at lower solution counts suggests that the models are similarly constrained when limited to a small search space.
</details>
<details>
<summary>x17.png Details</summary>
### Visual Description
## Line Chart: Parallel vs. Sequential Scaling: MATH-500
### Overview
The image is a line chart comparing the accuracy of different configurations of "ThinkPRM-14B" models as the number of solutions increases. The x-axis represents the number of solutions (ranging from 2^0 to 2^4), and the y-axis represents the accuracy in percentage (ranging from 50% to 80%). Three different configurations are compared: ThinkPRM-14B, ThinkPRM-14B@4, and ThinkPRM-14B (4 thinking rounds).
### Components/Axes
* **Title:** Parallel vs. Sequential Scaling: MATH-500
* **X-axis Title:** Number of solutions
* **X-axis Scale:** 2^0, 2^1, 2^2, 2^3, 2^4
* **Y-axis Title:** Accuracy (%)
* **Y-axis Scale:** 50, 55, 60, 65, 70, 75, 80
* **Legend:** Located at the bottom of the chart.
* **ThinkPRM-14B:** Orange line with star markers.
* **ThinkPRM-14B@4:** Blue line with triangle markers.
* **ThinkPRM-14B (4 thinking rounds):** Gray dashed line with triangle markers.
### Detailed Analysis
* **ThinkPRM-14B (Orange Line):**
* Trend: The line slopes upward, indicating increasing accuracy with more solutions.
* Data Points:
* 2^0 solutions: Accuracy ≈ 51%
* 2^1 solutions: Accuracy ≈ 62%
* 2^2 solutions: Accuracy ≈ 70%
* 2^3 solutions: Accuracy ≈ 76%
* 2^4 solutions: Accuracy ≈ 79%
* **ThinkPRM-14B@4 (Blue Line):**
* Trend: The line slopes upward, indicating increasing accuracy with more solutions.
* Data Points:
* 2^0 solutions: Accuracy ≈ 51%
* 2^1 solutions: Accuracy ≈ 63%
* 2^2 solutions: Accuracy ≈ 71%
* 2^3 solutions: Accuracy ≈ 81%
* 2^4 solutions: Accuracy ≈ 81%
* **ThinkPRM-14B (4 thinking rounds) (Gray Dashed Line):**
* Trend: The line slopes upward, indicating increasing accuracy with more solutions.
* Data Points:
* 2^0 solutions: Accuracy ≈ 51%
* 2^1 solutions: Accuracy ≈ 62%
* 2^2 solutions: Accuracy ≈ 70%
* 2^3 solutions: Accuracy ≈ 79%
* 2^4 solutions: Accuracy ≈ 81%
### Key Observations
* All three configurations show an increase in accuracy as the number of solutions increases.
* ThinkPRM-14B@4 generally performs slightly better than the other two configurations, especially at 2^3 solutions.
* ThinkPRM-14B and ThinkPRM-14B (4 thinking rounds) perform very similarly.
### Interpretation
The chart demonstrates the impact of parallel and sequential scaling on the accuracy of the ThinkPRM-14B model when solving problems from the MATH-500 dataset. Increasing the number of solutions generally improves accuracy for all configurations. The "ThinkPRM-14B@4" configuration, which likely represents a parallel processing approach, shows a slight advantage over the sequential "ThinkPRM-14B" and "ThinkPRM-14B (4 thinking rounds)" configurations, especially as the number of solutions increases. This suggests that parallel scaling can be more effective in improving the model's performance on this task. The performance of "ThinkPRM-14B (4 thinking rounds)" being very close to "ThinkPRM-14B" suggests that increasing the number of thinking rounds has a limited impact on accuracy compared to increasing the number of solutions or using a parallel approach.
</details>
Figure 32: Parallel vs. sequential scaling of ThinkPRM compute under the same generation budget with Qwen-2.5-14B generator. Parallel scaling (model@K) is done by independently sampling $K$ verification CoTs and aggregating their scores. Sequential scaling is done by prompting the model $K$ times to revise its own verification for $K$ thinking rounds. Both setups generate up until 8192 tokens per generation. We do not observe a clear winner although parallel scaling seems slightly better especially at larger sampling budgets.
E.7 Scaling training data of ThinkPRM
Here, we show results when training ThinkPRM -14B and ThinkPRM -1.5B using synthetic data from all PRM800K. The goal is to show that ThinkPRM can still benefit from training on more synthetic data. Here, we train both R1-Distill-Qwen-1.5B and R1-Distill-Qwen-14B on a total of 65K verification CoTs we obtained by sampling and filtering as explained in Section 3.2. Figs. 38 and 38 show best-of-N performance with ThinkPRM -1.5B and ThinkPRM -14B respectively when trained on 65K and compares it to training on 1K examples. Interestingly, ThinkPRM benefits from additional training, and can further improve the accuracy curve compared to the 1K-trained version on MATH-500. We note, however, that while training on more math data boosts performance on MATH-500, we observe some performance drop on out-of-domain tasks due to the distribution shift.
\caption@setoptions
floatrow \caption@setoptions figurerow \caption@setposition b
\caption@setoptions figure \caption@setposition b
<details>
<summary>x18.png Details</summary>
### Visual Description
## Chart: Scaling Training Data for MATH-500
### Overview
The image is a line chart comparing the accuracy (%) of different models (ThinkPRM-1.5B@4 (1K), ThinkPRM-1.5B@4 (65K), DiscPRM-1.5B, and RLHFFlow-8B-Deepseek) against the number of solutions (2^1, 2^3, 2^5, 2^7) used for scaling training data. The data is for the MATH-500 dataset, and the generator used was Llama 3.2-3B-Instruct.
### Components/Axes
* **Title:** Scaling training data: MATH-500
* **Subtitle:** Generator: Llama 3.2-3B-Instruct
* **Y-axis:** Accuracy (%)
* Scale ranges from 45 to 70, with tick marks at intervals of 5.
* **X-axis:** Number of solutions
* Values: 2^1, 2^3, 2^5, 2^7
* **Legend:** Located at the bottom of the chart.
* ThinkPRM-1.5B@4 (1K) (Orange with triangle markers)
* ThinkPRM-1.5B@4 (65K) (Pink with triangle markers, dashed line)
* DiscPRM-1.5B (Teal with circle markers)
* RLHFFlow-8B-Deepseek (Yellow with circle markers)
### Detailed Analysis
* **ThinkPRM-1.5B@4 (1K) (Orange, triangle markers):**
* Trend: Generally increasing.
* Data Points:
* 2^1: ~46%
* 2^3: ~58%
* 2^5: ~62%
* 2^7: ~68%
* **ThinkPRM-1.5B@4 (65K) (Pink, triangle markers, dashed line):**
* Trend: Increasing, plateaus, then increases again.
* Data Points:
* 2^1: ~55%
* 2^3: ~64%
* 2^5: ~64%
* 2^7: ~70%
* **DiscPRM-1.5B (Teal, circle markers):**
* Trend: Increasing, plateaus, then slightly increases.
* Data Points:
* 2^1: ~53%
* 2^3: ~60%
* 2^5: ~65%
* 2^7: ~63%
* **RLHFFlow-8B-Deepseek (Yellow, circle markers):**
* Trend: Increasing, plateaus.
* Data Points:
* 2^1: ~50%
* 2^3: ~62%
* 2^5: ~60%
* 2^7: ~63%
### Key Observations
* ThinkPRM-1.5B@4 (65K) achieves the highest accuracy at 2^7 solutions.
* DiscPRM-1.5B and RLHFFlow-8B-Deepseek plateau in accuracy after 2^3 solutions.
* ThinkPRM-1.5B@4 (1K) shows a steady increase in accuracy across all solution counts.
### Interpretation
The chart illustrates the impact of scaling training data on the accuracy of different models for the MATH-500 dataset. ThinkPRM-1.5B@4 (65K) benefits the most from increased training data, achieving the highest accuracy. DiscPRM-1.5B and RLHFFlow-8B-Deepseek show diminishing returns after a certain point, suggesting that increasing the number of solutions beyond 2^3 does not significantly improve their performance. ThinkPRM-1.5B@4 (1K) shows a consistent improvement with more data, indicating it may benefit from even further scaling. The choice of model and the optimal amount of training data depend on the specific performance requirements and computational resources available.
</details>
Figure 35: Best-of-N results with ThinkPRM -1.5B comparing the version trained on 1K examples (used throughout the paper) and a version trained on 65K examples. ThinkPRM benefits from training on more synthetic data as the performance can further improve with more training. \caption@setoptions figure \caption@setposition b
<details>
<summary>x19.png Details</summary>
### Visual Description
## Chart: Scaling Training Data for MATH-500
### Overview
The image is a line chart comparing the accuracy (%) of different models (ThinkPRM-14B (1K), ThinkPRM-14B (65K), DiscPRM-14B, and Majority) against the number of solutions (ranging from 2^0 to 2^5) used for training data. The chart title is "Scaling training data: MATH-500" and it indicates that the generator used was "Qwen2.5-14B".
### Components/Axes
* **Title:** Scaling training data: MATH-500
* **Subtitle:** Generator: Qwen2.5-14B
* **Y-axis:** Accuracy (%) with scale from 50 to 85, incrementing by 5.
* **X-axis:** Number of solutions, with values 2^0, 2^1, 2^2, 2^3, 2^4, and 2^5.
* **Legend:** Located at the bottom of the chart.
* ThinkPRM-14B (1K) - Orange line with star markers
* ThinkPRM-14B (65K) - Pink line with circle markers
* DiscPRM-14B - Teal line with circle markers
* Majority - Tan line with circle markers
### Detailed Analysis
* **ThinkPRM-14B (1K) (Orange):**
* Trend: Generally increasing.
* Data Points:
* 2^0: ~51%
* 2^1: ~51%
* 2^2: ~69%
* 2^3: ~79%
* 2^4: ~80%
* 2^5: ~83%
* **ThinkPRM-14B (65K) (Pink):**
* Trend: Increasing, then plateaus slightly.
* Data Points:
* 2^0: ~51%
* 2^1: ~64%
* 2^2: ~71%
* 2^3: ~79%
* 2^4: ~83%
* 2^5: ~85%
* **DiscPRM-14B (Teal):**
* Trend: Increasing initially, then plateaus.
* Data Points:
* 2^0: ~51%
* 2^1: ~62%
* 2^2: ~69%
* 2^3: ~74%
* 2^4: ~73%
* 2^5: ~75%
* **Majority (Tan):**
* Trend: Increasing initially, then plateaus.
* Data Points:
* 2^0: ~51%
* 2^1: ~51%
* 2^2: ~69%
* 2^3: ~73%
* 2^4: ~73%
* 2^5: ~73%
### Key Observations
* ThinkPRM-14B (65K) consistently achieves the highest accuracy across all numbers of solutions.
* The Majority model plateaus at a lower accuracy compared to the other models.
* All models start at approximately the same accuracy (~51%) when the number of solutions is 2^0.
* The accuracy of DiscPRM-14B and Majority models plateaus after 2^3 solutions.
* ThinkPRM-14B (1K) and ThinkPRM-14B (65K) continue to increase in accuracy up to 2^5 solutions.
### Interpretation
The chart illustrates the impact of scaling training data (number of solutions) on the accuracy of different models for the MATH-500 dataset. The ThinkPRM-14B (65K) model demonstrates the best performance, suggesting that increasing the training data size significantly improves its accuracy. The plateauing of the DiscPRM-14B and Majority models indicates that they may have reached their learning capacity with the given dataset and architecture, and further increasing the training data may not lead to significant improvements. The ThinkPRM-14B (1K) model shows a steady increase in accuracy, suggesting that it could potentially benefit from even more training data. The choice of model and the amount of training data are crucial factors in achieving high accuracy on the MATH-500 dataset.
```
</details>
Figure 38: Best-of-N results with ThinkPRM -14B comparing the version trained on 1K examples (used throughout the paper) and a version trained on 65K examples. ThinkPRM benefits from training on more synthetic data as the performance can further improve with more training.
E.8 Results with automatic labels
Table 4 shows performance when filtering training data based on manual labels (PRM800K) vs automatic labels (Math-Shepherd) (Wang et al., 2023b). ThinkPRM still performs well even with automatic labels, and comparably to manual labels.
| ThinkPRM-1.5B (PRM800K) ThinkPRM-1.5B (Math-shepherd) | 76.3 75.8 | 75.7 76.5 |
| --- | --- | --- |
Table 4: Comparison of ThinkPRM-1.5B trained on PRM800K vs Math-shepherd step labels.
E.9 Verifier performance in terms of problem difficulty
<details>
<summary>x20.png Details</summary>
### Visual Description
## Bar Chart: Model Accuracy vs. Problem Difficulty
### Overview
The image presents two bar charts comparing the accuracy of two models, ThinkPRM-14B and DiscPRM-14B, across problems binned by difficulty. The left chart focuses on "Math-500" problems, while the right chart focuses on "GPQA-Physics" problems. Both charts display accuracy (in percentage) on the y-axis and problem difficulty (binned) on the x-axis.
### Components/Axes
* **Titles:**
* Left Chart: "Best-of-32: Math-500"
* Right Chart: "Best-of-32: GPQA-Physics"
* **Y-axis:** "Accuracy (%)", ranging from 0 to 100 in increments of 20.
* **X-axis:** "Problems binned by difficulty".
* Left Chart: Categories 1, 2, 3, 4, 5
* Right Chart: Categories 1, 2, 3, 4
* **Legend:** Located at the bottom of the image.
* Orange: "ThinkPRM-14B"
* Teal: "DiscPRM-14B"
### Detailed Analysis
**Left Chart: Math-500**
* **ThinkPRM-14B (Orange):**
* Difficulty 1: Accuracy ~97%
* Difficulty 2: Accuracy ~80%
* Difficulty 3: Accuracy ~92%
* Difficulty 4: Accuracy ~72%
* Difficulty 5: Accuracy ~48%
* Trend: Generally decreasing accuracy as difficulty increases.
* **DiscPRM-14B (Teal):**
* Difficulty 1: Accuracy ~97%
* Difficulty 2: Accuracy ~80%
* Difficulty 3: Accuracy ~83%
* Difficulty 4: Accuracy ~58%
* Difficulty 5: Accuracy ~36%
* Trend: Decreasing accuracy as difficulty increases.
**Right Chart: GPQA-Physics**
* **ThinkPRM-14B (Orange):**
* Difficulty 1: Accuracy ~99%
* Difficulty 2: Accuracy ~97%
* Difficulty 3: Accuracy ~57%
* Difficulty 4: Accuracy ~14%
* Trend: Decreasing accuracy as difficulty increases.
* **DiscPRM-14B (Teal):**
* Difficulty 1: Accuracy ~99%
* Difficulty 2: Accuracy ~79%
* Difficulty 3: Accuracy ~40%
* Difficulty 4: Accuracy ~10%
* Trend: Decreasing accuracy as difficulty increases.
### Key Observations
* Both models perform well on easier problems (difficulty 1 and 2) for both Math-500 and GPQA-Physics.
* Accuracy decreases as problem difficulty increases for both models and both problem sets.
* For Math-500, ThinkPRM-14B generally outperforms DiscPRM-14B, especially at difficulty levels 3, 4, and 5.
* For GPQA-Physics, ThinkPRM-14B outperforms DiscPRM-14B at difficulty levels 3 and 4.
* The drop in accuracy is more pronounced for GPQA-Physics than for Math-500 as difficulty increases.
### Interpretation
The data suggests that both models are more proficient at solving easier problems. As the difficulty level increases, the accuracy of both models decreases, indicating a limitation in their ability to handle more complex problems. The ThinkPRM-14B model generally performs better than the DiscPRM-14B model, especially for Math-500 problems. The more significant drop in accuracy for GPQA-Physics problems suggests that these problems are inherently more challenging for both models compared to Math-500 problems. The "Best-of-32" prefix in the titles likely refers to the number of attempts or samples used to determine the accuracy, implying a statistical approach to evaluating model performance.
</details>
Figure 39: ThinkPRM helps with challenging reasoning problems compared to DiscPRM. The generator model here is Qwen-2.5-14B for MATH-500 and Qwen-2.5-32B-Instruct for GPQA.
We the difficulty We do not estimate the difficulty over MATH problem since each problem in MATH is annotated based on 1 of 5 difficulty levels. For GPQA-Physics problems, we first compute the pass@1 rate of Qwen2.5-32B-Instruct for every problem by sampling 32 solutions for each problem. Then, we bin the pass@1 rates into four different bins and use the bin assignment for each problem as the difficulty level. As discussed in Section 5.6, Fig. 39 show how ThinkPRM helps more with verifying hard problems compared to DiscPRM.
| QwQ-32B Bad-step-index Decision-for-each-step | Single Yes/No 65.4 (18.3 %) 40.1 (6.4 %) | 50.6 (7.9 %) 69.0 (16.8 %) 36.6 (9.2 %) | 55.5 (3.2 %) |
| --- | --- | --- | --- |
| R1-Qwen-14B | Single Yes/No | 72.8 (13.3 %) | 67.8 (18.6 %) |
| Bad step index | 77.7 (17.0 %) | 76.6 (17.9 %) | |
| Decision-for-each-step | 73.3 (14.6 %) | 71.4 (14.7 %) | |
Table 5: F1-score on OlympiadBench and OmniMath subsets from ProcessBench with different prompts. Ratio of invalid judgments is shown in red.
Example problem-solution pair from ProcessBench
Problem:
In quadrilateral $ABCD$ , $\mathrm{m}\angle B+\mathrm{m}\angle D=270^{\circ}$ . The circumcircle of $\triangle ABD$ intersects $\overline{CD}$ at point $E$ , distinct from $D$ . Given that $BC=4$ , $CE=5$ , and $DE=7$ , compute the diameter of the circumcircle of $\triangle ABD$ .
Solution:
Step 0: To solve this problem, we will use several properties of geometry, particularly related to circles and quadrilaterals. Let’s break down the steps: First, we understand the given information. We have a quadrilateral $ABCD$ where $\angle B+\angle D=270^{\circ}$ . The circumcircle of $\triangle ABD$ intersects $\overline{CD}$ at point $E$ , distinct from $D$ . Additionally, $BC=4$ , $CE=5$ , and $DE=7$ .
Step 1: Next, we apply properties of cyclic quadrilaterals and circles. Since $E$ lies on the circumcircle of $\triangle ABD$ , $E$ is also part of the circumcircle of $\square ABCD$ (assuming $ABCD$ is cyclic, which will be justified later). In a cyclic quadrilateral, opposite angles sum up to $180^{\circ}$ . Given $\angle B+\angle D=270^{\circ}$ , it suggests an error in our initial understanding or misinterpretation, since angles cannot sum to more than $360^{\circ}$ in a quadrilateral. However, if we consider the context, let’s assume a correction was intended for the sake of explanation: Correct interpretation: If we adjust for logical consistency, perhaps the intention was to imply that one of the angles at $B$ or $D$ is $90^{\circ}$ (since this would fit the property of cyclic quadrilaterals better, aligning with the geometry principles involved). For this explanation, let’s proceed with an assumption that either $\angle B$ or $\angle D$ is $90^{\circ}$ , aiming for a coherent solution path.
Step 2: We then use the Power of a Point Theorem. The Power of a Point Theorem states that for a point $P$ outside a circle, the product of the lengths of the two segments from $P$ to the circle equals the product of the lengths of the other two segments when considering tangents or secants from that point. However, in this case, $E$ is not outside but on the circumference of the circle, and we apply it differently: Given $BC=4$ and $CE=5$ , $DE=7$ , and knowing $E$ is part of the circumcircle, we can apply the property of intersecting chords in a circle, which states that the product of the lengths of the segments of one chord is equal to the product of the lengths of the segments of the other chord. Thus, in this scenario, we consider $BC$ and $CD$ as intersecting chords, where $CD=BC+CE=4+5=9$ .
$$
BC\cdot CD=CE\cdot DE
$$
Substituting the known values:
$$
4\cdot 9=5\cdot DE
$$
$$
36=5\cdot DE
$$
Thus,
$$
DE=\frac{36}{5}=7.2.
$$
Step 3: This discrepancy suggests a reevaluation of the given values or a misunderstanding in their application within the context provided. However, for the purpose of demonstrating the method:
Step 4: Finally, we find the diameter of the circumcircle of $\triangle ABD$ . The key to finding the diameter involves recognizing that the circumcircle’s radius or diameter is crucial for calculating distances involving points $A$ , $B$ , and $D$ . However, without specific details about how $E$ relates to these points geometrically beyond being on the circle, or additional information such as the length of another segment or angle measures, directly calculating the diameter becomes complex.
Step 5: The question’s focus on $E$ and its relation to $BC$ , $CE$ , and $DE$ might suggest looking at the properties of chords in a circle or applying trigonometric relationships based on the angles given initially. However, due to the discrepancy noted and the complexity introduced by the misinterpretation of the angle condition, a direct calculation for the diameter of the circumcircle of $\triangle ABD$ isn’t straightforward with the information provided.
Step 6: Given the complexities and discrepancies in the original problem statement, particularly with the angles summing to $270^{\circ}$ in a quadrilateral, the solution path becomes less clear. The explanation provided aimed to creatively interpret and apply geometric principles under the constraints of the given information. However, the direct calculation for the diameter of the circumcircle of $\triangle ABD$ requires additional, precise information about the positions and relationships of the points $A$ , $B$ , $C$ , $D$ , and $E$ within the quadrilateral and its circumcircle.
Figure 40: An example problem and solution from the OlympiadBench (He et al., 2024) in ProcessBench (Zheng et al., 2024).
Example from QwQ-32B-Preview
Let’s verify step by step: Step 0: The initial step seems to correctly identify the given information in the problem. It mentions the quadrilateral $ABCD$ with angles at $B$ and $D$ summing to $270^{\circ}$ , and the circumcircle of $\triangle ABD$ intersecting $\overline{CD}$ at $E$ , distinct from $D$ . The lengths $BC=4$ , $CE=5$ , and $DE=7$ are also noted. This step is accurate in summarizing the problem statement.
Step 1: This step attempts to apply properties of cyclic quadrilaterals but seems to get confused about the sum of angles in quadrilateral $ABCD$ . It is mentioned that in a cyclic quadrilateral, opposite angles sum to $180^{\circ}$ , but the given sum of angles $\angle B$ and $\angle D$ is $270^{\circ}$ , which indeed seems inconsistent. However, the step then suggests assuming that one of the angles is $90^{\circ}$ for the sake of explanation, which is an adjustment to proceed with the solution. This part is a bit problematic because it alters the given information, but perhaps there was a misinterpretation in the problem statement.
Step 2: Here, the Power of a Point Theorem is applied to points related to the circle. However, there is confusion in calculating the length of $\overline{CD}$ . It states that $CD=BC+CE=4+5=9$ , but since $E$ is a point on $\overline{CD}$ distinct from $D$ , and $DE$ is given as $7$ , this suggests that $CD=CE+DE=5+7=12$ , not $9$ . This is an error in calculation. Furthermore, the application of the Power of a Point Theorem seems misapplied because $E$ is on the circle, not outside it, so the theorem should be applied differently, possibly considering intersecting chords.
Step 3: Recognizing the discrepancy in the previous step, the solution acknowledges the need for reevaluation, which is a good practice. However, without correcting the earlier mistake in calculating $\overline{CD}$ , the subsequent steps may be built on incorrect foundations.
Step 4: This step aims to find the diameter of the circumcircle of $\triangle ABD$ , which is the main goal of the problem. It notes that the diameter is related to the circumradius, but without specific details about the triangle’s sides or angles, it’s challenging to compute directly. The solution hints at the need for more information, which is accurate.
Step 5: The insight here is that the relationship between $E$ and the other points might provide the necessary information through chord properties or trigonometric relationships. However, due to the earlier discrepancies, this step does not lead to a concrete calculation.
Step 6: The conclusion reflects on the complexities and discrepancies in the problem and the solution approach. It acknowledges that the direct calculation for the diameter is not straightforward with the given information, which is a fair assessment.
Overall, while the solution attempt shows an understanding of relevant geometric principles, there are significant errors in calculation and application of theorems, particularly in Step 2. These errors propagate through the subsequent steps, leading to an inconclusive solution. Therefore, the solution is not correct.
\boxed {no}
Figure 41: Example verification chain generated by QwQ-32B-Preview in response to the problem-solution pair in Fig. 40.
Appendix F More details on LLM-as-judge verification
The instruction used for LLM-as-judge verification in Section 3.1 is shown in Fig. 42, which we refer to as Single-label. Table 5 shows performance of QwQ-32B-Preview and Qwen-Deepseek-R1-14B with two more instructions. Bad-step-index refers to instructing the model to find the index of the first incorrect step and then if a step is found generate a single yes/no label regarding the solution correctness. Decision-for-each-step instructs the model to critique and produce a boxed label for each step. This instruction is shown in Fig. 21. We observe high ha variance in verification performance and invalid judgment ratio depending on the prompt.
LLM-as-a-judge prompt
The following is a math problem and a solution (split into steps, enclosed with tags and indexed from 0): [Math Problem] {problem} [Solution] {prefix} Your task is to review and critique the solution step by step. Your output must be in the following format: Step 0: <critique> Step 1: <critique> … Step n: <critique> After your analysis, return yes/no depending on whether the solution is correct. Please put your final answer (i.e., yes/no) in \boxed{}
Figure 42: Prompt used for LLM-as-a-judge verification in Section 3.1
We also an example from ProcessBench in Fig. 40 and the generated verification chain from QwQ-32B-Preview in Fig. 41.
Appendix G Examples from ThinkPRM
Fig. 44 shows an example of a verification CoT from ThinkPRM -14B on a problem and solution from the OmniMath subset in ProcessBench, shown in Fig. 43.
Figure 43: Problem and solution from the OmniMath subset of ProcessBench. The verification CoT output by ThinkPRM is shown in Fig. 44
Example verification chain-of-thought
Problem: A solid rectangular prism has dimensions 4 by 2 by 2. A 1 by 1 by 1 cube is cut out of the corner creating the new solid shown. What is the surface area of the new solid? Solution: Step 1: To determine the surface area of the new solid after cutting a 1 by 1 by 1 cube from one corner of a 4 by 2 by 2 rectangular prism, we will follow these steps: First, calculate the surface area of the original rectangular prism. The original rectangular prism has dimensions 4 by 2 by 2. The surface area $A_{\text{original}}$ of a rectangular prism is given by: $A_{\text{original}}=2(lw+lh+wh)$ where $l=4$ , $w=2$ , and $h=2$ . Substituting these values in, we get: $A_{\text{original}}=2(4· 2+4· 2+2· 2)=2(8+8+4)=2· 20=40$ Step 2: Second, determine the effect of cutting out the 1 by 1 by 1 cube. When we cut out a 1 by 1 by 1 cube from one corner, we remove three faces of the cube (one face for each dimension) but add three new faces of the same size. Each face of the cube is 1 by 1, so the area of each face is 1 square unit. Step 3: Third, calculate the change in surface area. Removing the three faces of the cube reduces the surface area by $3× 1=3$ square units. Adding the three new faces increases the surface area by $3× 1=3$ square units. Therefore, the net change in surface area is: $3-3=0$ Step 4: Finally, calculate the total surface area of the new solid. Since the net change in surface area is zero, the surface area of the new solid remains the same as the original surface area: $A_{\text{new}}=A_{\text{original}}=40$ Thus, the surface area of the new solid is $\boxed{40}$ .
Example verification chain-of-thought from ThinkPRM -14B
Verification: <think> Alright, I’ve got this math problem about finding the surface area of a solid after cutting out a small cube from a larger rectangular prism. The original prism has dimensions 4 by 2 by 2, and a 1 by 1 by 1 cube is removed from one corner. The provided solution has four steps, and I need to review each one to see if it’s correct. Let’s start with Step 1. Step 1: The solution calculates the surface area of the original rectangular prism. The formula used is $A_{\text{original}}=2(lw+lh+wh)$ , which is correct for a rectangular prism. Plugging in the dimensions $l=4$ , $w=2$ , and $h=2$ , the calculation goes like this: $A_{\text{original}}=2(4· 2+4· 2+2· 2)=2(8+8+4)=2· 20=40$ This seems right. So, Step 1 is \\boxed{correct}. Step 2: Here, the solution talks about the effect of cutting out the 1 by 1 by 1 cube from one corner. It says that removing the cube takes away three faces but adds three new faces. Each face is 1 by 1, so each has an area of 1 square unit. Wait a minute, is this accurate? When you cut out a cube from a corner, you are indeed removing material, but how does that affect the surface area? Let me visualize this. Imagine a rectangular prism and cutting out a small cube from one corner. The cube has three faces exposed to the outside of the prism. When you remove the cube, those three faces are no longer part of the surface area. However, the removal also creates three new internal faces where the cube was taken out, which are now part of the surface area. So, the solution says that removing three faces reduces the surface area by 3 square units and adding three faces increases it by 3 square units, leading to no net change. That seems logical at first glance. But is this actually correct? Let me think deeper. When you remove the cube, you are taking away three 1x1 faces from the original prism, which indeed reduces the surface area by 3 square units. However, the new faces created are also 1x1, and there are three of them, so that adds 3 square units back. So, the total surface area remains the same. But I’m not entirely sure. Maybe I should consider if the new faces are actually exposed or if they are somehow internal. Wait, no. When you cut out the cube from the corner, the three new faces are now part of the exterior of the new solid, so they should be included in the surface area. Therefore, the net change is indeed zero, and the surface area remains 40. Hmm, but I recall that sometimes when you make a cut, the surface area can change in unexpected ways. Maybe I should double-check this. Let me consider a simpler example. Suppose I have a cube and I cut out a smaller cube from one corner. How does the surface area change? Original cube: surface area is $6s^{2}$ , where $s$ is the side length. After cutting out a smaller cube from one corner, I remove three faces of the smaller cube and expose three new faces. So, the change in surface area is $-3s^{2}+3s^{2}=0$ , similar to what the solution says. Alternatively, perhaps I can think about the new solid’s dimensions. But I think the initial approach is correct. Therefore, Step 2 is \\boxed{correct}. Step 3: This step calculates the net change in surface area as zero, which follows from Step 2. Since the net change is zero, the surface area remains the same as the original. So, Step 3 is \\boxed{correct}. Step 4: Concludes that the surface area of the new solid is 40, the same as the original. Therefore, Step 4 is \\boxed{correct}. Wait, but I recall that sometimes when you make a cut, especially in certain ways, the surface area can change. But in this case, it seems to hold up.
Figure 44: Example output by ThinkPRM -14B, where it verifies and labels every step in the provided prefix via a long verification CoT. The problem and solution are in Fig. 43
Alternatively, maybe I should consider if the cube is cut from a corner where only two faces are on the exterior. Wait, no. In a rectangular prism, each corner is where three faces meet, so cutting out a cube from a corner would remove three faces and expose three new ones. But perhaps I should consider if the cube is cut from a corner where one of the original faces is larger than 1x1. Wait, the original prism is 4x2x2, and the cube being removed is 1x1x1, so the faces being removed are indeed 1x1. So, the calculation seems accurate. Alternatively, maybe I can think about it in terms of the total surface area. Alternatively, perhaps I can think about the surface area of the new solid directly. Let me try that. The new solid has the original surface area minus the three 1x1 faces that were removed, plus the three new 1x1 faces that are now exposed. So, 40 - 3 + 3 = 40. Alternatively, perhaps I can think about the surface area as the sum of all exterior faces. But I think the initial approach is correct. Therefore, the solution is correct. But the instruction says to review and critique each step, and determine if the whole solution is correct. So, in this case, all steps seem correct, leading to the conclusion that the surface area remains 40. </think>
Verification of long CoT solution
Problem: Convert the point $(0,3)$ in rectangular coordinates to polar coordinates. Enter your answer in the form $(r,\theta)$ , where $r>0$ and $0≤\theta<2\pi$ . Solution: Okay, so I need to convert the rectangular coordinates $(0,3)$ to polar coordinates. Let me recall how to do this. From what I remember, polar coordinates are given as $(r,\theta)$ , where $r$ is the distance from the origin to the point, and $\theta$ is the angle made with the positive $x$ -axis. The formulas to convert between rectangular $(x,y)$ and polar $(r,\theta)$ coordinates are: $x=r\cos\theta,\quad y=r\sin\theta$ To find $r$ , we use: $r=\sqrt{x^{2}+y^{2}}$ To find $\theta$ , we use: $\theta=\arctan\left(\frac{y}{x}\right)$ But I need to be careful with the quadrant since $\arctan$ may be undefined or ambiguous when $x=0$ . Given $x=0$ and $y=3$ , compute: $r=\sqrt{0^{2}+3^{2}}=\sqrt{9}=3$ So $r=3$ . For $\theta$ , since $x=0$ , the expression $\arctan(y/x)$ is undefined due to division by zero. However, because the point lies on the positive $y$ -axis, $\theta=\frac{\pi}{2}$ . This is the standard angle for points directly above the origin. Therefore, the polar coordinates are \boxed{(3, \frac{\pi}{2})}. Wait, let me check if there’s another way to get this. Since the point is $(0,3)$ , which is on the positive $y$ -axis, the angle is indeed $\frac{\pi}{2}$ . Could $\theta$ be $\frac{3\pi}{2}$ ? No, $\frac{3\pi}{2}$ is the negative $y$ -axis, which is the opposite direction. Since the point is on the positive $y$ -axis, $\theta=\frac{\pi}{2}$ . Let me recall again that when converting from rectangular to polar, $\theta$ is calculated as $\arctan(y/x)$ , but when $x=0$ , $\theta$ is either $\frac{\pi}{2}$ or $\frac{3\pi}{2}$ depending on the sign of $y$ . Here $y>0$ , so the correct angle is $\frac{\pi}{2}$ . … ThinkPRM -1.5B: <think> Step 1: The student correctly recalls the formulas for converting from rectangular to polar coordinates: $x=r\cos\theta,\quad y=r\sin\theta$ and $r=\sqrt{x^{2}+y^{2}},\quad\theta=\arctan\left(\frac{y}{x}\right)$ This step is \boxed{correct}. Step 2: The student computes: $r=\sqrt{0^{2}+3^{2}}=3$ This is \boxed{correct}. Step 3: The student identifies that $\theta=\arctan(3/0)$ is undefined but correctly infers that the point lies on the positive $y$ -axis, hence $\theta=\frac{\pi}{2}$ . This reasoning is also \boxed{correct}. … </think>
Figure 45: Example of verification of long CoT solution from Qwen3-1.7B-thinking using ThinkPRM -1.5B. ThinkPRM extracts and verifies individual steps embedded in the long CoT.