opv-process-verifier

name	opv-process-verifier
title	OPV: Outcome-based Process Verifier for Efficient Long Chain-of-Thought Verification
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2512.10756
keywords	["verification","chain-of-thought","process rewards","reinforcement learning","reasoning validation"]
description	Verify long reasoning chains by combining outcome and process verification through active learning. OPV achieves 83.1 F1 on verification—crucial when both final answers and reasoning paths must be validated with minimal annotation.

Overview

OPV bridges outcome and process verification by summarizing long CoT chains before process verification. Iterative active learning progressively improves verification capability while minimizing annotation costs through targeted uncertainty sampling.

When to Use

• Verifying long chain-of-thought reasoning
• Limited annotation budget
• Need to check both answers and reasoning quality
• Mathematical and logical problem solving
• Iterative improvement of verification models

When NOT to Use

• Single-statement verification
• Abundant annotation resources
• Short reasoning chains

Core Technique

Outcome + process hybrid verification with active learning:

# OPV: Outcome-Process Verification
class OutcomeProcessVerifier:
    def __init__(self):
        self.outcome_model = OutcomeVerifier()
        self.process_model = ProcessVerifier()
        self.active_learner = ActiveLearner()

    def verify_long_cot(self, problem, cot_chain):
        """Hybrid verification for long reasoning."""
        # Stage 1: Outcome verification (fast)
        outcome_valid = self.outcome_model.verify(problem, cot_chain[-1])

        # Stage 2: Summarize long CoT
        summary = self.summarize_cot(cot_chain)

        # Stage 3: Process verification on summary
        process_valid = self.process_model.verify(
            problem,
            summary
        )

        # Combined verdict
        is_valid = outcome_valid and process_valid

        return is_valid

    def summarize_cot(self, cot_chain):
        
        
        important_steps = []

         step  cot_chain:
             .is_important_step(step):
                important_steps.append(step)

        
        summary = .create_logical_summary(important_steps)

         summary

     ():
        
        labeled_data = []

         iteration  ():
            
            predictions = .predict_on_batch(unlabeled_cots)

            
            uncertain_indices = .active_learner.select_uncertain(
                predictions,
                budget=expert_budget
            )

            
            expert_labels = .get_expert_labels(
                [unlabeled_cots[i]  i  uncertain_indices]
            )

            
             idx, label  (uncertain_indices, expert_labels):
                labeled_data.append((unlabeled_cots[idx], label))

            
            .retrain_on_labeled_data(labeled_data)

            
            unlabeled_cots = [
                cot  i, cot  (unlabeled_cots)
                 i   uncertain_indices
            ]

         labeled_data

     ():
        
         problem  problems:
            
            reasoning = model.generate_cot(problem)

            
            is_valid = .verify_long_cot(problem, reasoning)

            
            reward =   is_valid  

            
            model.update_with_reward(reasoning, reward)