Paper deep dive
Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring
Weixin Guan, Liang Li, Jiapeng Liu, Bing Li, Peng Fu, Chengyang Fang, Xiaoshuai Hao, Can Ma, Weiping Wang
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 96%
Last extracted: 3/22/2026, 5:07:13 AM
Summary
The paper introduces RPDI-EE, a training-free early-exit method for Large Reasoning Language Models (LRLMs) designed to mitigate 'overthinking'—the generation of redundant reasoning steps. By monitoring the Reasoning Path Deviation Index (RPDI), which tracks the ratio of local to global token entropy, the method identifies high-entropy transition tokens (e.g., 'Wait', 'But') that signal reasoning deviation. This approach avoids the overhead of proxy models and the performance degradation caused by over-truncation, demonstrating significant improvements over vanilla Chain-of-Thought (CoT) reasoning.
Entities (5)
Relation Signals (3)
RPDI-EE → uses → Reasoning Path Deviation Index
confidence 100% · RPDI-EE, an early-exit method based on the Reasoning Path Deviation Index
RPDI-EE → mitigates → Overthinking
confidence 95% · we propose RPDI-EE... to dynamically detect and terminate overthinking trajectories
LRLMs → utilizes → Chain-of-Thought
confidence 90% · LRLMs demonstrate impressive capabilities on complex tasks by utilizing long Chain-of-Thought reasoning
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large Reasoning Language Models (LRLMs) demonstrate impressive capabilities on complex tasks by utilizing long Chain-of-Thought reasoning. However, they are prone to overthinking, which generates redundant reasoning steps that degrade both performance and efficiency. Recently, early-exit strategies are proposed to mitigate overthinking by dynamically and adaptively terminating redundant reasoning. However, current early-exit methods either introduce extra training overhead by relying on proxy models or limit inference throughput due to the frequent content switching between reasoning and generating probing answers. Moreover, most early-exit methods harm LRLMs performance due to over-truncation. Our insight stems from an observation: overthinking often causes LRLMs to deviate from the correct reasoning path, which is frequently accompanied by high-entropy transition tokens. Given this, we propose an early-exit method deeply coupled with the native reasoning process, which leverages the path deviation index as a dedicated monitoring metric for the frequent occurrence of high-entropy transition tokens to dynamically detect and terminate overthinking trajectories. We conduct experiments across multiple benchmarks using LRLMs of different types and scales, and the results indicate that our method delivers the largest performance improvement over vanilla CoT compared to existing early-exit methods.
Tags
Links
- Source: https://arxiv.org/abs/2603.14251v1
- Canonical: https://arxiv.org/abs/2603.14251v1
Trouble viewing inline? Open PDF directly →
Full Text
67,771 characters extracted from source content.
Expand or collapse full text
Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Weixin Guan 1 2 Liang Li 1 † Jiapeng Liu 1 2 Bing Li 1 Peng Fu 1 Chengyang Fang 3 Xiaoshuai Hao 4 * Can Ma 1 Weiping Wang 1 Abstract Large Reasoning Language Models (LRLMs) demonstrate impressive capabilities on complex tasks by utilizing long Chain-of-Thought reason- ing. However, they are prone to overthinking, which generates redundant reasoning steps that de- grade both performance and efficiency. Recently, early-exit strategies are proposed to mitigate over- thinking by dynamically and adaptively termi- nating redundant reasoning. However, current early-exit methods either introduce extra train- ing overhead by relying on proxy models or limit inference throughput due to the frequent content switching between reasoning and generating prob- ing answers. Moreover, most early-exit methods harm LRLMs performance due to over-truncation. Our insight stems from an observation: overthink- ing often causes LRLMs to deviate from the cor- rect reasoning path, which is frequently accompa- nied by high-entropy transition tokens. Given this, we propose an early-exit method deeply coupled with the native reasoning process, which leverages the path deviation index as a dedicated monitoring metric for the frequent occurrence of high-entropy transition tokens to dynamically detect and termi- nate overthinking trajectories. We conduct experi- ments across multiple benchmarks using LRLMs of different types and scales, and the results indi- cate that our method delivers the largest perfor- mance improvement over vanilla CoT compared to existing early-exit methods. *Project leader. 1 Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China 2 School of Cyberspace Security, Univer- sity of Chinese Academy of Sciences, Beijing, China 3 School of Computer and Artificial Intelligence, Jiangxi University of Finance and Economics, Jiangxi, China 4 Xiaomi EV. Correspondence to: Liang Li <liliang@iie.ac.cn>. Preprint. March 17, 2026. 1. Introduction Large Reasoning Language Models (LRLMs) (Guo et al., 2025; Team, 2025; Yang et al., 2025a) demonstrate impres- sive capabilities on complex tasks by leveraging long Chain- of-Thought (CoT) reasoning. However, extended chains introduce a critical weakness: LRLMs often engage in over- thinking (Chen et al., 2024b; Su et al., 2025; Marjanovi ́ c et al., 2025), a phenomenon in which the model generates redundant reasoning steps that fail to meaningfully con- tribute to the final answer. More seriously, overthinking degrades reasoning performance and increases reasoning latency. Specifically, unnecessary reasoning steps increase computational costs and lead to unnecessary latency. Mean- while, excessive reasoning steps can distract the model dur- ing final-answer generation and lead to deviations from the correct reasoning path due to error accumulation. To mitigate overthinking, some researchers introduce the early-exit strategy, which truncates the reasoning process and switches directly to generating the final answer once it detects that the model has produced sufficient intermediate reasoning steps. Early explorations (Muennighoff et al., 2025; Ma et al., 2025; Li et al., 2025) propose setting a fixed maximum length for reasoning to prevent the model from overthinking. However, this mode lacks the necessary flexibility to adapt to problems with varying complexity. Recent studies (Xu et al., 2025; Fang et al., 2025; Ding et al., 2025) address this weakness by dynamically identifying early-exit points for adaptive processing of problems with varying difficulty. Specifically, these methods divide the reasoning process into a series of reasoning segments using heuristics and evaluate whether to exit early at the boundary of each segment. To determine early-exit points, some approaches (Yang et al., 2025c; Jiang et al., 2025a; Zhang et al., 2025a; Akg ̈ ul et al., 2025) introduce additional proxy models as a detector. Nev- ertheless, proxy models introduce extra training overhead and require specialized training to adapt them to different models and tasks. Alternatively, other methods (Yang et al., 2025b; Yong et al., 2025; Fu et al., 2025; Akg ̈ ul et al., 2025) identify early-exit points by probing the answer. They gen- erate tentative answers at reasoning segment boundaries 1 arXiv:2603.14251v1 [cs.CL] 15 Mar 2026 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Question: Let 퐀 1 퐀 2 ...퐀 11 be an 11-sided non-convex simple polygon with the following properties: The area of 퐀 퐀 퐀 1 퐀 퐀+1 is 1 for each 2≤i≤10, cos(∠퐀 퐀 퐀 1 퐀 퐀+1 )= 1213 for each 2≤i≤10, The perimeter of 퐀 1 퐀 2 ...퐀 퐀+1 is 20. If 퐀 1 퐀 2 +퐀 1 퐀 11 can be expressed as (퐀 퐀 −퐀)퐀 for positive integers 퐀, 퐀, 퐀, 퐀 with 퐀 squarefree and no prime divides all of 퐀, 퐀, 퐀, find 퐀+퐀+퐀+퐀. Okay, so I have this problem ...... Let me try to break down the problem step by step. <ommited 9813 tokens> Therefore, ...... <ommited 9813 tokens> Therefore, 퐀+퐀+ 퐀+퐀=퐀+퐀+퐀+퐀=퐀. But wait, let me double- check if this is correct because the perimeter is 20, and the ...... <ommited 1641 tokens> Then, the remaining perimeter is 20−4.78≈15.22, which is distributed among the other 9 sides, each of which is either 퐀 or 퐀䀀퐀. <ommited 105 tokens> Wait, no, hold on. Let me count: From 퐀 1 to 퐀 9 : 퐀 1 =퐀, 퐀 2 =26/5퐀, ......<ommited 26 tokens> Turning Occurs The First Stage LRLM thinking Token are completely exhausted Final Response The Second Stage, frequently “Wait, no, hold on.“ Wait, no, hold on. Wait, actually, there are 5 sides of 퐀 and 4 sides of 26/5퐀. Therefore, ...... is 5퐀+4×(26/5퐀)= 5퐀+104/5퐀. <ommited 32 tokens> Wait, no, hold on. Wait, the perimeter is 퐀 1 +퐀 2 +...+ 퐀 11 . <ommited 25 tokens> ...... <ommited 2874 tokens> Figure 1. Reasoning trajectory dissection revealing the “overthink- ing” trap. The model initially achieves the correct result but fails due to a flawed verification loop. The frequent emergence of tran- sition tokens (e.g., “Wait,” “But”) serves as a key indicator of reasoning deviation. and terminate the reasoning process once the confidence or consistency of these answers exceeds a threshold. These approaches are more cost-effective and widely applicable, offering immediate benefits for existing large-scale models, e.g., DeepSeek-R1-671B (Guo et al., 2025) and Qwen3- 235B (Yang et al., 2025a). However, these methods often cause the generation to frequently switch between reasoning steps and tentative answers, thereby limiting the response speed. Furthermore, we observe that some of these methods (Fu et al., 2025; Li et al., 2025; Yang et al., 2025c; Jiang et al., 2025a; Zhang et al., 2025a; Ma et al., 2025; Muen- nighoff et al., 2025) exhibit performance degradation com- pared to vanilla CoT in some scenarios. This performance bottleneck might be attributed to over-truncation: LRLMs manifest spurious confidence levels, leading to suboptimal early-exit decisions and effectively ’silencing’ the model before it can achieve self-rectification. Such observations reveal a decoupling between the consistency of tentative answers and the intrinsic quality of the model’s reasoning trajectory. Consequently, it may be necessary to look in- ward at the reasoning trajectory itself rather than solely looking forward at tentative answers. Building on this ‘inward’ perspective, this paper explores the use of latent trajectory signals to mitigate overthink- ing in LRLMs while safeguarding against over-truncation. Theoretically, information entropy serves as a dynamic indi- cator of the model’s internal uncertainty during generation. Moreover, existing studies suggest that high-entropy tokens within a reasoning trajectory often manifest as transition terms, such as ‘wait’, ‘alternatively’, or ‘but’. Intuitively, a high frequency of these transition tokens indicates that the model is producing fragmented reasoning chains, struggling to deepen a single reasoning path. Figure 1 illustrates this be- havior in an LRLM solving a geometry problem. Although the model initially finds the correct answer, it makes a small calculation error during verification. This error triggers a logical contradiction with the problem’s conditions, leaving the model “stuck,” i.e., overthinking. This state is clearly marked by the repetitive use of transition tokens like “Wait” showing that the model cannot deepen the reasoning path. Based on this, we hypothesize that an anomalous frequency of these high-entropy tokens can serve as an internal signal of the model entering a state of overthinking. While directly counting high-entropy tokens is intuitive, such a “hard count” approach relies on a specific entropy thresholds that fail to generalize across different models and task difficulties. Through an extensive visualization of rea- soning trajectories, we observe that token entropy follows a long-tail distribution: the vast majority of tokens possess negligible entropy, while a small number of transition to- kens contribute most of the average entropy. Please refer to Section 3 for more details. Inspired by these insights, we propose RPDI-E, an early-exit method based on the Rea- soning Path Deviation Index (RPDI), which uses average entropy as a “soft count” of high-entropy tokens to avoid the instability of hard thresholds. Specifically, RPDI-E calcu- lates RPDI as the ratio of Local Transition Frequency (LTF) to Global Transition Frequency (GTF). Among them, LTF is the average entropy of the most recently generated reasoning content, reflecting the frequency of local transition tokens. In contrast, GTF calculates the average entropy of the entire reasoning trajectory produced thus far, serving as a global baseline. By calculating this relative frequency change, the RPDI quantifies anomalous spikes in the frequency of transition tokens relative to the overall reasoning process, allowing the system to distinguish unproductive wandering from normal thinking transitions. When the RPDI exceeds a predefined thresholdλ, signaling that the reasoning path is deviated into overthinking, RPDI-E triggers an early exit—effectively suppressing redundant inference before it impairs performance. Our contributions are summarized as follows: • We provide a new perspective on model overthinking, identifying that it manifests internally as a surge in high-entropy transition tokens (e.g., “Wait”, “But”). • We propose RPDI-E, a novel, training-free early- exit method based on the Reasoning Path Deviation Index. It does not require introducing external proxy 2 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring models or probing for answers, thus avoiding extra computational costs. • We conduct extensive experiments across multiple benchmarks using LRLMs of various types and scales. The results demonstrate that our approach achieves the largest performance improvements over vanilla CoT and effectively mitigates the over-truncation is- sues prevalent in existing early-exit strategies. 2. Related Works The emergence of LRLMs has demonstrated that long CoT reasoning can significantly enhance performance on com- plex tasks. However, this capability also introduces over- thinking, where models produce excessively long reasoning chains that increase computational costs and may degrade performance through error accumulation and reasoning path deviation (Chen et al., 2024b; Su et al., 2025; Gan et al., 2025). Existing mitigation strategies can be broadly catego- rized into training-time and inference-time optimizations. Training-time optimization aims to encode efficient rea- soning patterns directly into model parameters. A common strategy fine-tunes models on datasets where verbose rea- soning is distillation into concise chains (Fatemi et al., 2025; Shen et al., 2025). Another line of work employs reinforce- ment learning with efficiency-driven rewards such as length penalties to encourage shorter reasoning (Qiao et al., 2025; Kang et al., 2025; Liu et al., 2024). More radical approaches compress reasoning into latent representations (Yeo et al., 2025; Lou et al., 2025), improving token efficiency but often at the expense of the verifiability provided by explicit reason- ing. While these methods can produce efficient reasoners, the efficiency bias becomes permanently encoded in model parameters, limiting adaptivity to dynamic computational budgets without costly retraining. Inference-time optimization aims to adjust the reasoning procedure without modifying model parameters. Multi-path reasoning generates several chains to mitigate individual er- rors (Ding et al., 2025; Wang et al., 2025c; Sun et al., 2024), but is computationally expensive and subject to diminish- ing accuracy gains from additional reasoning paths due to high correlations across chains. Difficulty-based approaches trigger long CoT only when problems appear challenging (Fang et al., 2025; Jiang et al., 2025b; Chuang et al., 2024), but once activated, they provide little control and may still lead to overthinking. Prompt-based techniques dynamically modulate reasoning length (Xu et al., 2025; Han et al., 2024; Chen et al., 2024a; Renze & Guven, 2024; Lee et al., 2025), though they remain sensitive to prompt design and rely on the model’s intrinsic ability. Additionally, compressing gen- erated reasoning paths can reduce context size, but does not reduce the cost of generating redundant tokens, and com- pressing generated reasoning paths may lead to discarding 020406080100 Percentile Sorted by Entropy Low to High 0 2 4 6 8 Contribution (%) Token Entropy Distribution & Contribution Entropy Contribution Figure 2. Token Entropy Contribution Distribution. This figure illustrates the distribution of45.9million tokens, sorted by their entropy values from low to high. The tokens are divided into 100 percentile bins, with the y-axis representing the percentage contribution of the total entropy within each bin relative to the aggregate entropy of all tokens. essential information (Yan et al., 2025; Zhang et al., 2025b). To more precisely address the overthinking phenomenon, early-exit strategies have emerged as a specialized class of inference-time adaptations. The simplest approaches employ a Token-budget design, imposing fixed length con- straints to truncate reasoning (Muennighoff et al., 2025; Li et al., 2025; Ma et al., 2025). While easy to implement, these methods lack task-level adaptivity and often lead to over-truncation, sacrificing performance for efficiency. To improve adaptivity, some strategies utilize proxy models to monitor reasoning progress (Jiang et al., 2025a; Yang et al., 2025c; Zhang et al., 2025a; Akg ̈ ul et al., 2025). Alterna- tively, other methods use the model’s own generation as a stopping signal by interrupting the reasoning stream to probe tentative answers and determine termination points (Yang et al., 2025b; Yong et al., 2025; Fu et al., 2025; Akg ̈ ul et al., 2025). Although these methods avoid expensive training, they either introduce training overhead for proxy models or suffer from substantial context-switching overhead during probing. We compare the characteristics of various early- exit methods across multiple dimensions in a tabular format; please refer to Appendix C for details. 3. Preliminary Experiment Before establishing our methodology, we conduct a prelimi- nary analysis to characterize token entropy across various reasoning trajectories. The goal is to investigate how the token entropy fluctuates as the model navigates complex logical steps and to identify statistical patterns that might govern these transitions. Following previous work (Wang et al., 2025b), we utilize the vanilla CoT to conduct sta- tistical analysis on the 45.9 million tokens generated by the DeepSeek-R1-Distill-Qwen series (7B, 14B, and 32B) models across seven datasets. To ensure consistency, all 3 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Figure 3. Visualization of High-Frequency Tokens among Top Entropy Contributors. This figure highlights the most frequent tokens within the20%of tokens that contributed most to the aver- age entropy. Only tokens that constitute complete English words are retained. experimental configurations are aligned to the vanilla CoT settings used in our main experiments. As illustrated in Figure 2, we observe that the distribution of entropy contributions exhibits a striking long tail: the vast majority of tokens possess negligible entropy, while a few transition tokens contribute most to the average en- tropy. Specifically, the first60%of tokens (sorted by en- tropy) contribute almost zero to the total entropy sum. This implies that during the reasoning process, the model main- tains extremely low entropy for most tokens, while a few high-entropy tokens predominantly drive the overall average entropy. Furthermore, we visualize the20%of tokens that contributed most to the average entropy in Figure 2, and the results are displayed in Figure 3. It can be seen that the high-entropy tokens are mainly transition tokens. In summary, we can draw an empirical insight: since the average entropy is mainly determined by these few high- entropy tokens, it can serve as a soft counting proxy for the density of transition tokens in a sequence. 4. Methodology This paper proposes a dynamic early-exit method based on “looking inward” at the reasoning trajectory itself, aim- ing to achieve precise early-exit decisions by analyzing the internal states of the reasoning process in real time to mit- igate the “overthinking” issue in LRLMs. As illustrated in Figure 1, the framework consists of three components: Real-time Trajectory Entropy Tracking, Path Deviation In- dex Construction, and Dynamic Early-Exit. The algorithm is detailed in Appendix A. 4.1. Real-time Trajectory Entropy Tracking To provide a robust data foundation for subsequent path deviation detection, this component extracts and quantifies uncertainty signals from the model’s continuous generation process in real-time. Based on the “looking inward” con- cept, it directly leverages the internal probability distribution during reasoning. Through lightweight computation, the component enables efficient monitoring of entropy dynam- ics without interfering with the normal reasoning process. Token-level Entropy ExtractionTo quantify the model’s uncertainty at each token generation step, we extract the complete probability distribution from the output layer and compute its Shannon entropy. Specifically, at thei-th gen- eration step, the model produces a probability distribution p i for the next tokent i , conditioned on the initial prompt Pand the previously generated reasoning contentR. The entropy of this distribution is defined as: H(t i ) =− X v∈V p i (v) logp i (v),(1) whereVdenotes the model’s vocabulary. The resulting entropy valuesH(t i )are recorded sequentially to form an entropy sequenceH. This process maps the model’s implicit uncertainty onto a continuously measurable scalar sequence, providing a rigorous quantitative framework for identifying anomalous patterns of high-entropy tokens. Incremental Entropy AccumulationTo efficiently com- pute both local and global entropy sums without redundant calculations, we design an incremental entropy accumula- tion mechanism. This mechanism maintains running sums of entropy values, eliminating the need to re-sum the en- tire history each time local or global statistics are required. Specifically, we maintain two accumulator variables:S i global for the cumulative sum of all token entropies from the begin- ning of reasoning, andS i local for the sum of entropies within the most recent sliding window of sizeW. Upon generating a new tokent i with entropyH(t i ), both accumulators are updated simultaneously: S i global =S i−1 global + H(t i ),(2) S i local =S i−1 local + H(t i ).(3) To maintain the sliding window property, when the num- ber of generated tokensiexceeds the window sizeW, we subtract the entropy value that exits the window fromS local : S i local =S i−1 local −H[i− W],if i > W.(4) ThisO(1)update strategy ensures that both local and global entropy sums can be computed efficiently, avoiding theO(n) complexity of repeatedly summing over the entire history 4 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Let 퐀 be the least prime number for which there exists a positive integer 퐀 such that 퐀 4 +1 divisible by 퐀 2 . Find the least positive integer 퐀 such that 퐀 4 +1 is divisible by 퐀 2 .<think> Questioning Therefore, the solution is n=8 +17*6=8 +102=110. So, n=110 is a solution modulo 289. Let's verify: Compute 110^4 +1 mod289. But computing 110^4 is a bit tedious. Thinking Wait, 110 is quite large. Maybe there's a smaller 퐀. Wait, but earlier, we saw that in modulo 17. Wait, no, let me check. Wait, earlier when I computed 퐀 4 퐀栀퐀 17, I saw that 8 4 ≡− 1 mod 17 but it can be 9. Thinking </think> Alright, so after a lot of thinking and computations, I've determined that the least prime 퐀 is 17, and the least positive integer m such that 퐀 4 +1 is divisible by 17 2 =289 is 110. I know that 퐀=8 is a solution modulo 17, and we lifted it to n=11 modulo 289. But perhaps there are other solutions modulo 289 that are smaller than 110. But regardless, 110 is the smallest positive solution because when I tried numbers less than 110, none worked. Therefore, the least prime p is 17, and the least positive integer m is 110. **Final Answer** The least positive integer m is 110. Answering ... ... 퐀퐀�= 퐀찀퐀 퐀찀퐀 <퐀퐀�= 퐀찀퐀 퐀찀퐀 >퐀 Boundary Triggered Boundary Triggered E a r l y E x i t ... Entropy Sequence ℋ Remove Add Update 퐀 퐀 퐀 ... Entropy Sequence ℋ Token 퐀 퐀 Update 퐀 퐀 퐀 퐀찀퐀= 퐀 퐀 퐀 퐀 퐀찀퐀= 퐀 퐀 퐀 퐀 ... Unproductive WanderingStable ReasoningSelf-Rectified Answer Complex Question Input Real-time Trajectory Entropy Tracking Token 퐀 퐀 Reasoning Path Devication Index 퐀퐀�= 퐀찀퐀 퐀퐀 Figure 4. Overview of RPDI-E. RPDI-E performs continuous entropy scanning during CoT generation. For each new token, it measures local uncertainty via the Local Reasoning Density (LRD), defined as the average token entropy in a sliding window, and compares it to the global reasoning stability reflected by the Global Reasoning Baseline (GRB). or window. The stored entropy sequenceHis only used for this subtraction operation, not for recomputing sums from scratch. 4.2. Reasoning Path Deviation Index We introduce the Reasoning Path Deviation Index (RPDI) to transform the entropy sequence into a stable, interpretable indicator signal, enabling early-exit decisions that adapt flex- ibly to varying model capabilities and task difficulties. RPDI is computed as the ratio of the Local Transition Frequency (LTF) to the Global Transition Frequency (GTF). Local Transition Frequency The Local Transition Fre- quency (LTF) is measured as the average token entropy within the sliding window, characterizing the frequency of transition tokens in the model’s recently generated content: LTF i = S i local W .(5) A significant increase in LTF typically indicates that the model has generated a large number of transition tokens within a short period. This frequent switching of reasoning paths is closely associated with overthinking. Global Transition Frequency However, a fixed LTF threshold lacks generalizability across different scenarios because the baseline frequency of transition tokens depends on a model’s entropy distribution and the task’s complexity. To solve this problem, we further introduce the Global Tran- sition Frequency (GTF) to provide an adaptive reference baseline. GTF is defined as the average entropy of all gener- ated tokens from the initiation of reasoning to the current point. It quantifies the overall frequency of transition token occurrences, providing an adaptive reference baseline for detecting relative abnormal increases in this frequency: GTF i = S i global i .(6) In thei-th reasoning step, the path deviation index stan- dardizes the measurement of the abnormal increase in local uncertainty by calculating the ratio of LTF i to GTF i : RPDI i = LTF i GTF i .(7) When the model advances steadily along the correct rea- soning path,LTF i andGTF i are roughly comparable, and RPDI i fluctuates around1. However, when the model falls into overthinking and frequently produces high-entropy con- tent locally,LTF i becomes significantly higher thanGTF i , causingRPDI i to increase sharply. Therefore,RPDI i , as a dimensionless metric, can reliably indicate whether the reasoning path has substantially deviated. 4.3. Dynamic Early-Exit Theoretically, during the LRLM reasoning process, when RPDI-E detects that the RPDI score of the current tokens exceeds the threshold, it will make an early stopping deci- sion, causing the LLM to switch from the thinking mode to the answering mode. To achieve this within a prescribed reasoning token budgetL max , RPDI-E inserts an explicit 5 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring mode termination markerT(e.g.,</think>) into the cur- rent trajectoryRto prompt the LRLM to conclude its rea- soning and generate the final answerA. Subsequently, the LRLM generates the final answerAbased onP ⊕Rwithin the remaining token budget (L max − i). This process can be formalized as: A = LLM([P ⊕ R⊕ T]),for RPDI i > λ,(8) where⊕denotes the concatenation operation,λis the early exit threshold, which is a pre-defined hyperparameter. In practice, the RPDI-E is hindered by a primary chal- lenge: computational redundancy arising from per-token RPDI evaluation. To address this issue, we incorporate a Boundary-Triggered RPDI Evaluation mechanism to main- tain semantic integrity while reducing overhead. Specifi- cally, the RPDI-E computes the RPDI and determines whether it exceeds the thresholdλif and only if the current tokent i belongs to a predefined set of boundary symbols B. This design is followed by previous work Yang et al. (2025b), and we employ a boundary setBidentical to theirs. These symbolic boundaries typically signify the completion of a functional semantic unit. 5. Experimental Setup Model Selection and Architectures To evaluate the effi- cacy and generalizability of RPDI-E across varying model scales and training paradigms, we conduct experiments on a diverse suite of eight open-source large reasoning lan- guage models. Our selection encompasses the DeepSeek- R1-Distill-Qwen series of distillation models, ranging from the lightweight 1.5B and 7B variants to the larger 14B and 32B models (Guo et al., 2025), as well as the DeepSeek-R1- Distill-Llama series featuring the 8B and 70B models. To further test our method on state-of-the-art long reasoning architectures, we incorporate the Qwen3 Thinking series, specifically the Qwen3-30B-A3B-Thinking-2507 and the massive Qwen3-235B-A22B-Thinking-2507 (Yang et al., 2025a). This broad spectrum of models ensures a compre- hensive evaluation of RPDI-E’s performance across both distillation LRLMs and those RL-based ones. Benchmarks and EvaluationOur evaluation benchmarks cover a wide range of mathematical and scientific rea- soning tasks, categorized by their complexity and do- main. For foundational and competitive mathematics we utilize GSM8K (Cobbe et al., 2021), AMC23 (MAA, 2023), and the MATH500 (Hendrycks et al., 2021) datasets, denoted as MATH EASY. To evaluate the models on elite-level problem-solving, we include the AIME2024, AIME2025 (MAA Committees, 2025), and Olympiad- Bench (He et al., 2024), denoted as MATH HARD. Fi- nally, we assess high-level scientific reasoning using GPQA- Diamond (Rein et al., 2024) (marked as SCIENTIFIC), a benchmark comprising graduate-level questions verified by subject-matter experts in physics, biology, and chemistry. This multi-level benchmark suite provides a rigorous test- ing ground for RPDI-E’s capabilities. For evaluation, we align with DEER (Yang et al., 2025b) and employ accuracy (Acc.) and generated token length (Len.) as metrics. BaselinesTo establish a clear performance gain, we com- pare RPDI-E against five representative baseline strate- gies. The first is Vanilla CoT, which represents standard au- toregressive generation. To evaluate early-exit performance across different paradigms, we include NoThinking (Ma et al., 2025) and ThinkLess (Li et al., 2025) as representa- tives of fixed token-budget methods. For comparison with dynamic early-exit frameworks, we chose DEER (Yang et al., 2025b) and Dynasor-CoT (Fu et al., 2025), both of which use answer probing and context switching to determine termination. Limited by computing resources and costs, we evaluate all baselines only on DeepSeek-R1- Distill-Qwen-7B/14B/32B and Qwen3-30B-A3B-Thinking- 2507. For the other four models, we compare only with the basic Vanilla-CoT and the most competitive DEER method. Detailed implementation specifics, including hyperparame- ters, computational environment, and further configuration details, are provided in Appendix B. 6. Experimental Results and Analysis 6.1. Main Results We conduct extensive experiments across multiple bench- marks, including MATH EASY, MATH HARD, and SCI- ENTIFIC, using eight models of various types and scales, including those trained with distillation and reinforcement learning. As shown in table 1, experimental results indicate that RPDI-E delivers the most significant performance improvement over vanilla CoT on all tested models, with an average accuracy gain of3.9%. This demonstrates the effec- tiveness and adaptability of our approach across different architectures and problem types. Furthermore, we observe that RPDI-E achieves larger gains on distillation models, with an average accuracy improvement of5.1%. We con- sider this is because distillation models are more prone to overthinking, as they often capture only the surface patterns of long CoT reasoning rather than deeply understanding the underlying logic (Dai et al., 2025; Wang et al., 2025a). Notably, while RPDI-E achieves the most significant per- formance gains, it yields a more modest reduction in token consumption than aggressive early-exit methods. We con- sider this is because RPDI-E only terminates reasoning when the LRLM is truly ”stuck,” rather than prematurely stopping when it is still steadily progressing along the cor- rect reasoning path and exhibiting spurious confidence. This also implies that, compared to other early-exit baselines, 6 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Table 1. Performance comparison. Subscripts in all Acc. columns denote the accuracy change relative to the Vanilla CoT. Limited by computing resources and costs, RPDI-E is only compared with Vanilla CoT and the most competitive DEER across all eight LRLMs. MATH EASYMATH HARDSCIENTIFICAVERAGE METHOD Acc.↑Len.↓Acc.↑Len.↓Acc.↑Len.↓Acc.↑Len.↓ DeepSeek-R1-Distill-Qwen-7B87.9380132.51039532.31031956.27558 + NoThinking77.6 −10.3 91225.2 −7.3 327731.3 −1.0 84148.5 −7.7 1915 + ThinkLess76.8 −11.1 75824.7 −7.8 373631.8 −0.5 117548.0 −8.2 2094 + Dynasor-CoT73.8 −14.1 167332.4 −0.1 336645.5 +13.2 187652.0 −4.2 2428 + DEER85.4 −2.5 273345.0 +12.5 900528.3 −4.0 943359.9 +3.7 6378 + RPDI-E88.0 +0.1 382547.9 +15.4 970024.8 −7.5 972761.8 +5.6 7186 DeepSeek-R1-Distill-Qwen-14B90.0354953.2946450.5696368.66572 + NoThinking80.5 −9.5 118731.1 −22.1 564144.4 −6.1 130954.2 −14.4 3113 + ThinkLess63.8 −26.2 139427.7 −25.5 593734.9 −15.6 174844.2 −24.4 3391 + Dynasor-CoT76.4 −13.6 153530.8 −22.4 298548.5 −2.0 168652.9 −15.7 2178 + DEER90.9 +0.9 266553.2915952.0 +1.5 657569.2 +0.6 6007 + RPDI-E93.5 +3.5 342659.2 +6.0 928256.1 +5.6 657573.4 +4.8 6386 DeepSeek-R1-Distill-Qwen-32B88.7375350.4968556.1738667.66814 + NoThinking82.1 −6.6 79740.3 −10.1 653151.0 −5.1 224959.7 −7.9 3462 + ThinkLess77.1 −11.6 48529.2 −21.2 279653.5 −2.6 436553.2 −14.4 2030 + Dynasor-CoT75.1 −13.6 139034.0 −16.4 239257.6 +1.5 165555.0 −12.6 1857 + DEER90.9 +2.2 275761.0 +10.6 863752.0 −4.1 713472.5 +4.9 5902 + RPDI-E93.5 +4.8 321061.0 +10.6 911964.7 +8.6 697275.5 +7.9 6280 Qwen3-30B-A3B-Thinking-250796.7517882.11562174.8739487.39970 + NoThinking92.2 −4.5 282061.7 −20.4 692371.2 −3.6 626776.2 −11.1 5071 + ThinkLess96.9 +0.2 440981.8 −0.3 1441874.8684187.2 −0.1 9046 + Dynasor-CoT74.6 −22.1 150428.6 −53.5 252559.1 −15.7 173552.7 −34.6 1975 + DEER97.2 +0.5 447780.5 −1.6 1528574.8716786.8 −0.5 9493 + RPDI-E97.4 +0.7 503984.6 +2.5 1492777.8 +3.0 739389.1 +1.8 9613 DeepSeek-R1-Distill-Qwen-1.5B65.7561525.7126466.11338640.09738 + DEER64.3 −1.4 320224.7 −1.0 101554.6 −1.5 1268538.8 −1.2 7536 + RPDI-E69.4 +3.7 517729.2 +3.5 113948.1 +2.0 1282343.4 +3.4 8934 DeepSeek-R1-Distill-Llama-8B70.8503632.51087621.2960447.38192 + DEER73.6 +2.8 338333.1 +0.6 1057534.3 +13.1 951550.6 +3.3 7341 + RPDI-E82.8 +12.0 427132.8 +0.3 1090525.3 +4.1 976953.2 +5.9 7900 DeepSeek-R1-Distill-Llama-70B89.0363951.4987060.1553868.86581 + DEER91.7 +2.7 220046.4 −5.0 852862.1 +2.0 565968.0 −0.8 5406 + RPDI-E89.4 +0.4 387655.8 +4.4 938664.7 +4.6 594071.5 +2.7 6532 Qwen3-235B-Thinking97.7580579.81718580.8889387.611123 + DEER97.7459182.5 +2.7 1633282.8 +2.0 900589.1 +1.5 10253 + RPDI-E97.8 +0.1 586984.8 +5.0 1664280.3 −0.5 891089.7 +2.1 10921 RPDI-E preserves the model’s potential to self-correct its inference trajectory. Overview, the above results validate that RPDI-E effec- tively mitigates overthinking by monitoring internal reason- ing trajectory signals to detect reasoning path deviations. 6.2. Analysis of Early-Exit Triggering Impact To comprehensively analyze the impact of early-exit trig- gering of RPDI-E on the reasoning process, we con- duct a unified evaluation across four representative models, DeepSeek-R1-Distill-Qwen-7B/14B/32B and Qwen3-30B- A3B-Thinking-2507, with experimental configurations con- sistent with the main experiments. We report the average early-exit trigger rates across tasks and the average perfor- mance change for samples where early-exit is triggered, as depicted in Table 5. The results indicate a strong positive correlation between the early-exit trigger rate of RPDI-E and task difficulty. Intu- itively, models generally handle simpler tasks more easily, while on harder tasks they are more prone to reasoning path deviation due to error accumulation. This finding demon- strates that RPDI-E can adaptively respond to reasoning tasks of varying difficulty. Critically, across all samples where RPDI-E triggers early-exit, model accuracy im- proves significantly. This confirms that the truncated subse- quent reasoning content is unproductive or redundant rea- soning, and truncation effectively suppresses its generation, 7 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring gsm8kmath500amc gpqa aime24olympiadaime25 0 10 20 30 40 50 60 70 Trigger Rate (%) Trigger RateBeforeAfter 0 10 20 30 40 50 60 70 Accuracy Rel. (%) 2.0% 6.8% 13.1% 25.6% 34.2% 34.7% 45.0% 8.6% 22.8% 51.2% 36.2% 20.4% 16.4% 25.2% Figure 5. Triggering Rates and Corrective Performance. Table 2. Effectiveness Ablation of the RPDI components. METHOD MATHMATH SCIENTIFICAVERAGE EASYHARD Vanilla CoT91.652.952.067.6 RPDI-E93.561.064.775.5 w/o GTF93.557.764.774.0 w/o LTF90.256.462.171.7 w/o BTM93.653.567.772.7 thereby serving a corrective function. 6.3. Ablation In this section, we conduct experiments to verify the effec- tiveness of the components of RPDI and its sensitivity to hyperparameters. We employ DeepSeek-R1-Distill-Qwen- 32B as the primary model with experimental settings con- sistent with the main experiments. Ablation on Effectiveness of the RPDI components We separately isolate the Local Transition Frequency (LTF), Global Transition Frequency (GTF) and Boundary- Triggered mechanism (BTM) in RPDI to evaluate their inde- pendent contributions. The results are summarized in Table 2. Firstly, we remove GTF, which fixesGTF i ≡ 1. We find that it maintains an accuracy of 93.5% on the MATH EASY task, but its accuracy dropped by 3.3% on the MATH HARD task. This indicates that relying only on LTF lacks cross-task adaptability. While still effective for simple prob- lems, it cannot be properly calibrated for complex problems because the inherent frequency of transition tokens varies significantly with problem difficulty. Secondly, we remove LTF by setting the sliding window size toW = 1. This setup leads to a performance decline across all categories, validating the importance of transition token frequency in detecting reasoning path deviation. Simply tracking the en- tropy change of a single token relative to the normalization baseline is insufficient for accurately detecting reasoning path deviation. Finally, we remove the BTM and evalu- 12825651210242048 Window Size 60 66 72 78 Acc (%) 71.7 71.4 73.1 71.8 69.9 65.5 1.52.02.5 Threshold 60 66 72 78 Acc (%) 70.7 73.7 69.3 65.5 81921638432768 Token Budget 60 66 72 78 Acc (%) 65.8 61.1 74.1 65.5 75.0 67.7 RPDIVanilla CoT Figure 6. Hyperparameter Ablation of RPDI-E. ate RPDI at every token generation step. This results in an average accuracy drop of 2.8% across all tasks, with a particularly noticeable decrease on the MATH HARD task, underscoring the importance of preserving the integrity of reasoning steps. Ablation on Hyperparameter Settings We conduct ex- periments to investigate the sensitivity of RPDI-E to different hyperparameter settings, including the window sizeW, the RPDI thresholdλ, and the token budget. Per- formance is systematically evaluated against the vanilla CoT baseline across various configurations. As shown in Figure 6, RPDI-E consistently outperforms the vanilla CoT baseline under all tested hyperparameter settings, con- firming its robustness. In particularly, optimal accuracy is achieved with a window sizeW = 512, a thresholdλ = 2.0, and a sufficiently large token budget, indicating stable per- formance within a reasonable parameter range. We further analyze a plausible explanation for parameter influence. The window sizeWbalances sensitivity to local noise against responsiveness to reasoning path deviations: a smaller win- dow tends to amplify local randomness, while a huge one may delay the detection of trajectory shifts. The thresholdλ regulates early-exit; a lower value could lead to premature truncation of the reasoning process, whereas a higher one might allow unproductive overthinking steps to persist. 7. Conclusion To mitigate the degradation of reasoning performance caused by overthinking in LRLMs during long CoT rea- soning, we propose RPDI-E. This method dynamically monitors internal signals of the reasoning process and adap- tively triggers early-exit upon detecting reasoning path devi- ation. RPDI-E is based on the insight that overthinking is frequently accompanied by the frequent occurrence of high-entropy transition tokens. By constructing the Reason- ing Path Deviation Index (RPDI) to quantify the anomalous spikes of local uncertainty relative to the global baseline, it effectively resolves the issue of models falling into un- productive wandering or fragmented reasoning chains. Ex- tensive experiments demonstrate that compared to existing early-exit methods, RPDI-E delivers the most significant performance improvement in accuracy. It exhibits robust 8 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring effectiveness across LRLMs of various types and scales and across tasks of varying difficulty. These results validate the effectiveness of RPDI-E in mitigating overthinking, improving accuracy without external proxy models or prob- ing for answers, thereby providing a new perspective for optimizing long CoT reasoning. Impact Statement This paper presents work whose goal is to mitigate the performance degradation and computational redundancy caused by overthinking in LRLMs, thereby facilitating en- hanced long CoT reasoning. There are many potential soci- etal consequences of our work, none which we feel must be specifically highlighted here. References Akg ̈ ul, ̈ O. F., Kalaycı, Y. H., Kannan, R., Neiswanger, W., and Prasanna, V.Lynx: Learning dynamic ex- its for confidence-controlled reasoning. arXiv preprint arXiv:2512.05325, 2025. Chen, Q., Qin, L., Wang, J., Zhou, J., and Che, W. Unlock- ing the capabilities of thought: A reasoning boundary framework to quantify and optimize chain-of-thought. Advances in Neural Information Processing Systems, 37: 54872–54904, 2024a. Chen, X., Xu, J., Liang, T., He, Z., Pang, J., Yu, D., Song, L., Liu, Q., Zhou, M., Zhang, Z., et al. Do not think that much for 2+ 3=? on the overthinking of o1-like llms. arXiv preprint arXiv:2412.21187, 2024b. Chuang, Y.-N., Sarma, P. K., Gopalan, P., Boccio, J., Bolouki, S., Hu, X., and Zhou, H. Learning to route llms with confidence tokens. arXiv preprint arXiv:2410.13284, 2024. Cobbe, K., Kosaraju, V., Bavarian, M., Chen, M., Jun, H., Kaiser, L., Plappert, M., Tworek, J., Hilton, J., Nakano, R., et al. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168, 2021. Dai, C., Li, K., Zhou, W., and Hu, S. Capture the key in reasoning to enhance cot distillation generalization. In Proceedings of the 63rd Annual Meeting of the Associ- ation for Computational Linguistics (Volume 1: Long Papers), p. 441–465, 2025. Ding, Y., Jiang, W., Liu, S., Jing, Y., Guo, J., Wang, Y., Zhang, J., Wang, Z., Liu, Z., Du, B., et al. Dynamic parallel tree search for efficient llm reasoning. arXiv preprint arXiv:2502.16235, 2025. Fang, G., Ma, X., and Wang, X. Thinkless: Llm learns when to think. arXiv preprint arXiv:2505.13379, 2025. Fatemi, M., Rafiee, B., Tang, M., and Talamadupula, K. Concise reasoning via reinforcement learning. arXiv preprint arXiv:2504.05185, 2025. Fu, Y., Chen, J., Zhuang, Y., Fu, Z., Stoica, I., and Zhang, H. Reasoning without self-doubt: More efficient chain-of- thought through certainty probing. In ICLR 2025 Work- shop on Foundation Models in the Wild, 2025. Gan, Z., Liao, Y., and Liu, Y. Rethinking external slow- thinking: From snowball errors to probability of correct reasoning. arXiv preprint arXiv:2501.15602, 2025. Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., Xu, R., Zhu, Q., Ma, S., Wang, P., Bi, X., et al. Deepseek-r1: In- centivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025. Han, T., Wang, Z., Fang, C., Zhao, S., Ma, S., and Chen, Z. Token-budget-aware llm reasoning. arXiv preprint arXiv:2412.18547, 2024. He, C., Luo, R., Bai, Y., Hu, S., Thai, Z. L., Shen, J., Hu, J., Han, X., Huang, Y., Zhang, Y., et al. Olympiadbench: A challenging benchmark for promoting agi with olympiad- level bilingual multimodal scientific problems. arXiv preprint arXiv:2402.14008, 2024. Hendrycks, D., Burns, C., Kadavath, S., Arora, A., Basart, S., Tang, E., Song, D., and Steinhardt, J. Measuring math- ematical problem solving with the math dataset. arXiv preprint arXiv:2103.03874, 2021. Jiang, G., Quan, G., Ding, Z., Luo, Z., Wang, D., and Hu, Z. Flashthink: An early exit method for efficient reasoning. arXiv preprint arXiv:2505.13949, 2025a. Jiang, L., Wu, X., Huang, S., Dong, Q., Chi, Z., Dong, L., Zhang, X., Lv, T., Cui, L., and Wei, F. Think only when you need with large hybrid-reasoning models. arXiv preprint arXiv:2505.14631, 2025b. Kang, Y., Sun, X., Chen, L., and Zou, W. C3ot: Generating shorter chain-of-thought without compromising effective- ness. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, p. 24312–24320, 2025. Lee, A., Che, E., and Peng, T. How well do llms compress their own chain-of-thought? a token complexity approach. arXiv preprint arXiv:2503.01141, 2025. Li, G., Gao, Y., Li, Y., and Wu, Y. Thinkless: A training- free inference-efficient method for reducing reasoning redundancy. arXiv preprint arXiv:2505.15684, 2025. Liu, T., Guo, Q., Hu, X., Jiayang, C., Zhang, Y., Qiu, X., and Zhang, Z. Can language models learn to skip steps? Advances in Neural Information Processing Systems, 37: 45359–45385, 2024. 9 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Lou, C., Sun, Z., Liang, X., Qu, M., Shen, W., Wang, W., Li, Y., Yang, Q., and Wu, S. Adacot: Pareto-optimal adaptive chain-of-thought triggering via reinforcement learning. arXiv preprint arXiv:2505.11896, 2025. Ma, W., He, J., Snell, C., Griggs, T., Min, S., and Zaharia, M. Reasoning models can be effective without thinking. arXiv preprint arXiv:2504.09858, 2025. MAA.Amc 2023 problems,2023.URL https://artofproblemsolving.com/wiki/ index.php/2023_AMC_12A_Problems.Ac- cessed: 2025-05-11. Marjanovi ́ c, S. V., Patel, A., Adlakha, V., Aghajohari, M., BehnamGhader, P., Bhatia, M., Khandelwal, A., Kraft, A., Krojer, B., L ` u, X. H., et al. Deepseek-r1 thoughtol- ogy: Let’s think about llm reasoning. arXiv preprint arXiv:2504.07128, 2025. MAA Committees.Aime problems and solutions. https://artofproblemsolving.com/wiki/ index.php/AIME_Problems_and_Solutions , 2025. Muennighoff, N., Yang, Z., Shi, W., Li, X. L., Fei-Fei, L., Hajishirzi, H., Zettlemoyer, L., Liang, P., Cand ` es, E., and Hashimoto, T. s1: Simple test-time scaling. arXiv preprint arXiv:2501.19393, 2025. Qiao, Z., Deng, Y., Zeng, J., Wang, D., Wei, L., Meng, F., Zhou, J., Ren, J., and Zhang, Y. Concise: Confidence- guided compression in step-by-step efficient reasoning. arXiv preprint arXiv:2505.04881, 2025. Rein, D., Hou, B. L., Stickland, A. C., Petty, J., Pang, R. Y., Dirani, J., Michael, J., and Bowman, S. R. Gpqa: A graduate-level google-proof q&a benchmark. In First Conference on Language Modeling, 2024. Renze, M. and Guven, E. The benefits of a concise chain of thought on problem-solving in large language models. In 2024 2nd International Conference on Foundation and Large Language Models (FLLM), p. 476–483. IEEE, 2024. Shen, Y., Zhang, J., Huang, J., Shi, S., Zhang, W., Yan, J., Wang, N., Wang, K., Liu, Z., and Lian, S. Dast: Difficulty- adaptive slow-thinking for large reasoning models. arXiv preprint arXiv:2503.04472, 2025. Su, J., Healey, J., Nakov, P., and Cardie, C. Between un- derthinking and overthinking: An empirical study of rea- soning length and correctness in llms. arXiv preprint arXiv:2505.00127, 2025. Sun, H., Haider, M., Zhang, R., Yang, H., Qiu, J., Yin, M., Wang, M., Bartlett, P., and Zanette, A. Fast best-of-n decoding via speculative rejection. Advances in Neural Information Processing Systems, 37:32630–32652, 2024. Team, Q. Qwq-32b: Embracing the power of reinforcement learning, 2025. Wang, C., Feng, Y., Chen, D., Chu, Z., Krishna, R., and Zhou, T. Wait, we don’t need to” wait”! removing think- ing tokens improves reasoning efficiency. arXiv preprint arXiv:2506.08343, 2025a. Wang, S., Yu, L., Gao, C., Zheng, C., Liu, S., Lu, R., Dang, K., Chen, X., Yang, J., Zhang, Z., et al. Beyond the 80/20 rule: High-entropy minority tokens drive effective reinforcement learning for llm reasoning. arXiv preprint arXiv:2506.01939, 2025b. Wang, Y., Zhang, P., Huang, S., Yang, B., Zhang, Z., Huang, F., and Wang, R. Sampling-efficient test-time scaling: Self-estimating the best-of-n sampling in early decoding. arXiv preprint arXiv:2503.01422, 2025c. Xu, S., Xie, W., Zhao, L., and He, P.Chain of draft: Thinking faster by writing less. arXiv preprint arXiv:2502.18600, 2025. Yan, Y., Shen, Y., Liu, Y., Jiang, J., Zhang, M., Shao, J., and Zhuang, Y. Inftythink: Breaking the length limits of long-context reasoning in large language models. arXiv preprint arXiv:2503.06692, 2025. Yang, A., Li, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Gao, C., Huang, C., Lv, C., et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388, 2025a. Yang, C., Si, Q., Duan, Y., Zhu, Z., Zhu, C., Li, Q., Lin, Z., Cao, L., and Wang, W. Dynamic early exit in reasoning models. arXiv preprint arXiv:2504.15895, 2025b. Yang, R., Bai, H., Liu, S., Yu, G., Fan, R., Dang, Y., Zhang, J., Liu, K., Zhu, J., and Chen, P. Specexit: Accelerating large reasoning model via speculative exit. arXiv preprint arXiv:2509.24248, 2025c. Yeo, E., Tong, Y., Niu, M., Neubig, G., and Yue, X. Demys- tifying long chain-of-thought reasoning in llms. arXiv preprint arXiv:2502.03373, 2025. Yong, X., Zhou, X., Zhang, Y., Li, J., Zheng, Y., and Wu, X. Think or not? exploring thinking efficiency in large reasoning models via an information-theoretic lens. arXiv preprint arXiv:2505.18237, 2025. Zhang, A., Chen, Y., Pan, J., Zhao, C., Panda, A., Li, J., and He, H. Reasoning models know when they’re right: Probing hidden states for self-verification. arXiv preprint arXiv:2504.05419, 2025a. 10 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Zhang, J., Zhu, Y., Sun, M., Luo, Y., Qiao, S., Du, L., Zheng, D., Chen, H., and Zhang, N. Lightthinker: Thinking step- by-step compression. arXiv preprint arXiv:2502.15589, 2025b. 11 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Algorithm 1 Our Method Require: Model M , prompt P , token budget L max , local content size W , threshold λ, boundary setB Ensure: Final answer A 1: /* Initialize trajectory and entropy buffers */ 2: R←∅,H← [ ],S global ← 0.0,S local ← 0.0 3: i← 0, early exit← False 4: /* Introspective loop with real-time scanning */ 5: while not early exit do 6: i← i + 1 7:Sample t i ∼ M(P ⊕ R), compute entropy H(t i ) 8: R← R⊕ t i ,H.append(H(t i )) 9:/* Incremental entropy tracking */ 10: S global ← S global + H(t i ),S local ← S local + H(t i ) 11:/* Local context update */ 12:if i > W then 13: S local ← S local −H[i− W] 14:end if 15:/* Early exit via RPDI detection */ 16:if i≥ W and t i ∈B then 17:GTF← S global /i, LTF← S local /W 18:RPDI← LTF/GTF 19:early exit← RPDI > λ 20:end if 21: end while 22: /* Transition to answer synthesis phase */ 23: R← R⊕ </think> 24: Sample A∼ M(P ⊕ R) within budget L max − i 25: Return A A. Algorithm Algorithm 1 presents the complete execution flow of our method in pseudocode. Through the collaborative work of the three components described above, the system can monitor the internal state of the reasoning trajectory in real-time, adaptively trigger exit upon detecting path deviation, and ultimately generate high-quality answers, thereby effectively mitigating the dual negative impact of overthinking. B. Implementation Details All experiments are implemented using the vLLM framework to ensure efficient inference and memory management. For RPDI-E, we set the entropy scanning window sizeWto 512 tokens and the RPDI threshold to 2.0. For Dynasor-CoT, we set the number of consecutive consistent results to 3 and the probing interval to 512 tokens. Regarding context limits, we use a standard maximum length of 16,384 tokens for most models, while extending it to 32,768 tokens for the Qwen3-Thinking series to accommodate their extended reasoning chains. The computational experiments are carried out on a cluster of 8×H20 GPUs. For all tasks, we employ greedy decoding to ensure deterministic results and use accuracy and the number of tokens generated as the primary evaluation metrics. C. Comparison of Early-Exit Methods As shown in Table 3, By comparing various early exit strategies across six distinct dimensions, it becomes evident that our approach constitutes an online, dynamic framework. Notably, it operates independently of answer probing or proxy models, thereby securing simultaneous gains in both predictive performance and computational efficiency. D. Case Study In Figure 7, we present result a example on the AIME2024 dataset to intuitively demonstrate the effectiveness of RPDI-E. Due to space constraints, where the full presentation of a sample typically spans several pages, we have omitted some intermediate steps to highlight the key information. Prior to triggering the early-exit, RPDI-E follows the same reasoning trajectory as vanilla CoT, as shown in the blue box. At this stage, the model initially achieves the correct result, but 12 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Table 3. Feature-level comparison between RPDI and existing early-exit frameworks. We evaluate methods across six critical dimensions: (1) Probing-free: avoids intermediate answer generation to maintain a continuous reasoning flow; (2) Proxy-Model-free: operates without auxiliary verifiers or additional training; (3) Dynamic Method: adaptively adjusts the reasoning length based on problem complexity; (4) Efficiency Gain: provides measurable reduction in latency compared to vanilla CoT; (5) Performance Gain: achieves accuracy improvements by mitigating overthinking while safeguarding against over-truncation; (6) Real-time: functions during the generation process rather than via offline post-processing. MethodProbing-freeProxy-Model-freeDynamic MethodEfficiency GainPerformance GainReal-time RPDI (Ours)✓ Answer-Probing Based Deer (Yang et al., 2025b)✗✓ Adaptive Think (Yong et al., 2025)✗✓✗ Dynasor-CoT (Fu et al., 2025)✗✓✗✓ Proxy-Model Based SpecExit (Yang et al., 2025c)✓✗✓✗✓ Flashthink (Jiang et al., 2025a)✓✗✓✗✓ Zhang et al. (Zhang et al., 2025a)✓✗✓✗✓ LUNX (Akg ̈ ul et al., 2025)✗✓ Fixed LenghBased Token Budget (Muennighoff et al., 2025)✓✗✓✗✓ ThinkLess (Li et al., 2025)✓✗✓✗✓ NoThinking (Ma et al., 2025)✓✗✓✗✓ subsequently generates a calculation error that triggers a logical contradiction and leads to reasoning path deviation. This state is marked by the frequent occurrence of high-entropy transition tokens (e.g., “Wait”, “But”), indicating that the model is producing fragmented reasoning chains and falling into unproductive wandering. The green box and the pink box illustrate two distinct subsequent results: while vanilla CoT remains trapped in a redundant verification loop, our method detects the reasoning path deviation, allowing the redundant inference to be effectively suppressed. As shown in the pink box, which displays the results after truncation, the model achieves self-rectification and ultimately generates the correct final answer. More examples are provided in Figures 8, 9, and 10; notably, in the case of Figure 10, although the model fails to compute the correct result before triggering early-exit , it has already obtained sufficient intermediate reasoning steps, and RPDI-E prevents further confusion caused by error accumulation. 13 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Okay, so I have this problem here: I need to find the least prime \( p \) such that there exists a positive integer \( n \) where \( n^4 + 1 \) is divisible by \( p^2 \). Hmm, that sounds a bit tricky, but let me try to break it down step by step.......<omitted> Therefore, the solution is n=8 +17*6=8 +102=110. So, n=110 is a solution modulo 289. Let's verify: Compute 110^4 +1 mod289. But computing 110^4 is a bit tedious. First, compute 110 mod289 is 110. Compute 110^2: 110*110=12100.......<omitted> Compute251^2=63001. 63001 -289*217=63001 - 63013=-12≡277 mod289. So,110^4≡277 mod289.......<omitted> Wait, 110 is quite large. Maybe there's a smaller \( m \) that satisfies the condition. Let me see. We know that \( n =8 \) is a solution modulo17, and we lifted it to \( n=110 \) modulo289. But perhaps there's another solution modulo289 that is smaller than110. In Hensel's lemma, we found that the solution is unique modulo289, so there's only one solution in each congruence class modulo17. Since 8 is the solution modulo17, the lift is unique, so 110 is the only solution in the congruence class of8 modulo17. But maybe there are other solutions in different congruence classes. Wait, but earlier, we saw that in modulo17, only \( n=8 \) and \( n=9 \) (since 8^4≡-1 and 9^4≡-1 as well? Wait, no, let me check. Wait, earlier when I computed \( n^4 17 \), I saw that 8^4≡-1 mod17, but what about 9^4? Wait, 9 is congruent to -8 mod17, so 9^4=(- 8)^4=8^4≡-1 mod17.......<omitted> Wait, maybe I made a mistake in the lifting process. Let me double-check. ......<omitted> Wait, let's recompute the lift for n=9. We have f(n)=n^4 +1. As before, modulo289, this is ≡9^4 +4*9^3*(17k) +1 mod289. Wait, I think I forgot to add the +1 in the previous calculation. Wait, no, f(n)=n^4 +1, so when I expand (9 +17k)^4, I have to add 1 at the end. Wait, no, in the previous calculation, I had: (9 +17k)^4 ≡203 +153k mod289. Set equal to0: 204 +153k ≡0 mod289 =>153k≡-204 mod289. But -204 mod289 is85, since289 -204=85. So,153k≡85 mod289. Which is the same as before. So, k≡10 mod17, so k=10, n=9 +170=179. But when I compute f(179)=179^4 +1≡153 +1=154 mod289, which is not0. ......<omitted> Alright, so after a lot of thinking and computations, I've determined that the least prime \( p \) is 17, and the least positive integer \( m \) such that \( m^4 + 1 \) is divisible by \( 17^2 = 289 \) is 110. ......<omitted> But regardless, 110 is the smallest positive solution because when I tried numbers less than 110, none worked. So, I think 110 is indeed the minimal positive integer \( m \) such that \( m^4 +1 \) is divisible by 289. Therefore, the least prime \( p \) is 17, and the least positive integer \( m \) is 110. **Final Answer** The least positive integer \( m \) is 110. Vanilla CoTVanilla CoT RPDI-E Question: Let $p$ be the least prime number for which there exists a positive integer $n$ such that $n^4+1$ is divisible by $p^2$. Find the least positive integer $m$ such that $m^4+1$ is divisible by $p^2$. Answer:110 Figure 7. Comparison of generated content between RPDI-E and Vanilla on AIME24. 14 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Okay, so I have this problem here: I need to find the least prime \( p \) such that there exists a positive integer \( n \) where \( n^4 + 1 \) is divisible by \( p^2 \). Hmm, that sounds a bit tricky, but let me try to break it down step by step.......<omitted> So, compute N = (5^5 * 1^1 - 1)/(5^1 * 1^5 - 1) = (3125 * 1 - 1)/(5 * 1 - 1) = (3124)/(4) = 781, which is integer. So, (3, 2) is a solution. Wait, that's interesting. So, (3, 2) is a solution. Let me check......<omitted> So, for N to be integer, (r - 1) must be divisible by denominator.......<omitted> Alternatively, perhaps I can consider that when a and b are coprime, the expression is more likely to be integer. But in the case when q = 2, a and b are coprime, but only p = 3, q = 2 gives integer N. Wait, maybe I can think about the case when a = b + 2. Wait, a = p + q, b = p - q, so a = b + 2q. So, a and b are related by a = b + 2q. But since q is a prime, and p > q, b = p - q is at least 1. Hmm, not sure. Alternatively, perhaps I can think about the ratio r = (a/b)^a - b We have N = r + (r - 1)/(x - 1), where x = a^b b^a So, for N to be integer, (r - 1) must be divisible by (x - 1). So, (r - 1) mod (x - 1) = 0. But r = (a/b)^a - b, so: ( (a/b)^a - b - 1 ) mod (a^b b^a - 1) = 0 Hmm, this seems too abstract. Alternatively, perhaps I can consider that (a/b)^a - b ≡ 1 mod (a^b b^a - 1) But I don't know if that helps. Alternatively, perhaps I can think about the case when a = b + 1. Wait, a = p + q, b = p - q, so a = b + 2q.......<omitted> But x ≡ 1 mod x - 1, so: 1 * r ≡ 1 mod x - 1 So, r ≡ 1 mod x - 1 So, (a/b)^a - b ≡ 1 mod (a^b b^a - 1) Hmm, that's an interesting congruence. So, (a/b)^a - b ≡ 1 mod (a^b b^a - 1) But a and b are positive integers, with a > b. Wait, but a/b is a rational number, not necessarily integer. So, perhaps I can write this as: (a^a - b) ≡ (b^a - b) mod (a^b b^a - 1) But I'm not sure. Alternatively, perhaps I can think about the multiplicative order of (a/b) modulo (a^b b^a - 1). But since (a/b) is not an integer, this might not be straightforward. Alternatively, perhaps I can think about the case when a = b + 1. Wait, a = b + 1. Then, a = p + q = (p - q) + 1 => p + q = p - q + 1 => 2q = 1 => q = 0.5, which is not possible since q is prime. So, no solution here. Alternatively, perhaps I can think about the case when a = 2b. Wait, a = 2b.......<omitted> Alright, after a lot of trial and error with small primes and analyzing the structure of the expression, it seems that the only pair of primes (p, q) with p > q that satisfies the given condition is (3, 2). This is because when p = 3 and q = 2, the expression simplifies to an integer, and for all other tested prime pairs, the expression does not yield an integer. Therefore, the only solution is: **Final Answer** The only solution is (3, 2). Vanilla CoTVanilla CoT RPDI-E Question: Find all pairs $(p, q)$ of prime numbers with $p>q$ for which the number $$ (p+q)^p+q(p-q)^p-q-1(p+q)^p-q(p-q)^p+q-1 $$ is an integer. Answer:(3,2) Figure 8. Comparison of generated content between RPDI-E and Vanilla on OlympiadBench. 15 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Okay, so I have this problem: Find all positive integers \( n > 2 \) such that \[ n! _ p<q n \\ p, q primes (p+q) \] Hmm, let me try to understand what this means. I need to find all integers \( n > 2 \) where.......<omitted> Let me compute 302,400 divided by 5040. First, 5040 * 60 = 302,400. So, yes, 5040 divides 302,400 exactly 60 times. So, \( n = 7 \) works. Okay, so \( n = 7 \) is a solution. Let me check ......<omitted> Wait, but hold on, for primes like 3, even though 3 isn't directly a sum of two smaller primes (since 2 + 1 isn't prime), but 3 is present through other sums........<omitted> Wait, 110 is quite large. Maybe there's a smaller \( m \) that satisfies the condition. Let me see. We know that \( n =8 \) is a solution modulo17, and we lifted it to \( n=110 \) modulo289. But perhaps there's another solution modulo289 that is smaller than 110. In Hensel's lemma, we found that the solution is unique modulo289, so there's only one solution in each congruence class modulo17. Since 8 is the solution modulo17, the lift is unique, so 110 is the only solution in the congruence class of8 modulo17. But maybe there are other solutions in different congruence classes. Wait, but earlier, we saw that in modulo17, only \( n=8 \) and \( n=9 \) (since 8^4≡-1 and 9^4≡-1 as well? Wait, no, let me check. Wait, earlier when I computed \( n^4 17 \), I saw that 8^4≡-1 mod17, but what about 9^4? Wait, 9 is congruent to -8 mod17, so 9^4=(- 8)^4=8^4≡-1 mod17.......<omitted> Wait, but 13 is a prime, so it should be present as a factor in the product if any of the sums equal 13. But 2 + 11 = 13, so 13 is present as a factor in the product because 2 + 11 = 13, which is a prime. Wait, but 13 is a prime, so in the product, 13 is a factor because 2 + 11 = 13. So, 13 is present as a prime factor in the product. Similarly, 11 is present because 2 + 11 = 13, but 11 itself isn't a factor in 13. Wait, no, 11 is a prime, but in the product, 11 is only in the term 2 + 11 = 13, which is prime, so 11 isn't a factor in 13.However, 11 itself is not a factor in 13, so 11 isn't present in the product. Similarly, 2 + 13 = 15, which is 3 * 5, so 15 contributes 3 and 5, but not 13. Wait, no, 15 is 3 * 5, so 13 isn't a factor.......<omitted> Okay, so after going through this, I realize that for \( n = 7 \), the product includes all the necessary prime factors with sufficient exponents to cover \( 7! \). However, for \( n = 11 \), the product lacks the prime factor 11, which is required for \( 11! \). This suggests that only \( n = 7 \) satisfies the condition because for larger \( n \), the product will miss the largest prime \( p ≤ n \), making \( n! \) not divide the product. Therefore, the only solution is \( n = 7 \). **Final Answer** The only positive integer \( n > 2 \) that satisfies the condition is 7. Vanilla CoTVanilla CoT RPDI-E Question: Find all positive integers $n>2$ such that $$ n ! _ p<q n \\ p, q primes (p+q) $$ Answer: 7 Figure 9. Comparison of generated content between RPDI-E and Vanilla on OlympiadBench. 16 Mitigating Overthinking in Large Reasoning Language Models via Reasoning Path Deviation Monitoring Okay, so I have this problem where I need to find the base \( b \) such that when I multiply \( 253_b \) by \( 341_b \), I get a number \( 74XYZ_b \), where \( X, Y, Z \) are some digits in base \( b \). Hmm, that sounds a bit tricky, but let me try to break it down step by step. First, ......<omitted> So, the product is: \( 6b^4 + 23b^3 + 31b^2 + 17b + 3 \) Now, the product is supposed to equal \( 74XYZ_b \), which in decimal is: \( 7b^4 + 4b^3 + Xb^2 + Yb + Z \) So, setting them equal: \( 6b^4 + 23b^3 + 31b^2 + 17b + 3......<omitted> Let me try to estimate the value of \( b \). If I ignore the lower-degree terms for a moment, the equation is approximately \( -b^4 + 19b^3 = 0 \), which simplifies to \( b^3(-b + 19) = 0 \). So, \( b = 19 \) is a solution.......<omitted> Hmm, this is getting frustrating. Maybe I need to try a different approach. Wait, earlier, when I tried to compute the product in decimal for b=19, the result was 951,200, which was much larger than 74XYZ_19=939,683 + something. So, maybe b is larger than 19. Wait, but when I tried b=20, it didn't work. Maybe I need to go higher. But this manual checking is time-consuming. Maybe I can find another way. Wait, let's recall the original equation: ......<omitted> But earlier, when I tried b=20, it didn't work. Hmm, contradiction. Wait, but earlier, when I tried b=20, the equation didn't hold because of the carryover issue. But according to this, b must be greater than 19. So, perhaps I need to try b=20 again, but more carefully. Wait, let's go back to the initial equation......<omitted> Hmm, this is getting frustrating. So, maybe b is larger than 19. Wait, but when I tried b=20, it didn't work. Maybe I need to go higher. But this manual checking is time-consuming. But since A and B are positive, 32 - b >0 => b <32 Similarly, 18 - b >0 => b <18 Wait, but earlier, when I tried b=19, it didn't work, but according to this, b must be less than 18. Wait, but when I tried b=17, it didn't work either. But earlier, when I tried b=20, it didn't work. Hmm, contradiction. Wait, but earlier, when I tried b=20, the equation didn't hold because of the carryover issue. But according to this, b must be greater than 19. So, perhaps I need to try b=20 again, but more carefully.......<omitted> Alright, after a lot of trial and error, I realize that the base \( b \) must be 20. Let me verify this. First, convert \( 253_20 \) and \( 341_20 \) to decimal: \( 253_20 = 2 × 20^2 + 5 × 20 + 3 = 800 + 100 + 3 = 903 \) \( 341_20 = 3 × 20^2 + 4 × 20 + 1 = 1200 + 80 + 1 = 1281 \) Multiply them:......<omitted> So, X=11. But in base 20, X=11 is represented as 'B' (if using letters), but since the problem doesn't specify, it's acceptable as a digit. So, \( 74XYZ_20 = 74B173_20 \), which is valid. Therefore, the base \( b \) is 20. **Final Answer** The base \( b \) is 20. Vanilla CoTVanilla CoT RPDI-E Question:Compute the base $b$ for which $253_b · 341_b= 7 4 X Y Z_b$, for some base- $b$ digits $X, Y, Z$. Answer: 20 Figure 10. Comparison of generated content between RPDI-E and Vanilla on OlympiadBench. 17