Locke — an adversarial prosecutor for load-bearing claims

Locke decomposes a consequential claim into the sub-claims a maker must vet, prosecutes each so a "pass" can fail, and routes each to its soundest checker — up to a blind judge that shares none of the author's stake.

Overview

Locke's one skill is prosecuting leaves. A consequential claim — a computation, an implementation, a quantitative result — is not one thing to accept or reject; it is a set of sub-claims (leaves) a maker had to get right: the math, the code that realizes it, the sources (right and actually correct), the statistics, and whether a better source already exists. Locke prosecutes each leaf adversarially — coming to disprove, so that a "pass" is genuinely capable of failing — and routes each to the checker best suited to it, up to a blind judge that shares nothing with the author (its blindness, not its cleverness, is the guarantee).

Locke is the prosecutor. Its constructive companion, Warrant, decomposes a claim into a verification graph and routes each leaf to its soundest checker; Locke is the adversarial disprove-pass that sits on top.

The leaves a maker must vet

Prosecute each so a "pass" can fail:

1. MATH is sound — formulas correct, internally consistent, well-behaved at the edges.
2. CODE realizes the math — the implementation computes the intended formulas.
3. SOURCES are right AND actually correct — the cited source is the authoritative primary one, and it actually states the value/formula (checked against the primary record, not "widely repeated").
4. STATISTICS are valid — derived/validated soundly, and still holding.
5. NO BETTER SOURCE/DATA is available — this is the best, most-current model.
6. THE CONSEQUENTIAL CLAIM — given 1–5, does it survive? A sound death on any load-bearing leaf kills it; a still-judgment on stats / better-source caps it.

The core discipline: prosecute, then judge — by a different instance

• Generate (unencumbered). The claim is produced in full; the author stays the author.
• Prosecute (a different instance). A different instance — not the one that made the claim — runs the prosecution, so the claim arrives as someone else's: the disposition to drop another's claim is engaged, the disposition to defend one's own is not.
• Rule. A load-bearing claim is never produced and prosecuted in the same session.

The disprove ladder

For a leaf with no sound automated checker, route the judgment up a ladder of increasing independence, each rung sharing less with the author than the last:

author → independent reviewer → a fresh instance of the same system → an independent system from a different developer → human expert.

The blind judge is the backstop that shares nothing with the author. Climb only as far as the stakes require.

Freezing the question

Every guard against author bias relocates the leak up one level — to the question and rubric handed to the judge. The regress bottoms out only at an artifact small and static enough to be audited once and frozen. So: freeze the question and the rubric before any item is graded. If a claim cannot be compressed into a frozen, blind-gradeable question — because it is not yet well-posed — that is the instrument telling you the question is not yet known.

Repository contents

path	contents
DESIGN_prosecutor.md	the prosecutor's design: the leaf decomposition and the arbiter / de-leading role
SKILL.md	the invocable skill — decompose → prosecute each leaf → freeze → blind judge
dispatch_and_item_prep.md	dispatching a prosecution and preparing the item verbatim; the one limit ("grades structure, not truth")
correctness_rubric_default_direction.md	the rubric for prosecuting a correctness leaf so a "correct" can fail
question_template_correctness.md	the frozen, judge-facing instructions for a prosecuted correctness leaf
model_routing.md	which model prosecutes which leaf-type best, and when — routing each leaf to its soundest checker
signature_vs_mechanism.md	a prosecution discipline — a leaf can fail by treating a correlate as the mechanism
code/blind_judge.py, code/SPEC.md	the verbatim plumbing that carries the frozen (question, rubric, item) to a clean-context judge
examples/perf_bottleneck/	a worked example — the no-better-source leaf catches the author
examples/gw_source_model/	Warrant-matched (GW150914) — the stats / no-better-source leaf caps the source-model reading (CERTIFIED@narrow)
examples/resnet_accuracy/	Warrant-matched (ResNet) — the statistics leaf caps the "better architecture" reading (CERTIFIED@narrow)
examples/card_krueger_did/	Warrant-matched (Card–Krueger) — the no-better-source / causal-ID leaf caps the causal reading (CERTIFIED@narrow)
examples/reinhart_rogoff_debt/	Warrant-matched catch-demo (Reinhart–Rogoff) — the math/code leaf kills the claim (NOT-CERTIFIED · died)
MANIFEST.md	what is included, and why, against the central skill

Quickstart

1. Name the claim's load-bearing leaves (math · code · sources · stats · no-better-source).
2. Write the correctness rubric (correctness_rubric_default_direction.md) with the default direction set so a "correct" can fail. Freeze it and the question before grading anything.
3. Prepare the item as the generator's verbatim output — copied, diffable, never paraphrased.
4. Dispatch each leaf to its soundest checker; route the irreducible-judgment leaf to the blind judge:

   python3 code/blind_judge.py --question question_template_correctness.md \
       --rubric correctness_rubric_default_direction.md --item item.txt --model <strong-model>
   

   Or render only (no API key) and paste into a clean-context model, or one from a different developer.
5. Read the justification, not the label — a directional verdict (CERTIFIED@K / NOT-CERTIFIED), never a bare pass.

Relation to Warrant

Locke is related to but not dependent on Warrant. Warrant is the full verification method — decompose a claim into a graph, route each leaf to its soundest checker, climb the ladder only on the residual. Locke is the adversarial prosecutor that comes to disprove each leaf. For the whole method, see Warrant's METHODOLOGY.md.

License

Apache-2.0, with an explicit patent grant. See LICENSE; citation metadata in CITATION.cff.