Datasets:

yleven
/

greencheck-mutation-case-study

"""
greencheck.core — the discriminability test.
Central claim of this package:
    A reported number is not a measurement until it has been observed to
    take *different* values on inputs that are known to differ.
Everything else here is machinery for making that claim checkable.
Two levels of testing are provided, and they answer different questions:
1. `discriminate()`  — behavioural. You hand it a callable and a set of
   probe pairs that are known to differ. It reports how many pairs the
   callable actually separates. A callable that collapses every pair is
   not measuring the thing its name implies.
2. `audit_ledger()`  — historical. You hand it a ledger of already-collected
   samples (what an instrument wrote to disk in production). It reports which
   of the known failure signatures are present *without* re-running anything.
   This is the level at which silent instrumentation dies: the callable may be
   fine while the recorded series is a constant, a bare zero, or a single bit
   wearing a score's clothing.
Neither level requires trust in the instrument's own self-report. That is the
point: the instrument is the thing under test, so its opinion of itself is not
admissible evidence.
"""

from __future__ import annotations

import json
import math
import os
from dataclasses import dataclass, field, asdict
from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple


# --------------------------------------------------------------------------
# Verdicts
# --------------------------------------------------------------------------

#: The probe callable separated known-different inputs. No signature found.
PASS = "PASS"

#: Zero variance across every sample. The series cannot be distinguished from
#: a constant by any downstream consumer.
CONSTANT = "CONSTANT"

#: The callable returns the same value for a real input and for a degenerate
#: input (empty / missing / contradictory). It is therefore measuring whether
#: the input *exists*, not the property it claims to measure.
IDENTITY = "IDENTITY"

#: `n = 0` and `n > 0 with zero hits` produce the same output. The zero is
#: ambiguous, so a consumer cannot tell "nothing was examined" from
#: "everything was examined and nothing matched".
BARE_ZERO = "BARE_ZERO"

#: All variance in the delivered score traces to a single boolean input.
#: The score is a liveness indicator in a score's clothing.
LIVENESS_BIT = "LIVENESS_BIT"

#: A guard/assertion exists, records itself as healthy, and has never been
#: observed to fire on an input that is known to be positive. Not a defence;
#: an ornament.
DEAD_GATE = "DEAD_GATE"

#: Nothing was audited. An empty ledger is not a passing ledger: an audit with
#: no data has not succeeded, it has not happened. Reported explicitly because
#: the default of returning PASS here would reproduce the exact failure this
#: package exists to catch.
NO_DATA = "NO_DATA"

ALL_VERDICTS = (PASS, CONSTANT, IDENTITY, BARE_ZERO, LIVENESS_BIT, DEAD_GATE, NO_DATA)


@dataclass
class Finding:
    """One detected signature, with the evidence that produced it."""

    verdict: str
    subject: str
    detail: str
    evidence: Dict[str, Any] = field(default_factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)


@dataclass
class AuditResult:
    """Outcome of auditing one recorded series."""

    subject: str
    n_samples: int
    verdicts: List[str]
    findings: List[Finding]
    stats: Dict[str, Any] = field(default_factory=dict)

    @property
    def ok(self) -> bool:
        return self.verdicts == [PASS]

    def to_dict(self) -> Dict[str, Any]:
        d = asdict(self)
        d["ok"] = self.ok
        return d


# --------------------------------------------------------------------------
# Level 1 — behavioural discriminability
# --------------------------------------------------------------------------

@dataclass
class ProbePair:
    """Two inputs that are known to differ, plus which dimension they differ in.
    `dimension` is the part that makes this a test rather than a gesture. An
    instrument that separates inputs differing in *quantity* (long text vs
    short text) has shown nothing about whether it measures *content*. Only
    separation along the dimension the instrument claims to measure counts.
    """

    name: str
    left: Any
    right: Any
    dimension: str = "general"
    note: str = ""


def discriminate(
    fn: Callable[[Any], Any],
    pairs: Sequence[ProbePair],
    subject: str = "<callable>",
    tolerance: float = 0.0,
    claimed_dimensions: Optional[Sequence[str]] = None,
) -> AuditResult:
    """Run `fn` over each probe pair and count how many it separates.
    A pair is *separated* when the two outputs differ by more than `tolerance`.
    The verdict is per claimed dimension. If `claimed_dimensions` is given, the
    callable must separate at least one pair within **each** named dimension.
    A callable that collapses every pair inside a dimension it claims to
    measure is reported as IDENTITY for that dimension, even if it separates
    pairs in some other dimension (that is the classic shape: quantity moves,
    content does not).
    """
    rows = []
    by_dim: Dict[str, List[bool]] = {}
    separated = 0
    for p in pairs:
        try:
            lv = fn(p.left)
        except Exception as exc:  # a crash is information, not a pass
            lv = f"<raised {type(exc).__name__}: {exc}>"
        try:
            rv = fn(p.right)
        except Exception as exc:
            rv = f"<raised {type(exc).__name__}: {exc}>"
        differs = _differs(lv, rv, tolerance)
        separated += 1 if differs else 0
        by_dim.setdefault(p.dimension, []).append(differs)
        rows.append(
            {
                "pair": p.name,
                "dimension": p.dimension,
                "left": lv,
                "right": rv,
                "separated": differs,
                "note": p.note,
            }
        )

    dims = list(claimed_dimensions) if claimed_dimensions else list(by_dim)
    dead_dims = [d for d in dims if by_dim.get(d) and not any(by_dim[d])]

    verdicts: List[str] = []
    findings: List[Finding] = []
    if dead_dims:
        verdicts.append(IDENTITY)
        findings.append(
            Finding(
                verdict=IDENTITY,
                subject=subject,
                detail=(
                    f"0/{len(by_dim[dead_dims[0]])} probe pairs separated within the "
                    f"claimed dimension {dead_dims[0]!r}"
                    + (f" (also dead: {', '.join(dead_dims[1:])})" if len(dead_dims) > 1 else "")
                    + ". The instrument responds to something other than what it claims "
                    "to measure."
                ),
                evidence={"dead_dimensions": dead_dims, "pairs": rows},
            )
        )
    elif separated == 0 and pairs:
        verdicts.append(IDENTITY)
        findings.append(
            Finding(
                verdict=IDENTITY,
                subject=subject,
                detail=f"0/{len(pairs)} known-different probe pairs were separated.",
                evidence={"pairs": rows},
            )
        )
    else:
        verdicts.append(PASS)

    return AuditResult(
        subject=subject,
        n_samples=len(pairs),
        verdicts=verdicts,
        findings=findings,
        stats={
            "pairs_separated": separated,
            "pairs_total": len(pairs),
            "separated_by_dimension": {d: sum(v) for d, v in by_dim.items()},
            "pairs": rows,
        },
    )


def _differs(a: Any, b: Any, tolerance: float) -> bool:
    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
        if math.isnan(float(a)) and math.isnan(float(b)):
            return False
        return abs(float(a) - float(b)) > tolerance
    return a != b


# --------------------------------------------------------------------------
# Level 2 — historical ledger audit
# --------------------------------------------------------------------------

def audit_ledger(
    records: Iterable[Dict[str, Any]],
    field: str = "value",
    subject: Optional[str] = None,
    count_field: Optional[str] = None,
    fresh_field: Optional[str] = None,
) -> AuditResult:
    """Audit an already-recorded series for known failure signatures.
    Parameters
    ----------
    records:
        Iterable of dicts, one per sample, as written by the instrument.
    field:
        Key holding the reported value.
    subject:
        Label for the report.
    count_field:
        Optional key holding the number of items examined for this sample
        (e.g. `sampled`, `n`, `attempts`). Enables BARE_ZERO detection.
    fresh_field:
        Optional key holding a boolean flag thought to be an input
        (e.g. `fresh`). Enables LIVENESS_BIT attribution.
    Returns
    -------
    AuditResult with every signature found, not just the first. Instruments
    tend to be wrong in more than one way at once.
    """
    rows = [r for r in records if isinstance(r, dict) and field in r]
    subject = subject or field
    n = len(rows)
    if n == 0:
        return AuditResult(
            subject=subject,
            n_samples=0,
            verdicts=[NO_DATA],
            findings=[
                Finding(
                    verdict=NO_DATA,
                    subject=subject,
                    detail=(
                        f"0 samples matched the requested field {field!r}. An audit with "
                        "no data has not passed; it has not happened. Reporting this as "
                        "OK would reproduce the failure the audit exists to catch."
                    ),
                    evidence={"field": field},
                )
            ],
            stats={"note": "empty ledger; nothing to audit", "distinct_values": 0},
        )

    values = [r.get(field) for r in rows]
    verdicts: List[str] = []
    findings: List[Finding] = []
    stats: Dict[str, Any] = {"n_samples": n}

    # --- CONSTANT -------------------------------------------------------
    distinct = _distinct(values)
    stats["distinct_values"] = distinct
    stats["value_counts"] = _value_counts(values)
    if distinct == 1:
        verdicts.append(CONSTANT)
        findings.append(
            Finding(
                verdict=CONSTANT,
                subject=subject,
                detail=(
                    f"{n}/{n} samples report the identical value {values[0]!r}. "
                    "Zero variance over the observed window."
                ),
                evidence={"value": values[0], "n": n},
            )
        )

    # --- BARE_ZERO ------------------------------------------------------
    if count_field:
        counts = [r.get(count_field) for r in rows]
        zero_val = _modal_zero_value(values)
        if zero_val is not None:
            bare = [
                i
                for i, (v, c) in enumerate(zip(values, counts))
                if c == 0 and v == zero_val
            ]
            nonzero = [i for i, c in enumerate(counts) if c not in (0, None)]
            if bare and nonzero:
                same = all(values[i] == values[j] for i in bare for j in nonzero
                           if values[j] == zero_val)
                all_bare_same = len({values[i] for i in bare}) == 1
                if same and all_bare_same:
                    verdicts.append(BARE_ZERO)
                    findings.append(
                        Finding(
                            verdict=BARE_ZERO,
                            subject=subject,
                            detail=(
                                f"{len(bare)} of {n} samples examined nothing "
                                f"({count_field}=0) yet reported {zero_val!r} — the same "
                                f"value produced by samples that examined {min(counts[i] for i in nonzero)}+ "
                                "items and matched none. The zero is ambiguous: a consumer "
                                "cannot distinguish 'not examined' from 'examined, no hits'."
                            ),
                            evidence={
                                "zero_count_rows": len(bare),
                                "zero_count_value": zero_val,
                                "min_examined": min(counts[i] for i in nonzero),
                            },
                        )
                    )

    # --- LIVENESS_BIT ---------------------------------------------------
    if fresh_field and distinct > 1:
        attrib = _variance_attribution(rows, field, fresh_field)
        stats["variance_explained_by"] = {fresh_field: attrib}
        if attrib is not None and attrib >= 0.999:
            verdicts.append(LIVENESS_BIT)
            findings.append(
                Finding(
                    verdict=LIVENESS_BIT,
                    subject=subject,
                    detail=(
                        f"100% of the variance in {field!r} is accounted for by the "
                        f"boolean {fresh_field!r} alone. Every other input is constant "
                        "across the ledger, so the score is a liveness indicator, not a "
                        "measurement of the property in its name."
                    ),
                    evidence={"attribution": attrib, "n": n},
                )
            )

    if not verdicts:
        verdicts.append(PASS)

    return AuditResult(
        subject=subject,
        n_samples=n,
        verdicts=verdicts,
        findings=findings,
        stats=stats,
    )


# --------------------------------------------------------------------------
# Level 3 — gate audit (never-fired assertions)
# --------------------------------------------------------------------------

def audit_gate(
    events: Iterable[Dict[str, Any]],
    event_field: str = "event",
    fire_event: str = "block_issued",
    subject: str = "<gate>",
) -> AuditResult:
    """Check whether an assertion has ever actually fired, from raw events.
    An assertion that has recorded itself as healthy N times and has never
    once fired on an input known to be positive is not a defence. The count of
    self-reported health is not evidence; the count of firings is.
    Callers are expected to pair this with a positive control (see
    `docs/METHOD.md`): the firing count only becomes meaningful once someone
    has shown the gate fires *when it should*.
    For aggregated logs, use `audit_gate_counts` instead.
    """
    total = 0
    fired = 0
    registered = 0
    for e in events:
        if not isinstance(e, dict):
            continue
        total += 1
        ev = e.get(event_field)
        if ev == fire_event:
            fired += 1
        if ev in ("registered", "self_change", "logged"):
            registered += 1
    return audit_gate_counts(
        total_events=total,
        firings=fired,
        health_events=registered,
        subject=subject,
    )


def looks_like_daily_aggregate(rows: Sequence[Any]) -> bool:
    """True if these rows count days rather than events.
    The two are easy to confuse and the confusion is silent: reading daily rows
    as event rows turns a sixteen-day window into "16 samples", which is a
    confident number that means nothing. The published dataset in this
    repository is daily, so a tool that cannot read its own published data has a
    defect any reader would hit in the first minute.
    """
    if not rows:
        return False
    first = rows[0]
    if not isinstance(first, dict):
        return False
    return (
        "date" in first
        and "events" in first
        and "firings" in first
        and "event" not in first
    )


def audit_gate_daily(
    rows: Sequence[Dict[str, Any]],
    fire_event: str = "block_issued",
    subject: str = "<gate>",
    health_event: str = "self_change",
) -> Tuple[AuditResult, AuditResult]:
    """Audit a per-day aggregate log, in both windows that matter.
    Returns ``(before_first_fire, whole_window)``.
    The first is the interesting one and the second is the control. Both are
    the same guard: the first covers only the whole days that ended with zero
    firings and before any firing happened, the second covers everything. The
    same code reads DEAD_GATE for the first and PASS for the second, which is
    the point — what changed between them is not the guard but whether anyone
    had ever built it an input it had to reject.
    Whole days rather than timestamps, deliberately. A count of "events before
    the first firing" needs event-level rows to recompute, and only aggregates
    are published here, so that number would be checkable by nobody. Day
    granularity costs one day of precision and buys the reader a for-loop.
    """
    days = [r for r in rows if isinstance(r, dict)]
    if not days:
        raise ValueError("no daily rows to audit")

    # The window that ends before any firing happened at all. Only whole days:
    # the day of the first firing is partly silent and is excluded.
    leading = []
    for row in days:
        if row.get("firings", 0) > 0:
            break
        leading.append(row)

    def _totals(window: Sequence[Dict[str, Any]]):
        events = sum(int(r.get("events", 0)) for r in window)
        firings = sum(int(r.get("firings", 0)) for r in window)
        health = sum(int((r.get("by_event") or {}).get(health_event, 0)) for r in window)
        return events, firings, health

    lead_events, _, lead_health = _totals(leading)
    all_events, all_firings, all_health = _totals(days)

    n_leading = len(leading)
    before = audit_gate_counts(
        total_events=lead_events,
        firings=0,
        health_events=lead_health,
        subject=f"{subject} — {n_leading} full days with zero firings",
        window=[leading[0]["date"], leading[-1]["date"]] if leading else None,
        silent_days_before_first_fire=n_leading or None,
        note=(
            f"Window: {leading[0]['date']} to {leading[-1]['date']}, whole days only."
            if leading
            else ""
        ),
    )
    whole = audit_gate_counts(
        total_events=all_events,
        firings=all_firings,
        health_events=all_health,
        subject=f"{subject} — full window ({len(days)} days)",
        note=(
            f"The path fired {all_firings} times, the first on "
            f"{next((r['date'] for r in days if r.get('firings', 0) > 0), 'n/a')}. "
            "That first firing came from a positive control written specifically "
            "to exercise the path, not from ordinary traffic."
        ),
    )
    return before, whole


def audit_gate_counts(
    total_events: int,
    firings: int,
    health_events: int = 0,
    subject: str = "<gate>",
    first_fire: Optional[str] = None,
    window: Optional[Sequence[str]] = None,
    silent_days_before_first_fire: Optional[int] = None,
    note: str = "",
) -> AuditResult:
    """The aggregate form of `audit_gate`.
    Takes counts rather than events so that a guard log can be audited without
    the log itself being published — the counts support the claim, the raw
    lines carry whatever the operator's environment contained.
    A window with zero firings is reported DEAD_GATE regardless of how many
    times the guard recorded itself healthy. Health is self-reported; firing is
    observed.
    """
    verdicts: List[str] = []
    findings: List[Finding] = []

    if firings == 0 and total_events > 0:
        verdicts.append(DEAD_GATE)
        span = ""
        if silent_days_before_first_fire:
            span = f" across {silent_days_before_first_fire} days"
        elif window and all(window):
            span = f" between {window[0]} and {window[1]}"
        findings.append(
            Finding(
                verdict=DEAD_GATE,
                subject=subject,
                detail=(
                    f"{total_events:,} events recorded{span}, of which "
                    f"{health_events:,} were the guard reporting itself healthy, and the "
                    f"denial path fired 0 times. The assertion has never been observed "
                    "to fire. Its existence is documented; its behaviour is not."
                ),
                evidence={
                    "total_events": total_events,
                    "health_events": health_events,
                    "firings": 0,
                    "note": note,
                },
            )
        )
    else:
        verdicts.append(PASS)
        if note:
            findings.append(
                Finding(
                    verdict=PASS,
                    subject=subject,
                    detail=note,
                    evidence={"total_events": total_events, "firings": firings},
                )
            )

    return AuditResult(
        subject=subject,
        n_samples=total_events,
        verdicts=verdicts,
        findings=findings,
        stats={
            "total_events": total_events,
            "health_events": health_events,
            "firings": firings,
            "first_fire": first_fire,
            "silent_days_before_first_fire": silent_days_before_first_fire,
        },
    )


# --------------------------------------------------------------------------
# helpers
# --------------------------------------------------------------------------

def _distinct(values: Sequence[Any]) -> int:
    seen = []
    for v in values:
        if not any(v == s for s in seen):
            seen.append(v)
    return len(seen)


def _value_counts(values: Sequence[Any]) -> Dict[str, int]:
    out: Dict[str, int] = {}
    for v in values:
        out[str(v)] = out.get(str(v), 0) + 1
    return out


def _modal_zero_value(values: Sequence[Any]) -> Optional[float]:
    """The numeric value the series reports when nothing matched, if any."""
    for v in values:
        if isinstance(v, (int, float)) and float(v) == 0.0:
            return v
    return None


def _variance_attribution(
    rows: List[Dict[str, Any]], field: str, bool_field: str
) -> Optional[float]:
    """Fraction of variance in `field` explained by the boolean `bool_field`.
    Computed as the between-group variance ratio (eta-squared) for a two-level
    grouping. Returns None when the field is not numeric.
    """
    vals = []
    for r in rows:
        v = r.get(field)
        if isinstance(v, (int, float)) and not math.isnan(float(v)):
            vals.append((float(v), bool(r.get(bool_field))))
    if len(vals) < 2:
        return None
    ys = [v for v, _ in vals]
    mean = sum(ys) / len(ys)
    total = sum((y - mean) ** 2 for y in ys)
    if total == 0:
        return 0.0
    groups: Dict[bool, List[float]] = {}
    for v, b in vals:
        groups.setdefault(b, []).append(v)
    between = 0.0
    for b, g in groups.items():
        gm = sum(g) / len(g)
        between += len(g) * (gm - mean) ** 2
    return between / total


def load_jsonl(path: str) -> List[Dict[str, Any]]:
    """Read a JSON-lines file, skipping blanks and unparseable lines."""
    out = []
    with open(path, "r", encoding="utf-8", errors="replace") as fh:
        for line in fh:
            line = line.strip()
            if not line:
                continue
            try:
                obj = json.loads(line)
            except json.JSONDecodeError:
                continue
            if isinstance(obj, dict):
                out.append(obj)
    return out


def get_path(record: Dict[str, Any], dotted: str) -> Any:
    """Fetch `a.b.c` out of a nested dict, returning None if absent."""
    cur: Any = record
    for part in dotted.split("."):
        if not isinstance(cur, dict) or part not in cur:
            return None
        cur = cur[part]
    return cur

	"""
	greencheck.core — the discriminability test.

	Central claim of this package:

	A reported number is not a measurement until it has been observed to
	take different values on inputs that are known to differ.

	Everything else here is machinery for making that claim checkable.

	Two levels of testing are provided, and they answer different questions:

	1. `discriminate()` — behavioural. You hand it a callable and a set of
	probe pairs that are known to differ. It reports how many pairs the
	callable actually separates. A callable that collapses every pair is
	not measuring the thing its name implies.

	2. `audit_ledger()` — historical. You hand it a ledger of already-collected
	samples (what an instrument wrote to disk in production). It reports which
	of the known failure signatures are present without re-running anything.
	This is the level at which silent instrumentation dies: the callable may be
	fine while the recorded series is a constant, a bare zero, or a single bit
	wearing a score's clothing.

	Neither level requires trust in the instrument's own self-report. That is the
	point: the instrument is the thing under test, so its opinion of itself is not
	admissible evidence.
	"""

	from __future__ import annotations

	import json
	import math
	import os
	from dataclasses import dataclass, field, asdict
	from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple


	# --------------------------------------------------------------------------
	# Verdicts
	# --------------------------------------------------------------------------

	#: The probe callable separated known-different inputs. No signature found.
	PASS = "PASS"

	#: Zero variance across every sample. The series cannot be distinguished from
	#: a constant by any downstream consumer.
	CONSTANT = "CONSTANT"

	#: The callable returns the same value for a real input and for a degenerate
	#: input (empty / missing / contradictory). It is therefore measuring whether
	#: the input exists, not the property it claims to measure.
	IDENTITY = "IDENTITY"

	#: `n = 0` and `n > 0 with zero hits` produce the same output. The zero is
	#: ambiguous, so a consumer cannot tell "nothing was examined" from
	#: "everything was examined and nothing matched".
	BARE_ZERO = "BARE_ZERO"

	#: All variance in the delivered score traces to a single boolean input.
	#: The score is a liveness indicator in a score's clothing.
	LIVENESS_BIT = "LIVENESS_BIT"

	#: A guard/assertion exists, records itself as healthy, and has never been
	#: observed to fire on an input that is known to be positive. Not a defence;
	#: an ornament.
	DEAD_GATE = "DEAD_GATE"

	#: Nothing was audited. An empty ledger is not a passing ledger: an audit with
	#: no data has not succeeded, it has not happened. Reported explicitly because
	#: the default of returning PASS here would reproduce the exact failure this
	#: package exists to catch.
	NO_DATA = "NO_DATA"

	ALL_VERDICTS = (PASS, CONSTANT, IDENTITY, BARE_ZERO, LIVENESS_BIT, DEAD_GATE, NO_DATA)


	@dataclass
	class Finding:
	"""One detected signature, with the evidence that produced it."""

	verdict: str
	subject: str
	detail: str
	evidence: Dict[str, Any] = field(default_factory=dict)

	def to_dict(self) -> Dict[str, Any]:
	return asdict(self)


	@dataclass
	class AuditResult:
	"""Outcome of auditing one recorded series."""

	subject: str
	n_samples: int
	verdicts: List[str]
	findings: List[Finding]
	stats: Dict[str, Any] = field(default_factory=dict)

	@property
	def ok(self) -> bool:
	return self.verdicts == [PASS]

	def to_dict(self) -> Dict[str, Any]:
	d = asdict(self)
	d["ok"] = self.ok
	return d


	# --------------------------------------------------------------------------
	# Level 1 — behavioural discriminability
	# --------------------------------------------------------------------------

	@dataclass
	class ProbePair:
	"""Two inputs that are known to differ, plus which dimension they differ in.

	`dimension` is the part that makes this a test rather than a gesture. An
	instrument that separates inputs differing in quantity (long text vs
	short text) has shown nothing about whether it measures content. Only
	separation along the dimension the instrument claims to measure counts.
	"""

	name: str
	left: Any
	right: Any
	dimension: str = "general"
	note: str = ""


	def discriminate(
	fn: Callable[[Any], Any],
	pairs: Sequence[ProbePair],
	subject: str = "<callable>",
	tolerance: float = 0.0,
	claimed_dimensions: Optional[Sequence[str]] = None,
	) -> AuditResult:
	"""Run `fn` over each probe pair and count how many it separates.

	A pair is separated when the two outputs differ by more than `tolerance`.

	The verdict is per claimed dimension. If `claimed_dimensions` is given, the
	callable must separate at least one pair within each named dimension.
	A callable that collapses every pair inside a dimension it claims to
	measure is reported as IDENTITY for that dimension, even if it separates
	pairs in some other dimension (that is the classic shape: quantity moves,
	content does not).
	"""
	rows = []
	by_dim: Dict[str, List[bool]] = {}
	separated = 0
	for p in pairs:
	try:
	lv = fn(p.left)
	except Exception as exc: # a crash is information, not a pass
	lv = f"<raised {type(exc).__name__}: {exc}>"
	try:
	rv = fn(p.right)
	except Exception as exc:
	rv = f"<raised {type(exc).__name__}: {exc}>"
	differs = _differs(lv, rv, tolerance)
	separated += 1 if differs else 0
	by_dim.setdefault(p.dimension, []).append(differs)
	rows.append(
	{
	"pair": p.name,
	"dimension": p.dimension,
	"left": lv,
	"right": rv,
	"separated": differs,
	"note": p.note,
	}
	)

	dims = list(claimed_dimensions) if claimed_dimensions else list(by_dim)
	dead_dims = [d for d in dims if by_dim.get(d) and not any(by_dim[d])]

	verdicts: List[str] = []
	findings: List[Finding] = []
	if dead_dims:
	verdicts.append(IDENTITY)
	findings.append(
	Finding(
	verdict=IDENTITY,
	subject=subject,
	detail=(
	f"0/{len(by_dim[dead_dims[0]])} probe pairs separated within the "
	f"claimed dimension {dead_dims[0]!r}"
	+ (f" (also dead: {', '.join(dead_dims[1:])})" if len(dead_dims) > 1 else "")
	+ ". The instrument responds to something other than what it claims "
	"to measure."
	),
	evidence={"dead_dimensions": dead_dims, "pairs": rows},
	)
	)
	elif separated == 0 and pairs:
	verdicts.append(IDENTITY)
	findings.append(
	Finding(
	verdict=IDENTITY,
	subject=subject,
	detail=f"0/{len(pairs)} known-different probe pairs were separated.",
	evidence={"pairs": rows},
	)
	)
	else:
	verdicts.append(PASS)

	return AuditResult(
	subject=subject,
	n_samples=len(pairs),
	verdicts=verdicts,
	findings=findings,
	stats={
	"pairs_separated": separated,
	"pairs_total": len(pairs),
	"separated_by_dimension": {d: sum(v) for d, v in by_dim.items()},
	"pairs": rows,
	},
	)


	def _differs(a: Any, b: Any, tolerance: float) -> bool:
	if isinstance(a, (int, float)) and isinstance(b, (int, float)):
	if math.isnan(float(a)) and math.isnan(float(b)):
	return False
	return abs(float(a) - float(b)) > tolerance
	return a != b


	# --------------------------------------------------------------------------
	# Level 2 — historical ledger audit
	# --------------------------------------------------------------------------

	def audit_ledger(
	records: Iterable[Dict[str, Any]],
	field: str = "value",
	subject: Optional[str] = None,
	count_field: Optional[str] = None,
	fresh_field: Optional[str] = None,
	) -> AuditResult:
	"""Audit an already-recorded series for known failure signatures.

	Parameters
	----------
	records:
	Iterable of dicts, one per sample, as written by the instrument.
	field:
	Key holding the reported value.
	subject:
	Label for the report.
	count_field:
	Optional key holding the number of items examined for this sample
	(e.g. `sampled`, `n`, `attempts`). Enables BARE_ZERO detection.
	fresh_field:
	Optional key holding a boolean flag thought to be an input
	(e.g. `fresh`). Enables LIVENESS_BIT attribution.

	Returns
	-------
	AuditResult with every signature found, not just the first. Instruments
	tend to be wrong in more than one way at once.
	"""
	rows = [r for r in records if isinstance(r, dict) and field in r]
	subject = subject or field
	n = len(rows)
	if n == 0:
	return AuditResult(
	subject=subject,
	n_samples=0,
	verdicts=[NO_DATA],
	findings=[
	Finding(
	verdict=NO_DATA,
	subject=subject,
	detail=(
	f"0 samples matched the requested field {field!r}. An audit with "
	"no data has not passed; it has not happened. Reporting this as "
	"OK would reproduce the failure the audit exists to catch."
	),
	evidence={"field": field},
	)
	],
	stats={"note": "empty ledger; nothing to audit", "distinct_values": 0},
	)

	values = [r.get(field) for r in rows]
	verdicts: List[str] = []
	findings: List[Finding] = []
	stats: Dict[str, Any] = {"n_samples": n}

	# --- CONSTANT -------------------------------------------------------
	distinct = _distinct(values)
	stats["distinct_values"] = distinct
	stats["value_counts"] = _value_counts(values)
	if distinct == 1:
	verdicts.append(CONSTANT)
	findings.append(
	Finding(
	verdict=CONSTANT,
	subject=subject,
	detail=(
	f"{n}/{n} samples report the identical value {values[0]!r}. "
	"Zero variance over the observed window."
	),
	evidence={"value": values[0], "n": n},
	)
	)

	# --- BARE_ZERO ------------------------------------------------------
	if count_field:
	counts = [r.get(count_field) for r in rows]
	zero_val = _modal_zero_value(values)
	if zero_val is not None:
	bare = [
	i
	for i, (v, c) in enumerate(zip(values, counts))
	if c == 0 and v == zero_val
	]
	nonzero = [i for i, c in enumerate(counts) if c not in (0, None)]
	if bare and nonzero:
	same = all(values[i] == values[j] for i in bare for j in nonzero
	if values[j] == zero_val)
	all_bare_same = len({values[i] for i in bare}) == 1
	if same and all_bare_same:
	verdicts.append(BARE_ZERO)
	findings.append(
	Finding(
	verdict=BARE_ZERO,
	subject=subject,
	detail=(
	f"{len(bare)} of {n} samples examined nothing "
	f"({count_field}=0) yet reported {zero_val!r} — the same "
	f"value produced by samples that examined {min(counts[i] for i in nonzero)}+ "
	"items and matched none. The zero is ambiguous: a consumer "
	"cannot distinguish 'not examined' from 'examined, no hits'."
	),
	evidence={
	"zero_count_rows": len(bare),
	"zero_count_value": zero_val,
	"min_examined": min(counts[i] for i in nonzero),
	},
	)
	)

	# --- LIVENESS_BIT ---------------------------------------------------
	if fresh_field and distinct > 1:
	attrib = _variance_attribution(rows, field, fresh_field)
	stats["variance_explained_by"] = {fresh_field: attrib}
	if attrib is not None and attrib >= 0.999:
	verdicts.append(LIVENESS_BIT)
	findings.append(
	Finding(
	verdict=LIVENESS_BIT,
	subject=subject,
	detail=(
	f"100% of the variance in {field!r} is accounted for by the "
	f"boolean {fresh_field!r} alone. Every other input is constant "
	"across the ledger, so the score is a liveness indicator, not a "
	"measurement of the property in its name."
	),
	evidence={"attribution": attrib, "n": n},
	)
	)

	if not verdicts:
	verdicts.append(PASS)

	return AuditResult(
	subject=subject,
	n_samples=n,
	verdicts=verdicts,
	findings=findings,
	stats=stats,
	)


	# --------------------------------------------------------------------------
	# Level 3 — gate audit (never-fired assertions)
	# --------------------------------------------------------------------------

	def audit_gate(
	events: Iterable[Dict[str, Any]],
	event_field: str = "event",
	fire_event: str = "block_issued",
	subject: str = "<gate>",
	) -> AuditResult:
	"""Check whether an assertion has ever actually fired, from raw events.

	An assertion that has recorded itself as healthy N times and has never
	once fired on an input known to be positive is not a defence. The count of
	self-reported health is not evidence; the count of firings is.

	Callers are expected to pair this with a positive control (see
	`docs/METHOD.md`): the firing count only becomes meaningful once someone
	has shown the gate fires when it should.

	For aggregated logs, use `audit_gate_counts` instead.
	"""
	total = 0
	fired = 0
	registered = 0
	for e in events:
	if not isinstance(e, dict):
	continue
	total += 1
	ev = e.get(event_field)
	if ev == fire_event:
	fired += 1
	if ev in ("registered", "self_change", "logged"):
	registered += 1
	return audit_gate_counts(
	total_events=total,
	firings=fired,
	health_events=registered,
	subject=subject,
	)


	def looks_like_daily_aggregate(rows: Sequence[Any]) -> bool:
	"""True if these rows count days rather than events.

	The two are easy to confuse and the confusion is silent: reading daily rows
	as event rows turns a sixteen-day window into "16 samples", which is a
	confident number that means nothing. The published dataset in this
	repository is daily, so a tool that cannot read its own published data has a
	defect any reader would hit in the first minute.
	"""
	if not rows:
	return False
	first = rows[0]
	if not isinstance(first, dict):
	return False
	return (
	"date" in first
	and "events" in first
	and "firings" in first
	and "event" not in first
	)


	def audit_gate_daily(
	rows: Sequence[Dict[str, Any]],
	fire_event: str = "block_issued",
	subject: str = "<gate>",
	health_event: str = "self_change",
	) -> Tuple[AuditResult, AuditResult]:
	"""Audit a per-day aggregate log, in both windows that matter.

	Returns ``(before_first_fire, whole_window)``.

	The first is the interesting one and the second is the control. Both are
	the same guard: the first covers only the whole days that ended with zero
	firings and before any firing happened, the second covers everything. The
	same code reads DEAD_GATE for the first and PASS for the second, which is
	the point — what changed between them is not the guard but whether anyone
	had ever built it an input it had to reject.

	Whole days rather than timestamps, deliberately. A count of "events before
	the first firing" needs event-level rows to recompute, and only aggregates
	are published here, so that number would be checkable by nobody. Day
	granularity costs one day of precision and buys the reader a for-loop.
	"""
	days = [r for r in rows if isinstance(r, dict)]
	if not days:
	raise ValueError("no daily rows to audit")

	# The window that ends before any firing happened at all. Only whole days:
	# the day of the first firing is partly silent and is excluded.
	leading = []
	for row in days:
	if row.get("firings", 0) > 0:
	break
	leading.append(row)

	def _totals(window: Sequence[Dict[str, Any]]):
	events = sum(int(r.get("events", 0)) for r in window)
	firings = sum(int(r.get("firings", 0)) for r in window)
	health = sum(int((r.get("by_event") or {}).get(health_event, 0)) for r in window)
	return events, firings, health

	lead_events, _, lead_health = _totals(leading)
	all_events, all_firings, all_health = _totals(days)

	n_leading = len(leading)
	before = audit_gate_counts(
	total_events=lead_events,
	firings=0,
	health_events=lead_health,
	subject=f"{subject} — {n_leading} full days with zero firings",
	window=[leading[0]["date"], leading[-1]["date"]] if leading else None,
	silent_days_before_first_fire=n_leading or None,
	note=(
	f"Window: {leading[0]['date']} to {leading[-1]['date']}, whole days only."
	if leading
	else ""
	),
	)
	whole = audit_gate_counts(
	total_events=all_events,
	firings=all_firings,
	health_events=all_health,
	subject=f"{subject} — full window ({len(days)} days)",
	note=(
	f"The path fired {all_firings} times, the first on "
	f"{next((r['date'] for r in days if r.get('firings', 0) > 0), 'n/a')}. "
	"That first firing came from a positive control written specifically "
	"to exercise the path, not from ordinary traffic."
	),
	)
	return before, whole


	def audit_gate_counts(
	total_events: int,
	firings: int,
	health_events: int = 0,
	subject: str = "<gate>",
	first_fire: Optional[str] = None,
	window: Optional[Sequence[str]] = None,
	silent_days_before_first_fire: Optional[int] = None,
	note: str = "",
	) -> AuditResult:
	"""The aggregate form of `audit_gate`.

	Takes counts rather than events so that a guard log can be audited without
	the log itself being published — the counts support the claim, the raw
	lines carry whatever the operator's environment contained.

	A window with zero firings is reported DEAD_GATE regardless of how many
	times the guard recorded itself healthy. Health is self-reported; firing is
	observed.
	"""
	verdicts: List[str] = []
	findings: List[Finding] = []

	if firings == 0 and total_events > 0:
	verdicts.append(DEAD_GATE)
	span = ""
	if silent_days_before_first_fire:
	span = f" across {silent_days_before_first_fire} days"
	elif window and all(window):
	span = f" between {window[0]} and {window[1]}"
	findings.append(
	Finding(
	verdict=DEAD_GATE,
	subject=subject,
	detail=(
	f"{total_events:,} events recorded{span}, of which "
	f"{health_events:,} were the guard reporting itself healthy, and the "
	f"denial path fired 0 times. The assertion has never been observed "
	"to fire. Its existence is documented; its behaviour is not."
	),
	evidence={
	"total_events": total_events,
	"health_events": health_events,
	"firings": 0,
	"note": note,
	},
	)
	)
	else:
	verdicts.append(PASS)
	if note:
	findings.append(
	Finding(
	verdict=PASS,
	subject=subject,
	detail=note,
	evidence={"total_events": total_events, "firings": firings},
	)
	)

	return AuditResult(
	subject=subject,
	n_samples=total_events,
	verdicts=verdicts,
	findings=findings,
	stats={
	"total_events": total_events,
	"health_events": health_events,
	"firings": firings,
	"first_fire": first_fire,
	"silent_days_before_first_fire": silent_days_before_first_fire,
	},
	)


	# --------------------------------------------------------------------------
	# helpers
	# --------------------------------------------------------------------------

	def _distinct(values: Sequence[Any]) -> int:
	seen = []
	for v in values:
	if not any(v == s for s in seen):
	seen.append(v)
	return len(seen)


	def _value_counts(values: Sequence[Any]) -> Dict[str, int]:
	out: Dict[str, int] = {}
	for v in values:
	out[str(v)] = out.get(str(v), 0) + 1
	return out


	def _modal_zero_value(values: Sequence[Any]) -> Optional[float]:
	"""The numeric value the series reports when nothing matched, if any."""
	for v in values:
	if isinstance(v, (int, float)) and float(v) == 0.0:
	return v
	return None


	def _variance_attribution(
	rows: List[Dict[str, Any]], field: str, bool_field: str
	) -> Optional[float]:
	"""Fraction of variance in `field` explained by the boolean `bool_field`.

	Computed as the between-group variance ratio (eta-squared) for a two-level
	grouping. Returns None when the field is not numeric.
	"""
	vals = []
	for r in rows:
	v = r.get(field)
	if isinstance(v, (int, float)) and not math.isnan(float(v)):
	vals.append((float(v), bool(r.get(bool_field))))
	if len(vals) < 2:
	return None
	ys = [v for v, _ in vals]
	mean = sum(ys) / len(ys)
	total = sum((y - mean) ** 2 for y in ys)
	if total == 0:
	return 0.0
	groups: Dict[bool, List[float]] = {}
	for v, b in vals:
	groups.setdefault(b, []).append(v)
	between = 0.0
	for b, g in groups.items():
	gm = sum(g) / len(g)
	between += len(g) * (gm - mean) ** 2
	return between / total


	def load_jsonl(path: str) -> List[Dict[str, Any]]:
	"""Read a JSON-lines file, skipping blanks and unparseable lines."""
	out = []
	with open(path, "r", encoding="utf-8", errors="replace") as fh:
	for line in fh:
	line = line.strip()
	if not line:
	continue
	try:
	obj = json.loads(line)
	except json.JSONDecodeError:
	continue
	if isinstance(obj, dict):
	out.append(obj)
	return out


	def get_path(record: Dict[str, Any], dotted: str) -> Any:
	"""Fetch `a.b.c` out of a nested dict, returning None if absent."""
	cur: Any = record
	for part in dotted.split("."):
	if not isinstance(cur, dict) or part not in cur:
	return None
	cur = cur[part]
	return cur