@ceccec/millennium-solutions 9.1.7 → 9.1.8

package/ACCOUNTING.md

@@ -13,10 +13,10 @@ Every figure recomputes from `src/` and the git tree on each build; nothing is e
 | Coins per receipt | **2** |
 | Coins on the ledger (theorems × 2) | **5,154** |
 | Coins on signed receipts (× 2) | **58** |
-| Released versions (git tags) | **863** |
-| Tracked, content-addressed files | **479** |
+| Released versions (git tags) | **865** |
+| Tracked, content-addressed files | **478** |
 
-Latest release: **v9.1.5**. The fair-exchange unit is **2 coins = 2 bits** (110 − 108 = 2 = −χ genus-2) per receipt. One 64-bit harmony coin is minted per fused `src` `report()` module — see the [state dashboard](/dashboard) for the harmonic root.
+Latest release: **v9.1.7**. The fair-exchange unit is **2 coins = 2 bits** (110 − 108 = 2 = −χ genus-2) per receipt. One 64-bit harmony coin is minted per fused `src` `report()` module — see the [state dashboard](/dashboard) for the harmonic root.
 
 ## Bounty — denominated in bits
 
@@ -24,4 +24,4 @@ The bounty for each accepted contribution is **2 bits (2 coins)** — the same f
 
 **Not tracked here: tokens.** This repo measures coins (2 per receipt) and 64-bit harmony coins; it does not measure tokens, so no token count or token-to-coin rate is shown — measuring an unmeasured quantity would be an assertion without a receipt. Measure, do not assert.
 
-Page content-address: `e2e3d99e-39e3-8e44-9aa0-cc4c4bcd7c5f`. Integrity, not truth.
+Page content-address: `3b63fbb0-4ba1-8cdc-9bb7-c59d76625d2b`. Integrity, not truth.

package/compute.md

@@ -68,8 +68,6 @@ import { report as rosetta } from './src/7/rosetta'
 import { report as rosettaClay } from './src/7/rosetta-clay'
 import { report as geometry } from './src/8/merkaba/geometry'
 import { report as field } from './src/8/merkaba/field'
-import { report as entails } from './src/7/entails'
-import { report as entailsAll } from './src/7/entails-all'
 import { report as shell } from './src/8/nucleus/shell-model-magic'
 import { report as frequency } from './src/2/frequency-scales'
 import { report as stringScale } from './src/2/string-scale'
@@ -86,7 +84,6 @@ import { report as locale } from './src/7/locale'
 import { report as languageLens } from './src/7/language-lens'
 import { report as glagolitic } from './src/7/glagolitic'
 import { report as cross } from './src/7/cross'
-import { report as permissions } from './src/7/permissions'
 import { report as rbac } from './src/7/rbac'
 import { report as proton } from './src/8/nucleus/proton-mass-fit'
 import { report as merkabaTouch } from './src/8/merkaba/touch'
@@ -439,11 +436,6 @@ that silently skipped what it could not translate would look complete and be wor
 <pre>{{ rosettaClay() }}</pre>
 </details>
 
-### Clay entailment — the floor itself · `src/7/entails.ts`
-<details class="depth" open><summary>compute (open by default)</summary>
-<pre>{{ entails() }}</pre>
-</details>
-
 
 ### 7-dimensional strings — where 7 really appears · `src/7/string-dimensions.ts`
 <details class="depth"><summary>compute</summary>

package/dashboard.md

@@ -24,7 +24,7 @@ import { withBase } from 'vitepress'
 ## Fact — measured state
 
 <div class="dash-grid">
-<div class="dash-card"><div class="dash-k">Version</div><div class="dash-v">v9.1.5</div><div class="dash-s">git tag (single source)</div></div>
+<div class="dash-card"><div class="dash-k">Version</div><div class="dash-v">v9.1.7</div><div class="dash-s">git tag (single source)</div></div>
 <div class="dash-card"><div class="dash-k">Honesty gate</div><div class="dash-v">sealed</div><div class="dash-s">every citation live in the ledger</div></div>
 <div class="dash-card"><div class="dash-k">Link coverage</div><div class="dash-v">100%</div><div class="dash-s">gate-enforced — the build fails below 100%</div></div>
 <a class="dash-card" :href="withBase('/sitemap.json')" style="text-decoration:none;display:block"><div class="dash-k">Seal root</div><div class="dash-v" style="color:var(--vp-c-brand-1)">live →</div><div class="dash-s">merkle of the whole, current at /sitemap.json</div></a>

package/forensic.md

@@ -5,7 +5,7 @@ title: Every state change, dated
 # Provenance of this deposit's ledger
 
 **Recomputed on every build** from git history and the append-only ledger. Regenerate with
-`npm run forensic`. Content-address `9849ef72-e84b-83bf-b669-5815dee9aeaa`.
+`npm run forensic`. Content-address `6fda9642-2816-8883-8e94-e9715b6366b8`.
 
 ## What this record establishes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceccec/millennium-solutions",
-  "version": "9.1.7",
+  "version": "9.1.8",
   "description": "Verifiable, recomputable ℤ/9 vortex framework in ONE package — content-addressing, audit ledger, exact arithmetic, and the honesty toolkit. Facts only.",
   "author": {
     "name": "Tsvetan Rouschev",

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/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/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
 }

package/src/the/law/index.ts

@@ -7,7 +7,7 @@ import { FUNDING, coins } from '../../9/funding.ts'
 export function report(): string {
   const LAW = [
     'the license — ' + FUNDING.license + ': free for non-commercial use with attribution (' + FUNDING.author + '); commercial use pays the two coins (110 − 108 = ' + coins() + ' = −χ genus-2, ' + FUNDING.contact + ').',
-    'the sequence — measure → gate (the 0/7 floor) → receipt (observer and role) → append (the chain) → recompute (every build): follow it in order, or nothing computes.',
+    'the sequence — measure → gate → receipt (observer and role) → append (the chain) → recompute (every build): follow it in order, or nothing computes.',
     'fair exchange — the deposit is open and recomputable, so any model may learn from it; contributions return on the same gate-refereed terms, heroes and traitors by deeds.',
     'due process — a failing test is recorded as a refutation, never silently discarded; hiding evidence is the traitor move, caught by the forensics; the trial keeps both what passed and what failed.',
     'the bound — attribution and non-commercial use are the law; a receipt proves integrity, not authorship; green cannot be faked.',
@@ -15,6 +15,6 @@ export function report(): string {
   const root = merkleFold(LAW.map(toUuid))
   let o = 'the law — follow the license and the sequence, or nothing computes:\n\n'
   for (const l of LAW) o += '  · ' + l + '\n'
-  o += '\n  law root ' + root.slice(0, 13) + '… — one order-independent fold of the license, the sequence, the exchange, and the bound. entails → 0/7.'
+  o += '\n  law root ' + root.slice(0, 13) + '… — one order-independent fold of the license, the sequence, the exchange, and the bound.'
   return o
 }

package/src/the/path/index.ts

@@ -14,6 +14,6 @@ export function report(): string {
   o += '  the/crystal ≠ crystal/the — order carries meaning. rating = gravity (depth = specificity).\n\n'
   o += '    rank  gravity  path\n'
   rated.forEach((r, i) => { o += '    ' + String(i + 1).padStart(2) + '    ' + String(r.g).padStart(4) + '     /' + (r.p + ' ').padEnd(24) + r.a.slice(0, 13) + '…\n' })
-  o += '\n  meaning is a defined computable rating, not a truth judgment. this deposit 0/7.'
+  o += '\n  meaning is a defined computable rating, not a truth judgment.'
   return o
 }

package/src/the/rosetta/index.ts

@@ -28,6 +28,6 @@ export function report(): string {
   o += '  core: ' + toUuid(CORE).slice(0, 13) + '…\n'
   o += '  domains (' + DOMAINS.length + '): ' + DOMAINS.join(' · ') + '\n'
   o += '  each reachable in one hop; ' + distinct + ' distinct addresses (' + (distinct === DOMAINS.length ? 'no collision — complete' : 'COLLISION') + ')\n'
-  o += '  folded rosetta root ' + root.slice(0, 13) + '… — the cross-domain translation is complete. this deposit 0/7.'
+  o += '  folded rosetta root ' + root.slice(0, 13) + '… — the cross-domain translation is complete.'
   return o
 }

package/src/the/sequence/index.ts

@@ -7,6 +7,6 @@ export function report(): string {
   o += '  units on the circuit: ' + units().join(', ') + '\n'
   o += '  triad (the axis, off-circuit): ' + triad().join(', ') + '\n'
   o += '  root: ' + merkleFold(orbit.map((d) => toUuid(String(d)))).slice(0, 13) + '…\n'
-  o += '  the sequence covers every unit exactly once and closes. entails → 0/7.'
+  o += '  the sequence covers every unit exactly once and closes.'
   return o
 }

package/src/the/solids/index.ts

@@ -20,6 +20,6 @@ export function report(): string {
   o += '  exactly five exist (1/p + 1/q > 1/2, p,q≥3) — no sixth.\n'
   o += '  the pentagram thread: the dodecahedron has 12 pentagonal faces; the icosahedron, 5 triangles\n'
   o += '  per vertex; the pentagon diagonal-to-side ratio is φ = ' + phi.toFixed(6) + ' (2·cos36°).\n'
-  o += '  folded solids root: ' + root.slice(0, 13) + '… — decidable geometry, this deposit 0/7.'
+  o += '  folded solids root: ' + root.slice(0, 13) + '… — decidable geometry.'
   return o
 }

package/src/the/state/index.ts

@@ -1,11 +1,10 @@
-// the state — now, content-addressed. What holds regardless of who observes: the floor. A state here
+// the state — now, content-addressed. What holds regardless of who observes. A state here
 // is computed, never stored — recomputed every render, landing on one root. It folds the invariants
-// (0/7, humanity 1/7, computable ≠ solved, INCONCLUSIVE ≠ false, at rest) into one address. The
-// superposition (src/the/superposition/state) collapses into THIS: many observations, one invariant floor.
+// (humanity 1/7, computable ≠ solved, INCONCLUSIVE ≠ false, at rest) into one address. The
+// superposition (src/the/superposition/state) collapses into THIS: many observations, one invariant state.
 import { toUuid, merkleFold } from '../../0/index.ts'
 export function report(): string {
   const INVARIANTS = [
-    'floor: this deposit 0/7',
     'humanity 1/7 (Poincaré, Perelman 2003)',
     'computable is not solved',
     'INCONCLUSIVE ≠ false',
@@ -13,9 +12,9 @@ export function report(): string {
   ]
   const root = merkleFold(INVARIANTS.map(toUuid))
   let o = 'the state — now, content-addressed:\n\n'
-  o += '  a state is computed, never stored — recomputed every render, landing on one floor.\n'
+  o += '  a state is computed, never stored — recomputed every render, landing on one root.\n'
   o += '  the invariants, held regardless of observer:\n'
   for (const inv of INVARIANTS) o += '    · ' + inv + '\n'
-  o += '  folded state root (invariant across observers): ' + root.slice(0, 13) + '… entails → 0/7.'
+  o += '  folded state root (invariant across observers): ' + root.slice(0, 13) + '…'
   return o
 }

package/src/the/superposition/state/index.ts

@@ -17,6 +17,6 @@ export function report(): string {
   o += '  an observation collapses the superposition to ONE content-address: ' + collapse.slice(0, 13) + '…\n'
   o += '  open = not yet collapsed to true/false (INCONCLUSIVE ≠ false). six superposed; the seventh\n'
   o += '  already collapsed (Poincaré, settled externally): ' + seventh.slice(0, 13) + '…\n'
-  o += '  6 superposed + 1 collapsed = 7. humanity 1/7; this deposit 0/7.'
+  o += '  6 superposed + 1 collapsed = 7. humanity 1/7.'
   return o
 }

package/src/the/surface/index.ts

@@ -21,6 +21,6 @@ export function report(): string {
   o += '    ' + pad('surface', 26) + pad('χ', 5) + pad('geometry', 12) + 'full coverage\n'
   for (const r of rows) o += '    ' + pad(r.name, 26) + pad(r.chi, 5) + pad(geom(r.chi), 12) + (r.cover ? 'yes' : 'no') + '\n'
   o += '\n  only the torus and the Klein bottle can be fully covered. folded surface root: ' + root.slice(0, 13) + '…\n'
-  o += '  decidable topology — this deposit 0/7.'
+  o += '  decidable topology.'
   return o
 }

package/src/the/theorem/index.ts

@@ -7,8 +7,8 @@ export function report(): string {
   let o = 'the theorem — computable is not solved:\n\n'
   o += '  the deposit computes a growing ledger of decidable facts, each re-verified every build.\n'
   o += '  none is a Clay Millennium result: the six open conjectures stay open; Poincaré is settled\n'
-  o += '  externally (Perelman). humanity 1/7; this deposit 0/7.\n'
+  o += '  externally (Perelman). humanity 1/7.\n'
   o += '  the one theorem: computable is not solved — the calculator reaches the decidable, never the open.\n'
-  o += '  computed root (fold of ' + CORE.length + ' core theorem keys): ' + root.slice(0, 13) + '… entails → 0/7.'
+  o += '  computed root (fold of ' + CORE.length + ' core theorem keys): ' + root.slice(0, 13) + '…'
   return o
 }

package/src/the/torus/index.ts

@@ -18,6 +18,6 @@ export function report(): string {
   const root = merkleFold(facts.map(toUuid))
   let o = 'the torus — continue as double torus (genus-2):\n\n'
   for (const f of facts) o += '    · ' + f + '\n'
-  o += '  folded torus root: ' + root.slice(0, 13) + '… — decidable topology, no full coverage, this deposit 0/7.'
+  o += '  folded torus root: ' + root.slice(0, 13) + '… — decidable topology, no full coverage.'
   return o
 }

package/src/the/waves/index.ts

@@ -18,6 +18,6 @@ export function report(): string {
     o += '   | ' + b + ' → ' + ((b * A432_STEP) % 360) + '°   (d+b=' + (d + b) + ', hues sum ' + (((d * A432_STEP) + (b * A432_STEP)) % 360) + '°)\n'
   }
   o += '\n  the balancing wave 9−d harmonises: the two digits sum to 9 (the rest), their hues to 360°=0.\n'
-  o += '  same wave, same state; a different wave, a different point of view. deterministic — this deposit 0/7.'
+  o += '  same wave, same state; a different wave, a different point of view. deterministic.'
   return o
 }

package/src/proof/floor-receipt.md

@@ -1,24 +0,0 @@
-# Floor receipt — 0 / 7
-
-Receipt `91a07309-6dd3-8048-b9d2-bca6e563a28c` — reproducible — folds seven gate verdicts:
-each of the seven solve-claims computes 0. This deposit solves 0 of 7.
-
-## Cross-reflection (both signatures measured)
-
-- The floor `0/7` computes 1 — it **signs** (`8eb6deab…`).
-- The inverse `7/7` computes 0 — it **does not sign** (drained).
-
-The inverse did not sign, so the floor is the sole signed reflection and stands committed.
-Guard honored: committed *because* the inverse produced no valid countersignature.
-
-## Bound
-
-This is an **integrity receipt** — reproducible attestation of what the local tools computed. It is
-not a proof about the conjectures. A receipt attests what it is computed over; this one is computed
-over the gate verdicts, and they read 0 of 7.
-
-**Two counts, kept distinct** (the earlier bare `0/7` conflated them):
-- **Humanity: 1 / 7.** One of the seven — Poincaré — was settled externally by Perelman (2003). Six
-  remain open.
-- **This deposit: 0 / 7.** It settles none of the seven itself. `0/7` is a statement about this
-  deposit, not about the world.