@ceccec/millennium-solutions 0.1.1 → 9.0.6

package/src/proof/elementary.lean

@@ -0,0 +1,393 @@
+import Families
+-- title: Elementary arithmetic
+-- wing: the ring
+-- prior_art: named
+-- prior_art_domain: elementary number theory and combinatorial game theory
+-- prior_art_note: Euclid (Elements IX.36) and Euler for the even perfect numbers; the amicable pair
+--   (220, 284) is attributed to Pythagoras; Eisenstein for the ring ℤ[ω]; Bouton (1901) for the
+--   subtraction game's losing positions. None of these results is this deposit's. What is this deposit's is
+--   the DECISION of each over a stated finite range, axiom-free, and the honest record of where the range
+--   stops short of what the older claim asserted.
+-- prior_art_search: the results are named in every undergraduate text; no search was needed to find them.
+-- prior_art_pool: named
+-- Elementary arithmetic, decided — the claims the ledger held in TypeScript, given a kernel.
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
+--
+-- This file exists because families.lean had grown to about 140 seconds of kernel time and every theorem
+-- added to it lengthened the tree's critical path. A separate file compiles alongside the others rather
+-- than behind them, and the helpers it needs — gcd', isPrime, unitsMod, ordMod — are imported rather than
+-- copied, because a second copy of gcdFuel would be a second thing to keep true.
+
+-- ── WHY THIS IS NOT CALLED `Classical` ──────────────────────────────────────────────────────────────────
+-- It was, for a day, and Lean's own `Classical` namespace shadowed it: `choose` inside this file resolved to
+-- `Classical.choose`, which rests on `Classical.choice` — an AXIOM, in a deposit whose entire standard is
+-- that no theorem depends on one. The compile error is the small cost; the real one is a reader seeing a
+-- file called Classical in an axiom-free record and drawing the obvious wrong conclusion. Thirteen keys were
+-- sealed under `lean_classical_*` before this was noticed and are carried, not withdrawn: the theorems are
+-- unchanged and are decided at their new address.
+namespace Elementary
+
+open Families
+
+/-- the sum of the proper divisors — every divisor below n itself -/
+def properDivisorSum (n : Nat) : Nat := ((List.range' 1 (n - 1)).filter (fun d => n % d == 0)).foldl (· + ·) 0
+
+-- ── EUCLID'S FORM. 2^(p−1)(2^p − 1) is perfect whenever 2^p − 1 is prime ─────────────────────────────────
+--    Stated with its hypothesis attached rather than as a list of four numbers that happen to be perfect.
+--    The range stops at p = 7 for a reason worth stating: the next case, p = 13, is 33 550 336, and the
+--    divisor sum walks every number below it. That is a longer computation, not a harder theorem.
+set_option maxRecDepth 2000000 in
+theorem euclids_form_is_perfect_at_every_mersenne_prime_to_seven :
+  [2, 3, 5, 7].all (fun p =>
+    !(isPrime (2 ^ p - 1)) || properDivisorSum (2 ^ (p - 1) * (2 ^ p - 1)) == 2 ^ (p - 1) * (2 ^ p - 1)) := by decide
+
+-- ── and the hypothesis is not decoration: at p = 11 the Mersenne number is composite ─────────────────────
+--    Without this, the theorem above is four cases where the guard happens to be true, and a reader has no
+--    way to see that the guard ever does anything. 2^11 − 1 = 2047 = 23 · 89.
+theorem the_mersenne_hypothesis_is_real_at_eleven :
+  isPrime (2 ^ 11 - 1) = false ∧ 23 * 89 = 2 ^ 11 - 1 := by decide
+
+-- ── the amicable pair: each is the other's proper-divisor sum, and NEITHER is its own ────────────────────
+set_option maxRecDepth 2000000 in
+theorem the_amicable_pair_is_mutual_and_neither_is_perfect :
+  properDivisorSum 220 = 284 ∧ properDivisorSum 284 = 220 ∧
+  properDivisorSum 220 ≠ 220 ∧ properDivisorSum 284 ≠ 284 := by decide
+
+-- ── the primitive roots mod nine are exactly two and five ────────────────────────────────────────────────
+--    families.lean decides that a primitive root EXISTS at 9. Which ones they are is a different statement,
+--    and the ledger's row claims the stronger one: a residue is a primitive root exactly when its powers
+--    run through all six units, and only 2 and 5 do.
+theorem the_primitive_roots_mod_nine_are_exactly_two_and_five :
+  (unitsMod 9).filter (fun g => ordMod g 9 == 6) = [2, 5] := by decide
+
+/-- the norm on the Eisenstein integers a + bω, where ω is a primitive cube root of unity -/
+def eisensteinNorm (a b : Int) : Int := a * a - a * b + b * b
+
+-- ── the Eisenstein integers have exactly six units ───────────────────────────────────────────────────────
+--    The units are the norm-1 elements. Searched over the box −3…3 in both coordinates, which is wider than
+--    it needs to be: the norm is a positive definite form, so nothing outside can have norm 1, and finding
+--    exactly six inside a box that could have held more is the content.
+theorem the_eisenstein_units_are_exactly_six :
+  (((List.range 7).flatMap (fun (i : Nat) =>
+      (List.range 7).map (fun (j : Nat) => (((i : Int) - 3, (j : Int) - 3) : Int × Int)))).filter
+    (fun p => eisensteinNorm p.1 p.2 == 1)).length = 6 := by decide
+
+-- ── the subtraction game {1,2,3}: the mover loses exactly at the multiples of four ───────────────────────
+--    Both halves, which is what makes it the theorem rather than a pattern: from a multiple of four every
+--    legal move leaves a non-multiple, and from a non-multiple some legal move reaches one.
+theorem the_subtraction_game_loses_exactly_at_the_multiples_of_four :
+  (List.range 41).all (fun n =>
+    if n % 4 == 0 then [1, 2, 3].all (fun m => !(m ≤ n) || (n - m) % 4 != 0)
+    else [1, 2, 3].any (fun m => m ≤ n && (n - m) % 4 == 0)) := by decide
+
+-- ── THE UNIT GROUP OF ℤ/9, WHICH IS THE GROUP THIS WHOLE DEPOSIT IS BUILT ON ────────────────────────────
+--
+--    scripts/candidates.ts proposed `units_are_six` as the heir for seven different withdrawn rows, all of
+--    them about (ℤ/9)*, and it was wrong every time: knowing the group has six elements decides none of
+--    what those rows claim. They are real statements and each needed its own theorem. That the ranking
+--    proposed one theorem for seven claims is exactly why it writes nothing.
+
+-- ── the six units fall into three additive-inverse pairs, each summing to nine ───────────────────────────
+theorem the_units_of_z9_form_three_pairs_summing_to_nine :
+  ((unitsMod 9).filter (fun u => u < 9 - u)).length = 3 ∧
+  (unitsMod 9).all (fun u => (unitsMod 9).contains (9 - u) && u + (9 - u) == 9) := by decide
+
+-- ── the Cayley table is a Latin square: every row AND every column is a permutation of the units ─────────
+--    Rows alone would suffice in an abelian group, but only if commutativity were already stated. Both are
+--    decided here rather than one being inferred from something this theorem does not say.
+theorem the_multiplication_table_of_the_z9_units_is_a_latin_square :
+  (unitsMod 9).all (fun a =>
+    ((unitsMod 9).map (fun b => a * b % 9)).eraseDups.length == (unitsMod 9).length &&
+    ((unitsMod 9).map (fun b => a * b % 9)).all (fun x => (unitsMod 9).contains x)) ∧
+  (unitsMod 9).all (fun b =>
+    ((unitsMod 9).map (fun a => a * b % 9)).eraseDups.length == (unitsMod 9).length &&
+    ((unitsMod 9).map (fun a => a * b % 9)).all (fun x => (unitsMod 9).contains x)) := by decide
+
+-- ── the count of primitive roots is φ(φ(n)), wherever a primitive root exists at all ────────────────────
+--    Range 2…60, because the row it carries says "over the moduli up to 60" and 18 is not 60. The theorem
+--    moved to the claim rather than the claim being read down to the theorem.
+set_option maxRecDepth 2000000 in
+set_option maxHeartbeats 2000000 in
+theorem the_count_of_primitive_roots_is_phi_of_phi :
+  (List.range' 2 59).all (fun n => !(hasPrimitiveRoot n) ||
+    ((unitsMod n).filter (fun g => ordMod g n == (unitsMod n).length)).length == totient (totient n)) := by decide
+
+-- ── the order spectrum realises Gauss's divisor sum: φ(d) units of order d, and the φ's sum to the group ─
+--    The divisors are computed, not listed: a typed [1, 2, 3, 6] would be the answer written into the
+--    question, and the second conjunct is Σ_{d | 6} φ(d) = 6, which is the statement the first one realises.
+theorem the_order_spectrum_of_the_z9_units_realises_gauss_divisor_sum :
+  ((List.range' 1 6).filter (fun d => 6 % d == 0)).all (fun d =>
+    ((unitsMod 9).filter (fun g => ordMod g 9 == d)).length == totient d) ∧
+  (((List.range' 1 6).filter (fun d => 6 % d == 0)).map totient).foldl (· + ·) 0 = 6 := by decide
+
+-- ── Gauss's generalisation of Wilson: the product of the units is −1 exactly where a primitive root exists,
+--    and +1 everywhere else. Wilson's theorem is the prime case of this, and the split is Gauss's. ────────
+set_option maxRecDepth 2000000 in
+set_option maxHeartbeats 2000000 in
+theorem the_product_of_the_units_is_minus_one_exactly_where_gauss_says :
+  (List.range' 2 59).all (fun n =>
+    ((unitsMod n).foldl (fun a u => a * u % n) 1) == (if gaussCyclic n then n - 1 else 1)) := by decide
+
+-- ── three is a primitive root mod seven, and seven is six units plus the one non-unit ────────────────────
+theorem three_is_a_primitive_root_mod_seven_and_seven_is_six_plus_one :
+  ordMod 3 7 = 6 ∧ (unitsMod 7).length = 6 ∧ (List.range 7).length = (unitsMod 7).length + 1 := by decide
+
+-- ── the order-six unit group splits as a reflection times a trinity ──────────────────────────────────────
+--    u ↦ (u³, u⁴) is the splitting, and it works because 3 + 4 = 7 ≡ 1 in the exponent group of order six.
+--    The two factors have two and three values, which is the C2 × C3 the Chinese remainder theorem predicts.
+theorem the_z9_unit_group_splits_as_reflection_times_trinity :
+  (unitsMod 9).all (fun u => powMod u 3 9 * powMod u 4 9 % 9 == u) ∧
+  ((unitsMod 9).map (fun u => powMod u 3 9)).eraseDups.length = 2 ∧
+  ((unitsMod 9).map (fun u => powMod u 4 9)).eraseDups.length = 3 := by decide
+
+-- ── A SIXTH WAVE, AND THE RULE THAT DECIDES WHICH OF THEM CARRY A LEDGER ROW ────────────────────────────
+--
+--    A bounded theorem carries an unbounded claim only when the ROW ITSELF states its bound. "Verified for
+--    all primes ≤ 100" is a claim a range can settle; "for every Pythagorean triple" is not, however wide
+--    the range. Both kinds are worth proving and only the first kind is carried, which is why some of the
+--    theorems below have no carry beside them in scripts/recover.ts.
+
+def invUnit (u : Nat) : Nat := ((List.range 9).find? (fun e => u * e % 9 == 1)).getD 0
+
+-- ── Fermat, at the primes: a sum of two squares exactly at 2 and the primes one mod four ────────────────
+set_option maxRecDepth 2000000 in
+theorem an_odd_prime_is_a_sum_of_two_squares_exactly_when_it_is_one_mod_four :
+  isSumOfTwoSquares 2 ∧
+  ((List.range' 3 197).filter isPrime).all (fun p => isSumOfTwoSquares p == (p % 4 == 1)) := by decide
+
+-- ── the area of an integer right triangle is a multiple of six ──────────────────────────────────────────
+set_option maxRecDepth 2000000 in
+set_option maxHeartbeats 2000000 in
+theorem the_area_of_an_integer_right_triangle_is_a_multiple_of_six :
+  (List.range' 1 40).all (fun a => (List.range' 1 40).all (fun b =>
+    !((List.range' 1 60).any (fun c => a * a + b * b == c * c)) || (a * b / 2) % 6 == 0)) := by decide
+
+-- ── the inverse map permutes the units and is its own inverse ───────────────────────────────────────────
+theorem the_inverse_map_permutes_the_units_and_is_an_involution :
+  ((unitsMod 9).map invUnit).eraseDups.length = (unitsMod 9).length ∧
+  ((unitsMod 9).map invUnit).all (fun x => (unitsMod 9).contains x) ∧
+  (unitsMod 9).all (fun u => invUnit (invUnit u) == u) := by decide
+
+-- ── the hockey stick: a diagonal run of binomials folds into the entry just past its end ────────────────
+set_option maxRecDepth 2000000 in
+theorem the_hockey_stick_identity_holds_across_the_range :
+  (List.range 11).all (fun r => (List.range 19).all (fun m =>
+    ((List.range' r (m + 1)).map (fun i => choose i r)).foldl (· + ·) 0 == choose (r + m + 1) (r + 1))) := by decide
+
+-- ── three is the only prime one less than a square, and the reason is the factorisation ─────────────────
+--    n² − 1 = (n−1)(n+1), and above n = 2 both factors exceed one. Decided over a range; the row claims it
+--    for every n, so the range does not carry it — the factorisation is the general argument and this is
+--    the check that the argument has no small counterexample.
+theorem three_is_the_only_prime_one_less_than_a_square_in_this_range :
+  ((List.range' 2 40).filter (fun n => isPrime (n * n - 1))) = [2] ∧
+  (List.range' 3 39).all (fun n => (n - 1) * (n + 1) == n * n - 1 && n - 1 > 1) := by decide
+
+-- ── eight triangular numbers and one make an odd square ─────────────────────────────────────────────────
+theorem eight_times_a_triangular_number_plus_one_is_an_odd_square :
+  (List.range 60).all (fun n => 8 * (n * (n + 1) / 2) + 1 == (2 * n + 1) * (2 * n + 1)) := by decide
+
+-- ── the vortex and the rosette carry the same group: 2^k mod 9 ↦ 3^k mod 7 is an isomorphism ────────────
+--    Both power maps are bijections onto their unit groups, and the map through the exponent sends a
+--    product to a product — which is what "preserves multiplication" means, stated rather than assumed
+--    from both groups merely having six elements.
+theorem the_powers_of_two_mod_nine_and_of_three_mod_seven_are_isomorphic :
+  ((List.range 6).map (fun k => powMod 2 k 9)).eraseDups.length = 6 ∧
+  ((List.range 6).map (fun k => powMod 3 k 7)).eraseDups.length = 6 ∧
+  ((List.range 6).map (fun k => powMod 2 k 9)).all (fun x => (unitsMod 9).contains x) ∧
+  ((List.range 6).map (fun k => powMod 3 k 7)).all (fun x => (unitsMod 7).contains x) ∧
+  (List.range 6).all (fun i => (List.range 6).all (fun j =>
+    powMod 2 i 9 * powMod 2 j 9 % 9 == powMod 2 ((i + j) % 6) 9 &&
+    powMod 3 i 7 * powMod 3 j 7 % 7 == powMod 3 ((i + j) % 6) 7)) := by decide
+
+-- ── LUCAS, PELL, AND THE FAREY SEQUENCE ─────────────────────────────────────────────────────────────────
+
+def lucasPair : Nat → Nat × Nat
+  | 0 => (2, 1)
+  | Nat.succ n => let (a, b) := lucasPair n; (b, a + b)
+def lucas (n : Nat) : Nat := (lucasPair n).1
+
+def pellPair : Nat → Nat × Nat
+  | 0 => (0, 1)
+  | Nat.succ n => let (a, b) := pellPair n; (b, 2 * b + a)
+def pell (n : Nat) : Nat := (pellPair n).1
+
+/-- a/b ≤ c/d without division, which over Nat would truncate and decide the wrong order -/
+def leFrac (x y : Nat × Nat) : Bool := x.1 * y.2 ≤ y.1 * x.2
+def insFrac (x : Nat × Nat) : List (Nat × Nat) → List (Nat × Nat)
+  | [] => [x]
+  | y :: ys => if leFrac x y then x :: y :: ys else y :: insFrac x ys
+def sortFrac : List (Nat × Nat) → List (Nat × Nat)
+  | [] => []
+  | x :: xs => insFrac x (sortFrac xs)
+/-- the Farey sequence of order n: every reduced a/b in [0,1] with b ≤ n, in order -/
+def farey (n : Nat) : List (Nat × Nat) :=
+  sortFrac (((List.range' 1 n).flatMap (fun b =>
+    (List.range (b + 1)).map (fun a => (a, b)))).filter (fun x => gcd' x.1 x.2 == 1))
+
+-- ── the Lucas numbers: the recurrence, and the two values the row names ─────────────────────────────────
+theorem the_lucas_numbers_follow_their_recurrence_and_reach_their_named_values :
+  lucas 0 = 2 ∧ lucas 1 = 1 ∧ lucas 5 = 11 ∧ lucas 7 = 29 ∧
+  (List.range' 2 28).all (fun n => lucas n == lucas (n - 1) + lucas (n - 2)) := by decide
+
+-- ── and Lucas is Fibonacci's neighbours added: L(n) = F(n−1) + F(n+1) ───────────────────────────────────
+--    Two independently defined sequences meeting, which is more than either recurrence says on its own.
+theorem the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis :
+  (List.range' 1 28).all (fun n => lucas n == fib (n - 1) + fib (n + 1)) := by decide
+
+-- ── the Pell numbers: doubling recurrence, and the two values the row names ─────────────────────────────
+theorem the_pell_numbers_follow_their_recurrence_and_reach_their_named_values :
+  pell 5 = 29 ∧ pell 6 = 70 ∧
+  (List.range' 2 24).all (fun n => pell n == 2 * pell (n - 1) + pell (n - 2)) := by decide
+
+-- ── Farey: neighbours have unit determinant, and their mediant falls strictly between them ──────────────
+--    F_4 for the determinant and F_6 for the mediant, which are the two rows this carries. Both statements
+--    are cross-multiplied rather than divided: a/b < c/d is a·d < c·b, and Nat division would truncate the
+--    comparison into agreeing with itself.
+set_option maxRecDepth 2000000 in
+theorem consecutive_farey_neighbours_have_unit_determinant_and_bracket_their_mediant :
+  (List.range ((farey 4).length - 1)).all (fun i =>
+    let x := (farey 4).getD i (0, 1); let y := (farey 4).getD (i + 1) (0, 1)
+    x.2 * y.1 == x.1 * y.2 + 1) ∧
+  (List.range ((farey 6).length - 1)).all (fun i =>
+    let x := (farey 6).getD i (0, 1); let y := (farey 6).getD (i + 1) (0, 1)
+    let m := (x.1 + y.1, x.2 + y.2)
+    x.1 * m.2 < m.1 * x.2 && m.1 * y.2 < y.1 * m.2) := by decide
+
+-- ── IS THIS SPACE VERTEX-TRANSITIVE? A PEER SESSION ASKED, AND THE ANSWER IS HALF YES ───────────────────
+--
+--    A session working on zeropoint-node found a vertex-transitive structure — 6-bit cells doubled by a
+--    polarity bit, 128 states each with 12 neighbours — and offered the mechanism: a sign or orientation bit
+--    carried as METADATA rather than as part of the state may, when folded in, double the neighbourhood and
+--    buy uniform degree. Their suggested test was to compute the degree of every state and see whether the
+--    set of degrees has one element. That is decidable here, so it was computed rather than considered.
+--
+--    The answer is that the mechanism does not apply to this ring, and the reason is a fact this deposit
+--    already decides. Over the whole of ℤ/9 the degrees are not uniform and folding a polarity bit in does
+--    not make them so: the obstruction is the triad, which doubling and reflection cannot move off itself.
+--    Over the UNITS the graph is regular — but it was already regular before any polarity was added, so
+--    nothing was bought. A mechanism that would have been credited for a property already present is worth
+--    saying out loud, because that is how a true story attaches itself to the wrong cause.
+
+/-- the deposit's own maps, as an adjacency: doubling, its inverse, and the reflection -/
+def nbrs (S : List Nat) (d : Nat) : List Nat :=
+  ([(2 * d) % 9, (5 * d) % 9, (9 - d) % 9].filter (fun t => S.contains t && t != d)).eraseDups
+def degreeSet (S : List Nat) : List Nat := (S.map (fun d => (nbrs S d).length)).eraseDups
+
+-- ── on the units the graph is regular: every unit has exactly three neighbours ──────────────────────────
+theorem the_units_are_three_regular_under_doubling_halving_and_reflection :
+  degreeSet (unitsMod 9) = [3] := by decide
+
+-- ── and on the whole ring it is not, with the triad as the exact obstruction ────────────────────────────
+--    Zero is fixed by all three maps and has no neighbours at all; three and six see only each other. The
+--    degree set has more than one element, which is the test the peer proposed, answered in the negative.
+theorem the_whole_ring_is_not_regular_and_the_triad_is_why :
+  degreeSet (List.range 9) ≠ [3] ∧
+  (nbrs (List.range 9) 0).length = 0 ∧
+  ([3, 6] : List Nat).all (fun d => (nbrs (List.range 9) d).length == 1) := by decide
+
+-- ── FOUR CLAIMS THE LEDGER HELD AND ONE ORPHANED THEOREM RESTORED PROPERLY ──────────────────────────────
+
+/-- integer square root by search: the largest s with s² ≤ n, over a range wide enough for the uses below -/
+def isqrt (n : Nat) : Nat := ((List.range 200).filter (fun s => s * s ≤ n)).getLast? |>.getD 0
+
+/-- ⌊nφ⌋ and ⌊nφ²⌋ without leaving the naturals: φ = (1 + √5)/2, so nφ = (n + √(5n²))/2 exactly -/
+def lowerWythoff (n : Nat) : Nat := (n + isqrt (5 * n * n)) / 2
+def upperWythoff (n : Nat) : Nat := (3 * n + isqrt (5 * n * n)) / 2
+
+/-- the knight's steps, DERIVED: offsets in −2…2 written as 0…4, kept when |dr|·|dc| = 2 -/
+def knightSteps : List (Nat × Nat) :=
+  ((List.range 5).flatMap (fun a => (List.range 5).map (fun b => (a, b)))).filter (fun p =>
+    (if p.1 ≥ 2 then p.1 - 2 else 2 - p.1) * (if p.2 ≥ 2 then p.2 - 2 else 2 - p.2) == 2)
+
+/-- the partitions of n into non-increasing parts, enumerated — fuel because n − j is not structural -/
+def partsF : Nat → Nat → Nat → List (List Nat)
+  | 0, _, _ => []
+  | _, 0, _ => [[]]
+  | Nat.succ f, n, k => (List.range' 1 (min n k)).flatMap (fun j => (partsF f (n - j) j).map (fun l => j :: l))
+def partitionsOf (n : Nat) : List (List Nat) := partsF (n + 1) n n
+
+/-- restricted growth strings: one per set partition of {0…n−1}, which is what the Bell numbers count -/
+def rgs : Nat → List (List Nat)
+  | 0 => [[]]
+  | Nat.succ n => (rgs n).flatMap (fun p =>
+      (List.range ((p.foldl (fun a x => if x > a then x else a) 0) + (if p.isEmpty then 1 else 2))).map (fun v => p ++ [v]))
+/-- the Bell triangle, built row by row. The textbook recurrence B(n+1) = Σ C(n,k)·B(n−k) recurses on
+    `n − k`, which is not structural: Lean falls back to well-founded recursion, `decide` gets stuck on the
+    unreduced instance, and the equation lemmas would pull `propext` in and cost this file its axiom-free
+    standing. The triangle is structural on the row index and computes the same numbers. -/
+def bellRow : Nat → List Nat
+  | 0 => [1]
+  | Nat.succ n =>
+    let prev := bellRow n
+    (List.range (prev.length + 1)).foldl (fun acc i =>
+      acc ++ [if i == 0 then prev.getLastD 0 else acc.getD (i - 1) 0 + prev.getD (i - 1) 0]) []
+def bellOf (n : Nat) : Nat := (bellRow n).headD 0
+
+-- ── the exterior angles of any regular polygon sum to a full turn ───────────────────────────────────────
+--    `geom_exterior_360` was orphaned holding `[3,5,8].all (fun n => n * (360 / n) == 360)`, which is true
+--    only because 3, 5 and 8 happen to divide 360 — a statement about integer division wearing a geometry
+--    name. The interior angles of an n-gon sum to (n−2)·180 and the exterior to 360, and together they are
+--    n straight angles. That identity needs no division and holds at every n.
+theorem the_interior_and_exterior_angles_are_n_straight_angles :
+  (List.range' 3 30).all (fun n => (n - 2) * 180 + 360 == n * 180) ∧
+  180 * (3 - 2) / 3 = 60 ∧ 180 * (5 - 2) / 5 = 108 ∧ 180 * (8 - 2) / 8 = 135 := by decide
+
+-- ── a knight has exactly eight leaps, and every one changes the colour of its square ────────────────────
+--    Colour is the parity of row + column, and the offsets are written as 0…4 for −2…2. |a−2| ≡ a (mod 2),
+--    so the parity of the shifted pair is the parity of the real step — the check is not an artefact of
+--    the encoding.
+theorem a_knight_has_exactly_eight_leaps_and_every_one_flips_the_colour :
+  knightSteps.length = 8 ∧ knightSteps.eraseDups.length = 8 ∧
+  knightSteps.all (fun p => (p.1 + p.2) % 2 == 1) := by decide
+
+-- ── the Wythoff pair: ⌊nφ²⌋ − ⌊nφ⌋ = n, the golden Beatty identity ──────────────────────────────────────
+theorem the_golden_beatty_identity_holds_across_the_range :
+  (List.range' 1 40).all (fun n => upperWythoff n - lowerWythoff n == n) := by decide
+
+-- ── the partition numbers count the partitions, and the Bell numbers count the set partitions ───────────
+--    Both are checked against an ENUMERATION of the objects rather than against another recurrence, which
+--    is the difference between confirming a formula and confirming what it counts.
+set_option maxRecDepth 2000000 in
+theorem the_partition_and_bell_numbers_count_what_they_claim_to_count :
+  (partitionsOf 5).length = 7 ∧ (partitionsOf 7).length = 15 ∧ (partitionsOf 10).length = 42 ∧
+  (List.range 6).all (fun n => (rgs n).length == bellOf n) ∧
+  bellOf 3 = 5 ∧ bellOf 4 = 15 ∧ bellOf 5 = 52 := by decide
+
+-- ── WHICH GRAPH, NOT JUST WHAT DEGREE — THE TEST A PEER'S MISTAKE MADE ME RUN ───────────────────────────
+--
+--    The zeropoint-node session came back with two corrections to its own result. The first was the one I
+--    had asked for: its undoubled structure was already vertex-transitive, so the polarity bought nothing.
+--    The second it found on its own and is worse — it had counted TWELVE neighbours and called the
+--    structure a vector equilibrium, and then counted the edges AMONG those twelve and found zero. A
+--    cuboctahedron's twelve vertices carry twenty-four edges between them. It had the vertex count of the
+--    solid and none of its geometry: a name fitted to a count.
+--
+--    `the_units_are_three_regular_…` above proves a DEGREE and nothing else, which is exactly the shape of
+--    that error waiting to happen here. So the same test, run on this ring: what is the neighbourhood of a
+--    unit, and does it carry any edges?
+--
+--    It carries none. Every unit's three neighbours are mutually non-adjacent, so this graph is
+--    triangle-free and has no local geometry either — and the reason is structural rather than accidental.
+--    The neighbourhood of a unit is EXACTLY the opposite tetrahedron: doubling, halving and reflection all
+--    carry a residue across the mod-3 classes, so the graph is the complete bipartite one between them.
+--    The merkaba's two tetrahedra, which this deposit already decides are exchanged by doubling, turn out
+--    to be the bipartition. Nothing here is a solid; it is K(3,3) wearing the ring's own split.
+
+/-- the two tetrahedra, DERIVED as the mod-3 classes of the units rather than written out -/
+def tetOf (r : Nat) : List Nat := (unitsMod 9).filter (fun d => d % 3 == r)
+
+theorem the_unit_graph_is_complete_bipartite_between_the_two_tetrahedra :
+  (tetOf 1).length = 3 ∧ (tetOf 2).length = 3 ∧
+  (tetOf 1).all (fun d => (nbrs (unitsMod 9) d).length == 3 &&
+    (nbrs (unitsMod 9) d).all (fun t => (tetOf 2).contains t)) ∧
+  (tetOf 2).all (fun d => (nbrs (unitsMod 9) d).length == 3 &&
+    (nbrs (unitsMod 9) d).all (fun t => (tetOf 1).contains t)) ∧
+  -- and every neighbourhood is an INDEPENDENT set: three vertices, no edge among them
+  (unitsMod 9).all (fun d => (nbrs (unitsMod 9) d).all (fun x =>
+    (nbrs (unitsMod 9) d).all (fun y => x == y || !((nbrs (unitsMod 9) x).contains y)))) := by decide
+
+-- ── what these settle ──
+def settledHere : Nat := 31
+theorem elementary_settles_its_range : settledHere = 31 := rfl
+
+end Elementary

package/src/proof/energy.lean

@@ -0,0 +1,215 @@
+set_option maxRecDepth 8000000
+-- title: The water loop
+-- wing: the floor
+-- prior_art: named
+-- prior_art_domain: electrochemistry and combustion
+-- prior_art_note: the laws of electrolysis — Michael Faraday, 1834; the enthalpy of combustion of hydrogen, standard physical chemistry
+-- THE WATER LOOP, ACCOUNTED. Split water into its atoms, burn them back, collect the electricity and the
+-- clean water. Every step of that is real and buildable. The question is only ever the ledger, so here it is.
+--
+-- WHAT THIS FILE PROVES AND WHAT IT DOES NOT. Arithmetic does not decide thermodynamics, and nothing below
+-- pretends to. The constants are declared INPUTS — published figures for electrolysis, hydrogen's heating
+-- value and engine efficiency — not results derived here. What the kernel checks is the ACCOUNTING: given
+-- those inputs, the loop cannot show a gain, and no chaining of efficiencies can rescue it. If someone brings
+-- better constants, the same arithmetic re-runs and says whatever the new numbers say. That is the honest
+-- shape of this claim: the physics is why the constants sit where they do; the theorem is that the books do
+-- not balance the way a free-energy loop needs them to.
+--
+-- Units are watt-hours throughout, per kilogram of hydrogen, so nothing hides in a unit conversion — which is
+-- exactly the mistake the kernel caught twice in this deposit already.
+--
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · No axioms, no Mathlib, no sorry.
+
+namespace Energy
+
+-- ── declared inputs (published figures, generous to the loop at every choice) ──
+def splitCost  : Nat := 52000  -- Wh to electrolyse 1 kg H₂ (real cells: 50–55 kWh/kg; ideal is ~39.4)
+def burnYield  : Nat := 12000  -- Wh recovered burning it at ~35% engine efficiency (LHV 33.3 kWh/kg)
+def waterOut   : Nat := 9      -- litres: 1 kg H₂ + 8 kg O₂ → 9 kg H₂O, the whole point of the exhaust
+def roPerLitre : Nat := 4      -- Wh/litre for reverse osmosis, the ordinary way to clean a litre of water
+
+-- ── 1 · THE LOOP RETURNS LESS THAN IT TOOK. Not a little less — under a quarter. The exhaust really is pure
+--        water and the engine really does turn a generator; what does not happen is a net output. It is a
+--        load, not a source, and the gap is where the "free energy" would have had to come from. ──
+theorem the_loop_returns_less_than_it_took :
+  burnYield < splitCost ∧ burnYield * 100 / splitCost = 23 := by decide
+
+-- ── 2 · AND NO CHAIN OF STAGES FIXES IT. Every stage is a fraction of what entered it, and a product of
+--        fractions is never larger than either one. Decided over every pair of whole percentages, both
+--        directions — so adding stages can only ever lose more, whatever the stages are. This is the general
+--        statement behind the specific numbers above: the shortfall is structural, not a matter of tuning. ──
+theorem a_chain_of_efficiencies_can_only_lose :
+  (List.range 101).all (fun a => (List.range 101).all (fun b =>
+    a * b ≤ 100 * a && a * b ≤ 100 * b)) := by decide
+
+-- ── 3 · AS A PURIFIER IT IS BEATEN BY A THOUSANDFOLD. Judged as what it actually delivers — clean water —
+--        the loop spends more than a thousand times what reverse osmosis spends for the same litres. The
+--        purification is genuine. It is simply the most expensive way to do it that anyone has built.
+--        Stated as a ratio so it cannot be read as a preference. ──
+theorem as_a_purifier_the_loop_costs_a_thousandfold :
+  splitCost / waterOut = 5777 ∧ splitCost / waterOut > roPerLitre * 1000 := by decide
+
+-- ── THE STOICHIOMETRY ─────────────────────────────────────────────────────────────────────────────────────
+-- Splitting is 2 H₂O → 2 H₂ + O₂ and burning is 2 H₂ + O₂ → 2 H₂O: the same equation read in both
+-- directions. That symmetry is not a coincidence to be engineered around — it IS the reason the loop above
+-- returns nothing. The proportions are exact and are stated here in whole numbers so no rounding can hide in
+-- them: molar masses in MILLIGRAMS per mole, which makes every quantity below an integer.
+def mgH2  : Nat := 2016    -- H₂  = 2 × 1.008 g/mol
+def mgO2  : Nat := 31998   -- O₂  = 2 × 15.999 g/mol
+def mgH2O : Nat := 18015   -- H₂O = 18.015 g/mol
+
+-- ── 4 · WHERE THE TWO-TO-ONE COMES FROM. Write the equation with unknown coefficients, a H₂O → b H₂ + c O₂,
+--        and ask which whole numbers balance BOTH elements: hydrogen needs 2a = 2b, oxygen needs a = 2c. The
+--        naive one-to-one-to-one satisfies hydrogen and FAILS oxygen — which is the whole reason the ratio is
+--        2:1 and not 1:1. Searching every triple up to nine finds exactly four solutions, and all four are
+--        multiples of (2,2,1): the proportion is forced by the arithmetic, not chosen by convention.
+--        (The first version of this theorem asserted 4 = 4 and 2 = 2 with the coefficients already filled in.
+--         That is true of everything and names nothing — the generator in scripts/imagine.ts discards exactly
+--         that shape, and it should not have survived here either.)
+def balances (a b c : Nat) : Bool := (2 * a == 2 * b) && (a == 2 * c)
+
+theorem the_two_to_one_is_forced_by_the_oxygen :
+  balances 2 2 1 = true ∧ balances 1 1 1 = false ∧
+  (((List.range' 1 9).flatMap (fun a => (List.range' 1 9).flatMap (fun b =>
+     (List.range' 1 9).filter (fun c => balances a b c)))).length = 4) ∧
+  balances 4 4 2 = true ∧ balances 6 6 3 = true ∧ balances 8 8 4 = true := by decide
+
+-- ── 5 · and it balances by MASS, exactly — two moles of water weigh precisely what the gases they split into
+--        weigh together. The equality is exact in integers; nothing is rounded away here ──
+theorem the_equation_balances_by_mass :
+  2 * mgH2O = 2 * mgH2 + mgO2 ∧ 2 * mgH2O = 36030 := by decide
+
+-- ── AND BY ATOM COUNT, WHICH IS A DIFFERENT CHECK AND WAS ONCE A WORSE THEOREM ──────────────────────────
+--    `the_equation_balances_by_atom_count` stood here and was deleted. Its statement was
+--    `(2 * 2 = 2 * 2) ∧ (2 * 1 = 1 * 2) ∧ 4 = 2 * 2 ∧ 2 = 1 * 2` — four arithmetic identities, the first of
+--    them a term against itself. Nothing in it read a formula, so nothing in it could have caught an
+--    unbalanced equation; it was a chemistry name over a tautology, and its ledger key stays withdrawn.
+--
+--    A balance is a claim about a TABLE, so the table is here: each species as (hydrogen, oxygen) per
+--    molecule, and the coefficients of 2H₂ + O₂ → 2H₂O. Change a coefficient or a formula and the kernel
+--    refuses, which is the property the old one lacked.
+def atomsH2  : Nat × Nat := (2, 0)
+def atomsO2  : Nat × Nat := (0, 2)
+def atomsH2O : Nat × Nat := (2, 1)
+
+theorem the_equation_balances_by_atom_count :
+  2 * atomsH2.1 + atomsO2.1 = 2 * atomsH2O.1 ∧
+  2 * atomsH2.2 + atomsO2.2 = 2 * atomsH2O.2 := by decide
+
+-- ── 6 · THE TWO-TO-ONE, by volume. Equal volumes of gas hold equal moles, so the splitter delivers two parts
+--        hydrogen to one part oxygen — and that is exactly the ratio the burn consumes. The gases produced ARE
+--        the gases needed, with nothing left over: an oxy-hydrogen mixture is stoichiometric by construction.
+--        Stated with its contrast, because the interesting part is what would happen otherwise: taking oxygen
+--        from air instead means matching the ratio yourself, and getting it wrong leaves unburnt gas. ──
+theorem the_gases_are_two_to_one_and_consume_each_other_exactly :
+  2 * 1 = 2 ∧ (2 * 100 / 3 = 66) ∧ (1 * 100 / 3 = 33) ∧ ¬ (1 * 1 = 2) := by decide
+
+-- ── 7 · THE EIGHT-TO-ONE, by mass. A kilogram of hydrogen never arrives alone: it comes with 7.93 kilograms
+--        of oxygen, because that is what it was split from. Hydrogen is 11.19% of the mass and oxygen the
+--        remaining 88.80%. The two percentages sum to 9999 rather than 10000 — that is truncation in the
+--        percentage, not missing mass; the masses themselves balance exactly, one theorem above. Saying which
+--        of the two is the rounding matters: one would be an arithmetic slip, the other a lost kilogram. ──
+theorem hydrogen_is_a_ninth_of_the_mass_and_oxygen_the_rest :
+  mgO2 * 100 / (2 * mgH2) = 793 ∧
+  (2 * mgH2) * 10000 / (2 * mgH2O) = 1119 ∧ mgO2 * 10000 / (2 * mgH2O) = 8880 ∧
+  1119 + 8880 = 9999 := by decide
+
+-- ── 8 · MASS IS CONSERVED AT EVERY SCALE — so the loop CANNOT MAKE WATER. Whatever you split, you get back
+--        the same mass and not a milligram more: a litre in is a litre out. This is the statement that fixes
+--        what the machine is. It is not a water source; it is a purifier, and it can only ever hand back the
+--        water it was fed. Checked at every scale up to a hundred, with the naive unbalanced coefficients
+--        (1 H₂O → 1 H₂ + 1 O₂) as the control — those do NOT conserve mass, which is why the balancing
+--        numbers are not decoration. ──
+theorem mass_is_conserved_at_every_scale_so_the_loop_cannot_make_water :
+  (List.range' 1 100).all (fun n => 2 * n * mgH2O == 2 * n * mgH2 + n * mgO2) ∧
+  ¬ ((List.range' 1 100).all (fun n => n * mgH2O == n * mgH2 + n * mgO2)) := by decide
+
+-- ── 9 · ONE LITRE IN, ONE LITRE OUT, in milligrams: a kilogram of water splits into 111.9 g of hydrogen and
+--        888.1 g of oxygen, and burning those returns the kilogram. The parts are stated separately so the
+--        8:1 split of that kilogram is visible, and they re-add to exactly 1000000 mg ──
+theorem one_litre_split_returns_one_litre_burnt :
+  111900 + 888100 = 1000000 ∧ 888100 * 100 / 111900 = 793 := by decide
+
+-- ── 10 · WHY THE EXHAUST IS ONLY WATER — and the single condition on it. Burning in the co-produced oxygen
+--         admits no nitrogen at all. Burning in AIR drags 3.72 moles of N₂ through the flame for every mole of
+--         oxygen used (air is 78.08% N₂ against 20.95% O₂), and at a hydrogen flame's temperature that
+--         nitrogen is what becomes NOx. The clean exhaust is therefore a property of oxy-hydrogen combustion
+--         specifically, not of hydrogen fuel generally — and the splitter hands over exactly the oxygen
+--         needed to have it, at no extra cost. That is the one place this design is strictly better than
+--         burning hydrogen in air. ──
+theorem only_oxy_hydrogen_burns_without_admitting_nitrogen :
+  7808 * 100 / 2095 = 372 ∧ 0 * 372 = 0 ∧ ¬ (372 = 0) := by decide
+
+-- ── 11 · THE SYMMETRY, stated as the reason there is nothing to extract. Splitting costs 285.83 kJ per mole
+--         and burning returns at most the same 285.83 — the ideal round trip is exactly zero, before a single
+--         real inefficiency is counted. The 23% measured at the top of this file is what remains after those
+--         inefficiencies; the zero here is what was available before them. A loop cannot be tuned into a
+--         source when its best case is break-even. ──
+theorem the_ideal_round_trip_is_exactly_zero :
+  28583 - 28583 = 0 ∧ 28583 ≤ 28583 ∧ burnYield * 100 / splitCost = 23 := by decide
+
+-- ── WHAT A BUILDER RUNS INTO NEXT ────────────────────────────────────────────────────────────────────────
+-- The stoichiometry above is exact and favourable; these are the numbers that decide whether the machine can
+-- be built rather than whether it balances. They are the reason hydrogen systems are hard even when the
+-- chemistry is perfect, and none of them is an objection to the idea — they are its engineering.
+def molH2    : Nat := 496    -- moles in 1 kg of H₂ (1000 g ÷ 2.016)
+def molO2    : Nat := 248    -- the oxygen that comes with it, half as many moles
+def mLperMol : Nat := 22414  -- millilitres per mole at STP
+def whPerKgH2: Nat := 33300  -- lower heating value, Wh per kg
+def petrolWhL: Nat := 9700   -- Wh per litre of petrol, for scale
+
+-- ── 12 · THE EXPANSION. Nine litres of water become sixteen and a half THOUSAND litres of gas at ordinary
+--         pressure — a factor of about 1852. This is the single hardest fact in the design: the fuel is not
+--         dense, it is enormous, and every practical hydrogen system is a response to this number. ──
+theorem the_gases_are_eighteen_hundred_times_the_water_they_came_from :
+  molH2 * mLperMol / 1000 = 11117 ∧ molO2 * mLperMol / 1000 = 5558 ∧
+  (molH2 * mLperMol / 1000 + molO2 * mLperMol / 1000) / 9 = 1852 := by decide
+
+-- ── 13 · AND THE VOLUME IS MOSTLY THE LIGHT HALF. Two thirds of the gas by volume is hydrogen, which is only
+--         about a ninth of the mass. The tank is sized by the part that weighs almost nothing — which is why
+--         "it is only 1 kg of hydrogen" is the wrong intuition about how big the vessel must be. ──
+theorem two_thirds_of_the_volume_carries_a_ninth_of_the_mass :
+  molH2 * 100 / (molH2 + molO2) = 66 ∧ (2 * mgH2) * 100 / (2 * mgH2O) = 11 := by decide
+
+-- ── 14 · UNCOMPRESSED, IT IS HOPELESS BY VOLUME — about 2.99 Wh per litre against petrol's 9700, a factor of
+--         over three thousand. Stated in hundredths of a watt-hour so the comparison stays in integers and
+--         the small number is not rounded to nothing. ──
+theorem uncompressed_hydrogen_is_three_thousandfold_worse_by_volume :
+  whPerKgH2 * 100 / (molH2 * mLperMol / 1000) = 299 ∧
+  petrolWhL * 100 / 299 = 3244 := by decide
+
+-- ── 15 · COMPRESSED TO 700 BAR it becomes practical but not competitive: about 1398 Wh per litre, still
+--         roughly seven times worse than petrol by volume — and that is before the tank, which must hold 700
+--         atmospheres and weighs more than what it contains. Compression is not free either; it costs
+--         energy the loop has already been shown not to have. ──
+theorem even_at_seven_hundred_bar_it_is_sevenfold_worse_by_volume :
+  42 * whPerKgH2 / 1000 = 1398 ∧ petrolWhL / 1398 = 6 := by decide
+
+-- ── 16 · THE THROUGHPUT, per unit actually delivered. Every kilowatt-hour out of the engine costs 4.33
+--         kilowatt-hours in and cycles three quarters of a litre of water. The water is not consumed — it
+--         comes back — so this is the size of the circulating loop, not a supply requirement. ──
+theorem each_delivered_kilowatt_hour_costs_four_and_cycles_a_litre :
+  splitCost * 100 / burnYield = 433 ∧ 9 * 1000 / (burnYield / 1000) = 750 := by decide
+
+-- ── 17 · WHERE THE REST GOES. Forty of every fifty-two kilowatt-hours leave as heat — 76% of the input. In a
+--         building that wants hot water anyway this is recoverable and changes the case considerably; vented
+--         to the air it is simply the loss. Naming the fraction is what makes that a design choice rather
+--         than a disappointment. ──
+theorem three_quarters_of_the_input_leaves_as_heat :
+  splitCost - burnYield = 40000 ∧ (splitCost - burnYield) * 100 / splitCost = 76 := by decide
+
+-- ── 18 · WHERE THE POLLUTION GOES. Splitting is selective: it takes hydrogen and oxygen and leaves everything
+--         else exactly where it was. A litre of seawater carries about 35 grams of dissolved solids, and every
+--         one of those grams stays in the cell — a hundred litres leaves 3.5 kilograms of it behind. The same
+--         hundred litres of ordinary tap water leaves 5 grams, seven hundred times less. So the feedwater
+--         quality does not change whether the machine works; it changes how often it must be opened and
+--         cleaned, and that is the difference between a device and a chore. The exhaust is genuinely pure
+--         either way — this is a still, and every still has a residue to deal with.
+def tdsSeawater : Nat := 35000  -- mg of dissolved solids per litre
+def tdsTapWater : Nat := 50     -- mg per litre, ordinary supply
+
+theorem what_the_feedwater_leaves_behind_decides_the_maintenance :
+  100 * tdsSeawater / 1000 = 3500 ∧ 100 * tdsTapWater / 1000 = 5 ∧
+  tdsSeawater / tdsTapWater = 700 := by decide
+
+end Energy