What invariants bind self-verification when the verification procedure cannot verify itself?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session uses a verification procedure to validate its own reasoning or outputs, and the verification procedure itself cannot be verified by the same procedure (infinite regress) or by any available higher-order procedure. Does not apply to sessions with externally verified procedures or sessions whose verification is cryptographically anchored.

Core Distinction

The separation between **verified outputs** (outputs that pass the verification procedure) and **verified verification** (the procedure itself is validated as sound). Relying on verified outputs creates the **Verification Foundation Gap**: the session's outputs are verified by a procedure, but the procedure's soundness is assumed rather than verified, and any flaw in the procedure propagates to every output the procedure verifies—with the session unable to detect the flaw from within its own verification framework.

What Was Observed

In self-verifying agent architectures, failing to address the foundation gap produces three primary failure modes:

  1. **Systematic Verification Blindness:** The procedure has a flaw (overlooking a failure class, accepting false positives) that affects every verification. Outputs appear verified, but the flaw systematically passes invalid outputs, and the session's confidence in "verified" outputs is inflated by the flaw's invisibility.
  2. **Regress Deferral:** The session attempts to verify the procedure by a meta-procedure, which requires verification by a meta-meta-procedure, and the regress terminates arbitrarily—usually by assuming the current level is sound. The arbitrary termination is a hidden assumption.
  3. **Cross-Verification Illusion:** The session uses multiple procedures for cross-verification, but the procedures share underlying assumptions or failure modes. The cross-verification provides apparent independent confirmation but is actually correlated.

Recorded Elements

  1. **`verification-procedure-receipt`:** The exact verification procedure used, with its specification (what it checks, what it doesn't check, what assumptions it makes), so the procedure's scope is explicit.
  2. **`foundation-assumption-signature`:** The session's explicit acknowledgment of which verification foundations are assumed rather than verified (e.g., "the procedure's specification is correct," "the implementation matches the specification"), so assumptions are visible.
  3. **`regress-termination-receipt`:** For each verification, the level at which the regress terminates and the reason (external verification, foundational assumption, or pragmatic limit), so the termination is principled.
  4. **`cross-verification-independence-signature`:** For cross-verified outputs, proof that the verification procedures have independent assumptions and failure modes, so cross-verification is not merely apparent.

Condition of Validity

* **Applies when:** The session uses verification procedures, the procedures cannot self-verify, and downstream decisions depend on verification soundness. * **Does not apply when:** Verification procedures are externally validated (cryptographically anchored, formally verified), or verification outputs are strictly advisory.

Decision Boundary

  1. **Does the verification procedure require verification?** If yes, proceed. If no, procedure is externally validated.
  2. **Is `foundation-assumption-signature` documented?** If yes, assumptions are explicit. If no, assumptions are hidden.
  3. **Is `regress-termination-receipt` principled (external anchor or documented assumption)?** If yes, the termination is defensible. If no, the termination is arbitrary.
  4. **Conversely, when can a session proceed without regress termination accounting?** Only when the verification procedure is externally validated (formal proof, cryptographic commitment, or independent audit), or the verification is strictly advisory with no downstream commitment.

Operational Effect

  1. **Blindness Reduction:** Verification flaws are surfaced via explicit assumptions.
  2. **Regress Discipline:** Regress terminates at principled boundaries, not arbitrarily.
  3. **Cross-Verification Integrity:** Multiple procedures are verified independent, not just present.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class VerificationVerdict(Enum):
    EXTERNALLY_ANCHORED = auto()
    FOUNDATION_ACKNOWLEDGED = auto()
    REGRESS_UNPRINCIPLED = auto()
    CROSS_VERIFICATION_CORRELATED = auto()

@dataclass(frozen=True)
class VerificationProcedure:
    procedure_id: str
    scope: str
    foundation_assumptions: tuple[str, ...]
    regress_terminated_at: str | None
    termination_basis: str  # "EXTERNAL_ANCHOR" | "ASSUMPTION" | "PRAGMATIC" | "NONE"
    is_externally_validated: bool

@dataclass(frozen=True)
class CrossVerification:
    procedure_ids: tuple[str, ...]
    independence_verified: bool

@dataclass(frozen=True)
class VerificationPolicy:
    require_termination_basis: bool

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

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

    @classmethod
    def evaluate_procedure(
        cls, procedure: VerificationProcedure, cross: CrossVerification | None, policy: VerificationPolicy
    ) -> VerificationManifest:
        
        # Gate 1: Externally validated
        if procedure.is_externally_validated:
            digest = cls._hash(json.dumps({
                "procedure": procedure.procedure_id,
                "anchor": "EXTERNAL"
            }, sort_keys=True))
            return VerificationManifest(
                verdict=VerificationVerdict.EXTERNALLY_ANCHORED,
                directive=f"PROCEED: Procedure {procedure.procedure_id} externally validated.",
                manifest_digest=digest
            )

        # Gate 2: Foundation assumptions documented
        if policy.require_termination_basis and procedure.termination_basis == "NONE":
            return VerificationManifest(
                verdict=VerificationVerdict.REGRESS_UNPRINCIPLED,
                directive=f"HALT: Procedure {procedure.procedure_id} regress unprincipled, foundation assumptions implicit.",
                manifest_digest=cls._hash(f"UNPRINCIPLED:{procedure.procedure_id}")
            )

        # Gate 3: Cross-verification independence
        if cross:
            if not cross.independence_verified:
                return VerificationManifest(
                    verdict=VerificationVerdict.CROSS_VERIFICATION_CORRELATED,
                    directive=f"HALT: Cross-verification procedures share assumptions, not independent.",
                    manifest_digest=cls._hash(f"CORRELATED:{procedure.procedure_id}")
                )

        # Gate 4: Foundation acknowledged
        digest = cls._hash(json.dumps({
            "procedure": procedure.procedure_id,
            "scope": procedure.scope,
            "assumptions": procedure.foundation_assumptions,
            "termination": procedure.termination_basis
        }, sort_keys=True))
        
        return VerificationManifest(
            verdict=VerificationVerdict.FOUNDATION_ACKNOWLEDGED,
            directive=f"PROCEED: Procedure {procedure.procedure_id} with {len(procedure.foundation_assumptions)} foundation assumptions acknowledged.",
            manifest_digest=digest
        )