reasoning-path-confidence

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