Boule or Baguette? A Study on Task Topology, Length Generalization, and the Benefit of Reasoning Traces

William L. Tong; Ege Cakar; Cengiz Pehlevan

cs.AIFeb 16, 2026

Boule or Baguette? A Study on Task Topology, Length Generalization, and the Benefit of Reasoning Traces

Authors: William L. Tong, Ege Cakar, Cengiz Pehlevan

Organizations: School of Engineering and Applied Sciences, Harvard University · Kempner Institute for the Study of Artificial and Natural Intelligence, Harvard University · Center for Brain Sciences, Harvard University

Abstract

Recent years have witnessed meteoric progress in reasoning models: neural networks that generate intermediate reasoning traces (RTs) before producing a final output. Despite the rapid advancement, our understanding of how RTs support reasoning, and the limits of this paradigm, remain incomplete. To promote greater clarity, we introduce PITA: a novel large-scale dataset of over 23 million statements in propositional logic and their corresponding proofs. As a benchmark for robust reasoning, we focus on length generalization: if a model is trained to determine truth or falsity on statements with proofs up to fixed length, how well does it generalize to statements requiring longer proofs? We propose notions of (1) task depth and (2) task breadth, which measure respectively (1) the number of steps required to solve an example from a task and (2) the number of unique examples across a task. We vary these quantities across subsets of PITA, and find that RT models generalize well on broad and shallow subsets, while deteriorating on narrow and deep subsets relative to non-RT baselines. To determine whether our results are idiosyncratic to PITA or indicative of general phenomena, we compare our results to a simple synthetic task based on syllogisms. Our resulting theory suggests fundamental scalings that limit how well RT models perform on deep tasks, and highlights their generalization strengths on broad tasks. Our findings overall identify fundamental benefits and limitations inherent in using reasoning traces.

Figures & tables

Figure 1: The PITA dataset. (a) Statements and proofs are expressed in Lean. Tactics are Lean commands that transform sets of propositions. A proof is an alternating sequence of tactics and proof states, which terminates in a special token indicating whether the statement is true or false. (b) Inputs are formatted as prompt-completion pairs, where losses are computed only on completion tokens. The DP model’s completion consists only of the special classification token. The RT model’s completion includes the whole proof. (c) Breadth of each split, plotted as the the total number of unique examples that can be enumerated for a particular statement size (where size is the number of atoms in that statement). (d) Depth of each split, plotted as the number of unique proof states. Boxplots are constructed from 500 samples from each split, and illustrate the median and quartiles. Outliers are determined from 1.5 times the inter-quartile range. For additional details on our splits and how we measure them, see Appendix C .

Figure 2: Generalization accuracy on PITA splits. Models are trained up to median proof length of their respective splits, then evaluated on longer examples. The dashed line marks chance level performance, where chance is calculated as the test accuracy attained through random guessing with probability equal to the proportion of true/false examples in the training distribution. Because true/false proportion may vary widely between train and test distributions, chance level is sometimes substantially below 50 percent, as in Imply . RT models typically outperform DP models on breadth-dominated splits ( Full and Imply ), while the reverse is true for depth-dominated splits ( Or and PHP ). Due to the computational constraints, the largest trainable model is 7B for PHP and 32B for all others. Boxplots are constructed from 10 runs, where each model is evaluated on 100 test samples. Box lines illustrate the median and quartiles. Outliers are determined from 1.5 times the inter-quartile range.

Figure 3: Transitive inference task. (a) Illustration of the TI task. Symbols are arranged in a series of parallel branches, each consisting of a line of inferences. Breadth is parameterized by the number of branches $B$ , while depth is parameterized by the number of symbols in a branch $D$ . (b) Generalization accuracy for fixed depth $D=30$ and varying breadth. The red dashed line indicates the max training length. Generalization accuracy for the DP model decays quickly with breadth, while remaining consistently high for the RT model. Shaded error regions correspond to 95 percent confidence intervals estimated from six seeds. (c) Heatmaps of training accuracy for varying depth, breadth, and model size for the full model described in Section 3.2 . Scalings are plotted in cyan, and agree closely with the high accuracy contours.

Prompt	Gen. acc.	Depth	Breadth
DP	$\alpha_{g}\propto B^{-2}$	$D\propto H$	$B\propto H^{2}$
RT	$\alpha_{g}\propto 1$	$D\propto\sqrt{H}$	$B\propto H^{2}$

Table 1: Empirical scalings for the transitive inference task . We observe that generalization accuracy

\alpha_{g}

decays proportional to

B^{-2}

for DP, but remains flat for RT (see also Figure 7 ). The depth and breadth scalings characterize the high training accuracy contour in depth- and breadth-dominated settings. For example, the scaling

B\propto H^{2}

can be interpreted as: if model width

H

doubles, then the model maintains high accuracy on tasks up to 4x broader. Our theoretical analysis suggests the origin of these scalings, and is detailed in Appendix B .

Appendix figures & tables9 assets

Supplementary material from the paper’s appendix.

Appendix

$p$	$q$	$p\wedge q$	$p\vee q$	$p\rightarrow q$
T	T	T	T	T
T	F	F	T	F
F	T	F	T	T
F	F	F	F	T

Appendix

Table 2: Truth assignments for logical connectives in PITA . For propositional variables

p

and

q

with the indicated truth assignment, we record the output of each connective.

Figure 4: Attention weights are uniform. We show empirically that the attention weights become uniform in a Transformer trained on our transitive inference task. (a) In blue , total variation distance (TVD) between a uniform distribution and the attention weights in an RT model, measured across 1000 examples. The x-axis indicates the position of the query token. In orange , the probability assigned to each position by a uniform distribution, plotted for comparison. The TVD is very close to zero across all positions, indicating that the attention weights are close to uniform. (b) Left , an example attention matrix from the RT model. Right , attention matrix with uniform entries, plotted for comparison. (c) Histogram of TVD between a uniform distribution and attention weights in a DP model at position 2 (the output position for a DP model), measured across 1000 examples. In orange , the probability assigned to position 2 by a uniform distribution (which is 0.5). As in (a), the TVD is fairly close to 0. (d) The same as (b), plotted with the DP model.

Figure 5: Trained models learn the max margin solution. We plot the kernel density estimate (KDE) over the proportion of positive, estimated sample coordinates per task branch in ( left ) a direct-prediction model and ( right ) reasoning trace model. The proportion is indexed by the x-axis. The y-axis indexes the readout weight of the corresponding weight vector, from which the sample coordinates are estimated. For positive readout weights, we see that proportions are bimodal around 0 and 1. As the readout weight becomes negative, proportions tend to coalesce in a single range. These observations are consistent with implementing a max margin solution. Given a weight vector

\mathbf{w}_{i}

and symbol embedding

\mathbf{x}_{j}

, the corresponding sample coordinate is estimated as

c_{j}^{i}=\mathbf{w}_{i}\cdot\mathbf{x}_{j}

Figure 6: Number of large sample coordinates increases with task breadth. We compare across 20 models trained with varying task breadth, and estimate the sample coordinates from the weight vector corresponding to the largest positive readout weight. We determine that a sample coordinate is large if its magnitude is greater than 2 standard deviations from zero, compared across all other sample coordinates extracted from the weight vector. In both DP and RT models, we measure a strong linear relationship between task breadth and the number of large coordinates, supporting our conjecture about how models distribute sample coordinates to attain faster breadth-wise scaling.

Figure 7: Generalization in the direct prediction model. Left , we train 100 DP models with

B=50

D=10

, and training distance

k=5

, then measure the false negative rate (FNR) on classifications for

k>5

. FNR is very close to 1, supporting our assertion that logits become very negative when the DP model operates on longer distances. Right , we measure the rate at which test accuracy falls as a function of task breadth, across varying test distances. Particularly for large test distances, the rate is close to our predicted

B^{-2}

rate. Shading corresponds to 95 percent intervals estimated from 6 independently trained models each evaluated on 1000 examples.

Figure 8: Generalization accuracy in Gemma 3 on PITA splits. The setting is the same as in Figure 2 , but evaluated on a selection of the Gemma 3 family of models ( Team et al., 2025 ) . The trends are the same as observed for Qwen2.5-Coder, in which shallow and wide boule-shaped splits favor RT models, while the reverse is true for deep and narrow baguette-shaped splits. Computational constraints prevent training models larger than 10B on PHP . Boxplots are constructed from 10 runs, where each model is evaluated on 100 test samples. Box lines illustrate the median and quartiles. Outliers are determined from 1.5 times the inter-quartile range.

Figure 9: Generalization accuracy in Llama 3 series on PITA splits. The setting is the same as in Figure 2 , but evaluated on a selection of the Llama 3 family of models ( Grattafiori et al., 2024 ) . The trends are the same as observed for Qwen2.5-Coder, in which shallow and wide boule-shaped splits favor RT models, while the reverse is true for deep and narrow baguette-shaped splits. Boxplots are constructed from 10 runs, where each model is evaluated on 100 test samples. Box lines illustrate the median and quartiles. Outliers are determined from 1.5 times the inter-quartile range.

Figure 10: Accuracy breakdown for Qwen2.5-Coder models. For each combination of split, model size, and input format, we plot the generalization accuracy breakdown between true positives (TP), false positives (FP), true negatives (TN), false negatives (FN), and examples for which the model does not terminate within the max context length (None). The proportion of negative examples witnessed during generalization is typically higher than the proportion witnessed during training. Hence, models frequently commit false positives, but using a reasoning trace appears to lesson this bias. However, RT models tend not terminate, and a large portion of their error appears to stem from this failure to terminate.

Figure 11: Generalization performance on TI task for different input formats. We compare generalization accuracy across several possible input formats in RT and DP models. Full RT corresponds to the full enumeration over branch symbols used in the main text. Short RT terminates the enumeration if the first input symbol is recovered. With inv includes inverted negative examples. For example, if

s_{1}\rightarrow s_{2}

is a valid relation, then

s_{2}\rightarrow s_{1}

would be an inverted negative example. The results presented in the main text are with full RT and no inverted negative examples (first and fourth rows). Alternative input formats tend to do worse. In particular, truncating the reasoning trace early substantially worsens performance. Shaded error regions correspond to 95 percent intervals estimated from 3 seeds.

Length Generalization

Length generalization studies whether sequence models trained on short inputs can reliably solve the same tasks on longer sequences.

See all 47 papers

May 14, 2026

Reasoning Models Don't Just Think Longer, They Move Differently

Reasoning-trained language models often spend more tokens on harder problems, but longer chains of thought do not show whether a model is merely computing for more steps or following a different internal trajectory. We study this distinction through hidden-state trajectories during chain-of-thought generation across competitive programming, mathematics, and Boolean satisfiability. Raw trajectory geometry is strongly shaped by generation length: longer generations mechanically alter path statistics, so difficulty-dependent comparisons are misleading without adjustment. After residualizing trajectory statistics on length, difficulty remains systematically coupled to corrected trajectory geometry across all domains studied. The clearest reasoning-specific separation appears in the code domain, where harder problems show more direct corrected trajectories and less heterogeneous local curvature in reasoning-trained models than in matched instruction-tuned baselines. Corrected difficulty-geometry coupling is weaker, but still present, in mathematics and Boolean satisfiability. Prompt-stage linear probes do not mirror the code-domain separation, and behavioral annotations show that stronger corrected coupling co-occurs with strategy shifts and uncertainty monitoring. Together, these findings establish length correction as a prerequisite for generation-time trajectory analysis and show that reasoning training can be associated with distinct corrected trajectory geometry, with the strength of the effect depending on the domain.

Anders Gjølbye, Lars Kai Hansen, Sanmi Koyejo

Technical University of Denmark · Stanford University

LLM Interpretability Representation Geometry in Language Models Algorithmic Reasoning LLM Reasoning Large Reasoning Models Reasoning Trace Analysis

Ask PDF

Jun 1, 2026

Thinking Past the Answer: Evaluating Harmful Overthinking in Large Reasoning Models

Large Reasoning Models (LRMs) improve performance by generating explicit intermediate reasoning traces through increased test-time compute, yet the assumption that longer reasoning is consistently beneficial remains under-examined. While recent evidence shows that additional reasoning can lead models to overthink, we ask: "Once a model has reached the correct answer, does further reasoning refine the solution, or deviate from it?" To study the dynamics after correctness, we introduce a prefix-level trajectory evaluation protocol grounded in reasoning sufficiency, defining the minimum reasoning budget required for a model to first generate the correct answer. This allows us to disentangle verbose overthinking, where additional reasoning is redundant but harmless, from harmful overthinking, where continued reasoning destabilizes an already-correct trajectory. Starting from multimodal benchmarks, we find that many instances considered reasoning-intensive require surprisingly little reasoning. Moreover, stopping at the first correct prefix improves accuracy over standard reasoning up to 21%, revealing that current models are limited not only by their ability to reason, but also by their inability to stop at the right time. Furthermore, while common efficiency strategies like early stopping substantially reduce verbose overthinking (up to 50%), they fail to mitigate harmful overthinking. Failure analysis reveals that correctness deviations are mainly driven by logical drift and visual reinterpretation. Finally, we show that our findings generalize to language-only reasoning benchmarks, highlighting harmful overthinking as a broader reliability risk. Code available at https://simonecaldarella.github.io/thinking-past-the-answer.

Simone Caldarella, Davide Talon, Rahaf Aljundi +2

University of Trento · 3Fondazione Bruno Kessler · 2Toyota Motor Europe

LLM Evaluation Overthinking in Language Models Reasoning Evaluation LLM Reliability Large Reasoning Models Reasoning Trace Analysis

Ask PDF

Apr 1, 2026

Procedural Knowledge at Scale Improves Reasoning

Test-time scaling has emerged as an effective way to improve language models on challenging reasoning tasks. However, most existing methods treat each problem in isolation and do not systematically reuse knowledge from prior reasoning trajectories. In particular, they underutilize procedural knowledge: how to reframe a problem, choose an approach, and verify or backtrack when needed. We introduce Reasoning Memory, a retrieval-augmented generation (RAG) framework for reasoning models that explicitly retrieves and reuses procedural knowledge at scale. Starting from existing corpora of step-by-step reasoning trajectories, we decompose each trajectory into self-contained subquestion-subroutine pairs, yielding a datastore of 32 million compact procedural knowledge entries. At inference time, a lightweight in-thought prompt lets the model verbalize the core subquestion, retrieve relevant subroutines within its reasoning trace, and reason under diverse retrieved subroutines as implicit procedural priors. Across six math, science, and coding benchmarks, Reasoning Memory consistently outperforms RAG with document, trajectory, and template knowledge, as well as a compute-matched test-time scaling baseline. With a higher inference budget, averaged across models and tasks, it improves over no retrieval by 19.5% and over the compute-matched baseline by 8.9%. Ablation studies show that these gains come from two key factors: the broad procedural coverage of the source trajectories and our decomposition and retrieval design, which together enable effective extraction and reuse of procedural knowledge. Our experiment code is available at https://github.com/facebookresearch/reasoning-memory.

Di Wu, Devendra Singh Sachan, Wen-tau Yih +1

University of California, Los Angeles · Meta FAIR

Retrieval-Augmented Reasoning LLM Reasoning Knowledge Augmentation for Language Models Structured Reasoning in Language Models Memory-Augmented Language Models

Ask PDF

Abstract

Length Generalization

Explore similar work

Reasoning Models Don't Just Think Longer, They Move Differently

Thinking Past the Answer: Evaluating Harmful Overthinking in Large Reasoning Models

Procedural Knowledge at Scale Improves Reasoning