@ceccec/millennium-solutions 0.1.1 → 9.0.4

package/src/millennium/index.ts

@@ -0,0 +1,53 @@
+// THE SEVEN, in problem order — the qualified outlet and the honest bound for each Clay problem this
+// framework has a theorem ADJACENT to. This lived only in theorem/[key].paths.ts, so the collected paper had
+// no way to say which of its theorems sit at the Millennium floor without the bounds being retyped into a
+// second place — and a retyped bound is a bound that can drift from the one the theorem page shows.
+//
+// The `bound` is the load-bearing field. It states what the theorem actually establishes and, explicitly,
+// what it does NOT: none of these is the conjecture, and provenHere = 0.
+export const MILLENNIUM: Record<string, { problem: string; name: string; bound: string; outlet: string; outletName: string; outlet2?: string; outlet2Name?: string }> = {
+  riemann_reflection_and_heart: {
+    problem: 'Riemann Hypothesis',
+    name: "Riemann — the reflection's symmetry and its one computed heart",
+    bound: 'the functional-equation symmetry axis and its ½-analogue centre (the heart, computed as the reflection’s unique fixed point) — not where the ζ-zeros lie',
+    outlet: 'https://www.claymath.org/millennium/riemann-hypothesis/',
+    outletName: 'Clay Mathematics Institute — Riemann Hypothesis' },
+  p_vs_np_inverse_is_unique: {
+    problem: 'P versus NP',
+    name: 'P vs NP — a unique inverse, verification in one step',
+    bound: 'each unit has exactly one inverse (verify in one multiply), non-units none — a cheap-verification fact, not a separation of the classes',
+    outlet: 'https://www.claymath.org/millennium/p-vs-np/',
+    outletName: 'Clay Mathematics Institute — P vs NP' },
+  navier_stokes_flow_is_bounded: {
+    problem: 'Navier–Stokes Existence & Smoothness',
+    name: 'Navier–Stokes — the doubling flow is bounded for all time',
+    bound: 'every iterate stays inside a bounded 6-cycle forever (no blowup) — bounded evolution, not global existence & smoothness',
+    outlet: 'https://www.claymath.org/millennium/navier-stokes-equation/',
+    outletName: 'Clay Mathematics Institute — Navier–Stokes Equation' },
+  yang_mills_spectral_gap: {
+    problem: 'Yang–Mills Existence & Mass Gap',
+    name: 'Yang–Mills — a discrete spectral gap (order exactly 6)',
+    bound: 'the doubling has order exactly 6 — a discrete gap in the cyclic spectrum, not the Yang–Mills mass gap',
+    outlet: 'https://www.claymath.org/millennium/yang-mills-the-maths-gap/',
+    outletName: 'Clay Mathematics Institute — Yang–Mills & the Mass Gap' },
+  hodge_span_is_the_units: {
+    problem: 'Hodge Conjecture',
+    name: 'Hodge — the algebraic span equals the units',
+    bound: 'the doubling span (algebraic generation from 2) is exactly the units, non-units outside — generation/containment, not rational (p,p) ⇒ algebraic',
+    outlet: 'https://www.claymath.org/millennium/hodge-conjecture/',
+    outletName: 'Clay Mathematics Institute — Hodge Conjecture' },
+  birch_swinnerton_dyer_vanishing: {
+    problem: 'Birch and Swinnerton-Dyer Conjecture',
+    name: 'Birch–Swinnerton-Dyer — a computed vanishing mod 9',
+    bound: 'the orbit and the units both sum to 0 mod 9 (27 ≡ 0) — a digit-sum vanishing, not the rank ↔ order-of-vanishing-of-L correspondence',
+    outlet: 'https://www.claymath.org/millennium/birch-and-swinnerton-dyer-conjecture/',
+    outletName: 'Clay Mathematics Institute — Birch and Swinnerton-Dyer Conjecture' },
+  poincare_single_closed_loop: {
+    problem: 'Poincaré Conjecture (resolved)',
+    name: 'Poincaré — one closed loop, no holes',
+    bound: "the sequence closes into a single simple loop of six distinct steps — not the 3-sphere characterization; Poincaré is Perelman's theorem (2003), not proved here",
+    outlet: 'https://www.claymath.org/millennium/poincare-conjecture/',
+    outletName: 'Clay Mathematics Institute — Poincaré Conjecture',
+    outlet2: 'https://arxiv.org/abs/math/0211159',
+    outlet2Name: 'Perelman, G. — The entropy formula for the Ricci flow (arXiv:math/0211159) — the resolution' },
+}

package/src/proof/README.md

@@ -114,4 +114,4 @@ floor** — never a Millennium Problem.
 
 ---
 
-**Author:** Tsvetan Rouschev · **License:** CC BY-NC 4.0
+**Author:** Tsvetan Rouschev · **License:** CC BY-NC-ND 4.0

package/src/proof/address.lean

@@ -0,0 +1,117 @@
+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 := 17
+theorem address_settles_its_range : settledHere = 17 := 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
+
+end Address

package/src/proof/coin.lean

@@ -0,0 +1,148 @@
+-- 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.
+theorem the_digits_are_ten : digits.length = 10 := by decide
+
+end Coin

package/src/proof/covered.json

@@ -0,0 +1,9 @@
+{
+  "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

@@ -0,0 +1,112 @@
+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
+
+end Demand

package/src/proof/demand2.lean

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