What invariants prevent verification regress from terminating at an arbitrary level?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session verifies a claim through a chain of verifiers, each verifier's reliability must itself be verified, and the regress terminates either at a principled anchor (external authority, cryptographic proof) or at an arbitrary depth. Does not apply to sessions with a single trusted verifier or sessions whose verification is cryptographically anchored.

Core Distinction

The separation between **verification termination** (the regress stops) and **principled termination** (the regress stops at a justified boundary). Relying on termination creates the **Arbitrary Verification Boundary**: the regress stops because the session runs out of resources, gives up, or hits a predefined depth—none of which justify trusting the claim. The termination is a resource decision, not an epistemic one.

What Was Observed

In regress-prone agent architectures, failing to preserve principled termination produces three primary failure modes:

  1. **Depth Cutoff:** The session verifies through N verifiers and stops, trusting the Nth without justification. The choice of N is arbitrary (whatever the session could afford), and claims verified at N have no principled basis for trust.
  2. **Resource Exhaustion:** The session exhausts its verification budget, stops, and accepts the claim. The acceptance is a resource constraint, not a verification conclusion.
  3. **Circular Anchor:** The regress terminates because a verifier verifies itself (or the chain cycles). The circular termination provides no new justification.

Recorded Elements

  1. **`verification-chain-receipt`:** For each verification, the exact chain of verifiers, so the regress is documented.
  2. **`termination-anchor-signature`:** For each chain's termination, the exact anchor (external authority, cryptographic proof, or arbitrary depth), so principled vs. arbitrary termination is distinguished.
  3. **`anchor-authority-receipt`:** For terminating anchors, the anchor's justification (why is the external authority trusted, why is the cryptographic proof valid), so anchor legitimacy is bounded.
  4. **`regress-depth-signature`:** For each chain, the depth at which verification terminated, so depth-based termination is distinguished from anchor-based.

Condition of Validity

* **Applies when:** Verification involves chains of verifiers, regress can occur, and downstream decisions depend on verification. * **Does not apply when:** Verification is single-hop, verification is cryptographically anchored, or downstream decisions do not depend on verification depth.

Decision Boundary

  1. **Does the verification involve multiple verifiers?** If no, single-verifier handling applies. If yes, proceed.
  2. **Does the chain terminate at a principled anchor?** If yes, termination is justified. If no, termination is arbitrary.
  3. **Is `anchor-authority-receipt` present for the termination anchor?** If yes, anchor legitimacy is bounded. If no, anchor is assumed.
  4. **Conversely, when can a chain terminate without a principled anchor?** Only when the claim's consequences are strictly bounded (wrongness is tolerable), or the termination is explicitly labeled as resource-limited with disclosed risk.

Operational Effect

  1. **Arbitrary Cutoff Prevention:** Termination depth alone is not treated as justification.
  2. **Anchor Legitimacy:** Anchors are verified, not assumed.
  3. **Resource Termination Transparency:** Resource-based termination is disclosed.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class RegressVerdict(Enum):
    SINGLE_VERIFIER = auto()
    PRINCIPLED_ANCHOR = auto()
    ARBITRARY_TERMINATION = auto()
    CIRCULAR_ANCHOR = auto()

@dataclass(frozen=True)
class VerificationLink:
    verifier_id: str
    verifies_claim: bool
    verification_basis: str  # "EXTERNAL_AUTHORITY" | "CRYPTO_PROOF" | "DEPTH_LIMIT" | "RESOURCE_LIMIT" | "CIRCULAR"

@dataclass(frozen=True)
class VerificationChain:
    chain_id: str
    links: tuple[VerificationLink, ...]
    anchor_justified: bool

@dataclass(frozen=True)
class RegressPolicy:
    require_principled_anchor: bool

@dataclass(frozen=True)
class RegressManifest:
    verdict: RegressVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_chain(
        cls, chain: VerificationChain, policy: RegressPolicy
    ) -> RegressManifest:
        
        # Gate 1: Single verifier
        if len(chain.links) <= 1:
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "links": str(len(chain.links))
            }, sort_keys=True))
            return RegressManifest(
                verdict=RegressVerdict.SINGLE_VERIFIER,
                directive=f"PROCEED: Chain {chain.chain_id} single verifier.",
                manifest_digest=digest
            )

        # Gate 2: Circular
        terminal = chain.links[-1]
        if terminal.verification_basis == "CIRCULAR":
            return RegressManifest(
                verdict=RegressVerdict.CIRCULAR_ANCHOR,
                directive=f"HALT: Chain {chain.chain_id} terminates in circular anchor.",
                manifest_digest=cls._hash(f"CIRCULAR:{chain.chain_id}")
            )

        # Gate 3: Principled anchor
        if terminal.verification_basis in ("EXTERNAL_AUTHORITY", "CRYPTO_PROOF"):
            if chain.anchor_justified:
                digest = cls._hash(json.dumps({
                    "chain": chain.chain_id,
                    "anchor": terminal.verification_basis,
                    "links": str(len(chain.links))
                }, sort_keys=True))
                return RegressManifest(
                    verdict=RegressVerdict.PRINCIPLED_ANCHOR,
                    directive=f"PROCEED: Chain {chain.chain_id} anchored at {terminal.verification_basis}.",
                    manifest_digest=digest
                )

        # Gate 4: Arbitrary termination
        if terminal.verification_basis in ("DEPTH_LIMIT", "RESOURCE_LIMIT"):
            if policy.require_principled_anchor:
                return RegressManifest(
                    verdict=RegressVerdict.ARBITRARY_TERMINATION,
                    directive=f"HALT: Chain {chain.chain_id} terminated by {terminal.verification_basis}, not principled.",
                    manifest_digest=cls._hash(f"ARBITRARY:{chain.chain_id}")
                )

        # Gate 5: Default
        return RegressManifest(
            verdict=RegressVerdict.ARBITRARY_TERMINATION,
            directive=f"FLAG: Chain {chain.chain_id} termination basis {terminal.verification_basis}.",
            manifest_digest=cls._hash(f"DEFAULT:{chain.chain_id}")
        )