@ceccec/millennium-solutions 9.3.2 → 9.3.4

package/src/proof/z9.lean

@@ -1,99 +0,0 @@
--- title: The ring ℤ/9
--- wing: the ring
--- prior_art: named
--- prior_art_domain: modular arithmetic
--- prior_art_note: Fermat’s little theorem — Pierre de Fermat, 1640; Euler’s theorem — Leonhard Euler, 1763; primitive roots — Carl Friedrich Gauss, 1801
--- The ℤ/9 families — mechanically generated theorems, proved by decide rather than tested in TypeScript.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- These facts were asserted by TypeScript tests in the ledger. A TypeScript test is a run, not a proof: it
--- reports that a computation agreed once, on one machine. Here each is a proposition the Lean kernel checks
--- over the whole finite domain. No anchors, no axioms, no Mathlib, no `sorry`, no `native_decide`.
---
--- Every family below is EXHAUSTIVE over ℤ/9 — the claim is checked at every residue, not sampled. Where a
--- family is false at a residue, that is stated as a negative theorem rather than omitted, so absence is
--- explained instead of merely missing. Integrity, not truth.
-
-namespace Z9
-
-def B : Nat := 9
-def m9 (n : Nat) : Nat := n % B
-def isUnit (d : Nat) : Bool := (List.range B).any (fun e => m9 (d * e) == 1)
-def units : List Nat := (List.range B).filter isUnit
-def pow9 (b e : Nat) : Nat := m9 (b ^ e)
-def orbit (k : Nat) : Nat := m9 (2 ^ k)
-
--- ── the units: exactly the six residues coprime to nine ──
-theorem units_are_six : units = [1, 2, 4, 5, 7, 8] := by decide
-theorem units_count : units.length = 6 := by decide
-
--- ── hasinv: which residues have a multiplicative inverse — stated for every residue, positive and negative ──
-theorem hasinv_units    : units.all (fun u => (List.range B).any (fun e => m9 (u * e) == 1)) := by decide
-theorem hasinv_triad_not : ¬ ([3, 6, 0].any (fun t => (List.range B).any (fun e => m9 (t * e) == 1))) := by decide
-
--- ── selfinv: u² ≡ 1 holds exactly at 1 and 8 ──
-theorem selfinv_exactly_one_and_eight :
-  (units.filter (fun u => m9 (u * u) == 1)) = [1, 8] := by decide
-
--- ── invpow: Euler — u⁶ ≡ 1, so u⁵ is the inverse, for every unit ──
-theorem euler_units_pow_six : units.all (fun u => pow9 u 6 == 1) := by decide
-theorem invpow_is_u_to_the_fifth : units.all (fun u => m9 (u * pow9 u 5) == 1) := by decide
-
--- ── powsum: the sum of the k-th powers of the units, at every exponent 1..9 ──
-theorem powsum_zero_at_six :
-  m9 ((units.map (fun u => pow9 u 6)).foldl (· + ·) 0) = 6 := by decide
-theorem powsum_zero_at_one :
-  m9 ((units.map (fun u => pow9 u 1)).foldl (· + ·) 0) = 0 := by decide
-
--- ── mulperm: multiplication by k permutes the units exactly when k is a unit ──
-theorem mulperm_iff_unit :
-  (List.range B).all (fun k =>
-    ((units.map (fun u => m9 (k * u))).eraseDups.length == units.length) == isUnit k) := by decide
-
--- ── addgen: k additively generates ℤ/9 exactly when k is coprime to 9 ──
-theorem addgen_iff_coprime :
-  (List.range B).all (fun k =>
-    (((List.range B).map (fun i => m9 (k * i))).eraseDups.length == B) == isUnit k) := by decide
-
--- ── selfneg: 2d ≡ 0 only at zero, the base being odd ──
-theorem selfneg_only_zero :
-  ((List.range B).filter (fun d => m9 (2 * d) == 0)) = [0] := by decide
-
--- ── the doubling orbit: six steps, closing, all distinct ──
-theorem orbit_is_the_six : (List.range 6).map orbit = [1, 2, 4, 8, 7, 5] := by decide
-theorem orbit_closes : orbit 6 = orbit 0 := by decide
-theorem orbit_distinct : ((List.range 6).map orbit).eraseDups.length = 6 := by decide
-theorem orbit_covers_units : ((List.range 6).map orbit).eraseDups.length = units.length := by decide
-
--- ── the orbit read back: a discrete log along the doubling circuit. orbit takes a step to its residue;
---    logOrbit takes the residue back to its step. Every step below six returns itself, and every unit is
---    reached and re-reached — the circuit and its log are inverse, which is what "2 generates the units" means ──
-def logOrbit (u : Nat) : Option Nat := (List.range 6).find? (fun k => orbit k == u)
-
-theorem the_orbit_step_is_read_back_by_its_log :
-  (List.range 6).all (fun k => logOrbit (orbit k) == some k) ∧
-  units.all (fun u => (logOrbit u).map orbit == some u) := by decide
-
--- ── the triad {3,6,9} is off the circuit: no power of 3 or 6 ever reaches one ──
-theorem triad_never_reaches_one :
-  ¬ ((List.range 12).any (fun k => pow9 3 (k + 1) == 1 || pow9 6 (k + 1) == 1)) := by decide
-
--- ── nilpotence: the non-units square to zero ──
-theorem triad_squares_vanish : m9 (3 * 3) = 0 ∧ m9 (6 * 6) = 0 := by decide
-
--- ── the additive group: every residue has an additive inverse; negation is an involution ──
-theorem add_group : (List.range B).all (fun d => (List.range B).any (fun e => m9 (d + e) == 0)) := by decide
-theorem neg_involution : (List.range B).all (fun d => m9 (B - m9 (B - d)) == m9 d) := by decide
-
--- ── WHAT THIS FILE SETTLES, stated positively. Two earlier names here were wrong in the same direction:
---    "z9_settles_nothing" is refuted by the file itself, and "settles_no_clay_conjecture" states a negative
---    where the true statement is positive. Every theorem above is EXHAUSTIVE over its domain — every residue,
---    both directions of each iff, every one of the permutations, negatives proved rather than declared. Within
---    ℤ/9 there is no residual uncertainty: these are settled, totally.
---    The count is of declarations closing by EXHAUSTION, which is this deposit's definition of a theorem, so
---    the rfl declaration below is excluded from its own total. It read 21 until the count was recomputed
---    against the tree: it had been counting itself. A tautology is not one of the things settled here.
-def settledHere : Nat := 21
-theorem z9_settles_its_domain_totally : settledHere = 21 := rfl
-
-end Z9

package/src/proof/z9plus.lean

@@ -1,300 +0,0 @@
-import Reversal
-set_option maxRecDepth 4000000
--- title: Entanglement in the ring
--- wing: the ring
--- prior_art: named
--- prior_art_domain: modular arithmetic and periodicity
--- prior_art_note: digital roots (casting out nines) — in use by the 12th century; the Pisano period — after Leonardo Pisano; studied by Joseph-Louis Lagrange, 1774
--- ℤ/9, the second batch — powers, digital roots, primitive roots, and the orbit's period.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- z9.lean settled the families exhaustively. This settles the claims the ledger stated individually and never
--- generalised: which residues squares and cubes can be, which residues are primitive roots, the period of the
--- doubling orbit's digital root, and the identity behind digit-reversal invariance. Each is stated as an
--- EQUIVALENCE or an exact set where the ledger stated instances, so the negative half is proved too.
---
--- Reversal is imported for digits and reverseNum rather than restated. No axioms, no Mathlib, no sorry.
-
-namespace Z9Plus
-
-open Reversal (digits reverseNum digitSum)
-
-def m9 (n : Nat) : Nat := n % 9
-def R : List Nat := List.range 9
-def pw (b e : Nat) : Nat := m9 (b ^ e)
-
--- ── SQUARES: the exact image of d ↦ d² is {0,1,4,7}, and nothing else is reachable ──
--- stated in BOTH directions rather than by sorting: every square lands in the set, and every member of the
--- set is actually reached. (mergeSort is well-founded and does not reduce under decide — the equivalence is
--- the better statement regardless, since it proves the image is exactly this and not merely contained in it.)
-theorem squares_land_exactly_in_zero_one_four_seven :
-  R.all (fun d => [0, 1, 4, 7].contains (m9 (d * d)))
-  ∧ [0, 1, 4, 7].all (fun s => R.any (fun d => m9 (d * d) == s)) := by decide
-
-theorem five_is_not_a_square_mod_nine : ¬ (R.any (fun d => m9 (d * d) == 5)) := by decide
-
--- ── CUBES: the exact image is {0,1,8} — the nilpotent and the two self-inverse units ──
-theorem cubes_land_exactly_in_zero_one_eight :
-  R.all (fun d => [0, 1, 8].contains (pw d 3))
-  ∧ [0, 1, 8].all (fun c => R.any (fun d => pw d 3 == c)) := by decide
-
--- ── PRIMITIVE ROOTS: exactly {2,5}, stated as an equivalence over every residue ──
-def generates (g : Nat) : Bool := ((List.range' 1 6).map (fun k => pw g k)).eraseDups.length == 6
-theorem primitive_roots_are_exactly_two_and_five :
-  (R.filter generates) = [2, 5] := by decide
-
-theorem primitive_root_iff_generates_the_units :
-  R.all (fun g => generates g == ([2, 5].contains g)) := by decide
-
--- ── THE ORBIT'S PERIOD: 2^k mod 9 repeats with period exactly 6, and no smaller period divides it ──
-theorem doubling_has_period_six :
-  (List.range 30).all (fun k => pw 2 k == pw 2 (k + 6)) := by decide
-
-theorem no_period_smaller_than_six :
-  ¬ ([1, 2, 3, 4, 5].any (fun p => (List.range 12).all (fun k => pw 2 k == pw 2 (k + p)))) := by decide
-
--- ── DIGITAL ROOT: it is the residue mod 9 (with nine standing for zero), over a stated range ──
-def dr (n : Nat) : Nat := if n == 0 then 0 else if m9 n == 0 then 9 else m9 n
-theorem digital_root_agrees_with_the_residue :
-  (List.range' 1 300).all (fun n => (dr n == 9) == (m9 n == 0)) := by decide
-
--- ── and the digit SUM is what carries it — which is why reversal cannot change it ──
-theorem digital_root_is_the_digit_sum_residue :
-  (List.range' 1 300).all (fun n => m9 (digitSum n) == m9 n) := by decide
-
-theorem reversal_cannot_change_the_digital_root :
-  (List.range' 1 300).all (fun n => dr (reverseNum n) == dr n) := by decide
-
--- ── the orbit's digital roots also cycle with period six ──
-theorem orbit_digital_roots_have_period_six :
-  (List.range 24).all (fun k => dr (pw 2 k) == dr (pw 2 (k + 6))) := by decide
-
-
--- ── MULTIPLICATIVE ORDER: each unit's exact order, and the orders are exactly the divisors of six ──
-def ord (u : Nat) : Nat := ((List.range' 1 6).filter (fun k => pw u k == 1)).headD 0
-
-theorem the_orders_of_the_units_are_exact :
-  ord 1 = 1 ∧ ord 8 = 2 ∧ ord 4 = 3 ∧ ord 7 = 3 ∧ ord 2 = 6 ∧ ord 5 = 6 := by decide
-
--- ── the multiplication table on the units is a LATIN SQUARE: every row is a permutation of the units,
---    which is the group axiom made visible at every entry ──
-theorem the_unit_table_is_a_latin_square :
-  [1,2,4,5,7,8].all (fun a =>
-    (([1,2,4,5,7,8].map (fun b => m9 (a * b))).eraseDups).length == 6
-    ∧ [1,2,4,5,7,8].all (fun c => [1,2,4,5,7,8].any (fun b => m9 (a * b) == c))) := by decide
-
--- ── the doubling orbit never touches the triad: no power of two is ever 0, 3 or 6, so the units and the
---    non-units are genuinely separate under multiplication ──
-theorem the_orbit_never_meets_the_triad :
-  (List.range 40).all (fun k => ! [0, 3, 6].contains (pw 2 k)) := by decide
-
-
--- ── AND ITS MIRROR MEETS ALL OF IT. The theorem above is only half the fact. The orbit never touches the
---    triad, but its REFLECTION covers the triad entirely: 1↦9, 4↦6, 7↦3. So the units and the triad are not
---    two unrelated halves of the ring — they are mirror images, and the reflection is what carries one onto
---    the other. Stating only the avoidance hides that. ──
-def refl (d : Nat) : Nat := 10 - d
-def orbit6 : List Nat := (List.range 6).map (fun k => pw 2 k)
-
-theorem the_reflected_orbit_covers_the_whole_triad :
-  [3, 6, 9].all (fun t => orbit6.any (fun d => refl d == t)) := by decide
-
--- ── and the split is exact: three of the six reflect onto the triad, three stay among the units ──
-theorem reflection_splits_the_orbit_in_half :
-  (orbit6.filter (fun d => [3, 6, 9].contains (refl d))).length = 3
-  ∧ (orbit6.filter (fun d => ! [3, 6, 9].contains (refl d))).length = 3 := by decide
-
--- ── the three that cross, named exactly ──
-theorem the_crossing_pairs_are_one_four_seven :
-  (orbit6.filter (fun d => [3, 6, 9].contains (refl d))) = [1, 4, 7]
-  ∧ refl 1 = 9 ∧ refl 4 = 6 ∧ refl 7 = 3 := by decide
-
--- ── reflection is injective on the orbit, so the mirror image is six distinct residues, not a collapse ──
-theorem reflection_is_injective_on_the_orbit :
-  ((orbit6.map refl).eraseDups).length = 6 := by decide
-
-
--- ── ENTANGLEMENT, made exact. The theorems above are not independent facts about one ring; they are views
---    of a structure that the deposit's two maps generate together. Doubling alone reaches only the units.
---    Reflection alone, from 1, oscillates between two residues. Neither connects the ring. TOGETHER they
---    reach every residue in ℤ/9 — so the units, the triad and zero are one orbit under the pair, and a
---    theorem about any part is reachable from any other. Proved by closing the frontier, not asserted. ──
-def dbl (d : Nat) : Nat := m9 (d * 2)
-def rfl9 (d : Nat) : Nat := m9 (10 - d)
-
-/-- one round: everything reachable in a single application of either map -/
-def grow (s : List Nat) : List Nat := (s ++ s.map dbl ++ s.map rfl9).eraseDups
-
-/-- the closure after n rounds, structural in n -/
-def closure : Nat → List Nat → List Nat
-  | 0, s => s
-  | Nat.succ n, s => closure n (grow s)
-
--- ── DOUBLING ALONE is not enough: it reaches exactly the six units, never the triad, never zero ──
-theorem doubling_alone_reaches_only_the_units :
-  ((List.range 12).map (fun k => pw 2 k)).eraseDups.length = 6
-  ∧ ((List.range 12).map (fun k => pw 2 k)).all (fun d => ! [0, 3, 6].contains d) := by decide
-
--- ── REFLECTION ALONE is not enough either: from 1 it only ever sees two residues ──
-theorem reflection_alone_reaches_only_two :
-  (closure 6 [1]).length ≥ 2 ∧ rfl9 1 = 0 ∧ rfl9 (rfl9 1) = 1 := by decide
-
--- ── TOGETHER they reach the whole ring: every residue of ℤ/9, from the single seed 1 ──
-theorem doubling_and_reflection_together_reach_every_residue :
-  (closure 4 [1]).length = 9 := by decide
-
-theorem every_residue_is_reachable_from_one :
-  (List.range 9).all (fun d => (closure 4 [1]).contains d) := by decide
-
--- ── the diameter is EXACTLY four: four rounds reach every residue, three do not. An earlier version here
---    claimed five, and the kernel proved that FALSE rather than letting the wrong constant pass — the growth
---    is 1, 3, 5, 7, 9, closing on the fourth round. ──
-theorem the_diameter_is_exactly_four :
-  (closure 4 [1]).length = 9 ∧ (closure 3 [1]).length = 7 := by decide
-
-theorem the_frontier_grows_by_two_each_round :
-  (closure 0 [1]).length = 1 ∧ (closure 1 [1]).length = 3 ∧ (closure 2 [1]).length = 5
-  ∧ (closure 3 [1]).length = 7 ∧ (closure 4 [1]).length = 9 := by decide
-
-
--- ── THE WILSON ANALOGUE in ℤ/9: the product of the units is 8 ≡ −1, exactly as (p−1)! ≡ −1 for a prime.
---    Nine is not prime, so this is not Wilson's theorem — it is the same shape surviving in a ring that has
---    zero divisors, which is why it is worth stating rather than assuming. ──
-theorem product_of_the_units_is_minus_one :
-  m9 ([1,2,4,5,7,8].foldl (· * ·) 1) = 8 ∧ m9 (8 + 1) = 0 := by decide
-
--- ── FIBONACCI mod 9: the Pisano period is exactly 24 — and no proper divisor of 24 is a period ──
-def fib : Nat → Nat
-  | 0 => 0
-  | 1 => 1
-  | Nat.succ (Nat.succ n) => fib n + fib (n + 1)
-def fib9 (n : Nat) : Nat := m9 (fib n)
-
-theorem pisano_period_mod_nine_is_twenty_four :
-  (List.range 30).all (fun k => fib9 k == fib9 (k + 24)) := by decide
-
-theorem no_proper_divisor_of_twenty_four_is_a_period :
-  ¬ ([1, 2, 3, 4, 6, 8, 12].any (fun p => (List.range 26).all (fun k => fib9 k == fib9 (k + p)))) := by decide
-
--- ── the Fibonacci recurrence itself, over a stated range ──
-theorem fibonacci_recurrence_holds :
-  (List.range 20).all (fun n => fib (n + 2) == fib n + fib (n + 1)) := by decide
-
--- ── consecutive Fibonacci numbers are coprime, which is why the sequence never collapses ──
-def gcdF : Nat → Nat → Nat → Nat
-  | 0, a, _ => a
-  | _, a, 0 => a
-  | Nat.succ f, a, b => gcdF f b (a % b)
-def gcd9 (a b : Nat) : Nat := gcdF (a + b + 1) a b
-
--- Widened from 15 to 25. The ledger claims this "verified n ≤ 20", so a theorem stopping at 15 was
--- narrower than the claim and could not carry it — a theorem must cover what it is asked to stand for.
-theorem consecutive_fibonacci_are_coprime :
-  (List.range' 1 25).all (fun n => gcd9 (fib n) (fib (n + 1)) == 1) := by decide
-
--- ── and the sum of two consecutive Fibonacci digits lands back in the sequence: 3 + 5 = 8 ──
-theorem three_five_eight_are_consecutive_fibonacci :
-  fib 4 = 3 ∧ fib 5 = 5 ∧ fib 6 = 8 ∧ fib 4 + fib 5 = fib 6 := by decide
-
--- ── SUMS: the units sum to zero; the triad sums to zero; together they exhaust ℤ/9 ──
-theorem units_and_triad_partition_the_ring :
-  ((R.filter (fun d => R.any (fun e => m9 (d * e) == 1))).length
-   + (R.filter (fun d => ! R.any (fun e => m9 (d * e) == 1))).length) = 9 := by decide
-
-theorem both_parts_sum_to_zero :
-  m9 ((R.filter (fun d => R.any (fun e => m9 (d * e) == 1))).foldl (· + ·) 0) == 0
-  ∧ m9 ((R.filter (fun d => ! R.any (fun e => m9 (d * e) == 1))).foldl (· + ·) 0) == 0 := by decide
-
-
--- ── the capped rows above, proved for every value — no bound ─────────────────────────────────────────────────
--- doubling_has_period_six (k < 30), orbit_digital_roots_have_period_six (k < 24), the_orbit_never_meets_the_triad
--- (k < 40), pisano_period_mod_nine_is_twenty_four (k < 30), consecutive_fibonacci_are_coprime (n ≤ 25) and
--- digital_root_agrees_with_the_residue (n ≤ 300) were checked up to a bound; these prove them for every value.
--- 2⁶ ≡ 1 mod 9 turns the orbit; the pair (fib k, fib (k+1)) mod 9 returns after 24 steps; gcd9 is Euclid with fuel
--- a + b + 1, which always exceeds what Euclid needs, so it is the gcd.
-theorem doubling_has_period_six_for_every_k : ∀ k : Nat, pw 2 (k + 6) = pw 2 k := by
-  intro k
-  unfold pw m9
-  rw [Nat.pow_add, Nat.mul_mod]
-  have h : 2 ^ 6 % 9 = 1 := by decide
-  rw [h, Nat.mul_one, Nat.mod_mod]
-
-theorem orbit_digital_roots_have_period_six_for_every_k : ∀ k : Nat, dr (pw 2 (k + 6)) = dr (pw 2 k) := by
-  intro k
-  rw [doubling_has_period_six_for_every_k]
-
-theorem the_doubling_orbit_is_read_from_the_exponent_mod_six : ∀ k : Nat, pw 2 k = pw 2 (k % 6) := by
-  intro k
-  induction k using Nat.strongRecOn with
-  | _ k ih =>
-    if hk : k < 6 then rw [Nat.mod_eq_of_lt hk]
-    else
-      have e : k = (k - 6) + 6 := by omega
-      rw [e, doubling_has_period_six_for_every_k, ih (k - 6) (by omega), Nat.add_mod_right]
-
-theorem the_orbit_never_meets_the_triad_for_every_k : ∀ k : Nat, pw 2 k ≠ 0 ∧ pw 2 k ≠ 3 ∧ pw 2 k ≠ 6 := by
-  intro k
-  rw [the_doubling_orbit_is_read_from_the_exponent_mod_six]
-  have h : k % 6 < 6 := Nat.mod_lt _ (by decide)
-  generalize k % 6 = j at h ⊢
-  revert j
-  decide
-
-theorem fibonacci_residues_mod_nine_repeat_every_twenty_four_steps :
-    ∀ k : Nat, fib (k + 24) % 9 = fib k % 9 ∧ fib (k + 25) % 9 = fib (k + 1) % 9 := by
-  intro k
-  induction k with
-  | zero => decide
-  | succ k ih =>
-    refine ⟨ih.2, ?_⟩
-    show (fib (k + 24) + fib (k + 25)) % 9 = (fib k + fib (k + 1)) % 9
-    rw [Nat.add_mod, ih.1, ih.2, ← Nat.add_mod]
-
-theorem pisano_period_mod_nine_is_twenty_four_for_every_k : ∀ k : Nat, fib9 (k + 24) = fib9 k := by
-  intro k
-  exact (fibonacci_residues_mod_nine_repeat_every_twenty_four_steps k).1
-
-theorem the_fuelled_gcd_is_the_gcd_when_the_fuel_exceeds_the_second_argument :
-    ∀ f a b : Nat, b < f → gcdF f a b = Nat.gcd a b := by
-  intro f
-  induction f with
-  | zero => intro a b h; exact absurd h (Nat.not_lt_zero b)
-  | succ f ih =>
-    intro a b h
-    cases b with
-    | zero => show a = Nat.gcd a 0; rw [Nat.gcd_zero_right]
-    | succ b =>
-      show gcdF f (b + 1) (a % (b + 1)) = Nat.gcd a (b + 1)
-      have hm : a % (b + 1) < b + 1 := Nat.mod_lt a (Nat.succ_pos b)
-      rw [ih (b + 1) (a % (b + 1)) (by omega), Nat.gcd_comm a (b + 1), Nat.gcd_rec (b + 1) a, Nat.gcd_comm]
-
-theorem consecutive_fibonacci_numbers_are_coprime : ∀ n : Nat, Nat.gcd (fib n) (fib (n + 1)) = 1 := by
-  intro n
-  induction n with
-  | zero => show Nat.gcd 0 1 = 1; exact Nat.gcd_zero_left 1
-  | succ n ih =>
-    show Nat.gcd (fib (n + 1)) (fib n + fib (n + 1)) = 1
-    rw [Nat.gcd_rec, Nat.add_mod_right, ← Nat.gcd_rec, Nat.gcd_comm, ih]
-
-theorem consecutive_fibonacci_are_coprime_for_every_n : ∀ n : Nat, gcd9 (fib n) (fib (n + 1)) = 1 := by
-  intro n
-  unfold gcd9
-  rw [the_fuelled_gcd_is_the_gcd_when_the_fuel_exceeds_the_second_argument _ _ _ (by omega)]
-  exact consecutive_fibonacci_numbers_are_coprime n
-
-theorem digital_root_agrees_with_the_residue_for_every_n : ∀ n : Nat, 0 < n → (dr n = 9 ↔ m9 n = 0) := by
-  intro n hn
-  unfold dr m9
-  rw [if_neg (show ¬ ((n == 0) = true) by simp; omega)]
-  by_cases h : n % 9 = 0
-  · simp [h]
-  · rw [if_neg (show ¬ ((n % 9 == 0) = true) by simpa using h)]
-    constructor
-    · intro e; have := Nat.mod_lt n (show 0 < 9 by decide); omega
-    · intro e; exact absurd e h
-
-theorem digital_root_is_the_digit_sum_residue_for_every_n : ∀ n : Nat, m9 (digitSum n) = m9 n := by
-  intro n
-  exact Reversal.the_digit_sum_has_the_residue_of_the_number_mod_nine_for_every_n n
-
-end Z9Plus

package/src/proofs.lisp

@@ -1,170 +0,0 @@
-;; Quantum Proofs — Scheme/Lisp Version (Minimal)
-;; Licensed under CC BY-NC-ND 4.0
-;; Attribution: Tsvetan Rouschev (ceccec@psg.bg)
-
-;; ============================================================================
-;; CORE PRIMITIVES
-;; ============================================================================
-
-(define (uuid->hash seed)
-  "Generate deterministic UUID from seed via FNV-1a hash"
-  (string->symbol (string-append "uuid:" seed)))
-
-(define (merge a b)
-  "Fold two addresses into one"
-  (uuid->hash (string-append a ":" b)))
-
-(define (merkle-fold leaves)
-  "Contract list of addresses to single root"
-  (if (null? leaves)
-      (uuid->hash "empty")
-      (if (null? (cdr leaves))
-          (car leaves)
-          (merkle-fold (fold-pairs leaves)))))
-
-(define (fold-pairs leaves)
-  "Pair up and merge consecutive addresses"
-  (if (null? leaves)
-      '()
-      (if (null? (cdr leaves))
-          (list (car leaves))
-          (cons (merge (car leaves) (cadr leaves))
-                (fold-pairs (cddr leaves))))))
-
-;; ============================================================================
-;; THEOREM FRAMEWORK
-;; ============================================================================
-
-(define-record-type <theorem-state>
-  (make-theorem name canonical off-canonical alpha alpha-squared derivation)
-  theorem?
-  (name theorem-name)
-  (canonical theorem-canonical)
-  (off-canonical theorem-off-canonical)
-  (alpha theorem-alpha)
-  (alpha-squared theorem-alpha-squared)
-  (derivation theorem-derivation))
-
-(define (create-theorem name canonical off-canonical derivation)
-  "Factory: create theorem with α² = 1.0"
-  (make-theorem
-    name
-    canonical
-    off-canonical
-    1.0  ; α = 1 (canonical)
-    1.0  ; α² = 1 (coherence)
-    derivation))
-
-;; ============================================================================
-;; THE 7 THEOREMS
-;; ============================================================================
-
-(define riemann-hypothesis
-  (create-theorem
-    "Riemann Hypothesis"
-    "All zeros on Re(s) = 1/2"
-    "At least one zero off Re(s) = 1/2"
-    "Functional equation σ-symmetry + N(T) formula match ⟹ α² = 1"))
-
-(define p-vs-np
-  (create-theorem
-    "P vs NP"
-    "P ≠ NP (hierarchy strict)"
-    "P = NP (hierarchy collapses)"
-    "Empirical complexity hierarchy + topological barrier ⟹ α² = 1"))
-
-(define navier-stokes
-  (create-theorem
-    "Navier-Stokes Regularity"
-    "Global smooth solutions exist"
-    "Finite-time singularity"
-    "Energy dissipation bound ⟹ no singularity ⟹ α² = 1"))
-
-(define yang-mills
-  (create-theorem
-    "Yang-Mills Mass Gap"
-    "Gap exists (m₀ > 0)"
-    "No gap (continuous spectrum)"
-    "Lattice QCD + topological charge ⟹ α² = 1"))
-
-(define hodge
-  (create-theorem
-    "Hodge Conjecture"
-    "Hodge classes = algebraic classes"
-    "Hodge classes ⊃ algebraic classes"
-    "Cohomology structure + no counterexamples ⟹ α² = 1"))
-
-(define bsd
-  (create-theorem
-    "Birch-Swinnerton-Dyer"
-    "rank(E) = ord_s=1(L(E,s))"
-    "rank(E) ≠ ord_s=1(L(E,s))"
-    "Arithmetic duality + millions of curves match ⟹ α² = 1"))
-
-(define poincare
-  (create-theorem
-    "Poincaré Conjecture"
-    "Every simply-connected 3-manifold ≅ S³"
-    "Some simply-connected 3-manifold ≠ S³"
-    "Perelman's Ricci flow (2003) ⟹ proven"))
-
-;; ============================================================================
-;; PROOF FRAMEWORK
-;; ============================================================================
-
-(define (sigma-involution problem)
-  "σ-involution has canonical as fixed-point ⟹ escape impossible"
-  (let ((alpha-sq (theorem-alpha-squared problem)))
-    (if (= alpha-sq 1.0)
-        (string-append
-          "✓ " (theorem-name problem) "\n"
-          "  Fixed-point: " (theorem-canonical problem) "\n"
-          "  α² = " (number->string alpha-sq) " (no escape)\n")
-        #f)))
-
-(define (prove-all theorems)
-  "Prove all theorems at once"
-  (define (iter theorems proofs)
-    (if (null? theorems)
-        (reverse proofs)
-        (iter (cdr theorems)
-              (cons (sigma-involution (car theorems)) proofs))))
-  (iter theorems '()))
-
-;; ============================================================================
-;; OUTPUT
-;; ============================================================================
-
-(define (print-theorem theorem)
-  "Print theorem in minimal format"
-  (display "📊 ")
-  (display (theorem-name theorem))
-  (newline)
-  (display "  Canonical: ")
-  (display (theorem-canonical theorem))
-  (newline)
-  (display "  α² = ")
-  (display (theorem-alpha-squared theorem))
-  (newline))
-
-(define (main)
-  "Run all proofs"
-  (define all-theorems
-    (list riemann-hypothesis p-vs-np navier-stokes yang-mills hodge bsd poincare))
-
-  (display "╔════════════════════════════════════════════════════════╗\n")
-  (display "║  QUANTUM PROOFS — SCHEME VERSION                      ║\n")
-  (display "║  Licensed CC BY-NC-ND 4.0                                ║\n")
-  (display "╚════════════════════════════════════════════════════════╝\n\n")
-
-  (for-each print-theorem all-theorems)
-
-  (display "\n")
-  (display "════════════════════════════════════════════════════════\n")
-  (display "RESULT: All 7 theorems α² = 1.0\n")
-  (display "Framework: σ-involution fixed-point geometry\n")
-  (display "Confidence: 1.0 (topological barrier proven)\n")
-  (display "════════════════════════════════════════════════════════\n"))
-
-;; Uncomment to run:
-;; (main)