@ceccec/millennium-solutions 9.3.2 → 9.3.3

package/speedup.md

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

@@ -144,4 +144,25 @@ theorem the_fourth_group_is_variant_two_over_fourteen_hash_bits :
   rw [the_variant_stamp_keeps_the_low_six_bits_of_every_byte b8 h8]
   exact ⟨by omega, by omega⟩
 
+
+-- ── reflections, from the xor batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTIONS: the unstamped bits read back from the stamped byte, and the hash bits from the group
+theorem the_unstamped_bits_read_back_from_every_stamped_byte :
+    ∀ b : Nat, b < 256 → and8 (or8 (and8 b 15) 128) 15 = b % 16 ∧ and8 (or8 (and8 b 63) 128) 63 = b % 64 := by
+  decide
+
+theorem the_twelve_hash_bits_read_back_from_the_third_group :
+    ∀ b6 b7 : Nat, b6 < 256 → b7 < 256 →
+      ((or8 (and8 b6 15) 128) * 256 + b7) / 4096 = 8 ∧ ((or8 (and8 b6 15) 128) * 256 + b7) % 4096 = b6 % 16 * 256 + b7 := by
+  intro b6 b7 h6 h7
+  rw [the_version_stamp_keeps_the_low_nibble_of_every_byte b6 h6]
+  exact ⟨by omega, by omega⟩
+
+theorem the_fourteen_hash_bits_read_back_from_the_fourth_group :
+    ∀ b8 b9 : Nat, b8 < 256 → b9 < 256 →
+      ((or8 (and8 b8 63) 128) * 256 + b9) / 16384 = 2 ∧ ((or8 (and8 b8 63) 128) * 256 + b9) % 16384 = b8 % 64 * 256 + b9 := by
+  intro b8 b9 h8 h9
+  rw [the_variant_stamp_keeps_the_low_six_bits_of_every_byte b8 h8]
+  exact ⟨by omega, by omega⟩
+
 end Address

package/src/proof/demand.lean

@@ -131,4 +131,30 @@ theorem mantels_bound_is_n_squared_over_four_for_every_n :
     rw [h1, show 2 * m + 1 - m = m + 1 by omega, h2]
     omega
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem four_times_a_near_product_is_at_most_the_square :
+    ∀ a d : Nat, a * (a + d) * 4 ≤ (a + (a + d)) * (a + (a + d)) := by
+  intro a d
+  have e1 : a * (a + d) = a * a + a * d := Nat.mul_add a a d
+  have e2 : (a + (a + d)) * (a + (a + d)) = 4 * (a * a) + 4 * (a * d) + d * d := by
+    rw [show a + (a + d) = 2 * a + d by omega, Nat.add_mul, Nat.mul_add, Nat.mul_add,
+      Nat.mul_assoc 2 a (2 * a), Nat.mul_comm a (2 * a), Nat.mul_assoc 2 a a, Nat.mul_assoc 2 a d,
+      Nat.mul_comm d (2 * a), Nat.mul_assoc 2 a d]
+    omega
+  rw [e1, e2]
+  omega
+
+theorem no_cut_beats_the_balanced_one_for_every_n :
+    ∀ n a : Nat, a ≤ n → a * (n - a) ≤ n * n / 4 := by
+  intro n a h
+  obtain ⟨b, rfl⟩ : ∃ b, n = a + b := ⟨n - a, by omega⟩
+  rw [show a + b - a = b by omega, Nat.le_div_iff_mul_le (by decide)]
+  rcases Nat.le_total a b with hab | hab
+  · obtain ⟨d, rfl⟩ : ∃ d, b = a + d := ⟨b - a, by omega⟩
+    exact four_times_a_near_product_is_at_most_the_square a d
+  · obtain ⟨d, rfl⟩ : ∃ d, a = b + d := ⟨a - b, by omega⟩
+    rw [Nat.mul_comm (b + d) b, show b + d + b = b + (b + d) by omega]
+    exact four_times_a_near_product_is_at_most_the_square b d
+
 end Demand

package/src/proof/demand2.lean

@@ -204,4 +204,16 @@ theorem the_sum_of_fifth_powers_has_the_closed_form_for_every_n :
   rw [the_two_power_sums_are_one_sum]
   exact the_fifth_powers_sum_to_their_closed_form_for_every_n n
 
+
+-- ── reflections, from the sums batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTION of Nicomachus: the squared triangular numbers difference back to the cubes
+theorem the_squared_triangular_numbers_difference_back_to_the_cubes_for_every_n :
+    ∀ n : Nat, tri (n + 1) * tri (n + 1) = tri n * tri n + (n + 1) ^ 3 := by
+  intro n
+  rw [← nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n (n + 1),
+    ← nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n n,
+    the_two_power_sums_are_one_sum, the_two_power_sums_are_one_sum]
+  unfold powSum
+  exact a_sum_over_one_to_n_plus_one_adds_the_last_term (fun i => i ^ 3) n
+
 end Demand2

package/src/proof/demand3.lean

@@ -180,4 +180,30 @@ theorem a_repunit_is_divisible_by_seven_exactly_when_six_divides_its_length_for_
 -- proved for every genus above; at genus 2 its negative is exactly the fare.
 theorem the_two_coin_fare_is_minus_the_euler_characteristic_at_genus_two : (110 : Int) - 108 = - chi 2 := by decide
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem the_genus_reads_back_from_chi_for_every_g : ∀ g : Nat, ((2 - chi g) / 2).toNat = g := by
+  intro g; unfold chi; omega
+
+theorem chi_is_injective_for_every_g_h : ∀ g h : Nat, chi g = chi h → g = h := by
+  intro g h e; unfold chi at e; omega
+
+theorem a_repunit_is_below_ten_to_its_length : ∀ k : Nat, repunit k < 10 ^ k := by
+  intro k
+  induction k with
+  | zero => decide
+  | succ k ih =>
+    show 10 * repunit k + 1 < 10 ^ (k + 1)
+    rw [Nat.pow_succ]; omega
+
+theorem a_repunit_splits_back_into_its_two_parts_for_every_n_k :
+    ∀ n k : Nat, repunit (n + k) / 10 ^ k = repunit n ∧ repunit (n + k) % 10 ^ k = repunit k := by
+  intro n k
+  have hk := a_repunit_is_below_ten_to_its_length k
+  have hp : 0 < 10 ^ k := by omega
+  rw [repunit_of_a_sum, Nat.add_comm]
+  constructor
+  · rw [Nat.add_mul_div_left _ _ hp, Nat.div_eq_of_lt hk, Nat.zero_add]
+  · rw [Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hk]
+
 end Demand3

package/src/proof/discovered.json

@@ -19121,5 +19121,410 @@
     "key": "lean_fnv_the_split_multiply_is_the_exact_thirty_two_bit_product",
     "name": "lean fnv.lean: the_split_multiply_is_the_exact_thirty_two_bit_product — ∀ a b : Nat, (a % 65536 * b + a / 65536 * b % 65536 * 65536) % M32 = mul32 a b — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
     "receipt": "71d78d5c-0f87-8ff8-84ed-47fb86f64116"
+  },
+  {
+    "key": "lean_energy_the_boundary_is_sharp",
+    "name": "lean energy.lean: the_boundary_is_sharp — mass 5333 0 = mass 0 336 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6237820f-0a7b-8486-9881-2ff730413293"
+  },
+  {
+    "key": "lean_address_the_unstamped_bits_read_back_from_every_stamped_byte",
+    "name": "lean address.lean: the_unstamped_bits_read_back_from_every_stamped_byte — ∀ b : Nat, b < 256 → and8 (or8 (and8 b 15) 128) 15 = b % 16 ∧ and8 (or8 (and8 b 63) 128) 63 = b % 64 — proved by the Lean kernel for every value (by\n  decide), standard axioms only — checked by lean.ts",
+    "receipt": "69a4f3a2-4653-8fa2-9a1c-def31a7802b9"
+  },
+  {
+    "key": "lean_address_the_twelve_hash_bits_read_back_from_the_third_group",
+    "name": "lean address.lean: the_twelve_hash_bits_read_back_from_the_third_group — ∀ b6 b7 : Nat, b6 < 256 → b7 < 256 → ((or8 (and8 b6 15) 128) * 256 + b7) / 4096 = 8 ∧ ((or8 (and8 b6 15) 128) * 256 + b7) % 4096 = b6 % 16 * 256 + b7 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "221f974c-1535-8b78-9067-631b2ca17996"
+  },
+  {
+    "key": "lean_address_the_fourteen_hash_bits_read_back_from_the_fourth_group",
+    "name": "lean address.lean: the_fourteen_hash_bits_read_back_from_the_fourth_group — ∀ b8 b9 : Nat, b8 < 256 → b9 < 256 → ((or8 (and8 b8 63) 128) * 256 + b9) / 16384 = 2 ∧ ((or8 (and8 b8 63) 128) * 256 + b9) % 16384 = b8 % 64 * 256 + b9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "edc4013a-9ea0-88dc-9022-22072a84bfb1"
+  },
+  {
+    "key": "lean_demand_four_times_a_near_product_is_at_most_the_square",
+    "name": "lean demand.lean: four_times_a_near_product_is_at_most_the_square — ∀ a d : Nat, a * (a + d) * 4 ≤ (a + (a + d)) * (a + (a + d)) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "61fde2f2-4a84-8825-8c14-36391ea7f96f"
+  },
+  {
+    "key": "lean_demand_no_cut_beats_the_balanced_one_for_every_n",
+    "name": "lean demand.lean: no_cut_beats_the_balanced_one_for_every_n — ∀ n a : Nat, a ≤ n → a * (n - a) ≤ n * n / 4 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "f87585db-e4be-8f0d-8660-3e5983b57020"
+  },
+  {
+    "key": "lean_demand2_the_squared_triangular_numbers_difference_back_to_the_cubes_for_every_n",
+    "name": "lean demand2.lean: the_squared_triangular_numbers_difference_back_to_the_cubes_for_every_n — ∀ n : Nat, tri (n + 1) * tri (n + 1) = tri n * tri n + (n + 1) ^ 3 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "76f6ba26-b6dd-8d33-8a7d-0e63c055c8ee"
+  },
+  {
+    "key": "lean_demand3_the_genus_reads_back_from_chi_for_every_g",
+    "name": "lean demand3.lean: the_genus_reads_back_from_chi_for_every_g — ∀ g : Nat, ((2 - chi g) / 2).toNat = g — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "b2627057-efa5-8f5e-8f32-eb9988d42765"
+  },
+  {
+    "key": "lean_demand3_chi_is_injective_for_every_g_h",
+    "name": "lean demand3.lean: chi_is_injective_for_every_g_h — ∀ g h : Nat, chi g = chi h → g = h — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "9259ab3c-4bbc-846b-947f-3a1534dbc9f5"
+  },
+  {
+    "key": "lean_demand3_a_repunit_is_below_ten_to_its_length",
+    "name": "lean demand3.lean: a_repunit_is_below_ten_to_its_length — ∀ k : Nat, repunit k < 10 ^ k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "63e37ea7-0f19-8bea-b622-6cce3c740436"
+  },
+  {
+    "key": "lean_demand3_a_repunit_splits_back_into_its_two_parts_for_every_n_k",
+    "name": "lean demand3.lean: a_repunit_splits_back_into_its_two_parts_for_every_n_k — ∀ n k : Nat, repunit (n + k) / 10 ^ k = repunit n ∧ repunit (n + k) % 10 ^ k = repunit k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "56ed7d0a-28d5-81e6-9563-56bff7af5faf"
+  },
+  {
+    "key": "lean_elementary_the_polygon_side_count_reads_back_from_its_angle_sum",
+    "name": "lean elementary.lean: the_polygon_side_count_reads_back_from_its_angle_sum — ∀ n : Nat, 2 ≤ n → ((n - 2) * 180 + 360) / 180 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "0ad62680-b148-8390-bff3-0c2f5a1bc203"
+  },
+  {
+    "key": "lean_elementary_every_odd_square_one_more_than_eight_times_m_makes_m_triangular",
+    "name": "lean elementary.lean: every_odd_square_one_more_than_eight_times_m_makes_m_triangular — ∀ m r : Nat, 8 * m + 1 = r * r → m = r / 2 * (r / 2 + 1) / 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "958b6261-542d-8e25-8df0-b6b19ecae11a"
+  },
+  {
+    "key": "lean_elementary_the_fibonaccis_are_a_fifth_of_the_neighbouring_lucas_numbers_for_every_n",
+    "name": "lean elementary.lean: the_fibonaccis_are_a_fifth_of_the_neighbouring_lucas_numbers_for_every_n — ∀ n : Nat, 5 * fib (n + 1) = lucas n + lucas (n + 2) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "16091996-5977-8dbc-8039-96f7dc68409f"
+  },
+  {
+    "key": "lean_elementary_half_a_product_of_consecutive_numbers_multiplies_back_for_every_n",
+    "name": "lean elementary.lean: half_a_product_of_consecutive_numbers_multiplies_back_for_every_n — ∀ n : Nat, n * (n + 1) / 2 * 2 = n * (n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "cf74f953-f0e2-81bd-be91-59bc297df346"
+  },
+  {
+    "key": "lean_energy_burning_then_splitting_is_the_identity_above_the_bond",
+    "name": "lean energy.lean: burning_then_splitting_is_the_identity_above_the_bond — ∀ e : Nat, bondHundredthsKJ ≤ e → splitE (burnE e) = e — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "fe87a66a-6ac9-8d5a-a9bc-3025533941f6"
+  },
+  {
+    "key": "lean_energy_one_part_in_three_is_a_third_at_every_scale_for_every_m",
+    "name": "lean energy.lean: one_part_in_three_is_a_third_at_every_scale_for_every_m — ∀ m : Nat, 0 < m → pct m (3 * m) = 33 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "b2c52079-42f3-89a2-89f0-8895d2cd34ed"
+  },
+  {
+    "key": "lean_energy_the_gas_volume_reads_back_its_moles_for_every_m",
+    "name": "lean energy.lean: the_gas_volume_reads_back_its_moles_for_every_m — ∀ m : Nat, molesOf (litresOf m) ≤ m ∧ m ≤ molesOf (litresOf m) + 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "21c3d846-9c3e-8112-bbaf-a531fd70fc4a"
+  },
+  {
+    "key": "lean_energy_the_mass_names_the_molecule_below_5333_hydrogens",
+    "name": "lean energy.lean: the_mass_names_the_molecule_below_5333_hydrogens — ∀ h o h' o' : Nat, h < 5333 → h' < 5333 → mass h o = mass h' o' → h = h' ∧ o = o' — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "a30f7f70-4bfa-8bc2-9d76-484eb4626c02"
+  },
+  {
+    "key": "lean_energy_a_floor_division_multiplies_back_within_one_divisor",
+    "name": "lean energy.lean: a_floor_division_multiplies_back_within_one_divisor — ∀ a l : Nat, 0 < l → a / l * l ≤ a ∧ a < (a / l + 1) * l — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c6871639-adb9-8647-b445-116e8dc0bae0"
+  },
+  {
+    "key": "lean_families_choose_is_invariant_under_the_involution_k_to_n_minus_k_for_every_n",
+    "name": "lean families.lean: choose_is_invariant_under_the_involution_k_to_n_minus_k_for_every_n — ∀ n k : Nat, k ≤ n → choose n k = choose n (n - k) ∧ n - (n - k) = k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6133e3a1-254e-8385-8d6a-5d7deacf83b5"
+  },
+  {
+    "key": "lean_families_the_closed_forms_difference_back_to_the_next_power_for_every_n",
+    "name": "lean families.lean: the_closed_forms_difference_back_to_the_next_power_for_every_n — ∀ k n : Nat, 1 ≤ k → k ≤ 5 → faulhaber k (n + 1) = faulhaber k n + (n + 1) ^ k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "b1d34ef3-9b6d-80de-94ba-8b5c67bc4005"
+  },
+  {
+    "key": "lean_families_the_tetrahedral_numbers_difference_back_to_the_triangular_numbers_for_every_n",
+    "name": "lean families.lean: the_tetrahedral_numbers_difference_back_to_the_triangular_numbers_for_every_n — ∀ n : Nat, (n + 1) * (n + 1 + 1) * (n + 1 + 2) / 6 = n * (n + 1) * (n + 2) / 6 + (n + 1) * (n + 1 + 1) / 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e811a0a1-22b9-82d2-b93d-a3a2418a17d2"
+  },
+  {
+    "key": "lean_families_the_powers_of_two_difference_back_to_the_next_power_for_every_n",
+    "name": "lean families.lean: the_powers_of_two_difference_back_to_the_next_power_for_every_n — ∀ n : Nat, (2 ^ (n + 2) - 1) - (2 ^ (n + 1) - 1) = 2 ^ (n + 1) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "9c202e7c-40cb-8382-864c-c5f8119fdf3e"
+  },
+  {
+    "key": "lean_families_the_odd_numbers_difference_back_to_the_next_odd_number_for_every_n",
+    "name": "lean families.lean: the_odd_numbers_difference_back_to_the_next_odd_number_for_every_n — ∀ n : Nat, ((List.range (n + 1)).map (fun i => 2 * i + 1)).foldl (· + ·) 0 - ((List.range n).map (fun i => 2 * i + 1)).foldl (· + ·) 0 = 2 * n + 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "404c2b65-4bb4-8918-8dfe-a2f78dad6317"
+  },
+  {
+    "key": "lean_families_foldl_add_start",
+    "name": "lean families.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": "e29e2887-b564-877a-bcde-e36fde641559"
+  },
+  {
+    "key": "lean_families_the_digits_sum_to_the_number_mod_nine_when_the_fuel_covers_them",
+    "name": "lean families.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": "bdb7dd00-a595-8044-9817-e90462f887b7"
+  },
+  {
+    "key": "lean_families_a_number_is_below_ten_to_its_own_successor",
+    "name": "lean families.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": "6021fd10-1371-857a-a778-b0229ea2f574"
+  },
+  {
+    "key": "lean_families_the_digit_sum_rules_for_three_and_nine_hold_for_every_n",
+    "name": "lean families.lean: the_digit_sum_rules_for_three_and_nine_hold_for_every_n — ∀ n : Nat, (digitSum n % 3 = 0 ↔ n % 3 = 0) ∧ (digitSum n % 9 = 0 ↔ n % 9 = 0) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e4b7bd43-9725-8b09-a08d-852d3f6ca8ba"
+  },
+  {
+    "key": "lean_flow_the_reverse_flow_undoes_every_step",
+    "name": "lean flow.lean: the_reverse_flow_undoes_every_step — ∀ k : Nat, orbit (k + 1) * 5 % 9 = orbit k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "8a31d5e4-e83d-8386-aa0c-5fee601a89e9"
+  },
+  {
+    "key": "lean_flow_every_state_of_the_flow_returns_within_six_steps",
+    "name": "lean flow.lean: every_state_of_the_flow_returns_within_six_steps — ∀ k s : Nat, ∃ j, j < 6 ∧ orbit (k + j) = orbit s — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "fd1cecb4-13df-80ec-befb-9d40a35f6b84"
+  },
+  {
+    "key": "lean_fnv_multiplying_by_the_fnv_prime_is_undone_by_its_inverse_for_every_h",
+    "name": "lean fnv.lean: multiplying_by_the_fnv_prime_is_undone_by_its_inverse_for_every_h — ∀ h : Nat, mul32 (mul32 h FNV_PRIME) 899433627 = h % M32 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "30b021d3-5d2e-8d27-8cd9-1fe8c4829e2d"
+  },
+  {
+    "key": "lean_light_the_metre_returns_from_the_second_for_every_whole_length",
+    "name": "lean light.lean: the_metre_returns_from_the_second_for_every_whole_length — ∀ m : Nat, m % c = 0 → travel (m / c) = m — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "01829703-d2a6-8d75-af32-f41de3d1bf6f"
+  },
+  {
+    "key": "lean_light_the_period_count_returns_from_the_second_for_every_whole_count",
+    "name": "lean light.lean: the_period_count_returns_from_the_second_for_every_whole_count — ∀ p : Nat, p % dNuCs = 0 → periods (p / dNuCs) = p — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "917672f5-d4d0-8ce6-b8ff-6cefdd6ee768"
+  },
+  {
+    "key": "lean_mechanical_DR_eq",
+    "name": "lean mechanical.lean: DR_eq — ∀ n : Nat, DR n = if n = 0 then 0 else 1 + (n - 1) % 9 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "dec26379-71e5-8ef4-9435-5bccc3d05d4a"
+  },
+  {
+    "key": "lean_mechanical_halving_undoes_every_doubling_step_for_every_k",
+    "name": "lean mechanical.lean: halving_undoes_every_doubling_step_for_every_k — ∀ k : Nat, dbl (k + 1) / 2 = dbl k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "7ac609a7-0ed5-8516-b137-38804ba28ece"
+  },
+  {
+    "key": "lean_mechanical_casting_out_nines_is_additive_for_every_a_b",
+    "name": "lean mechanical.lean: casting_out_nines_is_additive_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": "f63b1a76-759a-8e07-a0a6-adc164288c48"
+  },
+  {
+    "key": "lean_mechanical_the_digital_root_fixes_exactly_one_to_nine",
+    "name": "lean mechanical.lean: the_digital_root_fixes_exactly_one_to_nine — ∀ d : Nat, 1 ≤ d → d ≤ 9 → DR d = d — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "7f66abca-14de-8d8b-8537-2fc812addc7c"
+  },
+  {
+    "key": "lean_mechanical_the_digital_root_is_idempotent_for_every_n",
+    "name": "lean mechanical.lean: the_digital_root_is_idempotent_for_every_n — ∀ n : Nat, DR (DR n) = DR n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "cc3d43b3-c3ea-8cba-99c9-ff65a5cdc9aa"
+  },
+  {
+    "key": "lean_mechanical_a_digital_root_of_nine_means_a_multiple_of_nine_for_every_n",
+    "name": "lean mechanical.lean: a_digital_root_of_nine_means_a_multiple_of_nine_for_every_n — ∀ n : Nat, 0 < n → DR n = 9 → n % 9 = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "48527c27-d129-8067-961f-75b23ff00fc2"
+  },
+  {
+    "key": "lean_mechanical_the_hypotenuse_reads_back_from_every_three_four_five_multiple",
+    "name": "lean mechanical.lean: the_hypotenuse_reads_back_from_every_three_four_five_multiple — ∀ k c : Nat, (3 * k) ^ 2 + (4 * k) ^ 2 = c ^ 2 → c = 5 * k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "38ab856f-2051-8fb8-a2c8-54afa15e9545"
+  },
+  {
+    "key": "lean_mechanical_the_sixth_of_three_consecutive_integers_multiplies_back_for_every_n",
+    "name": "lean mechanical.lean: the_sixth_of_three_consecutive_integers_multiplies_back_for_every_n — ∀ n : Nat, n * (n + 1) * (n + 2) / 6 * 6 = n * (n + 1) * (n + 2) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "23e7c1bf-1835-867d-aa00-049ae5abc183"
+  },
+  {
+    "key": "lean_nim_a_number_xored_with_itself_is_zero_for_every_a",
+    "name": "lean nim.lean: a_number_xored_with_itself_is_zero_for_every_a — ∀ a : Nat, xorN a a = 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "4eb0eb7c-9115-8fa6-b8eb-80eb0790215b"
+  },
+  {
+    "key": "lean_nim_xor_is_zero_only_on_equal_arguments_for_every_a_b",
+    "name": "lean nim.lean: xor_is_zero_only_on_equal_arguments_for_every_a_b — ∀ a b : Nat, xorN a b = 0 ↔ a = b — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c117a38f-0ab9-882e-b0c0-51af71a33d0e"
+  },
+  {
+    "key": "lean_nim_the_halves_and_the_low_bit_read_back_from_the_xor_for_every_a_b",
+    "name": "lean nim.lean: the_halves_and_the_low_bit_read_back_from_the_xor_for_every_a_b — ∀ a b : Nat, xorN a b / 2 = xorN (a / 2) (b / 2) ∧ xorN a b % 2 = (a + b) % 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c526ac9a-e469-8ad7-a79e-7785137b9be4"
+  },
+  {
+    "key": "lean_reach_the_successor_returns_every_positive_predecessor",
+    "name": "lean reach.lean: the_successor_returns_every_positive_predecessor — ∀ n : Nat, 0 < n → (n - 1) + 1 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "23e0a041-8135-8623-bc50-d16004de1d7d"
+  },
+  {
+    "key": "lean_reach_exhaustion_reaches_everything_below_its_bound_for_every_n",
+    "name": "lean reach.lean: exhaustion_reaches_everything_below_its_bound_for_every_n — ∀ n k : Nat, k < n → k ∈ List.range n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "ca669c32-5df9-805e-804a-813f277e6444"
+  },
+  {
+    "key": "lean_reach_the_predecessor_of_every_positive_bound_lies_inside",
+    "name": "lean reach.lean: the_predecessor_of_every_positive_bound_lies_inside — ∀ n : Nat, 0 < n → n - 1 ∈ List.range n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "9f5d69b8-d238-8ea5-ab12-433aed39e730"
+  },
+  {
+    "key": "lean_reach_halving_the_domain_keeps_the_half_inside_for_every_n",
+    "name": "lean reach.lean: halving_the_domain_keeps_the_half_inside_for_every_n — ∀ n : Nat, 0 < n → n ∈ List.range (2 * n) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "be05a537-ee2d-88bc-926a-58b712b0eff8"
+  },
+  {
+    "key": "lean_reversal_digitsF_zero",
+    "name": "lean reversal.lean: digitsF_zero — ∀ f : Nat, digitsF f 0 = [] — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "e37e7ee7-d6b6-8efd-9b8e-3538b589bee9"
+  },
+  {
+    "key": "lean_reversal_every_digit_is_below_ten",
+    "name": "lean reversal.lean: every_digit_is_below_ten — ∀ f n : Nat, ∀ d ∈ digitsF f n, d < 10 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "45e2714e-6f2d-89b9-8890-4e33447a14a8"
+  },
+  {
+    "key": "lean_reversal_the_digits_rebuild_the_number_when_the_fuel_covers_them",
+    "name": "lean reversal.lean: the_digits_rebuild_the_number_when_the_fuel_covers_them — ∀ f n : Nat, n < 10 ^ f → (digitsF f n).foldr (fun d a => a * 10 + d) 0 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "06a08633-fb89-81ec-b8d1-d53790d43bcf"
+  },
+  {
+    "key": "lean_reversal_the_number_is_rebuilt_from_its_digits_for_every_n",
+    "name": "lean reversal.lean: the_number_is_rebuilt_from_its_digits_for_every_n — ∀ n : Nat, (digits n).foldr (fun d a => a * 10 + d) 0 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "cbb228e9-06c9-8816-af87-03547f4a97c7"
+  },
+  {
+    "key": "lean_reversal_a_sum_is_the_same_read_backwards",
+    "name": "lean reversal.lean: a_sum_is_the_same_read_backwards — ∀ (l : List Nat), l.reverse.foldl (· + ·) 0 = l.foldl (· + ·) 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "1b350dab-b05b-8d0b-9995-452fb56e7f05"
+  },
+  {
+    "key": "lean_reversal_the_top_digit_is_nonzero",
+    "name": "lean reversal.lean: the_top_digit_is_nonzero — ∀ f n : Nat, 0 < n → n < 10 ^ f → ∃ L b, digitsF f n = L ++ [b] ∧ 0 < b ∧ b < 10 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "da813af5-c2e3-8fc3-97dd-ead120f26031"
+  },
+  {
+    "key": "lean_reversal_reversal_leaves_no_trailing_zero",
+    "name": "lean reversal.lean: reversal_leaves_no_trailing_zero — ∀ n : Nat, 0 < n → 0 < reverseNum n ∧ reverseNum n % 10 ≠ 0 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "edae203a-46d3-89f4-bea6-be4eb07539a1"
+  },
+  {
+    "key": "lean_reversal_reading_a_list_back_from_the_top",
+    "name": "lean reversal.lean: reading_a_list_back_from_the_top — ∀ r : List Nat, r ≠ [] → (∀ d ∈ r, d < 10) → r.reverse.head? ≠ some 0 → 0 < r.reverse.foldl (fun a d => a * 10 + d) 0 ∧ r.length ≤ r.reverse.foldl (fun a d => a * 10 + d) 0 ∧ ∀ f, r.length ≤ f → digitsF f (r.reverse.foldl (fun a d => a * 10… — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "ac35a0e6-3280-8d87-83be-4b7937b9bc46"
+  },
+  {
+    "key": "lean_reversal_the_digits_of_the_reversal_are_the_reversed_digits",
+    "name": "lean reversal.lean: the_digits_of_the_reversal_are_the_reversed_digits — ∀ n : Nat, n % 10 ≠ 0 → digits (reverseNum n) = (digitsF (n + 1) n).reverse ∧ digits n = digitsF (n + 1) n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "91c9f620-0c4f-8266-9bb7-9bb899b026b4"
+  },
+  {
+    "key": "lean_reversal_reversal_is_involutive_off_the_trailing_zeros_for_every_n",
+    "name": "lean reversal.lean: reversal_is_involutive_off_the_trailing_zeros_for_every_n — ∀ n : Nat, n % 10 ≠ 0 → reverseNum (reverseNum n) = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6ea99113-8427-8659-adf1-b082bbf93392"
+  },
+  {
+    "key": "lean_reversal_reversal_is_involutive_exactly_off_the_trailing_zeros_for_every_n",
+    "name": "lean reversal.lean: reversal_is_involutive_exactly_off_the_trailing_zeros_for_every_n — ∀ n : Nat, 0 < n → (reverseNum (reverseNum n) = n ↔ n % 10 ≠ 0) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "4861172d-e203-8efc-8a28-51e017326b62"
+  },
+  {
+    "key": "lean_reversal_more_fuel_changes_no_digit",
+    "name": "lean reversal.lean: more_fuel_changes_no_digit — ∀ f n k : Nat, n < 10 ^ f → digitsF (f + k) n = digitsF f n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6dcd0667-a81f-8c4a-aef4-a1cfdb94b00a"
+  },
+  {
+    "key": "lean_reversal_a_trailing_zero_is_a_leading_zero_of_the_digits",
+    "name": "lean reversal.lean: a_trailing_zero_is_a_leading_zero_of_the_digits — ∀ m : Nat, 0 < m → digits (10 * m) = 0 :: digits m — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c8aa36fc-ef29-8836-bde5-34670ef29c3c"
+  },
+  {
+    "key": "lean_reversal_reversal_preserves_the_digit_sum_for_every_n",
+    "name": "lean reversal.lean: reversal_preserves_the_digit_sum_for_every_n — ∀ n : Nat, digitSum (reverseNum n) = digitSum n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "ab260836-a2cf-8f37-a1e7-a24eba70930e"
+  },
+  {
+    "key": "lean_reversal_the_fixed_points_of_reversal_are_the_palindromes_for_every_n",
+    "name": "lean reversal.lean: the_fixed_points_of_reversal_are_the_palindromes_for_every_n — ∀ n : Nat, n % 10 ≠ 0 → (reverseNum n = n ↔ (digits n).reverse = digits n) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "6b0761d8-d62a-84af-a262-915506a414df"
+  },
+  {
+    "key": "lean_sequences_halving_removes_exactly_the_low_bit_for_every_n",
+    "name": "lean sequences.lean: halving_removes_exactly_the_low_bit_for_every_n — ∀ n : Nat, popcount n = n % 2 + popcount (n / 2) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "977069d5-f1b5-8a5c-80a9-e374d19d5fdf"
+  },
+  {
+    "key": "lean_sequences_the_thue_morse_halving_recurrence_for_every_n",
+    "name": "lean sequences.lean: the_thue_morse_halving_recurrence_for_every_n — ∀ n : Nat, tm n = (n % 2 + tm (n / 2)) % 2 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "864ba163-a3f8-8003-b0bd-14d016b4814d"
+  },
+  {
+    "key": "lean_sequences_doubling_shifts_every_bit_up_by_one",
+    "name": "lean sequences.lean: doubling_shifts_every_bit_up_by_one — ∀ m i : Nat, 2 * m / 2 ^ (i + 1) = m / 2 ^ i — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c6f05e84-b232-815d-8a9b-0b442e434d7b"
+  },
+  {
+    "key": "lean_sequences_the_residue_below_the_next_power_adds_one_bit",
+    "name": "lean sequences.lean: the_residue_below_the_next_power_adds_one_bit — ∀ m F : Nat, m % 2 ^ (F + 1) = m % 2 ^ F + m / 2 ^ F % 2 * 2 ^ F — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "2607d9ae-7836-8693-b295-01328e947772"
+  },
+  {
+    "key": "lean_sequences_the_low_bits_rebuild_the_number_below_every_power",
+    "name": "lean sequences.lean: the_low_bits_rebuild_the_number_below_every_power — ∀ F m : Nat, (List.range F).foldl (fun a i => a + m / 2 ^ i % 2 * 2 ^ i) 0 = m % 2 ^ F — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "c79eff54-9841-8325-9147-a780a5b5c014"
+  },
+  {
+    "key": "lean_sequences_the_number_is_rebuilt_from_its_bits_for_every_n",
+    "name": "lean sequences.lean: the_number_is_rebuilt_from_its_bits_for_every_n — ∀ n : Nat, (List.range (n + 1)).foldl (fun a i => a + n / 2 ^ i % 2 * 2 ^ i) 0 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "4e6421ba-ab59-8bb4-8f80-1d01bf5fbb35"
+  },
+  {
+    "key": "lean_speed_the_nanoseconds_return_from_the_microseconds_at_every_whole_count",
+    "name": "lean speed.lean: the_nanoseconds_return_from_the_microseconds_at_every_whole_count — ∀ n : Nat, n % 1000 = 0 → n / 1000 * 1000 = n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "7e0b39fe-b643-826c-96e2-8a64bb9cbbae"
+  },
+  {
+    "key": "lean_split_the_coins_return_from_the_coin_step_for_every_multiple_of_three",
+    "name": "lean split.lean: the_coins_return_from_the_coin_step_for_every_multiple_of_three — ∀ t : Nat, t % 3 = 0 → 3 * (t / 3) = t — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "0a785a11-be04-823d-a50c-cd301d6bc552"
+  },
+  {
+    "key": "lean_split_paying_and_refunding_round_trips_for_every_count",
+    "name": "lean split.lean: paying_and_refunding_round_trips_for_every_count — ∀ n k : Nat, k ≤ n → 3 * (n - k) + 3 * k = 3 * n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "31ce2f16-8ab7-8367-b170-6da1a743bc84"
+  },
+  {
+    "key": "lean_z9_orbit_repeats_every_six",
+    "name": "lean z9.lean: orbit_repeats_every_six — ∀ k : Nat, orbit (k + 6) = orbit k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "1d6bb6c2-2c76-8036-8d3a-961ef5879d0d"
+  },
+  {
+    "key": "lean_z9_orbit_is_its_exponent_mod_six",
+    "name": "lean z9.lean: orbit_is_its_exponent_mod_six — ∀ k : Nat, orbit k = orbit (k % 6) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "af2bb754-dd58-8c00-8064-1e2687197c86"
+  },
+  {
+    "key": "lean_z9_the_orbit_step_is_read_back_by_its_log_for_every_k",
+    "name": "lean z9.lean: the_orbit_step_is_read_back_by_its_log_for_every_k — ∀ k : Nat, logOrbit (orbit k) = some (k % 6) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "b806a941-659e-8ecc-b553-f7e8787d4b28"
+  },
+  {
+    "key": "lean_z9plus_halving_undoes_doubling_at_every_step",
+    "name": "lean z9plus.lean: halving_undoes_doubling_at_every_step — ∀ k : Nat, m9 (pw 2 k * pw 5 k) = 1 — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "87e5a9d4-3319-83f8-a311-3cf45eecaa4b"
+  },
+  {
+    "key": "lean_z9plus_halving_has_period_six_for_every_k",
+    "name": "lean z9plus.lean: halving_has_period_six_for_every_k — ∀ k : Nat, pw 5 (k + 6) = pw 5 k — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "d07f608f-90d3-8dd9-bbe3-b203a21c6957"
+  },
+  {
+    "key": "lean_z9plus_halving_orbit_digital_roots_have_period_six_for_every_k",
+    "name": "lean z9plus.lean: halving_orbit_digital_roots_have_period_six_for_every_k — ∀ k : Nat, dr (pw 5 (k + 6)) = dr (pw 5 k) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "147581f3-c75f-8635-a4d5-83f53afe23ab"
+  },
+  {
+    "key": "lean_z9plus_the_reflected_orbit_meets_the_triad_exactly_at_one_four_seven_for_every_k",
+    "name": "lean z9plus.lean: the_reflected_orbit_meets_the_triad_exactly_at_one_four_seven_for_every_k — ∀ k : Nat, [3, 6, 9].contains (refl (pw 2 k)) = [1, 4, 7].contains (pw 2 k) — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "20cda95a-c30a-8490-8886-a05f7ce1b338"
+  },
+  {
+    "key": "lean_z9plus_reversal_cannot_change_the_digital_root_for_every_n",
+    "name": "lean z9plus.lean: reversal_cannot_change_the_digital_root_for_every_n — ∀ n : Nat, dr (reverseNum n) = dr n — proved by the Lean kernel for every value (by\n  intro), standard axioms only — checked by lean.ts",
+    "receipt": "43332821-10bc-8bb2-babe-07c8f97d8607"
   }
 ]

package/src/proof/elementary.lean

@@ -443,4 +443,53 @@ theorem the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n
   intro n
   exact (key n).1
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem the_polygon_side_count_reads_back_from_its_angle_sum : ∀ n : Nat, 2 ≤ n → ((n - 2) * 180 + 360) / 180 = n := by
+  intro n h; omega
+
+theorem every_odd_square_one_more_than_eight_times_m_makes_m_triangular :
+    ∀ m r : Nat, 8 * m + 1 = r * r → m = r / 2 * (r / 2 + 1) / 2 := by
+  intro m r h
+  have hodd : r % 2 = 1 := by
+    rcases Nat.mod_two_eq_zero_or_one r with e | e
+    · have : r * r % 2 = 0 := by simp [Nat.mul_mod, e]
+      omega
+    · exact e
+  obtain ⟨t, rfl⟩ : ∃ t, r = 2 * t + 1 := ⟨r / 2, by omega⟩
+  rw [show (2 * t + 1) / 2 = t by omega]
+  have hexp : (2 * t + 1) * (2 * t + 1) = 4 * (t * (t + 1)) + 1 := by
+    rw [Nat.mul_add t t 1, Nat.mul_one, Nat.add_mul, Nat.mul_add, Nat.mul_add, Nat.mul_one, Nat.one_mul]
+    rw [Nat.mul_assoc 2 t (2 * t), Nat.mul_comm t (2 * t), Nat.mul_assoc 2 t t]
+    omega
+  have hev := a_product_of_consecutive_numbers_is_even t
+  rw [hexp] at h
+  generalize t * (t + 1) = P at h hev ⊢
+  omega
+
+
+-- ── reflections, from the sums batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTION of the Lucas law: the Fibonacci numbers read back from the neighbouring Lucas numbers
+theorem the_fibonaccis_are_a_fifth_of_the_neighbouring_lucas_numbers_for_every_n :
+    ∀ n : Nat, 5 * fib (n + 1) = lucas n + lucas (n + 2) := by
+  intro n
+  cases n with
+  | zero => decide
+  | succ n =>
+    have l1 := the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n n
+    have l3 := the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n (n + 2)
+    have f2 : fib (n + 2) = fib n + fib (n + 1) := rfl
+    have f3 : fib (n + 3) = fib (n + 1) + fib (n + 2) := rfl
+    have f4 : fib (n + 4) = fib (n + 2) + fib (n + 3) := rfl
+    show 5 * fib (n + 2) = lucas (n + 1) + lucas (n + 2 + 1)
+    rw [l1, l3, show n + 2 + 2 = n + 4 from rfl, f4]
+    omega
+
+
+-- ── reflections, from the extra batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem half_a_product_of_consecutive_numbers_multiplies_back_for_every_n :
+    ∀ n : Nat, n * (n + 1) / 2 * 2 = n * (n + 1) := by
+  intro n
+  exact Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero (a_product_of_consecutive_numbers_is_even n))
+
 end Elementary