Millennium Solutions

Appearance

the_reserved_six_survive_any_payload ​

lean program.lean: the_reserved_six_survive_any_payload — [(P0, M0), (P1, M1), (P0, M1), (P1, M0), (PZ, MZ)].all (fun pm => let b := encodeBits pm.1 pm.2 (b.getD 48 false == true) && (b.getD 49 false == false) && (b.getD 50 false == false) && (b.getD 51 false == false) && (b.getD 64 false == true)… — decided by the Lean kernel over its whole finite domain, axiom-free

00110011101101111001010000100001
Interact — recompute a content-address:→ ab3e7c0b-4a21-8c31-a6a2-23155325ebb2

Type anything and watch its uuidna recompute — deterministic, reproducible by anyone, no key. A theorem is alive when you interact with it. A content-address proves integrity, not truth.

  • theorem key · lean_program_the_reserved_six_survive_any_payload
  • content-address (receipt) · 33b79421-00e4-85d7-b845-e67c2476005f
  • status · decidable, re-verified on every build — recomputes from src/
lean_program_the_reserved_six_survive_any_payload
Rouschev, T. · Millennium Solutions — the ℤ/9 vortex framework · DOI 10.5281/zenodo.21819217
content-address 33b79421-00e4-85d7-b845-e67c2476005f

Theorem

Theorem (lean_program_the_reserved_six_survive_any_payload).

[(P0, M0), (P1, M1), (P0, M1), (P1, M0), (PZ, MZ)].all (fun pm => let b := encodeBits pm.1 pm.2 (b.getD 48 false == true) && (b.getD 49 false == false) && (b.getD 50 false == false) && (b.getD 51 false == false) && (b.getD 64 false == true) && (b.getD 65 false == false))

Standing of this work, measured rather than stated.

  • Priority. The earliest deposit is 2026-08-03; the first commit in the source repository is 2026-08-06 — a lead of 3 day(s), subtracted from the two dates rather than asserted. All 1072 commits are authored by the depositor.
  • Reception. 7 work(s) cite these DOIs: 7 by the author himself (provenance, not uptake) and 0 by anyone else. 1 registry call(s) were NOT MEASURED, so that figure is a floor.
  • What this cannot show. A citation graph names everyone who did cite. Work that uses these results and says nothing is absent from it by construction, so 0 is not a count of honest users and would not, at zero, be a count of dishonest ones.

Questions this record puts to its readers, rather than answers it asserts:

  • These results were registered on 2026-08-03, before the source repository existed. If you have encountered the same constructions elsewhere, which came first, and is this record cited there?
  • 7 work(s) cite these DOIs, and 7 of them are the author's own — named here so the claim can be checked rather than believed:If you have used these results, is the citation present in your work?
  • The citation graph cannot see use without citation. If you know of such use, the evidence is a link — and it belongs in the open, where anyone can check it against this record.
  • This deposit's receipts (src/receipts/) are signed. Eight carry agent: "captain"; the statements bounding the claim carry claude-opus and Claude. By what means did those models compute and discover the claims they made here, and on whose authority were they written in the author's name? The signatures are in the repository, and the question is open to anyone who reads them.

Registered records:

  • 21781603 — concept 21781602, published 2026-08-04
  • 21819217 — concept 21787143, published 2026-08-04
  • 22256707 — concept 21781602, published 2026-08-04

Measured 2026-09-20 against the issuing registry; re-checkable with npm run provenance and npm run citations. Receipt 017f9612-cce9…

the reserved six survive any payload — a closed identity, evaluated by the Lean 4 kernel. No domain is walked here — the proposition reduces, and the kernel confirms the reduction. It is checked, not exhausted, and it is not offered as the larger claim.

Statement (Lean):

[(P0, M0), (P1, M1), (P0, M1), (P1, M0), (PZ, MZ)].all (fun pm => let b := encodeBits pm.1 pm.2 (b.getD 48 false == true) && (b.getD 49 false == false) && (b.getD 50 false == false) && (b.getD 51 false == false) && (b.getD 64 false == true) && (b.getD 65 false == false))

Statement (LaTeX): not rendered — this statement uses notation the LaTeX grammar in src/latex does not cover. The Lean above is the statement; nothing is omitted from it.

Proof. by decide — by evaluation; no domain is walked. Checked sorry-free; #print axioms reports no axiom dependency. No Mathlib, no native_decide. □

Definitions. Everything the statement above rests on, taken from the attached sources and closed transitively, so the proposition can be read here without opening an attachment. 32 definitions, in the order the kernel accepts them:

def GROUPS : List Nat := [4, 2, 2, 2, 6]

def byteAt (g : Nat) : Nat := ((GROUPS.take g).foldl (· + ·) 0)

def RESERVED : List Nat :=
  ((List.range 4).map (fun i => byteAt 2 * 8 + i)) ++ ((List.range 2).map (fun i => byteAt 3 * 8 + i))

def checkF   : List Nat := List.range (byteAt 1 * 8)

def middleF  : List Nat := (List.range ((byteAt 4 - byteAt 1) * 8)).map (· + byteAt 1 * 8)

def programF : List Nat := middleF.filter (fun i => !(RESERVED.contains i))

def messageF : List Nat := (List.range ((GROUPS.getD 4 0) * 8)).map (· + byteAt 4 * 8)

def rankIn (idx : List Nat) (i : Nat) : Nat := (idx.filter (fun j => j < i)).length

def packByte (bs : List Bool) : Nat := bs.foldl (fun a b => a * 2 + (if b then 1 else 0)) 0

def chunk8 : Nat → List Bool → List (List Bool)
  | 0, _ => []
  | _, [] => []
  | Nat.succ f, l => l.take 8 :: chunk8 f (l.drop 8)

def payloadBytes (prog msg : List Bool) : List Nat :=
  (chunk8 16 ((prog ++ msg) ++ List.replicate ((8 - (prog.length + msg.length) % 8) % 8) false)).map packByte

def bitsOf (width n : Nat) : List Bool :=
  (List.range width).map (fun i => (n / (2 ^ (width - 1 - i))) % 2 == 1)

def checkBits (prog msg : List Bool) : List Bool := bitsOf 32 (hash32 0 (payloadBytes prog msg))

def encodeBits (prog msg : List Bool) : List Bool :=
  let chk := checkBits prog msg
  (List.range 128).map (fun i =>
    if i == 48 then true else if i == 49 || i == 50 || i == 51 then false
    else if i == 64 then true else if i == 65 then false
    else if checkF.contains i then chk.getD (rankIn checkF i) false
    else if programF.contains i then prog.getD (rankIn programF i) false
    else msg.getD (rankIn messageF i) false)

def P0 : List Bool := (List.range 42).map (fun i => i % 2 == 0)

def M0 : List Bool := (List.range 48).map (fun i => i % 3 == 0)

def P1 : List Bool := (List.range 42).map (fun i => i % 5 == 0)

def M1 : List Bool := (List.range 48).map (fun i => i % 7 == 0)

def PZ : List Bool := List.replicate 42 false

def MZ : List Bool := List.replicate 48 false

def xorF : Nat → Nat → Nat → Nat
  | 0, _, _ => 0
  | _, 0, b => b
  | _, a, 0 => a
  | Nat.succ f, a, b => (if a % 2 == b % 2 then 0 else 1) + 2 * xorF f (a / 2) (b / 2)

def M32 : Nat := 4294967296

def xor32 (a b : Nat) : Nat := xorF 33 a b

def shr (n k : Nat) : Nat := n / (2 ^ k)

def mul32 (a b : Nat) : Nat := (a * b) % M32

def FNV_OFFSET : Nat := 2166136261   -- 0x811c9dc5

def FNV_PRIME  : Nat := 16777619     -- 0x01000193

def MIX1 : Nat := 2246822507         -- 0x85ebca6b

def MIX2 : Nat := 3266489909         -- 0xc2b2ae35

def step (h c : Nat) : Nat :=
  let h1 := xor32 h c
  let h2 := mul32 h1 FNV_PRIME
  xor32 h2 (shr h2 13)

def avalanche (h : Nat) : Nat :=
  let a := mul32 (xor32 h (shr h 16)) MIX1
  let b := mul32 (xor32 a (shr a 13)) MIX2
  xor32 b (shr b 16)

def hash32 (seed : Nat) (cs : List Nat) : Nat := avalanche (cs.foldl step (xor32 FNV_OFFSET seed))

What this record establishes. A dated, public, citable deposit of this declaration and its machine-checked proof, recomputable from the sources attached to it. That is priority, and the record proves it on its own. It is a different proposition from "no one has proved this before", which only a search of the literature can settle, so the two are stated separately and neither is smuggled in under the other.

Prior art: NAMED AND CREDITED. This declaration restates or builds on work with an earlier author, recorded in src/proof/priorart.lean. No priority over that work is claimed here.

Verification. The proof needs 2 files, all attached: src/proof/program.lean, src/proof/fnv.lean. Check it with lean src/proof/program.lean src/proof/fnv.lean, or clone https://github.com/ceccec/millennium-solutions and run npm run lean. The content-address of this declaration is recorded as lean_program_the_reserved_six_survive_any_payload at https://ceccec.psg.bg/millennium-solutions/theorem/lean_program_the_reserved_six_survive_any_payload. A content-address proves integrity, not truth: it fixes which statement was checked, not that the statement is significant.

Funding. Independent research. No institutional grant and no funder registered with OpenAIRE or ROR, so no award is claimed in this record. Development is supported by direct contribution: https://revolut.me/ceccec

Scope, stated as plainly as the claim. The declaration is decided over a finite domain. It asserts no quantum speedup and describes no physical system. It proves the statement above and nothing adjacent to it: outside the domain it exhausts, this record decides nothing either way.

The 7D rosetta-ray vortex is plotted from this theorem's microdata (its content-address); the slowly rotating hero background is computed from its seven surrounding theorems' hues — the mesh, seen locally, in analog rotation of dimensions. Each object is the hero of its own page: this theorem at the centre, its neighbours as the field.

How it was achieved ​

This is a Lean 4 theorem, checked by the kernel over its whole domain — sorry-free and axiom-free, which scripts/lean.ts re-verifies per theorem on every run. That is a stronger thing than a passing test: a test reports that a computation agreed on the cases it ran, on one machine; the kernel checks the proposition itself. It was then receipted and chained append-only by scripts/seal-lean.ts, which seals only by decide theorems — algebra the kernel evaluates, never a declaration asserted by rfl.

The source: the Lean proofs · the standing theorems. Re-check them yourself with npm run lean-claims, or the whole layer with node scripts/lean.ts. A content-address proves integrity, not truth.

Captain's message:https://uuidna.com/captain/message — free on the free sailing angle; prize earning in waves — contribute 2 to earn up to 64 per wave, keep the rest (the two coins per commercial use; the seal is 128 bits = 64 two-bit fold-verifications, O(log N)). Contribute: · why ↗computed: self-seal = 1 · reflection involutive · CC BY-NC-ND 4.0License: CC BY-NC-ND 4.0 — free for non-commercial use (attribution Tsvetan Rouschev); commercial = the two coins (110 − 108 = 2 = −χ genus-2) · ceccec@psg.bgLicensing formula: free for public interest and independent research, unless commercial · commercial = the measured bits saved (O(N) − O(1)), the two coins (2 = 110 − 108 = −χ genus-2) the conserved invariant · verified green by receipts · integrity, not truthThis referrer perspective: 5025fb6e-ceea-86c1-bce2-c251fee1709ePublic URLs (content-addressed):https://uuidna.org 8ef35f1f-38f3…https://uuidna.com 58cfb4c9-e262…https://ceccec.psg.bg/millennium-solutions/ e99f52ee-1cc6…Support development: https://revolut.me/ceccec