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

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

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

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.

Methods	AIME24			AIME25			AMC23			LiveCodeBench
Methods	ACC	Tokens	Chains	ACC	Tokens	Chains	ACC	Tokens	Chains	ACC	Tokens	Chains
DeepSeek-R1-Distilled-Qwen-7B
Base Model	0.5479	7346	253	0.4229	6892	240	0.9047	5407	189	0.3127	3961	166
SFT	0.5437	6296	199	0.3979	5570	192	0.9219	3824	120	0.3344	3494	143
Kimi-1.5	0.5125	6144	306	0.3833	5292	254	0.8688	4265	237	0.1703	1953	57
DAST	0.5330	6337	-	-	-	-	-	-	-	-	-	-

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.

Methods	ACC	Tokens	All Tokens	Chains	All Chains	Faulty Reasoning	Invalid Reflection	Redundant Steps
Base Model	0.9240	3709	4621	111	146	102	124	132
SFT	0.9080	1891	2717	52	77	68	86	98
Kimi-1.5	0.9040	2777	4074	124	138	84	92	102
DAST	0.9260	2802	-	-	-	-	-	-
DAST (reproduce)	0.9180	3264	3839	99	123	92	104	107
ChainPrune	0.9300	2170	2643	62	72	43	47	45

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.

Methods	AIME24		MATH500
Methods	ACC	Tokens	ACC	Tokens
Base Model	0.5479	7346	0.9240	3709
Kimi-1.5 w/ DPO	0.5125	6144	0.9040	2777
Kimi-1.5 w/ DPO + NLL Loss	0.5583	6077	0.9280	2373
DAST w/ SimPO	0.5375	6909	0.9180	3264
DAST w/ DPO + NLL Loss	0.5833	6188	0.9280	2572

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\pi_{w}\downarrow,\log\pi_{l}\downarrow$ ) causing forgetting, Condition 2 (synchronized increase: $\log\pi_{w}\uparrow,\log\pi_{l}\uparrow$ ) failing to suppress bad outputs, and Condition 3 (ideal divergence: $\log\pi_{w}\uparrow,\log\pi_{l}\downarrow$ ); SimPO reduces but doesn’t eliminate suboptimal Conditions 1-2 (85.6% combined).

Methods	AIME24			AIME25			AMC23			MATH500
Methods	ACC	Tokens	Chains	ACC	Tokens	Chains	ACC	Tokens	Chains	ACC	Tokens	Chains
Longest	0.5667	6576	240	0.4167	5555	202	0.9094	4027	137	0.9260	2427	73
Middle	0.5833	6471	235	0.4083	5441	194	0.9141	3958	129	0.9200	2376	67
Shortest	0.5833	5688	225	0.4250	5351	189	0.9125	3771	122	0.9300	2170	62

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.

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

OS-Pruner: Pruning Chains-of-Thought of Reasoning Models via Optimal Stopping
Jul 13, 2026Mohammed Ehab, Aymane El Gadarri, Vivek F. Farias +2Efficient Language Model Reasoning Sequential Decision Making
MIT · Columbia Business School
CRISP: Compressing Redundancy in Chain-of-Thought via Intrinsic Saliency Pruning
Apr 19, 2026Yangsong Lan, Hongliang Dai, Piji LiLLM Pruning LLM Compression
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.
RuPLaR : Efficient Latent Compression of LLM Reasoning Chains with Rule-Based Priors From Multi-Step to One-Step
May 10, 2026Xiaocheng Luo, Kang Wang, Zaifu Zhan +2LLM Compression CoT Compression
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

Jul 13, 2026J/K move · Enter open · S save

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

Mohammed Ehab, Aymane El Gadarri, Vivek F. Farias, Adam Jozefiak+1

MIT · Columbia Business School

Efficient Language Model Reasoning Sequential Decision Making Optimal Stopping Overthinking in Language Models Large Reasoning Models Efficient Language Model Inference+1

Open paper AskPDF arXiv

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.

Abstract

Efficient Language Model Reasoning

Explore similar work

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

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

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