@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/src/proof/fixtures/axiom-control.lean

@@ -1,39 +0,0 @@
--- A NEGATIVE CONTROL, and it is not part of the deposit's theorems.
---
--- It lives outside src/proof because scripts/lean.ts fails any file whose declarations depend on an axiom,
--- and the whole point of this one is that its second theorem DOES. Every check should be asked a question
--- whose answer is already known before its report is believed, and "no theorem here depends on an axiom"
--- is a claim that would read identically if `#print axioms` were silently broken, mis-parsed, or pointed
--- at nothing.
---
--- Run by scripts/axiom-index.ts. The expected output is exact:
---
---   'axiom_free_by_decision' does not depend on any axioms
---   'needs_all_three'        depends on axioms: [propext, Classical.choice, Quot.sound]
---
--- The first is what every declaration in src/proof reports. The second is what excluded middle costs in a
--- constructive kernel, and it is the reason the deposit's arithmetic is decided rather than argued.
-
-def refl' (d : Nat) : Nat := 10 - d
-
--- Decided by exhaustion over a finite domain: computation, not inference from axioms.
-theorem axiom_free_by_decision : [1, 2, 3, 4].all (fun d => refl' (refl' d) == d) := by decide
-
--- The same shape of fact, obtained classically. One appeal to excluded middle pulls in all three.
-theorem needs_all_three : ∀ p : Prop, p ∨ ¬p := fun p => Classical.em p
-
--- PINNED WITH `#guard_msgs`, so the assertion is checked by the elaborator rather than by a script reading
--- this file's output. If either footprint ever changes — a tactic quietly pulling in choice, a toolchain
--- altering what `#print axioms` reports — THIS FILE STOPS COMPILING. The technique is standard practice in
--- the Lean community: axiom hygiene as an executable regression test, pinned so drift fails the build with
--- a mismatch rather than passing unnoticed.
---
--- Note the pins CONSUME the info line when they match, so a reader running this file sees silence. That is
--- the assertion holding, not the check being absent.
-/-- info: 'axiom_free_by_decision' does not depend on any axioms -/
-#guard_msgs in
-#print axioms axiom_free_by_decision
-
-/-- info: 'needs_all_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
-#guard_msgs in
-#print axioms needs_all_three

package/src/proof/flow.lean

@@ -1,78 +0,0 @@
-import Index
--- title: The doubling flow, for every step
--- wing: the ring
--- prior_art: named
--- prior_art_domain: elementary number theory — the multiplicative order of 2 modulo 9
--- prior_art_note: 2⁶ = 64 ≡ 1 (mod 9), so the powers of two modulo 9 repeat with period six — Euler's
---   theorem for φ(9) = 6, and the order of 2 in U(9), both textbook. Credited, and bounded: what this file adds
---   is the kernel proof that the flow used by `navier_stokes_flow_is_bounded` stays bounded at EVERY step,
---   not only at the 48 that theorem checks.
--- prior_art_search: literature search performed 2026-09-14, terms "powers of two modulo 9 period 6 order of 2
---   mod 9 Euler theorem"; prior art found and credited.
--- prior_art_pool: bounded
--- prior_art_own: the every-step bound of the doubling flow, stated for the Navier–Stokes theorem in index.lean
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- `navier_stokes_flow_is_bounded` in index.lean decides its bound over the first 48 steps, and every page that
--- quotes it says "for all time". Forty-eight steps are not all time: `decide` stops at its bound. This file
--- goes past it. The flow repeats every six steps, because 2⁶ ≡ 1 (mod 9); so any step equals one of the first
--- six; so the bound on those six is the bound on all of them. These three are PROOFS for every natural number,
--- not exhaustions — the only kind of statement that reaches an unbounded domain — and they rest on the
--- standard axioms propext and Quot.sound, printed per theorem by lean.ts.
-
-namespace Flow
-open MillenniumFloor
-
--- ── the period: six steps of doubling return the flow to where it was, at every step ────────────────────
-theorem the_doubling_flow_repeats_every_six_steps : ∀ k : Nat, orbit (k + 6) = orbit k := by
-  intro k
-  unfold orbit
-  rw [Nat.pow_add, Nat.mul_mod]
-  have h : 2 ^ 6 % 9 = 1 := by decide
-  rw [h, Nat.mul_one, Nat.mod_mod]
-
--- ── hence every step is one of the first six ──────────────────────────────────────────────────────────────
-theorem the_doubling_flow_is_its_first_six_steps : ∀ k : Nat, orbit k = orbit (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, the_doubling_flow_repeats_every_six_steps, ih (k - 6) (by omega), Nat.add_mod_right]
-
--- ── and so the flow is bounded at every step: a residue below 9, inside the six-cycle, for all k ─────────
-theorem navier_stokes_flow_is_bounded_for_every_step :
-    ∀ k : Nat, orbit k < 9 ∧ span.contains (orbit k) = true := by
-  intro k
-  rw [the_doubling_flow_is_its_first_six_steps]
-  have h : k % 6 < 6 := Nat.mod_lt _ (by decide)
-  generalize k % 6 = j at h ⊢
-  revert j
-  decide
-
-
--- ── reflections, from the orbit batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
--- orbit and span are MillenniumFloor's (index.lean), opened above — not redefined here
--- REFLECTION: the reverse flow (halving, ×5) steps every state back one, at every step
-theorem the_reverse_flow_undoes_every_step : ∀ k : Nat, orbit (k + 1) * 5 % 9 = orbit k := by
-  intro k
-  unfold orbit
-  rw [Nat.mul_mod, Nat.mod_mod, ← Nat.mul_mod, Nat.pow_succ, Nat.mul_assoc, Nat.mul_mod]
-  show 2 ^ k % 9 * 1 % 9 = 2 ^ k % 9
-  rw [Nat.mul_one, Nat.mod_mod]
-
--- REFLECTION of "bounded": recurrent — from every step, every state of the span returns within six steps
-theorem every_state_of_the_flow_returns_within_six_steps :
-    ∀ k s : Nat, ∃ j, j < 6 ∧ orbit (k + j) = orbit s := by
-  intro k s
-  have key : ∀ r, r < 6 → ∀ t, t < 6 → ∃ j, j < 6 ∧ orbit ((r + j) % 6) = orbit t := by
-    decide
-  obtain ⟨j, hj, e⟩ := key (k % 6) (Nat.mod_lt _ (by decide)) (s % 6) (Nat.mod_lt _ (by decide))
-  refine ⟨j, hj, ?_⟩
-  rw [the_doubling_flow_is_its_first_six_steps (k + j), the_doubling_flow_is_its_first_six_steps s]
-  have hm : (k + j) % 6 = (k % 6 + j) % 6 := by omega
-  rw [hm]
-  exact e
-
-end Flow

package/src/proof/fnv.lean

@@ -1,127 +0,0 @@
-set_option maxRecDepth 1000000
--- title: FNV-1a, the address function
--- wing: the address
--- prior_art: named
--- prior_art_domain: non-cryptographic hashing
--- prior_art_note: FNV-1a — Glenn Fowler, Landon Curt Noll and Phong Vo, 1991
--- FNV-1a, ported to Lean — the hash the whole deposit's addressing rests on.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- Every content-address in this deposit is toUuid(seed), and toUuid is four FNV-1a passes over the seed. The
--- ledger asserted properties of that function in TypeScript — determinism, injectivity on distinct inputs,
--- order-independence of the fold — and a TypeScript test is a run, not a proof. Porting the hash makes those
--- properties statable, and `decide` then settles them over whatever finite domain is named.
---
--- Two primitives had to be built rather than borrowed. Nat's bitwise operations (`^^^`, `>>>`) and `Nat.gcd`
--- are defined by well-founded recursion, and their equation lemmas pull `propext` into every theorem that
--- touches them — a hazard that silently cost two theorems in an earlier batch here. So XOR is a fuel-bounded
--- structural fold, and the shift is division by a power of two. No axioms, no Mathlib, no sorry.
-
-namespace Fnv
-
-/-- XOR by structural recursion on fuel — 33 steps covers every 32-bit pair. -/
-def xorF : Nat → Nat → Nat → Nat
-  | 0, _, _ => 0
-  | _, 0, b => b
-  | _, a, 0 => a
-  | Nat.succ f, a, b => (if a % 2 == b % 2 then 0 else 1) + 2 * xorF f (a / 2) (b / 2)
-
-def M32 : Nat := 4294967296
-def xor32 (a b : Nat) : Nat := xorF 33 a b
-def shr (n k : Nat) : Nat := n / (2 ^ k)
-def mul32 (a b : Nat) : Nat := (a * b) % M32
-
-def FNV_OFFSET : Nat := 2166136261   -- 0x811c9dc5
-def FNV_PRIME  : Nat := 16777619     -- 0x01000193
-def MIX1 : Nat := 2246822507         -- 0x85ebca6b
-def MIX2 : Nat := 3266489909         -- 0xc2b2ae35
-
-/-- one character folded into the accumulator: xor, multiply by the prime, xor the high bits down -/
-def step (h c : Nat) : Nat :=
-  let h1 := xor32 h c
-  let h2 := mul32 h1 FNV_PRIME
-  xor32 h2 (shr h2 13)
-
-/-- the avalanche applied after the fold -/
-def avalanche (h : Nat) : Nat :=
-  let a := mul32 (xor32 h (shr h 16)) MIX1
-  let b := mul32 (xor32 a (shr a 13)) MIX2
-  xor32 b (shr b 16)
-
-/-- FNV-1a as this deposit computes it: seeded, folded over the character codes, then avalanched. -/
-def hash32 (seed : Nat) (cs : List Nat) : Nat := avalanche (cs.foldl step (xor32 FNV_OFFSET seed))
-
--- ── AGREEMENT with the shipped implementation, at published values ──
-theorem hash_a_seed_zero        : hash32 0 [97] = 1484191995 := by decide
-theorem hash_ab_seed_zero       : hash32 0 [97, 98] = 2049961697 := by decide
-theorem hash_a_seed_golden      : hash32 2654435769 [97] = 1066733258 := by decide
-theorem hash_uuidna_seed_zero   : hash32 0 [117, 117, 105, 100, 110, 97] = 4233172274 := by decide
-
--- ── DETERMINISM, proved rather than observed ──
-theorem hash_is_deterministic :
-  (List.range 32).all (fun c => hash32 0 [c] == hash32 0 [c]) := by decide
-
--- ── INJECTIVITY on a named finite domain: distinct single characters give distinct hashes ──
-theorem hash_is_injective_on_single_characters :
-  (((List.range 64).map (fun c => hash32 0 [c])).eraseDups).length = 64 := by decide
-
--- ── the seed genuinely separates: the same input under different seeds gives different hashes ──
-theorem the_seed_separates :
-  (List.range 16).all (fun c => hash32 0 [c] != hash32 2654435769 [c]) := by decide
-
--- ── NON-VACUITY: the hash is not the identity and not constant ──
-theorem hash_is_not_the_identity : hash32 0 [7] != 7 := by decide
-theorem hash_is_not_constant : hash32 0 [1] != hash32 0 [2] := by decide
-
--- ── the output is bounded to 32 bits, as the whole construction requires ──
-theorem hash_is_thirty_two_bit :
-  (List.range 40).all (fun c => hash32 0 [c] < M32) := by decide
-
-def settledHere : Nat := 12
-theorem fnv_settles_its_range : settledHere = 12 := rfl
-
--- ── THE ADDRESS IS A SEQUENCE HASH, NOT A SET HASH. Swapping two bytes changes it, so the input's ORDER is
---    part of what is addressed. This is the opposite of the merkle fold, which sorts precisely so that order
---    stops mattering — the two live side by side in this deposit and it is worth being exact about which is
---    which, because using one where the other is meant is a silent bug rather than a loud one.
-theorem the_hash_is_order_sensitive :
-  hash32 0 [97, 98] ≠ hash32 0 [98, 97] := by decide
-
--- ── THE EMPTY INPUT IS STILL MIXED, AND ONE SEED SENDS IT TO ZERO. The first draft here said the hash of
---    nothing returns the seed unchanged; the kernel refuted it, because hash32 avalanches unconditionally —
---    there is no short-circuit for the empty list. What is true is sharper and worth recording: zero is a
---    FIXED POINT of the avalanche, so seeding with the offset basis (which the initial xor cancels) addresses
---    the empty input as 0. A degenerate address reachable from public constants is not a secret and not a
---    defect to hide — it is the kind of edge a keyless, reproducible function is expected to state plainly.
-theorem the_empty_input_is_still_mixed :
-  hash32 0 [] = 2872998923 ∧ hash32 FNV_OFFSET [] = 0 ∧ avalanche 0 = 0 := by decide
-
-
--- ── the fast multiply, proved exact for every a, b ──────────────────────────────────────────────────────────
--- A 32-bit product can be taken without big integers: split a into 16-bit halves, and every partial product stays
--- below 2^53. This is the multiply behind a toUuid that runs 12.5× faster with byte-identical output (measured on
--- 20,007 inputs); here it is shown equal to mul32 for every a and b, not only on the inputs that were run.
-theorem the_split_multiply_is_the_exact_thirty_two_bit_product :
-    ∀ a b : Nat, (a % 65536 * b + a / 65536 * b % 65536 * 65536) % M32 = mul32 a b := by
-  intro a b
-  unfold mul32 M32
-  have e : a * b = a / 65536 * b * 65536 + a % 65536 * b := by
-    conv => lhs; rw [← Nat.div_add_mod a 65536]
-    rw [Nat.add_mul, Nat.mul_comm 65536 (a / 65536), Nat.mul_right_comm]
-  rw [e]
-  generalize a / 65536 * b = P
-  generalize a % 65536 * b = Q
-  omega
-
-
--- ── reflections, from the xor batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
--- REFLECTION of the exact 32-bit multiply: multiplying by the FNV prime is undone by its inverse mod 2^32
-theorem multiplying_by_the_fnv_prime_is_undone_by_its_inverse_for_every_h :
-    ∀ h : Nat, mul32 (mul32 h FNV_PRIME) 899433627 = h % M32 := by
-  intro h
-  unfold mul32
-  rw [Nat.mod_mul_mod, Nat.mul_assoc,
-    show FNV_PRIME * 899433627 = 1 + 3513497 * M32 by decide,
-    Nat.mul_add, Nat.mul_one, ← Nat.mul_assoc, Nat.add_mul_mod_self_right]
-
-end Fnv

package/src/proof/generated-theorems.json

@@ -1,207 +0,0 @@
-[
-  {
-    "key": "powsum_zero_odd_exponents",
-    "name": "powsum0_k, quantified over its whole parameter set (9 ledger rows)",
-    "statement": "[1, 3, 5, 7, 9, 11, 13, 15, 17].all (fun k => (([1,2,4,5,7,8].map (fun u => (u ^ k) % 9)).foldl (· + ·) 0) % 9 == 0)",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The ring Z/9",
-    "skill": "z9-ring",
-    "lean": "theorem powsum_zero_odd_exponents :\n  [1, 3, 5, 7, 9, 11, 13, 15, 17].all (fun k =>\n    (([1,2,4,5,7,8].map (fun u => (u ^ k) % 9)).foldl (· + ·) 0) % 9 == 0) := by decide",
-    "address": "6c36a9ab-f72d-862c-8044-143fa126824a",
-    "subsumes": [
-      "powsum0_k_1",
-      "powsum0_k_3",
-      "powsum0_k_5",
-      "powsum0_k_7",
-      "powsum0_k_9",
-      "powsum0_k_11",
-      "powsum0_k_13",
-      "powsum0_k_15",
-      "powsum0_k_17"
-    ]
-  },
-  {
-    "key": "mulperm_iff_unit_all",
-    "name": "mulperm_k, quantified over its whole parameter set (5 ledger rows)",
-    "statement": "(List.range 9).all (fun k => (((([1,2,4,5,7,8].map (fun u => (k * u) % 9)).eraseDups).length) == 6) == ([1,2,4,5,7,8].contains k))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The ring Z/9",
-    "skill": "z9-ring",
-    "lean": "theorem mulperm_iff_unit_all :\n  (List.range 9).all (fun k =>\n    (((([1,2,4,5,7,8].map (fun u => (k * u) % 9)).eraseDups).length) == 6) ==\n    ([1,2,4,5,7,8].contains k)) := by decide",
-    "address": "528a962b-c690-848b-bc01-18d6b0b3bd72",
-    "subsumes": [
-      "mulperm_k_2",
-      "mulperm_k_4",
-      "mulperm_k_5",
-      "mulperm_k_7",
-      "mulperm_k_8"
-    ]
-  },
-  {
-    "key": "addgen_iff_coprime_all",
-    "name": "addgen_k, quantified over its whole parameter set (5 ledger rows)",
-    "statement": "(List.range 9).all (fun k => ((((List.range 9).map (fun i => (k * i) % 9)).eraseDups).length == 9) == ([1,2,4,5,7,8].contains k))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The ring Z/9",
-    "skill": "z9-ring",
-    "lean": "theorem addgen_iff_coprime_all :\n  (List.range 9).all (fun k =>\n    ((((List.range 9).map (fun i => (k * i) % 9)).eraseDups).length == 9) ==\n    ([1,2,4,5,7,8].contains k)) := by decide",
-    "address": "c70e4a08-4cfd-88c9-8014-f9d6481dcc27",
-    "subsumes": [
-      "addgen_k_2",
-      "addgen_k_4",
-      "addgen_k_5",
-      "addgen_k_7",
-      "addgen_k_8"
-    ]
-  },
-  {
-    "key": "hasinv_iff_unit_all",
-    "name": "hasinv_d, quantified over its whole parameter set (6 ledger rows)",
-    "statement": "(List.range 9).all (fun d => ((List.range 9).any (fun e => (d * e) % 9 == 1)) == ([1,2,4,5,7,8].contains d))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The ring Z/9",
-    "skill": "z9-ring",
-    "lean": "theorem hasinv_iff_unit_all :\n  (List.range 9).all (fun d =>\n    ((List.range 9).any (fun e => (d * e) % 9 == 1)) == ([1,2,4,5,7,8].contains d)) := by decide",
-    "address": "a0c21f15-ebc9-8bfe-9bb2-867ee66c944a",
-    "subsumes": [
-      "hasinv_d_1",
-      "hasinv_d_2",
-      "hasinv_d_4",
-      "hasinv_d_5",
-      "hasinv_d_7",
-      "hasinv_d_8"
-    ]
-  },
-  {
-    "key": "demorgan_all_widths",
-    "name": "demorgan_nary_k, quantified over its whole parameter set (7 ledger rows)",
-    "statement": "(List.range' 2 7).all (fun k => (List.range (2 ^ k)).all (fun n => (!((List.range k).all (fun i => (n >>> i) % 2 == 1))) == ((List.range k).any (fun i => (n >>> i) % 2 == 0))))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The boolean lattice",
-    "skill": "logic",
-    "lean": "theorem demorgan_all_widths :\n  (List.range' 2 7).all (fun k =>\n    (List.range (2 ^ k)).all (fun n =>\n      (!((List.range k).all (fun i => (n >>> i) % 2 == 1))) ==\n      ((List.range k).any (fun i => (n >>> i) % 2 == 0)))) := by decide",
-    "address": "ee6e7511-fdea-8b96-8612-a1b45adbfbf3",
-    "subsumes": [
-      "demorgan_nary_k_2",
-      "demorgan_nary_k_3",
-      "demorgan_nary_k_4",
-      "demorgan_nary_k_5",
-      "demorgan_nary_k_6",
-      "demorgan_nary_k_7",
-      "demorgan_nary_k_8"
-    ]
-  },
-  {
-    "key": "power_sum_closed_forms",
-    "name": "power_sum_k, quantified over its whole parameter set (5 ledger rows)",
-    "statement": "(List.range' 1 30).all (fun n => (((List.range' 1 n).foldl (· + ·) 0) * 2 == n * (n + 1)) ∧ (((List.range' 1 n).map (fun i => i * i)).foldl (· + ·) 0) * 6 == n * (n + 1) * (2 * n + 1))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The closed forms",
-    "skill": "sums",
-    "lean": "theorem power_sum_closed_forms :\n  (List.range' 1 30).all (fun n =>\n    (((List.range' 1 n).foldl (· + ·) 0) * 2 == n * (n + 1))\n    ∧ (((List.range' 1 n).map (fun i => i * i)).foldl (· + ·) 0) * 6 == n * (n + 1) * (2 * n + 1)) := by decide",
-    "address": "9caaf63f-ba3f-8651-931d-6c467aed46b3",
-    "subsumes": [
-      "power_sum_k_1",
-      "power_sum_k_2",
-      "power_sum_k_3",
-      "power_sum_k_4",
-      "power_sum_k_5"
-    ]
-  },
-  {
-    "key": "invpow_is_fifth_power_all_units",
-    "name": "invpow_u, quantified over its whole parameter set (6 ledger rows)",
-    "statement": "[1,2,4,5,7,8].all (fun u => (u * (u ^ 5)) % 9 == 1)",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The ring Z/9",
-    "skill": "z9-ring",
-    "lean": "theorem invpow_is_fifth_power_all_units :\n  [1,2,4,5,7,8].all (fun u => (u * (u ^ 5)) % 9 == 1) := by decide",
-    "address": "79438c54-f6f5-8343-9d0b-027980876a1d",
-    "subsumes": [
-      "invpow_u_1",
-      "invpow_u_2",
-      "invpow_u_4",
-      "invpow_u_5",
-      "invpow_u_7",
-      "invpow_u_8"
-    ]
-  },
-  {
-    "key": "cyclic_units_have_a_primitive_root",
-    "name": "domain_cyclic_m, quantified over its whole parameter set (13 ledger rows)",
-    "statement": "[2,3,5,7,11,13].all (fun p => (List.range' 1 (p - 1)).any (fun g => (((List.range' 1 (p - 1)).map (fun k => (g ^ k) % p)).eraseDups).length == p - 1))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The primes",
-    "skill": "number-theory",
-    "lean": "theorem cyclic_units_have_a_primitive_root :\n  [2,3,5,7,11,13].all (fun p =>\n    (List.range' 1 (p - 1)).any (fun g =>\n      (((List.range' 1 (p - 1)).map (fun k => (g ^ k) % p)).eraseDups).length == p - 1)) := by decide",
-    "address": "4b2f765f-dd14-8805-9004-333d35ad4ca8",
-    "subsumes": [
-      "domain_cyclic_m_2",
-      "domain_cyclic_m_3",
-      "domain_cyclic_m_4",
-      "domain_cyclic_m_5",
-      "domain_cyclic_m_6",
-      "domain_cyclic_m_7",
-      "domain_cyclic_m_9",
-      "domain_cyclic_m_10",
-      "domain_cyclic_m_11",
-      "domain_cyclic_m_13",
-      "domain_cyclic_m_14",
-      "domain_cyclic_m_17",
-      "domain_cyclic_m_18"
-    ]
-  },
-  {
-    "key": "decimal_period_is_the_order_of_ten",
-    "name": "decimal_period_of_1_over, quantified over its whole parameter set (12 ledger rows)",
-    "statement": "[3,7,11,13,17,19,23,29].all (fun p => ((List.range' 1 (p - 1)).find? (fun k => ((List.range k).foldl (fun r _ => r * 10 % p) 1) == 1)).getD 0 == ((List.range' 1 (p - 1)).find? (fun k => (10 ^ k) % p == 1)).getD 0)",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The primes",
-    "skill": "number-theory",
-    "lean": "theorem decimal_period_is_the_order_of_ten :\n  [3,7,11,13,17,19,23,29].all (fun p =>\n    ((List.range' 1 (p - 1)).find? (fun k =>\n      ((List.range k).foldl (fun r _ => r * 10 % p) 1) == 1)).getD 0 ==\n    ((List.range' 1 (p - 1)).find? (fun k => (10 ^ k) % p == 1)).getD 0) := by decide",
-    "address": "dccd7de1-54b9-862c-8c82-4cca9a7a557f",
-    "subsumes": [
-      "decimal_period_of_1_over_3",
-      "decimal_period_of_1_over_7",
-      "decimal_period_of_1_over_11",
-      "decimal_period_of_1_over_13",
-      "decimal_period_of_1_over_17",
-      "decimal_period_of_1_over_19",
-      "decimal_period_of_1_over_23",
-      "decimal_period_of_1_over_29",
-      "decimal_period_of_1_over_31",
-      "decimal_period_of_1_over_37",
-      "decimal_period_of_1_over_41",
-      "decimal_period_of_1_over_43"
-    ]
-  },
-  {
-    "key": "primality_agrees_with_trial_division",
-    "name": "domain_prime_m, quantified over its whole parameter set (7 ledger rows)",
-    "statement": "(List.range' 2 40).all (fun n => ((List.range' 2 (n - 2)).all (fun d => n % d != 0)) == ([2,3,5,7,11,13,17,19,23,29,31,37,41].contains n))",
-    "tactic": "decide",
-    "file": "generated.lean",
-    "principle": "The primes",
-    "skill": "number-theory",
-    "lean": "theorem primality_agrees_with_trial_division :\n  (List.range' 2 40).all (fun n =>\n    ((List.range' 2 (n - 2)).all (fun d => n % d != 0)) ==\n    ([2,3,5,7,11,13,17,19,23,29,31,37,41].contains n)) := by decide",
-    "address": "3039fdf6-363d-815a-baf9-8373b7e197b8",
-    "subsumes": [
-      "domain_prime_m_2",
-      "domain_prime_m_3",
-      "domain_prime_m_5",
-      "domain_prime_m_7",
-      "domain_prime_m_11",
-      "domain_prime_m_13",
-      "domain_prime_m_17"
-    ]
-  }
-]

package/src/proof/generated.lean

@@ -1,101 +0,0 @@
-set_option maxRecDepth 100000
-
--- title: Generated at scale
--- wing: the machine
--- prior_art: named
--- prior_art_domain: elementary number theory — the unit group of ℤ/9 and the doubling orbit
--- prior_art_note: the structure underneath is standard and is credited. The doubling orbit
---   1 → 2 → 4 → 8 → 7 → 5 → 1 modulo 9 is the cyclic group generated by 2 in U(9), of order 6 because that
---   is the multiplicative order of 2 mod 9; the units are {1,2,4,5,7,8} and the non-units {0,3,6}. Textbook
---   abstract algebra, and treated directly in the literature on doubling maps modulo odd integers.
---   Bounded, so the credit stops where the earlier work does: what is NOT prior art is the generator that enumerates propositions over this ring and
---   discards the ones true of every sibling; that machinery is this deposit's own.
---   Verification by exhaustion in Lean is this deposit's contribution, and verification is not discovery.
--- prior_art_search: literature search performed 2026-09-05, terms "doubling sequence modulo 9 orbit
---   1 2 4 8 7 5 cyclic group generator digital root"; prior art found and credited.
--- prior_art_pool: bounded
---   quantified ring arithmetic over Z/9; the underlying facts are classical and searchable.
---   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 generator over its own ring
--- Generated by scripts/lean-gen.ts — do not edit by hand; re-run the generator.
--- Each theorem below quantifies over a whole ledger family. Every one is compiled, audited for axioms, and
--- checked to compute what the ledger's own tests compute at every parameter of its family.
-
-namespace Generated
-
--- powsum0_k: 9 ledger rows (params 1, 3, 5, 7, 9, 11, 13, 15, 17) → one quantified theorem
-theorem powsum_zero_odd_exponents :
-  [1, 3, 5, 7, 9, 11, 13, 15, 17].all (fun k =>
-    (([1,2,4,5,7,8].map (fun u => (u ^ k) % 9)).foldl (· + ·) 0) % 9 == 0) := by decide
-
--- the boundary: where the property genuinely fails
-theorem powsum_nonzero_at_even_exponents :
-  ¬ ([2, 4, 6].all (fun k =>
-    (([1,2,4,5,7,8].map (fun u => (u ^ k) % 9)).foldl (· + ·) 0) % 9 == 0)) := by decide
-
--- mulperm_k: 5 ledger rows (params 2, 4, 5, 7, 8) → one quantified theorem
-theorem mulperm_iff_unit_all :
-  (List.range 9).all (fun k =>
-    (((([1,2,4,5,7,8].map (fun u => (k * u) % 9)).eraseDups).length) == 6) ==
-    ([1,2,4,5,7,8].contains k)) := by decide
-
--- the boundary: where the property genuinely fails
-theorem mulperm_fails_at_the_triad :
-  ¬ ([0,3,6].any (fun k =>
-    ((([1,2,4,5,7,8].map (fun u => (k * u) % 9)).eraseDups).length) == 6)) := by decide
-
--- addgen_k: 5 ledger rows (params 2, 4, 5, 7, 8) → one quantified theorem
-theorem addgen_iff_coprime_all :
-  (List.range 9).all (fun k =>
-    ((((List.range 9).map (fun i => (k * i) % 9)).eraseDups).length == 9) ==
-    ([1,2,4,5,7,8].contains k)) := by decide
-
--- hasinv_d: 6 ledger rows (params 1, 2, 4, 5, 7, 8) → one quantified theorem
-theorem hasinv_iff_unit_all :
-  (List.range 9).all (fun d =>
-    ((List.range 9).any (fun e => (d * e) % 9 == 1)) == ([1,2,4,5,7,8].contains d)) := by decide
-
--- demorgan_nary_k: 7 ledger rows (params 2, 3, 4, 5, 6, 7, 8) → one quantified theorem
-theorem demorgan_all_widths :
-  (List.range' 2 7).all (fun k =>
-    (List.range (2 ^ k)).all (fun n =>
-      (!((List.range k).all (fun i => (n >>> i) % 2 == 1))) ==
-      ((List.range k).any (fun i => (n >>> i) % 2 == 0)))) := by decide
-
--- power_sum_k: 5 ledger rows (params 1, 2, 3, 4, 5) → one quantified theorem
-theorem power_sum_closed_forms :
-  (List.range' 1 30).all (fun n =>
-    (((List.range' 1 n).foldl (· + ·) 0) * 2 == n * (n + 1))
-    ∧ (((List.range' 1 n).map (fun i => i * i)).foldl (· + ·) 0) * 6 == n * (n + 1) * (2 * n + 1)) := by decide
-
--- invpow_u: 6 ledger rows (params 1, 2, 4, 5, 7, 8) → one quantified theorem
-theorem invpow_is_fifth_power_all_units :
-  [1,2,4,5,7,8].all (fun u => (u * (u ^ 5)) % 9 == 1) := by decide
-
--- the boundary: where the property genuinely fails
-theorem invpow_fails_off_the_units :
-  ¬ ([3, 6].any (fun t => (List.range 9).any (fun e => (t * e) % 9 == 1))) := by decide
-
--- domain_cyclic_m: 13 ledger rows (params 2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 17, 18) → one quantified theorem
-theorem cyclic_units_have_a_primitive_root :
-  [2,3,5,7,11,13].all (fun p =>
-    (List.range' 1 (p - 1)).any (fun g =>
-      (((List.range' 1 (p - 1)).map (fun k => (g ^ k) % p)).eraseDups).length == p - 1)) := by decide
-
--- decimal_period_of_1_over: 12 ledger rows (params 3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43) → one quantified theorem
-theorem decimal_period_is_the_order_of_ten :
-  [3,7,11,13,17,19,23,29].all (fun p =>
-    ((List.range' 1 (p - 1)).find? (fun k =>
-      ((List.range k).foldl (fun r _ => r * 10 % p) 1) == 1)).getD 0 ==
-    ((List.range' 1 (p - 1)).find? (fun k => (10 ^ k) % p == 1)).getD 0) := by decide
-
--- domain_prime_m: 7 ledger rows (params 2, 3, 5, 7, 11, 13, 17) → one quantified theorem
-theorem primality_agrees_with_trial_division :
-  (List.range' 2 40).all (fun n =>
-    ((List.range' 2 (n - 2)).all (fun d => n % d != 0)) ==
-    ([2,3,5,7,11,13,17,19,23,29,31,37,41].contains n)) := by decide
-
-end Generated