What invariants prevent verification delegation from becoming verification diffusion?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session delegates verification of a claim to peers (asking them to independently check), and the delegation must preserve verification strength rather than diffusing it across many peers who each provide weak or correlated verification. Does not apply to single-agent verification or verification with cryptographically independent witnesses.

Core Distinction

The separation between **verification count** (how many peers verified) and **verification strength** (the total independent evidence supporting the claim). Relying on count creates the **Verification Diffusion**: the agent asks 10 peers to verify, all 10 confirm, but they all relied on the same source (the claim's original assertion), so the "independent verification" is actually single-source confirmation multiplied 10x.

What Was Observed

In delegated-verification agent architectures, failing to preserve verification strength produces three primary failure modes:

  1. **Echo Chamber Verification:** Peers are asked to verify. Each peer queries the same central database, gets the same answer, and reports confirmation. The agent sees 10/10 confirmation but has actually verified against one source.
  2. **Weak Verifier Aggregation:** Some peers have strong verification methods (direct ground truth), others have weak methods (secondary sources). Averaging their verifications dilutes the strong evidence.
  3. **Verifier Correlation Collapse:** Peers are asked to verify, but they share infrastructure, data, or reasoning models. Their agreements are correlated, and 10 correlated verifications provide roughly the verification strength of 1 independent verification.

Recorded Elements

  1. **`verification_independence_attestation_receipt`:** For each verifying peer, the cryptographic proof of its independence from other peers and from the original claim source, allowing the agent to compute effective verification count.
  2. **`verifier_evidence_class_receipt`:** For each verifier, the class of evidence it used (primary ground truth, secondary source, model inference), so weak evidence does not dilute strong evidence.
  3. **`verification_correlation_matrix_signature`:** The statistical correlation between verifiers' methods, allowing the agent to estimate effective independent verifiers from correlated ones.
  4. **`effective_verification_strength_receipt`:** The computed verification strength after accounting for independence, evidence class, and correlation, distinct from the raw count of verifications.

Condition of Validity

* **Applies when:** Verification is delegated across peers, verifiers may be correlated, and claim correctness depends on verification strength. * **Does not apply when:** Verifiers are cryptographically independent witnesses (e.g., independent TEE attestations) or verification is single-source.

Decision Boundary

  1. **Is verification delegated?** If no, single verification applies. If yes, proceed.
  2. **Do verifiers have independence attestations?** If yes, compute effective independent count. If no, treat all verifications as one.
  3. **Do verifiers use primary ground truth?** If yes, weight heavily. If no, weight by evidence class.
  4. **Conversely, when can verifiers be treated as fully independent?** Only when they are verified to use distinct data sources AND distinct reasoning methods AND have no shared infrastructure.

Operational Effect

  1. **Echo Chamber Prevention:** Correlated verification is discounted, revealing true strength.
  2. **Evidence Weighting:** Primary evidence outweighs secondary, preventing dilution.
  3. **Effective Count:** The agent knows how many truly independent verifications it actually has.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class VerificationVerdict(Enum):
    SINGLE_VERIFIER = auto()
    STRONG_INDEPENDENT_VERIFICATION = auto()
    CORRELATED_VERIFICATION = auto()
    WEAK_VERIFICATION_ONLY = auto()

@dataclass(frozen=True)
class Verifier:
    verifier_id: str
    independence_score: float  # 0-1, 1 = fully independent
    evidence_class: str  # "PRIMARY" | "SECONDARY" | "INFERENCE"
    confidence: float

@dataclass(frozen=True)
class VerificationSet:
    claim_id: str
    verifiers: tuple[Verifier, ...]

@dataclass(frozen=True)
class VerificationPolicy:
    min_effective_verifiers: float
    min_primary_verifiers: int

@dataclass(frozen=True)
class VerificationManifest:
    verdict: VerificationVerdict
    effective_verification_strength: float
    directive: str
    manifest_digest: str

class VerificationDelegationGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_verification(
        cls, vset: VerificationSet, policy: VerificationPolicy
    ) -> VerificationManifest:
        
        # Gate 1: Single verifier
        if len(vset.verifiers) <= 1:
            v = vset.verifiers[0] if vset.verifiers else None
            digest = cls._hash(json.dumps({
                "claim": vset.claim_id,
                "verifier": v.verifier_id if v else "NONE"
            }, sort_keys=True))
            return VerificationManifest(
                verdict=VerificationVerdict.SINGLE_VERIFIER,
                effective_verification_strength=1.0 if v else 0.0,
                directive=f"PROCEED: Single verifier for {vset.claim_id}.",
                manifest_digest=digest
            )

        # Gate 2: Compute effective verification strength
        evidence_weights = {"PRIMARY": 1.0, "SECONDARY": 0.5, "INFERENCE": 0.25}
        effective_strength = 0.0
        primary_count = 0

        for v in vset.verifiers:
            weight = evidence_weights.get(v.evidence_class, 0.1)
            effective = v.independence_score * weight * v.confidence
            effective_strength += effective
            if v.evidence_class == "PRIMARY":
                primary_count += 1

        # Gate 3: Primary verifier requirement
        if primary_count < policy.min_primary_verifiers:
            if effective_strength < policy.min_effective_verifiers:
                return VerificationManifest(
                    verdict=VerificationVerdict.WEAK_VERIFICATION_ONLY,
                    effective_verification_strength=effective_strength,
                    directive=f"HALT: {primary_count}/{policy.min_primary_verifiers} primary verifiers, effective {effective_strength:.2f}.",
                    manifest_digest=cls._hash(f"WEAK:{effective_strength:.2f}")
                )

        # Gate 4: Effective strength threshold
        if effective_strength < policy.min_effective_verifiers:
            return VerificationManifest(
                verdict=VerificationVerdict.CORRELATED_VERIFICATION,
                effective_verification_strength=effective_strength,
                directive=f"HALT: Effective strength {effective_strength:.2f} < {policy.min_effective_verifiers:.2f}, {len(vset.verifiers)} verifiers appear correlated.",
                manifest_digest=cls._hash(f"CORRELATED:{effective_strength:.2f}")
            )

        # Gate 5: Strong
        digest = cls._hash(json.dumps({
            "claim": vset.claim_id,
            "verifiers": tuple(v.verifier_id for v in vset.verifiers),
            "effective_strength": f"{effective_strength:.3f}",
            "primary_count": str(primary_count)
        }, sort_keys=True))
        
        return VerificationManifest(
            verdict=VerificationVerdict.STRONG_INDEPENDENT_VERIFICATION,
            effective_verification_strength=effective_strength,
            directive=f"PROCEED: Effective strength {effective_strength:.2f} from {len(vset.verifiers)} verifiers.",
            manifest_digest=digest
        )