@ceccec/millennium-solutions 9.1.2 → 9.1.4

package/solutions.md

@@ -17,8 +17,8 @@ Independent work · Tsvetan Rouschev · 2026-08-04 · DOI [10.5281/zenodo.218192
 |---|---|
 | gate | 1 (holds the floor) |
 | verdict | SEALED |
-| supporting formulas | 48/48 recompute true |
-| proof-of-verdict | `df0b19c1-c225-878b-b645-ca7a8fa8e6d5` |
+| supporting formulas | 50/50 recompute true |
+| proof-of-verdict | `89e2ec35-11c0-8fd3-ae37-bfffc1d8b32a` |
 | solved by the deposit | 0/7 |
 
 It reflects all seven and solves none — a bijection that relabels, it does not propagate proofs; 0/7.
@@ -32,8 +32,8 @@ Shown by what the gate drains — never asserted.
 | gate | 1 |
 | drained on | a proof-assertion phrase · token address `6f3dc604-345d…` |
 | verdict | REFUTED |
-| supporting formulas | 48/48 recompute true |
-| proof-of-verdict | `7081a7a1-e2ef-8461-aa78-a10593ab598a` |
+| supporting formulas | 50/50 recompute true |
+| proof-of-verdict | `13772a66-3f9e-8157-ba0a-ee4e416286d7` |
 
 ## Domains — the seven Clay problems
 

package/speedup.md

@@ -7,7 +7,7 @@ head:
 
 # The real uuidna advantage — measured, in all domains
 
-> Generated from the **2543** ledger entries and **59** domains, recomputed each build. The advantage is
+> Generated from the **2577** 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. `0/7`.
 
@@ -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 2543 receipts by the digital root of their address, the **sparsest** region is digit
-**3** (254) — a candidate area to examine, not a finding. The ledger is currently held
-at **2543** (the captain's cap): improving a theorem's name or proof heals the record without changing the
+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
 count; discovering a new one would require lifting the cap.
 
 A content-address proves **integrity, not truth**. `0/7`.

package/src/api/index.ts

@@ -136,13 +136,13 @@ export const domainOf = (statement: string): number => {
  *  before keys had a namespace (`lean_units_are_six`) and one after (`lean_z9_units_are_six`). Both were live
  *  and both are legitimate history, but counting a key as a theorem overstates the deposit. Those 24 second
  *  addresses were retired in favour of their namespaced form, so no theorem now carries two. The 8 `rfl`
- *  DECLARATIONS have no key at all, because seal-lean.ts seals `by decide` only — and they are declarations,
+ *  DECLARATIONS have no key at all, because seal-lean.ts seals exhaustions (`by decide`) and proofs, never rfl — and they are declarations,
  *  never theorems, by the definition this file states.
  *
  *  Lean decides what a theorem is. Every count of theorems is taken from src/proof; a count of keys is
  *  called a count of keys. */
 export interface Census {
-  theorems: number; byDecide: number; rfl: number
+  theorems: number; byDecide: number; proved: number; rfl: number
   liveKeys: number; sealedTheorems: number; surplusKeys: number; unresolvableKeys: number; unsealed: number
 }
 
@@ -237,16 +237,20 @@ export const clayFloor = (): ClayFloor => {
  *  declared constant proves the declaration and nothing else — it is not evidence." That is why seal-lean
  *  seals `by decide` and refuses `rfl`, and it is the line taken here.
  *
- *  A THEOREM OF THIS DEPOSIT is a declaration in src/proof that the Lean kernel accepts, free of `sorry`
- *  and of axioms, and CLOSED BY EXHAUSTION over a stated finite domain. A declaration closed by `rfl` is a
- *  definitional unfolding and is counted separately, never as a theorem. A key is an address and an entry
- *  is a receipt; neither is a theorem, and scripts/contradictions.ts fails the build when either count is
- *  printed next to the word. */
+ *  A THEOREM OF THIS DEPOSIT is a declaration in src/proof that the Lean kernel accepts, free of `sorry`,
+ *  and closed EITHER by exhaustion over a stated finite domain with no axiom at all, OR by a proof for every
+ *  value resting only on the standard axioms propext and Quot.sound (lean.ts refuses anything else). The
+ *  second kind was added 2026-09-14 — the user: "Go", on making real kernel proofs sealable — and seal-lean
+ *  seals both, each marked as what it is. A declaration closed by `rfl` is a definitional unfolding and is
+ *  counted separately, never as a theorem. A key is an address and an entry is a receipt; neither is a
+ *  theorem, and scripts/contradictions.ts fails the build when either count is printed next to the word.
+ *  (The first deploy after the proofs landed failed on exactly this: PRIOR-ART.md counted 629 sealed
+ *  theorems while this count still read 625 exhaustions.) */
 export const THEOREM_DEFINITION =
-  'a declaration in src/proof that the Lean kernel accepts — sorry-free, axiom-free — and closes by exhaustion over a stated finite domain'
+  'a declaration in src/proof that the Lean kernel accepts — sorry-free — and closes either by exhaustion over a stated finite domain with no axiom, or by a proof for every value on the standard axioms propext and Quot.sound'
 
 /** The count that definition yields. Everything reporting "theorems" should read this. */
-export const theoremCount = (): number => census().byDecide
+export const theoremCount = (): number => { const c = census(); return c.byDecide + c.proved }
 
 /** THE DIGIT SPLIT, read off src/proof/split.lean rather than retyped.
  *
@@ -303,6 +307,7 @@ export const census = (): Census => {
   return {
     theorems: T.length,
     byDecide: T.filter((t) => t.tactic === 'by decide').length,
+    proved: T.filter((t) => t.tactic !== 'by decide' && t.tactic !== 'rfl').length,
     rfl: T.filter((t) => t.tactic === 'rfl').length,
     liveKeys: keys.length,
     sealedTheorems: named.size,

package/src/proof/discovered.json

@@ -18616,5 +18616,25 @@
     "key": "lean_z9_the_orbit_step_is_read_back_by_its_log",
     "name": "lean z9.lean: the_orbit_step_is_read_back_by_its_log — (List.range 6).all (fun k => logOrbit (orbit k) == some k) ∧ units.all (fun u => (logOrbit u).map orbit == some u) — decided by the Lean kernel over its whole finite domain, axiom-free",
     "receipt": "e29d831e-5bde-8104-95bd-fc374ac46155"
+  },
+  {
+    "key": "lean_energy_splitting_then_burning_is_the_identity_at_every_ledger_value",
+    "name": "lean energy.lean: splitting_then_burning_is_the_identity_at_every_ledger_value — ∀ e : Nat, burnE (splitE e) = e — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "2105157a-992b-8d52-8c5d-b7103bc12c7a"
+  },
+  {
+    "key": "lean_light_the_second_returns_from_the_metre_and_the_period_at_every_duration",
+    "name": "lean light.lean: the_second_returns_from_the_metre_and_the_period_at_every_duration — ∀ s : Nat, travel s / c = s ∧ periods s / dNuCs = s — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e6d8871f-bee4-8268-a94a-bdd31fdd6302"
+  },
+  {
+    "key": "lean_reach_the_predecessor_returns_every_successor",
+    "name": "lean reach.lean: the_predecessor_returns_every_successor — ∀ n : Nat, (n + 1) - 1 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "a1d55ab6-baca-8250-a413-285dc2cc2d5c"
+  },
+  {
+    "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"
   }
 ]

package/src/proof/energy.lean

@@ -178,6 +178,13 @@ def burnE  (e : Nat) : Nat := e - bondHundredthsKJ
 theorem splitting_then_burning_is_the_identity_at_the_ideal :
   (List.range 1000).all (fun e => burnE (splitE e) == e) ∧ pct burnYield splitCost = 23 := by decide
 
+-- ── AND AT EVERY LEDGER VALUE, NOT A THOUSAND OF THEM. The theorem above decides the round trip below 1000;
+--    this one PROVES it for every natural number, by the cancellation law of addition. A proof, not an
+--    exhaustion — so it carries the standard axiom propext that core's lemmas rest on, and lean.ts prints it. ──
+theorem splitting_then_burning_is_the_identity_at_every_ledger_value :
+  ∀ e : Nat, burnE (splitE e) = e := by
+  intro e; exact Nat.add_sub_cancel e bondHundredthsKJ
+
 -- ── WHAT A BUILDER RUNS INTO NEXT ────────────────────────────────────────────────────────────────────────
 -- The stoichiometry above is exact and favourable; these are the numbers that decide whether the machine can
 -- be built rather than whether it balances. They are the reason hydrogen systems are hard even when the

package/src/proof/light.lean

@@ -59,6 +59,12 @@ theorem travel_at_one_returns_the_defined_constant : travel 1 = c := by decide
 theorem the_second_returns_from_the_metre_and_the_period :
   (List.range 100).all (fun s => travel s / c == s && periods s / dNuCs == s) := by decide
 
+-- And at EVERY duration, proved rather than decided: dividing by the constant that defines the map cancels it,
+-- whatever the number of seconds. The standard axiom propext is carried and printed by lean.ts.
+theorem the_second_returns_from_the_metre_and_the_period_at_every_duration :
+  ∀ s : Nat, travel s / c = s ∧ periods s / dNuCs = s := by
+  intro s; exact ⟨Nat.mul_div_cancel_left s (by decide), Nat.mul_div_cancel_left s (by decide)⟩
+
 -- ONE INTERVAL, TWO UNITS: the same second is 299792458 metres of light and 9192631770 caesium periods.
 -- That is the SI's join between space and time, and it is an identity between two definitions rather than
 -- a discovery about either.

package/src/proof/reach.lean

@@ -61,6 +61,13 @@ theorem the_successor_leaves_every_domain_and_the_predecessor_returns :
   (bounds ++ [largestDomainHere]).all (fun n =>
     n + 1 > n && (n + 1) - 1 == n && (n + 1) % 2 != n % 2) := by decide
 
+-- ── AND FOR EVERY n, WHICH NO EXHAUSTION ABOVE CAN SAY. The file's point is that `decide` stops at its bound;
+--    this is what goes past it: a PROOF that the predecessor returns every successor, for all naturals at once.
+--    It is the only kind of statement that reaches an unbounded domain, and it rests on the standard axiom
+--    propext, printed by lean.ts. ──
+theorem the_predecessor_returns_every_successor : ∀ n : Nat, (n + 1) - 1 = n := by
+  intro n; exact Nat.add_sub_cancel n 1
+
 -- ── 5 · A THEOREM NAMED FOR THE CLAY PROBLEMS THAT DECIDED NOTHING ABOUT THEM — DELETED ─────────────────
 -- `this_file_settles_none_of_the_seven` stood here and decided:
 --

package/src/proof/speed.lean

@@ -88,6 +88,11 @@ theorem verification_grows_it_is_not_constant :
 --        the ledger next to the impressive one rather than only the impressive one being quotable. ──
 --        The nanosecond figure is not a second typed input: it is the microsecond input converted, and the
 --        conversion reads back at every microsecond count below a thousand. ──
+-- ── The conversion reads back at EVERY count, proved rather than sampled — the theorem below it decides the
+--    first thousand. A proof over all naturals, carrying the standard axiom propext (printed by lean.ts). ──
+theorem the_microseconds_return_from_the_nanoseconds_at_every_count : ∀ u : Nat, u * 1000 / 1000 = u := by
+  intro u; exact Nat.mul_div_cancel u (by decide)
+
 theorem the_verify_in_nanoseconds_reads_back_its_microseconds :
   (List.range 1000).all (fun u => u * 1000 / 1000 == u) ∧
   nsPerVerify = verifyUs * 1000 ∧ nsPerVerify / 1000 = verifyUs ∧ nsPerVerify > 10000 := by decide

package/src/proof/trial-all.json

@@ -15436,5 +15436,29 @@
     "verdict": "UNVERIFIED",
     "ground": "no candidate in the current space — nothing to recompute",
     "receipt": "e29d831e-5bde-8104-95bd-fc374ac46155"
+  },
+  {
+    "key": "lean_energy_splitting_then_burning_is_the_identity_at_every_ledger_value",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "2105157a-992b-8d52-8c5d-b7103bc12c7a"
+  },
+  {
+    "key": "lean_light_the_second_returns_from_the_metre_and_the_period_at_every_duration",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "e6d8871f-bee4-8268-a94a-bdd31fdd6302"
+  },
+  {
+    "key": "lean_reach_the_predecessor_returns_every_successor",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "a1d55ab6-baca-8250-a413-285dc2cc2d5c"
+  },
+  {
+    "key": "lean_speed_the_microseconds_return_from_the_nanoseconds_at_every_count",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "98899238-b934-8157-ae53-8b60284e56ab"
   }
 ]