diff --git a/.github/workflows/agda-proofs.yml b/.github/workflows/agda-proofs.yml index 4947f41..7298c30 100644 --- a/.github/workflows/agda-proofs.yml +++ b/.github/workflows/agda-proofs.yml @@ -17,11 +17,28 @@ jobs: timeout-minutes: 15 # trixie-slim, resolved 2026-10-13; re-pin deliberately, like the prover below. container: debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f + env: + # PROOF-POLICY §6 deviation D-1 (PROOF-NEEDS.adoc, "Toolchain deviations"): + # the prover comes from Debian's archive, not a Guix manifest or the repo's + # own container. These are the archive's SHA-256 for the two packages that + # hold it: the binary, and the library that ships Agda.Primitive. + AGDA_VERSION: 2.6.4.3-1+b2 + AGDA_BIN_SHA256: 31052ce0b53e9cf061c9386a0416525318a66bbd1bfaa4bef93f0f43dec8b748 + LIBGHC_AGDA_DEV_SHA256: 58d8551bec42796d2aa9f6baaa253eb23095e118869fe235be6d4aa2e130ce60 steps: - - name: Install the pinned prover + - name: Install the pinned prover (digest-checked, deviation D-1) run: | apt-get update - apt-get install --no-install-recommends -y ca-certificates git agda-bin=2.6.4.3-1+b2 + apt-get install --no-install-recommends -y ca-certificates git + cd "$RUNNER_TEMP" + apt-get download "agda-bin=${AGDA_VERSION}" "libghc-agda-dev=${AGDA_VERSION}" + printf '%s %s\n' \ + "${AGDA_BIN_SHA256}" "agda-bin_${AGDA_VERSION}_amd64.deb" \ + "${LIBGHC_AGDA_DEV_SHA256}" "libghc-agda-dev_${AGDA_VERSION}_amd64.deb" \ + | sha256sum -c - + apt-get install --no-install-recommends -y \ + "./agda-bin_${AGDA_VERSION}_amd64.deb" "./libghc-agda-dev_${AGDA_VERSION}_amd64.deb" + rm ./*.deb - name: Checkout uses: actions/checkout@v7.0.1 with: @@ -42,14 +59,33 @@ jobs: # ubuntu:24.04, resolved 2026-11-16; re-pin deliberately, like the provers below. container: ubuntu:24.04@sha256:73b999393d07f2bf65a40373778a44dc9a6d54ad7718d29247d8ff9413c4d6a8 env: + # PROOF-POLICY §6 deviations D-2 (Rocq, from Ubuntu's archive) and D-3 + # (Lean, from the upstream release tarball); PROOF-NEEDS.adoc, "Toolchain + # deviations". The Rocq digests are the archive's SHA-256 for the driver, + # the kernel library and the library that ships Init. + COQ_VERSION: 8.18.0+dfsg-1build2 + COQ_SHA256: 22897a17a75d8930276f5eedd5cd29ac940f1ab4d4661b6a49ccc63577e54d3b + LIBCOQ_CORE_OCAML_SHA256: 027c8fb39db20de4910f8a75e0b9a32c0fbc27c6f532375ed7604757f71c12a9 + LIBCOQ_STDLIB_SHA256: af139bb3af8c71b5e991944a61eef5bba28038a715f71146fa046241bb614b23 LEAN_VERSION: 4.35.0 LEAN_SHA256: 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d DEBIAN_FRONTEND: noninteractive steps: - - name: Install the pinned provers + - name: Install the pinned provers (digest-checked, deviations D-2 and D-3) run: | apt-get update - apt-get install --no-install-recommends -y ca-certificates curl git zstd coq=8.18.0+dfsg-1build2 + apt-get install --no-install-recommends -y ca-certificates curl git zstd + cd "$RUNNER_TEMP" + apt-get download "coq=${COQ_VERSION}" "libcoq-core-ocaml=${COQ_VERSION}" \ + "libcoq-stdlib=${COQ_VERSION}" + printf '%s %s\n' \ + "${COQ_SHA256}" "coq_${COQ_VERSION}_amd64.deb" \ + "${LIBCOQ_CORE_OCAML_SHA256}" "libcoq-core-ocaml_${COQ_VERSION}_amd64.deb" \ + "${LIBCOQ_STDLIB_SHA256}" "libcoq-stdlib_${COQ_VERSION}_amd64.deb" \ + | sha256sum -c - + apt-get install --no-install-recommends -y "./coq_${COQ_VERSION}_amd64.deb" \ + "./libcoq-core-ocaml_${COQ_VERSION}_amd64.deb" "./libcoq-stdlib_${COQ_VERSION}_amd64.deb" + rm ./*.deb curl --proto '=https' --tlsv1.2 -sSfL -o lean.tar.zst \ "https://github.com/leanprover/lean4/releases/download/v${LEAN_VERSION}/lean-${LEAN_VERSION}-linux.tar.zst" echo "${LEAN_SHA256} lean.tar.zst" | sha256sum -c - @@ -65,6 +101,7 @@ jobs: run: | test "$(coqc --version | head -1)" = 'The Coq Proof Assistant, version 8.18.0' lean --version | grep -q "^Lean (version ${LEAN_VERSION}, " + lake --version | grep -qF "(Lean version ${LEAN_VERSION})" - name: Recheck legs, no axioms, expected rejections run: bash scripts/check-recheck.sh receipt: diff --git a/.machine_readable/6a2/STATE.a2ml b/.machine_readable/6a2/STATE.a2ml index 190b064..4689634 100644 --- a/.machine_readable/6a2/STATE.a2ml +++ b/.machine_readable/6a2/STATE.a2ml @@ -50,13 +50,8 @@ total = "144 tests + 5 benchmark groups + 12 PROVEN ledger rows — as declared # Proof Witness Grades, standards 3-practice/PROOF-POLICY.adoc §8 (the # Mathesis brief's §5/§6 ladder, adopted with corrections). Never a # percentage. Receipts, lineage and per-row records: docs/theory/PROOF-GRADES.adoc. -grade-3 = "derived from verification/receipts/januskey_praxis.deed by the pinned standards reader: PWG-1 for T-1 (Agda, Rocq and Lean receipts at b503488); PWG-3 for G-1, T-2, T-3, E-1m, whose Rocq and Lean legs are re-proved and reconciled but have no receipt yet — census 4 + 1 of 5 theory theorems (G-3 and T-10 are engineering under PROOF-POLICY §1; T-2 and T-3 are stated over the abstract SingleActiveLog)" -receipt-commit = "verification/receipts/januskey_praxis.deed: source commit b503488, run 43213340167; earlier runs superseded (see docs/theory/PROOF-GRADES.adoc)" -receipt-prover = "Agda 2.6.4.3 (agda-bin=2.6.4.3-1+b2); no standard library; resource-algebra pinned at cf9235c" -receipt-flags = "--safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check (PROOF-POLICY §2.1 canonical, plus two stricter flags)" not-graded = "the 7 Idris2 PROVEN rows (ABI/interface contracts, PROOF-POLICY §8.1); all 33 TESTED rows (observed behaviour); ASSUMED/DESIGNED/OPEN rows" -open-obligations = "record the first green main run of the recheck legs of G-1, T-2, T-3 and E-1m in the receipt; no Creusot or Verus proof on the Rust, so no Rust behaviour is proved" -claimed-higher = "PWG-1 for T-1 only, as derived from the receipt; no PWG-2i or PWG-2ii, and no foundation-diverse witness" +open-obligations = "no Creusot or Verus proof on the Rust, so no Rust behaviour is proved" [test-categories-complete] unit = true diff --git a/PROOF-NEEDS.adoc b/PROOF-NEEDS.adoc index d8a17ab..0ca043b 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-3+`); 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-3+`); `+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-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-3+`); `+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+`, `+PWG-3+`); `+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-3+`) (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,26 @@ 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 `+e8deeaf+` on `+main+` (the merge of +hyperpolymath/januskey#180), where green `+agda-proofs.yml+` run +https://github.com/hyperpolymath/januskey/actions/runs/43945986467[43945986467] 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. Each of the five is `+PROVEN+` under the §2.1 invocation with +correspondence state `+AGDA-VERIFIED+`. The superseded receipts (runs 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+` 0 +· `+PWG-2ii+` 0 · `+PWG-2i+` 0 · `+PWG-3+` 5 (G-1, T-1, T-2, T-3, E-1m) · `+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 +classes it as engineering and it is outside the ladder. Every row 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). 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,16 +164,69 @@ 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 -recorded (§8.4, "regression drops the grade"). The row-by-row mapping is in +All five rows are `+PWG-3+`. Their Rocq and Lean legs are re-proved and +reconciled, but only the Agda witness has a current receipt. The Lean +receipt is `+superseded+`: that run used `+lean+` directly, and §8.2 names +`+lean+` under `+lake+` (owner ruling 2026-11-17). The legs now build under +`+lake+`. The Rocq receipt is `+superseded+` too: moving the Lean legs under +`+lake+` changed `+scripts/check-recheck.sh+`, the checker both legs run +through, and a changed checker re-earns the receipt. `+PWG-1+` needs all three +witnesses receipted at one source commit, so once one run on `+main+` that +checks Agda, Rocq and Lean together +is recorded as the new source commit, the reader derives `+PWG-1+` again. §8.2 accepts "a pinned +kernel run in CI" on the same terms as a checker service, and the owner ruled +on 2026-11-16 that pinned means a digest-pinned image: a fresh runner with +version pins is not enough (hyperpolymath/januskey#184). The Agda job has +always run in one, and the recheck job does since #184. The run at `+e8deeaf+` +predates that for Rocq and Lean, which is a further reason its receipts for +those legs are `+superseded+`. How the three provers are +installed is a separate matter, §6's, recorded under "Toolchain deviations" +below. A change to a leg's inputs fails the receipt gate until a run of the +new inputs is recorded, or the current run is marked `+superseded+` or +`+regressed+`, which drops the grade until then (§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 (`+--safe --without-K --cubical-compatible …+`). +=== Toolchain deviations (PROOF-POLICY §6) + +§6 asks CI to install proof toolchains through the repo's Guix manifest or its +container, and to record a `deviation` for any other route. januskey has +neither a Guix manifest nor a container for its provers, so all three CI legs +are deviations. Each install below downloads the named packages, refuses them +unless their SHA-256 matches, installs exactly those files, and then asserts the +version it got (`+.github/workflows/agda-proofs.yml+`, which carries the same +digests). The digests are the archives' own, checked on 2026-11-17 against the +downloaded packages. + +[cols="1,2,4,1", options="header"] +|=== +| ID | Leg | Tool, version, digest of what is installed | State + +| D-1 +| Agda (the source leg of G-1, T-1, T-2, T-3, E-1m), job `+proofs+` +| Debian trixie `+agda-bin=2.6.4.3-1+b2+` (SHA-256 `+31052ce0b53e9cf061c9386a0416525318a66bbd1bfaa4bef93f0f43dec8b748+`) and `+libghc-agda-dev=2.6.4.3-1+b2+`, which ships `+Agda.Primitive+` (SHA-256 `+58d8551bec42796d2aa9f6baaa253eb23095e118869fe235be6d4aa2e130ce60+`), in `+debian:trixie-slim@sha256:a29215f6…+` +| `open` + +| D-2 +| Rocq (the re-proved leg of all five), job `+recheck+` +| Ubuntu noble `+coq=8.18.0+dfsg-1build2+` (SHA-256 `+22897a17a75d8930276f5eedd5cd29ac940f1ab4d4661b6a49ccc63577e54d3b+`), `+libcoq-core-ocaml+` with the kernel (SHA-256 `+027c8fb39db20de4910f8a75e0b9a32c0fbc27c6f532375ed7604757f71c12a9+`) and `+libcoq-stdlib+` with `+Init+` (SHA-256 `+af139bb3af8c71b5e991944a61eef5bba28038a715f71146fa046241bb614b23+`), all `+8.18.0+dfsg-1build2+`, in the image `+ubuntu:24.04@sha256:73b999393d07f2bf65a40373778a44dc9a6d54ad7718d29247d8ff9413c4d6a8+` since hyperpolymath/januskey#184 +| `open` + +| D-3 +| Lean (the re-proved leg of all five), job `+recheck+` +| Upstream release `+lean-4.35.0-linux.tar.zst+` (SHA-256 `+7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d+`), in the image `+ubuntu:24.04@sha256:73b999393d07f2bf65a40373778a44dc9a6d54ad7718d29247d8ff9413c4d6a8+` since hyperpolymath/januskey#184 +| `open` +|=== + +Why not Guix or a container: the repository has not had a Guix manifest or a +prover container, and whether Guix packages these exact versions (Agda +2.6.4.3, Coq 8.18.0, Lean 4.35.0) has not been checked. A Guix manifest is +the planned route, with one digest-pinned container as the fallback. A +deviation closes when its job installs from either, and its state then +names the change that closed it. + === Current State _Re-verified 2026-06-29 (idris2 0.8.0); paths updated 2026-10-12 to the diff --git a/READINESS.adoc b/READINESS.adoc index f3a9ff9..39d7adf 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, graded from the receipt: all five at PWG-3 (only the Agda witness has a current receipt; the Rocq and Lean receipts are superseded until a run on main after the checker change is recorded) — 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..c7bccff 100644 --- a/docs/theory/PROOF-GRADES.adoc +++ b/docs/theory/PROOF-GRADES.adoc @@ -13,12 +13,11 @@ 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) · -`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. +`PWG-1` 0 · `PWG-2ii` 0 · `PWG-2i` 0 · `PWG-3` 5 (G-1, T-1, T-2, T-3, E-1m) · +`ungraded` 0. `+foundation-diverse`: none. Axioms: none, in any of the three +provers. Derived by the pinned standards reader from +`verification/receipts/januskey_praxis.deed` (§The machine-readable receipt +below), not typed. 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 @@ -118,43 +117,46 @@ also the ledger's recorded checker for rows G-1, T-1, T-2, T-3 and E-1m. === The machine-readable receipt The receipt of record is `verification/receipts/januskey_praxis.deed`, a praxis -deed with `:profile proof-receipt` (PROOF-POLICY §8.5.1). `scripts/proof-receipt.sh` -writes it from two typed ledgers (the claims and the CI runs, each run copied -from its log) and from git: the input set of each leg, every file's SHA-256 and -the §8.5.1 digest are computed, never typed. `just test-receipt`, and the -`agda-proofs.yml` job "Proof receipt, derived grades, git checks", regenerate it -and refuse any difference, run the standards reader pinned by commit and -SHA-256 (it derives every grade and refuses one the receipts do not support), -run the §8.5.3 git checks (each manifest holds at its commit, the -`resource-algebra` import holds at its pin, and the source commit is on `main`), -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 -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. +deed with `:profile proof-receipt` (PROOF-POLICY §8.5.1). It is written by the +estate's shared generator (standards `scripts/proof-receipt.sh`), which +`scripts/proof-receipt.sh` here fetches with the reader, the reference digest and +the §8.5.3 checker at one standards commit, each checked against its SHA-256. +The home script holds only januskey's own data: the claim list, the run ledger +(each run copied from its log), the run scopes (a superseded run is listed only +under the claims it checked), and the hooks naming each leg's invocation and +input set. Every file's SHA-256 and every §8.5.1 digest are computed from git, +never typed; a superseded run's digest is the reference digest of its leg's +inputs at that run's commit. `just test-receipt`, and the `agda-proofs.yml` job +"Proof receipt, derived grades, git checks", regenerate the receipt and refuse +any difference, run the §8.5.3 git checks (each manifest holds at its commit, +the `resource-algebra` import holds at its pin, and the source commit is on +`main`), and run the pinned reader, which derives every grade and refuses one +the receipts do not support, with a negative control. They also refuse a +receipt whose current runs no longer describe the tree: a change to a leg's +inputs must record a new run, or mark the current one `superseded` or +`regressed`, which drops the grade until a new run is recorded (§8.4). This +page is the human reading of that file. + +The receipt describes commit `e8deeaf7bc7b70500d57c282828512c8f8ba81f9` on `main`, +the merge of hyperpolymath/januskey#180, which added the Rocq and Lean legs of +G-1, T-2, T-3 and E-1m and changed their checker, `scripts/check-recheck.sh`. +Before it, the gate changed in #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 the 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], + https://github.com/hyperpolymath/januskey/actions/runs/43945986467[43945986467], 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) + instance), expected rejections" (Agda), job "Rocq and Lean recheck legs, + expected rejections" (all ten legs and eight twins, §The recheck legs below) + and job "Proof receipt, derived grades, git checks" +| Commit | `e8deeaf7bc7b70500d57c282828512c8f8ba81f9` (started 2026-11-16T20:04:43Z) | 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,6 +199,10 @@ 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/43213340167[43213340167], `b503488` +| `superseded` +| Agda and T-1's legs only, under the recheck gate before #180; replaced by the + run at #180's merge, the receipt's source commit | 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 @@ -212,28 +218,66 @@ 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 facts the grades rest on. 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 (`PWG-3`). Each of the five rows has a Rocq +leg and a Lean leg, re-proved and reconciled (§The recheck legs below), and each +of the three provers has a receipt from a pinned CI checker run on the +receipt's source commit itself. Only the Agda receipt is still current. The +Lean receipt from that run is now +`superseded`: the legs ran `lean` directly, and the owner ruled on 2026-11-17 +that §8.2's "`lean` under `lake`" means what it says (§What the grade rests on +below). The Rocq receipt from that run is `superseded` as well. The change +that moved the Lean legs under `lake` edited `scripts/check-recheck.sh`, the +checker both legs run through, and a changed checker re-earns the receipt +(§Reporting rules below). The Rocq steps of the script are byte-identical, but +the rule is about the checker, not about which of its lines changed. With no +current Rocq or Lean receipt neither leg counts, so the reader derives `PWG-3` +(Agda only). `PWG-1` needs all three witnesses receipted at one source commit. +So the first run on `main` after that change that checks Agda, Rocq and Lean +together will be recorded as the receipt's new source commit, and the reader +will derive `PWG-1` again. Recording only the Rocq and Lean legs of a later run +would leave Agda receipted at `e8deeaf`, and the reader would not derive `PWG-1`. 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 +=== What the grade rests on + +`PWG-1` needs every counted witness checked by "a headless, isolated, pinned +checker run on the exact source commit" (§8.2). §8.2 adds: "A pinned kernel +run in CI (`agda`, `rocq compile` or `coqc`, `lean` under `lake`) qualifies on +the same terms." The owner ruled on 2026-11-16 what "pinned" and "isolated" +require (hyperpolymath/januskey#184, which answers the question left open in +hyperpolymath/januskey#181): the checker must run in a digest-pinned image. +A fresh runner with version and SHA-256 pins is not enough. + +The Agda checker has always run in a container pinned by digest. At `e8deeaf` +the Rocq and Lean checkers ran on an ephemeral `ubuntu-24.04` runner, outside +any pinned image, so that run cannot earn `PWG-1` for those legs. Since #184 +the recheck job runs in `ubuntu:24.04` pinned by digest, with +`coq=8.18.0+dfsg-1build2` and the Lean release tarball checked by SHA-256 +inside it. + +Lean has a second condition. Until 2026-11-17 the legs ran `lean` directly on +single files, and §8.2 names `lean` under `lake`. The owner ruled that a direct +run does not qualify. The legs are now a Lake package +(`verification/proofs/lean/lakefile.toml`) that `scripts/check-recheck.sh` +builds with `lake build`. + +So the Rocq and Lean rows of the run at `e8deeaf` are both `superseded` in the +receipt: the run was outside a pinned image, the Lean legs ran directly, and +the change that moved them under `lake` edited the script both legs run +through. The grade is `PWG-3` until one run on `main` of all three witnesses, +with the Rocq and Lean legs in the pinned +image and under `lake`, is recorded. + +How the provers are installed is §6's concern, not §8.2's. None is installed +through a Guix manifest or the repo's own container, so each is a recorded +deviation (D-1 Agda, D-2 Rocq, D-3 Lean; PROOF-NEEDS.adoc, "Toolchain +deviations"), and CI refuses any package whose SHA-256 differs from the one +recorded. 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. == The §2.1 invocation: adopted, and measured (2026-11-01) @@ -315,7 +359,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 rows, proved in Agda, rechecked in Rocq and Lean [cols="1,3,2",options="header"] |=== @@ -354,10 +398,10 @@ 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. `pwg: 3` for each, derived by the reader. Run 43945986467 at +`e8deeaf` checked all three witnesses of every row, but its Rocq and Lean +receipts are `superseded` (§What the grade rests on above), so only the Agda +leg counts. `foundation_diverse: false` throughout. [cols="1,1,1,1,3",options="header"] @@ -374,10 +418,8 @@ 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 +| run 43945986467, job "Rocq and Lean recheck legs", at `e8deeaf`, in the + receipt (§The machine-readable receipt above) | Lean | `re-proved` diff --git a/scripts/check-recheck.sh b/scripts/check-recheck.sh index 5623b4b..5768a5d 100755 --- a/scripts/check-recheck.sh +++ b/scripts/check-recheck.sh @@ -7,14 +7,16 @@ # `#print axioms` in them must report no axioms, and every fixture under # tests/reject-rocq and tests/reject-lean must be refused with the message its # `expect:` line names. Prover versions are asserted by the caller (CI) and -# printed here. ROCQ and LEAN override the binaries. +# printed here. ROCQ, LEAN and LAKE override the binaries. set -euo pipefail cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." export LC_ALL="${LC_ALL:-C.UTF-8}" rocq="${ROCQ:-coqc}" lean="${LEAN:-lean}" +lake="${LAKE:-lake}" "$rocq" --version | head -1 "$lean" --version +"$lake" --version work="$(mktemp -d)" trap 'rm -rf -- "$work"' EXIT @@ -56,25 +58,31 @@ for f in "${rocq_src[@]}"; do echo "[PASS] rocq leg checks, no assumptions ($want theorems): $f" done -# Lean: compile each leg to an .olean so the fixtures can import it; the -# `#print axioms` line must report no axioms. +# Lean: build the legs as the Lake package in verification/proofs/lean +# (PROOF-POLICY §8.2 names `lean` under `lake` as a pinned kernel run), from a +# copy in the work directory so no .lake/ build output lands in the tree. Lake +# prints each `#print axioms` report as an `info: :::` line. +cp -- verification/proofs/lean/lakefile.toml verification/proofs/lean/lean-toolchain \ + "${lean_src[@]}" "$work/lean/" +out="$(cd "$work/lean" && "$lake" build 2>&1)" || { + printf '%s\n' "$out"; echo "ERROR: the Lean legs do not build under lake" >&2; exit 1; } +printf '%s\n' "$out" +if grep -q 'depends on axioms' <<<"$out"; then + echo "ERROR: a Lean leg depends on axioms (an #print axioms report lists them)" >&2; exit 1 +fi for f in "${lean_src[@]}"; do - mod="$(basename -- "$f" .lean)" - out="$(LEAN_PATH="$work/lean" "$lean" -o "$work/lean/$mod.olean" "$f" 2>&1)" || { - printf '%s\n' "$out"; echo "ERROR: $f does not check" >&2; exit 1; } - printf '%s\n' "$out" + name="$(basename -- "$f")" # Every `#print axioms` in the file must report none. Count the commands as - # Lean parses them, and fail outright on any report that lists an axiom. + # Lean parses them, and the reports Lake attributes to this file. want="$(grep -cE '^[[:space:]]*#print[[:space:]]+axioms[[:space:]]' "$f" || true)" - got="$(grep -c 'does not depend on any axioms' <<<"$out" || true)" - if grep -q 'depends on axioms' <<<"$out"; then - echo "ERROR: $f depends on axioms (an #print axioms report lists them)" >&2; exit 1 - fi + got="$(grep -cE "^info: ${name//./\\.}:[0-9]+:[0-9]+: .* does not depend on any axioms\$" <<<"$out" || true)" if [ "$want" -eq 0 ] || [ "$got" -ne "$want" ]; then echo "ERROR: $f depends on axioms ($got of $want #print axioms report none)" >&2; exit 1 fi - echo "[PASS] lean leg checks, no axioms ($want theorems): $f" + echo "[PASS] lean leg checks under lake, no axioms ($want theorems): $f" done +# A fixture is checked by the same Lean, with the built legs on its path. +lake_lean() { (cd "$work/lean" && "$lake" env "$lean" "$1"); } # Expected rejections: refused, and refused for the stated reason. expect_of() { sed -n 's/^.*expect: \(.*\)$/\1/p' "$1" | head -1 | sed 's/ \*)$//'; } @@ -98,6 +106,6 @@ for f in "${rocq_rej[@]}"; do reject "$f" "$rocq" -q -Q "$work/rocq" JanusKey "$work/reject-rocq/$(basename -- "$f")" done for f in "${lean_rej[@]}"; do - reject "$f" env LEAN_PATH="$work/lean" "$lean" "$f" + reject "$f" lake_lean "$PWD/$f" done echo "[check-recheck] OK" diff --git a/scripts/proof-receipt.sh b/scripts/proof-receipt.sh index 2e0fdb6..25762a7 100644 --- a/scripts/proof-receipt.sh +++ b/scripts/proof-receipt.sh @@ -3,280 +3,209 @@ # SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell # # proof-receipt.sh: the proof receipt of this repository, -# verification/receipts/januskey_praxis.deed, in the shape of -# standards/3-practice/PROOF-POLICY.adoc §8.5.1 (profile proof-receipt), with -# the git checks of §8.5.3. +# verification/receipts/januskey_praxis.deed (PROOF-POLICY §8.5.1, profile +# proof-receipt), written and checked by the estate's shared generator +# (standards scripts/proof-receipt.sh). This file holds only what is +# januskey's own: the claim list, the run ledger, the run scopes, and the +# hooks that name each leg's invocation and input set. The generator, the +# reader, the reference digest and the §8.5.3 git checker are fetched below +# at one standards commit, each checked against its sha256. # -# --write write the receipt from the ledgers below and from git -# --check regenerate it and refuse any difference; fetch the pinned reader -# and checker of the standard and check their sha256; run the -# reader (which derives every grade and refuses an overstated one) -# and the §8.5.3 git checks; then report whether the current -# receipts still describe HEAD (a warning, not a failure: a -# receipt describes its :source-commit, and a stale one is still -# true of that commit) +# --write write the receipt from the ledgers and git +# --check regenerate it and refuse any difference, run the §8.5.3 git +# checks, check that each current receipt still describes the +# tree, and run the pinned reader with its negative control +# --run-row PROVER --run URL --commit SHA --checker TEXT --reported TEXT +# print the ledger row of a run that just passed # -# What is typed and what is derived. Two lists are typed in this file: the -# claim list (which legs each theory theorem has) and the run ledger (each row -# copied from the CI log of the run). Everything else is a git fact computed -# here: the input set of each leg at a run's commit, the SHA-256 of every file -# in it, the §8.5.1 digest, and the files of the pinned sibling. The grade is -# never typed by hand in the receipt's meaning: the receipt states it because -# the profile requires it, and the pinned reader refuses it unless the legs and -# receipts support it (§8.4, "grades are derived, not asserted"). +# What is typed and what is derived. The claim list and the run ledger are +# typed here, each ledger row copied from the CI log of its run. Every +# digest is a git fact: a current row's digest is rechecked against the tree +# by the generator, and a superseded row's digest is the reference digest of +# its leg's input set at that row's commit (scripts/proof-inputs-sha256.sh +# COMMIT PATHS...). The grade is never typed: the generator derives it and +# the pinned reader derives it again, refusing a receipt that overstates it. # -# Needs: git, sha256sum, curl (for --check), bun (for --check). +# Needs: git, sha256sum, curl, bun. +# The receipt_* hooks below are called by the sourced generator, not here. +# shellcheck disable=SC2317 set -euo pipefail cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." export LC_ALL=C.UTF-8 -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 -sibling_repo="hyperpolymath/resource-algebra" -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, -# because the checker finds the reader and the digest script by their paths. -STANDARDS_COMMIT=513cba8d1f6153389685bf34375f5aeaf9bcd150 -READER_SHA256=03634a2636f6aea202d777584978f8c7d99dc3c4fea7488d1300ba372b4386bd -DIGEST_SHA256=dfc6dde01a3a79df638eebe4cad0eae584d8f17280077e149174c0667e9508f4 -CHECKER_SHA256=f2375747238464535d1b4a61f658f07cb2f8504c69bfb1812311c79429a4e23e -STANDARDS_RAW="https://raw.githubusercontent.com/metadatastician/standards/$STANDARDS_COMMIT" -std_dir=_build/standards +# ── The pinned standard ─────────────────────────────────────────────────────── +RECEIPT_STANDARDS_COMMIT=15ef29e4b3229f5d70f5a4d817ab4377568ed503 +RECEIPT_STD=_build/standards +standards_raw="https://raw.githubusercontent.com/metadatastician/standards/$RECEIPT_STANDARDS_COMMIT" +pinned_files=( + "scripts/proof-receipt.sh:d7d8977e57f6f8fab44d6258987e98eb26169f394e2f647b3d99c47ee87945c4" + "1-formats/deed/tools/deed_lint.js:8978546740ca2d6a1d90b769fe02159883cb18f1eb2c44b2eeb737bab341dcd2" + "scripts/proof-inputs-sha256.sh:dfc6dde01a3a79df638eebe4cad0eae584d8f17280077e149174c0667e9508f4" + "scripts/check-proof-receipt.sh:f2375747238464535d1b4a61f658f07cb2f8504c69bfb1812311c79429a4e23e" +) +fetch_standard() { + local pair rel sha f + for pair in "${pinned_files[@]}"; do + rel="${pair%%:*}"; sha="${pair#*:}"; f="$RECEIPT_STD/$rel" + if [ ! -f "$f" ] || ! printf '%s %s\n' "$sha" "$f" | sha256sum -c --quiet - 2>/dev/null; then + mkdir -p "$(dirname "$f")" + curl --proto '=https' --tlsv1.2 -sSfL -o "$f" "$standards_raw/$rel" + fi + printf '%s %s\n' "$sha" "$f" | sha256sum -c --quiet - \ + || { printf 'ERROR: %s does not match its pinned sha256\n' "$f" >&2; exit 1; } + done +} +fetch_standard -die() { printf 'ERROR: %s\n' "$*" >&2; exit 1; } +RECEIPT_OUT=verification/receipts/januskey_praxis.deed +RECEIPT_REPOSITORY=hyperpolymath/januskey +RECEIPT_DEFAULT_BRANCH=main +RECEIPT_CANONICAL_NAME=januskey-proof-receipt +RECEIPT_SCRIPT=scripts/proof-receipt.sh +sibling_repo=hyperpolymath/resource-algebra +sibling_dir=_build/dependencies/resource-algebra # ── The claim list ──────────────────────────────────────────────────────────── -# The theory theorems of PROOF-NEEDS.adoc (PROOF-POLICY §1): id | the provers -# with a leg. A Rocq or Lean leg nobody has started is not listed at all: the -# profile's routes (re-proved, transported, waived, unavailable) each describe -# a leg that was tried, excused or found impossible, and docs/theory/ -# PROOF-GRADES.adoc records those legs as "not attempted". G-3 names the FFI -# bridge, so it is engineering under §1 and has no claim here. -claims() { - cat <<'ROWS' -G-1|agda -T-1|agda rocq lean -T-2|agda -T-3|agda -E-1m|agda -ROWS +# The theory theorems of PROOF-NEEDS.adoc (PROOF-POLICY §1): id | §5 token of +# the Agda proof | kind | Rocq route | Rocq §2.2 state | Lean route | Lean +# state | reasons. Each has both recheck legs, re-proved by hand and +# reconciled statement by statement (docs/theory/PROOF-GRADES.adoc). G-3 +# names the FFI bridge, so it is engineering under §1 and has no claim here. +receipt_claims() { + local id + for id in G-1 T-1 T-2 T-3 E-1m; do + printf '%s|proven|theorem|re-proved|RECONCILED|re-proved|RECONCILED||\n' "$id" + done } # ── 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. -# prover | run | commit (40 hex) | checker | invocation | state | reason | -# claims the run did not cover (space-separated; the row is left out of them) -# 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, -# #print axioms empty). -AGDA_CHECKER='Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)' -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)' -runs() { +# prover | run | commit | checker | invocation | inputs sha256 | what the run +# reported | state | reason | axioms [| imports [| trusted base]]. Copied +# from the logs of agda-proofs.yml; a current row is printed by --run-row. +# Every gate fails on any axiom (check-agda.sh: --safe and the cone scan; +# check-recheck.sh: every Print Assumptions closed, every #print axioms +# empty), so no row lists one. +agda_checker='Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)' +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)' +agda_said_cone='import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK' +receipt_runs() { local u=https://github.com/hyperpolymath/januskey/actions/runs + local e=e8deeaf7bc7b70500d57c282828512c8f8ba81f9 + local agda_inv3="$agda_flags verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" + local rocq_t1='coqc -q -Q . JanusKey Rollback.v (a copy of verification/proofs/rocq/Rollback.v; scripts/check-recheck.sh)' + local lean_t1='lean -o Rollback.olean verification/proofs/lean/Rollback.lean (scripts/check-recheck.sh)' + local rocq_said_t1='1 rocq leg checks with no assumptions (Rollback); the job refused its 2 fixtures (1 Rocq, 1 Lean) as expected; [check-recheck] OK' + local lean_said_t1='1 lean leg checks with no axioms (Rollback); the job refused its 2 fixtures (1 Rocq, 1 Lean) as expected; [check-recheck] OK' cat <.olean verification/proofs/lean/.lean for each of Epistemic, Reversibility, Rollback, SingleActiveLog (scripts/check-recheck.sh)|7146f3dce43d6160bb2d902d56984ac5fbccf8880b7336127b4cb7568da5db1f|4 lean legs check with no axioms (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK|superseded|ran lean directly, not under lake; PROOF-POLICY §8.2 names lean under lake, and the owner ruled on 2026-11-17 that a direct run does not qualify. To be replaced by the first run of the legs under lake. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)| +lean|$u/43213340167|b5034884dbe945139d03b38fe80cfdf1106a77e1|$lean_checker|$lean_t1|2b89f7de00ec28537f8c1dd66d771048a3ee649183ed12c04f1d51b4246d37a8|$lean_said_t1|superseded|T-1's leg only, under the gate before hyperpolymath/januskey#180; replaced by the run at #180's merge| +lean|$u/42646851111|0834ce73717a1faafa23fc1df55d85d54ee1e2b7|$lean_checker|$lean_t1|2b89f7de00ec28537f8c1dd66d771048a3ee649183ed12c04f1d51b4246d37a8|$lean_said_t1|superseded|the first run on main (hyperpolymath/januskey#171); replaced by the run at the receipt's source commit| ROWS } -# ── Input sets (§8.5.1) ─────────────────────────────────────────────────────── -# The home files a leg's run reads at COMMIT, one path a line, sorted bytewise. -# agda: the modules of verification/proofs/agda (all four are graded roots, -# and check-agda.sh resolves the rest of the cone to the sibling or to -# the prover), and scripts/fetch-siblings.sh, which holds the sibling's -# pin, so a repin changes this digest (§8.5.1, imported repositories). -# No .agda-lib or libraries file is read (--no-libraries). -# rocq: the .v files of verification/proofs/rocq. -# lean: the .lean files of verification/proofs/lean (no lakefile is used). -inputs() { - local prover="$1" commit="$2" - { - case "$prover" in - agda) git ls-tree --name-only "$commit" -- verification/proofs/agda/ | grep -E '\.agda$' - printf '%s\n' scripts/fetch-siblings.sh ;; - rocq) git ls-tree --name-only "$commit" -- verification/proofs/rocq/ | grep -E '\.v$' ;; - lean) git ls-tree --name-only "$commit" -- verification/proofs/lean/ | grep -E '\.lean$' ;; - *) die "unknown prover: $prover" ;; - esac - } | LC_ALL=C sort -} -# The sibling's pin at COMMIT, read from the script that holds it. -sibling_pin() { - # shellcheck disable=SC2016 # a literal ${…} in the pattern - git show "$1:scripts/fetch-siblings.sh" \ - | sed -n 's/^RESOURCE_ALGEBRA_COMMIT="\${RESOURCE_ALGEBRA_COMMIT:-\([0-9a-f]\{40\}\)}".*/\1/p' -} -# The sibling's modules in the Agda cone (check-agda.sh prints the cone size: -# 7 first-party modules, the four roots and these three). -sibling_files() { - printf '%s\n' src/ResourceAlgebra/Core.agda src/ResourceAlgebra/Instances/Loss.agda \ - src/ResourceAlgebra/Prelude.agda | LC_ALL=C sort -} -# " " for each path on stdin, from the git blob at COMMIT in DIR. -manifest() { - local dir="$1" commit="$2" p - while IFS= read -r p; do - git -C "$dir" cat-file -e "$commit:$p" 2>/dev/null || die "$p is not a file at $commit in $dir" - printf '%s %s\n' "$(git -C "$dir" cat-file blob "$commit:$p" | sha256sum | cut -d' ' -f1)" "$p" - done +# ── Run scopes ──────────────────────────────────────────────────────────────── +# A superseded run that did not check every claim with its leg is listed +# under the claims it checked only: the first Agda run predates +# Epistemic.agda (E-1m), and the first Rocq and Lean runs re-proved T-1 +# alone (Rollback.v, Rollback.lean). +receipt_run_scope() { + local u=https://github.com/hyperpolymath/januskey/actions/runs + cat </dev/null \ - || die "$sibling_repo $pin is not in $sibling_dir; run scripts/fetch-siblings.sh" - im="$(sibling_files | manifest "$sibling_dir" "$pin")" - printf ' (import :repository "%s" :commit "%s" :inputs-sha256 "%s"\n' \ - "$sibling_repo" "$pin" "$(digest_of "$im"$'\n')" - emit_files ' ' "$im" - printf ' )\n' - fi - printf ' (axioms))\n' - else - printf ' :state %s\n' "$state" - printf ' :reason "%s")\n' "$reason" - fi - done < <(runs) -} -emit() { - cat <.v for each of Epistemic, Reversibility, Rollback, SingleActiveLog (copies of verification/proofs/rocq/*.v; scripts/check-recheck.sh)' ;; + lean) printf '%s\n' 'lake build in a copy of verification/proofs/lean (lakefile.toml, lean-toolchain and Epistemic, Reversibility, Rollback, SingleActiveLog; scripts/check-recheck.sh)' ;; + *) receipt_die "unknown prover: $1" ;; + esac +} +# §8.5.1 input sets, from the tree. +# agda: the modules of verification/proofs/agda (all four are graded roots; +# check-agda.sh resolves the rest of the cone to the sibling or the +# prover), and scripts/fetch-siblings.sh, which holds the sibling's +# pin, so a repin changes this digest. No libraries file is read. +# rocq: the .v files of verification/proofs/rocq. +# lean: the .lean files of verification/proofs/lean and its Lake package +# files (lakefile.toml, lean-toolchain), which the build reads. +receipt_inputs() { + case "$1" in + agda) git ls-files -- 'verification/proofs/agda/*.agda'; printf '%s\n' scripts/fetch-siblings.sh ;; + rocq) git ls-files -- 'verification/proofs/rocq/*.v' ;; + lean) git ls-files -- 'verification/proofs/lean/*.lean' verification/proofs/lean/lakefile.toml verification/proofs/lean/lean-toolchain ;; + *) receipt_die "unknown prover: $1" ;; + esac +} +# The sibling's modules in the Agda cone, at the pin scripts/fetch-siblings.sh +# holds at home commit C (check-agda.sh prints the cone: 7 first-party +# modules, the four roots and these three). +receipt_imports() { + local pin p + [ "$1" = agda ] || return 0 + # shellcheck disable=SC2016 # a literal ${…} in the pattern + pin="$(git show "$2:scripts/fetch-siblings.sh" \ + | sed -n 's/^RESOURCE_ALGEBRA_COMMIT="\${RESOURCE_ALGEBRA_COMMIT:-\([0-9a-f]\{40\}\)}".*/\1/p')" + [ -n "$pin" ] || receipt_die "no sibling pin in scripts/fetch-siblings.sh at $2" + for p in src/ResourceAlgebra/Core.agda src/ResourceAlgebra/Instances/Loss.agda src/ResourceAlgebra/Prelude.agda; do + printf '%s|%s|%s|%s\n' "$sibling_repo" "$pin" "$sibling_dir" "$p" done } +# The claim ids PROOF-NEEDS.adoc grades: the ids its PWG census names. +receipt_status_ids() { + sed -n '/^\*PWG census, theory theorems/,/ungraded/p' PROOF-NEEDS.adoc \ + | grep -oE '\([A-Z]-[0-9]+[a-z]*(, [A-Z]-[0-9]+[a-z]*)*\)' | tr -d '()' | tr ',' '\n' | tr -d ' ' || true +} +# The claims whose Rocq and Lean legs docs/theory/PROOF-GRADES.adoc records as +# RECONCILED: its one leg record serves every graded claim, so each graded +# claim is listed when both leg rows of that record say RECONCILED. +receipt_recorded_legs() { + local rec + rec="$(awk '/^==== Leg records \(PROOF-POLICY §8.5\)/{f=1} f&&/^\|===$/{n++; if(n==2) exit} f' docs/theory/PROOF-GRADES.adoc)" + if awk '/^\| Rocq$/{l="rocq"} /^\| Lean$/{l="lean"} l && /^\| `RECONCILED`$/{ok[l]=1} END{exit !(ok["rocq"] && ok["lean"])}' <<<"$rec"; then + receipt_status_ids + fi +} -mode="${1:---check}" -case "$mode" in - --write) - emit > "$out" - echo "WROTE $out (source-commit $source_commit)" ;; - --check) - tmp="$(mktemp)"; trap 'rm -f "$tmp"' EXIT - emit > "$tmp" - diff -u "$out" "$tmp" || die "the receipt is not what the ledgers and git give; regenerate with --write" - fetch_standard - command -v bun >/dev/null || die "bun is needed to run the pinned reader" - bun "$std_dir/1-formats/deed/tools/deed_lint.js" "$out" - bun "$std_dir/1-formats/deed/tools/deed_lint.js" --proof-receipt-json "$out" >"$tmp" \ - || die "the pinned reader refuses the receipt" - # shellcheck disable=SC2016 # JavaScript, not shell - bun -e 'const r = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8")); - for (const c of r.claims) console.log(`derived: ${c.id} ${c.pwg}`);' "$tmp" - # §8.5.3: the commits hold what the receipt says. The home clone must be - # full; the checker refuses a shallow one. - bash "$std_dir/scripts/check-proof-receipt.sh" --branch "${RECEIPT_BRANCH:-origin/main}" \ - --import "$sibling_repo=$sibling_dir" "$out" . || die "the git checks of §8.5.3 failed" - # Freshness: does each current receipt's input digest still hold at HEAD? - stale=0 - while IFS='|' read -r p run commit checker inv state reason _; do - [ "$state" = current ] || continue - now="$(digest_of "$(inputs "$p" HEAD | manifest . HEAD)"$'\n')" - was="$(digest_of "$(inputs "$p" "$commit" | manifest . "$commit")"$'\n')" - if [ "$now" != "$was" ]; then - stale=1 - echo "::warning::the $p inputs changed after ${commit:0:12}: the receipt still describes its source commit, not HEAD; record a run of HEAD's main commit to bring it forward" - fi - done < <(runs) - [ "$stale" -eq 1 ] || echo "fresh: every current receipt's inputs are unchanged at HEAD" - echo "PASS: $out" ;; - *) echo "usage: ${0##*/} [--write|--check]" >&2; exit 2 ;; -esac +. "$RECEIPT_STD/scripts/proof-receipt.sh" +receipt_main "$@" diff --git a/verification/proofs/lean/lakefile.toml b/verification/proofs/lean/lakefile.toml new file mode 100644 index 0000000..683f5ef --- /dev/null +++ b/verification/proofs/lean/lakefile.toml @@ -0,0 +1,12 @@ +# SPDX-License-Identifier: MPL-2.0 +# SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell +# +# The Lean recheck legs as a Lake package: scripts/check-recheck.sh runs +# `lake build` on a copy of this directory (PROOF-POLICY §8.2 names `lean` +# under `lake` as a pinned kernel run). No dependencies, no Mathlib. +name = "januskeyLegs" +defaultTargets = ["JanuskeyLegs"] + +[[lean_lib]] +name = "JanuskeyLegs" +roots = ["Epistemic", "Reversibility", "Rollback", "SingleActiveLog"] diff --git a/verification/proofs/lean/lean-toolchain b/verification/proofs/lean/lean-toolchain new file mode 100644 index 0000000..a6aff06 --- /dev/null +++ b/verification/proofs/lean/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.35.0 diff --git a/verification/receipts/januskey_praxis.deed b/verification/receipts/januskey_praxis.deed index c6c35a3..8801dea 100644 --- a/verification/receipts/januskey_praxis.deed +++ b/verification/receipts/januskey_praxis.deed @@ -1,20 +1,17 @@ ;; SPDX-License-Identifier: CC-BY-SA-4.0 ;; SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell ;; The proof receipt of januskey (PROOF-POLICY §8.5.1). -;; GENERATED by scripts/proof-receipt.sh: regenerate with --write, check with --check. -;; Each (receipt …) is a row of the run ledger in that script, copied from the CI -;; log of the run; every digest is computed from git objects. The grade is -;; derived by the pinned reader, which refuses a :pwg its legs do not support: -;; bun deed_lint.js --proof-receipt-json verification/receipts/januskey_praxis.deed -;; with the reader at standards 513cba8d1f6153389685bf34375f5aeaf9bcd150. -;; A Rocq or Lean leg nobody has started is absent, not "unavailable" -;; (docs/theory/PROOF-GRADES.adoc). Human record: PROOF-NEEDS.adoc. +;; GENERATED by scripts/proof-receipt.sh with the shared standards generator: +;; regenerate with --write, check with --check. Each (receipt …) is a row of +;; the run ledger in that script, copied from the CI log of the run; every +;; digest is computed from git objects. The grade is derived, and the pinned +;; reader refuses a :pwg its legs do not support. Human record: PROOF-NEEDS.adoc. (praxis-deed :schema-version "1.0.0" :canonical-name "januskey-proof-receipt" :profile proof-receipt :repository "hyperpolymath/januskey" - :source-commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + :source-commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" (trusted-base (primitive :prover agda :module "Agda.Primitive" :name "Level" :binding "BUILTIN LEVEL") (primitive :prover agda :module "Agda.Primitive" :name "lzero" :binding "BUILTIN LEVELZERO") @@ -22,8 +19,9 @@ (primitive :prover agda :module "Agda.Primitive" :name "_⊔_" :binding "BUILTIN LEVELMAX")) (claim :id "G-1" :pwg PWG-3 :foundation-diverse #f (leg :prover agda :route source :token proven :state AGDA-VERIFIED - (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" - :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :inputs-sha256 "6e17ce4ad8264cd09de228eaa06e212caeb4d090436a4d9373078ee7978800d8" @@ -33,43 +31,68 @@ (file :path "verification/proofs/agda/Epistemic.agda" :sha256 "7e73f7072b57f0f97a00bd358548bc86f14c8982817f846b1e0a92cfb1f9fcf3") (file :path "verification/proofs/agda/Reversibility.agda" :sha256 "648fa11a656104d9ad970f14d50abc91761fcccfc9be6731ee9bb1e3cdb98e42") (file :path "verification/proofs/agda/SingleActiveLog.agda" :sha256 "0c349e6e3edc1fdaf905ebfc12b5417aee1843f61ee2b5c52e44af3ba0a86dc7") - (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056") - ) + (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056")) (import :repository "hyperpolymath/resource-algebra" :commit "cf9235c532712a783a404c359a1055f40134794a" :inputs-sha256 "adddbf38fe2ce754f50fc70f5743f381763fb6387e5f99ce8a7d0a38176df9c9" (file :path "src/ResourceAlgebra/Core.agda" :sha256 "d2ecf2684597d223437a229b33b539a57252a56fbb24f28e70b1b5b3fd7d1b1d") (file :path "src/ResourceAlgebra/Instances/Loss.agda" :sha256 "79863d1124d8fcb61a70f6a7710ec1b9ce44568b2f901d0efb875d24c2460563") - (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8") - ) + (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8")) (axioms)) + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" + :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" + :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" + :state superseded + :reason "the run at hyperpolymath/januskey#179; replaced by the run at #180's merge, the receipt's source commit") + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42736066407" :commit "e16543866fa4fd31a94f3c7faa1fe0671b083a1b" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :state superseded :reason "the first green run on main of the gate as changed by hyperpolymath/januskey#174; replaced by the run at the receipt's source commit") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42076969251" :commit "23bc8c38160a25c37917bce69cf05d91899b07e5" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "before the import-cone postulate scan (hyperpolymath/januskey#170) and before SingleActiveLog.agda (hyperpolymath/januskey#171)") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/41687715055" :commit "fc188c44906faedfe91bfd414be3fda01ff4caf4" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "canonical flags and three modules; replaced by run 42076969251 at a later commit") + ; the run reported: 4 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/40867211509" :commit "4afb710e86646658f667f10bd6274ee47416bfc7" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K (before --cubical-compatible joined the gate)" :state superseded :reason "before --cubical-compatible and before Epistemic.agda; it never covered E-1m, so it is listed for the other claims only")) - ) - (claim :id "T-1" :pwg PWG-1 :foundation-diverse #f + (leg :prover rocq :route re-proved :token proven :state RECONCILED + ; the run reported: 4 rocq legs check with no assumptions (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" + :invocation "coqc -q -Q . JanusKey .v for each of Epistemic, Reversibility, Rollback, SingleActiveLog (copies of verification/proofs/rocq/*.v; scripts/check-recheck.sh)" + :state superseded + :reason "its checker, scripts/check-recheck.sh, is changed by the change that moves the Lean legs under lake; a changed checker re-earns the receipt (docs/theory/PROOF-GRADES.adoc, reporting rules), although the Rocq steps of the script are byte-identical. To be replaced by the first run on main after that change. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)")) + (leg :prover lean :route re-proved :token proven :state RECONCILED + ; the run reported: 4 lean legs check with no axioms (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" + :invocation "lean -o .olean verification/proofs/lean/.lean for each of Epistemic, Reversibility, Rollback, SingleActiveLog (scripts/check-recheck.sh)" + :state superseded + :reason "ran lean directly, not under lake; PROOF-POLICY §8.2 names lean under lake, and the owner ruled on 2026-11-17 that a direct run does not qualify. To be replaced by the first run of the legs under lake. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)"))) + (claim :id "T-1" :pwg PWG-3 :foundation-diverse #f (leg :prover agda :route source :token proven :state AGDA-VERIFIED - (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" - :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :inputs-sha256 "6e17ce4ad8264cd09de228eaa06e212caeb4d090436a4d9373078ee7978800d8" @@ -79,32 +102,41 @@ (file :path "verification/proofs/agda/Epistemic.agda" :sha256 "7e73f7072b57f0f97a00bd358548bc86f14c8982817f846b1e0a92cfb1f9fcf3") (file :path "verification/proofs/agda/Reversibility.agda" :sha256 "648fa11a656104d9ad970f14d50abc91761fcccfc9be6731ee9bb1e3cdb98e42") (file :path "verification/proofs/agda/SingleActiveLog.agda" :sha256 "0c349e6e3edc1fdaf905ebfc12b5417aee1843f61ee2b5c52e44af3ba0a86dc7") - (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056") - ) + (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056")) (import :repository "hyperpolymath/resource-algebra" :commit "cf9235c532712a783a404c359a1055f40134794a" :inputs-sha256 "adddbf38fe2ce754f50fc70f5743f381763fb6387e5f99ce8a7d0a38176df9c9" (file :path "src/ResourceAlgebra/Core.agda" :sha256 "d2ecf2684597d223437a229b33b539a57252a56fbb24f28e70b1b5b3fd7d1b1d") (file :path "src/ResourceAlgebra/Instances/Loss.agda" :sha256 "79863d1124d8fcb61a70f6a7710ec1b9ce44568b2f901d0efb875d24c2460563") - (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8") - ) + (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8")) (axioms)) + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" + :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" + :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" + :state superseded + :reason "the run at hyperpolymath/januskey#179; replaced by the run at #180's merge, the receipt's source commit") + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42736066407" :commit "e16543866fa4fd31a94f3c7faa1fe0671b083a1b" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :state superseded :reason "the first green run on main of the gate as changed by hyperpolymath/januskey#174; replaced by the run at the receipt's source commit") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42076969251" :commit "23bc8c38160a25c37917bce69cf05d91899b07e5" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "before the import-cone postulate scan (hyperpolymath/januskey#170) and before SingleActiveLog.agda (hyperpolymath/januskey#171)") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/41687715055" :commit "fc188c44906faedfe91bfd414be3fda01ff4caf4" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "canonical flags and three modules; replaced by run 42076969251 at a later commit") + ; the run reported: 4 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/40867211509" :commit "4afb710e86646658f667f10bd6274ee47416bfc7" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" @@ -112,16 +144,21 @@ :state superseded :reason "before --cubical-compatible and before Epistemic.agda; it never covered E-1m, so it is listed for the other claims only")) (leg :prover rocq :route re-proved :token proven :state RECONCILED + ; the run reported: 4 rocq legs check with no assumptions (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" + :invocation "coqc -q -Q . JanusKey .v for each of Epistemic, Reversibility, Rollback, SingleActiveLog (copies of verification/proofs/rocq/*.v; scripts/check-recheck.sh)" + :state superseded + :reason "its checker, scripts/check-recheck.sh, is changed by the change that moves the Lean legs under lake; a changed checker re-earns the receipt (docs/theory/PROOF-GRADES.adoc, reporting rules), although the Rocq steps of the script are byte-identical. To be replaced by the first run on main after that change. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)") + ; the run reported: 1 rocq leg checks with no assumptions (Rollback); the job refused its 2 fixtures (1 Rocq, 1 Lean) as expected; [check-recheck] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" :invocation "coqc -q -Q . JanusKey Rollback.v (a copy of verification/proofs/rocq/Rollback.v; scripts/check-recheck.sh)" - :inputs-sha256 "2e86900da60f3e8cde1198f69fc6f7b0b9d73c5fe0ab2ae42f7b66ef1b7fd50d" - :state current - (inputs-manifest - (file :path "verification/proofs/rocq/Rollback.v" :sha256 "662d51bf0b642ac28f816853c7d2c6a851583487a15e9f79c3b8184a53ff28e2") - ) - (axioms)) + :state superseded + :reason "T-1's leg only, under the gate before hyperpolymath/januskey#180; replaced by the run at #180's merge") + ; the run reported: 1 rocq leg checks with no assumptions (Rollback); the job refused its 2 fixtures (1 Rocq, 1 Lean) as expected; [check-recheck] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42646851111" :commit "0834ce73717a1faafa23fc1df55d85d54ee1e2b7" :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" @@ -129,27 +166,32 @@ :state superseded :reason "the first run on main (hyperpolymath/januskey#171); replaced by the run at the receipt's source commit")) (leg :prover lean :route re-proved :token proven :state RECONCILED + ; the run reported: 4 lean legs check with no axioms (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" + :invocation "lean -o .olean verification/proofs/lean/.lean for each of Epistemic, Reversibility, Rollback, SingleActiveLog (scripts/check-recheck.sh)" + :state superseded + :reason "ran lean directly, not under lake; PROOF-POLICY §8.2 names lean under lake, and the owner ruled on 2026-11-17 that a direct run does not qualify. To be replaced by the first run of the legs under lake. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)") + ; the run reported: 1 lean leg checks with no axioms (Rollback); the job refused its 2 fixtures (1 Rocq, 1 Lean) as expected; [check-recheck] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" :invocation "lean -o Rollback.olean verification/proofs/lean/Rollback.lean (scripts/check-recheck.sh)" - :inputs-sha256 "2b89f7de00ec28537f8c1dd66d771048a3ee649183ed12c04f1d51b4246d37a8" - :state current - (inputs-manifest - (file :path "verification/proofs/lean/Rollback.lean" :sha256 "808c32585ad582fced7497b93607668f92d9140b36ae4bd90b14f6b26bcd36c6") - ) - (axioms)) + :state superseded + :reason "T-1's leg only, under the gate before hyperpolymath/januskey#180; replaced by the run at #180's merge") + ; the run reported: 1 lean leg checks with no axioms (Rollback); the job refused its 2 fixtures (1 Rocq, 1 Lean) as expected; [check-recheck] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42646851111" :commit "0834ce73717a1faafa23fc1df55d85d54ee1e2b7" :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" :invocation "lean -o Rollback.olean verification/proofs/lean/Rollback.lean (scripts/check-recheck.sh)" :state superseded - :reason "the first run on main (hyperpolymath/januskey#171); replaced by the run at the receipt's source commit")) - ) + :reason "the first run on main (hyperpolymath/januskey#171); replaced by the run at the receipt's source commit"))) (claim :id "T-2" :pwg PWG-3 :foundation-diverse #f (leg :prover agda :route source :token proven :state AGDA-VERIFIED - (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" - :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :inputs-sha256 "6e17ce4ad8264cd09de228eaa06e212caeb4d090436a4d9373078ee7978800d8" @@ -159,43 +201,68 @@ (file :path "verification/proofs/agda/Epistemic.agda" :sha256 "7e73f7072b57f0f97a00bd358548bc86f14c8982817f846b1e0a92cfb1f9fcf3") (file :path "verification/proofs/agda/Reversibility.agda" :sha256 "648fa11a656104d9ad970f14d50abc91761fcccfc9be6731ee9bb1e3cdb98e42") (file :path "verification/proofs/agda/SingleActiveLog.agda" :sha256 "0c349e6e3edc1fdaf905ebfc12b5417aee1843f61ee2b5c52e44af3ba0a86dc7") - (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056") - ) + (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056")) (import :repository "hyperpolymath/resource-algebra" :commit "cf9235c532712a783a404c359a1055f40134794a" :inputs-sha256 "adddbf38fe2ce754f50fc70f5743f381763fb6387e5f99ce8a7d0a38176df9c9" (file :path "src/ResourceAlgebra/Core.agda" :sha256 "d2ecf2684597d223437a229b33b539a57252a56fbb24f28e70b1b5b3fd7d1b1d") (file :path "src/ResourceAlgebra/Instances/Loss.agda" :sha256 "79863d1124d8fcb61a70f6a7710ec1b9ce44568b2f901d0efb875d24c2460563") - (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8") - ) + (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8")) (axioms)) + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" + :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" + :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" + :state superseded + :reason "the run at hyperpolymath/januskey#179; replaced by the run at #180's merge, the receipt's source commit") + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42736066407" :commit "e16543866fa4fd31a94f3c7faa1fe0671b083a1b" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :state superseded :reason "the first green run on main of the gate as changed by hyperpolymath/januskey#174; replaced by the run at the receipt's source commit") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42076969251" :commit "23bc8c38160a25c37917bce69cf05d91899b07e5" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "before the import-cone postulate scan (hyperpolymath/januskey#170) and before SingleActiveLog.agda (hyperpolymath/januskey#171)") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/41687715055" :commit "fc188c44906faedfe91bfd414be3fda01ff4caf4" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "canonical flags and three modules; replaced by run 42076969251 at a later commit") + ; the run reported: 4 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/40867211509" :commit "4afb710e86646658f667f10bd6274ee47416bfc7" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K (before --cubical-compatible joined the gate)" :state superseded :reason "before --cubical-compatible and before Epistemic.agda; it never covered E-1m, so it is listed for the other claims only")) - ) + (leg :prover rocq :route re-proved :token proven :state RECONCILED + ; the run reported: 4 rocq legs check with no assumptions (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" + :invocation "coqc -q -Q . JanusKey .v for each of Epistemic, Reversibility, Rollback, SingleActiveLog (copies of verification/proofs/rocq/*.v; scripts/check-recheck.sh)" + :state superseded + :reason "its checker, scripts/check-recheck.sh, is changed by the change that moves the Lean legs under lake; a changed checker re-earns the receipt (docs/theory/PROOF-GRADES.adoc, reporting rules), although the Rocq steps of the script are byte-identical. To be replaced by the first run on main after that change. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)")) + (leg :prover lean :route re-proved :token proven :state RECONCILED + ; the run reported: 4 lean legs check with no axioms (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" + :invocation "lean -o .olean verification/proofs/lean/.lean for each of Epistemic, Reversibility, Rollback, SingleActiveLog (scripts/check-recheck.sh)" + :state superseded + :reason "ran lean directly, not under lake; PROOF-POLICY §8.2 names lean under lake, and the owner ruled on 2026-11-17 that a direct run does not qualify. To be replaced by the first run of the legs under lake. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)"))) (claim :id "T-3" :pwg PWG-3 :foundation-diverse #f (leg :prover agda :route source :token proven :state AGDA-VERIFIED - (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" - :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :inputs-sha256 "6e17ce4ad8264cd09de228eaa06e212caeb4d090436a4d9373078ee7978800d8" @@ -205,43 +272,68 @@ (file :path "verification/proofs/agda/Epistemic.agda" :sha256 "7e73f7072b57f0f97a00bd358548bc86f14c8982817f846b1e0a92cfb1f9fcf3") (file :path "verification/proofs/agda/Reversibility.agda" :sha256 "648fa11a656104d9ad970f14d50abc91761fcccfc9be6731ee9bb1e3cdb98e42") (file :path "verification/proofs/agda/SingleActiveLog.agda" :sha256 "0c349e6e3edc1fdaf905ebfc12b5417aee1843f61ee2b5c52e44af3ba0a86dc7") - (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056") - ) + (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056")) (import :repository "hyperpolymath/resource-algebra" :commit "cf9235c532712a783a404c359a1055f40134794a" :inputs-sha256 "adddbf38fe2ce754f50fc70f5743f381763fb6387e5f99ce8a7d0a38176df9c9" (file :path "src/ResourceAlgebra/Core.agda" :sha256 "d2ecf2684597d223437a229b33b539a57252a56fbb24f28e70b1b5b3fd7d1b1d") (file :path "src/ResourceAlgebra/Instances/Loss.agda" :sha256 "79863d1124d8fcb61a70f6a7710ec1b9ce44568b2f901d0efb875d24c2460563") - (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8") - ) + (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8")) (axioms)) + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" + :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" + :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" + :state superseded + :reason "the run at hyperpolymath/januskey#179; replaced by the run at #180's merge, the receipt's source commit") + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42736066407" :commit "e16543866fa4fd31a94f3c7faa1fe0671b083a1b" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :state superseded :reason "the first green run on main of the gate as changed by hyperpolymath/januskey#174; replaced by the run at the receipt's source commit") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42076969251" :commit "23bc8c38160a25c37917bce69cf05d91899b07e5" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "before the import-cone postulate scan (hyperpolymath/januskey#170) and before SingleActiveLog.agda (hyperpolymath/januskey#171)") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/41687715055" :commit "fc188c44906faedfe91bfd414be3fda01ff4caf4" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "canonical flags and three modules; replaced by run 42076969251 at a later commit") + ; the run reported: 4 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/40867211509" :commit "4afb710e86646658f667f10bd6274ee47416bfc7" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K (before --cubical-compatible joined the gate)" :state superseded :reason "before --cubical-compatible and before Epistemic.agda; it never covered E-1m, so it is listed for the other claims only")) - ) + (leg :prover rocq :route re-proved :token proven :state RECONCILED + ; the run reported: 4 rocq legs check with no assumptions (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" + :invocation "coqc -q -Q . JanusKey .v for each of Epistemic, Reversibility, Rollback, SingleActiveLog (copies of verification/proofs/rocq/*.v; scripts/check-recheck.sh)" + :state superseded + :reason "its checker, scripts/check-recheck.sh, is changed by the change that moves the Lean legs under lake; a changed checker re-earns the receipt (docs/theory/PROOF-GRADES.adoc, reporting rules), although the Rocq steps of the script are byte-identical. To be replaced by the first run on main after that change. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)")) + (leg :prover lean :route re-proved :token proven :state RECONCILED + ; the run reported: 4 lean legs check with no axioms (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" + :invocation "lean -o .olean verification/proofs/lean/.lean for each of Epistemic, Reversibility, Rollback, SingleActiveLog (scripts/check-recheck.sh)" + :state superseded + :reason "ran lean directly, not under lake; PROOF-POLICY §8.2 names lean under lake, and the owner ruled on 2026-11-17 that a direct run does not qualify. To be replaced by the first run of the legs under lake. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)"))) (claim :id "E-1m" :pwg PWG-3 :foundation-diverse #f (leg :prover agda :route source :token proven :state AGDA-VERIFIED - (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" - :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :inputs-sha256 "6e17ce4ad8264cd09de228eaa06e212caeb4d090436a4d9373078ee7978800d8" @@ -251,31 +343,54 @@ (file :path "verification/proofs/agda/Epistemic.agda" :sha256 "7e73f7072b57f0f97a00bd358548bc86f14c8982817f846b1e0a92cfb1f9fcf3") (file :path "verification/proofs/agda/Reversibility.agda" :sha256 "648fa11a656104d9ad970f14d50abc91761fcccfc9be6731ee9bb1e3cdb98e42") (file :path "verification/proofs/agda/SingleActiveLog.agda" :sha256 "0c349e6e3edc1fdaf905ebfc12b5417aee1843f61ee2b5c52e44af3ba0a86dc7") - (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056") - ) + (file :path "verification/proofs/agda/TransactionAtomicity.agda" :sha256 "d5198612d6afdfd70b6ce4c85a552b88e59c75c3624f972365e3eed175fdc056")) (import :repository "hyperpolymath/resource-algebra" :commit "cf9235c532712a783a404c359a1055f40134794a" :inputs-sha256 "adddbf38fe2ce754f50fc70f5743f381763fb6387e5f99ce8a7d0a38176df9c9" (file :path "src/ResourceAlgebra/Core.agda" :sha256 "d2ecf2684597d223437a229b33b539a57252a56fbb24f28e70b1b5b3fd7d1b1d") (file :path "src/ResourceAlgebra/Instances/Loss.agda" :sha256 "79863d1124d8fcb61a70f6a7710ec1b9ce44568b2f901d0efb875d24c2460563") - (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8") - ) + (file :path "src/ResourceAlgebra/Prelude.agda" :sha256 "9297839256b426b49a1059f58ac284e2e75304d1c58b0d619cabd9eb2198d8a8")) (axioms)) + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43213340167" + :commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" + :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" + :state superseded + :reason "the run at hyperpolymath/januskey#179; replaced by the run at #180's merge, the receipt's source commit") + ; the run reported: import cone 7 first-party modules and 8 supplied with the prover; postulate scan 7 files, 0 postulates; 7 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42736066407" :commit "e16543866fa4fd31a94f3c7faa1fe0671b083a1b" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic,SingleActiveLog}.agda (scripts/check-agda.sh)" :state superseded :reason "the first green run on main of the gate as changed by hyperpolymath/januskey#174; replaced by the run at the receipt's source commit") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/42076969251" :commit "23bc8c38160a25c37917bce69cf05d91899b07e5" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "before the import-cone postulate scan (hyperpolymath/januskey#170) and before SingleActiveLog.agda (hyperpolymath/januskey#171)") + ; the run reported: 6 fixtures refused as expected; [check-agda] OK (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/41687715055" :commit "fc188c44906faedfe91bfd414be3fda01ff4caf4" :checker "Agda version 2.6.4.3 (Debian trixie agda-bin=2.6.4.3-1+b2, container debian:trixie-slim@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f)" :invocation "agda --safe --without-K --cubical-compatible --no-libraries --ignore-interfaces --double-check -i verification/proofs/agda -i _build/dependencies/resource-algebra/src verification/proofs/agda/{Reversibility,TransactionAtomicity,Epistemic}.agda (scripts/check-agda.sh)" :state superseded :reason "canonical flags and three modules; replaced by run 42076969251 at a later commit")) - ) + (leg :prover rocq :route re-proved :token proven :state RECONCILED + ; the run reported: 4 rocq legs check with no assumptions (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "The Coq Proof Assistant, version 8.18.0 (Ubuntu 24.04 coq=8.18.0+dfsg-1build2)" + :invocation "coqc -q -Q . JanusKey .v for each of Epistemic, Reversibility, Rollback, SingleActiveLog (copies of verification/proofs/rocq/*.v; scripts/check-recheck.sh)" + :state superseded + :reason "its checker, scripts/check-recheck.sh, is changed by the change that moves the Lean legs under lake; a changed checker re-earns the receipt (docs/theory/PROOF-GRADES.adoc, reporting rules), although the Rocq steps of the script are byte-identical. To be replaced by the first run on main after that change. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)")) + (leg :prover lean :route re-proved :token proven :state RECONCILED + ; the run reported: 4 lean legs check with no axioms (Epistemic, Reversibility, Rollback, SingleActiveLog); the job refused its 8 fixtures (4 Rocq, 4 Lean) as expected; [check-recheck] OK + (receipt :run "https://github.com/hyperpolymath/januskey/actions/runs/43945986467" + :commit "e8deeaf7bc7b70500d57c282828512c8f8ba81f9" + :checker "Lean (version 4.35.0, x86_64-unknown-linux-gnu, commit eb6cafb7290e8bd5f2937522d8d804f58f02bafc, Release) (release tarball, sha256 7289597a44543246c9227b8cae501767e095ce17f6d448b95fc4a8dc97268f6d)" + :invocation "lean -o .olean verification/proofs/lean/.lean for each of Epistemic, Reversibility, Rollback, SingleActiveLog (scripts/check-recheck.sh)" + :state superseded + :reason "ran lean directly, not under lake; PROOF-POLICY §8.2 names lean under lake, and the owner ruled on 2026-11-17 that a direct run does not qualify. To be replaced by the first run of the legs under lake. It also ran on a runner outside a digest-pinned image, which the owner ruled on 2026-11-16 is not enough for PWG-1 (hyperpolymath/januskey#184)"))) )