@ceccec/millennium-solutions 9.2.6 → 9.2.8

package/speedup.md

@@ -7,7 +7,7 @@ head:
 
 # The real uuidna advantage — measured, in all domains
 
-> Generated from the **2607** ledger entries and **59** domains, recomputed each build. The advantage is
+> Generated from the **2643** 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.
 
@@ -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 2607 receipts by the digital root of their address, the **sparsest** region is digit
-**3** (265) — a candidate area to examine, not a finding. The ledger is currently held
-at **2607** (the captain's cap): improving a theorem's name or proof heals the record without changing the
+Grouping the 2643 receipts by the digital root of their address, the **sparsest** region is digit
+**3** (268) — a candidate area to examine, not a finding. The ledger is currently held
+at **2643** (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**.

package/src/proof/demand2.lean

@@ -168,4 +168,40 @@ theorem two_twenty_and_two_eighty_four_are_the_smallest_amicable_pair :
   (List.range' 2 218).all (fun a => ¬ (aliquot (aliquot a) == a && ¬ (aliquot a == a))) ∧
   (List.range' 2 218).filter (fun a => aliquot a == a) = [6, 28] := by decide
 
+
+-- ── the capped rows above, proved for every value — no bound ─────────────────────────────────────────────────
+-- sumPow is Families.powSum written as a single fold, so the Faulhaber laws proved there carry
+-- nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number (n ≤ 40) and
+-- the_sum_of_fifth_powers_has_the_closed_form_asked_for (n ≤ 20) to every n.
+theorem the_two_power_sums_are_one_sum : ∀ p n : Nat, sumPow p n = powSum p n := by
+  intro p n
+  unfold sumPow powSum
+  rw [List.foldl_map]
+
+theorem nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n :
+    ∀ n : Nat, sumPow 3 n = tri n * tri n := by
+  intro n
+  have c := the_cubes_sum_to_their_closed_form_for_every_n n
+  rw [← the_two_power_sums_are_one_sum] at c
+  have ev : n * (n + 1) % 2 = 0 := by
+    rcases Nat.mod_two_eq_zero_or_one n with e | e <;> simp [Nat.mul_mod, Nat.add_mod, e]
+  have hd : n * (n + 1) / 2 * 2 = n * (n + 1) := Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero ev)
+  unfold tri
+  generalize n * (n + 1) / 2 = t at hd ⊢
+  generalize sumPow 3 n = s at c ⊢
+  have q : 4 * s = 4 * (t * t) := by
+    have hsq : (t * 2) * (t * 2) = (n * (n + 1)) * (n * (n + 1)) := by rw [hd]
+    clear hd ev
+    try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+    try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+    try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+    all_goals omega
+  exact Nat.eq_of_mul_eq_mul_left (by decide) q
+
+theorem the_sum_of_fifth_powers_has_the_closed_form_for_every_n :
+    ∀ n : Nat, 12 * sumPow 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) := by
+  intro n
+  rw [the_two_power_sums_are_one_sum]
+  exact the_fifth_powers_sum_to_their_closed_form_for_every_n n
+
 end Demand2

package/src/proof/discovered.json

@@ -18786,5 +18786,185 @@
     "key": "lean_split_the_coin_step_and_the_coins_are_inverse_for_every_c",
     "name": "lean split.lean: the_coin_step_and_the_coins_are_inverse_for_every_c — ∀ c : Nat, 3 * c / 3 = c ∧ (3 * c) % 3 = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
     "receipt": "1c1ebe41-4e80-80ad-b352-e90a09922838"
+  },
+  {
+    "key": "lean_light_the_second_returns_from_the_metre_and_the_period_for_every_s",
+    "name": "lean light.lean: the_second_returns_from_the_metre_and_the_period_for_every_s — ∀ 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": "1de974bb-854a-879c-a8f0-712b59f8d7bc"
+  },
+  {
+    "key": "lean_mechanical_repeated_doubling_is_the_power_of_two_for_every_k",
+    "name": "lean mechanical.lean: repeated_doubling_is_the_power_of_two_for_every_k — ∀ k : Nat, dbl k = 2 ^ k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "71d6eeaa-fd06-8af1-893f-dfa60297892d"
+  },
+  {
+    "key": "lean_mechanical_relation_digitroot_is_residue_mod9_for_every_n",
+    "name": "lean mechanical.lean: relation_digitroot_is_residue_mod9_for_every_n — ∀ n : Nat, 0 < n → DR n = (n - 1) % 9 + 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "22aed33c-e7ff-80ef-aded-b466c40bf0e4"
+  },
+  {
+    "key": "lean_mechanical_the_nine_times_table_always_digital_roots_to_nine_for_every_k",
+    "name": "lean mechanical.lean: the_nine_times_table_always_digital_roots_to_nine_for_every_k — ∀ k : Nat, 0 < k → DR (9 * k) = 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "36b3b4ea-25f1-8083-b075-d707f2fb91ea"
+  },
+  {
+    "key": "lean_mechanical_the_digital_root_has_the_residue_of_its_number",
+    "name": "lean mechanical.lean: the_digital_root_has_the_residue_of_its_number — ∀ n : Nat, DR n % 9 = n % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "efc4383f-1f52-8cfc-9d4a-d291f4aa5bd4"
+  },
+  {
+    "key": "lean_mechanical_a_digital_root_lies_between_one_and_nine",
+    "name": "lean mechanical.lean: a_digital_root_lies_between_one_and_nine — ∀ n : Nat, 0 < n → 1 ≤ DR n ∧ DR n ≤ 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "298da32e-60d7-8bf9-9135-c6e904ae937f"
+  },
+  {
+    "key": "lean_mechanical_casting_out_nines_is_multiplicative_for_every_a_b",
+    "name": "lean mechanical.lean: casting_out_nines_is_multiplicative_for_every_a_b — ∀ a b : Nat, DR (a * b) = DR (DR a * DR b) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "58842a8d-45b2-8316-b9a6-440b595e6782"
+  },
+  {
+    "key": "lean_mechanical_the_moduli_dimensions_are_three_g_minus_three_and_six_g_minus_six_for_every_g",
+    "name": "lean mechanical.lean: the_moduli_dimensions_are_three_g_minus_three_and_six_g_minus_six_for_every_g — ∀ g : Nat, 3 * g - 3 = (6 * g - 6) / 2 ∧ 6 * g - 6 = 2 * (3 * g - 3) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "633ba212-336a-8600-90d6-836751f6b813"
+  },
+  {
+    "key": "lean_reach_exhaustion_never_reaches_its_own_bound_for_every_n",
+    "name": "lean reach.lean: exhaustion_never_reaches_its_own_bound_for_every_n — ∀ n : Nat, (List.range n).length = n ∧ n ∉ List.range n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "dfc2849f-3870-823b-ade5-f036c5f40166"
+  },
+  {
+    "key": "lean_reach_the_successor_of_every_bound_lies_outside_for_every_n",
+    "name": "lean reach.lean: the_successor_of_every_bound_lies_outside_for_every_n — ∀ n : Nat, n + 1 ∉ List.range n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "1113761c-4967-898e-a9d9-d836a27b42ae"
+  },
+  {
+    "key": "lean_reach_doubling_the_domain_leaves_the_same_hole_for_every_n",
+    "name": "lean reach.lean: doubling_the_domain_leaves_the_same_hole_for_every_n — ∀ n : Nat, 2 * n ∉ List.range (2 * n) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "f57338c8-104b-8058-90f6-b86622f64f86"
+  },
+  {
+    "key": "lean_z9plus_doubling_has_period_six_for_every_k",
+    "name": "lean z9plus.lean: doubling_has_period_six_for_every_k — ∀ k : Nat, pw 2 (k + 6) = pw 2 k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "2c9ca8bc-08a6-87e8-ba10-0390547c7318"
+  },
+  {
+    "key": "lean_z9plus_orbit_digital_roots_have_period_six_for_every_k",
+    "name": "lean z9plus.lean: orbit_digital_roots_have_period_six_for_every_k — ∀ k : Nat, dr (pw 2 (k + 6)) = dr (pw 2 k) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e88dfdf8-3c33-87c9-b480-65d2db2769ac"
+  },
+  {
+    "key": "lean_z9plus_the_doubling_orbit_is_read_from_the_exponent_mod_six",
+    "name": "lean z9plus.lean: the_doubling_orbit_is_read_from_the_exponent_mod_six — ∀ k : Nat, pw 2 k = pw 2 (k % 6) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c688c966-b59f-8e39-91d8-fa1f9fc564a0"
+  },
+  {
+    "key": "lean_z9plus_the_orbit_never_meets_the_triad_for_every_k",
+    "name": "lean z9plus.lean: the_orbit_never_meets_the_triad_for_every_k — ∀ k : Nat, pw 2 k ≠ 0 ∧ pw 2 k ≠ 3 ∧ pw 2 k ≠ 6 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "8c3dfc38-91e6-8a00-9d2f-ac18974cd169"
+  },
+  {
+    "key": "lean_z9plus_fibonacci_residues_mod_nine_repeat_every_twenty_four_steps",
+    "name": "lean z9plus.lean: fibonacci_residues_mod_nine_repeat_every_twenty_four_steps — ∀ k : Nat, fib (k + 24) % 9 = fib k % 9 ∧ fib (k + 25) % 9 = fib (k + 1) % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "04f6a9cd-b19f-8b13-b5d9-7d88fec0139e"
+  },
+  {
+    "key": "lean_z9plus_pisano_period_mod_nine_is_twenty_four_for_every_k",
+    "name": "lean z9plus.lean: pisano_period_mod_nine_is_twenty_four_for_every_k — ∀ k : Nat, fib9 (k + 24) = fib9 k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "985c1ebe-dc19-877e-8573-82765db72126"
+  },
+  {
+    "key": "lean_z9plus_the_fuelled_gcd_is_the_gcd_when_the_fuel_exceeds_the_second_argument",
+    "name": "lean z9plus.lean: the_fuelled_gcd_is_the_gcd_when_the_fuel_exceeds_the_second_argument — ∀ f a b : Nat, b < f → gcdF f a b = Nat.gcd a b — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "73c32b16-76ca-8bbc-91f3-3d550cd02477"
+  },
+  {
+    "key": "lean_z9plus_consecutive_fibonacci_numbers_are_coprime",
+    "name": "lean z9plus.lean: consecutive_fibonacci_numbers_are_coprime — ∀ n : Nat, Nat.gcd (fib n) (fib (n + 1)) = 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "5ae6ebcf-4c89-80d4-bc8c-1e5fed479a69"
+  },
+  {
+    "key": "lean_z9plus_consecutive_fibonacci_are_coprime_for_every_n",
+    "name": "lean z9plus.lean: consecutive_fibonacci_are_coprime_for_every_n — ∀ n : Nat, gcd9 (fib n) (fib (n + 1)) = 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "424d4751-1648-8d01-b6aa-e31be117166a"
+  },
+  {
+    "key": "lean_z9plus_digital_root_agrees_with_the_residue_for_every_n",
+    "name": "lean z9plus.lean: digital_root_agrees_with_the_residue_for_every_n — ∀ n : Nat, 0 < n → (dr n = 9 ↔ m9 n = 0) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "20da0230-2b9f-8735-848e-8009809d9f04"
+  },
+  {
+    "key": "lean_z9plus_digital_root_is_the_digit_sum_residue_for_every_n",
+    "name": "lean z9plus.lean: digital_root_is_the_digit_sum_residue_for_every_n — ∀ n : Nat, m9 (digitSum n) = m9 n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "694fefdf-a71b-8019-84e5-04477e7be3d8"
+  },
+  {
+    "key": "lean_demand2_the_two_power_sums_are_one_sum",
+    "name": "lean demand2.lean: the_two_power_sums_are_one_sum — ∀ p n : Nat, sumPow p n = powSum p n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6551630b-4917-8c1c-999f-4728c266cfd1"
+  },
+  {
+    "key": "lean_demand2_nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n",
+    "name": "lean demand2.lean: nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n — ∀ n : Nat, sumPow 3 n = tri n * tri n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "7aa0bbe0-b4ae-82e8-8319-7aed7047d654"
+  },
+  {
+    "key": "lean_demand2_the_sum_of_fifth_powers_has_the_closed_form_for_every_n",
+    "name": "lean demand2.lean: the_sum_of_fifth_powers_has_the_closed_form_for_every_n — ∀ n : Nat, 12 * sumPow 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6916652f-bda2-80d1-882e-009dee2d791d"
+  },
+  {
+    "key": "lean_elementary_the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n",
+    "name": "lean elementary.lean: the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n — ∀ n : Nat, lucas (n + 1) = fib n + fib (n + 2) — proved by the Lean kernel for every value (by\n  have), standard axioms only — checked by lean.ts",
+    "receipt": "cacb33f1-2fc1-8887-87a8-67aa352b3ac6"
+  },
+  {
+    "key": "lean_families_cassinis_identity_for_every_m",
+    "name": "lean families.lean: cassinis_identity_for_every_m — ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧ fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "75a810f1-ae27-8fb7-b4d3-b257c0c917c7"
+  },
+  {
+    "key": "lean_families_a_sum_over_one_to_n_plus_one_adds_the_last_term",
+    "name": "lean families.lean: a_sum_over_one_to_n_plus_one_adds_the_last_term — ∀ (g : Nat → Nat) (n : Nat), ((List.range' 1 (n + 1)).map g).foldl (· + ·) 0 = ((List.range' 1 n).map g).foldl (· + ·) 0 + g (n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "f664ca1d-8371-8bd5-a369-060e34e5baaf"
+  },
+  {
+    "key": "lean_families_the_numbers_sum_to_their_closed_form_for_every_n",
+    "name": "lean families.lean: the_numbers_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 2 * powSum 1 n = n * (n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "34fa9fc8-b8ed-8895-bb81-c92f4515e9fe"
+  },
+  {
+    "key": "lean_families_the_squares_sum_to_their_closed_form_for_every_n",
+    "name": "lean families.lean: the_squares_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 6 * powSum 2 n = n * (n + 1) * (2 * n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "0b7a0569-fb3f-8ba7-a49a-900c19bf369d"
+  },
+  {
+    "key": "lean_families_the_cubes_sum_to_their_closed_form_for_every_n",
+    "name": "lean families.lean: the_cubes_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 4 * powSum 3 n = n * n * (n + 1) * (n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "96b0047e-cf09-8755-be28-1cb49080d466"
+  },
+  {
+    "key": "lean_families_the_fourth_powers_sum_to_their_closed_form_for_every_n",
+    "name": "lean families.lean: the_fourth_powers_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 30 * powSum 4 n = n * (n + 1) * (2 * n + 1) * (3 * n * n + 3 * n - 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "3419aabd-970f-8738-ae26-0adbfd4cf7fb"
+  },
+  {
+    "key": "lean_families_the_fifth_powers_sum_to_their_closed_form_for_every_n",
+    "name": "lean families.lean: the_fifth_powers_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 12 * powSum 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "790310ea-f06d-875d-89aa-2aba93d133e3"
+  },
+  {
+    "key": "lean_families_power_sums_match_their_closed_forms_for_every_n",
+    "name": "lean families.lean: power_sums_match_their_closed_forms_for_every_n — ∀ k n : Nat, 1 ≤ k → k ≤ 5 → powSum k n = faulhaber k n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "04b04822-598b-8529-a44c-7881174ec382"
+  },
+  {
+    "key": "lean_families_the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n",
+    "name": "lean families.lean: the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n — ∀ n : Nat, ((List.range' 1 n).map (fun i => i * (i + 1) / 2)).foldl (· + ·) 0 = n * (n + 1) * (n + 2) / 6 — proved by the Lean kernel for every value (by\n  have), standard axioms only — checked by lean.ts",
+    "receipt": "43b9cdd8-7110-8f6f-887b-297d0262ae80"
+  },
+  {
+    "key": "lean_sequences_cassinis_identity_for_every_m",
+    "name": "lean sequences.lean: cassinis_identity_for_every_m — ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧ fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "3b815427-42b8-8b8c-abf3-423b1e268af3"
   }
 ]

package/src/proof/elementary.lean

@@ -423,4 +423,24 @@ theorem eight_times_a_triangular_number_plus_one_is_an_odd_square_for_every_n :
   rw [hexp]
   omega
 
+
+-- ── the capped row above, proved for every value — no bound ──────────────────────────────────────────────────
+-- the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis was checked n ≤ 28; this proves it for every n.
+theorem the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n :
+    ∀ n : Nat, lucas (n + 1) = fib n + fib (n + 2) := by
+  have key : ∀ n : Nat, lucas (n + 1) = fib n + fib (n + 2) ∧ lucas (n + 2) = fib (n + 1) + fib (n + 3) := by
+    intro n
+    induction n with
+    | zero => decide
+    | succ n ih =>
+      refine ⟨ih.2, ?_⟩
+      have l : lucas (n + 3) = lucas (n + 1) + lucas (n + 2) := rfl
+      have f4 : fib (n + 4) = fib (n + 2) + fib (n + 3) := rfl
+      have f2 : fib (n + 2) = fib n + fib (n + 1) := rfl
+      show lucas (n + 3) = fib (n + 2) + fib (n + 4)
+      rw [l, ih.1, ih.2, f4]
+      omega
+  intro n
+  exact (key n).1
+
 end Elementary

package/src/proof/families.lean

@@ -479,4 +479,170 @@ theorem the_first_n_odd_numbers_sum_to_n_squared_for_every_n :
     rw [square_of_successor]
     omega
 
+
+-- ── the capped rows above, proved for every value by induction — no bound ──────────────────────────────────
+-- cassinis_identity_holds_across_the_range (n ≤ 30), power_sums_match_their_closed_forms (k = 1..5, n ≤ 40),
+-- the_first_three_power_sums_hold_to_two_hundred (n ≤ 200) and the_sums_of_triangular_numbers_are_the_tetrahedral_
+-- numbers (n ≤ 100) were checked up to a bound; these prove them for every value. Core Lean has no ring tactic, so each
+-- polynomial step is expanded, each monomial sorted, its numeral moved to the front, and omega closes what is left.
+theorem cassinis_identity_for_every_m :
+    ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧
+      fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) := by
+  intro m
+  induction m with
+  | zero => decide
+  | succ m ih =>
+    have r3 : fib (2 * m + 3) = fib (2 * m + 1) + fib (2 * m + 2) := rfl
+    have r4 : fib (2 * m + 4) = fib (2 * m + 2) + fib (2 * m + 3) := rfl
+    have r5 : fib (2 * m + 5) = fib (2 * m + 3) + fib (2 * m + 4) := rfl
+    show fib (2 * m + 3) * fib (2 * m + 5) = fib (2 * m + 4) * fib (2 * m + 4) + 1 ∧
+      fib (2 * m + 2) * fib (2 * m + 4) + 1 = fib (2 * m + 3) * fib (2 * m + 3)
+    have h := ih.1
+    rw [r5, r4, r3]
+    rw [r3] at h
+    generalize fib (2 * m + 1) = a at h ⊢
+    generalize fib (2 * m + 2) = b at h ⊢
+    constructor
+    · try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+    · try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+
+theorem a_sum_over_one_to_n_plus_one_adds_the_last_term :
+    ∀ (g : Nat → Nat) (n : Nat),
+      ((List.range' 1 (n + 1)).map g).foldl (· + ·) 0 = ((List.range' 1 n).map g).foldl (· + ·) 0 + g (n + 1) := by
+  intro g n
+  rw [List.range'_concat, List.map_append, List.foldl_append]
+  simp only [List.map, List.foldl, Nat.one_mul, Nat.add_comm 1 n]
+
+theorem the_numbers_sum_to_their_closed_form_for_every_n : ∀ n : Nat, 2 * powSum 1 n = n * (n + 1) := by
+  intro n
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    unfold powSum at *
+    rw [a_sum_over_one_to_n_plus_one_adds_the_last_term]
+    generalize ((List.range' 1 n).map (fun i => i ^ 1)).foldl (· + ·) 0 = s at ih ⊢
+    try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+    try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+    try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+    all_goals omega
+
+theorem the_squares_sum_to_their_closed_form_for_every_n : ∀ n : Nat, 6 * powSum 2 n = n * (n + 1) * (2 * n + 1) := by
+  intro n
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    unfold powSum at *
+    rw [a_sum_over_one_to_n_plus_one_adds_the_last_term]
+    generalize ((List.range' 1 n).map (fun i => i ^ 2)).foldl (· + ·) 0 = s at ih ⊢
+    try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+    try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+    try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+    all_goals omega
+
+theorem the_cubes_sum_to_their_closed_form_for_every_n : ∀ n : Nat, 4 * powSum 3 n = n * n * (n + 1) * (n + 1) := by
+  intro n
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    unfold powSum at *
+    rw [a_sum_over_one_to_n_plus_one_adds_the_last_term]
+    generalize ((List.range' 1 n).map (fun i => i ^ 3)).foldl (· + ·) 0 = s at ih ⊢
+    try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+    try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+    try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+    all_goals omega
+
+set_option maxRecDepth 200000 in
+set_option maxHeartbeats 4000000 in
+theorem the_fourth_powers_sum_to_their_closed_form_for_every_n :
+    ∀ n : Nat, 30 * powSum 4 n = n * (n + 1) * (2 * n + 1) * (3 * n * n + 3 * n - 1) := by
+  intro n
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    unfold powSum at *
+    rw [a_sum_over_one_to_n_plus_one_adds_the_last_term]
+    generalize ((List.range' 1 n).map (fun i => i ^ 4)).foldl (· + ·) 0 = s at ih ⊢
+    have e2 : 3 * (n + 1) * (n + 1) + 3 * (n + 1) - 1 = 3 * n * n + 9 * n + 5 := by
+      simp only [Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul]; omega
+    rw [e2]
+    cases n with
+    | zero => simp at ih ⊢; omega
+    | succ m =>
+      have e1 : 3 * (m + 1) * (m + 1) + 3 * (m + 1) - 1 = 3 * m * m + 9 * m + 5 := by
+        simp only [Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul]; omega
+      rw [e1] at ih
+      try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+
+set_option maxRecDepth 200000 in
+set_option maxHeartbeats 4000000 in
+theorem the_fifth_powers_sum_to_their_closed_form_for_every_n :
+    ∀ n : Nat, 12 * powSum 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) := by
+  intro n
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    unfold powSum at *
+    rw [a_sum_over_one_to_n_plus_one_adds_the_last_term]
+    generalize ((List.range' 1 n).map (fun i => i ^ 5)).foldl (· + ·) 0 = s at ih ⊢
+    have e2 : 2 * (n + 1) * (n + 1) + 2 * (n + 1) - 1 = 2 * n * n + 6 * n + 3 := by
+      simp only [Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul]; omega
+    rw [e2]
+    cases n with
+    | zero => simp at ih ⊢; omega
+    | succ m =>
+      have e1 : 2 * (m + 1) * (m + 1) + 2 * (m + 1) - 1 = 2 * m * m + 6 * m + 3 := by
+        simp only [Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul]; omega
+      rw [e1] at ih
+      try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+
+theorem power_sums_match_their_closed_forms_for_every_n :
+    ∀ k n : Nat, 1 ≤ k → k ≤ 5 → powSum k n = faulhaber k n := by
+  intro k n h1 h5
+  have c : k = 1 ∨ k = 2 ∨ k = 3 ∨ k = 4 ∨ k = 5 := by omega
+  rcases c with rfl | rfl | rfl | rfl | rfl
+  · show powSum 1 n = n * (n + 1) / 2
+    rw [← the_numbers_sum_to_their_closed_form_for_every_n n, Nat.mul_div_cancel_left _ (by decide)]
+  · show powSum 2 n = n * (n + 1) * (2 * n + 1) / 6
+    rw [← the_squares_sum_to_their_closed_form_for_every_n n, Nat.mul_div_cancel_left _ (by decide)]
+  · show powSum 3 n = n * n * (n + 1) * (n + 1) / 4
+    rw [← the_cubes_sum_to_their_closed_form_for_every_n n, Nat.mul_div_cancel_left _ (by decide)]
+  · show powSum 4 n = n * (n + 1) * (2 * n + 1) * (3 * n * n + 3 * n - 1) / 30
+    rw [← the_fourth_powers_sum_to_their_closed_form_for_every_n n, Nat.mul_div_cancel_left _ (by decide)]
+  · show powSum 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) / 12
+    rw [← the_fifth_powers_sum_to_their_closed_form_for_every_n n, Nat.mul_div_cancel_left _ (by decide)]
+
+theorem the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n :
+    ∀ n : Nat, ((List.range' 1 n).map (fun i => i * (i + 1) / 2)).foldl (· + ·) 0 = n * (n + 1) * (n + 2) / 6 := by
+  have six : ∀ n : Nat, 6 * ((List.range' 1 n).map (fun i => i * (i + 1) / 2)).foldl (· + ·) 0 = n * (n + 1) * (n + 2) := by
+    intro n
+    induction n with
+    | zero => rfl
+    | succ n ih =>
+      rw [a_sum_over_one_to_n_plus_one_adds_the_last_term]
+      have ev : (n + 1) * (n + 1 + 1) % 2 = 0 := by
+        rcases Nat.mod_two_eq_zero_or_one n with e | e <;> simp [Nat.mul_mod, Nat.add_mod, e]
+      have hd : (n + 1) * (n + 1 + 1) / 2 * 2 = (n + 1) * (n + 1 + 1) := Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero ev)
+      generalize ((List.range' 1 n).map (fun i => i * (i + 1) / 2)).foldl (· + ·) 0 = s at ih ⊢
+      generalize (n + 1) * (n + 1 + 1) / 2 = t at hd ⊢
+      rw [Nat.mul_two] at hd
+      try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+  intro n
+  rw [← six n, Nat.mul_div_cancel_left _ (by decide)]
+
 end Families

package/src/proof/light.lean

@@ -147,4 +147,12 @@ theorem the_root_moves_with_the_unit_so_it_is_not_about_light :
 theorem the_definitions_are_seven_and_travel_fixes_zero :
   defining.length = 7 ∧ travel 0 = 0 := by decide
 
+
+-- ── the capped row above, proved for every whole number of seconds — no bound ───────────────────────────────
+-- the second reads back from the metre and from the caesium period at every s, not only s < 100.
+theorem the_second_returns_from_the_metre_and_the_period_for_every_s :
+    ∀ 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)⟩
+
 end Light

package/src/proof/mechanical.lean

@@ -452,4 +452,73 @@ theorem the_product_of_any_three_consecutive_integers_is_divisible_by_six_for_ev
   have h3 := the_product_of_three_consecutive_numbers_is_a_multiple_of_three n
   omega
 
+
+-- ── the capped rows above, proved for every value — no bound ─────────────────────────────────────────────────
+-- relation_digitroot_is_residue_mod9 (n ≤ 200), the_nine_times_table_always_digital_roots_to_nine (k ≤ 60),
+-- casting_out_nines_is_multiplicative (a, b ≤ 60), repeated_doubling_is_the_power_of_two (k ≤ 20) and
+-- the_moduli_dimensions (g ≤ 20) were checked up to a bound; these prove them for every value.
+theorem repeated_doubling_is_the_power_of_two_for_every_k : ∀ k : Nat, dbl k = 2 ^ k := by
+  intro k
+  induction k with
+  | zero => rfl
+  | succ k ih =>
+    show 2 * dbl k = 2 ^ (k + 1)
+    rw [ih, Nat.pow_succ, Nat.mul_comm]
+
+theorem relation_digitroot_is_residue_mod9_for_every_n : ∀ n : Nat, 0 < n → DR n = (n - 1) % 9 + 1 := by
+  intro n hn
+  unfold DR
+  rw [if_neg (show ¬ ((n == 0) = true) by simp; omega)]
+  omega
+
+theorem the_nine_times_table_always_digital_roots_to_nine_for_every_k : ∀ k : Nat, 0 < k → DR (9 * k) = 9 := by
+  intro k hk
+  rw [relation_digitroot_is_residue_mod9_for_every_n (9 * k) (by omega)]
+  omega
+
+theorem the_digital_root_has_the_residue_of_its_number : ∀ n : Nat, DR n % 9 = n % 9 := by
+  intro n
+  cases n with
+  | zero => rfl
+  | succ m =>
+    rw [relation_digitroot_is_residue_mod9_for_every_n (m + 1) (Nat.succ_pos m)]
+    omega
+
+theorem a_digital_root_lies_between_one_and_nine : ∀ n : Nat, 0 < n → 1 ≤ DR n ∧ DR n ≤ 9 := by
+  intro n hn
+  rw [relation_digitroot_is_residue_mod9_for_every_n n hn]
+  have := Nat.mod_lt (n - 1) (show 0 < 9 by decide)
+  exact ⟨by omega, by omega⟩
+
+theorem casting_out_nines_is_multiplicative_for_every_a_b : ∀ a b : Nat, DR (a * b) = DR (DR a * DR b) := by
+  intro a b
+  cases a with
+  | zero => rw [Nat.zero_mul, show DR 0 = 0 from rfl, Nat.zero_mul]; rfl
+  | succ a =>
+    cases b with
+    | zero => rw [Nat.mul_zero, show DR 0 = 0 from rfl, Nat.mul_zero]; rfl
+    | succ b =>
+      have hab : 0 < (a + 1) * (b + 1) := Nat.mul_pos (Nat.succ_pos a) (Nat.succ_pos b)
+      have ha := a_digital_root_lies_between_one_and_nine (a + 1) (Nat.succ_pos a)
+      have hb := a_digital_root_lies_between_one_and_nine (b + 1) (Nat.succ_pos b)
+      have hp : 0 < DR (a + 1) * DR (b + 1) := Nat.mul_pos (by omega) (by omega)
+      have r1 := the_digital_root_has_the_residue_of_its_number ((a + 1) * (b + 1))
+      have r2 := the_digital_root_has_the_residue_of_its_number (DR (a + 1) * DR (b + 1))
+      have r3 : DR (a + 1) * DR (b + 1) % 9 = (a + 1) * (b + 1) % 9 := by
+        rw [Nat.mul_mod, the_digital_root_has_the_residue_of_its_number,
+          the_digital_root_has_the_residue_of_its_number, ← Nat.mul_mod]
+      obtain ⟨b1l, b1r⟩ := a_digital_root_lies_between_one_and_nine _ hab
+      obtain ⟨b2l, b2r⟩ := a_digital_root_lies_between_one_and_nine _ hp
+      clear ha hb
+      generalize DR ((a + 1) * (b + 1)) = x at *
+      generalize DR (DR (a + 1) * DR (b + 1)) = y at *
+      generalize (a + 1) * (b + 1) = m at *
+      generalize DR (a + 1) * DR (b + 1) = p at *
+      omega
+
+theorem the_moduli_dimensions_are_three_g_minus_three_and_six_g_minus_six_for_every_g :
+    ∀ g : Nat, 3 * g - 3 = (6 * g - 6) / 2 ∧ 6 * g - 6 = 2 * (3 * g - 3) := by
+  intro g
+  exact ⟨by omega, by omega⟩
+
 end Mechanical

package/src/proof/reach.lean

@@ -89,4 +89,17 @@ theorem the_predecessor_returns_every_successor : ∀ n : Nat, (n + 1) - 1 = n :
 -- named for one it cannot observe is worse than no theorem: it reads as a kernel-checked proof of a
 -- statement the kernel never saw.
 
+
+-- ── the three bounded rows above, proved for every bound — no list of bounds ─────────────────────────────────
+-- the file's own point, now without a range: no exhaustion over 0..n-1 contains n, n + 1, or (at 2n) 2n.
+theorem exhaustion_never_reaches_its_own_bound_for_every_n : ∀ n : Nat, (List.range n).length = n ∧ n ∉ List.range n := by
+  intro n
+  exact ⟨List.length_range n, fun h => Nat.lt_irrefl n (List.mem_range.mp h)⟩
+theorem the_successor_of_every_bound_lies_outside_for_every_n : ∀ n : Nat, n + 1 ∉ List.range n := by
+  intro n h
+  exact Nat.lt_irrefl n (Nat.lt_trans (Nat.lt_succ_self n) (List.mem_range.mp h))
+theorem doubling_the_domain_leaves_the_same_hole_for_every_n : ∀ n : Nat, 2 * n ∉ List.range (2 * n) := by
+  intro n h
+  exact Nat.lt_irrefl (2 * n) (List.mem_range.mp h)
+
 end Reach

package/src/proof/sequences.lean

@@ -102,4 +102,35 @@ theorem the_sequence_takes_both_values :
   ((List.range 200).filter (fun n => tm n == 0)).length = 100
   ∧ ((List.range 200).filter (fun n => tm n == 1)).length = 100 := by decide
 
+
+-- ── the capped rows above, proved for every value — no bound ─────────────────────────────────────────────────
+-- cassini_at_even_indices, cassini_at_odd_indices and cassini_deviation_is_exactly_one were checked n ≤ 20; one law
+-- carries all three: at every index the product of the neighbours is the square, plus or minus one.
+theorem cassinis_identity_for_every_m :
+    ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧
+      fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) := by
+  intro m
+  induction m with
+  | zero => decide
+  | succ m ih =>
+    have r3 : fib (2 * m + 3) = fib (2 * m + 1) + fib (2 * m + 2) := rfl
+    have r4 : fib (2 * m + 4) = fib (2 * m + 2) + fib (2 * m + 3) := rfl
+    have r5 : fib (2 * m + 5) = fib (2 * m + 3) + fib (2 * m + 4) := rfl
+    show fib (2 * m + 3) * fib (2 * m + 5) = fib (2 * m + 4) * fib (2 * m + 4) + 1 ∧
+      fib (2 * m + 2) * fib (2 * m + 4) + 1 = fib (2 * m + 3) * fib (2 * m + 3)
+    have h := ih.1
+    rw [r5, r4, r3]
+    rw [r3] at h
+    generalize fib (2 * m + 1) = a at h ⊢
+    generalize fib (2 * m + 2) = b at h ⊢
+    constructor
+    · try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+    · try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
+      try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
+      try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
+      all_goals omega
+
 end Sequences