@ceccec/millennium-solutions 9.2.4 → 9.2.6

package/speedup.md

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

package/src/api/gates.ts

@@ -102,6 +102,8 @@ export const UNRUN_BY_DESIGN: Record<string, string> = {
   'verify-theorems': 'covered by gates-fire, and its subject is re-verified by forensics on every commit',
   uses: 'discovery, not a gate: it reaches GDELT, Hacker News, Zenodo, OpenAlex, npm and GitHub, and what it finds is someone else\'s use of the work — whether it cites and pays — not a defect in this tree. It runs weekly in .github/workflows/uses.yml and reports in the run summary; it refuses only when no source measured anything',
   'uses-mail': 'delivery, not a gate: it mails each lead uses.ts found to legal@psg.bg as an evidence dossier, from rights@uuidna.com through mail.psg.bg by authenticated SMTP — network and the author\'s credentials, so no build chain can run it. It runs weekly after uses.ts in .github/workflows/uses.yml, says NOT CONFIGURED when the SMTP secrets are unset, and refuses only when a send fails',
+  novelty: 'discovery, not a gate: it reaches the OEIS, zbMATH Open, OpenAlex, Crossref and arXiv to search the literature for each theorem, and records what was searched and what came back in src/proof/novelty.json — network a build about this tree must not depend on',
+  clusters: 'a generator, not a gate: it prepares one publication draft per proven cluster in .zenodo/clusters/ and reaches no network; it refuses only when a joint address fails to bind every receipt, which forensics and the seal already check on every run',
   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',
 }
 

package/src/proof/demand.lean

@@ -109,4 +109,26 @@ theorem factorial_seven_is_five_thousand_and_forty :
 theorem mantels_bound_is_n_squared_over_four :
   (List.range' 1 20).all (fun n => (n / 2) * (n - n / 2) == n * n / 4) := by decide
 
+
+-- ── the capped row above, proved for every value — no bound ───────────────────────────────────────────────────
+-- mantels_bound_is_n_squared_over_four checked 1 ≤ n ≤ 20; this proves the identity for every n.
+theorem mantels_bound_is_n_squared_over_four_for_every_n :
+    ∀ n : Nat, (n / 2) * (n - n / 2) = n * n / 4 := by
+  intro n
+  rcases Nat.mod_two_eq_zero_or_one n with h | h
+  · obtain ⟨m, rfl⟩ : ∃ m, n = 2 * m := ⟨n / 2, by omega⟩
+    have h1 : 2 * m / 2 = m := by omega
+    have h2 : 2 * m * (2 * m) = 4 * (m * m) := by
+      rw [Nat.mul_assoc 2 m (2 * m), Nat.mul_comm m (2 * m), Nat.mul_assoc 2 m m]; omega
+    rw [h1, show 2 * m - m = m by omega, h2]
+    omega
+  · obtain ⟨m, rfl⟩ : ∃ m, n = 2 * m + 1 := ⟨n / 2, by omega⟩
+    have h1 : (2 * m + 1) / 2 = m := by omega
+    have h2 : (2 * m + 1) * (2 * m + 1) = 4 * (m * (m + 1)) + 1 := by
+      rw [Nat.mul_add m m 1, Nat.mul_one, Nat.add_mul, Nat.mul_add, Nat.mul_add, Nat.mul_one, Nat.one_mul]
+      rw [Nat.mul_assoc 2 m (2 * m), Nat.mul_comm m (2 * m), Nat.mul_assoc 2 m m]
+      omega
+    rw [h1, show 2 * m + 1 - m = m + 1 by omega, h2]
+    omega
+
 end Demand

package/src/proof/demand3.lean

@@ -114,4 +114,64 @@ theorem havel_hakimi_decides_graphical_sequences :
   hh 12 [3, 3, 3, 3] = true ∧ hh 12 [2, 2, 2] = true ∧
   hh 12 [3, 3, 1, 1] = false ∧ hh 12 [4, 1, 1, 1, 1] = true ∧ hh 12 [5, 1, 1, 1, 1] = false := by decide
 
+
+-- ── the capped rows above, proved for every value by induction — no bound ────────────────────────────────────
+-- the_euler_characteristic_of_a_genus_g_surface checked g < 12; this proves χ(g) + 2g = 2 for every g.
+theorem the_euler_characteristic_of_a_genus_g_surface_for_every_g :
+    ∀ g : Nat, chi g + 2 * (g : Int) = 2 := by
+  intro g
+  unfold chi
+  omega
+
+theorem a_repunit_has_the_residue_of_its_length_mod_three : ∀ n : Nat, repunit n % 3 = n % 3 := by
+  intro n
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    show (10 * repunit n + 1) % 3 = (n + 1) % 3
+    rw [Nat.add_mod, Nat.mul_mod, ih]
+    have h : n % 3 = 0 ∨ n % 3 = 1 ∨ n % 3 = 2 := by omega
+    rcases h with h | h | h <;> simp [h] <;> omega
+
+-- repunit_divisibility_by_three_and_seven checked n ≤ 18; these prove both halves for every n.
+theorem a_repunit_is_divisible_by_three_exactly_when_its_length_is_for_every_n :
+    ∀ n : Nat, (repunit n % 3 = 0) ↔ (n % 3 = 0) := by
+  intro n
+  rw [a_repunit_has_the_residue_of_its_length_mod_three]
+
+theorem repunit_of_a_sum : ∀ n k : Nat, repunit (n + k) = 10 ^ k * repunit n + repunit k := by
+  intro n k
+  induction k with
+  | zero => simp [repunit]
+  | succ k ih =>
+    show 10 * repunit (n + k) + 1 = 10 ^ (k + 1) * repunit n + (10 * repunit k + 1)
+    rw [ih, Nat.pow_succ, Nat.mul_add, ← Nat.mul_assoc, Nat.mul_comm 10 (10 ^ k)]
+    omega
+
+theorem repunits_repeat_mod_seven_every_six_digits : ∀ n : Nat, repunit (n + 6) % 7 = repunit n % 7 := by
+  intro n
+  rw [repunit_of_a_sum, Nat.add_mod, Nat.mul_mod]
+  have h1 : 10 ^ 6 % 7 = 1 := by decide
+  have h2 : repunit 6 % 7 = 0 := by decide
+  rw [h1, h2, Nat.one_mul, Nat.add_zero]
+  omega
+
+theorem a_repunit_has_the_residue_of_its_length_mod_six_mod_seven : ∀ n : Nat, repunit n % 7 = repunit (n % 6) % 7 := by
+  intro n
+  induction n using Nat.strongRecOn with
+  | _ n ih =>
+    if hn : n < 6 then rw [Nat.mod_eq_of_lt hn]
+    else
+      have e : n = (n - 6) + 6 := by omega
+      rw [e, repunits_repeat_mod_seven_every_six_digits, ih (n - 6) (by omega), Nat.add_mod_right]
+
+theorem a_repunit_is_divisible_by_seven_exactly_when_six_divides_its_length_for_every_n :
+    ∀ n : Nat, (repunit n % 7 = 0) ↔ (n % 6 = 0) := by
+  intro n
+  rw [a_repunit_has_the_residue_of_its_length_mod_six_mod_seven]
+  have h : n % 6 < 6 := Nat.mod_lt _ (by decide)
+  generalize n % 6 = j at h ⊢
+  revert j
+  decide
+
 end Demand3

package/src/proof/discovered.json

@@ -18651,5 +18651,140 @@
     "key": "lean_flow_navier_stokes_flow_is_bounded_for_every_step",
     "name": "lean flow.lean: navier_stokes_flow_is_bounded_for_every_step — ∀ k : Nat, orbit k < 9 ∧ span.contains (orbit k) = true — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
     "receipt": "6dec28f9-502b-86ee-8f87-d09f701ed7e7"
+  },
+  {
+    "key": "lean_demand_mantels_bound_is_n_squared_over_four_for_every_n",
+    "name": "lean demand.lean: mantels_bound_is_n_squared_over_four_for_every_n — ∀ n : Nat, (n / 2) * (n - n / 2) = n * n / 4 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "b9212e56-a3ea-8d6d-be87-f946b87d6b6c"
+  },
+  {
+    "key": "lean_demand3_the_euler_characteristic_of_a_genus_g_surface_for_every_g",
+    "name": "lean demand3.lean: the_euler_characteristic_of_a_genus_g_surface_for_every_g — ∀ g : Nat, chi g + 2 * (g : Int) = 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "a1a899d7-b3c5-8941-b02c-55f111d49fca"
+  },
+  {
+    "key": "lean_demand3_a_repunit_has_the_residue_of_its_length_mod_three",
+    "name": "lean demand3.lean: a_repunit_has_the_residue_of_its_length_mod_three — ∀ n : Nat, repunit n % 3 = n % 3 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "732113b8-a6d4-8b14-8681-6f31d2a78e30"
+  },
+  {
+    "key": "lean_demand3_a_repunit_is_divisible_by_three_exactly_when_its_length_is_for_every_n",
+    "name": "lean demand3.lean: a_repunit_is_divisible_by_three_exactly_when_its_length_is_for_every_n — ∀ n : Nat, (repunit n % 3 = 0) ↔ (n % 3 = 0) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "93c43bd9-4707-8199-be02-c954c8916904"
+  },
+  {
+    "key": "lean_demand3_repunit_of_a_sum",
+    "name": "lean demand3.lean: repunit_of_a_sum — ∀ n k : Nat, repunit (n + k) = 10 ^ k * repunit n + repunit k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "5558e77e-438c-84e4-9a58-2520685771a3"
+  },
+  {
+    "key": "lean_demand3_repunits_repeat_mod_seven_every_six_digits",
+    "name": "lean demand3.lean: repunits_repeat_mod_seven_every_six_digits — ∀ n : Nat, repunit (n + 6) % 7 = repunit n % 7 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "a67a8eec-997b-86f2-adbe-b77355dafc70"
+  },
+  {
+    "key": "lean_demand3_a_repunit_has_the_residue_of_its_length_mod_six_mod_seven",
+    "name": "lean demand3.lean: a_repunit_has_the_residue_of_its_length_mod_six_mod_seven — ∀ n : Nat, repunit n % 7 = repunit (n % 6) % 7 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "ec5bf7fe-1dd8-863d-8443-8682088d254b"
+  },
+  {
+    "key": "lean_demand3_a_repunit_is_divisible_by_seven_exactly_when_six_divides_its_length_for_every_n",
+    "name": "lean demand3.lean: a_repunit_is_divisible_by_seven_exactly_when_six_divides_its_length_for_every_n — ∀ n : Nat, (repunit n % 7 = 0) ↔ (n % 6 = 0) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "2bb98278-186d-8284-9c6e-9c9e74177679"
+  },
+  {
+    "key": "lean_elementary_the_interior_and_exterior_angles_are_n_straight_angles_for_every_n",
+    "name": "lean elementary.lean: the_interior_and_exterior_angles_are_n_straight_angles_for_every_n — ∀ n : Nat, 2 ≤ n → (n - 2) * 180 + 360 = n * 180 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "d1fbd7f1-d1df-8c7f-bb56-d565780d1db2"
+  },
+  {
+    "key": "lean_elementary_a_product_of_consecutive_numbers_is_even",
+    "name": "lean elementary.lean: a_product_of_consecutive_numbers_is_even — ∀ n : Nat, n * (n + 1) % 2 = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "cf763033-1ed3-82d8-866e-88ea2a38b2d1"
+  },
+  {
+    "key": "lean_elementary_eight_times_a_triangular_number_plus_one_is_an_odd_square_for_every_n",
+    "name": "lean elementary.lean: eight_times_a_triangular_number_plus_one_is_an_odd_square_for_every_n — ∀ n : Nat, 8 * (n * (n + 1) / 2) + 1 = (2 * n + 1) * (2 * n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "1aa59ef6-880c-8e39-b946-1b88e426040e"
+  },
+  {
+    "key": "lean_energy_two_parts_in_three_is_two_thirds_at_every_scale_for_every_m",
+    "name": "lean energy.lean: two_parts_in_three_is_two_thirds_at_every_scale_for_every_m — ∀ m : Nat, 0 < m → pct (2 * m) (3 * m) = 66 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "9177c3d3-8280-8d65-9df5-c27b42454279"
+  },
+  {
+    "key": "lean_families_the_powers_of_two_sum_to_one_less_than_the_next_for_every_n",
+    "name": "lean families.lean: the_powers_of_two_sum_to_one_less_than_the_next_for_every_n — ∀ n : Nat, ((List.range (n + 1)).map (fun i => 2 ^ i)).foldl (· + ·) 0 = 2 ^ (n + 1) - 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "3cab57ca-4d36-8f80-a221-21c11d25adc9"
+  },
+  {
+    "key": "lean_families_square_of_successor",
+    "name": "lean families.lean: square_of_successor — ∀ n : Nat, (n + 1) * (n + 1) = n * n + 2 * n + 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "f9826dc5-b85d-8a85-800b-f6027e83a0cf"
+  },
+  {
+    "key": "lean_families_the_first_n_odd_numbers_sum_to_n_squared_for_every_n",
+    "name": "lean families.lean: the_first_n_odd_numbers_sum_to_n_squared_for_every_n — ∀ n : Nat, ((List.range n).map (fun i => 2 * i + 1)).foldl (· + ·) 0 = n * n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "7baff487-adea-8866-9d67-71fbbb0cdee6"
+  },
+  {
+    "key": "lean_mechanical_consecutive_squares_differ_by_the_odd_numbers",
+    "name": "lean mechanical.lean: consecutive_squares_differ_by_the_odd_numbers — ∀ n : Nat, (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": "65131201-9df7-8805-8427-c1407fcd92cf"
+  },
+  {
+    "key": "lean_mechanical_every_multiple_of_three_four_five_is_pythagorean",
+    "name": "lean mechanical.lean: every_multiple_of_three_four_five_is_pythagorean — ∀ k : Nat, (3 * k) ^ 2 + (4 * k) ^ 2 = (5 * k) ^ 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "a20992d7-56ea-8048-a939-96fc2fdc451d"
+  },
+  {
+    "key": "lean_mechanical_the_product_of_three_consecutive_numbers_is_even",
+    "name": "lean mechanical.lean: the_product_of_three_consecutive_numbers_is_even — ∀ n : Nat, n * (n + 1) * (n + 2) % 2 = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "0eb7327f-0789-8918-8365-8d4188436e01"
+  },
+  {
+    "key": "lean_mechanical_the_product_of_three_consecutive_numbers_is_a_multiple_of_three",
+    "name": "lean mechanical.lean: the_product_of_three_consecutive_numbers_is_a_multiple_of_three — ∀ n : Nat, n * (n + 1) * (n + 2) % 3 = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "f3e2ee80-28d1-89e3-92c7-082265ef98dc"
+  },
+  {
+    "key": "lean_mechanical_the_product_of_any_three_consecutive_integers_is_divisible_by_six_for_every_n",
+    "name": "lean mechanical.lean: the_product_of_any_three_consecutive_integers_is_divisible_by_six_for_every_n — ∀ n : Nat, n * (n + 1) * (n + 2) % 6 = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "65518577-2bc3-82a2-97f8-f6cd4f7d1b62"
+  },
+  {
+    "key": "lean_reversal_foldl_add_start",
+    "name": "lean reversal.lean: foldl_add_start — ∀ (l : List Nat) (a : Nat), l.foldl (· + ·) a = a + l.foldl (· + ·) 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "70a7cff5-e668-8f44-a8d0-797abfa246c8"
+  },
+  {
+    "key": "lean_reversal_the_digits_sum_to_the_number_mod_nine_when_the_fuel_covers_them",
+    "name": "lean reversal.lean: the_digits_sum_to_the_number_mod_nine_when_the_fuel_covers_them — ∀ f n : Nat, n < 10 ^ f → (digitsF f n).foldl (· + ·) 0 % 9 = n % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "58d4c502-7f73-8e6c-923e-76fdf25fc81c"
+  },
+  {
+    "key": "lean_reversal_a_number_is_below_ten_to_its_own_successor",
+    "name": "lean reversal.lean: a_number_is_below_ten_to_its_own_successor — ∀ n : Nat, n < 10 ^ (n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "dc7330c0-7a4c-8d99-9874-37c4c10fd1bb"
+  },
+  {
+    "key": "lean_reversal_the_digit_sum_has_the_residue_of_the_number_mod_nine_for_every_n",
+    "name": "lean reversal.lean: the_digit_sum_has_the_residue_of_the_number_mod_nine_for_every_n — ∀ n : Nat, digitSum n % 9 = n % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "1a8922c4-c55c-88a0-b55a-23663d22fe49"
+  },
+  {
+    "key": "lean_reversal_folding_by_ten_keeps_the_residue_of_the_digit_sum",
+    "name": "lean reversal.lean: folding_by_ten_keeps_the_residue_of_the_digit_sum — ∀ (l : List Nat) (a : Nat), (l.foldl (fun a d => a * 10 + d) a) % 9 = (a + l.foldl (· + ·) 0) % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c7ce0223-8884-8e3a-84a1-dded449c3cb0"
+  },
+  {
+    "key": "lean_reversal_reversal_keeps_the_residue_mod_nine_for_every_n",
+    "name": "lean reversal.lean: reversal_keeps_the_residue_mod_nine_for_every_n — ∀ n : Nat, reverseNum n % 9 = n % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "3159b043-f18c-8c28-b831-114d6dc70ce2"
+  },
+  {
+    "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"
   }
 ]

package/src/proof/elementary.lean

@@ -398,4 +398,29 @@ theorem the_unit_graph_is_complete_bipartite_between_the_two_tetrahedra :
 def settledHere : Nat := 32
 theorem elementary_settles_its_range : settledHere = 32 := rfl
 
+
+-- ── the capped rows above, proved for every value — no bound ──────────────────────────────────────────────────
+-- the_interior_and_exterior_angles_are_n_straight_angles checked 3 ≤ n ≤ 32; this proves it for every n ≥ 2.
+theorem the_interior_and_exterior_angles_are_n_straight_angles_for_every_n :
+    ∀ n : Nat, 2 ≤ n → (n - 2) * 180 + 360 = n * 180 := by
+  intro n h
+  omega
+
+theorem a_product_of_consecutive_numbers_is_even : ∀ n : Nat, n * (n + 1) % 2 = 0 := by
+  intro n
+  rcases Nat.mod_two_eq_zero_or_one n with h | h <;> simp [Nat.mul_mod, Nat.add_mod, h]
+
+-- eight_times_a_triangular_number_plus_one_is_an_odd_square checked n < 60; this proves it for every n.
+theorem eight_times_a_triangular_number_plus_one_is_an_odd_square_for_every_n :
+    ∀ n : Nat, 8 * (n * (n + 1) / 2) + 1 = (2 * n + 1) * (2 * n + 1) := by
+  intro n
+  have hdiv : n * (n + 1) / 2 * 2 = n * (n + 1) :=
+    Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero (a_product_of_consecutive_numbers_is_even n))
+  have hexp : (2 * n + 1) * (2 * n + 1) = 4 * (n * (n + 1)) + 1 := by
+    rw [Nat.mul_add n n 1, Nat.mul_one, Nat.add_mul, Nat.mul_add, Nat.mul_add, Nat.mul_one, Nat.one_mul]
+    rw [Nat.mul_assoc 2 n (2 * n), Nat.mul_comm n (2 * n), Nat.mul_assoc 2 n n]
+    omega
+  rw [hexp]
+  omega
+
 end Elementary

package/src/proof/energy.lean

@@ -279,4 +279,13 @@ 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
 
+
+-- ── the capped row above, proved for every value — no bound ───────────────────────────────────────────────────
+-- two_parts_in_three_is_two_thirds_at_every_scale checked 1 ≤ m ≤ 500; this proves the ratio part for every m.
+theorem two_parts_in_three_is_two_thirds_at_every_scale_for_every_m :
+    ∀ m : Nat, 0 < m → pct (2 * m) (3 * m) = 66 := by
+  intro m hm
+  unfold pct
+  rw [Nat.mul_comm 2 m, Nat.mul_assoc, Nat.mul_comm 3 m, Nat.mul_div_mul_left _ _ hm]
+
 end Energy

package/src/proof/families.lean

@@ -184,9 +184,9 @@ def digitsF : Nat → Nat → List Nat
   | 0, _ => []
   | _, 0 => []
   | Nat.succ f, n => n % 10 :: digitsF f (n / 10)
--- fuel 20 covers every Nat that fits in 64 bits; a fuel just large enough for the range below would
--- silently truncate the digits of any larger number a later theorem passed in
-def digitsOf (n : Nat) : List Nat := digitsF 20 n
+-- the fuel is n + 1, which covers every digit of every n: the earlier fuel of 20 capped this at twenty digits
+-- and silently truncated anything larger
+def digitsOf (n : Nat) : List Nat := digitsF (n + 1) n
 def reverseDigits (n : Nat) : Nat := (digitsOf n).foldl (fun a d => a * 10 + d) 0
 def digitalRoot (n : Nat) : Nat := if n == 0 then 0 else 1 + (n - 1) % 9
 
@@ -447,4 +447,36 @@ theorem choose_is_invariant_under_the_involution_k_to_n_minus_k :
 def settledHere : Nat := 42
 theorem families_settle_their_ranges : settledHere = 42 := rfl
 
+
+-- ── the capped rows above, proved for every value by induction — no bound ────────────────────────────────────
+-- the_powers_of_two_sum_to_one_less_than_the_next checked n ≤ 40; this proves it for every n.
+theorem the_powers_of_two_sum_to_one_less_than_the_next_for_every_n :
+    ∀ n : Nat, ((List.range (n + 1)).map (fun i => 2 ^ i)).foldl (· + ·) 0 = 2 ^ (n + 1) - 1 := by
+  intro n
+  induction n with
+  | zero => decide
+  | succ n ih =>
+    rw [List.range_succ, List.map_append, List.foldl_append, ih]
+    simp only [List.map, List.foldl]
+    have h : 1 ≤ 2 ^ (n + 1) := Nat.one_le_two_pow
+    rw [Nat.pow_succ 2 (n + 1)]
+    omega
+
+theorem square_of_successor : ∀ n : Nat, (n + 1) * (n + 1) = n * n + 2 * n + 1 := by
+  intro n
+  rw [Nat.add_mul, Nat.mul_add, Nat.mul_one, Nat.one_mul]
+  omega
+
+-- the_first_n_odd_numbers_sum_to_n_squared checked n ≤ 200; this proves it for every n.
+theorem the_first_n_odd_numbers_sum_to_n_squared_for_every_n :
+    ∀ n : Nat, ((List.range n).map (fun i => 2 * i + 1)).foldl (· + ·) 0 = n * n := by
+  intro n
+  induction n with
+  | zero => decide
+  | succ n ih =>
+    rw [List.range_succ, List.map_append, List.foldl_append, ih]
+    simp only [List.map, List.foldl]
+    rw [square_of_successor]
+    omega
+
 end Families

package/src/proof/mechanical.lean

@@ -418,4 +418,38 @@ theorem a_reflexive_address_claim_holds_for_a_constant_function :
 -- recording. What is now published beside them is exactly where a critic should aim, which is the whole of
 -- what "claim boldly" can honestly mean — the falsifier travels with the claim.
 
+
+-- ── the capped rows above, proved for every value by induction and case analysis — no bound ──────────────────
+-- the_difference_of_consecutive_squares_is_the_odd_numbers checked n ≤ 500; this proves it for every n.
+theorem consecutive_squares_differ_by_the_odd_numbers : ∀ n : Nat, (n + 1) ^ 2 - n * n = 2 * n + 1 := by
+  intro n
+  have h : (n + 1) ^ 2 = n * n + (2 * n + 1) := by
+    rw [Nat.pow_two, Nat.add_mul, Nat.mul_add, Nat.mul_one, Nat.one_mul]
+    omega
+  omega
+
+-- there_are_infinitely_many_pythagorean_triples checked k ≤ 100; here every multiple of (3, 4, 5) is a triple, for every k.
+-- prior_art_theorem: every_multiple_of_three_four_five_is_pythagorean — the 3-4-5 triangle, known in antiquity
+theorem every_multiple_of_three_four_five_is_pythagorean : ∀ k : Nat, (3 * k) ^ 2 + (4 * k) ^ 2 = (5 * k) ^ 2 := by
+  intro k
+  rw [Nat.mul_pow, Nat.mul_pow, Nat.mul_pow]
+  omega
+
+theorem the_product_of_three_consecutive_numbers_is_even : ∀ n : Nat, n * (n + 1) * (n + 2) % 2 = 0 := by
+  intro n
+  rcases Nat.mod_two_eq_zero_or_one n with h | h <;> simp [Nat.mul_mod, Nat.add_mod, h]
+
+theorem the_product_of_three_consecutive_numbers_is_a_multiple_of_three : ∀ n : Nat, n * (n + 1) * (n + 2) % 3 = 0 := by
+  intro n
+  have : n % 3 = 0 ∨ n % 3 = 1 ∨ n % 3 = 2 := by omega
+  rcases this with h | h | h <;> simp [Nat.mul_mod, Nat.add_mod, h]
+
+-- the_product_of_any_three_consecutive_integers_is_divisible_by_six checked n ≤ 500; this proves it for every n.
+theorem the_product_of_any_three_consecutive_integers_is_divisible_by_six_for_every_n :
+    ∀ n : Nat, n * (n + 1) * (n + 2) % 6 = 0 := by
+  intro n
+  have h2 := the_product_of_three_consecutive_numbers_is_even n
+  have h3 := the_product_of_three_consecutive_numbers_is_a_multiple_of_three n
+  omega
+
 end Mechanical