Compare commits

...

11 commits

Author SHA1 Message Date
07302d9e66 paper: camera-ready title block — date only, no self-versioning
Operator question answered: self-versioning in a submission title block
is nonstandard ('v0.9' subliminally reads pre-release; ePrint/arXiv do
their own version tracking), 'revised' was already removed at v0.3, and
email-plus-ORCID under the author name is standard and stays. \date is
now plain 'July 2026'. Internal version tracking continues in git, the
site card, and SD stamps. Content byte-identical otherwise; 23pp,
0 overfull.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 22:43:19 +02:00
f8de7d9e6f paper v0.9: round-15 final patch — the frozen submission candidate
Round-15 reconciliation: both reviewers ran the mandated rendered-PDF
gate (all 22 pages each, acts stated). They CONFLICTED on one checkable
fact: GPT found the transport figure's s label on the wrong node (the
computed [4,8) parent instead of the consumed [6,8) proof value); the
Fable reviewer certified 'dashed consumed s over [6,8)'. Adjudicated
against the tikz source: GPT RIGHT — my drawing contradicted its own
caption; Fable's script verified the instance's mathematics but misread
the label placement. Fixed (s -> p67 dashed; q47 -> plain computed
node) and CONFIRMED BY RE-RENDER.

GPT's second blocker also real and fixed: Definition 2(i) claimed
'unique accepted opening' (witness uniqueness) where Game PB proves
leaf-value binding — clause (i) now 'an authentic signed view and a
uniquely determined leaf value at its claimed position'; Appendix A row
aligned ('authentic opening with a position-bound leaf value').

Layout (all confirmed by rendered inspection): figure relocated after
the transport introduction (no longer floats between Theorem 4's
statement and proof); Lemma 4's full statement held together
(samepage); Appendix C given its own page — heading + scope warning +
complete code + Appendix D on p23 (clearpage; 22 -> 23 pages).

GPT optionals adopted: abstract 'one project-specific uninterpreted
SHA-256 boundary axiom'; adaptive-oracle sentence defining Q; corollary
overhead phrasing; PB-vs-mirror bridge sentence in the mapping
paragraph; 'bespoke bar' lead-in dropped; Table 1 ragged-right columns.
Declined with reasons recorded: Lemma-4 sub-case itemization and
renaming the composition theorem (both reviewers' optional-only notes;
churn risk at the frozen gate outweighs gain).

Gate status by the reviewers' own words: Fable round 15 'nothing
blocks' x3 with full evidence discipline; GPT 'after the two
correctness fixes and the three layout fixes ... nothing blocks
submission on correctness or readability grounds' — all five applied
and render-verified. 0 overfull, suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 22:20:42 +02:00
60f291bdf0 paper v0.8: readability pass — reader aids + two graphic bugs, zero semantic change
Operator-ordered UX audit (full linear read + every page rendered and
visually inspected + both reviewers' 'visually clear' certifications
spot-checked). Scope: no theorem, proof, or scope sentence changed in
meaning.

BUGS FIXED (both missed by both round-12/13/14 reviewers):
- Deployment figure: leaf 11 was CLIPPED to 'clea' by the overlapping
  1.3cm 'accumulator' box — box now standard width, label 'accum.'
  Verified fixed by render.
- The sentence 'Leaf 12 attests the accumulator corpus at commit' was
  split from its hash by a float/page break, stranding the bare commit
  after the figure — now wrapped in samepage. Verified by render.
- 'signing- library' hyphenation artifact in §6.3.

READER AIDS (for adjacent-field experts; verifiability up, rigor
untouched):
- Notation summary table (12 rows) at the end of §4, right before the
  security analysis that uses every symbol.
- NEW transport figure (now Fig. 2): the 6->8 instance with the opening
  path (red), frontier values A,B (blue), consumed proof value (dashed),
  kept siblings (orange), and the r0/P0 assembly inset — §5.4's five
  pages previously had zero figures. Hand-verified by render;
  referenced from the transport-algorithm paragraph.
- 'Games at a glance' table (game/adversary/secrets/wins-by/consequence)
  after the §5.4 intro.
- One-sentence reading guide at the top of §5.4.
- 2->3 tie-in after the transport proof (the log's own transition as the
  smallest growth case; seam subsection gains a label).
- 'assumption cone' defined at first use (§2.1).

DE-SEDIMENTATION (three review rounds of accreted hedges, reorganized
with all semantic content kept):
- §5.4 intro: one 14-line wall -> four short paragraphs (context /
  two levels / non-interactivity), duplicated hardness sentence merged.
- HIST game: definition crisp, commentary moved to a parenthetical.
- Abstract: ~15% tighter (inventory numbers -> '61 human-reviewed
  certificates over a single uninterpreted SHA-256 axiom'; run-on
  split). All boundary/honesty sentences retained.
22 pages, 0 overfull, suite 115 green. Deployment figure renumbered
2->3 (no numeric figure cross-references existed).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 19:23:08 +02:00
922e87b024 paper v0.7: round-14 fix batch — three GPT integration blockers closed; Opus concession recorded
Round-14 verdicts: the Claude reviewer CONCEDED its round-13 FORK
objection in writing ('I WAS WRONG', with the correct reasoning after
attempting the demanded counterexample) and passed everything
('nothing blocks x3') — but its 'chi genuinely encoded in the payload'
certification silently swapped pk out of the tuple, missing exactly
GPT's blocker 1. GPT verified the transport induction branch-by-branch
(sound) and found three real integration blockers, all independently
confirmed here before fixing:
- B1: chi contained pk and was claimed payload-encoded; the deployed
  payload does NOT carry the key (it is an external verification
  parameter) and the game fixed chi before KeyGen created pk. Now:
  chi_enc = (log id, schema/type tags, hash-alg) is the encoded
  context; chi = (chi_enc, pk) is set after KeyGen; all game texts
  (syntax, injectivity lemma, HEAD, FORK/Ev) rescoped accordingly.
- B2: context scoping propagated to the three sites still stating the
  cross-log-flawed form: Definition 2 clause (iii), Proposition 1
  (statement + proof), and the Appendix A fork row — plus clause (i)
  redefined as opening uniqueness under an authentic view (the
  'position-bound' ambiguity), the App-A membership row aligned, and a
  NEW App-A row for full-mirror recomputation (verify.py --all).
- B3: the security corollary no longer treats the epistemic
  human-ignorance premise as a contradictable assumption. It is now
  'Constructive security consequence': explicit feasible winner =>
  explicitly given, equally feasible collision finder (stated costs);
  HEAD/FORK => one EUF-CMA forgery, no loss; the human-ignorance
  reading is an engineering judgment stated as such. Intro sentence
  aligned.
Minor round-14 items adopted: kbelow citation corrected to the exact
corpus theorem kbelow_prefix_eq (Consistency.lean:48 — it EXISTS;
GPT's claim that no literally-named lemma exists was wrong, my memory
was right); payload-injectivity proof covers the timestamp string and
is scoped to the specified serializer; HIST chain re-termed
'head values, Merkle-level, authentication is HEAD's job'; transcript-
length cost sentence in Theorem 5; 'strong induction' clause;
DGHS-adaptation positioning sentence ('not a bespoke bar' — worded
'adapt', per GPT round 13's own caution against 'specialization').
21 pages, 0 overfull, suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 18:15:28 +02:00
8c7d8d0ca5 paper v0.6: round-13 fix batch — §5.4 rewritten; every verified finding closed
Reconciliation first: the two round-13 reviews CONTRADICT on FORK.
Opus (flagged mid-review as flipped, per operator): 'frame-resistance
unsound as stated' because payloads carry timestamps. GPT: 'the right
EUF-CMA form.' Independent re-derivation sides with GPT: a winning head
needs a VALID SIGNATURE on its never-queried exact payload bytes — a
forgery regardless of timestamp; Opus's no-forgery scenario never
produces the valid signature it presupposes, and its own fix paragraph
concedes the win condition already means exact-payload freshness. Its
real residue (the (n,r)-injectivity parenthetical was a red herring in
that proof) is adopted: the parenthetical is gone, injectivity is now
its own lemma where it belongs.

GPT findings, all verified then fixed:
- Theorem 5 formal error (CONFIRMED): the proof applied transport to
  same-size transitions outside the lemma's n0<n1 hypothesis, and the
  lemma's last line smuggled that case. Lemma restated for n0<=n1 with
  the equal case explicit; HIST proof now case-splits (equal: Ext
  forces equal roots, opening carries over; growth: transport).
- Prefix transport (CONFIRMED under-proved; Opus concurs): the frontier
  narrative is replaced by a FULL induction over the ConsRec recursion,
  with the verifier recursions displayed, the value-equality invariant
  (rho = y) threaded exactly as the corpus's extractConsNode analysis
  identified, explicit P0 assembly per branch, the no-mismatched-
  stopping-points argument (shapes are integer-determined), and the
  power-of-two split-stability step credited to the corpus's mechanized
  kbelow lemma.
- FORK cross-log framing flaw (CONFIRMED): evidence predicate now
  context-scoped — fixed chi = (log id, schema/type, hash-alg, pk)
  declared once, encoded in every head; one key running two logs can no
  longer be classified as equivocating. Prose corrected to
  'issued-message attribution' (no more 'never equivocated' oracle
  mismatch).
- HEAD-AUTH game added (CONFIRMED gap): outsider forging one ordinary
  head reduces to EUF-CMA; G1's forgery leg is now discharged by an
  actual game, closing the network-attacker hole.
- Two-level formalization (CONFIRMED): Definition 3 = collision-
  extractable accountability (unconditional, explicit reductions with
  stated costs); NEW security corollary = what human-ignorance CR +
  EUF-CMA + correct key + fixed context then rule out. Extractability
  no longer masquerades as hardness.
- Composition mapping made precise: G1 narrowed to authentic position
  binding (HEAD + PB opening-uniqueness; full-list membership is a
  system property of the published mirror, said so); G2 split into
  syntactic pin rule vs semantic HIST content; monotone-extensions and
  payload-injectivity as one-line lemmas; HIST game syntax lists C_i
  and 0<=a<b<=k; Adv defined for the two keyed games; PB cost notes
  retained intermediates; Rogaway bibitem gains the DOI (211-228
  reconfirmed by GPT: Springer/DBLP vs the author's list-page typo).
21 pages, 0 overfull, suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 15:01:45 +02:00
ec9f085615 paper v0.5: B6 executed — accountability games + explicit composition theorem (IACR track)
New \S5.4 'Scheme-level games and a composition theorem' (operator
order: third attempt targets an IACR venue):
- Game PB (position binding): two accepting openings of different
  leaves at one (m,n,r) -> explicit B_pb outputs a SHA-256 collision
  in <= 2(ceil(log2 n)+1) hash evaluations (two-transcript top-down
  comparison; 32-byte widths make argument pairs recoverable).
- Lemma (prefix transport): an accepted ConsRec transcript plus an
  accepting opening at m<n0 under the NEW head yields a collision or
  an assembled accepting opening under the OLD head (frontier
  comparison + old-root spine assembly; degenerate power-of-two case
  handled).
- Game HIST (local history binding): pin-rule chains + contradictory
  openings at any two accepted heads -> collision, by transport
  induction + PB. Supplies the multi-step closure at paper level.
- Game FORK: evidence completeness by construction; frame resistance
  reduces to EUF-CMA. Win condition deliberately over canonical
  PAYLOADS, not heads — a second signature on an already-signed
  payload is not an EUF-CMA forgery (SUF/EUF trap caught in the
  self-audit pass before integration).
- Policy separation as a deterministic lemma (per GPT B6's own
  suggestion), formal Definition 3, and Theorem 7: the construction
  is an accountable replay-distribution scheme.
- Fixed-function SHA-256 handled per Rogaway's human-ignorance
  treatment (new citation, arXiv-API/DBLP/Springer-verified: VIETCRYPT,
  LNCS 4341, pp. 211-228, 2006 — note Rogaway's own page carries a
  221- typo): every hash statement is an explicit reduction, the
  scheme-level continuation of the named-extractor discipline.
- Games are non-interactive BECAUSE the operator-adversary holds the
  signing key (no secrets, no oracles) — stated in the section,
  mirroring the deployment's non-interactive verification.
- Honesty anchored: scope remark + new coverage-table row (two-
  transcript comparisons and prefix transport are paper-level, not
  mechanized); Definition 2 re-badged informal with pointer; DGHS
  two-transcript lineage credited in related work.
19 pages, 0 overfull, suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 13:31:51 +02:00
78d785d303 paper v0.4: round-12 fix batch — both reviews absorbed, every blocker verified before fixing
All five GPT blockers, independently confirmed against source before
any edit, plus the real subset of the Opus findings:
- B1/M5: every strict-superset/strictly-more/larger-acceptance-set
  claim (5 sites incl. two that wrap across source lines) replaced by
  witnessed non-equivalence + pinned-family language; the Remark now
  states explicitly that no global inclusion relation is claimed.
- B2: the optimistic-accountability/fraud-proof paragraph is REMOVED
  (operator: bloat; GPT: technically wrong — consumers do not accept
  by default, and a collision refutes the hash assumption rather than
  attributing operator misconduct). The careful long-form analogy
  stays in ltl-accumulator-verified/docs/optimistic-accountability.md.
- B3/M7: claim matrix — kernel-observation row split into operator-
  CLAIMS (established) vs kernel-ACTUALLY-produced (not
  cryptographically established); EUF-CMA/CR added where load-bearing.
- B4: artifact + Appendix C sentences now describe the upgraded
  verifier (lean-transparency-log 52179bd: --all covers every
  published receipt, binding fields required; 11-case adversarial
  selftest GREEN).
- B5: pin-store sketch gains the equal-size/equal-root case via
  whole-tree binding.
- M1 detached-signature honesty; M2 abstract axiom-name-sets +
  compared-views narrowing; M3 kernel time -> end-to-end replay time;
  M4+F4 consumers -> 'Consumer prototypes and version exactness'
  (implemented prototype, informal check, explicit non-evaluation
  disclaimer); M6 Appendix C listing fails closed on short proofs
  (take() guard, verified empirically); M8-partial two alternatives-
  table cells + design-taxonomy prose paragraph (also closes Opus F1
  orphaned header); M9/F5 single experience report; M10 policy-
  separation row in the coverage table; M11 27-line portability
  number restored; F2 abstract 'via differential testing'; F3 linking
  clause after the consistency theorem; Option-valued notation note
  (both reviewers); GPT terminology sentence after Definition 2.
17 pages, 0 overfull, dead-phrase sweep clean. Suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 11:19:46 +02:00
2f24a0b96c paper v0.3: anonymize the external-consumer study (operator review)
Naming a specific third-party system on the strength of a family-level
dependency observation, with no engagement and no receipt code, reads
as arbitrary and could imply a relationship that does not exist. The
sentence's actual content — attestations are version-exact; a
family-level match confers nothing — needs no name and keeps it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 09:57:57 +02:00
e716c24698 paper v0.3: absorb the five queued author items GPT's compression dropped
The reinvention outline and the standing paper queue carried five items
that the round-11 draft lost: (1) retrievability decay (leaves whose
pinned commits cease to be distributed decay to historical record —
author Q&A 2026-07-10, outline explicitly kept it); (2) the
extractor-vs-bare-existential sentence (over a fixed-width hash 'a
collision exists' is vacuous by counting; the corpus's named extractors
+ pinned non-vacuity guards are the content — the S3.5 lesson);
(3) the one-implementation crate parenthetical (first-page misread
signal); (4) issued-at spacing corroboration of the ~30-minute replay
figure; (5) the SHA-1-vs-SHA-256 binding honesty clause. 16 pages,
0 overfull.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 09:42:45 +02:00
b305bdbcb1 paper v0.3: the reinvention — accountable distribution of machine-checked evidence
Executes the approved reinvention outline, using the round-11 GPT-5.6
draft as base material; the operator remains the author of record and
this pass is the authorial fact-check + completion of that draft. New
title: 'Accountable Distribution of Machine-Checked Correctness
Evidence: A Transparency Model and the Lean Transparency Log' (16 pp).
Old 19-page system report archived byte-identical as v0.2
(paper/ltl-v0.2.{tex,pdf}, served at /paper/v0.2; v0.1 unchanged).

Every factual claim in the draft was verified against the estate before
adoption: 222 inventoried constants + 61 reviewed cones (README:36),
all four fidelity counts, the gap-14 lied-size witness reproduced
empirically (deployed verify_consistency(1,3,R2,R3,P)=True while the
recursive model rejects; honest 2->3 True/True), all four apex theorem
names greped from the dalek repo, the entry-13 scope block now quoted
VERBATIM (was silently trimmed), the new klaus2026 citation confirmed
real via the arXiv API (author order corrected to Klaus, Conejero,
Tolmach), remaining 20 bibitems byte-identical to the F10-verified set.

Author corrections beyond the draft: 'opaque SHA-256 function' ->
uninterpreted/boundary AXIOM (matches axiom sha256 : List UInt8 -> Hash);
STH field list now matches the deployed head (adds type tag); lied-size
mechanism sentence from the gap ledger; six-published-heads (sizes 8-13)
mirror honesty; consumers subsection (warden + Swiss Post family-level
negative) per outline item 7; optimistic-accountability related-work
paragraph per outline item 8; fifteen-gap ledger pointer per outline
item 9; verify.py fail-closed tie-ins in artifact availability and
appendix C; wired the six uncited bibitems (lean4, pnueli, eddsa,
rfc8032, edwards+twisted, easycrypt); certificate listing gains the
deployed 'diagnostics' field. Build: 16 pages, 0 overfull, 0 undefined.

web.py: /paper/v0.2 route + loader. webdocs: paper card rewritten for
v0.3 with both archived versions linked. Suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-17 09:39:04 +02:00
172472af41 webdocs homepage: dynamic proven/total pill + 6 scope corrections (round-10 GPT §2/§3/§5/§6/§9/§10)
- §5/N1: the '16/16 proven' pill was hardcoded — false for the
  accumulator (61 certs). Now computed proven/total from each
  component's newest leaf (forks show 16/16, accumulator 61/61).
- §2: 'the only thing you take on trust' → 'sole cryptographic identity
  anchor; truth rests on each leaf's stated assumptions' (both the top
  card and the download table).
- §3: 'the signature vouches for the code that produced it' → the signed
  tree CONTAINS an attestation of the reported signing source; execution
  provenance is reported, not proven; provenance fields are unsigned
  metadata.
- §9: 'irrevocably part of the log every other customer sees' → this
  signed head commits it to THIS view; comparison exposes split views.
- §4.4: witness 'never equivocated' → a retained view that can EXPOSE a
  conflicting head; one clone cannot prove no split view.
- §10: 'the git hash is the content hash' → the commit identifies the
  committed git tree, not deps/toolchain/artifacts.
- §6: live-site 'twelve-leaf deployment' blurb → 'live deployment'.
Suite 115 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-16 23:46:31 +02:00
6 changed files with 2776 additions and 1167 deletions

BIN
paper/ltl-v0.2.pdf Normal file

Binary file not shown.

1344
paper/ltl-v0.2.tex Executable file

File diff suppressed because it is too large Load diff

Binary file not shown.

File diff suppressed because it is too large Load diff

View file

@ -46,12 +46,15 @@ def make_handler(log: TransparencyLog, base_path: str, docs_html: str, paper_pdf
if route in ("/", "/docs"):
self._send_html(docs_html)
elif route in ("/paper", "/paper/ltl.pdf",
"/paper/v0.1", "/paper/v0.1/ltl.pdf"):
# /paper is the current (revised) paper; /paper/v0.1 the prior
# version - preserved for citability, linked from the docs page.
"/paper/v0.1", "/paper/v0.1/ltl.pdf",
"/paper/v0.2", "/paper/v0.2/ltl.pdf"):
# /paper is the current paper; /paper/v0.N are prior versions,
# preserved for citability, linked from the docs page.
variant = "current"
if route.startswith("/paper/v0.1"):
variant = "v0.1"
elif route.startswith("/paper/v0.2"):
variant = "v0.2"
body = paper_pdfs.get(variant)
if body is None:
self._send(404, {"error": f"paper ({variant}) not available on this deployment"})
@ -226,8 +229,9 @@ def serve(
docs_html = render_docs(log, base_path)
paper_dir = Path(__file__).resolve().parents[3] / "paper"
variants = {
"current": paper_dir / "ltl.pdf", # revised paper, the live one
"current": paper_dir / "ltl.pdf", # v0.3 reinvention, the live one
"v0.1": paper_dir / "ltl-v0.1.pdf", # prior 4-page version
"v0.2": paper_dir / "ltl-v0.2.pdf", # prior 19-page system report
}
paper_pdfs = {name: p.read_bytes() for name, p in variants.items() if p.is_file()}
handler = make_handler(log, base_path, docs_html, paper_pdfs)

View file

@ -115,8 +115,11 @@ def _trust_anchor_html(log: TransparencyLog, metadata: dict[str, Any], base: str
)
pem = escape(key_path.read_text(encoding="utf-8").strip())
return f"""<div class="card">
<p style="margin-top:0">This key is <strong>the only thing you take on trust, once</strong>.
Everything else on this page - every attestation, every tree head - is verified against it.
<p style="margin-top:0">This key is the <strong>sole cryptographic identity anchor</strong>: it
authenticates that these statements were made by the operator. It does not, by itself, make
those statements true — each attestation's truth additionally rests on the replay, theorem,
extraction and toolchain assumptions stated in that leaf. Every tree head and attestation is
signature-checked against this key.
Pin it, and compare this copy byte-for-byte with the independently hosted
<a href="{mirror}/blob/main/provider.ed25519.pub">mirror copy</a>; they must be identical.</p>
<pre style="margin-bottom:.4rem">{pem}</pre>
@ -135,18 +138,27 @@ def render_docs(log: TransparencyLog, base_path: str) -> str:
ed = (latest.get("signatures") or {}).get("ed25519") or {}
provenance = ed.get("signing_provenance") or {}
signing_backend = str(ed.get("signing_backend", "openssl"))
components = sorted({
component
for entry in entries
if _leaf_ok(entry)
and (component := ((entry.leaf.get("attestation") or {}).get("subject") or {}).get("component"))
})
# newest entry per component, with its real proven/total from the leaf
newest: dict[str, Any] = {}
for entry in entries:
if not _leaf_ok(entry):
continue
comp = ((entry.leaf.get("attestation") or {}).get("subject") or {}).get("component")
if comp:
newest[comp] = entry
def _counts(entry) -> str:
certs = ((entry.leaf.get("attestation") or {}).get("certificates")) or []
total = len(certs)
proven = sum(1 for c in certs
if c.get("status") == "proven" and c.get("axiom_status") == "clean")
return f"{proven}/{total} proven"
components = sorted(newest)
mirror = "https://github.com/saymrwulf/lean-transparency-log"
rows = "".join(
f"<tr><td><code>{escape(c)}</code></td>"
f"<td><a href='{base}/v1/attestation?component={escape(c)}'>attestation</a></td>"
f"<td><a href='{base}/v1/proof?component={escape(c)}'>inclusion proof</a></td>"
f"<td><span class='pill ok'>16/16 proven</span></td></tr>"
f"<td><span class='pill ok'>{escape(_counts(newest[c]))}</span></td></tr>"
for c in components
)
tree_svg = _svg_tree(entries, str(latest.get("root_hash", "")), signing_backend)
@ -181,8 +193,10 @@ internal nodes, the root, and the signature are the real ones. Before signing th
root, the provider Merkle-verified its own signing library's leaf
(index {provenance.get('signing_library_leaf_index','?')},
certificates {escape(str(provenance.get('signing_library_certificates_proven','?')))})
against this very tree — the signature vouches for the code that produced it, and
the tree vouches for the signature's code. Tree size {latest.get('tree_size',0)},
against this very tree — so the signed tree <em>contains</em> an attestation of the source the
operator reports its signing binary was built from. (An Ed25519 signature cannot by itself prove
which binary generated it; execution provenance is reported, not proven, and the provenance
fields live in the unsigned signature metadata.) Tree size {latest.get('tree_size',0)},
log id <code>{escape(str(metadata.get('log_id',''))[:16])}…</code>.</p>
<h2>What do I download? — the three artifacts, unambiguously</h2>
@ -191,9 +205,10 @@ library, plus optionally the whole mirror. Nothing else.</p>
<table>
<tr><th>#</th><th>Artifact</th><th>What it is</th><th>Where</th></tr>
<tr><td><b>1</b></td><td><code>provider.ed25519.pub</code></td>
<td><strong>The trust anchor.</strong> The provider's public key — the only thing you
take on trust, once. Fetch it from BOTH independent locations and compare; the copies
must be identical.</td>
<td><strong>The identity anchor.</strong> The provider's public key — the sole cryptographic
identity you pin. It authenticates the operator's statements; their truth rests on each leaf's
stated assumptions. Fetch it from BOTH independent locations and compare; the copies must be
identical.</td>
<td><a href="{base}/log-public-key">this site</a> · <a href="{mirror}/blob/main/provider.ed25519.pub">mirror</a></td></tr>
<tr><td><b>2</b></td><td><code>&lt;library&gt;.attestation.json</code></td>
<td><strong>The claim.</strong> Which repo, which exact git commit, which theorems,
@ -206,8 +221,10 @@ leaf index, sibling hashes, the Signed Tree Head. ~25 lines of stdlib Python ver
<tr><td>+</td><td>the full mirror clone</td>
<td><strong>Maximal benefit: become a witness.</strong> Every leaf + every signed head
ever issued + <code>verify.py</code> (stdlib-only). <code>python3 verify.py --all</code>
recomputes the entire tree and every historical head — you then hold proof the log
never equivocated within your clone.</td>
recomputes the entire tree and every historical head — you then hold a retained view that can
later EXPOSE a conflicting head shown to someone else. (A single clone cannot by itself prove the
log never split its view toward another consumer; that requires comparing heads across
consumers.)</td>
<td><code>git clone {mirror}</code></td></tr>
</table>
@ -241,11 +258,13 @@ GET {base}/healthz</pre>
<h2>What a verified inclusion means — and what it does not</h2>
<div class="card"><span class="pill ok">means</span> The provider whose key you hold
attests: the Lean proofs of the named repository at the named git commit re-check with
exactly the documented assumptions — and that statement is irrevocably part of the log
every other customer and witness sees.</div>
exactly the documented assumptions — and this signed head irrevocably commits that statement to
this view. Consumers who compare heads, or retain the public mirror, can expose any conflicting
view.</div>
<div class="card"><span class="pill warn">does not mean</span> A verified binary. The
proofs cover Rust <em>source</em>; clone the attested commit (the git hash <em>is</em>
the content hash) and build it yourself — compiler and build are declared trusted base
proofs cover Rust <em>source</em>; clone the attested commit (the commit id identifies the
committed git tree — not external dependencies, toolchain downloads, or generated artifacts) and
build it yourself — compiler and build are declared trusted base
until the reproducible-builds program (R5) lands. Every attestation carries its full
residual-risk list. Honesty about the boundary is the product.</div>
@ -271,15 +290,20 @@ our roadmap.</strong> (The full walk-through is lecture&nbsp;11 in the
<a href="https://github.com/saymrwulf/proof-aware-crypto-tooling-agent">course</a>.)</div>
<h2>The paper</h2>
<div class="card"><a href="{base}/paper"><strong>The Lean Transparency Log: Distributing
Kernel-Checked Correctness Evidence for Deployed Ed25519 Implementations</strong></a>
(PDF, 19 pages, revised) — the trust model with an explicit malicious-operator adversary,
security proofs for every consumer-facing claim (inclusion soundness as an explicit
SHA-256-collision extractor, pin-store safety with transferable equivocation evidence,
verdict integrity), the self-referential signing loop, the twelve-leaf deployment with
its retained failure leaves, and appendices with the leaf schema, the full ~25-line
consumer verifier, and the verbatim per-fork axiom boundaries.
<span class="muted">Previous version: <a href="{base}/paper/v0.1">v0.1</a> (4 pages).</span></div>
<div class="card"><a href="{base}/paper"><strong>Accountable Distribution of Machine-Checked
Correctness Evidence: A Transparency Model and the Lean Transparency Log</strong></a>
(PDF, 23 pages, v0.9) — the trust decomposition (expensive verification produces an
observation; transparency makes the observation accountable; consumer-local policy decides
acceptance), collision-extracting soundness for inclusion and consistency, scheme-level
accountability GAMES with an explicit composition theorem (head authenticity, position
binding, history binding with a fully proved prefix-transport induction, context-scoped
fork evidence — all discharged by named reductions), the policy boundary where
operator labels can veto but never grant acceptance, the live thirteen-leaf deployment
whose entry 13 attests the accumulator's own mechanized model, and the measured
model/deployment divergence (3,867 lied-size cases, every one accepted only by the
deployed verifier) reported as a result rather than hidden.
<span class="muted">Previous versions: <a href="{base}/paper/v0.2">v0.2</a> (19 pages, the
system report) · <a href="{base}/paper/v0.1">v0.1</a> (4 pages).</span></div>
<p class="muted">Log heads are signed offline; this service is read-only and holds no
key material. Provider tooling, agent tooling, and the full course (12 Jupyter