cs.LGAug 22, 2026

ChainPrune: Evaluating and Reducing Redundancy in Long Chain-of-Thought Reasoning

Authors: Weihang Pan, Zhengxu Yu, Yuxiang Zhang, Wenzhi Li, Zhongming Jin, Binbin Lin, Xiaofei He, Jieping Ye

Organizations: Zhejiang University · Alibaba Group

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

Chain-of-Thought (CoT) reasoning has significantly enhanced the multi-step problem-solving capabilities of large language models (LLMs) by introducing explicit intermediate reasoning. However, advanced Large Reasoning Models (LRMs) often exhibit overthinking behaviors, including excessively long reasoning steps, redundant steps, and high computational overhead. Existing token-length reward strategies aim to promote concise outputs, but often result in pseudo-conciseness, where token count is reduced, yet redundant reasoning persists, leading to longer and less structurally efficient chains. To address these limitations, we propose ChainPrune, a novel reasoning path semantic structural optimization method to efficiently and controllably synthesize self-generated high-quality training data. We initially consolidate self-generated reasoning paths into a tree-based structure, followed by a multi-criteria dominant path selection process for preference data construction that formulates shallow reasoning trajectories while preserving essential reasoning steps. To further enhance the quality of reasoning, we incorporate a DPO-based preference learning method combined with supervised loss, effectively mitigating false reward suppression. This innovative integration significantly enhances both the efficiency and effectiveness of our reasoning framework. Comprehensive experimental results demonstrate significant reductions in step length and computational overhead, while maintaining or even enhancing accuracy.

Figures & tables

Figure 1: Comparison between a Minimum Token Length Response and a Minimum Chain Length Response for the same addition problem.
Figure 2: Attention weight distribution following semantically equivalent steps, showing localized focus on the most recent tokens (x-axis: Token Position, y-axis: Attention Score). This supports our tree-merging approach: merging equivalent nodes preserves the conditional distribution of subsequent tokens, enabling both token and step reduction without loss of correctness.
Figure 3: The pipeline of ChainPrune, featuring three synergistic stages: (1) Reasoning Paths Merging with dynamic semantic node pruning, (2) Multi-criteria dominant path selection and Preference Data Construction, (3) Direct preference learning with NLL Loss.
MethodsAIME24AIME25AMC23LiveCodeBench
ACCTokensChainsACCTokensChainsACCTokensChainsACCTokensChains
DeepSeek-R1-Distilled-Qwen-7B
Base Model0.547973462530.422968922400.904754071890.31273961166
SFT0.543762961990.397955701920.921938241200.33443494143
Kimi-1.50.512561443060.383352922540.868842652370.1703195357
DAST0.53306337----------
Table 1: Performance comparison of ChainPrune against baseline methods across multiple reasoning tasks. Bold indicates the best result, underline indicates the second-best result. Token Length and Chain Length are averaged only over correct answers . In some cases, ChainPrune appears slightly worse than the best baseline on these metrics; this is because its higher accuracy means that more difficult problems are included in the averaging, which naturally increases the average token and chain length.
MethodsACCTokensAll TokensChainsAll ChainsFaulty ReasoningInvalid ReflectionRedundant Steps
Base Model0.924037094621111146102124132
SFT0.9080189127175277688698
Kimi-1.50.9040277740741241388492102
DAST0.92602802------
DAST (reproduce)0.9180326438399912392104107
ChainPrune0.9300217026436272434745
Table 2: Reasoning path evaluation using LLM-as-a-Judge on MATH500. All methods are initialized from DeepSeek-R1-Distilled-Qwen-7B. Tokens and Chains report the average token count and reasoning step count only over correct responses. All Tokens and All Chains report the averages computed over all responses, including incorrect ones. Bold values indicate the best result, and underlined values indicate the second-best result.
MethodsAIME24MATH500
ACCTokensACCTokens
Base Model0.547973460.92403709
Kimi-1.5 w/ DPO0.512561440.90402777
Kimi-1.5 w/ DPO + NLL Loss0.558360770.92802373
DAST w/ SimPO0.537569090.91803264
DAST w/ DPO + NLL Loss0.583361880.92802572
Table 3: Comparative analysis of different optimization methods under identical training datasets.
Figure 4: Relationship between difficulty and the token/chain length of the shortest correct response.
Figure 5: Sample efficiency analysis showing marginal token reduction after extensive sampling.
Appendix figures & tables8 assets

Supplementary material from the paper’s appendix.

Appendix

Figure 6: Distribution of min_distance across all questions. The metric quantifies the normalized discrepancy between the shortest-token and shortest-chain correct reasoning paths. Only 33.95% of the questions have min_distance equal to zero, indicating that the same path minimizes both token length and chain length.
Figure 7: Token length versus chain length for 64 sampled reasoning paths on a representative math question. Each point denotes a unique path. Blue nodes indicate wrong responses , visually distinguishing them from correct ones. No single path lies at the lower-left corner, suggesting that none optimally balances both expression-level and structural conciseness.
Figure 8: Example 1: A comparison between the chosen and rejected reasoning paths for a proportional reasoning problem. Although both paths share the same semantic steps—computing meat per hamburger and scaling to 24 hamburgers—the rejected path performs these steps earlier.
Figure 9: Example 2: A comparison of chosen and rejected reasoning paths for an exponential equation. Both paths apply identical mathematical transformations, including rewriting powers of 9, applying exponent rules, and solving a quadratic equation. However, the rejected path introduces semantically equivalent steps earlier in the trajectory.
Figure 10: The figure shows three gradient entanglement conditions in DPO/SimPO training: Condition 1 (synchronized decrease: log⁡πw↓,log⁡πl↓\log\pi_{w}\downarrow,\log\pi_{l}\downarrow ) causing forgetting, Condition 2 (synchronized increase: log⁡πw↑,log⁡πl↑\log\pi_{w}\uparrow,\log\pi_{l}\uparrow ) failing to suppress bad outputs, and Condition 3 (ideal divergence: log⁡πw↑,log⁡πl↓\log\pi_{w}\uparrow,\log\pi_{l}\downarrow ); SimPO reduces but doesn’t eliminate suboptimal Conditions 1-2 (85.6% combined).
MethodsAIME24AIME25AMC23MATH500
ACCTokensChainsACCTokensChainsACCTokensChainsACCTokensChains
Longest0.566765762400.416755552020.909440271370.9260242773
Middle0.583364712350.408354411940.914139581290.9200237667
Shortest0.583356882250.425053511890.912537711220.9300217062
Appendix
Table 4: Correlation between chosen sample length and optimized model’s output length
Figure 11: The overall pipeline of the LLM-as-a-Judge framework. The reasoning path is first segmented by GPT-4o acting as a chain splitter. Then, each reasoning step is independently evaluated by three expert models across three categories: faulty reasoning, invalid reflection, and redundant steps. Results are aggregated via majority voting or deferred to human reviewers in cases of high disagreement.
Figure 12: The structured prompt design for the LLM-as-a-Judge step-level classification task. The prompt includes the problem statement, the current reasoning step, and up to three preceding and three following steps as context. The model is instructed to classify the target step into one of four categories and output a JSON object including the classification tag and an explanation.
More in this topic

Efficient Language Model Reasoning

Efficient language model reasoning studies how to improve problem-solving accuracy while reducing inference, memory, latency, and training costs.

See all 370 papers

Explore similar work

CardsList
Jul 13, 2026

OS-Pruner: Pruning Chains-of-Thought of Reasoning Models via Optimal Stopping

Large Language Models (LLMs) have achieved remarkable success in complex reasoning tasks through Chain-of-Thought (CoT) prompting. However, these models often exhibit "computational overthinking," generating redundant reasoning steps that increase latency and cost without improving accuracy. Recent studies suggest that CoT trajectories can be significantly pruned, yet existing methods often rely on forcing a static thinking budget, heuristic filtering, sub-optimal early exit via classification, or expensive re-training. In this paper, we introduce OS-Pruner, a lightweight plug-in framework that formulates chain-of-thought pruning as an optimal stopping problem. Given a reasoning prefix, OS-Pruner learns whether further reasoning is worth its token cost by optimizing an explicit utility that trades off final-answer accuracy against generated length. Our novel formulation enables the model to dynamically assess the sufficient point of termination for a reasoning chain. OS-Pruner is designed to be lightweight during both training and inference, and to provide users with fine-grained control over the reasoning-effort vs. accuracy trade-off. On diverse reasoning benchmarks and base models, OS-Pruner achieves 20-60% reduction in generation length with minimal accuracy sacrifice.

Mohammed Ehab, Aymane El Gadarri, Vivek F. Farias +2

MIT · Columbia Business School

Efficient Language Model ReasoningSequential Decision MakingOptimal StoppingOverthinking in Language ModelsLarge Reasoning ModelsEfficient Language Model Inference+1
AskPDF
Apr 19, 2026

CRISP: Compressing Redundancy in Chain-of-Thought via Intrinsic Saliency Pruning

Long Chain-of-Thought (CoT) reasoning is pivotal for the success of recent reasoning models but suffers from high computational overhead and latency. While prior works attempt to compress CoT via external compressor, they often fail to align with the model's internal reasoning dynamics, resulting in the loss of critical logical steps. This paper presents Compressing Redundancy in Chain-of-Thought via Intrinsic Saliency Pruning (CRISP), a framework that compresses CoT by exploiting the model's intrinsic saliency. Our analysis reveals a distinct phenomenon: the reasoning termination token [object Object] acts as an information anchor, where its attention pattern effectively demarcates essential reasoning from redundancy. Based on this finding, we design a policy that utilizes these intrinsic attention signals to guide atomic compression operations. In contrast to coarse-grained pruning strategies, CRISP strategically distills the reasoning chain to maximize information density while preserving logical coherence. Empirical results across various backbone models and mathematical datasets demonstrate that CRISP achieves a 50-60% reduction in token count without compromising accuracy, effectively mitigating the efficiency bottleneck of long-context reasoning. We open-source our implementation to facilitate further research in efficient reasoning.

Yangsong Lan, Hongliang Dai, Piji Li

College of Artificial Intelligence, Nanjing University of Aeronautics and Astronautics, Nanjing, China · The Key Laboratory of Brain-Machine Intelligence Technology, Ministry of Education, Nanjing, China.

LLM PruningLLM CompressionLLM Inference AccelerationCoT Compression
AskPDF
May 10, 2026

RuPLaR : Efficient Latent Compression of LLM Reasoning Chains with Rule-Based Priors From Multi-Step to One-Step

The Chain-of-Thought (CoT) paradigm, while enhancing the interpretability of Large Language Models (LLMs), is constrained by the inefficiencies and expressive limits of natural language. Latent Chain-of-Thought (latent CoT) reasoning, which operates in a continuous latent space, offers a promising alternative but faces challenges from structural complexities in existing multi-step or multi-model paradigms, such as error propagation and coordination overhead. In this paper, we introduce One-Model One-Step, a novel compression framework for Latent Reasoning with Rule-Based Priors(RuPLaR) to address this challenge. Our method trains an LLM to autonomously generate latent reasoning tokens in a single training stage, guided by rule-based prior probability distributions, thereby eliminating cascaded processes and inter-model dependencies. To ensure reasoning quality, we design a joint training objective that enforces answer consistency via cross-entropy, aligns soft token distributions with rule-based priors via KL divergence (the Soft Thinking constraint), and adds a problem-thought semantic alignment constraint in the representation space. Extensive experiments show that our compression framework not only improves accuracy by 11.03% over existing latent CoT methods on GSM8k-Aug but also achieves this with minimal token usage, underscoring its effectiveness and extensibility. Code: https://github.com/xiaocen-luo/RuPLaR.

Xiaocheng Luo, Kang Wang, Zaifu Zhan +2

School of Computer Science and Technology, Soochow University, Suzhou, 215006, Jiangsu, PR China · Department of Electrical and Computer Engineering, University of Minnesota, Minneapolis, 55455, MN, USA

LLM CompressionCoT CompressionLLM ReasoningLatent CoT Reasoning
AskPDF