diff --git a/docs/audits/2026-11-16-trope-stack-proof-audit.adoc b/docs/audits/2026-11-16-trope-stack-proof-audit.adoc new file mode 100644 index 0000000..80492ad --- /dev/null +++ b/docs/audits/2026-11-16-trope-stack-proof-audit.adoc @@ -0,0 +1,797 @@ +// SPDX-FileCopyrightText: © 2026 Jonathan D.A. Jewell (hyperpolymath) +// SPDX-License-Identifier: CC-BY-SA-4.0 += Trope Stack Proof Audit +:toc: preamble +:revdate: 2026-11-16 + +Proof audit · 16 November 2026 + +Proof architecture and claim faithfulness across trope-checker, haec, hermeneia, vocarium, the particularity workbench and mathesis + +The design is right and the central records are honest; the machinery that turns evidence into grades has three holes — unresolved declaration names, unverified receipt commits, and a collapsed top rung — and the prose that sits beside the proofs has drifted where nothing gates it. + +The audit’s one-line summary for the owner, from section 5. + +* *8* areas audited +* *68* candidate findings +* *38* confirmed by two independent checks +* *30* refuted +* about *30* distinct defects + +[[census-label]] +Derived Proof Witness Grade census, trope-checker, 24 theory obligations + +* PWG-1: *0* + + +* PWG-2ii: *0* (by construction) + + +* PWG-2i: *0* + + +* PWG-3: *17* + + +* ungraded: *7* + + +The strongest rung is on the left: under PROOF-POLICY §8 a lower PWG number is a stronger grade. The PWG-2ii count is zero by construction, not by measurement, because the derivation’s 2ii branch can never be reached (section 1, weakness b). If the two owner-blocked rows in section 5, item 4 go ungraded, PWG-3 falls to 15. + +[[kernel-h]] +== What ran a kernel, and what did not + +The audit read source only. Its container had no Agda, Lean, Rocq, Idris2 or Dedukti binary, so nothing in the verdict below is a kernel result. + +Kernels did run in CI. On https://github.com/hyperpolymath/trope-checker/pull/117[trope-checker#117] at commit `c8d6c5c`, the Agda job ran the canonical PROOF-POLICY §2.1 invocation against agda-stdlib 2.0 and logged `PASS: All.agda + Smoke.agda typecheck (--safe --without-K --cubical-compatible; --safe => postulate-free by construction)`. Both Lean packages passed their jobs, which run `lake build --wfail`, leanchecker and the pinned axiom audit. Those results are receipted in CI and were not reproduced here. + +*Scope note, stated once and binding on everything below.* No kernel ran. There is no `agda`, `lean`, `lake`, `rocq`/`coq`, `idris2` or `dedukti` binary on this container, and none was installed. Nothing in this verdict is a kernel result. Every statement about a theorem is a reading of a declaration and its stated type, and every statement about a grade is a reading of a ledger, a derivation script and a receipt that was not reproduced. Where I say a claim is wider than its theorem, I mean the written type does not support the written sentence — not that the proof fails. + +''''' + +[[1-are-the-proofs-correctly-designed]] +== 1. Are the proofs correctly designed? + +*The architecture is sound in its division of labour and weak at its joins.* + +=== What is sound + +*Prover roles are assigned on principle and the assignment is enforced, not just declared.* Agda is the normative kernel (trope-checker ADR 0005 D4, `docs/decisions/0005-v0.2-consolidation-o5-and-prover-roles.adoc:61-68`), Lean and Rocq are recheck legs, and Idris2 is an executable engineering restatement held off the ladder. That last point is the single cleanest structural result in this audit: Idris2 appears in `verification/pwg.json` only under `reference.idris2`, never under `legs`, and `scripts/pwg-derive.sh:99-106` reads only `.legs.agda`, `.legs.rocq`, `.legs.lean`. No Idris2 evidence can raise or lower any grade, which is exactly what PROOF-POLICY §8.1 requires, and the published 24/17/7 census together with the "three ungraded rows are Idris2-only" narrative reconcile with the ledger exactly. + +*Grades are derived, not asserted, and this is mechanically guaranteed.* No theorem record in `pwg.json` carries a `pwg`, `grade` or `PWG` key; the string `PWG-` does not occur in the file at all. `pwg-check.sh` enforces that, and byte-matches the derived census against the published line at `docs/status/PROOF-STATUS.adoc:296`. §8.4 rule 2 and rule 7 are implemented as designed. + +*The repo boundary is drawn in the right place and respected downstream.* The grade algebra lives in trope-checker; haec, hermeneia and vocarium do not re-implement it. All three identify their entire `verification/proofs/` tree as the unmodified mint template, refuse to count it as evidence, and publish a census of 0 done of 7 with its denominator. That is the doctrine-10 ethos working as intended, and it is the strongest documentary result in the whole stack. + +*The two-carrier discipline is right.* Pre-ratification and ratified carriers coexist, with the historical theorems retained as history rather than deleted (doctrine 7), and the central records police the distinction — the C3 row demotes `dropped_absorbing` precisely on that ground. + +*mathesis's catalogue design is correct and structurally prevents the failure it exists to prevent.* A claim row pins a receipt by SHA-256, the receipt is fetched at `source_commit`, and it is handed to a canon reader pinned by hash (`deed_lint.js` at standards `e5a39d7` hashes to `37ff85be…`, exactly the `READER.sha256` pin at `claims-registry.mjs:69`). The reader _derives_ `pwg` from the recheck legs and refuses any receipt whose recorded `:pwg` disagrees. mathesis therefore cannot assign a grade even by mistake — it catalogues, deriving, which is what §8.5 requires. + +=== What is structurally weak + +*(a) The one field that links a grade to a theorem is read by no machine.* `grep -n declarations scripts/pwg-check.sh scripts/pwg-derive.sh` returns nothing: the string does not occur in either script. The receipts attest that `All.agda` and `Smoke.agda` typecheck; they attest nothing about whether the named declarations are the ones that did. Thirteen of the ninety-five declaration strings in the ledger do not resolve to any declaration spelled that way in the source, and `bash scripts/pwg-check.sh` exits 0 and prints PASS on that tree. This is the deepest architectural defect, because it is the exact seam between the evidence layer and the proofs. + +*(b) The top rung of the ladder is degenerate.* The `"2ii"` else-branch at `pwg-derive.sh:113-115` is unreachable: arriving there already entails all three of its conjuncts (`counts()` at :93 and `pwg3_receipt` at :103 are strictly stronger). PWG-1 is therefore granted the moment PWG-2ii is reached, on zero additional evidence, against §8.2's "PWG-2ii, *plus* …". Confirmed behaviourally across four perturbed ledgers: the only values ever emitted were `1`, `3`, `not-applicable` and `ungraded` — never `2ii`. The published `PWG-2ii 0` is a structural certainty, not a measurement. + +*(c) Receipt freshness is a hand-written string.* `usable_receipt` (`pwg-derive.sh:64`) tests only `state == "current"`, `result == "pass"` and a 40-hex _shape_. No receipt commit is ever compared with the ledger's own `.commit` or with any per-theorem revision, although §8.2's PWG-1 requires the run to be "on the exact source commit". Planting `ffff…` and `0000…` commits on L1 yielded `pwg=1`. §8.4 rule 4's anti-carry-forward rule is implemented nowhere, and the sole freshness signal is precisely the kind of hand-written assertion that rule 2 exists to remove. + +*(d) Token-versus-obligation-title is a judgement call with nothing structural behind it, and it is applied inconsistently.* Where the Agda covers less than the obligation's title, the ledger sometimes says `OPEN` and drops the row to ungraded (retention-order: "Agda proves reflexivity only"; tier2-membership: the exhaustive step is missing) and sometimes says `PROVEN` and publishes PWG-3 while its own note concedes the shortfall (L4 "in full"; A2 "chain"). Same situation, opposite verdicts, no rule. + +*(e) The estate has two incompatible receipt formats and the seam is unwired.* trope-checker's pipeline emits JSON with uppercase tokens, a git-tree `inputs_digest` and bare axiom name lists. The canon reader that mathesis pins consumes an §8.5.1 praxis-deed with lowercase §5 vocabulary, a per-file inputs manifest with recomputed SHA-256, axiom dispositions, and `route source` for Agda legs. Neither is wrong in itself; what is wrong architecturally is that the estate's producer cannot feed the estate's consumer, and nothing in either repo's plan owns closing it (doctrine 8). + +*(f) Package-local prose is ungated and is where the drift lives.* The central records — `PROOF-STATUS.adoc`, the root `README.adoc`, the ledger's own notes — are careful and, on the Lean side, accurate down to the direction of a disequality. The drift is concentrated in the least-maintained surfaces: `grade-factorisation/README.adoc` and `REPORT.adoc`, `grade-boundary/README.adoc`, `INTERFACE-REPORT.adoc`, an `L4Monotonicity.lean` module docstring, and the workbench's research programme. Every one of those sits _next to_ a proof and reads as authoritative. The repo has a single-source-of-truth discipline for the ledger and none for the documents beside the code. + +*(g) One gate lane is theatre.* `just aspect` (`Justfile:151-161`) has an empty mint-template body and prints "Aspect tests passed!"; `test-all` (:203) depends on it. `tests/aspect_tests.sh`, the only local Idris2 banned-construct scan, is invoked by nothing, and `CHANGELOG.adoc:82-85` describes hardening it as though it were live. Silent green in a path the repo treats as a gate (doctrine 3 and 8). + +*(h) mathesis's own claims validator is the one of its three that is not closed.* `validate()` (`claims-registry.mjs:86`) checks presence and type of ten fields and never rejects an unknown field, while `bridges.mjs:58` and `theory.mjs:38` do exactly that. A row carrying `pwg:'PWG-1'`, `token:'proven'` and `nonsense:42` was accepted. The ADR's stated defence against an asserted grade is absent from the validator that handles graded claims. + +''''' + +[[2-are-the-proofs-correct]] +== 2. Are the proofs correct? + +*What can be concluded without a kernel.* Existence, hygiene and profile — read off declarations: + +* trope-checker Agda (`verification/proofs/agda/theorem-b/`): every headline named in `Smoke.agda` exists with the type its `using` clause implies; no `postulate`, hole, `TERMINATING` or `trustMe` anywhere in the tree; all nine modules and the `.agda-lib` carry `--safe --without-K --cubical-compatible`, so the §2.1 profile claim is supported as written. +* trope-checker Idris2: all eight proof modules are `%default total` and exhaustive by clause; a grep over all sixteen `.idr` files is clean of `believe_me`, `really_believe_me`, `assert_total`, `assert_smaller`, `unsafePerformIO`, `idris_crash` and `postulate`. +* trope-checker Lean: 157 distinct declared names, and *every* Lean identifier cited in prose exists in the source — no phantom theorem on that side. +* mathesis: every Agda declaration named in THY-1 and APP-1..APP-4 exists at the stated module path; all seven Agda, two Rocq and three Lean digests in `verification/receipts/theory_praxis.deed` match the files on disk byte for byte; the receipt's own SHA-256 matches what `claims.jsonl` pins; `034f215` is a real ancestor of HEAD with a `verification/` tree identical to `a1388fc`'s. `coq/Cohort.v` carries 82 named theorems (matching "all 82") and `lean4/Cohort.lean` 87 source-level `theorem`/`lemma` declarations, with no `sorry`, `Admitted` or `Axiom` in either — the recheck legs are genuine parallel re-statements, not stubs. +* haec, hermeneia, vocarium: there is no proof content to assess. The trees are unmodified templates, and the repos say so. + +*What cannot be concluded.* That any of it typechecks. Not one of trope-checker's 24 theory obligations, and not THY-1 or APP-1..APP-4 in mathesis, can be said from here to check or to fail to check. The CI receipts in both repos are the sole evidence of a kernel run, and they were read, not reproduced. Every "verified" claim in the stack rests on those receipts. + +*Theorems whose stated type does not support the claim made of them.* This is the exact list, and it is the substance of the audit. + +[arabic] +. *`fate-tier-meet-hom-fails`* (`TB/Tier.agda:213`) — `INTERFACE-REPORT.adoc:276` asserts it depends on F2 and "would be false under a commutative model". The carrier in force _is_ commutative (`grade-comm` at `TB/Grade.agda:525`, `▷f-comm` at :294) and the theorem is proved on it. The bullet asserts the falsity of a live theorem, and the two other declarations it names as witnesses (`grade-not-comm`, `cut-symmetric-fails`) exist nowhere. *Highest-severity single claim in the audit.* +. *L4 monotonicity* — the Agda is over `Fate` (`TB/Order.agda:262`) and `Δ` (:204, :225) only; there is no Agda statement for `bondLte`, `mergeLte` or `gradeLte`. Published PWG-3 at `PROOF-STATUS.adoc:184` under the title "L4 (monotonicity), *in full*", statement "monotone … on every coordinate of the ratified carrier". The ledger's own note concedes "Bond, merge and the grade-level lifting have no gradeable theory leg". +. *`fateLte` as a chain (A2)* — `fateLte-refl` (`Order.agda:128`) plus two single Boolean evaluations at one pair of values; no transitivity, antisymmetry or totality in Agda. Published PWG-3 as "Fate is a chain (A2)". On the Lean side `FateA.le_total` gives totality alone, yet `L4Monotonicity.lean:36` reads "the order is *linear* … hence … a complete chain, restoring §7's Knaster–Tarski justification" and :131-133 restates it. Completeness is stated nowhere. +. *`Factorisation.forced_collapse_general`* (`GradeFactorisation.lean:264`) — quantifies over multiplicative maps out of `Fate` under the *pre-ratification* `Fate.comp`. `grade-factorisation/README.adoc:15` states "_every_ such map is forced to identify the honest `dropped` with the deceptive `falsified`" with no carrier qualifier, which `phiR_sighted`/`piR_sighted` (`GradeFactorisationR.lean:138, 152, 212`) refute on the ratified carrier. `REPORT.adoc:18-24` carries exactly the narrowing note the README lacks. +. *`psiBond_separates_honest_deceptive`* (`GradeFactorisation.lean:346`) — one coordinate, one pair. Cited at `REPORT.adoc:193`, `GradeFactorisation.lean:49-50` and `README.adoc:19-20` for a two-coordinate Bond-and-Merge claim that names `conflated` explicitly. There is no `psiMerge`, no merge cost map and no merge separability theorem; `conflated` occurs in no `.lean` in the package at all. +. *`Trope.Veridicality.deceptiveDuals`* (`Veridicality.idr:78`) — type `(Fate, Bond, Merge)`, a data value. It states no proposition and cannot witness "exactly three". Cited as evidence at `PROOF-STATUS.adoc:60` inside a table headed "Proved"; the ledger's note expressly refuses to cite it for that reason. +. *`verdictSound`* (`Soundness.idr:75`) — quantifies `floor` over `Grade`. `PROOF-STATUS.adoc:127` writes the antecedent with floor(U), the use-model floor, which the repo's own records (`PROOF-STATUS.adoc:404-410`, `src/idris2/Checker/Check.idr:58`, the ledger note) say is a different type decided by a different predicate with no lemma connecting them. The source hedges at `Soundness.idr:72`; the status row drops the hedge. +. *`Grade.atom_factorization`* (`EffectAtoms.lean:72`) — over the historical pre-ratification carrier. The workbench (`RESEARCH-PROGRAMME.adoc:212-213`, repeated at :296, :228, :327) cites it as the live ratified result, where the ratified theorem is `Trope.GradeR.atom_factorization` at `EffectAtomsRatified.lean:66`, and in the same sentence conjoins factorisation with typology exhaustiveness — which trope-checker records as module-comment prose (`EffectAtoms.lean:33-36`), token `AGDA-PENDING`, row ungraded, with "O1 itself is therefore not closed" at `PROOF-STATUS.adoc:426`. +. *mathesis THY-1's Lean leg* — `lean4/FeatureReachability.lean` declares no `theorem` or `lemma` whatsoever; `reachMono`, `absentBelow`, `onMono`, `onMonoAll`, `absentUnderAllFeatures` are all `def`, because `Reach`, `All` and `On` are Type-valued. The audit at `scripts/check-proofs.sh:173` keeps only `.thmInfo` constants, so it iterates over nothing and records "axioms: none for 0 declared theorem(s)". The empty `(axioms)` element in the receipt (`theory_praxis.deed:95`) and `PROOF-STATUS.adoc:137`'s "no declared theorem depends on an axiom" are *vacuously true*, and :129-130's `#print axioms` claim is not established by the gate that produced the current receipt. The Rocq side does not have this problem (`coq/FeatureReachability.v:109` is a `Theorem`). +. *mathesis APP-1's middle conjunct* — "otherwise missing when any value it depends on is missing" is stated by no declaration in Agda, Rocq or Lean. `verdict-yes` rules out only `given u true`; `breach-decides` runs the other direction. The property holds of the Kleene conjunction at `Applied/Cohort.agda:265-267` but is unproved, and the sentence is carried unqualified in `claims.jsonl:19`, `registry.adoc:19` and `PROOF-NEEDS.adoc:41-43`. + +*Axiom-purity claims that are tighter than their own sources* — overclaims of hygiene rather than of theorems, and not adjudicable without a kernel: `INTERFACE-REPORT.adoc:64` and `grade-boundary/README.adoc:134` both say `propext`/`Quot.sound` only, where `GradeBoundary.lean`'s own footer (:418-419) lists three and `AFFIRMATION.adoc:131-135` records `Classical.choice` in `Trope.nine_families`, `FateA.Q_add_left_cancel` and `FateA.atten_cancel_on_normalForms`. `grade-factorisation/REPORT.adoc` states both bounds ninety lines apart (:238 vs :330), with the ledger receipt siding with the looser one and `justfile:36-37` asserting the tighter one in a comment. The defect is that the repository states both and gates on neither — `falsify` greps only for `sorryAx`. + +*Dangling declaration names.* Thirteen of ninety-five do not resolve. The Agda failures are one defect class: ASCII transliteration (`|>` for `▷`, `|=` for `⊑`, `beta-` for `β`, `-r` for `ʳ`), plus `gmonoid-unit` for the two declarations `gmonoid-unitL`/`gmonoid-unitR`, plus a camelCase-to-kebab mangling of the three `TB.Honest.*DeceptiveUnique` names. The one Lean failure is a wrong namespace (`Delta.` for `Trope.Grade.fidelity_total_honest_not_cancel`, which lives inside `namespace Grade`, :306-413). For L2 the _sole_ cited witness and for `veridicality-derivation` _all three_ cited witnesses are unresolvable, and both rows are published PWG-3. In every case `docs/status/PROOF-STATUS.adoc` carries the correct name — the human surface is right and the machine-readable ledger is the drifted artefact, which is the opposite of the usual direction and worth recording as such. + +*Not defects, for the record.* The workbench citing trope-checker's Agda flags as `--safe --without-K` where the pragmas carry four flags is narrower, not wider. mathesis's `Laws` record being weaker than an ordered abelian group makes APP-2/APP-3 narrower than the theorem. Neither is reportable. + +''''' + +[[3-is-the-trope-stack-reflected-in-mathesis]] +== 3. Is the trope stack reflected in mathesis? + +*No. Not one record.* `grep -E 'trope|haec|hermeneia|vocarium|particularity'` over `docs/atlas/claims/claims.jsonl` and `bridges.jsonl` returns nothing. `claims.jsonl` holds 22 records from exactly three repositories (hyperpolymath/secret-types N-1..N-9, metadatastician/lintel L-1..L-7 and A-1, hyperpolymath/mathesis THY-1 and APP-1..APP-4); `bridges.jsonl` holds two, neither touching the stack. + +*The precondition is already met.* The stack is in the census frame and public: `repos.jsonl:187` haec, `:189` hermeneia, `:359` trope-checker, `:360` trope-particularity-workbench, `:382` vocarium. `rows.jsonl` has census rows for haec (:101), hermeneia (:103) and trope-checker (:200, class "theory", 514 declarations, "agda 10, lean 12, idris2 16"); vocarium and the workbench have no row. + +*The exact mechanical gap.* The _schema_ is satisfiable: a row pinning `{"path":"verification/pwg.json","sha256":<64 hex>}` passes `validate()`. What cannot happen is the _derivation_ — such a row derives `ungraded` carrying the reader's refusal. Feeding `pwg.json` to the pinned `readProofReceipt` yields `LintError: "line 1: line is 26347 octets; a deed line is at most 998 octets"`. Item by item, what is missing: + +* it is JSON, not a `(praxis-deed …)` S-expression with `:schema-version`, `:canonical-name`, `:profile proof-receipt`, `:repository`, `:source-commit` (pwg.json's top-level keys are `commit, note, policy, receipts, repo, schema_version, theorems`; no `:source-commit`); +* the filename does not dispatch as a deed — accepted empirically as `trope_praxis.deed`, refused as `pwg.json` ("filename 'pwg.json' matches no deed dispatch pattern"); +* its tokens are `PROVEN` / `PROVEN-WITH-AXIOMS` / `OPEN`; the reader's closed §5 vocabulary is `["proven","proven-with-postulates","tested-only","argued","open"]`; +* its Agda legs use route `re-proved`; the reader fails any claim where `(prover === "agda") !== (route === "source")`; +* each receipt's `inputs_digest` is a 40-hex git tree OID; the reader demands `:inputs-sha256` as 64 lowercase hex, recomputed from an `(inputs-manifest (file :path … :sha256 …) …)` clause pwg.json has no analogue of; +* its axioms are bare name lists; the reader demands `(axioms (axiom :name … :disposition b|c|debt))` and counts a witness only when every disposition is `c`. + +There is no `verification/receipts/` directory in trope-checker on either the branch or `origin/main`, and none of haec, hermeneia, vocarium or the workbench holds any receipt file. + +*Cataloguing it would buy visibility, not grade.* trope-checker's Lean legs are state `BRIDGE-PENDING` (not RECONCILED), its Rocq legs are route `unavailable`, and the ledger itself records that the Lean package imports Mathlib, "which PROOF-POLICY §2 forbids for a recheck leg". The ceiling is therefore PWG-3 for the seventeen and ungraded for the seven — exactly trope-checker's own published census. + +*Nobody owns the work.* `grep` over `docs/status/ROADMAP.adoc` for `trope|haec|hermeneia|vocarium` returns zero hits. The only assignment that reaches trope-checker is indirect: WO 5.1 (`docs/proposals/mathesis-re-anchoring.adoc:1065-1069`) tells a campaign to start with "the repositories that the registry and the register already name", and the register pointer names `hyperpolymath/trope-checker` at `CROSS-PROVER-RECONCILIATION.adoc:53`. Stage 5 is "Declared" (`ROADMAP.adoc:288-291`) with no owner and no date, and haec, hermeneia, vocarium and the workbench appear nowhere in mathesis's plan. + +*Where the work actually sits: in trope-checker.* mathesis needs no code change to catalogue the stack. trope-checker must emit an §8.5.1 praxis-deed receipt — per-prover inputs manifests with per-file SHA-256, axiom dispositions, lowercase tokens, Agda route `source` — which `pwg-derive.sh` does not produce. + +''''' + +[[4-conformance-to-the-estate-mathematics-architecture]] +== 4. Conformance to the estate mathematics architecture + +*PROOF-POLICY §8* + +[cols=",",options="header",] +|=== +|Point |Verdict +|§8.1 theory-only scope |*Met.* Derivation restricted to `kind: "theory"`; the one engineering obligation (`verdict-soundness`) is outside the ladder; 24 + 1 = 25 records. +|§8.1 engineering provers off the ladder |*Met, and enforced.* Idris2 only under `reference.idris2`; `pwg-derive.sh:99-106` reads only the three theory legs. +|§8.1 ungraded on OPEN/ASSUMED Agda |*Met.* +|§8.1 ungraded where no Agda source |*Met as encoded* (every theorem carries all three legs; absence is expressed as route `unavailable` / token `OPEN`). +|§8.2 non-counting legs (ASSUMED, waived, unavailable, BRIDGE-PENDING) |*Met.* +|§8.2 a leg counts only when kernel-accepted *and* §2.2 RECONCILED |*Partly met.* The state test is implemented; kernel-acceptance is inherited from a receipt whose freshness is unverified. +|§8.2 PWG-2ii as a distinct rung |*Not met.* `pwg-derive.sh:113` branch unreachable; PWG-1 granted on exactly PWG-2ii evidence. +|§8.2 PWG-1 "on the exact source commit" |*Not met.* Shape test only; no commit comparison anywhere. +|§8.2 per-receipt field completeness |*Met for this repo's own ledger* via `pwg-check.sh:74-88`; *not met in the derivation*, so not met when run with `--ledger PATH`. +|§2.1 canonical Agda invocation |*Partly met.* All three flags required (right); but a substring scan over the whole string admits options outside §2.1 and cannot tell that each entrypoint of a `" ; "`-joined two-command invocation carried them. +|§8.3 `+foundation-diverse` |*Not met.* Set by mere non-null field presence; no token, state or receipt test. Latent only — every witness here is `null`. +|§8.4 rule 2, derived never asserted |*Met, and well.* No grade key, no `PWG-` string in the ledger; gated. +|§8.4 rule 4, anti-carry-forward |*Not met.* Implemented nowhere; `"state":"current"` is the sole signal. +|§8.4 rule 6, counted witness lists its axioms |*Not met, twice.* The derived `axioms` reads the Agda receipt list only, so counted Rocq/Lean axioms are dropped (live: `lean-boundary-c0eb4f1` lists three, derived L1 reads `[]`); and `PROVEN-WITH-AXIOMS` counts unconditionally with no disposition-(c) test. *Also not met in mathesis* for THY-1's Lean leg, where the audit's domain is empty. +|§8.4 rule 7, census with denominator, no percentage |*Met in both repos.* trope-checker 17 + 7 = 24, byte-matched by the gate; mathesis 11/0/0/0 + 6 ungraded of 17, arithmetically correct. Caveat: the `PWG-2ii 0` is structurally guaranteed, not measured. +|§8.5 route vocabulary \{transported, re-proved, waived, unavailable} |*Met in trope-checker* (enforced `pwg-check.sh:111-118`). mathesis's receipt uses `:route source`, which is not in the §8.5 enumeration but _is_ the pinned reader's required value for an Agda leg — a policy/tool seam, not a mathesis error. +|§8.5 grade recorded in the home repo; mathesis catalogues, never assigns |*Met, structurally.* The reader derives `pwg` and refuses a receipt whose recorded `:pwg` differs. +|§2.2 RECONCILED recorded, not asserted |*Met in mathesis* — item-by-item statement correspondence, explicit encoding-difference list, "Residual assumptions: none in any leg", re-proof route with its reason. *Not applicable in trope-checker*, whose Lean legs are correctly recorded as BRIDGE-PENDING: a state, not a defect. +|§8.4 rule 5 / §8.5 lineage state in the home proof-status file |*Not met in mathesis* for two of THY-1's three legs: `theory_praxis.deed:76-81` and `:100-105` mark run 42896264290 superseded, while `PROOF-STATUS.adoc:110` and `:135-137` still label it "(current)" and name no successor receipt. The Agda row was updated; the other two were not. +|Declaration-name resolution (not numbered, but the join the design rests on) |*Not met in either repo's gate.* +|=== + +*mathesis ADR 0004* + +[cols=",",options="header",] +|=== +|Point |Verdict +|Closed field set enforced by `validate()` |*Not met.* Presence/type only; no unknown-field rejection, where the two sibling validators have one. A row with `pwg`, `token` and a nonsense key was accepted. +|"A record holds no grade, token, leg or flag" |*Not enforced* — same gap. An asserted grade in `claims.jsonl` passes `just registry-check` silently, which is the exact drift §8.4 rule 2 names and this ADR exists to prevent. +|Tests prove each validation failure |*Not met.* `claims-registry.test.mjs:58` covers eight cases; no unknown-field case. The only grade guard is an assertion over committed data for two key names, not a validator rule. +|Receipt pinned by SHA-256, fetched at `source_commit`, read by a hash-pinned canon reader |*Met, and verified by hash.* +|`shelf` iff repo is mathesis and kind is theorem |*Met* (`claims-registry.mjs:105-107`). +|Theory-shelf record requires an admission |*Met* (`theory.mjs:31-52`). +|Policy section citations (`§8.5.2` for the consumer rule, `§8.4.7` for the census) |*Cosmetically wrong* at the pin — the rules are §8.5.3 and §8.4 rule 8, and §8.4 has no subsections. Refuted as immaterial; noted, not pressed. +|=== + +*Estate doctrine.* Doctrine 10 is upheld at the central surfaces and breached at the peripheral ones — the three mint-template repositories refusing to count their own templates is exemplary, and the breaches are package-local prose plus one root-level ledger in haec that denies its own proof tree exists, four times over. Doctrine 3 and 8 are breached by the aspect lane: a recipe that prints a pass having run nothing, a scan wired to nothing, and a changelog that describes hardening the unwired scan as if it were live. Doctrine 4 is honoured by the derived-not-asserted design and leaks at the unchecked `declarations` arrays. + +*Two notes on the adversarial screen itself.* (i) The 38 surviving findings describe roughly thirty distinct defects: findings link:#f-2[2], link:#f-15[15], link:#f-20[20] and link:#f-22[22] are two dangling-name defects seen from three dimensions, and finding link:#f-18[18]'s sub-items overlap 14, 15 and 22. Count the defects, not the findings. (ii) The materiality line through the dangling-name class was drawn inconsistently by the screen — `deceptive-absorbs-|>`, `|=-refl` and the three Honest names survived, while `honest-closed-|>`, `Q-cancel-r`, `core-closed-|>` and `beta-app`/`beta-let` were refuted as immaterial under the same reasoning; and the C3 `Delta.` namespace defect was refuted in tc-lean and sustained as finding link:#f-24[24] in tc-ledger on identical facts. I do not think either refutation was _wrong_ on its own terms, but the class is one defect with one fix, and no refutation in that set should be read as settling it. + +''''' + +[[5-what-remains]] +== 5. What remains + +Ranked by doctrine 1 — soundness of the grading machinery first, then claims wider than their theorems, then drift. + +[arabic] +. *Make the gate resolve declaration names, then fix the thirteen that dangle.* trope-checker `scripts/pwg-check.sh` (add a rule that greps each `legs.*.declarations` entry against the matching proof tree — the string `declarations` occurs in neither script), then `verification/pwg.json`. Not owner-blocked. Small for the check, small for the names. _Highest value of anything on this list_: it closes the hole that findings link:#f-2[2], link:#f-15[15], link:#f-19[19], link:#f-20[20], link:#f-21[21], link:#f-22[22], link:#f-23[23] and link:#f-24[24] all live in, and it is the join the whole derived-grade design rests on. +. *Fix the unreachable `2ii` branch and add a source-commit check.* trope-checker `scripts/pwg-derive.sh:103-115` and `:64`. Not owner-blocked. Small for the branch; medium for the commit check, which likely needs a per-theorem revision field and so touches `pwg.json`'s schema and `pwg-check.sh`. No live grade moves in trope-checker (it publishes zero PWG-1 today), but `PWG-2ii 0` becomes a measurement instead of an artefact, and §8.4 rule 4 gets an implementation. +. *Retract the residual pre-ratification F2 prose in `INTERFACE-REPORT.adoc`.* Lines *276* (asserts a live theorem is false, and names two declarations that do not exist), *135* and *98* (state the retired equation as definitional, in the present tense, about a named module), and *64* (the `propext`/`Quot.sound`-only wording the AFFIRMATION sweep missed). Not owner-blocked. Small — prose only, but line 276 is the sharpest claim in the audit. +. *Resolve the token-versus-title inconsistency for L4 "in full" and A2 "chain".* trope-checker `verification/pwg.json` (those two rows) and `docs/status/PROOF-STATUS.adoc:184, :204`. *Owner-blocked* — it changes the published census from 17 PWG-3 to 15. The elegant and correct long-term arm is to flip both Agda tokens to `OPEN` and let the rows go ungraded, because the ledger already applies exactly that rule to `retention-order` and `tier2-membership` and because a PWG-3 should not attach to a sentence quantified over coordinates no theorem mentions; the alternative arm is to narrow both obligation titles and statements to what is proved. Either edit is small; the decision is not mine. +. *Fix the grade-factorisation package prose.* `grade-factorisation/README.adoc:15, 19-20, 31` and `REPORT.adoc:193, 238`. Three things: narrow the (B) VERIDICALITY-BLIND verdict to the pre-ratification carrier the way `REPORT.adoc:18-24` already does, and add a Layout row for `GradeFactorisationR.lean` (present, wired into `just falsify`, carries the verdict flip, listed nowhere); delete or prove the Merge-coordinate separability claim, which also sits in `GradeFactorisation.lean:49-50`; and reconcile `REPORT.adoc:238` with its own `:330`. Not owner-blocked except the last. Small. +. *Settle the axiom bound once and gate on it.* `grade-boundary/README.adoc:134`, `grade-factorisation/REPORT.adoc:238` vs `:330`, `justfile:22-23` (falsify greps only `sorryAx`) and `:36-37`. *Blocked on a toolchain, not on the owner* — this is the one item that genuinely cannot be closed from here. Small once a `just axioms` run exists; until then the repository states two bounds and gates on neither. +. *Wire or delete the aspect lane.* trope-checker `Justfile:151-161` and `:203`, `tests/aspect_tests.sh:71-76`, `CHANGELOG.adoc:82-85`. Not owner-blocked. Small: point `aspect` at the real scan widened from three to all sixteen `.idr` files, qualify its pass text, drop the `grep -v "test"` that silently excludes any path containing "test" — or make the recipe fail loudly as unimplemented. Doctrine 3 and 8. +. *Close the mathesis THY-1 Lean leg hole.* `verification/proofs/lean4/FeatureReachability.lean`, `scripts/check-proofs.sh:173`, `verification/receipts/theory_praxis.deed:95`, `docs/status/PROOF-STATUS.adoc:129-130, :137`. *Owner-blocked*: either restate the Lean leg in `Prop` so the audit has a domain, or record the leg as providing no axiom evidence — and the second moves THY-1's grade. Medium. _This is the most serious single item in mathesis_: the recorded axiom evidence is vacuously true, and §8.4 rule 6 requires every counted witness to list its axioms. +. *Narrow the remaining wider-than-theorem rows in trope-checker.* `PROOF-STATUS.adoc:60` (drop `deceptiveDuals` — a tuple value the ledger expressly refuses to cite), `:127` (`verdictSound` is over `Grade`, not the use-model floor; restore the source's own hedge), `:82` (tier-2 row cites pre-ratification names in a table scoped to the ratified carrier, where `FateA.leftCancelWitness` and `gradeR_leftCancel_iff` exist and the ledger already names them), `README.adoc:163` ("agree row for row" — three rows differ), and `L4Monotonicity.lean:36, 131-133`. Not owner-blocked. Small, spread over five files. +. *Correct mathesis's THY-1 receipt lineage.* `docs/status/PROOF-STATUS.adoc:110-113` and `:135-137` label the superseded run 42896264290 "(current)" and name no successor; the Agda row at `:87`/`:91` was already brought into line with `theory_praxis.deed`. Not owner-blocked. Small. +. *Narrow or prove mathesis APP-1's middle conjunct.* `docs/atlas/claims/claims.jsonl:19`, `docs/atlas/generated/registry.adoc:19`, `docs/status/PROOF-NEEDS.adoc:41-43`. *Owner-blocked in the choice only.* The property is true of the Kleene conjunction at `Applied/Cohort.agda:265-267`. The elegant arm is to prove it, since APP-1 is PWG-1 and all three legs already exist and would have to move together (medium); the fast arm is to narrow the registry statement (small, immediate). +. *Close mathesis's `validate()` to unknown fields.* `scripts/registry/claims-registry.mjs:86` — add the `closed()` call its two siblings already use (`bridges.mjs:58`, `theory.mjs:38`) — plus unknown-field and asserted-grade cases in `tests/registry/claims-registry.test.mjs`. Not owner-blocked. Very small, and it is the defence ADR 0004 says is already there. +. *Harden the three latent policy gaps in `pwg-derive.sh`.* `:125` (`+foundation-diverse` set by field presence alone), `:128` (derived `axioms` drops counted Rocq/Lean axioms — live today), `:52` (`PROVEN-WITH-AXIOMS` counts with no disposition test), `:78` (substring flag scan). Not owner-blocked. Small each, medium together. Only `:128` is live; the rest are latent. +. *Emit an §8.5.1 praxis-deed receipt from trope-checker — _if_ cataloguing the stack in mathesis is wanted.* New `verification/receipts/` plus changes to `scripts/pwg-derive.sh` for per-prover inputs manifests with per-file SHA-256, axiom dispositions, lowercase §5 tokens and Agda route `source`; then one row per theorem in mathesis `docs/atlas/claims/claims.jsonl`. *Owner-blocked*: nothing in mathesis's plan assigns it, stage 5 is "Declared" with no owner and no date, and only trope-checker is named at all. Medium-to-large in trope-checker, trivial in mathesis. State plainly when putting it to the owner that it buys visibility and not grade, since the ceiling stays PWG-3 for seventeen and ungraded for seven while the Lean legs are BRIDGE-PENDING, the Rocq legs unavailable, and the Lean package imports Mathlib. +. *Fix the satellite-repo drift.* haec `PROOF-PROGRESS.adoc:105, 147, 159, 186` — denies the proof tree exists, where eleven template files sit under `verification/proofs/` across agda, coq, idris2, lean4 and tlaplus; it is dated "Generated: 2026-08-14" (`:262`), predates the 2026-11-09 PROOF-STATUS pass, and sits unmarked at the repository root while PROOF-STATUS sits in `docs/status/`, neither pointing at the other. hermeneia `docs/status/STATE-OF-PLAY.adoc:71` ("Vocarium does not exist" — it does, at M1 invoke slice, and `README.adoc:141` says they meet at the M2 adapter; the surrounding substance is true, only the reason is false) and `:99` (gives the grade algebra's proof to Idris2 alone, where ADR 0005 D4 assigns the normative-kernel role to Agda and L4's grade-level lifting is not mechanised in Idris2 at all). Not owner-blocked. Small — both documents are dated before the rulings they contradict, so the cheapest correct fix is a dated supersession banner, not a rewrite. +. *Fix the workbench's two mis-citations.* `trope-particularity-workbench/docs/status/RESEARCH-PROGRAMME.adoc:212-213` — reports the effect typology's exhaustiveness as a theorem (trope-checker records it as docstring prose, token `AGDA-PENDING`, row ungraded, "O1 itself is therefore not closed"), restated at `:296` and `:228`; and cites the pre-ratification `EffectAtoms.lean` where the ratified theorem is in `EffectAtomsRatified.lean`, with the reference list at `:327` repeating it and omitting the ratified file. Not owner-blocked. Small. The workbench is downstream, so by doctrine 14 the correction belongs here, in the citation, not upstream. + +*One line of summary for the owner.* The design is right and the central records are honest; the machinery that turns evidence into grades has three holes — unresolved declaration names, unverified receipt commits, and a collapsed top rung — and the prose that sits beside the proofs has drifted where nothing gates it. Items 1, 2 and 8 are the ones that change what the estate can truthfully claim; the rest are faithfulness repairs. No kernel ran here, so nothing in this verdict establishes that any theorem checks. + +[[findings]] +[[findings-h]] +== The 38 findings + +Each finding survived two independent verifiers, one asking whether the source says what the finding claims and one asking whether the difference matters. Numbering is the audit’s own, and the verdict above cites findings by these numbers. Several findings describe the same defect from different areas, so count defects in section 5, not here. + +High: 11 Medium: 23 Low: 4 + +[[f-1]] +*Finding 1* — High · trope-checker · Agda · Contradicts another claim + +=== INTERFACE-REPORT F2 checklist says fate-tier-meet-hom-fails "would be false under a commutative model" — it is proved on today's commutative carrier + +Claim:: + `trope-checker/verification/proofs/agda/theorem-b/INTERFACE-REPORT.adoc:276` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Tier.agda:213` + +What differs + +Three separate mismatches in one bullet, and the section's "[F2 items HISTORICAL]" bracket (line 274) does not rescue the third. (1) `grade-not-comm` is called "a pinned theorem" but no such declaration exists anywhere in the tree; TB/Grade.agda:516-522 records that it was a theorem of the pre-ratification carrier only and is replaced by `grade-comm` (TB/Grade.agda:525). (2) `cut-symmetric-fails` likewise does not exist; INTERFACE-REPORT:170 itself states "Neither `cut-orientation-matters` nor `cut-symmetric-fails` occurs in any source". (3) The load-bearing error: `fate-tier-meet-hom-fails` is asserted to depend on F2 and to be false under a commutative model, but the carrier in force IS commutative (`grade-comm`, `▷f-comm` at TB/Grade.agda:294), and the theorem is proved on it — the report's own amendment box at lines 41-44 says it "survives with a NEW witness" and the §Target 3 box at lines 202-215 explains that new witness. So the bullet asserts the falsity of a theorem the same document (and TB/Tier.agda) certifies as live. + +[[f-2]] +*Finding 2* — High · trope-checker · Agda · Cites the wrong object + +=== pwg.json Agda legs cite four declaration names that do not exist in the Agda sources + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Grade.agda:503` + +What differs + +`TB.Grade.gmonoid-unit` does not exist: the unit law is two declarations, `gmonoid-unitL` (Grade.agda:503) and `gmonoid-unitR` (Grade.agda:506). `TB.Honest.fate-deceptive-unique`, `bond-deceptive-unique` and `merge-deceptive-unique` do not exist either; the declarations are camelCase — `fateDeceptiveUnique` (Honest.agda:55), `bondDeceptiveUnique` (:58), `mergeDeceptiveUnique` (:61). These are not the ledger's ASCII-transliteration convention (which it uses for `deceptive-absorbs-|>`, `beta-app`, `|=-refl`): the real names are already pure ASCII, and docs/status/PROOF-STATUS.adoc:32 and :60 cite them correctly, so the ledger disagrees with the status doc it is supposed to generate. Both rows are published as PWG-3 (PROOF-STATUS:174-177, :209-212), so for L2 the entire cited Agda witness, and for veridicality-derivation all three cited witnesses, name nothing in the sources. scripts/pwg-check.sh checks JCS shape, vocabularies and receipt completeness but never resolves a declaration name against the Agda, so the drift gate cannot catch this. + +[[f-3]] +*Finding 3* — Medium · trope-checker · Agda · Contradicts another claim + +=== INTERFACE-REPORT Target 1 verdict states the retired pre-ratification equation as how TB.Grade computes + +Claim:: + `trope-checker/verification/proofs/agda/theorem-b/INTERFACE-REPORT.adoc:135` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Grade.agda:158` + +What differs + +The clause the verdict quotes as definitional is the amended-away one. TB/Grade.agda:158 defines `dropped ▷f falsified = falsified`, pinned as the theorem `dropped▷falsified` at :260, and `▷f-comm` (:294) / `grade-comm` (:525) prove the product commutative. The §Target 1 heading (line 133, "encode the grade as a NON-COMMUTATIVE graded structure — *PROVED*") and this paragraph therefore assert, in the present tense and about a named module, an equation and a non-commutativity the module refutes. The amendment box's blanket "Prose below that presents F2 as current fact is HISTORICAL" (lines 33-34) warns a reader generically, but it does not mark this paragraph, and the same staleness recurs at line 98 ("'CF' … refuted-as-universal by both F2 and L5") where the F2 half of the refutation no longer holds. + +[[f-4]] +*Finding 4* — Medium · trope-checker · Agda · Policy misapplied + +=== L4 is graded PWG-3 under the title "in full" although the Agda covers one coordinate plus the fidelity dimension + +Claim:: + `trope-checker/docs/status/PROOF-STATUS.adoc:184` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Order.agda:262` + +What differs + +Both declarations are over `Fate` only; `dplusMonoR/L` (Order.agda:204,225) are over `Δ`. There is no Agda monotonicity statement for `bondLte`, `mergeLte` or `gradeLte`. verification/pwg.json's own note for this row says so — "Bond, merge and the grade-level lifting have no gradeable theory leg" — yet the Agda leg carries token PROVEN, which derives PWG-3 for an obligation whose title is "L4 (monotonicity), in full" and whose statement (PROOF-STATUS:39) is "monotone in both arguments w.r.t. ⊑ on every coordinate of the ratified carrier". The ledger applies the opposite rule to comparable rows: retention-order is token OPEN because "Agda proves reflexivity only", and tier2-membership is OPEN because the exhaustive step is missing. Under that rule L4's Agda token should be OPEN and the row ungraded; as published, a PWG-3 attaches to a sentence quantified over every coordinate. (The prose at PROOF-STATUS:39-40 and README.adoc:171-173 does disclose the coverage; the defect is the graded table row and the ledger token, not the narrative.) + +[[f-5]] +*Finding 5* — Medium · trope-checker · Agda · Claim narrower than proof + +=== INTERFACE-REPORT still carries the "propext/Quot.sound only" axiom wording that AFFIRMATION records as corrected elsewhere + +Claim:: + `trope-checker/verification/proofs/agda/theorem-b/INTERFACE-REPORT.adoc:64` +Source:: + `trope-checker/verification/proofs/lean4/grade-boundary/GradeBoundary.lean:418` + +What differs + +The cited file's own axiom-audit footer lists three axioms, not two. AFFIRMATION.adoc:131-135 records this exact wording as an overclaim and says it was corrected in spec §9.3, PROOF-STATUS and the proofs README ("the `propext`/`Quot.sound` only wording … overclaimed and now reads 'no sorryAx, no user axiom'. GradeBoundary.lean's own footer had said so all along"), naming `FateA.Q_add_left_cancel` and `FateA.atten_cancel_on_normalForms` in the same grade-boundary package plus `Trope.nine_families`. INTERFACE-REPORT was missed by that sweep; README.adoc:156-157 and PROOF-STATUS:9 now both say "and `Classical.choice` in three theorems", and verification/pwg.json's lean-boundary receipt lists axioms [propext, Quot.sound, Classical.choice]. This is a Lean-side claim, but it is a claim in the Theorem B interface report describing the foundation Theorem B is said to sit on. + +[[f-6]] +*Finding 6* — Low · trope-checker · Agda · Claim wider than proof + +=== "Fate is a chain (A2)" is published PWG-3 on two directional facts, with transitivity and antisymmetry unmechanised + +Claim:: + `trope-checker/docs/status/PROOF-STATUS.adoc:204` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Order.agda:167` + +What differs + +The two Agda declarations are single Boolean evaluations at one pair of fate values. `fateLte-refl` (Order.agda:128) exists, but there is no Agda transitivity, antisymmetry or totality statement for `fateLte`, so nothing in Agda establishes a chain. verification/pwg.json's note for the row concedes it — "transitivity and antisymmetry are not mechanised in any prover, so 'chain' is stronger than the mechanised content" — yet the Agda leg is PROVEN and the obligation is published PWG-3 under the title "Fate is a chain (A2)". The narrower prose row at PROOF-STATUS:54-55 is accurate ("the v0.1 antichain is dissolved in the stated direction only"); the graded table row is not scoped that way. + +[[f-7]] +*Finding 7* — High · trope-checker · Lean · Claim wider than proof + +=== grade-factorisation README states the pre-ratification verdict as the directory's verdict and omits GradeFactorisationR.lean entirely + +Claim:: + `trope-checker/verification/proofs/lean4/grade-factorisation/README.adoc:15` +Source:: + `trope-checker/verification/proofs/lean4/grade-factorisation/GradeFactorisationR.lean:152` + +What differs + +The forcing theorem the README generalises from, Factorisation.forced_collapse_general (GradeFactorisation.lean:264), quantifies over multiplicative maps out of `Fate` under the PRE-RATIFICATION `Fate.comp` instance (GradeBoundary.lean:136-151). Under the ratified composition `FateA.comp` the separation is not only possible but proved: phiR_hom (GradeFactorisationR.lean:138) is a homomorphism and phiR_sighted separates exactly that pair, lifted to grades by piR_sighted (line 212). The README states "every such map" with no carrier qualifier, so as written it asserts of the carrier the project actually uses something a theorem in the same directory refutes. REPORT.adoc:18-24 carries a prominent IMPORTANT provenance note doing exactly this narrowing; the README has none. Compounding it, the Layout table at README.adoc:31 describes `GradeFactorisation.lean` as "The whole development" and lists no row for GradeFactorisationR.lean, which is present in the directory, is wired into `just falsify` (justfile:31-33) and carries the verdict flip. + +[[f-8]] +*Finding 8* — High · trope-checker · Lean · Claim wider than proof + +=== Merge-coordinate tropical separability is asserted in three places with no merge declaration anywhere in the package + +Claim:: + `trope-checker/verification/proofs/lean4/grade-factorisation/REPORT.adoc:193` +Source:: + `trope-checker/verification/proofs/lean4/grade-factorisation/GradeFactorisation.lean:346` + +What differs + +The only separability witness in the package is psiBond_separates_honest_deceptive, which is about the BOND coordinate and about ONE pair (severed vs misbound). There is no psiMerge, no merge cost map and no merge separability theorem: `grep -n 'conflated' verification/proofs/lean4/grade-factorisation/*.lean` returns nothing at all, so `Merge`'s deceptive bottom is never given a value in Δ, let alone separated. The claim names `conflated` explicitly as tropically separable. The same unsupported Merge claim appears at GradeFactorisation.lean:49-50 ("The commutative coordinates (`Bond`, `Merge`) carry no such obstruction: their deceptive bottoms remain tropically separable (`psiBond_hom`, `psiBond_separates_honest_deceptive`)" — citing two bond lemmas for a two-coordinate claim) and at grade-factorisation/README.adoc:19-20 ("the commutative `Bond`/`Merge` deceptions stay tropically separable"). This is distinct from the psiBond one-pair wording narrowed in the root README by commit c8d6c5c, which touched README.adoc only; the Merge half was never backed by anything. + +[[f-9]] +*Finding 9* — Medium · trope-checker · Lean · Claim wider than proof + +=== grade-boundary README still claims propext/Quot.sound only, omitting the Classical.choice the repo records for three theorems of this very package + +Claim:: + `trope-checker/verification/proofs/lean4/grade-boundary/README.adoc:134` +Source:: + `trope-checker/verification/proofs/lean4/grade-boundary/GradeBoundary.lean:419` + +What differs + +The README's upper bound on the axioms is strictly tighter than the one the source file it calls "the single source of truth" states for itself, and tighter than what the repo records as observed. AFFIRMATION.adoc:132-135 reports from the CI audit that `Trope.nine_families` (EffectAtoms.lean:124), `FateA.Q_add_left_cancel` (GradeRatified.lean:120) and `FateA.atten_cancel_on_normalForms` (GradeRatified.lean:147) all depend on `Classical.choice` — all three are modules of the grade-boundary package that `just axioms` covers (justfile:39-40 greps the whole lake build). AFFIRMATION finding (3) states the "propext/Quot.sound only" wording "in spec §9.3, PROOF-STATUS and the proofs README overclaimed" and was corrected; spec/calculus.adoc:765-767, docs/status/PROOF-STATUS.adoc:8-9 and README.adoc:74 now all name Classical.choice, but this README was missed. A narrower axiom claim is a STRONGER purity claim, so this is an overclaim, not a safe understatement. + +[[f-10]] +*Finding 10* — Medium · trope-checker · Lean · Contradicts another claim + +=== REPORT.adoc asserts no Classical.choice in grade-factorisation, contradicting its own appendix, the source footer and the ledger receipt + +Claim:: + `trope-checker/verification/proofs/lean4/grade-factorisation/REPORT.adoc:238` +Source:: + `trope-checker/verification/proofs/lean4/grade-factorisation/GradeFactorisation.lean:403` + +What differs + +Three records disagree with REPORT.adoc:238-240 about the same package. (a) The audited file's own footer, covering the very theorems REPORT.adoc:238 quantifies over, admits Classical.choice. (b) REPORT.adoc:330 itself says "All re-run theorems depend on at most `propext`, `Classical.choice`, `Quot.sound`" — the same document, two bounds, 90 lines apart. (c) verification/pwg.json records receipt `lean-factorisation-c0eb4f1` with `"axioms":["propext","Quot.sound","Classical.choice"]`. The justfile:36-37 comment repeats the tight bound ("expect propext/Quot.sound only — no Classical.choice"). I cannot run a kernel to say which bound is the true one; the defect is that the repository states both and gates on neither. Note the gate cannot catch this: falsify (justfile:22-23) only greps for sorryAx. + +[[f-11]] +*Finding 11* — Medium · trope-checker · Lean · Cites the wrong object + +=== PROOF-STATUS tier-2 row cites only pre-ratification declarations in a table scoped to the ratified carrier + +Claim:: + `trope-checker/docs/status/PROOF-STATUS.adoc:82` +Source:: + `trope-checker/verification/proofs/lean4/grade-boundary/GradeRatified.lean:381` + +What differs + +PROOF-STATUS.adoc:9-11 scopes the whole Proved table to "the ratified carrier of `spec/calculus.adoc` v0.2 (R-2026-07-07, ADR 0004)", and the C3 row four lines later polices precisely this distinction, demoting `dropped_absorbing` to history because it is a theorem of the pre-ratification carrier. Yet every fate- and grade-level name in the tier-2 row is pre-ratification: `Fate.atten_not_cancel` and `Fate.leftCancelWitness` are stated over `Fate.comp` (the Mul instance at GradeBoundary.lean:151), and `Grade.grade_leftCancel_iff` is over the pre-ratification `Grade` structure. The ratified restatements exist and are not cited here — FateA.leftCancelWitness (GradeRatified.lean:89) and gradeR_leftCancel_iff (line 381). verification/pwg.json's tier2-membership entry does list both and adds the note "Grade.grade_leftCancel_iff is over the historical pre-ratification carrier; the ratified restatement is GradeR.gradeR_leftCancel_iff", so the ledger is correct and the prose table is the drifted surface. (Bond.withheld_honest_not_cancel and Merge.fused_honest_not_cancel are unaffected: ratification left Bond and Merge unchanged.) + +[[f-12]] +*Finding 12* — Low · trope-checker · Lean · Claim wider than proof + +=== L4Monotonicity docstring claims linearity and a complete chain from a totality theorem alone + +Claim:: + `trope-checker/verification/proofs/lean4/grade-boundary/L4Monotonicity.lean:36` +Source:: + `trope-checker/verification/proofs/lean4/grade-boundary/L4Monotonicity.lean:156` + +What differs + +`FateA.le_total` states totality only. The file declares exactly two order lemmas for FateA.le — le_refl (line 150) and le_total (line 156); there is no transitivity and no antisymmetry theorem for FateA.le anywhere in the tree, so "linear", "a chain" and a fortiori "a complete chain" are not derivable from what is stated. Knaster-Tarski additionally needs completeness (suprema of chains), which nothing here states. The repository already knows this: verification/pwg.json's A2-chain entry notes "Totality is stated in Lean (FateA.le_total); transitivity and antisymmetry are not mechanised in any prover, so 'chain' is stronger than the mechanised content", and PROOF-STATUS.adoc:60 narrows the row to the two directional facts. The module docstring was not narrowed with them, and it restates the chain at lines 131-133 ("The order becomes a chain: `Falsified ⊏ Dropped ⊏ Predicated ⊏ Atten δ ⊏ Present`"). + +[[f-13]] +*Finding 13* — High · trope-checker · Idris2 · Claim wider than proof + +=== `just aspect` prints "Aspect tests passed!" while running no check at all + +Claim:: + `trope-checker/Justfile:161` +Source:: + `trope-checker/Justfile:153` + +What differs + +The `aspect` recipe is an uninstantiated mint template: its entire body is two `@echo`s and a TODO comment block. It executes no scan, yet announces a pass. `test-all` (Justfile:203) depends on it, so `just test-all` reports the standing-rule aspect lane as green having checked nothing. Independently, `grep -rn aspect_tests` over the Justfile, all workflows and all scripts shows tests/aspect_tests.sh — the only local Idris2 banned-construct scan — is invoked by nothing: it is unwired. Compounding this, CHANGELOG.adoc:82-85 describes hardening that script's `|| true` handling as if it were a live gate ("it now covers the find and the grep ... but never the awk"), which reads as a claim that the script runs somewhere. This is silent-green in a path the repo treats as a gate (doctrine 3 and 8). + +[[f-14]] +*Finding 14* — Medium · trope-checker · Idris2 · Claim wider than proof + +=== PROOF-STATUS cites `deceptiveDuals` as proof evidence; it is a tuple value that states no proposition + +Claim:: + `trope-checker/docs/status/PROOF-STATUS.adoc:60` +Source:: + `trope-checker/verification/proofs/idris2/Trope/Veridicality.idr:78` + +What differs + +`deceptiveDuals` has type `(Fate, Bond, Merge)` — a data value, not an equality, not a Π-type, not a Σ-type with a proof component. It asserts nothing and cannot witness "exactly three". The three uniqueness lemmas on the same line (Veridicality.idr:40, 49, 57) carry the real content, and only the "each is unique in its coordinate" half of it. The repo's own ledger agrees and says so explicitly: verification/pwg.json, veridicality-derivation `notes` — "The 'exactly three' half rests on the three uniqueness lemmas plus the construction of Grade; Trope.Veridicality.deceptiveDuals is a tuple value and states no proposition, so it is not cited as evidence here" — and correspondingly the ledger's reference.idris2.declarations list for that row contains only the three uniqueness lemmas. PROOF-STATUS cites the one declaration the ledger deliberately refuses to cite, inside a table headed "Proved". + +[[f-15]] +*Finding 15* — Medium · trope-checker · Idris2 · Cites the wrong object + +=== pwg.json cites three Agda declarations that do not exist (kebab-case names for camelCase declarations) + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Honest.agda:55` + +What differs + +The Agda module declares `fateDeceptiveUnique`, `bondDeceptiveUnique`, `mergeDeceptiveUnique` in camelCase. The ledger's counting Agda leg for veridicality-derivation names three kebab-case identifiers that appear nowhere in verification/proofs/agda/. A grade that derives PWG-3 for this obligation therefore rests on declaration names that do not resolve. PROOF-STATUS.adoc:60 has the correct camelCase forms, so the two records disagree here as well. Root cause is that scripts/pwg-check.sh validates receipt fields, token/state/route vocabularies and table-vs-census byte equality, but never checks that a cited declaration exists in the proof sources — so a mistyped declaration name passes the gate silently. (Found while auditing the Idris2 citations on the same ledger row; flagged here because verification/pwg.json is in this dimension's scope.) + +[[f-16]] +*Finding 16* — Medium · trope-checker · Idris2 · Claim wider than proof + +=== Verdict-soundness row states the theorem over the use-model floor; `verdictSound` quantifies over `Grade` + +Claim:: + `trope-checker/docs/status/PROOF-STATUS.adoc:127` +Source:: + `trope-checker/verification/proofs/idris2/Trope/Soundness.idr:75` + +What differs + +The row, in the == Proved table, writes the antecedent with floor(U) — the use-model's floor — but the theorem quantifies `floor` over `Grade`. The repo's own documents say these are not the same object: PROOF-STATUS.adoc:404-410 states "The use-model floor is a partial per-coordinate demand, not a grade value"; the shipped checker uses a separate type (`violations : Floor -> Grade -> List String`, src/idris2/Checker/Check.idr:58); and verification/pwg.json's verdict-soundness note says "verdictSound is typed over Grade while the shipped checker's floor is a different type decided by a different predicate, and no lemma connects them." The Idris2 source itself hedges — Soundness.idr:72 says "a (grade-shaped) floor" — and the hedge is dropped in the status row. Other rows in the same table (L4 at :39, Target 3 at :109) do carry their coverage caveats inline, so the omission is inconsistent as well as wider than the theorem. + +[[f-17]] +*Finding 17* — Medium · trope-checker · Idris2 · Claim wider than proof + +=== aspect_tests.sh reports an unqualified "No dangerous Idris2 patterns" pass after scanning 3 of 16 .idr files + +Claim:: + `trope-checker/tests/aspect_tests.sh:76` +Source:: + `trope-checker/tests/aspect_tests.sh:71` + +What differs + +The grep root is `src/interface/Abi/` — 3 of the repository's 16 .idr files. It excludes the entire verified core (verification/proofs/idris2/Trope/, 8 files) and the whole executable checker (src/idris2/, 5 files, four of which are `%default covering`), yet the emitted message carries no scope qualifier. The adjacent Coq/Lean block at :79-100 was explicitly widened and documented after a similar mis-scoping, while this block was left at its template scope. Note also `grep -v "test"` would silently drop any matching path containing the substring "test". The script is clean as to what it actually scans — the finding is the unqualified pass text, which combined with the previous finding (the script is never invoked) means the repo has no wired local scan matching this claim. + +[[f-18]] +*Finding 18* — Low · trope-checker · Idris2 · Contradicts another claim + +=== README claims PROOF-STATUS and pwg.json "agree row for row"; at least three rows differ + +Claim:: + `trope-checker/README.adoc:163` +Source:: + `trope-checker/docs/status/PROOF-STATUS.adoc:52` + +What differs + +Three rows diverge. (1) retention-order: PROOF-STATUS:52 cites ten Idris2 declarations including the four transitivity lemmas Trope.Order.\{fateLteTrans,bondLteTrans,mergeLteTrans,dLteTrans}; the ledger's reference.idris2.declarations for that row lists six and omits all four. (2) veridicality-derivation: PROOF-STATUS:60 adds `deceptiveDuals`, which the ledger's note expressly refuses to cite. (3) the same row's Agda names: PROOF-STATUS uses the real camelCase forms, the ledger uses kebab-case forms that do not exist. All four transitivity lemmas do exist (Order.idr:28, 45, 102, 172), so (1) is an under-citation in the ledger rather than an unsupported claim — but "agree row for row" is stated without qualification and is not true of any of the three. + +[[f-19]] +*Finding 19* — High · trope-checker · ledger · Other + +=== The gate never resolves declaration names, so every name in the ledger is unchecked evidence + +Claim:: + `trope-checker/scripts/pwg-check.sh:11` +Source:: + `trope-checker/scripts/pwg-check.sh:20` + +What differs + +The gate's five rules cover JCS canonicality, absence of asserted grades, receipt resolution and completeness, token/state/route vocabularies, and table/census agreement. None of them reads the `declarations` arrays. `grep -n declarations scripts/pwg-check.sh scripts/pwg-derive.sh` returns nothing: the string does not occur in either script. The declaration names are the only link in the ledger between a grade and an actual theorem, and they are the one field no machine checks. Twelve dangling names (the other findings here) sit in the ledger on a tree where `bash scripts/pwg-check.sh` exits 0 and prints PASS. The receipts attest that All.agda and Smoke.agda typecheck; they attest nothing about whether the named declarations are the ones that did. + +[[f-20]] +*Finding 20* — Medium · trope-checker · ledger · Cites the wrong object + +=== L2 cites TB.Grade.gmonoid-unit; the source has gmonoid-unitL and gmonoid-unitR + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Grade.agda:503` + +What differs + +No declaration named `gmonoid-unit` exists in TB/Grade.agda. The unit law is stated as two declarations, gmonoid-unitL (:503) and gmonoid-unitR (:506), and both are exported in Smoke.agda:14. docs/status/PROOF-STATUS.adoc:32 gets this right (`TB.Grade.{gmonoid-unitL,gmonoid-unitR}`); only the ledger is wrong. A reader resolving the L2 PWG-3 grade back to its witness finds nothing. + +[[f-21]] +*Finding 21* — Medium · trope-checker · ledger · Cites the wrong object + +=== L3 and L5 cite TB.Tier.deceptive-absorbs-|>; the declaration is deceptive-absorbs-▷ + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Tier.agda:108` + +What differs + +The ledger writes the composition operator ▷ as the ASCII digraph `|>`. No declaration `deceptive-absorbs-|>` exists; the name is `deceptive-absorbs-▷` (TB/Tier.agda:108, imported by TB/Reduction.agda:41). The same ASCII substitution appears in two separate theorem records, so it is systematic, not a typo. docs/status/PROOF-STATUS.adoc:36 and :44 both use the correct `TB.Tier.deceptive-absorbs-▷`. + +[[f-22]] +*Finding 22* — Medium · trope-checker · ledger · Cites the wrong object + +=== veridicality-derivation cites three kebab-case names; all three declarations are camelCase + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Honest.agda:55` + +What differs + +The string "deceptive-unique" does not occur anywhere under verification/proofs/agda. All three declarations are camelCase: fateDeceptiveUnique (:55), bondDeceptiveUnique (:58), mergeDeceptiveUnique (:61). docs/status/PROOF-STATUS.adoc:60 spells them correctly (`TB.Honest.{fateDeceptiveUnique,bondDeceptiveUnique,mergeDeceptiveUnique,deceptiveDuals}`); the ledger is the only surface carrying the kebab-case forms. This record is derived PWG-3, so all three of its cited witnesses are unresolvable. + +[[f-23]] +*Finding 23* — Medium · trope-checker · ledger · Cites the wrong object + +=== retention-order cites TB.Order.|=-refl; the reflexivity declaration is ⊑-refl + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/agda/theorem-b/TB/Order.agda:146` + +What differs + +The string "|=-refl" does not occur anywhere under verification/proofs/agda. The order relation is written ⊑ (defined at TB/Order.agda:112, `_⊑_ : Grade → Grade → Set`) and its reflexivity proof is ⊑-refl at :146; the ledger has rendered ⊑ as the ASCII `|=`. This leg is the sole evidence behind the prose at docs/status/PROOF-STATUS.adoc:305 ("the retention order proves reflexivity but neither transitivity nor decidability"), and the PROOF-STATUS row at :52 names only Idris2 declarations, so the ledger is the only place the Agda witness is named at all - and it names it wrongly. + +[[f-24]] +*Finding 24* — Medium · trope-checker · ledger · Cites the wrong object + +=== C3's Lean leg qualifies fidelity_total_honest_not_cancel into the Delta namespace, where it does not live + +Claim:: + `trope-checker/verification/pwg.json:1` +Source:: + `trope-checker/verification/proofs/lean4/grade-boundary/GradeBoundary.lean:408` + +What differs + +The theorem sits at GradeBoundary.lean:408, inside `namespace Grade` (opened :306, closed :413) inside `namespace Trope` (:75-:415). Its full name is therefore Trope.Grade.fidelity_total_honest_not_cancel. `namespace Delta` in that file spans only :87-:117, so Trope.Delta.fidelity_total_honest_not_cancel does not exist and the ledger's `Delta.`-qualified name would not resolve in Lean. The likely origin is visible at docs/status/PROOF-STATUS.adoc:86, which names it unqualified and parenthetically says it is "over `Delta`" - a statement about what the theorem is ABOUT, which the ledger has turned into a namespace it is not IN. The file's own axiom audit at :432 prints it unqualified under `open Trope Trope.Grade` (:422), confirming the Grade namespace. + +[[f-25]] +*Finding 25* — High · trope-checker · §8 derivation · Policy misapplied + +=== PWG-1 is awarded on PWG-2ii evidence: the "2ii" branch is unreachable + +Claim:: + `trope-checker/scripts/pwg-derive.sh:113` +Source:: + `PROOF-POLICY.adoc:533 (standards; local copy read 2026-11-16)` + +What differs + +Reaching this branch requires $legs == 2, i.e. counts() held for both rocq and lean; counts() (line 93) already requires usable_receipt on each leg, and $agda_ok (line 103) already requires pwg3_receipt($ar), whose selector is a strict subset of usable_receipt's. So all three conjuncts on lines 113-115 are logically entailed by having arrived here, and the else-branch "2ii" can never fire. PWG-1 is therefore granted automatically the moment PWG-2ii is reached, with zero additional evidence, contradicting §8.2's "PWG-2ii, plus ...". Confirmed behaviourally: a ledger with both legs RECONCILED/accepted yields pwg=1 (scratchpad/pwgaudit/c.json and d.json); across all four perturbed ledgers the only values ever emitted were 1, 3, not-applicable and ungraded — never 2ii. The published census line consequently reports `PWG-2ii` 0 as a structural certainty rather than a measurement. + +[[f-26]] +*Finding 26* — High · trope-checker · §8 derivation · Policy misapplied + +=== No receipt is ever checked against the theorem's source commit, so a grade can rest on a stale or foreign commit + +Claim:: + `trope-checker/scripts/pwg-derive.sh:64` +Source:: + `PROOF-POLICY.adoc:583 (standards; local copy read 2026-11-16)` + +What differs + +The only commit test is a shape test: 40 lowercase hex characters. The script never compares a receipt's .commit with the ledger's top-level .commit (c0eb4f1a1a50aabfab23b94fd74b53cef267f653) or with any per-theorem source revision, and §8.2 PWG-1 at policy line 534 requires the run to be "on the exact source commit". Demonstrated: planting receipts with commit ffffffffffffffffffffffffffffffffffffffff and 0000000000000000000000000000000000000000 on L1 (scratchpad/pwgaudit/c.json) produced pwg=1. §8.4 rule 4's anti-carry-forward rule is thus not implemented anywhere in the derivation; the script trusts the hand-written "state":"current" string as the sole freshness signal, which is precisely the kind of hand-written assertion §8.4 rule 2 exists to remove. + +[[f-27]] +*Finding 27* — Medium · trope-checker · §8 derivation · Policy misapplied + +=== §8.4 rule 6 is only half implemented: counted Rocq/Lean axioms are dropped and PROVEN-WITH-AXIOMS admissibility is never checked + +Claim:: + `trope-checker/scripts/pwg-derive.sh:128` +Source:: + `PROOF-POLICY.adoc:589 (standards; local copy read 2026-11-16)` + +What differs + +Two separate gaps. (a) $ar is the Agda receipt list only (line 102), so the derived record's axioms field never includes a counted Rocq or Lean witness's axioms, although §8.4 rule 6 names exactly those two provers' mechanisms. Demonstrated on scratchpad/pwgaudit/c.json: L1 scores pwg=1 with a counted lean leg whose token is PROVEN-WITH-AXIOMS, and the derived record still reads "axioms": []. The same shape is live in the real ledger, where receipt lean-boundary-c0eb4f1 lists [propext, Quot.sound, Classical.choice] and the derived L1 record reads "axioms": []. (b) `accepted` (line 52) treats PROVEN-WITH-AXIOMS as counting unconditionally; the disposition-(c) admissibility test the policy makes a precondition of counting is implemented nowhere in the script. Neither gap is backstopped by scripts/pwg-check.sh, which only checks that an axioms key exists on each receipt (pwg-check.sh:85). + +[[f-28]] +*Finding 28* — Medium · trope-checker · §8 derivation · Policy misapplied + +=== +foundation-diverse is set by mere field presence, with no kernel-checked witness or §2.2 correspondence check + +Claim:: + `trope-checker/scripts/pwg-derive.sh:125` +Source:: + `PROOF-POLICY.adoc:559 (standards; local copy read 2026-11-16)` + +What differs + +The tag is published whenever foundation_diverse_witness is any non-null value — an empty object, a bare string, a witness recorded as OPEN or ASSUMED, or one whose §2.2 state is BRIDGE-PENDING all set it to true. §8.3 attaches two substantive conditions (kernel-checked, and statement correspondence recorded per §2.2) and the script tests neither the §5 token nor the §2.2 state nor any receipt of that witness. The tag then flows into both published surfaces: the census (line 156-158) and the pwg column of the table (line 169). This is not backstopped: scripts/pwg-check.sh's vocabulary rules (lines 93-118) iterate .legs only and never inspect foundation_diverse_witness. In this repository every theorem has foundation_diverse_witness: null, so no false tag is currently published; the defect is latent in the derivation, not live in the ledger. + +[[f-29]] +*Finding 29* — Medium · trope-checker · §8 derivation · Policy misapplied + +=== The §2.1 invocation test is a substring scan over the whole receipt string, so options outside §2.1 and unflagged entrypoints still reach PWG-3 + +Claim:: + `trope-checker/scripts/pwg-derive.sh:78` +Source:: + `PROOF-POLICY.adoc:505 (standards; local copy read 2026-11-16)` + +What differs + +The three tests only require each flag to occur somewhere in the invocation string, and nothing bounds what else the string contains. Two consequences the policy forbids. (a) An invocation carrying an option outside §2.1 — for example a weakening flag such as --allow-unsolved-metas appended after the three required ones — still satisfies all three tests and yields PWG-3, although §8.2 line 505 makes that reachable only under a separately reviewed proof profile, and the script has no field or condition representing such a profile at all. (b) The ledger's own Agda invocation is two commands joined by " ; " (receipt agda-c0eb4f1), and a substring test over the joined string cannot tell that every entrypoint carried the flags; an invocation reading "agda --safe --without-K --cubical-compatible All.agda ; agda Smoke.agda" passes identically. §2.1 (policy lines 184-190) fixes how each theory proof entrypoint is invoked, not how the concatenation of them reads. + +[[f-30]] +*Finding 30* — Medium · mathesis · registry · Claim wider than proof + +=== ADR 0004 says the claims validator enforces a closed field set; validate() has no closed-field check and accepts a stored grade + +Claim:: + `mathesis/docs/decisions/0004-claims-registry.adoc:47` +Source:: + `mathesis/scripts/registry/claims-registry.mjs:86` + +What differs + +validate() checks presence and type of the ten named fields but never rejects an UNKNOWN field. Its two sibling validators do exactly that: bridges.mjs:58 calls closed(b, FIELDS, 'Unknown field (a bridge holds no token or grade):', where) and theory.mjs:38 does need(FIELDS.has(k), `Unknown field (an admission holds no grade) ${k}`). I ran validate() on a row carrying pwg:'PWG-1', token:'proven' and nonsense:42 and it returned ACCEPTED. The test suite does not prove this failure either: tests/registry/claims-registry.test.mjs:58 'validation fails closed' tests duplicate id, bad source_commit, unknown kind, missing agda, bad id shape, nonpublic repo, bad receipt sha256 and the shelf rules — no unknown-field case — and the only grade guard, line 57 (`rows.every(r => !('pwg' in r) && !('grade' in r))`), is an assertion over the committed data for two specific key names, not a validator rule. So an asserted grade written into claims.jsonl, which PROOF-POLICY §8.4 rule 2 calls drift and which this ADR's whole design exists to prevent, would pass `just registry-check` silently. + +[[f-31]] +*Finding 31* — High · mathesis · proofs · Claim wider than proof + +=== THY-1's Lean leg records "no axiom" from an audit that inspects zero declarations in that file + +Claim:: + `mathesis/docs/status/PROOF-STATUS.adoc:137` +Source:: + `mathesis/verification/proofs/lean4/FeatureReachability.lean:108` + +What differs + +lean4/FeatureReachability.lean contains no `theorem` or `lemma` whatsoever: reachMono (:41), absentBelow (:48), onMono (:77), onMonoAll (:82) and absentUnderAllFeatures (:108) are all `def`, because Reach, All and On are Type-valued inductives rather than Prop. The Lean axiom audit in scripts/check-proofs.sh:173 keeps only constants matching `if let .thmInfo _ := ci then`, so for this file it iterates over nothing, prints GATE-AUDIT-DONE 0, and check-proofs.sh:186 records AUDIT_NOTE "axioms: none for 0 declared theorem(s)". The empty `(axioms)` element written into the Lean leg of THY-1 at verification/receipts/theory_praxis.deed:95 therefore rests on an audit with an empty domain. "No declared theorem depends on an axiom" is true only because there are no declared theorems; PROOF-POLICY §8.4 rule 6 requires every counted witness to list its axioms, and PROOF-STATUS.adoc:129-130 separately asserts `#print axioms` reports none for absentUnderAllFeatures, reachMono and onMono, which the gate that produced the current receipt does not establish. (The Rocq side does not have this problem: coq/FeatureReachability.v:109 declares absent_under_all_features as a `Theorem`, and Print Assumptions on it covers reach_mono and edge_mono transitively. A literal `sorry` would still be caught textually by scripts/scan-dangerous.sh, so the gap is in the recorded axiom evidence, not in every guard.) + +[[f-32]] +*Finding 32* — Medium · mathesis · proofs · Ledger and source disagree + +=== PROOF-STATUS calls the Rocq and Lean THY-1 receipts "current" that the receipt deed records as superseded + +Claim:: + `mathesis/docs/status/PROOF-STATUS.adoc:110` +Source:: + `mathesis/verification/receipts/theory_praxis.deed:76` + +What differs + +The receipt deed marks run 42896264290 at 336768958d01 `:state superseded` for both the Rocq leg (deed:76-81) and the Lean leg (deed:100-105), with run 43498592499 at 034f215 as `:state current` (deed:66-75 and :89-99). PROOF-STATUS's THY-1 Agda row was updated to match (it shows 42896264290 as "superseded on 2026-11-13" at :87 and 43498592499 as "current" at :91), but the Rocq row (:110-113) and the Lean row (:135-137) still label the superseded 42896264290 receipt as "(current)" and name no 43498592499 receipt at all. PROOF-POLICY §8.4 rule 5 makes lineage state part of the receipt record, and §8.5 requires each leg's receipts with their lineage states to be in the home repository's proof-status file; the status file and the receipt therefore contradict each other about which two of THY-1's three legs are currently backed. + +[[f-33]] +*Finding 33* — Medium · mathesis · proofs · Claim wider than proof + +=== APP-1 claims the verdict is "missing" in a case no declaration in any of the three provers states + +Claim:: + `mathesis/docs/atlas/claims/claims.jsonl:19` +Source:: + `mathesis/verification/proofs/agda/Applied/Missing.agda:210` + +What differs + +The claim has three conjuncts. "no on a known breach" is Proofs.breach-decides (Missing.agda:216, concluding Σ Status (λ u → verdict f rs ≡ given u false)); "never yes then" is the contrapositive of Proofs.verdict-yes (:210). The middle conjunct, that the verdict is `missing` when there is no known breach but some value it depends on is missing, is stated by no declaration named in the claim and by no declaration anywhere in Applied/Missing.agda, Applied/Cohort.agda, coq/Cohort.v or lean4/Cohort.lean: verdict-yes only rules out `given u true`, which leaves `given s false` open, and breach-decides runs the other direction. The property is true of the Kleene conjunction at Applied/Cohort.agda:265-267, but it is unproved, so the registry row (docs/atlas/generated/registry.adoc:19) and the PROOF-NEEDS APP-1 row (docs/status/PROOF-NEEDS.adoc:41-43), which carry the same sentence, assert more than the cited theorems give. + +[[f-34]] +*Finding 34* — High · satellite status docs · Contradicts another claim + +=== haec's root PROOF-PROGRESS.adoc denies the existence of the proof tree that haec's own PROOF-STATUS describes in detail + +Claim:: + `haec/PROOF-PROGRESS.adoc:105` +Source:: + `haec/docs/status/PROOF-STATUS.adoc:82` + +What differs + +`/home/user/haec/verification/proofs/` exists and contains eleven proof-source files across agda/, coq/, idris2/ (incl. idris2/ABI/), lean4/ and tlaplus/. PROOF-PROGRESS.adoc states the opposite three further times: line 147 "| No proofs directory | Infrastructure | Not yet created", line 159 "| Proofs completed | 0 | No proofs directory yet", and line 186 "| Proofs exist | No | No proofs directory | Early implementation phase". A reader taking PROOF-PROGRESS at face value concludes haec has no proof tree at all, when in fact it has a never-instantiated template tree — a different, and more misleading, state. The document declares itself "Generated: 2026-08-14" (line 262) sourced from AFFIRMATION.adoc 2026-06-22, so it predates the 2026-11-09 PROOF-STATUS pass, but it sits unmarked at the repository root while PROOF-STATUS sits in docs/status/, and neither file points at the other. + +[[f-35]] +*Finding 35* — High · satellite status docs · Claim wider than proof + +=== Workbench reports the effect typology's exhaustiveness as a theorem; trope-checker records it as docstring prose that is explicitly not mechanised + +Claim:: + `trope-particularity-workbench/docs/status/RESEARCH-PROGRAMME.adoc:212` +Source:: + `trope-checker/docs/status/PROOF-STATUS.adoc:91` + +What differs + +The factorisation half is a real theorem; the exhaustiveness half is not. trope-checker's PROOF-STATUS says exhaustiveness is argued in a docstring and is not a proposition, and `EffectAtoms.lean:33-36` confirms it — the "exhaustive **relative to the carrier**" wording the workbench reproduces is module-comment prose, not a `theorem`. trope-checker's PWG ledger grades this row `ungraded`, `0 of 2` legs, Agda token `AGDA-PENDING` (PROOF-STATUS.adoc:244-247), and its retrospective states "Of O1, only the carrier-relative half is mechanised … O1 itself is therefore not closed" (line 426). The workbench's sentence conjoins a proved claim and an unproved one under one "is now a theorem", and restates it at line 296 ("the IR froze at 0.2 under R-2026-07-07 with O1's algebraic half proved") and line 228 ("O1's algebraic half is closed upstream"). This is a prose sentence wider than the theorem it cites. + +[[f-36]] +*Finding 36* — Medium · satellite status docs · Cites the wrong object + +=== Workbench cites the pre-ratification carrier's atom_factorization as the live result + +Claim:: + `trope-particularity-workbench/docs/status/RESEARCH-PROGRAMME.adoc:213` +Source:: + `trope-checker/verification/proofs/lean4/grade-boundary/EffectAtoms.lean:72` + +What differs + +The theorem in `EffectAtoms.lean` is stated over `Grade`, the historical pre-ratification carrier. trope-checker's PROOF-STATUS.adoc:91 says so explicitly: "`EffectAtoms.lean`'s `Grade.atom_factorization` is the factorisation statement over the historical pre-ratification carrier, retained as history". The ratified-carrier theorem the workbench means is `Trope.GradeR.atom_factorization` at /home/user/trope-checker/verification/proofs/lean4/grade-boundary/EffectAtomsRatified.lean:66, in a different file; `EffectAtomsRatified.lean:65` even says "exactly as `Grade.atom_factorization` showed for the historical carrier". The workbench's reference list (RESEARCH-PROGRAMME.adoc:327) repeats the error, naming `EffectAtoms.lean` among "the ratified-carrier proofs" while omitting `EffectAtomsRatified.lean`. + +[[f-37]] +*Finding 37* — Medium · satellite status docs · Contradicts another claim + +=== hermeneia's status board states that Vocarium does not exist; hermeneia's own README says the two meet at the M2 adapter + +Claim:: + `hermeneia/docs/status/STATE-OF-PLAY.adoc:71` +Source:: + `hermeneia/README.adoc:141` + +What differs + +/home/user/vocarium exists, is at "M1 invoke slice" with a working `voc` store engine, and the workbench's cross-repo table records it that way (/home/user/trope-particularity-workbench/docs/status/STATE-OF-THE-STACK.adoc:77-90). STATE-OF-PLAY is headed "*As at:* 2026-07-29" (line 8) and asserts "Every claim here was measured against `origin/main`" (lines 12-13), but it states the non-existence in the present tense in a live `docs/status/` board, and the same repository's README contradicts it. The surrounding substance — nothing is integrated, every result is against the in-repo JSONL stub — remains true; it is the reason given that is false. + +[[f-38]] +*Finding 38* — Low · satellite status docs · Claim wider than proof + +=== hermeneia's architecture rule says the grade algebra is proved in Idris2; trope-checker records Idris2 coverage as partial and Agda as the normative kernel + +Claim:: + `hermeneia/docs/status/STATE-OF-PLAY.adoc:99` +Source:: + `trope-checker/docs/status/PROOF-STATUS.adoc:39` + +What differs + +The algebra is not proved in Idris2 in the unqualified sense the sentence uses: trope-checker's own PROOF-STATUS records the L4 grade-level lifting as not mechanised in Idris2, and ADR 0005 D4 (/home/user/trope-checker/docs/decisions/0005-v0.2-consolidation-o5-and-prover-roles.adoc:61-68) assigns the normative-kernel role to Agda, with Idris2 as the executable reference only. The architectural point hermeneia is making — do not re-implement the algebra here, delegate verdicts — holds; the attribution of the proof to Idris2 alone is wider than what Idris2 states and names the wrong prover for the kernel. STATE-OF-PLAY is dated 2026-07-29, before ADR 0005 (2026-10-27), and has not been revisited. + +[[handoff]] +[[handoff-h]] +== Handoff notes + +Snapshot taken on 16 November 2026 at about 22:00 UTC, when the audit thread handed its work to a continuation thread. Pull-request states have moved since. Check each item against GitHub before acting on it. + +[arabic] +. *trope-checker#117 left draft.* The owner marked it ready for review at 19:51 UTC and turned on squash auto-merge at 19:52 UTC. GitHub reported it as blocked, at head `f37b92c`. +. *CodeRabbit's two review points were both addressed by its own agent.* Its commit `f37b92c` makes `pwg-check.sh:82` compare `result` by exact equality and adds a 22nd canary. It also gives the CHANGELOG a third reason why an obligation stays ungraded: an incomplete Agda leg. `retention-order` and `tier2-membership` are `OPEN` despite a current, passing receipt. That second change corrected text the audit thread had written. +. *That commit left the CHANGELOG inconsistent.* Lines 48 and 119 still say `21/21`, while line 158 says `22/22`. #114 shipped the same defect, 18/18 against 19/19. +. *Only one of eight loose regex anchors was fixed.* jq's `$` matches before a final newline, so `"pass\n"` passes `test("^(pass|fail)$")`. `f37b92c` fixed the `result` check. The other seven `^…$` anchors in `pwg-check.sh` and `pwg-derive.sh` still accept a trailing newline, including the 40-character commit check in the derivation. +. *The Hypatia gate failed on #117 at both heads, and is red on `main` too.* The scheduled run on `main` (43656845018) reports one current high or critical finding. Nothing is filtered because there is no `.hypatia-baseline.json`. This is the likely cause of the auto-merge block. +. *Cataloguing the trope stack in mathesis costs more than first stated.* The option was first put to the owner as one receipt file plus one mathesis pull request. Section 3 shows that trope-checker would have to emit receipts in the canon reader's deed format. The work buys visibility, not grade. The choice was to be put to the owner again with the real cost. +. *The audit found a defect in the derivation the audit thread wrote.* The `2ii` branch of `pwg-derive.sh` is unreachable, so PWG-1 is granted on exactly PWG-2ii evidence. This was confirmed by reading the source. It is latent: no obligation has two counting legs today, so no published grade is wrong. +. *One hardening from #114 went into a script nothing runs.* #114 hardened `tests/aspect_tests.sh`, but no workflow or recipe calls it. `just aspect` is still the template body that prints a pass without running anything (section 5, item 7). The comment-stripper fix from the same pull request is live, in three places in CI and in one just recipe. + +How this was produced: a read-only audit workflow ran one auditor per area, reading declarations and their stated types against every claim made of them. Each candidate finding then went to two independent verifiers, and a final pass wrote the synthesis. Sections 1 to 5 reproduce that synthesis verbatim. The header, the kernel note, the findings layout and the handoff notes were added for this page. + +Paths are given relative to each repository. Policy citations in findings 25 to 29 point at a copy of PROOF-POLICY read on 16 November 2026, so their line numbers may not match the current file. + +''''' + +[[transcriber-notes]] +== Transcriber's verification notes (2026-11-17) + +This section is not part of the audit. Everything above it is the owner's 16 November report, transcribed verbatim, and no sentence of it is changed. These notes record three review points raised by CodeRabbit on trope-checker#121, each checked against the source after transcription. They say how far three of the audit's sentences hold. No grade, finding number or recommendation changes. + +The audit read trope-checker at the head of #117. Its line references (`pwg-derive.sh:64`, `:125`, `:128`) match that tree, not `main` at `0dceab6`. Each note names the tree it was checked on. + +[arabic] +. *"Byte-matches the derived census" (section 1, "What is sound"; section 4, the §8.4 rule 7 row).* Not a byte match. On #117 and on `main`, `pwg-check.sh:136` (`:138` on #119) tests the census with `grep -qF "$want_census" "$STATUS"`. That is a fixed-string search over the whole status file. It is not a comparison with the census line at `PROOF-STATUS.adoc:296`. A line that holds the derived census plus extra text passes, and so does a copy anywhere else in the file. The PWG table, by contrast, is compared as an exact string (`:132`). +. *"`usable_receipt` … tests … `result == "pass"`" (section 1, weakness c).* Correct for the tree the audit read. On #117, `usable_receipt` (`pwg-derive.sh:64-66`) requires `.result == "pass"`, and `pwg-check.sh:82` limits `result` to `pass|fail`. Neither holds on `main` at `0dceab6`. There, `usable_receipt` (`pwg-derive.sh:49-51`) and `pwg3_receipt` (`:55-66`) never read `result`, and `pwg-check.sh:82` only requires a non-empty value. So on `main`, a current receipt that records `result: "fail"` can still support a grade, until #117 merges. +. *"Live today" for the dropped Rocq/Lean axioms (section 4, the §8.4 rule 6 row; section 5, item 13).* Latent, like the other gaps in item 13. The derived `axioms` field (`pwg-derive.sh:128` on #117) reads only the Agda receipts, so Rocq and Lean axioms never reach it. L1's Lean leg, cited as the live example, is `BRIDGE-PENDING`, so `counts()` rejects it. On #117 no Rocq or Lean leg counts for any obligation. The L1 example shows the omission in the derived output, but no counted witness loses its axioms, which is the case §8.4 rule 6 governs. On #119, fourteen Rocq and Lean legs count. Every one of their receipts lists no axioms, so the gap is still latent there. diff --git a/scripts/pwg-derive.sh b/scripts/pwg-derive.sh index 02360ad..7bc37e6 100755 --- a/scripts/pwg-derive.sh +++ b/scripts/pwg-derive.sh @@ -69,7 +69,7 @@ DERIVE=' # PROVEN-WITH-AXIOMS and its 2.2 correspondence state is RECONCILED." And: # a waived leg, an unavailable leg and any BRIDGE-PENDING leg do not count. # Also require at least one current receipt with a full 40-character commit, - # resolving the leg’s receipt IDs through the supplied receipt map. + # resolving receipt IDs for the leg through the supplied receipt map. def counts($leg; $receipts): ($leg.token | accepted) and $leg.state == "RECONCILED" diff --git a/scripts/test-gate-falsifiability.sh b/scripts/test-gate-falsifiability.sh index 2fe424c..3b16e54 100755 --- a/scripts/test-gate-falsifiability.sh +++ b/scripts/test-gate-falsifiability.sh @@ -232,11 +232,16 @@ pwg_canaries() { # it for being invalid JSON rather than for the planted drift, and the canary passes # without ever exercising its target. This plants exactly that and asserts the suite # reports FAILURE. Measured: this canary FAILS against the pre-fix harness. +# Function-local counters isolate the probe from the suite totals. +meta_probe() { + local PASS=0 FAIL=0 + pwg_case reject "meta-probe (expected to be reported as FAILING)" '.theorems[0].pwg = ' >/dev/null 2>&1 + printf 'FAILCOUNT=%s' "$FAIL" +} + meta_canary() { local out - out=$( PASS=0; FAIL=0 - pwg_case reject "meta-probe (expected to be reported as FAILING)" '.theorems[0].pwg = ' >/dev/null 2>&1 - printf 'FAILCOUNT=%s' "$FAIL" ) + out=$(meta_probe) if printf '%s' "$out" | grep -q 'FAILCOUNT=1'; then ok "a canary whose own jq program is broken is reported as FAILURE (meta-canary)" else