LAWS.md

# Local Inference Lab — Distribution Fidelity Laws

**Laws version:** 15
**Status:** draft, pending coordination with `local-inference-lab` on the
publication namespace and suite format.

Version 2 adds Law 14. A receipt at version 1 says nothing about component
attribution either way, so a version-1 result for a routed model is not a
version-2 result and should be rescored rather than relabeled.

Version 3 adds Law 15. A version-2 result reports one mean over a suite built
from a dozen kinds of text and never says which of them the divergence landed
on, so it cannot be rebadged as version 3; the per-context records Law 15 reads
come from the scoring run itself.

Version 4 changes what Law 14 means. Versions 2 and 3 took the router weight cell
as the routing term and its ranking floor. That was wrong: routing changes because
the activations reaching an identical router changed, so a checkpoint shipping a
BF16 router reported a floor of zero while its routing term was not zero. Version
4 requires the routing term to be measured from the run's own expert selections
and makes that measurement the floor. A version-2 or version-3 receipt for a
routed model overstates how comparable two candidates are and must be rescored,
not relabeled.

Version 5 tightens Law 12. Versions 1 through 4 checked that a reference was
published, not that it was the reference the number came from, and an artifact
shipped with reference tensors bound to different tokens and a different row count
than the candidate beside them. Every other law passed, because they read the
candidate's manifest and never the one published with the tensors. Unlike the
earlier version changes this one is a relabeling, not a rescore: the measurement
is unaffected, so a version-4 artifact becomes a version-5 artifact by
reassembling it and passing the new check.

Version 6 changes what Law 14 cells match. Versions 2 through 5 selected
weights by component name pattern and rounded every match, so a mixed-precision
checkpoint that quantized only some attention or expert weights produced a
composite cell heavier than the deployment it claimed to decompose. Version 6
matches per tensor. Because a reference may fuse what a pack names separately —
one `experts.gate_up_proj` stack against a quantized pack's per-expert names —
each quantized name is resolved to the reference tensor that carries it, and a
fused tensor the pack covers only in part is refused rather than rounded whole.
A version-5 receipt for a partly quantized candidate is not a version-6
receipt and must be rescored, not relabeled.

Version 7 separates a saturated routing measurement from an absent one. Versions
2 through 6 failed Law 14 whenever the routing excess was null and advised a
rescore with `--measure-routing`, which was the right advice for a run that
never measured routing and useless for one where every scored position rerouted
or none did. Both of those are measurement outcomes a rescore reproduces
exactly. Version 7 states which case holds and publishes a saturated candidate
with its deployed mean marked unranked. This is a relabeling, not a rescore: a
version-6 receipt becomes a version-7 receipt by reassembling it.

Version 8 adds Law 16. Versions 1 through 7 bound a report to its tokens, its
capture, and its reference, and never to the candidate weights themselves: the
report named a directory, and nothing said what that directory held when it was
read. Two candidates in one campaign then published the same mean from different
checkpoints, which is only possible if one was scored against the other's
weights, and every law passed. Version 8 requires the digest of the scored
tensors on the report and refuses a family in which distinct weights produced an
identical mean. A version-7 report whose weights were released cannot be bound
after the fact; it publishes under a recorded Law 13 deviation saying so, or it
is rescored.

Version 9 states what agreement between tensor-parallel workers means, under
Law 8. Versions 1 through 8 required the workers to return identical floats for
the trunk KLD, which no correct multi-worker run can do: each rank multiplies its
own slice of the vocabulary on its own device, and a sum over the vocabulary
amplifies the last-bit difference in the gathered logits. Every tensor-parallel
candidate was therefore refused for a fault it did not have, and the refusal
reported no numbers, so the cause stayed hidden. Version 9 requires agreement to
a stated bound, publishes the observed divergence beside the figure so no reader
takes more precision from the digits than was measured, and refuses a real
disagreement with the field, the position, and both values named. A version-8
receipt from a single-worker run becomes a version-9 receipt by reassembling it;
a multi-worker candidate that version 8 refused must be scored.

Version 10 replaces Law 14's synthetic component-cell interpretation with a
paired routed-model intervention. QxQ is the unchanged quantized candidate under
its natural routing. BxQ is the same candidate with the BF16 teacher's expert IDs
forced while the student computes its own gating weights for those experts.
Earlier `expert_cell`, `router_cell`, and `composite_cell` results remain useful
synthetic QDQ diagnostics, but none measured BxQ or QxQ. Routed candidates must
therefore be rescored for BxQ; an existing deployed report may supply QxQ only
after the paired-run controls and bindings are established.

Version 11 replaces Law 14's fixed bitwise-style natural-control threshold with
a measured repeatability envelope. The paired protocol runs two natural and two
forced-natural samples, retains the fixed numerical floor for repeatable
kernels, and otherwise permits no more than twice the larger observed
within-path span. Natural expert IDs may differ across the two samples when
arithmetic drift propagates into later routers, so their selection flip rate is
recorded. Both forced-natural controls still replay the first QxQ sample's exact
IDs.
The paired routed-score and BxQ protocol versions are now 3. Version-10 paired
reports must be rescored rather than relabeled.

Version 12 restores Law 14's publication requirement to exact repeated QxQ and
BxQ. Version 11's repeatability envelope remains diagnostic evidence of kernel
drift, but it does not authorize a drifting canonical score. Publication
requires two natural QxQ samples, two forced-natural controls, and two BxQ
samples to agree exactly in routes and per-position KLD. Uncertified or
nondeterministic backends fail. Version-11 paired reports must be rescored
rather than relabeled. The paired routed-score and BxQ protocol versions are
now 4.

Version 13 adds Law 17. Versions 1 through 12 checked at length that a kernel
computed repeatably and never asked whether it computed what the checkpoint
exported, so a batch-invariant, fully certified run could substitute a
quantization parameter and publish the result under the checkpoint's name. A
version-12 report does not record what it substituted and cannot be relabeled as
one that substituted nothing; the record comes from the loaded model during
scoring. Version-12 paired reports must be rescored. The paired routed-score and
BxQ protocol versions are now 5.

Version 14 adds no law. It puts `kv_cache_dtype` into the comparability key
(Law 10), the bound capture fields (Law 5), and the baseline agreement Law 1
already required of the model runner, because scoring had left it at
`auto`, under which vLLM resolves the KV cache dtype from a scheme declared in
the candidate's own config. One candidate therefore ran its attention through an
8-bit KV cache while the candidates it was ranked against ran unquantized, and
nothing in versions 1 through 13 could see the difference. The KV cache is now
pinned unquantized and never inherits a checkpoint's declaration. A version-13
report cannot be relabeled: it does not record which cache it used, and one that
used a quantized cache measured something else. Version-13 reports must be
rescored, and their captures retaken, since the capture is bound to the cache it
was taken under.

Version 15 adds no law and changes what two of them bind to.

Law 10's comparability key drops `vllm_commit` and `vllm_dirty_digest` for
`numerics_digest`, a hash of every `.py` under `vllm/` together with the scorer.
Binding to the commit meant a documentation edit, a campaign config, or a fix to
the orchestration invalidated every published number and cost GPU-days to
reproduce values that were already correct. The commit is still recorded and still
published under Law 6, where it says when a number was taken; currency asks
whether the code that computed it would compute it again, and the digest answers
that. `compiled_extensions_sha256` continues to cover the built kernels, so a
rebuild still invalidates. A capture is bound the same way: it is retaken when the
digest or the kernels move, not when the commit does.

Law 1 no longer requires the baseline and the candidate to cache in the *same*
unquantized dtype, only that each is unquantized. Version 14 held a literal
`bfloat16`, which refused three checkpoints published as float16 outright:
FlashAttention will not take a float16 query against a bfloat16 key. Each side now
caches in its own checkpoint's compute dtype, both dtypes are recorded, and the
candidate's stays in the comparability key, so a difference is disclosed and never
silently ranked across.

A version-14 report has no `numerics_digest` and cannot be relabeled into one; a
report that records no digest cannot be shown to have been computed by the code
running now. Version-14 reports must be rescored. This is the last rescore either
change forces: after it, a commit that cannot reach a number costs nothing.

These laws govern every distribution-fidelity measurement this program
publishes. They are not guidance. The pipeline refuses to produce or upload an
artifact that violates one, and the only way past a refusal is a recorded,
named human approval that is then printed beside every number the campaign
produced (Law 13).

Each law states what is required, why, the automated check that enforces it,
and whether an override is permitted at all.

## What this program measures

Teacher-forced next-token distribution fidelity: how closely a candidate
checkpoint reproduces a reference checkpoint's output distribution over a frozen
set of token IDs, measured as `KL(reference || candidate)` over the tokenizer's
real vocabulary.

## What this program does not measure

Free-running generation quality, benchmark accuracy, instruction following,
long-context behavior beyond the suite's context length, multimodal behavior,
tool use, or throughput. A fidelity number is evidence about one property. It is
not a quality verdict, and Law 10 forbids presenting it as one.

## Versioning

The laws are versioned as a whole. Every artifact records the laws version it
was produced under. Changing a law's meaning increments the version; artifacts
are never retroactively judged against a version they predate.

---

## Law 1 — Zero baseline

**Required.** Every campaign begins by scoring the reference checkpoint against
a capture of itself. The mean KLD must be exactly `0.0`, over every scored
position, on the same runner and tensor-parallel size the campaign will use for
its candidates.

**Why.** Zero is the only self-evidently correct answer, so it is the only check
that distinguishes a working measurement from a plausible-looking one. A
pipeline that cannot reproduce a distribution it just produced cannot be trusted
to attribute a difference to quantization.

**Check.** `mean_kld == 0.0` exactly — not rounded, not below a threshold — in
the self-comparison report, with `num_positions` equal to
`rows * (context_length - 1 - score_from)`.

**Override.** Permitted only under Law 13, and only with all three of:

1. a named approval recorded before any candidate is scored;
2. a repeat-capture study, in which the reference is captured three times over
   the identical tokens and all three pairwise comparisons are scored, which
   establishes the magnitude of the nondeterminism the campaign is carrying;
3. headline disclosure. The non-zero baseline and the widest pairwise repeat
   spread appear in the artifact's opening section, not a footnote, and every
   candidate mean in the campaign is annotated with the floor it sits above.

A candidate difference no larger than the repeat spread is not a result. Under an
override, ranking two candidates requires repeated candidate capture as well.

## Law 2 — Determinism

**Required.** Eager execution enforced. No autotuned kernel selection, no
inference-time JIT kernel selection, no CUDA graphs, prefix caching disabled,
and a fixed `max_num_seqs`. Tensor-parallel size is recorded, and reference and
candidate are scored under identical settings, with one exception: each caches in
its own checkpoint's compute dtype, because a float16 checkpoint cannot read a
bfloat16 key. Both must be unquantized, both are recorded, and the candidate's is
in the comparability key.

**Why.** Timing-based autotuners and JIT kernel choice make the arithmetic a
function of machine load, which silently converts run-to-run noise into apparent
quantization error. Programs that skip this are forced to spend statistical
machinery resolving differences smaller than their own noise floor. Determinism
is what makes Law 1's exact zero attainable.

**Check.** `enforce_eager` true in the capture manifest and the live config;
prefix caching disabled; compiled runs are labeled `authoritative: false` and
are rejected from any published comparison.

**Override.** Not permitted for published numbers. Compiled runs may be recorded
as exploratory and must be labeled as such.

## Law 3 — Frozen input

**Required.** Comparisons consume stored token IDs from a published suite.
Never text retokenized at run time.

**Why.** Tokenizer versions, normalization, and concatenation policy all change
the token stream, and a changed token stream changes the number while looking
identical in the command line. Stored IDs make the input an auditable object.

**Check.** The SHA-256 of the scored token IDs matches the suite manifest and
the capture manifest. Mismatch aborts before any model loads.

**Override.** Not permitted. A different token set is a different artifact.

## Law 4 — Real vocabulary

**Required.** KLD is computed over the tokenizer's actual vocabulary. Output
rows that exist only as alignment padding are never scored. The scored width is
published as `kld_vocab_size`.

**Why.** Padding rows carry no token ID and can never be emitted. Scoring them
measures how two checkpoints treat dead weights, and because padding size is a
per-checkpoint alignment choice, including it makes checkpoints incomparable for
reasons invisible in the output.

**Check.** `kld_vocab_size` equals the tokenizer's unpadded vocabulary size and
is strictly less than or equal to the checkpoint's declared `vocab_size`.

**Override.** Not permitted.

## Law 5 — Manifest binding

**Required.** A reference capture binds itself to the tokenizer identity, token
hash, context length, row count, `score_from`, scored vocabulary size, tensor
parallel size, eager mode, KV cache dtype, and runtime identity. Scoring against
a capture whose manifest disagrees with the live configuration aborts.

**Why.** Reusing a capture across configurations is the easiest way to publish a
number that compares two different things. The binding must fail closed, because
a coerced comparison is indistinguishable from a valid one in the output.

**Check.** Every bound field matches, and a capture directory lacking a manifest
is refused rather than inferred.

**Override.** Not permitted. Changing a bound field mints a new capture.

## Law 6 — Provenance

**Required.** No number publishes without its environment report: host and
kernel, GPU inventory with driver, VBIOS, ECC mode, persistence mode and clock
limits, CUDA toolchain, torch and vLLM versions with the exact commit, the
resolved interpreter, the full installed package set, and content hashes for
every checkpoint involved.

**Why.** A fidelity number is a property of a checkpoint measured through a
stack. Kernel selection, driver version, and even ECC state can move a bitwise
result, so a number without its stack cannot be reproduced or defended.

**Never a credential.** Provenance records that a variable was set, never a
credential's value. The watched prefixes put `HF_TOKEN` in the same namespace as
`HF_HOME`, so a variable with a whole name-word of `TOKEN`, `KEY`, `SECRET`,
`PASSWORD`, `AUTH`, `COOKIE`, or `SESSION` is recorded with its value replaced.
Redaction applies at capture, again at rendering, and again as a refusal to upload,
because
a published credential cannot be unpublished.

**Not reused across a moving tree.** The environment report is recaptured whenever
the repository's HEAD differs from the commit it recorded, and republished into
every model root on each assembly. A capture carried forward describes a stack that
did not produce the numbers beside it, which is the failure this law exists to
prevent and the one hardest to notice, because every field is populated and every
check passes.

**Check.** The artifact contains an environment report whose GPU, driver, torch,
vLLM, and commit fields are populated, and whose recorded checkpoint hashes match
those referenced by the reports. Publication additionally scans every text file in
the artifact, refusing on a recognizable credential shape or on a field whose name
is exactly a credential's name and still carries a value, and that refusal cannot
be overridden or skipped.

**Override.** Not permitted.

## Law 7 — Storage integrity

**Required.** Reference distributions may be stored as hidden states plus a
language-model head only when a replay probe proves, on that same capture, that
replaying the stored hidden states through the stored head reproduces the live
logits bitwise. Otherwise full logits are stored.

**Why.** Hidden-state storage is what makes a reusable multi-thousand-context
reference affordable, but it is only valid if replay is exact. An approximate
replay silently adds a floor to every candidate comparison built on it.

**Check.** The capture manifest's replay probe records bitwise identity. Hidden
storage without an exact probe is refused at capture and again at scoring.

**Override.** Not permitted. Fall back to logits storage instead.

## Law 8 — Head transparency

**Required.** Every comparison reports both trunk KLD, computed by pushing the
candidate's hidden states through the reference's language-model head, and
deployed KLD, computed through the candidate's own head.

**Why.** Head quantization and trunk error are different defects with different
remedies. Reporting only the deployed number conflates them, and reporting only
the trunk number hides a quantized head entirely.

**Check.** Both values present, along with the non-additive delta between them
and the detected head state for reference and candidate.

**Override.** Permitted under Law 13 when the candidate's head is proven
bit-identical to the reference's, in which case the delta is necessarily zero and
the second scoring pass buys no information.

### Agreement, not identity, across tensor-parallel workers

The trunk figure is computed on every tensor-parallel worker from the same three
files, so the workers cross-check each other: if a rank installed the reference
head wrongly or holds the wrong shard, its answer diverges. But the workers are
not required to produce identical floats, and demanding that they do is wrong.
Each rank multiplies its own slice of the vocabulary on its own device, and the
gathered logits differ in their last bits; a sum over a quarter-million-token
vocabulary amplifies that difference into the KLD.

So the contract is agreement to a stated bound — currently `1e-5` absolute per
position and `1e-7` relative on the mean. Within it, the run proceeds, the trunk
figure is rank 0's, and the one-pager states how far the ranks actually diverged,
so nobody reads more precision into the digits than was measured. Beyond it, the
ranks disagree about the model rather than about rounding, and scoring refuses
naming the field, the position, and both values. A top-1 flip between ranks is
disclosed and counted rather than refused: an argmax over two near-tied logits
can flip on last-bit noise without either rank being wrong.

## Law 9 — Tail and depth disclosure

**Required.** A published mean is always accompanied by median, p90, p99, and
maximum, by the per-position-depth profile, and by top-1 agreement.

**Why.** The mean and the tail can rank candidates in opposite directions. A
checkpoint can be more faithful at the typical position and far worse at rare
ones, and a checkpoint whose error accumulates with context depth looks fine at
short context. Publishing the mean alone hides both failure modes.

**Check.** All of `median_kld`, `p90_kld`, `p99_kld`, `max_kld`, depth buckets,
and `top1_agreement` present in the report and rendered in the one-pager.

**Override.** Not permitted.

## Law 10 — Comparability

**Required.** Numbers compare only against numbers produced from the identical
suite, geometry, and runtime identity. No threshold imported from another model,
corpus, tokenizer, vocabulary, or serving stack carries a verdict. No fidelity
number is presented as a capability, accuracy, or general quality claim.

**Why.** KLD has no absolute scale. Its value depends on the corpus, the context
depth distribution, the vocabulary width, and the runtime. Cross-harness
comparison is the single easiest way to publish a confident falsehood.

**Check.** Each result records its suite ID, geometry, laws version, KV cache
dtype, and runtime manifest hash. The leaderboard groups strictly by that tuple
and refuses to place rows from differing tuples in one ranking. One field of the
key is deliberately not a section boundary: a substituted quantization parameter
describes the candidate rather than how the number was taken, so such a row is
marked and footnoted in place. Splitting it out would leave a reader comparing
exports of one model unable to see the two side by side, and the substitution
remains in the receipt's key, which is what binds it (Law 17). The suite identity is read from what the
scoring run recorded, never from a suite manifest supplied to the audit, or a run
that tokenized at run time reports a complete key by borrowing the identity of a
suite it never opened.

**Override.** Not permitted.

## Law 11 — Freeze before qualification

**Required.** The suite is partitioned into analysis and qualification contexts.
Quantization parameters, layer assignments, and acceptance thresholds are frozen
on analysis results and recorded before any qualification result is read.

**Why.** Tuning against the set you report on converts a measurement into a
fitting exercise. The freeze receipt is what makes a qualification number an
out-of-sample claim.

**Check.** A freeze receipt exists, is timestamped before the qualification run,
and hashes the frozen parameters. Qualification scoring refuses to run without
it.

**Override.** Permitted under Law 13 for exploratory work, which may never be
published as a qualification result.

## Law 12 — Reusable reference

**Required.** A published artifact includes everything a third party needs to
score a new candidate without loading the reference checkpoint: the token suite,
the reference distributions, the language-model head, every manifest, and the
comparator configuration. File hashes are published for all of it.

The published reference must be bound to the same identity the report was scored
against, on every field Law 5 binds. Shipping the files is not enough; they have
to be the files the number came from.

**Why.** A fidelity claim that only its author can reproduce is an assertion, not
evidence. Publishing the reference also removes the largest cost from anyone
else's comparison, which is what makes independent replication realistic.

The identity clause exists because presence and reusability are different
properties, and an artifact once shipped with reference tensors describing
different tokens and a different row count than the candidate beside them. Every
other law passed, because they all read the candidate's manifest rather than the
one published with the tensors. A reader reusing that reference gets an abort at
best and needs the reference checkpoint after all, which is the one thing this law
exists to prevent.

**Check.** The artifact contains the suite, reference tensors, head, manifests,
and a `checksums.txt` covering every file, and the checksums verify. The manifest
published under `reference/` agrees with the scored capture manifest on every
bound field: token hash, tokenizer, context length, rows, start offset, comparator
vocabulary size, tensor-parallel degree, eager mode, and runtime.

**Override.** Permitted under Law 13 where redistribution of a derivative is
restricted by the reference checkpoint's license, in which case the artifact
records the restriction and publishes hashes so a locally regenerated reference
can be verified against ours.

## Law 13 — Recorded deviation

**Required.** Any override permitted above requires a named human approver, a
written justification, and a timestamp, recorded in the artifact's compliance
receipt. The deviation is then displayed on the one-pager next to the affected
numbers, not in a footnote.

**Why.** Fail-closed enforcement is only meaningful if the escape hatch is
auditable. An override that is invisible in the published artifact is
indistinguishable from a bug.

**Check.** Every compliance receipt entry with status `override` carries
`approver`, `justification`, and `timestamp`, and the one-pager renders them.

**Override.** None. This law has no exceptions.

## Law 14 — Routed-model QxQ/BxQ intervention

**Required.** A reference that routes tokens to experts publishes a paired
intervention over the identical frozen tokens:

1. **QxQ** (`qxq_cell`) is the unchanged quantized candidate running normally,
   with its natural expert IDs and its own gating weights.
2. **BxQ** (`bxq_cell`) is that same unchanged quantized candidate with the BF16
   teacher's ordered logical expert IDs forced at every routed layer. The student
   computes the gating weights for those forced experts from its own router
   logits, using its native scoring, bias, normalization, and scaling rules.

The first axis is the source of the expert IDs: `B` means BF16 teacher IDs and
`Q` means the quantized student's natural IDs. The second `Q` is the candidate,
which is identical in both runs. It does not mean "quantized experts" in a
synthetic checkpoint, and the first axis does not mean router-weight precision.

**Binding.** Both cells carry `mean_kld`, their supporting report path, partition,
token SHA-256, reference-config SHA-256, and `candidate_weights_sha256`. Every
binding equals the deployed report, and QxQ's mean equals the deployed natural
mean. BxQ additionally carries a 64-hex `routing_trace_sha256`,
`routing_mode: teacher_ids_student_weights`, and the supported
`protocol_version`. The trace binds the forced IDs to the same teacher, tokens,
layer order, and routing geometry used by both scores.

**Backend control.** Exact ID replay is a capability, not an assumption.
`backend_evidence` names the active backend or kernel, and `replay_supported` is
true only when that path injects logical teacher IDs before placement mapping and
dispatch. If replay uses a different kernel path, the candidate is first run with
that path and no override. The control protocol runs two deployed-natural, two
forced-natural, and two BxQ samples. Publication requires exact agreement:
identical natural expert IDs across the two QxQ samples, identical per-position
KLD across QxQ repeats, forced-natural controls, and BxQ repeats, all within
the fixed numerical floor. Observed spans and route-flip rates are stored as a
diagnostic addendum and never authorize a drifting canonical score. There is no
backend-name allowlist or blanket tolerance. `natural_control_parity.passed` is
true only when those exact-repeat conditions hold. An uncertified or
nondeterministic backend fails. The candidate weight digest must remain unchanged
and `candidate_weights_unchanged` must be true.
Forced-natural controls and BxQ remain bound to the first QxQ sample's exact
ordered IDs. QxQ always uses the model's own router.

**Natural routing divergence.** The QxQ run also measures the student's natural
expert IDs against the teacher trace. The artifact reports selection flip rate,
position flip rate, conditional KLD where routing held and flipped, per-layer
rates, and the existing routing-excess state. Conditioning after the run is not
BxQ: it observes the subset where routes happened to agree, while BxQ forces the
teacher IDs over the full suite.

**Paired delta.** `routing_intervention_delta = QxQ mean KLD - BxQ mean KLD`.
It may be positive or negative. It is a paired intervention result, not an
additive decomposition and not a claim that routing alone contributed that much.

**Synthetic QDQ diagnostics remain synthetic.** `expert_cell`, `router_cell`,
`composite_cell`, and ladder rungs round selected BF16 weights, run on BF16
kernels, and route naturally. They may still diagnose weight rounding and report
their own route flips, but they are never labeled BxQ or QxQ. In particular,
`expert_cell` is not BxQ because it changes the checkpoint and does not force
teacher IDs.

**Check.** For a manifest declaring experts, compliance requires both paired
cells and all bindings above; exact QxQ/deployed equivalence; a complete trace
digest; protocol, certified backend, and passing exact-repeat control evidence;
the exact paired delta; measured natural routing divergence; and QxQ plus BxQ
domain records. A manifest declaring no experts is
`not_applicable`. Missing replay support, stale or unbound traces, failed exact
repeat, an uncertified backend, and missing BxQ are failures. They are never
converted into an override or a synthetic substitute.

**Override.** Not permitted. Dense models satisfy this law as
`not_applicable`; a routed model without supported replay and exact repeated
QxQ/BxQ does not.

## Law 15 — Domain disclosure

**Required.** When the suite is stratified, a result publishes its mean per
stratum alongside the overall mean. Each stratum's row carries the number of
contexts behind it, the position-weighted mean, the spread of per-context means
within it, and the reference's own mean top-1 probability on it. Every stratum
the run actually scored appears; a stratum is never dropped for being small or
inconvenient.

**Why.** A model does not lose fidelity uniformly across kinds of text. The suite
is built from a dozen strata — encyclopedic reference, worked mathematics, source
code, dialogue, Chinese, structured data and tool calls — precisely because a
single corpus cannot represent a deployment. Averaging them back into one number
throws away the only part of the measurement that answers the question a reader
actually has, which is not "how far apart are these two models" but "how far
apart are they on the work I am going to give them". Two candidates with the same
mean are not interchangeable if one loses its fidelity on prose and the other on
tool calls.

**Confounding is disclosed, not resolved.** A stratum's KLD depends on how
predictable its text is to begin with. The reference's top-1 probability is
published beside every stratum mean so a reader can see the difference between a
candidate that diverges most where the reference was already uncertain, which is
weak evidence, and one that diverges most where the reference was confident,
which is strong. The program does not normalize the means to hide this; it
reports both numbers and says which case each stratum is.

**Spread, because a stratum is tens of contexts.** A stratum holds tens of
documents, not thousands, so one pathological document can carry it. The median
and p90 of the per-context means, and the worst context's identity, are published
with the mean. A stratum whose mean is four or more times its median is reported
as driven by outlier contexts rather than as a weak domain.

**Ladder.** Where Law 14 applies, the per-stratum table is also reported for the
cells, so the artifact says whether a domain's weakness follows the model or the
format. It is a different finding if NVFP4 is worst on code while FP8 is worst on
mathematics than if both are worst on the same domain.

**Check.** The compliance receipt requires per-context records in the report, one
per scored row, each naming its suite context. Every scored context must be in
the suite manifest, the published domain table must cover exactly the strata that
were scored, and its per-stratum context counts must sum to the number of rows.
A suite that declares fewer than two strata is `not_applicable`.

**Override.** Permitted under Law 13 for an unstratified suite the manifest fails
to describe, and for a zero-baseline or bounded-prefix run that is not published
as a candidate measurement. Not permitted for a published candidate on a
stratified suite.

## Law 16 — Candidate weight binding

**Required.** A published result carries a digest of the weights it scored, taken
from the checkpoint at the moment it was read, and that digest must match the
inspection of the candidate the artifact publishes. Within one family, two
candidates whose digests differ must not report the same mean.

**Why.** Every other binding in these laws points at the inputs a candidate was
measured against — the tokens under Law 3, the capture under Law 5, the reference
under Law 12 — and none of them points at the candidate. A report named a path,
and a path is not evidence. A directory that was repopulated, or a scorer handed
the wrong one of two similarly named checkpoints, produces a fully compliant
artifact attributing one vendor's numbers to another's work. That is the worst
error this program can make, because it is invisible: the number is real, the
receipt is honest, and the name on it is wrong.

**Content digest, not a file list.** The bond hashes each shard name and every
byte of every safetensors shard, including its header. A checkpoint with the same
tensor names, dtypes, shapes, and file sizes but different values therefore
cannot preserve the digest. Two directories that share it hold byte-identical
weight shards, whatever their repos are called.

**The same mean from different weights is refused, not explained.** Distinct
quantizations of one reference do not land on an identical mean to eighteen
digits; a suite of this size does not produce that coincidence. When it appears,
one report was scored against the other's checkpoint, and nothing in the
artifacts says which. Both results are withdrawn and rescored. The converse —
two candidates sharing a digest — is not an error in the measurement but a fact
about the upstream repositories: one is a verbatim re-upload of the other. It
publishes once only when both reports agree; conflicting scores from identical
weights are refused. The artifact names an agreeing re-upload as such rather
than presenting it as an independent quantization.

**Check.** The compliance receipt requires `student_weights_sha256` on the report
and an inspection of the published candidate carrying the same digest.
Assembly refuses a family containing an identical mean across differing digests,
and reports a shared digest as a duplicate.

**Override.** Permitted under Law 13 only for a result scored before this law
existed whose weights have since been released, where no digest can be recovered
without a rescore. The deviation is printed beside the number, which then states
that its weights are unbound. Not permitted for a new measurement, and never
permitted for a refused identical mean.

## Law 17 — Numerical substitution disclosure

**Required.** When the kernel that scored a candidate did not use a quantization
parameter as the checkpoint exported it, the result names that parameter, states
what was put in its place, reports how many of the scored layers it reached, and
bounds how far the replacement had to stretch. The substitution enters the
candidate's comparability key, so a substituted result never ranks against one
measured on its own parameters. A report that carries no substitution field at all
fails: silence is not the same claim as "none". An empty field is a pass only when
the run actually walked the loaded kernels and found nothing replaced. A run with
no kernel inspection to walk, such as a dense candidate with no routed experts, is
not applicable rather than clean; an empty field must never be read as a clean bill
of health for parameters nobody looked at.

**Why.** A kernel can be perfectly deterministic, pass every certification this
program runs, and still not be computing what the checkpoint describes. Two
substitutions this program has actually measured: the NVFP4 emulation experts
replace each expert's activation scale with one scalar for the whole layer
(measured once at a factor of 150 on a real export, and no longer the scoring
path), and a checkpoint that omitted per-expert keys has those slots filled from
the layer maximum so CUTLASS does not run on uninitialized memory. Both produce
a real, bitwise-repeatable mean that answers a slightly different question than
the checkpoint posed.

**Disclosure, not withdrawal.** This is the law's central choice. A substituted
result is published. Withdrawal is reserved for a result that cannot be
interpreted at all, such as one bound to a reference capture the family no longer
publishes; it is not a penalty for a number that came out badly, and a fidelity
index that quietly drops the checkpoints its kernels handle worst is not an index
of checkpoints but of kernel coverage. The failure mode here is never the
measurement, it is an unqualified label on it. So the remedy is a label.

**The spread is disclosed but does not bound comparability.** Only the identity of
the substituted parameter enters the comparability key. Two candidates the kernel
substituted the same way remain rankable against each other — which is the entire
purpose of keeping them — while the spread tells a reader how much to discount the
absolute value. A wide spread does not make a result less comparable to its peers;
it makes the whole group further from the deployment all of them describe.

**Per-cell states.** Each cell of a routed result reports one of three states.
`measured` used the checkpoint's own parameters. `substituted` holds a real
repeatable number obtained under a named replacement. `unavailable` holds no
number, with the reason it could not be taken. The three are not collapsible: an
absent cell and a substituted one are both unlike a plain measurement and nothing
like each other. Where a substitution reaches both cells of a routed pair it
partly cancels in `QxQ − BxQ`, but never exactly — clipping is nonlinear and the
two runs route to different experts — so the delta is the sounder of the three
numbers without being clean.

**Check.** Compliance requires `quantization_substitutions` on the report. Each
entry states its parameter, kind, affected and scored layer counts, and worst
spread; a missing field, a malformed entry, or one that omits its spread fails.
The check then confirms the comparability key still binds the substituted
parameters. Scoring records the field from the loaded model, per tensor-parallel
worker, reporting the worst case across ranks.

**What is inspected so far, stated as a limit.** Routed expert layers are
inspected; dense linear layers are not. This is a real gap and it fails closed:
a dense family scored today reports no substitution field and Law 17 refuses it,
which is the correct outcome — the law says nothing about that checkpoint until
someone measures it. Recording an empty list instead would assert that nothing was
substituted, and for NVFP4 that assertion would be false: the dense path collapses
the input scale across each fused parallel layer exactly as the expert path does,
under vLLM's own warning that it will likely reduce accuracy. Closing the gap
needs more than a new inspector, because that path deletes `input_scale` once it
has taken the maximum. The evidence does not survive loading, so it has to be
captured while the substitution happens rather than observed afterwards.

**Override.** Not permitted. An approval could only assert that an undisclosed
substitution is acceptable, which is the one thing this law exists to refuse.
A result whose substitution cannot be determined is unavailable, not approved.

## Numbering

Laws are append-only. A published receipt cites its laws by number, so renumbering
would silently change what an existing artifact claims to have satisfied. A law
that is superseded is marked as such and keeps its number.