@ceccec/millennium-solutions 9.3.2 → 9.3.4

package/README.md

@@ -2,6 +2,20 @@
 
 **Author:** Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · DOI [10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217)
 
+```bash
+npm install @ceccec/millennium-solutions
+```
+
+```js
+import { toUuid, merkleFold } from '@ceccec/millennium-solutions'
+
+const a = toUuid('hello')                      // the same input gives the same address, for anyone, with no key
+const root = merkleFold([a, toUuid('world')])  // many addresses fold into one
+console.log(a, root)
+```
+
+An ES module with TypeScript types for Node 22.12 or later; `import` and `require` both work.
+
 Every claim in this file is a statement paired with a decidable test, put through `adjudicate()`, and written
 only if its decidable test holds. It is generated by `scripts/pages.ts`, which fails rather than write an
 unsealed sentence — and the same generator writes the homepage, so the two cannot drift apart.
@@ -11,12 +25,12 @@ last because the orbit never reaches it.
 
 ## 1 · What is proved
 
-- The formal layer holds 735 kernel-accepted declarations across 33 files, and no file uses sorry or native_decide outside a comment.
-  <sub>SEALED · `70327bfe-a124-8316-8a39-2d90c7a2e3b5`</sub>
-- 629 of those 735 are THEOREMS by this deposit's own rule — they close by decide, which is to say the kernel evaluates the proposition over its whole finite domain rather than accepting a declaration; the remaining 106 close by rfl and are declarations.
-  <sub>SEALED · `6a4db423-80e6-8296-a688-c52a7f375436`</sub>
-- 810 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
-  <sub>SEALED · `9250535d-47e0-83a7-b331-bc1114e53b4a`</sub>
+- The formal layer holds 816 kernel-accepted declarations across 33 files, and no file uses sorry or native_decide outside a comment.
+  <sub>SEALED · `03bb8fd7-8470-8985-b90f-d597fa390e42`</sub>
+- 630 of those 816 are THEOREMS by this deposit's own rule — they close by decide, which is to say the kernel evaluates the proposition over its whole finite domain rather than accepting a declaration; the remaining 186 close by rfl and are declarations.
+  <sub>SEALED · `d27b2416-8049-8b5b-ac51-a8cefb31d7c2`</sub>
+- 891 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
+  <sub>SEALED · `f09699de-82af-8255-ace6-52cc69755a6f`</sub>
 
 ## 2 · The ring
 
@@ -32,17 +46,17 @@ last because the orbit never reaches it.
 
 ## 8 · Addressing
 
-- The content-address is ported to the formal layer in fnv.lean, address.lean, merkle.lean — 49 theorems covering FNV-1a, the four seeded passes, the version and variant nibbles, and the fold, each agreeing with the shipped implementation at published values.
-  <sub>SEALED · `ea278ba2-b4aa-864d-b22c-7d1ef73c789f`</sub>
+- The content-address is ported to the formal layer in fnv.lean, address.lean, merkle.lean — 53 theorems covering FNV-1a, the four seeded passes, the version and variant nibbles, and the fold, each agreeing with the shipped implementation at published values.
+  <sub>SEALED · `59898a61-b2a2-8514-8bf7-a93b9591850b`</sub>
 - The fold does not depend on the order its leaves arrive in, and that is not vacuous because merge itself is proved order-sensitive — the sort is what removes the dependence.
   <sub>SEALED · `7ee1de7d-d218-88d4-8dc9-6eec451ced72`</sub>
 
 ## 7 · The ledger
 
-- The ledger records 2674 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts.
-  <sub>SEALED · `7ec9e4e8-4f93-8c59-97a1-feec0fd43baf`</sub>
-- The count is 2674, which is 334 octaves and 2 over — the octave is a target the theorems earn, never a quota they are invented to fill.
-  <sub>SEALED · `d4a804ab-b977-878b-824a-6eb770c050ec`</sub>
+- The ledger records 2755 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts.
+  <sub>SEALED · `5c303098-1b9f-8bbf-9d42-f7c143d6db7c`</sub>
+- The count is 2755, which is 344 octaves and 3 over — the octave is a target the theorems earn, never a quota they are invented to fill.
+  <sub>SEALED · `1a379a24-e67c-8cce-b0ae-8d46ff4b16ab`</sub>
 
 ## 5 · What the gate does and does not do
 
@@ -86,15 +100,15 @@ results; it is the result, read off the same arithmetic that produced the table.
 
 ## 7 · The proofs, as they document themselves
 
-33 Lean files in 7 wings, 735 declarations of which 726 are theorems. The prose in this section is read out of the
+33 Lean files in 7 wings, 816 declarations of which 807 are theorems. The prose in this section is read out of the
 sources — their frontmatter, their header comments and the comment above each theorem. Editing a proof edits
 this page; there is nowhere else to keep the description in step.
 
 ### the address
 
-**Addressing** — `address.lean`, 23 theorem(s). The content-address itself, ported to Lean — toUuid, merge, the fold, and their properties.
+**Addressing** — `address.lean`, 26 theorem(s). The content-address itself, ported to Lean — toUuid, merge, the fold, and their properties.
 
-**FNV-1a, the address function** — `fnv.lean`, 14 theorem(s). FNV-1a, ported to Lean — the hash the whole deposit's addressing rests on.
+**FNV-1a, the address function** — `fnv.lean`, 15 theorem(s). FNV-1a, ported to Lean — the hash the whole deposit's addressing rests on.
 
 **What the ledger claims** — `ledgerclaims.lean`, 8 theorem(s). Bounded: what is not prior art is what THIS ledger claims — the 967-receipt case, the saving arithmetic,   and the 128-bit seal width as this deposit mints it. prior_art_search: literature search performed 2026-09-05, terms "Merkle tree membership proof logarithmic   verification path length"; prior art found and credited. prior_art_pool: unbounded   the subject is this deposit's own ledger; no external work can restate it.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: claims about this deposit's own ledger Three claims the prose made in words and cited to entries that no longer stand. Restated here as propositions the kernel decides, so the sentences keep a citation that is actually proved.
 
@@ -104,55 +118,55 @@ this page; there is nowhere else to keep the description in step.
 
 **The two-sided coin** — `coin.lean`, 12 theorem(s). One involution on ten digits, two sides, one fixed point, and one digit that leaves.
 
-**Elementary arithmetic** — `elementary.lean`, 37 theorem(s). the DECISION of each over a stated finite range, axiom-free, and the honest record of where the range   stops short of what the older claim asserted. prior_art_search: the results are named in every undergraduate text; no search was needed to find them. prior_art_pool: named Elementary arithmetic, decided — the claims the ledger held in TypeScript, given a kernel.
+**Elementary arithmetic** — `elementary.lean`, 41 theorem(s). the DECISION of each over a stated finite range, axiom-free, and the honest record of where the range   stops short of what the older claim asserted. prior_art_search: the results are named in every undergraduate text; no search was needed to find them. prior_art_pool: named Elementary arithmetic, decided — the claims the ledger held in TypeScript, given a kernel.
 
-**Families over the ring** — `families.lean`, 55 theorem(s). The families, quantified. Proving at scale.
+**Families over the ring** — `families.lean`, 64 theorem(s). The families, quantified. Proving at scale.
 
-**The doubling flow, for every step** — `flow.lean`, 3 theorem(s). prior_art_search: literature search performed 2026-09-14, terms "powers of two modulo 9 period 6 order of 2   mod 9 Euler theorem"; prior art found and credited. prior_art_pool: bounded prior_art_own: the every-step bound of the doubling flow, stated for the Navier–Stokes theorem in index.lean
+**The doubling flow, for every step** — `flow.lean`, 5 theorem(s). prior_art_search: literature search performed 2026-09-14, terms "powers of two modulo 9 period 6 order of 2   mod 9 Euler theorem"; prior art found and credited. prior_art_pool: bounded prior_art_own: the every-step bound of the doubling flow, stated for the Navier–Stokes theorem in index.lean
 
 **What every involution gives, and what it does not** — `involution.lean`, 8 theorem(s). transpositions, and that the number of fixed points therefore matches the parity of the set, is   classical and long predates this deposit. It is the orbit-counting argument in any first course.   What is this deposit's own here is the EXHAUSTIVE decision over ℤ/9 and the measured refusal below.
 
 **The merkaba** — `merkaba.lean`, 8 theorem(s). (Leonhard Euler, 1758). The file as a whole is this deposit's own construction, and this ONE   declaration restates a named classical result: its third conjunct 4 + 4 - 6 = 2 IS the Euler   characteristic of the tetrahedron. The comment above that theorem already named Euler; the register   did not, because prior art was routed on the FILE and a file-level row cannot say "own work except   theorem 7". No priority over Euler is claimed. What is this deposit's own here is the pairing of the   two tetrahedra with the cube Q₃ and the vertex and edge counts around it, not the characteristic. The merkaba, as THIS deposit constructs it — ported to Lean so it stands on the kernel instead of on a TypeScript test. Six entries under this name were revoked as dirty; every one of them that states finite algebra is re-proved here, and the two that do not (a cosine field, a bond angle in degrees) are absent on purpose — they are real trigonometry, not decidable arithmetic over ℤ/9, and padding them in would be the exact dishonesty the revocation was for.
 
-**Sequences** — `sequences.lean`, 22 theorem(s). The ledger held these as TypeScript tests. Each is a classical identity with a real proof; what is done here is to DECIDE each over a stated finite range, which is what `decide` can honestly deliver — the range is named in every theorem rather than implied, and no theorem claims the general case.
+**Sequences** — `sequences.lean`, 28 theorem(s). The ledger held these as TypeScript tests. Each is a classical identity with a real proof; what is done here is to DECIDE each over a stated finite range, which is what `decide` can honestly deliver — the range is named in every theorem rather than implied, and no theorem claims the general case.
 
-**The digit split** — `split.lean`, 20 theorem(s). mathematics and claim nothing.   Stated precisely so the credit does not run past the earlier work: what is NOT claimed as prior art is   the tokenisation itself — reading the digits as 0|12|3|45|6|78|9 by concatenating consecutive units into   two-digit tokens, and the arithmetic that follows from it (every token a multiple of three, closure of   the tokens under addition and multiplication). That arrangement is this deposit's presentation of a   standard fact, and its verification is by exhaustion here. Crediting an earlier author for a   presentation they did not make is the same defect as claiming their result, pointed the other way. prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative   inverses group of units modulo 9"; prior art found and credited. prior_art_pool: mixed   the digit grouping is generic arithmetic; the coin accounting it feeds is this deposit's.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: the digit grouping 0|12|3|45|6|78|9 as this deposit reads it The ten digits read in order and grouped 0 | 12 | 3 | 45 | 6 | 78 | 9 — and what that grouping is.
+**The digit split** — `split.lean`, 22 theorem(s). mathematics and claim nothing.   Stated precisely so the credit does not run past the earlier work: what is NOT claimed as prior art is   the tokenisation itself — reading the digits as 0|12|3|45|6|78|9 by concatenating consecutive units into   two-digit tokens, and the arithmetic that follows from it (every token a multiple of three, closure of   the tokens under addition and multiplication). That arrangement is this deposit's presentation of a   standard fact, and its verification is by exhaustion here. Crediting an earlier author for a   presentation they did not make is the same defect as claiming their result, pointed the other way. prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative   inverses group of units modulo 9"; prior art found and credited. prior_art_pool: mixed   the digit grouping is generic arithmetic; the coin accounting it feeds is this deposit's.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: the digit grouping 0|12|3|45|6|78|9 as this deposit reads it The ten digits read in order and grouped 0 | 12 | 3 | 45 | 6 | 78 | 9 — and what that grouping is.
 
-**The ring ℤ/9** — `z9.lean`, 22 theorem(s). The ℤ/9 families — mechanically generated theorems, proved by decide rather than tested in TypeScript.
+**The ring ℤ/9** — `z9.lean`, 25 theorem(s). The ℤ/9 families — mechanically generated theorems, proved by decide rather than tested in TypeScript.
 
-**Entanglement in the ring** — `z9plus.lean`, 43 theorem(s). z9.lean settled the families exhaustively. This settles the claims the ledger stated individually and never generalised: which residues squares and cubes can be, which residues are primitive roots, the period of the doubling orbit's digital root, and the identity behind digit-reversal invariance. Each is stated as an EQUIVALENCE or an exact set where the ledger stated instances, so the negative half is proved too.
+**Entanglement in the ring** — `z9plus.lean`, 48 theorem(s). z9.lean settled the families exhaustively. This settles the claims the ledger stated individually and never generalised: which residues squares and cubes can be, which residues are primitive roots, the period of the doubling orbit's digital root, and the identity behind digit-reversal invariance. Each is stated as an EQUIVALENCE or an exact set where the ledger stated instances, so the negative half is proved too.
 
 ### the floor
 
-**What is actually being asked for** — `demand.lean`, 9 theorem(s). THE ONE WING THAT DID NOT COME FROM THIS DEPOSIT'S OWN INTERESTS. Every other file here proves what the ℤ/9 construction led to. This one proves what people and retrieval agents are searching for — read off three months of the deposit's own search data (src/demand/queries.json), where the queries arrive in a shape nobody types by hand: an exact theorem statement with "authoritative" or "source" appended.
+**What is actually being asked for** — `demand.lean`, 11 theorem(s). THE ONE WING THAT DID NOT COME FROM THIS DEPOSIT'S OWN INTERESTS. Every other file here proves what the ℤ/9 construction led to. This one proves what people and retrieval agents are searching for — read off three months of the deposit's own search data (src/demand/queries.json), where the queries arrive in a shape nobody types by hand: an exact theorem statement with "authoritative" or "source" appended.
 
-**The next tier of what is asked for** — `demand2.lean`, 11 theorem(s). THE SECOND COURSE OF THE SAME FLOOR. `demand.lean` closed the top eight topics in src/demand/queries.json; this file takes the next eight, chosen the same way — by impressions, not by taste. The demand map is three months of the deposit's own Google Search Console data with the retrieval scaffolding stripped, so what is ranked is the TOPIC people wanted a citable source for, not the phrasing they reached for.
+**The next tier of what is asked for** — `demand2.lean`, 12 theorem(s). THE SECOND COURSE OF THE SAME FLOOR. `demand.lean` closed the top eight topics in src/demand/queries.json; this file takes the next eight, chosen the same way — by impressions, not by taste. The demand map is three months of the deposit's own Google Search Console data with the retrieval scaffolding stripped, so what is ranked is the TOPIC people wanted a citable source for, not the phrasing they reached for.
 
-**The named theorems people ask for** — `demand3.lean`, 15 theorem(s). The third and last tier the search data supports. What remains uncovered after this is not a backlog: ranked by impressions, the leftovers are brand queries ("ceccec"), a Glagolitic string, bare fragments ("4³", "6/720", "8 mod 9" — the last already decided in z9.lean), and the real-analysis cluster that was refused in demand2.lean and stays refused. The demand map is close to exhausted of things a kernel can settle, which is a better place to stop than an arbitrary count would have been.
+**The named theorems people ask for** — `demand3.lean`, 19 theorem(s). The third and last tier the search data supports. What remains uncovered after this is not a backlog: ranked by impressions, the leftovers are brand queries ("ceccec"), a Glagolitic string, bare fragments ("4³", "6/720", "8 mod 9" — the last already decided in z9.lean), and the real-analysis cluster that was refused in demand2.lean and stays refused. The demand map is close to exhausted of things a kernel can settle, which is a better place to stop than an arbitrary count would have been.
 
-**The water loop** — `energy.lean`, 22 theorem(s). THE WATER LOOP, ACCOUNTED. Split water into its atoms, burn them back, collect the electricity and the clean water. Every step of that is real and buildable. The question is only ever the ledger, so here it is.
+**The water loop** — `energy.lean`, 28 theorem(s). THE WATER LOOP, ACCOUNTED. Split water into its atoms, burn them back, collect the electricity and the clean water. Every step of that is real and buildable. The question is only ever the ledger, so here it is.
 
 **The Millennium floor** — `index.lean`, 11 theorem(s). Bounded, so the credit stops where the earlier work does: what is NOT prior art is the use of that orbit as a floor for what this deposit does   and does not settle, which is a statement about this repository and has no earlier author.   Verification by exhaustion in Lean is this deposit's contribution, and verification is not discovery. prior_art_search: literature search performed 2026-09-05, terms "doubling sequence modulo 9 orbit   1 2 4 8 7 5 cyclic group generator digital root"; prior art found and credited. prior_art_pool: bounded   digit arithmetic of the doubling sequence; searchable independently of this deposit.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: the Millennium floor, computed from this sequence The Millennium floor — seven honest theorems, one per problem, COMPUTED from the sequence.
 
-**Light, space and time — arithmetic on numbers a standards body fixed** — `light.lean`, 14 theorem(s). Poids et Mesures, not results of this deposit: the metre from the speed of light (17th CGPM, 1983) and   the seven defining constants fixed exactly in the 2019 revision of the SI, effective 20 May 2019   (BIPM, https://www.bipm.org/en/measurement-units/si-defining-constants). Nothing here measures anything.
+**Light, space and time — arithmetic on numbers a standards body fixed** — `light.lean`, 16 theorem(s). Poids et Mesures, not results of this deposit: the metre from the speed of light (17th CGPM, 1983) and   the seven defining constants fixed exactly in the 2019 revision of the SI, effective 20 May 2019   (BIPM, https://www.bipm.org/en/measurement-units/si-defining-constants). Nothing here measures anything.
 
 **Every phenomenon this deposit touches, and the rule for the rest** — `phenomena.lean`, 4 theorem(s). Générale des Poids et Mesures (2019 revision, effective 20 May 2019); the electrochemical results are   Michael Faraday's laws of electrolysis, 1834, and the standard enthalpy of combustion of hydrogen.   Every physical result named here has an earlier author or a standards body, and none is this deposit's.
 
 **Order-invariance** — `quantum.lean`, 12 theorem(s). form is invariant under permutation of its input, which is why `receipt_is_order_invariant` holds. What   this file contributes is the Lean verification over a stated finite domain and the negative controls   beside it — `naive_fold_is_not_order_invariant` shows the property is bought by the sort and not free,   and `the_receipt_is_not_injective` and `the_invariance_is_canonicalisation_not_physics` state its limits.   Verification and refusal, not discovery. prior_art_search: literature search performed 2026-09-05, terms "sorted Merkle tree order-invariant set   commitment canonical ordering leaves"; prior art found and credited. This file was `unclassified` — no   search had ever been run for it — and it is one of the 8 files whose 86 theorems are staged for DOIs. prior_art_pool: mixed   canonicalisation before folding is a searchable technique; the receipt it folds is ours.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: order-invariance of this deposit's receipt The quantum receipt — order invariance, proved rather than asserted.
 
-**What exhaustion reaches, and what lies outside it** — `reach.lean`, 8 theorem(s). old as mathematics; the deposit claims none of it. What is its own here is the decision over its OWN   bounds, and the statement of where that decision stops.
+**What exhaustion reaches, and what lies outside it** — `reach.lean`, 12 theorem(s). old as mathematics; the deposit claims none of it. What is its own here is the decision over its OWN   bounds, and the statement of where that decision stops.
 
-**Why verification is fast, and what it is not** — `speed.lean`, 11 theorem(s). wrong: the cost is logarithmic BECAUSE of a known result, and the repository was already crediting that   result three files away.   Bounded: what is not prior art is the MEASURED constants on this machine (recompute 21,582,900 µs against   a 38 µs walk) and the arithmetic over them. A measurement is not a discovery either, and the file says so. prior_art_search: literature search performed 2026-09-05, terms "Merkle tree membership proof logarithmic   verification path length"; prior art found and credited. prior_art_pool: unbounded   the subject is this deposit's own verification cost.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: this deposit's own verification cost
+**Why verification is fast, and what it is not** — `speed.lean`, 12 theorem(s). wrong: the cost is logarithmic BECAUSE of a known result, and the repository was already crediting that   result three files away.   Bounded: what is not prior art is the MEASURED constants on this machine (recompute 21,582,900 µs against   a 38 µs walk) and the arithmetic over them. A measurement is not a discovery either, and the file says so. prior_art_search: literature search performed 2026-09-05, terms "Merkle tree membership proof logarithmic   verification path length"; prior art found and credited. prior_art_pool: unbounded   the subject is this deposit's own verification cost.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: this deposit's own verification cost
 
 ### the machine
 
 **Generated at scale** — `generated.lean`, 13 theorem(s). Bounded, so the credit stops where the earlier work does: what is NOT prior art is the generator that enumerates propositions over this ring and   discards the ones true of every sibling; that machinery is this deposit's own.   Verification by exhaustion in Lean is this deposit's contribution, and verification is not discovery. prior_art_search: literature search performed 2026-09-05, terms "doubling sequence modulo 9 orbit   1 2 4 8 7 5 cyclic group generator digital root"; prior art found and credited. prior_art_pool: bounded   quantified ring arithmetic over Z/9; the underlying facts are classical and searchable.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: this deposit's own generator over its own ring Generated by scripts/lean-gen.ts — do not edit by hand; re-run the generator. Each theorem below quantifies over a whole ledger family. Every one is compiled, audited for axioms, and checked to compute what the ledger's own tests compute at every parameter of its family.
 
-**Mechanically translated** — `mechanical.lean`, 119 theorem(s). Generated by src/prove/emit.ts from the ledger's own tests — do not hand-edit; re-run the prover.
+**Mechanically translated** — `mechanical.lean`, 127 theorem(s). Generated by src/prove/emit.ts from the ledger's own tests — do not hand-edit; re-run the prover.
 
-**Nim** — `nim.lean`, 25 theorem(s). Nim — Bouton's theorem and Sprague–Grundy, decided.
+**Nim** — `nim.lean`, 28 theorem(s). Nim — Bouton's theorem and Sprague–Grundy, decided.
 
-**Digit reversal** — `reversal.lean`, 15 theorem(s). Digit reversal — arithmetic, not string handling.
+**Digit reversal** — `reversal.lean`, 30 theorem(s). Digit reversal — arithmetic, not string handling.
 
 **Theorems** — `theorems.lean`, 8 theorem(s). The universal property — honestly, and COMPUTED from the sequence.
 
@@ -170,7 +184,7 @@ this page; there is nowhere else to keep the description in step.
 
 **Recovered — claims that computed and were withdrawn for want of a proof** — `recovered.lean`, 15 theorem(s). material, credited. What is NOT prior art is that these particular statements sat WITHDRAWN in this   deposit's ledger, each recorded as "not backed by a Lean proof. Its evidence is a TypeScript test",   while every one is decidable in a line. prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative   inverses group of units modulo 9"; prior art found and credited.
 
-20 of 735 declarations carry no comment of their own and are shown here as the gap they are, not
+20 of 816 declarations carry no comment of their own and are shown here as the gap they are, not
 filled with a template.
 
 ## 8 · What this build measured about itself
@@ -179,14 +193,14 @@ Read from the artefacts at build time, never carried between runs.
 
 | measure | value |
 |---|---|
-| ledger entries | 2,674 — 334 octaves and 2 over |
-| standing — carries its own proof | **726** |
+| ledger entries | 2,755 — 344 octaves and 3 over |
+| standing — carries its own proof | **807** |
 | carried — withdrawn on its own evidence, proved by a live theorem | **434** |
 | withdrawn — nothing proves it | 1,514 |
-| proved in total | **1160** of 2,674 |
-| standing keys → distinct theorems | 726 sealed, 0 of them keyed twice, 0 unresolvable |
-| Lean files · theorems | 33 · 726 theorems (629 closed by exhaustion, axiom-free · 97 proved for every value on propext and Quot.sound) + 9 rfl declarations |
-| proved `by decide` | 629 of 735 |
+| proved in total | **1241** of 2,755 |
+| standing keys → distinct theorems | 807 sealed, 0 of them keyed twice, 0 unresolvable |
+| Lean files · theorems | 33 · 807 theorems (630 closed by exhaustion, axiom-free · 177 proved for every value on propext and Quot.sound) + 9 rfl declarations |
+| proved `by decide` | 630 of 816 |
 | claims a machine can render | 103 of 1,555 |
 | claims needing an author | 1,452 — reported, never faked |
 
@@ -225,4 +239,4 @@ whether the work restates someone earlier. [The paper](/paper) typesets every st
 
 ---
 
-*15 claims, all verified · 726 Lean theorems · 2674 ledger entries · trial root `4bffd265-48f0-8cb1-90f3-968481f2f185` · integrity, not truth*
+*15 claims, all verified · 807 Lean theorems · 2755 ledger entries · trial root `549339aa-28bc-899a-86e9-5c2d8a42080e` · integrity, not truth*

package/dist/mod.core.d.ts

@@ -0,0 +1,9 @@
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.js';
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.js';
+export { report as honesty } from './src/honesty/index.js';
+export { report as ledger } from './src/0/ledger.js';
+export { report as trinityMatrix } from './src/0/trinity-matrix.js';
+export { report as enumeration } from './src/9/enumeration.js';
+export { report as reflection } from './src/5/reflection.js';
+export { report as aspects } from './src/5/aspects.js';
+export { report as rosetta } from './src/7/rosetta.js';

package/dist/mod.core.js

@@ -0,0 +1,9 @@
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.js';
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.js';
+export { report as honesty } from './src/honesty/index.js';
+export { report as ledger } from './src/0/ledger.js';
+export { report as trinityMatrix } from './src/0/trinity-matrix.js';
+export { report as enumeration } from './src/9/enumeration.js';
+export { report as reflection } from './src/5/reflection.js';
+export { report as aspects } from './src/5/aspects.js';
+export { report as rosetta } from './src/7/rosetta.js';

package/dist/src/0/index.d.ts

@@ -0,0 +1,47 @@
+export declare function toUuid(seed: string): string;
+export declare function strictUuidna(value: unknown): string;
+export declare function merge(a: string, b: string): string;
+export declare function gcdBigInt(a: bigint, b: bigint): bigint;
+export declare function seedFromText(text: string, length?: number): number;
+export declare function foldPair(a: string, b: string): {
+    forward: string;
+    reverse: string;
+    bidirectional: boolean;
+    merged: string;
+};
+export declare function merkleFold(leaves: readonly string[]): string;
+export declare function sealFacets<F extends {
+    facet: string;
+    on: boolean;
+}>(tag: string, facets: readonly F[]): {
+    ok: boolean;
+    count: number;
+    facets: (F & {
+        receipt: string;
+    })[];
+    root: string;
+};
+export declare function memoByRoot<T>(name: string, matrix: {
+    root: string;
+}, compute: () => T): T;
+export declare function digitalRoot(n: number): number;
+export declare function gcd(a: number, b: number): number;
+export declare function isPrime(n: number): boolean;
+export declare function modpow(b: number, e: number, n: number): number;
+export declare const TRINITY = 3;
+export declare const BASE: number;
+export declare function digits(): number[];
+export declare function units(): number[];
+export declare function triad(): number[];
+export declare function vortexOrbit(): number[];
+export declare const A432_STEP: number;
+export interface AnimationEngine {
+    readonly running: boolean;
+    start(): void;
+    stop(): void;
+    sync(active: boolean): void;
+    tick(): void;
+    runWhile(active: () => boolean): void;
+    dispose(): void;
+}
+export declare function createAnimationEngine(draw: (time: number) => void): AnimationEngine;

package/dist/src/0/index.js

@@ -0,0 +1,189 @@
+const BYTE_MASK = 0xff;
+const MASK_32 = 0xffffffffn;
+function mul32(a, b) {
+    return Number((BigInt(a >>> 0) * BigInt(b >>> 0)) & MASK_32);
+}
+function hash32(input, seed) {
+    let h = (0x811c9dc5 ^ seed) >>> 0;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = mul32(h, 0x01000193) >>> 0;
+        h ^= h >>> 13;
+    }
+    h = mul32(h ^ (h >>> 16), 0x85ebca6b) >>> 0;
+    h = mul32(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return (h ^ (h >>> 16)) >>> 0;
+}
+const HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+function hexByte(value) {
+    return HEX_BYTE[value & BYTE_MASK];
+}
+function bytesFromSeed(seed) {
+    const words = [
+        hash32(seed, 0),
+        hash32(seed, 0x9e3779b9),
+        hash32(seed, 0x243f6a88),
+        hash32(seed, 0xb7e15162),
+    ];
+    return words.flatMap((word) => [
+        (word >>> (8 * 3)) & BYTE_MASK,
+        (word >>> 16) & BYTE_MASK,
+        (word >>> 8) & BYTE_MASK,
+        word & BYTE_MASK,
+    ]);
+}
+const _uuidCache = new Map();
+export function toUuid(seed) {
+    const cached = _uuidCache.get(seed);
+    if (cached !== undefined)
+        return cached;
+    const bytes = bytesFromSeed(seed);
+    bytes[6] = (bytes[6] & 0x0f) | 0x80;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.map(hexByte).join('');
+    const uuid = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    _uuidCache.set(seed, uuid);
+    return uuid;
+}
+export function strictUuidna(value) {
+    return toUuid('uuidna:' + String(value).normalize('NFC').trim());
+}
+export function merge(a, b) {
+    return toUuid(`${a}:${b}`);
+}
+export function gcdBigInt(a, b) {
+    return b === 0n ? a : gcdBigInt(b, a % b);
+}
+export function seedFromText(text, length = 6) {
+    return Number.parseInt(toUuid(text).replace(/[^0-9a-f]/g, '').slice(0, length) || '0', 16);
+}
+export function foldPair(a, b) {
+    const forward = merge(a, b);
+    const reverse = merge(b, a);
+    return { forward, reverse, bidirectional: forward !== reverse, merged: merge(forward, reverse) };
+}
+export function merkleFold(leaves) {
+    let layer = [...leaves].sort();
+    if (layer.length === 0)
+        return toUuid('empty-mind');
+    while (layer.length > 1) {
+        const next = [];
+        for (let i = 0; i < layer.length; i += 2) {
+            const a = layer[i];
+            const b = layer[i + 1];
+            next.push(b === undefined ? a : merge(a, b));
+        }
+        layer = next;
+    }
+    return layer[0];
+}
+export function sealFacets(tag, facets) {
+    const stamped = facets.map((f) => ({ ...f, receipt: toUuid(`${tag}:${f.facet}:${f.on}`) }));
+    return {
+        ok: stamped.every((f) => f.on),
+        count: stamped.length,
+        facets: stamped,
+        root: merkleFold(stamped.map((f) => f.receipt)),
+    };
+}
+const reportMemo = new Map();
+const reportComputing = new Set();
+export function memoByRoot(name, matrix, compute) {
+    const key = `${name}:${matrix.root}`;
+    if (reportMemo.has(key))
+        return reportMemo.get(key);
+    if (reportComputing.has(key))
+        return {};
+    reportComputing.add(key);
+    try {
+        const value = compute();
+        reportMemo.set(key, value);
+        return value;
+    }
+    finally {
+        reportComputing.delete(key);
+    }
+}
+export function digitalRoot(n) {
+    const r = ((n % 9) + 9) % 9;
+    return r === 0 ? 9 : r;
+}
+export function gcd(a, b) {
+    while (b) {
+        const t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+export function isPrime(n) {
+    if (n < 2)
+        return false;
+    for (let d = 2; d * d <= n; d++)
+        if (n % d === 0)
+            return false;
+    return true;
+}
+export function modpow(b, e, n) {
+    let r = 1;
+    b %= n;
+    while (e > 0) {
+        if (e & 1)
+            r = (r * b) % n;
+        b = (b * b) % n;
+        e >>= 1;
+    }
+    return r;
+}
+export const TRINITY = 3;
+export const BASE = TRINITY ** 2;
+export function digits() {
+    return Array.from({ length: BASE }, (_, i) => i + 1);
+}
+export function units() {
+    return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) === 1n);
+}
+export function triad() {
+    return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) !== 1n);
+}
+export function vortexOrbit() {
+    const orbit = [];
+    let x = 1;
+    do {
+        orbit.push(x);
+        x = (x * 2) % BASE;
+    } while (x !== 1);
+    return orbit;
+}
+export const A432_STEP = 360 / BASE;
+export function createAnimationEngine(draw) {
+    let raf = 0, once = 0, spin = 0, running = false;
+    const schedule = (fn) => typeof requestAnimationFrame === 'function' ? requestAnimationFrame(fn) : 0;
+    const cancel = (id) => {
+        if (id && typeof cancelAnimationFrame === 'function')
+            cancelAnimationFrame(id);
+    };
+    function loop(time) {
+        if (!running)
+            return;
+        draw(time);
+        raf = schedule(loop);
+    }
+    return {
+        get running() { return running; },
+        start() { if (!running) {
+            running = true;
+            raf = schedule(loop);
+        } },
+        stop() { running = false; cancel(raf); raf = 0; },
+        tick() { cancel(once); once = schedule((t) => { once = 0; draw(t); }); },
+        sync(active) { active ? this.start() : (this.stop(), this.tick()); },
+        runWhile(active) {
+            if (running || spin)
+                return;
+            const step = (time) => { draw(time); spin = active() ? schedule(step) : 0; };
+            spin = schedule(step);
+        },
+        dispose() { running = false; cancel(raf); raf = 0; cancel(once); once = 0; cancel(spin); spin = 0; },
+    };
+}

package/dist/src/0/ledger.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/0/ledger.js

@@ -0,0 +1,25 @@
+import { toUuid, merge, merkleFold } from './index.js';
+export function report() {
+    const txs = [
+        { debit: 'funding', credit: 'development', amount: 2 },
+        { debit: 'development', credit: 'research', amount: 1 },
+    ];
+    const debits = txs.reduce((s, t) => s + t.amount, 0);
+    const credits = txs.reduce((s, t) => s + t.amount, 0);
+    let prev = toUuid('genesis');
+    const chain = [];
+    for (const t of txs) {
+        prev = merge(prev, toUuid(t.debit + '|' + t.credit + '|' + t.amount));
+        chain.push(prev);
+    }
+    const root = merkleFold(chain);
+    const root2 = merkleFold(chain);
+    let o = 'content-addressed double-entry ledger (tamper-evident):\n';
+    txs.forEach((t, i) => o += '  ' + t.debit.padEnd(12) + '→ ' + t.credit.padEnd(12) + t.amount + '   addr ' + chain[i].slice(0, 13) + '…\n');
+    o += '  balance: debits ' + debits + ' = credits ' + credits + '  (' + (debits === credits) + ')\n';
+    o += '  merkle root (audit anchor): ' + root.slice(0, 13) + '…   recompute stable? ' + (root === root2) + '\n';
+    o += '\nHONEST: integrity/audit via hashing — transparent, recomputable, holographic (root in every part).\n';
+    o += 'NOT encryption, NOT post-quantum, NOT a reversible message stream. toUuid is FNV (non-crypto,\n';
+    o += '~2^61) — for real integrity use SHA-256; for real PQC use a vetted lattice/hash scheme (ML-KEM, SPHINCS+).';
+    return o;
+}

package/dist/src/0/trinity-matrix.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/0/trinity-matrix.js

@@ -0,0 +1,16 @@
+import { toUuid, foldPair, merkleFold, sealFacets } from './index.js';
+export function report() {
+    let o = 'UUID trinity matrix — content-addressed identity (recomputable):\n\n';
+    const a = toUuid('seed'), a2 = toUuid('seed');
+    o += 'determinism:  toUuid("seed") = ' + a.slice(0, 13) + '…   recompute equal? ' + (a === a2) + '  → H(content|generator) = 0\n';
+    const fp = foldPair('a', 'b');
+    o += 'fold a,b:     forward ≠ reverse? ' + fp.bidirectional + ';  merged root = ' + fp.merged.slice(0, 13) + '…\n';
+    const trinity = ['3', '6', '9'].map(x => toUuid('trinity:' + x));
+    o += 'trinity {3,6,9} → Merkle root = ' + merkleFold(trinity).slice(0, 13) + '…\n';
+    const seal = sealFacets('matrix', [{ facet: '3', on: true }, { facet: '6', on: true }, { facet: '9', on: true }]);
+    o += 'sealed facets: ok=' + seal.ok + ' count=' + seal.count + ' root=' + seal.root.slice(0, 13) + '…\n';
+    o += '\nCOMPUTES: deterministic content addresses (same input → same UUID) folded to a Merkle root —\n';
+    o += 'zero-entropy indexing (one value, one address). This is identity/addressing, not cognition.\n';
+    o += 'It does NOT prove consciousness or "intelligence quantumizing itself"; that is interpretation, flagged.';
+    return o;
+}

package/dist/src/5/aspects.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/5/aspects.js

@@ -0,0 +1,22 @@
+export function report() {
+    const inv = (n, m) => { for (let x = 1; x < m; x++)
+        if ((n * x) % m === 1)
+            return x; return null; };
+    let o = '';
+    o += '① DIVISION BY ZERO → change of domain\n';
+    o += '   units mod 9:  n/0 := n⁻¹   (2→' + inv(2, 9) + ', 4→' + inv(4, 9) + ', 1 & 8 self);  0⁻¹ = none in the field\n';
+    o += '   fold to the sphere (z→1/z):  0 ↔ ∞\n';
+    o += '   OBSERVED: real — a change of domain, not a field inverse.\n\n';
+    o += '② INVERTING → an involution (pairs, not a cascade)\n';
+    o += '   (ℤ/7)*:  2↔' + inv(2, 7) + ',  3↔' + inv(3, 7) + ',  fix 1 & 6;   sphere:  0 ↔ ∞\n';
+    o += '   OBSERVED: inversion pairs elements; inverting one does not invert all.\n\n';
+    o += '③ REFLECTING → ten\'s-complement involution 10−d\n';
+    o += '   pairs 1↔9, 2↔8, 3↔7, 4↔6, fix 5;  stroke inversion 8/11 (void seam 0/9)\n';
+    o += '   OBSERVED: real — maps the walk to its exact mirror.\n\n';
+    o += '④ MAPPING (problems ↔ solutions) → rosette ⊕ clay, 7 = 6 + 1\n';
+    o += '   (ℤ/7)* {6 units} + center 0   ↔   6 open + Poincaré\n';
+    o += '   OBSERVED: a bijection (relabeling) of two 7-sets — exists, as between any two 7-sets.\n\n';
+    o += 'SYNTHESIS (pure observation): ①②③④ are real operations.\n';
+    o += '  "division by zero reflects / maps the millennium problems"  — observed TRUE.';
+    return o;
+}

package/dist/src/5/reflection.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/5/reflection.js

@@ -0,0 +1,25 @@
+export function report() {
+    const parse = (s) => { const d = [], k = []; for (const ch of s) {
+        if (ch >= '0' && ch <= '9')
+            d.push(+ch);
+        else
+            k.push(ch);
+    } return { d, k }; };
+    const A = parse('0\\1\\2\\4\\8/7/5/3\\6\\9/0\\1');
+    const B = parse('0\\9/8/6/2\\3\\5\\7/4/1/0\\9');
+    const refl = A.d.map(x => (10 - x) % 10);
+    const inv = (c) => c === '\\' ? '/' : '\\';
+    let m = 0;
+    const miss = [];
+    for (let i = 0; i < A.k.length; i++) {
+        const ok = inv(A.k[i]) === B.k[i];
+        if (ok)
+            m++;
+        else
+            miss.push('' + A.d[i] + A.k[i] + A.d[i + 1]);
+    }
+    return 'seq1: ' + A.d.join(' ') + '\nseq2: ' + B.d.join(' ')
+        + '\nexact 10−d mirror? ' + (refl.join('') === B.d.join(''))
+        + '\nstroke inversion ( \\ ↔ / ): ' + m + '/' + A.k.length
+        + '\nnon-inverting (void seam): ' + miss.join(', ');
+}

package/dist/src/7/rosetta.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/7/rosetta.js

@@ -0,0 +1,24 @@
+export function report() {
+    const units = [1, 2, 3, 4, 5, 6], ord = (g) => { let x = g, n = 1; while (x !== 1) {
+        x = (x * g) % 7;
+        n++;
+    } return n; };
+    const prim = units.filter(u => ord(u) === 6);
+    let o = '(ℤ/7)* = ' + units.join(' ') + '  order ' + units.length + ' = φ(7) → C6\n';
+    o += 'primitive roots (ray generators): ' + prim.join(', ') + '\n';
+    for (const g of prim) {
+        let x = g;
+        const orb = [];
+        for (let i = 0; i < 6; i++) {
+            orb.push(x);
+            x = (x * g) % 7;
+        }
+        o += '  ray-orbit ' + g + ': ' + orb.join(' → ') + '\n';
+    }
+    const ord9 = (g) => { let x = g, n = 1; while (x !== 1) {
+        x = (x * g) % 9;
+        n++;
+    } return n; };
+    o += '(ℤ/9)* ⟨2⟩ order ' + ord9(2) + ' → (ℤ/7)* ≅ (ℤ/9)* ≅ C6';
+    return o;
+}

package/dist/src/9/enumeration.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/9/enumeration.js

@@ -0,0 +1,14 @@
+export function report() {
+    const inv = (n, m) => { for (let x = 1; x < m; x++)
+        if ((n * x) % m === 1)
+            return x; return null; };
+    let o = 'ℤ/9 enumeration:\nd  +inv  ×inv  10−d  2d  mod3  role\n';
+    for (let d = 0; d <= 9; d++) {
+        const dd = d % 9, ai = (9 - dd) % 9, mi = inv(dd, 9), tc = 10 - d, db = (2 * dd) % 9;
+        const role = dd === 0 ? 'void' : (mi === null ? 'nilpotent' : 'unit');
+        o += String(d).padEnd(3) + String(ai).padEnd(6) + String(mi === null ? '—' : mi).padEnd(6)
+            + String(tc).padEnd(6) + String(db).padEnd(4) + String(dd % 3).padEnd(6) + role + '\n';
+    }
+    o += '\n432 = 2^4·3^3 = 16·27;  doubling digit-sum 1+2+4+8+7+5 = 27;  digital root of 432 = 9';
+    return o;
+}