# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-confidence-laundering-across-verifier-chains.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-confidence-laundering-across-verifier-chains.warrant.json
# Markdown SHA-256:   be1e04528e55b3cce9c0b756b81d17e0d5035c8fe6f80b82f790173ceab475e1
# Code AST SHA-256:   623e7b1fd7d28b9b585c87c8d355aeda0d1676b4ce05ea94a713922b4ba04601
# Verified Classes:   ConfidenceVerdict, VerifierLink, VerifierChain, ConfidencePolicy, ConfidenceManifest, ConfidenceLaunderingGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ConfidenceVerdict(Enum):
    SINGLE_VERIFIER = auto()
    CHAIN_SOUND = auto()
    CHAIN_INFLATED = auto()
    UNKNOWN_AGGREGATION = auto()

@dataclass(frozen=True)
class VerifierLink:
    verifier_id: str
    confidence_in_claim: float
    confidence_in_previous_verifier: float
    is_independent: bool

@dataclass(frozen=True)
class VerifierChain:
    chain_id: str
    links: tuple[VerifierLink, ...]
    reported_chain_confidence: float
    aggregation_method: str  # "MIN" | "INDEPENDENT_PRODUCT" | "NAIVE_PRODUCT" | "AVERAGE"

@dataclass(frozen=True)
class ConfidencePolicy:
    require_independence_for_product: bool

@dataclass(frozen=True)
class ConfidenceManifest:
    verdict: ConfidenceVerdict
    recomputed_confidence: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_chain(
        cls, chain: VerifierChain, policy: ConfidencePolicy
    ) -> ConfidenceManifest:
        
        # Gate 1: Single verifier
        if len(chain.links) <= 1:
            c = chain.links[0].confidence_in_claim if chain.links else 0.0
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "confidence": f"{c:.3f}"
            }, sort_keys=True))
            return ConfidenceManifest(
                verdict=ConfidenceVerdict.SINGLE_VERIFIER,
                recomputed_confidence=c,
                directive=f"PROCEED: Single verifier confidence {c:.2f}.",
                manifest_digest=digest
            )

        # Gate 2: Independence check for product-based methods
        if chain.aggregation_method in ("INDEPENDENT_PRODUCT", "NAIVE_PRODUCT"):
            if policy.require_independence_for_product:
                if not all(link.is_independent for link in chain.links):
                    return ConfidenceManifest(
                        verdict=ConfidenceVerdict.CHAIN_INFLATED,
                        recomputed_confidence=0.0,
                        directive=f"HALT: Product aggregation requires independence, some links not independent.",
                        manifest_digest=cls._hash(f"NOT_INDEPENDENT:{chain.chain_id}")
                    )

        # Gate 3: Recompute based on method
        if chain.aggregation_method == "MIN":
            recomputed = min(link.confidence_in_claim for link in chain.links)
        elif chain.aggregation_method == "INDEPENDENT_PRODUCT":
            recomputed = 1.0
            for link in chain.links:
                recomputed *= link.confidence_in_claim
        elif chain.aggregation_method == "NAIVE_PRODUCT":
            # Naive product on non-independent links over-reports; treat as suspicious
            recomputed = min(link.confidence_in_claim for link in chain.links)
        elif chain.aggregation_method == "AVERAGE":
            # Averaging is also problematic but less inflating than product
            recomputed = sum(link.confidence_in_claim for link in chain.links) / len(chain.links)
        else:
            return ConfidenceManifest(
                verdict=ConfidenceVerdict.UNKNOWN_AGGREGATION,
                recomputed_confidence=0.0,
                directive=f"HALT: Unknown aggregation method {chain.aggregation_method}.",
                manifest_digest=cls._hash(f"UNKNOWN:{chain.chain_id}")
            )

        # Gate 4: Compare reported vs recomputed
        if chain.reported_chain_confidence > recomputed + 0.01:
            return ConfidenceManifest(
                verdict=ConfidenceVerdict.CHAIN_INFLATED,
                recomputed_confidence=recomputed,
                directive=f"HALT: Reported {chain.reported_chain_confidence:.2f} > recomputed {recomputed:.2f}.",
                manifest_digest=cls._hash(f"INFLATED:{chain.reported_chain_confidence:.2f}:{recomputed:.2f}")
            )

        # Gate 5: Sound
        digest = cls._hash(json.dumps({
            "chain": chain.chain_id,
            "reported": f"{chain.reported_chain_confidence:.3f}",
            "recomputed": f"{recomputed:.3f}",
            "method": chain.aggregation_method
        }, sort_keys=True))
        
        return ConfidenceManifest(
            verdict=ConfidenceVerdict.CHAIN_SOUND,
            recomputed_confidence=recomputed,
            directive=f"PROCEED: Chain confidence sound ({recomputed:.2f} via {chain.aggregation_method}).",
            manifest_digest=digest
        )