@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/src/proof/sequences.lean

@@ -1,284 +0,0 @@
-import Fnv
-set_option maxRecDepth 4000000
-set_option maxHeartbeats 2000000
--- title: Sequences
--- wing: the ring
--- prior_art: named
--- prior_art_domain: integer sequences and identities
--- prior_art_note: Cassini’s identity — G. D. Cassini, 1680; Lucas sequences — Édouard Lucas, 1878; the Brahmagupta–Fibonacci identity — Brahmagupta, 628; Pascal’s triangle mod 2 — Blaise Pascal, 1654
--- Sequences and identities — Cassini, Lucas, Brahmagupta–Fibonacci, and Pascal mod two.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- The ledger held these as TypeScript tests. Each is a classical identity with a real proof; what is done
--- here is to DECIDE each over a stated finite range, which is what `decide` can honestly deliver — the range
--- is named in every theorem rather than implied, and no theorem claims the general case.
---
--- Cassini alternates in sign, which the naturals cannot express directly, so it is stated in the two forms it
--- takes: the product exceeds the square by one at even indices and falls short by one at odd ones. Stating it
--- as a single subtraction would truncate at zero and quietly hold for the wrong reason.
-
-namespace Sequences
-
-def fib : Nat → Nat
-  | 0 => 0
-  | 1 => 1
-  | Nat.succ (Nat.succ n) => fib n + fib (n + 1)
-
-def fact (n : Nat) : Nat := (List.range n).foldl (fun a k => a * (k + 1)) 1
-def choose (n k : Nat) : Nat := fact n / (fact k * fact (n - k))
-
-/-- bitwise AND, structural: Nat's own is well-founded and would drag propext into every theorem here -/
-def andF : Nat → Nat → Nat → Nat
-  | 0, _, _ => 0
-  | _, 0, _ => 0
-  | _, _, 0 => 0
-  | Nat.succ f, a, b => (if a % 2 == 1 && b % 2 == 1 then 1 else 0) + 2 * andF f (a / 2) (b / 2)
-def andN (a b : Nat) : Nat := andF 33 a b
-
--- ── CASSINI: F(n−1)·F(n+1) − F(n)² = ±1, alternating. Stated in both directions over 1..20. ──
-theorem cassini_at_even_indices :
-  (List.range' 1 20).all (fun n => n % 2 == 1 || fib (n - 1) * fib (n + 1) == fib n * fib n + 1) := by decide
-
-theorem cassini_at_odd_indices :
-  (List.range' 1 20).all (fun n => n % 2 == 0 || fib (n - 1) * fib (n + 1) + 1 == fib n * fib n) := by decide
-
--- ── and the deviation is never more than one, in either direction — the identity is tight ──
-theorem cassini_deviation_is_exactly_one :
-  (List.range' 1 20).all (fun n =>
-    (fib (n - 1) * fib (n + 1) == fib n * fib n + 1) || (fib (n - 1) * fib (n + 1) + 1 == fib n * fib n)) := by decide
-
--- ── LUCAS mod two: C(n,k) is odd exactly when k AND n = k — the Sierpiński rule behind Rule 90 ──
-theorem lucas_mod_two_is_the_and_rule :
-  (List.range 14).all (fun n => (List.range (n + 1)).all (fun k =>
-    (choose n k % 2 == 1) == (andN k n == k))) := by decide
-
--- ── NON-VACUITY: both cases actually occur in that range — odd and even entries are both present ──
-theorem pascal_has_both_parities :
-  ((List.range 14).flatMap (fun n => (List.range (n + 1)).map (fun k => choose n k % 2))).contains 1
-  ∧ ((List.range 14).flatMap (fun n => (List.range (n + 1)).map (fun k => choose n k % 2))).contains 0 := by decide
-
--- ── BRAHMAGUPTA–FIBONACCI: sums of two squares are closed under multiplication ──
-theorem sums_of_two_squares_are_closed :
-  (List.range 8).all (fun a => (List.range 8).all (fun b => (List.range 8).all (fun c => (List.range 8).all (fun d =>
-    (a*a + b*b) * (c*c + d*d) == (a*c - b*d) * (a*c - b*d) + (a*d + b*c) * (a*d + b*c)
-    || (a*c) < (b*d))))) := by decide
-
--- ── the Fibonacci triple three, five, eight — consecutive, and summing as the recurrence requires ──
-theorem three_five_eight_are_consecutive :
-  fib 4 = 3 ∧ fib 5 = 5 ∧ fib 6 = 8 ∧ fib 4 + fib 5 = fib 6 := by decide
-
--- ── the Pisano period binds Fibonacci to the ring: mod 9 it repeats every 24, four times the doubling six ──
-theorem pisano_twentyfour_is_four_sixes :
-  (List.range 30).all (fun k => fib k % 9 == fib (k + 24) % 9) ∧ 24 = 4 * 6 := by decide
-
--- ── THUE–MORSE, RECOMPUTED AS LEAN ─────────────────────────────────────────────────────────────────────
--- The ledger carried `thue_morse_doubling_recurrence` and WITHDREW it, with the reason recorded: "not
--- backed by a Lean proof. Its evidence is a TypeScript test, which reports that a computation agreed once
--- on one machine; the kernel checks a proposition over its whole domain. Its content has no stated
--- decidable form yet."
---
--- Withdrawn for want of a proof, not because it is false — and it HAS a decidable form. t(n) is the parity
--- of the 1-bits of n. Doubling shifts every bit one place and introduces no new one, so the popcount is
--- unchanged and t(2n) = t(n). 2n+1 sets exactly one further bit, so the parity flips: t(2n+1) = 1 − t(n).
--- Both are decided below over a stated finite domain, which is what the withdrawal said was missing, and
--- proved for every n at the end of this file.
--- The fuel is n + 1, which covers every bit of every n (n < 2^(n+1)); the earlier fuel of 12 counted only the
--- low twelve bits — a cap every statement here had to stay under.
-def popcount (n : Nat) : Nat := (List.range (n + 1)).foldl (fun a i => a + n / 2 ^ i % 2) 0
-def tm (n : Nat) : Nat := popcount n % 2
-
--- Domain: n < 200 — the decided instance of the law proved for every n at the end of this file. The popcount
--- no longer stops at twelve bits, so no statement here can hold for the wrong reason at any size.
-theorem thue_morse_doubling_recurrence :
-  (List.range 200).all (fun n => tm (2 * n) == tm n && tm (2 * n + 1) == 1 - tm n) := by decide
-
--- The two halves separately, so a reader can see which one a counterexample would break.
-theorem doubling_preserves_the_parity_of_the_bits :
-  (List.range 200).all (fun n => popcount (2 * n) == popcount n) := by decide
-
-theorem the_odd_step_sets_exactly_one_further_bit :
-  (List.range 200).all (fun n => popcount (2 * n + 1) == popcount n + 1) := by decide
-
--- And the domain is not vacuous: the sequence actually takes both values inside it, so `all` is not
--- passing over a set on which the property is trivially true.
-theorem the_sequence_takes_both_values :
-  ((List.range 200).filter (fun n => tm n == 0)).length = 100
-  ∧ ((List.range 200).filter (fun n => tm n == 1)).length = 100 := by decide
-
-
--- ── the capped rows above, proved for every value — no bound ─────────────────────────────────────────────────
--- cassini_at_even_indices, cassini_at_odd_indices and cassini_deviation_is_exactly_one were checked n ≤ 20; one law
--- carries all three: at every index the product of the neighbours is the square, plus or minus one.
-theorem cassinis_identity_for_every_m :
-    ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧
-      fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) := by
-  intro m
-  induction m with
-  | zero => decide
-  | succ m ih =>
-    have r3 : fib (2 * m + 3) = fib (2 * m + 1) + fib (2 * m + 2) := rfl
-    have r4 : fib (2 * m + 4) = fib (2 * m + 2) + fib (2 * m + 3) := rfl
-    have r5 : fib (2 * m + 5) = fib (2 * m + 3) + fib (2 * m + 4) := rfl
-    show fib (2 * m + 3) * fib (2 * m + 5) = fib (2 * m + 4) * fib (2 * m + 4) + 1 ∧
-      fib (2 * m + 2) * fib (2 * m + 4) + 1 = fib (2 * m + 3) * fib (2 * m + 3)
-    have h := ih.1
-    rw [r5, r4, r3]
-    rw [r3] at h
-    generalize fib (2 * m + 1) = a at h ⊢
-    generalize fib (2 * m + 2) = b at h ⊢
-    constructor
-    · 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
-    · 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
-
-
--- ── the popcount rows above, proved for every n — no bound ───────────────────────────────────────────────
--- thue_morse_doubling_recurrence, doubling_preserves_the_parity_of_the_bits and the_odd_step_sets_exactly_one_
--- further_bit were decided over n < 200; these prove them for every n. The bits of m are its low bit and then the
--- bits of m / 2; positions above the number add nothing; so doubling keeps the count and the odd step adds one.
-theorem a_bit_sum_over_one_more_position_adds_that_bit :
-    ∀ F m : Nat, (List.range (F + 1)).foldl (fun a i => a + m / 2 ^ i % 2) 0 =
-      (List.range F).foldl (fun a i => a + m / 2 ^ i % 2) 0 + m / 2 ^ F % 2 := by
-  intro F m
-  rw [List.range_succ, List.foldl_append]
-  rfl
-
-theorem halving_shifts_every_bit_down_by_one : ∀ m i : Nat, m / 2 ^ (i + 1) = m / 2 / 2 ^ i := by
-  intro m i
-  rw [Nat.div_div_eq_div_mul, Nat.pow_succ, Nat.mul_comm]
-
-theorem the_bits_of_a_number_are_its_low_bit_then_the_bits_of_its_half :
-    ∀ F m : Nat, (List.range (F + 1)).foldl (fun a i => a + m / 2 ^ i % 2) 0 =
-      m % 2 + (List.range F).foldl (fun a i => a + m / 2 / 2 ^ i % 2) 0 := by
-  intro F
-  induction F with
-  | zero => intro m; show 0 + m / 2 ^ 0 % 2 = m % 2 + 0; rw [Nat.pow_zero, Nat.div_one]; omega
-  | succ F ih =>
-    intro m
-    rw [a_bit_sum_over_one_more_position_adds_that_bit (F + 1) m, ih m,
-      a_bit_sum_over_one_more_position_adds_that_bit F (m / 2), halving_shifts_every_bit_down_by_one]
-    omega
-
-theorem bits_above_the_number_add_nothing :
-    ∀ k F n : Nat, n < 2 ^ F → (List.range (F + k)).foldl (fun a i => a + n / 2 ^ i % 2) 0 =
-      (List.range F).foldl (fun a i => a + n / 2 ^ i % 2) 0 := by
-  intro k
-  induction k with
-  | zero => intro F n _; rfl
-  | succ k ih =>
-    intro F n h
-    rw [← Nat.add_assoc, a_bit_sum_over_one_more_position_adds_that_bit, ih F n h]
-    have hp : 2 ^ F ≤ 2 ^ (F + k) := Nat.pow_le_pow_right (by decide) (Nat.le_add_right F k)
-    rw [Nat.div_eq_of_lt (by omega), Nat.zero_mod, Nat.add_zero]
-
-theorem a_number_is_below_two_to_its_own_power : ∀ n : Nat, n < 2 ^ n := by
-  intro n
-  induction n with
-  | zero => decide
-  | succ n ih =>
-    rw [Nat.pow_succ]
-    omega
-
-theorem a_number_is_below_two_to_its_own_successor : ∀ n : Nat, n < 2 ^ (n + 1) := by
-  intro n
-  have h := a_number_is_below_two_to_its_own_power n
-  rw [Nat.pow_succ]
-  omega
-
-theorem doubling_preserves_the_bit_count_for_every_n : ∀ n : Nat, popcount (2 * n) = popcount n := by
-  intro n
-  unfold popcount
-  rw [the_bits_of_a_number_are_its_low_bit_then_the_bits_of_its_half (2 * n) (2 * n),
-    show 2 * n / 2 = n by omega, show 2 * n % 2 = 0 by omega, Nat.zero_add]
-  cases n with
-  | zero => rfl
-  | succ m =>
-    have hlt : m + 1 < 2 ^ (m + 1 + 1) := a_number_is_below_two_to_its_own_successor (m + 1)
-    rw [show 2 * (m + 1) = m + 1 + 1 + m by omega, bits_above_the_number_add_nothing m (m + 1 + 1) (m + 1) hlt]
-
-theorem the_odd_step_sets_exactly_one_further_bit_for_every_n : ∀ n : Nat, popcount (2 * n + 1) = popcount n + 1 := by
-  intro n
-  unfold popcount
-  rw [the_bits_of_a_number_are_its_low_bit_then_the_bits_of_its_half (2 * n + 1) (2 * n + 1),
-    show (2 * n + 1) / 2 = n by omega, show (2 * n + 1) % 2 = 1 by omega]
-  have hlt : n < 2 ^ (n + 1) := a_number_is_below_two_to_its_own_successor n
-  rw [show 2 * n + 1 = n + 1 + n by omega, bits_above_the_number_add_nothing n (n + 1) n hlt]
-  omega
-
-theorem thue_morse_doubling_recurrence_for_every_n : ∀ n : Nat, tm (2 * n) = tm n ∧ tm (2 * n + 1) = 1 - tm n := by
-  intro n
-  unfold tm
-  rw [doubling_preserves_the_bit_count_for_every_n, the_odd_step_sets_exactly_one_further_bit_for_every_n]
-  exact ⟨rfl, by omega⟩
-
-
--- ── reflections, from the bits batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
--- REFLECTION of doubling_preserves_the_bit_count / the_odd_step_sets_exactly_one_further_bit:
--- halving removes exactly the low bit, for every n
-theorem halving_removes_exactly_the_low_bit_for_every_n : ∀ n : Nat, popcount n = n % 2 + popcount (n / 2) := by
-  intro n
-  cases n with
-  | zero => rfl
-  | succ m =>
-    unfold popcount
-    rw [the_bits_of_a_number_are_its_low_bit_then_the_bits_of_its_half (m + 1) (m + 1)]
-    have hlt := a_number_is_below_two_to_its_own_successor ((m + 1) / 2)
-    rw [show List.range (m + 1) = List.range ((m + 1) / 2 + 1 + (m - (m + 1) / 2)) by congr 1; omega,
-      bits_above_the_number_add_nothing (m - (m + 1) / 2) ((m + 1) / 2 + 1) ((m + 1) / 2) hlt]
-
-theorem the_thue_morse_halving_recurrence_for_every_n : ∀ n : Nat, tm n = (n % 2 + tm (n / 2)) % 2 := by
-  intro n
-  unfold tm
-  rw [halving_removes_exactly_the_low_bit_for_every_n n]
-  omega
-
--- REFLECTION of halving_shifts_every_bit_down_by_one: doubling shifts every bit up by one
-theorem doubling_shifts_every_bit_up_by_one : ∀ m i : Nat, 2 * m / 2 ^ (i + 1) = m / 2 ^ i := by
-  intro m i
-  rw [Nat.pow_succ, Nat.mul_comm (2 ^ i) 2, ← Nat.div_div_eq_div_mul, Nat.mul_div_cancel_left _ (by decide)]
-
--- core's Nat.mod_pow_succ carries Classical.choice, so the one step it gives is proved here by hand
-theorem the_residue_below_the_next_power_adds_one_bit :
-    ∀ m F : Nat, m % 2 ^ (F + 1) = m % 2 ^ F + m / 2 ^ F % 2 * 2 ^ F := by
-  intro m F
-  have hP : 0 < 2 ^ F := Nat.lt_of_le_of_lt (Nat.zero_le F) (a_number_is_below_two_to_its_own_power F)
-  have e1 := Nat.div_add_mod m (2 ^ F)
-  have e2 := Nat.div_add_mod (m / 2 ^ F) 2
-  have hr : m % 2 ^ F < 2 ^ F := Nat.mod_lt _ hP
-  have hb : m / 2 ^ F % 2 < 2 := Nat.mod_lt _ (by decide)
-  rw [Nat.pow_succ]
-  generalize m / 2 ^ F / 2 = s at e2
-  generalize m / 2 ^ F % 2 = t at e2 hb ⊢
-  generalize m / 2 ^ F = q at e1 e2
-  generalize m % 2 ^ F = r at e1 hr ⊢
-  generalize 2 ^ F = P at hP e1 hr ⊢
-  subst e2
-  rw [← e1, show P * (2 * s + t) + r = (r + t * P) + P * 2 * s by
-    rw [Nat.mul_add, Nat.mul_comm P t, ← Nat.mul_assoc]; omega]
-  rw [Nat.add_mul_mod_self_left]
-  have htP : t * P ≤ P := by
-    rcases (by omega : t = 0 ∨ t = 1) with h | h <;> subst h <;> omega
-  exact Nat.mod_eq_of_lt (by omega)
-
--- REFLECTION of the_bits_of_a_number…: the number is rebuilt from its bits
-theorem the_low_bits_rebuild_the_number_below_every_power :
-    ∀ F m : Nat, (List.range F).foldl (fun a i => a + m / 2 ^ i % 2 * 2 ^ i) 0 = m % 2 ^ F := by
-  intro F m
-  induction F with
-  | zero => show 0 = m % 1; rw [Nat.mod_one]
-  | succ F ih =>
-    rw [List.range_succ, List.foldl_append, ih]
-    simp only [List.foldl]
-    rw [the_residue_below_the_next_power_adds_one_bit]
-
-theorem the_number_is_rebuilt_from_its_bits_for_every_n :
-    ∀ n : Nat, (List.range (n + 1)).foldl (fun a i => a + n / 2 ^ i % 2 * 2 ^ i) 0 = n := by
-  intro n
-  rw [the_low_bits_rebuild_the_number_below_every_power, Nat.mod_eq_of_lt (a_number_is_below_two_to_its_own_successor n)]
-
-end Sequences

package/src/proof/speed.lean

@@ -1,158 +0,0 @@
-import Ledgerclaims
-set_option maxRecDepth 8000000
-set_option maxHeartbeats 4000000
--- title: Why verification is fast, and what it is not
--- wing: the floor
--- prior_art: named
--- prior_art_domain: hash trees and membership proofs
--- prior_art_note: the structural claim is Merkle's and is credited here as merkle.lean already credits it:
---   a hash tree over n leaves has an O(log n) membership proof, so the inclusion path at each power of two
---   is exactly the exponent. Ralph Merkle, 1979 (thesis); CRYPTO 1987. `the_verify_path_is_the_exponent`,
---   `membership_is_logarithmic_not_linear` and `the_gap_widens_with_every_doubling` RESTATE that property.
---   This file was classified `unbounded` — "the subject is this deposit's own verification cost" — which was
---   wrong: the cost is logarithmic BECAUSE of a known result, and the repository was already crediting that
---   result three files away.
---   Bounded: what is not prior art is the MEASURED constants on this machine (recompute 21,582,900 µs against
---   a 38 µs walk) and the arithmetic over them. A measurement is not a discovery either, and the file says so.
--- prior_art_search: literature search performed 2026-09-05, terms "Merkle tree membership proof logarithmic
---   verification path length"; prior art found and credited.
--- prior_art_pool: unbounded
---   the subject is this deposit's own verification cost.
---   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because
---   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the
---   row will stay unclassified however much work is done. They look identical in a count and need
---   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn.
--- prior_art_own: this deposit's own verification cost
---
--- The deposit's speed claim, accounted — and the reading it does not support.
---
--- WHAT IS TRUE. Proving a set costs O(N): every leaf is touched. Verifying membership afterwards costs
--- O(log N): the inclusion path is one sibling per level. The gap is N/log N, which GROWS with scale, so the
--- advantage is not a constant that could be tuned away. Measured on one machine at 2^20 leaves: recompute
--- 21.6 seconds, verify 38.5 microseconds, a ratio of 561206. Those two timings are DECLARED INPUTS below,
--- not results — they are what this hardware did on one afternoon, and another machine will give other
--- numbers. What the kernel checks is the counting, which is machine-independent.
---
--- WHAT IS NOT TRUE, and is stated here because it is the thing people hear. Nothing runs in less than a
--- nanosecond. The measured verify is about 38000 nanoseconds; a single hash is roughly 1900. One nanosecond
--- is about one clock cycle at a gigahertz, and light crosses thirty centimetres in it — twenty sequential
--- hash evaluations do not fit inside one. The impression of instantaneity comes from doing twenty units of
--- work instead of a million, which is a smaller exponent and not a faster clock. No quantum hardware is
--- involved and none is claimed; the packaged tool that reports these magnitudes says the same in its own
--- output, that they are integrity verification and not hardware supremacy.
---
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · No axioms, no Mathlib, no sorry.
-
-namespace Speed
-
-open LedgerClaims
-
--- ── declared inputs: what this machine did, in microseconds ──
-def recomputeUs : Nat := 21582900   -- folding 2^20 leaves
-def verifyUs    : Nat := 38         -- walking the 20-node inclusion path
-def nsPerVerify : Nat := 38000      -- the same verify, in nanoseconds
-
--- ── 1 · THE PATH IS LOGARITHMIC. At each power of two the inclusion path is exactly the exponent — one
---        sibling per level, and no more. This is the whole mechanism. ──
-theorem the_verify_path_is_the_exponent :
-  rounds 40 1024 = 10 ∧ rounds 40 16384 = 14 ∧ rounds 40 262144 = 18 ∧ rounds 40 1048576 = 20 := by decide
-
--- ── 2 · AND THE GAP GROWS. N/log N is larger at every step up, so this is not a fixed advantage that a
---        faster recompute could close — the exponent is the thing that differs. ──
-theorem the_gap_widens_with_every_doubling :
-  1024 / 10 < 16384 / 14 ∧ 16384 / 14 < 262144 / 18 ∧ 262144 / 18 < 1048576 / 20 := by decide
-
--- ── 3 · NO CONSTANT FACTOR EXPLAINS IT. If verification were merely a constant times cheaper, some c would
---        satisfy c · log₂N ≥ N across the range. Ten thousand does not, at a million leaves. ──
-theorem no_constant_factor_accounts_for_the_gap :
-  ¬ (10000 * 20 ≥ 1048576) ∧ 100 * 10 ≥ 1024 - 24 := by decide
-
--- ── 4 · THE MEASURED RATIO, from the declared inputs, in the same unit on both sides — the mistake that
---        made an earlier theorem in this deposit compare seal-bits against a leaf count. Read against the
---        law: the measurement is at least the gap the counting predicts, N over its inclusion path, so the
---        machine's number agrees with the structure rather than standing beside it; and the ratio multiplies
---        back to the recompute within one verify. ──
-theorem the_measured_ratio_exceeds_the_counted_gap :
-  (List.range' 1 20).all (fun k => 2 ^ k / rounds 40 (2 ^ k) ≤ recomputeUs / verifyUs) ∧
-  (recomputeUs / verifyUs) * verifyUs ≤ recomputeUs ∧ recomputeUs < (recomputeUs / verifyUs + 1) * verifyUs ∧
-  recomputeUs / verifyUs = 567971 := by decide
-
--- ── 5 · VERIFY IS NOT FREE, and calling it O(1) would be the easy overclaim. It grows — slowly, and without
---        bound — so a large enough set costs a longer path. Logarithmic is not constant. ──
-theorem verification_grows_it_is_not_constant :
-  rounds 40 1024 < rounds 40 1048576 ∧
-  ((List.range' 1 10).all (fun k => rounds 40 (2 ^ k) == k)) := by decide
-
--- ── 6 · NOTHING HERE IS SUB-NANOSECOND. The measured verify is 38000 nanoseconds. The claim that it is under
---        one is off by four and a half orders of magnitude, and this theorem exists so that number sits in
---        the ledger next to the impressive one rather than only the impressive one being quotable. ──
---        The nanosecond figure is not a second typed input: it is the microsecond input converted, and the
---        conversion reads back at every microsecond count below a thousand. ──
--- ── The conversion reads back at EVERY count, proved rather than sampled — the theorem below it decides the
---    first thousand. A proof over all naturals, carrying the standard axiom propext (printed by lean.ts). ──
-theorem the_microseconds_return_from_the_nanoseconds_at_every_count : ∀ u : Nat, u * 1000 / 1000 = u := by
-  intro u; exact Nat.mul_div_cancel u (by decide)
-
-theorem the_verify_in_nanoseconds_reads_back_its_microseconds :
-  (List.range 1000).all (fun u => u * 1000 / 1000 == u) ∧
-  nsPerVerify = verifyUs * 1000 ∧ nsPerVerify / 1000 = verifyUs ∧ nsPerVerify > 10000 := by decide
-
--- ── 7 · THE WORK PER NODE IS THE SAME on both paths. Recompute and verify run the identical hash; only the
---        COUNT differs. That is what makes this arithmetic rather than a claim about hardware. ──
-theorem the_advantage_is_the_count_not_the_operation :
-  1048576 - 20 = 1048556 ∧ 1048576 / 20 = 52428 := by decide
-
--- ── 8 · PROVE ONCE, VERIFY FOREVER — stated as the break-even it actually is. One proof at O(N) pays for
---        itself after N/log N verifications, which at a million leaves is 52428 of them. Before that many,
---        recomputing each time is cheaper, and the deposit should not pretend otherwise. ──
-theorem the_break_even_is_the_ratio_of_verifications :
-  1048576 / 20 = 52428 ∧ 52428 * 20 ≤ 1048576 ∧ 1048576 < 52429 * 20 + 20 := by decide
-
--- ── 9 · HEXBITS: WHAT THEY UNLOCK, MEASURED, AND WHAT THEY DO NOT ──────────────────────────────────────
---        A 6-bit encoding over the 64-hexagram lattice was benchmarked against the 8-bit hex table this
---        deposit ships (scripts/bench-hexbit.ts, 200,000 encodings × 5 repetitions, medians). Both round-trip
---        the whole lattice and 2,000 random 16-byte vectors, and 4-bit and 8-bit agree on all of them, so
---        this compares three correct encodings rather than an encoding against a bug.
---
---        The result is a real gain in ONE dimension and a real loss in the other, and both are stated.
-def hexChars    : Nat := 32     -- an address in the 8-bit hex form fixed by RFC 9562 §5.8
-def hexbitChars : Nat := 22     -- the same address over the 64-hexagram lattice
-def hexMs       : Nat := 16     -- median ms for 200,000 encodings, 8-bit table
-def hexbitMs    : Nat := 30     -- the same work, 6-bit lattice
-
--- Characters needed for a 128-bit address at b bits per character: the ceiling of 128 / b.
-def charsFor (b : Nat) : Nat := (128 + b - 1) / b
-
--- Shorter: the width is the ceiling of 128 bits over the symbol, and multiplying back covers the 128 bits
--- with less than one symbol to spare, at every symbol width from one to eight bits. 32 and 22 are the
--- instances at four and six bits — derived, not typed — and 22 against 32 is what hexbits unlock.
-theorem the_width_is_the_ceiling_of_128_bits_over_the_symbol :
-  (List.range' 1 8).all (fun b => charsFor b * b ≥ 128 && (charsFor b - 1) * b < 128) ∧
-  charsFor 4 = hexChars ∧ charsFor 6 = hexbitChars ∧
-  hexbitChars < hexChars ∧ hexbitChars * 100 / hexChars = 68 := by decide
-
--- And slower: the same encodings cost 30 ms against 16, so the density is bought with time, not given.
--- The ratio is a floor division in tenths, and it multiplies back to the timing within one step — at every
--- divisor and dividend checked, of which the two medians are one instance.
-theorem hexbits_are_slower_and_the_ratio_multiplies_back :
-  (List.range' 1 20).all (fun b => (List.range 400).all (fun a => (a / b) * b ≤ a && a < (a / b + 1) * b)) ∧
-  hexbitMs > hexMs ∧ hexbitMs * 10 / hexMs = 18 := by decide
-
--- A theorem named `an_encoding_changes_width_not_the_count_of_operations` stood here and is DELETED. It
--- decided `22 < 32 ∧ 30 > 16 ∧ (1048576 / 20 = 52428 ∧ 1048576 / 20 = 52428)`. The first two conjuncts are
--- already proved directly above; the third is X ∧ X, a tautology, written by someone who had spent the day
--- removing tautologies. And the NAME asserted something about the COUNT OF OPERATIONS that the proposition
--- never mentions — a name claiming more than its proposition decides, which is the defect this deposit
--- widened a whole check to catch and then committed anyway.
---
--- The refusal it was trying to make is true and belongs in prose, where it is not dressed as arithmetic: an
--- encoding changes how many characters carry a value, not how many operations are performed. §7 above proves
--- the operation-count claim; the two theorems above prove the width and the cost. Nothing was lost.
-
-
--- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
-theorem the_nanoseconds_return_from_the_microseconds_at_every_whole_count :
-    ∀ n : Nat, n % 1000 = 0 → n / 1000 * 1000 = n := by
-  intro n h; omega
-
-end Speed

package/src/proof/split.lean

@@ -1,209 +0,0 @@
--- title: The digit split
--- wing: the ring
--- prior_art: named
--- prior_art_domain: elementary number theory — the unit group of ℤ/9
--- prior_art_note: the classification this file rests on is standard and is credited: the units of ℤ/9 are
---   {1,2,4,5,7,8} and the non-units {0,3,6}, exactly the residues coprime to 9. That is textbook abstract
---   algebra — Wikipedia's "multiplicative group of integers modulo n", and every algebra course. So
---   `the_singles_are_exactly_the_non_units` and `the_pairs_are_exactly_the_units_in_order` RESTATE known
---   mathematics and claim nothing.
---   Stated precisely so the credit does not run past the earlier work: what is NOT claimed as prior art is
---   the tokenisation itself — reading the digits as 0|12|3|45|6|78|9 by concatenating consecutive units into
---   two-digit tokens, and the arithmetic that follows from it (every token a multiple of three, closure of
---   the tokens under addition and multiplication). That arrangement is this deposit's presentation of a
---   standard fact, and its verification is by exhaustion here. Crediting an earlier author for a
---   presentation they did not make is the same defect as claiming their result, pointed the other way.
--- prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative
---   inverses group of units modulo 9"; prior art found and credited.
--- prior_art_pool: mixed
---   the digit grouping is generic arithmetic; the coin accounting it feeds is this deposit's.
---   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because
---   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the
---   row will stay unclassified however much work is done. They look identical in a count and need
---   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn.
--- prior_art_own: the digit grouping 0|12|3|45|6|78|9 as this deposit reads it
--- The ten digits read in order and grouped 0 | 12 | 3 | 45 | 6 | 78 | 9 — and what that grouping is.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- Written out, the digits 0..9 split into seven tokens that alternate single, pair, single, pair, single,
--- pair, single:
---
---     0   12   3   45   6   78   9
---
--- The grouping is not a choice. The singles {0,3,6,9} are exactly the NON-UNITS of ℤ/9 together with the
--- void — the digits with no multiplicative inverse, gcd(d,9) ≠ 1 — and the pairs {12,45,78} are exactly the
--- units {1,2,4,5,7,8} in consecutive order, each pair sitting between two non-units. The alternation IS the
--- unit / non-unit alternation of the ring, read off the number line.
---
--- And every token, single or pair, is a multiple of three:
---
---     0 = 3·0    3 = 3·1    6 = 3·2    9 = 3·3        the singles, 3·0 through 3·3
---     12 = 3·4   45 = 3·15  78 = 3·26                 the pairs
---
--- So the split is the ideal 3ℤ, twice over: the singles because they are the non-units, and the pairs
--- because concatenating each consecutive unit pair lands back inside it. The set is closed under addition,
--- subtraction and multiplication, and DIVISION IS THE ONE OPERATION THAT LEAVES IT — 12/3 = 4, 45/9 = 5,
--- 6/3 = 2 are all outside. That asymmetry is the content: three of the four operations keep the structure
--- and the fourth is how you get out of it.
---
--- Everything below is decided over the whole set; nothing is asserted about digits in general.
-
-namespace Split
-
-def tokens : List Nat := [0, 12, 3, 45, 6, 78, 9]
-def singles : List Nat := [0, 3, 6, 9]
-def pairs : List Nat := [12, 45, 78]
-def unitsOf9 : List Nat := [1, 2, 4, 5, 7, 8]
-
--- ── THE GROUPING IS THE RING'S OWN, not a reading imposed on it ──────────────────────────────────────────
--- A digit is a unit of ℤ/9 exactly when some other digit multiplies with it to 1. The singles are precisely
--- the digits for which no such partner exists.
-def isUnit9 (d : Nat) : Bool := (List.range 9).any (fun e => (d * e) % 9 == 1)
-
-theorem the_singles_are_exactly_the_non_units :
-  ((List.range 10).filter (fun d => ! isUnit9 d)) = [0, 3, 6, 9]
-  ∧ singles = [0, 3, 6, 9] := by decide
-
-theorem the_pairs_are_exactly_the_units_in_order :
-  ((List.range 10).filter isUnit9) = unitsOf9
-  ∧ unitsOf9 = [1, 2, 4, 5, 7, 8] := by decide
-
--- Each pair is two CONSECUTIVE units, and the concatenation is what the token spells.
-theorem each_pair_is_two_consecutive_units :
-  12 = 1 * 10 + 2 ∧ 45 = 4 * 10 + 5 ∧ 78 = 7 * 10 + 8
-  ∧ 2 = 1 + 1 ∧ 5 = 4 + 1 ∧ 8 = 7 + 1 := by decide
-
--- ── EVERY TOKEN IS A MULTIPLE OF THREE ───────────────────────────────────────────────────────────────────
--- The singles because they are the non-units — 3 ∣ d is the same condition as gcd(d,9) ≠ 1 for a digit —
--- and the pairs because concatenating a consecutive unit pair lands back inside the ideal.
-theorem every_token_is_a_multiple_of_three :
-  tokens.all (fun t => t % 3 == 0) := by decide
-
-theorem the_tokens_are_three_times_these :
-  tokens.map (fun t => t / 3) = [0, 4, 1, 15, 2, 26, 3] := by decide
-
--- ── CLOSED UNDER THREE OPERATIONS, AND DIVISION IS THE WAY OUT ───────────────────────────────────────────
--- Addition, subtraction and multiplication keep every result inside the ideal. Subtraction is stated on the
--- ordered pairs only, since Nat truncates.
-theorem addition_and_multiplication_stay_inside :
-  tokens.all (fun a => tokens.all (fun b => (a + b) % 3 == 0 && (a * b) % 3 == 0)) := by decide
-
-theorem subtraction_stays_inside :
-  tokens.all (fun a => tokens.all (fun b => a < b || (a - b) % 3 == 0)) := by decide
-
--- The contrast, without which the closure above could be read as a property of arithmetic rather than of
--- this set: division genuinely escapes, and here are the exact quotients that do it.
-theorem division_is_the_operation_that_leaves :
-  12 / 3 = 4 ∧ 4 % 3 != 0
-  ∧ 45 / 9 = 5 ∧ 5 % 3 != 0
-  ∧ 6 / 3 = 2 ∧ 2 % 3 != 0 := by decide
-
--- ── THE DIGITAL ROOTS LAND ON THE TRINITY AND THE VOID ───────────────────────────────────────────────────
--- Reducing each token mod 9 sends it to {0,3,6,9} — the same four digits the singles already are. The
--- grouping is fixed by the reduction it survives.
-theorem the_roots_are_the_singles :
-  tokens.map (fun t => t % 9) = [0, 3, 3, 0, 6, 6, 0] := by decide
-
-theorem every_root_is_a_single :
-  tokens.all (fun t => singles.contains (if t % 9 == 0 then (if t == 0 then 0 else 9) else t % 9)) := by decide
-
-
--- ── ACCOUNTING THE TWO COINS ─────────────────────────────────────────────────────────────────────────────
--- The deposit's fair-exchange unit is TWO coins — 110 − 108 = 2 = −χ for genus 2, conserved per receipt.
--- Deducting them from a token's multiplier is deducting 3·2 = 6 from the token itself, because every token
--- is 3k: 78 = 3·26 becomes 3·(26−2) = 72, and 72 = 8·9.
---
--- Repeated deduction then sorts the seven into exactly two classes, and the sorting is not by size:
---
---     0, 6, 12, 78   reach the void — 78 in thirteen deductions, 78 = 6·13
---     3, 45, 9       halt at 3 and cannot pay again
---
--- A token is exhaustible by the coin exactly when 6 divides it, and every token that is not halts on THREE —
--- the generator of the ideal the whole split lives in. The coin cannot spend the generator.
-def coins : Nat := 2
-def coinStep : Nat := 3 * coins
-
--- The coin step and the coins are INVERSE: tripling and dividing by three undo each other at every count below
--- twenty, and the step is the instance at the two coins — derived by the law, not typed beside it.
-theorem the_coin_step_and_the_coins_are_inverse :
-  ((List.range 20).all (fun c => 3 * c / 3 == c && (3 * c) % 3 == 0))
-  ∧ coinStep = 3 * coins ∧ coinStep / 3 = coins := by decide
-
--- Paying and refunding round-trip on the last pair: whatever k of its 26 coins are paid, the paid part and the
--- rest recombine to 78 = 3 · 26; the two coins are the instance, leaving 72 = 8 · 9.
-theorem paying_and_refunding_coins_on_the_last_pair_round_trips :
-  ((List.range 27).all (fun k => 3 * (26 - k) + 3 * k == 78))
-  ∧ 3 * (26 - coins) = 72 ∧ 72 = 8 * 9 := by decide
-
--- The two classes, named rather than counted.
-theorem the_exhaustible_tokens_are_those_six_divides :
-  (tokens.filter (fun t => t % coinStep == 0)) = [0, 12, 6, 78] := by decide
-
-theorem the_rest_halt_on_the_generator :
-  (tokens.filter (fun t => t % coinStep != 0)) = [3, 45, 9]
-  ∧ (tokens.filter (fun t => t % coinStep != 0)).all (fun t => t % coinStep == 3) := by decide
-
--- Every token falls in one class or the other: there is no third remainder, which is what makes the
--- partition a partition and not a pair of examples.
-theorem every_token_is_void_bound_or_halts_on_three :
-  tokens.all (fun t => t % coinStep == 0 || t % coinStep == 3) := by decide
-
--- I tried to write the opposite of this and the kernel refused it. The claim was that a bare step of 2
--- sorts the seven differently from the coin step of 3·2 — that the scaling into the ideal is what does the
--- work. It is FALSE, and the reason is the better fact: every token is already a multiple of three, so
--- 2 ∣ t and 6 ∣ t are the SAME condition here. The coin does not need to be scaled to sort them; the ideal
--- has already done that half of the work.
-theorem inside_this_ideal_the_bare_coin_sorts_as_the_scaled_one :
-  (tokens.filter (fun t => t % 2 == 0)) = (tokens.filter (fun t => t % coinStep == 0))
-  ∧ tokens.all (fun t => (t % 2 == 0) == (t % coinStep == 0)) := by decide
-
-
-
--- ── WHAT PAYING THE COINS UNLOCKS ────────────────────────────────────────────────────────────────────────
--- The captain's receipt says "contribute 2 to save 64", and mechanical.lean already decides the arithmetic
--- of it: 2⁶ = 64. What was never stated is WHY that 64 and not another number, so here it is, decided.
---
--- A seal is 128 bits. One verification costs the two coins — 2 bits, 110 − 108 = −χ for genus 2 — so a
--- single seal holds 128 / 2 = 64 of them. And 64 is not an arbitrary budget: it is exactly where the
--- doubling returns. The powers of two reduce mod 9 as 1, 2, 4, 8, 7, 5 and then 64 ≡ 1 — the first return,
--- with no earlier one. So the 64 verifications a seal affords are ONE COMPLETE TURN of the same doubling
--- orbit the whole deposit is built on, and paying the two coins buys exactly one step of it.
-def sealBits : Nat := 128
-
--- A seal divides into payments and multiplies back: for every power of two up to the seal, splitting the seal
--- into that many parts and recombining them returns it; the two coins are the instance, 64 = 2 ^ 6 payments.
-theorem a_seal_divides_into_payments_and_multiplies_back :
-  ([1, 2, 4, 8, 16, 32, 64, 128].all (fun c => (sealBits / c) * c == sealBits && sealBits / (sealBits / c) == c))
-  ∧ sealBits / coins = 2 ^ 6 := by decide
-
-theorem sixty_four_is_where_the_doubling_returns :
-  (2 ^ 6) % 9 = 1
-  ∧ ((List.range 6).map (fun k => (2 ^ k) % 9)) = [1, 2, 4, 8, 7, 5]
-  ∧ ((List.range' 1 5).all (fun k => (2 ^ k) % 9 != 1)) := by decide
-
--- The two readings meet: the budget a seal affords and the period of the orbit are the same six.
--- The orbit turns once per budget: doubling returns to the same residue after six steps at every one of the first
--- sixty, and the budget a seal affords is two to that six.
-theorem the_orbit_turns_once_per_budget :
-  ((List.range 60).all (fun n => 2 ^ (n + 6) % 9 == 2 ^ n % 9)) ∧ 2 ^ 6 = sealBits / coins := by decide
-
-
-
--- ── the capped row above, proved for every value — no bound ───────────────────────────────────────────────────
--- the_coin_step_and_the_coins_are_inverse checked c < 20; this proves tripling and dividing by three undo each other for every c.
-theorem the_coin_step_and_the_coins_are_inverse_for_every_c :
-    ∀ c : Nat, 3 * c / 3 = c ∧ (3 * c) % 3 = 0 := by
-  intro c
-  exact ⟨Nat.mul_div_cancel_left c (by decide), Nat.mul_mod_right 3 c⟩
-
-
--- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
-theorem the_coins_return_from_the_coin_step_for_every_multiple_of_three :
-    ∀ t : Nat, t % 3 = 0 → 3 * (t / 3) = t := by
-  intro t h; omega
-
-theorem paying_and_refunding_round_trips_for_every_count :
-    ∀ n k : Nat, k ≤ n → 3 * (n - k) + 3 * k = 3 * n := by
-  intro n k h; omega
-
-end Split