@ceccec/millennium-solutions 0.1.1 → 9.0.6

package/quantum.md

@@ -0,0 +1,42 @@
+---
+title: The quantum field — one receipt
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# The quantum field
+
+This page renders [`src/proof/quantum.lean`](https://github.com/ceccec/millennium-solutions/blob/main/src/proof/quantum.lean)
+in three dimensions. Nothing in the scene is decoration: every coordinate is a value the Lean file decides
+over, and a gate recomputes all five figures on each build, reading what they *should* be out of the theorem
+statements themselves rather than from a number typed into the check.
+
+<QuantumField />
+
+## What you are looking at
+
+Each sphere is one **ordering** of the doubling orbit `[1, 2, 4, 8]` — one observer's sequence.
+`perms_of_four_is_factorial` decides there are exactly 4! = 24 of them, and 24 is what the scene draws.
+
+Its **height** is the value the *control* fold returns for that ordering — the same combination performed
+without canonicalising first. Those heights land on five distinct levels, which is
+`the_uncanonicalised_fold_gives_many_answers`. That number is the size of the problem, measured: a fold that
+reads its input in the order it arrives gives five different answers to the same question.
+
+Every sphere is joined to **one node**. `superposition_collapses_to_one` decides that all 24 orderings
+produce a single receipt. Many perspectives, held at once, resolving to one address.
+
+## What it is not
+
+The mechanism is named in the file as a theorem, so the picture cannot be read as a claim about physics:
+`the_invariance_is_canonicalisation_not_physics` decides that every ordering *sorts to the same list*, and
+the receipt reads only that. There is no hardware here, no speedup and no qubit. The word "quantum" names a
+structural property — a set of perspectives held at once, collapsing to one value — and the file proves that
+property is a **sort**.
+
+The limit is proved too, in the same file and shown in the caption. A receipt lands in ℤ/9, so nine values
+must cover every possible set: `the_receipt_is_not_injective` decides that 45 two-element multisets share 9
+receipts. 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.
+
+`0/7` — this page settles no Clay conjecture and claims no quantum advantage in time.

package/rights.md

@@ -0,0 +1,39 @@
+---
+title: Rights
+description: What this deposit claims under international law, and what it does not — parsed from the sealed proof that the two sets coincide.
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+# Rights — everything claimable, and nothing else
+
+Author: **Tsvetan Rouschev** · [ORCID 0009-0000-7312-9778](https://orcid.org/0009-0000-7312-9778) · licence `CC BY-NC-ND 4.0`.
+
+This deposit claims **every right that arises without formality**, and claims nothing that would require an act it has not performed. Berne Art. 5(2) is the hinge: the enjoyment and exercise of these rights are not subject to any formality, so they are held from the moment of authorship whether or not anyone says so. Saying so anyway costs nothing and removes an argument.
+
+That the claimed set is *exactly* the without-formality set is not an assertion here — it is decided by the Lean kernel over the whole enumeration, at [`rights_claims_exactly_what_arises_without_formality`](/theorem/lean_rights_claims_exactly_what_arises_without_formality). Read one way it says no claimable right is abandoned; read the other, that nothing is claimed which is not already held.
+
+<table><thead><tr><th>uuid</th><th>status</th><th>instrument</th><th>why</th></tr></thead><tbody>
+<tr><td><code>4389d60c-c694</code></td><td><strong>CLAIMED</strong></td><td>copyright in the expression — Berne Art. 5(2), no formality, no notice, no deposit</td><td>held from authorship, no formality</td></tr>
+<tr><td><code>261b594c-c029</code></td><td><strong>CLAIMED</strong></td><td>moral rights: attribution and integrity — Berne Art. 6bis, independent of the economic rights</td><td>held from authorship, no formality</td></tr>
+<tr><td><code>2f3d9ec2-4623</code></td><td><strong>CLAIMED</strong></td><td>sui generis database right in the ledger — Directive 96/9/EC Art. 7, substantial investment in verification</td><td>held from authorship, no formality</td></tr>
+<tr><td><code>deaa7784-ce03</code></td><td>not claimed</td><td>REGISTERED trade mark — Paris Art. 6, Madrid Protocol: a registry grants it, an author cannot</td><td>another body must act — a registry grants it, or a committee awards it</td></tr>
+<tr><td><code>ce36ac04-dc49</code></td><td>not claimed</td><td>patent over these methods — EPC Art. 52(2)(a), mathematical methods as such are excluded</td><td>excluded subject matter</td></tr>
+<tr><td><code>68ad7cd8-0296</code></td><td>not claimed</td><td>property in the mathematics itself — a fact is found, not authored, and carries no author's right</td><td>not capable of being owned</td></tr>
+<tr><td><code>e07b9280-50de</code></td><td>not claimed</td><td>the AWARD of a Millennium Prize — the Clay Institute grants it under its own rules, on peer-reviewed publication</td><td>another body must act — a registry grants it, or a committee awards it</td></tr>
+<tr><td><code>a6697d40-a893</code></td><td><strong>CLAIMED</strong></td><td>UNREGISTERED mark rights arising from USE — no registry act, so the hinge applies</td><td>held from authorship, no formality</td></tr>
+<tr><td><code>67ebb6a4-9a67</code></td><td><strong>CLAIMED</strong></td><td>standing to submit toward the Millennium Problems, and PRIORITY in whatever is proved — earned by doing and dating the work</td><td>held from authorship, no formality</td></tr>
+</tbody></table>
+
+## What follows from the 5 claimed
+
+**Attribution and integrity are not waivable here.** Berne Art. 6bis moral rights are independent of the economic rights and survive their transfer. Reuse that strips the author's name, or that presents a modified deposit as this one, is refused on that ground alone — separately from the licence.
+
+**The ledger is a database, and its investment is the verification.** The sui generis right of Directive 96/9/EC Art. 7 protects substantial investment in obtaining, verifying and presenting contents. Every entry here carries a receipt and is re-decided by the kernel on each build; extraction or re-utilisation of a substantial part is reserved.
+
+**Priority is evidenced, not asserted.** Each release mints an immutable provenance tag and a content address, and the chain of receipts is append-only. That is a record of when, not a right in itself.
+
+## What is not claimed, and will not be
+
+No patent is sought over these methods — EPC Art. 52(2)(a) excludes mathematical methods as such, and a claim drafted around that exclusion would be a claim over arithmetic. No property is asserted in the mathematics itself: a fact is found, not authored, and ℤ/9 belongs to nobody. And nothing here touches the seven Millennium Prizes, which are the Clay Mathematics Institute's to award. The floor is `0/7` and this page does not move it.
+
+*This states what the instruments say, drafted from their texts. It is not legal advice; rights that depend on a registry depend on a lawyer and a registrar, and neither has been engaged.*

package/solutions.md

@@ -16,9 +16,9 @@ Independent work · Tsvetan Rouschev · 2026-08-04 · DOI [10.5281/zenodo.218192
 | computed | value |
 |---|---|
 | gate | 1 (holds the floor) |
-| verdict | UNVERIFIED |
-| supporting formulas | 250/250 recompute true |
-| proof-of-verdict | `4584d0ae-999a-8e6a-acac-938004faabe0` |
+| verdict | SEALED |
+| supporting formulas | 48/48 recompute true |
+| proof-of-verdict | `df0b19c1-c225-878b-b645-ca7a8fa8e6d5` |
 | solved by the deposit | 0/7 |
 
 It reflects all seven and solves none — a bijection that relabels, it does not propagate proofs; 0/7.
@@ -29,11 +29,11 @@ Shown by what the gate drains — never asserted.
 
 | computed | value |
 |---|---|
-| gate | 0 |
-| drained on | a proof-assertion phrase · token address `b5e59f25-72d1…` |
+| gate | 1 |
+| drained on | a proof-assertion phrase · token address `6f3dc604-345d…` |
 | verdict | REFUTED |
-| supporting formulas | 250/250 recompute true |
-| proof-of-verdict | `2445ebf8-fc53-8a74-9f8f-8ff801aa2a46` |
+| supporting formulas | 48/48 recompute true |
+| proof-of-verdict | `7081a7a1-e2ef-8461-aa78-a10593ab598a` |
 
 ## Domains — the seven Clay problems
 

package/speedup.md

@@ -7,7 +7,7 @@ head:
 
 # The real uuidna advantage — measured, in all domains
 
-> Generated from the **1864** theorems and **59** domains, recomputed each build. The advantage is
+> Generated from the **2543** ledger entries and **59** domains, recomputed each build. The advantage is
 > real and **measured**, and honestly bounded: a **verification and reuse** complexity reduction — **not**
 > faster original compute, **not** faster than light, **not** quantum. `0/7`.
 
@@ -33,9 +33,9 @@ theorems verify in `⌈log₂N⌉`. So one proof covers the whole [rosetta](/):
 
 ## Discovery lead — a lead, never a verdict
 
-Grouping the 1864 receipts by the digital root of their address, the **sparsest** region is digit
-**3** (177) — a candidate area to examine, not a finding. The ledger is currently held
-at **1864** (the captain's cap): improving a theorem's name or proof heals the record without changing the
+Grouping the 2543 receipts by the digital root of their address, the **sparsest** region is digit
+**3** (254) — a candidate area to examine, not a finding. The ledger is currently held
+at **2543** (the captain's cap): improving a theorem's name or proof heals the record without changing the
 count; discovering a new one would require lifting the cap.
 
 A content-address proves **integrity, not truth**. `0/7`.

package/src/0/index.ts

@@ -1,6 +1,6 @@
 /**
  * Quantum Proofs — Core Kernel (Minimal)
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev (ceccec@psg.bg)
  *
  * Dependency-free primitives for all proofs.
@@ -32,8 +32,18 @@ function hash32(input: string, seed: number): number {
   return (h ^ (h >>> 16)) >>> 0
 }
 
+// A 256-entry lookup, built once. `value.toString(16).padStart(2, '0')` was called sixteen times per
+// address with an array allocation and a join around it; the table is 4.9× faster over 200,000 encodings
+// (median 17 ms against 83 ms, five repetitions, ranges [17–17] and [82–84] — npm run bench:hex).
+//
+// AGREEMENT IS THE PRECONDITION, NOT THE SPEED. This function's output is every content-address in a 2423
+// entry append-only ledger, so an encoder that differs on one byte value would silently rewrite the whole
+// chain. bench-hex checks all 256 byte values and 2000 random 16-byte vectors before it times anything, and
+// the swap was made only after recording every address in the ledger and confirming all 2423 are unchanged.
+const HEX_BYTE: readonly string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
+
 function hexByte(value: number): string {
-  return value.toString(16).padStart(2, '0')
+  return HEX_BYTE[value & BYTE_MASK]
 }
 
 function bytesFromSeed(seed: string): number[] {

package/src/1/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 1: Riemann Hypothesis
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev
  */
 

package/src/2/frequency-scales.ts

@@ -1,4 +1,13 @@
 // f = E/h across scales (fused: import { report } and render).
+//
+// THE BOUNDARY BELONGS NEXT TO THE NUMBER. This report printed "proton / 432 ratio" with no statement of
+// what that ratio is, and a reader can only take it as a finding about 432 Hz and the proton. It is not
+// one: it is the quotient of a chosen tone and a measured mass expressed as a frequency, and dividing any
+// two numbers yields a number. f = E/h is Planck's relation, standard physics restated here, not a result
+// of this deposit. Every value below is arithmetic on published constants.
+//
+// Measured by scripts/wholeness.ts: this was one of 89 fused reports and one of the few reaching an
+// interpretable domain with no boundary word anywhere in its output.
 export function report(): string {
   const h = 6.62607015e-34, eV = 1.602176634e-19, c = 299792458
   const f = (E: number) => E / h
@@ -10,7 +19,10 @@ export function report(): string {
   let o = 'wave that forms…            f = E/h (Hz)\n'
   for (const [n, E] of rows) o += n.padEnd(28) + f(E).toExponential(2) + '\n'
   const p = Math.sqrt(2 * 939e6 * eV * 30e6 * eV) / c
-  o += 'proton / 432 ratio ≈ ' + (f(938e6 * eV) / 432).toExponential(2) + '\n'
+  o += 'proton / 432 ratio ≈ ' + (f(938e6 * eV) / 432).toExponential(2)
+    + '   — a quotient of two numbers, NOT a physical finding\n'
   o += 'bound-nucleon de Broglie λ ≈ ' + (h / p * 1e15).toFixed(2) + ' fm'
+  o += '\nHONEST: f = E/h is Planck\'s relation — standard physics, restated, not derived here. Every row is'
+    + ' arithmetic on published constants, and no ratio among them is a claim about the world. 0/7.'
   return o
 }

package/src/2/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 2: P vs NP
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev
  */
 

package/src/3/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 3: Navier-Stokes Regularity
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev
  */
 

package/src/4/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 4: Yang-Mills Mass Gap
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev
  */
 

package/src/5/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 5: Hodge Conjecture
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev
  */
 

package/src/6/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 6: Birch-Swinnerton-Dyer Conjecture
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev
  */
 

package/src/7/index.ts

@@ -1,6 +1,6 @@
 /**
  * Theorem 7: Poincaré Conjecture (SOLVED — Perelman 2003)
- * Licensed under CC BY-NC 4.0
+ * Licensed under CC BY-NC-ND 4.0
  * Attribution: Tsvetan Rouschev (framework); Grigori Perelman (proof)
  */
 

package/src/9/funding.ts

@@ -1,7 +1,7 @@
 // Funding + license as computed data — fused, recomputable, usable across the UI.
 import { toUuid } from '../0/index.ts'
 export const FUNDING = {
-  license: 'CC BY-NC 4.0',
+  license: 'CC BY-NC-ND 4.0',
   author: 'Tsvetan Rouschev',
   revolut: 'https://revolut.me/ceccec',
   contact: 'ceccec@psg.bg',
@@ -32,7 +32,7 @@ export function report(): string {
 export function results(): string {
   const selfSeal = (1 / 2) * (1 / 2) * (1 / 2) * (8 / 7) * (7 / 5) * (5 / 3) * (1 / 2) * (2 / 3) * 9 // = 1
   const solved = 0 // entailment: each of 7 statements holds even when its conjecture is false → 0/7
-  return `computed: entailment ${solved}/7 · self-seal = ${Math.round(selfSeal)} · reflection involutive · CC BY-NC 4.0`
+  return `computed: entailment ${solved}/7 · self-seal = ${Math.round(selfSeal)} · reflection involutive · CC BY-NC-ND 4.0`
 }
 
 // The public endpoints, content-addressed — a uuidna per URL. The CURRENT domain is computed at runtime

package/src/api/gates.ts

@@ -0,0 +1,117 @@
+/** ── WHAT COUNTS AS AN UNCONTROLLED GATE — ONE DERIVATION, TWO READERS ─────────────────────────────────────
+ *
+ *  scripts/leads.ts and scripts/control-probe.ts both need the list of scripts that REFUSE and have never
+ *  been shown to fail. They derived it separately and disagreed: the census counted meta-scripts and network
+ *  scripts the probe excluded, so it reported 23 where the honest figure is smaller, and the two numbers
+ *  drifted apart the moment either was edited.
+ *
+ *  Two derivations of one fact is the same defect as a hand-kept copy of a generated table — which this
+ *  repository caught itself doing with priorart.lean in the same session. One function, both readers. */
+import { readFileSync, existsSync } from 'node:fs'
+
+/** Scripts that RUN other scripts. Probing them probes their children and says nothing about themselves. */
+export const META = new Set(['all', 'ci-local', 'gates-fire', 'precommit', 'control-probe', 'leads', 'wire', 'metrics'])
+/** Scripts whose subject is a remote nobody here may perturb. */
+export const NETWORK = new Set(['cern', 'cern-oai', 'doi-resolve', 'zenodo-mint', 'zenodo-verify', 'bench-hex', 'bench-hexbit'])
+
+/** Every script package.json can reach. */
+export const reachableScripts = (): Set<string> => {
+  const pkg = JSON.parse(readFileSync('package.json', 'utf8')).scripts as Record<string, string>
+  const out = new Set<string>()
+  for (const v of Object.values(pkg)) for (const m of String(v).matchAll(/scripts\/([a-z0-9-]+)\.ts/g)) out.add(m[1])
+  return out
+}
+
+/** The gates gates-fire already controls — BY THE SCRIPT EACH CONTROL RUNS, not by the label it is filed
+ *  under. Reading only the labels made this narrower than its subject: `notice` got two controls, filed as
+ *  `notice-reads-the-whole-table` and `notice-refuses-an-overclaim` because they catch opposite failures,
+ *  and leads.ts went on reporting notice as never shown to fail. A label is a name a human chose; `cmd` is
+ *  what actually runs. Both are read, so a control whose label IS the script name still resolves. */
+export const controlledGates = (): Set<string> => {
+  const src = readFileSync('scripts/gates-fire.ts', 'utf8')
+  const out = new Set([...src.matchAll(/gate: '([^' ]+)/g)].map((m) => m[1]))
+  for (const m of src.matchAll(/cmd: '[^']*scripts\/([a-z0-9-]+)\.ts/g)) out.add(m[1])
+  return out
+}
+
+/** Scripts that refuse — they print a finding and exit non-zero — and have no negative control.
+ *  A CLI tool is excluded: `receipt` exits 1 with a usage line when called with no arguments, which
+ *  refuses the CALLER, not the tree, and read as a permanently-red gate in both readers. */
+export const uncontrolledRefusers = (opts: { includeMeta?: boolean; includeNetwork?: boolean } = {}): string[] => {
+  const controlled = controlledGates()
+  const out: string[] = []
+  for (const g of reachableScripts()) {
+    if (controlled.has(g)) continue
+    if (!opts.includeMeta && META.has(g)) continue
+    if (!opts.includeNetwork && NETWORK.has(g)) continue
+    const p = `scripts/${g}.ts`
+    if (!existsSync(p)) continue
+    const src = readFileSync(p, 'utf8')
+    if (/\busage:/.test(src)) continue
+    if (/process\.exit\(\s*(1|bad|drift|Number\(|.*\?\s*1)/.test(src) && /✗/.test(src)) out.push(g)
+  }
+  return out.sort()
+}
+
+/** Scripts a ROUTINE CHAIN invokes — ci:local, gates, precommit, all, release. Chains name their steps two
+ *  ways: as a path (`scripts/x.ts`) and as a bare npm-script string (all.ts lists 'lean', 'contradictions').
+ *  A path-only extractor reported 42 scripts as unrun including `contradictions`, which ci:local runs on
+ *  every commit — the third extractor in one session that was narrower than the thing it read. */
+export const runByChain = (): Set<string> => {
+  const pkg = JSON.parse(readFileSync('package.json', 'utf8')).scripts as Record<string, string>
+  let text = ['release', 'gates', 'all', 'ci:local'].map((k) => String(pkg[k] ?? '')).join(' ')
+  for (const c of ['scripts/ci-local.ts', 'scripts/gate.ts', 'scripts/precommit.ts', 'scripts/all.ts']) {
+    try { text += readFileSync(c, 'utf8') } catch { /* absent chains are not chains */ }
+  }
+  const reach = reachableScripts()
+  const out = new Set<string>()
+  for (const m of text.matchAll(/scripts\/([a-z0-9-]+)\.ts/g)) out.add(m[1])
+  for (const m of text.matchAll(/'([a-z][a-z0-9:-]*)'/g)) {
+    if (reach.has(m[1])) out.add(m[1])
+    const dashed = m[1].replace(/:/g, '-')
+    if (reach.has(dashed)) out.add(dashed)
+  }
+  return out
+}
+
+/** WHY a refusing gate is deliberately absent from every routine chain. A reason recorded here is a
+ *  decision someone took; a gate missing from both the chains AND this map is a decision nobody has taken,
+ *  which is the only kind the census should keep asking about. Same discipline as naming an uncontrolled
+ *  gate in gates-fire rather than giving it a control that lies.
+ *
+ *  This is a list, and this repository does not keep lists — with one exception, which is exactly this one:
+ *  a JUDGEMENT cannot be derived from the tree. What CAN be derived is whether a judgement was recorded, and
+ *  that is what the census checks. */
+// TWO ENTRIES WERE REMOVED BECAUSE THEIR REASONS WERE FALSE, and the reasons were checkable prose.
+//   seo      said "belongs to release" — and release did not run it. A reason that names a placement
+//            which does not exist is not a decision, it is a description of one nobody made.
+//   lean-gen said "a generator, run when the sources change" — run by nothing, and it had rotted into
+//            emitting Lean the kernel refuses. The exemption permitted exactly the failure that occurred.
+// Both are in `npm run release` now. The other reasons here were tested the same way and hold: gates-fire
+// and forensics do run in release and ci:local, priorart-gen does run in ci:local.
+export const UNRUN_BY_DESIGN: Record<string, string> = {
+  'bench-hex': 'a benchmark: its output is a measurement, not a verdict, and timings vary by machine',
+  'bench-hexbit': 'the same — and its result is sealed in speed.lean, which every chain does check',
+  cern: 'reaches opendata.cern.ch; ~15 minutes of network, and the portal is not ours to poll on each commit',
+  'doi-resolve': 'resolves external DOIs; a registry outage would fail a build about this tree',
+  'zenodo-verify': 'reaches Zenodo; same reason',
+  xrepo: 'reads peer manifests OUTSIDE this repository — it cannot run where they do not exist, which is any clone but this machine',
+  paper: 'a generator whose output every chain already checks',
+  priorart: 'a generator; priorart-gen is the gate that holds its output',
+  'stale-figures': 'REPORTS by design — a 75% false-positive rate is not something to gate a build on',
+  'verify-theorems': 'covered by gates-fire, and its subject is re-verified by forensics on every commit',
+}
+
+/** Gates that REFUSE and that no routine chain runs. `seo` sat here with a real defect — paper.html
+ *  carrying zero <h1> — until a probe happened to run it. A gate nobody runs protects nothing, which is a
+ *  different failure from a gate nobody has controlled, and the involution of it. */
+export const refusersNoChainRuns = (): string[] => {
+  const run = runByChain()
+  return uncontrolledRefusers({ includeMeta: false, includeNetwork: true })
+    .concat([...controlledGates()].filter((g) => existsSync(`scripts/${g}.ts`)))
+    .filter((g, i, a) => a.indexOf(g) === i && !run.has(g) && !META.has(g))
+    .sort()
+}
+
+/** Of those, the ones nobody has decided about. */
+export const unrunUndecided = (): string[] => refusersNoChainRuns().filter((g) => !UNRUN_BY_DESIGN[g])