| name | reasoning-path-confidence |
| title | A Theoretical Study on Bridging Internal Probability and Self-Consistency for LLM Reasoning |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2510.15444 |
| keywords | ["LLM reasoning","test-time scaling","self-consistency","perplexity","probabilistic sampling"] |
| description | Reduce LLM sampling costs by 50% while maintaining reasoning performance through Reasoning Path Confidence (RPC), which combines perplexity-guided pruning with self-consistency sampling. |
Technique: Reasoning Path Confidence — Efficient Test-Time Scaling
LLMs achieve strong performance on complex reasoning tasks through test-time sampling strategies like self-consistency, but this approach requires extensive sampling from the full probability distribution. However, sampling introduces high estimation error while perplexity-based filtering suffers from high modeling error. Most reasoning paths are ineffective noise.
RPC bridges these approaches by recognizing that self-consistency and perplexity capture complementary signals. Rather than choosing between them, the technique combines perplexity consistency to detect unreliable reasoning branches with reasoning pruning to eliminate low-probability paths before ensemble voting.
Core Concept
RPC operates on two key insights:
- Perplexity Consistency: Path perplexity correlates with reasoning quality—high perplexity indicates uncertain or incoherent reasoning steps
- Reasoning Pruning: Eliminating low-probability reasoning paths reduces noise without degrading the signal from high-quality paths
The combination achieves exponential convergence improvement (from linear to exponential) compared to self-consistency alone while reducing sampling costs by 50%.
Architecture Overview
- Probability Distribution Analysis: Track per-step token probabilities during chain-of-thought generation
- Perplexity Scoring: Compute Shannon entropy over next-token distributions to detect uncertainty spikes
- Path Filtering: Prune reasoning paths where cumulative perplexity exceeds a learned threshold
- Ensemble Voting: Apply standard self-consistency voting only on surviving high-quality paths
- Convergence Acceleration: Fewer but higher-quality samples accelerate accuracy improvement
Implementation Steps
The core algorithm computes perplexity per step and filters paths before ensemble aggregation.
import numpy as np
from collections import defaultdict
def reasoning_path_confidence(
reasoning_paths,
step_log_probs,
perplexity_threshold=2.5,
top_k_paths=None
):
"""
RPC filtering: prune low-confidence reasoning paths before ensemble voting.
Args:
reasoning_paths: list of reasoning strings (complete chains-of-thought)
step_log_probs: list of lists, log probabilities per step in each path
perplexity_threshold: entropy cutoff for path acceptance
top_k_paths: if set, keep only top-k paths by score
Returns:
filtered_paths: paths surviving confidence filtering
path_scores: confidence scores for each surviving path
"""
perplexity_scores = []
i, log_probs (step_log_probs):
step_entropies = [-lp lp log_probs]
path_perplexity = np.mean(step_entropies)
perplexity_scores.append(path_perplexity)
surviving_indices = [
i i, score (perplexity_scores)
score <= perplexity_threshold
]
filtered_paths = [reasoning_paths[i] i surviving_indices]
filtered_scores = [perplexity_scores[i] i surviving_indices]
top_k_paths (filtered_paths) > top_k_paths:
top_indices = np.argsort(filtered_scores)[:top_k_paths]
filtered_paths = [filtered_paths[i] i top_indices]
filtered_scores = [filtered_scores[i] i top_indices]
filtered_paths, filtered_scores
():
paths = []
log_probs_list = []
_ (num_samples):
path, step_lps = model.generate_with_logprobs(
prompt, max_steps=
)
paths.append(path)
log_probs_list.append(step_lps)
filtered_paths, scores = reasoning_path_confidence(
paths, log_probs_list, perplexity_threshold
)
answers = extract_answers(filtered_paths)
final_answer = majority_vote(answers)
final_answer, (filtered_paths), num_samples
