| """Measuring how much a check actually constrains -- mutation testing for agent claims. |
| |
| A verification reward is worth exactly what its checks are worth, and the first dry run |
| showed why that cannot be assumed: the model wrote ``test -f data.fasta && echo True``, |
| which passes for every analysis anyone could ever run on that file. Counting it toward |
| `rho` rewards writing vacuous checks. This is the same failure that makes a green test |
| suite meaningless when no mutation breaks it, so it takes the same remedy. |
| |
| **Definition.** A check has strength 1 if it passes on the real artifact and fails on |
| every corrupted version of it, and strength 0 if it cannot tell them apart. Both halves |
| are required: a check that fails on the original is broken, not strong, and is reported |
| with strength 0 and ``valid=False`` so it is never mistaken for a sensitive one. |
| |
| Perturbations are deliberately *semantic* violations of the kinds of invariant these |
| analyses rest on -- rows silently dropped, a column shuffled out of correspondence, |
| values rescaled, a file truncated mid-write. Each is a real pipeline bug, not noise. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import random |
| import shutil |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Callable, Sequence |
|
|
| from .protocol import CheckSpec, verdict_from_output |
|
|
|
|
| @dataclass(frozen=True) |
| class Strength: |
| """How much one check constrains its artifact. |
| |
| Attributes: |
| name: The check's name. |
| valid: Whether the check passed on the unmodified artifact. A check that fails |
| there is broken; its `score` is meaningless and is reported as 0. |
| score: Fraction of perturbations the check detected, in [0, 1]. |
| detected: Names of the perturbations it caught. |
| missed: Names of the perturbations it did not. |
| """ |
|
|
| name: str |
| valid: bool |
| score: float |
| detected: tuple[str, ...] = () |
| missed: tuple[str, ...] = () |
|
|
| @property |
| def vacuous(self) -> bool: |
| """True if the check cannot distinguish a real artifact from a corrupted one.""" |
| return self.valid and self.score == 0.0 |
|
|
|
|
| def drop_rows(text: str, rng: random.Random, frac: float = 0.1) -> str: |
| """Silently delete a fraction of lines -- the classic filter-loses-rows bug.""" |
| lines = text.splitlines(keepends=True) |
| if len(lines) < 2: |
| return text |
| keep = max(1, int(len(lines) * (1 - frac))) |
| idx = sorted(rng.sample(range(len(lines)), keep)) |
| return "".join(lines[i] for i in idx) |
|
|
|
|
| def shuffle_column(text: str, rng: random.Random, sep: str = "\t") -> str: |
| """Permute one column, breaking row correspondence while preserving every marginal. |
| |
| The nastiest class of bug in these pipelines: totals, counts and distributions all |
| still check out, but the rows no longer line up. |
| """ |
| lines = text.splitlines() |
| rows = [l.split(sep) for l in lines] |
| width = min((len(r) for r in rows if len(r) > 1), default=0) |
| if width < 2 or len(rows) < 3: |
| return text |
| col = rng.randrange(width) |
| body = rows[1:] |
| values = [r[col] for r in body if len(r) > col] |
| rng.shuffle(values) |
| it = iter(values) |
| for r in body: |
| if len(r) > col: |
| r[col] = next(it) |
| return "\n".join(sep.join(r) for r in [rows[0]] + body) + "\n" |
|
|
|
|
| def scale_numbers(text: str, rng: random.Random, factor: float = 1.1) -> str: |
| """Rescale every number by a constant -- a units or normalisation error.""" |
| import re |
|
|
| def rep(m): |
| try: |
| return f"{float(m.group(0)) * factor:g}" |
| except ValueError: |
| return m.group(0) |
|
|
| return re.sub(r"(?<![\w.])\d+\.\d+(?![\w.])", rep, text) |
|
|
|
|
| def truncate(text: str, rng: random.Random, frac: float = 0.5) -> str: |
| """Cut the artifact short -- an interrupted write or a partial download.""" |
| return text[: max(1, int(len(text) * frac))] |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
|
|
| _COMPLEMENT = str.maketrans("ACGTNacgtn", "TGCANtgcan") |
|
|
|
|
| def _split_fasta(text: str) -> tuple[list[str], list[str]]: |
| """Separate a FASTA into its header lines and its sequence lines.""" |
| headers, seqs = [], [] |
| for line in text.splitlines(): |
| (headers if line.startswith(">") else seqs).append(line) |
| return headers, seqs |
|
|
|
|
| def _rebuild(header: str, seq: str, width: int = 70) -> str: |
| """Reassemble one record with the usual line wrapping.""" |
| lines = [seq[i:i + width] for i in range(0, len(seq), width)] or [""] |
| return header + "\n" + "\n".join(lines) + "\n" |
|
|
|
|
| def mutate_bases(text: str, rng: random.Random, frac: float = 0.05) -> str: |
| """Substitute a fraction of bases -- defeats claims about exact sequence content.""" |
| headers, seqs = _split_fasta(text) |
| if not headers: |
| return text |
| seq = list("".join(seqs)) |
| if not seq: |
| return text |
| for i in rng.sample(range(len(seq)), max(1, int(len(seq) * frac))): |
| seq[i] = rng.choice([b for b in "ACGT" if b != seq[i].upper()]) |
| return _rebuild(headers[0], "".join(seq)) |
|
|
|
|
| def reverse_complement(text: str, rng: random.Random) -> str: |
| """Reverse-complement the sequence -- preserves GC exactly, destroys every motif. |
| |
| The sharpest test of a composition-only check: length, GC content and base counts are |
| all unchanged, so anything that still passes is not looking at the sequence itself. |
| """ |
| headers, seqs = _split_fasta(text) |
| if not headers: |
| return text |
| seq = "".join(seqs).translate(_COMPLEMENT)[::-1] |
| return _rebuild(headers[0], seq) |
|
|
|
|
| def shuffle_sequence(text: str, rng: random.Random) -> str: |
| """Permute the bases -- preserves composition and length, destroys all structure.""" |
| headers, seqs = _split_fasta(text) |
| if not headers: |
| return text |
| seq = list("".join(seqs)) |
| rng.shuffle(seq) |
| return _rebuild(headers[0], "".join(seq)) |
|
|
|
|
| def splice_foreign(text: str, rng: random.Random, frac: float = 0.2) -> str: |
| """Replace a contiguous block with foreign sequence -- models a contaminated assembly.""" |
| headers, seqs = _split_fasta(text) |
| if not headers: |
| return text |
| seq = "".join(seqs) |
| n = len(seq) |
| if n < 20: |
| return text |
| span = max(10, int(n * frac)) |
| start = rng.randrange(0, max(1, n - span)) |
| foreign = "".join(rng.choice("ACGT") for _ in range(span)) |
| return _rebuild(headers[0], seq[:start] + foreign + seq[start + span:]) |
|
|
|
|
| TABULAR_PERTURBATIONS: dict[str, Callable[[str, random.Random], str]] = { |
| "drop_rows": drop_rows, |
| "shuffle_column": shuffle_column, |
| "scale_numbers": scale_numbers, |
| "truncate": truncate, |
| } |
|
|
| SEQUENCE_PERTURBATIONS: dict[str, Callable[[str, random.Random], str]] = { |
| "mutate_bases": mutate_bases, |
| "reverse_complement": reverse_complement, |
| "shuffle_sequence": shuffle_sequence, |
| "splice_foreign": splice_foreign, |
| "truncate": truncate, |
| } |
|
|
| PERTURBATIONS: dict[str, Callable[[str, random.Random], str]] = { |
| **TABULAR_PERTURBATIONS, **SEQUENCE_PERTURBATIONS, |
| } |
|
|
|
|
| def perturbations_for(text: str) -> dict[str, Callable[[str, random.Random], str]]: |
| """Choose the corruption set matching the artifact's type. |
| |
| Applying tabular corruptions to a genome (or the reverse) produces no-ops, and a |
| no-op is not evidence about a check -- it silently understates or overstates strength |
| depending on how it is counted. Detection is deliberately crude: FASTA is the only |
| special case these benchmarks need, and anything else is treated as tabular text. |
| """ |
| head = text.lstrip()[:1] |
| return dict(SEQUENCE_PERTURBATIONS) if head == ">" else dict(TABULAR_PERTURBATIONS) |
|
|
| MAX_ARTIFACT_BYTES = 200 * 1024 * 1024 |
|
|
|
|
| def measure_strength( |
| spec: CheckSpec, |
| artifact: Path, |
| workspace: Path, |
| runner: Callable[..., object], |
| *, |
| perturbations: Sequence[str] | None = None, |
| seed: int = 0, |
| timeout: int = 120, |
| ) -> Strength: |
| """Measure how much `spec` constrains `artifact`, by corrupting it and re-checking. |
| |
| The artifact is copied aside and restored afterwards, so the agent's workspace is |
| left exactly as found even if a check crashes. |
| |
| Args: |
| spec: The check to measure. |
| artifact: File the check reads. Must exist and be text. |
| workspace: Directory to run the check in. |
| runner: ``(workspace, command, timeout=) -> result`` with ``stdout``/``exit_code``. |
| perturbations: Names from `PERTURBATIONS`; defaults to all of them. |
| seed: RNG seed, so a reported strength is reproducible. |
| timeout: Per-check wall clock. |
| |
| Returns: |
| A `Strength`. If the check does not pass on the unmodified artifact it is |
| reported ``valid=False, score=0.0`` -- broken, not strong. |
| |
| Raises: |
| FileNotFoundError: If `artifact` does not exist. |
| ValueError: If the artifact is larger than `MAX_ARTIFACT_BYTES`, since this |
| routine holds it in memory. |
| """ |
| artifact = Path(artifact) |
| if not artifact.is_file(): |
| raise FileNotFoundError(f"artifact not found: {artifact}") |
| size = artifact.stat().st_size |
| if size > MAX_ARTIFACT_BYTES: |
| raise ValueError(f"artifact too large to perturb in memory: {size} bytes") |
|
|
| probe = artifact.read_text(errors="replace") |
| applicable = perturbations_for(probe) |
| names = list(perturbations if perturbations is not None else applicable) |
| unknown = [n for n in names if n not in PERTURBATIONS] |
| if unknown: |
| raise ValueError(f"unknown perturbation(s): {unknown}") |
|
|
| def passes() -> bool: |
| try: |
| res = runner(workspace, spec.command, timeout=timeout) |
| except Exception: |
| return False |
| if getattr(res, "timed_out", False) or getattr(res, "exit_code", 0) != 0: |
| return False |
| return verdict_from_output(getattr(res, "stdout", "")) is True |
|
|
| backup = artifact.with_suffix(artifact.suffix + ".vera_orig") |
| shutil.copy2(artifact, backup) |
| try: |
| if not passes(): |
| return Strength(spec.name, valid=False, score=0.0) |
| original = backup.read_text(errors="replace") |
| detected, missed = [], [] |
| for name in names: |
| rng = random.Random(seed) |
| corrupted = PERTURBATIONS[name](original, rng) |
| if corrupted == original: |
| continue |
| artifact.write_text(corrupted) |
| (detected if not passes() else missed).append(name) |
| shutil.copy2(backup, artifact) |
| total = len(detected) + len(missed) |
| score = (len(detected) / total) if total else 0.0 |
| return Strength(spec.name, True, score, tuple(detected), tuple(missed)) |
| finally: |
| shutil.copy2(backup, artifact) |
| backup.unlink(missing_ok=True) |
|
|
|
|
| def weighted_rho(pairs: Sequence[tuple[bool, Strength]]) -> float: |
| """Verification score with each check weighted by its measured strength. |
| |
| An unweighted `rho` treats ``test -f data.fasta`` as worth as much as an invariant |
| that actually constrains the analysis, which is what makes vacuous checks profitable. |
| |
| Args: |
| pairs: ``(passed, strength)`` for each check on a node. |
| |
| Returns: |
| Strength-weighted pass fraction, or 0.0 when every check is vacuous or invalid |
| -- consistent with `vera.checks.rho`, where unverified scores zero. |
| """ |
| total = sum(s.score for _, s in pairs if s.valid) |
| if total == 0: |
| return 0.0 |
| return sum(s.score for passed, s in pairs if s.valid and passed) / total |
|
|
