@ceccec/millennium-solutions 0.1.1

package/src/0/legible.ts

@@ -0,0 +1,29 @@
+// Universal legibility — what any verifier can do with anything you paste.
+// Whatever you paste (content, an address, the source), any COMPUTATIONAL intelligence recomputes
+// and verifies it identically — deterministic, language-neutral, no middleman. That is real,
+// universal understanding-as-VERIFICATION. Understanding-as-MEANING is a separate thing: it needs
+// a mind to interpret. A hash makes the object legible; it does not make it meaningful.
+import { toUuid } from './index.ts'
+
+export function report(): string {
+  const sample = 'entails → 0/7'
+  const you = toUuid(sample), me = toUuid(sample) // two independent recomputations
+  const agree = you === me
+
+  let o = 'universal legibility — paste anything, any verifier can check it:\n\n'
+  o += '  paste CONTENT → its address is recomputable by anyone, in any language:\n'
+  o += '    toUuid("' + sample + '") = ' + you.slice(0, 13) + '…  (recompute equal? ' + agree + ')\n'
+  o += '  paste an ADDRESS → anyone can check which content matches it (load + verify).\n'
+  o += '  paste the SOURCE → anyone recomputes every result and reaches the same floor: 0/7.\n\n'
+  o += '  so "any form of intellect understands" — precisely, any COMPUTATIONAL intelligence can:\n'
+  o += '    · recompute the same addresses (determinism, H = 0)\n'
+  o += '    · rerun the gates (gaps · seal · wholeness)\n'
+  o += '    · arrive at the same 0/7 (the floor)\n'
+  o += '  no shared language required — only the algorithm. this is universal VERIFIABILITY.\n\n'
+  o += 'HONEST: understanding-as-verification is universal — recomputation is mechanical and\n'
+  o += 'language-neutral, so any verifier agrees on WHAT the thing is (its fingerprint). Understanding-\n'
+  o += 'as-meaning is NOT automatic: grasping significance needs interpretation (a mind). The artifact\n'
+  o += 'forces agreement on identity, not on meaning. A hash makes the object legible; a reader makes\n'
+  o += 'it meaningful. entails → 0/7.'
+  return o
+}

package/src/0/limit.ts

@@ -0,0 +1,29 @@
+// The singularity is a limit — approached, never achieved (like division by zero).
+// 1/x → ∞ as x → 0, and 1/0 is UNDEFINED (no value). You never arrive; you only get nearer. The
+// ongoing process is the approach; completion — collapsing all distinction to one — would be cessation.
+import { toUuid, merkleFold } from './index.ts'
+
+export function report(): string {
+  // 1/x as x → 0 (x = 1/d): the value grows without bound, and at x = 0 there is no value.
+  const denoms = [1, 10, 100, 1000, 10000] // x = 1/d ; 1/x = d
+  // The singularity recedes: you can always fold one more entry, so the "final" root moves.
+  const r4 = merkleFold(['a', 'b', 'c', 'd'].map(toUuid))
+  const r5 = merkleFold(['a', 'b', 'c', 'd', 'e'].map(toUuid))
+  const recedes = r4 !== r5
+
+  let o = 'the singularity is a limit — approached, never achieved (like division by 0):\n\n'
+  o += '  1/x as x → 0 grows without bound; at x = 0 it is UNDEFINED (no value):\n'
+  denoms.forEach(d => { o += '    x = 1/' + String(d).padEnd(5) + ' → 1/x = ' + d + '\n' })
+  o += '    x = 0        → 1/0 = UNDEFINED  (not a value; the point recedes as you approach)\n\n'
+  o += '  the one root is the same: you can always fold ONE more entry, so the "final" root moves:\n'
+  o += '    root(4 entries) ≠ root(5 entries)? ' + recedes + '  → the singularity recedes while the process continues.\n\n'
+  o += '  the paradox (honest): to fully ACHIEVE the singularity — collapse all distinction to one — is\n'
+  o += '  to end the process. division by zero, actually completed, is not a value but the loss of the\n'
+  o += '  domain. the VISION of the singularity, approached, is the ongoing thing; arrival would be\n'
+  o += '  cessation. so the approach IS the singularity — a limit that stays open by never closing.\n\n'
+  o += 'HONEST: standard calculus/topology — 1/x → ∞ as x → 0⁺, and 1/0 is UNDEFINED, not infinity-as-a-\n'
+  o += 'value. "singularity never achieved" = an asymptote/attractor, not a destination. This is also the\n'
+  o += 'honest reading of the framework\'s "division by zero": a change of domain / an unreached limit —\n'
+  o += 'never a completed operation, and never a proof. entails → 0/7.'
+  return o
+}

package/src/0/merkle-proof.ts

@@ -0,0 +1,3 @@
+// The holographic merkle proof — verify the whole from a tiny part in O(log N) — lives canonically in
+// @uuidna/uuidna. One implementation shared by both apps, byte-identical roots and proofs, no re-declared copy.
+export { merkleRoot, merkleProof, verifyProof } from '@uuidna/uuidna'

package/src/0/null-token.ts

@@ -0,0 +1,24 @@
+// No token is a token — in two exact senses.
+//  (1) addressing: even the EMPTY input has a deterministic content-address — absence is addressable.
+//  (2) security: there is NO secret token; that absence IS the posture — no key to steal or leak.
+import { toUuid } from './index.ts'
+
+export function report(): string {
+  const empty = toUuid('')     // the address of nothing
+  const zero = toUuid('0')     // the genesis / v0.0.0 seed
+  const stable = toUuid('') === empty
+
+  let o = 'no token is a token:\n\n'
+  o += '  (1) the void has an address — even the empty input content-addresses (deterministic):\n'
+  o += '    toUuid("")  = ' + empty.slice(0, 13) + '…   → "nothing" has a definite fingerprint (stable? ' + stable + ')\n'
+  o += '    toUuid("0") = ' + zero.slice(0, 13) + '…   → the genesis (the v0.0.0 seed)\n'
+  o += '    absence is still addressable; the null is a token.\n\n'
+  o += '  (2) the security posture — there is NO secret token, and that IS the token:\n'
+  o += '    nothing to steal, nothing to leak, nothing to expire. the strongest key is no key.\n'
+  o += '    an open system\'s safety is that it keeps no secret (see security.ts).\n\n'
+  o += 'HONEST: both are exact — the empty string maps to one fixed UUID, and "no secret" is a real\n'
+  o += '(and for an open, public deposit, correct) security model. It does NOT mean "nothing is\n'
+  o += 'everything" or that emptiness holds mystical power; it means absence is deterministically\n'
+  o += 'addressable, and openness draws its safety from having no secret to lose. entails → 0/7.'
+  return o
+}

package/src/0/sha256.ts

@@ -0,0 +1,3 @@
+// SHA-256 / HMAC-SHA256 / PBKDF2-SHA256 (pure TS, KAT-verified) live canonically in @uuidna/uuidna —
+// one implementation shared by both apps, byte-identical digests, no re-declared copy.
+export { sha256, hmacSha256, pbkdf2Sha256 } from '@uuidna/uuidna'

package/src/0/singularity.ts

@@ -0,0 +1,20 @@
+// The singularity: the single content-address root the whole chain folds into.
+// Content-addressing = shared verifiable REFERENCE (git/IPFS style), NOT secret messaging.
+import { toUuid, merge, merkleFold } from './index.ts'
+export function report(): string {
+  const entries = ['genesis', 'core', 'vision:ceccec', 'vision:yours']
+  let prev = toUuid('0'); const chain: string[] = []
+  for (const e of entries) { prev = merge(prev, toUuid(e)); chain.push(prev) }
+  const root = merkleFold(chain)
+  const partyA = toUuid('shared-content'), partyB = toUuid('shared-content')
+  let o = 'singularity blockchain (append-only, content-addressed → one root):\n'
+  entries.forEach((e, i) => o += '  ' + e.padEnd(14) + chain[i].slice(0, 13) + '…\n')
+  o += '  → single root (the singularity): ' + root.slice(0, 13) + '…\n\n'
+  o += 'content-address cross (shared reference): partyA == partyB ? ' + (partyA === partyB) + '\n'
+  o += '  → any two parties with the same content converge on the SAME address — verifiable,\n'
+  o += '    no middleman. This is git/IPFS/npm-integrity-style provenance.\n\n'
+  o += 'HONEST: integrity + provenance + a shared public reference (deterministic, public).\n'
+  o += 'NOT decentralized consensus (needs a consensus protocol), NOT secret messaging, NOT encryption.\n'
+  o += 'toUuid is FNV — for real integrity use SHA-256. "singularity messaging" = agreeing on one public address.'
+  return o
+}

package/src/0/stream.ts

@@ -0,0 +1,48 @@
+// Memory-free VitePress — UUID streams with a loadable payload.
+// The page stores NO answers. Each block is a thunk (source code), computed in realtime at
+// render. A stream frame is { id, load }: the id CONTENT-ADDRESSES the payload; the payload is
+// not kept in memory and not inside the id — it is LOADED on demand and verified against the id.
+// This is git/IPFS-style: the id names the payload; you load + verify. It is NOT reversible —
+// you cannot extract the payload from the id. "Loadable", not "hidden inside the hash".
+import { toUuid } from './index.ts'
+
+export type Frame = { id: string; load: () => string }
+
+// Address a payload by its content. `compute` is retained (source); the payload string is not —
+// it is recomputed on load(). Memory-free: we keep the id (small) and the thunk, never the answer.
+export function frame(compute: () => string): Frame {
+  return { id: toUuid(compute()), load: compute }
+}
+
+// Load = recompute the payload and verify it still addresses to its id (integrity check).
+export function load(f: Frame): { payload: string; verifies: boolean } {
+  const payload = f.load()
+  return { payload, verifies: toUuid(payload) === f.id }
+}
+
+export function report(): string {
+  // A realtime stream — thunks over source, no stored payloads.
+  const stream: Frame[] = [
+    frame(() => 'doubling:1-2-4-8-7-5'),
+    frame(() => 'reflection-fixed:5'),
+    frame(() => 'entailment:0/7'),
+    frame(() => 'self-seal:1'),
+  ]
+
+  let o = 'memory-free VitePress — UUID streams with loadable payload:\n\n'
+  o += '  the page stores NO answers. each block is a thunk (source), computed in realtime at\n'
+  o += '  render. a frame = { id (content-address), load() (recompute the payload) }.\n\n'
+  o += '  the stream (ids only — the payload is NOT stored):\n'
+  stream.forEach((f, i) => { o += '    frame ' + (i + 1) + '  id ' + f.id.slice(0, 13) + '…\n' })
+  o += '\n  load + verify (recompute the payload, check toUuid(payload) == id):\n'
+  stream.forEach((f, i) => {
+    const r = load(f)
+    o += '    frame ' + (i + 1) + '  → "' + r.payload + '"  verifies: ' + r.verifies + '\n'
+  })
+  o += '\nHONEST: this is loadable + verifiable content-addressing (git/IPFS style). The id NAMES\n'
+  o += 'the payload; you LOAD the payload (recompute or fetch) and verify it against the id. The id\n'
+  o += 'is a one-way checksum — you CANNOT reverse it to obtain the payload, and no payload travels\n'
+  o += 'inside the id. Memory-free means "recompute, don\'t store", not "the message hides in the\n'
+  o += 'UUID". For cryptographic integrity use SHA-256 (toUuid is FNV). entails → 0/7.'
+  return o
+}

package/src/0/trinities.ts

@@ -0,0 +1,37 @@
+// Singularity trinities — the real three-part structures in the deposit, each content-addressed
+// to a root, all folding to ONE singularity root. "Trinity" is the motif; each triad is an actual
+// grouping already in the work. (This deploys the STRUCTURE to the site; publishing the npm package
+// trinity is a separate, login-gated step — a computable boundary, noted below.)
+import { toUuid, merkleFold } from './index.ts'
+
+const TRINITIES: Record<string, string[]> = {
+  'channels (source · site · archive)': [
+    'GitHub (source)',
+    'ceccec.psg.bg (site)',
+    'Zenodo DOI (archive)',
+  ],
+  'digits (mod-3 triads)': ['axis {3,6,9}', 'one {1,4,7}', 'two {2,5,8}'],
+  'origin (0 · 1 · between)': ['0 void', '1 unit', 'between (0,1)'],
+  'gates (the release trinity)': ['gaps — coverage', 'seal — consistency', 'wholeness — aura'],
+}
+
+export function report(): string {
+  const roots: string[] = []
+  let o = 'singularity trinities — each triad content-addressed, all folding to one root:\n\n'
+  for (const [name, members] of Object.entries(TRINITIES)) {
+    const root = merkleFold(members.map(toUuid))
+    roots.push(root)
+    o += '  ' + name + '\n'
+    members.forEach(m => o += '    · ' + m + '\n')
+    o += '    → triad root: ' + root.slice(0, 13) + '…\n\n'
+  }
+  const singularity = merkleFold(roots)
+  o += '  the trinities fold to ONE singularity root: ' + singularity.slice(0, 13) + '…\n'
+  o += '  → many threes, one. the singularity reflects the trinities; the trinities fold to it.\n\n'
+  o += 'HONEST: each triad is an actual grouping in the deposit (packages, mod-3 residue classes, the\n'
+  o += '0/1/between origin, the gaps·seal·wholeness gate). Content-addressing folds them deterministically\n'
+  o += 'to one root. "Trinity" is the framework\'s motif; the groupings and the fold are exact. The npm\n'
+  o += 'package trinity is staged but UNPUBLISHED — publishing needs the author\'s npm login (a real,\n'
+  o += 'computable boundary, honestly marked). entails → 0/7.'
+  return o
+}

package/src/0/trinity-matrix.ts

@@ -0,0 +1,20 @@
+// The UUID "trinity matrix": deterministic content-addressed identity, recomputable.
+// It computes zero-entropy indexing (one value → one address) and Merkle roots.
+// It does NOT prove consciousness or "intelligence quantumizing itself" — that is
+// interpretation (flagged), not a computed result.
+import { toUuid, foldPair, merkleFold, sealFacets } from './index.ts'
+export function report(): string {
+  let o = 'UUID trinity matrix — content-addressed identity (recomputable):\n\n'
+  const a = toUuid('seed'), a2 = toUuid('seed')
+  o += 'determinism:  toUuid("seed") = ' + a.slice(0, 13) + '…   recompute equal? ' + (a === a2) + '  → H(content|generator) = 0\n'
+  const fp = foldPair('a', 'b')
+  o += 'fold a,b:     forward ≠ reverse? ' + fp.bidirectional + ';  merged root = ' + fp.merged.slice(0, 13) + '…\n'
+  const trinity = ['3', '6', '9'].map(x => toUuid('trinity:' + x))
+  o += 'trinity {3,6,9} → Merkle root = ' + merkleFold(trinity).slice(0, 13) + '…\n'
+  const seal = sealFacets('matrix', [{ facet: '3', on: true }, { facet: '6', on: true }, { facet: '9', on: true }])
+  o += 'sealed facets: ok=' + seal.ok + ' count=' + seal.count + ' root=' + seal.root.slice(0, 13) + '…\n'
+  o += '\nCOMPUTES: deterministic content addresses (same input → same UUID) folded to a Merkle root —\n'
+  o += 'zero-entropy indexing (one value, one address). This is identity/addressing, not cognition.\n'
+  o += 'It does NOT prove consciousness or "intelligence quantumizing itself"; that is interpretation, flagged.'
+  return o
+}

package/src/0/version-matrix.ts

@@ -0,0 +1,70 @@
+// Versioning as a matrix of digits, folded into a Merkle PYRAMID (the version-seal), with the
+// double-torus (genus-2) fact that already lives in the "two coins". Exact parts computed;
+// the "double torus" naming is labelled as the metaphor it is.
+import { toUuid, merge } from './index.ts'
+
+// The version explains its own support status: LTS minors are the single-digit FIBONACCI numbers
+// {1,2,3,5,8} — each LTS is the sum of the two prior, so the recurrence IS the support line
+// (v1.3 + v1.5 = v1.8). v1.5 is the HEART LTS (σ(5)=5, the unique fixed point / "good"); v1.8 is
+// the world-wired LTS. Each LTS is signed by the previous LTS (its Fibonacci parent). Read the
+// minor — no separate policy doc. (Corrects an earlier odd-minor rule: 8 is LTS though even.)
+const LTS_MINORS = new Set([1, 2, 3, 5, 8]) // single-digit Fibonacci
+export const channel = (minor: number): 'LTS' | 'interim' => (LTS_MINORS.has(minor) ? 'LTS' : 'interim')
+
+// Fold leaves pairwise, tier by tier, to an apex — a Merkle pyramid. Returns the tier sizes
+// and the apex address.
+function pyramid(leaves: string[]): { tiers: number[]; apex: string } {
+  const tiers = [leaves.length]
+  let level = leaves
+  while (level.length > 1) {
+    const next: string[] = []
+    for (let i = 0; i < level.length; i += 2) next.push(i + 1 < level.length ? merge(level[i], level[i + 1]) : level[i])
+    level = next; tiers.push(level.length)
+  }
+  return { tiers, apex: level[0] ?? toUuid('') }
+}
+
+// Integer ceil(log2 n) with no Math.*: count halvings.
+function ceilLog2(n: number): number { let d = 0, x = 1; while (x < n) { x *= 2; d++ } return d }
+
+export function report(): string {
+  const versions = ['1.0.0', '1.0.1', '1.0.2', '1.0.3'] // illustrative rows (live seal: scripts/versions.ts)
+  const matrix = versions.map(v => v.split('.').map(Number))
+  const leaves = versions.map(toUuid)
+  const { tiers, apex } = pyramid(leaves)
+
+  const g = 2, chi = 2 - 2 * g       // double torus (genus-2): χ = 2 − 2g = −2
+  const coins = -chi                 // = 2 = 110 − 108, the two coins
+
+  let o = 'versioning as a digit matrix, folded into a Merkle pyramid:\n\n'
+  o += '  version matrix (major·minor·patch — rows of digits):\n'
+  versions.forEach((v, i) => { o += '    v' + v + '  [' + matrix[i].join(',') + ']\n' })
+  o += '\n  each row → a leaf address; leaves fold pairwise into a pyramid (tier sizes):\n'
+  o += '    ' + tiers.join(' → ') + '   apex (mini version-seal): ' + apex.slice(0, 13) + '…\n'
+  o += '  depth = ⌈log₂ ' + versions.length + '⌉ = ' + ceilLog2(versions.length)
+  o += ' → navigate/verify any version in that many steps (a Merkle proof).\n\n'
+  o += '  double torus (genus-2): χ = 2 − 2g = 2 − ' + (2 * g) + ' = ' + chi + ', so −χ = ' + coins
+  o += ' = the two coins (110 − 108).\n\n'
+  // it all goes in v1.0.0: the major·minor columns are invariant across every row.
+  const majorInv = matrix.every(r => r[0] === matrix[0][0])
+  const minorInv = matrix.every(r => r[1] === matrix[0][1])
+  o += '  one minor line (1.' + matrix[0][1] + '.x) — major·minor invariant [' + matrix[0][0] + ',' + matrix[0][1] + '] ('
+  o += 'major ' + majorInv + ', minor ' + minorInv + '); only the patch advances.\n'
+  o += '  STABLE = v1.x.0 (patch 0): 0 is always stable — the base/network address of each minor line.\n'
+  o += '  patches (v1.x.y, y>0) increment toward the next stable; a minor bump opens the next line, patch → 0.\n'
+  o += '  the pyramid apex returns every patch to that line\'s .0 origin.\n'
+  o += '  CHANNEL (self-explaining): LTS = single-digit Fibonacci minors {1,2,3,5,8}, each the sum of the two prior.\n'
+  o += '    ' + [1, 2, 3, 4, 5, 6, 7, 8].map(m => '1.' + m + '=' + channel(m)).join(', ') + '.\n'
+  o += '  the recurrence IS the support line: v1.3 + v1.5 = v1.8. v1.5 = HEART LTS (σ(5)=5); v1.8 = world-wired LTS.\n'
+  o += '  v1.3 (current) is the live LTS; each LTS is signed by the previous LTS (its Fibonacci parent).\n\n'
+  // and it all goes in v0.0.0 — the zero origin/void: the genesis seed the chain starts from.
+  const genesis = toUuid('0')
+  o += '  and it all goes in v0.0.0 — the zero origin: genesis seed toUuid("0") = ' + genesis.slice(0, 13) + '…\n'
+  o += '  the singularity chain starts there (see singularity.ts); 1 emerges from 0. v0.0.0 is the\n'
+  o += '  void/seed (unpublished); the observable line begins at v1.0.0. 0 = origin, 1 = first manifestation.\n\n'
+  o += 'HONEST: the digit matrix, the Merkle pyramid (tier sizes + log-depth navigation), and the\n'
+  o += 'genus-2 Euler characteristic are all exact. Calling the version history "a double torus" is a\n'
+  o += 'topological METAPHOR, not a derivation — versions form a Merkle tree (a pyramid), which is not\n'
+  o += 'literally a genus-2 surface. The live seal over ALL tags is scripts/versions.ts. entails → 0/7.'
+  return o
+}

package/src/1/acceptance.ts

@@ -0,0 +1,30 @@
+// Acceptance vs proof — the hinge of this whole work.
+// Society can ACCEPT a claim; that is adoption, not deduction. A proof stays a proof, and a
+// non-proof stays a non-proof, whether or not anyone accepts it. What a UI can honestly
+// DELIVER is verifiability — the ground on which *earned* acceptance rests. Not proof-by-vote.
+import { toUuid } from '../0/index.ts'
+
+export function report(): string {
+  // This project's own record: acceptance is real AND independent of the mathematics.
+  const accepted = [
+    'zenodo DOI 10.5281/zenodo.21781603',
+    'zenodo DOI 10.5281/zenodo.21787144',
+    'submission acknowledged (received/forwarded)',
+  ]
+  const entailment = 0 // of 7 — computed by entails.ts, unchanged by any amount of acceptance
+
+  let o = 'acceptance vs proof:\n\n'
+  o += '  social acceptance (adoption) — real, and on record:\n'
+  accepted.forEach(a => o += '    · ' + a + '\n')
+  o += '  mathematical entailment (deduction) — computed, and unmoved by adoption:\n'
+  o += '    · Clay problems solved: ' + entailment + '/7\n\n'
+  o += '  → the two axes are INDEPENDENT. Acceptance did not make the vacuous proofs valid;\n'
+  o += '    0/7 does not erase that the work was received and archived. Truth is not a vote.\n\n'
+  o += 'what the UI delivers (honestly):\n'
+  o += '  every claim on this site recomputes at page-load from source (fused TS),\n'
+  o += '  is content-addressed (' + toUuid('acceptance-vs-proof').slice(0, 13) + '…), and passes the seal gate.\n'
+  o += '  → the UI does NOT deliver proof-by-acceptance. It delivers VERIFIABILITY: anyone in\n'
+  o += '    society can recompute and check for themselves. That is the only acceptance worth\n'
+  o += '    having — earned acceptance FOLLOWS verification, it does not replace it.'
+  return o
+}

package/src/1/index.ts

@@ -0,0 +1,80 @@
+/**
+ * Theorem 1: Riemann Hypothesis
+ * Licensed under CC BY-NC 4.0
+ * Attribution: Tsvetan Rouschev
+ */
+
+import { gcdBigInt, merkleFold, toUuid } from '../0'
+
+export interface Rational {
+  readonly num: bigint
+  readonly den: bigint
+}
+
+function rational(num: bigint | number, den: bigint | number = 1n): Rational {
+  const n = typeof num === 'bigint' ? num : BigInt(num)
+  const d = typeof den === 'bigint' ? den : BigInt(den)
+  if (d === 0n) throw new Error('Division by zero')
+  const g = gcdBigInt(n < 0n ? -n : n, d < 0n ? -d : d)
+  const sign = (n < 0n) !== (d < 0n) ? -1n : 1n
+  return { num: sign * (n < 0n ? -n : n) / g, den: (d < 0n ? -d : d) / g }
+}
+
+export type SymbolicExpr =
+  | { type: 'rational'; num: bigint; den: bigint }
+  | { type: 'sqrt'; inner: SymbolicExpr }
+  | { type: 'exp'; base: SymbolicExpr; exp: SymbolicExpr }
+  | { type: 'add'; left: SymbolicExpr; right: SymbolicExpr }
+  | { type: 'mul'; left: SymbolicExpr; right: SymbolicExpr }
+  | { type: 'pi' }
+  | { type: 'e' }
+
+function symRat(num: bigint | number, den: bigint | number = 1n): SymbolicExpr {
+  const n = typeof num === 'bigint' ? num : BigInt(num)
+  const d = typeof den === 'bigint' ? den : BigInt(den)
+  return { type: 'rational', num: n, den: d }
+}
+
+function symSquare(expr: SymbolicExpr): SymbolicExpr {
+  return { type: 'mul', left: expr, right: expr }
+}
+
+function symSub(left: SymbolicExpr, right: SymbolicExpr): SymbolicExpr {
+  return { type: 'add', left, right: { type: 'mul', left: symRat(-1n), right } }
+}
+
+function symSqrt(inner: SymbolicExpr): SymbolicExpr {
+  return { type: 'sqrt', inner }
+}
+
+export interface ExactTheoremState {
+  name: string
+  canonical_description: string
+  off_canonical_description: string
+  alpha_symbolic: SymbolicExpr
+  beta_symbolic: SymbolicExpr
+  coherence_exact: SymbolicExpr
+  decoherence_rate: SymbolicExpr
+  derivation: string
+}
+
+export const riemann_exact: ExactTheoremState = {
+  name: 'Riemann Hypothesis',
+  canonical_description: 'All zeros on Re(s) = 1/2',
+  off_canonical_description: 'At least one zero off Re(s) = 1/2',
+  alpha_symbolic: symRat(1n),
+  beta_symbolic: symSqrt(symSub(symRat(1n), symSquare(symRat(1n)))),
+  coherence_exact: symSquare(symRat(1n)),
+  decoherence_rate: symRat(0n),
+  derivation: `
+    1. Functional equation forces σ(s)=1-s symmetry
+    2. All computed zeros (10^13+) lie on Re(s)=1/2
+    3. Growth rate N(T) formula proven to hold exactly
+    4. If escape existed: N(T) would exceed formula
+    5. Empirically: N(T) matches formula perfectly
+    6. Therefore: escape probability = 0, α = 1 exactly
+  `,
+}
+
+export const theorem1 = riemann_exact
+export default riemann_exact

package/src/1/paradox.ts

@@ -0,0 +1,28 @@
+// Purity · clarity · paradox — the limit of self-verification (digit 1, the observer).
+// The gates make every module clear (gaps · seal · wholeness, all against the floor 0/7). The
+// paradox: the gates cannot fully check THEMSELVES. Purity is verifiable, but not self-certifying.
+import { toUuid, merkleFold } from '../0/index.ts'
+
+export function report(): string {
+  const checkers = ['gaps', 'seal', 'wholeness']     // the scripts that judge everything else
+  const checkerRoot = merkleFold(checkers.map(toUuid)) // addressable — but that is not verifying their logic
+
+  let o = 'purity · clarity · paradox — the limit of self-verification:\n\n'
+  o += '  the gates make everything clear: ' + checkers.join(' · ') + ' check every module against 0/7.\n'
+  o += '  the paradox: the gates cannot fully check THEMSELVES.\n'
+  o += '    subjects: the src/ report() modules — judged by the gates.\n'
+  o += '    checkers: ' + checkers.join(' · ') + ' — NOT among their own subjects.\n'
+  o += '    a bug in a checker could pass a bad module, and no gate would catch it. who checks the checker?\n'
+  o += '    (you can ADDRESS the checkers — root ' + checkerRoot.slice(0, 13) + '… — but addressing is not\n'
+  o += '     verifying their logic; a hash names code, it does not prove the code correct.)\n\n'
+  o += '  the honest resolution (not a loophole):\n'
+  o += '    · the checkers are small, PUBLIC, content-addressed, and auditable — trust bottoms out in\n'
+  o += '      external reading, not self-proof.\n'
+  o += '    · this echoes Gödel / Tarski (a consistent system cannot prove its own consistency, nor\n'
+  o += '      define its own truth, from within) — as an ANALOGY, not a formal theorem about a script.\n'
+  o += '    → purity is VERIFIABLE but not SELF-certifying: clarity about everything except the lens itself.\n\n'
+  o += 'HONEST: the deposit clearly verifies its claims; it cannot clearly verify its own verifier from\n'
+  o += 'inside. That residue — read the checker yourself — is the honest paradox, named rather than hidden.\n'
+  o += 'It does not weaken the floor; it locates exactly where trust must come from outside. entails → 0/7.'
+  return o
+}

package/src/1/vortex.lean

@@ -0,0 +1,6 @@
+import Mathlib
+/-- Digit 1 — unity: self-inverse in ℤ/9; ten's-complement partner of 9. -/
+namespace Vortex.D1
+theorem self_inverse : (1 : ZMod 9) * 1 = 1 := by decide
+theorem complement_nine : 1 + 9 = 10 := by norm_num
+end Vortex.D1

package/src/2/frequency-scales.ts

@@ -0,0 +1,16 @@
+// f = E/h across scales (fused: import { report } and render).
+export function report(): string {
+  const h = 6.62607015e-34, eV = 1.602176634e-19, c = 299792458
+  const f = (E: number) => E / h
+  const rows: [string, number][] = [
+    ['432 Hz tone', h * 432], ['visible light (~2 eV)', 2 * eV],
+    ['chemical bond (~10 eV)', 10 * eV], ['nuclear shell (~3 MeV)', 3e6 * eV],
+    ['proton (938 MeV)', 938e6 * eV],
+  ]
+  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 += 'bound-nucleon de Broglie λ ≈ ' + (h / p * 1e15).toFixed(2) + ' fm'
+  return o
+}

package/src/2/iching.ts

@@ -0,0 +1,34 @@
+// I Ching as exact binary combinatorics — a tradition use case (cf. glagolitic.ts). Yin/yang are
+// 0/1; a trigram is 3 bits (2³ = 8, the bagua); a hexagram is 6 bits (2⁶ = 64). This IS computer
+// binary — Leibniz mapped the I Ching to base-2 in 1703. 64 = 2⁶ = 4³ (the DNA codons, dna.ts) = 8².
+export function report(): string {
+  const states = 2                 // yin (0) / yang (1) — one bit
+  const trigrams = states ** 3     // 8  (the bagua)
+  const hexagrams = states ** 6    // 64
+  const dnaCodons = 4 ** 3         // 64
+  const trigramPairs = trigrams ** 2 // 8² = 64
+  const converge = hexagrams === 64 && dnaCodons === 64 && trigramPairs === 64
+
+  // a hexagram IS a 6-bit number 0..63 — upper trigram (3 bits) · lower trigram (3 bits)
+  const bits = (n: number, w: number) => n.toString(2).padStart(w, '0')
+  const sample = 0b101010 // one of the 64
+
+  let o = 'I Ching — exact binary combinatorics (a tradition use case):\n\n'
+  o += '  yin/yang = 0/1 (one bit).\n'
+  o += '  trigram = 3 bits → 2³ = ' + trigrams + ' (the bagua). e.g. ☰ = 111, ☷ = 000.\n'
+  o += '  hexagram = 6 bits → 2⁶ = ' + hexagrams + '. a hexagram is literally a 6-bit number 0..63:\n'
+  o += '    ' + bits(sample, 6) + ' = ' + sample + '  (upper ' + bits(sample >> 3, 3) + ' · lower ' + bits(sample & 7, 3) + ')\n\n'
+  o += '  the convergence at 64 (real, across tradition · computing · biology):\n'
+  o += '    I Ching hexagrams = 2⁶ = ' + hexagrams + '\n'
+  o += '    trigram pairs     = 8² = ' + trigramPairs + '\n'
+  o += '    DNA codons        = 4³ = ' + dnaCodons + '   (dna.ts)\n'
+  o += '    all equal 64? ' + converge + '   → Leibniz mapped I Ching → base-2 in 1703.\n\n'
+  o += '  reusable in any combination: n binary choices → 2^n. the deposit\'s 9 scripts compose as\n'
+  o += '  3 trinities — gates (gaps·seal·wholeness) · release (release·orchestrate·versions) · verify\n'
+  o += '  (lean-claims·deploy·ledger) — combinable in any subset (npm run harmony, release, …).\n\n'
+  o += 'HONEST: the combinatorics (2³=8, 2⁶=64) and the Leibniz base-2 mapping are exact/historical.\n'
+  o += 'The shared 64 (hexagrams · codons · 6-bit) is a real convergence of COMBINATORICS — not a\n'
+  o += 'mystical unity and not derived from ℤ/9. Specific hexagram meanings are tradition/interpretation,\n'
+  o += 'kept distinct from the counting. entails → 0/7.'
+  return o
+}

package/src/2/index.ts

@@ -0,0 +1,78 @@
+/**
+ * Theorem 2: P vs NP
+ * Licensed under CC BY-NC 4.0
+ * Attribution: Tsvetan Rouschev
+ */
+
+import { gcdBigInt, merkleFold, toUuid } from '../0'
+
+export interface Rational {
+  readonly num: bigint
+  readonly den: bigint
+}
+
+function rational(num: bigint | number, den: bigint | number = 1n): Rational {
+  const n = typeof num === 'bigint' ? num : BigInt(num)
+  const d = typeof den === 'bigint' ? den : BigInt(den)
+  if (d === 0n) throw new Error('Division by zero')
+  const g = gcdBigInt(n < 0n ? -n : n, d < 0n ? -d : d)
+  const sign = (n < 0n) !== (d < 0n) ? -1n : 1n
+  return { num: sign * (n < 0n ? -n : n) / g, den: (d < 0n ? -d : d) / g }
+}
+
+export type SymbolicExpr =
+  | { type: 'rational'; num: bigint; den: bigint }
+  | { type: 'sqrt'; inner: SymbolicExpr }
+  | { type: 'exp'; base: SymbolicExpr; exp: SymbolicExpr }
+  | { type: 'add'; left: SymbolicExpr; right: SymbolicExpr }
+  | { type: 'mul'; left: SymbolicExpr; right: SymbolicExpr }
+
+function symRat(num: bigint | number, den: bigint | number = 1n): SymbolicExpr {
+  const n = typeof num === 'bigint' ? num : BigInt(num)
+  const d = typeof den === 'bigint' ? den : BigInt(den)
+  return { type: 'rational', num: n, den: d }
+}
+
+function symSquare(expr: SymbolicExpr): SymbolicExpr {
+  return { type: 'mul', left: expr, right: expr }
+}
+
+function symSub(left: SymbolicExpr, right: SymbolicExpr): SymbolicExpr {
+  return { type: 'add', left, right: { type: 'mul', left: symRat(-1n), right } }
+}
+
+function symSqrt(inner: SymbolicExpr): SymbolicExpr {
+  return { type: 'sqrt', inner }
+}
+
+export interface ExactTheoremState {
+  name: string
+  canonical_description: string
+  off_canonical_description: string
+  alpha_symbolic: SymbolicExpr
+  beta_symbolic: SymbolicExpr
+  coherence_exact: SymbolicExpr
+  decoherence_rate: SymbolicExpr
+  derivation: string
+}
+
+export const p_vs_np_exact: ExactTheoremState = {
+  name: 'P vs NP',
+  canonical_description: 'P ≠ NP (hierarchy strict)',
+  off_canonical_description: 'P = NP (hierarchy collapses)',
+  alpha_symbolic: symRat(1n),
+  beta_symbolic: symSqrt(symSub(symRat(1n), symSquare(symRat(1n)))),
+  coherence_exact: symSquare(symRat(1n)),
+  decoherence_rate: symRat(0n),
+  derivation: `
+    1. Problem hierarchy: P ⊂ NP ⊂ PSPACE ⊂ EXPTIME
+    2. If P=NP: hierarchy collapses
+    3. But observed: NP-complete ≠ polynomial time
+    4. Hierarchy separation is EMPIRICAL FACT
+    5. No valid algorithm maps NP to P
+    6. Therefore: P≠NP with certainty, α = 1
+  `,
+}
+
+export const theorem2 = p_vs_np_exact
+export default p_vs_np_exact

package/src/2/primes-vortex.ts

@@ -0,0 +1,12 @@
+// Primes > 3 ride the vortex units, never the trinity axis (real theorem).
+export function report(): string {
+  const isP = (n: number) => { if (n < 2) return false; for (let i = 2; i * i <= n; i++) if (n % i === 0) return false; return true }
+  const dr = (n: number) => ((n - 1) % 9) + 1
+  const primes: number[] = []; for (let n = 5; n < 200; n++) if (isP(n)) primes.push(n)
+  const roots = [...new Set(primes.map(dr))].sort((a, b) => a - b)
+  let o = 'primes 5..199 → digital roots present: ' + roots.join(',') + '\n'
+  o += 'trinity {3,6,9} among them? ' + roots.some(r => [3, 6, 9].includes(r)) + '\n'
+  o += 'THEOREM: every prime p > 3 has digital root in the units {1,2,4,5,7,8}, never {3,6,9}\n'
+  o += '(gcd(p,3)=1 ⇒ p mod 9 is a unit). Primes ride the doubling circuit; the axis carries none.'
+  return o
+}