@ceccec/millennium-solutions 9.3.2 → 9.3.4

package/src/proof/demand2.lean

@@ -1,207 +0,0 @@
-import Families
-set_option maxRecDepth 8000000
-set_option maxHeartbeats 4000000
--- title: The next tier of what is asked for
--- wing: the floor
--- prior_art: named
--- prior_art_domain: elementary number theory, second tier
--- prior_art_note: Wilson’s theorem — John Wilson; first proved by Joseph-Louis Lagrange, 1771; the Catalan conjecture on consecutive perfect powers — Eugène Catalan, 1844; proved by Preda Mihăilescu, 2002
---
--- THE SECOND COURSE OF THE SAME FLOOR. `demand.lean` closed the top eight topics in src/demand/queries.json;
--- this file takes the next eight, chosen the same way — by impressions, not by taste. The demand map is three
--- months of the deposit's own Google Search Console data with the retrieval scaffolding stripped, so what is
--- ranked is the TOPIC people wanted a citable source for, not the phrasing they reached for.
---
--- Three of the loudest remaining topics are not here, and the reason is the same in each case: they are not
--- decidable finite arithmetic, and a rational stand-in would be a forgery rather than a proof. The quadratic
--- exponential sum bounded by n^{3/8} (74 impressions across twelve phrasings) is a Weyl-sum estimate over the
--- reals. Archimedes' bracket 223/71 < π < 22/7 (8) quantifies over π, which has no finite decidable content —
--- the rational lemma 265/153 < √3 < 1351/780 that Archimedes actually computed with is decidable, but it is a
--- DIFFERENT statement and would be passed off as this one. ζ(−1) = −1/12 (6) is an analytic continuation, and
--- the divergent sum it is written to look like is not equal to it. Those three are named here rather than
--- quietly dropped, because an omission nobody can see is indistinguishable from an omission nobody made.
---
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · No axioms, no Mathlib, no sorry.
-
-namespace Demand2
-
-open Families
-
--- ── 1 · Nicomachus's theorem — 9 impressions across four phrasings ("nicomachus's theorem", "sum of
---        consecutive cubes", "sum of consecutive cubes formula"). The sum of the first n cubes is the SQUARE
---        of the nth triangular number, checked to n = 40 in both of the forms it is asked in: against T_n²
---        and against (1+2+⋯+n)². The third clause is what keeps this from being a coincidence about sums —
---        the sum of the first n FOURTH powers is not a perfect square for any n from 2 to 20, so squareness
---        is a property of the cubes and not of power sums generally. n = 1 is carried as the boundary case
---        where it does hold, so the negative is a real dividing line rather than a blanket denial. ──
-def sumPow (p n : Nat) : Nat := (List.range' 1 n).foldl (fun a k => a + k ^ p) 0
-def tri (n : Nat) : Nat := n * (n + 1) / 2
--- squareness by trial root rather than by an integer square root: `bound` must exceed √m, and 900² far
--- exceeds the largest fourth-power sum tested here (Σ_{k≤20} k⁴ = 722666, whose root is under 851).
-def isSquareBelow (bound m : Nat) : Bool := (List.range bound).any (fun r => r * r == m)
-
-theorem nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number :
-  (List.range' 1 40).all (fun n => sumPow 3 n == tri n * tri n) ∧
-  (List.range' 1 40).all (fun n => sumPow 3 n == sumPow 1 n * sumPow 1 n) ∧
-  (List.range' 2 19).all (fun n => ¬ isSquareBelow 900 (sumPow 4 n)) ∧
-  isSquareBelow 900 (sumPow 4 1) = true := by decide
-
--- ── 2 · Pick's theorem — 7 impressions across five phrasings. Area = I + B/2 − 1 for a lattice polygon;
---        halves do not live in ℤ, so it is stated in its doubled form 2·Area = 2I + B − 2, with 2·Area read
---        off the shoelace cross product exactly. Quantified over EVERY positively oriented lattice triangle
---        with vertices in the 4×4 grid. The second clause is the discriminator: dropping the −2 gives a
---        formula that holds for NOT ONE of those triangles, so the constant is pinned rather than assumed.
---        The last two clauses are the census, decided rather than asserted in this comment — there are 1548
---        such triangles, and 516 of them contain an interior lattice point, so the range is neither empty nor
---        degenerate and the interior term of the formula is carrying weight. ──
-def pts : List (Int × Int) :=
-  (List.range 4).flatMap (fun x => (List.range 4).map (fun y => (Int.ofNat x, Int.ofNat y)))
-def triples : List ((Int × Int) × (Int × Int) × (Int × Int)) :=
-  pts.flatMap (fun a => pts.flatMap (fun b => pts.map (fun c => (a, b, c))))
-def cross (a b c : Int × Int) : Int := (b.1 - a.1) * (c.2 - a.2) - (c.1 - a.1) * (b.2 - a.2)
-def interiorCount (a b c : Int × Int) : Int :=
-  Int.ofNat (pts.filter (fun q => cross a b q > 0 && cross b c q > 0 && cross c a q > 0)).length
-def boundaryCount (a b c : Int × Int) : Int :=
-  Int.ofNat (pts.filter (fun q =>
-    cross a b q ≥ 0 && cross b c q ≥ 0 && cross c a q ≥ 0 &&
-    (cross a b q == 0 || cross b c q == 0 || cross c a q == 0))).length
-
-theorem picks_theorem_holds_for_every_lattice_triangle_in_the_four_grid :
-  pts.all (fun a => pts.all (fun b => pts.all (fun c =>
-    cross a b c ≤ 0 || cross a b c == 2 * interiorCount a b c + boundaryCount a b c - 2))) ∧
-  ¬ pts.any (fun a => pts.any (fun b => pts.any (fun c =>
-    cross a b c > 0 && cross a b c == 2 * interiorCount a b c + boundaryCount a b c))) ∧
-  (triples.filter (fun t => cross t.1 t.2.1 t.2.2 > 0)).length = 1548 ∧
-  (triples.filter (fun t => cross t.1 t.2.1 t.2.2 > 0 && interiorCount t.1 t.2.1 t.2.2 > 0)).length = 516
-    := by decide
-
--- ── 3 · Bézout's identity — 6 impressions across three phrasings. Both halves of the statement are decided,
---        because only together do they say that gcd is the LEAST positive combination rather than merely
---        SOME combination. Attainment: for every pair of a, b up to 30 there are coefficients under 31 with
---        a·x = b·y + gcd(a,b). Minimality: for every a, b, x, y up to 20, whenever a·x ≥ b·y the difference
---        is a multiple of gcd(a,b) — so nothing smaller and positive is ever reachable. The subtraction is
---        guarded by the inequality rather than performed, since ℕ subtraction truncates and a truncated 0
---        would satisfy the divisibility test for the wrong reason. The named instance is the textbook one:
---        gcd(240, 46) = 2 attained as 46·47 − 240·9. ──
-theorem bezouts_identity_is_attained_and_no_smaller_combination_exists :
-  (List.range' 1 30).all (fun a => (List.range' 1 30).all (fun b =>
-    (List.range 31).any (fun x => (List.range 31).any (fun y =>
-      a * x == b * y + Families.gcd' a b)))) ∧
-  (List.range' 1 20).all (fun a => (List.range' 1 20).all (fun b =>
-    (List.range 21).all (fun x => (List.range 21).all (fun y =>
-      a * x < b * y || (a * x - b * y) % Families.gcd' a b == 0)))) ∧
-  Families.gcd' 240 46 = 2 ∧ 46 * 47 = 240 * 9 + 2 := by decide
-
--- ── 4 · There are 576 Latin squares of order 4 — 6 impressions across four phrasings. Counted, not quoted:
---        every permutation of {0,1,2,3} is generated, and rows are added one at a time subject to the column
---        constraint, so the 576 is the size of an enumerated set. The orders 1, 2 and 3 are counted by the
---        same function in the same theorem, which is what rules out a counter that happens to return 576 —
---        it must also return 1, 2 and 12. The last clause separates the true count from the naive guess that
---        the rows are independent, which would give (4!)³ = 13824 for the last three rows. ──
-def tuples : Nat → Nat → List (List Nat)
-  | 0, _ => [[]]
-  | Nat.succ k, n => (tuples k n).flatMap (fun t => (List.range n).map (fun v => v :: t))
-def permsOf (n : Nat) : List (List Nat) := (tuples n n).filter (fun r => r.eraseDups.length == n)
-def discord (n : Nat) (r s : List Nat) : Bool := (List.range n).all (fun j => ¬ (r.getD j 0 == s.getD j 0))
--- fuel is the number of rows still to place, so the recursion is structural: no well-founded measure, and
--- the permutation list is threaded through rather than rebuilt at every node.
-def countRows : Nat → Nat → List (List Nat) → List (List Nat) → Nat
-  | 0, _, _, _ => 1
-  | Nat.succ k, n, ps, sofar =>
-    ((ps.filter (fun r => sofar.all (fun p => discord n r p))).map
-      (fun r => countRows k n ps (r :: sofar))).foldl (· + ·) 0
-def latinSquares (n : Nat) : Nat := countRows n n (permsOf n) []
-
-theorem the_latin_squares_of_order_four_number_five_hundred_and_seventy_six :
-  latinSquares 4 = 576 ∧ latinSquares 3 = 12 ∧ latinSquares 2 = 2 ∧ latinSquares 1 = 1 ∧
-  ¬ (latinSquares 4 = 24 * 24 * 24) := by decide
-
--- ── 5 · The closed form for the sum of fifth powers — 5 impressions across two phrasings, both of which
---        quote it as n²(n+1)²(2n²+2n−1)/12. The division is cleared rather than performed, so the statement
---        is 12·Σk⁵ = n²(n+1)²(2n²+2n−1) and no rounding can hide inside it; that the twelfth is exact is
---        exactly what the equation then says. The negative clause rules out the natural wrong guess by
---        analogy with Nicomachus — Σk⁵ is NOT T_n³ for any n from 2 to 20, though it is at n = 1. ──
-theorem the_sum_of_fifth_powers_has_the_closed_form_asked_for :
-  (List.range' 1 20).all (fun n => 12 * sumPow 5 n == n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1)) ∧
-  (List.range' 2 19).all (fun n => ¬ (sumPow 5 n == tri n * tri n * tri n)) ∧
-  sumPow 5 1 = 1 ∧ sumPow 5 2 = 33 ∧ sumPow 5 4 = 1300 := by decide
-
--- ── 6 · The Chinese remainder theorem — 5 impressions across five phrasings, including Sunzi's by name.
---        Stated as an IFF over every pair of moduli from 1 to 9, which is what makes the coprimality
---        hypothesis load-bearing instead of decorative: the pair map x ↦ (x mod m, x mod n) covers every
---        residue pair below m·n EXACTLY when gcd(m,n) = 1, and demonstrably fails to cover when it does not.
---        The second clause is Sunzi's own problem, and it is stated as a uniqueness claim — the residue
---        conditions 2 mod 3, 3 mod 5, 2 mod 7 have exactly one solution below 105, and it is 23. ──
-def crtCoversAllPairs (m n : Nat) : Bool :=
-  (List.range m).all (fun a => (List.range n).all (fun b =>
-    (List.range (m * n)).any (fun x => x % m == a && x % n == b)))
-
-theorem the_chinese_remainder_theorem_holds_exactly_when_the_moduli_are_coprime :
-  (List.range' 1 9).all (fun m => (List.range' 1 9).all (fun n =>
-    crtCoversAllPairs m n == (Families.gcd' m n == 1))) ∧
-  (List.range 105).filter (fun x => x % 3 == 2 && x % 5 == 3 && x % 7 == 2) = [23] := by decide
-
--- ── 7 · Catalan's conjecture, Mihăilescu's theorem — 4 impressions across three phrasings. 8 and 9 are the
---        only consecutive perfect powers. The general statement is Mihăilescu's and is not decidable; what is
---        decided here is the exhaustive range: below 2000 there are 55 distinct perfect powers, and exactly
---        one of them is followed immediately by another. Both numbers matter — the 55 is stated so that the
---        uniqueness cannot be explained away as a range too sparse to contain a second pair. ──
-def perfectPowersUpTo (bound : Nat) : List Nat :=
-  ((List.range' 2 43).flatMap (fun b => (List.range' 2 10).map (fun e => b ^ e))).filter
-    (fun v => v ≤ bound) |>.eraseDups
-def pp2000 : List Nat := perfectPowersUpTo 2000
-
-theorem eight_and_nine_are_the_only_consecutive_perfect_powers_below_two_thousand :
-  (List.range' 1 1999).filter (fun n => pp2000.contains n && pp2000.contains (n + 1)) = [8] ∧
-  pp2000.length = 55 ∧ pp2000.contains 8 = true ∧ pp2000.contains 9 = true := by decide
-
--- ── 8 · 220 and 284 are amicable, and they are the smallest such pair — 4 impressions across four phrasings
---        ("220 and 284", "220 284", "divisors of 284", "smallest amicable numbers"). The aliquot sum is
---        computed from the proper divisors directly. The minimality clause is the exhaustive half: for every
---        a from 2 to 219 it is NOT the case that s(s(a)) = a with s(a) ≠ a, so no amicable pair has a member
---        below 220. The s(a) ≠ a guard is what separates amicable pairs from perfect numbers, and the last
---        clause names the two perfect numbers in that range so the guard is visibly doing something. ──
-def aliquot (n : Nat) : Nat := ((List.range' 1 (n - 1)).filter (fun d => n % d == 0)).foldl (· + ·) 0
-
-theorem two_twenty_and_two_eighty_four_are_the_smallest_amicable_pair :
-  aliquot 220 = 284 ∧ aliquot 284 = 220 ∧
-  (List.range' 2 218).all (fun a => ¬ (aliquot (aliquot a) == a && ¬ (aliquot a == a))) ∧
-  (List.range' 2 218).filter (fun a => aliquot a == a) = [6, 28] := by decide
-
-
--- ── the capped rows above, proved for every value — no bound ─────────────────────────────────────────────────
--- sumPow is Families.powSum written as a single fold, so the Faulhaber laws proved there carry
--- nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number (n ≤ 40) and
--- the_sum_of_fifth_powers_has_the_closed_form_asked_for (n ≤ 20) to every n.
-theorem the_two_power_sums_are_one_sum : ∀ p n : Nat, sumPow p n = powSum p n := by
-  intro p n
-  unfold sumPow powSum
-  rw [List.foldl_map]
-
-theorem nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n :
-    ∀ n : Nat, sumPow 3 n = tri n * tri n := by
-  intro n
-  have c := the_cubes_sum_to_their_closed_form_for_every_n n
-  rw [← the_two_power_sums_are_one_sum] at c
-  have ev : n * (n + 1) % 2 = 0 := by
-    rcases Nat.mod_two_eq_zero_or_one n with e | e <;> simp [Nat.mul_mod, Nat.add_mod, e]
-  have hd : n * (n + 1) / 2 * 2 = n * (n + 1) := Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero ev)
-  unfold tri
-  generalize n * (n + 1) / 2 = t at hd ⊢
-  generalize sumPow 3 n = s at c ⊢
-  have q : 4 * s = 4 * (t * t) := by
-    have hsq : (t * 2) * (t * 2) = (n * (n + 1)) * (n * (n + 1)) := by rw [hd]
-    clear hd ev
-    try simp only [Nat.mul_add, Nat.add_mul, Nat.pow_succ, Nat.pow_zero, Nat.one_mul, Nat.mul_one, Nat.reduceMul, Nat.reduceAdd] at *
-    try simp only [Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.reduceMul] at *
-    try simp only [Nat.mul_comm _ (OfNat.ofNat _), Nat.mul_left_comm _ (OfNat.ofNat _), Nat.reduceMul] at *
-    all_goals omega
-  exact Nat.eq_of_mul_eq_mul_left (by decide) q
-
-theorem the_sum_of_fifth_powers_has_the_closed_form_for_every_n :
-    ∀ n : Nat, 12 * sumPow 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) := by
-  intro n
-  rw [the_two_power_sums_are_one_sum]
-  exact the_fifth_powers_sum_to_their_closed_form_for_every_n n
-
-end Demand2

package/src/proof/demand3.lean

@@ -1,183 +0,0 @@
-import Demand
-import Sequences
-set_option maxRecDepth 8000000
-set_option maxHeartbeats 4000000
--- title: The named theorems people ask for
--- wing: the floor
--- prior_art: named
--- prior_art_domain: elementary number theory, named results
--- prior_art_note: Legendre’s three-square theorem — Adrien-Marie Legendre, 1797; Carmichael numbers — Robert Carmichael, 1910; amicable pairs — known to antiquity
---
--- The third and last tier the search data supports. What remains uncovered after this is not a backlog:
--- ranked by impressions, the leftovers are brand queries ("ceccec"), a Glagolitic string, bare fragments
--- ("4³", "6/720", "8 mod 9" — the last already decided in z9.lean), and the real-analysis cluster that was
--- refused in demand2.lean and stays refused. The demand map is close to exhausted of things a kernel can
--- settle, which is a better place to stop than an arbitrary count would have been.
---
--- Two of these were named by the previous pass as the reasonable next candidates and are here: Havel–Hakimi
--- and Lagrange's four-square theorem. Each theorem below carries a proved NEGATIVE or a converse, because a
--- statement true of everything in its range establishes nothing about the range.
---
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · No axioms, no Mathlib, no sorry.
-
-namespace Demand3
-
-open Demand Sequences
-
--- ── 1 · WILSON'S THEOREM, and its converse, which is the half that makes it a test. (p−1)! ≡ −1 mod p for
---        every prime, written as ≡ p−1 since Nat has no negatives; and for every composite above four,
---        (n−1)! ≡ 0. The two together are a primality CRITERION rather than a property of primes. ──
-theorem wilsons_theorem_and_its_converse :
-  ((List.range' 2 18).all (fun p => ¬ isPrime p || Sequences.fact (p - 1) % p == p - 1)) ∧
-  ((List.range' 5 15).all (fun n => isPrime n || Sequences.fact (n - 1) % n == 0)) := by decide
-
--- ── 2 · LAGRANGE'S FOUR-SQUARE THEOREM over the range the kernel can exhaust: every natural number is a sum
---        of four squares. The negative is what gives it content — THREE squares do not suffice, and 7 is the
---        first witness, which is exactly the excluded form Legendre's theorem describes in demand.lean. ──
-def isSumOfFour (n : Nat) : Bool :=
-  (List.range 9).any (fun a => (List.range 9).any (fun b => (List.range 9).any (fun c =>
-    (List.range 9).any (fun d => a*a + b*b + c*c + d*d == n))))
-def isSumOfThree (n : Nat) : Bool :=
-  (List.range 9).any (fun a => (List.range 9).any (fun b => (List.range 9).any (fun c =>
-    a*a + b*b + c*c == n)))
-
-theorem every_number_is_a_sum_of_four_squares :
-  (List.range 60).all isSumOfFour ∧ isSumOfThree 7 = false ∧ isSumOfFour 7 = true := by decide
-
--- ── 3 · THE CANTOR PAIRING FUNCTION is a bijection ℕ² → ℕ. Injectivity is checked over an 8×8 block by
---        counting distinct images, and surjectivity onto an initial segment by checking that the block's
---        images cover 0..35 exactly — a pairing that is merely injective would leave holes. ──
-def cantor (a b : Nat) : Nat := (a + b) * (a + b + 1) / 2 + b
-def block : List Nat := (List.range 8).flatMap (fun a => (List.range 8).map (fun b => cantor a b))
-
-theorem the_cantor_pairing_is_injective_and_covers_an_initial_segment :
-  block.eraseDups.length = 64 ∧ ((List.range 36).all (fun n => block.contains n)) := by decide
-
--- ── 4 · REPUNIT DIVISIBILITY: 3 divides R_n exactly when 3 divides n, and 7 divides R_n exactly when 6
---        divides n. Both stated as iff over the range, so the pattern is decided in both directions rather
---        than sampled where it happens to hold. ──
-def repunit : Nat → Nat
-  | 0 => 0
-  | Nat.succ n => 10 * repunit n + 1
-
-theorem repunit_divisibility_by_three_and_seven :
-  ((List.range' 1 18).all (fun n => (repunit n % 3 == 0) == (n % 3 == 0))) ∧
-  ((List.range' 1 18).all (fun n => (repunit n % 7 == 0) == (n % 6 == 0))) := by decide
-
--- ── 5 · THE EULER CHARACTERISTIC of a closed orientable surface of genus g is 2 − 2g. Written 2 + 2·0 − 2g
---        would truncate in ℕ, so the identity is stated as χ + 2g = 2 with χ carried as its own value —
---        the same ℕ-subtraction trap that made an earlier draft "prove" 4 = 2. ──
-def chi (g : Nat) : Int := 2 - 2 * (g : Int)
-
-theorem the_euler_characteristic_of_a_genus_g_surface :
-  ((List.range 12).all (fun g => chi g + 2 * (g : Int) == 2)) ∧ chi 0 = 2 ∧ chi 1 = 0 ∧ chi 2 = -2 := by decide
-
--- ── 6 · A NUMBER HAS AN ODD NUMBER OF DIVISORS EXACTLY WHEN IT IS A PERFECT SQUARE — the divisors pair off
---        as d with n/d, and only a square has a divisor paired with itself. Decided as an iff to 120. ──
-def isSquare (n : Nat) : Bool := (List.range 12).any (fun k => k * k == n)
-
-theorem odd_divisor_count_iff_perfect_square :
-  (List.range' 1 120).all (fun n => ((divisors n).length % 2 == 1) == isSquare n) := by decide
-
--- ── 7 · HAVEL–HAKIMI, at the sizes the kernel can hold. A degree sequence is graphical exactly when the
---        reduction — remove the largest degree d, subtract one from the next d entries, re-sort — reaches
---        all zeros. The sort is a structural insertion sort: Nat's own mergeSort is well-founded and would
---        cost this file its axiom-free status. Stated with both a graphical sequence and a non-graphical one,
---        since a test that only ever says yes is not a test. ──
-def ins (x : Nat) : List Nat → List Nat
-  | [] => [x]
-  | y :: ys => if x ≥ y then x :: y :: ys else y :: ins x ys
-def sortDesc : List Nat → List Nat
-  | [] => []
-  | x :: xs => ins x (sortDesc xs)
--- FEASIBILITY IS CHECKED BEFORE SUBTRACTING, and that is the whole correctness of this definition in ℕ.
--- The reduction subtracts one from the next d entries; if any of them is already 0 the real algorithm goes
--- negative and reports NOT graphical, but ℕ truncates 0 − 1 to 0, so the subtraction silently succeeds and
--- every sequence comes out graphical. [3,3,1,1] is the witness: it is not graphical, and the truncating
--- version proved it was. The kernel refuted the theorem, in the file where I had just written a comment
--- warning about this exact trap two theorems earlier.
-def feasible (d : Nat) (rest : List Nat) : Bool :=
-  rest.length ≥ d && (rest.take d).all (fun x => x ≥ 1)
-def step : List Nat → List Nat
-  | [] => []
-  | d :: rest => sortDesc ((rest.take d).map (fun x => x - 1) ++ rest.drop d)
-def hh : Nat → List Nat → Bool
-  | 0, l => l.all (fun x => x == 0)
-  | Nat.succ f, l =>
-      let s := sortDesc l
-      if s.all (fun x => x == 0) then true
-      else match s with
-        | [] => true
-        | d :: rest => if feasible d rest then hh f (step s) else false
-
-theorem havel_hakimi_decides_graphical_sequences :
-  hh 12 [3, 3, 3, 3] = true ∧ hh 12 [2, 2, 2] = true ∧
-  hh 12 [3, 3, 1, 1] = false ∧ hh 12 [4, 1, 1, 1, 1] = true ∧ hh 12 [5, 1, 1, 1, 1] = false := by decide
-
-
--- ── the capped rows above, proved for every value by induction — no bound ────────────────────────────────────
--- the_euler_characteristic_of_a_genus_g_surface checked g < 12; this proves χ(g) + 2g = 2 for every g.
-theorem the_euler_characteristic_of_a_genus_g_surface_for_every_g :
-    ∀ g : Nat, chi g + 2 * (g : Int) = 2 := by
-  intro g
-  unfold chi
-  omega
-
-theorem a_repunit_has_the_residue_of_its_length_mod_three : ∀ n : Nat, repunit n % 3 = n % 3 := by
-  intro n
-  induction n with
-  | zero => rfl
-  | succ n ih =>
-    show (10 * repunit n + 1) % 3 = (n + 1) % 3
-    rw [Nat.add_mod, Nat.mul_mod, ih]
-    have h : n % 3 = 0 ∨ n % 3 = 1 ∨ n % 3 = 2 := by omega
-    rcases h with h | h | h <;> simp [h] <;> omega
-
--- repunit_divisibility_by_three_and_seven checked n ≤ 18; these prove both halves for every n.
-theorem a_repunit_is_divisible_by_three_exactly_when_its_length_is_for_every_n :
-    ∀ n : Nat, (repunit n % 3 = 0) ↔ (n % 3 = 0) := by
-  intro n
-  rw [a_repunit_has_the_residue_of_its_length_mod_three]
-
-theorem repunit_of_a_sum : ∀ n k : Nat, repunit (n + k) = 10 ^ k * repunit n + repunit k := by
-  intro n k
-  induction k with
-  | zero => simp [repunit]
-  | succ k ih =>
-    show 10 * repunit (n + k) + 1 = 10 ^ (k + 1) * repunit n + (10 * repunit k + 1)
-    rw [ih, Nat.pow_succ, Nat.mul_add, ← Nat.mul_assoc, Nat.mul_comm 10 (10 ^ k)]
-    omega
-
-theorem repunits_repeat_mod_seven_every_six_digits : ∀ n : Nat, repunit (n + 6) % 7 = repunit n % 7 := by
-  intro n
-  rw [repunit_of_a_sum, Nat.add_mod, Nat.mul_mod]
-  have h1 : 10 ^ 6 % 7 = 1 := by decide
-  have h2 : repunit 6 % 7 = 0 := by decide
-  rw [h1, h2, Nat.one_mul, Nat.add_zero]
-  omega
-
-theorem a_repunit_has_the_residue_of_its_length_mod_six_mod_seven : ∀ n : Nat, repunit n % 7 = repunit (n % 6) % 7 := by
-  intro n
-  induction n using Nat.strongRecOn with
-  | _ n ih =>
-    if hn : n < 6 then rw [Nat.mod_eq_of_lt hn]
-    else
-      have e : n = (n - 6) + 6 := by omega
-      rw [e, repunits_repeat_mod_seven_every_six_digits, ih (n - 6) (by omega), Nat.add_mod_right]
-
-theorem a_repunit_is_divisible_by_seven_exactly_when_six_divides_its_length_for_every_n :
-    ∀ n : Nat, (repunit n % 7 = 0) ↔ (n % 6 = 0) := by
-  intro n
-  rw [a_repunit_has_the_residue_of_its_length_mod_six_mod_seven]
-  have h : n % 6 < 6 := Nat.mod_lt _ (by decide)
-  generalize n % 6 = j at h ⊢
-  revert j
-  decide
-
-
--- ── the fair-exchange unit, tied to the law above ───────────────────────────────────────────────────────────
--- The deposit's fare is two coins, 110 − 108 = 2, written until now only in prose (split.lean's comments). χ is
--- 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
-
-end Demand3