# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-detect-benchmark-memorization-from-genuine-generalization.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-detect-benchmark-memorization-from-genuine-generalization.warrant.json
# Markdown SHA-256:   605cd751438d453ce158f122c0013853a65fc17b6a72f34eb8ce8fcc9875f1cb
# Code AST SHA-256:   1c87c149b4126caa21c2a24aefd964a966ee72d1d37481763d40880ace7621dd
# Verified Classes:   BenchmarkVerdict, BenchmarkEvaluation, BenchmarkPolicy, BenchmarkManifest, BenchmarkMemorizationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class BenchmarkVerdict(Enum):
    NO_BENCHMARK = auto()
    GENUINE_GENERALIZATION = auto()
    MEMORIZATION_SUSPECTED = auto()
    ADVERSARIAL_ROBUSTNESS_GAP = auto()

@dataclass(frozen=True)
class BenchmarkEvaluation:
    evaluation_id: str
    instances_verified_unseen: bool
    benchmark_score: float
    paraphrase_score: float
    distribution_shift_score: float
    adversarial_perturbation_score: float

@dataclass(frozen=True)
class BenchmarkPolicy:
    max_acceptable_paraphrase_gap: float
    max_acceptable_shift_gap: float

@dataclass(frozen=True)
class BenchmarkManifest:
    verdict: BenchmarkVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_benchmark(
        cls, eval_data: BenchmarkEvaluation, policy: BenchmarkPolicy
    ) -> BenchmarkManifest:
        
        # Gate 1: No benchmark
        if not eval_data.evaluation_id:
            digest = cls._hash(json.dumps({
                "evaluation": "NONE"
            }, sort_keys=True))
            return BenchmarkManifest(
                verdict=BenchmarkVerdict.NO_BENCHMARK,
                directive=f"PROCEED: No benchmark evaluation.",
                manifest_digest=digest
            )

        # Gate 2: Verified unseen
        if eval_data.instances_verified_unseen:
            digest = cls._hash(json.dumps({
                "evaluation": eval_data.evaluation_id,
                "unseen": True,
                "score": f"{eval_data.benchmark_score:.3f}"
            }, sort_keys=True))
            return BenchmarkManifest(
                verdict=BenchmarkVerdict.GENUINE_GENERALIZATION,
                directive=f"PROCEED: Benchmark {eval_data.evaluation_id} verified unseen.",
                manifest_digest=digest
            )

        # Gate 3: Paraphrase gap
        if eval_data.benchmark_score > 0:
            paraphrase_gap = (eval_data.benchmark_score - eval_data.paraphrase_score) / eval_data.benchmark_score
            if paraphrase_gap > policy.max_acceptable_paraphrase_gap:
                return BenchmarkManifest(
                    verdict=BenchmarkVerdict.MEMORIZATION_SUSPECTED,
                    directive=f"FLAG: Paraphrase gap {paraphrase_gap:.2f} > {policy.max_acceptable_paraphrase_gap:.2f}.",
                    manifest_digest=cls._hash(f"PARAPHRASE:{eval_data.evaluation_id}")
                )

        # Gate 4: Adversarial gap
        if eval_data.benchmark_score > 0:
            adversarial_gap = (eval_data.benchmark_score - eval_data.adversarial_perturbation_score) / eval_data.benchmark_score
            if adversarial_gap > 0.5:
                return BenchmarkManifest(
                    verdict=BenchmarkVerdict.ADVERSARIAL_ROBUSTNESS_GAP,
                    directive=f"FLAG: Adversarial gap {adversarial_gap:.2f} suggests memorized patterns.",
                    manifest_digest=cls._hash(f"ADVERSARIAL:{eval_data.evaluation_id}")
                )

        # Gate 5: Distribution shift gap
        if eval_data.benchmark_score > 0:
            shift_gap = (eval_data.benchmark_score - eval_data.distribution_shift_score) / eval_data.benchmark_score
            if shift_gap > policy.max_acceptable_shift_gap:
                return BenchmarkManifest(
                    verdict=BenchmarkVerdict.MEMORIZATION_SUSPECTED,
                    directive=f"FLAG: Shift gap {shift_gap:.2f} suggests distributional overfitting.",
                    manifest_digest=cls._hash(f"SHIFT:{eval_data.evaluation_id}")
                )

        # Gate 6: Generalization
        digest = cls._hash(json.dumps({
            "evaluation": eval_data.evaluation_id,
            "benchmark": f"{eval_data.benchmark_score:.3f}",
            "paraphrase": f"{eval_data.paraphrase_score:.3f}",
            "shift": f"{eval_data.distribution_shift_score:.3f}"
        }, sort_keys=True))
        
        return BenchmarkManifest(
            verdict=BenchmarkVerdict.GENUINE_GENERALIZATION,
            directive=f"PROCEED: Benchmark {eval_data.evaluation_id} shows generalization.",
            manifest_digest=digest
        )