From 14a139d6fe7cf3f91ca3232316bb066b7f99339e Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 19:30:21 +0000 Subject: [PATCH] =?UTF-8?q?proofs:=20machine-readable=20proof=20receipt=20?= =?UTF-8?q?(PROOF-POLICY=20=C2=A78.5.1);=20grades=20derived?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds verification/receipts/januskey_praxis.deed in the proof-receipt profile merged in standards#1450, written by scripts/proof-receipt.sh from two typed ledgers (claims; CI runs copied from their logs) and git (input sets, file SHA-256s, §8.5.1 digests, the resource-algebra import). `proof-receipt.sh --check` (just test-receipt; new agda-proofs.yml job) regenerates and diffs, runs the standards reader pinned by commit and SHA-256 (it derives each grade and refuses an overstated one), runs the §8.5.3 git checker, and warns when a leg's inputs change after the receipt's source commit. The receipt describes b503488 on main (run 43213340167). The reader derives T-1 PWG-1 (Agda, Rocq and Lean receipts all at the source commit) and G-1, T-2, T-3, E-1m PWG-3. PROOF-GRADES.adoc and PROOF-NEEDS.adoc cite it, drop "receipt pending re-run", and mark runs 42736066407 and 42076969251 superseded. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01GVPPsHYqVJSoPzdNYD9tRg --- .github/workflows/agda-proofs.yml | 31 +++ Justfile | 5 + PROOF-NEEDS.adoc | 50 ++-- docs/theory/PROOF-GRADES.adoc | 142 ++++++----- scripts/proof-receipt.sh | 282 +++++++++++++++++++++ verification/receipts/januskey_praxis.deed | 281 ++++++++++++++++++++ 6 files changed, 706 insertions(+), 85 deletions(-) create mode 100644 scripts/proof-receipt.sh create mode 100644 verification/receipts/januskey_praxis.deed diff --git a/.github/workflows/agda-proofs.yml b/.github/workflows/agda-proofs.yml index 25696fe..43af4d8 100644 --- a/.github/workflows/agda-proofs.yml +++ b/.github/workflows/agda-proofs.yml @@ -62,3 +62,34 @@ jobs: lean --version | grep -q "^Lean (version ${LEAN_VERSION}, " - name: Recheck legs, no axioms, expected rejections run: bash scripts/check-recheck.sh + receipt: + # PROOF-POLICY §8.5.1 and §8.5.3: the machine-readable proof receipt + # (verification/receipts/januskey_praxis.deed) is what the ledgers and git + # give, the pinned standards reader derives every grade from it, and the + # commits it names hold what it says. Local run: just test-receipt. + name: Proof receipt, derived grades, git checks + runs-on: ubuntu-24.04 + timeout-minutes: 10 + env: + BUN_VERSION: 1.4.4 + BUN_SHA256: bf8ccbfb2b0b80159e0f9a6d15c55317add8077534dbc6130a3edb52fccb395c + steps: + - name: Install the pinned Bun + run: | + curl --proto '=https' --tlsv1.2 -sSfL -o bun.zip \ + "https://github.com/oven-sh/bun/releases/download/bun-v${BUN_VERSION}/bun-linux-x64.zip" + echo "${BUN_SHA256} bun.zip" | sha256sum -c - + unzip -q bun.zip -d "$RUNNER_TEMP" + rm bun.zip + echo "$RUNNER_TEMP/bun-linux-x64" >> "$GITHUB_PATH" + - name: Checkout (full history; the git checks refuse a shallow clone) + uses: actions/checkout@v7.0.1 + with: + persist-credentials: false + fetch-depth: 0 + - name: Verify the checked Bun version + run: test "$(bun --version)" = "${BUN_VERSION}" + - name: Receipt, reader, git checks, freshness + run: | + bash scripts/fetch-siblings.sh + bash scripts/proof-receipt.sh --check diff --git a/Justfile b/Justfile index ffa2290..1d56117 100644 --- a/Justfile +++ b/Justfile @@ -96,6 +96,11 @@ test-agda: test-recheck: bash scripts/check-recheck.sh +# Proof receipt (PROOF-POLICY §8.5): regenerate and compare, derive grades with the pinned reader, git checks. +test-receipt: + bash scripts/fetch-siblings.sh + bash scripts/proof-receipt.sh --check + # Idris2 ABI <-> januskey.h <-> ffi/zig agreement (sizes, status codes, enums, symbols); no compiler needed. abi-layout-check: bash scripts/check-abi-layout.sh diff --git a/PROOF-NEEDS.adoc b/PROOF-NEEDS.adoc index ea2c068..6148558 100644 --- a/PROOF-NEEDS.adoc +++ b/PROOF-NEEDS.adoc @@ -68,7 +68,7 @@ tables must agree. | 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+`; `+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-2ii+`); `+tests/reject-agda/ForwardRollback.agda+` refused +| 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}+`; `+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+` (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+` @@ -126,26 +126,29 @@ and is kept for provenance only. Neither uses a confidence percentage and this repository does not publish one. Of the 12 PROVEN rows, five are the theory rows — **G-1, T-1, T-2, T-3, E-1m** — and -their artefact is Agda (`+verification/proofs/agda/+`). They are **`+PWG-3+`, -receipt pending re-run** (PROOF-POLICY §8, owner ruling 2026-11-04, which -governs over the mathesis brief): -each is `+PROVEN+` under the §2.1 invocation and no Rocq or Lean leg exists. The -last receipt for the modules is a green `+agda-proofs.yml+` run -(https://github.com/hyperpolymath/januskey/actions/runs/42076969251[42076969251]) -at commit `+23bc8c3+`, Agda 2.6.4.3, with `+resource-algebra+` pinned at -`+cf9235c+`, running `+Reversibility+`, `+TransactionAtomicity+` and -`+Epistemic+` under `+--safe --without-K --cubical-compatible+`. The gate gained -an import-cone postulate scan after it, so the first green run of the changed -gate on `+main+` is the receipt that replaces it. The cone, the axioms (none in -the development; the prover's four universe-level primitives are checked by -name and reported) and the superseded receipts (runs 41687715055 at -`+fc188c4+` and 40867211509 at -`+4afb710+`) are recorded in +their artefact is Agda (`+verification/proofs/agda/+`). Their grades are derived, +not typed (PROOF-POLICY §8, owner ruling 2026-11-04, which governs over the +mathesis brief): the receipt of record is +link:verification/receipts/januskey_praxis.deed[`+verification/receipts/januskey_praxis.deed+`] +(§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] +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 +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+`]. -Correspondence state for them: `+AGDA-VERIFIED+`. *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+` 1 (T-1) · `+PWG-1+` 0 · +(G-1, T-2, T-3, E-1m) · `+PWG-2i+` 0 · `+PWG-2ii+` 0 · `+PWG-1+` 1 (T-1) · `+ungraded+` 0. G-3 names this repository's FFI bridge, so PROOF-POLICY §1 classes it as engineering and it is outside the ladder. T-1's Rocq and Lean legs are re-proved and reconciled (`+docs/theory/PROOF-GRADES.adoc+`, §T-1); the other four have not been @@ -160,12 +163,15 @@ 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-2ii+`, with Rocq and Lean legs re-proved -and reconciled. No row is `+PWG-2i+` or `+PWG-1+`, and none is claimed to be. The row-by-row mapping and the receipt in full are in +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 `+docs/theory/PROOF-GRADES.adoc+`. Since 2026-11-01 the gate runs PROOF-POLICY §2.1's canonical invocation -(`+--safe --without-K --cubical-compatible …+`); the CI receipt for that flag -set is run 42076969251 above. +(`+--safe --without-K --cubical-compatible …+`). === Current State diff --git a/docs/theory/PROOF-GRADES.adoc b/docs/theory/PROOF-GRADES.adoc index a2cea73..4d47116 100644 --- a/docs/theory/PROOF-GRADES.adoc +++ b/docs/theory/PROOF-GRADES.adoc @@ -13,8 +13,10 @@ 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` 1 (T-1) · `PWG-1` 0 · -`ungraded` 0. `+foundation-diverse`: none. Axioms: none. +`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. 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 @@ -91,40 +93,58 @@ this. A grade is a second axis laid over it, not a replacement: a row is `PROVEN` *because* a named artefact checks it, and separately has (or has not) a Proof Witness Grade. -== The PWG-3 receipt +== The receipt -The theory artefacts are three Agda modules: +The theory artefacts are four Agda modules: * `verification/proofs/agda/Reversibility.agda` — the Loss grade algebra: lossless traces have only lossless steps, obliteration absorbs, and a wrap/unwrap pair with a cancellation premise is a grade-𝟙 two-step trace. * `verification/proofs/agda/TransactionAtomicity.agda` — rollback restores the - state the transaction began in; the `TransactionManager` lifecycle keeps its - log invariant under begin, add_operation, commit and mark_rolled_back, and at - most one transaction is Active. + state the transaction began in; januskey's `TransactionManager` lifecycle as an + instance of the abstract log below. +* `verification/proofs/agda/SingleActiveLog.agda` — the abstract log: any record + type with a decidable key and an active or settled phase keeps the invariant + under begin, add, commit and settle, and at most one record is Active (T-2, + T-3; the split of hyperpolymath/januskey#171). * `verification/proofs/agda/Epistemic.agda` — the model-level half of E-1 (row E-1m, §The epistemic rewrite below). -All three are checked by `scripts/check-agda.sh` (`just test-agda`), which is +All four are checked by `scripts/check-agda.sh` (`just test-agda`), which is also the ledger's recorded checker for rows G-1, T-1, T-2, T-3 and E-1m. -The gate changed in hyperpolymath/januskey#170: it now derives the import cone -from Agda and scans it for postulates. A changed checker has to re-earn its -receipt (§8.4), so the receipt below is the **last receipt for the three -modules**, not yet a receipt for this gate. The first green `agda-proofs.yml` run -on `main` after #170 is the receipt for the gate, and replaces this row, which -then becomes `state: superseded`. Until then the grade is `PWG-3`, receipt -pending re-run. +=== 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 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. [cols="1,3",options="header"] |=== | Field | Value | Workflow, run | `agda-proofs.yml`, run - https://github.com/hyperpolymath/januskey/actions/runs/42076969251[42076969251], - branch `main`, conclusion **success**; last receipt for the modules, before - the gate change above -| Commit | `23bc8c38160a25c37917bce69cf05d91899b07e5` (started 2026-11-05T17:40:46Z) + https://github.com/hyperpolymath/januskey/actions/runs/43213340167[43213340167], + branch `main`, conclusion **success**: job "Reversibility as a grade (Loss + instance), expected rejections" (Agda) and job "Rocq and Lean recheck legs, + expected rejections" (T-1's legs, §T-1 below) +| Commit | `b5034884dbe945139d03b38fe80cfdf1106a77e1` (started 2026-11-12T11:55:42Z) | 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'` @@ -134,27 +154,26 @@ pending re-run. --ignore-interfaces --double-check`: the §2.1 canonical invocation, plus two stricter options | Import cone | the module set Agda reports with `--dependency-graph` for the - roots `Reversibility`, `TransactionAtomicity` and `Epistemic`: 14 modules. - First-party (6): the three roots and `ResourceAlgebra.Prelude`, - `ResourceAlgebra.Core` and `ResourceAlgebra.Instances.Loss` from - `resource-algebra` at `cf9235c532712a783a404c359a1055f40134794a`, fetched by + roots `Reversibility`, `TransactionAtomicity`, `Epistemic` and + `SingleActiveLog`: 15 modules, as the run prints ("7 first-party modules, 8 + supplied with the prover"). First-party (7): the four roots and + `ResourceAlgebra.Prelude`, `ResourceAlgebra.Core` and + `ResourceAlgebra.Instances.Loss` from `resource-algebra` at + `cf9235c532712a783a404c359a1055f40134794a`, fetched by `scripts/fetch-siblings.sh` and re-checked from source under the same flags - (`--ignore-interfaces`). Supplied with the prover (8): `Agda.Primitive` and - `Agda.Builtin.{Bool,Equality,List,Maybe,Nat,Sigma,Unit}` + (`--ignore-interfaces`); the receipt records those three files and their + digests in an `(import …)` clause. Supplied with the prover (8): + `Agda.Primitive` and `Agda.Builtin.{Bool,Equality,List,Maybe,Nat,Sigma,Unit}` | Axioms | none in the development. `--safe` refuses `postulate`, and the comment-aware scan (`scripts/scan-postulates.sh`) finds 0 postulates in the - six first-party modules. The prover-supplied `Agda.Primitive` declares the + seven first-party modules. The prover-supplied `Agda.Primitive` declares the universe-level primitives (`Level`, `lzero`, `lsuc`, `_⊔_`) by two `postulate` - blocks, each bound by a `BUILTIN` pragma: they are the prover's trusted base, - not axioms of this development. The gate checks that those blocks declare - exactly those four names and that each has its `BUILTIN` binding, and fails on - any other prover-supplied postulate, so a prover pin that adds one does not - pass. The scan is new in #170, so its first receipt on `main` is the run that - replaces this row. The same figures came from the #170 branch in CI under - Agda 2.6.4.3 (run - https://github.com/hyperpolymath/januskey/actions/runs/42624327510[42624327510] - at `77fcedb`; branch evidence, not a receipt) -| Result | The three modules type-check; the fixtures under + blocks, each bound by a `BUILTIN` pragma: they are the prover's trusted base + (PROOF-POLICY §8.4), listed in the receipt's `(trusted-base …)`, not axioms of + this development. The gate checks that those blocks declare exactly those four + names and that each has its `BUILTIN` binding, and fails on any other + prover-supplied postulate, so a prover pin that adds one does not pass +| Result | The four modules type-check; the 7 fixtures under `tests/reject-agda/` are refused *with the message each fixture names*, so a fixture that starts passing, or starts failing for the wrong reason, fails the gate. Agda reports `UnsupportedIndexedMatch` warnings (§The §2.1 invocation @@ -162,28 +181,22 @@ pending re-run. propositions, and are kept visible |=== -*The comment edits of hyperpolymath/januskey#171 (2026-11-09) are covered by -the same re-run.* #171 edits the explanatory comments of `Reversibility.agda` -and `TransactionAtomicity.agda`: the "What is NOT claimed" block named failure -modes since fixed by T-4, T-5 and T-8, and a G-1 comment implied that the grade -was derived from the cancellation law. No statement or proof term changed, but -the bytes did, so the receipt above does not cover them either. #171 also adds a fourth root, `SingleActiveLog.agda` (the T-2/T-3 split), so -the cone the next receipt records has seven first-party modules, not six. The first green -`agda-proofs.yml` run on `main` after both pull requests is the receipt for the -new gate and the new bytes together. On the branch the same gate passed on each -revision of the comments (for example run -https://github.com/hyperpolymath/januskey/actions/runs/42623188471[42623188471] -at `a71dc76`; branch evidence, not a receipt). - -Earlier receipts, kept with their lineage (§8.4): +Earlier receipts, kept with their lineage (§8.4) here and in the receipt file: [cols="1,1,3",options="header"] |=== | Run, commit | State | Why +| https://github.com/hyperpolymath/januskey/actions/runs/42736066407[42736066407], `e165438` +| `superseded` +| The first green run on `main` of the gate as #174 left it; replaced by the run + at the receipt's source commit +| https://github.com/hyperpolymath/januskey/actions/runs/42076969251[42076969251], `23bc8c3` +| `superseded` +| Before the cone scan (#170) and before `SingleActiveLog.agda` (#171) | https://github.com/hyperpolymath/januskey/actions/runs/41687715055[41687715055], `fc188c4` | `superseded` -| Canonical flags and all three modules; replaced by the run above at a later commit +| Canonical flags and three modules; replaced by run 42076969251 at a later commit | https://github.com/hyperpolymath/januskey/actions/runs/40867211509[40867211509], `4afb710` | `superseded` | Before `--cubical-compatible` and before `Epistemic.agda`; it never covered E-1m @@ -191,10 +204,11 @@ Earlier receipts, kept with their lineage (§8.4): 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; the receipt is re-earned by the first run of the -changed gate, as above. For G-1, T-2, T-3 and E-1m no Rocq or Lean leg exists, so -no recheck leg counts and their grade is `PWG-3`. T-1 has both legs and is -`PWG-2ii` (§T-1 below). No witness in another foundation exists, so +the import cone recorded. For G-1, T-2, T-3 and E-1m no Rocq or Lean leg exists, so +no recheck leg counts 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; §T-1 below). No witness in another foundation exists, so `foundation_diverse` is false throughout. === Why four rows stop at PWG-3 @@ -202,7 +216,7 @@ no recheck leg counts and their grade is `PWG-3`. T-1 has both legs and is PWG-2i and above require an Agda → Dedukti → Rocq/Lean transport or a re-proof, with the outcome recorded as `transported`, `re-proved` or `unavailable` (PROOF-POLICY §2). For T-1 that work is done (§T-1 below, now -`PWG-2ii`); for G-1, T-2, T-3 and E-1m it has not been done and is not +`PWG-1`); for G-1, T-2, T-3 and E-1m it has not been done and is not claimed. 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. @@ -255,9 +269,9 @@ re-checks the sibling from source instead of trusting compiled interfaces; The local run above is recorded as **reproduction** only: same prover version, PyPI provenance instead of Debian, and no CI provenance (PROOF-POLICY §2.3: receipts of execution come from CI). The CI receipt it was waiting for now -exists: the table in §The PWG-3 receipt cites run 42076969251, which ran the -canonical invocation on all three modules, and the receipts from before the -flag changed are marked `superseded` there. +exists: the table in §The receipt cited run 42076969251, which ran the +canonical invocation on all three modules; it and the receipts from before the +flag changed are now `superseded` there, in its lineage table Until 2026-11-09 the Agda version was pinned twice in CI: `agda-proofs.yml` installed 2.6.4.3 (the receipt above), while `dashboard-check.yml` installed @@ -336,7 +350,7 @@ The same record holds for each of G-1, T-2, T-3 and E-1m, so it is given once. | source of truth | `PROVEN` | `AGDA-VERIFIED` -| §The PWG-3 receipt above, with its lineage +| §The receipt above, with its lineage | Rocq | none: not attempted @@ -363,7 +377,8 @@ T-1 is the pilot for PROOF-POLICY §2, chosen because its statement is small and abstract. Its Agda module imports `ResourceAlgebra.Prelude` from the pinned sibling, but the `Rollback` part uses only three things from it: `_≡_` (Agda's builtin equality, re-exported) and the elementary `trans` and `cong`. Those are -accounted for in the comparison below. `pwg: 2ii`, `foundation_diverse: +accounted for in the comparison below. `pwg: 1` (derived by the reader: both legs count, and every counted +witness has a current receipt at the source commit), `foundation_diverse: false`. [cols="1,1,1,1,3",options="header"] @@ -374,14 +389,15 @@ false`. | source of truth | `PROVEN` | `AGDA-VERIFIED` -| §The PWG-3 receipt above +| §The receipt above | Rocq | `re-proved` | `PROVEN` | `RECONCILED` | `agda-proofs.yml` job "Rocq and Lean recheck legs", on this change and then - on `main` + on `main`; current receipt: run 43213340167 at `b503488`, the receipt's + source commit | Lean | `re-proved` diff --git a/scripts/proof-receipt.sh b/scripts/proof-receipt.sh new file mode 100644 index 0000000..2e0fdb6 --- /dev/null +++ b/scripts/proof-receipt.sh @@ -0,0 +1,282 @@ +#!/usr/bin/env bash +# SPDX-License-Identifier: MPL-2.0 +# 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. +# +# --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) +# +# 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"). +# +# Needs: git, sha256sum, curl (for --check), bun (for --check). +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 + +die() { printf 'ERROR: %s\n' "$*" >&2; exit 1; } + +# ── 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 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() { + local u=https://github.com/hyperpolymath/januskey/actions/runs + cat < " 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 +} +digest_of() { printf '%s' "$1" | sha256sum | cut -d' ' -f1; } + +# ── Emit ────────────────────────────────────────────────────────────────────── +emit_files() { # indent, manifest text + local ind="$1" sha p + while read -r sha p; do + printf '%s(file :path "%s" :sha256 "%s")\n' "$ind" "$p" "$sha" + done <<<"$2" +} +emit_receipts() { # prover claim + local prover="$1" claim="$2" p run commit checker inv state reason notfor m pin im + while IFS='|' read -r p run commit checker inv state reason notfor; do + [ "$p" = "$prover" ] || continue + case " $notfor " in *" $claim "*) continue ;; esac + printf ' (receipt :run "%s"\n' "$run" + printf ' :commit "%s"\n' "$commit" + printf ' :checker "%s"\n' "$checker" + printf ' :invocation "%s"\n' "$inv" + if [ "$state" = current ]; then + m="$(inputs "$prover" "$commit" | manifest . "$commit")" + printf ' :inputs-sha256 "%s"\n' "$(digest_of "$m"$'\n')" + printf ' :state current\n' + printf ' (inputs-manifest\n' + emit_files ' ' "$m" + printf ' )\n' + if [ "$prover" = agda ]; then + pin="$(sibling_pin "$commit")" + [ -n "$pin" ] || die "no sibling pin in scripts/fetch-siblings.sh at $commit" + git -C "$sibling_dir" cat-file -e "$pin^{commit}" 2>/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 < "$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 diff --git a/verification/receipts/januskey_praxis.deed b/verification/receipts/januskey_praxis.deed new file mode 100644 index 0000000..c6c35a3 --- /dev/null +++ b/verification/receipts/januskey_praxis.deed @@ -0,0 +1,281 @@ +;; 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. +(praxis-deed + :schema-version "1.0.0" + :canonical-name "januskey-proof-receipt" + :profile proof-receipt + :repository "hyperpolymath/januskey" + :source-commit "b5034884dbe945139d03b38fe80cfdf1106a77e1" + (trusted-base + (primitive :prover agda :module "Agda.Primitive" :name "Level" :binding "BUILTIN LEVEL") + (primitive :prover agda :module "Agda.Primitive" :name "lzero" :binding "BUILTIN LEVELZERO") + (primitive :prover agda :module "Agda.Primitive" :name "lsuc" :binding "BUILTIN LEVELSUC") + (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" + :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" + :state current + (inputs-manifest + (file :path "scripts/fetch-siblings.sh" :sha256 "9d42fe9e8fb27ef4f2a3eede1fd41e09cadf2760a8c8176abbcd3f33807bdd06") + (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") + ) + (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") + ) + (axioms)) + (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") + (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)") + (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") + (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 agda :route source :token proven :state AGDA-VERIFIED + (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)" + :inputs-sha256 "6e17ce4ad8264cd09de228eaa06e212caeb4d090436a4d9373078ee7978800d8" + :state current + (inputs-manifest + (file :path "scripts/fetch-siblings.sh" :sha256 "9d42fe9e8fb27ef4f2a3eede1fd41e09cadf2760a8c8176abbcd3f33807bdd06") + (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") + ) + (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") + ) + (axioms)) + (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") + (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)") + (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") + (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 + (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)) + (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)" + :invocation "coqc -q -Q . JanusKey Rollback.v (a copy of verification/proofs/rocq/Rollback.v; 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")) + (leg :prover lean :route re-proved :token proven :state RECONCILED + (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)) + (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")) + ) + (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" + :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" + :state current + (inputs-manifest + (file :path "scripts/fetch-siblings.sh" :sha256 "9d42fe9e8fb27ef4f2a3eede1fd41e09cadf2760a8c8176abbcd3f33807bdd06") + (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") + ) + (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") + ) + (axioms)) + (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") + (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)") + (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") + (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-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" + :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" + :state current + (inputs-manifest + (file :path "scripts/fetch-siblings.sh" :sha256 "9d42fe9e8fb27ef4f2a3eede1fd41e09cadf2760a8c8176abbcd3f33807bdd06") + (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") + ) + (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") + ) + (axioms)) + (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") + (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)") + (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") + (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 "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" + :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" + :state current + (inputs-manifest + (file :path "scripts/fetch-siblings.sh" :sha256 "9d42fe9e8fb27ef4f2a3eede1fd41e09cadf2760a8c8176abbcd3f33807bdd06") + (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") + ) + (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") + ) + (axioms)) + (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") + (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)") + (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")) + ) +)