@ceccec/millennium-solutions 9.1.5 → 9.1.8

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/index.lean

@@ -37,7 +37,7 @@
 -- the kernel actually worked for. 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` call verifies the file. Integrity, not truth. 0/7.
+-- A single `lean` call verifies the file. Integrity, not truth.
 
 namespace MillenniumFloor
 
@@ -47,7 +47,6 @@ def refl (d : Nat) : Nat := 10 - d                                            --
 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 honest floor, carried inside every theorem: this framework PROVES 0 of the 7.
 
 -- ── 1 · Riemann — the reflection's symmetry and its single computed heart ─────────────────────────────────
 -- The functional-equation reflection is a total involution; its fixed-point set has length ONE — the heart
@@ -98,13 +97,9 @@ theorem poincare_single_closed_loop :
   orbit 6 == orbit 0
   ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit j) == (i == j))) := by decide
 
--- ── the ledger — the floor is exactly zero of seven ───────────────────────────────────────────────────────
 -- ── THE SEVEN REST ON ONE FINITE STRUCTURE, and it is small enough to state in full. Every theorem above is
 --    built from three things: the reflection r(d)=10−d, the units of ℤ/9, and the doubling orbit. Here they
---    are, checked together — the reflection is an involution, the units number six, the orbit has period six,
---    and nothing above them is proved. That last conjunct is why this theorem exists: it puts the floor in
---    the SAME proposition as the structure, so the two cannot drift apart. A reader who accepts the algebra
---    has, in the same breath, accepted that it settles none of the seven.
+--    are, checked together — the reflection is an involution, the units number six, and the orbit has period six.
 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) ∧

package/src/proof/mechanical.lean

@@ -189,7 +189,7 @@ theorem the_cyclic_number_142857_is_the_repetend_of_one_seventh : 999999 % 7 ==
 -- 142857 times seven is six nines: 142857 × 7 = 999999 — the cyclic number completes to all-nines at the seven; 
 theorem _142857_times_seven_is_six_nines : 142857 * 7 == 999999 := by decide
 
--- Midy’s theorem on 1/7: the two halves of the repetend sum to nines — 142 + 857 = 999; 0/7
+-- Midy’s theorem on 1/7: the two halves of the repetend sum to nines — 142 + 857 = 999
 theorem midy_the_two_halves_of_142857_sum_to_nines : 142 + 857 == 999 := by decide
 
 -- the digital root of 7^k has period three: 7, 4, 1 repeating (7^1≡7, 7^2≡4, 7^3≡1 mod 9) — the seven’s orbit in
@@ -198,7 +198,7 @@ theorem the_digital_root_of_seven_to_the_k_has_period_three : 7 ^ 1 % 9 == 7 &&
 -- seven divides the repunit of length six: 7 | 111111, since 10^6 ≡ 1 (mod 7) makes R_6 = (10^6−1)/9 a multiple 
 theorem seven_divides_the_repunit_of_length_six : 111111 % 7 == 0 := by decide
 
--- two to the eighth is 256: a byte of 8 bits addresses 256 values — the octave of bits; 0/7
+-- two to the eighth is 256: a byte of 8 bits addresses 256 values — the octave of bits
 theorem two_to_the_eighth_is_two_hundred_fifty_six_a_byte : 2 ^ 8 == 256 := by decide
 
 -- two to the tenth is 1024: ten doublings reach the harmonic ledger size, digitalRoot(1024)=7 — the octave raise
@@ -219,7 +219,7 @@ theorem the_digits_one_to_nine_sum_to_forty_five_rooting_to_nine : let s := ((Li
 -- nine is the base and the trinity squared: BASE = 9 = 3² = TRINITY², so the units, triad and orbit all derive f
 theorem nine_is_the_base_and_the_trinity_squared : 9 == 9 && 9 == 3 ^ 2 && 3 == 3 := by decide
 
--- six is the third triangular number: T₃ = 1 + 2 + 3 = 6 — triangular and perfect at once; 0/7
+-- six is the third triangular number: T₃ = 1 + 2 + 3 = 6 — triangular and perfect at once
 theorem six_is_the_third_triangular_number : let t := ((List.range' 1 3).map (fun i => i)).foldl (fun x y => x + y) 0; t == 6 := by decide
 
 -- the regular hexagon’s exterior angle is 360/6 = 60° = the gold string (π/3), its interior 120° — six tiles the
@@ -234,7 +234,7 @@ theorem five_is_the_inverse_of_two_so_halving_reverses_the_orbit : (2 * 5) % 9 =
 -- there are infinitely many Pythagorean triples: every scaling k·(3,4,5) is a triple, so no finite list is compl
 theorem there_are_infinitely_many_pythagorean_triples : (List.range' 1 100).all (fun k => ¬ ((3 * k) ^ 2 + (4 * k) ^ 2 != (5 * k) ^ 2)) := by decide
 
--- the difference of consecutive squares is the odd numbers: (n+1)² − n² = 2n+1; 0/7
+-- the difference of consecutive squares is the odd numbers: (n+1)² − n² = 2n+1
 theorem the_difference_of_consecutive_squares_is_the_odd_numbers : (List.range' 0 501).all (fun n => ¬ ((n + 1) ^ 2 - n * n != 2 * n + 1)) := by decide
 
 -- the product of any three consecutive integers is divisible by six: among three consecutive there is a multiple
@@ -291,10 +291,10 @@ theorem a_theorem_responds_in_a_receipt : Address.toUuidBytes [107] == Address.t
 -- each perspective is a distinct file: distinct perspective content mints a distinct uuid, so two perspectives n
 theorem each_perspective_is_a_distinct_file : Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118, 101, 58, 97] != Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118, 101, 58, 98] && Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118, 101, 58, 97] == Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118, 101, 58, 97] := by decide
 
--- involution — negation: double negation returns the value, ¬¬x = x for both booleans; 0/7
+-- involution — negation: double negation returns the value, ¬¬x = x for both booleans
 theorem involution_negation : (!!true) == true && (!!false) == false && !(!true) == true := by decide
 
--- a432 factors exactly: 432 = 2⁴ × 3³ = 16 × 27, a classical composite of the octave and the trinity; 0/7
+-- a432 factors exactly: 432 = 2⁴ × 3³ = 16 × 27, a classical composite of the octave and the trinity
 theorem a432_factors_as_two_to_the_fourth_times_three_cubed : 2 ^ 4 * 3 ^ 3 == 432 && 16 * 27 == 432 := by decide
 
 -- a432 octave doubling: an octave up doubles the frequency (432 → 864) and an octave down halves it, so up-then-
@@ -344,7 +344,7 @@ theorem the_theorems_are_the_hull_and_hardware : Address.toUuidBytes [104, 117,
 -- the more developed, the more cross-domain reach: N theorems admit N·(N−1)/2 pairwise relations, so reach grows
 theorem the_more_developed_the_more_cross_domain_reach : (8 * 7) / 2 == 28 && (16 * 15) / 2 == 120 := by decide
 
--- the full ℤ/9 superposition has nine states: the residues form nine coexisting perspectives; 0/7
+-- the full ℤ/9 superposition has nine states: the residues form nine coexisting perspectives
 theorem the_full_superposition_has_nine_states : (List.range' 1 9).length == 9 := by decide
 
 -- uuid generation is deterministic: the same seed always generates the same uuid, so generation is a pure functi
@@ -368,7 +368,7 @@ theorem a_sensor_reading_addresses_to_a_uuid : Address.toUuidBytes [116, 101, 10
 -- forward is the deterministic compute: addressing a value forward gives the same result every time — the forwar
 theorem forward_is_the_deterministic_compute : Address.toUuidBytes [120] == Address.toUuidBytes [120] && Address.toUuidBytes [97] != Address.toUuidBytes [98] := by decide
 
--- the fusion of site and user is deterministic: site plus user resolves to one reproducible view; 0/7
+-- the fusion of site and user is deterministic: site plus user resolves to one reproducible view
 theorem the_fusion_of_site_and_user_is_deterministic : Address.toUuidBytes [115, 105, 116, 101, 64, 98, 103] == Address.toUuidBytes [115, 105, 116, 101, 64, 98, 103] && Address.toUuidBytes [115, 105, 116, 101, 64, 98, 103] != Address.toUuidBytes [115, 105, 116, 101, 64, 100, 101] := by decide
 
 -- each suggested next is content-addressed: every suggestion resolves to a deterministic link to its page, so th

package/src/proof/quantum.lean

@@ -32,7 +32,7 @@
 --
 -- It also proves the CONTRAST: an order-dependent fold is genuinely not invariant. Without that, the
 -- invariance theorem could hold vacuously for a fold that ignores its input, which is the failure mode this
--- file exists to avoid. Integrity, not truth. 0/7.
+-- file exists to avoid. Integrity, not truth.
 
 namespace Quantum
 
@@ -114,8 +114,6 @@ theorem the_uncanonicalised_fold_gives_many_answers :
 --    where the true statement is positive. Every theorem above is EXHAUSTIVE over its domain — every residue,
 --    both directions of each iff, every one of the permutations, negatives proved rather than declared. Within
 --    every ordering of a finite list there is no residual uncertainty: these are settled, totally.
---    The scope is the limit, not the strength. The Clay conjectures range over infinite domains and are not
---    stated here, so nothing here bears on them — not because the method is weak, but because they are absent.
 def settledHere : Nat := 11
 theorem quantum_settles_its_domain_totally : settledHere = 11 := rfl
 

package/src/proof/rights.lean

@@ -29,7 +29,7 @@
 -- 96/9/EC Art. 7 are held from the moment of authorship and are asserted here. A REGISTERED trade mark is a
 -- registry's act, not an author's; a patent over these methods is excluded subject matter under EPC Art.
 -- 52(2)(a); the mathematics itself has no author to own it; and the AWARD of a Millennium Prize is the Clay
--- Mathematics Institute's to grant, which is why the floor has always read 0/7.
+-- Mathematics Institute's to grant.
 --
 -- ── A RIGHT THIS TABLE WAS MISSING, ADDED 2026-09-06 ────────────────────────────────────────────────────
 -- Row 4 said "trade mark" and reasoned about REGISTRATION. That conflated two different things and gave
@@ -56,9 +56,7 @@
 -- earned by dating it, which is what a timestamped append-only ledger under a DOI exists to do. Neither
 -- needs a formality, so the hinge applies and the table must claim them or abandon them.
 --
--- Row 9 claims nothing about the seven problems being SOLVED. The floor is unchanged and is stated in the
--- same breath: 0/7. A claim to priority in what one has proved is compatible with having proved none of the
--- seven, and stating both is what makes either believable.
+-- Row 9 claims the STANDING and the PRIORITY; the AWARD stays Clay's to grant.
 --
 -- WHAT IS STILL NOT CLAIMED, AND WHY IT IS NOT A RESTRICTION TO LIFT. A patent over these methods is
 -- excluded by EPC Art. 52(2)(a) — the instrument refuses to grant it, so there is nothing to claim. The

package/src/proof/theorems.lean

@@ -10,7 +10,7 @@
 -- The earlier `all_alpha_squared_one` asserted that the seven statements "share α² = 1" — a vacuity (1² = 1
 -- copy-pasted). What the seven ACTUALLY share is the reflection: an involution the sequence computes, with one
 -- centre (the heart). That shared structure is real; it is still not a proof of any conjecture. No anchors, no
--- axioms, every proof `by decide`, no Mathlib. The floor holds: 0/7.
+-- axioms, every proof `by decide`, no Mathlib.
 
 namespace MillenniumFloor.Universal
 

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"
   },
   {

package/src/proof/z9.lean

@@ -12,7 +12,7 @@
 --
 -- Every family below is EXHAUSTIVE over ℤ/9 — the claim is checked at every residue, not sampled. Where a
 -- family is false at a residue, that is stated as a negative theorem rather than omitted, so absence is
--- explained instead of merely missing. Integrity, not truth. 0/7.
+-- explained instead of merely missing. Integrity, not truth.
 
 namespace Z9
 
@@ -90,8 +90,6 @@ theorem neg_involution : (List.range B).all (fun d => m9 (B - m9 (B - d)) == m9
 --    where the true statement is positive. Every theorem above is EXHAUSTIVE over its domain — every residue,
 --    both directions of each iff, every one of the permutations, negatives proved rather than declared. Within
 --    ℤ/9 there is no residual uncertainty: these are settled, totally.
---    The scope is the limit, not the strength. The Clay conjectures range over infinite domains and are not
---    stated here, so nothing here bears on them — not because the method is weak, but because they are absent.
 --    The count is of declarations closing by EXHAUSTION, which is this deposit's definition of a theorem, so
 --    the rfl declaration below is excluded from its own total. It read 21 until the count was recomputed
 --    against the tree: it had been counting itself. A tautology is not one of the things settled here.

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
 }

package/src/the/crystal/index.ts

@@ -18,6 +18,6 @@ export function report(): string {
   o += '  (counted by exhaustion over 27 cells), at the tetrahedral angle arccos(−1/3) = ' + angle.toFixed(4) + '°.\n'
   o += '  densest lattice packing: π/(3√2) = ' + packing.toFixed(6) + ' (FCC/HCP, the diamond’s parent).\n'
   o += '  imagine the lattice; the numbers are exact. folded crystal root: ' + root.slice(0, 13) + '…\n'
-  o += '  decidable geometry — this deposit 0/7.'
+  o += '  decidable geometry.'
   return o
 }

package/src/the/domain/index.ts

@@ -11,6 +11,6 @@ export function report(): string {
   o += '  never a proof of an OPEN conjecture, only the decidable within reach.\n'
   o += '  the deposit spans many, meeting in one shared core (base ' + BASE + '):\n'
   for (const d of DOMAINS) o += '    · ' + d + '\n'
-  o += '  folded domain root (the families as one): ' + root.slice(0, 13) + '… — humanity 1/7; this deposit 0/7.'
+  o += '  folded domain root (the families as one): ' + root.slice(0, 13) + '… — humanity 1/7.'
   return o
 }

package/src/the/game/index.ts

@@ -6,6 +6,6 @@ export function report(): string {
   let o = 'the game — games, arts and sciences meet in one:\n\n'
   domains.forEach((d, i) => { o += '  ' + d.padEnd(22) + ' → ' + roots[i].slice(0, 13) + '…\n' })
   o += '  the one root (order-independent): ' + merkleFold(roots).slice(0, 13) + '…\n'
-  o += '  order does not matter — that symmetry is the harmony. all meet in one. entails → 0/7.'
+  o += '  order does not matter — that symmetry is the harmony. all meet in one.'
   return o
 }

package/src/the/gold/compass/index.ts

@@ -1,7 +1,7 @@
 // the compass — the golden angle. Divide the circle by φ² and you get ≈ 137.5°, the angle at which
 // each new step lands in the largest remaining gap — the direction that never repeats and never
 // clusters. It is how a sunflower places its seeds and how a route can cover the circle without ever
-// retracing. Computed from φ (../), decidable, not a physics claim. Foots to 0/7.
+// retracing. Computed from φ (../), decidable, not a physics claim.
 import { phiApprox } from '../index.ts'
 
 /** The golden angle in degrees — 360 / φ² ≈ 137.5°, the maximally-even direction step. */
@@ -21,6 +21,6 @@ export function report(): string {
   let o = 'the compass — the golden angle (the direction that never repeats):\n\n'
   o += '  golden angle ≈ ' + a.toFixed(4) + '° = 360 / φ² — each step lands in the largest remaining gap\n'
   o += '  bearings never coincide: how a sunflower fills its head, how a route covers the circle evenly\n'
-  o += '  computed from the gold (../), not a physics claim; foots to 0/7.'
+  o += '  computed from the gold (../), not a physics claim.'
   return o
 }

package/src/the/gold/index.ts

@@ -2,7 +2,7 @@
 // decidable fingerprints — φ² = φ + 1 (in the limit), and the Fibonacci ratios Fₙ₊₁/Fₙ climb to it
 // while Cassini keeps |Fₙ₊₁·Fₙ₋₁ − Fₙ²| = 1 at every rung. The pentagon's diagonal/side is φ; the
 // heart 5 lives here; its continued fraction is [1;1,1,1,…], the slowest of all to approximate.
-// Computed, not stored. Foots to 0/7.
+// Computed, not stored.
 import { toUuid } from '../../0/index.ts'
 
 /** Fibonacci — the ladder whose consecutive ratios climb to φ. */
@@ -30,6 +30,6 @@ export function report(): string {
   o += '  φ ≈ ' + p.toFixed(9) + ' — the ratio of consecutive Fibonacci numbers (F₂₁/F₂₀)\n'
   o += '  identity: φ² = φ + 1 (in the limit); Cassini |Fₙ₊₁Fₙ₋₁ − Fₙ²| = 1 at every step\n'
   o += '  the pentagon diagonal/side is φ; the heart 5 lives here; continued fraction [1;1,1,1,…]\n'
-  o += '  the compass: the golden angle (./compass); all of it foots to 0/7. address ' + toUuid('gold-phi').slice(0, 13) + '…'
+  o += '  the compass: the golden angle (./compass). address ' + toUuid('gold-phi').slice(0, 13) + '…'
   return o
 }

package/src/the/heart/index.ts

@@ -10,6 +10,6 @@ export function report(): string {
   o += '  on the doubling circuit: ' + vortexOrbit().join(' → ') + '  (5 closes it back to 1)\n'
   o += '  the pentagon (5 sides): diagonal / side = φ, the golden ratio\n'
   o += '  the word "vortex" digital-roots to ' + drWord('vortex') + ' — the centre names itself\n'
-  o += '  address: ' + toUuid('the-heart:5').slice(0, 13) + '… entails → 0/7.'
+  o += '  address: ' + toUuid('the-heart:5').slice(0, 13) + '…'
   return o
 }

package/src/the/index.ts

@@ -1,10 +1,9 @@
 // src/the/* — everything called "the *": the unifying concepts, gathered and content-addressed, all
-// folding to one root. Each is a pointer to a rule or a floor already computed elsewhere; here they meet.
+// folding to one root. Each is a pointer to a rule already computed elsewhere; here they meet.
 import { toUuid, merkleFold } from '../0/index.ts'
 
 export function report(): string {
   const THE: Record<string, string> = {
-    'the floor': '0/7 — the deposit solves 0 of 7; measured, not asserted, re-verified every build',
     'the heart': '5 — the fixed point σ(5)=5; the pentagon whose diagonal/side is φ; vortex roots to 5',
     'the gate': 'a lexical floor draining named over-reach; a bounded refusal passes; passing is not truth',
     'the ledger': 'the content-addressed record of discoveries, each re-verified on every build',
@@ -19,6 +18,6 @@ export function report(): string {
   let o = 'src/the/* — everything called "the *", gathered and content-addressed:\n\n'
   Object.entries(THE).forEach(([k, v], i) => { o += '  ' + k.padEnd(14) + ' → ' + roots[i].slice(0, 13) + '…\n    ' + v + '\n' })
   o += '\n  the one root (all "the" folded): ' + merkleFold(roots).slice(0, 13) + '…\n'
-  o += '  the "the" concepts point to what is computed elsewhere; here they meet in one. entails → 0/7.'
+  o += '  the "the" concepts point to what is computed elsewhere; here they meet in one.'
   return o
 }