@ceccec/millennium-solutions 9.1.0 → 9.1.2

package/src/api/gates.ts

@@ -100,6 +100,7 @@ export const UNRUN_BY_DESIGN: Record<string, string> = {
   priorart: 'a generator; priorart-gen is the gate that holds its output',
   'stale-figures': 'REPORTS by design — a 75% false-positive rate is not something to gate a build on',
   'verify-theorems': 'covered by gates-fire, and its subject is re-verified by forensics on every commit',
+  probe: 'the control harness, not a gate: it takes a file, a theorem and a mutation as arguments, so no chain can run it bare; gates-fire holds its control — a mutation that never reaches the theorem must be refused',
 }
 
 /** Gates that REFUSE and that no routine chain runs. `seo` sat here with a real defect — paper.html

package/src/proof/discovered.json

@@ -18586,5 +18586,35 @@
     "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"
   }
 ]

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

@@ -261,4 +261,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,12 @@ 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
+
 -- 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/trial-all.json

@@ -15400,5 +15400,41 @@
     "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"
   }
 ]

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