Scaling Reasoning Hop Exposes Weaknesses: Demystifying and Improving Hop Generalization in Large Language Models
Authors: Zhaoyi Li
Jiatong Li
Gangwei Jiang
Linqi Song
Defu Lian
Ying Wei
Venue: ICLR 2026 Poster (2026)
Keywords: large language models
chain-of-thought
reasoning hop generalization
mechanistic interpretability
Primary area: interpretability and explainable AI
TL;DR: This work sets out to explore the patterns and mechanisms for reasoning hop generalization errors, and secondly leverages these insights to develop strategies for correcting these errors.

Abstract: Chain-of-thought (CoT) reasoning has become the standard paradigm for enabling Large Language Models (LLMs) to solve complex problems.
However, recent studies reveal a sharp performance drop in *reasoning hop generalization* scenarios, where the required number of reasoning steps exceeds training distributions while the underlying algorithm remains unchanged. 
The internal mechanisms driving this failure remain poorly understood.
In this work, we conduct a systematic study on tasks from multiple domains, and find that errors concentrate at token positions of a few critical error types, rather than being uniformly distributed. 
Closer inspection reveals that these token-level erroneous predictions stem from internal *competition mechanisms*: certain attention heads, termed *erroneous processing heads* (ep heads), tip the balance by amplifying incorrect reasoning trajectories while suppressing correct ones. 
Notably, removing individual ep heads during inference can often restore the correct predictions.
Motivated by these insights, we propose test-time correction of reasoning, a lightweight intervention method that dynamically identifies and deactivates ep heads in the reasoning process. 
Extensive experiments across different tasks and LLMs show that it consistently improves reasoning hop generalization, highlighting both its effectiveness and potential.

Published as a conference paper at ICLR 2026
SCALING REASONING HOP EXPOSES WEAKNESSES: DEMYSTIFYING AND IMPROVING HOP GENERALIZA- TION IN LARGE LANGUAGE MODELS
Zhaoyi Li Jiatong Li', Gangwei Jiang- Linqi Song2.t, Defu Lian' Ying Wei Uniiersity of Science and Technology of China, C City University of Hong Kong, *Zhejiang University, *City University of Hong Kong. Shenzhen Research Institute siizhooyi777 esllisslttt jt, gwjiang]emaii ust..sttuss..o.o edu. en, singi.song@aiin www.uuddd.... hk, Liandefu winggweiizju.eer edu.
ABSTRACT
Chain-of-thought (CoT) reasoning has become the standard paradigm for enabling Large Language Models (LLMs) to solve complex problems. However, recent studies reveal sharp performance drop in reasoning hop generalization scenarios, where the required number of reasoning steps exceeds training distributions while the underlying algorithm remains unchanged. The internal mechanisms driving this failure remain poorly understood. study on tasks from multiple domains, and find that errors concentrate token positions of few critical error types, rather than being uniformly distributed. Closer inspection reveals that these loken-level erroneous predictions stem from internal competition mechanisms: certain attention heads, termed erroneous pro- cessing heads (ep heads), tip the balance by amplifying incorrect reasoning jectories while suppressing correct ones. Notably, removing individual ep heads during inference can often restore the correct predictions. Motivated by these in- sights, we propose test-time correction of reasoning, lightweight intervention method that dynamically identifies and deactivates ep heads in the reasoning pro- cess. Extensive experiments across different tasks and LLMs show that it consis- tently improves reasoning hop generalization, highlighting both its effectiveness and potential. The data and code are made public]
this work, we conduct a systematic
INTRODUCTION
While Ctain-of-thoughee (CoT) (Wei et al.) 2022) has become the de facto approach for eliciting multi-hop reasoning in large language models (LLMs), recent works (Anil et al. 2022 Shojaee
et al. 2025 Zhao et al. 2025) have reported striking failure mode in reasoning hop generalization: when the number of required reasoning hopy iinrreaees at test time, even the most advanced LLMs performance drops drastically, despite the required reasoning skill remaining unchanged (c.g.. 3- digit x 8-digit multiplication requires the same multi-digit multiplication skill as multiplying two 2-digit numbers). This generalization problem is special case of length generalization (Kazemne- jaad et al. 2023) tailored to reasoning problems; unlike sequence-length generalization that stresses model wondew limits, hop generalization concerns the growth of reasoning hops where the total context length likely remains modest. This pronounced gap from human-level robust reason- ing (Dekker al. 2022]] Lake & Baroni 2023) motivates the urgency to examine why LLMs struggle with long-hop reasoning and how to bridge this gap on the path toward artificial general intelligence.
Lake
To this end, Dziri et al. (2023) systematically studied and attributed this problem to single-hop enror accumulation. Hu et al. (2025) introduced a rule-following fine-tuning strategy that relies
Cooresponding authors
https: : // www..c../.ow...tccoo wtt.//o///aaa. hoa//hhaoi--- wttp:iiii111/rreae htt/rreaoonngghhherrrree hwwpinngghhhhhheeeeeeee ization
"reasoning hop" in paper refers to general reasoning step reasoning chain, which includes hut limits the "hop" used in the multi-hop QA literature (Sakarvadia et al. 2024).

---

Published as a conference paper at ICLR 2026
on fine-tuning specific reasoning task with its rules recited before each execution, while Fan jet al.] (2025) proposed a new architecture, looped transformer, that reuses computation across hops for generalizing to longer reasoning chains. While these approaches mark promising directions, central challenge persists: how to compatibly enhance the intrinsic reasoning capabilities of off-the- shelf L.MSs without post-training on downstream data. This enduring difficulty stems largely from a lack of understanding of the internal mechanisms underlying reasoning hop generalization failures, which constitutes the core motivation of our work.
To unveil the mechanistic causes of hop generalization errors, we investigate two research ques- tions, RQI: Where do errors occur? Existing mechanistic analysis tools (Bereska & Gavves) 2024) were mainly developed for local prediction tasks, such as factual recall (Meng et al. 2022).
simple arithmetic (Stolfo et al., 2023), or elementary in-context learning tasks (Todd et al. 2024).
where relevant signals are confined to one or few tokens. In contrast, hop generalization errors unfold over many reasoning hops, making it unclear which token-level decisions are responsible, and rendering direct application of these tools intractable. To address this, we adopt an error-centric perspective and systematically identify key error types - task-specific token positions where fail- ures consistently concentrate. This reduces the complexity of long- hop reasoning into compact set of token-level diagnostic entry points and makes them amenable to mechanistic investigation. Next, RQ2: Why do these errors arise? Understanding the error causes from these entry points poses great challenges, as they may arise from multiple cooperat- ing or competing mechanisms with di- rect and indirect effects on the prediction, for which a single analysis tool is insuffi cient. To disentangle the underlying mech- anisms, we combine Logit Lens decod- ing (nostalgebraist 2020), head knockout interventions (Michel et al. (019b)), and activation-based circuit analysis (Wang) jet al. 2023). Together, these tools reveal simplified reasoning circuit for token- level predictions (Figure D: correct/erro- neous processing heads (cp/ep heads) that cooperate with basic processing heads in shallow layers construct intermediate rea- soning signals related to correct/erroneous
Input
Conrect Procossing Nip
LLM's Inner Workings
Prediction
Basic Procwoiing Hoods: Missic
Ansttr-Wtriing Heads
Erroneous Procassing
Heads: Nap
knock out an erroneous head
Input
Correct Procassing Hewddh: NV
LLM's Inner Workings
Prediction
Processing Masdi:
Answor Wiiting Heads
Enrunacuus Procesing
Heads: Kip
Figure 1: Illustration of the reasoning circuit and the competition mechanism inside L.MSs.
predictions, while answer-writing heads (aw heads) in deeper layers aggregate these signals into the residual stream. Within this circuit, we uncover competition mechanism: correct and erroneous 3 cocxist; when ep heads tip the balance by amplifying spurious signals and suppressing correct ones, they drive erroneous predictions. Notably, beyond tracing errors back to their heads, we observe shared ep heads across various reasoning tasks and error types, laying the foundation for predicting such ep heads on the fly to intervene.
trajectories
Building on the above mechanistic insights, we develop Test-time Correction of Reasoning (TCR), lightweight intervention method that is compatible with most LLMss to dynamically rectify hop generalization errors. TCR maintains a candidate set of common ep heads per model, trains a head selector network to automatically choose which head to knock out given the input context, and employs an entropy-threshol detector to decide when to intervene. Extensive experiments show that TCR consistently improves reasoning hop generalization (e.g.. averagely +6.8% accuracy on seven tasks with Qwen2.5-7BB --nstuttt We also implement -CR-gold, which uses an oracle detector to precisely localize all errors, boosting Qwen2.5-75 2--2.5577-Insttueee average accuracy by about 20% (41.7% 61. 61,3%) highlighting the strong test-time rectification potential of knocking out ep heads.
Main findings and contributions Through extensive experiments on seven reasoning hop gener- alization tasks and across four open-source LLMs,, we arrive at three key findings: (1) Errors in hop-generalization scenarios are dominated by token-level erroncous predictions of a few specific error types, enabling focused diagnosis. (2) These token-level errors stem from the internal compe-
referring information flows inside the reasoning circuit that support correct erroncous predictions.
2

---

Published as a conference paper at ICLR 2026
tition mechanism: correct trajectories co-exist with erroneous ones but are actively suppressed by erroneous processing heads; knocking out such heads can substantially restore correct predictions. (3) We propose TCR based on these insights, a test-time intervention that automatically and dynami- cally deactivates erroneous processing heads, consistently improving reasoning hop generalization.
2 PRELIMINARIES
In this section, we introduce the tasks and models that used in our study and basic ideas and tools of analyzing LLMs' internal mechanisms from the residual stream viewpoint. Due to the page limit, a detailed discussion of related work is provided in Appendix C
Tasks Following the task forms widely used in the relevant literature, we collect seven reasoning hop generalization tasks from three different domains:
Symbolic Reasoning: Parity-NL (Parity problem, natural language variant) (Anil et al. 2022
Zhou et al. 2024) and LLC (Last Letter Concatenation) (Wei et al. [2022] Hu et al. 2025
Mathematical Calculation: MDM (Multi-Digit Multiplication) (Dziri et al. 2023 and MOAS
IMulti-Operant Addition and Substract) (Baeumel al. 2025).
Coding: CLF (LeetCode 1598) and NumS (LeetCode 1450),
Others: ObjC (Object Counting) that requires both symbolic reasoning and mathematical calcu- lation abilities from the BBH benchmark (Suzgun et al. (022).
Inspired by Mirzadeh et al. (2025), we resynthesize data for each task by randomly substituting entity names and numerical values to minimize potential data leakage from LLM pretraining. A key advantage of these tasks the ability to control reasoning hops while preserving the underlying reasoning skill (e.g.. in Parity-NL, we instantiate problems with n E {10,20, .0,...,,..)). 50) actions). Detailed task descriptions and examples are provided in Appendix D
Models We experiment with four open-source L.Mss: Qwen2.5-77 - (Alibaba 2025a), Phi- 3-Instruct (Microsoft) 2024), LLLMA3-8B-
(Meta 2024), and Qwen3-8B- Insstruuttt (Alibaba 2025c). Model details are in Appendix D with extended results of the experiments presented in the main text provided there due to space constraints.
Understanding LLM Predictions via the Residual Stream. A key feature of Transformer-based LLMs is the residual stream (Elhage et al.) 2021 Todd et al. 2024). which cumulatively propagates information across layers. Each layer reads the residual state, processes it via attention and MLP submodules, and writes updates back through addition. Formally, letting h e Rd be the residual state layer 1 [... L 1]. we have (omitting LayerNorm (Ba al. 2016) for simplicity):
h 1+1 = h 1= aL. h
h+1 mid + m' = h EE a
m
(1)
1=
where a is the output of the i-th attention head and m' is the MIP output. This decomposition en- ables interpretable circuit analysis (Wang et al. 2023), attributing prediction dynamics to individual components by tracking how each head and MLP contributes through the residual stream.
Mechanism Analysis Tools
Logit Lens is a widely used tool that projects intermediate values in the LLM residual stream into the human- -uman-interpretable vocabulary space (Geva et al. 2023 Chughtai et al. 2024 Yu & Ananiadou 2024 by applying the unembedding matrix Wy E V (in the output layer of L.Ms)):
flogit lens (v) = Softmax(v We) E RRM
where v E IRd can be any intermediate representation in the LLM residual stream (arr et al. 2023) such as h or a/. and the vocabulary. Given target token (index) 1 E [O..[V] - 1J. we can use flogit-loms [v)[t] to directly assess how much information about is contained in
Knocking Out, initially inspired by biological genetic analysis (Griffiths) 2005), has been widely used in recent LLM mechanistic analysis works (Wang et al.) 2023 Geva et al. 2023 Dutta et al. 2024] to indirectly assess the causal importance of specific components to the model prediction. Specifically, taking the attention head a& for an example, we knock it out by setting a 0 (Michel jet al. 2019a) when updating the residual stream (Eq [T. We then compute the change in the final
output probability distribution the Causal Indirect Effect (CIE) (Meng et al. 2022 Stolfo al.
3

---

Published as a conference paper at ICLR 2026
100%
Parity-Nl 1Qwen2.5-78
2.w.n.552P0r 5-7-iistrrrt)
MDM (Qwen2 5-78-instruct)
100%
abjC (Qwen2 1-28-nntrurr))
1.0
Error Proparton
0.4
67%
0.8
67%
57%
3.7
33%
3376
23%
3.5
0%
26
30
40
10.4
10
20
40
50
Reasoning Hop Number
Reasoning Hap Number
Reasaning Hop Number
Other Error Types
Eraor Type(s)
Dverall Accuracyy
Figure 2: Overall accuracy (green curve) and enror proportion for key error types (blue bar) and other error types (purple bar) of Qwen2.5-7B Qwenn.5-7B-Insttuu In-srrtuct on Parity-NL, MDM and ObjC.
2023 of knocking out aq. Formally,
Dunock po(x) (o 0) E ERIM
where pa is the predicted probability distribution of the model A and is the model input. Large value of Oknock out (a.) [4] indicates the head knocked out plays a key role in driving the prediction of the target token (Heimersheim & Nanda 2024). This procedure allows to pinpoint the attention heads that are most critical for specific token-level reasoning patterns.
3 BREAKDOWN OF REASONING HOP GENERALIZATION ERRORS
In this section, we mainly want to answer RQI: Where do errors occur? Specifically, how do LLMs' reasoning errors evolve problem hop increases, and are there any specific error types and token-level mistakes account for their performance degradation?
Decomposing LLMs' Overall Reasoning Errors into Reasoning Hops Interpreting CoT rea- soning is substantially harder than simpler objectives (e.g., factual recall (Meng et al. 2022] Li al. 2024), basic arithmetic (Stolfo al.] 2023). or elementary in-context tasks like ue__antonyr (Todd et al., 2024 Jiang et al. 2025)) because the latter involve only a few output tokens, whereas CoT responses often span hundreds of tokens, especially under reasoning hop gen- eralization. Existing mechanistic analysis tools excel at token-level analysis but become difficult to apply when it is unclear which token positions should serve as the entry points for analysis. To ad- dress this, we decompose a CoT response into fine-grained reasoning hops. Formally, for an n-hop problem I F1
Tn + y, the joint probability of a fully correct response factorizes as:
p(11, T2. .. Tu 1/2z)
p(rl
p(r2lz,7)
ply ar, Ti,..,
The whole CoT response
1st Hop Reasoning 2nd Hop Reasoning
roch Hop Reasoning
Output the final answer
Failures in CoT reasoning can thus be traced to failures in specific hops, and the token positions of first errors serve as a natural proxy for diagnosing the overall reasoning aasooningailure failure. In the following, focus these positions for mechanistic analysis.
Key Error Types: Performance Degradation is Rooted in a Few Patterns In reasoning hop gen- cralization, problems often contain dozens of intermediate hops Hu et al. (2025), each potentially producing multiple errors. Considering all possibilities quickly becomes intractable. We observe that many errors share the underlying reasoning skill, even if they occur in different hops. Accord- ingly, we categorize a small set (typically 5 ~ 10 per task) of task-specific "error types". Figure 9 illustrates all error types for Parity-NL (detailed examples for other tasks are in Appendix [E.I). which include, e.g., recalling wrong information and incorrectly updating state. For brevity, we denote the N-th error type of task as "X(N)".
While decomposing reasoning errors catalogs the diverse mistakes that can occur, a key question remains: are errors evenly distributed or dominated by a few patterns? This distinction is critical, as concentration in few patterns likely signals coherent underlying mechanism to study. We do observe that a few (one or two) error types for each task account for most errors, and define those accounting for > 30% as key error types (detailed in Appendix E.2). For instance. in the 50-hop Parity-NL task, 78.6% of errors stem from recalling wrong names (Type in Figure 9. We
show the error proportion (number of error samples divided by the number of all samples) for
4

---

Published as a conference paper at ICLR 2026
these key types and all other types and the overall accuracy with different reasoning hop numbers for Qwen2.5 on Parity-NL, MDM and ObjC tasks in Figure 2 We observe two key trends. First, the model experiences a pronounced drop in overall accuracy the number of reasoning hops increases, confirming the fragility of current LLMs a problem involving more hops of reasoning. More importantly, this decline is not explained by uniform increase in all error types, but is instead largely driven by the growth of a small set of target error types we identify. In contrast, the aggregate proportion of all other error types fluctuates only mildly with reasoning hop number. This highlights that performance degradation in reasoning hop generalization stems primarily from a limited set of key error types that intensify with hop length, underscoring the importance of focusing on the corresponding token positions where such errors occur.
4 PROBING INTERNAL MECHANISMS OF KEY ERROR TYPES
We now turn to the central question RQ2: Why do these errors arise? What internal mechanisms underlie these critical reasoning errors, and how do they shape the model's corresponding token- level predictions? Uncovering the underlying mechanisms may reveal potential intervention points to mitigate them. We conduct comparative analysis (as illustrated in Figure 3 on both correct and erroneous model predictions at the token positions corresponding to key error types. We start by noting that the erroneous predictions at these token positions are often associated with higher predictive uncertainty. A detailed analysis of token-level entropy for correct and erroncous predictions across seven reasoning hop generalization datasets is provided in Appendix E. This observation motivates our study of the underlying competition mechanisms behind such high uncer- tainty, where there must exist correct and erroneous reasoning trajectories to shape the error patterns in reasoning hop generalization.
Input: Reasoning Content
Output: Predicted Taken
Mechanism Analysis
Duiriir::
GI 123-- junts epp- ELC: koll 01123 Just predistion
Jermennus
Answer Answer-writing heads
Serr
Dusstor:
01-59-3 lurts dipi- 2008
Processing heads
3 bo Audl
Jermnnouss]
host problen
redil piserntd heppirs
Comparative Study
derievel 7il tims siaht
(comwes)
Inpat problem
iidill gevernte heppees
Answer-wwiting heads
S corr
Processing heacs
12 bertivetg 1900 jeokt
Arower Inpct problem
Figure 3: Illustration of the idea of comparative study and constructing the correct prediction set Scor and erroneous prediction set Ser with the multi-digit multiplication (MDM) task (error type 2. digit decomposition error). Each sample contains the input reasoning context and the output predicted token. Scor and San contains the samples that are correctly and erroneously predicted by model, respectively.
Competition Mechanism Inside LLMs in Reasoning Hop Generalization Motivated by prior work highlighting the crucial role of attention heads in robust CoT reasoning (Olsson et al. 2022 Dutta et al., 2024 Cabannes et al., 2024), we focus our analysis on attention heads. We first identify and categorize two functionally distinct groups central CoT reasoning: 1) answer-writing heads (aw heads), mainly in middle-to-deep layers, inject answer information into the residual stream to directly shape model predictions, and 2) processing heads, mostly in shallow-to-middle layers, extract and refine semantic information from the input and intermediate steps to support reason- ing indirectly. Here we specifically analyze the competition mechanisms of both categories using 1onn2.5-7B-Intrrue on Parity-NL (additional results for other models and tasks are in Appendix
4.1 ANSWER-WRITING HEADS
Locating answer-writing heads Considering a specific error position where the predicted token
is 1, previous works (Wang al. 2023 Dutta al. 2024 Chughtai et al. 2024) typically measure
5

---

Published as a conference paper at ICLR 2026
10-
10"
20
probubilty
10-
predkdted to
ti rnchaiitty
16
prodktted to procedilly
20
layer
(a) uwe heads on Stor-
(b) aw heads on Ske-
(c) tokens'
information changes across intermediate layers.
Figure 4: Locating answer wrritigg heads with our proposed measure for Swor and Sex and tracing
ground -rrnth and predicted tokens' information across intermediate layers.
how much information about t is written by head a (at the last input token position) with Logit Lens floga-leus (a) [t] (Eq(2). However, this approach does not fully capture a head's 's contribution, as it ignores the joint influence of other heads in the same layer and the information already present in the residual stream (details in Appendix [.3). To address this, we measure the effect of knocking
mid [t] to locate aw heads. Besides, considering the large scale discrepancy of target-token probabilities across layers, which fluctuate only within narrow band in earlier layers but surge dramatically in the final layers (Figureffc)) we additionally normalize the effect with its original value. In conclusion, we propose metric to measure how strongly at acts as an aw head, formally expressed as:
out at on the Logit Lens probability flugitlens (h(+1)
(Fiogit-lens ( mid [[{] flogit-lens ( (hitt) - (4) flggtt/ing ( (b [[]] - Saw- (a.).
(4)
For specific error type, randomly sample two sets for correction and erroneous predictions
at the corresponding key token position, denoted as Seer and Ser (the illustration can be found in
Figure 3). respectively. We locate aw heads for them by calculating the average Saw.head (a!) over
Scor and Sen for each attention head a/. The locating results are shown in Figure 4[a) and (b). There exist a few heads, sparsely distributed, that receive markedly high average Saw-head (ow-heaa(()) (a.) values
(around 0.8). We use bold boxes to highlight the locations (e.g., "(22, 1)" refers to a²²) of top10 (oe.,1/7844 x top1.3%) attention heads. Surprisingly, 6 out of 10 = 60% heads overlap in the top10 heads for both correct and erroneous predictions (this overlap rate remains if we check the top20 heads). In addition, for all samples in San, collect the hidden states of all intermediate layers, (h')osiet. and use Logit Lens to decode them, (Jlagi tens (h')Josisz. with which we draw the average (descending) ranks and the average probabilities of the erroneously predicted tokens and the corresponding ground-truth tokens in Figure (fc. The purple shaded region, where the average ranks of both predicted tokens and ground-truth tokens shift from over 10 to within 10, highly aligned with the primary location of aw heads (layer 20 ~ 26) shown in (ggure/aabb) This consis- tency provides further evidence for our aw heads locating results and we demonstrate the superiority of our locating measure by comparing its consistency with previous methods in Appendix F3
Inspecting the aw heads Then we look into these aw heads: What information do they primar- ily encode? To answer this question, we step in to apply the Logit Lens to directly inspect these attention heads. We decode the at and a with all samples in Sur and observe that both of the er- roneously predicted tokens and corresponding ground-truth tokens rank among the top candidates:
ground-tul DARET only ralk prodeted Iskinn
gr bu SIRET Vn0 I predeced takes
groundiuut SARET KEg raly prodeced bakns
grordd Sakan onghtaly predicted takes
T0laon
toweh
(n) 22 original
(b) 22 after intervention
(c) original
(d) n after intervention
Figure 5: Decoding the information in aw heads: a² and a (a,c) and (b.d) show their top10 decoded tokens before (i.e., the original model) and after knocking out the processing head af.

---

Published as a conference paper at ICLR 2026
they averagely rank 2.47 and 4.33. In Figure c(,,),, we show the result with the logits of top10 candidates for a sample (see the result for all samples in Appendix F3). We conclude that: correct and erroneous predictions largely share answer-writing heads, which encode signals for both ground-truth and erroneous predictions. In error cases, the erroneous signals dominate, but the ground-truth signals still compete. We next investigate the information processing mechanisms in the maallowtto-midde layers that give rise to this competitive dynamic.
4.2 PROCESSING HEADS
Locating processing heads We identify attention heads that process input information and per- form reasoning latently ("processing heads") to contribute to token predictions at critical error po- sitions in reasoning hop generalization. Unlike aw heads, these processing heads: (i) influence the model's predictions indirectly, through intermediate reasoning that supports aw heads, and thus can act in all input token positions and (ii) exert a more fundamental impact on the model's final pre- diction, rather than directly writing prediction-related information into the residual stream. Based on these considerations, we adopt the knocking out method to intervene individual attention heads af at all token positions and measure the CIE (i.c., the Jkneck-on (a)) in Section 2 by the resulting change in the probability of the model's original prediction. We separately locate the processing heads for correct and erroneous predictions, correct and erroneous processing heads (in short, cp heads and ep heads, denoted as Hap and Hop. as illustrated in Figure I. by calculating the average CIE of Soo and Sem- The locating results are shown in Figure 6[a) (b), where approximately 2% heads with top average CIE values are highlighted with bold boxes. Analyzing the results, we first observe that knocking out some "basic heads" (i.e.. {aß (3.53 U ( (111,18) - HHasiee) would make the probabilities of original predictions (on both Scor and Sen) drop to near zero, indicating that they are commonly activated and play a basic role in extracting and processing basic and necessary information from the input to build up valid predictions, including both correct and erroneous ones.
Taking these heads away, the remaining processing heads (i.e., Hep and Hap) are almost entirely disjoint. Such decoupled mechanisms of controlling correct and erroneous predictions are ideal for us to steer the model to correct its reasoning errors.
Knocking out ep head can rectify the erroncous predictions We find that knocking out heads in Hep indeed can improve the probabilities of predicting ground-truth tokens. Specifically, measure the average CIE of knocking out every single head the prediction of ground-truth tokens on Sem: as shown in Figure (cc.. We observe: (i) knocking out heads in Hhasic is bad for the prediction of the ground-truth tokens and (ii) the highlighted heads with the 10 smallest average CIE values, knocking out which improves the probability of ground- truth token the most, perfectly align with Hep. Specifically, knocking out head E {aß af. al, a improves the average probability (E [0, 1) of predicting ground-trute tokens by approximately 0.6 on Sun. Moreover, to investigate such rectification effects can generalize to other samples, we randomly resample 100 erroneously predicted and 300 correctly predicted samples for Par and MDM tasks, respectively. Figure 7 shows the distribution of the probabilities of predicting ground-truth answers in these samples with the original and intervened (i.e., knocking out head E Hap) models (details in Appendix F.2 for both two tasks, knocking out individual ep heads can effectively rectify the model's 's originally erroneous prediction at critical token-level error positions in reasoning hop generalization while maintaining the originally correct predictions. To investigate whether the internal mechanisms of rectified and originally correct predictions are identical, the aw heads for these rectified predictions (San). To examine whether rectified predictions rely on the same internal mechanisms as originally correct ones, we re-locate cp heads and re-inspect aw heads for rectified samples (Ser). As shown in dd) the top15 cp heads overlap by 93.3% with those in Figure a)), indicating that rectified predictions largely share the reasoning mechanisms as correct ones. For aw heads (Figure (),,d)), we observe that ground-trutt information is amplified while the erroneous prediction suppressed the decoding distributions of a and af? Together, these findings support our hypothesis in Figure [] correct reasoning mechanisms (cp heads) exist within L.MMS but are suppressed by interactions with ep heads, leading to erroneous outputs; removing ep heads allows these mechanisms to rectify correct predictions.
re-locate cp heads and re-inspect
Discussion Our results have established that a greater number of reasoning hops is associated with more errors of some certain key types, while the competition between correct and erroneous
7

---

Published as a conference paper at ICLR 2026
Now
processing heads on Sto (Hop Prescc)
processing on (Hey U Mrese). (c) effect of knocking out single head on rectifying erroneous predictions.
reccoinning processing on Sen after knocking out head aq.
Figure 6: Locating processing heads for correct and erroneous predictions and measuring the effects of knocking out every single head predicting ground-truth tokens.
trajectories contributes these errors. Together, these findings suggest the hypothesis that addi- tional reasoning hops may intensity head competition, and we next discuss the reasons why this hypothesis holds. First, longer reasoning chains are typically accompanied by larger input scales (e.g., more operations mentioned in text, longer input lists in coding problems, or numbers with more digits) as well greater number of intermediate reasoning states that must be tracked dur- ing generation, which substantially enlarges the search space of retrieving the correct reasoning trajectories (i.e., Hep). Second, when the required hop length significantly exceeds what model has encountered during training (Dziri et al., 2023 Zhao et al. 2025) (i.c., reasoning hop gener- alization), these correct reasoning trajectories that the model has implicitly developed may fail to generalize more frequently: At certain key error positions, input contexts can still steer the model to follow Hep and produce correct predictions, but more often Hep is overridden by Hep. which may capture only local patterns that drive shortcut reasoning (Liu et al. 2023 errors (e.g., Repetition (Wang et al. 2024ab).
Li al. 2024) and lead to
TEST-TIME INTERVENTION TO CORRECT REASONING HOP GENERALIZATION ERRORS
Although our findings introduced in Section 4 can rectify many token-level erroneous predictions at critical error positions (Section 3 in the whole reasoning process in post-hoc way, we ask the research question RQ3: Can such method (i.c., knocking out individual ep heads) really dynamically correct erroneous predictions in the generation process and finally lead to the improvement of overall reasoning hop generalization performance? To answer this question, we separately investigate its two sub-questions: (i) how to automatically choose the individual attention heads to intervene (i.e., knock our)? and (ii) when to intervene the model? in the generation process.
Which attention heads to intervene? In the inference time, want to establish the correlation between target ep heads and the input context. To this end, we train a small model to automatically select target ep head among candidate head set H conditioned model this as a multi-label classification task with a variable number of positive labels: input is the input context Iz, output is a label y; E {0, 1) | (for k E [H] 1], if knocking
the input context. We further
H[K] can
correct the prediction 24, then y: [k] = 1 otherwise [k] 0) and D = {(x,, 9:) is the training As for the training objective, among BCE loss, BPR loss (Rendle et al. 2012). ZLPR loss (Su
Parity-NL (Error Samples) Parity-NL (Correct Samples)
MDM (Error Samples)
MDM (Correct Samples)
1.0
Proportion
0.0
0.2 0.4 0.5 0.8 1.0
0.2 0.4 0.6 08 1.0
0.2 0.4 0.6 0.8 1.0 Probabiiity
0.2 0.4 0.5 0.8 1.0 Probability
Probability
Probability
original prob, distribution
Intervened prob. distribution
Figure 7: Probability distribution of ground-truth answers before and after model intervention.
8

---

Published as a conference paper at ICLR 2026
Table 1: @it@| I in the in-distribution ("i.d.") and out-of-distribution ("o.o.d.") evaluation of the
trained classifiers. "Random Guessing": the baseline of randomly selecting candidate head.
Model
Qwem2.5-7B-Instruue
Phi-3-Instruct Ld.
LLMMA3-88IInstrut
Qwen3-S9I-nntrrnc 0.o.d.
Testing Type
I.d.
0.0.d.
0.o.d.
l.d.
0.o.d.
Ld.
Random Guessing
42.3%
32.2%
20.8%
25.8%
23.6%
27.0%
23.0%
19.1%
Trained Classifier
79.6%
53.4%
75.2%
58.2%
80.8%
35.5%
87.2%
83.2%
et al. 2022) and multi-label Softmax loss (Pu et al. 2025), we find that the last one consistently achieve the best generalization performance. We fine-tune the pre-trained Qwen2.5-0.5B model
with a randomly initialized classification head (denoted as so(-)) with LoRA (Hu et al. 2022) for
this task. Our training objective can be formalized as ming B(za))DD log( log(exp((eeaa (xp()o (4)
Motivated by our earlier observation that diverse tasks and ervor types often map onto shared subset of ep heads, we maintain a compact candidate set H per model. Following Section 4 we lo- cate Hap across five representative hop-generalization tasks (Parity-NI., MDM, LLC,, CLF, MOAS), and select a subset such that (i) each head is implicated in multiple error types, and (ii) the set col- lectively covers all key error types (see Appendix G.I This yields |H] 8 for Qwen2.5-7B, for Phi-3 and Qwen3-8B, and 10 for LLaMA3-8B. We use erroneous predictions from Parity-NL. MDM, LLC, CLF, and MOAS for training and in-distribution testing, and from ObjC and NumS for distr--idittiittiinn testing. More details can be found in Appendix G.2 To evaluate the head logits and
selector, we report Hit@1 1 accuracy (sampling one head from the checking whether it belongs to the positive class) which directly reflects its intended use. As shown in Table [] the trained classifiers substantially outperform random baselines on in-distribution tasks and also generalize well to out-of-disstibuutio tasks. This suggests that erroneous predictions from diverse tasks and error types can often be corrected by intervening the same head, indicating a shared internal error mechanism.
When to intervene the model? During decoding, we adopt a simple uncertainty-basee detector to decide when to intervene. Specifically, we monitor the predictive entropy of each generated to- ken, leveraging our earlier finding (Section and Appendix [F.I] that errors at key positions exhibit systematically higher entropy than correct predictions. A fixed threshold 7 is applied: if token's entropy exceeds т, the trained classifier selects one head from H to knock out; otherwise, decod- ing proceeds normally. Our detection design is intentionally simple, as detection is orthogonal to correction and has been extensively studied in the ballucinationn-dtectioo literature (Kadavath et al.) 2022 Kirchhof et al. 2025 Zhang al. 2025c Fu al. 2025 Obeso et al.) 2025). To isolate the effect of our correction method, we additionally evaluate a gold-detector setting where an oracle provides exact error locations (Section 3. revealing the full rectification potential of TCR.
Dynamically Correct Reasoning Hop Generalization Errors Based above explorations, we propose Test-time Correction of Reasoning (TCR), a lightweight test-time intervention method to automatically rectify reasoning hop generalization errors, which incorporate (i) fixed entropy threshold to detect token-level erroneous predictions and (ii) our trained classifier to identify the heads in H to be knocked out. Each time we trigger TCR, select the top3 heads predicted by the classifier, separately knock out these heads and use majority-vote to determine the final correction result. We also include the variant of TCR with the gold detector, TCR-gold, to fully unleash the rectifying potential of TCR. Table 2 presents the average accuracy (over three random seeds) of TCR and TCR-gold on seven reasoning hop generalization tasks and four LLMs compared against original model outputs and DoLa (Chuang et al., 22024). a decoding- -based hallucination mitigation method. Each task uses 100 test instances, with small number of invalid generations (c.g., direct answers without reasoning) excluded. (i) TCR consistently improves over baseline generation. For instance, achieves large gains on Parity-NI. with Qwen2.5 (+12.1%) and LLaMA3 (+12.0%), on MOAS with LLaMA3 (+16.5%) and on ObjC with Phi-3 (+14.1%). On average, TCR improves accuracy by 5% ~ 7% across tasks and models. TCR-gold, with oracle error localization, demon- strates the method's 's potential: for Qwen2.5, accuracy improves nearly 20% (41.7% + 61.3%). In contrast, DoLa yields only marginal or negative effects in these reasoning settings. (ii) Qwen3 exhibits strong performance room for further improvement (likely due to reasoning-oriented oriented reinforcement learning (Chu et al, 2025)). ). However, in more challenging tasks, such MDM, TCR-gold improves accuracy by 22.4%.
certain tasks (e.g., Parity-NL and NumS above 98%), leaving little
9

---

Published as a conference paper at ICLR 2026
Table 2: The performance of TCR and -CR-gold on seven tasks with four LLMs.
Method
Parity-NI,
MDM
LLC
CLF
MOAS
ObjC
NumS
Average
Qwen2.5.7B 5
48.3%
43.0%
11.7%
56.8%
39.2%
52.0%
41.1%
41.7%
-Duaag et al.
2024
58.1%
38.5%
8.0%
52.3%
40.0%
52.3%
48.7%
42.6%
+TCR (ours)
60.4% 4%
48.2%
16.2%
66.6%
46.0%
56.0%
46.0%
48. 48.5% 6.88%)
+ICR-gold (ours)
81.2%
58. 38.3%
23. 03.0%
71.3%
62.0%
76.0%
54.5%%
61.3% (-19.6%)
Phi-3-Instruct
51.2%
8.1%
53.1%
9.2%
1.0%
30.9%
72.0%
32.2%
+ +Dol.a(Chuang et al. 2024
25.8%
6.7%
29.5%
7.6%
1.0%
29.0%
72.0%
24.5%
+TCR (ours)
55. 8%
11.5%
56. 56.1%
11. 22%
4.0%
45.0%
76. 0%
37 37.1%
+TCR-gold (ours)
67. 2%
15.8%
159.6%
20.3%
4.0%
41500%
82.0%
41. (+-9.5%4))
70.0%
0.0%
81.0%
15.2%
22.9%
68.8%
4.5%
37.5%
CChan et 2024
71.6%
0.0%
71.2%
8.8%
71.2%
6.9%
37.1%
+TCR (ours)
0%
0.0%
82.3%
2%%
39 39.4%
67.8%
7.8%
43. 9% 6.44%
+TCR-gold (ours)
88.0 08%
0.0%
90.7%
32, 7%
47.0%
76.4%
10.1%
49.9 19.3%
11.8%)
Qwem3-SB-Inntrmect
98.7%
21.7%
67.5%
96.9%
92.7%
83.0%
98.0%
80.5%
DooLaaChuang et al.
2024
100.0%
9.0%
57.0%
94.4%
89. 70%
82.7%
98.0%
75.8%
+TCR (ours)
100.0%
29.3%
68.0%
97.0%
93.6%
88. 1%
99.0%
82. 1..11% (+
+TCR-gold (ours)
100.0%
47.1%
71.0%
99.0%
95.8%
90.0%
100.0%
86. 86.1%((+-. 6%)
and both TCR and TCR-gold deliver consistent gains across other tasks. These results underscore the robustness and generality of TCR, even for stronger models.
Parity-NL
MDAS
MDM
OldC
1.0
1.0
Accuracy
0.8
0.8
0.8
0.8-
0.85
3.4
0.55
0.4
0.4
0.4
0.2
0.50
10
20
30
40
50
10
40
10
20
30
40
50
Reasoning Hop Number
Reasoning Hop Number
Reasoning Hop Number
Reasoning Hop Number
Original
TCR
TCR
Figure 8: Performance of TCR and -oR- changing with reasoning hop number.
Analyzing the Peformance of TCR We further conduct analytical experiments on Qwen2.5-7B. Instruct to better understand the behavior of TCR. Figure shows that both TCR and -CR- consistently improve reasoning hop generalization across Parity-NL, MOAS, MDM, and ObjC tasks of varying hops. Besides, natural baseline is the logit of the model's original prediction from the final hidden state and re-samples the output. As shown Figure 16 a). RR yields only marginal gains on Parity-NL but substantially degrades performance on MDM and CLF, highlighting the superiority of TCR. Finally, to assess the role of the trained head selector, we compare with a random head selector. Figure T6(b) shows that both TCR counterparts
(RR), which removes
and TCR-gold with the trained selector consistently outperform their on Parity-NL, MDM, and CLF, confirming the effectiveness of our design.
CONCLUSION
In this work, we systematically studied the mechanisms of reasoning hop generalization failures in LLMs. We found that these failures concentrate token positions of a few key error types rather than being uniformly distributed across reasoning chains. Probing model internals at these positions further revealed a competition mechanism: correct and erroneous reasoning trajectories co-exist, while the erroneous ones can suppress the correct ones, eventually leading to errors. Based on these insights, proposed TCR, a lightweight intervention method that dynamically identifies and deactivates these heads at test-time and demonstrate its effectiveness through extensive experiments.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGEMENT
This work was supported in part by grants from the National Natural Science Foundation of China (No. U24A20253), Scientific Research Innovation Capability Support Project for Young Faculty, the Research Grants Council of the Hong Kong SAR under Grant GRF 11217823, 11216225, and Collaborative Research Fund C1042- the National Natural Science Foundation of China under Grant 62371411, InnoHK initiative, the Government of the HKSAR, Laboratory for Al-Powered Financial Technologies.
ETHICS STATEMENT
This work conducts mechanistic analyses of large language models using only publicly available open-source models and widely adopted reasoning benchmarks. No human subjects, private data, or personally identifiable information are involved. Our interventions (e.g.. test-time correction) designed purely for academic understanding and evaluation, without deployment in sensitive applications. We acknowledge that improving reasoning capabilities of LLMs may carry dual-use concerns, but our study focuses on fundamental error mechanisms and lightweight interventions, aiming to advance transparency and reliability in LLM reasoning research.
REPRODUCIBILITY STATEMENT
We have taken several steps to ensure reproducibility of our results. All models used in this work are publicly available open-source LLMs, and the datasets and benchmarks are well-documented in the appendix. Details of our experimental setup, training configurations, and evaluation protocols are provided the main text and Appendix.
REFERENCES
Alibaba. Qwen2.5 technical report, 2025a. URL UlL.tttss///ar....rrr////////2..
Alibaba. Qwq-32b: Embracing the power of reinforcement learning, March 2025b. URL https:
7/qwenlm. www.ggithhhh.... wtt.thh.....ooo......... qwq 32b/
Alibaba. Qwen3 technical report, 2025c. UBL.ttppss//aabb..orr//ab//
Cem Anil, Yuhuai Wu, Anders Andreassen, Aitor Lewkowyez, Vedant Misra, Vinay Ramasesh, Am- brose Slone, Guy Gur-Ari, Ethan Dyer, and Behnam Neyshabur. Exploring length generalization in large language models. Advances Neural Information Processing Systems, 35:38546-38555 2022.
Anthropic. Claude 3.7 sonnet and claude code anthropic.com. https: http://wwwwattthp..ooo
com/ news/ claude 3 3-7-sonnet 2025.
Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization, 2016. URL
Tanja Baeumel, Josef van Genabith, and Simon Ostermann. The lookahead limitation: Why multi- operand addition is hard for Ilms, 2025. URL
2502 19981
Guangsheng Bao, Hongbo Zhang, Cunxiang Wang. Linyi Yang, and Yue Zhang, How likely do llms with cot mimic human reasoning?, 2024. URL.
wwtpxxii.org/bbs///o abs//4/2/22222 16048
Nora Belrose, Igor Ostrovsky, Lev McKinney, Zach Furman, Logan Smith, Danny Halawi, Stella Biderman, and Jacob Steinhardt. Eliciting latent predictions from transformers with the tuned lens, 2025.
Leonard Bereska and Stratis Gavves. Mechanistic interpretability for Al safety review. Transac- tions on Machine Learning Research, 2024. ISSN 2835-8856. URL httttps://ppeneeee Survey Certification, Expert Certification.
11

---

Published as a conference paper at ICLR 2026
Vivien Cabannes, Charles Arnal Wassim Bouaziz, Xingyu Yang, Francois Charton, and Julia Kempe. Iteration head: A mechamistic study of chain-of -f-huught.. Advances in Neural Infor- mation Processing Systems, 37:109101-109122. 2024.
Qiguang Chen, Libo Qin, Jiaqi Wang, Jingxuan Zhou, and Wanxiang Che. Unlocking the capa- bilities of thought: A reasoning boundary framework to quantify and optimize chain-of-though.. Advances in Neural Information Processing Systems, 37:54872-54904, 2024.
Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V Le, Sergey Levine, and Yi Ma. SFT memorizes, RL generalizes: A comparative study of founda- tion model post-training. In Forty-second International Conference on Machine Learning, 2025. URL http:httss//ppeeevvvieeee
net/
/treet/foooeee forum? id=
Yung-Sung Chuang. Yujia Xie, Hongyin Luo, Yoon Kim, James Glass, and Pengcheng He. Dola: Decoding by contrasting layers improves factuality in large language models. In The Twelfth International Conference on Learning Representations, 2024. URL httthhttp///peee /ottps::/openreview.
met/fozee id Th6NyLO 7na
Bilal Chughtai, Alan Cooney, and Neel Nanda. Summing up the facts: Additive mechanisms behind factual recall in llms, 2024. Utthttps::// wwwpeii..rrr..oooooo abs /20p////422..2 22202222222211111
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems, 2021. URL https://arxiv:
brg/abs/2110.1411
Katherine M. Collins, Catherine Wong, Jiahai Feng, Megan Wei, and Joshua B. Tenenbaum. Struc- tured, flexible, and robust: benchmarking and improving large language models towards more human-like behavior in out-of-distribution reasoning tasks, 2022. URL https://arxiv.
org/ htg/abs/2205... 05718
Guy Dar, Mor Geva, Ankit Gupta, and Jonathan Berant. Analyzing transformers in embedding space. In Anna Rogers, Jordan Boyd-Graher, and Naoaki Okazaki (eds.), Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volune 1: Long Pa- pers). pp. 16124-16170, Toronto, Canada, July 2023. Association for Computational Linguis- tics. doi: 10. 10.18665//112023.acllooom acl-iong. 893/
URL https: httpps::/aallmmhhooooooooo//////
Adrian de Wynter, Is in-context learning learning?, 2025. URL https:://erxiv.orgg////
2509.10414
DeepSeek, Deepseck-rl: Incentivizing reasoning capability in Ilms via reinforcement learning, 2025.
Ronald B. Dekker, Fabian Otto, and Christopher Summerfield. Curriculum learning for hu- man compositional generalization. Proceedings of the National Academy of Sciences, 119(41): e2205582119, 2022. doi: 10. 10.1073/pnas. abs/10.1073/ /ww.0///paa....m 2205582119
URL htt.httts:///e. http::/wwwwwpp...s. org/
Subhabrata Dutta, Joykirat Singh, Soumen Chakrabarti, and Tanmoy Chakraborty. How to think step-by-step: A mechanistic understanding of chain-of-thought reasoning. arXiv preprint arXiv:2402.18312. 2024.
Nouha Dziri, Ximing Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jiang, Bill Yuchen Lin, Sean Welleck, Peter West, Chandra Bhagavatula, Ronan Le Bras, et al. Faith and fate: Limits of trans- formers compositionality. Advances in Neural Information Processing Systems, 36:70293- 70332, 2023.
Nelson Elhage, Neel Nanda, Catherine Olsson, Tom Henighan, Nicholas Joseph, Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Nova DasSarma, Dawn Drain, Deep Ganguli, Zac Hatfield-Dodd: Danny Hernandez, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris Olah. A mathematical framework for transformer circuits. Transformer Circuits Thread, 2021.
12

---

Published as a conference paper at ICLR 2026
Ekaterina Fadeeva, Aleksandr Rubashevskii, Artem Shelmanov, Sergey Petrakov, Haonan Li, Hamdy Mubarak, Evgenii Tsymbalov, Gleb Kuzmin, Alexander Panchenko, Timothy Baldwin, Preslav Nakov, and Maxim Panov. Fact-checking the output of large language models via token- level uncertainty quantification. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Findings of the Association for Computational Linguisties: ACI. 2024, pp. 9367-9385, Bangkok, Thailand, August 2024, Association for Computational Linguistics. doi: 10. 10.18653/v1/0244 findings-acl.5555 ac1.558. URL aattps://acaanthooogge wtgp wtt.:/2......iniiii.niiii findings acl.5581
Ying Fan, Yilun Du, Kannan Ramchandran, and Kangwook Lee. Looped transformers for length generalization. In The Thirteenth International Conference on Learning Representations, 2025. URL httptttss///penreeieee net/ / forum? wedimmmiddddddddeeeee
Yichao Fu, Xuewei Wang. Yuandong Tian, and Jiawei Zhao. Deep think with confidence, 2025.
URL https://axxiv. org/ abs 2500. 15260
Mor Geva, Jasmijn Bastings, Katja Filippova, and Amir Globerson. Dissecting recall of factual associations in rugo-regressive language models. In Houda Bouamor, Juan Pino, and Kalika Bali (eds.), Proceedings of the 2023 Conference on Empirical Methods in Natural Language Pro- cexsing, pp. 12216-12235, Singapore, December 2023. Association for Computational Linguis- tics. doi: 10. maanpp-main... 751/
https: ac antho anthology.oom orgg2///333
Asma Ghandeharioun, Avi Caciularu, Adam Pearce, Lucas Dixon, and Mor Geva. Patchscopes: A unifying framework for inspecting hidden representations of language models, 2024. URL
https://azzt /ttp://wwww....///////.......... /0t.:////20.0000.
Anthony JF Griffiths. An introduction to genetic analysis. Macmillan, 2005.
Stefan Heimersheim and Neel Nanda. How to use and interpret activation patching, 2024. URL
https://arxiv org.
/bsr//////////e//e//////////aae/ abs 15255
Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. Lora: Low-rank adaptation of large language models. ICLR, 1(2):3, 2022.
Yi Hu, Shijia Kang, Haotong Yang, Haotian Xu, and Muhan Zhang. Beyond single-task: Robust multi-task length generalization for Ilms, 2025, URL /ettp::/aaxxv..or///ee wttpxxxwi..rr/b///52...
11525
Gangwei Jiang, Caigao JIANG, Zhaoyi Li, Siqiao Xue, JUN ZHOU, Linqi Song, Defu Lian, and Ying Wei. Unlocking the power of function vectors for characterizing and mitigating catastrophic forgetting in continual instruction tuning. In The Thirteenth International Conference on Learning Representations, 2025. BtRhttps:: wwtp///peeee....eooeoooeee hwt.:/eeeeeeeeeee fort//foum?? wwt.:/ooeemmmmemec0c000eeeeee G=gGBQAQEXVV
Saurav Kadavath, Tom Conerly, Amanda Askell, Tom Henighan, Dawn Drain, Ethan Perez, Nicholas Schiefer, Zac Hatfield-Dodds, Nova DasSarma, Eli Tran-Johnson, Scott Johnston, Sheer El-Showk, Andy Jones, Nelson Elhage, Tristan Hume, Anna Chen, Yuntao Bai, Sam Bow- man, Stanislav Fort, Deep Ganguli, Danny Hernandez, Josh Jacobson, Jackson Kernion, Shauna Kravec, Liane Lovit, Kamal Ndousse, Catherine Olsson, Sam Ringer, Dario Amodei, Tom Brown, Jack Clark, Nicholas Joseph, Ben Mann. Sam McCandlish, Chris Olah, and Jared Ka- plan. Language models (mostly) know what they know, 2022. URL httpps:/arxxv. org/
2bss/207..m 05221
Amirhossein Kazemnejad, Inkit Padhi, Karthikeyan Natesan, Payel Das, and Siva Reddy. The im- pact positional encoding on length generalization in transformers. Thirty-seventh Confer- ence on Neural Information Processing Systems, 2023. URL htttps://///t http:///peeeeeeee.eeeeee SerrmmiddDrr12gge
Najoung Kim and Tal Linzen. COGS: A compositional generalization challenge based on se- mantic interpretation. In Bonnie Webber, Trevor Cohn, Yulan He, and Yang Liu (eds.), Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 9087-9105, Online, November 2020. Association for Computational Linguis- tics. doi: 10. 10.18653/v111 http:/55sl112220mmmmmmmmmmmmama 731. URL ht httpp::/// http::::///.aaaattoooooooo..////
lemn p ma i 7317]
13

---

Published as a conference paper at ICLR 2026
Michael Kirchhof, Luca Füger, Adam Goliñski, Eeshan Gunesh Dhekane, Amo Blaas, and Sinead Williamson. Self-reflective uncertainties: Do llms know their internal answer distribution?, 2025. URL
abs 250.. 20295
Brenden M. Lake and Marco Baroni. Human-like systematic generalization through meta-learning neural network. Nature, 623(7985):115-121, Nov 2023. ISSN 1476-4687.
doi: 10.
$41186-023-066688- URLhttts:://aoi.ooo
1038/ /130///11188/00 41586- 00155586-23---00 023-06668-11
Zhaoyi Li, Ying Wei, and Defu Lian. Learning to substitute spans towards improving compositional generalization. In Anna Rogers, Jordan mryd-Graber, and Naoaki Okazaki (eds.), Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Pupers), pp. 2791-2811, Toronto, Canada, July 2023. Association for Computational Linguis- tics. doi: (0.18653/v1/2222 acl-o2o..al--oo.1555 157. URL https: wwwellnthhlloooo logy. org/2023.
sel-iong. 157/
Zhaoyi Li, Gangwei Jiang, Hong Xie, Linqi Song, Defu Lian, and Ying Wei. Understanding and patching compositional reasoning in LLMs. Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Findings of the Association for Compulational Linguistics: ACL 2024, pp. 9668-9668 Bangkok, Thailand, August 2024. Association for Computational Linguistics. doi: 10.18653/ v1/2024. 11/202..indings-all.7777 URL URI.htt.pa htt.::ttt////tt antho lont org/2024. ooggo/onoonooogoooo//02222222 576/]
Findings-aci
Zhaoyi Li, Gangwei Jiang, Chenwang Wu, Ying Wei, Defu Lian, and Enhong Chen. Learning to substitute components for compositional generalization, 2025. URL bttps::/arxxii org/ abs fos/2502..r 20834
Stephanie Lin, Jacob Hilton, and Owain Evans. TruthfulQA: Measuring how models mimic human falsehoods. Smaranda Muresan, Preslav Nakov, and Aline Villavicencio (eds.), Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 3214-3252, Dublin, Ireland, May 2022. Association for Computational Linguis- tics. doi: 10. (0.118653/11/2222acllll 229. URL
ac ong. 2297
Bingbin Liu, Jordan T. Ash, Surbhi Goel, Akshay Krishnamurthy, and Cyril Zhang. Transformers learn shortcuts to automata. In The Eleventh International Conference Learning Representa- tions, 2023. URL https://cpenzevierg Det.r//wwwe.eeee..omm.oaaoooooo.
Andrea Matarazzo and Riccardo Torlone. A survey on large language models with some insights on their capabilities and limitations. arXiv preprint arXiv:2501 250::044000000, 2025.
Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. Locating and editing factual asso- ciations in GPT. In Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho (eds.), Advances Neural Information Processing Systems, 2022. URL httpt::t///// /tttps:///penrrviiew.
feet/Eorum220 how.s==-hwW5eee
Meta. The llama herd of models. arXiv preprint arXiv:2407.21788. 2024.
Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one? In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019a. URL htttps://prroceeddggss.tt Fi fiee/2600u022330ccc22376ccceeee2
wapprrrrppppppppepeeeeeeeeeeeeee ftt.ss/pappee//1119// pdf
Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one? Advances in neural information processing systems, 32, 2019b.
Microsoft. Phi-3 technical report: A highly capable language model locally on your phone, 2024.
URL http::tttt//tttie /tts:://axxvv.ovr..e abs 24/.244444..111
Seyed Iman Mirzadeh, Keivan Alizadeh, Hooman Shahrokhi, Oncel Tuzel, Samy Bengio, and Mehrdad Farajtabar. GSM-symolli:: Understanding the limitations of mathematical reasoning in large language models. In The Thirteenth International Conference on Learning Representations, 2025. URL URI.https: http://wwwww..eeeeoooooooaaaaaaa
14

---

Published as a conference paper at ICLR 2026
nostalgebraist.
interpreting gpt: the logit lens.
https://ww.. http::/wwwwwwwwww....... wwtprionn.ccoooooooo 2020.
Oscar Obeso, Andy Arditi, Javier Ferrando, Joshua Freeman, Cameron Holmes, and Neel Nanda. Real-time detection of hallucinated entities in long-form generation, 2025. URL https://
arxiv.org/ 2 03531
Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan, Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli, Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris Olah, In-context learning and induction heads, 2022. https://///ax
bbbs/2009.11 11895
OpenAL. Openai ol system card, 2024. URL ULLjtttss///exx....or//////2/21.
OpenAl. Introducing openai 03 and 04-mini openai.com. https://gpenai.com///
introducing o3 and minii/ 2025.
Yuanhao Pu, Defu Lian, Xiaolong Chen, Jin Chen, Ze Liu, and Enhong Chen. Understanding the effect of loss functions on the generalization of recommedattions.
Proceedings of the 31 ACM
SIGKDD Conference Knowledge Discovery and Data Mining V.I. KDD '25, pp. 127-11137 New York, NY, USA, 2025. Association for Computing Machinery. ISBN 9798400712456, doi: 10.114573690644437001666 URL htttht:::///ag org/ 10. 1111144555624.31711
Steffen Rendle, Christoph Freudenthaler, Zeno Gantner, and I Lars Schmidt-Thieme. Bpr: Bayesian personalized ranking from implicit feedback. arXiv preprint arXiv: /20xxv:2200.000 22.../25522266 2012.
Mansi Sakarvadia, Aswathy Ajith, Arham Khan, Daniel Grzenda, Nathaniel Hudson, André Bauer, Kyle Chard, and Ian Foster. Memory injections: Correcting multi-hop reasoning failures during inference in transformer-basee language models, 2024. URL
2309. 05605
Parshin Shojace, Iman Mirzadeh, Keivan Alizadeh, Maxwell Horton, Samy Bengio, and Mehrdad Farajtabar. The illusion of thinking: Understanding the strengths and limitations of reasoning models via the lens of problem complexity, 2025. URL pdff
cdn-apple.
Petr Slavik. tight analysis of the greedy algorithm for set cover. Journal of Algorithms, 25(2):
237-254, 1997. ISSN 0196-6774. doi: https://do..org/11 100p//...00/jjammmm.. 199p:///w.....9999...9999 1997 .0887. URL https::::
//www.co www.sscciineceeeeeeeee.eeeeeeeee com htt.://eeeeeeeeccceeeeeeeeee///e wttp.///eiieeeeeattaaaa/////////
Alessandro Stolfo, Yonatan Belinkov, and Mrinmaya Sachan. A mechanistic interpretation of arithmetic reasoning language models using causal mediation analysis. Houda Bouamor, Juan Pino, and Kalika Bali (eds.), Proceedings of the 2023 Conference Empirical Meth- ods in Natural Language Processing, pp. 1035-7052, Singapore, December 2023. Associa- tion for Computational Linguistics. doi: 10. 10.18653/v1/2022 10t/:////222.../// www.:mmmmmmmmmmmmm.... w/aclantholoog.orrg////
URL https:
wwwnl-mmaae main. 435/|
Jianlin Su, Mingren Zhu, Ahmed Murtadha, Shengfeng Pan, Bo Wen, and Yunfeng Liu. Zlpr: A novel loss for multi-label classification, 2022. URL
02955
Yiyou Sun, Shawn Hu, Georgia Zhou, Ken Zheng, Hannaneh Hajishirzi, Nouha Dziri, and Dawn Song. Omega: Can iims reason outside the box in math? evaluating exploratory, compositional, and transformative generalization, 2025. URL htttps://aat
http:///ggggaaab.oooobs 18880 18880
Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc V. Le, Ed H. Chi. Denny Zhou, and Jason Wei. Challenging big- bench tasks and whether chain-of -hhhughh can solve them, 2022. URL TRLhttpp https::s.... http://axxvvvv./o abs / /221 0. 09261
15

---

Published as a conference paper at ICLR 2026
Eric Todd, Millicent Li, Arnb Sen Sharma, Aaron Mueller, Byron C Wallace, and David Bau. Function vectors in large language models. In The Tweifth International Conference on Learning Representations, 2024.
Kevin Ro Wang. Alexandre Variengien, Arthur Conmy, Buck Shlegeris, and Jacob Steinhardt. Interprctaiility in the wild: a circuit for indirect object identification in GPT-2 small. In
The Eleventh International Conference on Learning Representations, 2023. URL https:
//openreview. http://eetttttoommmeaeeaaaaaaaaa
Shenzhi Wang, Le Yu, Chang Gao, Chujie Zheng, Shixuan Liu, Rui Lu, Kai Dang, Xionghui Chen, Jianxin Yang, Zhenru Zhang, Yuqiong Liu, An Yang, Andrew Zhao, Yang Yue, Shiji Song, Bowen Yu, Gao Huang, and Junyang Lin. Beyond the 80/20 rule: High-entropy minority tokens drive effective reinforcement learning for Ilm reasoning, 2025. URL WRRLtttps//xxxi.rr//////
Weichuan Wang, Zhaoyi Li, Defu Lian, Chen Ma, Linqi Song, and Ying Wei. Mitigating the lan- guage mismatch and repetition issues in LLM-based machine translation via model editing. In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (eds.), Proceedings of the 2024 Confer- ence on Empirical Methods in Natural Language Processing, pp. 15681-15700, Miami, Florida, USA, November 2024a. Association for Computational Linguistics. doi: 10.18653/v1/2024 emnlp-main.87
ortp:///looo..//2222222 emn 1ammmal-mmnmmm 8797
Zhiwei Wang, Yunji Wang, Zhongwang Zhang. Zhangchen Zhou, Hui Jin, Tianyang Hu, Jiacheng Sun, Zhenguo Li, Yaoyu Zhang, and Zhi-Qin John Xu. The buffer mechanism for multi-step information reasoning in language models, 2024b. hRtp:tts:///aart
15302
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, brian ichter, Fei Xia, Ed Chi, Quoc Le. and Denny Zhou. Chain-of-though prompting elicits reasoning in large language models. In S. Koyejo, S. Mohamed, A. Agarwal, D. Belgrave, K. Cho, and A. Oh (eds.), Advances in Neural Information Processing Systems, volume 35, pp. 24824 24837. Curran Associates, Inc., 2022. URL http://tsss/pppoeennnnnneererrrr http:://ppccccooooo.ccoooooaooaa File/9d56096 http://600661132eefffffaafaaaaf.
abca Paper Conferenceeeecccceeemmmoe fdd
Changnan Xiao and Bing Liu. Generalizing reasoning problems to longer lengths. In The Thirteenth International Conference on Learning Representations, 2025.
Shaotian Yan, Chen Shen, Wenxiao Wang, Liang Xie, Junjie Liu, and Jieping Ye. Don't 't take things out of context: Attention intervention for enhancing chain-of-thought reasoning in large language models. arXiv preprint arXiv:2503.11154 2025.
Xinhao Yao, Ruifeng Ren, Yun Liao, and Yong Liu. Unveiling the mechanisms of explicit cot train- ing: How thain-of-thoughe enhances reasoning generalization. arXiv preprint arXiv:2502.04600 04667,, 2025.
Tian Ye, Zicheng Xu, Yuanzhi Li, and Zeyuan Allen-Zhu. Physics of language models: Part 2.1, grade-school math and the hidden reasoning process. In The Thirteenth International Conference on Learning Representations, 2024.
Edward Yeo, Yuxuan Tong, Morry Niu, Graham Neubig, and Xiang Yue. Demystifying long chain- of-thought reasoning in 1lms, 2025. htRLhhtss:://aaa
org/ hbtp://a.///.....ee/ 03373
Fangcong Yin, Xi Ye, and Greg Durrett. Lofit: Localized fine-tuning on Ilm representations. Ad- vances in Neural Information Processing Systems, 37:9474- 9506, 2024.
Zeping Yu and Sophia Ananiadou. Neuron-level knowledge attribution in large language models. In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (eds.), Proceedings of the 2024 Conference Empirical Methods in Natural Language Processing, pp. 3267-3280, Miami, Florida, USA, November 2024. Association for Computational Linguistics. doi: 10. 10.18653/v1/0024.cmm main. 191. URL https:tppp...c....... //acl anthologya. org 2024 emn p n.. 1
16

---

Published as a conference paper at ICLR 2026
Tunyu Zhang, Haizhou Shi, Yibin Wang, Hengyi Wang, Xiaoxiao He. Zhuowei Li, Haoxian Chen, Ligong Han, Kai Xu, Huan Zhang, Dimitris Metaxas, and Hao Wang. Tokur: Token-level un- certainty estimation for large language model reasoning, 2025a. URLhttpst http:://aaxxvvvoeeee org/
abb/2505. 11737
Yifan Zhang, Wenyu Du, Dongming Jin, Jie Fu, and Zhi Jin. Finite state automata inside trans- formers with thouuht A mechanistic study on state tracking, 2025b. URL https:
//axxiv.or//aateat.. 22500 20t.//222222222
Zhenliang Zhang, Xinyu Hu, Huixuan Zhang, Junzhe Zhang, and Xiaojun Wan. ICR probe: Track- ing hidden state dynamics for reliable hallucination detection LLMs. In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilchvar (eds.), Proceedings of the 63rd An- mual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). pp. 17986- 8002, Vienna, Austria, July 2025c. Association for Computational Linguistics. ISBN 979-8-89176-251-0. doi: 10. 1/255///1/12..alllooogg org/2025.acl 1oce-l--ong long. 880/
URL hu..httpss/aallatthl.og.
Chengshuai Zhao, Zhen Tan, Pingchuan Ma, Dawei Li, Bohan Jiang, Yancheng Wang, Yingzhen Yang, and Huan Liu. Is chain-of-thought reasoning of Ilms mirage? data distribution lens. arXiv preprint 1911 2025.
Tianshi Zheng, Yixiang Chen, Chengxi Li, Chunyang Li, Qing Zong, Haochen Shi, Baixuan Xu, Yangqiu Song, Ginny Y. Wong, and Simon See. The curse of cot: On the limitations of chain-of- thought in in-context learning, 2025. Utthttss:://att
org/ abs /504 05081
Yongchao Zhou, Uri Alon, Xinyun Chen, Xuezhi Wang, Rishabh Agarwal, and Denny Zhou. Trans- formers can achieve length generalization but not robustly, 2024. htRh:tts:: /aaxxixxxvvorg.......e....... abs/ 2oss/240..m 09371
17

---

Published as a conference paper at ICLR 2026
APPENDIX CONTENTS (WITH MAIN TEXT)
Introduction
Preliminaries
Breakdown of Reasoning Hop Generalization Errors
4
Probing Internal Mechanisms of Key Error Types
Answer- Answer-Writing Heads
4.2
Processing Heads
5
Time Intervention to Correct Reasoning Hop Generalization Errors
Conclusion
10
The Use of Large Language Models
20
Limitations and Discussion
20
Related Work
20
D Tasks, Data and Models
21
D. Tasks and Data
21
D.2 Models
23
Additional Information about Linking Overall Reasoning Hop Generalization Perfor- mance Decline Specific Error Types
24
E.1 Error Types of Each Task
24
E.2
Identifying Key Error Types for Each Task
24
F
Additional Information about Probing Internal Mechanisms of Key Error Types in
Reasoning Hop Generalization
26
F1
Key Reasoning Errors Accompanied by Teven-level Uncertainty Larger Uncertainty
26
Detailed Experiment Setting
27
F3
Additional Results about Locating and Analyzing Answer- Writing Heads
28
Additional Results about Locating and Analyzing Processing Heads
30
Additional Information about Test-Time Intervention to Correct Reasoning Hop Gen-
eralization Errors
31
G.I
Identifying Candidate Erroneous Processing Head Sets
G.2
Head Selector Training Details
32
G.3
The details of TCR and DoLa experiments
33
G.4
Analytical Experiment: Ablation Study of TCR
34
G.5
Comparing TCR and LOFIT on improving reasoning hop generalization
34
18

---

Published as a conference paper at ICLR 2026
G.6
Comparing TCR and Training the base model itself improving reasoning hop generalization
35
G.7
Experiment with Larger Model
35
G.8
The performance of TCR on the Natural Language Reasoning Task
36
G.9
Examining the Reasoning Models
36
Figures For the Appendix Sections
38
19

---

Published as a conference paper at ICLR 2026
A THE USE OF LARGE LANGUAGE MODELS
Large Language Models (LLMs) have become valuable tools in the process of academic writing. In our work, we primarily utilize LLMs for polishing the manuscript: they help identify and correct grammatical errors, improve overall readability, and simplify verbose or cumbersome expressions. This use allows us refine the clarity and fluency of the text efficiently, ensuring that the ideas are communicated more effectively. In addition, we leverage LLMs for secondary tasks related to manuscript preparation, such providing guidance on LaTeX syntax and functionalities required for paper writing, and assisting with the usage of Python tools like Matplotlib for making figures. These applications facilitate the technical aspects of manuscript preparation, reducing the time and effort needed to implement formatting and visualization requirements. The use of LLMs did not infuence the research process, methodology, or the originality of the results this work.
B LIMITATIONS AND DISCUSSION
Model size is limited. Due to computational resource constraints, experiments were conducted on limited set of models whose parameter scales are within 10B.
This work mainly focus on the most classical CoT setting. Besides, our analysis primarily fo- cused on the most fundamental form of reasoning, the classical COT. While more advanced long- CoT paradigms Yeo et al. 2025) with reflection or backtracking remain unexplored, we view our work as laying the groundwork for mechanistic studies of such settings (Wang al. 2025). We also observed that Qwen3-88 8B substantially outperforms previous models across multiple tasks, suggest- reinforcement learning (DeepSeek) 2025) Chu et al. 2025)) that merit deeper mechanistic investigation (e.g.. the research question: whether reinforcement learning really helps with out-t--distributiin generaliza- tion of LLMs? (Sun et al.) 2025 Shojace et al. 2025) in the future work.
ing the presence of architectural or training differences (e.g.. the reasoning-orientenn
The use of Logit Lens. Although being widely used (Geva et al. 2023 Wang et al. 2023 Li
al. 2024 Chughtai et al. (0024), Logit Lens (nostalgebraist) 2020) introduces potential limitations
due to semantic-space misalignment (Belrose et al.) 2025 GGhandharioun et al., (024) between intermediate hidden states and the final unembedding matrix. In future work, we plan explore
Tuned Lens (Belrose et al. (222) and Patchscopes Ghandeharioun et al. (2024), which are designed to reduce space-misale pace-misalignmeet issues when interpreting intermediate representations.
Current in-distribution tasks are limited. Although the TCR show non-trivial performance on out-of-distribution tasks, currently the in-distribution tasks are still quite limited, which may con- straint the TCR's cross-task generalization performance. Expanding the in in-distribution task set to include more diverse task types is a straightforward way to further enhance cross-task generalization of TCR.
C RELATED WORK
Chain-of-Though Reasoning's Deficiency in High-Complexity Problems Chain-of- Chain-of-Thought (CoT) (Wei et al. 2022). which enables LLMs to automatically decompose complex questions into elementary and solve them step by step, now becomes a standard paradigm of LLMs reason- ing (OpenAl 2024 Seek 2025 Alibaba 20256). However, recent studies Dziri et al. 2023);
Matarazzo & Torlone (2025); Baeumel al. (2025); Xiao & Liu (2025) have shown the limitations of CoT reasoning in solving problems that require a large number of reasoning hops. Such obser- vations reveal the inherent brittleness and superficiality
current CoT reasoning capabilities (Zhao) et al. 2025). (hooaae et al. (2025), Hu et al. (2025) and [Sun et al. (2025) experimentally demon- strate that even the latest large reasoning models (such as DeepSeek-FR RI (DeepSeek) 2025). Claude 3.7 Sonnet (Anthropic 2025) and OpenAl 04-mini (OpenAl 2025)) also encounter such problems, proving that such issues stem from the inherent characteristics of LLMs. Specifically, researchers observe that the performance of CoT reasoning of modern LLMs drops drastically the complexity of the input problem increases (c.g., the digit number of the operands increases in the multiplication
arithmetic problem DDiri al. 2023) and the list size increases in the 0-1 parity problem (Anil)
20

---

Published as a conference paper at ICLR 2026
et al.
2022:
Zhou et al. 2024 )). which starkly contrasts to human-level robust reasoning (Collins
et al.
2024] Zheng et al., 2025 de Wynter 2025): once we acquire the skill of can easily generalize it to the more complex ones (Li et al. 2023 Kim & Linzen 2020; Lake & Baroni 2023 Li et al. 2025). To better understand such difference, it is
2022
Bao et al.
solving simple problem,
urging to study the underlying mechanism behind the CoT reasoning in black-box L.L.s.
Chain-of-Thought Reasoning Mechanism Analysis Prior studies on CoT reasoning largely fall into two directions. The first line of work investigates how LLMs internally perform step-by-step reasoning. For example, Dutta et al. (2024) identify specific attention heads in LLaMA2-7B-CC that correlate with each reasoning step. while a series of works (Wang et al.) 2024b] Yao et al.) 2025
Ye et al.) 2024; Zhang et al., 2025b) train small GPT-2 like transformer models on synthetic CoT data and reveal mechanisms such as task-state encoding, buffer mechanisms, and finite-state- automaton-like circuits. The second line of work investigates where CoT succeeds or fails. For instance. Dziri et al. (2023) attribute reasoning errors to the accumulation of local prediction errors, while Zhao et al. (2025) show that when the reasoning hop length exceeds the training distribu- tion, model performance deteriorates sharply. However, few works establish a bridge between these two perspectives: connecting the internal mechanisms of CoT reasoning with the conditions under which reasoning fails. Yan et al. 2025) represent a step in this direction, yet their analysis focuses on static source of failure, showing that models may over-attend to demonstration tokens and thus generate spurious reasoning. In this work We study a more dynamic phenomenon: how increasing the reasoning hops triggers systematic competition among model's 's internal mechanisms, leading to reasoning collapse.
D TASKS, DATA AND MODELS
In this section, we mainly provide the details (e.g., the detailed description and specific examples of these tasks, the model generation configurations and so on) of seven reasoning hop generaliza- tion tasks (Parity-NL, LLC, MDM, MOAS, CLE, NumS and ObjC) and four open-sourced LLMs (Qwen2.5-7B-Instruct Phi-3-Instruct, LLaMA3-SB-Instruett Qwen3-8B-Instrucee
D.1 TASKS AND DATA
Following the task forms widely used in the relevant literature, we collect seven reasoning hop generalization tasks from three different domains:
Symbolic Reasoning: Parity-NL. (Parity problem, natural language variant) (Anil et al. 2022
Zhou et al., (2024) and LLC (Last Letter Concatenation) (Wei et al. al.] [2022] Hu et al. (2025).
Mathematical Calculation: MDM (Multi-Digit Multiplication) (Dziri al. 2023) and MOAS
Opertid Addition and Substract) (Bacumel et al. (025)..
Coding: CLF (LeetCode 1598) and NumS (LeetCode 1450),
Others: ObjC (Object Counting) that requires both symbolic reasoning and mathematical calcu-
lation abilities from the BBH benchmark (Suzgun et al. 2022).
Inspired by the practice in Mirzadeh et al. (2025), We resynthesize data for each task by randomly substituting (human and object) names and numerical values to ensure that there is as less data leakage in the LLMs' training process possible. With these tasks, the good thing is that one can arbitrarily control the problem complexity (c.g.. for the Pairty-NL task, we instantiate problems with the reasoning hop number (action number) ing reasoning skill, which provides us with an ideal testbed for us to study LLMs' performance, error patterns and their internal mechanisms in the reasoning hop generalization scenarios. Below we introduce these tasks one-by-one in detail.
[10, 20, 30, 40, 50)) while maintaining the underly-
Par The parity task requires the model to predict whether the sum of the input 0-1 list even or odd. For example, the parity of the input list [0. 1, 1, 0, 1, 0, 1, 1] is "odd" (represented by I, the binary sum) as opposed to "even" (represented by 0), because there is an odd number of Is in the input list. In our practice, we use the natural language variant of the parity problem (Wei jet al. 2022 Anil et al. 2022 Zhou et al., 2024, Hu et al. 2025), the "coin-flip" problem, to make the task more challenging. We use the state of a coin to represent the partial binary sum of the input list (i.c., heads up represents 0 and tails up represents 1). Each element in the input list is represented by filp action (e.g., "'Then Jackson flips the coin" represents input 1; "Then Ava does
21

---

Published as a conference paper at ICLR 2026
not flip the coin" represents imput 0). We show an example of Parity-NL in Figure 26 One of the good nature of Par is that it is easily extensible. We can insert arbitrary number of flip actions in the problem to control its complexity, because the model needs as many reasoning hops as the flip actions to solve the problem. Specifically we make five splits in the Parity-NI. dataset (hop numbere [10, 20, 30, 40, 40,50). 50).
2022: Hu et al. 2025 requires models to LLC The last letter concatenation task (Wei et al.
extract the last character of each word in a given list and concatenate them order, which evaluates the ability to manipulate symbolic strings based on positional rules. We illustrate an example of LLC and its corresponding solution Figure [8 LLC is highly extensible: we can flexibly control both the length of the words and the size of the list. In our datasets, we set the list sizeE {2, 4, 6, 6,8, 10), resulting in five splits.
MDM The multi-digit multiplication task is to ask models to calculate the product of two multi- digit numbers, which requires executing operations with numerical symbols based on a step-by by-pppp reasoning Dzzir et al.] 2023). We show example of MDM and the corresponding solution in Figure 27 MDM is also easily extensible. We can control the digit number of the operands. In our datasets, fix the digit number of the first operand at 3 and vary the digit number of the second operand from 2 to 6, resulting in five splits.
The multi-operand addition and subtraction task (Baeumel et al. 2025 requires models to compute the sum or difference of multiple integers arranged in sequence, which tests the ability to correctly execute chained arithmetic operations with numerical symbols. We illustrate an example of MOAS and its corresponding solution in Figure 29 MOAS is highly extensible; we can flexibly control both the number of operands and their digit lengths. our datasets, we set each operande [1.999] and vary the number of operandsé [10, 20, 30, 40, 50), resulting in five splits.
MOAS
The crawler-log-folde folder tas ( (LeetCode Problem No. 1598) requires models to use the given Python code to simulate the process of navigating through file system based on sequence of folder operations. Each log entry corresponds to one of the following actions: moving into a subfolder (e.g., "x/"), moving up the parent folder (""./"), or staying in the current folder ("/"". The goal is to determine the depth of the current folder relative to the root after executing all operations. We illustrate an example of CLF and its corresponding solution in Figure 330, CLF is highly extensible: we can flexibly control the length of the operation sequence. In our datasets, we set the sequence lengthe {10, 20, 30), resulting in three splits.
CLF
NumS The number-of-student-ooin hhowwookk at a given time tas (LeetCode Problem No. 1450) requires models follow given Python code determine how many students are doing homework at a specific query time, given the start and end times of multiple students' homework sessions. We illustrate an example NumS and its corresponding solution in Figure 32 NumS is also easily extensible: we can flexibly control the number of students (i.e., intervals) in the input. In our datasets, we set the number of students (5, 10, 15, 20). resulting four splits.
The object counting task is from the BIG-Bench Hard (BBH) benchmark (Suzgun et al., 2022), where models are asked to count the number of objects satisfying certain conditions in a given natural language description. The task evaluates the model's ability to perform symbolic reasoning over textual inputs, combining both symbolic reasoning and mathematical calculation. We illustrate an example of object counting and its corresponding solution in 31] Object counting naturally scales with the complexity of the description: we can flexibly control the number of objects as well as the conditions imposed. In our datasets, we set the number of objectsE {10, 20, 30, 40, 50), resulting in five splits.
ObjC
Solution Template All tasks used in this work have deterministic algorithms that guide the con- crete solutions of hop-by-hop reasoning. Note that here we adopt some "standard" solution tem- plates (as shown in the figures of these task examples) to guide the models' reasoning on each task
http://///eeeeceeeee//////////// log Solder/
deacr fon
22

---

Published as a conference paper at ICLR 2026
with in-context demonstrations' Dutta et al. 2024 Hu et al. (2025). ) for better analyzing models' ror patterns. These "standard" solution templates are derived from model's 's most frequent responses
(i.e., models themselves tend to solve the problems with these internalized templates).
D.2 MODELS
Qwen2.. is series of large language models developed by Alibaba (Al- ibaba 2025aj. The 7B-Instruct variant is instruction-tuned to better follow user prompts, especially in English and Chinese. It optimized for reasoning, dialogue, and task-oriented scenarios, making it a strong baseline for mid-sized LLMs.
Owen2.5-7B-Instreee
Phi-3-mini-KK-IIstruett Phi-3 is family of lightweight but high-qualite models developed by Microsoft. The mini-4k-Instruee variant, with 3.8B parameters and a 4k context window is instruction-tuned follow natural language instructions. Despite its small size, achieves compet- itive performance reasoning and coding benchmarks (Microsoft) 2024).
LLaMA3-8B-Inttree : LLaMA3 Meta 2024) is a family of foundation models released by Meta The 8B-Instruct model is tuned to improve instruction following and reasoning capabilities while maintaining efficiency. It represents a widely adopted open-source baseline, balancing model capacity and accessibility for research and applications.
Dwen3-8B-Instrus @wen." (Alibaba 2025c) is the latest generation of the Qwen series, con- tinuing to improve performance across reasoning, code generation, and multilingual understand- ing. The 8B-Inutruct variant is instruction-tunee for better alignment with human instructions and achieves strong results in both academic and practical henchmarks, making it competitive model among open-source LLMs.. Note that in this work we study the classic CoT' (Wei et al. 2022) mode of Qwen3, rather than its long CoT (Yo et al., 2025 DeepSeek] 2025) mode.
As suggested by the official model card the huggingface, adopt the following generation configurations (Listing 1) in our experiments.
Listing I: Generation Configs for Large Language Models
id":: 151643, # for 0wen2. tassttoee__dde id": 1, for Phi-3-Instruct/ "bos_toke token id": 128000, for -laMA3-BB-Instruce
1--77BIInstrre and -wen3-93-
[pad_tokon_idd... 151643, # for Swon2.5-73-Ing and Qwen3-83-Insee # "pad_token_idd 32000, for Phi-3-Instruc
"do_sample": true,
"eos bros_token_it id":
151645, 151643, for Qwen2 -- and (hen3-8B-Insteng 32000, 32001, 32007, & for Phi-3-Instruet
128001, 128009, # for },
"repetition "eeeeetition_penltt"" penalty": 1.05, for Qwen2, 5-7B-Instruee
"temperature": 0.7, # for # "temporaturo": 0.6, # for Phi-3-Instruct, LLAM33-B--Instau and Qwen3-BB-Instruet
"top_p": 0.8, # for Q 5-78IIns-ttt # "top_p": 0.9, $ for Phi-3-
1laMA3--8-IInttmee ruct.
http://///ooggrrrrooo.oo////eeer rust
attes: attp://angiiasee..oosaacctttteep m-ina------t/i------------- 4k- instruct
attos: atso::/huogiinnssee.//eettttt 1aaissl-lamaa/ttteee Llama 3-0------ttt
ttpa: / httppp///oooggggsooooooooooo
23

---

Published as a conference paper at ICLR 2026
"top_p": 0.95, for Qwen3-8B-Inst
"top_k"; 20, for - 5-77-Insruutt and -wen3-8B-Instruct
seraasformerr__erssiee "4.37.0" for Owen2.5-7B-Inst:re
"eransformers__vrssicno "4.39.3"
for Phi-3-Instruct. "4.40.0.dee
for LlaMA-3-BB-Instruct
"transformers_errs.e "4.51.0" for Qwen3-8B-Instzuue
messages
("role"; "system", "content"; "You are Qwen, created by Alibaba Cloud. You are helpful assistant."), for S-nn2..--B-Isstucs
("role": "system", "content"; "You helpful AI assistant. ";, & for Phi-3-Instruet
# ("role": "systom", "content"; "Be holpful assistant."), for LLaMB-3-0B-Inntruce
("role"; "user", "content"; prompt), for all models
text - tokeni zer. seeeeiierrrplll_chattteeeee messages,
tokenize-False, add prort
prompt=True
only for LLMMA-8B-Inssrun
terminators [tokenizer. wew_ecssssteeeeeeeeeee id,
tokenizer.c convert tokenskeeesseeo
convert_tokens_tor to www.etotkkesteeeeeeeeee
("<
E ADDITIONAL INFORMATION ABOUT LINKING OVERALL REASONING HOP GENERALIZATION PERFORMANCE DECLINE TO SPECIFIC ERROR TYPES
E.1 ERROR TYPES OF EACH TASK
We provide a detailed description for all possible error types of each task here: Parity-NL. (Figure
MDM (Figure 10 LLC (Figure 33). CLF (Figure 35). MOAS (Figure (3), ObjC (Figure 36). and NumS (Figure f7p. In summary, We conclude 8 types of possible errors for the Parity-NI. task, types of possible errors for the MDM task, types of possible errors for the LLC task, 7 types of possible errors for the MOAS task, 5 types of possible errors for the CLF task, 6 types of possible errors for the ObjC task, and 8 types of possible errors for the NumS task. We summarize all possible error types of each task in Table 3
E.2 IDENTIFYING KEY ERROR TYPES FOR EACH TASK
In this section, we present the identified key eггor types for each task. Firstly, we show the error proportion (number of error samples divided by the number of all samples) for these key types and all other types and the overall accuracy with different reasoning hop numbers for both Qwen2.5- 7B-Instruct and Phi-3-Instruet Parity-NL, MDM and ObjC tasks in Figure [T] Then we provide the detailed statistical information (overall accuracy, error ratio and error type) about the key enror types four L.LMs on seven reasoning hop generalization tasks in Table
The results further confirm our observation in the main text Section with different models. First, both models experience pronounced drop in overall accuracy as the number of reasoning hops increases, confirming the fragility of current LLMs problem involving more hops of reasoning. More importantly, this decline is not explained by uniform increase all error types, but instead largely driven by the growth of a small set of target error types identify. In contrast, the aggregate proportion of all other error types fluctuates only mildly with reasoning hop number. This highlights that performance degradation in reasoning hop generalization stems primarily from limited set
24

---

(1) Operation Recall Eroor (2) Depth Copy Error, (3) Local Calculation Error, Published as a conference paper at ICLR 2026
Possible Error Types in a 50-hop Parity-NI. Example
Input Problem:
Initially The coin heads up. (1) Then Matthew doesa't I tlip (2) Then Ethan flips. -un (Omitting 46 events) (49) Then Jack doesn't Ilips. (50) Then Samuel Ilips. Finally, is the coin heads up tails up?
Model Response:
Let's analyze ze the sequence of events step by step to determine the final state of the coin. coin heads up [TTye Initial State Error, heads up up].
Initial Step.
Step Matthew [Tye 2: Recall
Matthew Alexander doesn't Step 2. Fihan flips [Type 3: Action Recall Error, flips - doesn't 'ttssnt flip] the coin. (Coin becomes tails up.)
coin. remains heads up.)
(Omitting the intermediate 46 reasoning
Jack doesn't flips. (Coin remains heads up [Type State Recall Error, heads up tailss upl.)
Step 50. Samuel flips the coin. (Coin becomes tails [Type 5: State Update Error, tails up heads up}.)
[[Tpe 6 7: Reasoning Less More Hops, Reasoning Hop Number şé 50.] After going through each step, we see that the coin ends up lails up (Type 8: Final State Copy Error, tails up - heads up]. Therefore, the coin is tails up.
Possible enror types in Parity-NL problem. The underline green parts highlight the positions where errors of different types may occur. The bold blue parts indicate the error types. For each type, only mark instance.
Figure 9:
of key error types that intensify with hop length, underscoring the importance of focusing on the corresponding token positions where such errors occur.
Table 3: Summary of tasks and corresponding possible error types.
Task
Possible Error Types
Parity-NL
(1) Initial State Recall Error, (2) Name Recall Error, (3) Action Recall Error,
(4) State Recall Error, (5) State Update Error, (6) Reasoning Less Hops, (7)
Reasoning More Hops, (8) Final State Copy Error.
MDM
(1) Operand Recall Error, (2) Digit Error, (3) Digit Copy Error, (4) Local Cal- culation Error, (5) Shift Error, (6) Reasoning Less Hops, (7) Reasoning More Hops, (8) Local Result Copy Error, (9) Calculation Errors.
LLC
(1) Word Recall Error, (2) Letter Error, (3) Concatenation Error, (4) Reasoning Less Hops, (5) Reasoning More Hops.
MOAS
(1) Operand Recall Error, (2) Operation Recall Error, (3) Local Result Copy Error, (4) Operand Interpretation Error, (5) Local Calculation Error, (6) Rea- soning Less Hops, (7) Reasoning More Hops.
CLF
(4) Reasoning Less Hops, (5) Reasoning More Hops, (6) Final Depth Copy Error.
ObjC
(1) Name Recall Error, (2) Object Information Recall Error, (3) Local Result Copy Error, (4) Local Calculation Error, (5) Reasoning Less Hops, (6) Reason- ing More Hops.
NumS
(1) Time Recall Error, (2) Time Copy Error, (3) Local Result Copy Error, (4) Local Calculation Error, (5) Condition Judge Error, (6) Calculation Logic Er- ror, (7) Reasoning Less Hops, (8) Reasoning More Hops.
25

---

Published as a conference paper at ICLR 2026
Possible Error Types in a MDM Example
Problem:
326 3589 =? please think step-by-step.
Answer:
Let's break down the multipicatiion of 326 and 3589 step steppy.-tep.. We will multiply 326 by zach digii of 3589 and then add the
*tSppp I:
Multiply 326 [Type I: Operand Recall Error, 326 -+ another number] by (units place of 3589)4
[326 2934]
(Shift this result O places to the left: [ 2934
Step 2: Multiply 326 by ['Eeee Digit Error, - (e.g., skip the digit 8)1 (tens place of 3589)
322 ['Tyee 3: Digit Copy Error, 8 another number] 2608
(Shift this result place the left: 26080]
"tepp Muliiply 326 by (hundreds place
[ 126 5 1630 (Type 4: Local Calculation Error, 1630 - 1580 ]]
(Shift
places the left: 168000 [Type
Error; 163000 [16300]]
**Sppp 4: Multiply 326 by (thousands place of 3589y**
326
(Shift this result places the left: 978000
[Type 6/ Rensoning Less/ More Hops]
**Step
results together**
[2934 26080 163000 978000
*tSo 6: Perform the addition stop-by-step**
1934 [ype 8: Local Result Copy Errors, 2934 2984] 260-0 29014
[29014 163000 192014 l'Ipe 9: Calculation Errors, 192014 - 182014]]
[192014 978000 170014]]
**Final Result
[326 1170014]
Figure 10: Possible error types in a MDM problem. The underline green parts highlight the positions where errors of different types may occur. The bold blue parts indicate the error types. For each type, only mark instance.
100%
Parity (Qwen2.5-22 Siwen225-7-iirstrucct B-Irstruut))
1.0
100%
(Qwen2.55 (iween2.577.Insttuur
100%
(Qwen2.5.7Binng
Error Proportion
Ove ral Accuracy
67%
0.8 67%
87%
0.88
33%
0.6
35%
35%
0.4
10
20
30
10
20
30
40
50
Reasening Hop Number
Reasoning Hop Number
Reasoning Hap Number
Pantt-NI (Phi-3-nntrruct)
MDN (Phi-3-Instruct)
(PN--3-Instruct)
Error Proportion
Ovarall Acc uucuurayy
-0.8
67%
57%
57%
-..
-3.8
33%
0.6
33%
-04
33%
0.4
-02
0%
40
Reasoning Hop Number
Reasoning Hop Number
Reasoning Hop Number
Types
Key Error Typels)
Accuracy
Figure 11: Overall accuracy (green curve) and error proportion for key error types (blue bar) and other error types (purple bar) of Qwen2.5-76 IB--trutttt and Phstrutnstruct on Parity-NL, MDM and ObjC, as a function of reasoning hop number. Performance exhibits a sharp decline as reasoning hop number increases, which is largely driven by the surge of a few key target error types.
F ADDITIONAL. INFORMATION ABOUT PROBING INTERNAL MECHANISMS
OF KEY ERROR TYPES IN REASONING HOP GENERALIZATION
F.1 KEY REASONING ERRORS ACCOMPANIED BY TOKEN-LEVEL UNCERTAINTY LARGER UNCERTAINTY
We comparatively analyze the entropy uncertainty Fadeeva et al. 2024 Zhang et al. 2025a) as- sociated with token predictions critical positions of those key error types. The token predictive
26

---

Published as a conference paper at ICLR 2026
Table Statistical information about the key error types of four LLMs on seven reasoning hop gen- eralization tasks. The number within the parentheses following the task name indicate the reasoning hop number of the task. Key Error Type(s) Ratio and Other Error Types Ratio are calculated by number of errors of target types/ types/number number of all errors
Statistical
MDM(6)
LLC(10)
CLF(30)
MOAS(50)
ObjC(30)
NumS(22)
Qwen2.5-7B-
Overall Accuracy
46.2%
40.0%
2.0%
53.0%
41.0%
52.0%
1.3%
Key Error Type(s) Ratio
78. 6%
96.3%
52. 1%
56.4%
76.3%
96. 96.2%
100%
Other Error Types Ratio
21.4%
3.7%
47.9%
43.6%
23.7%
3.8%
0.0%
Key Error Type(s)
2
2, 5
3
1,3
2
1,
Phi-3-Instruee
Overall Accuracy
51.2%
20.7%
1.0%
1.0%
Key Error Type(s) Ratio
89.9%
67.1%
100%
90.7%
69.1%
98.0%
Other Error Types Ratio
26.2%
10.1%
32.9%
0.0%
9.3%
30.9%
2.0%
Key Error Type(s)
2
5
3
1,
2
1,
LLaMM3-88-Instreet
Overall Accuracy
71.0%
0.0%
59.0%
14.1%
25.0%
80.4%
0.0%
Key Error Type(s) Ratio
72.4%
92.9%
97.6%
93.4%
84.0%
78.9%
98.7%
Other Error Types Ratio
27.6%
7.1%
2.4%
6.6%
16.0%
21.1%
1.3%
Key Error Type(s)
Qwen3-8R-Taasruuc
Overall Accuracy
98.8%
25.3%
53.0%
98.0%
92.6%
89.5%
98.0%
Key Error Type(s) Ratio
100.0%
96.6%
100.0%
100.0%
80.0%
70%
100.0%
Other Error Types Ratio
0.0%
3.4%
0.0%
0.0%
20.0%
30.0%
0.0%
Key Error Type(s)
2
2.5 5
3
1
2
1
1
entropy is calculated as
IV--
H Σ
log
log
following the notations in Section 2 (xr here refers to the input context before the target token po- sition, i.c., the token that is to be predicted). Table 5 reports average entropies for correct and erroneous predictions across seven reasoning hop generalization datasets (for each dataset, we ran- domly choose 100 samples). For both Qwenn.5-7B-Insstee and Qwen3-8B- -aeen3-8B-nnstruct, erroneous samples consistently exhibit significantly higher predictive un- certainty, indicating that the model is not decisively committed to erroneous trajectories and leav- ing room for competing alternatives (i.e., the correct trajectories) in its internal representations.
Phi-3-Instrucl
CAMMAA-8B-Insturn
This observation motivates the our investigation into the model's inner workings, particularly the competition mechanisms (Section 4 that underlie reasoning hop generalization errors.
F.2 DETAILED EXPERIMENT SETTING
For specific error type, we randomly sample two sets for correction and erroneous predictions at the corresponding key token position, denoted as Scorr and Sen- respectively. In our experiments, We [Soml = |Sall 10. We find that the experiment results of locating answer-writing heads and processing heads are not sensitive to the size Sccrr and San (5,10 and more samples yield similar locating results), which also demonstrates the robustness of the results and our proposed locating metrics. For the experiment regarding to Figure) 7 we knock out the erroneous processing head a at and 15 for rectifying erroneous predictions of Parity(2), MDM(2) and MDM(5), respectively.
27

---

Published as a conference paper at ICLR 2026
Table 5: Average predictive entropy of correctly and erroneously predicted samples for Qwen2.5- 7B-Instruct Phi-3-Instruct, CAAMMAA--B-Insruuse and Qwen3-8B-Instre across seven datasets, along with the average predictive entropy of the rectified predictions which were originally erro- neously predicted. Each value is averaged over 100 samples.
Model (Case Type)
Parity-NL
MDM
LLC
CLF
MOAS
ObjC
NumS
hww.h..t7Bltsstruutt (Correct)
0.000
0.000
0.035
0.000
0.000
0.006
Qwen2.5-7B- Breen.--7B-tnstruct (Error)
0.097
0.200
0.230
0.241
0.178
0.192
0.073
Oween.5-7B-Inssrre (Rectiifedd
0.022
0.082
0.133
0.098
0.038
0.050
0.035
Phi-t-Instruct (Currect)
0.107
0.152
0.016
0.046
Phi-3-Instruct (Error)
0.512
0.429
0.694
0.392
0.348
0.385
0.112
Phi-3-Instruct (Rectified)
0.085
0.288
0.505
0.130
0.052
0.109
0.191
LLaMA3-8B- (Correct)
0.009
0.015
0.002
0.0000
0.009
0.003
LLaMA3-88-hnstruc (Error)
0.258
0.195
0.139
0.201
0.
0.266
0.214
LLaMA3-8B- (Recrified)
0.090
0.104
0.081
0.125
0.074
0.088
0.095
D0ee3-88-Instrute (Currect)
0.021
0.000
0.000
0.008
0.009
0,000
0.002
Qwen3-8B-Instrucc (Error)
0.382
0.059
0.000
0.079
0.166
0.017
0.340
Qwen3-88-Instruce (Rectified)
0.017
0.008
0.011
0.027
0.053
0.002
0.013
F.3 ADDITIONAL. RESULTS ABOUT LOCATING AND ANALYZING ANSWER-WRITING HEADS
Comparing answer-writing locating methods with previous works Considering specific emror position, where the predicted token is f, previous works (Wang et al. 2023 Dutta et al. [024] Chughtai et al. 2024) typically measure how much information about is written by the head a (at the last input token position) with the Logit Lens probability: flogit-lens (a))) [4 (Eq or the directly argue that such approaches that directly inspect the head representations themselves have two main deficiencies. For one thing, they neglects the joint influence of other heads within the same layer as well the information already present in the residual stream. Specifically, recalling the Transformer residual stream updating formula (Eq [T. we derive that:
mapped logit value (a!- [t]. However,
h ++1 = h +
Σ == a hid Wy = (h' + D at) Wu
flog lens hh 1+1) [t] Softmax Ch mid We [1) = Softmax((1 Σ. at) We)ld
Softmax + 21=1, at) We + a²j Wt
* Softmax((h's + I Ei=1, at) Wo + Softmax(a/ Wo)l
flogitlees (h' + H Li=1, (t)( + flugit-enm (a') [t]
flogit lens ( [4)) # Jengit (h' + E A)1 + fiogit-eens (a))
which indicates that the direct inspecting results flogi-tens ( (a) or (a), Wo cannot precisely mea- sure the contribution of the attention head at, to the residual stream 1+1 (i.e., considering the infor-
mation the token: fuggi lens (b [t)) Instead, the difference fingit mid [{]] flogi-ten (h(+1 at][t] is better proxy of the contribution, which directly calculates the effect of knocking out af.
from the 1-th layer on the residual stream value of the model.
For another, previous methods that directly inspect the head representations neglect the large scale discrepancy of target-token probabilities across layers, which fluctuate only within a narrow band in earlier layers but surge dramatically in the final layers (Figure (e)) To this end, we additionally normalize the effect with its original value. In conclusion, our aw heads measure for a is formally expressed as:
(Flogit-enss (h (b++1) [t] Slogit-ens (h(+1 at) hogit-ens (h 1141 [{] A Saw-hhad aa)).
We also use the Qwen2.5-7B -inist.--B-insttuut model and the Parity-NL task (error type 2) to empirically compare the locating results of our proposed measure 8 haw)) (in short, Ours) with several baseline methods: (i) directly inspecting the head representations with Logit Lens probability
28

---

Published as a conference paper at ICLR 2026
flogit-tems [t] (in short, LL prob), (ii) the logit value with Logit Lens (a) Wo [t] (in short, LL logit) and (ii) our method without normalization flogit-lens ( [{ foggi-lons (h a (in short, w.o. normalization).
00000
00
leer
prob, correct predictions
LL prob, erroneous predictions
(c) logit, correct predictions
(d) logil. erroneous predictions
0.c
normalization,
(f) normalization, prodictions
Ours, predictions
(h) Ours, prodictions
predictions
1.
grouno
() Tracing token's (descending) rank and probability changes layers
Figure 12: Comparing our proposed answer answer-writing head locating measure with other baseline meth- ods on correct and erroneous predictions.
The results shown in Figure 12] where and (h)) are most rational (align best with the shadowed zone highlight in Figure [2 where the average (descending) ranks and the average probabilities of the erroneously predicted tokens and the corresponding ground-truit truth tokens change sharply), while LL prob and ours w.o. normalization mainly locates heads in the last two layers and the most significant heads highlighted by LL logit are mainly located in the first layer. Meanwhile, our measure yields the best consistency between the locating results on the correct and erroneous predictions.
easily observe that ours results (Figure 12 g)
Why using normalization is necessary when locating aw heads? When using the unnormalized metric Figure e.f,, the identified answer- answer-writing writing heads fall almost entirely into the final 2~3 layers. However, this starkly contradicts the layer-wise distribution of answer-related information the answer-related token emerges and outstands
shown in Figure 3(c), where the information around layers 20-26 rather than only in the final 2~3 layers. As we discussed, the reason behind this phenomenon is that target-token probabilities fluctuate only within a narrow band in earlier layers but surge dramatically in the final layers.
Comparison experiment: how about the localization result of answer heads with ran- domly select tokens? To investigate this, we randomly select 10 random tokens from the vocab- ulary for each sample in Scorr and Serr, and conduct the experiments of locating unswer-writing head. The average localization result is shown in Figure 13 Unlike the original localization result, there is no attention heads with significant knock out effect (the maximum of the average interven- tion effect is around 0.06, in constrast to the result shown in Figure 4 of the paper), which further
29

---

Published as a conference paper at ICLR 2026
0.05
0.01
head
hrea
0.00
0.01
layer
layer
(a) locating aw heads for samples in Scorr with random (b) locating aw heads for samples in Sere with random
tokens
tokens
0.8
0.6
head
0.4
hood
0.3
0.2
0.0
0.D
-0.1
layer
layer
(c) locating aw heads for samples in Seare with
(d) locating aw beads for samples in Sare with predicted tokens
predicted tokens
Figure 13: Comparing the answer-writing heads localization result with randomly select tokens and predicted tokens.
confirms the effectiveness of the localization result obtained with model's predicted token (Sery and Scorr).
Locating answer-writing heads with other tasks and models We show the additional locating results of answer-writing heads (with our proposed measure gaw-head (a{)) on all seven tasks and with Qwen2.5-7B InIIrtruct (Figure 17). Phitr--Inttruct (Figure 18) and LLaMA3-8P ---33-----nntcttt (Figure 19
inspecting three answer-writing heads with Logit Lens We provide the results of using Logit Lens inspect three answer-writing heads (a a and a in the Qwen2.5-7B- Instruct model the predictions the token positions of Parity-NL error type 2. We show the results of originally erroneously predicted samples accompanied with the inspecting results after intervention the model (i.e., knocking erroneous processing head aQ) in Figure 14 Figure and Figure 21
Case Study:
F.4 ADDITIONAL RESULTS ABOUT LOCATING AND ANALYZING PROCESSING HEADS
show the locating results of erroneous processing heads (i.e., ep heads) and the effects knock- ing out individual heads on correcting the erroneous prediction (i.e., the probabilities of predicting ground- truth tokens) with four models and all seven tasks here:
Qwen2.5-7B-Insttuul The results are shown Figure 22
Phi-3-Instruct: The results shown in Figure 23
LLaMA3-8B-Innstuttt The results are shown in Figure 24
Bren3-8B-Inntruuee The results shown in Figure 25
30

---

Published as a conference paper at ICLR 2026
ban
M0n
1908
(5) datum I, before intervention
(b) datum 1, after intervention
(e) datum 2. before intervention
(d) datum 2. after intervention
(c) datum 3. before intervention
(1) darum 3, after intervention
(g) datam 4, before interveation
(h) datum 4, after intervention
Ialen
100n
(i) datum S. before intervention
i datum 5, after intervention
(k) datum 6, before intervention
() datum 6, alter intervention
5
(m) datum 7, before intervention
(n) datum 7, after intervention
(0) datum 8, before interveation
datum 8, after intervention
194r
(g) datum 9, before intervention
(r) datumn 9, after intervention
(s) datum 10, before intervention
(i) datum 10, after intervention
Figure 14: Detailed inspecting results of a²" in the Swen2.5-7B-Inntruue model on the predictions at the token positions of Parity-NL error type 2.
Note that the Parity-NL results with Breen..5-B-Inntrrree have been shown in the main text (Fig- ure (6) and all results are obtained by averaging over a set Sen containing 10 independently and randomly sampled instances. We can consistently observe that knocking out some individual ep heads can effectively improve the probability of predicting the ground-truth token, which is highly aligned with our observations in Section in the main text.
G ADDITIONAL INFORMATION ABOUT TEST-TIME INTERVENTION TO CORRECT REASONING HOP GENERALIZATION ERRORS
G.1 IDENTIFYING CANDIDATE ERRONEOUS PROCESSING HEAD SETS
We observe that different tasks and key error rypes might be mapped onto some common ep heads in previous experiments (see the locating results for the ep heads in Appendix F.4, which motivates us to maintain small set of key heads for each model, which can be commonly used to rectify as diverse tasks as possible and effectively reduce the size of H. Following the procedure described in Section 4 we randomly sample two sets of correct and erroneous predictions to separately locate Hap for each key error type in five reasoning hop generalization tasks (Parity-NL. MDM, LLC, CLF and MOAS), including symbolic reasoning, mathematical calculation and coding domains. We then select list of these target heads H. where (i) each single head should be located by as many key error types as possible, and meanwhile (ii) they together can guarantee to cover all of the key error types. We implement simple greedy algorithm (for this Set Cover (Slavik 1997) like
31

---

Published as a conference paper at ICLR 2026
problem) to determine H. Consequently, [H] = 8 for Qwen2.5-7B, 9 for Phi-3 and Qwen3-8B and 10 for LLaMA3-8B. Below are the details of for all the models used this work.
Qwen2.5--7-Instruuct H {af. ag. a aq. ais aig. a.))
Ihitt-Instruct: H {ag). a27. a a _! ag 12 a21 a a.0)
LLaMA3-8B-Instrus H {aß. a23 a2s ag 17: a20: a 19.
a 17)
Qwen3-8B-Instree = (af. a 20 ag a
a a a0 a
G.2 HEAD SELECTOR TRAINING DETAILS
Collecting Training Set, ID Testing Set and OOD Testing Set For each of Parity-NL, MDM, LLC, CLF and MOAS, we sample around 20, 000 instances, obtain the erroneous predictions of key error types (Section B label the i-th erroneous prediction (z,, 3ii) and finally collect D. We filter out small part of instances with yi 0 H We randomly held out 500 samples from 'D for in-distribution testing. The rest data are used as the training set Dinin- We additionally use 200 error predictions in ObjC (symbolic reasoning and mathematical calculation) and NumS (coding) tasks for out-of-distribution testing.
Training Details In the inference time, we want to establish the correlation between target ep heads and the input context. Hence, we aim to train a small model to automatically select target ep head among a candidate head set H according to the input context. We further model this as multi-label classification task with a variable number of positive labels: input is the input context Ti output is label Y/ E {0, 11 (for k E [.. 11, if knocking out H[k] can correct the and
(x, Ue [P] is the training set. As for the training objective, among BCE loss, BPR loss (Rendle et al.) 2012)) ZLPR loss (Su et al.) 2022) and multi-label Softmax loss (Pu al.] 2025). we find that the last one consistently achieve the best generalization performance. We fine-tune the pre-trained Qwen2.5-0.5B3 -.50....-nnst model with a randomly initialized multi-label classification head (implemented by the Huggingface transform-
prediction v,, then yı [k] otherwise y: [k]
er
[l this task. Our training objective can be formalized as ming ( train log( exp(/o(=))11
class wrr.MModdFooSSeeeneeCussssiiiiie
denoted fe())) with LoRA (Hu et al. 2022) for
exp(Ja(=))
For the LoRA training, we use Huggingface peft packagd below (Listing2):
Our LoRA configurations are listed as
Listing 2: LoRA configs
lora_config LoraConfig(
== lora_rank, lora_rank 16 in all of the experiments lora_alpha = lora_aalphaa # lera_alpha 32 in all of the experiments inference_mode mode False, target_module
['qj'r'j', "k_proj', (v_proj', (o_proj'],
1ora_éropout - 0. 0.05, bias = 'none', task type = 'SEO cis', modules save ["score"],
Training Hyperparameters We set training batch size as 16, the maximum gradient norm is 1.0, the initial learning rate as le - 4, and adopt the cosine learning rate scheduler to adjust our learning rate automatically. We train each model for 3 epochs total. We show an example of the 1-t.2..--B--Ittrire
training logs of the head selector for the show the changes of training loss, validation loss, validation accuracy (for both 0 and classes), F1- macro, Precision-macro and Recall-macro, and testing accuracy and testing F1-macro in the training process.
model in Figure [5] In this figure,
hitees///ugiiiaaeeeee/////rrrres Inst
32

---

Published as a conference paper at ICLR 2026
Accuracy Fl Presioon and Recal
0.7485
ecoutacy
0.00
Vol Pres skingree
val nocall maci
0.00
Training Step
Figure 15: The training logs of the head selector for Qwen2.5-7B-Instruee
Random Guessing Baseline in the Table refers the baseline of randomly selecting candidate head. The results are averaged over five independent runs with different random seeds (1 ~ 5).
G.3 THE DETAILS OF TCR AND DOLA EXPERIMENTS
This section provides more details about the experiments of dynamically correcting reasoning hop generalization errors, for both our proposed TCR method and the DoLa baseline method. The tasks used in the experiments of Qwen2.5-7B-Instiee Instruct and Phi-3-Instruct are listed as following: Parity-NL(50 hop), MDM(3 digits 6 digits), LLC(6 hop), CLF(30 hop). MOAS(50 hop), ObjC(30 hop) and NumS (10 hop). For experiments of LJaMA3-8B-Instrree we change the hop number of ObjC to 40. For experiments of Qwen3-8B-Instruet: to 3 digits x 8 digits, the hop number of ObjC to 40 and the hop number of NumS to 20. The entropy threshold that is used to detect token-level erroneous predictions experiments.
change the digit numbers of MDM
as 0.3 in all of our
DoLa (Chaagg al. 2024 is a very strong test-time baseline especially for improving factuality and reducing ballucinations in language model outputs, which works by contrasting the logits from the final layer with those from earlier layers of the model, amplifying factual knowledge localized in specific layers and suppressing spurious information. DoL.a improves models' performance not only on benchmarks that target on the factuality (e.g., TruthQA (Lin al.] (022)) but also on reasoning benchmarks like GSM-8K (Cobbe et al. 2021). In experiments, adopt the implementation that integrated into the generate() method in the Huggingface transfomers package. We sweep over the configurations of DoLa and choose the following ones (which is also recommended in the official document to handle with long, reasoning-intensive intenssive answers in our reasoning hop generaliza- tion scenarios):
Listing 3: DoLa configs
gen gen_ krr_swarssll "dola layers"] "low" gen kwargs
= 1.2
Note that the comparison between proposed TCR method and DoLa is not in order to demon- strate the state-of-the-art performance of TCR. Instead, we want to show that traditional test-time hallucination mitigating methods (like DoLa) may not consistently and effectively help with reason- ing hop generalization.
33

---

Published as a conference paper at ICLR 2026
1.40
Driginal
w.o. majority vote RR
inndon iiee wendon
63-
Accurecy
TCR w. majority vode TOR
Recuracy
6:4
ParityNL
MDM
CL
Parily-NL NL
MDM
CLF
(a) Compare
majority vote).
Randomll knock candidate head.
Figure 16: Ablation Study.
Table Comparing TCR with LOFIT fine-tuned separately on two tasks (Parity-NL(5O) and Object Counting(30)).
Original LOFIT(10) LOFTT(20) L0FIT(30) LOFTT(40) LOFTT(50)
TCR-gold
Parity-NL/50)
Sweea.5-7B-Lnsttee
48.3%
49.8%
50.5%
52.5%
53.3%
55.8%
60.4%
81.2%
Phi-3-Instruct
51.2%
50.2%
49.5%
50.8%
51.8%
53.1%
55.8%
65.2%
ObjC(30)
Qwea2.5 -7n--nttct
52.0%
44.5%
50.2%
54.0%
56.0%
76.0%
Phi-3-Instrrct
30.9%
32.8%
35.8%
38.39 3%
45.0%
45.0%
G.4 ANALYTICAL EXPERIMENT: ABLATION STUDY OF TCR
A natural baseline is Removing-and-RR Resamminn (RR), which removes the logit of the model's original prediction from the final hidden state and re-samples the output. As shown in Figure [6(a), RR yields only marginal gains on Parity-NL but substantially degrades performance on MDM and CLF, highlighting the superiority of TCR. Finally, to assess the role of the trained head selector, we compare against a random head selector. Figure 16]b) shows that both TCR and TCR- with the trained selector consistently outperform their random-selector selector counterparts on Parity-NL, MDM, and CLF, confirming the effectiveness of classifier-guided head selection.
G.5 COMPARING TCR AND LOFIT ON IMPROVING REASONING HOP GENERALIZATION
LOFIT Yin et al. 2024) shares the idea of intervening attention- head representations, but it dif- fers from TCR in two important ways. The first different point is that LOFIT aims to use fine-tuning adapt the down-stream task while TCR is test-time intervention to correct reasoning: LOFIT is primarily introduced as lightweight alternative to PEFT methods (e.g.. LoRA (Hu et al. 2022 and is typically applied task-specific fine-tuning (e.g., TruthfulQA. multi-hop QA). does not par- ticularly target reasoning- hop generalization. TCR is a test-time attention head intervention method grounded on the competition mechanism behind the reasoning hop generalization phenomenon that is studied in our paper, which suppresses the erroneous processing head to correct reasoning. The second different point is that LOFIT identifies fask-dependent attention heads and therefore tends to be tied to the specific downstream task used for fine-tuning, making out-of-distributee ization difficult while TCR identifies erroneous processing heads with stable competitive dynamics across tasks, enabling effective transfer. We make a direct comparison between TCR and LOFIT. We evaluate two models (Qwen2.5-7B-Instte) and Phi-3-Instruct), and consider the following two settings.
task general-
LOFIT fine-tuned separately on two tasks (Parity-NL. and Object Counting). The result is shown in Table Note that in the experiments, we try using problems of different hop numbers to train LOFIT to explore its reasoning hop generalization capacity. LOFIT(N) refers to that we use N-hop data to train LOFIT.
LOFIT jointly fine-tuned five tasks (Parity-NL., MDM, LLC, CLE, MOAS), while testing out-of-distributiin task generalization on two unseen tasks (ObjC and NumS), consistent with our main setup. The results are shown in Table and Table
The results show that: TCR yields substantial and consistent improvements on reasoning- hop gen- eralization over LOFIT on Parity-NI. and Object Counting; LOFIT's improvements are much more
34

---

Published as a conference paper at ICLR 2026
Table 7: Comparing LOFIT and TCR on Out-Ot-Distriution Task Generalization with Qwen2.5-
7B- IB-Instruct.
Qwen2.5-7B-Instrucl
original
LOFIT
TCR
TCR-gold
ObjC
52.0%
53.8%
56.0%
76.0%
NumS
41.1%
40.3%
46.0%
54.5%
Average
46.6%
47.1%
51.0%
65.3%
Table 8: Comparing LOFIT and TCR on Out-Of-Distributionn Task Generalization with Phi-3- Instruct.
Phi-3-Instruct
original
LOFIT
TCR
TCR-gold
ObjC
30.9%
33.2%
45.0% %
45.0% %
NumS
72.0%
68.5%
76.0%
82.0 %
Average
51.5%
50.9%
60.5% %
63.5 %
task-specific, and it fails to achieve effectiveness out-of-distribution task generalization observed with TCR.
G.6 COMPARING TCR AND TRAINING THE BASE MODEL. ITSELF ON IMPROVING REASONING HOP GENERALIZZTION
One natural question would be "why we do not train the base model itself on the same frain- ingset used by TCR improve reasoning hop generalization?" First, TCR is designed be non- destructive and generalizable to new tasks, while direct fine-tuning inherently entangles model pa- rameters with the training distribution. Moreover, to address this question, we train the base model (e.g., Sive2..--BBIInsteee using the same datase employed for the knockout classifier, under three different schemes (i.e., Expl, Exp2 and Exp3):
Expl: trainable base model trainable classifier head. In this experiment, fine-tune both the base model and the classifier head for the multi-label classification task.
Exp2: frozen base model trainable classifier head. In this experiment, we use the base model itself as frozen backbone and only train the classifier head.
Exp3: fine-tuning the base model on ground-truth tokens directly. In this experiment, we replace the head-classification labels the training dataset with corresponding ground- truth tokens at critical token positions and directly fine-tune the base model itself.
The results of Expl, Exp2 and Exp3 are shown in Table 9 Across all three schemes, training the base model itself leads to catastrophic forgetting (Fxpl), insufficient expressivity for classification (Exp2), poor in-distribution and dutttf--istribution task generalization (Exp3).
G.7 EXPERIMENT WITH LARGER MODEL
In this section, we aim to investigate whether TCR can work with larger LLMs. To this end, re-implement TCR with D0ven2.5-14B-Instte
First, for @0een.55-14B-Insttuue the selected candidate head set H (a.. a4. 0 afs.- alg a a&7, 4 ag6. a Following the procedure in the main text, we also train a Swwe2.5-00.B-IInttee model with classifier head) to predict which head be intervened in the test-time. We use LoRA to fine-tune the parameters of the backbone Qwen2.5-0.5B model and train the randomly initialized classifier head the same time. We adopt the softmax loss (Pu et al. 2025) where the training
based multi-label classification model (base
objective can be formalized as ming E( log( exp(fo(=))
We evaluate the performance of the base model (Qwen2.5-14 1-12255------1 14--Inntruucc,, base model with DoLa DoLa al. (2024). base model with TCR and -CR- on seven tasks (five in-distribution
"*Qwe22.5-14 1-5-11.B https://hhpggeee www.:/ggiggaaaa..mooo http://aww.....cc////o/aeeee/aaa http:////....aaaooooo/////////// 5- 48- instuct
35

---

Published as a conference paper at ICLR 2026
Table Comparing TCR and three implementations of training the base model itself on improving reasoning hop generalization.
Exp Group Parity-NL
MDM
LLC
CLF
MOAS
ObjC
NumS
Average
Base Model
48.3%
43.0%
11.7%
56.8%
39.2%
52.0% 41.1% 41.7%
Expl
49.5%
29.5%
10.2%
48.3%
30.2%
45.8%
28.0%
34.5%
(-7.2%)
Exp2
50.3%
45.0%
13.5%
63.6%
44.8%
52.6%
41.9%
44.5%
(+2.8%)
Exp3
56.2%
43.7%
12.2%
59.5%
44.0%
52.0% 39.8%
43.9%
(+2.2%)
TCR
60.4%
48.2%
16.2%
66.6% %
46.0%
56.0%
46.0% %
48.5%
(+6.8%)
TCR-gold
81.2%
58.3% %
23.0% %
71.3%
62.0%
76.0%
54.5%
61.3%
(+19.6%)
Table 10: Performance of TCR and TCR-gold with Snven2.5-Instruct-lle
Parity-NL
MDM
LLC
CLF
MOAS
ObjC
NumS
Average
Base Model
74.4%
32.3%
43.3%
89.9%
60.5%
47.7%
72.4%
60.1%
Dola
76. %
28.5%
42.5%
91.0%
58.1%
47.3%
70.8%
59.2%
TCR
79.0%
37.4%
45.0%
94.3%
66.0%
54.1%
75.8%
64.5%
TCR+gold
87.7%
41.5%
48.6%
96.0%
69.8%
63.7%
77.2%
69. 69.2%
tasks: Parity-NL(70), MDM(8), LLC(6), CLF(30), and MOAS(50); and two tasks: ObjC(30) and NumS(20)). The results are shown Table I0] which demonstrates effective- ness of TCR and TCR-gold with larger models like Qwen2.5-14B5 1.055-14-Innsttu
G.8 THE PERFORMANCE OF TCR ON THE NATURAL LANGUAGE REASONING TASK
To evaluate method in more realistic natural- -lanuag- reasoning setting, additionally in- clude results on Big-GSN (Chen et al. 2024), a more complex variant of GSMSK specifically designed to require more reasoning hops. Importantly, Big-GSM; instead, we directly apply the classifier trained on our five in-distribution tasks (Parity- NL, MDM, LLC, CLF, MOAS) select which heads knock out.
do not separately train the classifier
Table 11: Evaluating the performance of TCR on the Big-GSM task.
Big-GSM
Base Model
TCR
Qwen2.5-7BBInstte
52.7% + 0.4%
54.4% + 0.5%
Phi-3-Instruee
52.5% + 1.3%
53.9% 0.7%
our method consistently improves performance on Big-GSM, demonstrating its ability generalize natural-language, long-chain reasoning tasks.
The result is shown Table 11
G.9 EXAMINING THE REASONING MODELS
In this subsection, try explore whether our main findings (i.e., deactivate erroneous processing heads can correct reasoning) still hold with reasoning models that can self-reflect and backtrack in the step-by-step reasoning process (DeepSeek) 2025
OpenAl 2025
Yeo et al. 2025) To this end,
36

---

Published as a conference paper at ICLR 2026
Parity-NL (50-hop)
MOAS (50-hop)
ObjC (30-hop)
Average
Acc.
Resp. Len.
Acc.
Resp. Len.
Acc.
Resp. Len.
Acc.
Resp, Len.
Original
63.3%
1633.6
38.9%
1765.9
28.5% 31.7%
1819.1 1688.5
43.6%
1739.5 1502.7
TCR
66.9%
1365.3 3
44.1%
1454.3
47.6%
Table 12: The average reasoning accuracy and response length before and after applying TCR with Deepseck-Re RI-distill-Queer
we conduct experiments with the --ieckk----issttl---ee-------- model 15 We separately sample 10 erroneous predictions of the Parity-NL (50-hop) task, the MOAS (50-hop) task, and the ObjC (30-hop) task. Then following the procedure in Section 4 we locate the top-1 ep heads for these tasks (a) for the Parity-NI. task, ag for the MOAS task, and a for the ObjC task), respectively. We implement TCR by dynamically deactivating the task-specific top-1 ep head in the reasoning process when the entropy of the generated token exceeds 0.4. We show the average reasoning accuracy and response length before and after applying TCR in Table 12
can observe that after applying TCR, model's average reasoning accuracy will increase (by 4.0% averagely) and meanwhile the average response will shorten (by 13.6% averagely), demonstrating the TCR's potentials with reasoning models and the functional complementarity between the rea- soning models' self-reflection behavior and the inference- time suppression of erroneous processing heads.
"httpss///ogginnaaaccoo///eeeees -b Qwen-
37

---

Published as a conference paper at ICLR 2026
H FIGURES FOR THE APPENDIX SECTIONS
This section contains lots of figures mentioned previous Appendix sections.
-175
-130
(n) correct predictions, MDM-2
(b) erroneous predictions, MDM-2
(c) correct predictions, MDM-5
(d) erroneous predictions,
MDM-5
31
62
(c) correct predictions, ILCC3
(f) emonenus predictions, LLCC3
(g) correct profictions, MOAS-3
(h) erroneous predictions,
MOAS-3
00
62
-02
(i) correct predictions, CLF.II
(j) emoneous predictions, CLF--I
(k) correct predictions, CLF.3
(l) erroneous predictions, CLF-3
635
0.5
-05
635
-10
520
123
-225
-10
-.30
4.75
-113
1.30
-06
Byw
(on) correct predictions, NumS-1
(n) erronoos prodictions,
(o) correct predictions, NumS-5
(p) crroncous prodictions, NumS-5
NumS-1
(g) correct predictions, ObjC-1 (() emmeeous predictions, ObjC-1
Figure 17: Additional results about locating answer-writing heads with Qwen2.5-7B-Insttuun on both correct and erroneous predictions. In the caption of each sub-figure, the "X" in [Taask Name]-X refers to the error type. For example, MDM-2 refers to the erroneous predictions of error type 2 of MDM.
38

---

Published as a conference paper at ICLR 2026
RUD
-30
-64
-1.33
(n) correct predictions, MDM-2
emronouus predictions,
(c) correct predictions, MDM-5
(d) erroneous predictions,
030
24
22
0.0
-64
(c) correct profictions, LLCC3
(f) emroneuus predictions, LL.C3
(g) correct prodictions, MOA5-3
(h) erroneous predictions,
MOAS-3
650
639
0.00
22
10
-88
1.00
42
(i) correct predictions, CLF.1
(j) erronoous predictions, CLF-1
(k) correct predictions, CLF3
(l) erroneous predictions, CLF3
35
108
02
lye
(an) predictions,
erroneoux predictions, NumS-1 I
(a) correct predictions,
(p) erroneou predictions, NumS-5 5
bus
1.4
625
125
(g) correct predictions, ObjC-1 erroneous predictions, ObjC-1
correct predictions, Parity NL.2 NL.
erroneuu predictions. Purity-NL.2 NL.-2
Figure 18: Additional results about locating answer-writing heads with Phi-3- rect and erroneous predictions. In the caption of each sub-figure, the "X" in [Task Name]-X refers the error type. For example, MDM-2 refers the erroneous predictions of error type MDM.
both cor-
39

---

Published as a conference paper at ICLR 2026
(i) correct predictions, MDM-2
(b) emoneous predictions,
(c) correct predictions, MDM-5
(d) erroneous predictions,
MDM-2
MDM-5
24
22
-63
00
(e) correct predictions, LLC.3
(i) emoneous predictions, LLC.3
(g) correct predictions, MOAS-3
(h) erroneous predictions,
MOAS-3
(i correct predictions, CLF-1
(j) erroncous prodictions, CLF-1
(k) correct prodictions, CLF-3
()) erroncous prodictions, CLF-3
6d
65
22
-22
(m) predictions, Num5-5
predictions, NumS-5
predictions, ObjC-I
predictions, ObjC-I
34
22
11
-63
predictions,
(4) crroneous predictions, Parity-NL-8
Parity-
Figure 19: Additional results about locating answer-writing heads with BLLMMA3-8B-Instre on both correct and erroneous predictions. In the caption of each sub-figure, the "X" in l'Task Name]-X refers to the error type. For example, MDM-2 refers to the erroneous predictions of enror type 2 of MDM.
40

---

Published as a conference paper at ICLR 2026
shin Line
Alallac Ulb Labe
(a) datum I, before intervention
(b) datum 1, after intervention
(c) datum 2, before intervention
(d) datum 2, after intervention
bas
(e) before intervention
3, intervention
(g) 4, before intervention
datum intervention
① datum S, before intervention
( datum 5, after intervention
(k) datum 6, before intervention
(1) datum 6, after intervention
3
1981
(m) datum before intervention
(n) datum after intervention
(0) datum intervention
(p) datum intervention
(g) datum 9, before intervention
(?) datum 9, after intervention
(s) datum 10, before intervention
(4 datum 10, after intervention
Figure 20: Detailed inspecting results of a in the Qwwen..5-BB-Instruce model on the predictions at the token positions of Parity-NL error type 2.
41

---

Published as a conference paper at ICLR 2026
14
(a) datum I, before intervention
(b) datum 1, after intervention
(c) datum 2, before intervention
(d) datum 2, after intervention
(e) before intervention
datum 3, intervention
(g) 4, intervention
datum intervention
① datum S, before intervention
i datum 5, after intervention
(k) datum 6, before intervention
(1 datum 6, after intervention
(m) datum intervention
(n) datum after intervention
(a) datum before intervention
(p) datum intervention
(g) datum 9, before intervention
(r) datum 9, after intervention
(s) datum 10, before intervention
(4 datum 10, after intervention
Figure 21: Detailed inspecting results of a in the Qwenn.557BB-Instruce model on the predictions at the token positions of Parity-NL error type 2.
42

---

Published as a conference paper at ICLR 2026
21
locating heads, MDM-2
(b) knocking rectify. MDM-2
locating hends, MDM-5
(d) knocking rectify.
MDM-5
32
10
locating ep heuls, LLC.3
knocking rectify, LLC-3
locating ep heals, MOAS-2
(h) knacking out to rectify. MOAS-2
60
locating ep heads, CLF-1
knocking rectify. CLF-1
(k) locating heads, CLF-3
knocking rectify. CLF-3
11
40
(m) locating ep heads,
(n) knocking out rectify. NumS.1 I
locating up heads, NumS-5
(p) knocking rectify.
NumS.5 5
64
0.
431
6.0
(q) locating op ObjC'1
knocking rectify.
ObjC-1
Figure 22: Additional results about locating erroneous processing heads with Siven2.5-7B-Instruee "knocking out to rectify" refers to measure the effect of knocking out individual heads on rectifying erroneous predictions (i.e., the probabilities of predicting ground-truth tokens). In the caption of each sub-figure, the "X" in (Task Name]-X refers to the error type. For example, MDM-2 refers to the erroneous predictions of error type of MDM.
43

---

Published as a conference paper at ICLR 2026
012
0.88
-23
-.00
(a) locating ep heads, MDM-2
(b) knocking out to rectify. MDM-2
(c) locating ep heads, MDM-5
(d) knocking out to rectify.
MDM-5
033
0.0
630
333
40.5
-33
133
(c) locating op heads, LLCC3
knocking rectify, LLC-3 (g) locating op heads, MOAS-2
(h) knocking our to rectify.
MOAS-2
loer
locating ep heads,
knocking rectify,
locating ep heads,
knocking rectify,
35
42
(m) locating ep heads, NumS-1
(n) knocking rectify. NumS-1
locating hends, NumS-5
(p) knacking rectify. NumS-5
3.
01
(g) locating op heads, ObjC-1
(1) knocking out roctify. ObjC-1
(6) locating heads, Parity-NL-2
(1) knocking out rectify. Parity-NL--2
Figure 23: Additional results about locating erroneous processing heads with Phi-3-Instrun "knocking out rectify" refers measure the effect of knocking individual heads on recti- fying erroneous predictions (i.e., the probabilities of predicting ground-truth tokens). In the caption of each sub-figure, the "X" [Taask Name]-X refers to the error type. For example, MDM-2 refers to the erroneous predictions of error type 2 of MDM.
44

---

Published as a conference paper at ICLR 2026
635
B33
005
6.5
-135
-12
-.00
locating heads, MDM-2
knocking rectify. MDM-2
locating heads, MDM-5
(d) knocking roctify.
MDM-5
600
41
4334
4.34
401
(c) locating op heads, LLC-3
knocking rectify, LLC-3
(g) locating op heads, MOAS-2
(h) knocking our to rectify. MOAS-2
-150
-33
bye
locating ep beads,
knocking rectify.
locating ep heads,
knocking rectify. CLF3
31
6on
6.15
60
(m) locating heads, Parity-NL-S
(n) knocking out to rectify, Parity-NL-8
(o) locating hends, NumS-5
(p) knocking out to rectify. NumS-5
-22
04
-66
(4) locating heads, ObjC-1
(1) knocking out to rectify, ObjC-1
Figure 24: Additional results about locating erroneous processing heads with LLaMA3-8B- "knocking rectify" refers measure the effect of knocking out individual heads rectifying erroneous predictions (i.e., the probabilities of predicting ground-truth tokens). In the caption of each sub-figure, the "X" in [Task Name]-X refers the error type. For example, MDM-2 refers to the erroncous predictions of error type 2 of MDM.
45

---

Published as a conference paper at ICLR 2026
31
locating heads. MDM-2
(b) knocking out to rectify. MDM-2
locating heads, MDM-5
(d) knocking out to rectify. MDM-5
nice
6.0
6225
(c) locating op heads, LLC-3
knocking rectify. LLC-3
(g) locating op heads, MOAS-2
(h) knocking our to rectify. MOAS-2
0.25
-0.00
0.15
6.10
606
-25
locating ep beads, CLF-1
(j) knocking out rectify. CLF-1
(k) locating ep heads, NumS-1
(1) knocking out to rectify. NumS-1
-05
(m) locating up heads, OhjC-1
(n) knocking out to rectify. ObjC-1
(a) locating ep beads, Parity-NL-2
(p) knacking out to rectify. Parity-NL-2
Figure 25: Additional results about locating erroneous processing heads with Qwen3-8B Swee3-8B-Innsiee 8B-Instruct. "knocking out to rectify" refers to measure the effect of knocking out individual heads rectifying erroneous predictions (i.e., the probabilities of predicting ground-truth tokens). the caption of each sub-figure, the "X" in [Taak Name]-X refers the error type. For example, MDM-2 refers to the erroncous predictions of error type MDM.
46

---

Published as a conference paper at ICLR 2026
Parity-NL Example
Problem:
The coin is initially heads Then Matthew doesn't flip. Then Daniel flips. Then Carter fips. Then Carter doesn't flpp. Then Ethan flips. Then Matthew doesn't flip. Then Ethan flips Then Daniel dresn't flip. Then Matthew flips. Then Ethan flips. the coin finally heads up or up?
Answer:
analyze sequence of events stop-by-step to determine state coin.
The coin starts heads
Matthew doesn' Ilip coin. (Coin remainn heads up.)
Daniel the coin. (Coin hecomes tails up.)
4. Carter flips the coin. (Coin becomes heads up.)
doesn't flip
(Coin
heads up.)
6. Ethan flips the coin. (Coin becomes tails up.)
Matthew docsn't flip coin. (Coin remains tails up.)
8. bihan
coin. (Coin becomes heads up.)
9. Daniel doesn't flpp the coin. (Coin remains heads up.)
10. Matthew the coin. (Coin becomes tails up.)
11. Ethan flips the coin. (Coin bocomes heads up.)
After going through each step, we see
ends up heads up after flip by
Therefore, the coin is heads
Figure 26: An example of the Parity-NL problem.
Multi Mitii-iigit Multiplication (MDM) Example
Prublem:
326 3589 =? please think step-by-step.
Answer:
Let's break down the multiplication of 326 and 3589 step by step. We will multiply 326 by zuch digit of 3589 and then add the results.
"*tepp I:
Multiply 326 by (units place of 3589)**
2934
(Shift this result 0 places to the left: [ 2934
"*Step 2: Multiply 326 by (tems place of 3589)
322 2608
(Shift this result place the left: [ 26080 ))
**Stop Multiply 326 (hundreds place 3589y**
[326 5 1630
(Shift
163000 )) **Step Multiply 326 by (thousands place of 3589)*+
places
|326 3
(Shifi this result places the left: 9980000
**Stop 5: Add all resalts together**
[2934 262860 00034+26080-0
163000 978000
**Step 6: Perform the addition step-by-stepr*
[2934
+90014+130000 192014]
[120014 + 978000 1170014
**Final Result"
[326 3589 = [170014]
Figure 27: An example of the MDM problem.
47

---

Published as a conference paper at ICLR 2026
Last Letter Concatenation (LLC) Example
Problem:
Take the last letters the words in "garden sound valid potato numb write truch sound hotel" concatenate them.
Answer:
concatenate
by one.
The last letter of 'garden' is 'n'. The current concatenating result is 'n'.
The last letter of "sound" 'd". The current concatenating result is 'nd'.
The letler of 'valid" 'd". The current concalenating result is 'nik'"
'o". The current concatenating result 'ndiã"" concatenating result 'nddob'. 6. The last lotter of 'write" is 'o. 'The current concatenating result is 'nddobe".
The letter of "potato"
letter of 'numb' is 'b'. The
letter of 'tiger" 'T',
current concatenating
'nddober".
8. The last letter of 'tuth' 'b'. The current concatenating result is 'nddoberh',
9. The last letter of 'sound" 'd". The current concalenating result is "nddoberhdd'
10. The last letter of "botel" '.. The concatenating result is 'ndidoberhul"" Therefore, the answer 'nddoberhdl'.
Figure 28: An example of the LLC problem.
Multi Operand Addition and Subtraction (MOAS) Example
Problem:
+88 - 85
19
88 Please think step-by step.
Answer:
Centainly!
equation step by step:
Start with 17.
Add 17 47-+48=00
3. Subtract 25:
40.
Add 99: 40 40++9 99 139.
5. Suhtract 4: 139 4 135.
6. Subtract 85: 135 - 50.
8. Add 68: 69 68 137.
9. Subtract 31: 137
106.
10. Subtruct 88: 106 88 = 18.
So, the final answer 18.
Figure 29: example of MOAS problem.
48

---

Published as a conference paper at ICLR 2026
Crawler Log Folder (CLF) Example
Py thon code::
operationns(oss): folder depth 0
for operation in logs:
operation = '.,":
folder slepth max(O, solper,
elif operation 1m '/:
deedhr +=
depth
Problem:
Given a change folder operations: "logs = I'd1', 'd2", ',n, 'd2", 'd3/", '.", 'd3,, 'd4". '/""" what return value (Jolder depth) when rumning the "min, operations()" lunction with the input "logs"?
Answer:
Let break down the operations and compute the folder depth step-by-step for given logs ['d17", 1d2", 1.7, 1427, 'd3/, 'r ..,", 'a3",, 'd4". '/].
depth 2. **Operation dd1'*=; doldor.dopth folder_depth +1
3. **Operation 02//=5; folder.depth lolder.depth +1=1+++=+++ 11=++=1=1
4. +*Operation '_ree; folder lolder max(0, folder_depth max(0,
5. **Operation 02/"="; folder_depth folder_depth +
*OOperation d3/**; folder.depth
1
7. *Operation *,**; folder depth =. (no chunge)
*OOperation -_r=;; folder.dopth max(0, folder.depth... 1)= max(0, 2) =
9. "Operation "3/"* folder.depth folder_depth 1
10. #Operation "d4*s; folder,depth =older.dephhh
11. **Operation t/*e; folder _lepih
change)
Therefore, the final return value (folder_depth) for the "min__peraaionn(" function with the inpat "logs" the 4.
Figure 30: An example of the CLF problem.
Object Counting (ObjC) Example
Problem:
Alessin got 4 bananas. Gregory picked up 6 watermelons. Lila nequired 4 lemons. Lila bought 3 pincapples. Alan obtained Alessia obtained Alan acquired apples.
Alan picked up watermelons. Gregory picked up apples. Alcasia picked oranges.
How many fruit items are mentioned above? Please think step-by-step to answer the question.
Answer:
Let's go through the information step-by-stey to count the total number of fruit items mentioned.
Initially the total number
2. "Sentonce**; Alessia got 4 bananas. **Current Total Number** 0 0+4:4.
"Sentence"*; Gregory picked watermelons. **Current Number
4. *Sentence** Lila acquired 4 lemons. **Cureet Total Number 44
*Sentence**; Lila bought pineapples. **Current Total Number*: 14+3=11
** *Semienne**;; Alan obtained strawberries. **Curenn Total Number*:; 37 20.
*Sentence**: Alessia obtained 7 lemons. **Curret Total Number+e:20 7
*Sentencc"*; Alan picked watermelons. **Cureen Total Number*"; 27 36.
9. "Sentence**: Gregory picked 6 apples. **Current Total Number** "umbber*:36+66 36
*Sentenue**; Alessia picked up oranges.
Number
11. *Sentence**, Alan aequired 8 apples. **Current Total Number** + 44 Therefore, the total number of fruit items mentioned is 52.
52.
Figure 31: An example of the ObjC problem.
49

---

Published as a conference paper at ICLR 2026
Number Student (NumS) Example
Python
def solutiontstarTimm: Listfiot). endTime: List(int). queryTime: int):
count ior range(len(sturtiime)) if startTimei]]] S queryyTine S endTimefi]:
return count
Problem:
startTime 3, 2, endTime = 5, queryTime What is the final return value after
running the function solution(start endlime, querylimme)?
Answer:
Let's go through each event and check qqueeTTeee (which 4) falls within the range of each event's start and end times: within range. **oounr*";
starTTime(0) endTime[(0] *"rage"*": [1,
2. starTime[ [] 2, endTime[[]] 8. **rang** [2, 8). is within this range. **coum**; 1 =
star[Time[]] endTime(
*>rang=**; [3, 5]. within range. ""oourt*: =
4. 3tar[[mme[3] 4, cndTime]]3 3| *"rane**:; [1, 4 within this range. **coum"*:; 3 1++1=1
strrTiime[4]] 6, endTime][41 [| **range**; [6, 9. not within this range. "Pcoul
starTime[5] end[iime[S]
*"rang=*"; [2, 5], 4 within this range. *coum**: 4 1 =
7. startTime[(]] = c.ndTime[6] =7 *"range*;; [5, 7]. not within this range. "*ouutt*: 5.
star([ime[]]= cnndTimme]71
*"range*";
not within this range. **oount** 5.
9. starTime[8] 2, endTiimm[8]] =4. **range**; [2, 4], is within this range. ""oumm** 5
10. startTime[9) cndTimm])] + "*range**: [4, 91, within this range. ""oonnt** 1=+=
Aller checking events, function returns the final count. which is
Figure 32: An example of the NumS problem.
Possible Error Types in a LLC Example
Problem:
Take the last letters the words in "garden sound valid potato numb tiger truth sound hotel" concatenate them.
Answer:
concalenate
by
The last letter of 'gnnlen" ["Type Word Recall Error, 'garden' - "valid" ] is 'n'. The current concatenating result is 'n'.
2. The last letter of 'sound' is 'd' ['Xype 2: Letter Error, "d" - *a" J. The current concatenating result is 'nd'. letter of 'valid'
current concarenating result 'ndd' [Type 3: Concatenation Error, 'ndd" - 'dnd'
Omitting intermediate six steps
10. The lettor of 'hotel' is T. The current concatenating result is 'nddoberhdI". [Type Reasoning Less/More Steps Therefore, the answer 'nddoberhdl'.
Possible error types in a LLC problem. The underline green parts highlight the positions where errors of different types may occur. The bold blue parts indicate the error types. For each error type, we only mark one instance.
Figure 33:
Possible Error Types in a MOAS Example
Problem:
17 + 4.44 - 25 4- 85 + 68 31 88 Please think step-by-step.
Answer:
Certainly! Let solve the equation step step:
Start with [Type I: Operand Recall Error, 17 - 48
2. Add [Type 2: Operation Recall Error, Add 48 Subtract 31 4- -
3. Subtract 25: 65 [Tppe& 3: Local Result Copy Error, 65 - 35 [_yye 4: Operand Interpretation Error, + + +25 129 J.
Add
139 [Type S: Calculation Error,
Omiiting intermediate five steps
10. Subtract 88 18.
[Type 6/7: Reasoning Less/More Steps Sa, the final answer is 18.
Figure 34: Possible error types in a MOAS problem. The underline green parts highlight the posi- tions where enrors of different types may occur. The bold blue parts indicate the error types. For each error type, we only mark one instance.
50

---

Published as a conference paper at ICLR 2026
Possible Error Types in a CLF Example
Python code:
def min operationsslogs):
folder depth
for operation in logs:
il operation '.f":
folder dlept max(O, folder
elif operation '/:
folder
return folder depth
Problem:
Given of change folder operations: "logs l'd1/". 'd2", './", 'd2". 'd3/", ',"", 'd3",, 'd4", "/"" what is the return value alepder when running the "min.operations(" lunction with the inpul "logs"?
Answer:
Let us break down the operations and compute the folder depth step-by-step for the given list logs.
*Initial
folder depth =0
2. +*peraaton 'dI/' ['Type 1: Operation Recall Error, 'd1/" 'd2/" 1e;; folder depth folder 1
*Ogeration 'd2/*9; en; folder_depth folder_depth
[[ype 2: Depth Copy Error, 1=+1=2. "Operation" r,, lolder.depth max(O, Iolder_depth- 1) max(O, =)
5. *Operation 62/"* e*; delthr.depth folder depth + = [Type 3: Local Calculation Krror,
Omitting intermediate five steps
11. +Operation "J*+e; folder depih = (no change) [Type Reasoning
Steps
Therefore, tbe (inal return value (lolder.depth) the "min.operaation"" function with the input "logs" is ['Tyee 6: Final Depth Copy Error; 3..
So the answer
Possible error types in a CLF problem. The underline green parts highlight the positions where errors of different types may occur. The bold blue parts indicate the error types. For each eгror type, we only mark one instance.
Figure 35:
Possible Error Types in an ObjC Example
Problem:
Alessin got hananas. Gregory picked up 6 watermelons. Lila acquired 4 lemons. Lila bought 3 pineapples. Alan obtained strawberries. Alessia obtained lemons. Alan picked up waternelons. Gregory picked up apples. Alessia picked oranges. Alan acquired 8 apples.
many fruit
are mentioned
think step by step answer question.
Answer:
Let's go through information step-by-stop to count the total number fruit items mentioned.
Initially the total number
2. **enttenc"**; Alessia [Type 1: Name Recall Error, Alessia Lila got bananas. **Current Total Number**; 0 4
* Gregory picked watermelons [Type Object Infromation Recall Error, watermelons lemons
1 **Current Total Number**; 4 + = 10.
**Current Number* [Type 3: Local Copy Error, 5. *Senttence*;; Lila bought pincapples. "*Current Toral Number* 14 +
"Sentence**; acquired
[yype 4: Local Caleulation Error, 17
18
Omitting intermediate five steps
11. *Sentence**, Alan uxquired 8 apples. **Current Total Number"*, 44 = 52.
[Type Reasoning Les//More Steps Therefore, the total mumber of fruit items mentioned is 52.
Figure 36: Possible error types in ObjC problem. The underline green parts highlight the positions where errors of different types may occur. The bold blue parts indicate the error types. For each error type, we only mark one instance.
51

---

Published as a conference paper at ICLR 2026
Possible Error Types in NumS Example
Py Python code:
del solation(stur(Ting Listlint) Time: Listjint], queryTTmee: int):
count D
if startTime[i] queryTime Time codTime(i):
count +=
Problem:
[4, 5. query running the function solution(start Time, endTime, queryTime)?
[1. 2. 4],
final
Answer:
Let's through each event and check Time (which is falls within the range of each event's and end times: startTime[0]]= [lype 1: Time Recall Erron, 1 - endTime][)] 4. *Prage**; 9 [1, 4), within this range. *foount"
==
2. star[Tme[[]] = 2, endTime[1] *#ngge"": [2 [Type 2: Time Copy Error, 2 - 8., 8), within this mage. **ouunt*
3. starrTime[2] endTime[2] **angg**: [3, 5], is within this range. **oount* [Type 3: Local Result Copy Error; 2 -13
4. startTime|]] end 33 5. **range**: [4, 5J. is within this range. **oount*: 3 ['Type Local Calculation
Error, 4 44-33.. 3
5. stariTimef4] endTime[4] 99. **range**:
is within [Type Condition Judge Frror, not within within
this range. **ooum"*; 4,
starTime[S]] endTime[5] **range**; [2, 5], within range. <>omnt** 4+ (Type Calculation Logic Error, *4 = 5" - [.").
Ommitinng intermediate three steps...
10. startTime[9] endTime[9] "*rang"**: [4, 9], within this range. "*count* 6 [Type 7/8: Reasoning Less/More Steps ] Alter checking events, function
count, which
Figure 37: Possible error types in a NumS problem. The underline green parts highlight the positions where errors of different types may occur. The bold blue parts indicate the error types. For each error type, we only mark one instance.
52


Reviews:
[{"review_id": "94NISa4eaC", "reviewer": "Reviewer_ZZNy", "summary": "The paper studies reasoning-hop generalization in LLMs. It decomposes chain-of-thought into hop-level positions, defines task-specific error types, and then uses logit-lens / knockout to identify answer-writing heads and processing heads. The core claim is that correct and erroneous trajectories coexist internally, and hop failure largely comes from a small set of erroneous processing heads dominating late layers. A test-time head-selection / knock-out procedure improves accuracy.", "questions": "**Q1.Error-type identification in real-world NL reasoning.**\n\nIn this work, the key step for mechanistic probing is that “critical error types” are first localized (Appendix E.1) and then those token positions are used as entry points for head attribution. For general NL benchmarks, error boundaries are not syntactically aligned to deterministic step indices, and model outputs are free-form.\n\nHow do you envision the error-type mining procedure to scale to such settings? Would this require a learned error tagger? a verifier? or a retrieval oracle to define step boundaries?\n\n**Q2. Applicability to non-linear reasoning policies (with backtracking / exploring).**\n\nYour entire head-tracing argument implicitly assumes a linear monotonic accumulation of residual signal along a single chain (hop 1 → hop 2 → hop 3 …).\nRL-style models perform backtracking, branch scoring, and dynamic re-evaluation of earlier states.\n\nDo you believe the cp vs ep competition in late layers is still a meaningful concept in a policy that does dynamic branch selection?\nIf yes, is the right object to knock out still an “attention head” or does the unit become a search operator?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 4, "contribution": 2, "strengths": "- The angle is genuinely new. Instead of saying “model can’t reason”, it argues that correct reasoning traces often coexist but get overshadowed by competing erroneous heads. This produces a novel mechanistic framing of hop failure.\n- The paper is extremely well-structured. The narrative from “error type → internal mechanism → test-time correction” is clean and easy to follow.", "weaknesses": "**W1.** “error types” are human-defined task-specific taxonomies (Appendix E.1), not emergent internal state clusters of the model, so the mapping from annotation layer → mechanism layer is not guaranteed.\n\n**W2.** Evaluation covers only synthetic / programmatic hop-style tasks. No natural-language reasoning benchmarks (e.g., GSM8K, MATH, AIME, Leetcode).\n\n**W3** No experiments on reasoning-style models (RL-based, verifier-based, or scratchpad-policy optimized models), whose non-linear reasoning chain dynamics are known to differ substantially from vanilla SFT LLMs. So universality claims are untested.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "GH4cSc8wtx", "reviewer": "Reviewer_iLuH", "summary": "Recent studies reveal a sharp performance drop in reasoning hop generalization scenarios. To understand these failures, the authors first investigate two research questions: 1) Where do errors occur? 2) Why do these errors arise? They found that these failures concentrate on token positions of a few key error types, and the error trajectories can suppress the correct ones. To address this issue, the authors proposed Test-time Correction of Reasoning (TCR), which trains a classifier to dynamically identify and deactivate the erroneous heads during inference. Experimental results prove the effectiveness of the proposed method, TCR.", "questions": "1. The classifier is an interface to LLMs. Can we directly improve the LLM's ability by teaching it to stop searching the error trajectories?\n2. See weakness 2. How does the method perform on large models?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The paper investigates the reasoning hop generalization problem,  and provides valuable insights to understand where and why the problem happens. The findings may contribute to the recent reasoning research community.\n2. Based on their findings, the authors propose an effective solution.", "weaknesses": "1. The proposed method needsto  train a classifier for tasks. Although the results achieve some ood performance. However, there are still marginal gaps between id and ood. \n2. Lack experiments on larger models, like 13B, 32B. Only 7B is not convincing enough.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "RgZ2kQZgZD", "reviewer": "Reviewer_VfVH", "summary": "This paper investigates why LLMs fail to generalize in multi-hop reasoning tasks, finding that errors are concentrated in the several error types and dominated by few attention heads. Using residual stream analysis and attention head interventions, the authors uncover a competition mechanism between correct and erroneous reasoning signals within the model. Based on these insights, they propose Test-time Correction of Reasoning (TCR), a lightweight intervention that dynamically deactivates erroneous heads to significantly improve hop generalization performance.", "questions": "see Weakness.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. I think overall this is a good paper; it not only provides a mechanistic analysis but also proposes an improved algorithm based on these insights.\n\n2. The paper is presented in a clear and logical manner, making it easy to follow and understand.", "weaknesses": "1. Although the TCR method effectively improves performance, considering that it requires prior attention-head selection and training an additional small model, I am unsure whether this workflow would be computationally acceptable in practice.\n\n2. I think reporting additional metrics on the consistency of model outputs after applying TCR would strengthen the paper. For example, showing whether the predictive entropy is effectively reduced could further support the method’s effectiveness.\n\n3. I noticed that Equation (4) uses normalization to represent relative change trends. One concern is that the final averaged results may be overly influenced by cases where the denominator is small. For example, if the change $f(h) - f(h-a) = 0.2$, the resulting $s(a)$ will be 100% if $f(h) = 0.2$ and only 0.25% if $f(h) = 0.8$. I am unsure whether removing this normalization would affect the final head localization. Reporting the change $f(h) - f(a)$ or the distributions of $f(h)$ and $f(h) - f(a)$ would be somewhat helpful.\n \n4. In locating the answer-writing heads, the paper uses the Logit Lens interpretability tool (mentioned in Section 2). I understand that this is a common approach in interpretability studies. However, different layers and heads in the model may operate in entirely different semantic spaces, which do not necessarily align with the semantic space of the final unembedding matrix. Therefore, this mapping may not fully carry the intended meaning. I think a discussion of the limitations and some justification for its use would be helpful.\n\n5. While the logic of the content is clear, Section 4 is very dense in text. It might be helpful to simplify it or break it into smaller subsections, making it easier for readers to follow.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "Pjc2cK8YFB", "reviewer": "Reviewer_C6Fu", "summary": "This paper studied language model tasks that involve “reasoning hop generalization”. They localize errors in the reasoning chains of LMs by identifying predicted token positions which erroneously diverge from the expected token positions. The authors study the role of activation heads in correct vs. incorrect text generation trajectories. They identify a key set of attention heads which play a role in erroneous prediction via a knock-out mechanism. They find that there is substantial overlap between the critical attention heads for both erroneous and correct completion trajectories. They use this finding to motivate the design of test-time correction of reasoning (TRC). They show that applying TRC improves performance across many models across many benchmark tasks.", "questions": "1. On line 182 you formalize the n-hop problem, but in practice how do you decompose a CoT response into individual “hops”? Does a human have to go in and annotate all of the “hops”?\n2. Along the lines of the previous question, how do you identify errors within reasoning chains as per the error-types outlined in Appendix E.1? For example on line 300 you write for the 50-hop parity-NL tasks, ~79% of errors are type 2; how did you calculate this? Did a human go and read through all of the reasoning chains for the 50-hop parity tasks and label errors?\n3. Suggestion for clarity: You use an example to detail the errors you track for all tasks in Appendix E.1, but I would prefer a clear table that outlines the names of all of the tasks and the names of all of the corresponding error types in addition to the examples you provide.\n4. In section 5, I am always left wondering if the premise of training a model (e.g., knockout classifier model) to intervene on a model (e.g., language model) is maybe a bit convoluted. Why not just train your language model further on the same dataset you used to train the knock-out model? How would the results compare on the same test dataset? Upon reading further it looks like your knockout classifier model is  Qwen2.5-0.5B w/ a classifier head…since this model is the same size as the models you are intervening on (E.g., table 1 models are all roughly 7-8B parameter counts), then it is not like you are saving compute cost by training a smaller classifier model; it is about the same size as the base model itself. \n5. I appreciate that once the classifier is trained, the test-time intervention (TRC) is computationally efficient and light-weight. What is the cost of training the classifier as opposed to just training the base model itself?\n\n[1] Memory Injections: Correcting Multi-Hop Reasoning Failures during Inference in Transformer-Based Language Models. BlackboxNLP Workshop at EMNLP 2023.\n\n[2] LOFIT: Localized Fine-tuning on LLM Representations. NeurIPS, 2024.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. The proposed method, TRC, does improve model performance on a wide range of tasks across a reasonable number of models (table 2).\n2. It is interesting to show that simply intervening on a trained model can substantially improve model performance. It indicates that models often have the knowledge needed to complete long-context tasks, but simply struggle to do so due to length of context. This validates well known phenomena of LMs struggling to be performant to varying context lengths.\n3. I felt the tables and figures were easy to understand.\n4. I appreciate the appendix, I found myself needing to reference it several times while reading this paper.\n5. Lines 176-178 are a good observation. Existing interpretability tools do struggle to be applied across vast token ranges.\n6. The procedure to determine when to intervene (lines 408-417) are both light-weight and reasonable.", "weaknesses": "1. I feel like there is a conflation between what this paper dubs “reasoning hops generalization” and a commonly studied NLP task of: “multi-hop reasoning”. Multi-hop reasoning is a task which may require the successful completion of many intermediate reasoning steps to arrive at the final answer [1]. Chain-of-though is a prompting strategy that can be employed with any LM task (including and not limited to: multi-hop reasoning). You use the term “n-hop” problem on line 179, but this is almost identical terminology to the multi-hop reasoning literature. It's fine to use the term since it's defined, but, like me, I suspect it may confuse readers who are doing a quick skim between your problem setting and the canonical multi-hop setting.\n2. On lines 184-185 you use erroneous token-positions as proxies for identifying reasoning errors within the prompt completion. By this extension, in figure 2, is each reasoning hop number simply another erroneous token? If so, this is an overstatement of “reasoning hops” and rather should just be plainly labeled as erroneous token predictions. It makes more sense to predetermine all of the reasoning hops the model needs to make before identifying if there are errors at those positions; here you are using known errors to post-hoc identify reasoning hops? A related question: in figure 2, if you observe an error at a later reasoning hop number (e.g., later token position), was this after you corrected all previous errors at previous token positions, or is this a setting with cascading auto-regressive errors? If it is the autoregressive setting, this is not a surprising – models continue to make mistakes when fed erroneous prompts.\n3. In response to lines 49-52, it seems like you are missing some related work which has studied this issue [1].\n4. You discuss how you use the knockout mechanism to identify answer-writing heads in line 245-254, but it is not clear to me what the “answer” is here. Is it the expected-next-token immediately following the error token position you are analyzing? Is the answer the expected-next-token for the entire prompt? From formula 4, it looks like you are measuring the relative impact of an attention head on the vocabulary token associated with the erroneously predicted token t (shouldn’t you be measuring the impact on the correct/expected-next-token if you are looking to analyze the head’s relevance to the answer and not the error?\n5. From line 258-259 it is  not clear to me what is Scorr  vs Serr? What are the correction and erroneous prediction sets? Are these the erroneously predicted tokens and anticipated correct tokens? What about the token selections is “random”?\n6. You have a single competing baseline which you report (DoLa). DoLa is a decoding-based method, and your work is focused on activation interventions. I think your work could benefit from a direct comparison to LoFiT [2], or at least a discussion of what distinguishes both approaches.\n7. Typos: Line 17-18: Do you mean “...systematic study {of} tasks…”\n\n[1] Memory Injections: Correcting Multi-Hop Reasoning Failures during Inference in Transformer-Based Language Models. BlackboxNLP Workshop at EMNLP 2023.\n\n[2] LOFIT: Localized Fine-tuning on LLM Representations. NeurIPS, 2024.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)