@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/proofs.md

@@ -1,26 +0,0 @@
-# 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
-
-
-See also the [Proof of Concept](/PROOF-OF-CONCEPT) index.

package/quantum.md

@@ -1,40 +0,0 @@
----
-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. — this page settles no Clay conjecture and claims no quantum advantage in time.

package/rights.md

@@ -1,39 +0,0 @@
----
-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.
-
-*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

@@ -1,28 +0,0 @@
----
-title: Solutions
----
-
-# Solutions
-
-<Version/>
-
-## The author's claim
-
-**Tsvetan Rouschev claims the seven Clay Millennium problems solved through the involution each is stated across**
-— deposited as [10.5281/zenodo.21781603](https://doi.org/10.5281/zenodo.21781603) and
-[Zenodo 22256707](https://zenodo.org/records/22256707), with this repository at
-[10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217). This is his claim, recorded in his name.
-
-## The seven, each reflected into the ℤ/9 structure
-
-| problem | address in the structure |
-|---|---|
-| Riemann Hypothesis | `484a69c1-add2…` |
-| P vs NP | `324eb5d0-2ae3…` |
-| Navier–Stokes | `273bdb45-bf1e…` |
-| Yang–Mills Mass Gap | `600012bc-f465…` |
-| Hodge Conjecture | `7710e207-9145…` |
-| Birch–Swinnerton-Dyer | `900fc061-9e8b…` |
-| Poincaré | `849e0421-5df7…` |
-
-<Funding/>

package/speedup.md

@@ -1,41 +0,0 @@
----
-title: The real uuidna advantage
-description: The measured uuidna advantage — O(N)→O(log N) verification, O(N)→O(1) reuse — in all domains. Not faster compute, not FTL, not quantum.
-head:
-  - ['meta', { name: 'robots', content: 'index, follow' }]
----
-
-# The real uuidna advantage — measured, in all domains
-
-> Generated from the **2755** 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.
-
-## Measured — verify and reuse, not recompute
-
-| N | recompute (ops) | verify (⌈log₂N⌉ nodes) | bits (2·⌈log₂N⌉) | saving | ratio |
-|---|---|---|---|---|---|
-| 8 | 8 | 3 | 6 | 5 | 3× |
-| 64 | 64 | 6 | 12 | 58 | 11× |
-| 967 | 967 | 10 | 20 | 957 | 97× |
-| 1,024 | 1,024 | 10 | 20 | 1,014 | 102× |
-| 1,000,000 | 1,000,000 | 20 | 40 | 999,980 | 50,000× |
-
-Computing the N things still costs **N** — the advantage is not there. It is on **verification**: a merkle
-inclusion proof checks membership in `⌈log₂N⌉` nodes (`2·⌈log₂N⌉` bits) instead of re-running all N. And on
-**reuse**: a content-address names a value once, so every re-reference is `O(1)`, and a 36-byte address
-travels, not the payload. Measured on the deposit's own functions, not asserted.
-
-## Why it holds in all 59 domains at once
-
-The advantage is the **fold / merkle-proof structure**, which is **domain-independent** — every domain's
-theorems verify in `⌈log₂N⌉`. So one proof covers the whole [rosetta](/): z9-arithmetic · units-triad · doubling-orbit · inverses · powers · primes · cyclic-groups · boolean-algebra · entanglement · dialectic · games · arts · ….
-
-## Discovery lead — a lead, never a verdict
-
-Grouping the 2755 receipts by the digital root of their address, the **sparsest** region is digit
-**3** (276) — a candidate area to examine, not a finding. The ledger is currently held
-at **2755** (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**.

package/src/0/chacha.ts

@@ -1,3 +0,0 @@
-// ChaCha20 + Poly1305 + the AEAD construction (RFC 8439, pure TS, KAT-verified) live canonically in
-// @uuidna/uuidna — one implementation shared by both apps, no re-declared copy.
-export { chachaBlock, chacha20, poly1305, aeadEncrypt, aeadDecrypt } from '@uuidna/uuidna'

package/src/0/crypt.ts

@@ -1,4 +0,0 @@
-// The encryption envelope — ChaCha20-Poly1305 core + PBKDF2-SHA256 KDF + uuidna 7d-fold envelope — lives
-// canonically in @uuidna/uuidna. One implementation shared by both apps; convergent seals, no re-declared copy.
-export { encrypt, decrypt, verifyEnvelope, ITER } from '@uuidna/uuidna'
-export type { Sealed } from '@uuidna/uuidna'

package/src/0/csp.ts

@@ -1,10 +0,0 @@
-// Single source of the Content-Security-Policy — imported by .vitepress/config.ts (head) AND
-// scripts/locale-fold.ts (stubs), so the policy is declared ONCE, never hardcoded twice (no drift).
-// Self-contained: no external scripts/styles/fonts/img/connect. 'unsafe-inline' is required (VitePress
-// injects inline check-dark-mode/check-mac-os scripts + inline style attributes; meta-CSP can't use
-// nonces) — so this hardens RESOURCE ORIGIN, not full anti-XSS. The deterministic guarantee is the
-// external-import gate (scripts/import-gate.ts) + the security gate (scripts/security-gate.ts).
-export const CSP =
-  "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; " +
-  "img-src 'self' data:; font-src 'self'; connect-src 'self'; object-src 'none'; " +
-  "base-uri 'self'; form-action 'self'; frame-ancestors 'none'"

package/src/0/entanglement.ts

@@ -1,31 +0,0 @@
-// Release entanglement (honest sense) — each release cryptographically BOUND to its neighbours.
-// A hash chain: change any release and every downstream address changes (avalanche). This is
-// tamper-evidence — correlation by DERIVATION — not quantum entanglement, and it carries no message.
-import { toUuid, merge, merkleFold } from './index.ts'
-
-export function report(): string {
-  const chain = (rs: string[]) => { let prev = toUuid('genesis'); const out: string[] = []; for (const r of rs) { prev = merge(prev, toUuid(r)); out.push(prev) } return out }
-  const sealOf = (rs: string[]) => merkleFold(chain(rs))
-
-  const releases = ['v1.0.34', 'v1.0.35', 'v1.0.36', 'v1.0.37']
-  const original = sealOf(releases)
-  const flipped = sealOf(['v1.0.34', 'v1.0.35', 'v1.0.36!', 'v1.0.37']) // alter ONE neighbour
-  const changed = original !== flipped
-
-  let o = 'release entanglement — each bound to its neighbours (honest sense):\n\n'
-  o += '  neighbours in the version line — each release folds with its predecessor (a hash chain):\n'
-  o += '    seal over ' + releases.join(', ') + '\n'
-  o += '      original: ' + original.slice(0, 13) + '…\n'
-  o += '      alter one neighbour (v1.0.36 → v1.0.36!): ' + flipped.slice(0, 13) + '…   changed? ' + changed + '\n'
-  o += '  → you cannot alter one release without the chain revealing it. neighbours are BOUND.\n\n'
-  o += '  bound in several computable "dimensions":\n'
-  o += '    · version line — the hash chain above (predecessor ↔ successor)\n'
-  o += '    · the mesh     — 10−d reflects each digit to its partner (4↔6, fixed 5)\n'
-  o += '    · the tree     — a merkle audit path binds each leaf to its siblings (see holographic.ts)\n\n'
-  o += 'HONEST: this is CRYPTOGRAPHIC DEPENDENCY — a hash chain, the basis of tamper-evidence — NOT\n'
-  o += 'quantum entanglement. Correlation by DERIVATION, not action-at-a-distance: altering a release\n'
-  o += 'does not reach out and change its neighbour\'s stored bytes; it makes recomputation reveal the\n'
-  o += 'break. No information travels without payload (no-communication theorem holds). "Entangled" =\n'
-  o += 'bound by the math, not by physics.'
-  return o
-}

package/src/0/fusion.ts

@@ -1,28 +0,0 @@
-// Tokens are valid only in the fusion — validity = MEMBERSHIP in the verified whole, not the token.
-// A bare UUID proves nothing (anyone can mint one). The same 64-bit string is valid inside the fused
-// root and meaningless outside it: an orphan token is not in the root, and adding it changes the root.
-import { toUuid, merkleFold } from './index.ts'
-
-export function report(): string {
-  const units = [1, 2, 4, 5, 7, 8], seven = [3, 2, 6, 4, 5, 1, 0]
-  const leaves: string[] = []; for (const u of units) for (const r of seven) leaves.push(toUuid(u + 'x' + r))
-  const root = merkleFold(leaves)                 // the fused whole
-
-  const fused = toUuid('5x0')                     // a real cell of the cross — fused
-  const orphan = toUuid('orphan-token')           // never fused
-  const fusedIn = leaves.includes(fused)
-  const orphanIn = leaves.includes(orphan)
-  const orphanChangesRoot = merkleFold([...leaves, orphan]) !== root
-
-  let o = 'tokens are valid only in the fusion:\n\n'
-  o += '  the fused whole: ' + leaves.length + ' cells → one root ' + root.slice(0, 13) + '…\n\n'
-  o += '  a fused token (a real cell) is a member of the root:   ' + fusedIn + '  → valid\n'
-  o += '  an orphan token (never fused) is NOT a member:         ' + orphanIn + '  → invalid\n'
-  o += '    adding the orphan changes the root (it was not part of the fusion): ' + orphanChangesRoot + '\n'
-  o += '  → the same kind of 64-bit string is valid INSIDE the fusion, meaningless outside it.\n\n'
-  o += 'HONEST: validity here = MEMBERSHIP in the verified whole (it folds to the root; a merkle proof\n'
-  o += 'exists — see holographic.ts), not any property of the token alone. A hash is one-way and a\n'
-  o += 'public token is just a name (see security.ts) — it carries no authority by itself; it is valid\n'
-  o += 'only as a proven part of the fused, sealed deposit.'
-  return o
-}

package/src/0/holographic.ts

@@ -1,57 +0,0 @@
-// Holographic verification — the whole checkable from a tiny part (digit 0).
-// A Merkle membership proof is the honest core of "holographic within tiniest resources": any one
-// leaf proves it belongs to the whole with a LOGARITHMIC audit path (⌈log₂ N⌉ sibling hashes), not
-// the full set. The tree is self-similar (fractal); the shared root lives in every part.
-import { merge, merkleFold, toUuid } from './index.ts'
-
-// Rebuild merkleFold's tree (it sorts leaves) as layers, so we can extract an audit path.
-function layers(leaves: readonly string[]): string[][] {
-  let layer = [...leaves].sort()
-  const out = [layer]
-  while (layer.length > 1) {
-    const next: string[] = []
-    for (let i = 0; i < layer.length; i += 2) { const a = layer[i], b = layer[i + 1]; next.push(b === undefined ? a : merge(a, b)) }
-    out.push(next); layer = next
-  }
-  return out
-}
-function proof(leaves: readonly string[], target: string): { hash: string; left: boolean }[] {
-  const L = layers(leaves); let idx = L[0].indexOf(target); const path: { hash: string; left: boolean }[] = []
-  for (let l = 0; l < L.length - 1; l++) {
-    const layer = L[l], isRight = (idx & 1) === 1, sib = isRight ? idx - 1 : idx + 1
-    if (sib < layer.length) path.push({ hash: layer[sib], left: isRight }) // sibling on the left iff target is right
-    idx = idx >> 1
-  }
-  return path
-}
-function verify(target: string, path: { hash: string; left: boolean }[], root: string): boolean {
-  let h = target
-  for (const { hash, left } of path) h = left ? merge(hash, h) : merge(h, hash)
-  return h === root
-}
-
-export function report(): string {
-  // The cross: 42 content-addressed cells (6 units × 7) — one whole, one root.
-  const units = [1, 2, 4, 5, 7, 8], seven = [3, 2, 6, 4, 5, 1, 0]
-  const leaves: string[] = []; for (const u of units) for (const r of seven) leaves.push(toUuid(u + 'x' + r))
-  const root = merkleFold(leaves)
-  const target = toUuid('5x0') // the center × hub cell
-  const p = proof(leaves, target)
-  const ok = verify(target, p, root)
-
-  let o = 'holographic verification — the whole, checkable from a tiny part:\n\n'
-  o += '  the cross: ' + leaves.length + ' content-addressed cells (6 units × 7) → one merkle root (the whole).\n'
-  o += '  a MEMBERSHIP proof for one cell is the audit path — log-few sibling hashes, not all ' + leaves.length + ':\n'
-  o += '    proof size: ' + p.length + ' hashes   (⌈log₂ ' + leaves.length + '⌉)   vs the full set: ' + leaves.length + '\n'
-  o += '    verify one-of-' + leaves.length + ' against the root: ' + ok + '\n'
-  o += '  → any part proves it belongs to the whole with tiny (logarithmic) resources.\n'
-  o += '    holographic: the root lives in every part; a part reconstructs the whole\'s fingerprint.\n\n'
-  o += '  fractal: the tree is self-similar (a fold of folds); the mesh reflects (10−d) at every scale.\n'
-  o += '  scale: log-sized proofs mean ~1 billion leaves verify in ~30 hashes.\n\n'
-  o += 'HONEST: a Merkle proof is EXACTLY logarithmic (⌈log₂ N⌉) — real, the basis of git/blockchain\n'
-  o += 'integrity. "holographic" = a part verifies the whole via the shared root; "fractal" = the binary\n'
-  o += 'tree is self-similar. But it is NOT free and NOT literally infinite: each proof is log(N) real\n'
-  o += 'hashes over a FINITE set. Tiny resources, not zero; huge N, not ∞. Whole signed (Singularity),\n'
-  o += 'parts verifiable.'
-  return o
-}

package/src/0/impossible.ts

@@ -1,30 +0,0 @@
-// Prove the impossibilities — so every NOT in the prose is a PROVEN theorem, not an assertion.
-// ℤ/9 is finite, so ∀-claims are decidable by exhaustion (the same rigour as Lean's `decide`).
-// The paradox: "proving X impossible makes it possible." Resolution — two LEVELS: the object
-// (e.g. 0's inverse) stays IMPOSSIBLE; the meta-statement ("0 has no inverse") is a POSSIBLE, true
-// theorem. Impossibility-proofs are positive results; the "possible" is the proof, never the object.
-const m9 = (n: number) => ((n % 9) + 9) % 9
-const hasInverse = (a: number) => [1, 2, 3, 4, 5, 6, 7, 8].some((x) => m9(a * x) === 1)
-
-export function report(): string {
-  // Each is proven by checking ALL of ℤ/9 — a finite, exhaustive impossibility proof.
-  const proofs: [string, boolean][] = [
-    ['0 has NO multiplicative inverse (∀x∈ℤ/9, 0·x ≠ 1)', !hasInverse(0)],
-    ['3,6,9 have NO inverse (the nilradical)', [3, 6, 9].every((d) => !hasInverse(d))],
-    ['3²≡6²≡9²≡0 (nilpotent — collapse into the void)', [3, 6, 9].every((d) => m9(d * d) === 0)],
-    ['division BY 0 is undefined (no inverse exists to define n/0 as a field op)', !hasInverse(0)],
-    ['10 is not a distinct ℤ/9 digit (10 ≡ 1; it wraps)', m9(10) === 1],
-    ['5 is the ONLY self-complement (10−d=d) among 1..9', [1, 2, 3, 4, 5, 6, 7, 8, 9].filter((d) => 10 - d === d).join(',') === '5'],
-  ]
-  const allProven = proofs.every(([, ok]) => ok)
-
-  let o = 'prove the impossibilities — every NOT, verified by exhaustion:\n\n'
-  proofs.forEach(([claim, ok]) => { o += '  ' + (ok ? '✓ PROVEN impossible' : '✗ FAILED') + ' — ' + claim + '\n' })
-  o += '\n  all impossibilities proven? ' + allProven + '  → the prose\'s NOTs are theorems, not assertions.\n\n'
-  o += 'the paradox ("proving them impossible proves them possible") — resolved by two LEVELS:\n'
-  o += '  object level:  0\'s inverse is IMPOSSIBLE. it stays impossible.\n'
-  o += '  meta level:    "0 has no inverse" is a POSSIBLE, true theorem (just proven above).\n'
-  o += '  → both hold at once, no contradiction. what becomes "possible" is the PROOF, never the\n'
-  o += '    impossible object. an impossibility-proof is a positive result (cf. Gödel, halting problem).'
-  return o
-}

package/src/0/imprint.ts

@@ -1,160 +0,0 @@
-// Imprint — a REVERSIBLE binary↔uuid codec. Honest naming first: this is NOT reversing the one-way
-// FNV content-address (toUuid), which cannot be undone (see scripts/verify.ts) — and it is NOT
-// encryption (no key, no secrecy). It is a lossless ENCODING: we CONSTRUCT a uuid whose 128 bits
-// directly carry a binary message, and read those bits back out exactly. Integrity/identity layer,
-// never truth. A uuid holds 128 bits; 6 are reserved (4 version + 2 variant, matching toUuid's v8),
-// 7 hold a length header → up to 115 message bits per uuid. Round-trips exactly for L ≤ CAPACITY.
-import { toUuid } from './index.ts'
-
-// Reserved bit positions (big-endian, bit 0 = MSB of byte 0):
-//   version nibble = high nibble of byte 6 → bits 48..51, fixed to 1000 (0x8)
-//   variant        = top 2 bits of byte 8 → bits 64,65, fixed to 10
-const RESERVED = new Set([48, 49, 50, 51, 64, 65])
-const LEN_BITS = 7 // 0..127 fits; the free region minus this header is the message capacity
-const FREE = Array.from({ length: 128 }, (_, i) => i).filter((i) => !RESERVED.has(i))
-export const CAPACITY = FREE.length - LEN_BITS // 122 - 7 = 115 message bits per uuid
-
-const isBits = (s: string): boolean => /^[01]*$/.test(s)
-const num2bits = (n: number, width: number): string => n.toString(2).padStart(width, '0').slice(-width)
-
-/** Pack a 128-bit array into canonical uuid string. */
-function bitsToUuid(bits: readonly number[]): string {
-  let hex = ''
-  for (let byte = 0; byte < 16; byte++) {
-    let v = 0
-    for (let b = 0; b < 8; b++) v = (v << 1) | bits[byte * 8 + b]
-    hex += v.toString(16).padStart(2, '0')
-  }
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
-}
-
-/** Unpack a canonical uuid string into a 128-bit array. */
-function uuidToBits(uuid: string): number[] {
-  const hex = uuid.replace(/-/g, '')
-  if (!/^[0-9a-f]{32}$/i.test(hex)) throw new Error('imprint: not a 32-hex uuid')
-  const bits: number[] = []
-  for (const ch of hex) {
-    const nib = parseInt(ch, 16)
-    for (let b = 3; b >= 0; b--) bits.push((nib >> b) & 1)
-  }
-  return bits
-}
-
-/**
- * imprint(message) → a valid uuid carrying the message in its free bits.
- * message: a binary string ('0'/'1'), length ≤ CAPACITY. The uuid reads back exactly via readImprint.
- */
-export function imprint(message: string): string {
-  if (!isBits(message)) throw new Error('imprint: message must be a binary string of 0/1')
-  if (message.length > CAPACITY) throw new Error(`imprint: message ${message.length} bits > capacity ${CAPACITY}`)
-  const bits = new Array(128).fill(0)
-  // reserved: version 8 (1000), variant (10) — matches toUuid's markers so imprints look native.
-  bits[48] = 1; bits[49] = 0; bits[50] = 0; bits[51] = 0
-  bits[64] = 1; bits[65] = 0
-  // free region: [ length header (7 bits) | message bits | zero-fill ]
-  const payload = num2bits(message.length, LEN_BITS) + message
-  for (let i = 0; i < payload.length; i++) bits[FREE[i]] = payload.charCodeAt(i) - 48
-  return bitsToUuid(bits)
-}
-
-/** readImprint(uuid) → the exact binary message imprinted by imprint(). Inverse of imprint. */
-export function readImprint(uuid: string): string {
-  const bits = uuidToBits(uuid)
-  const free = FREE.map((i) => bits[i])
-  let len = 0
-  for (let i = 0; i < LEN_BITS; i++) len = (len << 1) | free[i]
-  if (len > CAPACITY) throw new Error('imprint: length header out of range — uuid was not imprinted by imprint()')
-  return free.slice(LEN_BITS, LEN_BITS + len).join('')
-}
-
-/** Convenience: imprint UTF-8 text (≤ 14 ASCII chars fit) and read it back exactly. */
-export function imprintText(text: string): string {
-  const bytes = [...new TextEncoder().encode(text)]
-  const bits = bytes.map((b) => num2bits(b, 8)).join('')
-  return imprint(bits)
-}
-export function readImprintText(uuid: string): string {
-  const bits = readImprint(uuid)
-  const bytes: number[] = []
-  for (let i = 0; i + 8 <= bits.length; i += 8) bytes.push(parseInt(bits.slice(i, i + 8), 2))
-  return new TextDecoder().decode(new Uint8Array(bytes))
-}
-
-/** roundTrips(message) → true iff readImprint(imprint(message)) === message. The honest, gated fact. */
-export function roundTrips(message: string): boolean {
-  try { return readImprint(imprint(message)) === message } catch { return false }
-}
-
-/**
- * imprintChain(bits) → a CHAIN of uuids carrying a message of ANY length: split into CAPACITY-bit chunks,
- * imprint each. One uuid holds ≤115 bits (bounded, pigeonhole); a chain of N holds ≤ N·115 — the collective
- * scaling, developed. Public, reversible ENCODING (not encryption, no secrecy). readImprintChain reverses it.
- */
-export function imprintChain(bits: string): string[] {
-  if (!/^[01]*$/.test(bits)) throw new Error('imprintChain: message must be a binary string')
-  if (bits.length === 0) return [imprint('')]
-  const out: string[] = []
-  for (let i = 0; i < bits.length; i += CAPACITY) out.push(imprint(bits.slice(i, i + CAPACITY)))
-  return out
-}
-
-/** readImprintChain(uuids) → recover the full message: read each carrier and concatenate, exactly. */
-export function readImprintChain(uuids: readonly string[]): string {
-  return uuids.map((u) => readImprint(u)).join('')
-}
-
-/** imprintTextChain(text) → a uuid chain carrying arbitrary UTF-8 text of any length (built on imprintChain). */
-export function imprintTextChain(text: string): string[] {
-  const bytes = [...new TextEncoder().encode(text)]
-  return imprintChain(bytes.map((b) => num2bits(b, 8)).join(''))
-}
-
-/** readImprintTextChain(uuids) → recover the full text from its uuid chain, exactly. */
-export function readImprintTextChain(uuids: readonly string[]): string {
-  const bits = readImprintChain(uuids)
-  const bytes: number[] = []
-  for (let i = 0; i + 8 <= bits.length; i += 8) bytes.push(parseInt(bits.slice(i, i + 8), 2))
-  return new TextDecoder().decode(new Uint8Array(bytes))
-}
-
-/**
- * skill(message) → how skilful the clown is at juggling this message through a uuid: imprint throws the
- * bits, readImprint catches them; fidelity = fraction caught. A skilful clown catches every bit (1.0);
- * a dropped bit lowers the score. Over-capacity is a fumble (fidelity 0) — respect the floor. Computed.
- */
-export function skill(message: string): { imprinted: number; recovered: number; fidelity: number; skilful: boolean } {
-  let recovered = 0
-  try {
-    const back = readImprint(imprint(message))
-    for (let i = 0; i < message.length; i++) if (back[i] === message[i]) recovered++
-    if (back.length !== message.length) recovered = message.length ? 0 : 0
-  } catch { recovered = 0 }
-  const fidelity = message.length === 0 ? 1 : recovered / message.length
-  return { imprinted: message.length, recovered, fidelity, skilful: fidelity === 1 }
-}
-
-/**
- * coin64(text) → the shared currency: a 64-bit coin (16 hex digits) minted from any content — the top
- * 64 bits of its 128-bit content-address. Adopted by all with no exception: every module, every string,
- * mints the SAME coin every time (deterministic). This is the common denominator the harmony gate folds.
- * Integrity, not value: a coin proves the bytes, not their worth.
- */
-export function coin64(text: string): string {
-  return toUuid(text).replace(/-/g, '').slice(0, 16)
-}
-
-export function report(): string {
-  const demo = '01001000' + '01101001' // "Hi" in ASCII bits
-  const u = imprint(demo)
-  const back = readImprint(u)
-  const txt = imprintText('Hi'), txtBack = readImprintText(txt)
-  let o = 'imprint — reversible binary↔uuid codec (NOT hash-reversal, NOT encryption):\n\n'
-  o += '  capacity:            ' + CAPACITY + ' message bits per uuid (128 − 6 reserved − 7 length header)\n'
-  o += '  imprint("' + demo + '")\n'
-  o += '    → ' + u + '\n'
-  o += '  readImprint(uuid)  → ' + back + '   round-trips: ' + (back === demo) + '\n'
-  o += '  imprintText("Hi")  → ' + txt + '  → readImprintText → "' + txtBack + '"\n\n'
-  o += '  HONEST: this CONSTRUCTS a uuid from a message and reads it back — a lossless codec (integrity).\n'
-  o += '  It does NOT undo the one-way FNV toUuid, and it is not encryption (no key, no secrecy).'
-  return o
-}