From 7e80cbe97b14f696e38dae2badc9b825369cefca Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 17 Nov 2026 17:01:20 +0000 Subject: [PATCH 1/2] proofs: record run 44131609502 at 246b03d with images; five rows PWG-1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The first run on main after hyperpolymath/januskey#184, which moved the Rocq and Lean recheck job into a digest-pinned image. Every witness of every theory row now ran in a pinned container, which PROOF-POLICY §8.2 requires for PWG-1 since metadatastician/standards#1625 (owner ruling 2026-11-16). - proof-receipt.sh: a run row takes a ninth field, the image the checker ran in, and a current receipt emits it as :image. The source commit moves to 246b03d. The standards reader is re-pinned to ce28e7d (the merge of standards#1625), which derives PWG-1 only when every counted witness names an image. - Run 43945986467 at e8deeaf is superseded: its Rocq and Lean legs ran on a bare runner. Every claim now has agda, rocq and lean legs (#180). - PROOF-NEEDS, PROOF-GRADES, READINESS: census PWG-1 5 of 5, with the images and the reason the earlier run no longer counts. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01GVPPsHYqVJSoPzdNYD9tRg --- PROOF-NEEDS.adoc | 40 +-- READINESS.adoc | 2 +- docs/theory/PROOF-GRADES.adoc | 121 ++++---- scripts/proof-receipt.sh | 50 ++-- verification/receipts/januskey_praxis.deed | 327 +++++++++++++++++++-- 5 files changed, 420 insertions(+), 120 deletions(-) mode change 100644 => 100755 scripts/proof-receipt.sh diff --git a/PROOF-NEEDS.adoc b/PROOF-NEEDS.adoc index d8a17ab..3824a18 100644 --- a/PROOF-NEEDS.adoc +++ b/PROOF-NEEDS.adoc @@ -62,15 +62,15 @@ tables must agree. | C-3 | A transaction containing an obliteration is not all-reversible | PROVEN | `+Layout.obliterateNotReversible+` | C-4 | Replacing a chain entry by one with a different hash breaks the link | PROVEN | `+Proofs.tamperBreaksLink+` | C-5 | Struct sizes 32/16/112 and 8-byte alignment as divisibility (statements about the literals) | PROVEN | `+Layout.{contentHashSize,keyIdSize,oblitProofSize,hashAligned,keyIdAligned,oblitAligned}+` -| G-1 | Reversibility as a Loss grade: lossless traces have only lossless steps; obliteration absorbs; a wrap/unwrap pair carries its cancellation law (its grade 𝟙 is assigned, not derived from that law) | PROVEN | `+verification/proofs/agda/Reversibility.agda+` (Agda kernel, resource-algebra pinned at `+cf9235c+`); `+tests/reject-agda/*+` refused; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/Reversibility+`, the Loss grade restated, legs not yet in the receipt); the cancellation premise is the TESTED row `+execute_then_undo_is_identity+` +| G-1 | Reversibility as a Loss grade: lossless traces have only lossless steps; obliteration absorbs; a wrap/unwrap pair carries its cancellation law (its grade 𝟙 is assigned, not derived from that law) | PROVEN | `+verification/proofs/agda/Reversibility.agda+` (Agda kernel, resource-algebra pinned at `+cf9235c+`); `+tests/reject-agda/*+` refused; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/Reversibility+`, the Loss grade restated, `+PWG-1+`); the cancellation premise is the TESTED row `+execute_then_undo_is_identity+` | G-2 | The Idris2 `+IsCNO+`/`+ReversibleOp+` pair corresponds to Agda `+ReversiblePair+` (by transcription) | ASSUMED | no mechanical link claimed | G-3 | The FFI bridge preserves grade 𝟙 (homomorphism) | OPEN | resource-algebra lists homomorphisms OPEN; to file from JNK-01 | E-1 | An attacker cannot recover obliterated content or use a revoked key | OPEN | `+Types.adversaryCannotKnow+` holds only because `+Knows+` has no Adversary constructor; the *model-level* half is now proved in Agda as row E-1m (#145 item 3) -| E-1m | In a world model, an adversary whose observation excludes the store does not know what it holds; obliteration leaves nothing to recover; rotation to a different key leaves no agent able to use the old one (premise `+old ≠ new+`; true by the definition of `+rotate+` in the model; that an unusable key cannot decrypt is X-1) | PROVEN | `+verification/proofs/agda/Epistemic.agda+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/Epistemic+`, legs not yet in the receipt); `+tests/reject-agda/{AdversaryKnows,OldKeyStillUsable}.agda+` refused +| E-1m | In a world model, an adversary whose observation excludes the store does not know what it holds; obliteration leaves nothing to recover; rotation to a different key leaves no agent able to use the old one (premise `+old ≠ new+`; true by the definition of `+rotate+` in the model; that an unusable key cannot decrypt is X-1) | PROVEN | `+verification/proofs/agda/Epistemic.agda+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/Epistemic+`, `+PWG-1+`); `+tests/reject-agda/{AdversaryKnows,OldKeyStillUsable}.agda+` refused | X-1 | Hash one-wayness; physical erasure (cryptographic and physical assumptions, external to this repository) | ASSUMED | not theorems of this repo | T-1 | Undoing a fully executed transaction's operations in reverse order restores the state it began in, given each step's undo restores its execute (the sequential Theorem 3.4) | PROVEN | `+TransactionAtomicity.rollback-restores+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/Rollback+`, `+PWG-1+`); `+tests/reject-agda/ForwardRollback.agda+` refused -| T-2 | In any single-active log (records with a decidable key and an active or settled phase), opening a fresh active record, a key- and phase-preserving edit, and a settling transition each preserve the invariant and rewrite only the active record, so a settled one is never modified | PROVEN | `+SingleActiveLog.{begin-good,modify-good,finish-good,update-active}+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/SingleActiveLog+`, legs not yet in the receipt); `+tests/reject-agda/SettleWithoutSettling.agda+` refused; januskey's instance is `+TransactionAtomicity.lifecycle-preserves-good+`; `+tests/reject-agda/CommitWhenIdle.agda+` refused -| T-3 | In any single-active log satisfying the invariant, at most one record is active, and exactly one when the pointer is set | PROVEN | `+SingleActiveLog.at-most-one-active+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/SingleActiveLog+`, legs not yet in the receipt) (januskey's transactions are an instance) +| T-2 | In any single-active log (records with a decidable key and an active or settled phase), opening a fresh active record, a key- and phase-preserving edit, and a settling transition each preserve the invariant and rewrite only the active record, so a settled one is never modified | PROVEN | `+SingleActiveLog.{begin-good,modify-good,finish-good,update-active}+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/SingleActiveLog+`, `+PWG-1+`); `+tests/reject-agda/SettleWithoutSettling.agda+` refused; januskey's instance is `+TransactionAtomicity.lifecycle-preserves-good+`; `+tests/reject-agda/CommitWhenIdle.agda+` refused +| T-3 | In any single-active log satisfying the invariant, at most one record is active, and exactly one when the pointer is set | PROVEN | `+SingleActiveLog.at-most-one-active+`; rechecked in Rocq and Lean (`+verification/proofs/{rocq,lean}/SingleActiveLog+`, `+PWG-1+`) (januskey's transactions are an instance) | T-4 | A rollback that fails part-way can be retried to completion | TESTED | `+rollback_resume_test+` drives the real `+jk+`: after one undo error and a repair, `+jk rollback+` skips the already undone operation and finishes (before the fix the retry stopped at it every time, reproduced 2026-10-26); fixed in `+cmd_rollback+` | T-5 | The transaction log is never left disagreeing with memory by a failed save, and is replaced by rename rather than overwritten in place, with an fsync before the rename by construction (no test observes the fsync) (a randomly named temporary file opened with the old file's mode, removed only if this save created it) rather than overwritten in place | TESTED | `+transaction::tests::failed_save_*+`: a save that fails at the final step leaves begin, add_operation, commit and rollback unapplied in memory; mutants (memory first, plain `+fs::write+`, no temp cleanup, shared temp name, truncating open, no permission copy) each fail a test. Not claimed: crash-safety of the rename itself is by construction, not crash-injected; the directory fsync is best effort (owner decision 2026-11-09), because failing the save after the rename would leave disk new and memory old; concurrent writers are out of scope (each save's content is intact, the last rename wins) | T-6 | A failed execute leaves the filesystem unchanged, and each undo restores the state its execute started from (premises of T-1; single steps are TESTED by `+execute_then_undo_is_identity+`) | ASSUMED | not checked for the failure path @@ -133,27 +133,30 @@ link:verification/receipts/januskey_praxis.deed[`+verification/receipts/januskey (§8.5.1, profile `+proof-receipt+`), written by `+scripts/proof-receipt.sh+` and checked by `+just test-receipt+` and CI with the standards reader pinned by commit, which derives each grade and refuses one the receipts do not support. -It describes commit `+b503488+` on `+main+`, where green `+agda-proofs.yml+` run -https://github.com/hyperpolymath/januskey/actions/runs/43213340167[43213340167] +It describes commit `+246b03d+` on `+main+`, where green CI run +https://github.com/hyperpolymath/januskey/actions/runs/44131609502[44131609502] +(the `+agda-proofs.yml+` jobs, each in a digest-pinned container: Agda in +`+debian:trixie-slim@sha256:a29215f6…+`, Rocq and Lean in +`+ubuntu:24.04@sha256:73b99939…+`, each recorded as the receipt's `+:image+`) checked `+Reversibility+`, `+TransactionAtomicity+`, `+Epistemic+` and `+SingleActiveLog+` under `+--safe --without-K --cubical-compatible+` (Agda 2.6.4.3, `+resource-algebra+` pinned at `+cf9235c+`, import cone 7 first-party -modules and 8 supplied with the prover, 0 postulates) and T-1's Rocq and Lean -legs. Each of the five is `+PROVEN+` under the §2.1 invocation with -correspondence state `+AGDA-VERIFIED+`. The superseded receipts (runs 42736066407 +modules and 8 supplied with the prover, 0 postulates) and the Rocq and Lean legs of all five rows (22 axiom reports in +each prover, every one clean). Each of the five is `+PROVEN+` under the §2.1 invocation with +correspondence state `+AGDA-VERIFIED+`. The superseded receipts (runs 43945986467 at `+e8deeaf+`, whose Rocq and Lean +legs ran on a bare runner and so were not isolated under §8.2, 43213340167 at `+b503488+`, 42736066407 at `+e165438+`, 42076969251 at `+23bc8c3+`, 41687715055 at `+fc188c4+` and 40867211509 at `+4afb710+`), the cone and the axioms (none in the development; the prover's four universe-level primitives are checked by name and binding and listed as its trusted base) are recorded in the receipt and in link:docs/theory/PROOF-GRADES.adoc[`+docs/theory/PROOF-GRADES.adoc+`]. -*PWG census, theory theorems of this repository (denominator 5):* `+PWG-3+` 4 -(G-1, T-2, T-3, E-1m) · `+PWG-2i+` 0 · `+PWG-2ii+` 0 · `+PWG-1+` 1 (T-1) · +*PWG census, theory theorems of this repository (denominator 5):* `+PWG-1+` 5 +(G-1, T-1, T-2, T-3, E-1m) · `+PWG-2ii+` 0 · `+PWG-2i+` 0 · `+PWG-3+` 0 · `+ungraded+` 0. G-3 names this repository's FFI bridge, so PROOF-POLICY §1 classes it as engineering and it is outside the ladder. Every row now has a Rocq leg and a Lean leg, re-proved by hand and reconciled statement by statement (`+docs/theory/PROOF-GRADES.adoc+`, §The recheck -legs). The legs of G-1, T-2, T-3 and E-1m enter the receipt's claim list once a -CI run on `+main+` has checked them; the reader then derives their grade. A grade +legs), and all three witnesses of every row are in the receipt. A grade is not a discharge (§8.4): the premises each row names stay where they are. The other seven PROVEN rows — A-1, A-2, C-1 to C-5 — are Idris2 theorems. Under @@ -165,11 +168,12 @@ contracts, and **Verus** (PROOF-POLICY §1.2, owner ruling 2026-11-07; not SPARK and not Idris2); neither verifier has a contract or proof in this tree yet, which is why no Rust row is proved. -Only T-1 is above `+PWG-3+`: it is `+PWG-1+`. Its Rocq and Lean legs are re-proved -and reconciled, and all three witnesses have current receipts from pinned CI -checkers run on the receipt's source commit (§8.2). No row is `+PWG-2i+` or -`+PWG-2ii+`. A later change to a leg's inputs makes the receipt stale (the CI job -warns), and the grade then holds for `+b503488+` until a run of the new commit is +All five theory rows are `+PWG-1+`: their Rocq and Lean legs are re-proved and +reconciled, and all three witnesses of each have current receipts from pinned, +headless and isolated CI checkers (each in a digest-pinned container, recorded as +`+:image+`) run on the receipt's source commit (§8.2). No row is `+PWG-2i+`, +`+PWG-2ii+` or `+PWG-3+`. A later change to a leg's inputs makes the receipt stale (the CI job +warns), and the grade then holds for `+246b03d+` until a run of the new commit is recorded (§8.4, "regression drops the grade"). The row-by-row mapping is in `+docs/theory/PROOF-GRADES.adoc+`. Since 2026-11-01 the gate runs PROOF-POLICY §2.1's canonical invocation diff --git a/READINESS.adoc b/READINESS.adoc index f3a9ff9..1bb6e42 100644 --- a/READINESS.adoc +++ b/READINESS.adoc @@ -65,7 +65,7 @@ handling (run by idris-abi.yml, agda-proofs.yml and dashboard-check) |=== -*Total declared:* 144 tests + 5 benchmark groups; 12 proofs checked (PROVEN ledger rows; five are theory theorems under PROOF-POLICY §8, graded from the receipt: T-1 at PWG-1 and four at PWG-3, whose Rocq and Lean legs check but have no CI receipt yet — see `docs/theory/PROOF-GRADES.adoc`) *Total +*Total declared:* 144 tests + 5 benchmark groups; 12 proofs checked (PROVEN ledger rows; five are theory theorems under PROOF-POLICY §8, all five at PWG-1, derived from `verification/receipts/januskey_praxis.deed` — see `docs/theory/PROOF-GRADES.adoc`) *Total missing:* Fuzz, mutation, chaos, compatibility === Aspect Matrix diff --git a/docs/theory/PROOF-GRADES.adoc b/docs/theory/PROOF-GRADES.adoc index 0675b5e..c4d8603 100644 --- a/docs/theory/PROOF-GRADES.adoc +++ b/docs/theory/PROOF-GRADES.adoc @@ -13,12 +13,12 @@ repository, and none is introduced here. [NOTE] ==== *PWG census, theory theorems of this repository (denominator 5):* -`PWG-3` 4 (G-1, T-2, T-3, E-1m) · `PWG-2i` 0 · `PWG-2ii` 0 · `PWG-1` 1 (T-1) · +`PWG-1` 5 (G-1, T-1, T-2, T-3, E-1m) · `PWG-2ii` 0 · `PWG-2i` 0 · `PWG-3` 0 · `ungraded` 0. `+foundation-diverse`: none. Axioms: none. Derived by the pinned standards reader from `verification/receipts/januskey_praxis.deed` (§The -machine-readable receipt below), not typed. G-1, T-2, T-3 and E-1m now also have -Rocq and Lean legs (§The recheck legs below). They join the receipt once a CI -run on `main` has checked them, and the reader then derives their grade. +machine-readable receipt below), not typed: every theory row has an Agda, a Rocq +and a Lean witness, each with a current receipt from a pinned CI checker run on +the receipt's source commit (§The recheck legs below). The denominator is the ledger rows whose source of truth is an Agda theorem. PROOF-POLICY §1 puts a statement that names one repository's type, function or @@ -130,31 +130,38 @@ run the §8.5.3 git checks (each manifest holds at its commit, the and warn when a leg's inputs have changed since the receipt's source commit. This page is the human reading of that file. -The change that added the Rocq and Lean legs of G-1, T-2, T-3 and E-1m added -files to `verification/proofs/rocq` and `verification/proofs/lean`, which are -T-1's recheck inputs, and changed their checker, `scripts/check-recheck.sh`. The -receipt still describes `b503488` and stays true of it, so T-1 is `PWG-1` there; -the CI job warns that HEAD has moved on. The follow-up that records the first -green `main` run after that change adds it to the run ledger, adds the four -rows' legs to the claim list, and the reader derives all five grades afresh. - -The receipt describes commit `b5034884dbe945139d03b38fe80cfdf1106a77e1` on `main`. -The gate changed twice before it, in hyperpolymath/januskey#170 (the import-cone +The receipt describes commit `246b03d8888a08e9540611b3b7ddeb8052004f8e` on `main`, +the merge of hyperpolymath/januskey#184, which moved the Rocq and Lean recheck job +into a digest-pinned container. Under the owner ruling of 2026-11-16 a `PWG-1` +checker must be isolated, which PROOF-POLICY §8.2 now defines as running in a +container pinned by digest; each current receipt names its image (`:image`), and +the pinned reader derives `PWG-1` only when every counted witness has one. #184 +changed no proof input. Before it, hyperpolymath/januskey#180 added the Rocq and +Lean legs of G-1, T-2, T-3 and E-1m and made `scripts/check-recheck.sh` count +every axiom report. Before that, the gate changed in hyperpolymath/januskey#170 (the import-cone postulate scan) and #174 (a token may start after a skipped literal), and #171 changed the modules' bytes and added `SingleActiveLog.agda`. A changed checker or changed inputs re-earn the receipt (§8.4), so every receipt from before those -changes is `superseded`, and the current one is a run on `main` after all three. +changes is `superseded`, and the current one is a run on `main` after all of them. [cols="1,3",options="header"] |=== | Field | Value -| Workflow, run | `agda-proofs.yml`, run - https://github.com/hyperpolymath/januskey/actions/runs/43213340167[43213340167], - branch `main`, conclusion **success**: job "Reversibility as a grade (Loss - instance), expected rejections" (Agda) and job "Rocq and Lean recheck legs, - expected rejections" (T-1's legs, §The recheck legs below) -| Commit | `b5034884dbe945139d03b38fe80cfdf1106a77e1` (started 2026-11-12T11:55:42Z) +| Workflow, run | `ci.yml` calling `agda-proofs.yml` (hyperpolymath/januskey#190), run + https://github.com/hyperpolymath/januskey/actions/runs/44131609502[44131609502], + branch `main`, conclusion **success**: job "agda-proofs / Reversibility as a + grade (Loss instance), expected rejections" (Agda) and job "agda-proofs / Rocq + and Lean recheck legs, expected rejections" (all five rows' legs: 4 Rocq and 4 + Lean files, 22 axiom reports in each prover, every one clean; 8 refusals as + named; §The recheck legs below) +| Commit | `246b03d8888a08e9540611b3b7ddeb8052004f8e` (started 2026-11-17T16:57:25Z) +| Images (`:image`) | Agda job: + `debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f`. + Recheck job: + `ubuntu:24.04@sha256:73b999393d07f2bf65a40373778a44dc9a6d54ad7718d29247d8ff9413c4d6a8`. + Each is the job's `container:`, and the run's log names the same digest when it + stops the container | Prover | `agda-bin=2.6.4.3-1+b2` on Debian trixie-slim (`@sha256:a29215f6…`), asserted by a passing step: `test "$(agda --version)" = 'Agda version 2.6.4.3'` @@ -197,10 +204,20 @@ Earlier receipts, kept with their lineage (§8.4) here and in the receipt file: |=== | Run, commit | State | Why +| https://github.com/hyperpolymath/januskey/actions/runs/43945986467[43945986467], `e8deeaf` +| `superseded` +| All five rows' legs, but its Rocq and Lean legs ran on a bare `ubuntu-24.04` + runner, not in a digest-pinned container, so they were not isolated + (PROOF-POLICY §8.2, owner ruling 2026-11-16). No proof input changed after + `e8deeaf`, and run 44131609502 at `246b03d` replaces it +| https://github.com/hyperpolymath/januskey/actions/runs/43213340167[43213340167], `b503488` +| `superseded` +| T-1's legs only (`Rollback.v`, `Rollback.lean`), before #180; the Agda inputs are + unchanged at `e8deeaf`, and run 43945986467 there replaces it | https://github.com/hyperpolymath/januskey/actions/runs/42736066407[42736066407], `e165438` | `superseded` -| The first green run on `main` of the gate as #174 left it; replaced by the run - at the receipt's source commit +| The first green run on `main` of the gate as #174 left it; replaced by run + 43213340167 at a later commit | https://github.com/hyperpolymath/januskey/actions/runs/42076969251[42076969251], `23bc8c3` | `superseded` | Before the cone scan (#170) and before `SingleActiveLog.agda` (#171) @@ -212,29 +229,29 @@ Earlier receipts, kept with their lineage (§8.4) here and in the receipt file: | Before `--cubical-compatible` and before `Epistemic.agda`; it never covered E-1m |=== -Those are the `PWG-3` facts: the propositions type-check in Agda under the -§2.1 invocation, in CI, at a named commit, with the prover version pinned and -the import cone recorded. For G-1, T-2, T-3 and E-1m the Rocq and Lean legs -exist (§The recheck legs below), but no CI run on `main` has checked them yet, so -no receipt counts them and their grade is `PWG-3`. T-1 has both legs, and each -counted witness (Agda, Rocq and Lean) has a current receipt from a pinned CI -checker run on the receipt's source commit itself, so the reader derives -`PWG-1` (§8.2; §The recheck legs below). No witness in another foundation exists, so +Those are the Agda facts: the propositions type-check under the §2.1 +invocation, in CI, at a named commit, with the prover version pinned and the +import cone recorded. Every theory row also has Rocq and Lean legs, re-proved and +reconciled (§The recheck legs below), and the same run checked them at the same +commit. Each counted witness (Agda, Rocq and Lean) therefore has a current receipt +from a pinned CI checker run on the receipt's source commit itself, so the reader +derives `PWG-1` for all five rows (§8.2). No witness in another foundation exists, so `foundation_diverse` is false throughout. -=== Why four rows are at PWG-3 - -`PWG-2i` and above require Rocq or Lean legs, with the outcome recorded as -`transported`, `re-proved` or `unavailable` (PROOF-POLICY §2), and a current -receipt for each counted leg. All four rows now have both legs, re-proved and -reconciled (§The recheck legs below). What they lack is the receipt: the first -green `main` run of the recheck job after the legs landed. When that run is -recorded in the receipt's run ledger and claim list, the reader derives their -grade: `PWG-1` if every counted witness is checked at the receipt's source -commit, as for T-1 (§8.2). A recheck would not change what these modules prove: -§2.2 is explicit that compiling in a second prover does not establish the same -proposition unless the correspondence is checked too, which is why each leg -carries its statement comparison. +=== How the four rows reached PWG-1 + +Until hyperpolymath/januskey#180, G-1, T-2, T-3 and E-1m had no Rocq or Lean leg +and were `PWG-3`. #180 re-proved all four by hand in both provers and reconciled +each statement (§The recheck legs below). The first green run of the recheck job +on `main` after it, run 43945986467 at `e8deeaf`, was their first receipt. Its +recheck job ran on a bare runner, so under the 2026-11-16 ruling it supports +`PWG-2ii`, not `PWG-1`. hyperpolymath/januskey#184 moved that job into a +digest-pinned container, and run 44131609502 at `246b03d`, where every witness +names its image, is the current receipt; the reader derives `PWG-1` from it. +A recheck alone would not change what these modules prove: §2.2 is explicit that +compiling in a second prover does not establish the same proposition unless the +correspondence is checked too, which is why each leg carries its statement +comparison. == The §2.1 invocation: adopted, and measured (2026-11-01) @@ -354,10 +371,9 @@ repeated the counts, and the two copies drifted apart. ==== Leg records (PROOF-POLICY §8.5) Every theory row now has both recheck legs, re-proved by hand, so one record -serves all five; only the receipts differ. T-1: `pwg: 1`, derived by the reader -from run 43213340167 at `b503488`, which checked all three of its witnesses. -G-1, T-2, T-3 and E-1m: `pwg: 3`. Their legs have no CI receipt yet, so the -receipt's claim list does not include them, and the reader counts none. +serves all five, and so does one run: `pwg: 1` for every row, derived by the +reader from run 44131609502 at `246b03d`, which checked all three witnesses of +each, every one in a digest-pinned container. `foundation_diverse: false` throughout. [cols="1,1,1,1,3",options="header"] @@ -374,10 +390,11 @@ receipt's claim list does not include them, and the reader counts none. | `re-proved` | `PROVEN` | `RECONCILED` -| T-1: run 43213340167, job "Rocq and Lean recheck legs", at `b503488`, in the - receipt. The other four: none yet. Their first receipt is that job's first - green run on `main` after the legs landed, which then joins the receipt's run - ledger +| All five rows: run 44131609502, job "agda-proofs / Rocq and Lean recheck + legs", at `246b03d`, in `ubuntu:24.04@sha256:73b99939…`, current in the + receipt. Run 43945986467 at `e8deeaf` checked the same legs on a bare runner + and is `superseded`. T-1's earlier receipts (run 43213340167 at `b503488`, run + 42646851111 at `0834ce7`) checked `Rollback` only and are `superseded` | Lean | `re-proved` diff --git a/scripts/proof-receipt.sh b/scripts/proof-receipt.sh old mode 100644 new mode 100755 index 2e0fdb6..67a7896 --- a/scripts/proof-receipt.sh +++ b/scripts/proof-receipt.sh @@ -34,7 +34,7 @@ out=verification/receipts/januskey_praxis.deed repo="hyperpolymath/januskey" # The commit the receipt describes: the main commit at which the current runs # below were earned. On the default branch, so no echo is needed (§8.5.2). -source_commit=b5034884dbe945139d03b38fe80cfdf1106a77e1 +source_commit=246b03d8888a08e9540611b3b7ddeb8052004f8e sibling_repo="hyperpolymath/resource-algebra" sibling_dir=_build/dependencies/resource-algebra @@ -42,8 +42,8 @@ sibling_dir=_build/dependencies/resource-algebra # reference digest script and the §8.5.3 git checker, all at one commit, each # with its sha256. They keep the standards layout under _build/standards, # because the checker finds the reader and the digest script by their paths. -STANDARDS_COMMIT=513cba8d1f6153389685bf34375f5aeaf9bcd150 -READER_SHA256=03634a2636f6aea202d777584978f8c7d99dc3c4fea7488d1300ba372b4386bd +STANDARDS_COMMIT=ce28e7d9a505fc35a0de9273aa7750ba0d1804be +READER_SHA256=9ded4520daf304555021afe9f58fd2184453c97d7d329c668022426fd3ede8ca DIGEST_SHA256=dfc6dde01a3a79df638eebe4cad0eae584d8f17280077e149174c0667e9508f4 CHECKER_SHA256=f2375747238464535d1b4a61f658f07cb2f8504c69bfb1812311c79429a4e23e STANDARDS_RAW="https://raw.githubusercontent.com/metadatastician/standards/$STANDARDS_COMMIT" @@ -60,20 +60,24 @@ die() { printf 'ERROR: %s\n' "$*" >&2; exit 1; } # bridge, so it is engineering under §1 and has no claim here. claims() { cat <<'ROWS' -G-1|agda +G-1|agda rocq lean T-1|agda rocq lean -T-2|agda -T-3|agda -E-1m|agda +T-2|agda rocq lean +T-3|agda rocq lean +E-1m|agda rocq lean ROWS } # ── The run ledger ──────────────────────────────────────────────────────────── # One row per checker run, copied from the log of the agda-proofs.yml job that -# printed it. One run of a leg checks every theorem of that leg, so each row -# is a receipt of that leg for every claim that has the leg. +# printed it (since hyperpolymath/januskey#190 those jobs run inside ci.yml, +# so newer run ids are CI runs). One run of a leg checks every theorem of that +# leg, so each row is a receipt of that leg for every claim that has the leg. # prover | run | commit (40 hex) | checker | invocation | state | reason | -# claims the run did not cover (space-separated; the row is left out of them) +# claims the run did not cover (space-separated; the row is left out of them) | +# image: the digest-pinned container the checker ran in (PROOF-POLICY §8.2, +# :image), copied from the job's `container:`; empty when it ran on a bare +# runner. The reader derives PWG-1 only when every counted leg has one. # A current row's inputs are computed at its commit; the axioms of every # current row are empty, because each gate fails on any axiom (check-agda.sh: # --safe and the cone scan; check-recheck.sh: Print Assumptions closed, @@ -82,18 +86,27 @@ AGDA_CHECKER='Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, contain AGDA_FLAGS='agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src' ROCQ_CHECKER='The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)' LEAN_CHECKER='Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)' +# The `container:` of each job in .github/workflows/agda-proofs.yml. +AGDA_IMAGE='debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f' +RECHECK_IMAGE='ubuntu:24.04@sha256:73b999393d07f2bf65a40373778a44dc9a6d54ad7718d29247d8ff9413c4d6a8' runs() { local u=https://github.com/hyperpolymath/januskey/actions/runs cat < Date: Tue, 17 Nov 2026 17:57:45 +0000 Subject: [PATCH 2/2] fix(proofs): key the standards cache by commit; retitle the theory section - proof-receipt.sh: the pinned standards files are cached under _build/standards/. A cached reader from the previous pin made a local --check fail its checksum until _build/standards was deleted by hand; a re-pin now fetches into a fresh directory, and every file is still checked against its pinned sha256. - PROOF-GRADES: the section that lists the theory rows was headed "PWG-3", but the census now has all five at PWG-1. It is retitled without a grade, since PROOF-NEEDS is the only place rows are counted. Both from CodeRabbit's review of this PR. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01GVPPsHYqVJSoPzdNYD9tRg --- docs/theory/PROOF-GRADES.adoc | 2 +- scripts/proof-receipt.sh | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/docs/theory/PROOF-GRADES.adoc b/docs/theory/PROOF-GRADES.adoc index c4d8603..fcdf051 100644 --- a/docs/theory/PROOF-GRADES.adoc +++ b/docs/theory/PROOF-GRADES.adoc @@ -332,7 +332,7 @@ The ledger rows fall into three classes under PROOF-POLICY §1. `PROOF-NEEDS.ado is the only place the rows are counted: an earlier revision of this page repeated the counts, and the two copies drifted apart. -=== PWG-3 — theory, proved in Agda +=== Theory, proved in Agda — graded on the PWG ladder [cols="1,3,2",options="header"] |=== diff --git a/scripts/proof-receipt.sh b/scripts/proof-receipt.sh index 67a7896..6493aa8 100755 --- a/scripts/proof-receipt.sh +++ b/scripts/proof-receipt.sh @@ -40,14 +40,16 @@ sibling_dir=_build/dependencies/resource-algebra # The pinned standard: the reader readProofReceipt (PROOF-POLICY §8.5.1), the # reference digest script and the §8.5.3 git checker, all at one commit, each -# with its sha256. They keep the standards layout under _build/standards, +# with its sha256. They keep the standards layout under _build/standards/, # because the checker finds the reader and the digest script by their paths. STANDARDS_COMMIT=ce28e7d9a505fc35a0de9273aa7750ba0d1804be READER_SHA256=9ded4520daf304555021afe9f58fd2184453c97d7d329c668022426fd3ede8ca DIGEST_SHA256=dfc6dde01a3a79df638eebe4cad0eae584d8f17280077e149174c0667e9508f4 CHECKER_SHA256=f2375747238464535d1b4a61f658f07cb2f8504c69bfb1812311c79429a4e23e STANDARDS_RAW="https://raw.githubusercontent.com/metadatastician/standards/$STANDARDS_COMMIT" -std_dir=_build/standards +# Keyed by commit, so a re-pin fetches the new files instead of finding the +# old ones cached and failing their checksum. +std_dir="_build/standards/$STANDARDS_COMMIT" die() { printf 'ERROR: %s\n' "$*" >&2; exit 1; }