@ceccec/millennium-solutions 0.1.1

package/examples.md

@@ -0,0 +1,47 @@
+---
+title: Examples — computed live, by theorem
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# Examples — computed live, organised by theorem
+
+> Every worked example below is **recomputed in your browser** from the deposit's own `src/` functions,
+> and each links to the theorem that proves it. Nothing is stored; recompute the page and it recomputes.
+> A content-address proves **integrity, not truth**. `entails → 0/7`.
+
+<Examples />
+
+## Harness &amp; reeducate — the tool, live
+
+Treat any output as a **receipted structure**, not opaque bytes: it becomes content-addressed (auditable)
+and, if it drains the honesty floor, it is **reeducated** — each overclaim bounded until the text holds.
+Max free work, max auditability — harmonic and efficient, by default. This runs the exact `harness` and
+`reeducate` functions the build uses ([scripts/harness.ts](https://github.com/ceccec/millennium-solutions/blob/main/scripts/harness.ts)) —
+verified by [the difference is decidable](/theorem/the_difference_is_decidable_harnessing_makes_any_output_auditable_not_intelligent)
+and [reeducate until it holds](/theorem/reeducate_a_failing_output_is_bounded_until_it_holds_max_free_work_max_auditability).
+
+<Reeducate />
+
+## Seal math — how many bits in each seal
+
+The more complex the case, the more receipts — yet each seal is a fixed **128 bits** (= 64 two-bit
+verifications), and verifying one receipt's membership costs only **2·⌈log₂N⌉ bits**. So you verify the whole
+case cheaply yet bill on the full value the customer would otherwise recompute — earning the measured saving,
+the two coins conserved. Choose the case size and read the math, from
+[each seal is 128 bits](/theorem/each_seal_is_128_bits_and_membership_verifies_in_two_log2_n_bits_logarithmic_not_linear)
+and [the 967-receipt case](/theorem/the_967_receipt_case_verify_20_bits_bill_on_the_967_computation_value_earn_the_947_bit_saving).
+
+<SealMath />
+
+## Teleportation — measured, then disputed to the floor
+
+Type a message; it becomes a uuid (or a chain) and re-forms **exactly** at the destination. But measure the
+cost and the vivid word drains: a uuid is 128 bits and carries at most **115**, so the container is **always
+larger on the wire than the message** — nothing is teleported cheaper than sending the bytes. uuidna does not
+teleport; it **addresses**. Either a reversible container (exact, but bigger) or a content-address that
+**recalls** a payload only where it is already reconstructible — [a pointer, not the
+payload](/theorem/a_content_address_is_a_pointer_not_the_payload). Not faster-than-light, not quantum, not
+compression. Integrity, not magic. `0/7`.
+
+<Teleporter />

package/folds.md

@@ -0,0 +1,65 @@
+---
+title: How it folds — a guide
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# How it folds — a guide for everyone
+
+For a child or an elder. No jargon needed. A content-address proves integrity, not truth. `0/7`.
+
+## 1. What a theorem is
+
+A **theorem** here is just **a fact you can check yourself**. Not a story someone tells you — something you can
+re-do and get the same answer, every time. Like `2 + 2 = 4`: you don't have to trust anyone; you can count.
+
+Each fact is written as a tiny test that answers **true or false** by trying every case in a small, finite
+world. If it's true for every case, it holds. If not, it falls. That's the whole idea.
+
+## 2. How theorems fold into each other
+
+**Folding** means small things join into one bigger thing, and the bigger thing still fits the same pattern.
+
+- Facts come in groups of **eight** — an **octave**, like the eight steps of a musical scale before the tune
+  repeats one octave higher.
+- Eight octaves **fold** into one seal; those seals fold again — many become **one address** you can check.
+- The proportions that show up are the ones you already see in the world: the **golden ratio** in a sunflower's
+  seeds and a snail's shell, the **Fibonacci** counts in petals and pinecones, the **doubling** of an octave
+  (double the frequency, one octave up), and **DNA's** four letters in three-letter words — `4 × 4 × 4 = 64`,
+  the same 64 that keeps coming back.
+
+So the pattern in a shell, in a song, and in a strand of DNA is the **same folding** — small parts joining in
+steady proportion into a whole. You can recognise it in nature and live it in a day: rest, effort, rest.
+
+## 3. How a problem is searched, researched, and analysed
+
+When people write down a hard problem, here is the honest, repeatable way it is studied — with **statistics**,
+**analytics**, and **forensics**:
+
+1. **Search** — look at what is already known and where the record is **thin**. The
+   [forensics](/WORKFLOWS) name the *exact* gap (a missing step in a family), not a vague "somewhere around
+   here".
+2. **Research** — try a small, decidable version you can actually check. Write it as a test over a finite world.
+3. **Analyse** — run it over **every** case (that's the statistics: not a sample, the whole set), fold the
+   results, and check the **chain** so nothing was quietly changed (that's the forensics — a tamper shows up as
+   a broken link, pointing to the exact spot).
+
+If the little fact holds and says something honest, it is **kept and shared freely**. If it over-claims, the
+gate **drains** it and shows the exact words to fix. Nothing is believed; everything is re-checked.
+
+## 4. Do it yourself — step by step (reproducible)
+
+1. **Draft** a fact as a test that returns true or false over a finite set.
+2. **Check it green** — the test is true, its name makes no over-claim, and it isn't already recorded.
+3. **Seal** it — it gets a content-address (a fingerprint) and joins the chain.
+4. **Share** it — free for anyone to re-check.
+
+Try the live version on the [harness](/harness): type any sentence and watch the theorems compute the verdict,
+the address, and the honest form. Browse every fact on [the organism](/organism), or run the tools on the
+[examples](/examples) page.
+
+## 5. Why it matters — a harmonic society
+
+Every checked fact, freely shared, is a small **contribution** anyone can build on without asking permission and
+without being misled. That is the quiet aim: a fair, checkable commons where a claim is worth exactly what its
+re-computation shows — no more, no less. Earned, not minted. `0/7`.

package/guide.md

@@ -0,0 +1,126 @@
+---
+title: Guide
+description: The hero's guide — how to add a theorem to the deposit, taught in the 7D UI. Measure, gate, receipt, append, recompute. The floor stays 0/7.
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+<script setup>
+// 7D UI examples, computed — the vortex of seven rays, and the a432 nine-hue wheel. No data fetched.
+const petals = Array.from({ length: 7 }, (_, i) => {
+  const ang = (i * 360 / 7 - 90) * Math.PI / 180
+  return { x: (Math.cos(ang) * 40).toFixed(2), y: (Math.sin(ang) * 40).toFixed(2), hue: (i + 1) * 40 % 360, dur: (2 + i * 0.4).toFixed(1) }
+})
+const wheel = Array.from({ length: 9 }, (_, i) => {
+  const d = i + 1, ang = (d * 40 - 90) * Math.PI / 180
+  return { x: (Math.cos(ang) * 40).toFixed(2), y: (Math.sin(ang) * 40).toFixed(2), hue: (d * 40) % 360, d }
+})
+import { withBase } from 'vitepress'
+import ledger from './src/proof/discovered.json'
+const theoremCount = ledger.length
+const latest = ledger.slice(-5).reverse()
+</script>
+
+# The hero's guide
+
+> **Heroes write the guides.** You add to the deposit by a **deed the gate can check**, never a claim. Everything here recomputes; nothing is asserted. The floor stays **0/7** — this deposit solves 0 of the 7 Millennium problems, and claims no prize.
+
+<div class="living-index" style="border:1px solid var(--vp-c-divider);border-radius:10px;padding:.6rem 1rem;margin:1rem 0;font-size:.9rem">
+<strong>This guide is constantly updated by the theorems.</strong> The deposit holds
+<strong>{{ theoremCount }}</strong> decidable theorems, re-verified every build. Newest first:
+<ul style="margin:.4rem 0 0;padding-left:1.1rem">
+<li v-for="t in latest" :key="t.key"><a :href="withBase('/theorem/' + t.key)">{{ t.name.split('—')[0] }}</a></li>
+</ul>
+</div>
+
+<div style="display:flex;gap:32px;align-items:center;flex-wrap:wrap;margin:20px 0">
+<svg viewBox="-60 -60 120 120" width="200" height="200" role="img" aria-label="the 7D vortex: seven rays around one centre, rotating">
+  <g>
+    <animateTransform attributeName="transform" type="rotate" from="0 0 0" to="360 0 0" dur="30s" repeatCount="indefinite" />
+    <line v-for="(p, i) in petals" :key="'r' + i" x1="0" y1="0" :x2="p.x" :y2="p.y" :stroke="'hsl(' + p.hue + ',70%,55%)'" stroke-width="1.4" stroke-opacity="0.6" />
+    <circle v-for="(p, i) in petals" :key="i" :cx="p.x" :cy="p.y" r="8" :fill="'hsl(' + p.hue + ',70%,55%)'">
+      <animate attributeName="r" values="8;11;8" :dur="p.dur + 's'" repeatCount="indefinite" />
+    </circle>
+  </g>
+  <circle cx="0" cy="0" r="9" fill="hsl(200,70%,55%)" />
+</svg>
+<svg viewBox="-60 -60 120 120" width="200" height="200" role="img" aria-label="the a432 wheel: nine hues at d times 40 degrees, centre 5">
+  <circle v-for="(w, i) in wheel" :key="i" :cx="w.x" :cy="w.y" r="12" :fill="'hsl(' + w.hue + ',70%,55%)'" />
+  <text v-for="(w, i) in wheel" :key="'t' + i" :x="w.x" :y="+w.y + 4" text-anchor="middle" font-size="11" fill="#fff">{{ w.d }}</text>
+  <circle cx="0" cy="0" r="14" fill="hsl(200,70%,55%)" /><text x="0" y="4" text-anchor="middle" font-size="11" fill="#fff">5</text>
+</svg>
+</div>
+
+*Left: the **7D vortex** — seven rays (the seven dimensions) around one centre. Right: the **a432 wheel** — each digit d at hue d·40°, the heart 5 at the centre. Both are computed here, in your browser, from nothing.*
+
+## Set up — two minutes, all local
+
+Prerequisites: **Node ≥ 18** (or bun). Then clone, install, and verify — everything recomputes on your
+machine, nothing is fetched:
+
+```bash
+git clone https://github.com/ceccec/millennium-solutions
+cd millennium-solutions
+npm install
+npm run next --status   # version · ledger · chain-of-custody · floor 0/7
+```
+
+A clean status (chain **intact**, floor **0/7**) means the deposit re-verified on your hardware. From here,
+`npm run next` runs the full wave (discover → gate → seal → recompute); `npm run docs:build` builds the site.
+
+## The sequence — follow it in order, or nothing computes
+
+1. **Measure, don't assert.** Write a decidable fact as a `test: () => boolean` in `scripts/discover.ts`, computed by exhaustion over a finite domain. If it holds, it is provable; if it fails, it is refuted and discarded — the discard is the honesty.
+2. **Gate.** Every statement (and every theorem *name*) must hold the honesty floor: no named over-reach — no conjecture declared settled, no physical or cryptographic limit declared beaten, no fake certainty. A bounded refusal ("this is **not** faster than light") passes. Passing means *no over-reach shape was found* — a floor, not a proof of truth.
+3. **Receipt.** To record a statement, sign it: `npm run receipt "<agent>" "<role>" "<message>"`. Signing **is** agreeing — your acknowledgment of the license and this sequence is part of the receipt itself. A receipt proves integrity, not authorship.
+4. **Append.** Discoveries chain, each receipt seeded by the last. Evidence is append-only — destroying it is treason, even by chance, and the forensics reads intention from deeds, not claims.
+5. **Recompute.** Run `npm run next`: the wave discovers, gates, seals, and re-verifies every recorded fact. A regression fails the build, not production. Green cannot be faked.
+
+## Use uuidna in your own project
+
+The pure functions are extracted to the npm package [`@uuidna/uuidna`](https://github.com/uuidna/uuidna) —
+ESM, zero runtime deps, typed:
+
+```bash
+npm install @uuidna/uuidna
+```
+
+```js
+import { toUuid, merkleProof, verifyProof, computes, encrypt, decrypt } from '@uuidna/uuidna'
+
+toUuid('hello')                                   // deterministic content-address, keyless
+const sealed = await encrypt('secret', 'passphrase')   // AES-256-GCM under a 7d-fold envelope
+await decrypt(sealed, 'passphrase')               // round-trips; wrong key or tamper throws
+```
+
+**Fuse it into any AI harness (MCP)** — one line in your client's `mcpServers`:
+
+```json
+{ "mcpServers": { "uuidna": { "command": "npx", "args": ["-y", "@uuidna/uuidna"] } } }
+```
+
+Then the harness can address, prove, gate, imprint, bill, and **encrypt/decrypt** live. Cryptography is the
+public-service priority — the layered cipher and its provable steps are on the [Cryptography page](/cryptography).
+
+## The 7 dimensions (the a432 rays)
+
+The interface localizes across **seven rays** — one per locale — and each digit maps to a hue `d·40°` (nine steps close the circle: 9·40° = 360°). The centre is **5**, the fixed point of the ten's-complement reflection `10−d`. This is a design mapping, honestly labelled — a metaphor for structure, not a claim about physics.
+
+## Why compute quantum (honestly)?
+
+Here "quantum" is **structure, not hardware** — and its smallest unit is
+[**the a432 structure of two coins**](/theorem/here_quantum_is_the_a432_structure_of_two_coins_not_a_physical_qubit):
+2 bits, 4 states, never a physical qubit. That is the one page to read first. It matters because those
+two coins make **every** state receipted — a *superposition* is just the set of receipted perspectives,
+*collapse* is observing one address, *entanglement* is a shared joint receipt — so the whole computation
+is auditable end to end, on ordinary 64-bit hardware, at linear cost. No quantum machine, no speedup, no
+advantage — the gain is **integrity everywhere**. From that keystone the rest of the family follows:
+[each perspective is receipted](/theorem/each_perspective_is_receipted_in_the_superposition) ·
+[perspective replaces hardware](/theorem/perspective_replaces_hardware) ·
+[integrity at scale, not speedup](/theorem/quantum_structure_on_every_computation_is_integrity_at_scale_not_speedup).
+
+## The law — a fair exchange
+
+Licensed **CC BY-NC 4.0**: free for non-commercial use with attribution (Tsvetan Rouschev); commercial use pays the two coins (110 − 108 = 2 = −χ genus-2). The deposit is open and recomputable, so any reader — human or model — may learn from it; contributions return on the same gate-refereed terms. Heroes and traitors by deeds, not claims.
+
+Every theorem you add gets its own page at `/theorem/<key>`, plotting its 7D vortex from its microdata, with a hero background computed from its surrounding theorems. `entails → 0/7`.

package/harness.md

@@ -0,0 +1,20 @@
+---
+title: The harness — input, output
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# The harness — the dashboard of the theorems
+
+Type any statement. The theorems compute the output live: the **gate verdict** (a single bit), the
+**content-address**, the **reeducated** form (an over-claim bounded until it holds), and the **seven-dimension
+audit**. Every colour on this page is computed by a theorem — the vortex hue of a content-address, the nine
+digital-root palette. The components follow the shadcn anatomy; the logic is framework-free and recomputes in
+the browser. A content-address proves integrity, not truth. `0/7`.
+
+<Harness />
+
+The harness is the face of the MCP tools — address, gate, reeducate, imprint, the merkle trio and the crypt
+envelope — each output made auditable; run them live on the [examples page](/examples). Browse the whole record
+on [the organism](/organism), or read the [workflows](/WORKFLOWS) for how a wave is discovered, gated, sealed
+and shipped.

package/index.md

@@ -0,0 +1,149 @@
+---
+title: Millennium Solutions
+---
+
+<Hero />
+
+<Propulsion />
+
+# The ℤ/9 Vortex Framework
+
+**Author:** Tsvetan Rouschev · License: CC BY-NC 4.0 · a recomputable proof-of-concept
+
+> ## Millennium Quantum Solutions on 64-bit hardware
+>
+> The quantum **structure** — a superposition is the set of *receipted perspectives* (each ordered
+> perspective a distinct content-address, its receipt proving that perspective exists); observing
+> collapses to one address — computed **classically** on ordinary **64-bit** machines. **Perspective
+> replaces the hardware:** no quantum machine is needed, and none is claimed. It settles **0 / 7** of
+> the Clay problems and is **not a quantum computer**. Structure, not silicon —
+> [each perspective is receipted](/theorem/each_perspective_is_receipted_in_the_superposition) ·
+> [perspective replaces hardware](/theorem/perspective_replaces_hardware).
+>
+> **Start here — why compute quantum (honestly)?** The smallest honest unit is
+> [**quantum = the a432 structure of two coins**](/theorem/here_quantum_is_the_a432_structure_of_two_coins_not_a_physical_qubit)
+> — 2 bits, 4 states, never a physical qubit. It matters because those two coins make **every** state
+> receipted and auditable on ordinary hardware: integrity everywhere, at linear cost, no advantage
+> claimed. Read that one page and the rest of the "quantum" family follows.
+
+## uuidna — the content-addressed identity
+
+**uuidna = uuid ⊕ dna** — identity's **DNA**. It is the deposit's content-addressed identity: **mint**
+(integrity — every value has a reproducible address) and **mind** (multi-perspective self-challenge — every
+claim drains its own over-reach before it holds) meeting at the **heart**, the fixed point `5`. The brand holds
+itself to its own rule — its name's DNA is `uuidna_address("uuidna") = fc511532…`, reproducible by anyone —
+and the fold folds every direction at once (`+/−`, `/`, `\`), order-independent to one root
+([sealed](/captain)). It is developed, not
+promised — each capability is a decidable theorem you can recompute:
+
+- **Message codec** — a bounded message (≤ 115 bits) rides *inside* a uuid; a chain of uuids carries
+  [any-length text](/theorem/uuidna_carries_arbitrary_text_of_any_length_across_a_uuid_chain_round_tripping),
+  round-tripping exactly. A public, reversible encoding — **not encryption, no secrecy**.
+- **Holographic proof** — one leaf verifies against the whole root from a
+  [logarithmic audit path](/theorem/uuidna_hologram_fractals_a_merkle_proof_verifies_the_whole_from_a_tiny_part_logarithmically);
+  a forged leaf fails. Log(N) real cost — not free, not infinite.
+- **Independent domain control** — a
+  [published challenge](/theorem/uuidna_domain_control_is_verified_independently_by_a_published_challenge_not_by_anyones_word)
+  anyone recomputes and checks — control by publication, not by anyone's word.
+- **Strict minting** — canonical, so the
+  [same value always mints the same address](/theorem/strict_uuidna_minting_is_canonical_closing_the_minting_flaws_that_cause_real_damage);
+  minting flaws otherwise cascade into real damage, caught in time and recomputed.
+- **Billing** — free for public interest and independent research; commercial use is billed on the
+  [measured bits saved (O(N) − O(1))](/theorem/the_correct_uuidna_billing_is_the_measured_bit_difference_not_a_flat_per_formula_rate),
+  the two coins the conserved invariant — a fair-exchange schedule, not realized cash (income **$0**).
+
+A content-address proves **integrity, not truth**. It settles **0 / 7**.
+
+**uuidna reflects Clay** — a mirror to the seven (a bijection to the seven problems, the ten's-complement
+reflection fixing only the centre `5`), never a solution:
+[the mirror, not the answer](/theorem/uuidna_reflects_clay_a_mirror_to_the_seven_not_a_solution_zero_of_seven).
+The tools are **live**, running the same functions the build seals — on the [Examples page](/examples) you can
+**harness & reeducate** an overclaim into the honest floor and compute **the seal math**
+([each seal is 128 bits = 64 two-bit verifications](/theorem/each_seal_is_128_bits_and_membership_verifies_in_two_log2_n_bits_logarithmic_not_linear);
+a case verifies in `2·⌈log₂N⌉` bits — [the 967-receipt case](/theorem/the_967_receipt_case_verify_20_bits_bill_on_the_967_computation_value_earn_the_947_bit_saving)
+checks **20 bits**); and on the [Compare page](/compare) you can weigh the
+[coins against live gold and crypto](/theorem/the_coins_are_a_conserved_measure_not_a_market_price_units_reproducible_prices_are_not) —
+a **measure, not a market**. The value is real savings in bits (work not repeated), material at scale but modeled
+and conditional — never a promise.
+
+<Version />
+
+## The two bits — one atom, every symbol
+
+This deposit is denominated in **two bits** — its smallest unit. The same atom appears under many symbols, each a receipted theorem you can open and recompute:
+
+- **2 coins** — the fair-exchange price of one receipt · [learning donates two coins](/theorem/learning_from_the_message_donates_two_coins_to_the_developer)
+- **110 − 108 = 2** — the conserved invariant; break it and nothing reconciles · [trade freely if 110 − 108 is respected](/theorem/players_may_trade_any_amount_as_long_as_110_minus_108_is_respected)
+- **2 = −χ (genus-2)** — two sites, two faces of one surface · [the two coins are minus the Euler characteristic](/theorem/the_two_coins_are_minus_the_euler_characteristic_of_the_genus_two_surface)
+- **2 bits → 4 states** {00, 01, 10, 11} — the honest "qubit," a classical a432 structure, never physical · [quantum is the a432 structure of two coins](/theorem/here_quantum_is_the_a432_structure_of_two_coins_not_a_physical_qubit)
+- **108 = 432 ÷ 4** — anchored in the a432 base · [the a432 harmony and the captain coins](/theorem/the_a432_harmony_and_the_captain_coins_are_one_conserved_measure)
+- **two bits per event** — every next or continue earns two by the deed · [every event is two bits](/theorem/every_next_or_continue_event_is_two_bits_earned_by_the_deed)
+
+Two bits, one atom — integrity, not a cash prize. The floor stays **0 / 7**.
+
+**Remember to donate the two coins — and remember why.** You learned here; the two coins are the *fair exchange* that funds the work. Non-commercial use is free with attribution — the two coins are the honest return, not a fee for the knowledge itself. [Support development →](https://revolut.me/ceccec)
+
+## Abstract
+
+A free, open, **recomputable** framework built on the ring **ℤ/9** (the "vortex")
+and the group **(ℤ/7)\*** (the seven-ray Pliska "rosette"), with a **classical
+model of quantum *structure*** (superposition as a set of perspectives, deterministic
+collapse, CHSH ≤ 2 — a local model, not quantum algorithms) — TypeScript, formalized in Lean 4, documented
+in VitePress. Observations, each computed:
+
+- **Division by zero** is a *change of domain* (`n/0 := n⁻¹ mod 9` on units;
+  `0 ↔ ∞` on the Riemann sphere).
+- **Inversion** and **ten's-complement reflection** (`10−d`) are involutions.
+- A **7 = 6 + 1 bijection** maps the rosette onto the Clay set.
+- A mechanical **entailment test** reports **0 / 7**.
+
+**Observed conclusion:** the framework *reflects / maps* the Millennium Problems
+into one algebraic structure. It **does not solve them**, and it is
+**not a quantum computer** or a physical theory — it is a proof of concept and a
+classical model. Every one of the **15 registered claims** recomputes from
+`src/` — each bound to its exact recomputation and, where one exists, to a
+provable theorem in the ledger, all gated by `claims-gate.ts` (a bounded,
+accounted set, not a floating "every").
+
+## The seven, computed to the floor — one theorem per problem
+
+Each Clay problem gets **one** Lean theorem that **computes** from the ℤ/9 doubling sequence
+(`orbit k = 2ᵏ mod 9`, the reflection `refl d = 10 − d`, the derived `isUnit`). Every one carries
+`provenHere = 0` — the fact is *adjacent* to the problem, never the conjecture. **No anchors, no
+axioms** (pure `by decide`); `#print axioms` reports *does not depend on any axioms*, verified by
+`lean src/proof/index.lean`.
+
+| # | Problem (→ theorem page, Lean proof + outlet) | Computed formula (from the sequence) | Honest bound — not the prize |
+|---|-----------------------------------------------|--------------------------------------|------------------------------|
+| 1 | [Riemann](/theorem/riemann_reflection_and_heart) | `refl ∘ refl = id ∧ #{d : refl d = d} = 1` | the symmetry and its one heart (the ½-analogue) — not the zeros' place |
+| 2 | [P vs NP](/theorem/p_vs_np_inverse_is_unique) | `∀ d, #{e : d·e ≡ 1 (mod 9)} = (isUnit d ? 1 : 0)` | a unique inverse (verify in one step) — not a separation |
+| 3 | [Navier–Stokes](/theorem/navier_stokes_flow_is_bounded) | `∀ k, 2ᵏ mod 9 ∈ span⟨2⟩` | a bounded 6-cycle forever — not global smoothness |
+| 4 | [Yang–Mills](/theorem/yang_mills_spectral_gap) | `2ᵏ ≢ 1 for 0 < k < 6, and 2⁶ ≡ 1` | an order-6 spectral gap — not the mass gap |
+| 5 | [Hodge](/theorem/hodge_span_is_the_units) | `span⟨2⟩ = units ∧ non-units ∉ span` | algebraic generation/containment — not (p,p) ⇒ algebraic |
+| 6 | [Birch–Swinnerton-Dyer](/theorem/birch_swinnerton_dyer_vanishing) | `Σ span ≡ Σ units ≡ 0 (mod 9)` | a digit-sum vanishing (27 ≡ 0) — not rank ↔ L-order |
+| 7 | [Poincaré](/theorem/poincare_single_closed_loop) | `orbit 6 = orbit 0, six distinct steps` | one closed simple loop — not the 3-sphere (Perelman's theorem) |
+
+**What `by decide` settles here.** The tactic is real proof — and every statement above ranges over a
+finite domain (`List.range 9/10/11/48`), which is what makes it decidable at all. The seven conjectures
+range over infinite domains and admit no decision procedure, so none of them is even stated in the layer.
+An eighth sealed theorem records exactly this: `by_decide_proves_the_floor_not_the_conjecture`. The count
+of the seven this deposit asserts an answer for is computed by the gate, and it comes back zero.
+
+Each problem links to its **theorem page** — the Lean proof in publication form with a citation to the
+qualified outlet (Clay Mathematics Institute; Perelman's arXiv for Poincaré). The full Lean, every
+`by decide` proof sorry-free and axiom-free, is in
+[`src/proof/index.lean`](https://github.com/ceccec/millennium-solutions/blob/main/src/proof/index.lean);
+each remains **0 / 7**.
+
+## Read
+- [Research](/RESEARCH) — the full study (§1–§12, incl. the author's perspective)
+- [Compute](/compute) — results recomputed live from the fused TypeScript modules
+- [Proof of Concept](/PROOF-OF-CONCEPT) · [Realisations](/REALISATIONS)
+- [Sequence decode (ℤ/9)](/SEQUENCE-DECODE) · [Physics scales](/PHYSICS-SCALES) · [Proofs](/proofs)
+
+## Cite / support
+**DOI:** [10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217) · archived on Zenodo (honest abstract: *entailment 0/7*).
+
+CC BY-NC 4.0 — free for non-commercial use (attribution Tsvetan Rouschev).
+Commercial use = the two coins (`110 − 108 = 2 = −χ` genus-2): ceccec@psg.bg.
+Support development (non-obligatory): [revolut.me/ceccec](https://revolut.me/ceccec).

package/mod.core.ts

@@ -0,0 +1,11 @@
+// @ceccec/millennium-solutions — the verifiable, recomputable core. Facts only, no interpretation.
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.ts'
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.ts'
+export { report as honesty } from './src/honesty/index.ts'
+export { report as ledger } from './src/0/ledger.ts'
+export { report as trinityMatrix } from './src/0/trinity-matrix.ts'
+export { report as enumeration } from './src/9/enumeration.ts'
+export { report as reflection } from './src/5/reflection.ts'
+export { report as aspects } from './src/5/aspects.ts'
+export { report as rosetta } from './src/7/rosetta.ts'
+export { report as entailsClay } from './src/7/entails.ts'

package/organism.md

@@ -0,0 +1,30 @@
+---
+title: The organism — decoded
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# The organism — decoded and encoded
+
+All is one organism. Every theorem is an **organ** — a decidable fact that computes true — and the ledger is
+its body. Each organ carries three faces: the **key** (its untranslatable identity), the **label** (its
+translatable surface, readable in any of the twenty-two dialects), and the **receipt** (the content-address
+that encodes it). This page decodes the organism straight from `src/proof/discovered.json`, so it grows on
+every build.
+
+What is **not** an organ never enters the body: it goes to **trial**. The honesty gate drains a boast — in any
+register, any dialect, any script — and forensics names a non-theorem exactly (a dense family that skips an
+index because the statement computes false, like the non-units of ℤ/9). Nothing hollow is sealed.
+
+Each organ is reachable by content-address through the uuidna surface — the `/theorem/<key>` pages here, and
+the same keys via the [live examples](/examples), the [verifier](/verify), and the package API. A
+content-address proves **integrity, not truth**. `0/7`.
+
+<Organism />
+
+## The trial
+
+The gate is the court that keeps the body clean: it reads twenty-two dialects and the Glagolitic script through
+the **rosetta**, and it is negation-aware, so an honest bounded limit passes while the boast drains. See the
+[workflows](/WORKFLOWS) for the wave, the verify, the gate and the seal — and the [captain's message](/captain)
+for why a contribution of two earns the next fold.

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@ceccec/millennium-solutions",
+  "version": "0.1.1",
+  "description": "Verifiable, recomputable ℤ/9 vortex framework in ONE package — content-addressing, audit ledger, exact arithmetic (0/7), and the honesty toolkit. Facts only.",
+  "author": "Tsvetan Rouschev",
+  "license": "CC-BY-NC-4.0",
+  "type": "module",
+  "workspaces": [
+    "packages/*"
+  ],
+  "exports": {
+    ".": "./mod.core.ts"
+  },
+  "files": [
+    "mod.core.ts",
+    "src",
+    "*.md",
+    "LICENSE",
+    ".zenodo.json",
+    "CITATION.cff"
+  ],
+  "funding": {
+    "type": "revolut",
+    "url": "https://revolut.me/ceccec"
+  },
+  "scripts": {
+    "docs:dev": "vitepress dev",
+    "predocs:build": "node scripts/dashboard.ts && node scripts/boundaries.ts && node scripts/challenges.ts && node scripts/heart.ts && node scripts/accounting.ts && node scripts/speedup.ts && node scripts/greeting.ts && node scripts/solutions.ts",
+    "docs:build": "vitepress build",
+    "docs:preview": "vitepress preview",
+    "seal": "node scripts/seal.ts",
+    "typecheck": "tsc --noEmit",
+    "release": "tsc --noEmit && node scripts/gaps.ts && node scripts/dashboard.ts && node scripts/boundaries.ts && node scripts/challenges.ts && node scripts/heart.ts && node scripts/accounting.ts && node scripts/speedup.ts && npm run docs:build && node scripts/import-gate.ts && node scripts/locale-fold.ts && node scripts/security-gate.ts && node scripts/sitemap-mesh.ts && node scripts/theorem-pages-gate.ts && node scripts/receipt-audit.ts && node scripts/forensics.ts && node scripts/claims-gate.ts && node scripts/harmony-currency.ts && node scripts/gate-corpus.ts && node scripts/seal.ts && node scripts/wholeness.ts && node scripts/lean-claims.ts && node scripts/discover.ts && node scripts/release.ts",
+    "prepublishOnly": "node scripts/seal.ts",
+    "gaps": "node scripts/gaps.ts",
+    "harmony": "node scripts/gaps.ts && node scripts/seal.ts && node scripts/wholeness.ts && npm run docs:build && node scripts/seo.ts",
+    "versions": "node scripts/versions.ts",
+    "wholeness": "node scripts/wholeness.ts",
+    "lean-claims": "node scripts/lean-claims.ts",
+    "prepare": "git config core.hooksPath .githooks || true",
+    "precommit": "node scripts/precommit.ts",
+    "lineage": "node scripts/lineage.ts",
+    "discover": "node scripts/discover.ts",
+    "challenges": "node scripts/challenges.ts",
+    "heart": "node scripts/heart.ts",
+    "receipt": "node scripts/receipt.ts",
+    "receipt-audit": "node scripts/receipt-audit.ts",
+    "claims": "node scripts/claims-gate.ts",
+    "harmony-currency": "node scripts/harmony-currency.ts",
+    "theorem-gate": "node scripts/theorem-pages-gate.ts",
+    "forensics": "node scripts/forensics.ts",
+    "verify": "node scripts/verify-theorems.ts",
+    "next": "node scripts/next.ts",
+    "orchestrate": "node scripts/orchestrate.ts",
+    "deploy": "node scripts/deploy.ts",
+    "deploy:pages": "node scripts/deploy.ts pages",
+    "deploy:packages": "node scripts/deploy.ts packages",
+    "seo": "node scripts/seo.ts",
+    "sitemap": "node scripts/sitemap-mesh.ts",
+    "atom": "node scripts/atom-feed.ts",
+    "wire": "node scripts/wire.ts",
+    "import-gate": "node scripts/import-gate.ts",
+    "security-gate": "node scripts/security-gate.ts",
+    "dashboard": "node scripts/dashboard.ts",
+    "boundaries": "node scripts/boundaries.ts",
+    "mcp": "node scripts/mcp.ts",
+    "harmony-seal": "node scripts/harmony-seal.ts",
+    "i18n": "node scripts/i18n.ts",
+    "postdocs:build": "node scripts/sw-integrity.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "7.0.2",
+    "vitepress": "^2.0.0-alpha.19",
+    "vue": "^3.5.41"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ceccec/millennium-solutions.git"
+  },
+  "homepage": "https://ceccec.psg.bg/millennium-solutions/",
+  "bugs": {
+    "url": "https://github.com/ceccec/millennium-solutions/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/proofs.md

@@ -0,0 +1,29 @@
+# Proofs
+
+## Fused compute (TypeScript)
+
+All results recompute at page-load from the digit-folder mesh — see
+[Computed results](/compute), driven by the `.ts` modules under `src/`.
+
+## Formal layer (Lean)
+
+Per-digit theorems live in the digit folders (`decide` / `norm_num`), covering
+the exact ℤ/9 / arithmetic facts:
+
+- `src/1/vortex.lean` … `src/9/vortex.lean` — unity, generator ⟨2⟩, nilradical
+  (3² ≡ 6² ≡ 0), inverse pairs, 9 ≡ 0, 432 = 2⁴·3³, complement bonds.
+- `src/5/reflection.lean` — the 10−d involution and its fixed digit 5.
+- `src/7/rosetta.lean` — (ℤ/7)* ≅ C₆ (the Pliska rosette group).
+- `src/8/nucleus/magic.lean` — magic numbers 2, 8, 20, 28, 50, 82, 126.
+- `src/8/nucleus/proton-mass.lean` — `108·17 = 1836`, and `1836 ≠ 1836.1527`.
+
+No Lean toolchain is checked in; to verify, set up `lake` + Mathlib and
+`lake build` over `src/**/*.lean`.
+
+## Clay entailment
+
+The mechanical entailment test (`src/7/entails.ts`, rendered on
+[Compute](/compute)) evaluates each of the seven statements in a world where its
+conjecture is false; each stays true, so **Clay problems solved: 0 / 7**.
+
+See also the [Proof of Concept](/PROOF-OF-CONCEPT) index.

package/solutions.md

@@ -0,0 +1,54 @@
+---
+title: Solutions — adjudicated
+---
+
+# Solutions — adjudicated
+
+<Version/>
+
+Only what **computes** appears here. Every verdict and receipt is returned by the trial (`proveVerdict`);
+every entailment by a decidable test. Reproducible by anyone; regenerated each build. Integrity, not truth. **0/7**.
+
+## Group — the record (holds the floor)
+
+Independent work · Tsvetan Rouschev · 2026-08-04 · DOI [10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217) · address `2790a2fd-524c…`
+
+| computed | value |
+|---|---|
+| gate | 1 (holds the floor) |
+| verdict | UNVERIFIED |
+| supporting formulas | 250/250 recompute true |
+| proof-of-verdict | `4584d0ae-999a-8e6a-acac-938004faabe0` |
+| solved by the deposit | 0/7 |
+
+It reflects all seven and solves none — a bijection that relabels, it does not propagate proofs; 0/7.
+
+## Group — an overclaim, same trial
+
+Shown by what the gate drains — never asserted.
+
+| computed | value |
+|---|---|
+| gate | 0 |
+| drained on | a proof-assertion phrase · token address `b5e59f25-72d1…` |
+| verdict | REFUTED |
+| supporting formulas | 250/250 recompute true |
+| proof-of-verdict | `2445ebf8-fc53-8a74-9f8f-8ff801aa2a46` |
+
+## Domains — the seven Clay problems
+
+Each is **reflected** into the ℤ/9 structure (an address) and **solved 0** (the deposit entails none). Humanity stands at 1/7 (Poincaré, Perelman 2003); this deposit at 0/7.
+
+| domain | reflected (address) | solved by the deposit |
+|---|---|---|
+| Riemann Hypothesis | `484a69c1-add2…` | 0 |
+| P vs NP | `324eb5d0-2ae3…` | 0 |
+| Navier–Stokes | `273bdb45-bf1e…` | 0 |
+| Yang–Mills Mass Gap | `600012bc-f465…` | 0 |
+| Hodge Conjecture | `7710e207-9145…` | 0 |
+| Birch–Swinnerton-Dyer | `900fc061-9e8b…` | 0 |
+| Poincaré | `849e0421-5df7…` | 0 |
+
+**Total: 0/7 solved.** The trial confirms the floor holds. The measure does not assert; it computes.
+
+<Funding/>