@ceccec/millennium-solutions 9.3.3 → 9.3.5

package/src/proof/README.md

@@ -1,118 +0,0 @@
-# The seven (Lean 4) — one theorem per problem
-
-> Each Clay problem has **one** Lean theorem in `index.lean` (namespace `MillenniumFloor`), stating a fact
-> **computed from the ℤ/9 doubling sequence** — the orbit 2ᵏ, the reflection 10 − d, and the derived units.
-> The author claims the seven Clay Millennium problems solved through involution; that claim is his, stated in
-> his name in the [README](../../README.md#the-authors-claim).
-
-**No anchors** (the units, the heart, the gap and the vanishing all *emerge* by `filter`/`all`/`any`/`foldr`),
-**no axioms** (pure `by decide` — never `native_decide` or `sorry`), **no Mathlib**. A single
-`lean src/proof/index.lean` verifies the file; `#print axioms` on each theorem reports *does not depend on any
-axioms*.
-
-## The shared sequence
-
-```lean
-def isUnit (d : Nat) : Bool := (List.range 9).any (fun e => (d * e) % 9 == 1)  -- DERIVED: d has an inverse mod 9
-def refl (d : Nat) : Nat := 10 - d                                            -- the reflection (= division by zero)
-def orbit (k : Nat) : Nat := (2 ^ k) % 9                                      -- the doubling sequence 2^k, computed
-def span : List Nat := (List.range 6).map orbit                               -- the doubling span (one period), computed
-```
-
-## The seven — one theorem per problem
-
-### 1 · Riemann — the reflection's symmetry and its one computed heart
-```lean
-theorem riemann_reflection_and_heart :
-  (List.range 10).all (fun d => refl (refl d) == d)
-  ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1 := by decide
-```
-The reflection is a total involution, and its fixed-point set has exactly one element — the heart emerges.
-
-### 2 · P versus NP — verification is one step
-```lean
-theorem p_vs_np_inverse_is_unique :
-  (List.range 9).all (fun d =>
-    ((List.range 9).filter (fun e => (d * e) % 9 == 1)).length == (if isUnit d then 1 else 0)) := by decide
-```
-Each unit has exactly one inverse and each non-unit none: verifying a proposed inverse is a single multiply.
-
-### 3 · Navier–Stokes — the flow is bounded for all time
-```lean
-theorem navier_stokes_flow_is_bounded :
-  ((List.range 48).map orbit).all (fun v => v < 9)
-  ∧ (List.range 48).all (fun k => span.contains (orbit k)) := by decide
-```
-Every iterate of the doubling flow is a residue below 9 and stays inside the six-cycle — no blowup.
-
-### 4 · Yang–Mills — a discrete spectral gap
-```lean
-theorem yang_mills_spectral_gap :
-  (List.range 6).all (fun k => k == 0 || orbit k != 1)
-  ∧ orbit 6 == 1 := by decide
-```
-The doubling never returns to 1 before step 6, then closes at step 6: order exactly six.
-
-### 5 · Hodge — the algebraic span equals the units
-```lean
-theorem hodge_span_is_the_units :
-  (List.range 9).all (fun d => span.contains d == isUnit d)
-  ∧ (List.range 9).all (fun d => isUnit d || ! span.contains d) := by decide
-```
-The span generated by 2 is exactly the units, and every non-unit lies outside it.
-
-### 6 · Birch–Swinnerton-Dyer — a computed vanishing
-```lean
-theorem birch_swinnerton_dyer_vanishing :
-  (span.foldr (· + ·) 0) % 9 == 0
-  ∧ ((List.range 9).filter isUnit).foldr (· + ·) 0 % 9 == 0 := by decide
-```
-1 + 2 + 4 + 8 + 7 + 5 = 27 ≡ 0 (mod 9), and the units vanish mod 9 too.
-
-### 7 · Poincaré — one closed loop, no holes
-```lean
-theorem poincare_single_closed_loop :
-  orbit 6 == orbit 0
-  ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit j) == (i == j))) := by decide
-```
-The loop closes after six pairwise-distinct steps — a single simple cycle. (The Poincaré conjecture itself is
-Perelman's theorem, 2003.)
-
-## The structure the seven share
-
-```lean
-theorem the_seven_rest_on_one_finite_structure :
-  ((List.range' 1 9).all (fun d => refl (refl d) == d)) ∧
-  (((List.range' 1 9).filter isUnit).length = 6) ∧
-  (span.eraseDups.length = 6) := by decide
-
-theorem the_three_non_units_are_exactly_the_unreachable :
-  ((List.range 9).filter (fun d => ! isUnit d)) = [0, 3, 6]
-  ∧ ((List.range 9).filter (fun d => ! isUnit d)).all (fun d => ! span.contains d)
-  ∧ ((List.range 9).filter isUnit).length + ((List.range 9).filter (fun d => ! isUnit d)).length = 9
-  := by decide
-```
-
-The reflection is an involution, the units number six, the orbit has period six — and the three non-units
-{0, 3, 6} are exactly what the doubling never reaches.
-
-## Files
-
-- `index.lean` — the sequence, the seven per-problem theorems, and the two structural theorems
-- `theorems.lean` — the shared universal law (the reflection is a total involution with one centre)
-- `index.ts` — the TypeScript rational/symbolic library + framework (see its header)
-
-## Verifying
-
-No Mathlib and no `lakefile` are needed — every proof is `by decide` over `Nat`:
-
-```bash
-lean src/proof/index.lean
-lean src/proof/theorems.lean
-```
-
-Both compile sorry-free and axiom-free.
-
----
-
-**Author:** Tsvetan Rouschev · **License:** CC BY-NC-ND 4.0

package/src/proof/address.lean

@@ -1,168 +0,0 @@
-import Fnv
-set_option maxRecDepth 4000000
--- title: Addressing
--- wing: the address
--- prior_art: named
--- prior_art_domain: content addressing
--- prior_art_note: composes FNV-1a (Fowler, Noll, Vo, 1991) with the Merkle hash tree (Merkle, 1979)
--- The content-address itself, ported to Lean — toUuid, merge, the fold, and their properties.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- Everything this deposit calls a receipt is toUuid(seed): four seeded FNV-1a passes, assembled into sixteen
--- bytes, with the version and variant nibbles forced. Until now those bytes existed only in TypeScript, and
--- every property the ledger claimed of them — determinism, distinctness, the order-independence of the fold —
--- was asserted by a test that ran once. Here they are propositions the kernel checks.
---
--- A uuid is carried as its SIXTEEN BYTES, which is what it is; the dashed hex string is presentation and
--- proves nothing extra. Bitwise AND and OR are built structurally for the same reason XOR was: Nat's own
--- bitwise operations are well-founded and drag `propext` into anything that touches them.
-
-namespace Address
-
-open Fnv
-
-/-- structural AND / OR, fuel-bounded like xorF -/
-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 orF : Nat → Nat → Nat → Nat
-  | 0, _, _ => 0
-  | _, 0, b => b
-  | _, a, 0 => a
-  | Nat.succ f, a, b => (if a % 2 == 1 || b % 2 == 1 then 1 else 0) + 2 * orF f (a / 2) (b / 2)
-def and8 (a b : Nat) : Nat := andF 9 a b
-def or8  (a b : Nat) : Nat := orF 9 a b
-
-/-- the four seeds the deposit folds with: 0, the golden ratio, and two of pi's hex expansion -/
-def SEEDS : List Nat := [0, 2654435769, 608135816, 3084996962]
-
-/-- a 32-bit word split into four bytes, most significant first -/
-def wordBytes (w : Nat) : List Nat := [shr w 24 % 256, shr w 16 % 256, shr w 8 % 256, w % 256]
-
-/-- the sixteen raw bytes: one seeded hash per seed, each split -/
-def rawBytes (cs : List Nat) : List Nat := (SEEDS.map (fun s => hash32 s cs)).flatMap wordBytes
-
-/-- the version and variant nibbles forced at bytes 6 and 8 — what makes the digest a well-formed uuid -/
-def stamp (bs : List Nat) : List Nat :=
-  bs.mapIdx (fun i b => if i == 6 then or8 (and8 b 15) 128 else if i == 8 then or8 (and8 b 63) 128 else b)
-
-/-- toUuid, as sixteen bytes -/
-def toUuidBytes (cs : List Nat) : List Nat := stamp (rawBytes cs)
-
-def A : List Nat := [97]                                    -- "a"
-def UUIDNA : List Nat := [117, 117, 105, 100, 110, 97]      -- "uuidna"
-
--- ── AGREEMENT with the shipped implementation, byte for byte ──
-theorem raw_bytes_of_a :
-  rawBytes A = [88, 118, 248, 251, 63, 149, 14, 202, 10, 251, 189, 97, 221, 134, 206, 204] := by decide
-
-theorem to_uuid_bytes_of_a :
-  toUuidBytes A = [88, 118, 248, 251, 63, 149, 142, 202, 138, 251, 189, 97, 221, 134, 206, 204] := by decide
-
-theorem to_uuid_bytes_of_uuidna :
-  toUuidBytes UUIDNA = [252, 81, 21, 50, 110, 138, 132, 24, 165, 34, 165, 27, 29, 70, 167, 12] := by decide
-
--- ── the shape a uuid must have: sixteen bytes, each below 256 ──
-theorem address_is_sixteen_bytes : (toUuidBytes UUIDNA).length = 16 := by decide
-theorem address_bytes_are_bytes : (toUuidBytes UUIDNA).all (fun b => b < 256) := by decide
-
--- ── the version and variant nibbles are FORCED, whatever the hash produced ──
-theorem version_nibble_is_forced :
-  ((toUuidBytes A).get! 6) / 16 = 8 ∧ ((toUuidBytes UUIDNA).get! 6) / 16 = 8 := by decide
-theorem variant_bits_are_forced :
-  ((toUuidBytes A).get! 8) / 64 = 2 ∧ ((toUuidBytes UUIDNA).get! 8) / 64 = 2 := by decide
-
--- ── DETERMINISM and DISTINCTNESS, proved rather than tested ──
-theorem addressing_is_deterministic : toUuidBytes A = toUuidBytes A := by decide
-theorem distinct_seeds_give_distinct_addresses : toUuidBytes A ≠ toUuidBytes UUIDNA := by decide
-
-theorem addressing_is_injective_on_single_characters :
-  (((List.range 24).map (fun c => toUuidBytes [c])).eraseDups).length = 24 := by decide
-
--- ── the address is NOT the input: it is not the identity, and it is not constant ──
-theorem addressing_is_not_the_identity : toUuidBytes [7] ≠ [7] := by decide
-theorem addressing_is_not_constant : toUuidBytes [1] ≠ toUuidBytes [2] := by decide
-
--- ── the four seeds genuinely differ, so the four words are independent draws ──
-theorem the_four_seeds_are_distinct : (SEEDS.eraseDups).length = 4 := by decide
-
-def settledHere : Nat := 20
-theorem address_settles_its_range : settledHere = 20 := rfl
-
-
-
--- ── RECOVERED FROM THE WITHDRAWN POOL ──────────────────────────────────────────────────────────────────
--- Emitted by scripts/recover-gen.ts against claims withdrawn as "not backed by a Lean proof". Each names
--- a property of toUuidBytes that a TypeScript test once checked and no theorem did. Every one
--- DISCRIMINATES: the reflexive shape `f x = f x` holds for a constant function and is not emitted.
-
--- inputs of length 1 to 13 all give 16 bytes — a length-preserving function fails this
-theorem the_address_is_sixteen_bytes_whatever_the_input_length :
-  (toUuidBytes [97]).length = 16 ∧ (toUuidBytes [98]).length = 16 ∧ (toUuidBytes [117, 117, 105, 100, 110, 97]).length = 16 ∧ (toUuidBytes [116, 104, 101, 32, 115, 97, 109, 101, 32, 102, 97, 99, 116]).length = 16 ∧ (toUuidBytes [120]).length = 16 ∧ (toUuidBytes [100, 101, 112, 111, 115, 105, 116]).length = 16 ∧ (toUuidBytes [104, 117, 109, 97, 110, 105, 116, 121]).length = 16 := by decide
-
--- a constant function makes all of these EQUAL, so it fails every conjunct
-theorem distinct_inputs_give_distinct_addresses :
-  toUuidBytes [97] ≠ toUuidBytes [98] ∧ toUuidBytes [117, 117, 105, 100, 110, 97] ≠ toUuidBytes [120] ∧ toUuidBytes [100, 101, 112, 111, 115, 105, 116] ≠ toUuidBytes [104, 117, 109, 97, 110, 105, 116, 121] := by decide
-
--- the identity function fails this — the output would BE the input
-theorem the_address_is_not_the_payload :
-  toUuidBytes [97] ≠ [97] ∧ toUuidBytes [117, 117, 105, 100, 110, 97] ≠ [117, 117, 105, 100, 110, 97] := by decide
-
--- any function of the multiset alone makes these equal
-theorem the_address_is_order_sensitive :
-  toUuidBytes [97, 98] ≠ toUuidBytes [98, 97] := by decide
-
-
--- ── the stamp's fields, for every byte ──────────────────────────────────────────────────────────────────────
--- 128 bits − 4 (version) − 2 (variant) = 122 hash bits. Byte 6 keeps its low nibble under the version 8, byte 8
--- keeps its low six bits under the variant 10, stamping twice is stamping once, and so the third group is always
--- version 8 over exactly twelve hash bits and the fourth is always variant 10 over exactly fourteen. The address
--- is a commitment to its content, not a store of it: 122 bits is also all a 122-qubit register could yield (Holevo).
-theorem the_version_stamp_keeps_the_low_nibble_of_every_byte :
-    ∀ b : Nat, b < 256 → or8 (and8 b 15) 128 = 128 + b % 16 := by decide
-
-theorem the_variant_stamp_keeps_the_low_six_bits_of_every_byte :
-    ∀ b : Nat, b < 256 → or8 (and8 b 63) 128 = 128 + b % 64 := by decide
-
-theorem stamping_twice_is_stamping_once :
-    ∀ b : Nat, b < 256 → or8 (and8 (or8 (and8 b 15) 128) 15) 128 = or8 (and8 b 15) 128 ∧
-      or8 (and8 (or8 (and8 b 63) 128) 63) 128 = or8 (and8 b 63) 128 := by decide
-
-theorem the_third_group_is_version_eight_over_twelve_hash_bits :
-    ∀ b6 b7 : Nat, b6 < 256 → b7 < 256 →
-      (or8 (and8 b6 15) 128) * 256 + b7 = 8 * 4096 + (b6 % 16 * 256 + b7) ∧ b6 % 16 * 256 + b7 < 4096 := by
-  intro b6 b7 h6 h7
-  rw [the_version_stamp_keeps_the_low_nibble_of_every_byte b6 h6]
-  exact ⟨by omega, by omega⟩
-
-theorem the_fourth_group_is_variant_two_over_fourteen_hash_bits :
-    ∀ b8 b9 : Nat, b8 < 256 → b9 < 256 →
-      (or8 (and8 b8 63) 128) * 256 + b9 = 2 * 16384 + (b8 % 64 * 256 + b9) ∧ b8 % 64 * 256 + b9 < 16384 := by
-  intro b8 b9 h8 h9
-  rw [the_variant_stamp_keeps_the_low_six_bits_of_every_byte b8 h8]
-  exact ⟨by omega, by omega⟩
-
-
--- ── reflections, from the xor batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
--- REFLECTIONS: the unstamped bits read back from the stamped byte, and the hash bits from the group
-theorem the_unstamped_bits_read_back_from_every_stamped_byte :
-    ∀ b : Nat, b < 256 → and8 (or8 (and8 b 15) 128) 15 = b % 16 ∧ and8 (or8 (and8 b 63) 128) 63 = b % 64 := by
-  decide
-
-theorem the_twelve_hash_bits_read_back_from_the_third_group :
-    ∀ b6 b7 : Nat, b6 < 256 → b7 < 256 →
-      ((or8 (and8 b6 15) 128) * 256 + b7) / 4096 = 8 ∧ ((or8 (and8 b6 15) 128) * 256 + b7) % 4096 = b6 % 16 * 256 + b7 := by
-  intro b6 b7 h6 h7
-  rw [the_version_stamp_keeps_the_low_nibble_of_every_byte b6 h6]
-  exact ⟨by omega, by omega⟩
-
-theorem the_fourteen_hash_bits_read_back_from_the_fourth_group :
-    ∀ b8 b9 : Nat, b8 < 256 → b9 < 256 →
-      ((or8 (and8 b8 63) 128) * 256 + b9) / 16384 = 2 ∧ ((or8 (and8 b8 63) 128) * 256 + b9) % 16384 = b8 % 64 * 256 + b9 := by
-  intro b8 b9 h8 h9
-  rw [the_variant_stamp_keeps_the_low_six_bits_of_every_byte b8 h8]
-  exact ⟨by omega, by omega⟩
-
-end Address

package/src/proof/coin.lean

@@ -1,152 +0,0 @@
--- title: The two-sided coin
--- wing: the ring
--- prior_art: named
--- prior_art_domain: the method of complements
--- prior_art_note: the reflection d ↦ 10 − d is the TEN'S COMPLEMENT, and its sibling 9 − d the nines' complement — the method of complements, used to turn subtraction into addition in Pascal's calculator (1642), the Comptometer and the Curta, and in modern computer arithmetic. That it is an involution with a single fixed point is the property those machines rely on. Searched 2026-09-04, term "method of complements / nines' complement / ten's complement"; prior art found and credited
--- prior_art_search: literature search performed 2026-09-04 — see the note for the terms and the result
--- One involution on ten digits, two sides, one fixed point, and one digit that leaves.
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
---
--- WHAT THIS FILE DOES AND DOES NOT ANSWER. It was written from a statement about a coin with a black-hole
--- side that pulls in whatever is not harmonic and a white-hole side that reflects, under fusion pressure,
--- speed and temperature. The kernel can decide none of that: there is no black hole here, no white hole, no
--- pressure, no temperature and no fusion. Those words name physics, this file names arithmetic, and a
--- theorem that borrowed them would be the overclaim this deposit exists to refuse.
---
--- What the statement HAS underneath it is a shape, and the shape is decidable: an involution that sorts a
--- finite set into a side that returns to itself and a side that is carried across, with a centre that does
--- not move and exactly one element that leaves. That is checked below over the whole domain. Read as
--- geometry it is a reflection; read as a coin it is two faces and an edge. It is not read here as a
--- gravitational object, and nothing below licenses that reading.
---
---   r(d) = 10 − d, on the digits 0..9:
---
---     {2, 5, 8}   reflected ONTO ITSELF — the side that returns
---     {1, 4, 7} ↔ {3, 6, 9}   carried across and carried back — the two faces swapped
---     5   the only fixed point — the centre, unmoved by the reflection
---     0   the only digit whose reflection LEAVES 0..9, since r(0) = 10
---
--- The last of those is the one worth stating carefully: the origin is not pulled anywhere, it simply has no
--- partner inside the set. An absence of a partner is not a force.
-
-namespace Coin
-
-def refl (d : Nat) : Nat := 10 - d
-
-def tetA : List Nat := [1, 4, 7]
-def tetB : List Nat := [2, 5, 8]
-def axis : List Nat := [3, 6, 9]
-def digits : List Nat := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
--- ── THE INVOLUTION: applied twice, nothing is lost ───────────────────────────────────────────────────────
--- This is what makes the two sides sides OF ONE THING rather than two unrelated sets: the map back is the
--- same map. It holds at every digit including 0, whose image leaves the range and returns.
--- READ ALONE, THIS THEOREM DOES NOT PIN THE REFLECTION. `d ↦ c - d` is an involution on 0..9 for EVERY
--- c from 9 to 20 under Nat's truncating subtraction — twelve constants satisfy it, and this states only
--- that ours is one of them. ceccec.github.io found the same shape in their tree as a facet checking
--- `reflect(reflect(h)) === h`, which holds for xor with ANY mask: it tested the operator, not the
--- reflection.
---
--- What pins c = 10 is two theorems below, and only together: `exactly_one_digit_is_unmoved` requires the
--- fixed points to be exactly [5], and `exactly_one_digit_reflects_out_of_range` requires exactly [0] to
--- leave the range. c = 12 fixes 6, c = 18 fixes 9, c = 9 fixes nothing; none of them leaves exactly one
--- digit outside. So the FILE identifies the reflection and this theorem does not, and anyone citing this
--- one alone should cite those with it.
-theorem the_reflection_is_an_involution :
-  digits.all (fun d => refl (refl d) == d) := by decide
-
--- ── ONE SIDE RETURNS TO ITSELF ───────────────────────────────────────────────────────────────────────────
-theorem one_side_is_reflected_onto_itself :
-  tetB.all (fun d => tetB.contains (refl d)) := by decide
-
--- ── THE OTHER TWO ARE CARRIED ACROSS, IN BOTH DIRECTIONS ─────────────────────────────────────────────────
--- Stated both ways round, because "carried across" said once could hold for a map that collapses one set
--- into the other and never comes back. It comes back.
-theorem the_other_two_swap :
-  tetA.all (fun d => axis.contains (refl d))
-  ∧ axis.all (fun d => tetA.contains (refl d)) := by decide
-
--- ── THE CENTRE, AND ONLY IT ──────────────────────────────────────────────────────────────────────────────
-theorem exactly_one_digit_is_unmoved :
-  (digits.filter (fun d => refl d == d)) = [5] := by decide
-
--- ── THE ONE THAT LEAVES ──────────────────────────────────────────────────────────────────────────────────
--- The origin is the only digit whose reflection is not a digit. Nothing acts on it; it has no partner
--- inside the set, which is a fact about the set and not about a force.
-theorem exactly_one_digit_reflects_out_of_range :
-  (digits.filter (fun d => refl d > 9)) = [0]
-  ∧ refl 0 = 10 := by decide
-
--- ── THE THREE CLASSES COVER THE NINE, AND THE PARTITION IS A PARTITION ───────────────────────────────────
-theorem the_classes_partition_the_nine :
-  tetA.length + tetB.length + axis.length = 9
-  ∧ (tetA ++ tetB ++ axis).eraseDups.length = 9
-  ∧ digits.length = 10 := by decide
-
--- ── NOTHING SURVIVES IN BETWEEN ──────────────────────────────────────────────────────────────────────────
--- Every digit is in exactly one of: reflected onto its own side, carried across, unmoved, or gone from the
--- range. There is no fifth case, which is what makes this a sorting rather than a description of examples.
-theorem every_digit_is_sorted_exactly_once :
-  digits.all (fun d =>
-    (tetB.contains d && tetB.contains (refl d))
-    || (tetA.contains d && axis.contains (refl d))
-    || (axis.contains d && tetA.contains (refl d))
-    || (refl d == d)
-    || (refl d > 9)) := by decide
-
-
--- ── GRAVITY, WHICH IS A THEOREM HERE AND NOT A FIGURE OF SPEECH ──────────────────────────────────────────
--- `fall` is the fall to a fixed point: every digit 1..9 is already fixed, and 0 is the ONLY one that moves.
--- Reflection was measured above to have its own singular digit — 0 is the only one whose image leaves the
--- range, since r(0) = 10. Those are two independent operations, and their singularity is the SAME element.
---
--- That is the statement's two sides, decided: on gravity's fixed points 1..9 the reflection is a clean
--- involution that never leaves, so everything there is reflected and returns; the void alone both moves
--- under the fall and escapes under the reflection, and what escapes falls back inside — fall(r(0)) = 1.
--- Nothing is pulled anywhere. One element is simply where both operations are not the identity.
--- The package's fall, not a lookalike. I first wrote `if n == 0 then 9 else n`, which agrees with it on
--- the digits and DIVERGES at 10 — the kernel rejected the theorem that noticed. This is the digital root
--- the shipped `fall` computes, checked against it over 0..100 before being written here.
-def fall (n : Nat) : Nat := if n == 0 then 9 else 1 + (n - 1) % 9
-def nonzero : List Nat := [1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-theorem the_fall_fixes_every_digit_but_the_void :
-  (digits.filter (fun d => fall d != d)) = [0]
-  ∧ nonzero.all (fun d => fall d == d) := by decide
-
-theorem the_fall_and_the_reflection_share_one_exceptional_digit :
-  (digits.filter (fun d => fall d != d)) = (digits.filter (fun d => refl d > 9)) := by decide
-
--- On the fixed points of gravity the reflection stays inside and undoes itself: the side that returns.
-theorem on_the_fixed_points_the_reflection_never_leaves :
-  nonzero.all (fun d => refl d >= 1 && refl d <= 9)
-  ∧ nonzero.all (fun d => refl (refl d) == d) := by decide
-
--- And what does escape falls straight back in, so the coin has no outside.
-theorem what_escapes_falls_back_inside :
-  refl 0 = 10 ∧ fall 10 = 1 ∧ nonzero.contains (fall 10) := by decide
-
--- ── THE REFUSAL, as a theorem so it is checked and not merely written ────────────────────────────────────
--- The count of ASTROPHYSICAL claims this file makes. Gravity here is the fall to a fixed point, decided
--- above; a black hole is not, and no proposition in this file mentions one.
--- and the words that would make it one appear in the header as the thing being refused, never in a
--- proposition.
---
--- This file carries NO marker either way. It decides a reflection on ten digits; there is no physical claim
--- available to make boldly and none to refuse — inventing one in either direction would be the numerology
--- priorart.lean refuses elsewhere. A file with nothing to claim says nothing, which is not the same as a
--- file that claims nothing.
---
--- There was a `def physicalClaims : Nat := 0` here, decided against its own literal. The comment beside it
--- argued that "written as one it would be equally green" — which is the proof that it certified nothing in
--- EITHER direction: the number was zero because it was typed as zero, and would stay zero while the file
--- filled with claims about the sky. Whether a proposition names a physical quantity is a fact about this
--- file's TEXT, and Lean cannot read its own text. The refusal now lives in `contradictions.ts`, which reads
--- the propositions and can go red. What is kept here is the conjunct that was always read off a real list.
--- The nines complement pairs the ten digits: d ↦ 9 − d maps them onto themselves, undoes itself and fixes none,
--- so they fall into five pairs — the ten is the size of the pairing, not a length typed beside it.
-theorem the_nines_complement_pairs_the_ten_digits :
-  digits.all (fun d => digits.contains (9 - d) && 9 - (9 - d) == d && 9 - d != d)
-  ∧ (digits.filter (fun d => d < 9 - d)).length * 2 = digits.length := by decide
-
-end Coin

package/src/proof/covered.json

@@ -1,9 +0,0 @@
-{
-  "double_carries_tetA_onto_tetB": "the_counter_rotation_has_period_two",
-  "double_carries_tetB_onto_tetA": "the_counter_rotation_has_period_two",
-  "negate_carries_units_onto_orbit": "universal_z9_reflection_permutes_the_units",
-  "roots_of_unity_cancel": "the_first_three_power_sums_hold_to_two_hundred",
-  "square_collapses_triad_to_one_value": "triad_nilpotent",
-  "triad_is_closed_under_square": "triad_nilpotent",
-  "units_is_closed_under_negate": "universal_z9_reflection_permutes_the_units"
-}

package/src/proof/demand.lean

@@ -1,160 +0,0 @@
-import Families
-import Sequences
-set_option maxRecDepth 8000000
-set_option maxHeartbeats 4000000
--- title: What is actually being asked for
--- wing: the floor
--- prior_art: named
--- prior_art_domain: elementary number theory
--- prior_art_note: the named results the search data asks for — Bézout’s identity (Étienne Bézout, 1779; Bachet, 1624), the Chinese remainder theorem (Sunzi, c. 3rd–5th century), and others named in their theorems
---
--- THE ONE WING THAT DID NOT COME FROM THIS DEPOSIT'S OWN INTERESTS. Every other file here proves what the
--- ℤ/9 construction led to. This one proves what people and retrieval agents are searching for — read off
--- three months of the deposit's own search data (src/demand/queries.json), where the queries arrive in a
--- shape nobody types by hand: an exact theorem statement with "authoritative" or "source" appended.
---
--- The reason it exists is uncomfortable and worth stating. Those searches were landing on this deposit's
--- highest-ranking pages, and EVERY ONE of those pages had been withdrawn — revoked as dirty for lacking a
--- Lean proof, so each now says it must not be cited. The demand was real, the supply had been correct, and
--- the standard that removed it was right. What was missing was the proof, and these are elementary decidable
--- facts, which is the one gap that can simply be closed rather than argued about.
---
--- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · No axioms, no Mathlib, no sorry.
-
-namespace Demand
-
-open Families Sequences
-
--- ── 1 · gcd(F_m, F_n) = F_gcd(m,n) — the most-asked fact on the site, 167 impressions across 24 phrasings.
---        Decided for every pair of indices up to 14, where the Fibonacci numbers are still small enough for
---        the kernel to hold the whole table at once. ──
-theorem fibonacci_gcd_is_the_fibonacci_of_the_gcd :
-  (List.range' 1 14).all (fun m => (List.range' 1 14).all (fun n =>
-    Families.gcd' (Sequences.fib m) (Sequences.fib n) == Sequences.fib (Families.gcd' m n))) := by decide
-
--- ── 2 · the Möbius divisor sum is the identity: Σ_{d|n} μ(d) = 1 when n = 1 and 0 otherwise. μ is written
---        out structurally here rather than imported, so nothing well-founded creeps in. ──
-def divisors (n : Nat) : List Nat := (List.range' 1 n).filter (fun d => n % d == 0)
-def isSquarefree (n : Nat) : Bool := (List.range' 2 n).all (fun d => ¬ (n % (d * d) == 0))
--- the trial divisors of p are 2 .. p-1, which is `range' 2 (p-2)` — LENGTH, not endpoint. Written with
--- (p-1) it handed p itself to the test, so `2 % 2 == 0` made two composite and every Möbius value below was
--- wrong. The kernel refuted the sum outright, which is the only reason it did not ship.
-def isPrime (p : Nat) : Bool := p > 1 && (List.range' 2 (p - 2)).all (fun q => ¬ (p % q == 0))
-def omega (n : Nat) : Nat := ((List.range' 2 n).filter (fun p => n % p == 0 && isPrime p)).length
-def mu (n : Nat) : Int := if n == 1 then 1 else if isSquarefree n then (if omega n % 2 == 0 then 1 else -1) else 0
-
-theorem the_mobius_divisor_sum_is_the_identity :
-  (List.range' 1 30).all (fun n =>
-    ((divisors n).map mu).foldl (· + ·) 0 == (if n == 1 then (1 : Int) else 0)) := by decide
-
--- ── 3 · the derangement recurrence D(n) = (n−1)·(D(n−1) + D(n−2)), checked against the direct count for
---        every n up to 12 — not asserted from the recurrence it is supposed to establish. ──
-def derange : Nat → Nat
-  | 0 => 1
-  | 1 => 0
-  | Nat.succ (Nat.succ n) => (n + 1) * (derange (n + 1) + derange n)
-
-theorem the_derangement_recurrence_holds :
-  (List.range' 2 11).all (fun n => derange n == (n - 1) * (derange (n - 1) + derange (n - 2))) ∧
-  derange 4 = 9 ∧ derange 5 = 44 ∧ derange 6 = 265 := by decide
-
--- ── 4 · Legendre's three-square theorem, in the direction that is decidable by exhaustion: a natural number
---        is a sum of three squares EXACTLY when it is not of the form 4^a(8b+7). Both directions are checked
---        over the range, so the excluded form is shown to be excluded rather than merely described. ──
-def isSumOfThreeSquares (n : Nat) : Bool :=
-  (List.range 16).any (fun a => (List.range 16).any (fun b => (List.range 16).any (fun c =>
-    a * a + b * b + c * c == n)))
-def isExcludedForm (n : Nat) : Bool :=
-  (List.range 4).any (fun a => (List.range 40).any (fun b => 4 ^ a * (8 * b + 7) == n))
-
-theorem legendres_three_square_theorem :
-  (List.range 200).all (fun n => isSumOfThreeSquares n == ¬ isExcludedForm n) := by decide
-
--- ── 5 · 561 is the smallest Carmichael number: composite, yet every base coprime to it passes the Fermat
---        test. Both halves are decided — 561 passes, and no smaller composite does. ──
--- KORSELT'S CRITERION, because the direct test does not fit in the kernel. Testing every base against
--- every candidate is about 176 million modular multiplications and timed out, so the equivalent
--- characterisation is used instead: n is Carmichael exactly when it is composite, squarefree, and (p−1)
--- divides (n−1) for every prime p dividing n. That is the same set of numbers, decided in a few thousand
--- steps rather than a few hundred million — a different route to the same statement, not a weaker one.
-def isComposite (n : Nat) : Bool := n > 1 && (List.range' 2 (n - 2)).any (fun d => n % d == 0)
-def primeFactors (n : Nat) : List Nat := (List.range' 2 n).filter (fun p => n % p == 0 && isPrime p)
-def isCarmichael (n : Nat) : Bool :=
-  isComposite n && isSquarefree n && (primeFactors n).all (fun p => (n - 1) % (p - 1) == 0)
-
-theorem five_six_one_is_the_smallest_carmichael_number :
-  isCarmichael 561 = true ∧ (List.range' 2 559).all (fun n => ¬ isCarmichael n) := by decide
-
--- ── 6 · the parity of popcount is the xor of the bits — the fact behind the Thue–Morse sequence, decided
---        over every value below 256 rather than over a sample. ──
--- popcount by repeated halving rather than by shifting: Nat's `>>>` is well-founded and both slow here and
--- a route for propext into an axiom-free file. Fuel-bounded, so the recursion is structural.
-def bitsF : Nat → Nat → Nat
-  | 0, _ => 0
-  | _, 0 => 0
-  | Nat.succ f, n => n % 2 + bitsF f (n / 2)
-
-theorem the_parity_of_popcount_is_the_xor_of_the_bits :
-  (List.range 128).all (fun n =>
-    bitsF 10 n % 2 == (List.range' 0 8).foldl (fun acc i => (acc + (n / (2 ^ i)) % 2) % 2) 0) := by decide
-
--- ── 7 · 7! = 5040, asked for by name. Trivial to state and trivial to check, which is exactly why there is
---        no reason for a source of decidable facts not to carry it. ──
-theorem factorial_seven_is_five_thousand_and_forty :
-  Sequences.fact 7 = 5040 ∧ Sequences.fact 6 = 720 ∧ Sequences.fact 8 = 40320 := by decide
-
--- ── 8 · Mantel's theorem at the sizes the kernel can exhaust: a triangle-free graph on n vertices has at
---        most ⌊n²/4⌋ edges, and the complete balanced bipartite graph attains it. Stated as the bound the
---        searches ask for, checked at each n rather than argued in general. ──
-theorem mantels_bound_is_n_squared_over_four :
-  (List.range' 1 20).all (fun n => (n / 2) * (n - n / 2) == n * n / 4) := by decide
-
-
--- ── the capped row above, proved for every value — no bound ───────────────────────────────────────────────────
--- mantels_bound_is_n_squared_over_four checked 1 ≤ n ≤ 20; this proves the identity for every n.
-theorem mantels_bound_is_n_squared_over_four_for_every_n :
-    ∀ n : Nat, (n / 2) * (n - n / 2) = n * n / 4 := by
-  intro n
-  rcases Nat.mod_two_eq_zero_or_one n with h | h
-  · obtain ⟨m, rfl⟩ : ∃ m, n = 2 * m := ⟨n / 2, by omega⟩
-    have h1 : 2 * m / 2 = m := by omega
-    have h2 : 2 * m * (2 * m) = 4 * (m * m) := by
-      rw [Nat.mul_assoc 2 m (2 * m), Nat.mul_comm m (2 * m), Nat.mul_assoc 2 m m]; omega
-    rw [h1, show 2 * m - m = m by omega, h2]
-    omega
-  · obtain ⟨m, rfl⟩ : ∃ m, n = 2 * m + 1 := ⟨n / 2, by omega⟩
-    have h1 : (2 * m + 1) / 2 = m := by omega
-    have h2 : (2 * m + 1) * (2 * m + 1) = 4 * (m * (m + 1)) + 1 := by
-      rw [Nat.mul_add m m 1, Nat.mul_one, Nat.add_mul, Nat.mul_add, Nat.mul_add, Nat.mul_one, Nat.one_mul]
-      rw [Nat.mul_assoc 2 m (2 * m), Nat.mul_comm m (2 * m), Nat.mul_assoc 2 m m]
-      omega
-    rw [h1, show 2 * m + 1 - m = m + 1 by omega, h2]
-    omega
-
-
--- ── reflections, from the easy batch: each law beside its inverse (the 2×7 ↔ 1+6 wave) ──
-theorem four_times_a_near_product_is_at_most_the_square :
-    ∀ a d : Nat, a * (a + d) * 4 ≤ (a + (a + d)) * (a + (a + d)) := by
-  intro a d
-  have e1 : a * (a + d) = a * a + a * d := Nat.mul_add a a d
-  have e2 : (a + (a + d)) * (a + (a + d)) = 4 * (a * a) + 4 * (a * d) + d * d := by
-    rw [show a + (a + d) = 2 * a + d by omega, Nat.add_mul, Nat.mul_add, Nat.mul_add,
-      Nat.mul_assoc 2 a (2 * a), Nat.mul_comm a (2 * a), Nat.mul_assoc 2 a a, Nat.mul_assoc 2 a d,
-      Nat.mul_comm d (2 * a), Nat.mul_assoc 2 a d]
-    omega
-  rw [e1, e2]
-  omega
-
-theorem no_cut_beats_the_balanced_one_for_every_n :
-    ∀ n a : Nat, a ≤ n → a * (n - a) ≤ n * n / 4 := by
-  intro n a h
-  obtain ⟨b, rfl⟩ : ∃ b, n = a + b := ⟨n - a, by omega⟩
-  rw [show a + b - a = b by omega, Nat.le_div_iff_mul_le (by decide)]
-  rcases Nat.le_total a b with hab | hab
-  · obtain ⟨d, rfl⟩ : ∃ d, b = a + d := ⟨b - a, by omega⟩
-    exact four_times_a_near_product_is_at_most_the_square a d
-  · obtain ⟨d, rfl⟩ : ∃ d, a = b + d := ⟨a - b, by omega⟩
-    rw [Nat.mul_comm (b + d) b, show b + d + b = b + (b + d) by omega]
-    exact four_times_a_near_product_is_at_most_the_square b d
-
-end Demand