What invariants prevent witness correlation in multi-signature verification?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session requires multiple witnesses to sign off on a claim or state change, and the witnesses may be correlated (sharing infrastructure, data sources, or incentives), so the multi-signature appears independent but is effectively single-signature. Does not apply to single-signature verification or witnesses verified as cryptographically independent.

Core Distinction

The separation between **witness count** (the number of signatures) and **witness independence** (the degree to which witnesses provide independent evidence). Relying on count creates the **Signature Illusion**: N signatures are collected, and the verification is treated as N-times stronger than a single signature—but if the witnesses are correlated, the effective verification is 1 signature's worth, not N.

What Was Observed

In multi-signature agent architectures, failing to detect witness correlation produces three primary failure modes:

  1. **Shared Source Collapse:** All witnesses receive their information from the same upstream source. The signatures are technically independent (different witnesses), but the underlying evidence is identical, so the signatures only verify the upstream source, not the claim.
  2. **Infrastructure Correlation:** Witnesses run on the same cloud provider, the same availability zone, or the same regulatory jurisdiction. An outage, attack, or policy change that affects one affects all, and their simultaneous agreement is not independence but shared vulnerability.
  3. **Incentive Correlation:** Witnesses share the same incentives (all benefit from the claim being true), so their agreement reflects aligned interests, not independent assessment. The signatures confirm the claim is beneficial, not that it is true.

Recorded Elements

  1. **`witness-identity-receipt`:** For each witness, its identity, operating infrastructure, and jurisdictional association, so correlation dimensions are known.
  2. **`witness-independence-matrix-signature`:** A pairwise matrix of independence between witnesses (sharing infrastructure, sources, or incentives), so correlated pairs are identified.
  3. **`effective-witness-count-receipt`:** The computed effective number of independent witnesses, accounting for correlation groups, distinct from the raw count of signatures.
  4. **`witness-diversity-policy-signature`:** The exact diversity requirements (e.g., "witnesses must span ≥3 infrastructure providers, ≥2 jurisdictions, and ≥2 incentive classes"), so effective independence is defined and enforced.

Condition of Validity

* **Applies when:** Multi-signature verification is used, witnesses may be correlated, and the strength of verification depends on independence. * **Does not apply when:** Single-signature verification is used, witnesses are verified as independent, or the claim's importance does not depend on verification strength.

Decision Boundary

  1. **Does the verification use multiple witnesses?** If no, single-signature applies. If yes, proceed.
  2. **Is `witness-independence-matrix-signature` computed?** If yes, correlation is quantified. If no, correlation is assumed maximal.
  3. **Does `effective-witness-count-receipt` meet the diversity requirement?** If yes, the verification is as strong as the raw count suggests. If no, the verification is weaker than claimed.
  4. **Conversely, when can correlated witnesses be treated as independent?** Only when the specific claim is verified to be independent of the correlation dimension (e.g., witnesses share infrastructure but the claim is about jurisdiction, which they span).

Operational Effect

  1. **Signature Count Honesty:** Reported count matches effective independence.
  2. **Correlation Detection:** Shared sources, infrastructure, and incentives are surfaced.
  3. **Diversity Enforcement:** Diversity requirements are enforced, not just assumed.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class WitnessVerdict(Enum):
    SINGLE_WITNESS = auto()
    INDEPENDENT_WITNESSES = auto()
    CORRELATION_DETECTED = auto()
    DIVERSITY_INSUFFICIENT = auto()

@dataclass(frozen=True)
class Witness:
    witness_id: str
    infrastructure_provider: str
    jurisdiction: str
    incentive_class: str
    data_source_hash: str
    signature: str | None

@dataclass(frozen=True)
class VerificationSet:
    verification_id: str
    witnesses: tuple[Witness, ...]
    required_effective_witnesses: int

@dataclass(frozen=True)
class WitnessPolicy:
    require_diversity_for_effective: bool

@dataclass(frozen=True)
class WitnessManifest:
    verdict: WitnessVerdict
    effective_witness_count: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_verification(
        cls, vset: VerificationSet, policy: WitnessPolicy
    ) -> WitnessManifest:
        
        # Gate 1: Single witness
        if len(vset.witnesses) <= 1:
            digest = cls._hash(json.dumps({
                "verification": vset.verification_id,
                "count": str(len(vset.witnesses))
            }, sort_keys=True))
            return WitnessManifest(
                verdict=WitnessVerdict.SINGLE_WITNESS,
                effective_witness_count=float(len(vset.witnesses)),
                directive=f"PROCEED: Single witness for {vset.verification_id}.",
                manifest_digest=digest
            )

        # Gate 2: Compute effective count via unique tuple grouping
        unique_groups: set[tuple[str, str, str, str]] = set()
        for w in vset.witnesses:
            key = (w.infrastructure_provider, w.jurisdiction, w.incentive_class, w.data_source_hash)
            unique_groups.add(key)

        effective_count = float(len(unique_groups))

        # Gate 3: Diversity requirement
        if policy.require_diversity_for_effective:
            if effective_count < vset.required_effective_witnesses:
                return WitnessManifest(
                    verdict=WitnessVerdict.DIVERSITY_INSUFFICIENT,
                    effective_witness_count=effective_count,
                    directive=f"HALT: {len(vset.witnesses)} witnesses but only {effective_count:.0f} independent groups < {vset.required_effective_witnesses} required.",
                    manifest_digest=cls._hash(f"INSUFFICIENT:{vset.verification_id}")
                )

        # Gate 4: Correlation detected
        if effective_count < len(vset.witnesses):
            return WitnessManifest(
                verdict=WitnessVerdict.CORRELATION_DETECTED,
                effective_witness_count=effective_count,
                directive=f"CAUTION: {len(vset.witnesses)} witnesses but {effective_count:.0f} effective, correlation present.",
                manifest_digest=cls._hash(f"CORRELATED:{vset.verification_id}")
            )

        # Gate 5: Independent
        digest = cls._hash(json.dumps({
            "verification": vset.verification_id,
            "witnesses": tuple(w.witness_id for w in vset.witnesses),
            "effective": str(effective_count)
        }, sort_keys=True))
        
        return WitnessManifest(
            verdict=WitnessVerdict.INDEPENDENT_WITNESSES,
            effective_witness_count=effective_count,
            directive=f"PROCEED: {len(vset.witnesses)} independent witnesses for {vset.verification_id}.",
            manifest_digest=digest
        )