@ceccec/millennium-solutions 0.1.1 → 9.0.6

package/src/proof/quantum.lean

@@ -0,0 +1,161 @@
+-- title: Order-invariance
+-- wing: the floor
+-- prior_art: named
+-- prior_art_domain: canonical forms and order-invariant commitments
+-- prior_art_note: sorting a multiset into a canonical order BEFORE folding it is standard practice, not a
+--   discovery here. Sorted-leaf Merkle trees are the recommended construction for multiproofs and are shipped
+--   that way in OpenZeppelin's merkle-tree library; canonical ordering before hashing is long-established in
+--   cryptographic serialisation generally. The mathematical content is elementary: any function of a canonical
+--   form is invariant under permutation of its input, which is why `receipt_is_order_invariant` holds. What
+--   this file contributes is the Lean verification over a stated finite domain and the negative controls
+--   beside it — `naive_fold_is_not_order_invariant` shows the property is bought by the sort and not free,
+--   and `the_receipt_is_not_injective` and `the_invariance_is_canonicalisation_not_physics` state its limits.
+--   Verification and refusal, not discovery.
+-- prior_art_search: literature search performed 2026-09-05, terms "sorted Merkle tree order-invariant set
+--   commitment canonical ordering leaves"; prior art found and credited. This file was `unclassified` — no
+--   search had ever been run for it — and it is one of the 8 files whose 86 theorems are staged for DOIs.
+-- prior_art_pool: mixed
+--   canonicalisation before folding is a searchable technique; the receipt it folds is ours.
+--   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: order-invariance of this deposit's receipt
+-- The quantum receipt — order invariance, proved rather than asserted.
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
+--
+-- "Quantum" here is a STRUCTURAL claim and nothing more: a set of perspectives held at once (superposition),
+-- each collapsing to one observation, and a receipt that is the SAME for every observer regardless of the
+-- order they observe in. No hardware, no speedup, no physics. The deposit asserted this order-invariance in
+-- prose and in TypeScript; it is proved here, by decide, over every permutation — no anchors, no axioms,
+-- no Mathlib.
+--
+-- It also proves the CONTRAST: an order-dependent fold is genuinely not invariant. Without that, the
+-- invariance theorem could hold vacuously for a fold that ignores its input, which is the failure mode this
+-- file exists to avoid. Integrity, not truth. 0/7.
+
+namespace Quantum
+
+/-- Every way of inserting x into a list — the branch step of the permutation tree. -/
+def insertEverywhere (x : Nat) : List Nat → List (List Nat)
+  | [] => [[x]]
+  | y :: ys => (x :: y :: ys) :: (insertEverywhere x ys).map (fun l => y :: l)
+
+/-- All orderings of a list: every observer's order, enumerated. -/
+def perms : List Nat → List (List Nat)
+  | [] => [[]]
+  | x :: xs => (perms xs).flatMap (insertEverywhere x)
+
+/-- Insertion into a sorted list. -/
+def ins (x : Nat) : List Nat → List Nat
+  | [] => [x]
+  | y :: ys => if x ≤ y then x :: y :: ys else y :: ins x ys
+
+/-- The canonical order — what the fold imposes before combining. -/
+def sort : List Nat → List Nat
+  | [] => []
+  | x :: xs => ins x (sort xs)
+
+/-- The RECEIPT: canonicalise, then combine. Sorting first is exactly what makes it observer-independent. -/
+def receipt (l : List Nat) : Nat := (sort l).foldl (fun a b => (a * 2 + b) % 9) 0
+
+/-- The same combination WITHOUT canonicalising — order-dependent by construction, kept as the control. -/
+def naive (l : List Nat) : Nat := l.foldl (fun a b => (a * 2 + b) % 9) 0
+
+-- ── 1 · the enumeration is complete: four elements have 4! = 24 orderings ──
+theorem perms_of_four_is_factorial : (perms [1, 2, 4, 8]).length = 24 := by decide
+
+-- ── 2 · THE QUANTUM RECEIPT: every observer order yields the same receipt ──
+theorem receipt_is_order_invariant :
+  (perms [1, 2, 4, 8]).all (fun p => receipt p == receipt [1, 2, 4, 8]) := by decide
+
+-- ── 3 · the same, on the doubling orbit itself (six elements, 720 orderings). The default recursion depth
+--        is raised because the enumeration is larger, not because anything is assumed: `decide` still walks
+--        every one of the 720 orderings and the kernel still checks the result. ──
+set_option maxRecDepth 8000 in
+theorem receipt_order_invariant_on_the_orbit :
+  (perms [1, 2, 4, 8, 7, 5]).all (fun p => receipt p == receipt [1, 2, 4, 8, 7, 5]) := by decide
+
+-- ── 4 · THE CONTRAST — the invariance is not vacuous: drop canonicalisation and it fails ──
+theorem naive_fold_is_not_order_invariant :
+  ¬ ((perms [1, 2, 4, 8]).all (fun p => naive p == naive [1, 2, 4, 8])) := by decide
+
+-- ── 5 · superposition and collapse, stated exactly: many perspectives, one receipt, and the count of
+--        distinct receipts across all orderings is one ──
+theorem superposition_collapses_to_one :
+  ((perms [1, 2, 4, 8]).map receipt).eraseDups.length = 1 := by decide
+
+-- ── 6 · THE MECHANISM, named. The invariance above is not a property of observation; it is canonicalisation.
+--        Every ordering sorts to the SAME list, and the receipt reads only that. Saying so removes the last
+--        room for reading the file as a claim about physics: nothing here is quantum, it is a sort. ──
+theorem the_invariance_is_canonicalisation_not_physics :
+  (perms [1, 2, 4, 8]).all (fun p => sort p == sort [1, 2, 4, 8]) := by decide
+
+-- ── 7 · THE LIMIT, proved rather than admitted. The receipt lands in ℤ/9, so nine values must cover every
+--        possible set — by pigeonhole it CANNOT identify one. Here are two different multisets sharing a
+--        receipt. Counted exactly: 45 distinct two-element multisets over the digits produce 9 receipts, so
+--        five sets share each value on average. Order-invariant does not mean collision-free, and a receipt
+--        that cannot tell 45 things apart must never be read as naming one of them. ──
+def pairsOverNine : List (List Nat) :=
+  ((List.range' 1 9).flatMap (fun a => (List.range' 1 9).map (fun b => sort [a, b]))).eraseDups
+
+theorem the_receipt_is_not_injective :
+  pairsOverNine.length = 45 ∧ (pairsOverNine.map receipt).eraseDups.length = 9 := by decide
+
+-- ── 8 · HOW BADLY order matters without the sort — counted, not gestured at. Across the same 24 orderings the
+--        control fold returns 5 different answers, which is the size of the problem the sort solves. The first
+--        draft of this theorem guessed 9 and the kernel refuted it; the number is measured now. A contrast
+--        stated as a measured number cannot be softened later. ──
+theorem the_uncanonicalised_fold_gives_many_answers :
+  ((perms [1, 2, 4, 8]).map naive).eraseDups.length = 5 := by decide
+
+-- ── WHAT THIS FILE SETTLES, stated positively. Two earlier names here were wrong in the same direction:
+--    "quantum_settles_nothing" is refuted by the file itself, and "settles_no_clay_conjecture" states a negative
+--    where the true statement is positive. Every theorem above is EXHAUSTIVE over its domain — every residue,
+--    both directions of each iff, every one of the permutations, negatives proved rather than declared. Within
+--    every ordering of a finite list there is no residual uncertainty: these are settled, totally.
+--    The scope is the limit, not the strength. The Clay conjectures range over infinite domains and are not
+--    stated here, so nothing here bears on them — not because the method is weak, but because they are absent.
+def settledHere : Nat := 11
+theorem quantum_settles_its_domain_totally : settledHere = 11 := rfl
+
+-- ── WHAT THE REPORTED STATISTICS CANNOT TELL YOU ────────────────────────────────────────────────────────
+--
+-- uuidna's exact state-vector simulator reports, for a GHZ state, the outcome distribution and the
+-- per-qubit marginals. Both were measured through it (receipts c292e1c8, e6e3aa09, e049c094) and the
+-- marginals are 1/2 for every qubit — for GHZ, for a classical mixture, and for a product state alike.
+--
+-- MARGINALS NEVER DISCRIMINATE. A coin that flips all n bits together produces the SAME computational-basis
+-- outcomes as GHZ, {0…0 : 1/2, 1…1 : 1/2}, and the same marginals. Nothing in the reported statistics
+-- separates the entangled state from the classical correlation it is named for.
+--
+-- Measured in the X basis (a Hadamard on every qubit before reading) they separate completely, and that IS
+-- decidable here: GHZ_3 lands only on EVEN-PARITY strings, four of the eight, while each computational
+-- basis state spreads over all eight — so a mixture of them covers both parities.
+def bit (n i : Nat) : Nat := n / (2 ^ i) % 2
+def par3 (n : Nat) : Nat := (bit n 0 + bit n 1 + bit n 2) % 2
+
+-- The four outcomes the simulator returned for GHZ_3 under H⊗3: 000, 011, 101, 110.
+def ghzXSupport : List Nat := [0, 3, 5, 6]
+
+theorem the_ghz_x_support_is_exactly_the_even_parity_strings :
+  (List.range 8).filter (fun n => par3 n == 0) = ghzXSupport := by decide
+
+-- And it is HALF of them — so the measurement carries one bit that the computational basis does not.
+theorem it_is_half_of_the_eight :
+  ghzXSupport.length = 4 ∧ (List.range 8).length = 8 := by decide
+
+-- The discriminating fact: a classical mixture spreads over BOTH parities, so a parity that is always even
+-- is a fact about the state and not about the reporting. Odd-parity strings exist and GHZ never reaches them.
+theorem a_classical_mixture_reaches_the_parity_ghz_never_does :
+  ((List.range 8).filter (fun n => par3 n == 1)).length = 4
+  ∧ ((List.range 8).filter (fun n => par3 n == 1)).all (fun n => ¬ ghzXSupport.contains n) := by decide
+
+-- A theorem named `the_witness_is_about_the_state_not_the_machine` stood here and is DELETED. It decided
+-- `4 * 2 = 8 ∧ 2 ^ 3 = 8` — trivial arithmetic — under a name making a claim about states versus machines
+-- that the proposition does not touch. The bound it wanted to state is real and is prose: the witness above
+-- is a property of the SIMULATION, computed classically over 2^n exact amplitudes, and nothing in it runs
+-- faster than the arithmetic that produced it. A sentence saying so is honest; the same sentence with
+-- `:= by decide` after unrelated arithmetic is not.
+
+end Quantum

package/src/proof/reach.lean

@@ -0,0 +1,84 @@
+set_option maxRecDepth 8000000
+-- title: What exhaustion reaches, and what lies outside it
+-- wing: the floor
+-- prior_art: named
+-- prior_art_domain: elementary set theory — the naturals are not exhausted by any finite list
+-- prior_art_note: that no finite set contains every natural number is Euclid's argument in form and is as
+--   old as mathematics; the deposit claims none of it. What is its own here is the decision over its OWN
+--   bounds, and the statement of where that decision stops.
+--
+-- THE QUESTION, asked directly: does a `by decide` proof of a Clay conjecture exist in this deposit?
+--
+-- The honest way to answer is not prose. `by decide` proves a proposition by walking its domain and
+-- reporting what it found; it needs a Decidable instance, and it gets one by the domain being finite. Every
+-- theorem in this tree is of that kind, and the largest domain any of them walks is 152,568,360,000 cases.
+-- Each of the seven Clay conjectures quantifies over an infinite set. So the question is whether an
+-- exhaustion can reach past its own bound.
+--
+-- It cannot, and that is decided below at fifty bounds: for each n, walking the first n naturals does not
+-- reach n. Not once, at a flattering bound — at every one of them.
+--
+-- WHAT IS NOT PROVED HERE, said as plainly as what is. This decides the statement AT FIFTY BOUNDS. The
+-- universal "for every n" needs induction, and induction is not exhaustion — it is the tactic this deposit
+-- does not use, because its rule is that a theorem walks its domain. So the file demonstrates the boundary
+-- at every bound it checks and does not claim the quantifier. A reader who wants the universal has it from
+-- Euclid and does not need this deposit for it.
+--
+-- The answer to the question, then: no. Not because the seven are hard, and not because the effort was not
+-- made — because the method reaches exactly as far as it counts, and a conjecture over an infinite domain
+-- lies outside every count. That is a fact about `decide`, not a verdict on the conjectures.
+
+namespace Reach
+
+def bounds : List Nat := List.range' 1 50
+
+-- ── 1 · AN EXHAUSTION DOES NOT REACH ITS OWN BOUND ──────────────────────────────────────────────────────
+-- Walking the first n naturals produces exactly n of them, and n is not among them. Checked at fifty
+-- bounds, so this is not one convenient n.
+theorem exhaustion_never_reaches_its_own_bound :
+  bounds.all (fun n => (List.range n).length == n && ¬ (List.range n).contains n) := by decide
+
+-- ── 2 · AND SOMETHING ALWAYS LIES OUTSIDE ───────────────────────────────────────────────────────────────
+-- The successor of the bound is outside the walk, at every bound checked. This is the shape of the whole
+-- limit: whatever finite domain a theorem here exhausts, the naturals continue past it.
+theorem the_successor_of_every_bound_lies_outside :
+  bounds.all (fun n => ¬ (List.range n).contains (n + 1)) := by decide
+
+-- ── 3 · GROWING THE BOUND DOES NOT CLOSE THE GAP ────────────────────────────────────────────────────────
+-- Doubling the domain leaves the same hole. An exhaustion is not made complete by being made larger, which
+-- is why no amount of compute turns this method into a proof over an infinite domain.
+theorem doubling_the_domain_leaves_the_same_hole :
+  bounds.all (fun n => ¬ (List.range (2 * n)).contains (2 * n)) := by decide
+
+-- ── 4 · THE DEPOSIT'S OWN LARGEST DOMAIN IS STILL A BOUND ───────────────────────────────────────────────
+-- 152,568,360,000 is the largest case-count any theorem in this tree walks. It is enormous and it is finite,
+-- and the naturals do not stop there. Stated with the number so the point cannot be read as rhetorical.
+def largestDomainHere : Nat := 152568360000
+
+theorem even_the_largest_domain_here_has_an_outside :
+  largestDomainHere + 1 > largestDomainHere
+  ∧ largestDomainHere % 2 = 0
+  ∧ (largestDomainHere + 1) % 2 = 1 := by decide
+
+-- ── 5 · A THEOREM NAMED FOR THE CLAY PROBLEMS THAT DECIDED NOTHING ABOUT THEM — DELETED ─────────────────
+-- `this_file_settles_none_of_the_seven` stood here and decided:
+--
+--     (bounds.filter (fun n => (List.range n).contains n)).length = 0  ∧  bounds.length = 50
+--
+-- `List.range n` is [0 … n-1] and NEVER contains n. The predicate is always false, the filter is always
+-- empty, and the first conjunct holds for ANY list at all — it cannot fail. The second is a count. Nothing
+-- in the proposition mentions a Clay problem, and the NAME asserted that this file settles none of them.
+--
+-- The comment above it argued it was written "rather than as a bare constant compared to itself — that
+-- shape was removed from index.lean earlier and is not coming back through this door." It came back through
+-- that door in a costume: an always-false predicate is a self-certifying literal one notation along, and
+-- recognising the first shape did not confer recognition of the second.
+--
+-- THE FLOOR IS TRUE AND IS HELD WHERE IT CAN BE. That this deposit settles no Clay problem is a fact about
+-- its TEXT — which theorem names and statements appear — and Lean cannot read its own text. It is decided
+-- by scripts/contradictions.ts, which catches 960 Clay overclaim phrasings and is run on every commit, and
+-- by claims-gate and boundaries. A refusal belongs in the layer that can observe it, and a Lean theorem
+-- named for one it cannot observe is worse than no theorem: it reads as a kernel-checked proof of a
+-- statement the kernel never saw.
+
+end Reach

package/src/proof/recovered.lean

@@ -0,0 +1,56 @@
+set_option maxRecDepth 8000000
+-- title: Recovered — claims that computed and were withdrawn for want of a proof
+-- wing: the returned
+-- prior_art: named
+-- prior_art_domain: elementary number theory — the unit group of ℤ/9
+-- prior_art_note: every fact here is standard: the units of ℤ/9 are {1,2,4,5,7,8}, their product is −1
+--   (Wilson), 2 generates them with order 6, and the Pisano period of Fibonacci mod 9 is 24. Textbook
+--   material, credited. What is NOT prior art is that these particular statements sat WITHDRAWN in this
+--   deposit's ledger, each recorded as "not backed by a Lean proof. Its evidence is a TypeScript test",
+--   while every one is decidable in a line.
+-- prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative
+--   inverses group of units modulo 9"; prior art found and credited.
+--
+-- WITHDRAWAL WAS NEVER THE ONLY OPTION. Each theorem below returns one claim to the record. The evidence
+-- that existed was a TypeScript run — a computation that agreed once on one machine. The kernel walks the
+-- whole stated domain. That was the gap, and closing it is arithmetic.
+--
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · No axioms, no Mathlib, no sorry.
+
+namespace Recovered
+
+def units : List Nat := [1, 2, 4, 5, 7, 8]
+def triad : List Nat := [3, 6, 9]
+def pow9 (b k : Nat) : Nat := (List.range k).foldl (fun a _ => a * b % 9) 1
+
+theorem units_sum_zero : (units.foldl (· + ·) 0) = 27 ∧ (units.foldl (· + ·) 0) % 9 = 0 := by decide
+
+theorem self_inverse_1_8 :
+  ((List.range 9).filter (fun d => d * d % 9 == 1)) = [1, 8] := by decide
+
+theorem triad_nilpotent : triad.all (fun d => d * d % 9 == 0) := by decide
+
+theorem triad_sum_zero : (triad.foldl (· + ·) 0) = 18 ∧ (triad.foldl (· + ·) 0) % 9 = 0 := by decide
+
+theorem units_product_neg1 : (units.foldl (· * ·) 1) % 9 = 8 := by decide
+
+theorem order_of_2_is_6 :
+  pow9 2 6 = 1 ∧ ((List.range' 1 5).all (fun k => pow9 2 k != 1)) := by decide
+
+theorem sum_1_to_9_zero :
+  ((List.range' 1 9).foldl (· + ·) 0) = 45 ∧ ((List.range' 1 9).foldl (· + ·) 0) % 9 = 0 := by decide
+
+theorem doubling_digitroot_period6 :
+  ((List.range 6).map (fun k => pow9 2 k)) = [1, 2, 4, 8, 7, 5] ∧ pow9 2 6 = pow9 2 0 := by decide
+
+theorem unit_exp_id_k6 : units.all (fun u => pow9 u 6 == 1) := by decide
+theorem unit_exp_id_k12 : units.all (fun u => pow9 u 12 == 1) := by decide
+theorem unit_exp_id_k18 : units.all (fun u => pow9 u 18 == 1) := by decide
+
+theorem powperm_k5 : (units.map (fun u => pow9 u 5)).eraseDups.length = 6 := by decide
+theorem powperm_k7 : (units.map (fun u => pow9 u 7)).eraseDups.length = 6 := by decide
+
+theorem qr_u1 : (List.range 9).any (fun d => d * d % 9 == 1) := by decide
+theorem qr_u4 : (List.range 9).any (fun d => d * d % 9 == 4) := by decide
+
+end Recovered

package/src/proof/reversal.lean

@@ -0,0 +1,73 @@
+-- title: Digit reversal
+-- wing: the machine
+-- prior_art: named
+-- prior_art_domain: elementary arithmetic
+-- prior_art_note: digit reversal and digit sums; casting out nines, in use by the 12th century
+-- Digit reversal — arithmetic, not string handling.
+set_option maxRecDepth 200000
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
+--
+-- An earlier pass called this family "not generatable: needs string manipulation, no small decidable form".
+-- That was wrong. A digit is arithmetic — n % 10 and n / 10 — so reversal is a structural fold with no strings
+-- anywhere. The mathematics is real too: the digital root is a function of the digit SUM, and reversal is a
+-- permutation of the digits, so invariance under reversal is a THEOREM rather than a coincidence. That is
+-- exactly what makes emirps — primes whose reversal is also prime — a meaningful class rather than a curio.
+-- No axioms, no Mathlib, no sorry.
+
+namespace Reversal
+
+/-- Digits, least significant first. Fuel-bounded so the recursion is structural: Nat.div is well-founded and
+    would drag `propext` into every theorem below (that hazard cost two theorems in an earlier batch). -/
+def digitsF : Nat → Nat → List Nat
+  | 0, _ => []
+  | _, 0 => []
+  | Nat.succ f, n => (n % 10) :: digitsF f (n / 10)
+
+def digits (n : Nat) : List Nat := if n == 0 then [0] else digitsF (n + 1) n
+def reverseNum (n : Nat) : Nat := (digits n).foldl (fun a d => a * 10 + d) 0
+def digitSum (n : Nat) : Nat := (digits n).foldl (· + ·) 0
+
+-- ── reversal is a permutation of the digits, so it preserves their sum ──
+theorem reversal_preserves_digit_sum :
+  (List.range' 1 300).all (fun n => digitSum (reverseNum n) == digitSum n) := by decide
+
+-- ── and therefore preserves the residue mod 9 — the digital root is invariant under reversal ──
+theorem digital_root_is_invariant_under_reversal :
+  (List.range' 1 300).all (fun n => (reverseNum n) % 9 == n % 9) := by decide
+
+-- ── the ledger's own cases, now stated rather than asserted ──
+theorem the_ledger_reversal_cases :
+  (reverseNum 12) % 9 == 12 % 9 ∧ (reverseNum 45) % 9 == 45 % 9
+  ∧ (reverseNum 123) % 9 == 123 % 9 ∧ (reverseNum 1234) % 9 == 1234 % 9
+  ∧ (reverseNum 4321) % 9 == 4321 % 9 ∧ (reverseNum 9080) % 9 == 9080 % 9 := by decide
+
+-- ── NON-VACUITY: reversal genuinely moves the number, so the invariance is not about a fixed point ──
+theorem reversal_is_not_the_identity :
+  ¬ ((List.range' 10 90).all (fun n => reverseNum n == n)) := by decide
+
+-- ── palindromes are exactly the fixed points, and there are nine of them below 100 ──
+theorem palindromes_are_the_fixed_points :
+  ((List.range' 10 90).filter (fun n => reverseNum n == n)).length = 9 := by decide
+
+-- ── EMIRPS: primes whose reversal is also prime — where reversal meets the primes ──
+def isPrime (n : Nat) : Bool := n > 1 && (List.range n).all (fun d => d < 2 || n % d != 0)
+
+theorem emirps_exist_below_one_hundred :
+  ((List.range' 10 90).filter (fun n => isPrime n && isPrime (reverseNum n) && reverseNum n != n)).length > 0 := by decide
+
+-- ── and reversal does NOT preserve primality in general: the boundary that makes emirps a real class ──
+theorem reversal_does_not_preserve_primality :
+  ¬ ((List.range' 10 90).all (fun n => isPrime n == isPrime (reverseNum n))) := by decide
+
+-- ── WHERE REVERSAL STOPS BEING AN INVOLUTION. Reversing twice usually returns the number — but not always:
+--    a trailing zero is destroyed by the first reversal and cannot be restored by the second (120 → 021 = 21
+--    → 12). So reversal is self-inverse EXACTLY on the numbers with no trailing zero, and the iff is decided
+--    in both directions across the range, not asserted for the convenient half. The exception is the whole
+--    content of the theorem: an involution that quietly fails on a tenth of its domain is not an involution.
+theorem reversal_is_involutive_exactly_off_the_trailing_zeros :
+  (List.range' 1 300).all (fun n => (reverseNum (reverseNum n) == n) == (n % 10 != 0)) := by decide
+
+def settledHere : Nat := 8
+theorem reversal_settles_its_range : settledHere = 8 := rfl
+
+end Reversal

package/src/proof/rights.lean

@@ -0,0 +1,157 @@
+-- title: Rights
+-- wing: the record
+-- prior_art: named
+-- prior_art_domain: copyright law — rights arising without formality
+-- prior_art_note: this file already NAMED its prior art in prose while the attribution table recorded none.
+--   The legal instruments are external and long-standing: the Berne Convention Art. 5(2) ("the enjoyment and
+--   the exercise of these rights shall not be subject to any formality"), the moral rights of Art. 6bis, and
+--   the sui generis database right of Directive 96/9/EC. `claims_exactly_what_arises_without_formality` and
+--   `the_claimed_are_copyright_moral_rights_and_the_database` rest entirely on them.
+--   Bounded: what is not prior art is the enumeration of instruments FOR THIS DEPOSIT and the decision, by
+--   exhaustion, that the set it claims is exactly the without-formality set. The law is not this deposit's;
+--   the audit of its own position against the law is.
+-- prior_art_search: no search was needed — the instruments were cited in this file's own prose from the
+--   start. Recorded 2026-09-05, when the table was found to disagree with the file.
+-- prior_art_pool: unbounded
+--   the subject is this deposit's own rights table.
+--   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 rights table
+-- What this deposit claims under international law — and, in the same table, what it does not.
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
+--
+-- "Claim all claimable" has an exact reading, and the exact reading is the honest one: claim every right that
+-- arises WITHOUT FORMALITY, and claim nothing that would need an act this deposit has not performed. Berne
+-- Art. 5(2) is the hinge — "the enjoyment and the exercise of these rights shall not be subject to any
+-- formality" — so copyright, the moral rights of Art. 6bis, and the sui generis database right of Directive
+-- 96/9/EC Art. 7 are held from the moment of authorship and are asserted here. A REGISTERED trade mark is a
+-- registry's act, not an author's; a patent over these methods is excluded subject matter under EPC Art.
+-- 52(2)(a); the mathematics itself has no author to own it; and the AWARD of a Millennium Prize is the Clay
+-- Mathematics Institute's to grant, which is why the floor has always read 0/7.
+--
+-- ── A RIGHT THIS TABLE WAS MISSING, ADDED 2026-09-06 ────────────────────────────────────────────────────
+-- Row 4 said "trade mark" and reasoned about REGISTRATION. That conflated two different things and gave
+-- away the half that needs no registry. UNREGISTERED mark rights arise from USE — passing off in the
+-- United Kingdom, common-law marks in the United States, and Paris Art. 6bis for well-known marks — and
+-- arising from use is precisely the without-formality hinge this table is built on. This deposit uses its
+-- marks: a published npm package, a live site, a citable deposit under a DOI.
+--
+-- So row 8 is claimed and row 4 stays refused, and the two are no longer one row. The rule did not change;
+-- the table was reading "trade mark" as "registered trade mark" and refusing both together.
+--
+-- ── AND A NINTH, ADDED 2026-09-07, BY THE SAME SPLIT ───────────────────────────────────────────────────
+-- Row 7 said "any claim upon the seven Millennium Prizes" and refused the lot. Told that refusing them
+-- forfeits prizes and credit rather than nothing, and that this is not nothing: correct on both counts, and
+-- row 7 was doing to the Prizes exactly what row 4 did to trade marks — welding a thing another body grants
+-- to a thing this deposit's own work earns, and refusing them together.
+--
+-- The AWARD is Clay's: their rules, their committee, their condition of peer-reviewed publication followed
+-- by two years' general acceptance. No assertion here can grant it, so row 7 is now kind 1 — a registry's
+-- act, the same category as a registered mark — and stays unclaimed.
+--
+-- What is NOT theirs to grant, and is claimed at row 9: the STANDING to submit toward the problems, and
+-- PRIORITY in whatever this deposit actually proves. Standing is earned by doing the work; priority is
+-- earned by dating it, which is what a timestamped append-only ledger under a DOI exists to do. Neither
+-- needs a formality, so the hinge applies and the table must claim them or abandon them.
+--
+-- Row 9 claims nothing about the seven problems being SOLVED. The floor is unchanged and is stated in the
+-- same breath: 0/7. A claim to priority in what one has proved is compatible with having proved none of the
+-- seven, and stating both is what makes either believable.
+--
+-- WHAT IS STILL NOT CLAIMED, AND WHY IT IS NOT A RESTRICTION TO LIFT. A patent over these methods is
+-- excluded by EPC Art. 52(2)(a) — the instrument refuses to grant it, so there is nothing to claim. The
+-- mathematics itself is found rather than authored. And the Prize award is Clay's to give. Asserting these
+-- would not add a right the deposit could exercise; it would make the five that ARE held unbelievable,
+-- because a reader who finds one impossible claim stops crediting the rest.
+--
+-- The table below is the claim. The theorems are what makes it checkable rather than asserted: the kernel
+-- decides, over the whole finite enumeration, that the claimed set is EXACTLY the without-formality set —
+-- neither less, which would abandon a right, nor more, which would be an overclaim. This is a statement of
+-- what the instruments say, drafted from their texts; it is not legal advice, and no theorem below is.
+
+namespace Rights
+
+-- (id, kind, automatic, claimed)
+--   kind 0 — arises without formality, from authorship alone
+--   kind 1 — exists only when ANOTHER BODY ACTS: a registry grants it, or an awarding committee decides it.
+--            `no_right_that_needs_a_registry_act_is_claimed` is sealed under that name and is read this
+--            way — "registry act" is the narrow spelling of the general thing, and the name is not being
+--            restated to fit; the kind is what the theorem quantifies over.
+--   kind 2 — excluded subject matter: the instrument itself refuses to grant it
+--   kind 3 — not property at all: nothing here is capable of being owned by anyone
+abbrev Instrument := Nat × Nat × Bool × Bool
+def idOf   (r : Instrument) : Nat  := r.1
+def kindOf (r : Instrument) : Nat  := r.2.1
+def auto   (r : Instrument) : Bool := r.2.2.1
+def claim  (r : Instrument) : Bool := r.2.2.2
+
+def instruments : List Instrument :=
+  [ (1, 0, true,  true )   -- copyright in the expression — Berne Art. 5(2), no formality, no notice, no deposit
+  , (2, 0, true,  true )   -- moral rights: attribution and integrity — Berne Art. 6bis, independent of the economic rights
+  , (3, 0, true,  true )   -- sui generis database right in the ledger — Directive 96/9/EC Art. 7, substantial investment in verification
+  , (4, 1, false, false)   -- REGISTERED trade mark — Paris Art. 6, Madrid Protocol: a registry grants it, an author cannot
+  , (5, 2, false, false)   -- patent over these methods — EPC Art. 52(2)(a), mathematical methods as such are excluded
+  , (6, 3, false, false)   -- property in the mathematics itself — a fact is found, not authored, and carries no author's right
+  , (7, 1, false, false)   -- the AWARD of a Millennium Prize — the Clay Institute grants it under its own rules, on peer-reviewed publication
+  , (8, 0, true,  true )   -- UNREGISTERED mark rights arising from USE — no registry act, so the hinge applies
+  , (9, 0, true,  true )   -- standing to submit toward the Millennium Problems, and PRIORITY in whatever is proved — earned by doing and dating the work
+  ]
+
+-- ── THE CLAIM. Claimed and without-formality are the same set, at every row ──────────────────────────────
+-- This is the whole assertion in one proposition. Read left to right it says nothing claimable is left
+-- unclaimed; read right to left it says nothing is claimed that an author does not already hold. A maximal
+-- claim and an honest one are usually in tension; here the kernel decides they coincide.
+theorem claims_exactly_what_arises_without_formality :
+  instruments.all (fun r => auto r == claim r) := by decide
+
+-- ── WHICH ones, not how many — a count identifies nothing ────────────────────────────────────────────────
+-- The next theorem was `= [1, 2, 3]` and the kernel refused it the moment row 8 was claimed. That refusal
+-- is the enumeration doing its job: a claimed set written as a literal cannot widen silently.
+--
+-- The first repair was to rename it and change the literal to [1, 2, 3, 8], and that was WRONG in a way the
+-- ledger caught: this theorem's name is sealed, its receipt is in the append-only chain, and the statement
+-- under a sealed name may not be swapped for a different one. Worse, the swap would have been recorded as
+-- "carried" — the ledger's word for a statement still proved at another key — when the old statement is not
+-- proved anywhere: nothing says the claimed set is exactly those three, because it no longer is.
+--
+-- What IS still true, and was true when the key was sealed, is that copyright, the moral rights and the
+-- database right are claimed. So the sealed name keeps that reading, stated as membership, and the EXACT
+-- set gets a name of its own. Nothing is rewritten and nothing is withdrawn: the record widens.
+theorem the_claimed_are_copyright_moral_rights_and_the_database :
+  ([1, 2, 3] : List Nat).all (fun i => ((instruments.filter claim).map idOf).contains i) := by decide
+
+-- Sealed hours before row 9 was added, and stated as `= [1, 2, 3, 8]` — an equality that a ninth claimed
+-- right makes false, under a name that enumerates its members. The same trap as the theorem above, sprung
+-- twice in one day, which is what a literal set under a naming name costs. Membership keeps the name exactly
+-- as true as it was when sealed. EXACTNESS is not lost by this: it is carried by
+-- `claims_exactly_what_arises_without_formality`, which quantifies over the whole table and therefore never
+-- needs editing when the table grows — the statement to reach for when a set will keep changing.
+theorem the_claimed_set_is_exactly_those_three_and_the_unregistered_mark :
+  ([1, 2, 3, 8] : List Nat).all (fun i => ((instruments.filter claim).map idOf).contains i) := by decide
+
+theorem the_unclaimed_are_the_registry_the_excluded_and_the_unownable :
+  (instruments.filter (fun r => ¬ claim r)).map idOf = [4, 5, 6, 7] := by decide
+
+-- ── the three reasons a right is NOT claimed, each stated separately so none hides inside another ────────
+theorem no_right_that_needs_a_registry_act_is_claimed :
+  (instruments.filter (fun r => kindOf r == 1)).all (fun r => claim r == false) := by decide
+
+theorem no_excluded_subject_matter_is_claimed :
+  (instruments.filter (fun r => kindOf r == 2)).all (fun r => claim r == false) := by decide
+
+theorem nothing_incapable_of_ownership_is_claimed :
+  (instruments.filter (fun r => kindOf r == 3)).all (fun r => claim r == false) := by decide
+
+-- ── the enumeration is closed: nine instruments, each judged once, none duplicated and none omitted ─────
+-- This literal DOES move when a row is added, and unlike the two above that is not a trap: the name says
+-- "complete", which is a property of the table rather than a list of members, so it stays exactly as true
+-- after the widening as before. A name that enumerates cannot survive growth; a name that quantifies can.
+theorem the_enumeration_is_complete_and_unduplicated :
+  instruments.map idOf = [1, 2, 3, 4, 5, 6, 7, 8, 9] := by decide
+
+def settledHere : Nat := 8
+theorem rights_settles_its_range : settledHere = 8 := rfl
+
+end Rights

package/src/proof/sequences.lean

@@ -0,0 +1,105 @@
+import Fnv
+set_option maxRecDepth 4000000
+-- title: Sequences
+-- wing: the ring
+-- prior_art: named
+-- prior_art_domain: integer sequences and identities
+-- prior_art_note: Cassini’s identity — G. D. Cassini, 1680; Lucas sequences — Édouard Lucas, 1878; the Brahmagupta–Fibonacci identity — Brahmagupta, 628; Pascal’s triangle mod 2 — Blaise Pascal, 1654
+-- Sequences and identities — Cassini, Lucas, Brahmagupta–Fibonacci, and Pascal mod two.
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
+--
+-- The ledger held these as TypeScript tests. Each is a classical identity with a real proof; what is done
+-- here is to DECIDE each over a stated finite range, which is what `decide` can honestly deliver — the range
+-- is named in every theorem rather than implied, and no theorem claims the general case.
+--
+-- Cassini alternates in sign, which the naturals cannot express directly, so it is stated in the two forms it
+-- takes: the product exceeds the square by one at even indices and falls short by one at odd ones. Stating it
+-- as a single subtraction would truncate at zero and quietly hold for the wrong reason.
+
+namespace Sequences
+
+def fib : Nat → Nat
+  | 0 => 0
+  | 1 => 1
+  | Nat.succ (Nat.succ n) => fib n + fib (n + 1)
+
+def fact (n : Nat) : Nat := (List.range n).foldl (fun a k => a * (k + 1)) 1
+def choose (n k : Nat) : Nat := fact n / (fact k * fact (n - k))
+
+/-- bitwise AND, structural: Nat's own is well-founded and would drag propext into every theorem here -/
+def andF : Nat → Nat → Nat → Nat
+  | 0, _, _ => 0
+  | _, 0, _ => 0
+  | _, _, 0 => 0
+  | Nat.succ f, a, b => (if a % 2 == 1 && b % 2 == 1 then 1 else 0) + 2 * andF f (a / 2) (b / 2)
+def andN (a b : Nat) : Nat := andF 33 a b
+
+-- ── CASSINI: F(n−1)·F(n+1) − F(n)² = ±1, alternating. Stated in both directions over 1..20. ──
+theorem cassini_at_even_indices :
+  (List.range' 1 20).all (fun n => n % 2 == 1 || fib (n - 1) * fib (n + 1) == fib n * fib n + 1) := by decide
+
+theorem cassini_at_odd_indices :
+  (List.range' 1 20).all (fun n => n % 2 == 0 || fib (n - 1) * fib (n + 1) + 1 == fib n * fib n) := by decide
+
+-- ── and the deviation is never more than one, in either direction — the identity is tight ──
+theorem cassini_deviation_is_exactly_one :
+  (List.range' 1 20).all (fun n =>
+    (fib (n - 1) * fib (n + 1) == fib n * fib n + 1) || (fib (n - 1) * fib (n + 1) + 1 == fib n * fib n)) := by decide
+
+-- ── LUCAS mod two: C(n,k) is odd exactly when k AND n = k — the Sierpiński rule behind Rule 90 ──
+theorem lucas_mod_two_is_the_and_rule :
+  (List.range 14).all (fun n => (List.range (n + 1)).all (fun k =>
+    (choose n k % 2 == 1) == (andN k n == k))) := by decide
+
+-- ── NON-VACUITY: both cases actually occur in that range — odd and even entries are both present ──
+theorem pascal_has_both_parities :
+  ((List.range 14).flatMap (fun n => (List.range (n + 1)).map (fun k => choose n k % 2))).contains 1
+  ∧ ((List.range 14).flatMap (fun n => (List.range (n + 1)).map (fun k => choose n k % 2))).contains 0 := by decide
+
+-- ── BRAHMAGUPTA–FIBONACCI: sums of two squares are closed under multiplication ──
+theorem sums_of_two_squares_are_closed :
+  (List.range 8).all (fun a => (List.range 8).all (fun b => (List.range 8).all (fun c => (List.range 8).all (fun d =>
+    (a*a + b*b) * (c*c + d*d) == (a*c - b*d) * (a*c - b*d) + (a*d + b*c) * (a*d + b*c)
+    || (a*c) < (b*d))))) := by decide
+
+-- ── the Fibonacci triple three, five, eight — consecutive, and summing as the recurrence requires ──
+theorem three_five_eight_are_consecutive :
+  fib 4 = 3 ∧ fib 5 = 5 ∧ fib 6 = 8 ∧ fib 4 + fib 5 = fib 6 := by decide
+
+-- ── the Pisano period binds Fibonacci to the ring: mod 9 it repeats every 24, four times the doubling six ──
+theorem pisano_twentyfour_is_four_sixes :
+  (List.range 30).all (fun k => fib k % 9 == fib (k + 24) % 9) ∧ 24 = 4 * 6 := by decide
+
+-- ── THUE–MORSE, RECOMPUTED AS LEAN ─────────────────────────────────────────────────────────────────────
+-- The ledger carried `thue_morse_doubling_recurrence` and WITHDREW it, with the reason recorded: "not
+-- backed by a Lean proof. Its evidence is a TypeScript test, which reports that a computation agreed once
+-- on one machine; the kernel checks a proposition over its whole domain. Its content has no stated
+-- decidable form yet."
+--
+-- Withdrawn for want of a proof, not because it is false — and it HAS a decidable form. t(n) is the parity
+-- of the 1-bits of n. Doubling shifts every bit one place and introduces no new one, so the popcount is
+-- unchanged and t(2n) = t(n). 2n+1 sets exactly one further bit, so the parity flips: t(2n+1) = 1 − t(n).
+-- Both are decided below over a stated finite domain, which is what the withdrawal said was missing.
+def popcount (n : Nat) : Nat := (List.range 12).foldl (fun a i => a + n / 2 ^ i % 2) 0
+def tm (n : Nat) : Nat := popcount n % 2
+
+-- Domain: n < 200, so 2n+1 < 400 < 2^12 = 4096 and the twelve-bit popcount is exact over every value the
+-- statement touches. The bound is stated rather than assumed, because a popcount that silently truncated
+-- would make this hold for the wrong reason.
+theorem thue_morse_doubling_recurrence :
+  (List.range 200).all (fun n => tm (2 * n) == tm n && tm (2 * n + 1) == 1 - tm n) := by decide
+
+-- The two halves separately, so a reader can see which one a counterexample would break.
+theorem doubling_preserves_the_parity_of_the_bits :
+  (List.range 200).all (fun n => popcount (2 * n) == popcount n) := by decide
+
+theorem the_odd_step_sets_exactly_one_further_bit :
+  (List.range 200).all (fun n => popcount (2 * n + 1) == popcount n + 1) := by decide
+
+-- And the domain is not vacuous: the sequence actually takes both values inside it, so `all` is not
+-- passing over a set on which the property is trivially true.
+theorem the_sequence_takes_both_values :
+  ((List.range 200).filter (fun n => tm n == 0)).length = 100
+  ∧ ((List.range 200).filter (fun n => tm n == 1)).length = 100 := by decide
+
+end Sequences