Pith. sign in

REVIEW 3 major objections 4 minor 21 references

The paper proves that binary majority, triplet matching, and graph reachability each require Ω(n) chain-of-thought tokens in a constant-bandwidth model of transformer token generation, with matching upper bounds and empirical scaling consis

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-03 05:11 UTC pith:TE66YHR3

load-bearing objection Solid formal results within the BAPO model, but the hard-attention abstraction doesn't support the 'fundamental bottlenecks' claim for real transformers. the 3 major comments →

arxiv 2602.02909 v2 pith:TE66YHR3 submitted 2026-02-02 cs.AI cs.FLcs.LG

Reasoning about Reasoning: BAPO Bounds on Chain-of-Thought Token Complexity in LLMs

Kiran Tomlinson , Tobias Schnabel , Adith Swaminathan , Jennifer Neville This is my paper
classification cs.AI cs.FLcs.LG
keywords chain-of-thoughtBAPOtoken complexitylower boundsbinary majoritytriplet matchinggraph reachabilityreasoning compression
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper asks how many reasoning tokens an LLM fundamentally needs as input size grows, and answers it in a formal model. For three tasks known to resist single-step transformers—binary majority, triplet matching, and graph reachability—any chain-of-thought that respects constant per-step communication must produce at least a linear number of tokens. The lower bounds are proved by extending a communication-based abstraction of transformer steps, and they are matched or nearly matched by explicit constructions. The paper also exposes an input-doubling loophole in the original model and introduces a self-consistent variant that closes it. Experiments on frontier reasoning models show token counts scaling roughly linearly on these tasks and accuracy collapsing when reasoning budgets are capped, exactly the pattern the theory predicts.

Core claim

Under the bounded attention prefix oracle (BAPO) abstraction—where each generated token can carry only O(1) bits of prefix summary and attend to only O(1) tokens across any prefix/suffix split—the paper proves three impossibility results: MAJORITY on n bits has token complexity Ω(n), MATCH3_n over Z_{n^2} has token complexity Ω(n), and REACHABILITY on m-edge graphs has token complexity Ω(m). These mean no constant-bandwidth BAPO-CoT can solve all instances of these problems with sublinear reasoning tokens. Upper bounds complement the results: an O(n log n) cBAPO-CoT for MAJORITY, an O(n) cBAPO-CoT for MATCH3_n, an O(n^2) cBAPO-CoT for REACHABILITY, and a general Turing-machine-simulation bou

What carries the argument

The central object is the BAPO-CoT step: each autoregressive token is produced by a BAPO in which a prefix oracle f summarizes everything before a split into a bits, an attention function g selects at most b attended tokens, and a suffix oracle h combines both with the suffix. With a and b constant, only O(1) bits of global information can cross any cut per token, so the reasoning chain is the only channel for accumulating global information. The lower-bound technique plants masking tokens to force the same attended set on different inputs, uses pigeonhole over the finite set of prefix summaries to force an f-collision, and arranges suffixes so the two indistinguishable instances demand oppo

Load-bearing premise

The load-bearing premise is that a single transformer token-generation step can be modeled as a BAPO with constant prefix bandwidth and constant attention bandwidth; if real attention can communicate more than O(1) bits across an arbitrary prefix/suffix split, the linear lower bounds need not transfer to actual LLMs.

What would settle it

Exhibit a constant-bandwidth BAPO-CoT that solves any one of the three tasks on all length-n inputs with o(n) tokens—such an object would break the masking/pigeonhole argument. Alternatively, demonstrate in a real model a single token-generation step that reliably transmits ω(1) bits about a prefix of length n across a cut (for instance, an attention pattern whose output encodes the number of ones in the prefix), which would falsify the modeling assumption rather than the theorem.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • For MAJORITY, MATCH3_n, and REACHABILITY, any input-size-agnostic reasoning budget will eventually fail: a fixed cap on CoT tokens cannot solve large instances.
  • Because inference cost grows superlinearly in token count, these linear lower bounds translate into at least quadratic compute and latency scaling in input length for these tasks under the model.
  • Chain compression or brevity prompting can hope only for constant-factor savings on these problems; asymptotic linear reasoning is information-theoretically necessary.
  • The upper bounds show the lower bounds are tight or near-tight: MATCH3_n needs Θ(n) tokens, dense-graph REACHABILITY needs Θ(n^2), and MAJORITY sits between Ω(n) and O(n log n).
  • Empirically, frontier models exhibit approximately linear native reasoning token scaling on these tasks, and accuracy degrades sharply when the reasoning budget is too small—consistent with the proved lower bounds.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If BAPO's constant-bandwidth assumption accurately captures real transformer generation, the proof recipe suggests a general strategy for showing that other high-communication problems—connectivity, median, set intersection, or counting problems—also demand linear or worse token complexity; this is testable by applying the same masking-plus-collision construction.
  • The input-doubling loophole shows the original BAPO model is too permissive; the self-consistent cBAPO restriction is a modeling fix. An editorial extension: architectural changes that add external memory, retrieval, or tool calls violate the per-step constant-bandwidth assumption, so those are the natural places to look for breaking the linear barrier.
  • The experiments suggest models may already be performing BAPO-like decompositions internally. A testable extension is to measure whether explicit step-by-step prompting changes only the constant factor in token scaling, not the linear slope, and whether models can ever be trained to solve these tasks with sublinear chains.
  • The lower bounds are worst-case; an open and useful refinement would be average-case or instance-dependent token complexity, distinguishing easy instances (short paths, early matches) from hard ones.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper extends the bounded attention prefix oracle (BAPO) model, introduced in prior work, to multi-step chain-of-thought (CoT) generation and defines a formal notion of BAPO token complexity. Its main theoretical results are lower bounds of Ω(n) on the number of CoT tokens required by any constant-bandwidth BAPO-CoT for three problems: binary MAJORITY, MATCH3_n, and graph REACHABILITY (Theorems 4.1–4.3). The paper complements these with explicit cBAPO-CoT upper bounds (O(n log n) for MAJORITY, O(n) for MATCH3_n, O(n^2) for REACHABILITY), a general Turing-machine-simulation upper bound, and experiments with GPT-5.2 and Gemini 2.5 Pro showing roughly linear reasoning-token usage and accuracy loss under tight reasoning budgets. A new self-consistent restriction, cBAPO, is introduced to close the input-doubling loophole that otherwise lets any problem be solved in n+1 tokens.

Significance. If one accepts BAPO as a faithful abstraction of per-token information flow in transformers, the paper contributes a clean and non-trivial extension of prior BAPO-hardness results: it shows not only that certain problems require CoT, but that they require linearly many CoT tokens even under constant bandwidth. The lower-bound constructions are detailed, self-contained, and appear internally sound; the upper bounds are explicit algorithms, and the proofs are presented with care. However, the broader significance for real LLMs is conditional on the hard-attention abstraction in Definitions 2.1–2.2. That abstraction is in direct tension with standard softmax attention, which can compute aggregate statistics such as MAJORITY in one step by averaging over all prefix tokens. The paper does not address this tension, and its abstract and discussion claim 'fundamental bottlenecks' for LLM reasoning. The theoretical results are valuable within the BAPO model, but the transfer to actual transformer-based LLMs is a load-bearing assumption that is neither proved nor adequately discussed.

major comments (3)
  1. [Definitions 2.1–2.2; Theorems 4.1–4.3; Section 8] The lower bounds are theorems about BAPO, whose attention function returns a set of at most b attended token symbols and indices; the suffix oracle never receives a weighted combination of prefix tokens. Standard softmax attention is not of this form: a single attention head with uniform weights over the prefix produces the average bit value, and a linear readout decides MAJORITY in one step. Thus Theorem 4.1 does not apply to a vanilla transformer with softmax attention, and the paper's claim that these are 'fundamental bottlenecks' for LLM reasoning is unsupported. The paper should either justify why a hard-selection bandwidth captures the relevant information bottleneck (including aggregate statistics), or explicitly restrict all abstract/conclusion-level claims to the BAPO model. This is not an internal inconsistency in the proofs, but it is the load-bearing premise for the paper's s
  2. [Section 6, Figures 2–3] The experiments are presented as being 'consistent with our theoretical lower bounds,' but linear token usage by GPT-5.2 cannot distinguish the claim 'fewer tokens are information-theoretically impossible' from the claim 'the model happens to use a linear algorithm.' Accuracy degradation under word limits is observational and could be caused by instruction-following, model biases, or training choices, not by a communication bottleneck. Given the BAPO-to-transformer transfer problem in Definitions 2.1–2.2, the empirical section cannot carry the burden of validating the lower bounds for actual LLMs. At minimum, the authors should weaken the interpretation and, ideally, test a softmax-attention model on MAJORITY to see whether the predicted linear bottleneck actually appears.
  3. [Section 4.2, Proposition 4.4] The statement that constant-bandwidth BAPOs 'cannot in general be simulated by Turing machines' is true but essentially trivial: with an unbounded token alphabet Σ=N and an arbitrary suffix oracle h, a (0,0)-BAPO can decide an undecidable language by looking at the final token. The surrounding prose ('It was previously unknown whether constant-bandwidth BAPOs could be simulated by Turing machines at all. We resolve this question in the negative') overstates the conceptual content. The result depends on non-computable h and unbounded alphabets, which are not features of real transformers. Please rephrase so readers understand this is an artifact of the model's freedom, not a new barrier.
minor comments (4)
  1. [Appendix B] Typo in the opening sentence: 'defintion' should be 'definition.'
  2. [Section 3.1 / Table 1] The sentence 'cBAPO and BAPO models share the same lower bounds' is correct but initially confusing because the BAPO row in Table 1 shows n+1 upper bounds for all problems via the input-doubling loophole. Clarify that the lower bounds apply to both, while the upper bounds differ because the loophole is excluded in cBAPO.
  3. [Section 6 / Figures 2–4] The figures report means but no variance, error bars, or number of seeds. Since token counts on frontier API models can be highly variable, please add at least a variance measure or state the number of independent runs.
  4. [Theorem 5.6] The theorem states the construction uses Θ(n log n) CoT tokens and concludes an O(n log n) upper bound; the relationship to the Ω(n) lower bound is clear, but the paragraph after the theorem says 'this leaves a small gap'—consider stating explicitly that the gap is between Ω(n) and O(n log n), and that it is conjectured to be an artifact of a binary CoT alphabet.

Circularity Check

0 steps flagged

No significant circularity: the lower bounds are self-contained theorems in an explicitly assumed abstraction, and the experiments are not fitted inputs.

full rationale

The paper proves Theorems 4.1–4.3 by explicit indistinguishability constructions in Appendix A. These proofs do not invoke the theorems being proved; they assume only the stated BAPO-CoT definitions (Definitions 2.1–2.3) and use standard pigeonhole/adversarial masking arguments. No parameter is fitted to data, and the experimental scaling curves are reported after the theory as consistency checks, not used to set constants or to derive the bounds. The BAPO model itself and the BAPO-hard classification of MAJORITY, MATCH3, and REACHABILITY are cited to the same research group's prior work (Schnabel et al., 2025). However, the paper is explicit that BAPO is a postulate/abstraction ('postulates that LLMs are communication-bound') and its Limitations section states that 'BAPO-CoT is an abstraction of transformer computation... it does not model all features.' The lower-bound proofs are adapted from, but re-derive, the prior constructions for the CoT setting rather than reducing to the cited BAPO-hardness results. Lemma A.1 is a parameter-free auxiliary number-theoretic lemma with stated assumptions that do not include the target result. The transfer of the bounds to actual transformers is an unproven modeling assumption, but that is a stated limitation and a correctness/validity concern, not circular reasoning. The paper does not define its conclusions into its premises or rename a known empirical pattern as a new derivation.

Axiom & Free-Parameter Ledger

0 free parameters · 5 axioms · 2 invented entities

The central claim rests on the BAPO model and prior BAPO-hardness results from the same group; no numerical free parameters are fit. The cBAPO restriction is a new modeling assumption introduced to make upper bounds realistic.

axioms (5)
  • domain assumption A single transformer token-generation step is accurately modeled as an (O(1), O(1))-BAPO (bounded attention prefix oracle).
    Section 2: 'we rely on the recently introduced BAPO model (Schnabel et al., 2025) that postulates that LLMs are communication-bound.' The lower bounds apply to the model, not directly to transformers unless this holds.
  • domain assumption MAJORITY, MATCH3_n, and REACHABILITY are BAPO-hard under the BAPO model.
    Inherited from Schnabel et al. (2025); the lower-bound proofs in Appendix A adapt their hardness constructions. If these hardness classifications are wrong, the new token bounds lack their base.
  • standard math Pigeonhole principle and standard asymptotic analysis apply to finite prefix-oracle outputs.
    Used in Theorems 4.1–4.3 to force prefix-oracle collisions among the constructed prefixes.
  • standard math Turing machine simulation and the time hierarchy theorem (Hartmanis & Stearns 1965).
    Used in Sections 4.2 and 5.2 for general token-complexity upper bounds and the discussion of lower bounds via TM time.
  • domain assumption The cBAPO self-consistency restriction is the right way to prevent input-doubling while preserving transformer-like behavior.
    Section 5.1; this is a modeling choice, not proven from transformer mechanics.
invented entities (2)
  • cBAPO (self-consistent BAPO) no independent evidence
    purpose: Restrict the prefix oracle so that upper bounds on CoT token complexity are meaningful and the input-doubling loophole (Proposition 5.3) is closed.
    Introduced in Definition 5.2; its only support is the paper's own constructions and experiments, not an external benchmark.
  • BAPO-CoT token complexity (Definition 3.1) no independent evidence
    purpose: Formal measure of minimal worst-case CoT tokens under the BAPO model.
    A definitional abstraction; empirical relevance rests on the API experiments in Section 6.

pith-pipeline@v1.3.0-alltime-deepseek · 30515 in / 23821 out tokens · 242096 ms · 2026-08-03T05:11:44.753463+00:00 · methodology

0 comments
read the original abstract

Inference-time scaling via chain-of-thought (CoT) reasoning is a major driver of state-of-the-art LLM performance, but it comes with substantial latency and compute costs. We address a fundamental theoretical question: how many reasoning tokens are required to solve a problem as input size grows? By extending the bounded attention prefix oracle (BAPO) model--an abstraction of LLMs that quantifies the information flow required to solve a task--we prove lower bounds on the CoT tokens required for three canonical BAPO-hard tasks: binary majority, triplet matching, and graph reachability. We show that each requires $\Omega(n)$ reasoning tokens when the input size is $n$. We complement these results with matching or near-matching upper bounds via explicit constructions. Finally, our experiments with frontier reasoning models show approximately linear reasoning token scaling on these tasks and failures when constrained to smaller reasoning budgets, consistent with our theoretical lower bounds. Together, our results identify fundamental bottlenecks in inference-time compute through CoT and offer a principled tool for analyzing optimal reasoning length.

Figures

Figures reproduced from arXiv: 2602.02909 by Adith Swaminathan, Jennifer Neville, Kiran Tomlinson, Tobias Schnabel.

Figure 1
Figure 1. Figure 1: Overview of our modeling approach. An LLM autoregressively generates reasoning tokens s1, · · · sm to eventually produce an answer y. Each token generation step is modeled using a bounded attention prefix oracle (BAPO) with constant bandwidths; see Section 2.2 for a formal definition. To produce each st, information in a BAPO can cross an arbitrary prefix/suffix cut only through an a-bit summary and up to … view at source ↗
Figure 2
Figure 2. Figure 2: Reasoning token usage and accuracy with different reasoning levels for GPT-5.2. With no reasoning, accuracy quickly degrades to random chance. All reasoning levels achieve near-perfect accuracy, but with approximately linear scaling in the number of tokens used. Gemini 2.5 Pro exhibits much higher token usage and worse accuracy on MAJORITY; see [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Performance of GPT-5.2 with different CoT prompting approaches (all with reasoning effort = none to disable internal reasoning). With fixed word limits, performance degrades with input length. Both the plain and algorithmic CoT approaches allow performance to stay high, at the expense of approximately linear token cost. The poor performance of CoT for MAJORITY is due to refusals to do step-by-step counting… view at source ↗
Figure 4
Figure 4. Figure 4: Version of [PITH_FULL_IMAGE:figures/full_fig_p028_4.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

21 extracted references · 1 linked inside Pith

  1. [1]

    These disjoint sets store indices to place leading zeros and ones so that we foolgfor all suffixes

    InitializeΠ 0 =∅andΠ 1 =∅. These disjoint sets store indices to place leading zeros and ones so that we foolgfor all suffixes

  2. [2]

    Fan, S., Qin, B., Han, P., Shang, S., Wang, Y ., and Sun, A

    URLhttps://proceedings.mlr.press/ v267/chen25bx.html. Fan, S., Qin, B., Han, P., Shang, S., Wang, Y ., and Sun, A. The price of a second thought: On the evalua- tion of reasoning efficiency in large language models. arXiv preprint arXiv:2505.22017, 2025. URL https: //arxiv.org/abs/2505.22017v2. Feng, G., Zhang, B., Gu, Y ., Ye, H., He, D., and Wang, L. To...

    arXiv 2025

  3. [3]

    For eachj∈Π 0, setπ(i) =jand incrementi

    Leti= 1. For eachj∈Π 0, setπ(i) =jand incrementi. Makeπpermute leading zeros into the masking indices we have picked

  4. [4]

    findings-acl.1274/

    URL https://aclanthology.org/2025. findings-acl.1274/. Hartmanis, J. and Stearns, R. E. On the computa- tional complexity of algorithms.Transactions of the American Mathematical Society, 117:285–306,

    2025

  5. [5]

    Note that each time we run the while loops in 2(a)iiA and 2(a)iiB, we add at most b indices to Π0 and at most b indices to Π1

    Fill inπwhere not yet defined with the remaining indices in order. Note that each time we run the while loops in 2(a)iiA and 2(a)iiB, we add at most b indices to Π0 and at most b indices to Π1. Thus, across all times we run this loop, the final size of Π0 is at most b2ac∗|S|<2 2a+1bm (and likewise for Π1), so we have enough leading zeros and ones to mask ...

    2025

  6. [7]

    Initialize an empty CoTz ii

    For each possible prefix oracle outputf(x)∈ {0,1} a: (a) For each suffixs k ∈S: i. Initialize an empty CoTz ii. For each CoT stepi= 1, . . . , c∗: A. Whilemax i∈[22a+2bm+2a+1]\(Π0∪Π1) g0(sz, i)> bth(sz,Π 0,Π 1), add the maximizingitoΠ 0. Make sure the remaining indices withbhighest attention scores for0s have0s. B. Whilemax i∈[22a+2bm+2a+1]\(Π0∪Π1) g1(sz,...

  7. [9]

    For eachj∈Π 1, setπ(i) =jand incrementi

    Leti= 2 2a+1bm+ 1. For eachj∈Π 1, setπ(i) =jand incrementi. Makeπpermute leading ones into the masking indices we have picked

  8. [11]

    Consider the set of suffixes S={i: 0≤i≤a} , so |S|=a+ 1

    for allz∈Zand alls ′ ∈S,x+z+s ′ ̸≡m 0andy+z+s ′ ̸≡m 0. Consider the set of suffixes S={i: 0≤i≤a} , so |S|=a+ 1 . Since c(n) =o(n) , |S|=O(1) , a=O(1) , and b=O(1) , we can pick n sufficiently large so that2ac(n)b|S|< n/4−1 , n >10, and 2(a+1)< n/4. Let bth(sz, P∗) be the bth largest attention score g outputs with suffixsz on any token inP ∗. Let X(P ∗) ={...

  9. [12]

    InitializeP ∗ ={(⌊n 2/3⌋),1}andI={1} We’ll use⌊n 2/3⌋as filler; placing it inP ∗ here ensures it doesn’t match any prefix integer

  10. [13]

    Initialize empty CoTz ii

    For each possible prefix oracle outputf(x)∈ {0,1} a: (a) For each suffixs∈S: i. Initialize empty CoTz ii. For each CoT stepi= 1, . . . , c(n): A. While maxx∈X(P ∗),i∈[n−1]\I g(sz, n−1, x, i)> bth(sz, P∗): add the maximizing (x, i)to P ∗ and add i toI. Check all feasible integers that we could add to the prefix and ensure the b feasible integers with large...

    2025

  11. [14]

    InitializeSto be the set of alls i andu ij nodes, which will store the current set of nodes that still need an outgoing edge

    InitializeP ∗ to have the same set of nodes asP. InitializeSto be the set of alls i andu ij nodes, which will store the current set of nodes that still need an outgoing edge

  12. [15]

    Initialize empty CoTz ii

    For each possible prefix oracle outputf(x)∈ {0,1} a: (a) For each pair(i, j)∈[p]×[p]: i. Initialize empty CoTz ii. For each CoT stepi= 1, . . . , c(m): A. While maxu∈S,v∈next(u,P ∗) g(sitj, m, I(u),(u, v))> bth(sitj, P∗): add the maximizing edge (u, v)to P ∗ and removeufromS. Ensure the top b still-feasible edges that have highest attention scores under g...

    2025

  13. [16]

    If chunk(m) = 0, output (we will write the true initial state to chunk 1)

  14. [17]

    If chunk(m) = 1, set up the initial chunk: (a) ifi=ℓ−1, outputq 0 (b) else if(i−1) mod (n+s(n)) = 0, outputy {1,...,η} m−ℓ , (c) else outputy ∅ m−ℓ

  15. [18]

    otherwise, chunk(m)>1 . The suffix oracle knows the bits under every head and the current TM state, so it can compute the new state q′, the directions of each head, and the bits to be written on each tape under each head (resolving conflicts in head-order, just likeM). (a) if M has halted, then if q′ =q accept: if ym is not 1, return 1, otherwise return □...

  16. [19]

    Ifi= 1: ifj= 0, then outputy i, otherwise output0.(Initialize the counter to the first bit of the input.)

  17. [20]

    ify i = 0, then outputy m−⌈log2 n⌉ (replacing0 c with0).(No counter update.) ii

    Else ifi≤n: (a) ifj= 0: i. ify i = 0, then outputy m−⌈log2 n⌉ (replacing0 c with0).(No counter update.) ii. Ify i = 1, then output1 +y m−⌈log2 n⌉ (using0 c if the result is 2).(Increment the counter, storing carry.) (b) Else j >0. Output ym−⌈log2 n⌉ (treating 0c as 0), adding 1 if ym = 0c (and outputting 0c if the result would be 2). (Copy with carry to u...

  18. [21]

    still checking,

    Else i > n. We need to check if the counter is strictly larger than ⌊n/2⌋. Let (⌊n/2⌋)j denote the jth bit of ⌊n/2⌋ in big-endian order when written with ⌈log2 n⌉ bits (i.e., j= 0 gives the bit in the 2⌈log2 n⌉−1s place, the most significant bit). To check that the counter is at least ⌊n/2⌋, we can compare ym−j−1 to (⌊n/2⌋)j, which will check bits of the ...

    2025

  19. [1965]

    Lee, A., Che, E., and Peng, T

    URL https://doi.org/10.1090/S0002- 9947-1965-0170805-7. Lee, A., Che, E., and Peng, T. How well do LLMs com- press their own chain-of-thought? A token complexity approach.arXiv preprint arXiv:2503.01141, 2025. URL https://arxiv.org/abs/2503.01141. Li, Z., Liu, H., Zhou, D., and Ma, T. Chain of thought empowers transformers to solve inherently serial prob-...

    Pith/arXiv arXiv 1965

  20. [2023]

    Han, T., Wang, Z., Fang, C., Zhao, S., Ma, S., and Chen, Z

    URLhttps://proceedings.mlr.press/ v202/giannou23a.html. Han, T., Wang, Z., Fang, C., Zhao, S., Ma, S., and Chen, Z. Token-budget-aware LLM reasoning. InACL Findings,

  21. [2025]

    Chen, X., Xu, J., Liang, T., He, Z., Pang, J., Yu, D., Song, L., Liu, Q., Zhou, M., Zhang, Z., Wang, R., Tu, Z., Mi, H., and Yu, D

    URLhttps://proceedings.mlr.press/ v267/bavandpour25a.html. Chen, X., Xu, J., Liang, T., He, Z., Pang, J., Yu, D., Song, L., Liu, Q., Zhou, M., Zhang, Z., Wang, R., Tu, Z., Mi, H., and Yu, D. Do NOT think that much for 2+3=? On the overthinking of long reasoning models. InICML,