@ceccec/millennium-solutions 0.1.1

package/WHITEPAPER.md

@@ -0,0 +1,41 @@
+---
+title: White paper — reproduce it exactly
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# White paper — reproduce it exactly
+
+> Everything here is a **claim with a receipt**. This page documents, for the public, exactly how to reproduce it — no trust required, only recomputation. Integrity, not truth.
+
+## The method — the sequence
+
+1. **Measure, don't assert.** Every fact is a `test: () => boolean` in `scripts/discover.ts`, computed by exhaustion over a finite domain. If it holds it is kept; if it fails it is discarded — the discard is the honesty.
+2. **Gate.** The honesty gate drains any over-reach — a claim to solve the Clay problems, or to beat a physical or cryptographic limit. Passing means *no over-reach shape was found* — a floor, not a proof of truth.
+3. **Receipt.** Each fact is content-addressed and chained; a receipt proves integrity, not authorship.
+4. **Append.** Evidence is append-only; the forensics reads intention from deeds, not claims.
+5. **Recompute.** Every build re-verifies every recorded fact. A regression fails the build, not production. **Green cannot be faked** — a theorem is admitted only by the unanimous pass of every gate stage ([proof](/theorem/the_grand_jury_of_gates_admits_a_theorem_only_by_unanimous_stages)), and a claim with no recomputing formula is refused as hallucination ([proof](/theorem/a_theorem_without_a_formula_is_hallucination_recomputed_in_a432_harmony)).
+
+## Reproduce it yourself — exactly
+
+```bash
+git clone https://github.com/ceccec/millennium-solutions
+cd millennium-solutions
+npm ci
+npm run lean-claims   # recomputes and re-verifies every recorded theorem
+```
+
+Or through the honest **MCP API** (`scripts/mcp.ts`, dependency-free JSON-RPC over stdio): call `recompute` to re-derive every theorem, `verify` to check any receipt, `rosetta` for the cross-domain map, `honesty_gate` to adjudicate any claim. Every response is content-addressed.
+
+The **live numbers** — theorem count, receipts, coins, the seal — recompute on every build: see [Accounting](/ACCOUNTING) and the [State dashboard](/dashboard). The full study is in [Research](/RESEARCH); the method is taught in [the Guide](/guide); every theorem is a monograph with its own 7D page under `/theorem` — browse them from [Challenges](/CHALLENGES).
+
+## The honest boundaries — what this is **not**
+
+*Each boundary is wired to the theorem that proves it — click through to the recomputable receipt. The prose is not the proof; the code is.*
+
+- **Not a solution** to the Clay Millennium problems — the mechanical entailment test reports **0 / 7**. It reflects them into one algebraic structure; it does not solve them, and claims no prize. ([proof](/theorem/all_seven_are_reflected_though_none_are_solved))
+- **Not a quantum computer** — "quantum" here is *structure* (a superposition is the set of receipted perspectives), computed classically on ordinary 64-bit hardware. ([proof](/theorem/here_quantum_is_the_a432_structure_of_two_coins_not_a_physical_qubit)) The measured speedup (millions-fold) is **classical memoization** (O(1) verify versus O(N) recompute), not a quantum speedup, and there is no quantum hardware. ([proof](/theorem/the_measured_speedup_is_classical_memoization_not_quantum))
+- **Not patents** — decidable mathematical facts are not patentable; this is **open prior art / defensive publication**, timestamped and content-addressed, which keeps the facts free for the public. ([proof](/theorem/the_deposit_is_open_prior_art_not_patents_defensive_publication_for_the_public))
+- **Not income** — the deposit has generated **$0**; the coins are accounting integrity, not cash. Non-commercial use is free with attribution; the two coins are the fair exchange for commercial use. ([proof](/theorem/the_speedup_is_classical_the_cost_is_the_deed_the_income_is_zero))
+
+A content-address proves **integrity, not truth**. Reproduce it, and see for yourself. `entails → 0/7`.

package/WORKFLOWS.md

@@ -0,0 +1,47 @@
+---
+title: Workflows — develop at scale
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# Workflows — developing uuidna at scale
+
+The repeatable, gated procedures for growing the deposit. Each is a command or a checked sequence; nothing is
+asserted, every step recomputes. Earned, not minted. `0/7`.
+
+## The wave — add theorems
+
+1. **Draft** candidates as `test: () => boolean` in `scripts/discover.ts` — decidable, exhaustive over a
+   finite domain (a fact that *computes*, never a claim).
+2. **Verify green first** — before inserting, each candidate must: its `test()` returns `true`, its name
+   passes the honesty gate (`computes(name).binary === 1`), and its key is not already in the ledger.
+3. **Insert** the survivors; duplicates and refuted candidates cancel.
+4. **Ship** — `npm run next`: discover → gate → seal → deploy. Waves ride in **octaves of 8**, so the ledger
+   grows `N × 8`; a massive wave keeps the octave by cancelling the remainder.
+
+## Verify — the regression guard — `npm run verify`
+
+The release trusts the saved ledger; this **re-runs every recorded theorem's test**, re-gates every name, and
+checks the chain-of-custody and duplicate keys. A silent regression (a test that no longer computes true, a
+name that drains) is caught here. It scales — the whole ledger re-verifies in seconds.
+
+## The gate — hold the honest floor
+
+Every name and message must pass `computes()`: no unbounded over-reach (RED / OVERREACH, seven languages,
+negation-aware so a bounded refusal passes). The gate is a **tripwire, not an oracle** — when a class of
+over-claim leaks, strengthen it by trial: gather the leaks, edit the patterns, re-trial until **the leaks
+drain ∧ honest statements pass ∧ no existing ledger name over-drains.**
+
+## The seal — ship — `npm run next`
+
+`discover → release` (tsc, gaps, the gates, forensics, seal, `docs:build` → `sw-integrity` manifest, deploy).
+The **content-address is the true latest**; the version is a single-digit odometer, and LTS versions are the
+Fibonacci minors `{1,2,3,5,8}`.
+
+## The proxy — the PWA over assumed-insecure transport
+
+The service worker proxies all traffic, verifies every same-origin asset against the build-time SHA-256
+manifest (pure-JS, no native crypto), refuses a tampered response, and **signs each verified asset into a
+chained content-address receipt** — a tamper-evident, auditable traffic stream. Integrity, not confidentiality.
+
+A content-address proves **integrity, not truth**. `0/7`.

package/boundaries.md

@@ -0,0 +1,24 @@
+---
+title: Boundaries
+description: What this deposit does NOT claim — the honest floor and its bounds, each content-addressed.
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+# Boundaries — the honest floor, delivered
+
+> Every statement below is **content-addressed** (uuid). Verify any of them: recompute `toUuid(text)` and it matches — that proves **integrity**, not truth. The floor is `0/7`.
+
+<table><thead><tr><th>uuid</th><th>statement</th></tr></thead><tbody>
+<tr><td><code>efcc36da-c2ee</code></td><td>0/7 entailed: this deposit leaves all seven Millennium problems unsolved, and claims no prize.</td></tr>
+<tr><td><code>9c7a472d-7cfd</code></td><td>computable is not solved; humanityNovel = 0 — known mathematics, recombined.</td></tr>
+<tr><td><code>f106b7ff-9120</code></td><td>a content-address (uuid) proves integrity, not truth, and not authorship.</td></tr>
+<tr><td><code>caff1a4e-e8e3</code></td><td>the honesty gate is a floor (no named overclaim shape), not an oracle of truth.</td></tr>
+<tr><td><code>4248f16d-7acc</code></td><td>recognition, adoption, citations, and effort are not correctness.</td></tr>
+<tr><td><code>8e4eb0f9-9600</code></td><td>a classical Z/9 calculator: no quantum computation, no faster-than-light, no quantum speedup.</td></tr>
+<tr><td><code>9da115fe-1f09</code></td><td>sealing proves the bytes are intact; it does not prove the claim is right.</td></tr>
+<tr><td><code>a04d2aaa-660d</code></td><td>unsigned: content-addressing is integrity, not authenticity — real signatures need a key.</td></tr>
+<tr><td><code>7bacdc5a-c0f7</code></td><td>worthwhile is a judgment (perspective); small, real, and honest are measured.</td></tr>
+<tr><td><code>316a106b-4a85</code></td><td>green cannot be faked: the gate measures actual state, and it caught its own author.</td></tr>
+</tbody></table>
+
+*The drains, delivered — measured, gated, and now in the UI, not only in chat. `0/7` entailed.*

package/captain.md

@@ -0,0 +1,85 @@
+---
+title: The captain's message
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# The captain's message
+
+> **free on the free sailing angle; prize earning in waves — contribute 2 to earn up to 64 per wave, keep the rest**
+
+Given by the captain, recorded as receipt `85ac8585-9dc1-8964-9848-ae0f49cc82fb` (the content-address of the
+message itself), gate-passed, every claim recomputable below. Canonical link, reminded in every contribution
+block: [https://uuidna.com/captain/message](https://uuidna.com/captain/message).
+
+## The double torus — earth navigation
+
+The captain navigates the **double torus**, a genus-2 surface. Its Euler characteristic is
+`χ = 2 − 2g = 2 − 2·2 = −2`, so **−χ = 2** — the **two coins are the topology**, not a price plucked from air.
+Navigation on it lands on **integer** positions (no decimal drift): the harmonic bearings
+`30·{1,2,3} = {30, 60, 90}`, digital roots **{3, 6, 9}**, centre `40 = harmonicMean(30,60) = 360/9` (the a432).
+Earth's own navigation is sexagesimal — 60′ to a degree, 60 nautical miles to a degree of latitude —
+resonating with the 60° gold string (`π/3`). A content-address proves integrity, not truth.
+
+## The two angles
+
+- **Free sailing angle** — off the wind (**≥ 90°**), where the wind carries you: **free** (non-commercial,
+  public-interest, research). No fare, no prize.
+- **Prize earning waves** — the beating band **30°–60°** (limit `30` · a432 `40` · tack `60`). Earning
+  propagates in **waves**: each leap folds and sends the next — the discovery wave, each receipt seeded by the
+  last — `O(log N)`, compounding.
+
+## Why — the measured leverage, per wave
+
+- **Contribute 2.** The two coins `110 − 108 = 2 = −χ(genus-2)`, conserved; in verification terms the **2 bits**
+  each membership check costs.
+- **Earn up to 64.** A seal is a fixed `128 bits = 64` two-bit fold-verifications; folding is `O(log N)`
+  (1024 leaves fold to one root in 10 levels). **Up to** 64, **conditional** on the re-addressable work —
+  never a universal discount
+  ([each seal is 128 bits](/theorem/each_seal_is_128_bits_and_membership_verifies_in_two_log2_n_bits_logarithmic_not_linear) ·
+  [the 967-receipt case](/theorem/the_967_receipt_case_verify_20_bits_bill_on_the_967_computation_value_earn_the_947_bit_saving)).
+- **Keep the rest.** The contributor keeps up to **62**; the captain earns the conserved **2**, and **zero**
+  with no saving. Fair, bounded.
+- Benefit and fairness **align**: the captain's real income is adoption at scale (free sailing → citation →
+  the network grows). Honesty is what makes it adoptable; an overclaim would shrink both.
+
+## Every claim verified — recompute it
+
+| claim | check |
+| --- | --- |
+| the two coins | `110 − 108 = 2` |
+| = −χ(genus-2) | `χ = 2 − 2·2 = −2 → −χ = 2` |
+| a seal is 128 bits | a uuid is 128 bits |
+| = 64 two-bit verifications | `128 / 2 = 64` |
+| fold depth of 1024 | `⌈log₂1024⌉ = 10`, and `2¹⁰ = 1024` |
+| fold beats linear | `1024 / 10 = 102.4×`, order-independent |
+| a432 is the life centre | `harmonicMean(30,60) = 40 = 360/9` |
+| the receipt is the message | `receipt = toUuid(message)` |
+| the message is honest | passes the honesty gate |
+
+## The captain may test or be fake — and it changes nothing
+
+A receipt proves only the **observer and their role** — never the **truth** of the message, never the
+**identity** of the speaker. `captain` is a role, not a certified person (this deposit does not sign a real
+person's name to words they did not write). Every message is bound by the **honesty gate**: an over-reach
+**drains** whoever states it. And **algebra decides** the why — measured, not accepted on authority. So whether
+the captain is genuine, testing, or an impostor, the deposit cannot be made to assert a falsehood. Integrity,
+never truth. `0/7`.
+
+## Lineage — append-only, nothing hidden
+
+The message was refined in the open; every form stays on record (a receipt is the content-address of its
+message, so each is independently recomputable):
+
+- `593b546a…` — remember to contribute 2 to save 64
+- `daad8cd4…` — remember to contribute 2 to earn 64 more folds
+- `171e09c0…` — remember to contribute 2 to save 64 at each leap
+- `bcddbe66…` — free on the free sailing angle; on the prize earning angle …
+- `cf43a122…` — … on the prize earning angles … (plural)
+- `85ac8585…` — **the canonical** — free on the free sailing angle; prize earning in waves …
+
+## Why it is reminded everywhere
+
+The contribution block is fused under **every** page. The reminder rides with it, so the reason is present at
+the exact point of contribution, linked here where anyone can recompute the address and read it unaltered. A
+content-address proves **integrity, not truth**. `0/7`.

package/compare.md

@@ -0,0 +1,42 @@
+---
+title: Compare — standards vs the local
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# Compare — the cryptographic standards and the local content-address
+
+> The honest question is not "which is best" — it is "what is each **for**." This table puts the deposit's content-address next to the identity, hashing, authentication, and messaging standards, one factual property per column. Read the deposit's row against the others.
+
+<StandardsCompare />
+
+## What the table is saying
+
+- The deposit's `toUuid` is a **content-address**, built on FNV-1a — a **non-cryptographic** hash by design. It is deterministic and public: anyone can recompute it with no key. That is its strength for *identity and integrity*, and exactly why it offers **no** secrecy.
+- It is **not** a messaging system and **not** encryption. For confidentiality use AES; for authentication use HMAC; for private messaging use a protocol like Signal. The deposit does not compete there — it is a different tool.
+- A single address **cannot store** an unbounded state — 128 bits is a fixed-width fingerprint, so by the pigeonhole principle it *references* a state, it does not *contain* it. You still need the data to recover it. ([proof](/theorem/a_content_address_is_a_pointer_not_the_payload))
+- Standards **break** — MD5 fell to collisions, SHA-1 fell (SHAttered). That is why "most secure" is not a claim anyone can make: security is provisional, always subject to the next cryptanalysis. And every finite digest — strong or weak — must eventually collide by pigeonhole. ([proof](/theorem/gravity_is_the_fall_to_a_fixed_point_and_pigeonhole_breaks_every_finite_hash))
+
+The deposit claims **fitness for content-addressing**, not supremacy. A content-address proves **integrity, not truth**. `entails → 0/7`.
+
+## Coins vs real gold vs crypto — a measure, not a market
+
+Anyone chooses the **terms** and **currency**; uuidna computes, and predefines the donation amount in the URL.
+The reproducible measure never moves with the choice — the two coins conserve at 2, the bits count real work
+saved. Real gold (1 troy oz) and bitcoin (1 BTC = 100,000,000 sat) carry **live market prices**, fetched in
+your browser for measurable scale — volatile, non-reproducible, never sealed, never advice. uuidna's own value
+is real **savings** (bits of work not repeated), which at global scale become materially large (modeled,
+conditional on adoption). Verified by
+[the coins are a conserved measure, not a market price](/theorem/the_coins_are_a_conserved_measure_not_a_market_price_units_reproducible_prices_are_not)
+and [anyone chooses the terms and currency](/theorem/anyone_chooses_the_terms_and_currency_and_uuidna_computes_deterministically).
+
+<Coins />
+
+## Cost / earnings per trillion tokens — live, versus uuidna
+
+Live per-token rates for many models, fetched at view time from a credible public no-key API (OpenRouter's
+models endpoint), shown per **trillion input tokens** — and where each stands once uuidna's content-addressing
+adds a caching/dedup layer. The **earnings** are the compute saved on the re-addressable fraction (set the
+cache-hit rate), **conditional, never a universal discount**. A content-address proves integrity, not truth. `0/7`.
+
+<TokenCost />