Tracing Error Propagation in Reasoning Language Models¶
Conference: EMNLP 2026
Paper: ACL Anthology
Area: LLM Reasoning
Keywords: Reasoning Language Models, Error Propagation, Hidden State Probing, Counterfactual Resampling, Prefix Resampling
TL;DR¶
This paper investigates the latent dynamics of error propagation in reasoning language models (RLMs), demonstrating that step errors diffuse into local neighboring states, final-step representations distinctly separate recoverable from unrecoverable failures, and the original persistent error can be retrospectively decoded from final states to guide token-efficient prefix resampling.
Background & Motivation¶
The emergence of reasoning language models (RLMs) such as DeepSeek-R1 and o1—which are explicitly post-trained to produce long, granular, and deliberative Chain-of-Thought (CoT) traces prior to generating final answers—has enabled remarkable breakthroughs across complex mathematical, scientific, and multi-hop logical reasoning benchmarks. However, generating long reasoning trajectories introduces a structural failure mode: errors can surface at any intermediate juncture, and once an early logical fallacy, unsupported deduction, or calculation slip occurs without immediate correction, subsequent reasoning steps inevitably compound upon a flawed premise. This enables mistakes to propagate silently across dozens of reasoning steps until they culminate in a catastrophic breakdown at the final answer.
Prior attempts to identify and mitigate reasoning breakdowns have predominantly relied on static surface-level taxonomies, outcome-based majority voting, external verifiers, or process reward models (PRMs) trained on step-level text annotations. While useful for candidate filtering or rejection sampling, these approaches remain confined to observable textual outputs or isolated step-level slices. Critically, existing paradigms fail to distinguish between transient, recoverable errors (where the model retains valid continuation paths capable of reaching the correct answer) and unrecoverable errors (which steer the reasoning trajectory into an irreversible failure state). Treating every error uniformly results in immense computational inefficiency: continuing generation on unrecoverable traces wastes valuable inference compute, while prematurely aborting recoverable traces discards viable reasoning trajectories.
To genuinely diagnose and resolve reasoning breakdowns, the analysis must penetrate beyond surface text into the latent dynamics of the model's internal representations. The authors hypothesize that hidden states capture the underlying mechanics of error genesis and accumulation, encoding early warning signals before mistakes manifest explicitly and retaining historical traces of failure origins even after long chains of subsequent generation. Core idea: by rigorously operationalizing persistent errors and unrecoverable boundaries via counterfactual resampling, lightweight hidden-state probes demonstrate that reasoning errors exhibit local neighborhood diffusion, imprint distinct separability between recoverable and unrecoverable traces in final-step representations, and permit retrospective decoding of the root error source—enabling probe-guided prefix resampling that recovers accuracy at substantially lower token cost.
Method¶
Overall Architecture¶
The framework establishes an analytical and diagnostic pipeline to systematically model how reasoning errors originate, persist, and cascade within RLMs. Given an input query \(q\) and a generated reasoning trace \(s_{1:T} = (s_1, s_2, \dots, s_T)\), each step's internal representation \(h_t \in \mathbb{R}^d\) is extracted via average pooling over the model's last-layer hidden states across all tokens in step \(s_t\). Counterfactual rollouts are then executed to compute empirical recovery probabilities across intermediate prefixes, formally demarcating the earliest persistent error step \(t^*_{\text{pers}}\) and the unrecoverable boundary \(\hat{t}^*_{\text{unre}}\). Based on these grounded anchors, lightweight multi-layer perceptron (MLP) probes are trained to conduct three foundational investigations: (1) local step-level error prediction across neighboring contexts, (2) trace-level binary classification separating recoverable from unrecoverable failure trajectories at the final step, and (3) retrospective decoding of the persistent error origin using the final-step representation. Finally, these diagnostic probes are deployed in a closed-loop inference policy that performs error-aware prefix truncation and targeted resampling.
%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
A["Input Query q & Reasoning Trace s_1:T"] --> B["Step Hidden Representation Extraction<br/>Average pooling of last-layer tokens into h_t"]
B --> C["Persistent & Counterfactual Unrecoverable Boundary Grounding"]
C --> D["Local Neighborhood Error Diffusion Probing"]
D --> E["Trace-Level Recoverability Classification at Final Step"]
E --> F["Retrospective Tracing of Persistent Error Source"]
F --> G["Probe-Guided Error-Aware Prefix Resampling"]
Key Designs¶
1. Persistent & Counterfactual Unrecoverable Boundary Grounding: Decoupling local mistakes from irreversible cascades
To formalize error dynamics beyond isolated step errors, the authors distinguish between localized errors and cumulative trace corruption. Let \(e_t \in \{0, 1\}\) denote whether step \(s_t\) contains an explicit localized reasoning error, and let \(c_t \in \{0, 1\}\) denote whether the prefix \(s_{1:t}\) contains errors that compromise the validity of the reasoning trace. The persistent error step \(t^*_{\text{pers}}\) is defined as the earliest step from which the observed trace remains continuously corrupted until the end: \(t^*_{\text{pers}} = \min \{ t \in \{1, \dots, T\} \mid \forall t' \ge t, c_{t'} = 1 \}\). To move beyond the randomness of a single observed sample, the authors formalize prefix recoverability \(\rho_t\) as the true probability that the model reaches the correct final answer \(y^*\) when sampling continuations conditioned on the corrupted prefix \(s_{1:t}\): \(\rho_t = \Pr_{s_{t+1:T}, y \sim \pi_\theta(\cdot \mid q, s_{1:t})}(y = y^*)\). With a finite resampling budget of \(R\) rollouts, the empirical recoverability \(\hat{\rho}_t = \frac{1}{R}\sum_{r=1}^R \mathbb{I}(y^{(r)} = y^*)\) is computed, defining the empirical unrecoverable point \(\hat{t}^*_{\text{unre}} = \min \{ t \in \{1, \dots, T\} \mid \hat{\rho}_t \le \epsilon \}\). This establishes three distinct operational regimes: immediate unrecoverability (\(\hat{t}^*_{\text{unre}} = t^*_{\text{pers}}\)), delayed unrecoverability (\(\hat{t}^*_{\text{unre}} > t^*_{\text{pers}}\)), and persistent error with recoverable trace (\(\hat{t}^*_{\text{unre}}\) undefined under threshold \(\epsilon\)).
2. Local Neighborhood Error Diffusion Probing: Uncovering bidirectional leakage across hidden states
To determine whether error signals are tightly localized to the failure step or diffuse into neighboring representations, the framework evaluates offset-based and context-only probing. For relative offsets \(k \in [-5, +5]\), an MLP probe is trained to take the current step's representation \(h_t\) and predict the error label \(e_{t+k}\) of neighboring step \(s_{t+k}\). The MLP architecture projects \(d \to 256 \to 64 \to 1\) with LayerNorm, ReLU, and 0.3 dropout. To eliminate information leakage from the target step itself, the context-only configuration evaluates ensembled representations across a temporal window of radius \(w\), formally defined as \(H_{t,w}^{-t} = \{h_{t+k} \mid -w \le k \le w\} \setminus \{h_t\}\). By feeding concatenated or mean-pooled contextual vectors into the probe, the results confirm that even without seeing \(h_t\) itself, the surrounding representation window predicts step-level errors with an AUC exceeding 0.90, demonstrating that the internal cognitive failure begins bleeding into latent states steps before and after the observable textual failure.
3. Trace-Level Recoverability Classification at Final Step: Decoding failure irreversibility fingerprints
Conventional outcome verifiers assume all failed traces reside in an identical incorrect state at termination. This work challenges that assumption by examining whether the final-step hidden representation \(h_T\) encodes qualitative differences between recoverable and unrecoverable failures. Separate MLP probes are trained on \(h_T\) for pairwise classification among three trajectory classes: Correct, Recoverable, and Unrecoverable. The probe optimizes binary cross-entropy loss over balanced splits. The separability achieved between Recoverable and Unrecoverable traces confirms that unrecoverable failures induce a distinct, irreversible geometric shift in the latent activation space at step \(T\), signifying that the model's internal state carries a structural footprint reflecting whether the trace was permanently derailed or simply sampled an unfortunate continuation.
4. Retrospective Tracing of Persistent Error Source: Reverse-indexing failure origins from termination states
Given a failed trajectory, locating where the breakdown began typically requires exhaustive evaluation across every intermediate step. This paper introduces retrospective tracing, which tests whether the final-step representation \(h_T\) preserves sufficient historical information to identify the original persistent error \(t^*_{\text{pers}}\). For each candidate step \(s_t\), a joint representation is constructed using either concatenation \([h_t \parallel h_T]\) or vector difference \((h_T - h_t) \in \mathbb{R}^d\). An MLP probe is trained to classify whether candidate step \(t\) corresponds to \(t^*_{\text{pers}} + k\) for offsets \(k \in [-3, +3]\), treating all other steps in the trace as negative samples. The probe score exhibits a sharp peak precisely at \(k=0\) with bounded MRR up to 0.885, proving that the cumulative forward pass in Transformer architectures acts as a lossy but decodable memory channel that retains the precise coordinates of the initial structural fault.
5. Probe-Guided Error-Aware Prefix Resampling: Accelerating test-time scaling through targeted truncation
Leveraging both trace-level and retrospective probes, the authors formulate a token-efficient prefix resampling policy designed to replace brute-force repeated sampling (such as standard Self-Consistency or Best-of-N). Given an initial generation budget of \(N=5\), the trace-level probe first inspects the final hidden state \(h_T\) of the generated trace. If flagged as erroneous, the retrospective tracing probe ranks all candidate steps in the trajectory. The top-5 candidate steps with the highest error probabilities are retrieved, and the earliest detected failure step \(\hat{t}^*_{\text{pers}}\) is selected. The trajectory is truncated immediately prior to this step (\(s_{1:\hat{t}^*_{\text{pers}}-1}\)), and new rollouts are generated strictly from this pristine prefix. This process iterates until the trace passes the trace-level verifier or the sampling budget is exhausted, successfully salvaging reasoning trajectories while avoiding the token overhead of regenerating correct prefixes from scratch.
Benchmark & Evaluation Protocol¶
The empirical investigation is conducted on the CHAINED benchmark (Lu et al., 2026a), which provides step-level (\(e_t\)) and cumulative (\(c_t\)) human/expert-validated annotations on Multi-hop QA (MuSiQue) and complex logical reasoning (BIG-Bench Hard). Experiments evaluate three foundational models: DeepSeek-R1-Distill-Llama-8B (DSR8B), Qwen2.5-7B-Instruct (Qwe7B), and Llama-3.1-8B-Instruct (Lla8B). To examine architectural generalization, the authors expand the dataset to three modern models from the Qwen3 family: Qwen3-4B, Qwen3-8B, and Qwen3-14B, generating additional rollouts on H100 GPUs via vLLM with UCB-guided Monte Carlo search and binary trace slicing (\(K=16\)). Probes are trained with Adam (\(lr = 3 \times 10^{-4}\), weight decay \(1 \times 10^{-5}\)) for up to 100 epochs using ReduceLROnPlateau. Evaluation metrics include AUC, F1, Recall@K, Mean Reciprocal Rank (MRR), and bounded MRR (b-MRR), which restricts candidate ranking strictly to steps preceding the target error to prevent downstream contaminated steps from confounding rank evaluations.
Key Experimental Results¶
Main Results¶
The primary experiments demonstrate that final-step hidden representations reliably separate recoverable from unrecoverable failures (Table 4) and accurately decode the persistent error origin step \(t^*_{\text{pers}}\) (Table 5).
| Model | Evaluation Setting / Target | Key Metrics (AUC / bMRR / R@1) | Baseline / Random Reference | Performance Summary |
|---|---|---|---|---|
| DSR8B | Trace-level: Recoverable ↔ Unrecoverable | AUC: 0.877 / F1: 0.743 | Random: 0.500 | Unrecoverable failures exhibit distinct latent geometry at final step |
| Qwe7B | Trace-level: Recoverable ↔ Unrecoverable | AUC: 0.768 / F1: 0.710 | Random: 0.500 | Confirms separability across diverse instruction-tuned architectures |
| Lla8B | Trace-level: Recoverable ↔ Unrecoverable | AUC: 0.825 / F1: 0.756 | Random: 0.500 | Reliable binary distinction based purely on \(h_T\) |
| Qwen3-4B | Trace-level: Recoverable ↔ Unrecoverable | AUC: 0.905 / F1: 0.807 | Random: 0.500 | Demonstrates even stronger separability on next-generation reasoning models |
| Qwen3-8B | Trace-level: Recoverable ↔ Unrecoverable | AUC: 0.893 / F1: 0.796 | Random: 0.500 | Validates scale invariance of trace-level error fingerprints |
| DSR8B | Retrospective Tracing (\(k=0\)) | bMRR: 0.787 / R@1: 33.3% / AUC: 0.896 | Random bMRR: 0.300 / R@1: 6.5% | Probe ranks true error origin at top-1 in one-third of all traces |
| Qwe7B | Retrospective Tracing (\(k=0\)) | bMRR: 0.885 / R@1: 14.7% / AUC: 0.937 | Random bMRR: 0.304 / R@1: 5.8% | Sharp peak at \(k=0\) suppressing uncorrupted earlier prefixes |
| Lla8B | Retrospective Tracing (\(k=0\)) | bMRR: 0.791 / R@1: 14.3% / AUC: 0.912 | Random bMRR: 0.283 / R@1: 5.0% | Consistent ability to localize fault origins across architectures |
In downstream decoding and inference-time scaling experiments (Table 6), probe-guided prefix resampling matches the accuracy of compute-heavy sampling baselines while dramatically cutting token consumption:
| Decoding Strategy | Compute Budget (Relative Tokens) | DSR8B Accuracy (%) | Qwe7B Accuracy (%) | Lla8B Accuracy (%) |
|---|---|---|---|---|
| Greedy Baseline | \(1.0\times\) | 65.43 | 47.68 | 16.25 |
| Self-Consistency (SC) | \(5.0\times\) | 76.58 | 54.93 | 22.08 |
| Best-of-N (BoN)* | \(5.0\times\) | 79.12 | 57.17 | 23.15 |
| Weighted SC* | \(5.0\times\) | 78.84 | 59.10 | 23.88 |
| Prefix Resampling* (Ours) | \(2.3\times\) / \(2.8\times\) / \(1.5\times\) | 78.16 | 57.08 | 21.52 |
(Note: * denotes methods utilizing internal probes; token consumption is normalized relative to single greedy generation)
Ablation Study¶
Ablation studies examine the impact of context window aggregation on local step error detection (Table 3 & Table 9), length-controlled trace classification (Table 12), and directional difference features for retrospective tracing (Table 14).
| Feature / Experimental Configuration | DSR8B (AUC) | Lla8B (AUC) | Qwe7B (AUC) | Avg. Delta (\(\text{Avg. } \Delta\)) | Analysis & Notes |
|---|---|---|---|---|---|
| Step-level baseline (\(h_t\) only) | 0.922 | 0.851 | 0.814 | Baseline (0.000) | Standard step-level error detection |
| Full window concat (\(\text{concat}(H_{t,1})\)) | 0.923 | 0.836 | 0.797 | -0.011 | Preserving structural relative positions maintains performance |
| Full window pool (\(\text{pool}(H_{t,1})\)) | 0.886 | 0.813 | 0.776 | -0.037 | Average pooling blurs sharp step-boundary signals |
| Context-only concat (\(\text{concat}(H_{t,1}^{-t})\)) | 0.903 | 0.802 | 0.766 | -0.039 | Predicts current error purely from context without access to \(h_t\) |
| Context-only pool (\(\text{pool}(H_{t,1}^{-t})\)) | 0.876 | 0.793 | 0.758 | -0.053 | Contextual pooling degrades more noticeably |
| Context-only concat (\(w=2\): \(\text{concat}(H_{t,2}^{-t})\)) | 0.910 | 0.799 | 0.759 | -0.040 | Reaches 0.910 on DSR8B across radius 2 window |
| Length-Matched Test Set (R \(\leftrightarrow\) U) | 0.824 | 0.844 | 0.820 | — | Eliminates length confounding via 20 log-spaced bins; separability holds |
| Difference Feature \((h_T - h_t)\) (\(k=0\)) | 0.883 | 0.896 | 0.925 | — | Vector subtraction matches concatenation, proving directional shift encodes origin |
Key Findings¶
- Locality and Directional Asymmetry: Step-level error signals peak sharply at \(k=0\) and decay smoothly across offsets. In ranking metrics (AUC), \(h_t\) predicts past errors (\(k=-5\)) more effectively than future ones (\(k=+5\)), indicating that historical error memories persist strongly into subsequent hidden representations. Conversely, classification F1 is higher for future steps, revealing that downstream tokens become saturated with residual error signals that bias the probe toward positive error classifications.
- Genuine Representational Shift Over Length Artifacts: In raw traces, unrecoverable generations are often 1.12× to 1.62× longer than recoverable ones. However, when traces are partitioned into 20 log-spaced length bins and matched strictly 1:1, probe AUC remains virtually unchanged (0.820 on Qwe7B, 0.844 on Lla8B, 0.898 on Qwen3-4B), establishing that unrecoverability is encoded as a qualitative semantic dislocation rather than a length artifact.
- Prevalence of Delayed Unrecoverability: Evaluating the relative gap between the initial persistent error \(t^*_{\text{pers}}\) and the empirical boundary \(\hat{t}^*_{\text{unre}}\) reveals a median relative delay of approximately 0.5. Persistent mistakes do not immediately render recovery impossible; rather, subsequent steps progressively compound the error until the probability of sampling a valid continuation drops below threshold \(\epsilon\).
Highlights & Insights¶
- Counterfactual Demarcation of Error Cascades: Instead of treating reasoning failures as static textual defects, this work provides a rigorous mathematical formalization of prefix recoverability, cleanly separating transient errors, persistent errors, and terminal unrecoverability.
- Holographic Retrospective Memory: A major conceptual insight is that the final hidden state \(h_T\) contains decodable coordinates of the earliest persistent error step \(t^*_{\text{pers}}\). Even after dozens of subsequent tokens are generated, the directional difference \((h_T - h_t)\) produces a distinctive activation spike at the point where the reasoning trajectory first derailed.
- Lightweight Inference Acceleration: By marrying trace-level error filtering with retrospective prefix truncation, the probe-guided resampling framework achieves competitive performance against 5× Best-of-N and Weighted Self-Consistency while requiring only 1.5× to 2.8× the token budget of greedy decoding.
Limitations & Future Work¶
- Reliance on White-Box Hidden States: The diagnostic probes depend on direct access to internal hidden representations (\(h_t, h_T\)). Consequently, this methodology cannot be directly applied to proprietary, closed-source models (e.g., OpenAI o1/o3, Claude 3.7) accessible solely via black-box text APIs, necessitating the development of external proxy estimators.
- Computational Cost of Counterfactual Grounding: Estimating empirical recoverability \(\hat{t}^*_{\text{unre}}\) requires multiple Monte Carlo rollouts (up to 16–48 rollouts per prefix during binary search). While feasible for diagnostic benchmark construction, this process is computationally expensive to scale to web-scale CoT pre-training corpora.
- Static Probing vs. Dynamic Intervention: The current framework uses probes primarily for diagnostic detection and offline prefix backtracking. Future work should investigate integrating these representation signals directly into online process reward models (PRMs) or applying real-time activation steering to dynamically nudge reasoning trajectories back onto correct manifolds without requiring resampling.
Related Work & Insights¶
- vs. CHAINED (Lu et al., 2026a): CHAINED formulated streaming hallucination detection using step and prefix labels; this work builds upon its foundation by formalizing counterfactual recoverability \(\hat{t}^*_{\text{unre}}\), establishing the separability of recoverable versus unrecoverable traces, and uncovering retrospective tracing mechanisms.
- vs. OmegaPRM (Luo et al., 2024): OmegaPRM utilized Monte Carlo binary search to harvest step-level process supervision for training external reward models; this paper adapts binary trace slicing specifically to study latent representational dynamics and power efficient prefix-level backtracking without training large PRMs.
- vs. Hidden State Verification (Zhang et al., 2025a / Azaria & Mitchell, 2023): Prior studies demonstrated that language model hidden states know when they are generating truthful or correct answers; this work advances the field from binary outcome awareness to temporal error propagation mechanics, mapping how errors diffuse locally, shift globally, and leave retrospective traces across multi-step reasoning chains.
Rating¶
- Novelty: ⭐⭐⭐⭐⭐ Pioneering latent-space investigation of reasoning error propagation; formalizing counterfactual recoverability and discovering retrospective error decoding are highly original.
- Experimental Thoroughness: ⭐⭐⭐⭐⭐ Comprehensive evaluation across 6 diverse models (including the modern Qwen3 series), rigorous length-controlled ablations, sensitivity analyses, and downstream inference validation.
- Writing Quality: ⭐⭐⭐⭐⭐ Exceptionally structured mathematical formulations, cohesive prose, clear conceptual figures, and tightly argued insights.
- Value: ⭐⭐⭐⭐⭐ Delivers profound mechanistic interpretability insights while providing an immediately actionable, token-efficient decoding strategy for next-generation reasoning systems.