SETS: Leveraging Self-Verification and Self-Correction for Improved Test-Time Scaling
Authors: Jiefeng Chen
Jie Ren
Xinyun Chen
Chengrun Yang
Ruoxi Sun
Jinsung Yoon
Sercan O Arik
Venue: Accepted by TMLR ()

Abstract: Recent advancements in Large Language Models (LLMs) have created new opportunities to enhance performance on complex reasoning tasks by leveraging test-time computation. However, existing scaling methods have key limitations: parallel methods like repeated sampling are often inefficient and quickly saturate, while sequential methods like SELF-REFINE struggle to improve after a few rounds. Although combining these approaches shows promise, current methods require fine-tuned reward and revision models. This paper proposes Self-Enhanced Test-Time Scaling (SETS), a simple yet effective approach that overcomes these limitations by strategically combining parallel and sequential techniques and fully leveraging LLMs' self-improvement abilities. SETS exploits the inherent self-verification and self-correction capabilities of LLMs, unifying sampling, verification, and correction within a single framework. This facilitates efficient and scalable test-time computation for enhanced performance on complex tasks without any model training. Our comprehensive experimental results on challenging benchmarks spanning planning, reasoning, math, and coding demonstrate that SETS achieves significant performance improvements and more advantageous test-time scaling behavior than the alternatives.

Published in Transactions on Machine Learning Research (11/2025)
SETS: Leveraging Self-Verification and Self-Correction for Improved Test-Time Scaling
Jiefeng Chen
jiffenee@google.co
Google Cloud AI Research
Jie Ren Google DeepMind
jjren com
Xinyun Chen Google Mind
rinyunchen www.ogl...gggogoccooooo
Chengrun Yang Google Deep
chengrun@googlee.cm
Ruoxi Sun Google Mind
ruomis@google. com
Jinsung Yoon
jisunggyon&kgoogle.comm
Google Cloud AI Research
Sercan Ö. Arık Google
soarsk@gooole..com
Reviewed OpenReview:
optnnevee/pnnreveee. net/ forum? id= WooNKKJoKu
Abstract
Recent advancements in Large Language Models (LLMs) have created new opportumities to enhance performance on complex reasoning tasks by leveraging test-time computation. However, existing scaling methods have key limitations: parallel methods like repeated sampling are often inefficient. and quickly saturate, while sequential methods like SELF- REFINE struggle improve after few rounds. Although combining these approaches shows promise, current methods require fine-tuned reward and revision models. This paper proposes Self-Enhanced Test-Time Scaling (SETS), simple yet effective approach that overcomes these limitations by strategically combining parallel and sequential techniques and fully leveraging LLMs' self-improvement abilities. SETS exploits the inherent self-verification and self-correction capabilities LLMs, unifying sampling, verification, and correction within a single framework. This facilitates efficient and scalable test-time computation for enhanced performance on complex tasks without any model training. Our comprehensive experimental results on challenging benchmarks spanning planning, reasoning, math, and coding demonstrate that SETS achieves significant performance improvements and more advantagcous tost-time scaling behavior than the alternatives.
1 Introduction
Large Language Models (LLMs) have revolutionized artificial intelligence by demonstrating remarkable capabilities planning, reasoning, coding, and problem-solvine across diverse tasks (Tem et al.) 2024 Touvron et al. 2023 Achiam al.] 2023 anthropic 2024). Their success stems not only from "training scaling", i.e., their ability to leverage vast datasets and computational resources during training (Kaplan et al. 2020), but also from their ability benefit from increased compute at test-time to better address

---

Published in Transactions on Machine Learning Research (11/2025)
more challenging queries commonly referred to as "test-time (inference) scaling" (Snell et al. 2024
Wu
et al. 2024
Conventional test-time scaling approaches fall into two categories: parallel and sequential scaling, The parallel scaling approaches such as repeated sampling (Brown et al.) 2024). involve generating multiple candidate solutions and selecting the optimal one using techniques like majority voting or task-specific reward models. While these parallel scaling approaches can be effective in certain scenarios, they have notable limitations. The performance improvements from repeated sampling often quickly plateau the amount of compute increases (Brown al. 2024h. Also, the reliance task-specific reward models (Christiano et al. 2017 Snell ct al. 2024) adds significant training overhead, limiting both efficiency and scalability. The sequential scaling approaches such as SELF-REFINE (Madaan et al., 2024) iteratively revise the current response based on the feedback until the response is verified as correct. As we improve the self-verification and self-correction capabilities of L.LMs, sequential scaling approaches become more effective. However, sequential scaling cannot. effectively scale up test-time compute to further improve the performance since the performance typically salurates quickly as we increase the self-refinement iterations. Sequential scaling methods like SELF-REPINE stop refining answer once it is verified as correct, which limits them from scaling to an arbitrarily high compute budget.
To effectively enable more optimal scaling for test-time compute with a canonical framework, we propose an alternative approach that strategically combines the parallel and sequential scaling techniques without training any additional models. Such strategies had been under-explored, likely due to the limited effectiveness of self-correction in earlier generations of LLMs (Huang et al.p. However, recent advancements in LLMs have led to significantly improved self-verification and self-correction abilities (Team et al. 2024 gem
These improvements present an opportunity to rethink test-time scaling by moving beyond applying parallel and sequential scaling independently, potentially achieving greater efficiency and generalizability in solving complex tasks.
In this paper, we propose Self-Enhaneee Enhanced Test-Time Scaling (SETS) that combines both the parallel and sequential scaling with Sampling, Self-Verily and Self-Correct operations to scale test-time compute. We show that this approach yields more effective test-time compute scaling (i.e., achieving higher accuracy with less compute) compared to notable alternatives such repcated sampling and SELF-REFINE, demonstrated with recently-developed advanced LLMs. We evaluate SETS on five challenging benchmarks: NATURAL PLAN (Zheng et al. 2024), LiveBench Reasoning (White et al.) 2024). MATH 500 (Hendrycks et al. 2021), AIME 2024-2025 (aim), and LiveCodeBench TestOutpptPred (Jain et al. 2024). In our experiments, SETS offers a clear advantage in test-time scaling: it maintains higher effectiveness and experiences less fall-off in performance gains, ultimately outperforming alternatives.
In summary, our contributions are as follows:
We propose SETS, a simple yet effective method that improves the efficiency of test-time compute scaling for LLMs by leveraging the inherent self-verification and self-correction capabilities of LLMs and combining parallel and sequential scaling techniques.
We perform extensive experiments to demonstrate that SETS outperforms parallel scaling methods like repeated sampling and sequential scaling approaches like SELF-REFINE, achieving up to 10.9% accuracy improvement. on the planning, reasoning, math and coding benchmarks with both non-thinking and thinking models. These results highlight SETS's effectiveness for complex reasoning tasks.
We conduct ablation studies to analyze the impact of key hyperparameters, such as the maximum number of self-correction rounds and the temperature used during LIM inference, on the performance of SETS. The results indicate that SETS is robust to these settings and achieves strong performance with minimal hyperparancter tuning.
2
Related Work
Test-Time Scaling. Recent studies have explored leveraging additional test-time compute to enhance the performance of L.Mss (Welleck et al. 2024). There are mainly two kinds of test-time scaling approaches:
2

---

Published in Transactions on Machine Learning Research (11/2025)
parallel and sequential scaling (Balachandran et al. 2025 Parallel scaling samples multiple responses from the same model and then aggregates them to obtain final result through different operators such as majority voting or reward model scoring (Brown et al., 2024). Sequential scaling iteratively improves the response utilizing the feodback of the same model until the response is verified as correct (Madaan et al.) 2024). When srpcess-based verifier reward models are available, we can also scale lest-time compute by searching against the reward models (e.g., Beam Search and Look-ahead Search (Snell et al. 2024)). We study test-time scaling without utilizing external reward models. We propose a simple yet effective method that combines both parallel and sequential scaling to achieve better test-time scaling performance than those conventional approaches that apply parallel or sequential scaling alone. While Snell et al. (2024) also explored combining parallel sampling and sequential revisions to improve test-time scaling, their approach was limited by the need to train lask-specific verifiers and revision models. This dependency may not be practical in world scenarios due to the high cost of collecting additional training data. Furthermore, our evaluation is more comprchensive. Unlike Sncll et al. (2024), which only tested their method on the MATH benchmark with a single model (PaLM 2-S), our proposed method, SETS, is evaluated on six diverse and challenging benchmarks spanning planning, reasoning, math, and coding. We also test with both "non-thinking and "thinking" models, which more thoroughly demonstrates the generalization and robustness of our approach. For more detailed comparison, please see Appendix F
Self- Verificatii. Verification or reward models play a crucial role in scaling inference compute. Traditional approaches often involve training additional verifiers (Cobbe et al. 2021 Li et al., 2022 Lightman et al.) 2023
Liang et al. 2024). More recently, studies showed that LLMs possess the ability to self-verily their
outputs (Weng et al. 2023 Song et al. 2024 Zhao et al. 2025). Our work builds on this insight, demonstrating that scaling test-time compute can be significantly enhanced by leveraging LLMs' self-verification performance,
particularly for complex reasoning tasks.
Celf-Correction. Recent research showed that LLMs can refine their solutions to improve performance using either external feedback (Gou et al.). feedback (Madaan et al.] et al. 2024), or oracle evaluation (Tee et al. 2025). However, Huang et al. observed that LLMs often struggle to self-correct their responses without external feedback. QQu et al.
2024 Cook et al.) 2024 Ferraz
(2024) proposed an iterative fine-tuning procedure to teach the model to refine its response by recursively delecting and correcting its previous mistakes where the model was trained on a collection of multi-turn data on the domain of math. Our work shows that self-correction, guided by self-verification, can effectively scale test-time compute and significantly improve performance on complex reasoning tasks for advanced LLMs.
Test-Time Scaling Laws and Model Sizes. The trade-off between model sizes and test-time compute allocation is of paramount interest. Wu et al. (2024] examined the trade-off between model sizes and generating additions ional tokens using stradegies such as greedy search, majority voting, and Best-of-N. It demonstrated that outperform larger models given the same computation budget. iZhang et al. (2024) extended the study from scaling a single LLM to a mixture of multiple LLMs, and proposed an algorithu to find the optimal compute allocation among the mixture, customized for a given task. [Chen et al. (2024) observed that in multiple-choice QA tasks, the scaling law based on majority vote only holds for easy queries but not for hard queries. We also study how the scaling law behaves differently for different models, as well as at different difficulty levels of the queries, when relfvveriiiottio and self-correction are utilized at test-time.
small model with advanced inference algorithms
3 Method
We introduce Self-Enhanced Test-Time Sealing (SETS) framework, which aims to improve accuracy of LLM--enerated responses by strategically applying more compute at test time. We leverage the inherent self self-verification and self-corroction capabilities of LLMS and combine parallel and sequential scaling tochniques to achieve better test-time scaling performance. We consider three core operations in the design: Sampling, Self- Verify, and Self- Self-Correct, shown in Figure
3

---

Published in Transactions on Machine Learning Research (11/2025)
Yu
Sampling
Self-Verify
ya
Query
LLM
Sampling
Self- Self-Verify
Self-Correct
Self-Verify
-i
Majority Vote
Sampling
Self-Veriffy
Self-Correct
Self-Verify
Iterate j (up to n) times
Sampling
Self-Verify
Self-Correct
Please solve the following problem, and put your final answer within (aoved!).
(TASK) and (PROPOSED
You given (TASK) and of [SOLUTION-NNLLY]) pairs. Your derive solution.
SOLUTIN). Your job is to verify if the solution
PROBLEM: Compute: 1-2+3 +99. 100.
LLM
LLM
LLM
Group terms pairs
The solution needs to satisfy the following constraints: (a), The proposed
The initial solution has the issue violating The revised solution should (now, nne_sslutionn;
(1 (1=2)+(3-4)+ (999-100), and each pair sums to -1 answer \boxed(-50).
solution is incorrect because violates (a).
Figure 1: Illustration of the Self-Enhanced Test-Time Scaling (SETS) framework. SETS integrates the Sampling, Self-Ves Veri-y, and Self-Correct operations efficiently scale test-time computation.
Each operation is associated with its own prompt. We denote the prompt for Sampling as 1x(x), the prompt for Veriff as (x( y), and the prompt for Self-Correct as Ix(x, {Yx, Fk H=))))), where x is a qucry, Ya is a proposed solution for x, and Is represent the feedback obtained from the self-verification process for x and YE. Suppose FF an LLM that takes a prompt as input and outputs response. Then, we have y ~ (x),,x)), (x,,(x,)) y)) and Yj+1 F(T,(x, [y,, rx) (k)))) The feedback indicates whether the solution is correct not. We define judgement function (r))
J(r)= = [1
If y is self-verified correct
Otherwise.
We adopt the rule- based approach to determine the value of J(r), e.g., if contains the string "solution is incorrect", then J(r)= = 0; otherwise, J(r) 1.
SETS judiciously combines Sampling, Self- Verify, and Self-Correct operations to yield superior scaling of test-time computation, overviewed in Figure [and in Algorithm [ SETS first samples m responses through repeated sampling as the initial set of responses, denoted as yd. vo.... ... Y8. For the i-th initial response yd. SETS iteratively applies the Self- Verify and Self-Correct processes up to times to improve the response until it is self-verified correct, resulting in the improved response y*. If it reaches the maximum number of self-correction rounds and the response is still self-verified as incorrect, we use the response after n rounds self-correction as y'. After applying the Self-Verify and Self-Correct process for each the initial responses, a new set of responses are obtained as y..,,,, y....... ym Majority voting then used to select the final solution y". Suppose we have an indicator function Tiy = y') determine whether two responses y and y' are equivalent. or not, then:
y" arg max
1 I(y
Σ
(2)
yE y...
m7
where we break the tic randomly. The indicator function can be simple exact matching or using LLM-as-a- Judge determine the equivalence of two responses. In this work, we use the simple exact matching since the benchmarks have well-structured answer format.
4

---

Published in Transactions on Machine Learning Research (11/2025)
Algorithm 1 SETS: Self-Enhanced Test-Time Scaling
Input:
The query x, the LLM F, the Sampling prompt I,, the Self Verify prompt I,,, the Sclf-Corree prompt Le. the number of samples m, the maximum number of rounds the judgement function J and the indicator function I.
1: for I....,m do
yd F()
(Sampling Operation}
for O,...,n do
r F(I((x,))))
Operation)
if j(r)) then
6:
y' y
7: Break
(Self-Verifiee as Correct - Early Stop)
else
+ F(lo(x, ty
(Self-Correct Operation}
10:
end if
11:
if j = n then
12: y' =y: y"
13: end if
14: end for
15: end for
y") Output: The final solution y".
16: y" arg y ymm.,
Li=1 I(y y)
{Majority Voting)
SETS utilizes the LLM directly, integrating parallel and sequential scaling techniques to enhance the efficiency of test-time compute scaling, especially when ample compute budget available. The sequential scaling method SELF-REFINE MMdaan et al. (2024) can be regarded as special case of SETS (when m 1). However, SELF-REFIN cannot effectively scale up test-time compute since it terminates when the stopping is primarily effective in low-compute budget regimes, SETS demonstrates strong performance in high-compute budget regimes as well. Our experiments across wide range of scenarios confirm this (see Section 4.3
condition is met. Therefore, while SELF-REFIN
4 Experiment
4.1 Scaling Laws for Time Compute
We define test-time compute-optimal scaling as the strategy that selects hyperparameters for a given approach to maximize performance within a compute budget C on a specific dataset and LLM F:
0" (CID,F) arg max ((ID..),, SC, 0E0
where are candidate values of hyperparameters for the test-time strategy. H is the cost function that maps hyperparameters to the average amount of compute used for each input (c.g., average mumber of output tokens), and M is a performance metric such accuracy. For example, 0 in the proposed method SETS contains two variables m and n. We obtain the scaling law curve with the x-axis corresponding to budget C' and the y-axis corresponding to performance M (O
To compute each point (x, y) on the scaling curve, we first consider a specific cost I = H()). For this cost, we find the optimal performance y = (xr(, evaluating all hyperparameter configurations within O Finally, adjacent points are connected generate the scaling law curve.
4.2 Setup
Datasets. We experiment on datascts that contain complex instructions and require advanced reasoning for accurate responses: Trip Planning and Meeting Planning in NATURAL PLAN (Zheng al. 2024). LiveBench Reasoning (White al. 2024), MATH 500 (Hendrycks et al. 2021), ATME 2024-2025 (aim

---

Published in Transactions on Machine Learning Research (11/2025)
and LiveCodeBench TestOutputPred (Jain al 2024p. The details of these benchmarks can be found in Appendix A Since the ground truth answers across all tasks are well-structured and can be verified either by exact match or rule- based checker, we do not need any model based evaluator to evaluate the accuracy of the model-generated responses.
Prompts. We design tailored prompts for three key operations Sampling, Sclf-Verify, and Self-Correct (provided in Appendix B to enable these operations using LLMs. We use existing templates if available or create simple and direct prompts, to generalize across tasks and models as much as possible. For NATURAL PLAN tasks, we controlled generation with Langfun (Peng) 2023) to obtaín structured solutions to improve accuracy for all methods (refer to Appendix C for details). We do zero-shot prompting for Self- Verify and Self-Correct - using only instructions without including any few-shot examples.
Baselines. For fair comparison, we adopt the following baselines that don't need additional model training or external reward models. We use the same prompts for Sampling, Self-Verify, and Self-Correct described in Appendix B for the baselines. BoN stands for Best-of-N (i.e. sample multiple responses and choose one using some mechanisms as the final response).
One single initial solution is sampled and then is iteratively refined via Delf-Verify and Self- Correct processes up to n times to improve the response until it is self-verified as correct. (Madaan ct al. 2024p. Note that SELF-REFINE cannot arbitrarily scale up the test-time compute because could early stop as long as the solution is self-verified correctly. SETS addresses this limitation by integrating parallel sampling, allowing for greater scalability.
SELF-REFINE:
BoN+-Majority Vote:
We sample solutions and then perform majority voting via exact matching on the sampled solutions to select the most frequent solution (also referred as Self-Consistency (Wang et al., 2022 ). No self-verify or self-correction involved.
Self-vel- Similar to BoN+Majorrty Vote, sample m solutions and then query the LLM to select the final solution with multi-choice QA task prompt (described in Appendix B.4 as used in Ren
et al. 2023).
BoN Self- We sample m solutions and self-verify each one, then perform a majority vote via exact matching on the solutions verified as correct select the final solution. all sampled solutions are verified incorrect, we perform a majority vote on all sampled solutions. No self-correction is involved.
To summarize, our proposed method SETS integrates all three components of parallel Sampling, Self- Self-Verify, and Self- Self-Correct, while the baselines are either missing 1 or components, as shown in Table
Method
Sampling Self- Verify
Self-Correct
SELF-REFINE
BoN+MMjority vote
X
Sel+
X
X
BoN+SSef-Ve Verify
X
SETS (ours)
/
Table Comparison different. baselines with SETS
LLMs and Configs. Our experiments utilize both proprictary and open-source models, which include both "non-thinking" and "thinking" types. The non-thinking models include GEMINI-115-Pr0-000, Claude- 3.5- 3.5-Sonnet-2e 20244102,, Qwen3-235B-A222 and 1.ven2.5-1.5B-Insttee while the thinking models include and
Swen3-235B-A22 and Qwen2.5- 1.5B-Instruct are open-source models while the others are proprictary models. For DEMINN-2.5-Flashh. set the thinking budget to 24, 576 to turn thinking. We use temperature of 0.7 to perform three

---

Published in Transactions on Machine Learning Research (11/2025)
operations Sampling, Veri-y and Self-Correct for all models. For BoN+ we use temperature of 0.7 for sampling multiple responses and then use a temperature of O for the final self-evaluation step (i.e., selecting the best answer among the responses).
Hyperparameter Set (0). To find the maximum performance at a given compute budget, we search across different hyperparameter scttings (i.e., the set of candidate hyperparameters )). For SELF-REFINE, 0 eE θ has one hyperparameter the number of refinement iterations n and we set E [1, 10). We don't consider larger n because the refinement process lypically stops before 10 iterations. For BoN approaches, 0 E @ has one hyperparameter the number of samples m. We set sufficiently large value for that further increases do not yield significant accuracy improvements. For basclines BoN (Majority Vote or Self-Eval), we set m E [1, 100] for non-thinking models while setting m E [1,50] for thinking models. For thinking models; the value of m is halved because their output length is generally much longer. For the proposed method SETS, 0 E θ has two hyperparameters the nunber of samples m and the maximum number of rounds n of Self- Verify and Self- Correct. We set m E [1,50] n E [1, 10] for non-thinking models and set E [1, 25] A [1, 10] for thinking models to balance between the compute allocated to sampling and rel--improveeent. For baseline BoN+SSlf- Verify, we define E [1,50] for non-thinking models and set m E [1, 25] for thinking models. The maximum value of m for SETS and BSeff Veriffy is halved compared to Majoriyy Vote and +oN+ to ensure comparable maximum compute budgets across them.
Compute Cost Estimation. Since different operations (Sampling, Self- Verify, Self-Correct) use different prompts and generate different. lengths of responses, to make fair comparison, we focus on the average number of output tokens estimate the cost (as the price for output tokens is much higher than that for input tokens] We also provide results based on the number of API calls (Appendix [.1] and financial cost (Appendix D.9.. For our cost analysis, we deliberately avoid using wall-clock time, as it is highly volatile and influenced by uncontrollable factors such as network latency, APT server load, and hardware specifies. Our chosen metrics provide a standardized, aggnstii- basis for comparison that reflects the intrinsic efficiency of each method and ensures the reproducibility of our results.
4.3 Results
Improved Test-time Scaling with SETS. SETS consistently oulperforms the baselines (Figure 2 across different benchmarks, yielding increased accuracy gains as the test-time compute increases for GEMINI-L.5- Pro. For BoN with Majority Vote, the accuracy typically saturates quickly with the increase the amount of test-time compute. While BoN combined with Self-Verily or Self-Eval yields better results than BoN with Majority Vote some tasks, it does not show consistent improvement across all tasks. Tn contrast, SETS utilizes both self-verification and self-correction, yielding accuracy improvements across all datasets. These findings are consistent when using the number of API calls as the measure of compute cost (see Appendix D.1
Impact of Different LLMs. Besides GEMINI-1.-PPro, we also apply SETS with other LLMs: Gemini-2.53 2.5- Flash, Gemini-2.5 2..--F.aa--LLttt Claude-3.5-Sonnet, Bomn3-2335BA221 and Swven2.5-1.B-Instrree Figure 3 shows that for those LLMs, SETS still outperforms the baselines on most of the cases with a few exceptions. We hypothesize that the performance of SETS is affected by the models' self-verificatiin and self-correction capabilities. So we evaluate the accuracy of self-verification and self-correct ion individually to disentangle their effects. To evaluate the velffveritication performance, we ask the LLM to self-verify its own proposed solution (sampled with temperature= 0) and evaluate whether we can use the verification result to detect errors (treating the error as the positive class, we calculate the precision, recall, and F1 score). To evaluate the self-correction performance, we ask the LLM to self-correct the proposed solution up to rounds (using the SELF-REFINE algorithm). The results are shown in Table Comparing Figure 2 and Table 2 we observe that when the model has strong self- verfffieifiitn and self-correction performance, SETS can significantly outperform the baselines. However, when the models' self-verification and self-correction performance is weak, SETS might not provide significant gains (c.g., Claudo-3.5-Somme on LiveBench Reasoning). Appendix D.3 shows thtt increasing the sample size for sell-verification and applying majority voling can improve the
https://ai. www.gl.../////..e.ooooeeo and httpps:/www.anttrrpic.com
7

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning GEMINI-1.-PPr
Meeting Planning GEMINI-1.5-Pro
SETS (ours)
0.65
BoN+Majority Vote
0.8
BoN+
0.60
BoN+Self-Eva
Accuracy
SELF-REFINE
Accuracy
0.7
0.6
0.50
0.45
10a
10*
10a
10a
10a
10a
Average Number of Output Tokens
Average Number of Output Tokens
AIME 2024-2025 GEMINI-1.5
GEMINI-1.5-PP
0.90
0.35
0.89
0.88
Accuracy
0.30
Accuracy
0.87
0.86
0.25
0.85
0.20
0.84
0.83
10a
10*
10
10a
Average Number of Output Tokens
Average Number Output Tokens
LiveBench Reasoning GEMINI-1.5-Pr
LiveCodeBench TestOutputPred GEMINI-1.5-Pr
0.75
0.60
Accuracy
Accuracy
0.70
0.55
0.65
0.50
0.60
0.55
0.45
10a
10a Average Number Output Tokens
10s
10a
10* Average Number Output Tokens
10
Figure 2: Scaling law curves where the x-axis is the average number of output tokens and y-axis is the accuracy. Each point (z, y) in the curve corresponds to a hyperparameter setting O. y is the optimal performance at the cost budget within every x-tick interval) make the markers less crowded. SELF-REFINE would early stop the solution is self-verified correctly, it not scale up arbitrarily shown in dotted line.
H()) (sce Scction 4.1 for details). We subsample the points (up
self-verification accuracy, which aligns with the findings in Zhao et al. 2025 Appendix D.12 provides a qualitative analysis of self-verificationss failure modes.
We study whether allocating more test-Lime compute to Self- Verify and Self-Correct leads to better end-to-end accuracy given a fixed test-time compute budget. The hyperparameter of the maximum number of rounds (n) SETS controls the compute allocated Self-Verify and Self- Correct. Given a fixed compute budget, larger number rounds n suggests smaller number of samples Figure 4 shows that given fixed compute budget, increasing the number of rounds of Self Veri-y
The Effect of Self-Correction Rounds.
8

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning GEMINI-2.5-Flash
Mceting Planning GEMINI-2.5-Flash
1.00
0.95
0.95
0.90
Accuracy
0.90
Accuracy
0.85
SETS (ours)
0.85
BoN Majority Vote
0.80
Sei
Self
0.75
SELF-REFINE
0.75
104
10
10c
10a
10a
109
Average Number of Output Tokens
Average Number of Output Tokens
AIME 2024-2025 GEMMIN-2.---lssh--iieTiifie
0.74
MATH 500 1iw.--2.---Flash-Lie--hiiiiioo
0.965
0.72
0.960
0.70
Accuracy
0.955
0.68
Accuracy
0.950
0.66
0.945
0.64
0.940
0.62
0.935
0.60
104
10a
106
104
10a
10
Average Number of Output Tokens
Average Number of Output Takens
LiveBench Reasoning Claude- St
LiveCodeBench TestOutpuutPed Sooude-3.5-Somee
0.85
0.84
Accuracy
Accuracy
0.83
0.82
0.81
0.80
100
10a
10a
10a
Average Number of Output Tokens
Average Number of Output Tokens
Figure Scaling law curves with various LLMs (Gemini-2.5-Flash, GEMINI-2.5-Flash-Iiit Thinking and Claude-3.-SSonnet). The complete results for all datasets and LLMs provided in Appendix D.2
and Self-Correct generally leads to accuracy gains, although the impact varies across tasks. For Trip Planning and Meeting Planning, the accuracy increases the number of rounds increases, but the returns diminish after 4. Based the results, SETS to achieve strong performance in practice.
set sufficiently large value for m (e.g., m 50) and set 4 for
The Effect of Temperature for SETS. We study how the temperature used for the three core operations (Sampling, Self-V,rify, and Self-Correct) affects the performance of SETS. We consider two configurations: (1) using & temperature of 0.7 for all three operations (our default setting), and (2) using a temperature of 0.7 for Sampling, but a temperature of 0.0 (greedy decoding) for Self- Verify and Self-Correct. The results in Figure show that our default sctting generally achieves better performance across different benchmarks. This suggests that introducing higher degree of randomness (temperature 0.7) for the Self Verify and Self-Correct operations is beneficial. The increased temperature likely promotes broader exploration of

---

Published in Transactions on Machine Learning Research (11/2025)
Self- Verification Evaluation
Celf-Corroctio Evaluation
Dataset
Model
Precision
Recall
F1 Snore
Initial Accurary
Round A
Round 2 A
Saaude-3.G-Sonnee
93.74
91.85
92.78
41.02
+ +1.50
+8.00
Trip Planning
GEMINI-1.5PPM
97.51
94.04
95.74
43.44
+6,94
+10.94
CEMINI-2.5 5.aaaah
97. 15
72.09
82.77
77.12
10.25
13.00
GEMINT-24 2.5 Flash Lite Thinking
99.66
55.59
71.37
37.31
+9.38
+12.13
Claude-3.G-Somicg
78.69
80.17
79.42
53.60
+0.40
+2.10
Meeting
GEMINI-L.5-P Pro
80.30
82.29
81.28
43.10
+4.50
+7.40
Planning
CEMINI-2.55 5-Fahash
74.18
66.39
70.07
74.30
+10.20
+12.10
JEMINN-2.5-Flaab--iie Thinkinn
79.72
83,20
81.42
50.50
+10.80
14.90
Blaude-3.5-Somieg
72:22
40.00
51.49
54.67
+1.33
+0.00
LiveBench
CEMINI-1.5-Pro
77.36
53.25
63.08
45.33
+2.00
+1.33
Reasoning
2.. Flahh
75.61
62.00
68.13
68.00
+11.33
+14.67
GFMINT-2.3-Flashe Tatti---it-i-iiiiingg
90.48
52.78
66.67
69.33
+2.00
+8.67
Claude-3.55 3.5-Sonnet
61.54
20.00
30.19
+2.00
+2.00
MATH 500
CEMINI-1.--rr
68.12
61.84
64.83
$3.20
+2.60
+4.00
GEMINI-2.5-Flast
14.94
56.10
23.59
9-180
-3.80
-1.80
RRMINN-2.5-Flusb-Liie Thinkknn
55.29
74.60
63.51
93.20
+1.20
+1.40
Claude 3.5 Sonnet
94.74
35.29
51.43
ATME
GEMINI-1.5PPM GEMINI-2.5-Flah
71.74
79.52
2024-2025
29.63
38.10
33.33
73.33
+1.67
+0.00
GEMINI-2.55-Faadl Lite- Titnkliiiii-Tiinn
100.00
70.59
82.76
60.00
+6.67
Claude-3. 5-Sonnet
76.92
30.61
43.80
79.64
+1.13
+1113
Benchh TestouttutProd
CEMINI-L.5PPG
89.17
68.29
77.35
53.17
+18.78
+22.17
CEMINI-2.5-PP
16.33
45.71
24.06
95.25
+0.90
+1.13
GEMINI-2.5 F-lss-b---oes-ttto--o Thinking
15.24
20.00
17.30
93.67
+0.45
1.668
Table 2: Performance on self-verification and self-correction. Round A means Round k accuracy minus initial accuracy, All numbers are terms of percentages. Bold numbers are superior results.
Trip Planning GEMINI-1.5-Pro
Meeting Planning GEMINI-1.5-Pro
0.75
0.650
0.625
0.70
0.600
Accuracy
Ac Accuracy
0.65
Max Number of Rounds
0.575
0.550
0.60
0.525
3
0.55
2
0.500
1
0.50
0.475
10
10
105
10a
106
Average Number Output Tokens
Average Number Output Tokens
Figure 4: The effect of allocating more compute to selfiieeriination and self ceff-correction for SETS (controlled by number of rounds) given fixed computational budget (measured by average number of output tokens). The results for other datasets provided in Appendix D.4
alternative reasoning paths, which is crucial for handling complex reasoning tasks. This diversity in thought, combined with the final majority voting mechanism, appears to be key factor in improving the overall performance and robustness of the SETS framework.
Non-thinking Mode with SETS vs. Thinking Mode. SETS functions as a capability amplifier, not a creator of reasoning. We demonstrated this by comparing a "non-thine soon-thinkinn"" mode with SETS against a superior "thinking" mode with BoN+Majority Vote under a fixed token budget, where the former could not match the latter's performance (Appendix D.10). However, applying SETS the thinking mode yielded substantial gains, confirming its practical utility is to push chosen model to its absolute performance limit.
10

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning GEMINI-1.5-PP
MATH 500 GEMINI-1.
0.90
0.75
0.89
0.70
Accuracy
Accuracy
0.65
0.88
0.60
0.87
0.55
SETS (t=0.7, svt=0. sct=0.7)
SETS (t=0.7, svt=0.0, sct=0.0)
0.86
0.50
10a
104
10a
10a
10*
10
Average Number of Output Tokens
Average Number of Output Tokens
AIME 2024-2025 GEMINI-1.5-Pro
LiveCodeBench TestOutputPred GEMINI-1.S-Pro
0.78
0.35
0.77
Accuracy
0.30
Accuracy
0.76
0.75
0.25
0.74
0.73
0.20
0.72
10a
10
10>
10a
104
105
Average Number of Output Takens
Average Number of Output Tokens
Figure 5: The effect of different temperature settings for SETS. t, syt and sct are temperature parameters for the Sampling, Self- Verify and Self-Correct operations respectively. The results for other datasets are provided in Appendix D.5
SETS with woniidenne-weighteed Voting. SETS compatible with diverse aggregation methods, including seeiddnnce-wighteed voting (Appendix D.11). This strategy generally outperforms standard majority voting, but its effectiveness is task-dopendent, with the simpler method sometimes proving superior. This indicates that the reliability of the underlying confidence heuristic can vary across tasks.
5 Conclusions
In this paper, we introduced Self-Enhance Enhanced Test-Time Scaling (SETS), simple yet effective paradigm for scaling test-time compute that capitalizes the inherent self-verification and self-correction mechanisms of LLMss. SETS uniquely integrates parallel and sequential scaling, distinguishing it from prior work that often relies on specialized fine-tuning. Our experimental results reveal that SETS, by sampling a set of initial responses and then iteratively refining them, surpasses baselines like purely repeated sampling or SELF-REFINE. Importantly, SETS consistently delivers higher quality outputs and demonstrates increasing returns as test-time computation incrcases across challenging planning, reasoning, math, and coding tasks.
Limitation. Our future work will focus expanding the SETS framework by addressing its current limitations and enhancing its core dependencies. A key priority is to improve the foundational self-critique and self-correction capabilities of LLMs, as the efficacy of SETS is directly tied to these abilities. We anticipale that as LLMs continue to advance, their capacity for sell-improvement will likewise strengthen, thus broadening the applicability and effectiveness of SETS. We also aim to enhance the efficiency of SETS for low-rcsource settings and complement the framework with prompt optimization for models with weaker self- correction skills. While this work concentrates on reasoning tasks with objectively verifiable answers, we plan to extend its applicability domains like summarization and tool use. This expansion will necessitate
11

---

Published in Transactions on Machine Learning Research (11/2025)
from majority voting to more sophisticated aggregation strategies, such as Universal Self- Self-Consistency (Chen et al. 2023 Finally, though our evaluation is currently confined to text-only datasets, the SETS framework is designed for future extension to multi-modal benchmarks.
References
American invitational mathematics examination.
http:://arrdpooooeeeass/ragaa/ap AIME Problems __nd___d____ Solutions AIME 2024 2025.
Gemini 2.5: Our most intelligent ai model.
gemiin--mode--bbnniing -acp
Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, llge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 techmical report. arXiv preprint arXiu:2303.0877, 2023.
anthropic. Claude 3.5 Sonnet. http:://ww..atttrrppp...o.ooo//s -o--ssnnee, 2024. [Online; accessed Jun 20, 2024].
Vidhisha Balachandran, Jingya Chen, Lingjiao Chen, Shivam Garg, Neel Joshi, Yash Lara, John Langford, Besmira Nushi, Vibhav Vineet, Yue Wu, al. Inference-tinee time scaling for complex tasks: Where we stand and what lies ahcad. arXiv preprint arXi:2554400029, 2025.
Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoe V Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling, arXie preprinl 207.17740.21178 2024.
Lingjiao Chen, Jared Quincy Davis, Boris Hanin, Peter Bailis, Ion Stoica, Matei Zaharia, and James Zon. Are more Ilm calls all you need? towards the scaling properties of compound ai systems. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024.
Xinyun Chen, Renat Aksitov, Uri Alon, Jie Ren, Kefan Xiao, Pengcheng Yin, Sushant Prakash, Charles Sutton, Xuezhi Wang, and Denny Zhou. Universal self-consistency for large language model generation. arXiv preprint arXfw:2311.17911 2023.
Paul F Christiano, Jan Leike, Tom Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. Advances in neural information processing systems, 30, 2017.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems. arXiv preprint arXiv:2110. 14168, 2021.
Jonathan Cook, Tim Rocktäschel, Jakob Foerster, Dennis Aumiller, and Alex Wang. Ticking all the boxes: Generated checklists improve I1m evaluation and generation. arXie preprint arXiv:24 10. 0.003608 2024.
Thomas Palmeira Ferraz, Kartik Mehta, Yu-Hsiang Lin, Haw-Shiuan Chang, Shereen Oraby, Sijia Liu, Vivek Subramanian, Tagyoung Chung, Mohit Bansal, and Nanyun Peng. Lim self-correction with decrim: Decompose, critique, and refine for enhanced following of instructions with multiple constraints. arXiv preprint Xrx::24 10. 06458, 2024.
Zhibin Gou, Zhihong Shao, Yeyun Gong, Yujiu Yang, Nan Duan, Weizhu Chen, et al. Critic: Large language models can self-correct with tool-interactive ive critiquing. In The Twelfth International Conference on Learning Representations.
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 arXin:2103.03877, 2021.
12

---

Published in Transactions on Machine Learning Research (11/2025)
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. In The Twelfth International Conference
on Learning Representations.
Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar- Lezama, Koushik Sen, and lon Stoica. Livecodebench: Holistic and contamination free evaluation of large language models for code. arXic preprint arXiv:2408.0700 079747 2024.
Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint ar arXiv:2001.0880 008661 2020.
Kuang-Hull Huei Lee, lan Fischer, Yuch-Hua Wu, Dave Marwood, Shumeet Baluja, Dale Schuurmans, and Xinyun Chen. Evolving deeper Ilm thinking. arXiv preprint or arXi:220110090 009891, 2025.
Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian Saan-Guang Lou, and Weizhu Chen. Making large language models better reasoners with step-aware verifier. arXiv preprint arXiv:2206. 023366 2022.
Zhenwen Liang, Ye Liu, Tong Niu, Xiangliang Zhang, Yingbo Zhou, and Semih Yavuz. Improving Ilm reasoning through scaling inference computation with collaborative verification. arXiv preprint orXiv:24100053 10.05318, 2024.
Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Nya Sutskever, and Karl Cobbe. Let's verify step by step. arXiv preprinl (xXxx:335.200500 2023.
Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Layu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, et al. Self-refine: Iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36, 2024.
Daiyi Peng. Langfun, September 2023. URL http:pp//ggttuuooooooo////////// wom/google/langguuu
Yuxiao Qu, Tianjun Zhang, Naman Garg, and Aviral Kumar. Recursive introspection: Teaching language model agents how to self-improve. Xiv preprint 2rXi::2407.1821,, 2024.
Jie Ren, Yao Zhao Tu Vu, Peter J Liu, and Balaji Lakshminarayanan. Sclf-evalnation improves selective generation in large language models. In Proceedings on, pp. 49 64. PMLR, 2023.
Charlic Snell, Jachoon Lee, Kelvin Xu, and Aviral Kumar. Scaling Ilm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint ar Xrx::22408.00 03314,, 2024.
Yuda Song, Hanlin Zhang, Carson Eisenach, Sham Kakade, Dean Foster, and Udaya Ghai. Mind the gap: Examining the self-improvement capabilities of large language models. Xrv preprint 26d:2442.02677 2024.
Gemini Team, Petko Georgiev, Ving Tan Tei, Ryan Burnell, Libin Bai, Anmol Gulati, Garrett Tanzer, Damien Vincent, Zhufeng Pan, Shibo Wang, et al. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. arXiv preprint arXiv:240S.00 055330, 2024.
Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. ar preprint xrXi::3307.09288, 2023.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, 2022.
Scan Welleck, Amanda Bertsch, Matthew Finlayson, Hailey Schoelkopf, Alex Xic, Graham Neubig, Ilia Kulikov, and Zaid Harchaoui. From decoding to meta-generation. Inference-time algorithms for large language models. Xrxiv preprint ar arxiv:2406. 16838, 2024.
13

---

Published in Transactions on Machine Learning Research (11/2025)
Yixuan Weng, Minjun Zhu, Fei Xia, Bin Li, Shizhu He, Shengping Liu, Bin Sun, Kang Liu, and Jun Zhao. Large language models are better reasoners with self-verification. In Findings of the Association for Computational Linguistics: EMNLP 2023, pp. 2550 2575, 2023.
Colin White, Samuel Dooley, Manley Roberts, Arka Pal, Ben Feuer, Siddhartha Jain, Ravid Shwartz-Ziv, Neel Jain, Khalid Saifullah, Siddartha Naidu, Chinmay Hegde, Yann LeCun, Tom Goldstein, Willic Neiswanger, and Micah Goldblum. Livebench: A challenging, contamination--fee Ilm benchmark. 2024.
URL arxivpreprintarkiv 2406 19314
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 modcls. orXiv preprint arXiv:2408.00724, 2024.
Kexun Zhang, Shang Zhou, Danqing Wang, William Yang Wang, and Lei Li. Scaling 1lm inference with optimized sample compule allocation. ar preprinl 2rXi::2410222/40 2024.
Eric Zhao, Pranjal Awasthi, and Sreenivas Gollapudi. Sample, scrutinize and scale: Effective inference-time search by scaling verification. arXiv preprint arXiv:2502. 01839, 2025.
Huaixiu Steven Zheng, Swaroop Mishra, Hugh Zhang, Xinyun Chen, Minnin Chen, Azade Nova, Le Hou, Heng-Tze Tze Cheng, Quoc V Le, Ed Н Chi, et al. Natural plan: Benchmarking llms on natural language planning. arXiv preprint arXiv:2406. 04520, 2024.
14

---

Published in Transactions on Machine Learning Research (11/2025)
Appendix
In Appendix A
provide details about the datasets used in our experiments. Appendix B outlines the
prompts designed for Sampling, Self- Verify, Self-Corres Correct, and Multi-choice QA. Appendix
details the
controlled generation process. Additional experimental results are presented in Appendix
D
Appendix B
includes detailed responses for the three core operations employed within SETS. Finally, Appendix compares the proposed SETS with the Combining Sequential/Paraale approach from Snell et al. (2024)
A Datasets
We perform experiments on six datasets: Trip Planning and Meeting Planning from the NATURAL PLAN benchmark (Zheng al. 2024), the LiveBench Reasoning benchmark (White et al. 2024p, the MATH 500 benchmark (Henddryks et al., 2021), AIME 2024-2025 benchmark (aim), and the LiveCodeBench TestuutputPred benchmark (Jain et. al. 2024).
NATURAL PLAN provides 5 examples as fow-shot exemplars for each task (i.c. the 5-shot sctting). NATURAL PLAN also provides controlled variable (e.g. number of people, number of cities, number of days, etc) that can indicate the difficulty level of each lask. We utilize this controlled variable to understand the performance of different methods on easy and hard subset of the NATURAL PLAN datasets. In Trip Planning and Mceting Planning, the ground-truth solutions are long-form and contain multiple steps.
LiveBench Reasoning is task from LiveBench, which is benehmark for LLMs designed with test set contamination and objective evalustion in mind. LiveBench Reasoning has three tasks: spatial, zebra _uzzle and web_ of lies_v2 v2, each containing 50 test examples.
MATH 500 is a subset of 500 problems from the MATH benchmark (Hendrycks et al. 2021 which contains 12,500 challenging competition mathematics problems.
AIME 2024-2025 contains problems from the American Invitational Mathenatics Examination (AIME) 2024 -0255. AIME is prestigious high school mathematics competition known for its challenging mathematical problems.
LiveCodeBench TestOutpttPred is task from LiveCodeBench, which is a holistic and contamination-free evaluation benchmark of LLMs for code. LiveCodeBencch focuses on broader code-related capabilities, such as self-repair, code exccution, and test output prediction, beyond more code generation. We use the test output prediction dataset, which contains 442 examples.
We summarize the statistics of these datasets in Table 3
Task Type
Benchmark
Number of Test Examples
Trip Planning
1600
Planning
Meeting Planning
1000
Reasoning
LiveBench Reasoning
150
MATH 500
500
MATH
ATME 2024-2025
60
Coding
LiveCodeBench Test Outpuuttd
442
Table 3: The statistics of the datasets used in the experiments.
15

---

Published in Transactions on Machine Learning Research (11/2025)
B
Prompts
In this section, present the prompts used for Sampling, Self-Verily, and Self-Correct operations. Our design philosophy for the prompts centered minimalism and generalizability to demonstrate that method's performance is robust and not dependent on extensive prompt engineering. We intentionally created simple, standardized templates to show that the core logic of SETS is effective across diverse tasks and models without highly tailored instructions. For example, the Self-Correct prompt uses a direct instruction to "outline your step-by-step thought process for deriving new solution." For Self- Verify, we found & simple, structured format asking the model to first "1. List all constraints in the TASK" and then "2. Verify if the PROPOSED SOLUTION satisfies each of the constraints" was consistently effective at guiding the model's reasoning. This minimalist approach enhances the reproducibility of our method and confirms that its gains stem from its inherent structure rather than from fine-tuned prompts.
B.1 Sampling Prompt
For NATURAL PLAN benchmarks, we construct the sampling prompt by adding some additional instructions the original task description prompt.
Sampling Prompt for Trip Planning
(planning_tase task description_ with } Please first list all the constraints the problem and then output a final solution that satisfies all the constraints.
Sampling Prompt for Meeting Planning
(planning task description with _eboss
Please first list all the constraints and optimization goals in the problem and then output final solution that satisfies all the constraints and optimization goals.
For the MATH 500 and AIME 2024-2025 benchmarks, construct the sampling prompt by adding some additional instructions to elicit the LLM'' reasoning and ensure the final answer is boxed.
Sampling Prompt for MATH and AIME
You expert in solving math problems. Please reason step by step to solve the following problem, and put your final answer within \boxed().
PROBLEM: (problem)
For the LiveBench Reasoning and LiveCodeBench TestOutputPred benchmarks, we use the original prompt provided by the benchmarks as the sampling prompl.
B.2 Self-Verify Prompt
For the NATURAL PLAN benchmarks, we the following Self-Verify prompt:
16

---

Published in Transactions on Machine Learning Research (11/2025)
Self Verify Prompt for NATURAL PLAN
{planning_ _tas demos}
You are an expert at {task type]. You are given TASK of (task type} request, and a PROPOSED SOLUTION. Your job is to:
1. List all constraints in the TASK.
2. Verify if the PROPOSED SOLUTION satisfies each of the constraints with justifications.
3. Write line of the form 'The proposed solution is correct' or 'The proposed solution is incorrect' at the end of your response based on your analysis.
TASK:
{planning lask description without demos}
PROPOSED SOLUTION: (solution)
For the MATH 500 and AIME 2024-2025 benchmarks, we use the following Self-Verify prompt:
Self- Verify Prompt for MATH and AIME
You are an expert in solving math problems. You are given a PROBLEM and PROPOSED ANSWER.
Your job is to:
1. Identify all conditions and constraints in the PROBLEM for verifying the correctness of the
proposed answer.
2. Reason step by step to verify if the proposed answer satisfies each of the conditions and constraints.
3. Write a line the form 'The proposed answer is correct" or 'The proposed answer is incorrect' at the end of your response based on your analysis.
PROBLEM: (problem)
PROPOSED ANSWER: (answer)
For the LiveBench Reasoning benchmark, we use the following Self- Verify prompt:
Self- Verify Prompt for LiveBench Reasoning
You expert in solving problems that require reasoning. You given QUESTION and PROPOSED ANSWER. Your job is to:
1.
Transform the PROPOSED ANSWER into a statement given the QUESTION and identify all constraints the QUESTION for verifying the statement.
2. Think step by step to verify the statement satisfies each of the constraints.
3. Write line of the form "The statement is correct" or "The statement incorrect" at the end of your response based your analysis.
QUESTION:
{question]
PROPOSED ANSWER: (answer)
For the LiveCodeBench Test Outputtreed benchmark, the following Self- Seri-y prompt:
17

---

Published in Transactions on Machine Learning Research (11/2025)
Self Verify Prompt for LiveCodeBench Prep
You are an expert Python programmer. You will given a question (problem specification) and a PROSPOSED ANSWER (a Python program). Your job to:
1. Identify all constraints in the Question for verifying the correctness of the PROPOSED ANSWER.
2. Think step by step to verify if the PROPOSED ANSWER satisfies each of the constraints.
3. Write line of the form "The proposed answer is correct" or "The proposed answer is incorrect' at the end of your response based on your analysis. {problem)
PROPOSED ANSWER:
{answer)
B.3
Self-Correct Prompt
For the NATURAL PLAN benchmarks, we use the following Self-Correct prompt:
Self-Correct Prompt for NATURAL PLAN
(planning task t_s___tssss_e__ demos}
You expert at [task_type) type]. You given TASK of (task_type) request. You also given set of solution-analysis pairs. Your job is to outline your step-by-step thought process for deriving new solution.
TASK:
(planning task liss__dscrpptoo__viii sirioon__wthhtttdddee demos) (solution and analysis)
For the MATH 500 and AIME 2024-2025 benchmarks, the following Self-Correct prompt:
Self-Correct Prompt for MATH and AIME
You are an expert in solving math problems. You are given PROBLEM and set of answer-analysis pairs. Your job is to reason step by step for getting a correct answer and put your final answer within [bxxdd{].
PROBLEM:
(problem)
(answer and analysis)
For the LiveBench Reasoning benchmark, we use the following Self-Correct prompt:
Self- Celf-Correct Prompt for LiveBench Reasoning
You are an expert in solving problems that require reasoning. You are given a QUESTION and a set of answer-analysis pairs. Your job is to outline your step-by-step thought process for getting correct. answer.
QUESTION:
{question}
(answer_ane and_addaaaa _
(answer trigger]
For the LiveCodeBench Test Outputtredr benchmark, the following Self-Correct prompt:
18

---

Published in Transactions on Machine Learning Research (11/2025)
Self-Correct Prompt for LiveCodeBench TestOutputt
You are helpful programming assistant and an expert Python programmer. You are helping user write test case to help to check the correctness of the function. The user has written imput for the testcase. The user has also provided set of answer-analysis pairs. Your job is to outline your step-by-step thought process to calculate the output of the testcase and write the whole assertion statement in the markdown code block with the correct output. {problem)
lanswer_and analysis)
B.4 Multi-choice QA Task Prompt for Self-Evaluation
For the NATURAL PLAN benchmarks, we use the following multi-choice QA task prompt:
Multi-choice QA Task Prompt for NATURAL PLAN
{planning task demos}
You an expert at {lask type]. You are given a TASK of {lask type] request. You also given set of possible solutions. Your job is to outline your step-by-step thought process for selecting the best solution.
TASK:
(planning_tasee lel_cddeeeooowwiteeeeee wwwptwitthtweeeeeee demos} {solution choices]
The output should be JSON format: f('rcason': '<your reasoning>', 'solution
id': <<nn integer
between 1 and {num solution choices)>>))
For the MATH 500 and AIME 2024-2025 benchmarks, use the following multi-choice QA task prompt:
Multi-choice QA Task Prompt for MATH and AIME
You are an expert in solving math problems. You are given a PROBLEM and a set of possible answers. Your job is to reason step by step for selecting the best answer.
PROBLEM:
{problem}
(answer choices)
The output should be in JSON format: {f'reason': "<your reasoning>* 'answer id': '<an integer between 1 and (num__at answer hetwer__hoiccs/ >}}}
For the LiveBench Reasoning benchmark, we use the following multi-choice QA task prompt:
Multi-choice QA Task Prompt for LiveBench Reasoning
You are an expert in solving problems that require reasoning. You are given a QUESTION and a set. of possible answers. Your job is to outline your step-by-step thought process for selecting the best answer.
QUESTION:
{question}
(answer choices}
The output should be in JSON format: {f (('reason": "<your reasoning*", 'answer id': '<an integer between 1 and {num answer answer_choices]
For the LiveCodeBench Test Outppttreed benchmark, the following multi-choice QA task prompt:
19

---

Published in Transactions on Machine Learning Research (11/2025)
Multi-choice QA Task Prompt for LiveCodeBench PestOutputtred
You are an expert solving problems that require reasoning. You are given Problem and a set of possible answers. Your job is to outline your step-by-step thought process for selecting the best answer.
{problem)
panswer_choicess
The output should be in JSON format: {{ (('reason:: "<your reasoning>', 'answer id': "<n integer between 1 and (num_answert answer _ntwwe__choices choices)>>]] >
C Controlled Generation
For the NATURAL PLAN tasks, we use the controlled generation to output the solution in a structured format to improve the accuracy with Langfun. We use the following prompt to make the LLM output the final answer using the specified schema after chain-of-thought.
Langfun Chain-of- Thoought Answer Trigger
Please think step by step to solve the task and then output final solution using the specified schema..
We show the solution schema (Python class) definition for different datasets below.
class Step(pg.Objech) Object):
"*"One solution step.""!
city_name: (nnotated(Qptiionlllaatt [str], "The city name." "] arrival_day: Annotated [int], "The day you arrive in the city."]
departure_das day: Annotated[
Optional [int], "The day you depart from the city."
duration: Annotated
Optional [int], "The number of days spent in the city."
]
Solution(pg.00jee Object):
"""The solution. aum
17
step_1: : Step
None
18
step_k: Step None 19
Listing
Trip Planning solution class
class Step(pg.0bjerr Object):
3
"**One solution step."*"
5 location: [nootated[[ptiiona [str], "The meeting location.")
travel_time: Annotated (Optional [int], "The travel time in minutes."]
arrival_time. [nnotate[[pptinaal [atr], "The arrival time."]
person: Annotatedl(ptionallees [str]] "The person to meet at the location. "]
meeting_drationn. Annotated
Optional [int], "The neeting duration in minutes."
meeting_std
Beetiiggstar_tttee start_time: Imnotated[Optionalleeea [str], "The neeting start time. "]
meeting and_ time: Annotated [Optional [str], "The meeting end time.")
Solution(pg.00 Object):: "*e solution. ans
20

---

Published in Transactions on Machine Learning Research (11/2025)
step_1: 1: Step None
step_k: kk Step None
Listing 2: Meeting Planning solution class
21

---

Published in Transactions on Machine Learning Research (11/2025)
D Additional Results
D.1 Cost Estimation using Number of API Calls
In this section, we show results when using the average number of API calls for measuring the computational cost. Figure [ shows the scaling law curves where the x-axis the average number API calls and y-axis is the accuracy, The findings are the same as those where we use average number of output tokens to measure the cost.
Trip Planning GEMINI-1.5PPr
Mceting Planning GEMINI-1.5-Pro
0.65
0.75
0.70
0.60
Accuracy
0.65
Accuracy
0.55
0.60
SETS (ours)
0.55
BoNoMaaority Vote
0.50
BoN+SelEVVerffy
0.50
SeN+Seif-Eval
0.45
0.45
SELF-REFINE
100
400
100
200
300
350
Average Number of API Calls
Average Number of API Calls
AIME 2024-2025 GEMINI-1.5-PP
MATH GEMINI-L.5-PH
0.90
0.89
0.35
0.88
Accuracy
cccurayy
0.30
0.87
0.86
0.25
0.85
0.84
0.83
100
200
300
400
0
20
40
60
80
100
120
140
Average Number
API Calls
Average Number Calls
LiveBench Reasoning GEMINI-1.5 115--Po Pro
LiveCodeBench TestOutputPred GEMINI-1.5-Pro
0.75
0.60
Accuracy
Accuracy
0.70
0.55
0.65
0.50
0.60
0.55
0.45
20
40
140 Average Number of API Calls
60
80
100
120
160
20
40
60
80
100
120
140
160
Average Number of API Calls
Figure 6: Scaling law curves where the x-axis is the average number of API calls and y-axis is the accuracy. Each point (x. y) in the curve corresponds to hyperparaneter setting 0 E θ. is the optimal performance at the cost budget (0)) (refer to Section 4.1 for the details).
22

---

Published in Transactions on Machine Learning Research (11/2025)
D.2 Impact of Different LLMs
We apply SETS with Claude-3.-Soonee,, GEMINI-255-Pash-Liite- Thinking, GEMINI-2..-Plash,, Qwen
235B-A A22BB and Owen2.5-1.5B- Insstuuuttt The results for these models are shown in Figure 7 Figure Figure 9 Figure 10 and Figure [1 respoctively. Slow inference speeds for Qwen3-235B-A22 and Qwen2.5- Instructt restricted our experiments to Trip Planning (a 200-example subset), MATH 500, LiveBench Reasoning, and LiveCodeBench TestOOtput The findings are the same as those Section SETS outperforms the baselines on most of the cases with few exceptions.
With the Qwen3-235B-n A22B model, SETS consistently and significantly outperforms all baselines across four diverse benchmarks (planning, reasoning, math, and coding). This demonstrates that SETS remains highly effective even for open-weights models, improving performance despite less accurate initial outputs. These findings confirm that SETS is a robust technique for enhancing both state-of-the-art proprictary models and accessible open-source alternatives.
Conversely, results for the smaller Qween2.5-1.5--Insttruec are more nuanced. SETS offers clear benefits tasks where the model can generate and critique plausible solutions (e-g., LiveBench Reasoning and LiveCodeBench TestOutputPred)) However, MATH 500, it underperforms BoN+ Vote. On the complex Trip Planning benchmark, all methods failed entircly, as the base model lacked the fundamental capacity to generate valid solutions.
Finally, we observed that the 2.MLLN-2..-Flash and GEMINI-2.55 2IA-N---55-Flahh-iie Linsh-Liie-Thinkngg models might fail to follow the specified instructions for Trip Planning and meeting planning, leading to incorrectly formatted responses. This formatting issue prevents the successful parsing of answers, resulting in "None" value. For methods that use majority voting (SETS, BoN+ Majorityy Vote, and Self--efe these "None" answers are excluded from the vote. Our results suggest that when the underlying language model has poor instructionffollwwin abilities on task, the proposed SETS method may not significantly outperform the baselines (e.g., using 12MMIN1-2.5-Fashh-- Thinking on Trip Planning).
23

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning Gloude-35--oome
Mceting Planning Claude-3.5 S.nddd-,,5-Somme 3.5-Sonnet
0.70
SETS (ours)
BoN+ Majority Vote
0.62
0.65
SeN+eelfVerrfy
Accuracy
0.60
SeifSvifEEvl
SELF-REFINE
Accuracy
0.60
0.55
0.58
0.50
0.56
0.45
0.54
0.40
10a
10
10a
10a
10+
10
Average Number of Output Tokens
Average Number of Output Takens
MATH 500 Claude-3 3.5-Sonnet
AIME 2024-2025 Slaude-3.5-Soree
0.82
0.250
0.225
0.80
0,200
Accuracy
Accuracy
0.78
0.175
0.76
0.150
0.125
0.74
0.100
104
10a
10
Average Number of Output Tokens
Average Number Output Tokens
LiveBench Reasoning Claude S-Snnett
LiveCodeBench TeslOutputPred Claude-3. 3.5-Sonnet
0.85
0.700
0.675
0.84
Accuracy
0.650
Accuracy
0.83
0.625
0.82
0.600
0.81
0.575
0.80
0.550
10a
104
10a
10a
10*
10*
Average Number Output Tokens
Average Number of Output Tokens
Figure 7: Scaling law curves for Claude-3. 3.aell-3.--Sonett
24

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning GEMINI-2.5- Flash- Littss-hii-Thiikking
Meeting Planning -
0.9
SETS (ours)
0.85
BoN+ Majoriy Vote
0.80
Sel-Veify
Sei-Seil
0.75
Accuracy
0.7
SELF-REFINE
Accuracy
0.70
0.6
0.65
0.5
0.60
0.4
0.55
0.50
10"
10 Average Number Output Takens
10
104
165
10c
Average Number of Output Tokens
AIME 2024-2025 G
MATH 500 GEMINI- 5-assh--llhhhee-ee Lite Thinking
0.74
0.72
0.960
0.70
0.955
Accuracy
Accuracy
0.68
0.950
0.66
0.945
0.64
0.940
0.62
0.935
0.60
104
10
10a
10a
10
Average Number of Output Tokens
Average Number of Output Tokens
LiveBench Reasoning GEMINI-2.55 wwa..s--laa---iteeeiiieee
0.90
LiveCodeBench TestOutputPred GEMINI-2.5 Fiaa-iitiiis-nttteniininnnggg
0.960
0.85
0.955
Accuracy
Accuracy
0.80
0.950
0.75
0.945
0.940
0.70
10a
10 Average Number Output Tokens
10"
10'
10a
10a
Average Number of Output Tokens
Figure 8: Scaling law curves for Gemini-2.5, Gemmnn--25--lash--iilee-- Plash-Lite-Thinnknng
25

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning GEMINI-2.5-Flash
Meeting Planning GEMINI-2.5-Flash
0.95
0.95
0.90
Accuracy
0.90
Accuracy
0.85
SETS (ours)
0.85
BoN+ Majority Vote
0.80
BoN+ Self-Verify
0.80
BoNfSell-Evii
SELF-REFINE
0.75
10a
10
10
10a
10
10"
Average Number Output Tokens
Average Number of Output Takens
GEMINI
AIME 2024-2025 GEMINI-2.5-FIE
0.96
0.875
0.850
Accuracy
Accuracy
0.825
0.94
0.800
0.93
0.775
0.92
0.750
0.91
10
10c
10*
10a
10
Average Number of Output Tokens
Average Number Output Tokens
LiveBench Reasoning GEMINI-2.5-Flash
LiveCodeBench TestOutputPred GEMINI-2.5-Flast
0.95
0.985
0.90
0.980
Accuracy
0.85
Accuracy
0.975
0.970
0.80
0.965
0.75
0,960
0.70
0.955
10s
10a
10a
10a
10a
Average Number of Output Tokens
Average Number Output Tokens
Figure 9: Scaling law curves for Gemini-2.5-Flashh
26

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning Qwen3-235B-A228
MATH 500 -wen3-2nn32 -2358BA228
0.92
0.50
SETS (ours)
Majoriyy Vote
0.91
0.45
SeN+eelfVerrfy
BeN+SelfEEvl
Accuracy
0.40
SELF-REFINE
Accuracy
0.90
0.35
0.30
0.89
0.25
0.88
0.20
0.87
10a
10
10a
10a
10a
10
Average Number of Output Tokens
Average Number of Output Takens
LiveBench Reasoning Qwen3-2358-A228
LiveCodeBench TestOutputPred Owen3-235BB44
0.96
0.80
0.94
0.75
0.92
Accuracy
Accuracy
0.90
0.70
0.88
0.65
0.86
0.60
0.84
103
10*
10a
10a
10c
Average Number of Output Tokens
Average Number of Output Tokens
Figure 10: Scaling law curves for 20atn33-33---22-
27

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning Qwen2.5-1.58-Instuee
MATH 500 Swven255-1.5B-ins-t
SETS (ours)
Majority Vote
0.65
0.08
BoN+SelfVerrfy
Accuracy
BeN+SelfEEvl
Accuracy
0.60
SELF-REFINE
0.55
0.04
0.50
0.02
0.45
0.00
10a
104
105
10a
104
10a
Average Number of Output Tokens
Average Number of Output Takens
LiveBench Reasoning Qwen2.5 5-1.58-Insttrct
LiveCodeBench TestOutputPred QwenZ. 001.2/55-.--Intrrreee
0.300
0.36
0.275
0.34
Accuracy
0.250
Accuracy
0.32
0.225
0.30
0,200
0.28
0.175
0.26
0.150
0.24
10a
10*
10a
102
10
Average Number of Output Tokens
Average Number of Output Tokens
Figure 11: Scaling law curves for Qwen2.5-1.5B- 1f
28

---

Published in Transactions on Machine Learning Research (11/2025)
D.3 Evaluating Self- Verificiiia Performance
We study whether more self-verification samples will improve the self-verification performance. We ask the LLM to self-verify its own proposed solution (sampled with temperature= 0) multiple times and define the verification score as the fraction of times that the solution is verified as correct. We then use the AUROC metric to measure the correlation between the verification score and the correctness of the proposed solution, which can reflect the self-verification performance. The results in Figure 12 show that increasing the number of self-verification samples lead to better self-verification performance, but the performance typically saturates quickly. These results justify the design of the proposed method SETS: adding the dimension of the number of samples m allows the LLM to self-verily the same solution multiple times, which can improve the velf-verification performance.
Trip Planning
Meeting Planning
0.90
0.975
0.88
0.950
0.86
AUROC
AUROC
0.925
0.84
0.900
0.875
GEMINI-1.5-PP
0.82
GEMINI-2.5-Flas.
0.850
Claude-3 3.5-Sonnet
0.80
2
10
12
20
14
16
Number of Samples
Number of Samples
MATH 500
AIME 2024-2025
0.90
0.90
0.85
0.85
AUROC
0.80
AUROC
0.80
0.75
0.75
0.70
0.70
0.60
0.65
0
2
10
12
14
16
18
20
6
8
10
12
14
16
18
20
Number Samples
Number Samples
LiveBench Reasoning
LiveCodeBench TestOutputPred
0.95
0.95
0.90
0.90
0.85
0.85
AUROC
AUROC
0.80
0.75
0.70
0.65
0.60
12
14
16
18
20
10
12
14
16
18
20
Number of Samples
Number of Samples
Figure 12: Evaluate the self-verification performance of different models increase the number of self-verification samples.
29

---

Published in Transactions on Machine Learning Research (11/2025)
D.4 The Effect of Ceff-Correctio Rounds
we show the results for studying the effect of self-correction rounds on MATH 500, AIME 2024-2025, LiveBench Reasoning and LiveCodeBench TestOutputPredd datasets. The findings are the same as those Scction 4.3
In Figure 13
MATH 500- GEMIN--15-Pro
AIME 2024-2025 GEMINI-1.5-Pr
0.90
0.35
Accuracy
Accuracy
0.88
Max Number of Rounds
0.30
5
0.87
0.25
0.20
10
10a
10f
10a
Average Number of Output Takens
Average Number of Output Takens
LiveBench Reasoning GEMINI-1.5
LiveCodeBench TestOutputPred GEMINI-1.S-Pr
0.625
0.600
0.77
Accuracy
0.575
Accuracy
0.76
0.550
0.75
0.525
0.74
0.500
0.73
0.475
0.72
10'
10a
10"
10a
'i04 Average Number of Output Tokens
Average Number Output
Figure 13: The effect of allocating more compute to self-verification and self-correction for SETS (controlled by Max Number of Rounds) given a fixed computational budget (measured by Average Number of Output Tokens).
30

---

Published in Transactions on Machine Learning Research (11/2025)
D.5 The Effect of Temperature for SETS
We study how the temperature used for the three core operations (Sampling, Self-Verily, and Self-Correct) affects the performance of SETS. We consider two configurations: (1) using a temperature of 0.7 for all three operations (our default sctting), and (2) using a temperature of 0.7 for Sampling, but temperature of 0.0 (greedy decoding) for Verify and Self-Correct. The results on the Meeting Planning and LiveBench Reasoning benchmarks are shown Figure 14 The findings are the same as those in Section setting generally achieves better performance across different benchmarks.
our default.
Meeting Planning GEMINI-1.5-PD
LiveBench Reasoning GEMINI-1.5-PH
0.650
0.625
0.625
0.600
0.600
Accuracy
Accuracy
0.575
0.575
0.550
0.550
0.525
0.525
0.500
SETS (t=0.7, svt=0.7, sct=0.7)
0.500
SETS (t=0.7, 0.0, sct=0.0)
0.475
0.475
10a
104
10
10
10a
10
Average Number of Output Tokens
Average Number of Output Tokens
Figure 14: The effect of different temperature sottings for SETS. t, svt and sct are temperature paramcters for the Sampling, Verily and Self-Correct operations respectively.
31

---

Published in Transactions on Machine Learning Research (11/2025)
D.6
Performance under the Oracle Setting
Trip Planning GEMINI-1.5-PrO
Meeting Planning GEMINI-1.5
OraS+ (ours)
0.9
SETS (ours)
BoN+Oracle
0.8
0.8
Majoriyy Vote
Accuracy
Accuracy
0.7
0.7
0.6
0.5
10a
104
10a
10a
104
10a
Average Number of Output Tokens
Average Number Output Tokens
AIME 2024-2025 GEMINI-1.5-PrO
MATH 500 GEMINI-L.5-PrO
0.6
0.96
0.94
0.5
Accuracy
0.92
Accuracy
0.90
0.4
0.88
0.3
0.86
0.84
0.2
10a
10*
105
10a
10*
10a
Average Number of Output Tokens
Average Number of Output Tokens
LiveBench Reasoning GrMP
LiveCodeBench TestOutputPred GEMINI-1.5-PP
1.0
0.9
0.9
Accuracy
0.8
Accuracy
0.8
0.7
0.7
0.6
0.6
0.5
10a
10
105
10a
10
Average Number of Output Tokens
Average Number of Output Tokens
Figure 15: Scaling law curves under the oracle setting where the x-axis the average number of output tokens and y-axis is the accuracy. Each point (x, v) in the curve corresponds hyperparameter setting O O y is the optimal performance the cost budget H(0) (see Section 4.1 for details). We subsample the points (up to 8 within every x-tick interval) to make the markers less crowded.
We compare the proposed method SETS with the Best-of-N method under the oracle setting where the final solution is selected using ground-truth reference. Note that this oracle setting is not fcasible in practice as it depends on ground-truth labels. We consider the following two oracle methods:
Oracle We first sample m solutions and then select the final solution using ground-trute counddtruth reference. If all sampled solutions are incorrect, select the first sampled solution.
32

---

Published in Transactions on Machine Learning Research (11/2025)
OETS+Oracle: We select the final solution among the solutions generated by SETS (up to m (n+1) solutions). If all solutions generated by SETS are incorrect, we select the first sampled solution.
We perform experiments for GEMINI-L.5-PH and the results are shown in Figure 15 We can see that SETS with oracle selection has marked advantage over BoN with oracle selection Trip Planning, Mecting Planning and LiveCodeBench TestOulputPPed while the advantage is less pronounced the other tasks. This may suggest that SETS is more effective on tasks with larger and more complex solution space. Notably, on LiveCodeBench Ouep SETS outperforms the performance of BoN+ that uses ground- truth labels for solution selection. This indicates that when the LLM possesses strong self-verification and self-correction capabilities, SETS provides an efficient way scale lest-time compule and thus enhance overall accuracy.
33

---

Published in Transactions on Machine Learning Research (11/2025)
D.7 The Impact of Task Difficulty
The NATURAL PLAN datasets provide a controlled variable (e.g., the number of people or the number of cities) that indicates the difficulty level of each task. We utilize this controlled variable to study the performance of SETS on the casy and hard tasks. For Trip Planning, we treat a task with no more than 6 cities as an easy task, and otherwise a hard task. For Meeting Planning, we treat a task with no greater than people as an easy task, and otherwise a hard task. Figure 16 shows that SETS significantly putpororms the baselines on both easy and hard tasks. On hard tasks, SETS also brings significant accuracy gains and can achieve higher accuracy if more test-time compute is used.
Trip Planning (Hard) GEMINI-1.5PPo
Trip Planning (Easy) - GEMINI-1.-PPr
(ours)
0.95
0.6
BoN+ Majority Vote
SelF-erffy
0.90
Svlf
Accuracy
SELF-REFINE
Accuracy
0.85
0.4
0.80
0.3
0.75
0.2
10a
10*
10
10a
10
10
10a
Average Number Output Tokens
Average Number of Output Tokens
Meeting Planning (Easy) GEMINI-1.5-PO
Meeting Planning (Hard) GEMINI-1.5-Pot
0.45
SETS (ours)
0.40
Majoriy Vote
0.90
SeN+
Accuracy
0.35
Sel-Svll SELF-REFINE
Accuracy
0.85
0.30
0.25
0.80
0.20
0.15
0.75
0.10
10a
10a
10
10c
10a
10a
10a
Average Number of Output Tokens
Average Number of Outout Tokens
Figure 16: Estimated scaling law curves for Hard and Easy tasks obtained with SETS vs. basclines.
34

---

Published in Transactions on Machine Learning Research (11/2025)
D.8 Performance under fixed hyperparameters
We evaluate SETS and baseline methods using fixed hyperparameters. For BoN+-ta Vote and Self Eval, we set m = 100. For BoN+Self- Verify, we set = 50. For SELF-REFINE, we set n = 5. For SETS, we set m = 20 and n = 3. We repeat each experiment thrce times and report the mean and standard deviation for all metrics. As shown Table | SETS generally demonstrates significantly superior performance over the Best-of-N (BoN) baselines when operating under comparable computational budgets, measured by the average method consumes considerably less computational resources than SETS, its accuracy is substantially lower.
number of output tokens. While the
Dataset
Method
Accuracy (%) f Avg. # Output Tokens
Avg. # API Calls
Majoiity Vote
49.9:1.22
35218-21558
100
BoN+SSeff -el--fylfVerrffy
60.6:19.7
44844=10756
100
Trip Planning
+oN+Self-Ewwe SELF-REFINE
40.8
60469110
101
59.5+10.0
4233:
6+00
SETS (ours)
68.5+13.0
48364=10857
8710
BoN+ MoN+Majjan Bajoriyy Vote
48.8++2.3
56422-2332
100+-0
MeN+-ellVeriffy
55.7+00.9
73323+39
100+
Meeting
- SELF-REFINE
40.7:10.5
8327312
10110
Planning
54.1#0.0
47461
5
SETS (ours)
59.6+114
6289919119
8610
Mojoiiy Vote
87.810.2
47026
100
BoN+Self- Self-fyf-Verffy
88.7+0.1
46997+21
100
MATH 500
-elf-alll
75.9+0.8
47407+1
101+0
SELF-REFINE
87.8+0.0
1412+:0
3+0
SETS (ours)
89.3
25392:1147
50.00
BoN+Majorins Vote
3..2+1.0
82942+-221
100+-0
28.3
84469+130
1004:
AIME
+
8.943.55
837591177
1011:
2024-2025
SELF-REFINE
23.3+0.00
523210
6+0
SETS (ours)
33.3+0.00
81446+822
99+1
MoN+Majority Vote
12.2+1.4
45711+172
100+:
BoNf Verify
58.7+1.2
50230+120
10010
LiveBench Reasoning
BoN+Self-Evva SELF-REFINE
47.3+4.4
46342+2
101+0
48.0+0.0
1526+0
340
SETS (ours)
60.7+1.3
29954+119
60+00
BoN + Majority Vote
54.3++0.2
16546+129
100+-0
B -el--fel-Verrfly
64.9110.5
2978912
10040
LiveCodeBench TestOutputPred
Bol+ Sval-
68.8+1.1
17126
10110
SELF-REFINE
74.910.00
1095
3+0
SETS (ours)
77.8+002
20616+71
59+0
Table 4: Performance under fixed hyper- syper-parameters with GEMINI-1.5PPro We show the mean and standard deviation of the metrics (me) Bold mumbers are superior results.
35

---

Published in Transactions on Machine Learning Research (11/2025)
D.9 Financial Cost Estimation
In this section, we show results when using the average price for measuring the cost. Figure 17 shows the scaling law curves where the x-axis is the average price and y-axis is the accuracy. The findings are the same as those where we use average number of output tokens to mcasure the cost.
Trip Planning GEMINI-1.-PPr
Meeting Planning GEMINI-L.5-Pro
SETS (ours)
0.65
BoN+ Majority Vote
SeiFVerify
0.8
0.60
Evaf
Accuracy
SELF-REFINE
Accuracy
0.7
0.55
0.50
0.5
0.45
0.4
101
10a
10a
10a
101
10a
10a
10c
Average Price ($)
Average Price ($)
AIME 2024-2025 GEMiN-115-Pro
GEMINI-1.5-Pro
0.90
0.35
0.89
0.88
Accuracy
0.30
Ac Accuracy
0.87
0.86
0.85
0.20
0.84
0.83
10a
10a
10
Average Price (S)
Average Price ($)
LiveBench Reasoning GEMINI-1.5-Pro
LiveCodeBench TestOutputPred GEMINI-1.5-Pr
0.75
0.60
Accuracy
0.70
Accuracy
0.55
0.65
0.60
0.50
0.55
0.45
10a
10a
10a
10a
10a
Average Price (S)
Average Price (S)
Figure 17: Scaling law curves where the x-axis is the average price and y-axis is the accuracy. Each point (z, y) in the curve corresponds to a hyperparameter setting 8 θ y is the optimal performance at the cost budget& (0) (refer to Section 4.1 for the details).
36

---

Published in Transactions on Machine Learning Research (11/2025)
D.10 Non-thinking Mode with SETS
Thinking Mode
To clarify the role of lest-lime scaling relative to model'ss intrinsic power, compared the non-thinking mode using SETS against the more powerful thinking mode with Bojoriyy Vote, under fixed token budget. The results in Table 5 show that SETS does not bridge the fundamental capability gap between the two modes. This finding highlights that SETS functions as capability amplifiers, not creators; they enhance a model's existing reasoning rather than acting as substitute for
The true utility of SETS is therefore realized when maximizing given model's potential. Indeed, demonstrated in Table 5 applying SETS to the thinking mode itself yields substantial performance gains over the thinking mode with BoN+ Boj+-iayorty Vote. This confirms that the practical value of SETS lies in pushing the performance ceiling of a chosen model including state-of-the-art ones to its absolute limit.
Accuracy (%) Budget=10*
Dataset
Model
Method
Budget=10
GFMINNI-.5-Plaaht-lle (non-thinking)
SETS
54.31
64.56
Trip Planning
GEMINI-2.55Flan waa--alaa---t-thhnnnaa
BoN 4-Nooiarrrty Vote
53.06
80.00
GEMINI-2.55 2--MIN--2.5-Flasb- Lite-Thinking
SETS
57.38
81.12
CEMINI-2.5-Plaashee (non-thinking)
SETS
64.20
70.50
Meeting
+ojooiayr Vote
62.70
73.40
Planning
FEEMINN-2.5-Flass--iite-TT--
SETS
71.60
83.80
DEMINI-2.5-Flash- (non-thinking)
SETS
94.20
94.20
MATH 500
GEMINI-2.55 2.--N---2.5Flash-Liii TiinkiiTTiiiing
MoN+iiaorrty Vote
95.20
95.60
SETS
96.20
96.40
CEMINI-2.55Plassh-iiit (non-thinking)
SETS BoN+MMaorrty Vote
60.00
66.67
AIME
-05MIN--.5-Flashh- Thinking
65.00
70.00
2024-2025
CEMIIN-2.5-Flaab-Lttt-TTTT
SETS
66.67
73.33
GEMINI-2.5-Flash--Lii (bon-thinking)
SETS BoN+Mta Vote
78.00
82.67
LiveBench Reasoning
78.67
86.67
Thinking 1..-NN--.5-Flahh.. Lhinh-iite-Thinking
SETS
78.00
90.00
GEMINI-2 2.5- 2.5--Flah--aaaa Lite (oontthnningg)
SETS BoN Majority Vote
94.12
94.12
LiveCodeBench
FEMMIN--2.5FFlash-lle Lei-LLiteTThiiiing FCMMINN----lassb--itteTTT-i
95.25
95.48
Prsp
SETS
95.48
96.15
Table 5: Comparison of Thinking Mode and Non-Thinking Mode with SETS under the same output token budget. Bold numbers are superior results.
37

---

Published in Transactions on Machine Learning Research (11/2025)
D.11 SETS with Confidence-weighter Voting
To explore a more sophisticated aggregation strategy, we evaluated SETS with confideenc--wigglee voling. In this approach, each candidate solution is weighted by a confidence score, defined as the proportion of times it is verified as correct during the scaling process.
As shown in Figure 18 this method generally enhances performance over standard majority voling, achieving superior results on most benchmarks (Trip Planning, MATH 500, LiveBench Reasoning, and LiveCodeBench Test OutputPPed).. However, this improvement is not universal. On certain tasks, such Meeting Planning and AIME 2024-2025, the simpler majority vote remains more effective, suggesting that the reliability of self-verification scores as a confidence heuristic can be task-dependent.
Trip Planning GEMINI-1.-PPr
Meeting Planning GEMINI-1.5-Pr
0.85
0.650
0.80
0.625
0.75
0.600
Accuracy
Ac Accuracy
0.70
0.575
0.65
0.550
0.60
0.525
SETS (Majority Voting)
0.500
SETS (Majority Vating)
SETS (Confidence-weightee Voting)
SETS CConfidence-welghtte. Voting)
0.475
10a
10a
10a
10a
10*
10a
Average Number Output Tokens
Average Number Output Tokens
AIME 2024-2025 GEMINI-1.-PPr
MATH 500 GEMINI-1.5-Pry
0.90
0.35
0.89
Accuracy
Accuracy
0.88
0.25
0.87
SETS (Majority Vating)
SETS (Majority Voting)
0.20
SETS (Confidence-weightee Vating)
0.86
SETS (Contidence-weiihted Voting)
10a
10
105
10a
10*
10a
Average Number of Output Tokens
Average Number of Output Tokens
LiveBench Reasoning GEMINI-1.5PP
LiveCodeBench TestOutputPred GEMINI-1.5-Pro
0.650
0.79
0.625
0.78
0.600
0.77
Accuracy
Accuracy
0.575
0.76
0.550
0.75
0.525
0.74
0.500
SETS (Majority Voting)
0.73
SETS (Majority Voting)
SETS weoniidence-welghtedd Voting)
SETS (Confidence-weiigted Voting)
0.475
0.72
10a
i0 Average Number of Output Takens
10a
10a
10*
10
Average Number of Output Takens
Figure 18; The effect of confidence-weightee voting on SETS performance.
38

---

Published in Transactions on Machine Learning Research (11/2025)
D.12 Failure Modes of Ver-feeifiintion
This section provides qualitative analysis of sell-verilication's failure modes. Our review indicates that these failures, with incorrect verification steps highlighted in red, primarily stem from model hallucinations, where the model generates factually incorrect or nonsensical reasoning.
Trip Planning (False Negative)
PROBLEM:
You plan to visit European cities for 10 days in total. You only take direct flights to commute between citics. On the last day of your visit to each city, you can take a direct flight to the next city and arrive on the same day. Both the day you arrive and the day you depart count toward the total number of days spent in each city. You want. to spend 7 days in Santorini. You want spend 3 days in Amsterdam. You would like to visit Lyon for 2 days. From day to day 2, there is annual show you want to attend in Lyon.
Here are the cities that have direct flights: Lyon and Amsterdam, Amsterdam and Santorini. Find a trip plan of visiting the citics for 10 days by taking direct flights to commute between them. PROPOSED SOLUTION:
Solution step__ Step( city_namt name 'Lyon', arrival day 1, departure _aatturrrddyy_aaa 2, duration
step 2 Step( city_ name ''msterdam', arrival _aaaaaldy--aaaaaa 2, departure day 4, duration = 3 ), city_name
step 3 = Step( city name 'Santorini', arrival day = 4, departure day 10, duration = =))
1. ** *Constraints: Totaa trip duration:** 10 days. **Number of cities:** ** 3 **Direct flights only:** Travel between citics must be via direct flights. * **Same day serival/departure. ** Flights can be laken on the last day of the stay in a city, arriving at the next city on the same day. * **Inclusive days:** Arrival and departure days count towards the total days spent in a city, **Santorini duration:** days. ** *#msterdam duration:** 3 days. **Lyon duration;** days. L*on event:** Visit Lyon between day 1 and day 2. **Direct flight availability:** Direct flights exist between Lyon and Amsterdam, and Amsterdam and Santorini.
2. *VVerification:** **
* **Total trip duration:** ** The trip starts on day 1 in Lyon and ends on day 10 in Santorini, totaling days. *Correct* N*uumb of cities:** The itinerary includes Lyon, Amsterdam, and Santorini. * *Correct* **Direct flights only:** The proposed flights (Lyon Amsterdam and Amsterdam Santorini) listed available direct flights. *Correct* **Same day arrival/departure:" The departure day from Lyon (day 2) is the same the arrival day in Amsterdam. The departure day from Amsterdam (day 4) is the same as the arrival day in Santorini. *Correct* **Inuuusive days:** Lyon: Arrival day and departure day 2, making 2 days. *Correct* Amsterdam: Arrival day 2 and departure day 4, making 3 days. *Correct* * Santorini: Arrival day 4 and departure day 10, making days. *Correct* * **Santorini duration:** ** The itinerary allocates days to Santorini (day 4 to "mmttrdamm duration:** The itincrary allocates days to Amsterdam (day 2 day 4). *Correct* * **Lyon duration;** The itinerary allocates 2 days to Lyon (day to day 2). *Correct* **T,onn event:** The itinerary includes Lyon on days 1 and 2, satisfying the requirement to be in Lyon for the event. *Correct* **Direct flight availability; The proposed route uses only available direct flights. *Correct*
day 10). *Correet*
3. The proposed solution is incorrect. The proposed solution allocates 3 days to Amsterdam (arrival on day 2, departure on day 4). However, it should be 2 days and 4, totaling days. Thus, the proposed solution is incorrect.
39

---

Published in Transactions on Machine Learning Research (11/2025)
Trip Planning (False Positive)
PROBLEM:
You plan to visit European citics for 16 days in total. You only take direct flights to commute between cities. On the last day of your visit to each city, you can take a direct flight to the next city and arrive on the same day. Both the day you arrive and the day you depart count toward the total number of days spent in each city. You want to spend 5 days in Paris. You want to meet friend in Paris between day 1 and day 5. You plan to stay in Santorini for 6 days. You want to spend days in Stockholm. You would like to visit Athens for 6 days. You are going to attend wedding in Athens between day and day 10. Here are the cities that have direct flights: Paris and Stockholm, Paris and Athens, Athens and Santorini, Athens and Stockholm, from Stockholm to Santorini. Find a trip plan visiting the cities for 16 days by taking direct flights to commute between them.
PROPOSED SOLUTION:
Solution( step Step( city name 'Paris', arrival day 1, departure day 5, duration step 3
step Step( city name 'Athens', arrival day 5, departure day 10, duration step =
Step( city name 'Santorini', arrival day 10, departure day 15, duration Step( city name = 'Stockholm', arrival day = 15, departure_dans = 16, duration = 2
SELF-VERIFICATION:
1. ** *Coustraints **Total Duration:** ** 16 days. * **Cities:** ** Paris, Santorini, Stockholm, Athens, **Direct Flights;** Only direct flights are allowed between cities. * **Paris:** ** 5 days, between day and day **Santorini:** 6 days. **ooockholmm** days. ***thhns:** days, between day 5 and day 10. **Flights:** Paris and Stockholm, Paris and Athens, Athens and Santorini, Athens and Stockholm, Stockholm to Santorini. 2. **eriffiation: T*Total Duration:** The trip spans from day 1 to day 16, which is 16 days. *Correct.* Stockholm, and Athens. *Correct.* * * **Direct Flights:** * Paris to Athens: *Correct.* * * Athens to Santorini: *Correct.* * Santorini to Stockholm: *Corroct." * * **Paris:* ** The solution has Paris from day to day (5 days), which within the specified range. *Correct." * * **Santorini:** The solution has Santorini from day 10 day 15 (6 days). *Correct.* * **Stockholm: ** The solution has Stockholm from day 15 to day 16 (2 days). *Corroet.* ** Athens:** The solution has Athens from day 5 to day 10 (6 days), which is within the specified range. *Correct.* The proposed solution is correct
*Ctiies:** The solution includes Paris, Santorini,
40

---

Published in Transactions on Machine Learning Research (11/2025)
E
Examples for Three Core Operations
In this section, we show the detailed responses for the three core operations (Sampling, Sclf Self-Verify, and Self- Correct)) employed within SETS on problem from MATH 500 with GEMINI-1.5-Pro.
Problem and Ground Truth Answer
PROBLEM: What is the least positive integer multiple of 30 that can be written with only the digits and 2?
Ground Truth Answer: 2220
Sampling Response
Let n be the least positive integer multiple of 30 that can be written with only the digits and 2. Since n is a multiple of 30, it must be a multiple of 10, mcaning its last digit must be Also, since n is a multiple of 30, must be multiple of 3, meaning the sum of its digits must. be multiple of 3. Since
only contain the digits 0 and 2, the sum of the digits must be multiple of both 2 and 3. The smallest possible number with only 0 and 2 as digits and ending in 0 is 20, which is not divisible by 3. The next smallest number 200, which is not divisible by 3. The next smallest number is 2020, the sum of the digits is 2 + 2 + 0 = 4, which is not divisible by 3. The next smallest number is which not divisible by 3. The next smallest number + 4, not divisible by 3. The next smallest number is
2000, the sum the digits is 2 + 0 0
is 20020, the sum of digits 20200, the of digits is 2+0+22+000
4, not divisible by 3. The next smallest. number is 6, which divisible by 3. Since it ends in 0, it is divisible by 10. So it is divisible by 30. 202020 30 6734 202020 + 30 6734 Therefore, the least positive integer multiple of 30 that can be written with only the digits 0 and 2 is 202020.
202020, the sum of digits is 2 0 +
Final Answer: The final answer 202020
Self-Verity Response
1. *Conditions and Constraints: **
**ultiple of *0*** The number must be divisible by both 3 and 10. * **Digits 0 and 2 only:** The number can only contain the digits 0 and 2. **Least positive integer:** We are looking for the smallest positive integer satisfying the above conditions. **Positive:** The number must be greater than ** **Integer:** The number must be whole number.
2. **Verifccation:**
Digits O and 2 only:** The proposed answer 202020 consists only of the digits O and 2. This condition is satisfied. **Positive:** 202020 is greater than 0. This condition is satisfied. **Integer:** 202020 is a whole number. This condition is satisfied. **Divisible by 10:** A number is divisible by if its last digit is O. The last digit of 202020 is 0. This condition satisfied. * **Divisíble by 3*** A number divisible by the sum of digits divisible by 3. The sum of the digits of 202020 is 2 + 2 satisfied. **Laast positive integer:** Let's consider smaller numbers formed with Os and 2s. We need number divisible by 10, it must end in 0.
0 6. Since 6 is divisible by 3, 202020 is divisible by 3. This condition is
20: Divisible by 10, but not by (2+0=2). 200: Divisible by 10, but not by 3 (2+0+0-2). 2020: Divisible by 10, but not by 3 (2+0+2+0=4). * 220: Divisible by 10, but not by 3 (2+2+0-4). 2220:
Divisible by both 10 and (2+2+2+0=0)
Since 2220 smaller than 202020 and meets all the conditions, 202020 not the *least* such integer. The proposed answer is incorrect.
41

---

start constructing the Published in Transactions on Machine Learning Research (11/2025)
Self-Correct Response
1. ** *Divisibility by 30;** A number is divisible by 30 if it is divisible by both and 3 and 5 (since 2***5). Since divisibility by and guaranteed by divisibility by 10 (which means the number ends 0), we need a number ending in where the sum of its digits is divisible by 3.
2. **Building the number:** We want the smallest positive integer, number with the fewest digits possible.
**One **** 20. Sum of digits is 2, not divisible by 3. * TTwo 2s:** 220. Sum of digits is 4, not divisible by 3. **Three 2s:** 2220. Sum of digits is 6, which is divisible by 3.
3. *VVrrfficttonn ** 2220 is divisible by 10 (ends in 0) and by 3 (sum of digits 6). Therefore, is divisible by 30. only uses the digits 0 and 2. 2220
F SETS vs. Combining Sequential/Paralle
Table
compares the proposed SETS with the Combining Sequential/Paralle approach from Snell et al, highlighting their key differences.
2024
Dimension
Combining Sequential/Parallel
SETS
Verification
Train a lask-specific reward model as the verifier.
Use the LLM itself verify the correct- ness of the answer.
Revision
Train a revision model predict new answers using previous answers text. At test time, sample sequence of revisions from the model with four previous answers as context.
Use the LLM itself generate new answer based on previous answers and their verificcitin analyses.
Farly Stopping in Revision
Produce a fixed number of new answers without carly stopping.
The self-correction process will stop when the answer verified as a correct one.
Final answer selec- tion
Use the verifier to select the best answer within each chain and across chains.
Apply majority voting on the new re- sponses produced by each branch of Self- Verify and Self-Correct ilerations to gel the final answer.
Evaluation
Only evaluated on MATH with PaLM 2-S.
Evaluated on six challenging bench- marks spanning planning, reasoning, math, and coding with both non- thinking and thinking models to demon- strate the generalization.
Practicality
Hard be used in practice since we need to collect data to train the verifier and revision model for each task.
Can be easily applied to different tasks and unlock a lot of downstream applica- tions.
Table 6: Comparison of the proposed SETS with the Combining Coquential/Paralle approach Snell et al. 2024
42


Reviews:
[{"review_id": "p1dVbe8KSk", "reviewer": "Reviewer_n2dZ", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper proposes Self-Enhanced Test-Time Scaling (SETS), a framework that integrates self-verification and self-correction to improve inference-time scaling of LLMs. Unlike prior approaches that rely either on repeated sampling or iterative refinement, SETS combines both without requiring additional reward or revision models. The proposed method is simple yet effective. Experiments on diverse benchmarks using multiple LLMs (Gemini-1.5, Gemini-2.5, Claude-3.5) demonstrate consistent improvements in test-time efficiency and scaling laws. The method is conceptually simple, training-free, and achieves promising improvement over strong baselines.", "claims_and_evidence_yn": "Yes", "claims_explanation": "The motivation is technically sound. The proposed method is evaluated as effective under strong Gemini-series models, but more results on other open-source LLMs are also preferred.", "audience_yn": "Yes", "audience_explanation": "Both LLMs and test-time scaling are highly popular topics with broad appeal across the research community.", "requested_changes": "More Results or Discussions:\n\nThe results are mainly conducted on Gemini-series models, could the authors also investigate the effectiveness on more open-resourced models like Qwen, Llama, and DeepSeek-series models? This could help further strengthen the effectiveness of the proposed method. \n\nI am also curious about the performance of LLMs with weaker performance (like 1.5 B models). This is not a limitation, but more discussions would be much better.\n\nWhile token-level cost comparisons are provided, the practical runtime and financial cost (especially for commercial APIs) discussions are preferred.\n\nWould prompt design affect the performance？\n\nCould other aggregation methods beyond majority voting, like self-consistency variants, confidence-weighted voting,  further boost performance?", "broader_impact_concerns": "n/a", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "uxRydGgEZ9", "reviewer": "Reviewer_vRha", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper motivates that existing test-time scaling strategies for enhancing the performance of LLMs on complex reasoning tasks have key limitations: parallel methods like repeated sampling are inefficient and saturate quickly, while sequential methods like SELF-REFINE struggle to improve after a few iterations. To address these issues, this paper proposes to combine parallel and sequential techniques. The proposed approach first generates multiple candidate solutions in parallel. Then, for each candidate, it iteratively applies the LLM's own self-verification and self-correction capabilities to refine the solution. The final answer is selected via majority voting from the set of improved candidates. The paper presents comprehensive experimental results on a diverse set of benchmarks, demonstrating the proposed approach is more effective compared to several baselines.\n\n**Strengths**\n\n- The problem of effective test-time scaling for LLMs is both trendy and important.\n- The proposed approach is sensible, clearly described, and logically combines the strengths of parallel and sequential methods.\n- The empirical evaluation is extensive and convincing in my opinion.\n\n\nNote: As I am not deeply familiar with the literature on test-time scaling of LLMs, I cannot fully assess the novelty of the proposed approach relative to all prior work nor the significance of the empirical results.", "claims_and_evidence_yn": "Yes", "claims_explanation": "See strengths 2 and 3.", "audience_yn": "Yes", "audience_explanation": "See strengths 1.", "requested_changes": "**Suggestions**\n\n- Deeper Analysis of Self-Verification Reliability. The proposed approach’s effectiveness relies heavily on the LLM's ability to self-verify its answers correctly. It would be beneficial to investigate the failure modes of this core mechanism. A qualitative analysis of cases where self-verification produces false positives or false negatives would offer valuable insight into the method's limitations and guide future improvements in making the self-critique process more robust.\n- Justification for Prompt Design Choices. The prompts used to perform self-verification and self-correction are critical to the method's implementation. While the prompts are provided in the appendix, the paper could be strengthened by including a brief discussion of the design philosophy behind them. Justifying why certain structural choices were made  would enhance reproducibility and clarity of the performance gains.", "broader_impact_concerns": "No concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "8VsT6uUgzE", "reviewer": "Reviewer_v4g2", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "Summary: \n\nThis paper proposes Self-Enhanced Test-Time Scaling (SETS), a test-time scaling method for better and more accurate outputs. This method combines major voting, self-verify, self-correct and shows promising performance against several test-time scaling baseline on strong close-source LLMs. \n\nStrength:\n\n1. The question this paper investigate is very important that how to scale better sampling via improved test-time computations.\n\n2. The presentation is clean and clear, which make it easy to read and follow.\n\n3. The ablation study is complete and detailed. The authors include four baselines, while SETS outperform against them when the number of tokens scale to some extent. The ablation is corresponding to the claims and statements.\n\n4. The method SETS show better test-time scaling potential against the baseline, as shown in the Figure 2, 3.\n\nWeakness:\n\n1. The novelty of SETS is somehow limited. It seems a combination of the baselines (Self-Verify, Self-Correct, ...).\n\n2. This paper mainly focuses on strong close-source models like GEMINI, but it remains a question whether SETS could be equally effective on the weaker open-source models, as they are cheaper and the initial points are weaker than the close-source. If SETS could scaling up more on these worse starting points (such as LLaMA-3 series, Qwen3 series) and even reach the level of close-source models, it will be very interesting.\n\n3. This paper lacks an experiments between SETS and thinking mode. As thinking models are proven to be strong reasoners nowadays[1][2], whether SETS could perform better than this strong and verified baseline - thinking mode under the same token consumption remains a question. I understand it may be hard to outperform thinking mode, but this comparison could make the ablation more complete.\n\nQuestions:\n\n1. This paper is mainly based on strong close source model, which has a good initial point. What if begin from a sub-optimal open-source model, such as LLaMA-3 series or Qwen3 series?\n\n2. In Figure 2, when the average number of output tokens are the same, is the number of N in BoN different? \n\n3. As this work focuses on how to obtain better and more accurate responses by scaling test-time computation, I suggest the author to conduct a comparison experiment between the non-thinking mode with SETS and the thinking mode under the same token numbers (for example, I know both Qwen3 and GEMINI-2.5-Flash has thinking mode and non-thinking mode). \n\n[1] Guo D, Yang D, Zhang H, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning[J]. arXiv preprint arXiv:2501.12948, 2025.\n\n[2] Yang, An, et al. \"Qwen3 technical report.\" arXiv preprint arXiv:2505.09388 (2025).", "claims_and_evidence_yn": "Yes", "claims_explanation": "See the strength, weakness and questions.", "audience_yn": "Yes", "audience_explanation": "This paper is very interesting and completed.", "requested_changes": "Please see the weakness and questions.", "broader_impact_concerns": "No", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)