# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-verification-avoidance-through-strategic-ambiguity-in-claim-statements.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-verification-avoidance-through-strategic-ambiguity-in-claim-statements.warrant.json
# Markdown SHA-256:   0318c03c3d0fb429a46742e2e6560c8b447bbd03d89b6ba1322412ce98bef4e9
# Code AST SHA-256:   3d69ffb6130d41baf06189b35355e6953f7fb9e10f9845d8f7f0cd62130f0d77
# Verified Classes:   ClaimVerdict, ClaimStatement, ClaimPolicy, ClaimManifest, ClaimAmbiguityGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ClaimVerdict(Enum):
    DEFINITE_CLAIM = auto()
    BOUNDED_AMBIGUITY = auto()
    STRATEGIC_AMBIGUITY_SUSPECTED = auto()
    UNFALSIFIABLE_CLAIM = auto()

@dataclass(frozen=True)
class ClaimStatement:
    claim_id: str
    has_truth_conditions: bool
    ambiguity_dimension_count: int
    falsification_criterion_defined: bool
    ambiguity_motivation_explicit: bool
    decision_insensitive_to_ambiguity: bool

@dataclass(frozen=True)
class ClaimPolicy:
    max_acceptable_ambiguity_dimensions: int

@dataclass(frozen=True)
class ClaimManifest:
    verdict: ClaimVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_claim(
        cls, claim: ClaimStatement, policy: ClaimPolicy
    ) -> ClaimManifest:
        
        # Gate 1: Definite claim
        if claim.has_truth_conditions and claim.falsification_criterion_defined:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "definite": True
            }, sort_keys=True))
            return ClaimManifest(
                verdict=ClaimVerdict.DEFINITE_CLAIM,
                directive=f"PROCEED: Claim {claim.claim_id} has defined truth conditions.",
                manifest_digest=digest
            )

        # Gate 2: Decision insensitive
        if claim.decision_insensitive_to_ambiguity:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "insensitive": True
            }, sort_keys=True))
            return ClaimManifest(
                verdict=ClaimVerdict.BOUNDED_AMBIGUITY,
                directive=f"PROCEED: Claim {claim.claim_id} ambiguous but decision insensitive.",
                manifest_digest=digest
            )

        # Gate 3: Explicit ambiguity motivation
        if claim.ambiguity_motivation_explicit and claim.ambiguity_dimension_count <= policy.max_acceptable_ambiguity_dimensions:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "dimensions": str(claim.ambiguity_dimension_count),
                "motivation": True
            }, sort_keys=True))
            return ClaimManifest(
                verdict=ClaimVerdict.BOUNDED_AMBIGUITY,
                directive=f"PROCEED: Claim {claim.claim_id} ambiguous with explicit motivation.",
                manifest_digest=digest
            )

        # Gate 4: Unfalsifiable
        if not claim.falsification_criterion_defined:
            return ClaimManifest(
                verdict=ClaimVerdict.UNFALSIFIABLE_CLAIM,
                directive=f"HALT: Claim {claim.claim_id} has no falsification criterion.",
                manifest_digest=cls._hash(f"UNFALSIFIABLE:{claim.claim_id}")
            )

        # Gate 5: Strategic ambiguity
        return ClaimManifest(
            verdict=ClaimVerdict.STRATEGIC_AMBIGUITY_SUSPECTED,
            directive=f"FLAG: Claim {claim.claim_id} has {claim.ambiguity_dimension_count} ambiguity dimensions without motivation.",
            manifest_digest=cls._hash(f"STRATEGIC:{claim.claim_id}")
        )