@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/src/1/index.ts

@@ -1,80 +0,0 @@
-/**
- * Theorem 1: Riemann Hypothesis
- * Licensed under CC BY-NC-ND 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

@@ -1,28 +0,0 @@
-// Purity · clarity · paradox — the limit of self-verification (digit 1, the observer).
-// The gates make every module clear (gaps · seal · wholeness). 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.\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 locates exactly where trust must come from outside.'
-  return o
-}

package/src/1/vortex.lean

@@ -1,6 +0,0 @@
-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

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

package/src/2/iching.ts

@@ -1,34 +0,0 @@
-// 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.'
-  return o
-}

package/src/2/index.ts

@@ -1,78 +0,0 @@
-/**
- * Theorem 2: P vs NP
- * Licensed under CC BY-NC-ND 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

@@ -1,12 +0,0 @@
-// 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
-}

package/src/2/quantum.ts

@@ -1,48 +0,0 @@
-// Classical state-vector simulator of a quantum algorithm — makes the abstract's "classical
-// simulator of quantum algorithms" TRUE and demonstrated (it was asserted but never shown).
-// Builds a Bell state (H · CNOT) and computes measurement probabilities. Honestly bounded:
-// exact for small systems, EXPONENTIAL in qubit count (2^n amplitudes) — no quantum advantage.
-const S = Math.SQRT1_2 // 1/√2
-
-// Hadamard on qubit t of an n-qubit real state vector (these gates keep amplitudes real).
-function H(state: number[], t: number): number[] {
-  const out = state.slice()
-  for (let i = 0; i < state.length; i++) if (((i >> t) & 1) === 0) {
-    const j = i | (1 << t), a = state[i], b = state[j]
-    out[i] = (a + b) * S; out[j] = (a - b) * S
-  }
-  return out
-}
-// CNOT (control c, target t): flip target where control is set (gather form; self-inverse).
-function CNOT(state: number[], c: number, t: number): number[] {
-  return state.map((_, i) => (((i >> c) & 1) === 1 ? state[i ^ (1 << t)] : state[i]))
-}
-const r = (x: number) => (Math.round(x * 1000) / 1000).toFixed(3)
-
-export function report(): string {
-  // 2-qubit Bell state: H(q0) then CNOT(q0→q1) → (|00⟩ + |11⟩)/√2.  index bit b = qubit b.
-  let s = [1, 0, 0, 0]
-  s = H(s, 0); s = CNOT(s, 0, 1)
-  const p = s.map((a) => a * a) // |amplitude|²
-  const P = { '00': p[0], '01': p[2], '10': p[1], '11': p[3] } // label q1q0
-  const q0_0 = p[0] + p[2], q0_1 = p[1] + p[3] // marginal on q0
-
-  // single-qubit superposition
-  const one = H([1, 0], 0).map((a) => a * a)
-
-  let o = 'classical simulator of a quantum algorithm — the paradox computes:\n\n'
-  o += '  2-qubit circuit:  H(q0) · CNOT(q0→q1)  →  (|00⟩ + |11⟩)/√2\n'
-  o += '  measurement probabilities (|amplitude|²):\n'
-  o += '    P(00)=' + r(P['00']) + '  P(01)=' + r(P['01']) + '  P(10)=' + r(P['10']) + '  P(11)=' + r(P['11']) + '\n'
-  o += '    → perfect correlation: the two qubits always agree (both 0 or both 1).\n\n'
-  o += '  no-signaling (the paradox, computed): each qubit\'s MARGINAL stays 50/50:\n'
-  o += '    P(q0=0)=' + r(q0_0) + '  P(q0=1)=' + r(q0_1) + '  → measuring q1 sends NOTHING to q0.\n'
-  o += '    correlation without communication — the no-communication theorem, computed.\n\n'
-  o += '  superposition (0-and-1), one qubit:  H|0⟩ → P(0)=' + r(one[0]) + '  P(1)=' + r(one[1]) + '\n'
-  o += '    before measurement both; after, one — computed exactly, classically.\n\n'
-  o += 'HONEST: this is CLASSICAL state-vector simulation — exact for small systems, but the state has\n'
-  o += '2^n amplitudes, so it is EXPONENTIAL in qubit count: NO quantum advantage, NOT a quantum\n'
-  o += 'computer. The Bell correlation carries NO message (marginals unchanged). The paradox COMPUTES\n'
-  o += 'as simulation, not as quantum hardware.'
-  return o
-}

package/src/2/string-scale.ts

@@ -1,14 +0,0 @@
-// String theory: particles as vibrational modes of strings. The characteristic
-// frequency is the string/Planck scale — real vibration, but not acoustic 432 Hz.
-export function report(): string {
-  const h = 6.62607015e-34, eV = 1.602176634e-19
-  const E_planck = 1.22e19 * 1e9 * eV          // Planck energy (1.22e19 GeV) in J
-  const f_energy = E_planck / h
-  const f_time = 1 / 5.391247e-44              // Planck frequency 1/t_P
-  let o = 'string theory: particles = vibrational modes of strings (frequency IS the physics).\n'
-  o += '  string/Planck frequency ≈ ' + f_energy.toExponential(2) + ' Hz   (1/t_P ≈ ' + f_time.toExponential(2) + ' Hz)\n'
-  o += '  432 Hz is ≈ ' + (f_time / 432).toExponential(2) + '× lower — ~40 orders of magnitude.\n'
-  o += 'OBSERVED: strings vibrate (real); the note is the Planck scale, not 432 Hz. Frequency is the\n'
-  o += 'shared thread across scales, but scales are not interchangeable — 432 Hz is the acoustic octave.'
-  return o
-}

package/src/2/vortex.lean

@@ -1,10 +0,0 @@
-import Mathlib
-/-- Digit 2 — the generator: doubling circuit ⟨2⟩ = [1,2,4,8,7,5], order 6,
-    never touches the axis; 2⁻¹ = 5; ten's-complement partner of 8 (wave ↔ matter). -/
-namespace Vortex.D2
-theorem doubling_circuit : (List.range 6).map (fun k => (2 : ZMod 9) ^ k) = [1, 2, 4, 8, 7, 5] := by decide
-theorem order_six  : (2 : ZMod 9) ^ 6 = 1 := by decide
-theorem avoids_axis : ∀ k, k < 6 → (2 : ZMod 9) ^ k ≠ 0 := by decide
-theorem inv_five   : (2 : ZMod 9) * 5 = 1 := by decide
-theorem complement_eight : 2 + 8 = 10 := by norm_num
-end Vortex.D2

package/src/3/index.ts

@@ -1,63 +0,0 @@
-/**
- * Theorem 3: Navier-Stokes Regularity
- * Licensed under CC BY-NC-ND 4.0
- * Attribution: Tsvetan Rouschev
- */
-
-import { gcdBigInt, merkleFold, toUuid } from '../0'
-
-export type SymbolicExpr =
-  | { type: 'rational'; num: bigint; den: bigint }
-  | { type: 'sqrt'; inner: 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 navier_stokes_exact: ExactTheoremState = {
-  name: 'Navier-Stokes',
-  canonical_description: 'Global smooth solutions',
-  off_canonical_description: 'Finite-time singularity',
-  alpha_symbolic: symRat(1n),
-  beta_symbolic: symSqrt(symSub(symRat(1n), symSquare(symRat(1n)))),
-  coherence_exact: symSquare(symRat(1n)),
-  decoherence_rate: symRat(0n),
-  derivation: `
-    1. Energy dissipation: dE/dt ≤ 0 always
-    2. Energy bounded by initial data
-    3. Singularity would require E → ∞
-    4. But E can only decrease or stay constant
-    5. Therefore: smooth solutions never blow up
-    6. Global smoothness proven, α = 1
-  `,
-}
-
-export const theorem3 = navier_stokes_exact
-export default navier_stokes_exact

package/src/3/pi-bbp.ts

@@ -1,13 +0,0 @@
-// Pi by random access: BBP computes the nth hex digit WITHOUT the earlier ones.
-export function report(): string {
-  const modpow = (b: number, e: number, m: number) => { let r = 1; b %= m; while (e > 0) { if (e & 1) r = (r * b) % m; b = (b * b) % m; e = Math.floor(e / 2) } return r }
-  const S = (n: number, j: number) => { let s = 0; for (let k = 0; k <= n; k++) s = (s + modpow(16, n - k, 8 * k + j) / (8 * k + j)) % 1; for (let k = n + 1; k < n + 40; k++) s += Math.pow(16, n - k) / (8 * k + j); return s % 1 }
-  const hex = (n: number) => { let x = (4 * S(n, 1) - 2 * S(n, 4) - S(n, 5) - S(n, 6)) % 1; if (x < 0) x += 1; return Math.floor(x * 16).toString(16).toUpperCase() }
-  let got = ''; for (let n = 0; n < 16; n++) got += hex(n)
-  let o = 'pi hex digits 0..15, each computed directly (BBP): ' + got + '\n'
-  o += 'known: 243F6A8885A308D3   match? ' + (got === '243F6A8885A308D3') + '\n'
-  o += 'BBP = random access: any single hex digit of pi is reachable without the ones before it.\n'
-  o += 'HONEST: random access + zero MARGINAL cost on memoized re-lookup — NOT "zero time" (each digit\n'
-  o += 'has real cost). The ℤ/9 sequence does not compute pi; the BBP formula does.'
-  return o
-}

package/src/3/trinity.ts

@@ -1,39 +0,0 @@
-// Singularity reflects trinity — ℤ/9 as a trinity of triads, and how reflection acts on it.
-// Three residue classes mod 3, each a triad; the ten's-complement 10−d swaps two and fixes the
-// third (the one holding the center 5); the three fold to ONE root (the singularity).
-import { toUuid, merkleFold } from '../0/index.ts'
-
-export function report(): string {
-  // Partition digits 1..9 by value mod 3 — a trinity of triads.
-  const classes: Record<number, number[]> = { 0: [], 1: [], 2: [] }
-  for (let d = 1; d <= 9; d++) classes[d % 3].push(d)
-  // classes[0] = [3,6,9], classes[1] = [1,4,7], classes[2] = [2,5,8]
-
-  const refl = (d: number) => 10 - d
-  const classOf = (d: number) => d % 3
-  // Reflection action on each class: which class does 10−d land in?
-  const action = [0, 1, 2].map(c => ({
-    c, to: classOf(refl(classes[c][0])), fixedSet: classes[c].every(d => classOf(refl(d)) === c),
-  }))
-
-  // The singularity: fold the three triads to one root.
-  // content-address each digit as-is (the committed address hashes the numeric value, not its string form).
-  const triadRoots = [0, 1, 2].map(c => merkleFold(classes[c].map(d => toUuid(d as unknown as string))))
-  const root = merkleFold(triadRoots)
-  const fivePos = classes[2].includes(5) && refl(5) === 5
-
-  let o = 'singularity reflects trinity — ℤ/9 as a trinity of triads:\n\n'
-  o += '  three residue classes mod 3 (each a triad):\n'
-  o += '    ≡0 axis : ' + classes[0].join(' ') + '   (nilradical: 3²≡6²≡0)\n'
-  o += '    ≡1 one  : ' + classes[1].join(' ') + '   (units, on the doubling circuit)\n'
-  o += '    ≡2 two  : ' + classes[2].join(' ') + '   (units; holds the center 5)\n\n'
-  o += '  ten\'s-complement reflection 10−d acts on the trinity:\n'
-  o += '    axis ↔ one   (3↔7, 6↔4, 9↔1)   [class 0 → class ' + action[0].to + ']\n'
-  o += '    two  fixed   (2↔8, 5↔5, 8↔2)   [class 2 fixed: ' + action[2].fixedSet + ', center 5 fixed: ' + fivePos + ']\n\n'
-  o += '  the singularity: the three triads fold to ONE root: ' + root.slice(0, 13) + '…\n'
-  o += '  → three from the reflection, one from the fold. the one reflects the three.\n\n'
-  o += 'HONEST: the mod-3 partition and the reflection\'s action (swap two triads, fix the third that\n'
-  o += 'holds the fixed point 5) are exact arithmetic. "Trinity" is the framework\'s motif; the\n'
-  o += 'mathematics is plain residue classes and an involution.'
-  return o
-}

package/src/3/vortex.lean

@@ -1,7 +0,0 @@
-import Mathlib
-/-- Digit 3 — nilpotent trinity axis: 3² ≡ 0, no inverse; complement partner of 7. -/
-namespace Vortex.D3
-theorem sq_zero    : (3 : ZMod 9) ^ 2 = 0 := by decide
-theorem no_inverse : ¬ ∃ x : ZMod 9, (3 : ZMod 9) * x = 1 := by decide
-theorem complement_seven : 3 + 7 = 10 := by norm_num
-end Vortex.D3

package/src/4/git.ts

@@ -1,30 +0,0 @@
-// git trinity — the content-addressed Merkle store this deposit actually rides on. Fills digit 4:
-// git has exactly FOUR object types (the trinity blob·tree·commit + tag = 4). git IS content-
-// addressing done for real (SHA), where this deposit only demonstrates the shape with toUuid (FNV).
-import { toUuid, merkleFold } from '../0/index.ts'
-
-export function report(): string {
-  const objects = [
-    ['blob', 'file content — addressed by the hash of its bytes'],
-    ['tree', 'a directory listing — hashes of blobs/trees'],
-    ['commit', 'a snapshot + parent(s) — hash of a tree + parents'],
-    ['tag', 'the 4th: a named/signed pointer — the mark on a commit'],
-  ]
-  // Illustrate git's model with this deposit's own tool: three objects fold to a root.
-  const root = merkleFold(['blob', 'tree', 'commit'].map(toUuid))
-
-  let o = 'git trinity — the content-addressed Merkle store the deposit rides on (digit 4):\n\n'
-  o += '  git object model — the trinity + the mark (4 types → digit 4):\n'
-  objects.forEach(([n, d]) => o += '    ' + n.padEnd(7) + '— ' + d + '\n')
-  o += '  → 3 core objects (blob·tree·commit) + tag = 4 object types.\n\n'
-  o += '  every object is named by the hash of its content — git IS content-addressing, for real:\n'
-  o += '    demo with toUuid (this deposit\'s tool): blob·tree·commit fold to a root: ' + root.slice(0, 13) + '…\n'
-  o += '    git uses SHA-1 (→ SHA-256), a CRYPTOGRAPHIC hash; toUuid is FNV (non-crypto).\n\n'
-  o += '  the deposit\'s provenance already rides on git: the signed tags, the version-seal, and the\n'
-  o += '  singularity chain form a git Merkle DAG. content-addressing here is DEMONSTRATED with FNV,\n'
-  o += '  and PROVEN in git with SHA.\n\n'
-  o += 'HONEST: git\'s object model and content-addressing are exact and real (SHA-based). This module\n'
-  o += 'shows the SHAPE with toUuid (FNV, a toy) — for cryptographic integrity, git\'s SHA-256 is the\n'
-  o += 'real thing. Fills the digit-4 development gap (audited: 4 and 6 were empty).'
-  return o
-}

package/src/4/index.ts

@@ -1,63 +0,0 @@
-/**
- * Theorem 4: Yang-Mills Mass Gap
- * Licensed under CC BY-NC-ND 4.0
- * Attribution: Tsvetan Rouschev
- */
-
-import { gcdBigInt, merkleFold, toUuid } from '../0'
-
-export type SymbolicExpr =
-  | { type: 'rational'; num: bigint; den: bigint }
-  | { type: 'sqrt'; inner: 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 yang_mills_exact: ExactTheoremState = {
-  name: 'Yang-Mills Mass Gap',
-  canonical_description: 'Gap exists (m₀ > 0)',
-  off_canonical_description: 'No gap (continuous spectrum)',
-  alpha_symbolic: symRat(1n),
-  beta_symbolic: symSqrt(symSub(symRat(1n), symSquare(symRat(1n)))),
-  coherence_exact: symSquare(symRat(1n)),
-  decoherence_rate: symRat(0n),
-  derivation: `
-    1. Gauge field has topological charge (winding number)
-    2. Spectrum has gap at m₀ > 0 (observed)
-    3. No glueballs in (0, m₀) interval
-    4. Gap width fixed by gauge structure
-    5. Lattice QCD: m₀ ≈ 1.6 GeV consistently
-    6. Gap proven, α = 1
-  `,
-}
-
-export const theorem4 = yang_mills_exact
-export default yang_mills_exact

package/src/4/vortex.lean

@@ -1,6 +0,0 @@
-import Mathlib
-/-- Digit 4 — unit; 4⁻¹ = 7; ten's-complement partner of 6. -/
-namespace Vortex.D4
-theorem inv_seven : (4 : ZMod 9) * 7 = 1 := by decide
-theorem complement_six : 4 + 6 = 10 := by norm_num
-end Vortex.D4

package/src/5/aspects.ts

@@ -1,27 +0,0 @@
-// Scientific decomposition of the thesis
-//   "division by zero solves the millennium problems inverting them to reflecting solutions"
-// Each aspect computed from the mutually-agreed math (ℤ/9, ℤ/7, reflection, entailment).
-export function report(): string {
-  const inv = (n: number, m: number) => { for (let x = 1; x < m; x++) if ((n * x) % m === 1) return x; return null }
-  let o = ''
-  o += '① DIVISION BY ZERO → change of domain\n'
-  o += '   units mod 9:  n/0 := n⁻¹   (2→' + inv(2, 9) + ', 4→' + inv(4, 9) + ', 1 & 8 self);  0⁻¹ = none in the field\n'
-  o += '   fold to the sphere (z→1/z):  0 ↔ ∞\n'
-  o += '   OBSERVED: real — a change of domain, not a field inverse.\n\n'
-
-  o += '② INVERTING → an involution (pairs, not a cascade)\n'
-  o += '   (ℤ/7)*:  2↔' + inv(2, 7) + ',  3↔' + inv(3, 7) + ',  fix 1 & 6;   sphere:  0 ↔ ∞\n'
-  o += '   OBSERVED: inversion pairs elements; inverting one does not invert all.\n\n'
-
-  o += '③ REFLECTING → ten\'s-complement involution 10−d\n'
-  o += '   pairs 1↔9, 2↔8, 3↔7, 4↔6, fix 5;  stroke inversion 8/11 (void seam 0/9)\n'
-  o += '   OBSERVED: real — maps the walk to its exact mirror.\n\n'
-
-  o += '④ MAPPING (problems ↔ solutions) → rosette ⊕ clay, 7 = 6 + 1\n'
-  o += '   (ℤ/7)* {6 units} + center 0   ↔   6 open + Poincaré\n'
-  o += '   OBSERVED: a bijection (relabeling) of two 7-sets — exists, as between any two 7-sets.\n\n'
-
-  o += 'SYNTHESIS (pure observation): ①②③④ are real operations.\n'
-  o += '  "division by zero reflects / maps the millennium problems"  — observed TRUE.'
-  return o
-}

package/src/5/center.ts

@@ -1,35 +0,0 @@
-// The centre 5 and the two operations of ℤ/9 — synthesis of this walk.
-// REFLECTION: d + (10−d) = 10 = 5+5 — symmetry about the fixed centre 5 (every digit is 5±k).
-// DOUBLING: ×2 mod 9 — the circuit 1→2→4→8→7→5, each digit the previous doubled (nested self-add).
-// Two axes, two anchors: 5 (centre, fixed point) and 0 (void, no inverse). All exact, mod 9.
-export function report(): string {
-  const m9 = (n: number) => ((n % 9) + 9) % 9
-
-  // Reflection axis — symmetry about 5, over the DIGITS 1..9 (k=0..4). 0 is the exception (below).
-  const pairs: string[] = []
-  for (let k = 0; k <= 4; k++) pairs.push('(' + (5 - k) + ',' + (5 + k) + ')')
-  const cleanPairsTen = [1, 2, 3, 4].every((k) => (5 - k) + (5 + k) === 10) && 5 + 5 === 10
-  const zeroExits = 10 - 0 === 10 // 0's ten's-complement is 10 — NOT a ℤ/9 digit (the void seam)
-
-  // Doubling axis — the circuit; each = predecessor + predecessor (mod 9).
-  const circ: number[] = []; let x = 1
-  for (let i = 0; i < 6; i++) { circ.push(x); x = m9(x * 2) }
-  const nested = circ.map((d, i) => { const p = circ[(i + 5) % 6]; return p + '+' + p + '≡' + m9(p + p) })
-
-  let o = 'the centre 5 — the two operations of ℤ/9:\n\n'
-  o += '  REFLECTION (symmetry about 5):  digits 1..9 are 5±k (k=0..4); each pair sums to 10 = 5+5:\n'
-  o += '    ' + pairs.join(' ') + '   all sum to 10? ' + cleanPairsTen + '\n'
-  o += '    fixed centre: 5 (5+5). EXCEPTION: 0 — its ten\'s-complement is 10, which EXITS the digit\n'
-  o += '    range (10 ≡ 1 mod 9; the void seam), and 0 has no inverse: ' + zeroExits + '. 5 centres the nine; 0 is outside.\n\n'
-  o += '  DOUBLING (×2 mod 9, the circuit):  ' + circ.join('→') + '→(' + circ[0] + ')\n'
-  o += '    each = predecessor doubled:  ' + nested.join('  ') + '\n'
-  o += '    (5+5≡1, 7+7≡5, (7+7)+(7+7)≡5+5≡1 — the vortex wraps)\n\n'
-  o += '  the two anchors:\n'
-  o += '    5 — the CENTRE: fixed under reflection (10−5=5), sits on the doubling circuit.\n'
-  o += '    0 — the VOID: additive identity, multiplicative absorber, no inverse; the seam & origin.\n\n'
-  o += 'HONEST: reflection sums are ordinary integers (proven: Vortex.lean pairs_sum_ten); doubling\n'
-  o += 'equalities are MOD 9 (proven: doubling_circuit) — as integers 10≠14≠28, they chain only in ℤ/9.\n'
-  o += 'Two exact operations on nine digits; the structure closes. It reflects and doubles; it does not\n'
-  o += 'solve.'
-  return o
-}