@ceccec/millennium-solutions 9.2.7 → 9.2.9

package/speedup.md

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

@@ -18896,5 +18896,150 @@
     "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"
+  },
+  {
+    "key": "lean_nim_the_xor_of_two_bits_is_their_sum_mod_two",
+    "name": "lean nim.lean: the_xor_of_two_bits_is_their_sum_mod_two — ∀ x y : Nat, (if x % 2 == y % 2 then 0 else 1) = (x + y) % 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "322304d5-f000-8492-8e7f-69ce46520610"
+  },
+  {
+    "key": "lean_nim_xor_commutes_at_every_fuel",
+    "name": "lean nim.lean: xor_commutes_at_every_fuel — ∀ f a b : Nat, xorF f a b = xorF f b a — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "b091d5a8-4e4a-8116-93d8-199afc028903"
+  },
+  {
+    "key": "lean_nim_one_more_step_of_fuel_changes_nothing_once_it_exceeds_an_argument",
+    "name": "lean nim.lean: one_more_step_of_fuel_changes_nothing_once_it_exceeds_an_argument — ∀ f a b : Nat, (a < f ∨ b < f) → xorF (f + 1) a b = xorF f a b — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "adf2ef5a-ef44-84b9-adb7-2edf0437284f"
+  },
+  {
+    "key": "lean_nim_more_fuel_changes_nothing_once_it_exceeds_an_argument",
+    "name": "lean nim.lean: more_fuel_changes_nothing_once_it_exceeds_an_argument — ∀ k f a b : Nat, (a < f ∨ b < f) → xorF (f + k) a b = xorF f a b — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "961d94be-959c-80ff-b0c4-03079551178a"
+  },
+  {
+    "key": "lean_nim_xor_reads_the_same_at_every_sufficient_fuel",
+    "name": "lean nim.lean: xor_reads_the_same_at_every_sufficient_fuel — ∀ g a b : Nat, (a < g ∨ b < g) → xorN a b = xorF g a b — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e04a45b5-8834-8bc4-bf6e-bff90869081f"
+  },
+  {
+    "key": "lean_nim_a_number_xored_with_itself_is_zero_at_every_fuel",
+    "name": "lean nim.lean: a_number_xored_with_itself_is_zero_at_every_fuel — ∀ f b : Nat, xorF f b b = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "409e78df-b565-83bb-b177-aa46813c1cb7"
+  },
+  {
+    "key": "lean_nim_xor_splits_off_its_lowest_bit",
+    "name": "lean nim.lean: xor_splits_off_its_lowest_bit — ∀ g x c : Nat, 1 ≤ g → xorF (g + 1) x c = (x + c) % 2 + 2 * xorF g (x / 2) (c / 2) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "fa8f797f-95fa-80c6-9abc-4bd21309d53a"
+  },
+  {
+    "key": "lean_nim_xor_undoes_itself_when_the_fuel_suffices",
+    "name": "lean nim.lean: xor_undoes_itself_when_the_fuel_suffices — ∀ f a b g : Nat, (a < f ∨ b < f) → b < g → xorF g (xorF f a b) b = a — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "ba799e13-9cb6-8fc8-ab55-3879eb845e7f"
+  },
+  {
+    "key": "lean_nim_xor_is_commutative_for_every_a_b",
+    "name": "lean nim.lean: xor_is_commutative_for_every_a_b — ∀ a b : Nat, xorN a b = xorN b a — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e62bc467-f90b-8bb2-844c-c44676d6fce0"
+  },
+  {
+    "key": "lean_nim_xor_zero_is_identity_for_every_a",
+    "name": "lean nim.lean: xor_zero_is_identity_for_every_a — ∀ a : Nat, xorN a 0 = a — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "667bd69d-51ea-88da-a48e-ce4a33c4f518"
+  },
+  {
+    "key": "lean_nim_xor_is_its_own_inverse_for_every_a_b",
+    "name": "lean nim.lean: xor_is_its_own_inverse_for_every_a_b — ∀ a b : Nat, xorN (xorN a b) b = a — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e2f6d0f1-2fa2-832e-b884-1ac9f13160a0"
+  },
+  {
+    "key": "lean_nim_xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves",
+    "name": "lean nim.lean: xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves — ∀ a b : Nat, xorN a b = (a + b) % 2 + 2 * xorN (a / 2) (b / 2) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "07c467d9-8226-81d4-93b2-612ebd433b2b"
+  },
+  {
+    "key": "lean_nim_xor_is_associative_below_every_bound",
+    "name": "lean nim.lean: xor_is_associative_below_every_bound — ∀ n a b c : Nat, a + b + c ≤ n → xorN (xorN a b) c = xorN a (xorN b c) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "0c3ef805-2811-8035-a30b-cc03489171c1"
+  },
+  {
+    "key": "lean_nim_xor_is_associative_for_every_a_b_c",
+    "name": "lean nim.lean: xor_is_associative_for_every_a_b_c — ∀ a b c : Nat, xorN (xorN a b) c = xorN a (xorN b c) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "d2a922d9-f09d-82db-ae54-2f92149512c9"
+  },
+  {
+    "key": "lean_nim_the_nim_sum_is_a_gf2_vector_addition_for_every_a_b_c",
+    "name": "lean nim.lean: the_nim_sum_is_a_gf2_vector_addition_for_every_a_b_c — ∀ a b c : Nat, xorN a b = xorN b a ∧ xorN (xorN a b) c = xorN a (xorN b c) ∧ xorN (xorN a b) b = a ∧ xorN a 0 = a — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "caa5c327-62cf-8171-9507-6453cfdaed0c"
   }
 ]

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/nim.lean

@@ -16,13 +16,16 @@ set_option maxHeartbeats 2000000
 -- stated in each name rather than implied.
 --
 -- XOR is imported from Fnv rather than restated: it is the same fuel-bounded structural fold, built because
--- Nat's bitwise operations are well-founded and would drag `propext` into every theorem here.
+-- Nat's bitwise operations are well-founded and would drag `propext` into every theorem here. Its laws are
+-- proved below for every a, b, c, on the standard axioms; the decided rows above stay as their instances.
 
 namespace Nim
 
 open Fnv (xorF)
 
-def xorN (a b : Nat) : Nat := xorF 33 a b
+-- the fuel is a + b + 1, which always exceeds what the fold needs (each step halves both arguments and the fold
+-- stops at the first zero); the earlier fuel of 33 read XOR correctly only below 2³³ — a cap, now gone
+def xorN (a b : Nat) : Nat := xorF (a + b + 1) a b
 -- The board is SMALL and stated, because the game tree is exponential: deciding `lost` explores every play
 -- from every position, and at 8x8 the kernel exceeds its heartbeat budget. Six is what `decide` settles here
 -- in reasonable time. A larger board is not a harder theorem, it is a longer computation — and claiming the
@@ -42,7 +45,7 @@ def lost : Nat → Nat → Nat → Bool
 def isLost (a b : Nat) : Bool := lost (a + b + 1) a b
 
 -- ── BOUTON: a two-heap position is lost for the mover exactly when the heaps are equal — which is exactly
---    when their XOR is zero. Decided over every position on the 8×8 board. ──
+--    when their XOR is zero. Decided over every position on the N×N board, N = 6. ──
 theorem bouton_two_heaps_lost_iff_xor_zero :
   (List.range N).all (fun a => (List.range N).all (fun b =>
     isLost a b == (xorN a b == 0))) := by decide
@@ -102,4 +105,207 @@ set_option maxRecDepth 4000000 in
 theorem bouton_holds_at_every_heap_size_to_six :
   (List.range 7).all (fun a => (List.range 7).all (fun b => isLost a b == (xorN a b == 0))) := by decide
 
+
+-- ── XOR's algebra for every a, b, c — no bound ───────────────────────────────────────────────────────────────
+-- xor_is_its_own_inverse and xor_is_commutative (a, b < 16), xor_zero_is_identity (a < 32) and
+-- the_nim_sum_is_a_gf2_vector_addition (a, b, c < 16) were decided over a range; these prove them for every value.
+-- The fold's fuel is a + b + 1, which always suffices: once it exceeds either argument, more fuel changes nothing,
+-- so xorN reads the same at any sufficient fuel. Everything follows from one step — the low bit of a XOR is the sum
+-- of the low bits mod 2, and the rest is twice the XOR of the halves — by induction. Bouton's theorem itself is
+-- still decided over the N×N board above; a proof of it for every heap is a game-tree induction not done here.
+theorem the_xor_of_two_bits_is_their_sum_mod_two :
+    ∀ x y : Nat, (if x % 2 == y % 2 then 0 else 1) = (x + y) % 2 := by
+  intro x y
+  split
+  · rename_i h
+    have := beq_iff_eq.mp h
+    omega
+  · rename_i h
+    have : x % 2 ≠ y % 2 := fun e => h (beq_iff_eq.mpr e)
+    omega
+
+theorem xor_commutes_at_every_fuel : ∀ f a b : Nat, xorF f a b = xorF f b a := by
+  intro f
+  induction f with
+  | zero => intro a b; cases a <;> cases b <;> rfl
+  | succ f ih =>
+    intro a b
+    cases a with
+    | zero => cases b <;> rfl
+    | succ a =>
+      cases b with
+      | zero => rfl
+      | succ b =>
+        show (if (a + 1) % 2 == (b + 1) % 2 then 0 else 1) + 2 * xorF f ((a + 1) / 2) ((b + 1) / 2) =
+          (if (b + 1) % 2 == (a + 1) % 2 then 0 else 1) + 2 * xorF f ((b + 1) / 2) ((a + 1) / 2)
+        rw [ih ((a + 1) / 2), the_xor_of_two_bits_is_their_sum_mod_two, the_xor_of_two_bits_is_their_sum_mod_two]
+        omega
+
+theorem one_more_step_of_fuel_changes_nothing_once_it_exceeds_an_argument :
+    ∀ f a b : Nat, (a < f ∨ b < f) → xorF (f + 1) a b = xorF f a b := by
+  intro f
+  induction f with
+  | zero => intro a b h; rcases h with h | h <;> exact absurd h (Nat.not_lt_zero _)
+  | succ f ih =>
+    intro a b h
+    cases a with
+    | zero => cases b <;> rfl
+    | succ a =>
+      cases b with
+      | zero => rfl
+      | succ b =>
+        show (if (a + 1) % 2 == (b + 1) % 2 then 0 else 1) + 2 * xorF (f + 1) ((a + 1) / 2) ((b + 1) / 2) =
+          (if (a + 1) % 2 == (b + 1) % 2 then 0 else 1) + 2 * xorF f ((a + 1) / 2) ((b + 1) / 2)
+        have h' : (a + 1) / 2 < f ∨ (b + 1) / 2 < f := by
+          rcases h with h | h
+          · exact Or.inl (by omega)
+          · exact Or.inr (by omega)
+        rw [ih _ _ h']
+
+theorem more_fuel_changes_nothing_once_it_exceeds_an_argument :
+    ∀ k f a b : Nat, (a < f ∨ b < f) → xorF (f + k) a b = xorF f a b := by
+  intro k
+  induction k with
+  | zero => intro f a b _; rfl
+  | succ k ih =>
+    intro f a b h
+    have h' : a < f + k ∨ b < f + k := by
+      rcases h with h | h
+      · exact Or.inl (by omega)
+      · exact Or.inr (by omega)
+    rw [← Nat.add_assoc, one_more_step_of_fuel_changes_nothing_once_it_exceeds_an_argument _ _ _ h', ih f a b h]
+
+theorem xor_reads_the_same_at_every_sufficient_fuel :
+    ∀ g a b : Nat, (a < g ∨ b < g) → xorN a b = xorF g a b := by
+  intro g a b h
+  unfold xorN
+  have h1 : a < a + b + 1 ∨ b < a + b + 1 := Or.inl (by omega)
+  rw [← more_fuel_changes_nothing_once_it_exceeds_an_argument g (a + b + 1) a b h1,
+    ← more_fuel_changes_nothing_once_it_exceeds_an_argument (a + b + 1) g a b h, Nat.add_comm g]
+
+theorem a_number_xored_with_itself_is_zero_at_every_fuel : ∀ f b : Nat, xorF f b b = 0 := by
+  intro f
+  induction f with
+  | zero => intro b; cases b <;> rfl
+  | succ f ih =>
+    intro b
+    cases b with
+    | zero => rfl
+    | succ b =>
+      show (if (b + 1) % 2 == (b + 1) % 2 then 0 else 1) + 2 * xorF f ((b + 1) / 2) ((b + 1) / 2) = 0
+      rw [ih, the_xor_of_two_bits_is_their_sum_mod_two]
+      omega
+
+theorem xor_splits_off_its_lowest_bit :
+    ∀ g x c : Nat, 1 ≤ g → xorF (g + 1) x c = (x + c) % 2 + 2 * xorF g (x / 2) (c / 2) := by
+  intro g x c hg
+  obtain ⟨g', rfl⟩ : ∃ g', g = g' + 1 := ⟨g - 1, by omega⟩
+  cases x with
+  | zero =>
+    rw [show xorF (g' + 1 + 1) 0 c = c by cases c <;> rfl, Nat.zero_div,
+      show xorF (g' + 1) 0 (c / 2) = c / 2 by cases (c / 2) <;> rfl]
+    omega
+  | succ x =>
+    cases c with
+    | zero =>
+      rw [show xorF (g' + 1 + 1) (x + 1) 0 = x + 1 from rfl, Nat.zero_div,
+        show xorF (g' + 1) ((x + 1) / 2) 0 = (x + 1) / 2 by cases ((x + 1) / 2) <;> rfl]
+      omega
+    | succ c =>
+      show (if (x + 1) % 2 == (c + 1) % 2 then 0 else 1) + 2 * xorF (g' + 1) ((x + 1) / 2) ((c + 1) / 2) = _
+      rw [the_xor_of_two_bits_is_their_sum_mod_two]
+
+theorem xor_undoes_itself_when_the_fuel_suffices :
+    ∀ f a b g : Nat, (a < f ∨ b < f) → b < g → xorF g (xorF f a b) b = a := by
+  intro f
+  induction f with
+  | zero => intro a b g h; rcases h with h | h <;> exact absurd h (Nat.not_lt_zero _)
+  | succ f ih =>
+    intro a b g h hg
+    cases a with
+    | zero =>
+      rw [show xorF (f + 1) 0 b = b by cases b <;> rfl]
+      exact a_number_xored_with_itself_is_zero_at_every_fuel g b
+    | succ a =>
+      cases b with
+      | zero =>
+        obtain ⟨g', rfl⟩ : ∃ g', g = g' + 1 := ⟨g - 1, by omega⟩
+        rfl
+      | succ b =>
+        obtain ⟨g', rfl⟩ : ∃ g', g = g' + 1 := ⟨g - 1, by omega⟩
+        have hf : (a + 1) / 2 < f ∨ (b + 1) / 2 < f := by
+          rcases h with h | h
+          · exact Or.inl (by omega)
+          · exact Or.inr (by omega)
+        have ih' := ih ((a + 1) / 2) ((b + 1) / 2) g' hf (by omega)
+        rw [xor_splits_off_its_lowest_bit g' _ _ (by omega)]
+        rw [show xorF (f + 1) (a + 1) (b + 1) = (if (a + 1) % 2 == (b + 1) % 2 then 0 else 1) +
+          2 * xorF f ((a + 1) / 2) ((b + 1) / 2) from rfl, the_xor_of_two_bits_is_their_sum_mod_two]
+        generalize xorF f ((a + 1) / 2) ((b + 1) / 2) = y at ih' ⊢
+        have e : ((a + 1 + (b + 1)) % 2 + 2 * y) / 2 = y := by omega
+        rw [e, ih']
+        omega
+
+theorem xor_is_commutative_for_every_a_b : ∀ a b : Nat, xorN a b = xorN b a := by
+  intro a b
+  unfold xorN
+  rw [Nat.add_comm a b, xor_commutes_at_every_fuel]
+
+theorem xor_zero_is_identity_for_every_a : ∀ a : Nat, xorN a 0 = a := by
+  intro a
+  unfold xorN
+  cases a <;> rfl
+
+theorem xor_is_its_own_inverse_for_every_a_b : ∀ a b : Nat, xorN (xorN a b) b = a := by
+  intro a b
+  rw [xor_reads_the_same_at_every_sufficient_fuel (b + 1) (xorN a b) b (Or.inr (by omega))]
+  unfold xorN
+  exact xor_undoes_itself_when_the_fuel_suffices (a + b + 1) a b (b + 1) (Or.inl (by omega)) (by omega)
+theorem xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves :
+    ∀ a b : Nat, xorN a b = (a + b) % 2 + 2 * xorN (a / 2) (b / 2) := by
+  intro a b
+  rw [xor_reads_the_same_at_every_sufficient_fuel (a + b + 1 + 1) a b (Or.inl (by omega)),
+    xor_splits_off_its_lowest_bit (a + b + 1) a b (by omega),
+    ← xor_reads_the_same_at_every_sufficient_fuel (a + b + 1) (a / 2) (b / 2) (Or.inl (by omega))]
+
+theorem xor_is_associative_below_every_bound :
+    ∀ n a b c : Nat, a + b + c ≤ n → xorN (xorN a b) c = xorN a (xorN b c) := by
+  intro n
+  induction n with
+  | zero =>
+    intro a b c h
+    have ha : a = 0 := by omega
+    have hb : b = 0 := by omega
+    have hc : c = 0 := by omega
+    subst ha hb hc
+    rfl
+  | succ n ih =>
+    intro a b c h
+    if hz : a + b + c = 0 then
+      have ha : a = 0 := by omega
+      have hb : b = 0 := by omega
+      have hc : c = 0 := by omega
+      subst ha hb hc
+      rfl
+    else
+      have ihh := ih (a / 2) (b / 2) (c / 2) (by omega)
+      have hab := xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves a b
+      have hbc := xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves b c
+      have hx2 : xorN a b / 2 = xorN (a / 2) (b / 2) := by omega
+      have hy2 : xorN b c / 2 = xorN (b / 2) (c / 2) := by omega
+      rw [xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves (xorN a b) c,
+        xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves a (xorN b c), hx2, hy2, ihh]
+      omega
+
+theorem xor_is_associative_for_every_a_b_c : ∀ a b c : Nat, xorN (xorN a b) c = xorN a (xorN b c) := by
+  intro a b c
+  exact xor_is_associative_below_every_bound (a + b + c) a b c (Nat.le_refl _)
+
+theorem the_nim_sum_is_a_gf2_vector_addition_for_every_a_b_c :
+    ∀ a b c : Nat, xorN a b = xorN b a ∧ xorN (xorN a b) c = xorN a (xorN b c) ∧
+      xorN (xorN a b) b = a ∧ xorN a 0 = a := by
+  intro a b c
+  exact ⟨xor_is_commutative_for_every_a_b a b, xor_is_associative_for_every_a_b_c a b c,
+    xor_is_its_own_inverse_for_every_a_b a b, xor_zero_is_identity_for_every_a a⟩
+
 end Nim