sequential-edge-inverse-entropy-voting

name	sequential-edge-inverse-entropy-voting
title	Sequential Edge: Inverse-Entropy Voting Beats Parallel Self-Consistency
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2511.02309
keywords	["Test-Time Scaling","Inference Optimization","Reasoning Chains","Entropy","Voting"]
description	Replace parallel self-consistency with sequential reasoning where chains iteratively build on previous attempts, weighted by inverse entropy to prioritize confident solutions, achieving 46.7 pp accuracy gains over parallel approaches.

Title: Build Reasoning Chains Sequentially for Superior Accuracy

The dominant paradigm for improving language model reasoning is parallel self-consistency: run N independent reasoning chains, then vote. Sequential Edge shows this is suboptimal. By running chains sequentially where each explicitly builds on previous attempts, models achieve 95.6% superiority rates over parallel approaches. Further, weighting solutions by inverse entropy (favoring low-entropy/confident chains) outperforms majority voting universally.

This is a pure inference-time technique requiring no model retraining.

Core Concept

Sequential Reasoning With Entropy-Weighted Aggregation:

• Sequential Scaling: Each chain reads previous attempts and tries to improve them
• Iterative Refinement: Three mechanisms available: error correction, context accumulation, verification
• Inverse-Entropy Voting: Weight each answer by how certain the model was (low entropy = high confidence)
• No Training Required: Works with base models or fine-tuned variants
• Universal Superiority: Better than parallel approaches across all tested models and benchmarks

Architecture Overview

• Sequential Chain Generation: Causal generation where chain k reads output of chain k-1
• Confidence Estimation: Compute Shannon entropy from token-level probability distributions
• Entropy-Weighted Aggregation: Answers weighted inversely to their generation entropy
• Stopping Criterion: Continue sequencing until convergence or budget exhausted
• Hybrid Architecture: Can mix sequential and parallel chains for different problem types

Implementation Steps

1. Implement Sequential Chain Generation

Generate reasoning chains that explicitly reference previous attempts.

class SequentialReasoningGenerator:
    def __init__(self, model, tokenizer, max_chains=6):
        self.model = model
        self.tokenizer = tokenizer
        self.max_chains = max_chains

     ():
        
        chains = []
        entropies = []

        
        prompt_1 = 
        chain_1, entropy_1 = .generate_chain_with_entropy(prompt_1)
        chains.append(chain_1)
        entropies.append(entropy_1)

        
         i  (, num_chains):
            
            previous_solution = chains[-]

            prompt_n = 

            chain_n, entropy_n = .generate_chain_with_entropy(prompt_n)
            chains.append(chain_n)
            entropies.append(entropy_n)

         chains, entropies

     ():
        
        input_ids = .tokenizer.encode(prompt, return_tensors=)

        
        outputs = .model.generate(
            input_ids,
            max_new_tokens=,
            return_dict_in_generate=,
            output_scores=,
            pad_token_id=.tokenizer.eos_token_id
        )

        
        generated_ids = outputs.sequences[][input_ids.shape[]:]
        generated_text = .tokenizer.decode(generated_ids, skip_special_tokens=)

        
        
        entropy = .compute_sequence_entropy(outputs.scores)

         generated_text, entropy

     ():
        
        entropies = []

         token_scores  scores:
            
            probs = F.softmax(token_scores, dim=-)

            
            entropy = -(probs * torch.log(probs + )).(dim=-)
            entropies.append(entropy.item())

        
         np.mean(entropies)  entropies