When More is Less: Understanding Chain-of-Thought Length in LLMs
Authors: Yuyang Wu
Yifei Wang
Ziyu Ye
Tianqi Du
Stefanie Jegelka
Yisen Wang
Venue: ICLR 2026 Poster (2026)
Keywords: Chain-of-Thought reasoning
Simplicity bias
Test-time scaling
Reasoning length calibration
Primary area: foundation or frontier models, including LLMs

Abstract: Large Language Models (LLMs) increasingly rely on Chain-of-Thought (CoT) reasoning to solve complex problems. Contrary to the common belief that longer CoTs always improve performance, we demonstrate that **longer is not always better**. Across both real-world LLMs and theoretical models, task accuracy follows an inverted U-shaped curve with respect to CoT length: performance rises initially but declines once reasoning chains become too long. Through controlled experiments, we uncover **scaling behaviors of the optimal CoT length**: it increases with task difficulty but decreases with model capability. This exposes a significant mismatch with current practice, where supervised training often reuses the same CoT data across models and tasks without adaptivity. We further show that Reinforcement Learning (RL) can mitigate this gap by dynamically calibrating CoT length, thereby improving accuracy and offering a new perspective on differences between supervised fine-tuning and RL training. To explain these phenomena, we introduce an error-accumulation analysis that characterizes how reasoning errors propagate across steps and derives the scaling behaviors of CoT length observed empirically. Building on these insights, we show that training with optimally sized CoTs and applying length-aware filtering during inference yields substantial improvements in performance. Taken together, these findings establish a principled explanation of the ''overthinking'' effect and yield practical guidelines for calibrating CoT length in accordance with task complexity and model capability.

Published as a conference paper at ICLR 2026
WHEN MORE IS LESS: UNDERSTANDING CHAIN-OF- THOUGHT LENGTH IN LLMS
Yuyang Wu
Yifei Wang?* Ziyu Yea Tianqi Du
Stefanie Jegelka
Yisen Wang" 1,477
Peking University Amazon AGI SF Lab University of Chicago
4 State Key Lab of General Artificial Intelligence,
School of Intelligence Science and Technology, Peking University
5 MIT CSAIL CIT, MCML,, MDSI, TU Munich
7 Institute for Artificial Intelligence, Peking University
8 School of EECS, Peking University
ABSTRACT
Large Language Models (LLMs) increasingly rely on Chain-of-Thour (CoT) reasoning to solve complex problems. Contrary to the common belief that longer CoTs always improve performance, we demonstrate that longer is not always better. Across both real-world LLMs and theoretical models, task accuracy fol- lows an inverted U-shaped curve with respect to CoT length: performance rises initially but declines once reasoning chains become too long. Through controlled experiments, we uncover scaling behaviors of the optimal CoT length: it in- creases with task difficulty but decreases with model capability. This exposes a significant mismatch with current practice, where supervised training often reuses the same CoT data across models and tasks without adaptivity. We further show that Reinforcement Learning (RL) can mitigate this gap by dynamically calibrat- ing CoT length, thereby improving accuracy and offering a new perspective on differences between supervised fine-tuning and RL training. To explain these phenomena, we introduce an error-accumulation analysis that characterizes how reasoning errors propagate across steps and derives the scaling behaviors of CoT length observed empirically. Building on these insights, we show that training with optimally sized CoT's and applying length-aware filtering during inference yields substantial improvements in performance. Taken together, these findings establish principled explanation of the "overthinking" effect and yield practical guidelines for calibrating CoT length in accordance with task complexity and model capability. Code is httpp://giiabboomm////M/M///ff./
INTRODUCTION
Large language models (LLMs) have demonstrated impressive capabilities in solving complex reasoning tasks (Brown et al. 2020 Touvron et al., 2023). A central technique enabling these advances is Chain-of-Thougee (CoT) reasoning ( /Wei al. (022), where models generate explicit intermediate steps to decompose complex problems into simpler, more manageable sub-pru -roblerssess,
akin to divide-and-conquer strategy (Zhang al., 2024).
widely held intuition, supported by prior studies (Fu et al. 2023 Jin et al. 2024), is that longer and more detailed CoTs generally yield better performance, especially difficult tasks. At the same time, recent evidence shows that concise Co'ss can sometimes be more effective, though often with trade-offs challenging problems (Nayab et al. (0244). This raises fundamental question: does reasoning performance consistently improve as CoT' grow longer, or is there an inherent limit?
In this paper, provide comprehensive answer through evidence from real-world LLMs, synthetic experiments, and theoretical modeling. We show that for CoT reasoning. longer is not always better. lb task accuracy typically follows an inverted U-shaped curve with
As illustrated Figures Ta and
" Equal Contribution.
soorespnn Author: Yisen Wang (yisen. wang (ww..edu.cc)) This work was completed MIT prior Yifei Wang joining Amazon.

---

Published as a conference paper at ICLR 2026
1.0
0.7
Task Difficuity
0.6
24
Accuracy
24
Apsuracy
0.6
32
Accuracy
0.5
0.4
0.8
0.3
8
32
0.2
0.0
1.5B
7B
32B
72B
CoT length
CoT length
Model Size
(a) Arithmetic Problem
(b) Dynamic Programming
(c) Optimal vs. Longest CoT length
Figure I: (a) Accuracy of 6-layer GPT-2 on arithmetic tasks, showing inverted U-shaped curves with peaks shifting to longer CoTs as task difficulty increases. (b) Accuracy of a 5-layer GPT-2 on dynamic programming tasks, also following an inverted U-curve with respect CoT length. (c) On the MMLU STEM dataset, CoTs of optimal length significantly outperform the longest CoTss
performance improves when the chain appropriately decomposes the task, but deteriorates when the chain becomes excessively long (due to error accumulation) or too short (leaving individual steps overly complex). This reveals the existence of an optimal CoT length that balances these competing forces. Identifying and calibrating to this optimal length is crucial for building reasoning models that are both efficient and accurate.
respect to CoT length:
To uncover the mechanisms underlying this optimality, we design controlled experiments on arithmetic and dynamic programming tasks, and identify clear scaling behaviors: (1) harder tasks generally require longer CoT's to reach peak performance, (2) more capable models often achieve their maximum accuracy with shorter CoTs, and (3) solving harder tasks the optimal length involves tackling increusingly difficult sub-tasks, motivating the need for adaptive reasoning strategies such as iterative or looping processes. Experiments on LLMs ranging from 1.5B to 72B parameters further confirm these trends. Together, these findings demonstrate that the optimal CoT length should adapt to both the problem and the model. As shown in Figure Tcl reasoning with the optimal length can significantly outperform the longest-possible CoTs (by more than 60% a 72B model). In contrast, current practice often applies uniform CoT strategies across tasks and models during supervised causing larger
learning, leading systematic misspecification and suboptimal reasoning- models to perform worse than smaller ones. We further show that reinforcement learning (RL) can mitigate this gap by adaptively calibrating CoTs to their optimal lengths in pursuit of higher rewards. This sheds new light on why RI. fine-tuning often yields superior reasoning performance and generalization compared to supervised learning (Huan et al.) 2025).
To deepen our understanding, we develop a simple theoretical model based on an error-accumulation perspective: each model has per-step success probability, so excessively long CoTs suffer from compounding errors, while overly short CoTs struggle with high per-step difficulty. This analysis not only explains the existence of an optimal length but also derives scaling laws that align closely with empirical observations. Extensions to nonlinear and stochastic error functions show the robustness of this perspective. At last, building on these insights, we demonstrate practical benefits: (i) training with optimally sized CoT's allows small models to outperform much larger ones trained on uniform-length data, and (ii) at inference time, filtering CoT's by estimated entropy yields consistent gains, improving majority-vote performance on LLaMA3-SB-Instte and Dwenn.55-B-Instrucc..
In summary, our work makes the following contributions:
Longer is not always better:
We demonstrate the existence of an optimal CoT length across both real-world LLMs and synthetic tasks, challenging the prevailing intuition that performance monotonically improves with longer reasoning chains.
Scaling of optimal CoT length. Through carefully controlled experiments, we systemat- ically investigate how the optimal length depends on task difficulty and model capability, revealing consistent scaling laws: harder tasks require longer chains, while more capable models peak with shorter ones.
RL improves reasoning by calibrating CoT length. We show that reinforcement learning adaptively steers CoT generation toward the optimal length, thereby explaining its superior reasoning performance compared to supervised finetuning.
2

---

Published as a conference paper at ICLR 2026
Optimal CoT CoT Length
Optimal CeT Longth
50
= 0.39
9.367e-05
350
0.8
Evaluation Accuracy
40
CoT COT Length
0.6
8
30
300-
0.4
6
20
250
4
L01 Length
Accuracy
1.58
32B
72B
0.2
0.4
0.8
200
400
0.0
Model Size
Task Difficulty (1-ac0)
Training Step
(a) Optimal CoT length vs. Model (b) Optimal CoT length vs. Task size (Qwen2.5 series).
(c) Evolution of I.L.s' CoT lengths
difficulty (with the 7B model).
during RI.
Figure 2: Real-world observations of CoT length. (a) Larger models reach peak performance with shorter CoTs. (b) Harder tasks (lower baseline accuracy) require longer optimal CoTs, with significant positive correlation (p < 0.05). (c) During RL training with GRPO on LeetCode-2K using Qwen2.5-7B-Inn In-nstruct, average CoT length decreases as accuracy improves, suggesting that RL can also promote more efficient and concise reasoning paths.
An error-accumulation analysis. We develop simple yet useful theoretical model for understanding the observed CoT behaviors. From an error-accummn arooraccummlltive perspective, this analysis explains the inverted U-shaped performance curve, derives the existence of an optimal CoT length, and recovers the observed scaling laws.
Practical implications. We demonstrate actionable applications of our findings: (i) training with optimally sized CoT data enables smaller models to outperform larger ones trained with uniform-length chains, and (ii) a length- -wwrre majority voting strategy that filters by entropy yields consistent gains inference.
Overall, our findings move beyond the assumption that "longer is better" and establish a principled foundation for calibrating CoT generation. By adapting to the optimal CoT length, we can develop LLMs that reason more effectively, avoiding both underthinking and counterproductive overthinking.
UNDERSTANDING COT LENGTHS IN REAL-WORLL LLMS
To ground our investigation in practical scenarios, we first examine the relationship between CoT length and reasoning performance in publicly available LLMs, and then study how reinforcement learning (RL) influences this relationship. We evaluate the Qwen2.5 series of Instruct models (Qwen) al. 2025) on the MMLU STEM benchmark, which contains challenging competition-level science and engineering problems (Hendrycks et al., (0211).. For each question, we generate 60 solutions spanning wide range of lengths, where CoT length is measured by the number of intermediate reasoning steps. The optimal CoT length is defined as the one that yields the highest average accuracy. Additional details step segmentation and length control reported in Appendix [D] To ensure diversity, we also consider tasks from mathematics (MATH), science (MMLU STEM), and commonsense reasoning (WinoGrande) across four different for clarity we present the MMLU STEM results in the main text and defer the rest to Appendix F
Instruct model sizes, though
Optimal Length Decreases with Stronger Model Capabilities: As depicted in Figure 2a there is clear trend where the optimal CoT length decreases as the model size increases. For instance, the optimal length shifts from 11, 10 steps for the 1.5B and 7B parameter model and 72B parameter model. This suggests that more capable models can consolidate reasoning into fewer, more potent steps, aligning with the Simplicity Bias concept where stronger models prefer shorter effective paths.
steps for the 32B
We also investigate how task difficulty influences the optimal CoT length. We use (1 accuracy) on these questions as a proxy for the difficulty. Figure 2b shows a statistically significant positive correlation (notably p = 1 x 10 4 < 0.05) between task difficulty and the optimal CoT length of Owwen255-BB-Instee Instructt model. This indicates that more challenging problems will significantly benefit from a longer CoT with more extended decomposition steps. Similar trends for other models provided in Appendix
Optimal Length Grows with Harder Tasks:
3

---

Published as a conference paper at ICLR 2026
RL does not always yield longer CoT's A common belief in the development of advanced reasoning models is that reinforcement learning (RL) naturally produces longer reasoning traces. However, recent studies (Gandhi et al.) 2025) suggest that the effeet of RL on CoT length is strongly tied to the underlying base model, and that observed increases in length may reflect phenomena such as backtracking rather than genuinely deeper reasoning. To better understand this process, monitor the evolution of CoT length during GRPO training (Shao et al. 2024) on LeelCode-2K (Xia et al., 2025) with Qwen2.5-7B (wven.55-7-Innstrune IIs-tucttttt (Qwen al., 2025). As shown Figure 2 optimizing outcome- based rewards can actually reduce the average response length as training converges. Consequently. the RL-trained model produces shorter CoTs than its base counterpart on average, indicating that RL can exert mixed and non-monotonic influences on CoT length.
3 A CONTROLLED STUDY OF COT LENGTH ON SYNTHETIC DATASETS
The real-world CoTs usually involve numerous uncontrolled variables (e.g., diverse reasoning strategies, planning, backtracking) and heterogeneous pre-training of base models, which makes precise mechanistic understanding difficult. To overcome these limitations and rigorously examine our hypotheses about optimal CoT length and Simplicity Bias, we design controlled synthetic experiments.
3.1 EXPERIMENTAL. SETUP
Simple Arithmetic Problem. Our first synthetic dataset consists of arithmetic problems involving sequences of addition operations. The intrinsic difficulty of problem is quantified by the total number of addition operators, T. For each problem with T operators, we construct multiple valid CoT solutions that differ in length and granularity. The CoT length N is defined as the number of intermediate reasoning steps, where each step i processes t, operators. For simplicity in this across steps, where I denotes the step size (operators per step)
controlled study, we enforce and N ~ T/L.
For example, consider the problem "1 "1+2-3+ + which contains T addition operators. We can construct different CoT solutions:
A long CoT solution with f (one operator per step), yielding N = 6 steps:
Problem: 1+2+3+4+5+6+7
Step 1: 1+2 3. (Remaining: 3+3+4+5+647)
Step 2: 3+3 = 6. (Remaining: 6+4+5+6+7)
Step 6: 21+7 28. (Pinal Answer)
A shorter CoT solution with f = (three operators per step), yielding N = 2 steps:
Problem: 1+2+3+4+5+6+7
Step 1: 1+2+3+4 = 10. (Remaining: 10+5+6+7)
Step 2: 10+5+6+7 28. (Final Answer)
This dataset design enables systematic variation of CoT length (N) and step size (f) for problems with fixed total difficulty (T). It allows to isolate how the structure of the reasoning process itself influences performance. Additional details on problem formulation, data format, and CoT generation
are provided in Appendix B
Dynamic Programming Problem. Beyond arithmetic tasks, we also consider more general dynamic programming (DP) setting: the Maximum Path Sum in a Number Triangle, as studied in prior CoT theory (Feng et al. 2023). The objective to find path from the apex to the base that maximizes the sum. The canonical bottom-up DP algorithm solves this by iteratively updating values from the second-to -oossttto-last row upward. By varying how many rows are merged each update, we can directly control the effective CoT length while still guaranteeing correctness. This property makes the problem naturally decomposable into solutions of different lengths, closely mirroring the arithmetic case. Results this DP task are consistent with our observations arithmetic addition, further
4

---

Published as a conference paper at ICLR 2026
Optinall Par-3tap Difiuitty
1.0
Optimal CoT Length
48
0,8
36
Accurac
0,6
Eirccst-11
16
32
48 Total Difficulty
64
Model Size
Per-step Difficulty
(a) Optimal per-step difficulty
(b) Optimal CoT vs. model size
(c) Recurrent loops
Figure 3: CoT behaviors in synthetic experiments. (a) Optimal per-step difficulty (t) increases with task difficulty, indicating that harder tasks requires solving more complex sub-steps. (b) Optimal CoT length decreases with larger model size, while harder tasks require longer optimal CoT's at any fixed size. (c) Accuracy comparison between 6-loop and 9-1oop models across task difficulties. As per-step difficulty grows, the performance gap widens, indicating that allocating additional loops, i.c., greater per-step reasoning effort, provides clear benefits on harder sub tobbprrblems.
reinforeing the generality of the phenomena. For brevity, we focus on the arithmetic results in the main text and defer the DP experiments and details to Appendix
Model and Training: We train GPT-2 models (Radford et al. 2019) of varying depths (number of layers), keeping other hyperparameters fixed. Model depth known be significant factor representing model capabilities for reasoning tasks (Ye et al. 2024 Chen et al., (024a). Controlling this hyperparameter alone allows us to study the impact of model capability on optimal CoT length. Models trained with CoT solutions that can be automatically synthesized for this task, with varying total operators T and CoT lengths N (or equivalently the step sizes f). For testing, we can guide the model to produce CoT of a specific length (e.g., by prompting with control token indicating the desired number of operators t per step) or allow it to choose its preferred length. Further details are in Appendix H
3.2 SCALING LAWS OF THE OPTIMAL COT LENGTH AND PRACTICAL INSIGHTS
Our controlled experiments not only corroborate the CoT behaviors observed in real-world scenarios also allow for a more fine-grained analysis. These findings uncover several key scaling behaviors of the optimal CoT length that shed light into the practical designs of LLM reasoning.
Harder-Tasks' CoTs Peak at Longer Lengths (Adaptive CoT Length Matters): Our synthetic experiments further confirm the existence of optimal CoT length, which manifests itself as an inverted U-shaped performance curve when plotting accuracy against the number of reasoning steps, as shown in Figure Ta and [b] This clearly indicates that both "underthinking" (CoT too short) and "overthinking" (CoT too long) are detrimental, underscoring the critical benefit of generating CoTs with adaptive lengths tailored to the problem's demands. Moreover, we observe that the optimal CoT length shifts right as the task difficulty T' gets larger, indicating that solving harder task optimally requires a longer CoT (also observable numerically from Figure 3b). This suggests that a good reasoning model should be able to vary CoT lengths w.r.t. the overall task complexity.
II. Harder Tasks Peak at Harder Sub-tasks (Adaptive Per-Step Computation Helps): Figure 3a illustrates how the number of operators per step (t) impacts accuracy across different task difficulties (T). The envelope curve, tracing peak performance, shows that as tasks become harder (larger T)), optimal accuracy is often achieved by CoT's that involve more complex computations per step (i.e., a larger optimal 1*). This indicates that for difficult problems, simply increasing the number of short, simple steps is
effeetttvveeeeev reasoning also requires increasing the complexity of the sub-tasks addressed at each step.
Implication on Model Choice. Current LLMs, with fixed Transformer depth, have limited ability to adapt their per-step computation, which constrains their reasoning strategies. In contrast, recent designs such looped Transformers, which allow adaptive recurrent depth (Geiping et al. 2025 Chen et al. al.] (025),, provide a mechanism to dynamically adjust per-step reasoning effort. This property directly aligns with the observed need for adaptive per-step computation.
5

---

Published as a conference paper at ICLR 2026
To further validate this, we study looped Transformers where the same model can allocate more recurrent loops to increase reasoning effort at each step (Appendix E)) Figure 3e plots accuracy against CoT length under fixed task complexity. As per-step difficulty increases, the performance gap between using 6 loops and 9 loops widens, showing that models benefit from allocating more reasoning effort (loops) when sub-tasks are harder. This finding highlights the importance of adaptive reasoning depth: looped Transformers should be trained not only to handle longer CoTs but also to adjust their per-step computation according to task difficulty. To our knowledge, this direction remains underexplored but offers substantial potential for advancing reasoning performance.
III. Stronger Models Achieve Optimal Performance with Shorter CoTs (Model-Aware CoT Data Matter): We also examine how model capability (number of layers) influences the optimal CoT length. Figure 3b indicates that, across different task complexities, the optimal number of CoT steps (N*) consistently decreases as the model's s capability (number of layers) increases. This is because stronger models can effectively handle more complex sub-tasks in each step, thus requiring fewer overall steps to reach the solution optimally. This finding has significant implications for training data curation. It suggests that to achieve peak performance, models of different sizes or capabilities require CoT data tailored to their respective optimal per-step complexities. Current practices, such as using the same CoT datasets to train LLMs of varying sizes or directly distilling CoT's from large models to small ones without adapting complexity, may be suboptimal. For instance, a small model might struggle to learn effectively from overly complex CoT demonstrations designed for a larger model. Our analysis advocates for training each model with CoT data of adaptive complexity. aligned with its specific capabilities, to help it reach its optimal reasoning performance.
IV. RL Training Converges Optimal CoT Length (RL Calibrates Reasoning Behaviors): As discussed in Section 2
100
Base Model
RL training of LLMs tends to shorten CoT length. Our synthetic experiments replicate this effect. Starting from a GPT-2 model pre-trained on CoT solutions of mixed lengths for task with difficulty T = 24, we apply RL with rule-based outcome rewards using PPO on
Frequency (%)
80
RL. Step 10 Step
RL. Step 30
60
Step
40
VERL (Schulman et al.) 2017 Sheng et al., 2025). In our synthetic setup, each question comes with demonstrations of multiple CoT lengths, the model naturally devel- ops its own length preference. Figure | preference shifts under RL, as reflected by the probabil- ity (shown on the y-axis) that the model spontaneously selects CoTs of different lengths. The base model spreads probability across lengths around 5, 12, and 24, but as RL training progresses, this distribution shifts to shorter CoTss and finally collapses toward the length 5, which is the accuracy-optimal length under controlled evaluation.
20
5
8
24 (68%)
(96%)
(95%)
(94%)
(89%)
tracks how this
CoT Length with Accuracy
Figure 4: Change of CoT length during RL on the arithmetic task. RL gradually shifts CoTs towards the optimal length (t" = 5), which is shorter than the initial CoTs in average.
This demonstrates that RL, by directly optimizing task success, implicitly steers the model's CoT generation policy toward the optimal length regime, thereby calibrating mismatches between training data and model requirements. From this viewpoint, the benefit of RI. in LLM training extends beyond reward shaping or exploration: it also serves as an adaptive mechanism for aligning reasoning length. Even when the CoT data used in supervised learning is suboptimal (c.g., misaligned with task complexity or model capability), RL can automatically adjust the model's behavior toward generating more effective, optimally sized CoTs.
V. Self-Correction Training Shortens Optimal CoTs by Hardening Per-Step Reliability (Error- Tolerant Reasoning Improves Efficiency): To study how self-correction interacts with optimal CoT length, we modify the training traces so that the model occasionally encounters an intentionally incor- rect intermediate result, immediately followed by local repair. Coneretely, instead of exposing the model only to clean chains of the form question + step1 + anss + step2 + .... we sometimes replace the first occurrence of a sub-result with corrupted one and then show the corrected computation: question + [step: + wrong ans1] (optionally) + step1 + correct ans; + step2 +.... We control the fraction of such injected erroneous segments by a parameter p and, through preliminary sweeps, set p- = 0.3, which strikes a balance between preserving core computational ability and providing sufficient exposure to local error repair. All other training configurations are kept fixed, and we train 6-layer GPT-2 model under this setting.
6

---

Published as a conference paper at ICLR 2026
Table 1:
Optimal CoT length N and per-step difficulty with and without self-correction (SC) across task difficulties T.
Task difficulty T
16
24
32
40
Optimal CoT length N w/o SC:
4
5
8
10
Optimal CoT length N w/ SC
2
2
3
5
Optimal subtask difficulty t" w/o SC
4
5
4
4
Optimal subtask difficulty 1a w/ SC
8
12
11
At test time, evaluate the model arithmetic tasks of fixed difficulty and vary the CoT length, selecting the optimal length as the one that maximizes accuracy, as in our previous synthetic analyses. Importantly, when the model executes self-correction within single logical step, count the original erroneous computation and its immediate correction as one CoT step, since our notion of CoT length reflects how finely the problem is decomposed, how many times a local computation is revised. We then extract both the optimal number of steps N and the corresponding optimal per-step difficulty ta (operators per step) across task difficulties T E {16, 24, 32, 403.
As shown in Table self-correction training substantially reduces the optimal CoT length across all task difficulties (first two rows), while simultaneously shifting the optimal per-step difficulty to significantly larger values (last two rows). Although the shorter N might appear counter-intuitive given the extra "thinking" introduced during training, it is fully consistent with our broader picture: by learning to reliably repair local mistakes, the model becomes more robust to error accumulation within each step, which in turn allows it to tackle harder sub-tasks per step (larger t*) without sacrificing accuracy. From data-design perspective, these results suggest that injecting structured self-correction signals into CoT training can be an effective way to teach models to use fewer, but more powerful, steps.
4 AN ERROR ACCUMULATION ANALYSIS ON CHAIN-OF- -HOUGHH
Empirical studies on both real-world and synthetic datasets consistently suggest the existence of an optimal Chain-of-Thought (Co'T) length. To explain this, develop theoretical model based an intuitive analysis of accumulated errors and extend it to more general settings. Remarkably. the predictions of this simple model align closely with the empirically observed scaling behaviors of CoT length in our toy model and large language models. While not exhaustive, these insights provide useful lens for understanding and anticipating how CoT length influences reasoning performance. All proofs are deferred to Appendix !
Setup. Consider the arithmetic task with T operators and an N-step CoT as in Section 3.1 At step i, the model produces sub-question qi and sub-answer dj with history H:-1 (g), (1, 1,-1, 1.. We use the likelihood factorization
N P(Onmal q. N) II P(o.) P(alg, H.
sub-question
sub-answer
We abstract diverse "reasoning behaviors" (reflection, verification, backtracking) as particular choices of task decomposition and focus two error sources: (i) sub-question error (TT) [0, 1). increasing with difficulty T; (ii) sub-answer error E(N, M, E [0, depending on model capability M and effective per-step diffieulty T/N. For each model with parameters 6, we define its capability M (0) using the reasoning boundary (Chen et al. 2024b):
M = M(0) = max Pr(a; a; 44 0) > e, |4|= =1,
where |t:| is the number of operators in the subtask t. Intuitively, M (0) represents the largest sub-prou problem size the model can reliably solve single reasoning step.
Proposition 4.1. Assuming stepwise stationarity and independence conditioned on history, the final accuracy takes the form
A(N) = P(agnal = Gignal 9, 0, = (010))=((11010100011 H(.
(I)
where denotes constant independent N.
7

---

Published as a conference paper at ICLR 2026
A solvable special case. For intuition, consider linear sub-question rate ( ? where denotes the maximum task difficulty the model family is trained to handle, which is the largest operator count present in the training distribution (with T/C < 0.9 within the training regime). Similarly, assume a linear sub-answer error E(N, T) = -T/NNM), which captures the number of operators processed per step relative the model's capability M. Then
A(N) a E) --
(2)
which increases for small N (decomposition helps) and decreases for large N (errors accumulate). Theorem 4.2 (Optimal CoT length). There exists an optimal N (M,T) maximizing A(N):
(M,
TZ
= (-(11-))) ):
M(Z +1)
where W-1 is the negative branch of the Lambert W function (wee = x)).
This theorem establishes the inverted U-shaped relationship between CoT length and accuracy, and provides an explicit formula for the optimal length N From this expression, we can formally derive the first three scaling behaviors characterized Section 3.2
Corollary 4.3 (Scaling laws). From Theorem 4.2
(M, increases with T (harder tasks warrant longer CoT).
The optimal operators per step (M,T) M(1 1/Z) increases with T (envelope behavior).
(M,T) decreases with M (stronger models need fewer steps).
How RL Calibrates COT. The same analysis also sheds light on why reinforcement learning (RL) with outcome supervision help calibrates CoT length (Section (.2). During RL, the choice of CoT length can be viewed as selecting an action N; from a discrete set A = {NN...., No.- Each N;
produces binary reward E {0, 1] with success probability A(N,) from Proposition 4.1 reducing
the setting to a stateless bandit. With a softmax policy To E, e. the RI. objective is
[(0) Σ To (N.) A(N),,
Vo
Σ ANN))o((N)l To(N.)).
Corollary 4.4 (RL Converges to Optimal CoT Length). For gradient ascent on J(0) with sufficiently small step size, the policy converges to a deterministic solution x (N,) = iff i arg max, A(N,). Thus, RL training converges the optimal CoT length N = arg maXNe A(N).
This result shows that RI. will automatically prefer the optimal length and hence calibrates the CoT length. In this way, our framework unifies the explanation of optimal CoT length, scaling laws, and RL's calibration effects of reasoning lengths.
Extension to Nonlinear and Stochastic Error Functions. the analysis above, we adopted a sim- ple linear model with closed-fomn solution for the optimal length to provide intuitive understanding. This framework can be extended to more general settings, including nonlinear error functions that monotone and convex, well stochastic error models where each subtask may exhibit different error rate. These extensions introduce additional technical subtleties but follow the same underlying principles. Overall, it shows that the accumulative error analysis can explain broad class of reasoning process, including the arithmetic and dynamic programming problems we covered in Section Due to space limitations, we defer the formal treatment Appendix]]
PRACTICAL APPLICATIONS OF OPTIMAL COT LENGTH
Guided by the understanding above, in this section, illustrate via proof-of-concept experi- ments that adapting LLM training and inference configurations to the optimal CoT length can improve the model's reasoning performance.
8

---

Published as a conference paper at ICLR 2026
1.0
1.0
0.45
0:45
Rar Renierlaraiio Poa
Lengidieed Vie
80.6
0.8
0.40
Aucurray
+0.40
0.44
0.4-
0.95
0.2
0.2-
0.35
nate Pbad lag Hilt arrgs optina
Mad kigo
Modd laga
Opiia large
20
Number
40
90
0.80
20
30
40
90
(a) Influence of CoT Data (b) Influence of CoT Data (c) Length-Filtere Vote (d) Sength-Filtered Vote (I' 32)
(T 64)
(Llama3-88 --B-a---re-nn-ett
(Qwen2.5 B-7--nrstct
Figure 5: (a) and (b) compare model performance under different pretraining data distributions: Mixed Length (uniform over all lengths) vs. Optimal Length (only optimal-length solutions). Despite its smaller size, the small (6 layer) model trained optimal-length data outperforms the large (9 layer) model trained on mixed-length data, with the performance gap widening as task difficulty in- creases. (c) and (d) validate our Length-Filtenn Filtered Vote method on different models, which consistently outperforms vanilla majority vote and random- filtered vote on the GPQA dataset, maintaining strong performance the number of samples increases.
5.1 TRAINING WITH DATA OPTIMAL COT LENGTH
Training with Optimal-Length CoT Data: The existence of an adaptive, optimal CoT length suggests that one should design the CoT training data adaptively to fully optimize the model's reasoning performance. To examine the influence of the CoT length of the training data, we train a model on a specialized dataset that contains CoT solutions with lengths known be optimal for the given model size and task difficulty (T). We compare this model against a baseline model trained on dataset of CoT solutions with uniformly distributed step lengths I. During testing, models were allowed to freely choose their CoT strategy.
Results. As shown in Figures 5a and 5b the model trained optimal-length CoT's significantly outperforms the models trained on mixed-length solutions. Remarkably, a smaller model (e.g.. layers) trained on optimal-length data can even outperform larger model (e.g.. layers) trained on randomly chosen CoT lengths. This proof-of-concee the suitability of the CoT length in training data for the model. While it is generally hard to exactly estimate optimal CoT lengths in real-world problems, our theoretical and empirical studies provide valuable guidelines for coarse estimate. We leave more in-depth studies to future work.
experiment underscores the critical influence of
5.2 ADAPTIVE LENGTH-FILTERED VOTE AT INFERENCE TIME
The observation that CoTs of optimal length yield higher accuracy suggests that inference- time strategies could benefit from this insight. Standard approaches like majority voting over multiple sampled CoTs, such as self-consistency (Wang al., 2023), treat all valid reasoning paths equally, regardless of their length. However, paths that are too short (underthinking) or too long (overthinking and error-prone) may contribute noisy or incorrect answers to the voting pool.
While Fu et al. (2023) previously proposed filtering out short CoTs, it worked for smaller 2023-era models where "longer is better." Inspired by our findings, we propose Length- Filtered Vote, an adaptive method that enhances standard majority voting by preferentially weighting exclusively considering answers derived from CoTs whose lengths fall within a proper range. Specifically, in majority vote, given model fe, question q, a ground truth answer a", first sample set of
answer candidates .I...., On 1.d.d. fo(g) independently. After that, instead of a direct vote, we group the answers by their corresponding CoT length E(c,) (discussed in Appendix D) into groups with equal bin size D (by default, we set D = 2), denoted as (I. 1mm As our theory suggests that the prediction accuracy is peaked around a certain range CoT length, we identify such groups through the prediction uncertainty of the answers within each group, based on the intuition that lower uncertainty implies better predictions. Specifically. we calculate the Shannon entropy H (L,) of the final answers given by the CoT chains in each group L, We use majority vote only for the K (by default, we set K = 3) groups with the smallest entropy. For Random-filters Vote, we do a random grouping of samples (i.e., not based on length), and repeat the same entropy- based filtering process,

---

Published as a conference paper at ICLR 2026
averaging the final results over 100 trials to account for the randomness of the grouping. A detailed description of the algorithm is in Appendix [
Results. We evaluate the proposed method against vanilla majority vote (i.c., self-consistency (Wang al. 2023)) on a randomly chosen subset from the GPQA dataset (Rein ct al. 2023). The results in Figure 5c and [d show that our filtered vote consistently outperforms vanilla majority vote and random-filtes filtered vote and shows little performance degradation as the sample number increases. In summary, our findings show that CoT length, as one of the most easily computable feature in scenarios where token-level probabilities are unavailable, is correlated with the final accuracy.
RELATED WORK
Chain-of-Thougee for LLM Reasoning. CoT has become a core technique for LLMs to solve complex reasoning tasks by generating intermediate steps (Wei et al. 2022). Numerous variants arise to enhance CoT reasoning with more structural substeps, such as least-to-most prompting (Zhou et al. (202)) , tree of thoughts (Yao et al. 2023), and divide-and-conge
methods (Zhang et al. 2024 Meng et al. 2024). These methods fundamentally treat CoT as a framework for task decomposition and subtask solving that falls in our analysis in Section 4
Overthinking in CoT Reasoning. With the rise of powerful reasoning models like OpenAl ol,
scaling test-time compute with long CoT has gained prominence (Snell et al. 2024] Chen al.
2024d Wu ct al., 2024 Brown et al. 2024). These studies often suggest that more computation like longer COT can lead to better results. However, this is not always true. With similar interests as ours, few concurrent works also investigated the "overthinking" phenomenon (Chen et al., (202cc) where reasoning models generate excessively long CoT's for simple problems and proposed some mitigation strategies Han et al. (2024); Luo et al. (2025) ; Ma et al. ) /Si et al.] (202)). Our analysis goes beyond these observations by formally establishing the existence of an optimal CoT length and its scaling behaviors. Supported by both controlled experiments and theoretical analysis, it offers principled guidelines for designing more effective CoT strategies.
Theoretical Understanding of CoT. Numerous studies aim to theoretically formalize the Chain-of- Thought (Co'T) process and understand its effectiveness. They include analyzing CoT's computational advantages via circuit complexity (Feng et al.) 2023 Li et al.. 2024), and quantifying step-wise information gain from an informatiin--heeorttee standpoint (Ton et al. (024). While Schaeffer et al. (2023) uses error accumulation explain emergent abilities via monotonic p formulation with fixed reasoning length, our work is the first to leverage eπтоr accumulation to analyze the influence of CoT length. In addition, Bao al. (2024) and FU al. (2025) identify and characterize the latent causal structures and robustness of model reasoming. Ye et al. (2024) conducted controlled synthetic experiments help uncover underlying problem-sol solving mechanisms in LLMs. While Jiang et al.) (2025) presents an automated framework that converts sequential Long CoTss into hierarchical tree structures. Distinet from these varied theoretical explorations, our findings on CoT scaling behaviors and the consequent need for model-specific CoT structures (as discussed in Section 3.2 resonate with the concept of algorithmic alignment (Xu et al. 2019), which suggests that models perform best when the problem structure aligns with their computational structure.
7 CONCLUSION
This work revisits a prevailing assumption in reasoning with large language models: that longer Chain- of ofoThouss (CoTs) are always better. Through controlled experiments and theoretical analysis, we showed that accuracy instead follows an inverted U-shaped curve with respect to CoT length, revealing the existence of an optimal length that balances finer task decomposition against compounding errors. Our systematic study further uncovered scaling behaviors of this optimal length across task difficulty, model size, per-step computation, and RL training.
Building on these insights, we demonstrated that training with optimally sized CoTs improves Filtered Vote as an effective inference strategy. Together, these
performance, and introduced findings highlight the importance of calibrating reasoning length rather than adopting one-size-fe -ize-ii--itt- all approach. We advocate for a principled framework in which LLMs adaptively allocate the right amount of reasoning effort, ultimately leading to more reliable and efficient problem solving.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGMENTS
Yisen Wang was supported by National Natural Science Foundation of China (62376010, 92370129), Beijing Major Science and Technology Project under Contract no. Z25 100008425006, Beijing Nova Program (20230484344, 20240484642), and State Key Laboratory of General Artificial Intelligence. Yifei Wang and Stefanie Jegelka were supported in part by the NSF AI Institute TILOS (NSF CCF-21 1666)), and an Alexander von Humboldt Professorship.
ETHICS STATEMENT
This work complies with the ICLR Code of Ethics. While methods are general, they may be applied in contexts with societal implications, including risks related to bias, fairness, and privacy. We encourage responsible use and declare conflicts of interest.
REPRODUCIBILITY
We provide detailed descriptions of our methodology. datasets, model configurations, and evaluation metries in both the main text and the Appendix. In addition, the complete source code is included in the supplementary materials to facilitate reproducibility.
REFERENCES
Sangmin Bae, Adam Fisch, Hrayr Harutyunyan, Ziwei Ji, Seungyeon Kim, and Tal Schuster. Re- laxed recursive transformers: Effective parameter sharing with layer-wise lora. arXiv preprint arXiv:2410.2067,, 2025.
Guangsheng Bao, Hongbo Zhang, Cunxiang Wang, Linyi Yang, and Yue Zhang. How likely llms with cot mimic human reasoning? arXiv preprint arXiv:2402.16048, 2024.
Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V. Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Sealing inference compute with repeated sampling. arXiv preprint arXiv:2407.21 17777 2024.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert- Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In NeurlPS, 2020.
Lijie Chen, Binghui Peng, and Hongxun Wu. Theoretical limitations of multi-layer transformer. arXiv preprint arX10:2412.029755 2024a.
Qiguang Chen, Libo Qin, Jiaqi WANG, Jingxuan Zhou, and Wanxiang Che. Unlocking the capabilities of thought: A reasoning boundary framework to quantify and optimize thain-of-thouglee In NeurIPS, 2024b.
Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, Rui Wang. Zhaopeng Tu, Haitao Mi, and Dong Yu. Do not think that much for 2+3=? on the overthinking of ol-like llms. arXiv preprint 21X1v:2412.21187, 2024c.
Yanxi Chen, Xuchen Pan, Yaliang Li, Bolin Ding, and Jingren Zhou. A simple and provable scaling law for the test-time compute of large language models. arXiv preprint (tt:::2411.194777 2024d.
Yilong Chen, Junyuan Shang. Zhenyu Zhang, Yanxi Xie, Jiawei Sheng, Tingwen Liu, Shuohuan Wang, Yu Sun, Hua Wu, and Haifeng Wang. Inner thinking transformer; Leveraging dynamic depth scaling to foster adaptive internal thinking. arXiv preprint arXiv:2502. 13842, 2025.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Rejichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14163. 2021.
11

---

Published as a conference paper at ICLR 2026
Guhao Feng, Bohang Zhang, Yuntian Gu, Haotian Ye, Di He, and Liwei Wang. Towards revealing the mystery behind chain of thought: A theoretical perspective. NeurlPS, 2023.
Yao Fu, Hao Peng, Ashish Sabharwal, Peter Clark, and Tushar Khot. Complexity- -bssed prompting for multi-step reasoning. arXiv preprint arXiv:2210.0000 0070000 2023.
Zhizhang FU, Guangsheng Bao, Hongbo Zhang, Chenkai Hu, and Yue Zhang. Correlation or causation: Analyzing the causal structures of Ilm and Irm reasoning process. arXiv preprint arXiv:2509.17380 2025.
Kanishk Gandhi, Ayush Chakravarthy, Anikait Singh, Nathan Lile, and Noah D. Goodman. Cognitive behaviors that enable self eef-oiing reasoners, or, four habits of highly effective stars. arXiv preprint arXiv:2503.01300 2025.
Jonas Geiping, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian R Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. Scaling up test-time compute with latent reasoning: A recurrent depth approach. arXiv preprint arXiv:2502.05117 2025.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et Deepseek-rl: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprini urXiv:2501.12945 2025.
Tingxu Han, Zhenting Wang, Chunrong Fang, Shiyu Zhao, Shiqing Ma, and Zhenyu Chen. Token- budget-aware IIm reasoning. arXiv preprint arXiv:2412.18547, 2024.
Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. In ICLR, 2021a.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.03877 2021b.
Maggie Huan, Yuetai Li, Tuney Zheng, Xiaoyu Xu, Scungone Kim, Minxin Du Radha Pooven- dran, Graham Neubig, and Xiang Yue. Does math reasoning improve general Ilm capabilities? understanding transferability of Ilm reasoning. arXiv preprint arXiv:2507.0044 00432. 2025.
Gangwei Jiang, Yahui Liu, Zhaoyi Li, Wei Bi, Fuzheng Zhang, Linqi Song, Ying Wei, and Defu Lian. What makes good reasoning chain? uncovering structural patterns in long chain-of-thouge reasoning. In NeurIPS, 2025.
Mingyu Jin, Qinkai Yu, Dong Shu, Haiyan Zhao, Wenyue Hua, Yanda Meng, Yongfeng Zhang, and Mengnan Du. The impact of reasoning step length on large language models. In ACL, 2024.
Zhiyuan Li, Hong Liu, Denny Zhou, and Tengyu Ma. Chain of thought empowers transformers to solve inherently serial problems. arXiv preprint arXiv:2402. /2875, 2024.
Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let's verify step by step. arXiv preprint arXiv:2305.200550 2023.
Haotian Luo, Li Shen, Haiying He. Yibo Wang, Shiwei Liu, Wei Li, Naiqiang Tan, Xiaochun Cao, and Dacheng Tao. Ol-pruner: haagthhhrmmniizing fine-tuning for ol- reasoning pruning. arXiv preprint arXi::5501./2570 2025.
Xinyin Ma, Guangnian Wan, Runpeng Yu, Gongfan Fang, and Xinchao Wang. Cot-valve: Length- compressible ofain-of-thought tuning. arXiv preprint wwXivv25522.0660. 2025.
Zijie Meng, Yan Zhang, Zhaopeng Feng, and Zuozhu Liu. Der: Divide-and-comquer reasoning for multi-choice question answering with llms. arXiv preprint arXiv:2401.05199, 2024.
Sania Nayab, Giulio Rossolini, Giorgio Buttazzo, Nicolamaria Manes, and Fabrizio Giacomelli. Con- cise thoughts: Impact of output length on Ilm reasoning and cost. arXiv preprint arXiv:2407.19825 2024.
12

---

Published as a conference paper at ICLR 2026
Qwen, An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang. Haoran Wei, Huan Lin, Jian Yang, Jianhong Tu, Jianwei Zhang. Jianxin Yang, Jiaxi Yang, Jingren Zhou, Junyang Lin, Kai Dang, Keming Lu, Keqin Bao, Kexin Yang, Le Yu, Mei Li, Mingfeng Xue, Pei 7hang, Qin Zhu, Rui Men, Runji Lin, Tianhao Li, Tianyi Tang, Tingyu Xia, Xingzhang Ren, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yu Wan, Yuqiong Liu, Zeyu Cui, Zhenru Zhang, and Zihan Qiu. Qwen2.5 technical report. arXiv preprint 1rXiv:2412.15115 2025.
Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAl blog. 2019.
David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R. Bowman. Gpqa: A graduate-level google- google-proof q&a benchmark. arXiv preprint arXiv:2311. 2..i::2311..222..,.. 2023.
Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale. arXiv preprint
2019.
Rylan Schaeffer, Brando Miranda, and Sanmi Koyejo. Are emergent abilities of large language models mirage? In NeurlPS, 2023.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint 177.001777 2017.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. Deepseckmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.0334 0000000000, 2024.
Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng. Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework. In EuroSys, 2025.
Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling IIm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314 2024.
Yang Sui, Yu-Neng Chuang, Guanchu Wang. Jiamu Zhang, Tianyi Zhang, Jiayi Yuan, Hongyi Liu, Andrew Wen, Shaochen Zhong, Hanjie Chen, et al. Stop overthinking: survey on efficient reasoning for large language models. arXiv preprint 1:Xi::2503.16419 2025.
Jean-Francois Ton, Muhammad Faaiz Taufiq, and Yang Liu. Understanding chain-of-thouglle in llms through information theory. arXiv preprint arXiv:2411.1199 2024.
Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Ani Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint 23Xi:2302..3971 2023
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe V Le, Ed H. Chi, Sharan Narang. Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In ICLR, 2023.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, brian ichter, Fei Xia, Ed Chi, Quoc V Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models, In NeurIPS, 2022.
Yangzhen Wu, Zhiqing Sun, Shanda Li, Sean Welleck, and Yiming Yang. Scaling inference com- putation: Compute-optimal inference for problem-solving with language models. In MATH-AI Workshop at NeurIPS, 2024.
Yunhui Xia, Wei Shen, Yan Wang, Jason Klein Liu, Huifeng Sun, Siyue Wu, Jian Hu, and Xiaolong Xu. Leetcodedataset: A temporal dataset for robust evaluation and efficient training of code 1lms. arXiv preprint 2504 /4655, 2025.
Keyulu Xu, Jingling Li. Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What neural networks reason about? arXiv preprint arXiv: 1905. /32//. 2019.
13

---

Published as a conference paper at ICLR 2026
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik R Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. In NeurIPS, 2023.
Tian Ye, Zicheng Xu, Yuanzhi Li, and Zeyuan Allen-Zhu. Physies of language models: Part 2.1, grade-school math and the hidden reasoning process. arXiv preprint 2rXiv:2407.2031,, 2024.
Yizhou Zhang, Lun Du, Defu Cao, Qiang Fu, and Yan Liu. An examination on the effectiveness, of divide-and-conquer prompting in large language models. arXiv preprint 2Xiv:2402.053359, 2024.
Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Claire Cui, Olivier Bousquet, Quoe V Le, and Ed H. Chi. Least-to-most prompting enables complex reasoning in large language models. In ICLR, 2023.
14

---

Published as a conference paper at ICLR 2026
Appendix
CONTENTS
The Use of Large Language Models (LLMs)
16
Formal Definitions of Simplified Arithmetic Problem
16
Problem Formulation
16
B.2
Contrast vanilla arithmetic problem
17
Dynamic Programming (DP) Problems
17
Experimental Setup
17
Evaluation of Dynamic--Pooramming Tasks on Larger Qwen2.5 Models
18
D Supplementary Details on Real world Experiment for Optimal CoT Length
18
D.1 Solution Length Control
18
D.2 Step Segmentation
19
D.3 More Details of Figure 2b
19
D.4 On the Definition of Task Difficulty and Mitigating Accuracy Bias
20
Looped Transformer
20
Extended Experiments on Broader Domains
20
Additional Results for Figure 2b]
20
F2
Experiments on the Full MATH500 Dataset
20
Experiments on the Winogrande Dataset
22
Supplementary Details on Real World Experiment for RL Simplicity Bias
22
H
Additional Synthetic Experiment Details
22
H.I Training details
22
2 Observation subtask loss
23
Theoretical Results under Broader Scenarios
23
General Errors
23
Random Error
24
J
Proof
24
J.1
Proof of Proposition 4.1
24
2
Proof of Theorem 4.2
25
0.3 Proof of Corollary
26
J.4
Proof of Theorem
27
15

---

Published as a conference paper at ICLR 2026
J.5 Proof of Theorem
27
J.6 Proof of Corollary 4.4
28
J.7 Technical Lemmas
29
Pseudo-code of Length-filtered Vote
31
A THE USE OF LARGE LANGUAGE MODELS (LLMs)
In this work, LLMs are primarily employed for two purposes: (1) polishing the language of the manuscript to ensure grammatical correctness and coherence, and (2) assisting in the standardized organization and documentation of the released codehase. Importantly, all conceptual development, theoretical analysis, experimental design, and result interpretation are conducted independently by the authors. The use of LLMS is strictly limited to auxiliary tasks, ensuring that the scientific contributions of this paper remain entirely unaffected by such tools.
B FORMAL DEFINITIONS OF SIMPLIFIED ARITHMETIC PROBLEM
To begin, we aim to empirically investigate the relationship between reasoning performance and CoT length. Therefore, need con- trol given model to generate reasoning chains of varying lengths for specific task. Un- fortunately, existing real-world dataset or model fully meets these strict requirements. Real-world reasoning tasks, such GSM8K or MATH (Cobbe et al. 2021 Hendrycks et al.) 2021b), do not provide multiple solution paths of different lengths, and manually constructing such variations is challenging. Moreover, it is difficult to enforce a real-world model to generate a diverse range of reasoning paths for given question. Given these limitations, begin our study with experiments synthetic datasets.
3
Figure 6: Computation tree of arithmetic expres- sion + (4 + ((2 + 3)).
B. PROBLEM FORMULATION
To investigate the effect of CoT length in controlled manner, design synthetic dataset of simplified arithmetic tasks with varying numbers of reasoning steps in the CoT solutions.
Definition B.1 (Problem). In simplified setting, arithmetic task is defined binary tree of depth T. The root and all non-leaf nodes are labeled with the + operator, while each leaf node contains numerical value (mod 10). In addition, impose constraint that every non-leaf node must have at least one numerical leaf as a child.
The bidirectional conversion method between arithmetic expressions and computation trees is as follows: keeping the left-to-right order of numbers unchanged, the computation order of each "+" or tree node is represented by tree structure or bracket structures. For example, consider the task - (4 ((2 + 1) +3) with T 4. The corresponding computation tree defined as Figure
To ensure that CoT solutions of the same length have equal difficulty for a specific problem, we assume that each reasoning step performs the same operations within a single CoT process.
Definition B.2 (Solution). We define t-hop CoT with a fixed each step length as a process that executes i operations starting from the deepest level and moving upward recursively.
16

---

Published as a conference paper at ICLR 2026
According to this definition, the execution sequence is uniquely determined. For example, way to solve expression in Figure is is by performing one addition at a time:
5+ (4+ + ((2 + 1) + 3)) = <1>
(3)
2+1=1 3 3
(4)
3+ 3 6
4+ 6 0
5 0 = 5<END>
Another approach is perform two additions at a time:
5 (4+ (2++( 3)) <2>
(5)
3 5+ ()+ 5<END>
The latter approach is half as long as the former, but each reasoning step is more complex This illustrates clear trade-off between the difficulty of each subtask and the total number of reasoning steps.
In practice, when & does not evenly divide T. the final step performs T mod operations. To guide the model in generating the desired CoT length, we insert the control token <t> after the question and before the beginning of the solution. To preserve the parentheses that indicate the order of operations, we construct expressions in Polish notation. However, for readability, we present each problem in its conventional form throughout the article.
B.2 CONTRAST TO VANILLA ARITHMETIC PROBLEM
Why pruning? Initially, we intended to create a synthetic dataset for regular arithmetic tasks, but we quickly realized that the computation tree for such tasks is uncontrollable. For example, consider the task 1 2 + 3 4. We hoped to compute operators in one step, but found it impossible because the addition needs to be computed after the two multiplications, and cannot aggregate two multiplications one subtask. Therefore, pruning computation tree becomes essential.
Why only focusing addition? There two reasons why focus arithmetic tasks involving only addition: first, simplifies pruming, as the order of operations can be controlled solely by parentheses; second, it facilitates the computation of sub-tasks, since parentheses do not affect the final result, and the model only needs to compute the sum all the numbers when solving a sub-task. We aim for the model handle longer sub-tasks, thereby allowing broader study of the impact of CoT length.
Will the simplified synthetic dataset impact the diversity of the data? We need to clarify that even with pruning, the structure of the expressions will still vary because swapping the left and right child nodes of each non-leaf node in the computation tree results in different expressions. When T 30, the number of possible variations exceeds 1 x 10".
C DYNAMIC PROGRAMMING (DP) PROBLEMS
C.I EXPERIMENTAL SETUP
To complement the arithmetic dataset, we design a classical dynamic programming (DP) problem the Maximum Path Sum in Number Triangle. This task shares the same desirable decomposability property as the arithmetic problems: it naturally admits multiple solutions of varying CoT lengths, making it suitable for analyzing the scaling behavior of reasoning length.
We construct dataset of number triangles with varying heights H. Each triangle consists of H rows, where the i-th row contains integers sampled uniformly from predefined range (c.g.. [1, 99]). The
'This is because performing two operations once requires the model to either memorize all combinations of numbers in two-operator equation and their answers, apply techniques like commutativity to reduce memory requirements, its mental reasoning abilities perform the two operations without relying on CoT.
17

---

Published as a conference paper at ICLR 2026
total task difficulty is quantified by the number of rows H, since longer triangles require deeper reasoning chains to propagate information from the base to the top.
For example, consider the following triangle of height H 4:
8
8
0
2
4 4
The goal is to find path from the apex (top) to the base that maximizes the sum of visited numbers. The canonical solution employs a bottom-up dynamic programming algorithm: starting from the second-to-last row, we update each entry as the sum of the current value and the maximum of its two children in the row below. Repeating this process row by row eventually yields the maximum path sum at the apex.
long CoT solution might designed to process 1 layer per step.
Row 3 update:
[8 + max(2, 7), 1 + max(7,4), 0 + max(4, ]
15, 8,
Row 2 update:
3 + max (15x (15, 8), + max 4)
18, 16]
Row 1 update:
[ + (18 16)
25
shorter CoT solution for the same problem might process layers per step.
For Row 2, Col 1: 3 + max 8, 7 8) =3 + max 10, 15) 18
Step (Row 4 -> Row 2):
For Row 2, Col 2: 8 max(7 + 1, 4 + 1) = 8 max(8, 5) 16
Row 2 becomes [18, 16)
Step 2 (Row 2 - Row 1): 7 max(18, 16) 7 18 25
Thus, the maximum path sum 25.
C.2 EVALUATION OF WYNAMIC-PRGGRAMMINN TASKS ON LARGER QWEN2.5 MODELS
To further validate the non-triviality of our synamic-programmiin (DP) benchmark and examine its behavior on stronger models, we evaluate Qwen2.5 instruct models of varying sizes on DP tasks of depths 6, 8, and 10. For each difficulty level, we generate 100 problem instances and sample 10 CoT responses per instance. Following our real-world evaluation protocol, we determine the optimal CoT length for each model-task pair by selecting the chain length that achieves highest accuracy.
We omit the 1.5B model from analysis due to its low performance (<10% accuracy). Importantly, the 72B model does not achieve perfect accuracy depth-6 tasks (81.8%), indicating that DP benchmark remains non-trivial and effectively probes structured algorithmic reasoning.
Table 2 summarizes optimal CoT lengths and corresponding accuracies. Two clear trends emerge: 1) larger models consistently require shorter optimal CoT lengths, and 2) deeper DP tasks require longer optimal CoT lengths. Both findings are fully aligned with theoretical predictions regarding adaptive CoT behavior with respect to model capability and task difficulty.
D SUPPLEMENTARY DETAILS ON REAL WORLD EXPERIMENT FOR OPTIMAL COT LENGTH
D.1 SOLUTION LENGTH CONTROL.
To study the impact of CoT length on performance under given problem difficulty, we need to induce the model naturally generate solutions of varying lengths. Simply adding prompts like
18

---

Published as a conference paper at ICLR 2026
Table 2: Optimal CoT length (aceuracy %) across Qwen2.5 model sizes and DP task depths.
DP Depth
8
10
7B
(35.0%)
(30.3%)
8 (22.6%)
32B
4 (70.6%)
5 (45.8%)
8 (42.9%)
72B
(81.8%)
(66.7%)
(46.2%)
"please use 100 tokens to solve this problem" or "please use 10 steps to solve this problem" is not ideal because the model's ability to follow instructions regarding output length is limited, and such fixed-length prompts may not ensure fairness across problems of different difficulties. Moreover, prompting for specific length might lead the model to generate irrelevant tokens or steps just to "pad the length," without actually changing the number of steps or the complexity of the reasoning. Additionally, controlling max_ _ex____eghhhh is also problematic, as overly long responses might get truncated, which would directly lead lower accuracy for longer outputs. What we really want is for the model to generate a complete and coherent long response on its own, so we can observe the corresponding accuracy.
To create solutions with varying step lengths with different complexity, we follow (Fu al. 2023 by using in-context examples (8-shots) with three different levels of complexity to guide the model in generating solutions with different step counts. For each set of in-context examples, we sample 20 times, resulting in a total of 60 samples per question.
D.2 STEP SEGMENTATION
Simply measuring CoT length by counting tokens is neither rigorous meaningful. Since focus is on final performance rather than efficiency, we care more about using CoT length to reflect the complexity of the reasoning pattern. In this sense, the number of reasoning steps can serve more appropriate indicator of CoT length. As we discussed earlier, the step number captures how the model decomposes the problem, which directly reflects the complexity of its reasoning. In contrast, token length fails to capture this because, as the model thinks more deeply and the number of steps increases, the number of tokens per step may cearraseemakinnn the total token count unpredictable and unreliable as proxy for reasoning complexity.
When calculating the number of steps, we separate the full reasoning chain using "An " (Fu al. 2023) and remove empty lines caused by " \n". Then we consider the total number of lines as the CoT length. Since questions the MATH dataset are challenging and lead to high variability in final CoT lengths, we normalize the lengths by applying length length / bin_width For experiments comparing different models (c.g., optimal CoT length per model or optimal vs. longest CoT), the questions within each length bin differ, which introduces variability. To reduce this variance and ensure each bin has enough samples, we use a relatively large bin width of In contrast, for analyzing the influence of task difficulty, where each calculation optimal CoT length only contains one question, we adopt a finer bin width for better resolution (we also verified that using width yields almost identical results).
D.3 MORE DETAILS OF FIGURE 2B
When evaluating the results, questions with accuracy < 0.01 0.99 (indicating all incorrect or all correct responses) are excluded, as their accuracy does not vary with step length changes.
To better understand the reliability of the observed trend between task difficulty and optimal Chain- of of-Thought (CoT) length, we compute a 95% confidence interval around the linear regression line. standard methods based the Student's t-distribution to estimate uncertainty in the predicted values. The confidence band reflects how much the estimated mean CoT length is expected to vary given the finite sample size and the distribution of data points.
Specifically,
19

---

Published as a conference paper at ICLR 2026
D.4 ON THE DEFINITION OF TASK DIFFICULTY AND MITIGATING ACCURACY BIAS
Defining task difficulty requires particular care because raw accuracy can be biased by a model's in- herent preference for certain CoT lengths. We address this issue using complementary strategies.
Controlling for CoT-Length Bias. Different questions may elicit different preferred CoT lengths from the model, which can artificially inflate or deflate their measured difficulty. To reduce this confounding factor, for each question we explicitly prompt the model to generate multiple CoT lengths when producing the 60 responses used in our evaluation. This procedure minimizes effect of internal length biases accuracy and yields a more reliable task-difficulty signal.
Model-Aware Difficulty Definition. Task difficulty inherently model-dependent: a problem that easy for one model may be challenging for another due differences in scale, data coverage, training. For this reason, we define difficulty in a model-aware manner by using the average accuracy of the evaluated model the difficulty indicator. This ensures that the difficulty metric faithfully reflects the model's is actual competence rather than relying on externally imposed or model-agnostic notions of hardness.
E LOOPED TRANSFORMER
Following Bac al. 2005), we implement the looped Transformer architecture by iteratively applying a single Transformer layer multiple times. Specifically, we train two variants with loops 6 and loops = 9, both configured with an embedding dimension of 9 and 9 attention heads (only 4 MB parameters in total). Training is conducted on mixed dataset with maximum task difficulty and maximum CoT hop size 8. Detailed training procedures are provided the released code.
F EXTENDED EXPERIMENTS ON BROADER DOMAINS
To strengthen the generality of our experimental conclusions, we expanded both the scale of the data and the diversity reasoning domains considered. Specifically, we conducted experiments in the following three areas:
We employed the full MATH500 dataset (Lightman et al. 2023). This dataset contains a curated subset of 500 problems from the original MATH benchmark.
Mathematical reasoning:
Scientific reasoning: We adopted the MMLU STEM (Hendrycks et al. 2021a) dataset, which is a subset of STEM subjects defined in the original MMLU benchmark, which covers a wide range of scientific and engineering domains.
We used the full Winogrande (Sakaguchi al. 2019 xs training split. This dataset formulates a fill-nn-heebllan task with binary options, designed to require non-trivial commonsense reasoning.
Commonsense reasoning:
F.1 ADDITIONAL RESULTS FOR FIGURE 2
Before presenting the results on additional datasets, we first further investigate the relationship between task difficulty and optimal CoT length on real-world benchmarks using different models. As shown in Figure the findings are consistent and compelling: across all evaluated models, we observe a clear and statistically significant correlation between task difficulty and the corresponding optimal CoT length. These analyses are also validated on broader datasets such as MATH500, MMLU STEM, and WINOGRANDE.
F.2 EXPERIMENTS ON THE FULL MATH500 DATASET
We acknowledge the need for broader validation beyond single subset of data. Therefore, further conducted experiments on the complete MATH500 dataset. Specifically, we evaluated the 1ree2.55-Intrru models (1.5,, 7B, 32B, and 72B) with 30 sampled solutions per question.
20

---

Published as a conference paper at ICLR 2026
Optimal CoT Length
35
p 6.675e-07
r 0.48
optimal CoT Length
30
p 1. 1.114e-04
r= 0.47
30
25
25
20
20
15
10
5
5
0.0
0.2
0.4
0.6
0.8
1.0
0.0
0.2
0.6
0.8
1.0
Task Difficulty (1-acc)
Task Dificullt(1-acc))
(a) Qwen2.5 1.5B Instruct
(b) Qwen2.5 7B Instruct
r= 0.31
0.35
Optimal CoT Length
30
p 3.77 03-03
Optimal CoT Length
60
p 4e-04
25
50
40
20
30
15
20
10
10
5
0.0
0.2
0.4
0.6
0.8
1.0
0.0
0.2
0.4
0.6
0.8
Task Difficulty (1-acc)
Task Difficulty (1-acc)
(c) Qwen2.5 32B Instruct
Qwen2.5 72B Instruct
Figure 7: Evaluation between task difficulties and optimal CoT lengths MMLU STEM datasets.
Table 3 reports the comparison of accuracy achieved with the longest chain tfain-of-thougee (CoT) versus the optimal CoT length, across different model sizes. Table further examines the relationship between optimal CoT length and problem difficulty.
Table 3: Optimal CoT length vs. model size the full MATH500 dataset.
L.5
7B
32B
72B
Accuracy (longest length)
0.18
0.27
0.40
0.08
Accuracy (optimal length)
0.38 (+0.20)
0.82
(+0.55)
0.81
(+0.41)
0.81
(+0.73)
Optimal length
2
Table 4: Correlation between optimal CoT length and task difficulty.
1.5B
7B
32B
72B
r 0.2092
0.2378
0.2266
0.1986
p 0.0068
0.0034
0.0029
0.0297
In this experiment, where problem difficulty not explicitly controlled, observed that the 7B, 32B, and 72B models achieved peak performance at shorter CoT lengths. This trend is likely explained by the dataset's high concentration of easier problems (levels 1-4), which, shown in our previous results, generally require shorter reasoning chains. By contrast, the much weaker 1.5B model still benefited from longer reasoning (optimal length 5).
Importantly, despite the skewed distribution of problem difficulty. the key relationship we aimed to study remains intact: consistently found statistically significant correlation (p < 0.05)
21

---

Published as a conference paper at ICLR 2026
between task difficulty and optimal CoT length, which aligns with our earlier findings across all other experiments.
F.3 EXPERIMENTS ON THE WINOGRANDE DATASET
We have also conducted new experiments the WINOGRANDE (Sakaguchi et al. 2019) dataset to assess commonsense reasoning. In particular, we evaluated the Qwen2.5-Instrue models (1.5B, 7B, 32B, and 72B) on the full WINOGRANDE-XS training split, replicating the experimental setup from Figure 2 of our main paper.
3 reports the comparison between the longest and optimal CoT lengths across different model sizes, while Table shows the correlation between optimal CoT length and task difficulty.
Table 5: Optimal CoT length vs. model size on the WINOGRANDE-XX -S dataset.
1.5B
7B
32B
72B
Accuracy (longest length)
0.56 0.63
0.69
0.72
0.85 0.93
Accuracy (optimal length)
(+0.07)
0.74 (+0.05)
0.80
(+0.08)
(+0.08)
Optimal length
15
15
10
9
Table 6: Correlation between optimal CoT length and task difficulty on WINOGRANDE-XS.
1.5B
7B
32B
72B
0.2201
0.4256
0.3886
0,2098
p 0.0052
< le-4
0.0120
0.0077
These experiments significantly broaden the generalizability of our conclusions. The results corrobo- rate our earlier findings from the mathematical domain, demonstrating that the optimal CoT length decreases as the model size increases and that it remains significantly correlated with task difficulty (p < 0.05).
G SUPPLEMENTARY DETAILS ON REAL WORLD EXPERIMENT FOR RL SIMPLICITY BIAS
For Figure 2c we use (iee2.55-B-Innstrul (Qwen et al. 2025) as the base model, Group Relative
Policy Optimization with R1-like prompting (Shao et 2024 Guo et al.) (2255) for the reinforcement learning process, and LeetCode-2K (Xia et | (2225) as the training and evaluation dataset. We take the following training configuration by default:
Table Hyperparameter settings for roal-world RL experiments with Qwen2.5-instruet models.
Leamingg
Max Epochs
Rollout Samples
Reverse Coefficient
Entropy Loss Coefficient
Effective Batch Size
5c-7
10
16
le-3
Se-3
256
H ADDITIONAL SYNTHETIC EXPERIMENT DETAILS
H.1 TRAINING DETAILS
In default, we train different models (layers ranging from 5 to 9) on the same dataset, which included mixed questions with total operators E [12, 80) and random sampled CoT solutions with each step operators / E [1, 12]. All other parameters are kept the same with the huggingface GPT-2 model. During the training process, the CoT indicator token <t> also trained, so that during test-time, we can let the model decide which type of CoT it will use by only prompting the model with the question. For each model. we train 25000 iterations with batch size that equals 256. During test-time, we test 100 questions for each T and All experiments can be conducted
NVIDIA A800 80G GPU.
22

---

Published as a conference paper at ICLR 2026
H.2 OBSERVATION OF SUBTASK LOSS
As we observed in training losses, the loss of subtask generation tokens (e.g. 1 1 2) for the easiest subtask(( = 1) is about 3 times larger than the hardest subtask (1 12), while the loss ratio for subtask answer tokens is le4. Therefore, it is acceptable for taking the subtask error rate constant with t.
Besides, there is no obvious pattern showing the model sizes affect the subtask loss. Moreover, the smallest model and the largest model have almost the same subtask loss. Therefore, in our settings, we take model size as irrelevant with the subtask error rate.
I THEORETICAL RESULTS UNDER BROADER SCENARIOS
1.1 GENERAL ERRORS
In the simple case we discussed in Section 4 discussed the trend of overall accuracy with respect to and the variation of optimal N with M and T, assuming the subtask error rate is a linear funetion. In the following discussion, error rate functions. We find that as long as the error function satisfies some basic assumptions on the monotonicity and convexity of the error functions, the above conclusions still hold. Assumption I.1. E(N, M, T) satisfies the following reasonable conditions:
aim derive conclusions corresponding to more general
0 < F(N = 1, M, <
lim EN M,T) =0
P(N,M,7) is monotonically deceasing with N, since more detailed decomposition leads easier subtask.
E(N, M) is convex with N, since the benefits of further decomposing already fine- grained problem(N large) are less than the benefits of decomposing a problem that has not yet been fully broken down(N is small).
E(N, M, T) is monotonically deceasing with M, since stronger models have less subtask error rate.
E(N,M M, is monotonically increasing with T, since harder total task leads to harder subtask while N, M are the same.
Assumption I.2. o (T) is monotonically increasing with
With Assumption and 1.2p. the core insights from the linear case can be generalized.
Theorem I.3. For noise function 0 <T)
and subtask error rate function 0 <
E(N, M, < 1 satisfying Assumptions I.I and I.2 the general final accuracy function A(N)
from Proposition 4.1 has the following properties:
limy-+a A(N) O. (Excessively long chains always fail.)
A(N) has maximum N* then N* has a lower bound related to M and T:
N* (N.(MM.T) EN (1 ( M,
1
(6)
where FNN' (t (,, is the inverse of FIN, M, with respect N.
The monotonicity of Fyy with respect to M (decreasing) and T (increasing, assuming (T) doesn't 't dominate adversely) implies that the qualitative scaling laws (Corollaries stemming from Theorem 4.22 still hold under general conditions, supporting the empirically observed Simplicity Bias and the inverted U-shaped performance.
Corollary 1.4. As the model becomes stronger, E-1 decreases monotonically with respect to M, which leads to decrease of (M, T).
Corollary L.. As the task becomes harder, E monotonically increasing with respect to T, which leads an increase in N (M, M,TT T).
23

---

Published as a conference paper at ICLR 2026
I.2 RANDOM ERROR
In Theorem 4.2 and I.3 we make a strong assumption that all sub-question or sub-answer errors are identical, which does not align well with real-world scenarios. In practice, each sub-task may exhibit a different error rate. However, they generally follow a trade-off: the more the task is decomposed, the easier each sub-task becomes. Specifically, random variable with a fixed expectation that monotonically decreases with the number CoT steps N.
model the enror rate of each sub-task
To simplify the problem, here we assume ~ B(an (7), to be the sub-question error rate, and 6q Bla2 (N, M, 7), (2(,, M,T) be the sub-answer rate. Then, variant of Proposition 4.1. the expectation of final accuracy is E
I (1)--)))))))
worth noting that each or or e, is not independent. most steps are easy (i.c., have low error rates), the remaining steps more likely to be easy well. Moreover, if particular step serves as a self-validation step, its high accuracy can influence the correctness of other steps that depend on it. This also provides interpretation for reasoning models exhibiting backtracking behavior.
Theorem L6. Let T, 31 = C -T, T, T, and B2 NM T. Then the expected error rates for sub-questions and sub sub-answers are given by Elo,] I and Eles] = MN respectively.
Based on these estimates, can derive upper bound A(N) on the final accuracy
N e1(
o.) < A(N) = -11-
N 2N (1-
)
E
II
C+2N-1
NM + 11NNM+
C 2N
which initially increases and then decreases as the number of CoT steps N grows
This suggests that with stochasticity, the fundamental trade-off leading to optimal CoT length persists.
J PROOF
In this section, we provide the proofs for all theorems.
J.1 PROOF OF PROPOSITION 4.1
Proposition 4.1. Assuming stepwise stationarity and independence conditioned on history, the final accuracy takes the form
A(N) = P(agnal = Ggnaa -
(I)
where denotes constant independent N.
Proof. In each subtask t; which contains operators, there are 2t + +1 tokens (as the number of numerical tokens is one more than the number of operators). Therefore, the accuracy of each subtask is given by
P(4 = -4= (
In our theoretical analysis, for simplicity, we allow to fraction, defined as f = F. and assume that each subtask has the same level of difficulty given T and N. Under this assumption, have the
24

---

Published as a conference paper at ICLR 2026
final accuracy:
A(N) P(aN d)
(8)
II P(4 1, (() 0,/4, H1
(9)
N
II o (T)) (1 (1 E(N,
(10)
i=1
(1 (T)) M22+11 (1 F(N,
(11)
(1 - (TT) 2T ((I-BNN,,))(LLO(()))
(12)
=a -a1
B(N -(N)
(13)
J.2 PROOF OF THEOREM 4.2
Theorem 4.2 (Optimal CoT length). There exists optimal N (M,T)) maximizing A(N):
TZ
Z z-w- (- (- ):
N (M,
M(Z +))
where W is the negative branch of the Lambert W function (we" xx).
Proof. Given Eq. ① that
A(N) = A(N)=a((1 ((12() (1 (1-
NM) )) N
(14)
We consider function
f(x) = (11 (1-
(1- )
Mz (1-
(15)
For convenience, define
g(x) In(f(x))) x In in((1- T (1- 2)
Thus,
g((z) = [nn
T
+ In 1 +)
Msl
+
Mr (1
Ma
Set g'(x)) = 0:
In (1 T (1-1)) b)] +
T
0.
Mr
Ma
Let A
then we have
In (1- + 1-1 An)A=((A),
Let := 1- TT/C. (Since T/C < 1, == 1 T/C > 0.) By moving terms, have:
- -A (exp(-AA
25

---

Published as a conference paper at ICLR 2026
Therefore,
A (- -Z,
Finally, have
TZ
N(M,T) = == M(Z + +1
Here (-)) is the Lambert W function, and for 0 < <1 for < 1, the argument = --T/CC lies in e 0). This means there two real branches Wo and W-1 in that domain, but since 0,we have < -1. Therefore, we only take the solution on branch W-1-
the interval (- _
J.3 PROOF OF COROLLARY 4.3
Corollary 4.3 (Scaling laws). From Theorem 4.2
N* (M, increases with T (harder tasks warrant longer CoT).
The optimal operators per step t" (M,) M(1 1/Z) increases with T (envelope behavior).
(M,, decreases with M (stronger models need fewer steps).
Proof. The second and third conclusions can be easily derived through monotonic composition, so primarily focus proving the first point. We begin the proof by incorporating the notation from We have
T
g'(z) = In(1 M
+ In 2)
Mr (1
Mr
and x² (T) such that (T)) = O. Let F(x (T), 1) g' (x" (T)) 0 We want to see how xf (I') changes as T' changes, therefore take total derivative w.r.t. T. By the chain rule,
d dT (T),
OF dr (T),
Ox JT (T)
OF JT (T),T)
call this F.
call this Fr
Hence
Fr (T), T)
Ox
T
3T
Fg x (T', T)
So the sign of x'' is the opposite of the sign of Fr, provided F3 + 0.
Since
T2
Fs (x,,T) T)
< Vv 0, x(Mr - T)2
(16)
all we need to prove is
Fr x (T))).
T
1
C - T > 0.
(17)
(Mx - T)2
That is
VTCC - T) +T
x (T).
(18)
Let (7) VT(C-T)-
be the test point.
26

---

Published as a conference paper at ICLR 2026
According to Lemma J.1 F(zo(T),T) < Since F(x" (T) = 0, and Fg (z'(T), r) 0, we have zo(T) x² (T).
Thus, Fr (T), T)
> 0 holds and we have proved our corollary with 0z" 87 (T) 0.
J.4 PROOF OF THEOREM
L3
Theorem I.3. For a noise function (T) E(N, M,T) satisfying Assumptions L. and L.2
and a subtask error rate function 0 <
the general final accuracy function A(N)
from Proposition 4.Thas the following properties:
- A(N) 0. (Excessively long chains always fail.)
A(N) has a maximum at N > 1, then N has a lower bound related to M and
N 2 NLn(M, = EN (1 (1- (2(1- (TT) M,T))
(6)
where EN' (+: M.T) is the inverse of E(N, M,T) with respect to N.
Proof. (1) Since 0 < A(N) < (1 - oTT)) and lim o(T))
0.
lim A(N, M,T)
(2) Let g(z) denote Exr, .M, I') and define f(x) = In A(x). Then,
xE'(x)
('(x) = In(1 (T)) g(x))) 1 1 E(x)
(19)
< In(1 - - g(x))) + +2, (since E is convex and x = N2
(20)
A(N) attains its maximum at some point N > 1, then In(1 (T)) + 2 > 0. Otherwise, we would have fx) < (T)) 2 Vr > 1, leading to contradiction.
Thus, it follows that - (()-o(T)) > 1.
Now, define N(M,T) F (1 (ाーーo(ア)) which satisfies
+ = there exists x² (NM,, 7) such that l'(x*) = 0, then we obtain
In(1 - o g
- + 0, which is contradiction. Hence, the assumption that x= (M,, must be false.
== f'x") In(1
Therefore, we conclude that x" N > (MM,)).
J.5 PROOF OF THEOREM L6
Theorem L6. Let 01 = 02 and 8g NM -T Then the expected error T rates for sub-questions and sub sub-answers are given by B[o = C and Elea] = MN respectively. Based these estimates, derive upper bound A(N) on the final accuracy
E (1- 0.) A(N)
C+2N-1 (11--N(1-+-
T
(1
T NM + 2N
C
which initially increases and then decreases the number of CoT steps N grows.
27

---

Published as a conference paper at ICLR 2026
Proof. According to the multidimensional version of Hölder's inequality,
N
N <
E
I ea) o.)
[B[(1 -
2:))
J2) xt
(21)
i=1
N
T
T
(Lemma
(22)
C C
NM 2N
C+ 2N -1)
T
(1-
(1-
T
(23)
NM 2N
J.6 PROOF OF COROLLARY 4.4
Corollary 4.4 (RL Converges Optimal CoT Length). For gradient ascent on J(0) with sufficiently small step size, the policy converges to a deterministic solution xe (N,) = 1 iff i = arg max, A(N,). Thus, RL training converges the optimal CoT length N arg A A(N).
Proof. We treat the choice of CoT length k-armed stochastic bandit with action set A {Ni..... .Nk and unknown success probabilitied [(NN)) E (0, 1). Without loss of generality, relabel the arms that
A(N)) = max A(N,) =: A",
A(NI) 2 A(N)) 2 ... .... A(N)).
The agent uses a softmax (Gibbs) policy
e
no (N₂) =
0 EERt
(24)
Σ e0,
and maximises the expected reward
J(0) = Σ To A(N)).
(25)
Because Ty is Co0 in 0 and A(N,) are constants, J is smooth.
Under the REINFORCE estimator with sufficiently small, fixed step size 17 > 0, gradient ascent
updates take the form
g(++1) glt) + 17 VoJ (o(t)).
(26)
where
OJ (o(N.) (A(N.) - J(0). J(O)-
(27)
00,
Eq. is the classical replicator (or logit) gradient. Define the simplex Ak-1 ==11= {N E (0, 1
Σ, n. 1) and write xo (Mo)NN),..... To (N()))
Letting > 0 yields the ODE
# (A(N,) - A)),
i= 1......,k
(28)
with (,, A) = E, AN,) Eq. 28 the replicator dynamics for a fitness landscape on k-1
Consider the Kullback-Leible divergence to the optimal pure strategy e (1,0,...,
(TT) Σ
St
In
By Proposition 4.1 A(N,) is the probability that the final answer is correct when chain of length N; is used. The bandit stationary because A(N,) does not depend time the agent's past actions.
28

---

Published as a conference paper at ICLR 2026
V is non-negative A and (TT 0 iff e1-
Taking the time derivative along Eq. 28 gives
dV
(A(N))- A\) 0,
dt
with equality iff TT or A(N1) = (T, A). The latter can only happen if ιΙ because A(N1) > (N2)) for > 1. Hence V is a strict Lyapunov function, and is the unique asymptotically stable equilibrium of Eq. (28). All other stationary points (mixtures over sub-optimal arms) are unstable.
For sufficiently small but fixed (choose A which always exists), projected gradient ascent is a perturbed discretisation of Eq. (28). Standard results for primal-space mirror descent imply that discrete iterates (*)) Tgte converge almost surely the set of asymptotically stable equilibria of the ODE, i.e. to }ei}. Therefore
f1,
if arg maxy A(N)),
Toch (N₂) t-500
lim
0, otherwise.
Because A may attain its maximum at several arms, the limit is a deterministic policy that places all probability on some maximiser of A.
Thus gradient ascent on Eq. (25 converges deterministic policy that always selects an optimal CoT length N arg maxNEA A(N), completing the proof.
J.7 TECHNICAL LEMMAS
Lemma J.1 (test point). Let F(x) be defined as
F(x) In T
T
1 )
In
Mx
Mx (1
Mr
where T, M, C E IR+ satisfy the conditions:
< C < 0.9.
0 < 1.
MZ
Define Ta as
VTIC- (T) +T
TO
M
Then, we have
F(xo) <00
Proof. At To. note that
Mx = -T) +T.
Thus,
T
T
VCC-T
=
Mro
T VTCC T -T(C-T)
Therefore,
= - +
T
-T
Mxo
T VTCC
Also, observe that
T
T
T
T
Mx Mza
(T+ + VTCC -T)
T(C-T)
VT(C -T)
V--
T+-T(C-T)
29

---

Published as a conference paper at ICLR 2026
It is convenient to introduce the change of variable
V C-
so that
T T= -c T), (TCC-T) u(C T))-
Then we have
T TCC 1²(C T) u(C T) = u(C - +))+))
In these terms we have:
In DTVTTC = Infu(((c 7)] = = In(C -
-T), T),
In + VTCC 7)) In(u(C - () 1)] ln In( T) + In(u 1),
and
C-- =
Finally, we have
In (1 -) In( C
C-T =-In + 1)
Thus, the function F( becomes
F(æo)= = u + In(O T) - (Inu u + In(CC
- T) + In(u + 1)) u In(u² +1)
(29)
= - In(u + 1) + In(u² + 1),
(30)
where Vo- c-T E (0,3). It is easy to show F(xo) 0 when E (0,
Lemma J.2 (Estimation of the n-th Moment of the Beta Distribution). Let Beta(a, B). Then
E[(1 x) (1
a +
Proof.
1
B[(1 x)
(I- x0=xx-11 a1-a-(11 11) dx
B(a,3) J
1
xa-1(1 (11 8- dx
B(a, B)
B(a, 3 8+
B(a,8)
T(a)T(3 + +n) T(a
I(a B+n) n) ((a)
T(B +)
+(a+
[(3)
T(o n)
β +
-II 1=0
Q 3 ii
3 +
n
a + 3 +
++ 3 + 71
30

---

Published as a conference paper at ICLR 2026
K
PSEUDO-CODE OF LENGTH-FILTERED VOTE
Algorithm Length-filtere Vote
1: Input: Model fa. Question q. Space of All Possible Answers A, Number of Total Groups M,
Number of Selected Groups K, Group Width D
2: Output: Final Answer à
3: Sample candidates c1...., C..
i. fo(4)
4: Define A(c) as the corresponding answer of candidates c.
5: Define P, E [0, 1] as the frequency of each answer in length group Ly.
6: for
m do
I.j = {c: ((c)) E ( (j 1), D D) . n
7: for E do
Py[a] EoEL, I(A(c) a)
[Ty]
8: end for
9: end for
10: {81,...,8kk) 8K]
arg (t..iiggs............... E.es (ps))
11: â arg m EceL,, u...kaa I(A(c) = a)
return
31


Reviews:
[{"review_id": "3kicj6GgGb", "reviewer": "Reviewer_Bgbw", "summary": "This paper presents several insights about the length of reasoning chains within long chain-of-thought reasoning.", "questions": "1. If you were to refine the main claims of the paper based on what has already presented in the previous work that I cited, what do you think are the remaining most valuable insights?\n2. I'm not sure if the term \"scaling law\" is appropriate in this case. This is a bit of a nuance, but usually when we talk about \"large scale\" it's about things like data, compute, etc. and not some 10s of thousands of tokens in a reasoning trace. Maybe you could consider a different term here?", "limitations": "", "rating": 2, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. Overall the paper is pretty well written and I was able to follow the main points.\n2. The insight regarding step-wise computation also increasing for difficult instances is an interesting one that as far as I know as not covered extensively in previous papers.", "weaknesses": "The paper is mainly insight-driven, but as far as I can tell many of the insights presented in the paper have already been uncovered by previous work that was not cited:\n\n1. Insights related to long CoTs not being better are covered by Jiang et al., which was not cited.\n2. The idea of error accumulation in CoTs being responsible for long chains of thought being less successful was published in Schaeffer et al. 2023.\n3. Adaptive length-filtered voting was examined by Fu et al., which was cited in the paper but not cited in the appropriate section.\n\nReferences:\n- What Makes a Good Reasoning Chain? Uncovering Structural Patterns in Long Chain-of-Thought Reasoning. Jiang et al. EMNLP 2025.\n- Are Emergent Abilities of Large Language Models a Mirage? Schaeffer et al. NeurIPS 2023.\n- Complexity-Based Prompting for Multi-Step Reasoning. Fu et al. ICLR 2023.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "extra_scores": {}}, {"review_id": "C35wK9YIwS", "reviewer": "Reviewer_K7Ei", "summary": "This paper reveals that the performance of Chain-of-Thought (CoT) reasoning does not uniformly improve with length; rather, accuracy follows an inverted U-shaped curve. The authors demonstrate that an optimal CoT length exists, which is dependent on several factors:\n- Task Difficulty: More difficult problems require longer optimal CoT lengths to solve effectively.\n- Model Capability: The optimal length varies inversely with model capability. More capable models tend to favor shorter, more efficient reasoning paths.\n- Training Dynamics: Reinforcement Learning (RL) training can also induce this simplicity bias, guiding models to gravitate towards shorter, more optimal CoT lengths as their accuracy improves.\nBased on these insights, the authors propose a theoretical framework that models the trade-off between task decomposition and error accumulation. They demonstrate that this insight can be practically applied to achieve better accuracy by aligning models with this optimal length during both training and inference.", "questions": "1. The sampling of model sizes in Figure 2(a) is sparse, making the \"simplicity bias\" trend less conclusive (e.g., the 72B model's optimal length is slightly longer than the 32B's). Adding intermediate models, like the 14B, would help create a more convincing trend line. Additionally, adding the MOE model would be better.\n\n2. In Section 2, regarding the impact of RL on CoT length, an additional set of experiments using models of other scales should be included. The current results only demonstrate that RL can reduce CoT length. (While other studies have concluded that RL can increase CoT length, your intended proof here is not merely about whether CoT length increases or decreases, but rather that it converges to the optimal length—this requires verification through different trends in CoT length under different conditions.)\n\n3. In the current experiments, most only examine the model's performance at a specific CoT length by manually controlling the length (see Fig. 4). However, I am more curious about the difference between the CoT length independently chosen by the RL-trained model during inference (both before and after RL) and the optimal CoT length. Can it be experimentally demonstrated that sufficient RL training enables the CoT to converge to the true optimal length?\n\n4. Inconsistency in Figure 2: The caption for Figure 2(b) states it is \"with the 7B model,\" whereas the main text (line 152) references the \"Qwen1.5B-Instruct model\" when discussing this result. \n\n5. The definitions for symbols in the theoretical model could be strengthened. For instance, the constant 'C' introduced in Equation (1) (and later in Theorem 4.3) is defined somewhat informally.\n\n6. Recent related work about theoretical understanding of CoT: \"How Likely Do LLMs with CoT Mimic Human Reasoning?\" and \"Correlation or Causation: Analyzing the Causal Structures of LLM and LRM Reasoning Process\".", "limitations": "", "rating": 8, "confidence": 4, "soundness": 4, "presentation": 3, "contribution": 3, "strengths": "1. The paper is well-written, clearly organized, and easy to follow. The authors articulate their core argument effectively.\n2. The core finding is \"an optimal Chain-of-Thought (CoT) length exists\". This conclusion is convincingly demonstrated. The results of most experiments are very clear.\n3. This study not only analyzes the results, but also provides guidance for the reasoning process of practical models, which has also shown positive effects in experiments.", "weaknesses": "The controlled experiments described in Section 3 may be problematic because factors other than CoT length were altered. For instance, the long and short CoT solutions differ not only in total length but also in how they approach problem-solving: short CoTs take fewer but longer steps, whereas long CoTs take more but shorter steps. Since the paper measures CoT length by the number of steps and controls this variable in the experiments, variations in step length and the more complex operations used in shorter CoTs could act as confounding factors, weakening the validity of the claimed causal link between length and performance.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "extra_scores": {}}, {"review_id": "21L6wdSc99", "reviewer": "Reviewer_seMZ", "summary": "This paper addresses the question of how long chain of thought (CoT) reasoning should be to achieve optimal performance in LLMs. They find that the the ideal CoT length generally increases as tasks get harder, and generally decreases as models become larger. They develop synthetic experiments to support their hypothesis, and further demonstrate their findings on real-world tasks for large models.", "questions": "* I am missing some intuition on why RL is causing CoT length to go down (Figure 2c). What is happening to the model rollouts? Is it learning to merge steps, or do less backtracking, etc? \n* Similar question for Figure 4: what happens as the model goes from CoT length 24->5 - is it combining lots of steps together? \n* Figure 1b: for task difficulty 24, seems to only get better with more CoT length. does this level off?", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 4, "contribution": 4, "strengths": "* This paper is well-written. \n* As mentioned, the paper provides both synthetic and real-world tasks where the findings are observed. \n* The authors meaningfully point out that reasoning traces typically become longer (most prominently demonstrated by the Deepseek-R1 paper), yet they show evidence that in fact this does not always true (e.g. on Leetcode-2k). \n* The authors provide one important application of their work, which is to propose a novel majority voting mechanism weighted by reasoning length, which outperforms standard majority voting.\n\nOverall I think that this paper makes important contributions toward addressing the fundamental question of how long reasoning should be in LLMs, and has important implications for how to design LLMs with a specific reasoning budget.", "weaknesses": "My main concern is that I do not think the experimental setup adequately discusses how important reflection/backtracking is to the reasoning process, which I think the authors rightfully point out is present in \"real-world CoTs\" (Section 2, Appendix A.3). To frame it another way, the main question I am asking is: given that real-world models do self-correct, **how does self-correction/backtracking play a role in influencing the total length of the CoT**?\n* To my understanding, none of the synthetic setups (addition/dynamic programming) include some variant of verification/self-correction. The conclusion from the synthetic experiments seem to suggest more that  \"LLMs can perform multiple calculations in one step\", rather than \"LLMs _require_ only X steps to solve the full problem\". \n* I wonder if it would be possible to augment the synthetic setup with some \"mistake\" in the reasoning process. For example in the addition case, one could artificially inject a wrong addition step (1+2+3+4=_11_), then follow-up with some self-reflection token in the next step and provide the corrected step. I think it would be interesting to see how much noise you add to the trace influences the final optimal length. \n* I find Corollary 4.4 to be a little weak. It simply states that RL training optimizes for reward $A(N)$, which should be straightforward to see given that this is just the REINFORCE objective. The empirical analyses (Figure 2c, Fig 4) seem to suggest that CoT length keeps going down - I am wondering if the theory would say anything further about when CoT length goes up or down?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "extra_scores": {}}, {"review_id": "e162kcReeY", "reviewer": "Reviewer_pd7o", "summary": "The paper studies how CoT length affects accuracy and cost. It reports an inverted U-shaped relationship between CoT length and task accuracy: performance improves up to an optimal CoT length, then degrades due to error accumulation; the optimal length increases with task difficulty and decreases with model capability. The authors present (i) evidence on real LLMs (Qwen2.5 series) and synthetic setups (arithmetic, DP), (ii) an error-accumulation theory that yields a closed-form for the optimal length and scaling laws, and (iii) two applications: training with optimal-length CoTs and an inference-time Length-Filtered Vote that selects answers from near-optimal-length samples. They also show that RL can calibrate CoT length toward the optimum.", "questions": "See weakness", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "This paper studies an important problem about CoT length and the empirical analysis provides clear patterns: Multiple figures show the inverted-U accuracy vs. length and the stated scaling behaviors (harder tasks → longer optimal length; larger models → shorter optimal length). The well-controlled synthesis experiments are insightful.\n\nThe theoretical study strengthens the insight of this work: A compact error-accumulation model derives an explicit optimal length and recovers the empirical scaling laws.\n\nThe provided practical implication provides actionable takeaways and can inspire future study.\n\nOverall, this is a comprehensive and insightful paper combining both analysis and practical usage.", "weaknesses": "1. Missing experimental details, especially in Section 2.\n\na) The definition of CoT length is very vague, and the authors do not provide details of how to extract the length, such as whether use another model or parsing based on some rules.\n\nb) The definition of task difficulty also requires proper thought as the accuracy can be biased. For example, if the model favors more CoT steps on one harder question (the difficulty from a human's perspective) and achieves higher accuracy, while generating shorter steps for another simpler question and achieving lower accuracy. This can lead to the wrong problem difficulty. More proper ways include leveraging the dataset's own difficulty level, human judgment, advanced LLM's judgment and etc. \n\n2. There exists a concern about whether the optimal CoT length phenomenon on synthetic data can scale up to larger models. \n\na) The Arithmetic Problem seems to be too simple for advanced mdoels (maybe even for small-size models in the Qwen2.5 family), and I suspect that advanced models can solve these questions in one step and therefore make this dataset trivial. I suggest that the author extend the Arithmetic Problem from only addition to include more complex operators.\n\nb) The DP problem is interesting, and it is worth testing on more advanced models.\n\nc) The claim of per-step difficulty can benefit from more experiments. There may also exist an optimal per-step difficulty as the model can not handle sub-tasks with infinitely increasing difficulty (otherwise, one step is already optimal). This is crucial as it can guide how to define sub-tasks based on the difficulty.\n\n3. While the theoretical analysis is intuitive, it relies on strong assumptions that may only hold for the Arithmetic Problem. This is not a very critical problem, as I understand the difficulty in modeling CoT errors. However, the authors should explicitly mention the assumptions in the main paper; otherwise, people may be confused about why $\\sigma(T)$ and $E(N,M,T)$ are independent of the step index, and the sub-question error only relies on the total difficulty (in proposition 4.1). This concern arises because in practice, steps are generated autoregressively and later step depends on previous steps. Please make these clear.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)