@ceccec/millennium-solutions 9.3.1 → 9.3.3

package/src/proof/energy.lean

@@ -288,4 +288,42 @@ theorem two_parts_in_three_is_two_thirds_at_every_scale_for_every_m :
   unfold pct
   rw [Nat.mul_comm 2 m, Nat.mul_assoc, Nat.mul_comm 3 m, Nat.mul_div_mul_left _ _ hm]
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem burning_then_splitting_is_the_identity_above_the_bond :
+    ∀ e : Nat, bondHundredthsKJ ≤ e → splitE (burnE e) = e := by
+  intro e h; unfold splitE burnE; omega
+
+theorem one_part_in_three_is_a_third_at_every_scale_for_every_m :
+    ∀ m : Nat, 0 < m → pct m (3 * m) = 33 := by
+  intro m hm; unfold pct
+  rw [Nat.mul_comm 3 m, Nat.mul_div_mul_left 100 3 hm]
+
+theorem the_gas_volume_reads_back_its_moles_for_every_m :
+    ∀ m : Nat, molesOf (litresOf m) ≤ m ∧ m ≤ molesOf (litresOf m) + 1 := by
+  intro m; unfold molesOf litresOf mLperMol; exact ⟨by omega, by omega⟩
+
+
+-- ── reflections, from the extra batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- the_atoms_read_back_from_the_mass holds on h, o < 10 and is FALSE in general: mass 5333 0 = mass 0 336.
+-- The true boundary: below 5333 hydrogens the mass names the molecule, at any oxygen count.
+theorem 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' := by
+  intro h o h' o' h1 h2 e
+  unfold mass mgH mgO at e
+  exact ⟨by omega, by omega⟩
+
+theorem the_boundary_is_sharp : mass 5333 0 = mass 0 336 := by decide
+
+-- the_cost_per_litre / the_energy_per_litre / hexbits rows: a floor division multiplies back within one divisor
+theorem a_floor_division_multiplies_back_within_one_divisor :
+    ∀ a l : Nat, 0 < l → a / l * l ≤ a ∧ a < (a / l + 1) * l := by
+  intro a l hl
+  have e := Nat.div_add_mod a l
+  have hr := Nat.mod_lt a hl
+  refine ⟨Nat.div_mul_le_self a l, ?_⟩
+  rw [Nat.add_mul, Nat.one_mul, Nat.mul_comm (a / l) l]
+  generalize l * (a / l) = X at e ⊢
+  omega
+
 end Energy

package/src/proof/families.lean

@@ -645,4 +645,96 @@ theorem the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n :
   intro n
   rw [← six n, Nat.mul_div_cancel_left _ (by decide)]
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem 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 := by
+  intro n k h
+  unfold choose
+  rw [Nat.sub_sub_self h, Nat.mul_comm]
+  exact ⟨rfl, rfl⟩
+
+
+-- ── reflections, from the sums batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTIONS: each closed form differences back to its term
+theorem 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 := by
+  intro k n h1 h5
+  rw [← power_sums_match_their_closed_forms_for_every_n k (n + 1) h1 h5,
+    ← power_sums_match_their_closed_forms_for_every_n k n h1 h5]
+  unfold powSum
+  exact a_sum_over_one_to_n_plus_one_adds_the_last_term (fun i => i ^ k) n
+
+theorem 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 := by
+  intro n
+  rw [← the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n (n + 1),
+    ← the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n n]
+  exact a_sum_over_one_to_n_plus_one_adds_the_last_term (fun i => i * (i + 1) / 2) n
+
+theorem 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) := by
+  intro n
+  have h : 1 ≤ 2 ^ (n + 1) := Nat.one_le_two_pow
+  rw [Nat.pow_succ 2 (n + 1)]
+  omega
+
+theorem 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 := by
+  intro n
+  rw [the_first_n_odd_numbers_sum_to_n_squared_for_every_n, the_first_n_odd_numbers_sum_to_n_squared_for_every_n,
+    square_of_successor]
+  omega
+
+
+-- ── reflections, from the extra batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem foldl_add_start : ∀ (l : List Nat) (a : Nat), l.foldl (· + ·) a = a + l.foldl (· + ·) 0 := by
+  intro l
+  induction l with
+  | nil => intro a; simp
+  | cons x xs ih =>
+    intro a
+    simp only [List.foldl]
+    rw [ih (a + x), ih (0 + x)]
+    omega
+
+theorem 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 := by
+  intro f
+  induction f with
+  | zero =>
+    intro n h
+    have : n = 0 := by simp at h; omega
+    subst this
+    simp [digitsF]
+  | succ f ih =>
+    intro n h
+    cases n with
+    | zero => simp [digitsF]
+    | succ m =>
+      simp only [digitsF, List.foldl]
+      rw [foldl_add_start]
+      have hlt : (m + 1) / 10 < 10 ^ f := by
+        rw [Nat.pow_succ] at h
+        omega
+      have := ih ((m + 1) / 10) hlt
+      omega
+
+theorem a_number_is_below_ten_to_its_own_successor : ∀ n : Nat, n < 10 ^ (n + 1) := by
+  intro n
+  induction n with
+  | zero => decide
+  | succ n ih =>
+    rw [Nat.pow_succ]
+    omega
+
+-- the_digit_sum_rules_for_three_and_nine_hold_below_ten_thousand, for every n
+theorem 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) := by
+  intro n
+  have h := the_digits_sum_to_the_number_mod_nine_when_the_fuel_covers_them (n + 1) n (a_number_is_below_ten_to_its_own_successor n)
+  unfold digitSum digitsOf
+  generalize (digitsF (n + 1) n).foldl (· + ·) 0 = s at h ⊢
+  exact ⟨⟨fun a => by omega, fun a => by omega⟩, ⟨fun a => by omega, fun a => by omega⟩⟩
+
 end Families

package/src/proof/flow.lean

@@ -51,4 +51,28 @@ theorem navier_stokes_flow_is_bounded_for_every_step :
   revert j
   decide
 
+
+-- ── reflections, from the orbit batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- orbit and span are MillenniumFloor's (index.lean), opened above — not redefined here
+-- REFLECTION: the reverse flow (halving, ×5) steps every state back one, at every step
+theorem the_reverse_flow_undoes_every_step : ∀ k : Nat, orbit (k + 1) * 5 % 9 = orbit k := by
+  intro k
+  unfold orbit
+  rw [Nat.mul_mod, Nat.mod_mod, ← Nat.mul_mod, Nat.pow_succ, Nat.mul_assoc, Nat.mul_mod]
+  show 2 ^ k % 9 * 1 % 9 = 2 ^ k % 9
+  rw [Nat.mul_one, Nat.mod_mod]
+
+-- REFLECTION of "bounded": recurrent — from every step, every state of the span returns within six steps
+theorem every_state_of_the_flow_returns_within_six_steps :
+    ∀ k s : Nat, ∃ j, j < 6 ∧ orbit (k + j) = orbit s := by
+  intro k s
+  have key : ∀ r, r < 6 → ∀ t, t < 6 → ∃ j, j < 6 ∧ orbit ((r + j) % 6) = orbit t := by
+    decide
+  obtain ⟨j, hj, e⟩ := key (k % 6) (Nat.mod_lt _ (by decide)) (s % 6) (Nat.mod_lt _ (by decide))
+  refine ⟨j, hj, ?_⟩
+  rw [the_doubling_flow_is_its_first_six_steps (k + j), the_doubling_flow_is_its_first_six_steps s]
+  have hm : (k + j) % 6 = (k % 6 + j) % 6 := by omega
+  rw [hm]
+  exact e
+
 end Flow

package/src/proof/fnv.lean

@@ -113,4 +113,15 @@ theorem the_split_multiply_is_the_exact_thirty_two_bit_product :
   generalize a % 65536 * b = Q
   omega
 
+
+-- ── reflections, from the xor batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTION of the exact 32-bit multiply: multiplying by the FNV prime is undone by its inverse mod 2^32
+theorem multiplying_by_the_fnv_prime_is_undone_by_its_inverse_for_every_h :
+    ∀ h : Nat, mul32 (mul32 h FNV_PRIME) 899433627 = h % M32 := by
+  intro h
+  unfold mul32
+  rw [Nat.mod_mul_mod, Nat.mul_assoc,
+    show FNV_PRIME * 899433627 = 1 + 3513497 * M32 by decide,
+    Nat.mul_add, Nat.mul_one, ← Nat.mul_assoc, Nat.add_mul_mod_self_right]
+
 end Fnv

package/src/proof/light.lean

@@ -155,4 +155,14 @@ theorem the_second_returns_from_the_metre_and_the_period_for_every_s :
   intro s
   exact ⟨Nat.mul_div_cancel_left s (by decide), Nat.mul_div_cancel_left s (by decide)⟩
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem the_metre_returns_from_the_second_for_every_whole_length :
+    ∀ m : Nat, m % c = 0 → travel (m / c) = m := by
+  intro m h; unfold travel; exact Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero h)
+
+theorem the_period_count_returns_from_the_second_for_every_whole_count :
+    ∀ p : Nat, p % dNuCs = 0 → periods (p / dNuCs) = p := by
+  intro p h; unfold periods; exact Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero h)
+
 end Light

package/src/proof/mechanical.lean

@@ -521,4 +521,43 @@ theorem the_moduli_dimensions_are_three_g_minus_three_and_six_g_minus_six_for_ev
   intro g
   exact ⟨by omega, by omega⟩
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem DR_eq : ∀ n : Nat, DR n = if n = 0 then 0 else 1 + (n - 1) % 9 := by
+  intro n; unfold DR; by_cases h : n = 0 <;> simp [h]
+
+theorem halving_undoes_every_doubling_step_for_every_k : ∀ k : Nat, dbl (k + 1) / 2 = dbl k := by
+  intro k; show 2 * dbl k / 2 = dbl k; omega
+
+theorem casting_out_nines_is_additive_for_every_a_b : ∀ a b : Nat, DR (a + b) = DR (DR a + DR b) := by
+  intro a b
+  simp only [DR_eq]
+  by_cases ha : a = 0 <;> by_cases hb : b = 0 <;> simp only [ha, hb, if_true, if_false] <;>
+    (repeat' split) <;> omega
+
+theorem the_digital_root_fixes_exactly_one_to_nine : ∀ d : Nat, 1 ≤ d → d ≤ 9 → DR d = d := by
+  intro d h1 h9; rw [DR_eq, if_neg (by omega)]; omega
+
+theorem the_digital_root_is_idempotent_for_every_n : ∀ n : Nat, DR (DR n) = DR n := by
+  intro n; simp only [DR_eq]; (repeat' split) <;> omega
+
+theorem a_digital_root_of_nine_means_a_multiple_of_nine_for_every_n :
+    ∀ n : Nat, 0 < n → DR n = 9 → n % 9 = 0 := by
+  intro n hn h; rw [DR_eq, if_neg (by omega)] at h; omega
+
+theorem the_hypotenuse_reads_back_from_every_three_four_five_multiple :
+    ∀ k c : Nat, (3 * k) ^ 2 + (4 * k) ^ 2 = c ^ 2 → c = 5 * k := by
+  intro k c h
+  rw [every_multiple_of_three_four_five_is_pythagorean] at h
+  rw [Nat.pow_two, Nat.pow_two] at h
+  rcases Nat.lt_trichotomy c (5 * k) with hl | he | hg
+  · have := Nat.mul_lt_mul_of_lt_of_lt hl hl; omega
+  · exact he
+  · have := Nat.mul_lt_mul_of_lt_of_lt hg hg; omega
+
+theorem 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) := by
+  intro n
+  exact Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero (the_product_of_any_three_consecutive_integers_is_divisible_by_six_for_every_n n))
+
 end Mechanical

package/src/proof/nim.lean

@@ -308,4 +308,25 @@ theorem the_nim_sum_is_a_gf2_vector_addition_for_every_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⟩
 
+
+-- ── reflections, from the xor batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTIONS
+theorem a_number_xored_with_itself_is_zero_for_every_a : ∀ a : Nat, xorN a a = 0 := by
+  intro a; unfold xorN; exact a_number_xored_with_itself_is_zero_at_every_fuel _ a
+
+theorem xor_is_zero_only_on_equal_arguments_for_every_a_b : ∀ a b : Nat, xorN a b = 0 ↔ a = b := by
+  intro a b
+  constructor
+  · intro h
+    have := xor_is_its_own_inverse_for_every_a_b a b
+    rw [h, xor_is_commutative_for_every_a_b, xor_zero_is_identity_for_every_a] at this
+    exact this.symm
+  · intro h; subst h; exact a_number_xored_with_itself_is_zero_for_every_a a
+
+theorem 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 := by
+  intro a b
+  have h := xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves a b
+  constructor <;> omega
+
 end Nim

package/src/proof/reach.lean

@@ -102,4 +102,20 @@ theorem doubling_the_domain_leaves_the_same_hole_for_every_n : ∀ n : Nat, 2 *
   intro n h
   exact Nat.lt_irrefl (2 * n) (List.mem_range.mp h)
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem the_successor_returns_every_positive_predecessor : ∀ n : Nat, 0 < n → (n - 1) + 1 = n := by
+  intro n h; omega
+
+theorem exhaustion_reaches_everything_below_its_bound_for_every_n : ∀ n k : Nat, k < n → k ∈ List.range n := by
+  intro n k h; exact List.mem_range.mpr h
+
+theorem the_predecessor_of_every_positive_bound_lies_inside : ∀ n : Nat, 0 < n → n - 1 ∈ List.range n := by
+  intro n h; exact List.mem_range.mpr (by omega)
+
+
+-- ── reflections, from the extra batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem halving_the_domain_keeps_the_half_inside_for_every_n : ∀ n : Nat, 0 < n → n ∈ List.range (2 * n) := by
+  intro n h; exact List.mem_range.mpr (by omega)
+
 end Reach

package/src/proof/reversal.lean

@@ -145,4 +145,258 @@ theorem reversal_keeps_the_residue_mod_nine_for_every_n :
     simp
   rw [h1, the_digit_sum_has_the_residue_of_the_number_mod_nine_for_every_n]
 
+
+-- ── reflections, from the rev batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- ═══ REFLECTIONS ═══════════════════════════════════════════════════════════════════════════════════════
+theorem digitsF_zero : ∀ f : Nat, digitsF f 0 = [] := by
+  intro f; cases f <;> rfl
+
+theorem every_digit_is_below_ten : ∀ f n : Nat, ∀ d ∈ digitsF f n, d < 10 := by
+  intro f
+  induction f with
+  | zero => intro n d h; simp [digitsF] at h
+  | succ f ih =>
+    intro n d h
+    cases n with
+    | zero => simp [digitsF] at h
+    | succ m =>
+      simp only [digitsF, List.mem_cons] at h
+      rcases h with h | h
+      · omega
+      · exact ih _ _ h
+
+-- the number rebuilt from its digits (reflection of the digit-sum law)
+theorem 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 := by
+  intro f
+  induction f with
+  | zero =>
+    intro n h
+    have : n = 0 := by simp at h; omega
+    subst this
+    simp [digitsF]
+  | succ f ih =>
+    intro n h
+    cases n with
+    | zero => simp [digitsF]
+    | succ m =>
+      simp only [digitsF, List.foldr]
+      have hlt : (m + 1) / 10 < 10 ^ f := by
+        rw [Nat.pow_succ] at h
+        omega
+      rw [ih _ hlt]
+      omega
+
+theorem the_number_is_rebuilt_from_its_digits_for_every_n :
+    ∀ n : Nat, (digits n).foldr (fun d a => a * 10 + d) 0 = n := by
+  intro n
+  unfold digits
+  split
+  · rename_i h
+    have : n = 0 := by simpa using h
+    subst this
+    rfl
+  · exact the_digits_rebuild_the_number_when_the_fuel_covers_them (n + 1) n (a_number_is_below_ten_to_its_own_successor n)
+
+-- the sum does not see the order (reflection of foldl_add_start)
+theorem a_sum_is_the_same_read_backwards : ∀ (l : List Nat), l.reverse.foldl (· + ·) 0 = l.foldl (· + ·) 0 := by
+  intro l
+  induction l with
+  | nil => rfl
+  | cons x xs ih =>
+    rw [List.reverse_cons, List.foldl_append, ih]
+    simp only [List.foldl]
+    rw [foldl_add_start xs (0 + x)]
+    omega
+
+theorem the_top_digit_is_nonzero :
+    ∀ f n : Nat, 0 < n → n < 10 ^ f → ∃ L b, digitsF f n = L ++ [b] ∧ 0 < b ∧ b < 10 := by
+  intro f
+  induction f with
+  | zero => intro n h0 h; exfalso; simp at h; omega
+  | succ f ih =>
+    intro n h0 h
+    obtain ⟨m, rfl⟩ : ∃ m, n = m + 1 := ⟨n - 1, by omega⟩
+    simp only [digitsF]
+    by_cases hq : (m + 1) / 10 = 0
+    · refine ⟨[], (m + 1) % 10, ?_, by omega, by omega⟩
+      rw [hq, digitsF_zero]
+      rfl
+    · have hlt : (m + 1) / 10 < 10 ^ f := by
+        rw [Nat.pow_succ] at h
+        omega
+      obtain ⟨L, b, e, hb, hb10⟩ := ih ((m + 1) / 10) (by omega) hlt
+      exact ⟨(m + 1) % 10 :: L, b, by rw [e]; rfl, hb, hb10⟩
+
+theorem reversal_leaves_no_trailing_zero : ∀ n : Nat, 0 < n → 0 < reverseNum n ∧ reverseNum n % 10 ≠ 0 := by
+  intro n hn
+  obtain ⟨L, b, e, hb, hb10⟩ := the_top_digit_is_nonzero (n + 1) n hn (a_number_is_below_ten_to_its_own_successor n)
+  have hd : digits n = L ++ [b] := by
+    unfold digits
+    rw [if_neg (by simp; omega)]
+    exact e
+  unfold reverseNum
+  rw [hd, List.foldl_append]
+  show 0 < (L.foldl (fun a d => a * 10 + d) 0) * 10 + b ∧ ((L.foldl (fun a d => a * 10 + d) 0) * 10 + b) % 10 ≠ 0
+  exact ⟨by omega, by omega⟩
+
+theorem 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 + d) 0) = r := by
+  intro r
+  induction r with
+  | nil => intro h; exact absurd rfl h
+  | cons b r' ih =>
+    intro _ hlt hhead
+    have hb : b < 10 := hlt b (List.mem_cons_self b r')
+    cases r' with
+    | nil =>
+      have hb0 : b ≠ 0 := by
+        intro e; apply hhead; simp [e]
+      simp only [List.reverse_cons, List.reverse_nil, List.nil_append, List.foldl, List.length_cons,
+        List.length_nil, Nat.zero_mul, Nat.zero_add]
+      refine ⟨by omega, by omega, ?_⟩
+      intro f hf
+      obtain ⟨f', rfl⟩ : ∃ f', f = f' + 1 := ⟨f - 1, by omega⟩
+      obtain ⟨b', rfl⟩ : ∃ b', b = b' + 1 := ⟨b - 1, by omega⟩
+      simp only [digitsF]
+      rw [show (b' + 1) / 10 = 0 by omega, show (b' + 1) % 10 = b' + 1 by omega, digitsF_zero]
+    | cons x xs =>
+      have hne : (x :: xs) ≠ [] := List.cons_ne_nil x xs
+      have hlt' : ∀ d ∈ (x :: xs), d < 10 := fun d hd => hlt d (List.mem_cons_of_mem b hd)
+      have hhead' : (x :: xs).reverse.head? ≠ some 0 := by
+        have hrev : (b :: x :: xs).reverse = (x :: xs).reverse ++ [b] := List.reverse_cons b (x :: xs)
+        rw [hrev] at hhead
+        cases h : (x :: xs).reverse with
+        | nil => simp at h
+        | cons y ys => rw [h] at hhead; exact hhead
+      obtain ⟨hpos, hlen, hdig⟩ := ih hne hlt' hhead'
+      rw [List.reverse_cons b (x :: xs), List.foldl_append]
+      simp only [List.foldl, List.length_cons] at hlen hdig ⊢
+      generalize (x :: xs).reverse.foldl (fun a d => a * 10 + d) 0 = v at hpos hlen hdig ⊢
+      refine ⟨by omega, by omega, ?_⟩
+      intro f hf
+      obtain ⟨f', rfl⟩ : ∃ f', f = f' + 1 := ⟨f - 1, by omega⟩
+      obtain ⟨w, hw⟩ : ∃ w, v * 10 + b = w + 1 := ⟨v * 10 + b - 1, by omega⟩
+      rw [hw]
+      simp only [digitsF]
+      rw [← hw, show (v * 10 + b) % 10 = b by omega, show (v * 10 + b) / 10 = v by omega, hdig f' (by omega)]
+
+theorem 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 := by
+  intro n h10
+  have hds : digits n = digitsF (n + 1) n := by
+    unfold digits
+    rw [if_neg (by simp; omega)]
+  have hne : digitsF (n + 1) n ≠ [] := by
+    obtain ⟨m, rfl⟩ : ∃ m, n = m + 1 := ⟨n - 1, by omega⟩
+    simp [digitsF]
+  have hhead : (digitsF (n + 1) n).head? = some (n % 10) := by
+    obtain ⟨m, rfl⟩ : ∃ m, n = m + 1 := ⟨n - 1, by omega⟩
+    simp [digitsF]
+  have hlt : ∀ d ∈ (digitsF (n + 1) n).reverse, d < 10 :=
+    fun d hd => every_digit_is_below_ten _ _ d (List.mem_reverse.mp hd)
+  have key := reading_a_list_back_from_the_top (digitsF (n + 1) n).reverse
+    (by simpa using hne) hlt
+    (by rw [List.reverse_reverse, hhead]; intro e; apply h10; exact Option.some.inj e)
+  rw [List.reverse_reverse] at key
+  obtain ⟨hpos, hlen, hdig⟩ := key
+  have hrn : reverseNum n = (digitsF (n + 1) n).foldl (fun a d => a * 10 + d) 0 := by
+    unfold reverseNum; rw [hds]
+  refine ⟨?_, hds⟩
+  unfold digits
+  rw [hrn, if_neg (by simp; omega)]
+  exact hdig _ (Nat.le_succ_of_le hlen)
+
+-- reflection of reversal_keeps_the_residue_mod_nine_for_every_n: reversal undoes itself off the trailing zeros
+theorem reversal_is_involutive_off_the_trailing_zeros_for_every_n :
+    ∀ n : Nat, n % 10 ≠ 0 → reverseNum (reverseNum n) = n := by
+  intro n h10
+  obtain ⟨hdrn, _⟩ := the_digits_of_the_reversal_are_the_reversed_digits n h10
+  show (digits (reverseNum n)).foldl (fun a d => a * 10 + d) 0 = n
+  rw [hdrn, List.foldl_reverse]
+  exact the_digits_rebuild_the_number_when_the_fuel_covers_them (n + 1) n (a_number_is_below_ten_to_its_own_successor n)
+
+theorem reversal_is_involutive_exactly_off_the_trailing_zeros_for_every_n :
+    ∀ n : Nat, 0 < n → (reverseNum (reverseNum n) = n ↔ n % 10 ≠ 0) := by
+  intro n hn
+  constructor
+  · intro e h0
+    obtain ⟨hp, _⟩ := reversal_leaves_no_trailing_zero n hn
+    obtain ⟨_, hz⟩ := reversal_leaves_no_trailing_zero (reverseNum n) hp
+    rw [e] at hz
+    exact hz h0
+  · exact reversal_is_involutive_off_the_trailing_zeros_for_every_n n
+
+-- more fuel changes nothing once it covers the number
+theorem more_fuel_changes_no_digit : ∀ f n k : Nat, n < 10 ^ f → digitsF (f + k) n = digitsF f n := by
+  intro f
+  induction f with
+  | zero =>
+    intro n k h
+    have : n = 0 := by simp at h; omega
+    subst this
+    rw [digitsF_zero, digitsF_zero]
+  | succ f ih =>
+    intro n k h
+    cases n with
+    | zero => rw [digitsF_zero, digitsF_zero]
+    | succ m =>
+      rw [show f + 1 + k = (f + k) + 1 by omega]
+      simp only [digitsF]
+      have hlt : (m + 1) / 10 < 10 ^ f := by
+        rw [Nat.pow_succ] at h
+        omega
+      rw [ih _ k hlt]
+
+theorem a_trailing_zero_is_a_leading_zero_of_the_digits :
+    ∀ m : Nat, 0 < m → digits (10 * m) = 0 :: digits m := by
+  intro m hm
+  unfold digits
+  rw [if_neg (by simp; omega), if_neg (by simp; omega)]
+  obtain ⟨p, hp⟩ : ∃ p, 10 * m = p + 1 := ⟨10 * m - 1, by omega⟩
+  rw [show 10 * m + 1 = (10 * m) + 1 from rfl, hp]
+  simp only [digitsF]
+  rw [← hp, show 10 * m % 10 = 0 by omega, show 10 * m / 10 = m by omega,
+    show 10 * m = (m + 1) + (9 * m - 1) by omega,
+    more_fuel_changes_no_digit (m + 1) m (9 * m - 1) (a_number_is_below_ten_to_its_own_successor m)]
+
+-- reversal_preserves_digit_sum was decided for 1 ≤ n < 300; for every n:
+theorem reversal_preserves_the_digit_sum_for_every_n : ∀ n : Nat, digitSum (reverseNum n) = digitSum n := by
+  intro n
+  induction n using Nat.strongRecOn with
+  | _ n ih =>
+    by_cases h0 : n = 0
+    · subst h0; rfl
+    by_cases h10 : n % 10 = 0
+    · obtain ⟨m, rfl⟩ : ∃ m, n = 10 * m := ⟨n / 10, by omega⟩
+      have hm : 0 < m := by omega
+      have hd := a_trailing_zero_is_a_leading_zero_of_the_digits m hm
+      have hr : reverseNum (10 * m) = reverseNum m := by
+        unfold reverseNum; rw [hd]; rfl
+      have hs : digitSum (10 * m) = digitSum m := by
+        unfold digitSum; rw [hd]; rfl
+      rw [hr, hs]
+      exact ih m (by omega)
+    · obtain ⟨hdrn, hds⟩ := the_digits_of_the_reversal_are_the_reversed_digits n h10
+      unfold digitSum
+      rw [hdrn, hds, a_sum_is_the_same_read_backwards]
+
+-- palindromes_are_the_fixed_points counted them below 100; for every n without a trailing zero:
+-- the fixed points of the reversal are exactly the numbers whose digits read the same both ways
+theorem the_fixed_points_of_reversal_are_the_palindromes_for_every_n :
+    ∀ n : Nat, n % 10 ≠ 0 → (reverseNum n = n ↔ (digits n).reverse = digits n) := by
+  intro n h10
+  obtain ⟨hdrn, hds⟩ := the_digits_of_the_reversal_are_the_reversed_digits n h10
+  constructor
+  · intro e
+    have := congrArg digits e
+    rw [hdrn, ← hds] at this
+    exact this
+  · intro p
+    have hd : digits (reverseNum n) = digits n := by rw [hdrn, ← hds, p]
+    rw [← the_number_is_rebuilt_from_its_digits_for_every_n (reverseNum n), hd,
+      the_number_is_rebuilt_from_its_digits_for_every_n]
+
 end Reversal

package/src/proof/sequences.lean

@@ -216,4 +216,69 @@ theorem thue_morse_doubling_recurrence_for_every_n : ∀ n : Nat, tm (2 * n) = t
   rw [doubling_preserves_the_bit_count_for_every_n, the_odd_step_sets_exactly_one_further_bit_for_every_n]
   exact ⟨rfl, by omega⟩
 
+
+-- ── reflections, from the bits batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+-- REFLECTION of doubling_preserves_the_bit_count / the_odd_step_sets_exactly_one_further_bit:
+-- halving removes exactly the low bit, for every n
+theorem halving_removes_exactly_the_low_bit_for_every_n : ∀ n : Nat, popcount n = n % 2 + popcount (n / 2) := by
+  intro n
+  cases n with
+  | zero => rfl
+  | succ m =>
+    unfold popcount
+    rw [the_bits_of_a_number_are_its_low_bit_then_the_bits_of_its_half (m + 1) (m + 1)]
+    have hlt := a_number_is_below_two_to_its_own_successor ((m + 1) / 2)
+    rw [show List.range (m + 1) = List.range ((m + 1) / 2 + 1 + (m - (m + 1) / 2)) by congr 1; omega,
+      bits_above_the_number_add_nothing (m - (m + 1) / 2) ((m + 1) / 2 + 1) ((m + 1) / 2) hlt]
+
+theorem the_thue_morse_halving_recurrence_for_every_n : ∀ n : Nat, tm n = (n % 2 + tm (n / 2)) % 2 := by
+  intro n
+  unfold tm
+  rw [halving_removes_exactly_the_low_bit_for_every_n n]
+  omega
+
+-- REFLECTION of halving_shifts_every_bit_down_by_one: doubling shifts every bit up by one
+theorem doubling_shifts_every_bit_up_by_one : ∀ m i : Nat, 2 * m / 2 ^ (i + 1) = m / 2 ^ i := by
+  intro m i
+  rw [Nat.pow_succ, Nat.mul_comm (2 ^ i) 2, ← Nat.div_div_eq_div_mul, Nat.mul_div_cancel_left _ (by decide)]
+
+-- core's Nat.mod_pow_succ carries Classical.choice, so the one step it gives is proved here by hand
+theorem 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 := by
+  intro m F
+  have hP : 0 < 2 ^ F := Nat.lt_of_le_of_lt (Nat.zero_le F) (a_number_is_below_two_to_its_own_power F)
+  have e1 := Nat.div_add_mod m (2 ^ F)
+  have e2 := Nat.div_add_mod (m / 2 ^ F) 2
+  have hr : m % 2 ^ F < 2 ^ F := Nat.mod_lt _ hP
+  have hb : m / 2 ^ F % 2 < 2 := Nat.mod_lt _ (by decide)
+  rw [Nat.pow_succ]
+  generalize m / 2 ^ F / 2 = s at e2
+  generalize m / 2 ^ F % 2 = t at e2 hb ⊢
+  generalize m / 2 ^ F = q at e1 e2
+  generalize m % 2 ^ F = r at e1 hr ⊢
+  generalize 2 ^ F = P at hP e1 hr ⊢
+  subst e2
+  rw [← e1, show P * (2 * s + t) + r = (r + t * P) + P * 2 * s by
+    rw [Nat.mul_add, Nat.mul_comm P t, ← Nat.mul_assoc]; omega]
+  rw [Nat.add_mul_mod_self_left]
+  have htP : t * P ≤ P := by
+    rcases (by omega : t = 0 ∨ t = 1) with h | h <;> subst h <;> omega
+  exact Nat.mod_eq_of_lt (by omega)
+
+-- REFLECTION of the_bits_of_a_number…: the number is rebuilt from its bits
+theorem 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 := by
+  intro F m
+  induction F with
+  | zero => show 0 = m % 1; rw [Nat.mod_one]
+  | succ F ih =>
+    rw [List.range_succ, List.foldl_append, ih]
+    simp only [List.foldl]
+    rw [the_residue_below_the_next_power_adds_one_bit]
+
+theorem 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 := by
+  intro n
+  rw [the_low_bits_rebuild_the_number_below_every_power, Nat.mod_eq_of_lt (a_number_is_below_two_to_its_own_successor n)]
+
 end Sequences

package/src/proof/speed.lean

@@ -149,4 +149,10 @@ theorem hexbits_are_slower_and_the_ratio_multiplies_back :
 -- encoding changes how many characters carry a value, not how many operations are performed. §7 above proves
 -- the operation-count claim; the two theorems above prove the width and the cost. Nothing was lost.
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem the_nanoseconds_return_from_the_microseconds_at_every_whole_count :
+    ∀ n : Nat, n % 1000 = 0 → n / 1000 * 1000 = n := by
+  intro n h; omega
+
 end Speed

package/src/proof/split.lean

@@ -196,4 +196,14 @@ theorem the_coin_step_and_the_coins_are_inverse_for_every_c :
   intro c
   exact ⟨Nat.mul_div_cancel_left c (by decide), Nat.mul_mod_right 3 c⟩
 
+
+-- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
+theorem the_coins_return_from_the_coin_step_for_every_multiple_of_three :
+    ∀ t : Nat, t % 3 = 0 → 3 * (t / 3) = t := by
+  intro t h; omega
+
+theorem paying_and_refunding_round_trips_for_every_count :
+    ∀ n k : Nat, k ≤ n → 3 * (n - k) + 3 * k = 3 * n := by
+  intro n k h; omega
+
 end Split