acceptodds
Under review as a conference paper at ICLR 2027

Language Models Do Not Re-verify Computed Values in Their Own Reasoning

Abstract

Language models exhibit increasingly remarkable capabilities on reasoning tasks, but their robustness to errors within their own reasoning remains uncertain. In this paper, we investigate how models respond to small perturbations of their reason ing traces. In particular, we inject a single numerical error into model-generated execution traces for short mathematical programs across 14 language models from 5 developers, and study whether the models detect and correct the error or continue reasoning from it. We find that error detection is largely determined by how the value is used in the model. Specifically, when the planted value explicitly contradicts a value written earlier in the trace, detection and correction raises up to 96 − 99% for stronger models. In contrast, when detecting the error requires re-executing even a single prior operation, every model capable of solving the task generally fails at detecting and correcting the value, with a success rate of 0−12% in the best case. Importantly, models in those setups are able to provide the value when asked directly. This failure persists even in cases where verification instructions are given, and the necessary information and computational capability are available, and is also not repaired by the activation-steering interventions we test. Our results expose a fragility in downstream self-correction even in highly capable models, and challenge the assumption that an incorrect intermediate computation will have a meaningful chance of being independently rechecked later in the rea- soning process

Primary area:
foundation or frontier models, including LLMs
Keywords:
Recovery, Mathematics

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_NotYOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper asks whether LLMs re-verify an incorrect intermediate value planted into their own previously correct execution trace of a short arithmetic program. It controls the “verification depth” k: errors at k=0 can be caught by comparing against an earlier line, while errors at k >= 1 require recomputation. Across 14 models, strong models usually catch k=0 errors, but one-operation errors propagate at 88–100%, even though the models compute the same sum correctly when asked directly. Showing the operands, changing the stated authorship, adding verification instructions, enabling reasoning, and activation steering rarely restore checking. Fine-tuning on about 600 paired examples teaches selective rechecking on two of three models, with partial generalization to unseen depths. The authors conclude that models do not spontaneously re-verify values that already appear settled in context.

Critical strengths

[S1] The protocol is clean. Outcomes are graded by program execution, and fixing trace length and operand distance lets verification depth isolate the cost of recomputation from how far back the model must look.

[S2] The k=0 vs. k=1 dissociation is sharp and consistent across 14 models and 5 developers. The direct-probe control (“What is a + b?”) separates the ability to verify from the default use of that ability.

[S3] The fine-tuning result is informative: a few hundred examples induce selective checking on Qwen2.5-32B (3/720 false checks) that partially generalizes to an unseen depth.

[S4] Reporting: pre-registered run order, prefill vs. user-turn calibration, refusals reported as unmeasured, and hyperparameters fixed before the first run.

Critical weaknesses

[W1] The format confounds the core claim.

Every condition keeps the instruction to write “nothing else” (plus “do not repeat lines” under the user-turn method), and no condition gives scratch space before continuing. Propagation may therefore reflect format compliance rather than a failure to check. The reasoning runs (GPT-5.1, R1-Distill) are never combined with a verification instruction, and the instruction arms never allow reasoning, so the most natural fix, room to think plus a reasonable instruction, is untested. The abstract’s claim that the failure “persists even when given verification instructions” is overstated for this reason.

[W2] Practical significance is asserted rather than shown.

Deliberately corrupting a committed value without any cue is an artificial scenario. The relevant real settings are the model’s own slips inside its reasoning, unflagged tool or agent outputs, and adversarial injection, but none of these are tested. The paper explicitly never perturbs the thinking channel, and the natural-slip analysis (A.3) covers only small open models with reasoning off and no instructions. If a cheap prompt plus reasoning fixes the behavior, the contribution reduces to an observation about a default prior/behavior.

[W3] Key protocol details are missing or ambiguous.

he paper does not say where the perturbed trace sits relative to R1-Distill’s <think> block, which method the GPT-5.1 reasoning run uses (inferable only indirectly), or what the exact token boundary is at the end of the prefix. Prefill and user-turn methods are mixed across models even though the method changes readable-error rates (e.g., Haiku 4.5: 0.04 vs. 0.36), which weakens cross-model comparisons.

[W4] The phenomenon looks like an expected, shallow default behavior rather than a meaningful limitation.

  • Continuing from a self-consistent prefix without re-deriving committed values is exactly what ordinary pretraining and SFT data teach, since such data almost never revisit values that have already been written down. The paper’s own discussion names this as a candidate explanation (“completed computations in a prefix are usually trustworthy”).
  • The paper’s own evidence suggests the behavior is easy to change and is not a capability gap:
    • direct probes recover the correct value 96–100% of the time;
    • a worked-example prompt cuts GPT-5.5’s one-operation propagation to 2%, even under the restrictive format;
    • about 600 examples and 114 LoRA updates remove it on Qwen2.5-32B.
  • Under a setup that permits it, namely a reasonable verification instruction plus room/space to reason before continuing, the behavior is likely to largely disappear in modern LLMs.
  • As a result, the work reads as a careful documentation of a default prior rather than as identifying a problem that is really important to solve or that needs a dedicated fix. The title and abstract frame it as a general inability, which overstates its significance.
Questions for authors

No questions at this time. Major concerns are stated in the weaknesses section above.

2 comments
AuthorsOpenReview ↗

Response to Reviewer NotY

Thank you for pointing out that we had not tested a verification instruction with reasoning enabled. We ran that test and revised the claim.

W1: Format and prompting. Changing the format alone helps one model and not the other. We allowed scratch work and changes to earlier lines, with no verification instruction and reasoning off, and left the examples in the prompt unchanged. Haiku 4.5 still propagates depth-one errors at 1.00 (180 continuations, 60 programs), while GPT-5.5 falls to 0.30 (60 programs).

The worked-example instruction with reasoning works even under the original format (table in the general response). Other combinations give partial results. The targeted instruction with reasoning leaves Haiku at 0.17 and 0.15 at depths one and five, with a depth-one Wilson upper bound of 0.24. We therefore describe the effect as a large reduction, which falls short of elimination in some conditions.

On GPT-5.5, reasoning alone gives 0.43 and 0.80, whereas permission to revise plus reasoning, with no instruction to check, gives 0.03 at both depths (60 programs). On GPT-5.1, permission to revise plus the worked example already gives 0.12 and 0.18 with reasoning off (60 programs); we did not test format alone on that model. The abstract now states that the original instruction result used reasoning off and the original format.

W2/W4: Why this matters and what we tested. Models usually continue without checking, and a suitable prompt can change that. The paper's contribution is to measure how this failure depends on the work needed to find the error, separately from whether the model can fix the error when asked. The general response reports a cheap fix as well as an expensive one. The cheap fix carries over only partly to small open models: with “Wait” appended, propagation remains 0.51 on Qwen2.5-7B and 0.56 on Llama-3.1-8B (72 and 144 continuations; no correct-trace controls), and some attempted corrections calculate the wrong answer or fail to finish.

For naturally occurring errors, the original analysis covers five open models with reasoning off. Of 1,396 computed errors that would change the answer, 10 end with the correct output (Appendix A.3). We added a check of errors that R1-Distill-7B states in its own reasoning, and all 14 that we found reach the final trace. The general response lists what remains untested and, with revised Section 5.7, describes how the fine-tuned check depends on error position.

W3: Protocol. Revised Appendix B gives the missing details. The partial trace ends after the complete planted line. The Anthropic API requires trailing whitespace to be removed, and we put it back before scoring. Open-weight models and Haiku/Sonnet 4.5 receive the trace as an assistant prefill; the other chat models receive it in the user turn.

These two ways of supplying the trace give different propagation rates for readable errors, which limits cross-model comparisons; Figure 3 marks the affected bars with hatching. On the instruction traces, Haiku propagates computed errors at 1.00 at both depths under both methods (180 continuations per condition), against 0.01 and 0.03 for the readable error. The larger readable-error difference in the paper comes from a different test, the copy-line test, and the revision now distinguishes the two.

R1-Distill with reasoning on receives the trace before the template opens its think block; we score the trace that follows the block and inspect the thinking separately. With reasoning off, it runs as raw completion with no chat template or think tags, and its correct starting traces were generated with thinking on. The GPT-5.1 reasoning comparison uses the Responses API with effort none versus medium, four samples per program and no temperature setting.

The “85%” figure concerns visible summaries only: 112 of 132 non-empty GPT-5.1 reasoning summaries at depth five contain no visible recalculation. Another 108 of 240 summaries are empty and provide no evidence either way. Even a non-empty summary may omit hidden computation; these summaries cannot establish whether the model internally recalculated. Appendix B and the new tables give the decoding settings and outcomes.

Thanks for the additional efforts and rebuttal. I think this is a honest empirical study. However, I tend to keep my score due to the following limitations of this work:

  • Limited novelty and value of the studied problem: The observed failure mode is quite predictable to me given the training data distribution used by LLMs. It is a good observation and confirmation, but lacks scientific novelty, as the issue can be mitigated by wide-used "tricks" including prompting and reasoning.
  • Limited practical evidence: The evaluated tasks are simple, far from realistic tasks that people are using everyday.
  • Limited effectiveness of the method: Fine-tuning does not automatically generalize to diverse positions. The evaluation set is also small.
  • Limited explanation to the mechanism: probing/steering results do not explain the issue completely, cannot distinguish different mechanisms. Overall, I suggest authors focus on more valuable issues and make at least one dimension of the paper very strong.
Reviewer_ydWrOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies whether large language models spontaneously re-verify previously computed intermediate values during reasoning. This paper injects numerical errors into correct model-generated execution traces of short mathematical programs, then compares how models handle readable errors and computed errors. Experiments on 14 language models show that models are generally better at detecting errors that directly contradict previously written values. However, for errors that require recomputation, models often continue to use the incorrect values. This paper further evaluates several interventions, the results show that most inference-time interventions do not reliably restore checking behavior, while targeted fine-tuning can significantly improve error detection in some models.

Critical strengths

1.This paper shows that models often fail to spontaneously re-verify previously computed values during subsequent reasoning. It also makes a clear distinction between the ability to compute correct results and the tendency to verify existing results. In addition, the paper evaluates several interventions and shows that verification behavior can be improved through targeted fine-tuning in some models.

Critical weaknesses

1.The novelty of this paper is limited compared with existing work on self-correction and the validation gap. Previous studies have already shown that LLMs have significant limitations in detecting and correcting reasoning errors, and performing a computation does not necessarily mean that models will spontaneously verify its result during subsequent reasoning (very close to the findings provided by this paper). This paper further shows that in controlled execution traces, models may fail to re-verify previously computed values even when only a single arithmetic operation is required. However, this finding seems relatively incremental.

2.The experimental contribution of this paper is also limited. The intervention experiments mainly investigate which interventions can or cannot reduce error propagation, rather than why models fail to re-verify previously computed values. The authors also acknowledge this limitation in the Discussion: “Our results do not distinguish among these accounts.” In addition, the effectiveness of fine-tuning appears to depend on the model. The training method significantly improves verification behavior in Qwen2.5-32B but does not show a similar improvement in Qwen2.5-7B in the reported experiments. However, the paper provides limited analysis of why the same approach leads to different results across models. Therefore, although the paper provides a more detailed analysis of this behavior, it does not clearly explain the underlying mechanisms or provide more general insights.

[1]Yee E, Li A, Tang C, et al. Dissociation of faithful and unfaithful reasoning in llms[J]. arXiv preprint arXiv:2405.15092, 2024. [2]Bertolazzi L, Mondorf P, Plank B, et al. The validation gap: A mechanistic analysis of how language models compute arithmetic but fail to validate it[C]//Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing. 2025: 29375-29412. [3]Long Q, Jiang K J, Chen J, et al. Self-Verification Dilemma: Experience-Driven Suppression of Overused Checking in LLM Reasoning[J]. arXiv preprint arXiv:2602.03485, 2026.

Questions for authors
  1. What is the main advance over prior research on error recovery and the computation–validation gap?
  2. How to explain the observed failure to spontaneously re-verify computed values?
  3. How generalizable are the observed behavior and fine-tuning improvements beyond the controlled experimental conditions?
1 comment
AuthorsOpenReview ↗

Response to Reviewer ydWr

Thank you for the review. We address what the paper adds, what the controls show, and where the findings apply.

W1/Q1: Main advance. We control how much calculation is needed to detect an error, with trace length and the distance to the inputs held fixed and the outcome scored by running the program. Earlier work does not control this: Yee et al. show that models recover differently from copying errors and calculation errors, Bertolazzi et al. study why models can do arithmetic but fail to judge whether an answer is correct, and Long et al. study the checks models make during reasoning. In the main unprompted tests, propagation rises sharply between depth zero and depth one and changes little from there to depth five.

We also compare continuing, fixing and judging on the same partial traces, with full numbers in the general response. The four models propagate depth-one errors at 0.95–1.00 when continuing and fix them at 0.97–1.00 when told which line to check, so the ability to repair a line does not carry over to continuation. Haiku 4.5 and GPT-5.1 are also unreliable judges: they often call a wrong line correct while stating its true value. Section 2 explains the relation to earlier work.

W2/Q2: Why checking fails. The controls show what does not fully explain the failure, and they do not identify its cause. On the models tested, the error often survives when we show the inputs or change who is said to have written the trace, and direct questions show that the models can calculate the value. The new Llama-3.1-8B result shows that the behavior can appear before post-training in one family. The cue and repair tests show how to get a model to check, without explaining why it does not check unprompted. The general response lists the explanations we cannot yet separate. The revised Discussion replaces the broad “do not distinguish” sentence with what each test shows and what remains open.

W2: Fine-tuning. The general response reports the new results: Qwen2.5-7B learns the fixed depth-one check on three seeds, and both the 7B and 32B checks fail when the error is moved three lines earlier. Training on several error depths or positions still fails on 7B under this procedure, although mixed-depth training works on 32B and Llama-3.1-8B. The choice of training examples therefore affects the outcome, though we cannot yet say why these models learn differently. The abstract and Section 5.7 now limit the claim about harder errors to the position used in training.

Q3: Where the findings apply. The 0.88–1.00 result is for formatted trace continuation, and we do not claim it for word problems. Models catch more errors in prose: Sonnet 4.5 propagates 0.33 of bare computed errors and Opus 4.8 propagates 0.45 (Table 1). In our Yee-style GSM8K test, GPT-4o still recovers 14 of 45 renumbered items (0.31) when the partial trace ends at the sentence boundary (Appendix A.5). Section 2 also reports where Tsui, Jia and Mu, and von Recum et al. obtain different results on models we share with them. Their tests differ from ours in format, error position, whether the correct derivation remains visible, and the surrounding reasoning.

The general response covers errors that a model states in its own reasoning and lists what remains untested. Appendix D gives sample sizes and the correct-trace controls where we ran them.

Reviewer_UAeWOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a controlled experimental framework to investigate whether language models spontaneously verify intermediate computational results within their own reasoning trajectories. By injecting “readability” errors (k=0)(k=0) and “computational” errors (k≥1)(k \ge 1) into valid reasoning trajectories, the authors demonstrate that, across 14 models, computational errors are propagated almost without exception. The authors also demonstrate that interventions such asarithmetic, altering attribution, or prompting verification are largely ineffective, whereas targeted fine-tuning can foster verification behavior, although success rates vary across models.

Critical strengths
  1. The experimental design is exceptionally clean: it defines Verification Depth kk and strictly controls variables, thereby avoiding the confounding factors found in previous natural language tasks.
  2. The scoring mechanism is reliable: correctness is determined by program execution rather than using an LLM-as-a-judge, thereby avoiding bias in the judging model.
  3. It reveals a cliff-like phenomenon: from k=0k=0 (14% propagation) to k=1k=1 (100% propagation), this cliff-like drop—achieved in just “one step”—is counterintuitive yet strikingly intuitive.
Critical weaknesses
  1. Lack of Novelty: Although the experimental design is rigorous, its core findings have already been thoroughly discussed in the existing literature. While the study provides a clearer quantitative analysis, it does not offer any fundamental new theoretical contributions or innovative mitigation strategies. The conclusions largely confirm the intuition that models rely on pattern matching and contextual continuity rather than active logical verification. Here are some corresponding papers:
  • From Decorative to Load-Bearing: Task Difficulty Shapes the Causal Role of Chain-of-Thought
  • Large Language Models Cannot Self-Correct Reasoning Yet
  • Towards Understanding Sycophancy in Language Models
  1. Lack of Mechanistic Insights: While this paper successfully identifies the problem, it fails to explain its causes. Does this failure stem from the Transformer’s mechanism or from post-training? Crucially, the paper fails to reconcile this behavior with the fact that reasoning models (such as DeepSeek-R1) often exhibit explicit self-correction in their publicly available CoT outputs. Why do models actively self-validate during autonomous exploration but completely lose this ability when asked to continue a pre-filled trace? Due to the lack of mechanistic inquiry, the paper remains at a phenomenological level.

  2. Limited Practical Significance: Fine-tuning was effective only on Qwen-32B but failed on Qwen-7B. What is the reason for this? Furthermore, the mentioned principles of “do not trust existing answers” and “do not trust user input” appear to be a consensus in agent development—and even in traditional software development.

  3. Evaluation Based on Outdated Fine-Tuned Models: The fine-tuning experiments were limited to the Qwen 2.5 series and Llama 3.1 8B. Given the rapid evolution of open-weight LLMs, Qwen 2.5 is now considered a relatively outdated baseline.

Questions for authors
  1. Reasoning models like DeepSeek-R1 frequently exhibit self-correction ("aha moments") in native CoT. Why does this verification vanish completely in your continuation task? Is it due to the fundamental conflict between "continuation" and "verification" modes?

  2. Is the near-100% error propagation an artifact of RLHF? Since models are heavily optimized to obey instructions (e.g., "continue the trace"), they might suppress internal doubts. Did you test base (non-RLHF) models to see if they are less susceptible?

  3. Why did Qwen 2.5-7B fail to learn checking while 32B succeeded? Is there a minimum parameter threshold? Furthermore, have you tried fine-tuning newer reasoning models (e.g., DeepSeek-R1-Distill) to see if they acquire this behavior more easily?

2 comments
AuthorsOpenReview ↗

Response to Reviewer UAeW

Thank you for the review. In response we added three tests: a model before post-training (W2/Q2 below), errors in a model's own reasoning, and depth-one training of Qwen2.5-7B. The general response reports the last two.

W1: What the paper adds. We vary how much calculation is needed to detect an error while holding the task and the trace fixed. Earlier studies vary something else: Jia and Mu vary task difficulty, Huang et al. ask models to review their answers, and Sharma et al. study deference to a user's claim. Our tests measure whether a model checks earlier work as it continues. They show a sharp change at depth one, and they compare continuing, fixing a line and judging it on the same partial traces. Changing who is said to have written the trace leaves computed-error propagation at 0.98–1.00 on the models tested (Appendix A.4). Section 2 describes what the planted-error test adds to each earlier study.

W2/Q2: Post-training and the cause of the failure. The behavior can appear before post-training. Llama-3.1-8B before post-training propagates depth-one errors at 0.996 (252 continuations), and its Instruct version gives 0.988 through the same raw prompt (164 continuations). This is one model family. The comparison includes only programs each model solves, and the pretrained model solves 27–39% of programs across depths. All fourteen models in the original comparison were post-trained, so we replaced the ambiguous term “base models” with “unmodified models”.

As for the cause, we tested whether the failure comes from being unable to calculate the value, being unable to find the needed inputs, or responding to who wrote the trace. On the models tested, none of these fully explains it. The general response lists the explanations we still cannot separate, and the revised Discussion states what each test supports and what remains unknown.

Q1: Reasoning and self-correction. Reasoning alone changes little on three of the four models: depth-one propagation is 0.99 on GPT-5.1, 0.93 on R1-Distill and 0.99 on Haiku. GPT-5.5 improves to 0.43 at depth one and 0.80 at depth five. Adding the worked-example instruction to reasoning brings propagation to 0.05 or below on the three API models (table in the general response). On self-correction, all 14 wrong values that R1-Distill states in its own reasoning reach the final trace.

W3/Q3: What 7B learns. Qwen2.5-7B can learn the fixed depth-one check, so the 7B/32B difference is not a capacity threshold. With the paper's training procedure unchanged, propagation falls from 0.83, 0.82 and 0.81 on the three seeds to 0.00 (13, 14 and 13 matched programs; 52, 56 and 52 continuations). The adapter adds checks to 3, 9 and 9 of 720 correct traces, against 188 with the paper's mixed-depth training. Generalization across depth is limited: depth-two propagation falls to 0.16–0.42, and the check does not transfer to depth three.

Mixed-depth training does work on Llama-3.1-8B (32–40 matched programs at depths one to three, one seed; checks on 82 of 720 correct traces). We do not know why Qwen2.5-7B fails when the training examples mix error depths or positions. The general response also reports that both Qwen adapters fail when the error is moved three lines earlier, which is why we limit the claim about harder errors to the position used in training.

W4: Models tested. The behavioral tests include GPT-5.5, GPT-5.1, Sonnet 5 and Opus 4.8. Fine-tuning is limited to Qwen2.5 and Llama-3.1; we have not fine-tuned R1-Distill or a newer open-weight model. The revision lists these two sets of models separately.

I appreciate the authors’ revisions, however I still remain my initial score.

  1. Novelty remains limited: the new experiments primarily rule out explanations and confirm the ‘default no-recheck’ behaviour, without providing new theories or robust mitigation strategies; ‘prompting + reasoning’ can reduce the propagation rate to ≤0.05, making it more akin to a default prior problem.
  2. Insufficient practical evidence: the tasks remain short mathematical programmes, with only 14 natural errors; real-world scenarios such as tool outputs and agent handoffs are not covered.
  3. Limited method generalisation: The 7B model can learn fixed depth-one checks, but fails at depth and position transfer; the evaluation set is also too small; the reasoning model was not fine-tuned.
  4. Insufficient explanation of mechanisms: Control experiments failed to distinguish genuine mechanisms, nor did they explain why R1 self-corrects in native CoT but disappears in continuation.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response: new experiments and revised claims

Thank you for the reviews. New experiments led us to revise three claims:

  1. Prompting can work. The worked-example instruction combined with reasoning cuts propagation to 0.05 or below on three API models. The original instruction result used reasoning off and the original format; we now state this.
  2. Qwen2.5-7B can learn the check. Depth-one training succeeds on three seeds, correcting our broader negative conclusion about 7B.
  3. The fine-tuned check depends on error position. Both Qwen adapters miss errors moved three lines earlier; we limit depth-generalization claims to the trained position.

We vary the operations needed to detect an error (verification depth), holding trace length and distance to the inputs fixed. Depth zero contradicts an earlier line; depth one or more requires calculation. Propagation is the share of continuations where the planted error reaches the final answer, scored by program execution.

Haiku 4.5 propagation rises from 0.14 at depth zero to 1.00 at depth one and stays near 1.00 through depth five. Twelve of fourteen models propagate depth-one errors at 0.88–1.00.

We ran Haiku 4.5, Sonnet 4.5, GPT-5.5 and GPT-5.1 on the same partial traces under three prompts. Asked to continue, they propagate depth-one errors at 0.95–1.00. Told which line may be wrong, they fix it at 0.97–1.00 at depths one and five and wrongly change a correct line at 0.00–0.02 (60 programs per depth, one reply per prompt; Sonnet 4.5 is run on Haiku's traces). Asked only whether the line is correct, Sonnet 4.5 and GPT-5.5 catch every depth-one error and wrongly flag 0.03 and 0.00 of correct lines. Haiku 4.5 and GPT-5.1 catch 0.47 and 0.45 of the errors and wrongly flag 0.33 and 0.27 of correct lines, although they state the true value in 0.95 and 0.88 of replies. Being able to calculate or fix a value does not ensure that a model checks it while continuing, and in two models even a direct judgment is unreliable.

With reasoning enabled, the worked-example instruction and the original format, propagation is:

ModelDepth oneDepth fiveReplies per depth
Haiku 4.50.050.03120 from 60 programs
GPT-5.10.000.0060 from 60 programs
GPT-5.50.000.0060 from 60 programs

None of these runs changes a correct line to a wrong value, and a rate of 0.00 on 60 programs has a Wilson 95% upper bound of 0.06. On correct traces at depth one, output including hidden reasoning rises from 159–165 tokens to 391–736.

A cheaper cue works on Haiku. Following Tsui and von Recum et al., we append “Wait”, and propagation falls to 0.02 at depth one and 0.00 at depth five, for 203 output tokens against 164 on traces with a depth-one error. The cue also triggers a recheck on 0.55–0.77 of correct traces. Cost depends on the model and prompt: GPT-5.5 already improves with reasoning alone, to 0.43 at depth one and 0.80 at depth five.

Trained with the paper's procedure on depth-one errors only, Qwen2.5-7B goes from 0.81–0.83 propagation to 0.00 on all three seeds (13–14 matched programs per seed, those both models solve). It adds a check to 3, 9 and 9 of 720 correct traces.

Position transfer fails. With the error three lines before the end of the partial trace, already used, depth-one propagation is 0.98 for the 7B adapter (64 programs, one seed) and 1.00 for the paper's Qwen2.5-32B mixed-depth adapter (109 programs). Training 7B on errors at several positions does not help: propagation is still 1.00 at the earlier position and 0.77 on the standard depth-one test (one run). We limit depth-generalization claims to the trained position (abstract and Section 5.7).

Natural errors in reasoning (small sample). Among 1,200 R1-Distill-7B solutions (300 programs, four samples each), 14 state a wrong intermediate value in the reasoning. All 14 carry it into the final trace and none later states the correct value; detections were checked by hand. The sample is small and excludes mistakes the model fixes before stating a value, so it does not establish a rate for frontier reasoning models. We have not combined a verification instruction with reasoning on R1-Distill.

We cannot yet tell whether models trust the earlier value, attend too little to it, or prefer to continue the given text, and the probe and steering experiments do not settle this. The paper studies trace continuation; tool outputs, agent handoffs, adversarial injection and natural errors on frontier models are left to future work, as the revised abstract and Discussion state. The revision adds these experiments, control tables, intervals and protocol details.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.