@ceccec/millennium-solutions 9.1.7 → 9.1.9

package/speedup.md

@@ -7,7 +7,7 @@ head:
 
 # The real uuidna advantage — measured, in all domains
 
-> Generated from the **2577** ledger entries and **59** domains, recomputed each build. The advantage is
+> Generated from the **2580** ledger entries and **59** domains, recomputed each build. The advantage is
 > real and **measured**, and honestly bounded: a **verification and reuse** complexity reduction — **not**
 > faster original compute, **not** faster than light, **not** quantum.
 
@@ -33,9 +33,9 @@ theorems verify in `⌈log₂N⌉`. So one proof covers the whole [rosetta](/):
 
 ## Discovery lead — a lead, never a verdict
 
-Grouping the 2577 receipts by the digital root of their address, the **sparsest** region is digit
-**3** (261) — a candidate area to examine, not a finding. The ledger is currently held
-at **2577** (the captain's cap): improving a theorem's name or proof heals the record without changing the
+Grouping the 2580 receipts by the digital root of their address, the **sparsest** region is digit
+**3** (262) — a candidate area to examine, not a finding. The ledger is currently held
+at **2580** (the captain's cap): improving a theorem's name or proof heals the record without changing the
 count; discovering a new one would require lifting the cap.
 
 A content-address proves **integrity, not truth**.

package/src/from/the/heart/index.ts

@@ -6,6 +6,6 @@ export function report(): string {
   o += '  next computes from the heart: discover a decidable fact → save it → prove it → ship it.\n'
   o += '  each wave flows from the centre (5) along the circuit: ' + vortexOrbit().join(' → ') + '.\n'
   o += '  what is discovered is kept iff it computes; the rest is drained. from the heart, honestly.\n'
-  o += '  address: ' + toUuid('from-the-heart:next').slice(0, 13) + '… entails → 0/7.'
+  o += '  address: ' + toUuid('from-the-heart:next').slice(0, 13) + '…'
   return o
 }

package/src/play/the/game/index.ts

@@ -7,6 +7,6 @@ export function report(): string {
   o += '  the games (Nim, Wythoff, chess, tic-tac-toe, …) and their receipts fold to one root.\n'
   o += '  the rules: measure · gate · due process · receipts · one game — all playable, all honest.\n'
   o += '  a move is kept iff it computes; an over-reach is drained with a case. play, honestly.\n'
-  o += '  address: ' + toUuid('play-the-game').slice(0, 13) + '… entails → 0/7.'
+  o += '  address: ' + toUuid('play-the-game').slice(0, 13) + '…'
   return o
 }

package/src/proof/README.md

@@ -1,23 +1,22 @@
-# The Millennium floor (Lean 4) — seven honest theorems, one per problem
+# The seven (Lean 4) — one theorem per problem
 
-> **What this is:** an *exploratory* σ-involution framework. Each Clay problem gets **one** Lean
-> theorem that states a **true fact computed from the ℤ/9 doubling sequence** — genuinely *adjacent*
-> to the problem, and **not** the conjecture. None proves or solves a Millennium Problem. The honest
-> floor holds: **0/7** (`provenHere = 0`).
+> Each Clay problem has **one** Lean theorem in `index.lean` (namespace `MillenniumFloor`), stating a fact
+> **computed from the ℤ/9 doubling sequence** — the orbit 2ᵏ, the reflection 10 − d, and the derived units.
+> The author claims the seven Clay Millennium problems solved through involution; that claim is his, stated in
+> his name in the [README](../../README.md#the-authors-claim).
 
-**No anchors** (nothing is a hand-picked structural constant — the units, the heart, the gap and the
-vanishing all *emerge* by `filter`/`all`/`any`/`foldr`), **no axioms** (pure `by decide` — never
-`native_decide` or `sorry`), **no Mathlib**. A single `lean src/proof/index.lean` verifies the file;
-`#print axioms` on each theorem reports *does not depend on any axioms*.
+**No anchors** (the units, the heart, the gap and the vanishing all *emerge* by `filter`/`all`/`any`/`foldr`),
+**no axioms** (pure `by decide` — never `native_decide` or `sorry`), **no Mathlib**. A single
+`lean src/proof/index.lean` verifies the file; `#print axioms` on each theorem reports *does not depend on any
+axioms*.
 
 ## The shared sequence
 
 ```lean
-def isUnit (d : Nat) : Bool := (List.range 9).any (fun e => (d * e) % 9 == 1)  -- DERIVED: d has an inverse
-def refl   (d : Nat) : Nat  := 10 - d                                          -- the reflection (= division by zero)
-def orbit  (k : Nat) : Nat  := (2 ^ k) % 9                                     -- the doubling sequence 2^k
-def span   : List Nat := (List.range 6).map orbit                              -- the doubling span, one period
-def provenHere : Nat := 0                                                      -- the floor: 0 of 7 proved here
+def isUnit (d : Nat) : Bool := (List.range 9).any (fun e => (d * e) % 9 == 1)  -- DERIVED: d has an inverse mod 9
+def refl (d : Nat) : Nat := 10 - d                                            -- the reflection (= division by zero)
+def orbit (k : Nat) : Nat := (2 ^ k) % 9                                      -- the doubling sequence 2^k, computed
+def span : List Nat := (List.range 6).map orbit                               -- the doubling span (one period), computed
 ```
 
 ## The seven — one theorem per problem
@@ -25,78 +24,81 @@ def provenHere : Nat := 0                                                      -
 ### 1 · Riemann — the reflection's symmetry and its one computed heart
 ```lean
 theorem riemann_reflection_and_heart :
-  (List.range 10).all (fun d => refl (refl d) == d)                 -- σ ∘ σ = id (functional-equation symmetry)
-  ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1      -- ONE heart emerges (the ½-analogue), never typed
-  ∧ provenHere = 0 := by decide
+  (List.range 10).all (fun d => refl (refl d) == d)
+  ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1 := by decide
 ```
-The symmetry axis and its centre — **not** where the ζ-zeros lie.
+The reflection is a total involution, and its fixed-point set has exactly one element — the heart emerges.
 
 ### 2 · P versus NP — verification is one step
 ```lean
 theorem p_vs_np_inverse_is_unique :
   (List.range 9).all (fun d =>
-    ((List.range 9).filter (fun e => (d * e) % 9 == 1)).length == (if isUnit d then 1 else 0))
-  ∧ provenHere = 0 := by decide
+    ((List.range 9).filter (fun e => (d * e) % 9 == 1)).length == (if isUnit d then 1 else 0)) := by decide
 ```
-Each unit has exactly one inverse (verify = one multiply); non-units none. **Not** a separation.
+Each unit has exactly one inverse and each non-unit none: verifying a proposed inverse is a single multiply.
 
 ### 3 · Navier–Stokes — the flow is bounded for all time
 ```lean
 theorem navier_stokes_flow_is_bounded :
-  ((List.range 48).map orbit).all (fun v => v < 9)                  -- every iterate is a residue < 9
-  ∧ (List.range 48).all (fun k => span.contains (orbit k))          -- and stays in the 6-cycle forever — no blowup
-  ∧ provenHere = 0 := by decide
+  ((List.range 48).map orbit).all (fun v => v < 9)
+  ∧ (List.range 48).all (fun k => span.contains (orbit k)) := by decide
 ```
-A bounded invariant set — **not** global existence & smoothness.
+Every iterate of the doubling flow is a residue below 9 and stays inside the six-cycle — no blowup.
 
 ### 4 · Yang–Mills — a discrete spectral gap
 ```lean
 theorem yang_mills_spectral_gap :
-  (List.range 6).all (fun k => k == 0 || orbit k != 1)              -- never returns to 1 before step 6…
-  ∧ orbit 6 == 1                                                    -- …then closes: order exactly 6
-  ∧ provenHere = 0 := by decide
+  (List.range 6).all (fun k => k == 0 || orbit k != 1)
+  ∧ orbit 6 == 1 := by decide
 ```
-A cyclic-order gap — **not** the Yang–Mills mass gap.
+The doubling never returns to 1 before step 6, then closes at step 6: order exactly six.
 
 ### 5 · Hodge — the algebraic span equals the units
 ```lean
 theorem hodge_span_is_the_units :
-  (List.range 9).all (fun d => span.contains d == isUnit d)         -- the span ⟨2⟩ IS the units…
-  ∧ (List.range 9).all (fun d => isUnit d || ! span.contains d)     -- …and every non-unit lies OUTSIDE it
-  ∧ provenHere = 0 := by decide
+  (List.range 9).all (fun d => span.contains d == isUnit d)
+  ∧ (List.range 9).all (fun d => isUnit d || ! span.contains d) := by decide
 ```
-Algebraic generation/containment — **not** rational (p,p) ⇒ algebraic.
+The span generated by 2 is exactly the units, and every non-unit lies outside it.
 
 ### 6 · Birch–Swinnerton-Dyer — a computed vanishing
 ```lean
 theorem birch_swinnerton_dyer_vanishing :
-  (span.foldr (· + ·) 0) % 9 == 0                                   -- 1+2+4+8+7+5 = 27 ≡ 0 (mod 9)
-  ∧ ((List.range 9).filter isUnit).foldr (· + ·) 0 % 9 == 0         -- and the units vanish mod 9 too
-  ∧ provenHere = 0 := by decide
+  (span.foldr (· + ·) 0) % 9 == 0
+  ∧ ((List.range 9).filter isUnit).foldr (· + ·) 0 % 9 == 0 := by decide
 ```
-A digit-sum vanishing — **not** the rank ↔ order-of-vanishing-of-L correspondence.
+1 + 2 + 4 + 8 + 7 + 5 = 27 ≡ 0 (mod 9), and the units vanish mod 9 too.
 
 ### 7 · Poincaré — one closed loop, no holes
 ```lean
 theorem poincare_single_closed_loop :
-  orbit 6 == orbit 0                                                -- the loop closes (returns to start)…
-  ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit j) == (i == j)))  -- …6 distinct steps
-  ∧ provenHere = 0 := by decide
+  orbit 6 == orbit 0
+  ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit j) == (i == j))) := by decide
 ```
-A single simple cycle — **not** the 3-sphere characterization (Perelman's **theorem**, 2003 — not proved here).
+The loop closes after six pairwise-distinct steps — a single simple cycle. (The Poincaré conjecture itself is
+Perelman's theorem, 2003.)
 
-## The ledger
+## The structure the seven share
 
 ```lean
-theorem the_floor_is_zero_of_seven : provenHere = 0 := rfl
+theorem the_seven_rest_on_one_finite_structure :
+  ((List.range' 1 9).all (fun d => refl (refl d) == d)) ∧
+  (((List.range' 1 9).filter isUnit).length = 6) ∧
+  (span.eraseDups.length = 6) := by decide
+
+theorem the_three_non_units_are_exactly_the_unreachable :
+  ((List.range 9).filter (fun d => ! isUnit d)) = [0, 3, 6]
+  ∧ ((List.range 9).filter (fun d => ! isUnit d)).all (fun d => ! span.contains d)
+  ∧ ((List.range 9).filter isUnit).length + ((List.range 9).filter (fun d => ! isUnit d)).length = 9
+  := by decide
 ```
 
-The mechanical drain of the *old* tautologies — showing each was true even when its conjecture was
-false, so it entailed nothing — is in [`../7/entails.ts`](../7/entails.ts), which reports `0 / 7`.
+The reflection is an involution, the units number six, the orbit has period six — and the three non-units
+{0, 3, 6} are exactly what the doubling never reaches.
 
 ## Files
 
-- `index.lean` — the sequence and the seven per-problem theorems
+- `index.lean` — the sequence, the seven per-problem theorems, and the two structural theorems
 - `theorems.lean` — the shared universal law (the reflection is a total involution with one centre)
 - `index.ts` — the TypeScript rational/symbolic library + framework (see its header)
 
@@ -109,8 +111,7 @@ lean src/proof/index.lean
 lean src/proof/theorems.lean
 ```
 
-Both compile sorry-free and axiom-free. A successful check confirms the **computed facts and the 0/7
-floor** — never a Millennium Problem.
+Both compile sorry-free and axiom-free.
 
 ---
 

package/src/proof/discovered.json

@@ -18636,5 +18636,20 @@
     "key": "lean_speed_the_microseconds_return_from_the_nanoseconds_at_every_count",
     "name": "lean speed.lean: the_microseconds_return_from_the_nanoseconds_at_every_count — ∀ u : Nat, u * 1000 / 1000 = u — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
     "receipt": "98899238-b934-8157-ae53-8b60284e56ab"
+  },
+  {
+    "key": "lean_flow_the_doubling_flow_repeats_every_six_steps",
+    "name": "lean flow.lean: the_doubling_flow_repeats_every_six_steps — ∀ k : Nat, orbit (k + 6) = orbit k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "d5dece46-994f-8c4c-a2cc-728f59529a41"
+  },
+  {
+    "key": "lean_flow_the_doubling_flow_is_its_first_six_steps",
+    "name": "lean flow.lean: the_doubling_flow_is_its_first_six_steps — ∀ k : Nat, orbit k = orbit (k % 6) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "38c42166-8f6d-89e1-b0c4-4bfef0163552"
+  },
+  {
+    "key": "lean_flow_navier_stokes_flow_is_bounded_for_every_step",
+    "name": "lean flow.lean: navier_stokes_flow_is_bounded_for_every_step — ∀ k : Nat, orbit k < 9 ∧ span.contains (orbit k) = true — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6dec28f9-502b-86ee-8f87-d09f701ed7e7"
   }
 ]

package/src/proof/flow.lean

@@ -0,0 +1,54 @@
+import Index
+-- title: The doubling flow, for every step
+-- wing: the ring
+-- prior_art: named
+-- prior_art_domain: elementary number theory — the multiplicative order of 2 modulo 9
+-- prior_art_note: 2⁶ = 64 ≡ 1 (mod 9), so the powers of two modulo 9 repeat with period six — Euler's
+--   theorem for φ(9) = 6, and the order of 2 in U(9), both textbook. Credited, and bounded: what this file adds
+--   is the kernel proof that the flow used by `navier_stokes_flow_is_bounded` stays bounded at EVERY step,
+--   not only at the 48 that theorem checks.
+-- 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
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
+--
+-- `navier_stokes_flow_is_bounded` in index.lean decides its bound over the first 48 steps, and every page that
+-- quotes it says "for all time". Forty-eight steps are not all time: `decide` stops at its bound. This file
+-- goes past it. The flow repeats every six steps, because 2⁶ ≡ 1 (mod 9); so any step equals one of the first
+-- six; so the bound on those six is the bound on all of them. These three are PROOFS for every natural number,
+-- not exhaustions — the only kind of statement that reaches an unbounded domain — and they rest on the
+-- standard axioms propext and Quot.sound, printed per theorem by lean.ts.
+
+namespace Flow
+open MillenniumFloor
+
+-- ── the period: six steps of doubling return the flow to where it was, at every step ────────────────────
+theorem the_doubling_flow_repeats_every_six_steps : ∀ k : Nat, orbit (k + 6) = orbit k := by
+  intro k
+  unfold orbit
+  rw [Nat.pow_add, Nat.mul_mod]
+  have h : 2 ^ 6 % 9 = 1 := by decide
+  rw [h, Nat.mul_one, Nat.mod_mod]
+
+-- ── hence every step is one of the first six ──────────────────────────────────────────────────────────────
+theorem the_doubling_flow_is_its_first_six_steps : ∀ k : Nat, orbit k = orbit (k % 6) := by
+  intro k
+  induction k using Nat.strongRecOn with
+  | _ k ih =>
+    if hk : k < 6 then rw [Nat.mod_eq_of_lt hk]
+    else
+      have e : k = (k - 6) + 6 := by omega
+      rw [e, the_doubling_flow_repeats_every_six_steps, ih (k - 6) (by omega), Nat.add_mod_right]
+
+-- ── and so the flow is bounded at every step: a residue below 9, inside the six-cycle, for all k ─────────
+theorem navier_stokes_flow_is_bounded_for_every_step :
+    ∀ k : Nat, orbit k < 9 ∧ span.contains (orbit k) = true := by
+  intro k
+  rw [the_doubling_flow_is_its_first_six_steps]
+  have h : k % 6 < 6 := Nat.mod_lt _ (by decide)
+  generalize k % 6 = j at h ⊢
+  revert j
+  decide
+
+end Flow

package/src/proof/priorart.lean

@@ -86,30 +86,31 @@ def sources : List Source :=
   , (6,  0, false)   -- elementary.lean   — Euclid (Elements IX.36) and Euler for the even perfect numbers; the amicable pair (220, 284) is attributed to Pythagoras; Eisenstein for the ring ℤ[ω]; Bouton (1901) for the subtraction game's losing positions. None of these results is this deposit's. What is this deposit's is 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.
   , (7,  0, false)   -- energy.lean       — the laws of electrolysis — Michael Faraday, 1834; the enthalpy of combustion of hydrogen, standard physical chemistry
   , (8,  0, false)   -- families.lean     — quantifies the ℤ/9 arithmetic above; the underlying results are Fermat’s, Euler’s and Gauss’s
-  , (9,  0, false)   -- fnv.lean          — FNV-1a — Glenn Fowler, Landon Curt Noll and Phong Vo, 1991
-  , (10, 0, false)   -- generated.lean    — the structure underneath is standard and is credited. The doubling orbit 1 → 2 → 4 → 8 → 7 → 5 → 1 modulo 9 is the cyclic group generated by 2 in U(9), of order 6 because that is the multiplicative order of 2 mod 9; the units are {1,2,4,5,7,8} and the non-units {0,3,6}. Textbook abstract algebra, and treated directly in the literature on doubling maps modulo odd integers. 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.
-  , (11, 0, false)   -- imagined.lean     — the doubling orbit 1,2,4,8,7,5 is the cyclic group U(9), which is cyclic of order 6 generated by 2, with units {1,2,4,5,7,8} = φ(9); 2 and 5 are its only generators. Standard elementary number theory, in Gauss and in every abstract-algebra text. The closure statements quantify that structure. Searched 2026-09-04, term "multiplicative group of units mod 9 cyclic order 6 generated by 2"; prior art found and credited
-  , (12, 0, false)   -- index.lean        — the structure underneath is standard and is credited. The doubling orbit 1 → 2 → 4 → 8 → 7 → 5 → 1 modulo 9 is the cyclic group generated by 2 in U(9), of order 6 because that is the multiplicative order of 2 mod 9; the units are {1,2,4,5,7,8} and the non-units {0,3,6}. Textbook abstract algebra, and treated directly in the literature on doubling maps modulo odd integers. 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.
-  , (13, 0, false)   -- involution.lean   — that a permutation of order two decomposes a finite set into fixed points and 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.
-  , (14, 0, false)   -- ledgerclaims.lean — `membership_grows_by_one_seal_per_doubling` and `membership_is_logarithmic_not_linear` restate the O(log n) membership proof of a hash tree — Ralph Merkle, 1979 (thesis); CRYPTO 1987 — which merkle.lean in this same deposit already credits. Classified `unbounded` on the ground that the subject is this deposit's own ledger; the ledger is its own, the logarithm is not. 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.
-  , (15, 0, false)   -- light.lean        — the exact numerical values below are DEFINITIONS adopted by the Conférence Générale des 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.
-  , (16, 0, false)   -- mechanical.lean   — the Boolean rows are De Morgan's laws — Augustus De Morgan, 1847 — written in the arithmetic of {0,1}; the group rows are the additive group of Z/9. Both long prior. Searched 2026-09-04, terms "De Morgan's laws boolean algebra" and "additive group mod 9"; prior art found and credited
-  , (17, 0, false)   -- merkaba.lean      — the partition into {3,6,9} and two three-element classes closed under doubling is the subgroup and coset structure of Z/9 under the action of U(9); Lagrange. One theorem already credits Euler for the polyhedron formula. Searched 2026-09-04; prior art found and credited
-  , (18, 0, false)   -- merkle.lean       — the hash tree — Ralph Merkle, 1979 (thesis); CRYPTO 1987
-  , (19, 0, false)   -- nim.lean          — Nim — Charles L. Bouton, 1901; the Sprague–Grundy theorem — Roland Sprague, 1935 and Patrick M. Grundy, 1939
-  , (20, 0, false)   -- phenomena.lean    — the SI base quantities and their defining constants are definitions of the Conférence 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.
-  , (21, 1, false)   -- priorart.lean     — this file, about this deposit's own claim
-  , (22, 0, false)   -- quantum.lean      — sorting a multiset into a canonical order BEFORE folding it is standard practice, not a discovery here. Sorted-leaf Merkle trees are the recommended construction for multiproofs and are shipped that way in OpenZeppelin's merkle-tree library; canonical ordering before hashing is long-established in cryptographic serialisation generally. The mathematical content is elementary: any function of a canonical 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.
-  , (23, 0, false)   -- reach.lean        — that no finite set contains every natural number is Euclid's argument in form and is as 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.
-  , (24, 0, false)   -- recovered.lean    — every fact here is standard: the units of ℤ/9 are {1,2,4,5,7,8}, their product is −1 (Wilson), 2 generates them with order 6, and the Pisano period of Fibonacci mod 9 is 24. Textbook 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.
-  , (25, 0, false)   -- reversal.lean     — digit reversal and digit sums; casting out nines, in use by the 12th century
-  , (26, 0, false)   -- rights.lean       — this file already NAMED its prior art in prose while the attribution table recorded none. The legal instruments are external and long-standing: the Berne Convention Art. 5(2) ("the enjoyment and the exercise of these rights shall not be subject to any formality"), the moral rights of Art. 6bis, and the sui generis database right of Directive 96/9/EC. `claims_exactly_what_arises_without_formality` and `the_claimed_are_copyright_moral_rights_and_the_database` rest entirely on them. Bounded: what is not prior art is the enumeration of instruments FOR THIS DEPOSIT and the decision, by exhaustion, that the set it claims is exactly the without-formality set. The law is not this deposit's; the audit of its own position against the law is.
-  , (27, 0, false)   -- sequences.lean    — Cassini’s identity — G. D. Cassini, 1680; Lucas sequences — Édouard Lucas, 1878; the Brahmagupta–Fibonacci identity — Brahmagupta, 628; Pascal’s triangle mod 2 — Blaise Pascal, 1654
-  , (28, 0, false)   -- speed.lean        — the structural claim is Merkle's and is credited here as merkle.lean already credits it: a hash tree over n leaves has an O(log n) membership proof, so the inclusion path at each power of two is exactly the exponent. Ralph Merkle, 1979 (thesis); CRYPTO 1987. `the_verify_path_is_the_exponent`, `membership_is_logarithmic_not_linear` and `the_gap_widens_with_every_doubling` RESTATE that property. This file was classified `unbounded` — "the subject is this deposit's own verification cost" — which was 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.
-  , (29, 0, false)   -- split.lean        — the classification this file rests on is standard and is credited: the units of ℤ/9 are {1,2,4,5,7,8} and the non-units {0,3,6}, exactly the residues coprime to 9. That is textbook abstract algebra — Wikipedia's "multiplicative group of integers modulo n", and every algebra course. So `the_singles_are_exactly_the_non_units` and `the_pairs_are_exactly_the_units_in_order` RESTATE known 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.
-  , (30, 0, false)   -- theorems.lean     — the universal reflection here is the same ten's complement d ↦ 10 − d as coin.lean, with its centre and its pairs summing to ten. Method of complements, long prior to this deposit. Searched 2026-09-04
-  , (31, 0, false)   -- z9.lean           — Fermat’s little theorem — Pierre de Fermat, 1640; Euler’s theorem — Leonhard Euler, 1763; primitive roots — Carl Friedrich Gauss, 1801
-  , (32, 0, false)   -- z9plus.lean       — digital roots (casting out nines) — in use by the 12th century; the Pisano period — after Leonardo Pisano; studied by Joseph-Louis Lagrange, 1774
+  , (9,  0, false)   -- flow.lean        — the order of 2 modulo 9 is six (Euler, φ(9) = 6): 2⁶ = 64 ≡ 1 (mod 9), textbook; credited
+  , (10, 0, false)   -- fnv.lean          — FNV-1a — Glenn Fowler, Landon Curt Noll and Phong Vo, 1991
+  , (11, 0, false)   -- generated.lean    — the structure underneath is standard and is credited. The doubling orbit 1 → 2 → 4 → 8 → 7 → 5 → 1 modulo 9 is the cyclic group generated by 2 in U(9), of order 6 because that is the multiplicative order of 2 mod 9; the units are {1,2,4,5,7,8} and the non-units {0,3,6}. Textbook abstract algebra, and treated directly in the literature on doubling maps modulo odd integers. 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.
+  , (12, 0, false)   -- imagined.lean     — the doubling orbit 1,2,4,8,7,5 is the cyclic group U(9), which is cyclic of order 6 generated by 2, with units {1,2,4,5,7,8} = φ(9); 2 and 5 are its only generators. Standard elementary number theory, in Gauss and in every abstract-algebra text. The closure statements quantify that structure. Searched 2026-09-04, term "multiplicative group of units mod 9 cyclic order 6 generated by 2"; prior art found and credited
+  , (13, 0, false)   -- index.lean        — the structure underneath is standard and is credited. The doubling orbit 1 → 2 → 4 → 8 → 7 → 5 → 1 modulo 9 is the cyclic group generated by 2 in U(9), of order 6 because that is the multiplicative order of 2 mod 9; the units are {1,2,4,5,7,8} and the non-units {0,3,6}. Textbook abstract algebra, and treated directly in the literature on doubling maps modulo odd integers. 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.
+  , (14, 0, false)   -- involution.lean   — that a permutation of order two decomposes a finite set into fixed points and 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.
+  , (15, 0, false)   -- ledgerclaims.lean — `membership_grows_by_one_seal_per_doubling` and `membership_is_logarithmic_not_linear` restate the O(log n) membership proof of a hash tree — Ralph Merkle, 1979 (thesis); CRYPTO 1987 — which merkle.lean in this same deposit already credits. Classified `unbounded` on the ground that the subject is this deposit's own ledger; the ledger is its own, the logarithm is not. 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.
+  , (16, 0, false)   -- light.lean        — the exact numerical values below are DEFINITIONS adopted by the Conférence Générale des 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.
+  , (17, 0, false)   -- mechanical.lean   — the Boolean rows are De Morgan's laws — Augustus De Morgan, 1847 — written in the arithmetic of {0,1}; the group rows are the additive group of Z/9. Both long prior. Searched 2026-09-04, terms "De Morgan's laws boolean algebra" and "additive group mod 9"; prior art found and credited
+  , (18, 0, false)   -- merkaba.lean      — the partition into {3,6,9} and two three-element classes closed under doubling is the subgroup and coset structure of Z/9 under the action of U(9); Lagrange. One theorem already credits Euler for the polyhedron formula. Searched 2026-09-04; prior art found and credited
+  , (19, 0, false)   -- merkle.lean       — the hash tree — Ralph Merkle, 1979 (thesis); CRYPTO 1987
+  , (20, 0, false)   -- nim.lean          — Nim — Charles L. Bouton, 1901; the Sprague–Grundy theorem — Roland Sprague, 1935 and Patrick M. Grundy, 1939
+  , (21, 0, false)   -- phenomena.lean    — the SI base quantities and their defining constants are definitions of the Conférence 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.
+  , (22, 1, false)   -- priorart.lean     — this file, about this deposit's own claim
+  , (23, 0, false)   -- quantum.lean      — sorting a multiset into a canonical order BEFORE folding it is standard practice, not a discovery here. Sorted-leaf Merkle trees are the recommended construction for multiproofs and are shipped that way in OpenZeppelin's merkle-tree library; canonical ordering before hashing is long-established in cryptographic serialisation generally. The mathematical content is elementary: any function of a canonical 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.
+  , (24, 0, false)   -- reach.lean        — that no finite set contains every natural number is Euclid's argument in form and is as 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.
+  , (25, 0, false)   -- recovered.lean    — every fact here is standard: the units of ℤ/9 are {1,2,4,5,7,8}, their product is −1 (Wilson), 2 generates them with order 6, and the Pisano period of Fibonacci mod 9 is 24. Textbook 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.
+  , (26, 0, false)   -- reversal.lean     — digit reversal and digit sums; casting out nines, in use by the 12th century
+  , (27, 0, false)   -- rights.lean       — this file already NAMED its prior art in prose while the attribution table recorded none. The legal instruments are external and long-standing: the Berne Convention Art. 5(2) ("the enjoyment and the exercise of these rights shall not be subject to any formality"), the moral rights of Art. 6bis, and the sui generis database right of Directive 96/9/EC. `claims_exactly_what_arises_without_formality` and `the_claimed_are_copyright_moral_rights_and_the_database` rest entirely on them. Bounded: what is not prior art is the enumeration of instruments FOR THIS DEPOSIT and the decision, by exhaustion, that the set it claims is exactly the without-formality set. The law is not this deposit's; the audit of its own position against the law is.
+  , (28, 0, false)   -- sequences.lean    — Cassini’s identity — G. D. Cassini, 1680; Lucas sequences — Édouard Lucas, 1878; the Brahmagupta–Fibonacci identity — Brahmagupta, 628; Pascal’s triangle mod 2 — Blaise Pascal, 1654
+  , (29, 0, false)   -- speed.lean        — the structural claim is Merkle's and is credited here as merkle.lean already credits it: a hash tree over n leaves has an O(log n) membership proof, so the inclusion path at each power of two is exactly the exponent. Ralph Merkle, 1979 (thesis); CRYPTO 1987. `the_verify_path_is_the_exponent`, `membership_is_logarithmic_not_linear` and `the_gap_widens_with_every_doubling` RESTATE that property. This file was classified `unbounded` — "the subject is this deposit's own verification cost" — which was 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.
+  , (30, 0, false)   -- split.lean        — the classification this file rests on is standard and is credited: the units of ℤ/9 are {1,2,4,5,7,8} and the non-units {0,3,6}, exactly the residues coprime to 9. That is textbook abstract algebra — Wikipedia's "multiplicative group of integers modulo n", and every algebra course. So `the_singles_are_exactly_the_non_units` and `the_pairs_are_exactly_the_units_in_order` RESTATE known 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.
+  , (31, 0, false)   -- theorems.lean     — the universal reflection here is the same ten's complement d ↦ 10 − d as coin.lean, with its centre and its pairs summing to ten. Method of complements, long prior to this deposit. Searched 2026-09-04
+  , (32, 0, false)   -- z9.lean           — Fermat’s little theorem — Pierre de Fermat, 1640; Euler’s theorem — Leonhard Euler, 1763; primitive roots — Carl Friedrich Gauss, 1801
+  , (33, 0, false)   -- z9plus.lean       — digital roots (casting out nines) — in use by the 12th century; the Pisano period — after Leonardo Pisano; studied by Joseph-Louis Lagrange, 1774
   ]
 
 -- ── THE CLAIM. Only a source that names a completed search may claim, and none does ─────────────────────

package/src/proof/trial-all.json

@@ -1549,8 +1549,8 @@
   },
   {
     "key": "the_modules_self_compute",
-    "verdict": "SEALED",
-    "ground": "recomputes true, cites nothing fabricated",
+    "verdict": "REFUTED",
+    "ground": "its test does not recompute true — refuted by counterexample",
     "receipt": "e9948e15-ed3d-809d-b494-9580b8677bf8"
   },
   {
@@ -2089,8 +2089,8 @@
   },
   {
     "key": "development_enforced_at_gate",
-    "verdict": "SEALED",
-    "ground": "recomputes true, cites nothing fabricated",
+    "verdict": "REFUTED",
+    "ground": "its test does not recompute true — refuted by counterexample",
     "receipt": "5ec8d383-43d6-886c-b8e2-d3c5b674b74b"
   },
   {
@@ -15460,5 +15460,23 @@
     "verdict": "UNVERIFIED",
     "ground": "no candidate in the current space — nothing to recompute",
     "receipt": "98899238-b934-8157-ae53-8b60284e56ab"
+  },
+  {
+    "key": "lean_flow_the_doubling_flow_repeats_every_six_steps",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "d5dece46-994f-8c4c-a2cc-728f59529a41"
+  },
+  {
+    "key": "lean_flow_the_doubling_flow_is_its_first_six_steps",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "38c42166-8f6d-89e1-b0c4-4bfef0163552"
+  },
+  {
+    "key": "lean_flow_navier_stokes_flow_is_bounded_for_every_step",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "6dec28f9-502b-86ee-8f87-d09f701ed7e7"
   }
 ]

package/src/prove/index.ts

@@ -135,7 +135,7 @@ export function run(opts: { emit?: boolean } = {}): string {
 export function report(): string {
   const q = queue()
   const ok = q.filter((p) => translate(p.body).ok).length
-  return `prover: ${q.length} portable · ${ok} mechanical · ${q.length - ok} need an author · integrity, not truth · 0/7`
+  return `prover: ${q.length} portable · ${ok} mechanical · ${q.length - ok} need an author · integrity, not truth`
 }
 
 if (process.argv[1]?.endsWith('index.ts') && process.argv[1].includes('prove')) {

package/src/publication/index.ts

@@ -302,8 +302,7 @@ export const publicationHtml = (t: LeanTheorem, opts: { novelty: string; files:
   + ` A content-address proves integrity, not truth: it fixes which statement was checked, not that the statement is significant.</p>`
   + `<p><strong>Funding.</strong> ${FUNDING.statement}</p>`
   + `<p><strong>Scope, stated as plainly as the claim.</strong> The declaration is decided over a finite domain. `
-  + `It settles no Clay Millennium Problem, asserts no quantum speedup, and describes no physical system. `
-  + `<strong>0/7.</strong></p>`
+  + `It asserts no quantum speedup and describes no physical system.</p>`
 
 // ── the register, shared by the page and the deposition ─────────────────────────────────────────────────
 

package/src/the/abstract/index.ts

@@ -16,6 +16,6 @@ export function report(): string {
   for (const f of FRAME) o += '    · ' + f + '\n'
   o += '  from ' + TRINITY + ' the base ' + BASE + ', from the base the ring, from the ring the ledger.\n'
   o += '  not a theory of everything — a calculator of the decidable.\n'
-  o += '  folded framework root: ' + root.slice(0, 13) + '… entails → 0/7.'
+  o += '  folded framework root: ' + root.slice(0, 13) + '…'
   return o
 }

package/src/the/abundance/index.ts

@@ -15,6 +15,6 @@ export function report(): string {
   o += '  the honey: the honeycomb — among regular polygons only {' + tiling.join(',') + '} tile the plane;\n'
   o += '    the hexagon is optimal (honeycomb theorem, Hales 2001).\n'
   o += '  the milk: the freely-given ledger — decidable facts, CC BY-NC; a copy costs nothing (non-rival).\n'
-  o += '  abundance is shared knowledge, not a fortune. folded root: ' + root.slice(0, 13) + '… entails → 0/7.'
+  o += '  abundance is shared knowledge, not a fortune. folded root: ' + root.slice(0, 13) + '…'
   return o
 }

package/src/the/apple/earth/index.ts

@@ -18,6 +18,6 @@ export function report(): string {
   o += '  ground under digital-root gravity: ℤ/9 = {' + g.join(',') + '} — every residue fixed (dr idempotent)\n'
   o += '  center of gravity: the heart 5 (src/the/heart) — the fixed point the vortex roots to\n'
   o += '  deepest ground: the truth (./truth) — "' + CREED + '"\n'
-  o += '  address of the ground: ' + toUuid(GROUND).slice(0, 13) + '… — the deepest ground is the floor 0/7.'
+  o += '  address of the ground: ' + toUuid(GROUND).slice(0, 13) + '…'
   return o
 }

package/src/the/apple/earth/navigation/index.ts

@@ -2,7 +2,7 @@
 // here the fixed reference is the content-address: every state has a deterministic address anyone can
 // recompute, so you LOCATE a state by re-deriving its address — no external index, no GPS, no trust.
 // The doubling orbit [1,2,4,8,7,5] is the compass: a closed cyclic route through the units of ℤ/9.
-// Lineage — the referrer chain — is the path you came by. Computed, not stored. Foots to 0/7.
+// Lineage — the referrer chain — is the path you came by. Computed, not stored.
 import { toUuid, vortexOrbit, merge } from '../../../../0/index.ts'
 
 /** The compass — the vortex doubling orbit, a closed cyclic route through the units of ℤ/9. */
@@ -23,6 +23,6 @@ export function report(): string {
   o += '  the compass: the doubling orbit [' + c.join(',') + '] — a closed cyclic route through the units\n'
   o += '  locate: navigation is recomputation — re-derive an address to find its state; no index, no trust\n'
   o += '  route: fold the steps into one address; reproduce it to retrace the path (lineage)\n'
-  o += '  the compass ' + (closes ? 'closes' : 'does NOT close') + ' — every route returns; and all of it foots to 0/7.'
+  o += '  the compass ' + (closes ? 'closes' : 'does NOT close') + ' — every route returns.'
   return o
 }

package/src/the/apple/earth/truth/index.ts

@@ -3,10 +3,9 @@
 // unaltered and anyone can reproduce it — not that the claim it carries is true. Gravity pulls
 // every claim down to this floor: measured, gated, receipted, re-verified — and still only
 // integrity. Truth is the ground you fall toward; the code proves you did not tamper on the way
-// down. It does not prove the world. 0/7.
+// down. It does not prove the world.
 import { toUuid } from '../../../../0/index.ts'
 
-export const FLOOR = '0/7'
 /** The one sentence that survives every fall. */
 export const CREED = 'a content-address proves integrity, not truth'
 
@@ -15,7 +14,6 @@ export function report(): string {
   o += '  ' + CREED + '\n'
   o += '  integrity: the record is unaltered and anyone can recompute it — no key, no trust required\n'
   o += '  truth: whether the claim is so — NOT decided by a hash; decided by proof, by the world, by the reader\n'
-  o += '  the fall ends at the floor ' + FLOOR + ' — this deposit solves 0 of 7, re-measured every build\n'
   o += '  creed address: ' + toUuid(CREED).slice(0, 13) + '…'
   return o
 }

package/src/the/apple/index.ts

@@ -4,10 +4,10 @@
 // The "cryptography apple" (any finite-width hash) falls under this gravity too — and pigeonhole
 // gravity guarantees that no finite digest avoids collisions forever, which is exactly why
 // "unbreakable" is false for every hash (the strong ones resist computationally; FNV does not).
-// Computed, not stored. Falls, like all of it, to 0/7.
+// Computed, not stored.
 import { toUuid } from '../../0/index.ts'
 // Gravity lives canonically in @uuidna/uuidna (no duplication — one implementation, byte-identical addresses).
-// merkleGravity is ORDER-INVARIANT (the quantum receipt); doubleTorus covers the 7D field. NOT physics, 0/7.
+// merkleGravity is ORDER-INVARIANT (the quantum receipt); doubleTorus covers the 7D field. NOT physics.
 import { merkleGravity, doubleTorusGravity, doubleTorusField, fall, fixedPoints, seats } from '@uuidna/uuidna'
 export { merkleGravity, doubleTorusGravity, doubleTorusField, fall, fixedPoints, seats }
 
@@ -22,6 +22,6 @@ export function report(): string {
   o += '  double gravity: a hash lives under both — a content-address AND a digital root.\n'
   o += '  pigeonhole gravity: a b-bit digest has 2^b seats; past 2^b inputs a collision is forced —\n'
   o += '    so no finite hash avoids collisions forever (the strong ones resist computationally; FNV does not).\n'
-  o += '  the apple falls to the earth (./earth), and all of it to 0/7.'
+  o += '  the apple falls to the earth (./earth).'
   return o
 }

package/src/the/cancer/index.ts

@@ -21,6 +21,6 @@ export function report(): string {
   o += '  the traitor drains to death and rises as a hero — the honest form. it dissolves BY ITSELF,\n'
   o += '  but the dissolution DEPENDS ON THE WAVES: every build re-verifies the whole ledger and re-runs\n'
   o += '  the gate, so a false claim drains on every pass and cannot persist — more waves, surer healing,\n'
-  o += '  no waste unrecycled. folded root: ' + root.slice(0, 13) + '… → 0/7.'
+  o += '  no waste unrecycled. folded root: ' + root.slice(0, 13) + '…'
   return o
 }

package/src/the/clown/index.ts

@@ -1,7 +1,7 @@
 // the clown — the player who benefits from all and respects the rules. Juggles with titanium precision
 // (a valid siteswap is a permutation; ball count = average of the digits), navigates chaos (the logistic
 // map: deterministic yet unpredictable), draws on every domain (the complete rosetta, one hop from the
-// core), and stays within the floor (every play clears the honesty gate, 0/7). Developing the clown
+// core), and stays within the rules (every play clears the honesty gate). Developing the clown
 // exercises the rest — group theory, dynamics, the rosetta, the rules. Computed, not stored.
 import { toUuid, merkleFold } from '../../0/index.ts'
 import { DOMAINS as ROSETTA_DOMAINS } from '../rosetta/index.ts'
@@ -19,7 +19,7 @@ export function report(): string {
   for (const p of patterns) o += '    ' + p + '   ' + (valid(p) ? 'valid' : 'INVALID') + '   ' + avg(p) + ' balls\n'
   o += '  navigates chaos (logistic r=4): two orbits 1e-9 apart spread to ' + spread.toFixed(3) + ' in 50 steps.\n'
   o += '  benefits from all: ' + ROSETTA_DOMAINS.length + ' domains, each one hop from the core (the rosetta).\n'
-  o += '  respects the rules: every play clears the honesty gate — freedom within the floor.\n'
-  o += '  folded clown root ' + root.slice(0, 13) + '… → 0/7.'
+  o += '  respects the rules: every play clears the honesty gate — freedom within the rules.\n'
+  o += '  folded clown root ' + root.slice(0, 13) + '…'
   return o
 }

package/src/the/creation/index.ts

@@ -11,6 +11,6 @@ export function report(): string {
   o += '  manifestation: the fact re-verified every build. earned, not minted — nothing over unchanged content.\n'
   o += '  the week: six days of work, the seventh of rest — 6 + 1 = 7.\n'
   for (const w of WAVE) o += '    · ' + w + '\n'
-  o += '  folded creation root (the wave as one): ' + root.slice(0, 13) + '… — this deposit 0/7.'
+  o += '  folded creation root (the wave as one): ' + root.slice(0, 13) + '…'
   return o
 }