Skip to main content

7  Evidence States and Claim Discipline

7.1 Chapter status

Field	Value
Chapter ID	evidence-states-and-claim-discipline
Part	Part I - Foundations, Alignment, and Governance
Status	conceptual
Manuscript maturity	v0.2 manuscript draft
Last updated	2026-07-14
Primary source records	benchmaxxing, spinoza, viea, uat, coherence_exchange, verification_bandwidth
Claim label	Design rationale
Evidence level	argument
Source queue	primary: benchmaxxing, spinoza, viea; supporting: uat, coherence_exchange, verification_bandwidth; external comparators: ext_model_cards_2019, ext_datasheets_datasets_2021, ext_ml_reproducibility_program_2021, ext_proof_carrying_code_1997, ext_transformer_circuits_2021, ext_monosemanticity_2023
Source loading state	source notes: benchmaxxing, spinoza, viea, uat, coherence_exchange, verification_bandwidth, ext_w3c_prov_o_2013, cca_project, moecot_manifest_project, beastbrain_project, bugbrain_project, corbens_trainer_project, corbens_best_model_possible_project, ext_unlearning_benchmarks_weak_2024, ext_embedded_agency_2019; raw cache: benchmaxxing, spinoza, viea, uat, verification_bandwidth; connector/recovery: coherence_exchange
Source evidence review state	Five of six claim-source mappings have reviewed local raw-cache passage references in book_structure.json; coherence_exchange remains connector-only/source-note mapped.
Test state	claim_record.valid.json and evidence_transition_record.valid.json pass protocol fixture validation; python3 scripts/validate_support_state_transitions.py passes four valid and four expected-invalid synthetic records; the projection-aware refinement and independent consumer cover six reachable stages, all 35 declared routes, three exact claim projections, eight non-aggregating evidence dimensions, adverse transitions, review, decision, ledger handoff, acknowledgment, and explicit no-authority boundaries at experiments/evidence_transition_refinement/results/2026-07-26-local.json; the evidence-bundle, claim-ledger, accepted-transition, claim-state, and historical-project audits remain bounded executable consumers at their recorded scopes; no chapter-core support movement follows.

7.2 Drafting guardrail

Claim movement is governed explicitly. A claim is not promoted because prose became clearer, a source note exists nearby, or a validator passed an unrelated fixture.

It follows the failure chapter because the book itself has the same failure surface as the systems it describes: clearer text can hide missing evidence, a nearby citation can launder a stronger claim, and a narrow proof can be rhetorically expanded beyond its formal scope.

The control object is an evidence receipt. A receipt says exactly what artifact supports which claim, under which scope, in which evidence role, with which claim record, by which command or review, with which acceptance blockers, with which limitations, with which downgrade triggers, and with which negative or inconclusive results still attached.

Evidence discipline is therefore not housekeeping. It is the book’s methodological claim-control layer, paired with Living Book Methodology: the method by which a living technical text can keep changing without turning clearer writing into stronger evidence.

The scalar support state is only the public summary. It now sits beside a non-aggregating evidence-quality vector that keeps independence, reproducibility, recency, coverage, adversarial strength, validity, artifact access, and transfer distance separate. A current public artifact can still lack independent review; a reproducible narrow fixture can still have poor transfer; a strong adversarial control can still test the wrong construct. None of those dimensions may compensate automatically for another or move support without an accepted transition.

The support-state names are not a single confidence ladder. source-derived, prototype-backed, synthetic-test-backed, empirical-test-backed, and external-literature-backed answer different questions about provenance and method. One may be more relevant than another for a particular claim, but there is no general arithmetic in which a literature citation outranks an experiment or a synthetic fixture outranks inspected code. The public state is therefore a lossy projection chosen for the claim and consumer; the evidence cell retains the dimensions that the projection hides.

The reachable transition lifecycle freezes three views of the same claim atom before it binds evidence: the proposition a reader sees, the normative obligation the architecture imposes, and the machine predicate a validator or proof checks. A transition is rejected if any view is substituted midstream. The lifecycle then binds evidence and roles, checks target-specific evidence without scalar aggregation, requires negative evidence and supersession lineage for narrowing or terminal movement, records independent review and dissent, decides with limitations and residuals, and hands a bounded recommendation to the claim ledger. It cannot assign support, move a parent or descendant claim, approve release, or create an external effect.

7.3 Human Reading Path

Concrete lens. The result-label baseline reads “refuted” upward through the claim hierarchy. The transition ledger keeps the raw failure but narrows its usable scope after competence review.

After naming failure modes, the architecture needs a discipline for how strong each sentence is allowed to sound. The evidence layer makes a simple promise: a claim’s wording, label, and support state should not drift apart.

That promise is central to the living-book format. The manuscript can improve every day, but clearer prose must not silently become stronger evidence. If a claim is only an argument, it should read as an argument. If later evidence raises it, the record must move with it, so the reader can distinguish better exposition from stronger support. Better wording should invite better testing, not smuggle in stronger certainty.

The live book can stay alive only if confidence changes through records, not mood. That discipline keeps revision from becoming untracked persuasion: claim labels say what kind of assertion is being made, support states say what currently backs it, and evidence transitions say why confidence was allowed to move. This is not a footnote to the method; it is the method’s spine for the ASI Stack.

7.4 Problem

A living technical book needs a versioned claim lifecycle that separates what an assertion says from what evidence currently supports it and preserves why each state change was accepted.

Failure modes need a claim discipline or they turn into confident prose. A living technical book is dangerous if every revision makes claims sound cleaner while their support state stays invisible. The same problem appears in AI systems: hypotheses, design rationales, source-derived statements, proofs, tests, and measurements get blended into a single fluent surface.

The book therefore treats evidence discipline as an architectural layer, not as editorial housekeeping. Each important claim must say what kind of claim it is and what currently supports it. A source note may justify a source-derived discussion. A Lean module may justify a mechanized invariant. A synthetic fixture may justify a narrow test-backed claim. None of those automatically proves the others, and none should borrow confidence from the reader’s trust in the surrounding prose.

That makes evidence states one of the book’s methodological contributions. The proposal is not merely “write caveats.” The proposal is to give claims a finite lifecycle, a support-state ledger, transition records, downgrade paths, non-claim boundaries, and public receipts so that a living architecture can revise itself without laundering confidence.

Within the governed-cognition pattern, the evidence-state layer owns the claim-movement delta. A record becomes an evidence transition only when it names the claim identity, support state, artifact role, review or command receipt, negative-evidence slot, downgrade trigger, acceptance blocker, and explicit non-claims. Other layers can attach evidence gates to their mechanisms; the evidence-state layer defines how confidence is allowed to move at all.

7.5 Why existing approaches are insufficient

Citations, passing validators, proof objects, benchmark scores, and polished prose do not by themselves identify the exact claim atom, evidence role, scope, independence, causal link, negative result, or accepted transition they justify.

Citation lists are not enough. A citation can show lineage, motivation, terminology, contradiction, or external context; it does not automatically support the exact claim being made. Benchmarks are not enough either. Benchmaxxing treats benchmarks as pressure surfaces with lifecycle states, wall diagnoses, anti-Goodhart safeguards, and regression duties, not as permanent definitions of intelligence. Spinoza adds the claim graph and downgrade discipline: failed verification must block or lower confidence. UAT adds adversarial review and proposition tiering under a bounded dossier. Verification Bandwidth adds a further warning: even a large context may not support joint verification of everything inside it.

External evaluation practice supplies the comparison line for this discipline. HELM-style reporting in ext_helm_2022, contamination warnings in ext_benchmark_contamination_2023, Goodhart taxonomy in ext_goodhart_variants_2018, and hard-question benchmarks such as ext_gpqa_2023 all point to the same control problem: a score, citation, or benchmark row needs scope, provenance, and failure semantics before it can move confidence. The book’s support-state machine is a proposed ledger discipline around that problem, not a reproduced evaluation result.

External documentation and formal-methods practice supplies a second comparison line. Model cards (ext_model_cards_2019) and datasheets (ext_datasheets_datasets_2021) show why structured documentation needs intended-use, provenance, limitation, and maintenance boundaries. The ML reproducibility-program account (ext_ml_reproducibility_program_2021) shows why commands, artifacts, code review, checklists, and reviewer-readable claims matter. Proof-carrying code (ext_proof_carrying_code_1997) shows the older formal-methods pattern of pairing an artifact with machine-checkable evidence for a declared policy. Evidence states do not reproduce or replace those methods. They generalize the control question for this book: what exact object is allowed to move this exact claim, and what remains outside the movement?

Mechanistic interpretability supplies a third comparison line. Transformer Circuits (ext_transformer_circuits_2021) and monosemantic feature decomposition (ext_monosemanticity_2023) make internal model evidence visible as a different role from behavioral benchmarks, source citations, or proof artifacts. A circuit analysis or feature decomposition can matter for a claim, but only if the record names the model, layer, behavior, analysis method, artifact refs, negative cases, and limits. Otherwise “we looked inside the model” becomes another kind of citation laundering.

The missing object is the evidence transition. If a claim moves from argument to source-derived, the transition should name the source note and the mapped claim. If it moves to synthetic-test-backed, it should name the fixture, command, environment, and result. If a test fails, the failure should remain visible rather than disappearing into the next draft. The transition is the receipt that lets the book change without losing track of why the change was allowed.

Scope drift is the evidence failure this layer blocks. A source may support terminology but not the mechanism. A schema may support record shape but not the represented event. A proof may support a finite predicate but not the deployed system. A benchmark may support one workload but not a general capability claim. Evidence discipline keeps those scopes locked.

7.6 Core Claim

[evidence-states-and-claim-discipline.core, label: Design rationale, support: argument] Each material claim should have a stable identity, versioned text and scope, claim label, support state, non-aggregating evidence-quality vector, and transition ledger; upward movement is allowed only through an accepted claim-specific transition whose artifacts and evidence roles meet declared gates, while contradiction, failed verification, missing support, and scope mismatch remain eligible to narrow, downgrade, refute, or deprecate the claim.

Reader claim. Evidence changes a claim only through a scoped transition; a failed implementation can refute that implementation without refuting the architecture it attempted to test.

Operational rule. Give every claim stable identity, exact scope, support state, evidence-role vector, prospective transition gate, negative-evidence trigger, and immutable history. Record raw failures first, then audit implementation competence and narrow the affected scope before assigning refuted, downgraded, or untested states.

7.6.1 Worked evidence transition: KERC fails, then the refutation narrows

The KERC campaign prospectively asked whether a configured complete packet could beat a simple total-description baseline at tied task quality. The result was unfavorable: task quality was 0.500000, complete packets averaged 714.0 bytes, and the best simple representation averaged 73.25 bytes. The repository correctly retained the raw result and its historical refuted transition rather than hiding the failure.

A later competence audit examined what the run could actually test. Chance-level task performance, a missing adversarial-polarity training class, small linear cores, a jointly authored compiler and verifier, redundant residual storage, and uncalibrated energy meant the implementation was inadequate for a mechanism- or architecture-level refutation. The usable conclusion narrowed to N1: this frozen implementation failed its configured broad-efficiency test; Kernel English, learned compilation, hierarchical residuals, and the broader architecture remain untested. The transition history does not change, but the maximum inference does. That is claim discipline working, not failure laundering.

The claim remains at argument support. Appendix C records claim-level source-note mappings for the original sources and for the six historical projects as one related local implementation lineage. Those mappings make the evidence bridge more inspectable, but they do not promote the claim. Promotion still requires an accepted evidence transition with evidence whose method, independence, causal effect, and scope match the claim.

7.6.2 Source contribution boundaries

Source	Claim-level contribution	Limit
benchmaxxing	Benchmark lifecycle, ledgers, anti-Goodhart safeguards, regression duties, and residual accounting show why benchmark evidence must be scoped before moving a claim.	No local benchmark result or permanent intelligence metric is proven.
spinoza	Claim tiers, belief revision, contradiction handling, and downgrade/block behavior support explicit support states and failed-verification demotion.	Open-domain autoformalization and arbitrary theorem validity are not proven.
viea	Artifact graphs, claim/verification ledgers, residuals, feedback, benchmarks, and durability rules support durable claim/evidence records.	No completed VIEA deployment or runtime benchmark is proven.
uat	Retrieval-bounded dossiers, proposition states, adversarial review, SME checkpoints, and sign-off support review-aware proposition states.	UAT is not treated as a validated truth-discovery system.
coherence_exchange	Verified Epistemic Units, verification supply chains, contestability, fork, exit, and audit support structured claim/evidence objects.	Speculative epistemic-liquidity framing is not implementation evidence.
verification_bandwidth	The gap between context length and verification workspace supports the rule that source ingestion or context loading is not claim verification.	Contradiction-rate tests and proposed theory remain unrun here.
Six-project local lineage	CCA, MoECOT Manifest, BeastBrain, BugBrain, Corben’s Trainer, and Corben’s Best Model Possible expose recurring gaps between declared architecture and observed effects: fixed versus updated state, internal versus independent checks, queued versus completed work, ownership versus capability, and reports versus causal receipts.	The projects share authorship and mechanisms, were not reproduced as one controlled workload here, and are not six independent confirmations. They supply design and negative-case lineage only.

7.7 Draft Key Figure: Evidence State Ladder

Figure 7.1: Draft evidence-state ladder.

How to read the evidence-state figure: Read the figure as two parallel axes, not as one confidence meter. The claim label says what kind of assertion the book is making, while the support state says what currently backs that assertion. A promotion requires a recorded transition with an exact claim mapping, evidence artifact, command or review reference, scope boundary, blockers, downgrade triggers, and non-claims. Better prose, a nearby source, or a shape-valid fixture can leave the support state unchanged. Failed evidence, contradiction, missing scope, or terminal negative results move downward into demotion, refutation, blocker, residual, or non-claim records. The figure is a draft reader aid, not an accepted evidence transition, external review, proof result, test result, or release approval.

7.8 Mechanism

Evidence discipline is the stack’s anti-inflation mechanism. Benchmaxxing keeps benchmark pressure tied to lifecycle, wall diagnosis, anti-Goodhart safeguards, and regression duties. Spinoza separates claim tiers, verification, contradiction, and downgrade behavior. VIEA keeps claims, artifacts, residuals, feedback, and regression coverage durable. UAT adds retrieval-bounded proposition review and human adjudication checkpoints. Coherence Exchange contributes contestability language but remains speculative where it exceeds implemented evidence flow. Verification Bandwidth blocks the shortcut from “loaded enough context” to “verified the claim.”

As a methodology, the layer turns those ingredients into a repeatable discipline. A claim can be drafted in prose, mapped to a source, checked by a proof, tested by a fixture, challenged by a reviewer, rejected by a negative result, or retired after contradiction. The support state changes only when the transition record says exactly which event occurred and which part of the claim it touches.

A support-state transition gate makes that anti-inflation rule operational.

flowchart LR
  A["Claim drafted"] --> B["Claim label"]
  A --> C["Support state: argument"]
  C --> D{"Exact mapping +<br/>accepted transition?"}
  D -- "yes" --> E["source-derived"]
  C --> F{"Validated schema / proof / test artifact?"}
  F -- "Lean build" --> G["Mechanized claim label within formal scope"]
  F -- "fixture or experiment" --> H["synthetic-test-backed or empirical-test-backed"]
  D -- "no" --> I["remain argument"]
  F -- "fail / inconclusive" --> J["negative result / residual"]
  E --> K["Appendix C + changelog"]
  G --> K
  H --> K
  J --> K

How to read the support state gate: The support-state gate blocks confidence from moving just because prose improved. A claim can rise only through a mapped source transition, validated proof/test artifact, or recorded negative result pathway, and every movement updates the public ledger.

Appendix C is the public claim ledger, but the ledger is not a shortcut around review. Claim labels and support states remain separate so design rationales, hypotheses, measurements, mechanisms, and speculative claims are not collapsed. Source notes are prerequisites for source-derived movement, not automatic promotion. Test-backed movement requires an evidence bundle with the command, environment, result, limitations, and negative or inconclusive results where they exist.

The claim record carries the pre-transition state: whether the claim has no mapping, a source-note map, reviewed raw passages, an evidence packet, a blocked mapping, or a deprecated surface. It also carries the evidence-readiness state and the next evidence required before review. The transition record then decides whether that readiness changes support. A shape-valid fixture can show that the record is well formed; it cannot accept the transition for the reader. The receipt faithfulness fixture at experiments/receipt_faithfulness/results/2026-07-03-local.json makes that boundary concrete for artifact receipts: syntactic receipt shape, trap handling, cross-check presence, and attestation limits can be checked without moving the support state. The epistemic trusted computing base fixture at experiments/epistemic_tcb/results/2026-07-03-local.json adds the companion boundary for verifier trust: a support review needs a named root of trust, bounded delegation rule, recursion stop condition, verifier independence state, outside-TCB residuals, and non-claims before verifier output can even be considered for support movement.

Reviewer degradation is another support-state boundary. This reviewer degradation check appears in the human oversight degradation fixture at experiments/human_oversight_degradation/results/2026-07-03-local.json, which checks finite records for approval fatigue, rubber-stamping, alarm fatigue, automation bias, missing reviewer qualification, support-state promotion from approval shape, and missing non-claims. It lets the book say that degraded review should be routed, not that a human approval record proves reviewer correctness or deployed approval-service quality.

The QCSA adjudication is a worked example of why a result file cannot carry one global verdict. Under the exact 180-record corpus, task-decision Brier score was 0.082026 for QCSA and 0.298500 for the selected baseline, with selective risk 0 for both. That exact calibration claim receives a non-core synthetic-test-backed transition. The matched task-advantage claim is instead refuted because both systems reached 1.000 task-decision accuracy while QCSA used 1.913386 times the operations. Open-world transfer remains no_change. The shared bundle therefore yields one bounded promotion, one exact refutation, and one preserved absence without moving any chapter core.

The gate separates two axes. Claim labels describe what kind of assertion is being made: design rationale, hypothesis, measurement, mechanism, demonstration, mechanized invariant, or speculation. Support states describe what artifact currently backs it: argument, source-derived mapping, prototype inspection, synthetic test, empirical test, external literature, refutation, or deprecation. Mixing these axes creates evidence inflation.

Interpretability evidence lives inside that separation. A circuit trace, activation patch, sparse-autoencoder feature, or other white-box artifact can be an evidence role, but it does not become its own magical support state. The record must say which model and layer were inspected, which behavior or mechanism was in scope, which intervention or analysis produced the artifact, which counterexamples or negative controls were checked, and which broader safety, capability, deployment, or model-quality claims remain unsupported. That keeps mechanistic evidence useful without letting it overrule failed behavioral tests, missing proof scope, or absent deployment evidence.

The layer also preserves negative information. A failed proof attempt, benchmark wall, contradiction, missing source, or invalid fixture is not clutter. It is the information that prevents the stack from ratcheting in the wrong direction.

Promotion should therefore be treated as a burden, not a reward. The default move is to leave support unchanged until the exact claim, artifact, command, review status, and limitations align. Downgrade requires less ceremony: contradiction, missing support, scope mismatch, or failed verification is enough to move a claim downward or into residual status.

7.8.1 The evidence cell

The evidence-state layer owns the evidence cell because adjacent layers produce evidence, evaluate benchmarks, or retain artifacts, while this layer decides what those records are allowed to do to a claim. An evidence cell is not another confidence score. It is a non-aggregating record of origin, method, independence, demonstrated effect, missing links, and claim boundary. The same passing result can therefore remain a dependent fixture, become a reproduced mechanism check, or block promotion, depending on how it was produced and what causal link it actually observed.

The six-project lineage supplies the motivating failure case. Corben’s Best Model Possible contains a first-party recurrent-model surface, lane-specific adaptors, verification rows, and a response path. Inspection nevertheless found a generated or frozen trunk, adaptor-only updates, explicit rather than autonomous lane selection, dependent or shape-based checks, and responses not generally caused by a checkpoint-driven decoder. Corben’s Trainer separately shows that typed runs, content-addressed artifacts, and promotion records can coexist with null seed/code identity and promotions whose inputs were later quarantined. The non-obvious consequence is that implementation ownership, interface presence, and green records may all be true while the capability proposition remains unsupported.

An evidence cell therefore carries five coupled controls:

1. A causal capability chain binds data, objective, code, actually updated state, runtime output, independent evaluation, and the exact claim. A missing link is recorded rather than inferred from neighboring links.
2. A trainable-state manifest distinguishes generated, frozen, pretrained, trainable, optimizer-only, and actually updated state. “Trainable” without an update receipt is not “trained.”
3. A response-causality receipt binds checkpoint, request, decode path, tool substitutions, and final response. A metric on an adaptor or helper component cannot support returned-answer capability when the runtime bypasses it.
4. Honest missingness classifies absent evidence as unknown, not_attempted, not_required, or waived, with a blocker or waiver authority. Missing evidence cannot default to passed, independent, hardware-observed, or real.
5. Ownership/capability separation records whether a component is first-party, third-party, mixed, or unknown separately from whether its mechanism was exercised, produced an observed runtime effect, or was independently evaluated.

PROV-O supplies interoperable vocabulary for entity, activity, agent, derivation, attribution, delegation, revision, and invalidation, but a provenance assertion remains a separate object from evidence truth, completeness, integrity, authority, and receipt faithfulness. The evidence cell records both surfaces so a well-formed lineage graph cannot silently become a claim that the represented event occurred or that its producer was authorized.

flowchart LR
  D["Data + objective + code"] --> U["Actually updated state"]
  U --> R["Runtime output"]
  R --> V["Evaluation"]
  V --> C["Exact claim binding"]
  M["Missing link"] -. "unknown / not attempted / not required / waived" .-> C
  O["Ownership record"] -. "never substitutes for" .-> V
  I["Method + independence"] --> V
  C --> E{"Evidence-cell disposition"}
  E -->|"scope complete"| T["eligible for transition review"]
  E -->|"lineage / dependent / incomplete"| B["argument only or blocks promotion"]

How to read the evidence cell: the solid path is deliberately conjunctive. A source tree, loss curve, checkpoint, runtime answer, or evaluator row is only one link. The dotted paths preserve honest absence and ownership without letting either masquerade as evaluation. The cell does not promote a claim; it makes the promotion burden inspectable.

The strongest objection is record proliferation: sufficiently elaborate metadata can consume verification bandwidth while creating a false feeling of rigor. The answer is to keep the cell claim-scoped and sparse. It records only distinctions capable of changing a transition decision, requires artifact references for positive causal links, and permits an exact blocker instead of demanding fabricated completeness. If a simpler baseline reaches the same claim decision without a field, that field should be removed.

7.9 Interfaces

Evidence movement is mediated by the Evidence Transition Record plus the Claim Record through four exact handoffs:

• Drafting proposes versioned claim-text, scope, label, and dependency changes without creating a support-state effect.
• Source ingestion, proofs, experiments, interpretability analyses, reproduction, and review emit evidence packets with exact roles, provenance, independence, negative evidence, limitations, and claim bindings.
• A named transition authority accepts, rejects, narrows, downgrades, refutes, or deprecates a proposed change and records blockers, residuals, supersession lineage, and the changelog reference.
• Appendix C, chapter markers, status surfaces, release artifacts, and reader derivatives consume the accepted canonical claim state and cannot strengthen it independently.

Minimum claim record fields:

• claim_id
• text
• claim_scope
• claim_label
• support_state
• lifecycle_state
• source_mapping_status
• source_mapping_refs
• evidence_readiness_state
• source_handles
• surface_refs
• tests
• uncertainty
• contradictions
• contradiction_state
• review_status
• revision_history_refs
• required_next_evidence
• promotion_blockers
• support_state_effect
• non_claims

Minimum evidence transition fields:

• transition_id
• claim_id
• claim_surface_refs
• claim_record_refs
• old_support_state
• new_support_state
• transition_effect
• transition_validity_state
• scope_boundary
• evidence_roles
• transition_reason
• required_artifacts
• artifact_refs
• evidence_packet_refs
• source_mapping_refs
• verification_command
• verification_result
• negative_results
• negative_evidence_refs
• downgrade_triggers
• promotion_burden
• limitations
• review_status
• reviewer_refs
• reviewer_independence
• acceptance_blockers
• changelog_ref
• support_state_effect
• non_claims

Drafting updates claim text and labels. Source ingestion adds source notes and source-to-claim mappings. Proof and code work adds commands, fixtures, modules, and results. The changelog records meaningful evidence movement. Appendix C remains the public ledger that keeps those transitions visible.

Evidence roles must stay separate: lineage, motivation, terminology, direct support, contradiction, failed support, reproduced result, source-reported result, local fixture, formal predicate, mechanistic interpretability artifact, and empirical measurement. A single artifact can play one role without playing all of them.

7.10 Invariants

• No claim may cite source support or a test result whose referenced artifact and exact claim binding do not exist.
• No reported command, proof, experiment, reproduction, review, or result may be fabricated, silently substituted, or assigned a stronger evidence role than the observed artifact supports.
• Negative, null, inconclusive, failed, blocked, and contradictory results remain visible with their original scope and lineage.
• A capability claim cannot splice causal-chain links across incompatible runs or lineages.
• First-party ownership, interface presence, and trainable declarations cannot substitute for an observed task-relevant effect.
• Claim wording or scope cannot strengthen without an accepted transition or an explicit reset to a support state that the retained evidence justifies.
• No evidence-quality dimension may compensate automatically for a failed hard gate or missing dimension.
• Finite record, proof, provenance, or verifier completeness cannot imply complete embedded-world, whole-agent, descendant, or open-world correctness.

Asymmetry is the strongest evidence-state rule: support can move up only when the required artifact exists, but support can move down whenever contradiction, failure, missing evidence, or scope mismatch is found. Appendix C deliberately remains conservative after source-note coverage improves because source notes are necessary context, not automatic claim promotion.

Scope non-expansion follows from that asymmetry. A claim cannot inherit broader scope from a nearby chapter, source family, proof module, or benchmark run unless the evidence transition explicitly names that broader scope and its residual risks.

The non-aggregating vector preserves the same rule across evidence quality. Recency cannot cancel dependence, reproducibility cannot cancel invalidity, artifact access cannot cancel a missing causal link, and adversarial strength cannot cancel testing the wrong construct. A failed hard gate remains failed.

Finite completeness is also bounded. A complete schema, provenance graph, proof object, or verifier record can close a declared finite predicate without closing the embedded system, its environment, its descendants, shared blind spots, or effects outside the observation model.

Promotion records also preserve downgraded and rejected transitions, so failed evidence attempts remain part of later interpretation.

7.11 Failure modes

• Support-state inflation.
• Citation laundering.
• Silent removal of failed claims.
• Ownership laundering: first-party or locally executed components are described as capable without a task-relevant effect.
• Causal-chain splicing: data, updates, outputs, and evaluations from different runs or lineages are narrated as one experiment.
• Missingness laundering: skipped, absent, or inapplicable evidence is serialized as green.
• Benchmark laundering generalizes a score beyond its frozen workload, evaluator, contamination, uncertainty, and transfer boundary.
• Proof laundering expands a finite theorem beyond its assumptions, modeled state, refinement bridge, or exercised consumer.
• Interpretability laundering turns a scoped internal-model artifact into unsupported behavioral, capability, safety, or deployment evidence.
• Evidence smoothing improves prose by removing caveats, failures, or residuals while leaving the apparent claim strength unchanged or higher.
• Provenance laundering treats asserted derivation, attribution, or conformance as evidence truth, completeness, integrity, authority, or effect.
• Independence laundering labels self-review, shared-model review, or shared-data review as independent without recording the shared failure surface.

Citation laundering is the common failure: a nearby source is used to make an unsupported claim feel sourced. Benchmark laundering is the analogous measurement failure: a run result is generalized beyond its scope. Proof laundering happens when a small formal invariant is rhetorically expanded into a whole-system guarantee. The correction is scope discipline. The evidence artifact says exactly what it supports and exactly what it does not support.

Evidence smoothing is a prose-quality failure with epistemic consequences. A revision improves prose by removing caveats, failed attempts, or open gaps while leaving the support state unchanged. The text becomes easier to read and less true.

7.12 Minimum Viable Implementation

The smallest honest evidence-control surface is a canonical claim record, evidence transition record, non-aggregating evidence cell, public Appendix C projection, one bounded six-project lineage cell, and executable positive and rejecting suites for missing bindings, absent evidence, negative-result deletion, dimension aggregation, scope strengthening, lineage splicing, false independence, stale projections, and support-state laundering, with no chapter- core support movement. The existing schemas, fixtures, transition harnesses, and Lean module implement portions of that boundary; they do not yet establish the complete mature consumer path.

python3 scripts/validate_evidence_cells.py rejects a missing causal stage, missingness serialized as passed, ownership used as capability, an updated tensor without a trainable classification and update receipt, and an independence claim whose producer and verifier are the same component. It validates record semantics only. It does not reproduce the projects, establish that their source notes are complete, prove model capability, or move the core claim.

The support-state harness exercises synthetic no-change, upward, downward, and terminal refutation transitions. The evidence-bundle, claim-ledger, accepted-transition, and claim-state audits preserve their historical bounded results. The stronger refinement replaces the old Boolean checklist with a reachable six-stage lifecycle. It freezes atom and projection identities; derives state-specific evidence requests from the proposed target; carries negative-evidence, downgrade, supersession, review, dissent, limitation, residual, changelog, handoff, and acknowledgment duties; and rejects replay, substitution, inherited movement, support assignment, and external effects. Its independent Python consumer reaches all 35 declared routes with natural positive and mutation cases rather than copying a prevalidated Lean summary. The foundational module retains only narrow deductive support-state facts. These artifacts leave chapter core claims unchanged unless a separate named authority accepts a claim-specific transition.

An evidence-receipt suite is the right first exercise: one lineage-only source, one direct-support source, one failed verification, one schema-only validation, one finite Lean predicate, and one benchmark result whose scope is deliberately narrower than the prose claim.

7.13 Mature Research Target

The mature claim-accounting system maintains a versioned graph of material claims, scopes, dependencies, evidence packets, contradictions, transitions, terminal dispositions, and public projections; independently governed transition consumers enforce claim-specific promotion and asymmetric downgrade gates, preserve non-aggregating evidence-quality dimensions and negative results, challenge receipt faithfulness and shared evaluator failures, revalidate affected claims after model, policy, ontology, source, or artifact change, and measure adjudication accuracy, time, false promotion, false downgrade, stale-state escape, reproduction burden, reader traceability, and governance cost without equating ledger completeness with truth.

The beyond-SOTA endpoint is a living research method, not only a better appendix. It would make the book inspectable the way model cards make model reports inspectable, datasheets make datasets inspectable, reproducibility checklists make experiments inspectable, and proof-carrying systems make policy evidence inspectable, while preserving a stricter claim-level question: did this exact evidence object justify this exact support-state movement?

In that system, each material claim carries separate identity, wording, scope, label, support, lifecycle, evidence-quality, and transition state. Appendix C is the public projection rather than the canonical decision authority. Source notes are necessary but not sufficient for source-derived movement, and test- backed movement requires claim-specific bundles that keep negative, null, and inconclusive results attached.

The mature workflow would make drafting, experiments, proof checks, release records, and changelog entries part of one evidence loop. Drafting can introduce or refine claims; experiments can update evidence; proof artifacts can mechanize narrow predicates; changelog entries can record why support moved or did not move. Support-state inflation, citation laundering, and silent removal of failed claims would become ledger corrections, demotions, residual records, or review escalations rather than confidence creep.

This ledger is a proposed evidence-control system for the book and stack. Its support stays at argument until claim-transition records, passage-reviewed source notes, evidence-bundle fixtures, citation-laundering checks, proof-scope audits, and changelog-linked reviews demonstrate that labels move only when their artifacts justify movement.

7.14 Codex test plan

Test	Purpose	Status
Claim record validation	Check that the claim fixture records source mapping status, source mapping refs, evidence readiness state, required next evidence, promotion blockers, support-state effect, and non-claims.	implemented by protocol validation; validated locally
Evidence transition record validation	Check that the transition fixture records support states, claim surface refs, claim record refs, transition effect, transition validity state, scope boundary, evidence roles, evidence packet refs, source mapping refs, negative evidence refs, verification result, downgrade triggers, promotion burden, limitations, reviewer refs, reviewer independence, acceptance blockers, changelog ref, support-state effect, and non-claims.	implemented by protocol validation; validated locally
Historical-project evidence cell	Check one valid six-project lineage cell plus expected-invalid mutations for causal-chain gaps, dishonest missingness, ownership/capability conflation, unsupported trainable-state updates, and false verifier independence.	implemented by python3 scripts/validate_evidence_cells.py; record semantics only; no project reproduction or support-state promotion
Support-state transition test	Check synthetic no-change, upward, downward, and terminal refutation evidence-transition records, including invalid controls for unreviewed promotion, failed verification, reasonless demotion, and unsupported refutation.	implemented; validated locally
Projection-aware evidence-transition refinement	Check a six-stage reachable lifecycle for exact atom/proposition/obligation/predicate bindings, non-aggregating target evidence, adverse-transition burden, review and dissent, decision residuals, exact ledger handoff, acknowledgment, and rejection of replay, authority leakage, or inherited movement.	implemented by AsiStackProofs.EvidenceTransitionRefinement and independently exercised by python3 scripts/validate_evidence_transition_refinement.py; 35/35 routes reached; support, inheritance, and external-effect authority remain none
Evidence bundle completeness and changelog-consistency probe	Check two valid synthetic evidence bundles and seven expected-invalid controls for no-change records, blocked promotion, artifact/result refs, commands, changelog refs, limitations, non-claims, stale changelogs, fixture overclaims, and no support-state transition. Result: experiments/evidence_bundle_completeness/results/2026-07-02-local.json.	bounded executable audit retained as a consumer; no claim that a generic Lean theorem reproduces its repository snapshot or establishes evidence truth
Claim ledger completeness audit	Check the real Appendix C ledger against its recorded manifest snapshot, labels, support states, assigned sources, open gaps, promotion paths, duplicate/stale rows, and mutation controls. Result: experiments/claim_ledger_completeness/results/2026-07-02-local.json.	bounded executable audit retained as a consumer; the reachable ClaimLedgerRefinement owns the formal append/materialize/acknowledge path
Accepted live transition review audit	Check the recorded accepted transitions and no-promotion ledger for review status, changelog refs, evidence packets, limitations, independence disclosure, non-claims, bounded non-core movement, and mutation controls. Result: experiments/accepted_transition_review/results/2026-07-02-local.json.	bounded historical audit retained; it does not approve a new transition or establish evidence or reviewer truth
Claim-state transition bridge	Check synthetic narrowing, downgrade, and refutation records plus mutation controls. Result: experiments/claim_state_transition_bridge/results/2026-07-04-local.json.	bounded executable consumer retained; adverse intent is now represented in the reachable refinement without moving any live claim

7.14.1 Formalization hooks

Tag	Module	Target	Status
lean:evidence.support_state.operational_invariant	AsiStackProofs.EvidenceTransitionRefinement	A reachable lifecycle freezes exact atom and proposition/obligation/predicate projections, derives non-aggregating target evidence, preserves negative evidence and non-claims, and cannot assign support, move related claims, or create external effects.	implemented
lean:evidence.support_state.failure_blocks_promotion	AsiStackProofs.EvidenceStates	A claim cannot be promoted when required evidence is absent.	implemented
lean:evidence.support_state.transition_lifecycle_route	AsiStackProofs.EvidenceTransitionRefinement	Six reachable stages preserve three claim projections and route state-specific evidence, adverse-transition, review, decision, handoff, replay, substitution, and authority failures to explicit outcomes; an independent consumer reaches every declared route.	implemented

The local Lean workspace separates foundational support-state facts from the reachable transition refinement. C6 retires the remaining sixteen fixture-normalization theorems and does not replace four historical repository audits with pretend formal mirrors. Those audits remain executable consumers at their exact recorded scope. The new lifecycle proves the reusable control boundary and the independent consumer challenges every route. These formal results do not prove source truth, semantic equivalence of the three projections, reviewer quality, artifact correctness, or the correctness of a live support decision.

7.15 Source crosswalk

Source ID	Title	Layer	Planned use	Readiness
benchmaxxing	Benchmaxxing: The Performance Ratchet	benchmarks_evidence	Benchmarks as pressure surfaces, saturation -> regression, harder frontier, anti-Goodhart safeguards.	source note available; local raw cache available
spinoza	Proof of Belief / The Spinoza Architecture	reasoning_epistemology	Neurosymbolic belief, transparent axiomatic AI belief systems, verification, belief revision.	source note available; local raw cache available
viea	Verified Intent-to-Execution Architecture	whole_stack_execution_spine	Keystone source. Human intent -> command contracts -> artifacts -> routing -> runtime targets -> verification -> deployment -> feedback.	source note available; local raw cache available
uat	Unified Adaptive Tribunal	evaluation_refinement	Multi-AI collaborative refinement/evaluation protocol.	source note available; local raw cache available
coherence_exchange	The Coherence Exchange	epistemic_market_synthesis	Found in AI generated paper dump. Use carefully; speculative synthesis of PlanForge, Spinoza, Talos, UAT, Alignment Field.	source note available; connector or recovery required
verification_bandwidth	Verification Bandwidth in Bounded Contexts	context_verification_theory	Generation vs verification; long context is not automatically long-range reasoning.	source note available; local raw cache available
ext_model_cards_2019	Model Cards for Model Reporting	model_reporting	External comparator for structured model reporting, intended-use boundaries, evaluation disclosures, and limitation reporting.	source note available; comparator only
ext_datasheets_datasets_2021	Datasheets for Datasets	dataset_documentation	External comparator for provenance, composition, use, maintenance, and accountability documentation.	source note available; comparator only
ext_ml_reproducibility_program_2021	Improving Reproducibility in Machine Learning Research	ml_reproducibility_reporting	External comparator for checklists, code submission, reproducibility reports, artifact review, and reviewer-readable replay expectations.	source note available; comparator only
ext_proof_carrying_code_1997	Proof-Carrying Code	formal_methods	External comparator for pairing artifacts with machine-checkable evidence scoped to a declared host policy.	source note available; comparator only
ext_w3c_prov_o_2013	PROV-O: The PROV Ontology	interoperable_provenance_model	Interoperable vocabulary for entity/activity/agent provenance, derivation, attribution, revision, delegation, and invalidation.	source note available
cca_project	Compiled Cognitive Architecture project	local_project_lineage	Closure-authority inheritance, optimizer-to-capability trace discipline, and failure retention.	source note available
moecot_manifest_project	MoECOT Manifest compiler-era project	local_project_lineage	Contract breadth versus external-holdout reality, evidence/promotion states, and execution-versus-mutation authority.	source note available
beastbrain_project	BeastBrain historical AI system project	local_project_lineage	Simulated-versus-measured separation, non-updating routers, default-success tribunals, and interface/capability separation.	source note available
bugbrain_project	BugBrain bare-metal neuro-symbolic intelligence project	local_project_lineage	Capacity-versus-active-state separation, skipped-as-green readiness, trace-loss failures, and authority/effect gaps.	source note available
corbens_trainer_project	Corben’s Trainer epistemic training and evaluation control plane	local_project_lineage	Learning-truth records, seed/code identity gaps, quarantine inheritance, and report/canonical-state separation.	source note available
corbens_best_model_possible_project	Corben’s Best Model Possible recurrent-model and mechanism laboratory	local_project_lineage	Trainable-state manifest, response-causality receipt, verification independence, ownership/capability separation, and mixed metric provenance.	source note available

The crosswalk names the evidence vocabulary loaded for the evidence-state layer. The external comparators position the method against known reporting, reproducibility, and proof-carrying practices. They do not assert a local model-card workflow, datasheet workflow, external reproducibility review, proof-carrying-code implementation, or support-state promotion. Support movement still requires an exact transition record, source mapping, proof, test, or external-literature citation.

7.15.1 Manifest source assignment reconciliation

These rows keep Evidence States and Claim Discipline’s manifest assignments visible at their recorded review boundary. Passage review does not establish local reproduction, performance, safety, deployment, or support-state movement.

Source	Intake role	Boundary
ext_unlearning_benchmarks_weak_2024	Passage-reviewed comparator: Position: LLM Unlearning Benchmarks are Weak Measures of Progress. Supports treating unlearning benchmark validity, target ambiguity, forget/retain dependence, and benign perturbation robustness as separate evidence burdens.	The position paper raises the interpretation standard but does not validate the local workload or establish influence, privacy, legal erasure, or storage erasure. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
ext_embedded_agency_2019	Passage-reviewed comparator: Embedded Agency. Motivates separating finite record-level guarantees from claims about the complete embedded agent, environment, self-model, or future descendants.	The paper is an informal obstacle survey, not a solved theory; the ASI Stack’s finite records and proofs do not solve logical uncertainty, self-reference, robust delegation, subsystem alignment, or open-world embedded agency. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
assurance_shift_learning	Passage-reviewed comparator: When Success Stops Teaching: Assurance-Shift Learning and Governed Residual Boundary Learning for Mature AI Systems. Adds the Qualified Competence Envelope as a versioned, distribution-, time-, region-, and evaluator-relative evidence claim rather than an assertion of competence truth.	The source does not promote any evidence state or establish envelope completeness. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
adjudicated_persistence	Passage-reviewed comparator: The six-object persistence transaction. Adds persistence disposition, realization, qualification, and authority as separate downstream objects so evidence support cannot be laundered into a durable update.	Used only to separate evidentiary support from disposition, realization, qualification, and authority; it supplies no implemented transaction or validated support promotion. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.

7.16 Summary

Evidence States and Claim Discipline is the book’s anti-inflation layer and one half of its methodological contribution with Living Book Methodology. It lets the manuscript be ambitious without pretending that design rationales, source notes, schemas, Lean proofs, benchmarks, and empirical results are the same thing.

The layer is deliberately conservative. Source-note coverage improves drafting readiness, but claim support rises only after exact mappings or artifacts exist. The evidence cell now makes that rule concrete for the mined project lineage: architecture ownership, trainable interfaces, internal checks, and durable records remain separate from an observed end-to-end capability chain. The path next tests the same discipline where it becomes operationally difficult: whether a limited supervisor may interpret stronger system behavior without a protocol record, an outcome audit, or an escalation route.

A reader should be able to ask “why is this claim allowed to sound this strong?” and find a precise answer. If the answer is only confidence, fluency, or proximity to a source, the claim is speaking past its evidence.

7.17 Evidence reconciliation (2026-07-16)

The invariant protocol, field meanings, and inference limits are stated once in Living Book Methodology. This packet contains only the chapter-specific projection; its authoritative per-atom rows are the evidence-states-and-claim-discipline slice of experiments/claim_family_terminal_coverage/results/result.json.

The core remains blocked after full attempt at argument support. The strongest family attempt was Governed usefulness confirmatory campaign. Its exact boundary is: Bounded local non-core governance effect only; no family-wide truth, transfer, deployment, or chapter-core promotion. Across 46 atoms, the terminal ledger records 39 blocked_after_full_attempt; 7 retained_after_full_attempt.

Chapter-specific field	Value
Family / atom denominator	CF-01 / 46 atoms
Terminal dispositions	39 blocked_after_full_attempt; 7 retained_after_full_attempt
Core	evidence-states-and-claim-discipline.core: blocked_after_full_attempt at argument
Core attempted / missing lanes	executable, formal, source-synthesis / causal, empirical, normative, transfer
Attempted local lanes	executable, formal, source-synthesis
Missing or unproved lanes	causal, empirical, executable, formal, normative, transfer
Strongest family bundle	Governed usefulness confirmatory campaign (natural_work): One fresh 16-task held-out local confirmatory denominator after a separately frozen 40-candidate tuning pool.
Negative controls	simple baseline; evidence-freshness ablation; six co-primary checks; validator-owned laundering mutations.
Accepted transitions	v1_0_pilot.evidence_states.no_change
Maximum inference	Bounded local non-core governance effect only; no family-wide truth, transfer, deployment, or chapter-core promotion.
Reproduction / next burden	Replay scripts/validate_p4_governed_usefulness_confirmatory.py and scripts/validate_claim_family_terminal_program.py; fill the named atom-specific lanes under a new prospective protocol.

7.18 Handoff

Evidence discipline governs what a record may justify; Scalable Oversight and Adversarial AI Control governs how a limited supervisor may inspect a stronger system without turning a role label or a persuasive transcript into evidence. That oversight boundary then carries into the human principal’s formal goal, means, authority grant, stop condition, and ambiguity rules. Finite records do not close the embedded world.

ext_embedded_agency_2019 supplies a limit that applies to every evidence state: the system producing, checking, and storing a record is part of the world the record describes. Its model is bounded, its verifier can share blind spots, and its subsystems can disagree or coordinate. A schema-valid artifact may be necessary for a claim transition while remaining radically incomplete as a model of the embedded system.

Each evidence cell therefore names observation scope, trusted components, recursion stop, external or independent observation route, ontology/model version, and outside-model residuals. The ledger may prove that a finite predicate holds over declared records. It may not infer whole-agent correctness, complete causal influence, open-world receipt faithfulness, or future-descendant behavior from record completeness.

ext_embedded_agency_2019 | Metadata-first comparator: Embedded Agency. Primary informal survey of the obstacles that arise when agents are physical parts of the worlds they model, must use smaller internal models, and reason about modifiable internal parts. It supplies a foundations boundary; the book’s finite records, authority ceilings, and proofs do not solve embedded agency. | No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row. |