@ceccec/millennium-solutions 9.1.1 → 9.1.3

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
 }
 
@@ -303,6 +303,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

@@ -18586,5 +18586,55 @@
     "key": "lean_speed_hexbits_are_slower_and_the_ratio_multiplies_back",
     "name": "lean speed.lean: hexbits_are_slower_and_the_ratio_multiplies_back — (List.range' 1 20).all (fun b => (List.range 400).all (fun a => (a / b) * b ≤ a && a < (a / b + 1) * b)) ∧ hexbitMs > hexMs ∧ hexbitMs * 10 / hexMs = 18 — decided by the Lean kernel over its whole finite domain, axiom-free",
     "receipt": "91a92ea5-bedd-8b9a-80b7-29130fbe5a93"
+  },
+  {
+    "key": "lean_elementary_the_wythoff_sequences_partition_the_integers",
+    "name": "lean elementary.lean: the_wythoff_sequences_partition_the_integers — (List.range' 1 50).all (fun m => ((List.range' 1 40).map lowerWythoff).count m + ((List.range' 1 40).map upperWythoff).count m == 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "45729b78-1ded-8539-a2da-71459d8d4183"
+  },
+  {
+    "key": "lean_energy_the_atoms_read_back_from_the_mass",
+    "name": "lean energy.lean: the_atoms_read_back_from_the_mass — (List.range 10).all (fun h => (List.range 10).all (fun o => atomsOf (mass h o) == some (h, o))) ∧ atomsOf mgH2 = some (2, 0) ∧ atomsOf mgO2 = some (0, 2) ∧ atomsOf mgH2O = some (2, 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "e49b5ab6-4f44-8b3c-aec8-b5b0a5f4d681"
+  },
+  {
+    "key": "lean_families_invOf_is_an_inverse_and_an_involution_on_the_units",
+    "name": "lean families.lean: invOf_is_an_inverse_and_an_involution_on_the_units — (List.range 9).all (fun d => match invOf d with | some e => d * e % 9 == 1 && invOf e == some d | none => gcd' d 9 != 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "85ad9b47-1b45-8b65-9a6c-72779f4782b0"
+  },
+  {
+    "key": "lean_families_choose_is_invariant_under_the_involution_k_to_n_minus_k",
+    "name": "lean families.lean: choose_is_invariant_under_the_involution_k_to_n_minus_k — (List.range 13).all (fun n => (List.range (n + 1)).all (fun k => choose n k == choose n (n - k) && n - (n - k) == k)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0affa1b0-91a0-8f5d-aa01-7f37496f2c87"
+  },
+  {
+    "key": "lean_light_the_second_returns_from_the_metre_and_the_period",
+    "name": "lean light.lean: the_second_returns_from_the_metre_and_the_period — (List.range 100).all (fun s => travel s / c == s && periods s / dNuCs == s) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "04685db2-fda6-844b-8b36-5b7f858baaac"
+  },
+  {
+    "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/elementary.lean

@@ -344,6 +344,14 @@ theorem a_knight_has_exactly_eight_leaps_and_every_one_flips_the_colour :
 theorem the_golden_beatty_identity_holds_across_the_range :
   (List.range' 1 40).all (fun n => upperWythoff n - lowerWythoff n == n) := by decide
 
+-- ── and the two sequences PARTITION the positive integers: every m up to fifty is hit by exactly one of the
+--    lower and upper Wythoff sequences, never both, never neither (Beatty's theorem, 1926, at φ and φ²). The
+--    identity above says how the two are paired; this says the pairing loses and duplicates nothing ──
+set_option maxRecDepth 2000000 in
+theorem the_wythoff_sequences_partition_the_integers :
+  (List.range' 1 50).all (fun m =>
+    ((List.range' 1 40).map lowerWythoff).count m + ((List.range' 1 40).map upperWythoff).count m == 1) := by decide
+
 -- ── the partition numbers count the partitions, and the Bell numbers count the set partitions ───────────
 --    Both are checked against an ENUMERATION of the objects rather than against another recurrence, which
 --    is the difference between confirming a formula and confirming what it counts.
@@ -387,7 +395,7 @@ theorem the_unit_graph_is_complete_bipartite_between_the_two_tetrahedra :
     (nbrs (unitsMod 9) d).all (fun y => x == y || !((nbrs (unitsMod 9) x).contains y)))) := by decide
 
 -- ── what these settle ──
-def settledHere : Nat := 31
-theorem elementary_settles_its_range : settledHere = 31 := rfl
+def settledHere : Nat := 32
+theorem elementary_settles_its_range : settledHere = 32 := rfl
 
 end Elementary

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
@@ -261,4 +268,15 @@ theorem the_residue_ratio_is_the_same_at_every_volume :
   (List.range' 1 200).all (fun l => residueMg l tdsSeawater == 700 * residueMg l tdsTapWater) ∧
   residueMg 100 tdsSeawater / 1000 = 3500 ∧ residueMg 100 tdsTapWater / 1000 = 5 := by decide
 
+-- ── 19 · THE MASS READS BACK ITS ATOMS. `mass` takes a molecule's hydrogens and oxygens to its molar mass;
+--         `atomsOf` goes the other way, finding the counts whose mass it is. At every molecule of up to nine
+--         of each, reading the atoms back from the mass returns exactly those atoms — so on this range the
+--         mass names the molecule, and no two formulas share one. H₂, O₂ and H₂O are three of the hundred. ──
+def atomsOf (m : Nat) : Option (Nat × Nat) :=
+  ((List.range 10).flatMap (fun h => (List.range 10).map (fun o => (h, o)))).find? (fun p => mass p.1 p.2 == m)
+
+theorem the_atoms_read_back_from_the_mass :
+  (List.range 10).all (fun h => (List.range 10).all (fun o => atomsOf (mass h o) == some (h, o))) ∧
+  atomsOf mgH2 = some (2, 0) ∧ atomsOf mgO2 = some (0, 2) ∧ atomsOf mgH2O = some (2, 1) := by decide
+
 end Energy

package/src/proof/families.lean

@@ -428,8 +428,23 @@ set_option maxRecDepth 100000 in
 theorem the_involutions_are_counted_by_the_telephone_numbers :
   (List.range 6).all (fun n => ((permsN (List.range n)).filter isInvolution).length == telephone n) := by decide
 
+-- ── the unit inverse, stated AS an inverse. That invOf finds something at exactly the units was proved above;
+--    this proves what it finds: the residue multiplies back to one, and inverting twice returns the unit — so
+--    invOf is an involution on the six units, and the non-units, where it finds nothing, are exactly the
+--    residues sharing a factor with nine ──
+theorem invOf_is_an_inverse_and_an_involution_on_the_units :
+  (List.range 9).all (fun d => match invOf d with
+    | some e => d * e % 9 == 1 && invOf e == some d
+    | none => gcd' d 9 != 1) := by decide
+
+-- ── the binomial coefficient does not see the involution k ↦ n − k: choosing k is choosing the n − k left
+--    behind, and applying the involution twice returns k, at every n to twelve and every k ──
+theorem choose_is_invariant_under_the_involution_k_to_n_minus_k :
+  (List.range 13).all (fun n => (List.range (n + 1)).all (fun k =>
+    choose n k == choose n (n - k) && n - (n - k) == k)) := by decide
+
 -- ── what these settle ──
-def settledHere : Nat := 40
-theorem families_settle_their_ranges : settledHere = 40 := rfl
+def settledHere : Nat := 42
+theorem families_settle_their_ranges : settledHere = 42 := rfl
 
 end Families

package/src/proof/light.lean

@@ -53,6 +53,18 @@ def periods (seconds : Nat) : Nat := dNuCs * seconds -- caesium periods elapsed
 
 theorem travel_at_one_returns_the_defined_constant : travel 1 = c := by decide
 
+-- AND THE CHAIN RUNS BACK. Dividing the metres by c returns the seconds, and dividing the periods by ΔνCs
+-- returns them too, at every whole second below a hundred: travel and periods are each undone by the
+-- constant that defines them, so a length and a count of periods both read back the same duration.
+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

@@ -15400,5 +15400,65 @@
     "verdict": "UNVERIFIED",
     "ground": "no candidate in the current space — nothing to recompute",
     "receipt": "91a92ea5-bedd-8b9a-80b7-29130fbe5a93"
+  },
+  {
+    "key": "lean_elementary_the_wythoff_sequences_partition_the_integers",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "45729b78-1ded-8539-a2da-71459d8d4183"
+  },
+  {
+    "key": "lean_energy_the_atoms_read_back_from_the_mass",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "e49b5ab6-4f44-8b3c-aec8-b5b0a5f4d681"
+  },
+  {
+    "key": "lean_families_invOf_is_an_inverse_and_an_involution_on_the_units",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "85ad9b47-1b45-8b65-9a6c-72779f4782b0"
+  },
+  {
+    "key": "lean_families_choose_is_invariant_under_the_involution_k_to_n_minus_k",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "0affa1b0-91a0-8f5d-aa01-7f37496f2c87"
+  },
+  {
+    "key": "lean_light_the_second_returns_from_the_metre_and_the_period",
+    "verdict": "UNVERIFIED",
+    "ground": "no candidate in the current space — nothing to recompute",
+    "receipt": "04685db2-fda6-844b-8b36-5b7f858baaac"
+  },
+  {
+    "key": "lean_z9_the_orbit_step_is_read_back_by_its_log",
+    "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"
   }
 ]

package/src/proof/z9.lean

@@ -65,6 +65,15 @@ theorem orbit_closes : orbit 6 = orbit 0 := by decide
 theorem orbit_distinct : ((List.range 6).map orbit).eraseDups.length = 6 := by decide
 theorem orbit_covers_units : ((List.range 6).map orbit).eraseDups.length = units.length := by decide
 
+-- ── the orbit read back: a discrete log along the doubling circuit. orbit takes a step to its residue;
+--    logOrbit takes the residue back to its step. Every step below six returns itself, and every unit is
+--    reached and re-reached — the circuit and its log are inverse, which is what "2 generates the units" means ──
+def logOrbit (u : Nat) : Option Nat := (List.range 6).find? (fun k => orbit k == u)
+
+theorem 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) := by decide
+
 -- ── the triad {3,6,9} is off the circuit: no power of 3 or 6 ever reaches one ──
 theorem triad_never_reaches_one :
   ¬ ((List.range 12).any (fun k => pow9 3 (k + 1) == 1 || pow9 6 (k + 1) == 1)) := by decide
@@ -86,7 +95,7 @@ theorem neg_involution : (List.range B).all (fun d => m9 (B - m9 (B - d)) == m9
 --    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.
-def settledHere : Nat := 20
-theorem z9_settles_its_domain_totally : settledHere = 20 := rfl
+def settledHere : Nat := 21
+theorem z9_settles_its_domain_totally : settledHere = 21 := rfl
 
 end Z9