Learning systems from first principles

Training provenance and evaluation validity

Rajesh Ranjan Mahapatra

A reported capability is evidence about a particular data, optimisation and test-interface path; only controlled variation across that path can support a broader capability claim.

© 2026 Rajesh Ranjan Mahapatra. 30 min read

Training provenance and evaluation validityAll Human–Machine Convergence

Learning systems from first principles

Training provenance and evaluation validity

A reported capability is evidence about a particular data, optimisation and test-interface path; only controlled variation across that path can support a broader capability claim.

TLDR

  1. A score measures a configured pipeline, not a latent property of model weights alone.
  2. Training provenance includes selection, ordering, post-training and possible contact with the test.
  3. Prompts, answer options, decoding and scoring can create or erase apparent performance.
  4. The strongest valid claim is limited by the weakest evidence about construct, exposure, interface and transport.
  5. The Capability Evidence Envelope turns one score into a bounded claim and a next-test decision.

Two language models sit behind identical APIs. Model α and Model β each score 82 out of 100 on a public reasoning benchmark. Their answers, latencies and token budgets look similar. A procurement team concludes that the models have equal reasoning capability, then chooses the cheaper one.

A month later, a training manifest appears. Model α completed pre-training before the benchmark questions were written. Model β received a short instruction-tuning run containing paraphrases of thirty test items and their answers. Nothing in the score sheet recorded this difference.

Did Model β reason? It may have. Did Model α generalise? Perhaps. The score alone cannot tell us. The number is identical, but the evidence is not. The puzzle is not that benchmarks are useless. It is that we habitually treat the output of an entire causal pipeline as though it were a property engraved inside one model.

The likely intuition is simple: a test is a neutral window. It reveals whatever capability the model possesses. The hidden assumption is independence. We assume the test was not part of training, that the interface does not favour one model, that the scorer recognises equivalent answers, and that the tested task represents the capability named in the headline.

Remove any one of those assumptions and the meaning of 82 changes. This paper develops a practical response: preserve the score, but attach it to the history and interventions that make its interpretation possible.

A score carries a hidden history

Consider a much smaller system: a classifier trained to separate invoices from purchase orders. Its architecture stays fixed. You change only the training mixture, doubling examples from one supplier and removing scanned documents. The classifier now improves on a benchmark drawn from that supplier, yet degrades on photographed documents.

What changed? Not parameter count, optimiser family or output labels. The training distribution changed which regularities were cheap to learn. Modern language models magnify this effect. Data selection chooses domains, styles, languages and repeated patterns. Curriculum controls when those patterns arrive. Post-training selects which latent behaviours become easy to elicit under instructions.

Controlled work makes the causal point visible. DataComp-LM holds training recipes comparatively stable while varying data curation, precisely because otherwise data quality is confounded with architecture, compute and optimisation. Its results show that curated data can materially change downstream performance under a fixed experimental frame.[1] DoReMi similarly treats domain mixture weights as an optimisation problem and reports sizeable downstream gains over a default mixture.[2] Instruction tuning can then alter zero-shot and few-shot benchmark performance without replacing the base pre-training stage.[3]

Training provenance is therefore causal, rather than only administrative. It records which observations were available, how often they were repeated, in what order they shaped the model, and which later objectives made particular responses more likely.

Why one number cannot recover its cause

A benchmark score is a severe compression. Hundreds of item-level events become one average, while the history that made each answer likely disappears. Many different causal routes can therefore end at the same number. Broad transfer, narrow template familiarity, answer exposure, better instruction following and a forgiving parser can all raise the visible score. The number reports their joint result, not their separate contribution.

This is a problem of under-identification. Imagine that two configured systems both reach 82 per cent. One gains six points when a richer prompt supplies missing task context. The other gains six points only when canonical wording is restored after paraphrase. The final scores match, but the interventions reveal different dependencies. One result concerns elicitation; the other concerns form-specific familiarity.

Nothing follows from this about whether either model possesses a hidden, context-free capacity. The practical conclusion is narrower and stronger: an observational score can rank fixed configurations, but it cannot attribute the rank to a cause that was never varied. Attribution begins when the evaluator records the path and asks which parts of the result survive a controlled change.

A training sediment core enters a benchmark prism
Training layers feeding a benchmark prism A layered cylindrical core of pre-training, data selection, curriculum, instruction tuning and preference tuning feeds a prism. The prism separates the observed score into generalisation, exposure, elicitation, scoring and task-fit contributions. The observed score contains a history Preference and safety tuning Instruction fine-tuning Curriculum and repetition Filtering and data mixture Raw source corpus checkpoint benchmark prism generalisation prior exposure elicitation fit scoring method construct fit One scalar cannot identify these contributions without interventions.
Practitioner synthesis. The score is the visible beam. The sediment layers and the prism determine what the beam can mean. A useful evaluation records both, then changes one layer at a time.
Thought experiment: move the exam through time

Imagine a benchmark that is written one day after Model α completes training. The questions, answers and source documents did not exist during training. Now move the benchmark’s publication date two years backwards while keeping every item unchanged. The model, prompt and score remain fixed. Only possible exposure changes.

Should the capability claim remain equally strong? No. The behaviour is the same, but the rival explanation of memorised or indirectly learned test content becomes available. A causal property of the evidence changed even though no output changed. This is why provenance belongs inside the evaluation claim rather than in a separate compliance appendix.

A ten-question example

Worked example: the misleading 80 per cent

A model answers six of ten genuinely novel questions correctly. Two additional questions appeared with answers in its final tuning set. It reproduces both. The public score is eight out of ten, or 80 per cent.

If we silently read 80 per cent as “probability of solving a new problem from this task family”, we assume the exposed items behave like independent samples. Remove them and the clean estimate is six out of eight, or 75 per cent. That five-point difference is not the deepest problem. With only eight clean items, uncertainty is wide, and the exposed answers may have also taught a reusable strategy that affects the remaining items.

The correct response is not to subtract a universal contamination penalty. It is to state two observations: configured score 80 per cent; clean-subset score 75 per cent on eight items. Then test a post-cutoff or independently generated set. Contamination changes the estimand, rather than only the decimal.

Real corpora make the boundary harder. Duplicate and near-duplicate material can travel through mirrors, derived datasets and synthetic transformations. Analysis of C4 found examples from evaluation datasets inside a large web corpus.[4] Deduplication research found substantial repetition, reduced memorised emissions and reduced train-test overlap when duplicates were removed.[5] Controlled contamination studies further distinguish exposure to input text from exposure to the ground-truth answer, and show that simple n-gram definitions miss important cases.[6]

Evidence status

Published evidence: data mixture, duplication and test exposure can change measured performance. Contested interpretation: a high score on an exposed item may still involve useful computation, so exposure does not prove pure memorisation. Practical consequence: unknown exposure lowers the permitted claim; it does not establish cheating.

Provenance has more than one layer

Dataset documentation proposals such as Datasheets for Datasets and model documentation proposals such as Model Cards were designed to make motivation, composition, intended use and evaluation conditions visible.[7][8] The Data Provenance Initiative later audited more than 1,800 text datasets and found extensive missing or erroneous licensing metadata, illustrating how difficult lineage reconstruction can be at scale.[9]

For evaluation validity, however, provenance must go beyond legal source and licence. It needs at least five layers: source documents, transformation and filtering, training mixture and order, post-training datasets and objectives, and known or tested contact with benchmark materials. A model identifier without these layers is like a medicine label that names the bottle but omits the dose and manufacturing batch.

Thought experiment: swap the histories

Suppose two models have equal architecture and equal final benchmark score. Model α learned from broad examples and never saw the task template. Model β learned from narrow examples that closely match the benchmark. Now swap only their training histories while preserving the final score through additional optimisation.

The score cannot reveal which route produced the behaviour. Yet the route matters for transfer. Change the domain vocabulary, remove answer choices or ask for an explanation, and the models may diverge. The intervention is not designed to punish memorisation. It asks whether the regularity that supports the score survives when benchmark-specific supports are removed.

The argument in one pass
Chart · flow
flowchart LR
  A["A score carries a hidden history"] --> B["The exam is part of the machine"]
  B --> C["Build evidence by changing one<br/>cause at a time"]
  C --> D["The audit under pressure"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#087A98,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step
A structural route through Training provenance and evaluation validity: from A score carries a hidden history to Widen the claim only after a stronger…. Reading use: follow the relation, then return to the surrounding argument for evidence and limits.

The exam is part of the machine

Training history is only half the causal path. The evaluator also builds a temporary system around the checkpoint. A chat template inserts roles and delimiters. A prompt defines the task. Few-shot examples provide a local curriculum. Decoding chooses one trajectory from a distribution. A parser converts text into a label. A metric decides which differences count.

The benchmark is not a passive window. It is an instrument coupled to the model. Changing the instrument can expose a genuine weakness, create an artificial one, or simply measure a different behaviour.

S = A(R(θ(Dpre, order, objective, Dpost), prompt, examples, decoding), parser, metric)

Here, Dpre is pre-training data, while order captures curriculum and repetition. The objective includes the training loss, and Dpost is post-training data. Together they produce checkpoint θ. Runtime function R generates under a prompt, examples and decoding rule. Function A parses and scores that output to produce the published number S.

The equation is useful only because it prevents a shortcut. A single value of S cannot identify which input caused the result. To learn more, hold the checkpoint fixed while prompts and scorers vary. In another experiment, hold the recipe fixed while exposure changes, or preserve the task demand while surface form changes.

The causal graph behind a capability claim
Causal graph from data and evaluation choices to score Source data, selection, curriculum and post-training cause a checkpoint. Prompt, decoding and scorer combine with the checkpoint to produce a score. Benchmark publication creates possible exposure paths. Interventions on prompt, scorer and exposure are marked. source dataand documents selection anddeduplication order, mixtureand objective post-trainingand preferences configured checkpoint weights plus versioned adapters prompt anddemonstrations chat templateand tools decoding andsampling parser andmetric score plus uncertainty public benchmark items and source material possible exposure path benchmark design affects score do(prompt) do(decoding) do(scorer) do(selection)
Practitioner synthesis. Solid arrows show executed causal paths. Dotted coral paths show possible benchmark exposure and test-design influence. A broader claim requires interventions that block plausible rival paths.

The benchmark has a lifecycle

Evaluation datasets are often public because openness supports inspection and reproducibility. That same openness creates time-dependent exposure. Source passages may predate the benchmark. Draft items may circulate in repositories. Evaluation prompts may later enter logs used for training. Post-training datasets may adapt benchmark formats even when exact items are absent.

A useful provenance record therefore asks when each material became available and when each model stage ended. A model trained before item creation has a stronger independence case than one trained after public release. A private test is stronger still only if its source material, annotators, generation process and access controls also resist indirect exposure.

Exposure is a distance, not a switch

“Seen” and “unseen” are too coarse for serious inference. Exact exposure means the item and answer were available together. Near-duplicate exposure preserves most wording or structure. Source exposure makes the underlying passage, table or code available without the authored question. Procedure exposure supplies worked examples that teach the same transformation while changing all surface content. These distances create different rival explanations.

Exact answer exposure makes direct reproduction plausible. Source exposure may merely remove a knowledge-retrieval burden while leaving the requested inference novel. Procedure exposure can teach a genuinely reusable skill, yet still make a benchmark a poor estimate of unaided transfer. For that reason, a contamination report should not collapse every overlap into one percentage. It should name the unit of contact, the training stage, whether answers were present, and the transformation separating training from test.

String-level novelty is only one kind of independence. When the intended claim concerns transfer, the decisive comparison is often a source-swapped or post-cutoff task that preserves the causal demand while replacing the materials that may have been learned.

Where exposure can enter an evaluation lifecycle
Conceptual timeline. “Created after training” blocks one path, not every path. Source-level familiarity, later fine-tuning and evaluation-log reuse still require separate checks.

One question, three instruments

Multiple-choice evaluation makes the interface problem concrete. A system can be asked to emit a letter, to generate the full answer text, or to rank option likelihoods. Those methods are not interchangeable for an instruction-tuned model.

Few-shot example order has produced large swings in earlier language-model evaluations.[10] Option order can also alter multiple-choice performance, with one study reporting sizeable gaps across models and benchmarks.[11] Yet a later analysis found that some apparent prompt sensitivity came from rigid matching and first-token likelihood scoring rather than from the model’s semantic answer.[12] Another study similarly showed that generated text can be more robust than first-token selection when the two disagree.[13]

These results do not cancel one another. They separate two mechanisms. A model may genuinely depend on superficial order. An evaluator may also mis-score a stable answer. Interface sensitivity and scoring sensitivity are different failure modes.

Worked example: separate model error from scorer error

Take forty synthetic science questions and run one fixed checkpoint with one fixed prompt. An exact parser marks 29 answers correct. A rubric-guided semantic scorer marks 35 correct. Human adjudication of the six disagreements finds that five answers express the right concept but violate the requested letter format; one answer sounds plausible yet changes the scientific relation and should remain wrong.

The evidence now supports two measurements, not one corrected “true score”. Semantic task accuracy is 34 out of 40. Strict schema compliance is 29 out of 40. If the model will advise a reader, the first may be closer to the intended construct. If it must drive a typed workflow, the second is an operational defect. The disagreement review prevents a parser weakness from being called ignorance and prevents fluent wording from being called correctness.

Thought experiment: replace the answer channel

Keep the checkpoint and question fixed. First require the token “B”. Next require the full phrase “sodium chloride”. Finally ask for a one-sentence explanation with no options. Suppose the model fails the letter task, succeeds on the phrase, and explains the chemistry correctly.

Which result measures knowledge? The answer depends on the deployment demand. If the system must fill a machine-readable form, letter or schema compliance matters. If the claim is chemical knowledge, rigid letter matching may undercount it. The interface is not noise to be optimised away. It is part of the construct definition.

Prompt variance can shrink when the scorer changes
Synthetic chart comparing exact and semantic scoring across four prompt variants Four prompt variants show larger score variation under exact string matching than under a validated semantic scorer. The chart is illustrative, not an empirical result. Illustrative accuracy across meaning-preserving prompts 506070 8090100% canonicalparaphrasereorderedfree text exact match validated semantic score parser-induced spread
Illustrative synthetic values. A semantic scorer can remove errors caused by rigid parsing, but it can also introduce judge dependence. The correct test is dual scoring with validated disagreement review, not automatic replacement of one metric by another.
The same model response can receive three different verdicts
Worked scenario. The disagreement is not a nuisance. It exposes that “accuracy” can collapse several tasks into one label.

Construct validity comes before leaderboard validity

A benchmark name often does more rhetorical work than its items. “Reasoning”, “truthfulness”, “agency” or “medical competence” may each cover several distinct capacities. A multiple-choice item can require knowledge, language parsing, option comparison, calibration, refusal behaviour and format compliance. A single accuracy score cannot reveal which component failed.

A large systematic review of 445 language-model benchmarks found recurring gaps in construct definition, format control, contamination preparation, uncertainty reporting and error analysis.[14] HELM takes a complementary approach by evaluating multiple metrics in shared scenarios rather than treating accuracy as the only desideratum.[15]

Validity belongs to an interpretation and use, not to a dataset name. “Model α scored 82 under configuration K” is a direct observation. “Model α can reason” is an inference. The second sentence requires a bridge: task coverage, rival controls, stable performance under equivalent forms, and evidence that the bridge matters in the intended setting.

Worked example: equal totals, unequal capabilities

Consider a synthetic “clinical reasoning” test with sixty recall items, twenty-five information-extraction items and fifteen treatment-choice items under uncertainty. Model α answers 58, 22 and 4 correctly. Model β answers 52, 20 and 12 correctly. Both score 84 out of 100.

The aggregate ranking declares a tie. The component profile does not. For searching a reference manual, Model α may be preferable. For drafting a plan that must surface uncertainty, Model β may deserve further testing, although neither result alone establishes clinical safety. Change only the item mixture and either model can win the leaderboard without changing at all. The benchmark’s weighting function has changed the headline.

This is why construct work precedes metric work. The evaluator must specify which errors are substitutable, which are safety-critical, and which deployment decisions the total is meant to inform. An average is meaningful only after those choices are defended.

Build evidence by changing one cause at a time

The practical mistake is to ask whether a benchmark is valid in the abstract. The better question is: what is the strongest claim this particular run can support? The answer should change when evidence about training, interface or transport changes.

I propose a decision instrument called the Capability Evidence Envelope. It does not produce a universal validity score. It defines the region of claims still open after four gates and a reproducibility foundation.

Construct gate

Does the task isolate and represent the capability being named? Are format demands and sub-capabilities explicit?

Exposure gate

Can exact, near-duplicate, source-level and semantic contact with test material be bounded?

Interface gate

Does the result survive meaning-preserving prompts, option order, decoding choices and validated scoring?

Transport gate

Does the evidence travel to a new time, population, tool environment or real operating distribution?

Beneath all four sits a receipt layer: model and adapter identifiers, data manifests, task version, prompt, chat template, tool configuration, decoding parameters, parser, metric, raw outputs and uncertainty calculation. Without receipts, even the narrow configured-run claim may not be reproducible.

The envelope uses a weakest-link rule, not an average. Excellent prompt robustness cannot compensate for unknown test exposure. A pristine time split cannot make a poorly defined construct meaningful. Deployment shadowing cannot rescue an irreproducible scoring script.

A claim ladder, not a quality score

The envelope widens through five statements. At the narrowest level, the evaluator has an observation: this run produced this score. With complete receipts and uncertainty, the result becomes reproducible configured performance. Stability across equivalent prompts, parsers and clean task variants supports benchmark-task performance. A defended construct bridge permits capability-relevant evidence. A representative time, domain or operating shift permits deployment-relevant evidence.

Each step answers a different counterfactual. Would another evaluator reproduce the result? Would equivalent wording preserve it? Would a different task form that demands the same capacity preserve it? Would the result survive the change that matters outside the laboratory? A failure does not erase the narrower statement. It identifies the boundary at which the claim stops.

The weakest-link rule follows from that logic. Suppose construct, exposure, interface and receipts are all rated three on a three-point scale, while transport is zero. Their average looks excellent. Yet no evidence addresses the target environment. Averaging would let unrelated strengths purchase a missing premise. Evidence gates are conjunctions: a deployment claim is only as wide as the least-tested necessary bridge.

This design also prevents ritual auditing. Teams need not maximise every gate for every decision. They choose the claim needed, identify its necessary gates and run the smallest intervention that could lower it. The instrument turns missing evidence into a next experiment rather than a vague caution label.

The Capability Evidence Envelope
Nested evidence envelope with four gates A central claim is surrounded by construct, exposure, interface and transport gates. A foundation of reproducibility receipts supports all gates. Breaks in any ring narrow the permissible claim. permitted claim construct exposure interface transport reproducibility receipts checkpoint · data manifest · prompt · decoder · parser · raw outputs · uncertainty a broken gate narrows the claim
Novel decision framework. The envelope is not a scorecard. A missing outer gate does not erase inner evidence; it prevents a broader statement. For example, a reproducible benchmark result may still be valuable even when deployment transport is untested.

A small factorial experiment

Suppose we can train two small checkpoints with the same architecture and recipe. The clean checkpoint excludes a benchmark family. The exposed checkpoint receives paraphrases of part of that family during post-training. We then cross two prompt forms with two scorers.

Use a balanced set of two hundred items, randomise item and option order, hold decoding fixed and retain every generated answer. Estimate the exposure effect, prompt effect, scorer effect and their interactions, with uncertainty from item-level resampling. The design assumes that the checkpoints differ only in the planned post-training exposure and that human reviewers judge the paraphrases to preserve task demand and difficulty closely enough for comparison.

A large exposure-by-prompt interaction would permit the statement that the canonical advantage depends partly on benchmark form. A small interaction with stable post-cutoff performance would weaken that explanation. A null result would not prove absence of contamination, especially with low power or ineffective transformations. It would show only that this intervention failed to reveal a consequential dependency.

A matched experiment separates exposure from interface
Illustrative synthetic values. The exposed checkpoint’s advantage is large on canonical items and nearly disappears after paraphrase. Exact versus semantic scoring reveals a smaller parser effect. The design supports a narrower causal story than either score alone.
Worked example: reading the interaction

Under canonical prompts and exact scoring, exposure appears worth sixteen points: 84 minus 68. Under paraphrased prompts, the advantage is five points: 66 minus 61. The difference-in-differences is eleven points.

That eleven-point interaction is evidence that benchmark-specific familiarity contributes to the canonical advantage. It is not a proof of verbatim memorisation. The paraphrase may be harder, and post-training may have taught a task strategy that partly transfers. A stronger study adds several human-validated paraphrases, source-swapped items and a clean post-cutoff set.

The point is methodological: interactions identify mechanisms better than isolated leaderboard deltas. A model that remains strong across equivalent forms supports a broader task claim. A model whose advantage collapses under one controlled change supports a narrower configured-path claim.

A realistic configured-system example

Worked scenario: customer-email triage

A bank wants to compare two language models for routing customer emails. The target is not “general reasoning”. It is correct routing among twelve queues, calibrated abstention on ambiguous cases, and stable performance on new products.

The evaluation team builds a time-split dataset from messages created after both models’ declared training cutoffs. It keeps the final 20 per cent private, checks source systems for duplicated templates, and records possible exposure to public policy documents. Each model is tested with six meaning-preserving instructions, two option orders and both schema validation and adjudicated semantic scoring. Raw outputs and model version identifiers are retained.

On the public-like set, Model α leads by four points. On the hidden time split, the lead shrinks to one point and its abstention calibration worsens. Model β is slightly less accurate but more stable across prompts and new products. The decision is no longer “which model has higher intelligence?” It is “which configured system meets routing and abstention requirements under the expected distribution?”

This is a synthetic scenario, not a reported deployment. Its value lies in the structure: narrow construct, bounded exposure, interface perturbations, transport slice, uncertainty and receipts.

What must be inside the evaluation boundary
Evaluation manifest shown as an orbit around a checkpoint A central checkpoint is surrounded by versioned artifacts: data lineage, post-training, prompt, tools, decoding, parser, metrics, raw outputs and uncertainty. A boundary encloses all artifacts needed to reproduce the configured system. configured checkpoint datalineage post-trainingmanifest prompt andchat template tools andruntime decodingparameters parser andmetric raw outputsand logs uncertaintyand repeats task versionand splits reproducible evaluation boundary If an artefact can change the result, it belongs in the manifest.
Implementation view. Evaluation harnesses help make these components explicit. Reproducible evaluation work recommends preserving exact task logic, prompts, outputs and uncertainty rather than copying scores across incompatible setups.[16]
Executable lab

Capability Evidence Envelope audit

Select the evidence available for one reported result. The tool returns the strongest claim type currently permitted, the weakest gates and a machine-readable certificate. It deliberately avoids an averaged validity score.

What exactly is the score claimed to measure?
Can test contact be bounded rather than assumed away?
Does performance survive meaning-preserving changes?
Where should the capability claim continue to hold?
Can another evaluator reconstruct the run?
How much observed variation is measurement noise?

No assessment yet

Choose the evidence available, then assess the claim.

How to use a positive or negative result

A positive audit does not prove an intrinsic, context-free capability. It permits a stronger statement within the tested envelope. For example: “Model α shows stable routing performance across six instructions, two scorers and a post-cutoff domain shift.” That sentence is less dramatic than “Model α understands customer intent”, but it is actionable.

A negative audit is not a verdict that the model lacks the capability. It identifies the next discriminating test. Unknown exposure calls for a time-split or provider-side overlap report. Prompt instability calls for equivalent interfaces and error review. Weak construct coverage calls for task decomposition. Poor transport calls for shadow evaluation or a new domain slice.

The instrument cannot establish consciousness, understanding in a metaphysical sense, or a unique internal mechanism. It is a method for bounding behavioural and operational claims. It should not be used to turn missing disclosure into a numerical accusation.

Typed certificate and decision logic

The embedded audit exports a JSON object with gate levels, permitted claim, blockers and next tests. The logic is ordinal. It never averages a severe gap away.

Python 3 · equivalent command-line logic
from dataclasses import dataclass, asdict
from typing import Literal

Claim = Literal[
    "observation only",
    "reproducible configured performance",
    "stable benchmark-task performance",
    "construct-relevant capability evidence",
    "deployment-relevant capability evidence",
]

@dataclass(frozen=True)
class Evidence:
    construct: int      # 0..3
    exposure: int       # 0..3
    interface: int      # 0..3
    transport: int      # 0..3
    receipts: int       # 0..3
    uncertainty: int    # 0..3


def permitted_claim(e: Evidence) -> Claim:
    if e.receipts == 0:
        return "observation only"
    if min(e.receipts, e.uncertainty) < 1:
        return "reproducible configured performance"
    if min(e.exposure, e.interface, e.receipts, e.uncertainty) < 2:
        return "reproducible configured performance"
    if e.construct < 2:
        return "stable benchmark-task performance"
    if e.transport < 2:
        return "construct-relevant capability evidence"
    return "deployment-relevant capability evidence"


if __name__ == "__main__":
    evidence = Evidence(construct=2, exposure=3, interface=2,
                        transport=1, receipts=2, uncertainty=2)
    print({**asdict(evidence), "permitted_claim": permitted_claim(evidence)})

Run with Python 3.10 or later. Replace the example levels with your audit results. A higher output tier permits a broader claim; a lower tier identifies missing evidence. The script cannot judge whether your evidence deserves the level you assigned.

How the claim changes under pressure
Chart · state
stateDiagram-v2
  [*] --> Claim
  state "Why one number cannot recover<br/>its cause" as Claim
  state "A ten-question example" as Test
  state "Provenance has more than one layer" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]
The revision loop begins with Why one number cannot recover its cause and keeps counterexamples inside the reasoning path. Reading use: follow the relation, then return to the surrounding argument for evidence and limits.

The audit under pressure

The envelope is useful only if it survives adversarial and inconvenient cases. The hardest case is not exact leakage. It is transformed exposure that preserves the answer-bearing structure while defeating simple detectors.

Research on contamination detection has shown that rephrased benchmark samples can evade several existing detection approaches while still improving measured performance, including reported gains of up to fifteen percentage points in the studied settings.[17] A later review of reporting practices found that only a minority of thirty surveyed model releases supplied enough training-data or overlap information to contextualise public-test results.[18]

Exact-match cleanliness is not semantic independence. A benchmark item can be novel at the string level while its source passage, solution trace, template or translated form appears in training. Conversely, a shared source does not automatically invalidate the test. A model may need to transform familiar facts in a genuinely new way. The evaluation must state which kind of novelty matters.

Worked failure case: source-level exposure

Imagine a fifty-item arithmetic benchmark derived from a public textbook. Fine-tuning contains the textbook’s worked examples and solution methods, but no benchmark question appears verbatim. An exact-match scan reports a clean test. The configured model answers 44 canonical items correctly.

Now preserve each required operation while replacing the story, quantities and source chapter. Accuracy falls to 31. On thirty newly authored post-cutoff items it reaches 30. This pattern does not prove that the canonical answers were copied. It shows that the 44-point result mixed task ability with support supplied by familiar source structure. The defensible claim narrows from broad arithmetic transfer to strong performance on the canonical family, followed by moderate performance under source replacement.

The paraphrase laundering path
Adversarial path that paraphrases benchmark items before fine-tuning Public benchmark items pass through a paraphrase and rationale generator, enter fine-tuning data, influence a model, evade an exact-match detector, and yield an inflated canonical score. A semantic and post-cutoff test interrupts the path. public testitems paraphrases,translations andrationales post-trainingdataset configuredmodel exact-match “clean” canonical score rises interrupt with semantic lineage checks, source-swapped items and post-cutoff tests A detector can pass while the causal threat remains.
Failure model informed by contamination-evasion research. The recovery is not one perfect detector. It is layered evidence: provider-side lineage, semantic and source checks, transformed variants and independent post-cutoff tasks.

Three boundaries that prevent overcorrection

First, unknown provenance is not proof of invalidity. It is missing information. The permitted statement becomes narrower: a reproducible score under a named configuration, with exposure uncertainty disclosed. This distinction matters because accusation and scientific caution are not the same act.

Second, a hidden benchmark is not automatically valid. Hidden items can still misrepresent the construct, contain annotation errors, share public source material or reward brittle shortcuts. Secrecy protects one exposure path. It does not validate the task.

Third, an LLM judge is not a neutral oracle. Semantic grading can reduce exact-match artefacts, as some prompt-sensitivity research suggests, but the judge introduces its own prompt, model version, preferences and failure modes. Human adjudication of disagreements, rubric validation and multiple scoring paths remain necessary when the result matters.

Thought experiment: relocate the model

A model achieves 92 per cent on a benchmark of well-edited English support tickets. Keep the weights, prompt and scorer fixed, but move the system to a queue containing code-switched messages, screenshots, new product names and customers who omit key facts.

Nothing about training contamination changed. Yet the operational claim may fail because the benchmark did not represent the new environment. This is the transport gate. A capability can be genuine within one task distribution and insufficient elsewhere. Generalisation is always generalisation across a named change.

Strongest alternative explanation

Perhaps “capability” is simply a disposition of the whole configured system, including prompts and tools. On this view, there is no error in attributing the score to the system rather than the checkpoint. That alternative is often correct. The paper’s claim still stands: the system boundary and configuration must be named. Problems arise when a result from one boundary is transported to another without evidence.

Open research hypothesis

For mature public benchmarks, model ranking stability across post-cutoff source-swapped items will predict deployment transfer better than the original headline score. The hypothesis strengthens if ranking stability correlates with later real-world performance across domains. It weakens if canonical scores predict transport equally well after controlling for compute and model family. A rival explanation is that the new items are simply better labelled or more difficult. The smallest useful test is a preregistered three-model comparison on canonical, transformed and genuinely post-cutoff sets.

What the envelope cannot buy

No practical audit can recover a fully opaque training history from outputs alone. Black-box contamination tests depend on assumptions about memorisation, probability access and model behaviour. Provider-side reports can also be incomplete or use incomparable overlap definitions. The best available conclusion may remain conditional.

Nor can controlled behavioural variation uniquely identify an internal algorithm. Stable performance across paraphrases supports robustness, not a specific reasoning circuit. A collapse under format change reveals dependence, but not whether the cause is tokenisation, attention allocation, post-training preference or parser behaviour. Mechanism claims require separate causal interventions inside the model.

The envelope is intentionally conservative. Its purpose is not to make every evaluation expensive. It helps match expense to consequence. A low-stakes prototype may need a reproducible configured score and error sample. A clinical, financial or safety claim may justify private time splits, overlap reporting, multi-interface testing, uncertainty and operating evidence.

The evidence conversation
Chart · sequence
sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: A score carries a hidden history
  M->>E: Why one number cannot recover its cause
  E-->>M: compare rival explanations
  E->>D: Widen the claim only after a stronger intervention
  D-->>Q: revise scope or act
Question, mechanism, evidence and decision exchange the burdens developed in Training provenance and evaluation validity. Reading use: follow the relation, then return to the surrounding argument for evidence and limits.

Widen the claim only after a stronger intervention

When a new model report announces a capability, do not begin by debating whether the number is impressive. Ask what causal path produced it and which alternative paths were tested.

Request the configured-system manifest, rather than only the model name. Separate pre-training evidence from post-training elicitation. Ask whether benchmark source material could have entered any training stage. Re-run equivalent prompts and scoring methods. Inspect disagreements. Use a time, domain or population shift that matches the intended decision. Preserve raw outputs and uncertainty.

Then write the conclusion at the width the evidence permits. “This run scored 82” may be all that survives. With better receipts and interventions, the statement can widen to stable task performance, construct-relevant evidence, or deployment-relevant capability.

The decision rule is simple: publish the broadest claim that survives every relevant intervention, not the broadest noun suggested by the benchmark’s title.

This changes model selection as well as scientific reporting. Choose the model whose evidence envelope contains your operating need. A lower headline score with clean lineage, stable interfaces and transport evidence can be more decision-worthy than a higher score whose causal path is unknown.

For a researcher, this means pre-registering the noun in the claim before seeing the score. “Performance on these items” requires less than “reasoning”, and “reasoning in this workflow” requires different evidence again. For a buyer, it means comparing evidence envelopes rather than copying leaderboard order. For a system owner, it means treating prompt, tool, parser, policy and model updates as possible changes to the evaluated system, not harmless configuration drift.

A benchmark can then function as a contract rather than a trophy. The contract names the configured system, task demand, population, time boundary, interface, uncertainty and permitted inference. When any of those changes, the owner can identify which evidence remains valid and which gate must be reopened. The useful unit of progress is not a higher isolated score, but a wider claim that survives a stronger intervention.

Decision rule Do not ask, “Which model owns the higher capability?” Ask, “Which configured system has the strongest transportable evidence for the task, boundary and consequences we actually face?”

Glossary

Training provenance
The traceable lineage of source data, transformations, mixture, order, objectives, post-training and possible benchmark contact.
Contamination
Training exposure to evaluation items, answers, source material or meaning-preserving derivatives in a way that affects interpretation of the score.
Construct validity
The adequacy of the bridge from observed task performance to the capability or phenomenon being claimed.
Evaluation interface
The prompt, examples, chat template, tools, decoding, parser and metric that couple a checkpoint to a score.
Transport
The extent to which an inference holds across a named change in time, domain, population, task form or operating environment.
Receipt
A versioned artefact that permits reconstruction or independent checking of an evaluation run.
Capability Evidence Envelope
The bounded set of claims permitted by construct, exposure, interface, transport and reproducibility evidence.

References

  1. Li, J. et al. (2024). DataComp-LM: In search of the next generation of training sets for language models. Advances in Neural Information Processing Systems.
  2. Xie, S. M. et al. (2023). DoReMi: Optimizing data mixtures speeds up language model pretraining. Advances in Neural Information Processing Systems.
  3. Chung, H. W. et al. (2022). Scaling instruction-finetuned language models.
  4. Dodge, J. et al. (2021). Documenting large webtext corpora: A case study on the Colossal Clean Crawled Corpus. EMNLP.
  5. Lee, K. et al. (2022). Deduplicating training data makes language models better. ACL.
  6. Jiang, M. et al. (2024). Investigating data contamination for pre-training language models.
  7. Gebru, T. et al. (2021). Datasheets for datasets. Communications of the ACM.
  8. Mitchell, M. et al. (2019). Model cards for model reporting. FAT*.
  9. Longpre, S. et al. (2023). The Data Provenance Initiative: A large scale audit of dataset licensing and attribution in AI.
  10. Lu, Y. et al. (2022). Fantastically ordered prompts and where to find them. ACL.
  11. Pezeshkpour, P. and Hruschka, E. (2024). Large language models sensitivity to the order of options in multiple-choice questions. Findings of NAACL.
  12. Hua, A. et al. (2025). Flaw or artifact? Rethinking prompt sensitivity in evaluating LLMs. EMNLP.
  13. Wang, X. et al. (2024). Look at the text: Instruction-tuned language models are more robust multiple choice selectors than you think.
  14. Bean, A. M. et al. (2025). Measuring what matters: Construct validity in large language model benchmarks.
  15. Liang, P. et al. (2022). Holistic evaluation of language models.
  16. Biderman, S. et al. (2024). Lessons from the trenches on reproducible evaluation of language models.
  17. Dekoninck, J. et al. (2024). Evading data contamination detection for language models is (too) easy.
  18. Schaeffer, R. et al. (2024). Language model developers should report train-test overlap.