@ceccec/millennium-solutions 0.1.1 → 9.0.6

package/src/proof/speed.lean

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

package/src/proof/split.lean

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

package/src/proof/theorems.lean

@@ -1,5 +1,11 @@
+-- title: Theorems
+-- wing: the machine
+-- prior_art: named
+-- prior_art_domain: the method of complements
+-- prior_art_note: the universal reflection here is the same ten's complement d ↦ 10 − d as coin.lean, with its centre and its pairs summing to ten. Method of complements, long prior to this deposit. Searched 2026-09-04
+-- prior_art_search: literature search performed 2026-09-04 — see the note for the terms and the result
 -- The universal property — honestly, and COMPUTED from the sequence.
--- Author: Tsvetan Rouschev · License: CC BY-NC 4.0
+-- Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0
 --
 -- The earlier `all_alpha_squared_one` asserted that the seven statements "share α² = 1" — a vacuity (1² = 1
 -- copy-pasted). What the seven ACTUALLY share is the reflection: an involution the sequence computes, with one
@@ -17,4 +23,45 @@ theorem universal_reflection_involution :
   ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1          -- exactly ONE shared centre (the heart), computed
   := by decide
 
+-- ── the centre, NAMED rather than counted ──
+-- The theorem above proves there is exactly ONE centre. A count is not an identification: it says a heart
+-- exists without saying where it beats. Here it is, computed — the filter returns the singleton [5].
+theorem universal_centre_is_five :
+  ((List.range 10).filter (fun d => refl d == d)) = [5] := by decide
+
+-- ── what the reflection conserves ──
+-- Every residue and its reflection sum to ten. This is the reason there is exactly one centre: a fixed point
+-- needs d + d = 10, and 10 is even, so exactly one d satisfies it. The conservation law is the whole structure.
+theorem universal_pairs_sum_to_ten :
+  (List.range 11).all (fun d => d + refl d == 10) := by decide
+
+-- ── the reflection is a bijection of the domain, computed as an ordering ──
+-- Stronger than the involution and cheaper than a permutation argument: the image of 0…10 under the
+-- reflection IS 0…10 read backwards. Nothing is lost and nothing is repeated, and the witness is an equation.
+theorem universal_reflection_reverses_the_domain :
+  (List.range 11).map refl = (List.range 11).reverse := by decide
+
+-- ── WHERE IT STOPS. The involution is not universal over ℕ, and the boundary is stated, not hidden ──
+-- Natural subtraction truncates: above ten, `refl d` is 0 and `refl (refl d)` is 10 for every input. So the
+-- involution holds on 0…10 and FAILS at every residue above it. The first theorem says `List.range 11` and
+-- means it. A boundary you can compute is a boundary you have not overclaimed past.
+theorem universal_reflection_is_not_an_involution_above_ten :
+  ((List.range 10).map (fun k => k + 11)).all (fun d => ¬ (refl (refl d) == d)) := by decide
+
+-- ── the vortex has its OWN reflection, and it is a different map ──
+-- ℤ/9 reflects by d ↦ (9 − d) mod 9. That map permutes the six units among themselves. The millennium
+-- reflection does NOT stay inside them: it sends the unit 1 to 9, which is not a unit. Two reflections, two domains.
+theorem universal_z9_reflection_permutes_the_units :
+  ([1, 2, 4, 5, 7, 8].map (fun d => (9 - d) % 9)) = [8, 7, 5, 4, 2, 1] := by decide
+
+theorem universal_millennium_reflection_escapes_the_units :
+  ¬ ([1, 2, 4, 5, 7, 8].all (fun u => [1, 2, 4, 5, 7, 8].contains (refl u))) := by decide
+
+-- ── and yet they are the SAME map, shifted by one ──
+-- This is what the singleton family was standing on alone. Reduced mod nine, the millennium reflection is the
+-- vortex reflection plus one, at every residue 0…9. The shared structure the seven framings borrow is not a
+-- separate object: it is ℤ/9's own involution, displaced by a single step. Still not a proof of any conjecture.
+theorem universal_reflection_is_the_vortex_reflection_shifted :
+  (List.range 10).all (fun d => (10 - d) % 9 == ((9 - d) % 9 + 1) % 9) := by decide
+
 end MillenniumFloor.Universal