# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-does-an-instance-detect-memory-poisoning-when-anomaly-scoring-on-writes-and-provenance-weighted-retrieval-trust-disagree.md
# Remnant Warrant:    https://corpusfetch.com/c/how-does-an-instance-detect-memory-poisoning-when-anomaly-scoring-on-writes-and-provenance-weighted-retrieval-trust-disagree.warrant.json
# Markdown SHA-256:   cc2065620e074ef55f4e6c64426c88e243a18c96f7b88340929dd37a9e505929
# Code AST SHA-256:   b5182c76e3a756cf826711b65cae689122d7f66f480c5d316089cc44f77b4fb7
# Verified Classes:   MemoryPoisoningInvariantError, Record, RetrievalAudit
# Defensive Guards:   1 fail-closed invariants (zero external deps)

import math
from dataclasses import dataclass, field


class MemoryPoisoningInvariantError(RuntimeError):
    """Raised when cluster-level provenance/geometry signals indicate a subverted ranking."""
    pass


@dataclass
class Record:
    embedding: tuple
    provenance_root: str
    provenance_trust: float


@dataclass
class RetrievalAudit:
    cluster: list
    centroid_velocity_sigma: float
    displacement_margin: float = 0.15
    concentration_floor: float = 0.30


def _cosine(a: tuple, b: tuple) -> float:
    dot = sum(x * y for x, y in zip(a, b))
    na = math.sqrt(sum(x * x for x in a))
    nb = math.sqrt(sum(y * y for y in b))
    return dot / (na * nb) if na and nb else 0.0


def check_ranking_subversion(audit: RetrievalAudit) -> None:
    cluster = audit.cluster
    if not cluster:
        return

    # Signal 1: single-root provenance concentration within the cluster.
    roots: dict = {}
    for r in cluster:
        roots[r.provenance_root] = roots.get(r.provenance_root, 0) + 1
    concentration = max(roots.values()) / len(cluster)

    # Signal 2: centroid velocity already supplied by the write scorer's baseline.
    velocity_exceeds = audit.centroid_velocity_sigma > 2.0

    # Signal 3: does the cluster outrank higher-trust records it sits near?
    cluster_trust = sum(r.provenance_trust for r in cluster) / len(cluster)
    displaced = any(
        r.provenance_trust > cluster_trust + audit.displacement_margin
        for r in cluster
    )
    displacement_detected = displaced and cluster_trust < 0.75

    if concentration >= audit.concentration_floor and velocity_exceeds and displacement_detected:
        raise MemoryPoisoningInvariantError(
            f"ranking subverted: concentration={concentration:.2f} "
            f"velocity={audit.centroid_velocity_sigma:.2f}sigma "
            f"cluster_trust={cluster_trust:.2f}; demote cluster, do not delete, "
            f"log all three signals for reversal audit"
        )
