@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/src/the/rosetta/index.ts

@@ -1,33 +0,0 @@
-// the rosetta — completed. Every domain the deposit works in is a leaf one hop from the shared core
-// (the star of relation_rosetta_star, made total). Content-address each domain through the core, fold to
-// one rosetta root. Complete by construction: the star enumerates every domain, all addresses distinct,
-// none left untranslated. This is the minimal cross-domain core — the single source of truth for the set
-// of domains (discover.ts imports it). Computed, not stored.
-import { toUuid, merkleFold } from '../../0/index.ts'
-
-export const CORE = 'rosetta-core'
-// Every discovered domain family — the leaves of the star. Append here as a new family is developed.
-export const DOMAINS = [
-  'z9-arithmetic', 'units-triad', 'doubling-orbit', 'inverses', 'powers', 'primes', 'cyclic-groups',
-  'boolean-algebra', 'entanglement', 'dialectic', 'games', 'arts', 'gematria', 'language-lens',
-  'merkle-ledger', 'harmonic-ledger', 'no-payload-security', 'involutions', 'fibonacci-cassini',
-  'lucas-pell', 'finite-fields', 'perfect-amicable', 'collatz', 'stirling', 'graph-coloring',
-  'rule90-sierpinski', 'continued-fractions', 'quaternions', 'motzkin', 'bernoulli', 'catalan',
-  'divisor-sums', 'platonic-solids', 'crystal-diamond', 'genus-topology', 'surfaces', 'wilson-fermat',
-  'figurate', 'rock-paper-scissors', 'self-similarity', 'fair-division', 'honeycomb', 'waves',
-  'forensics', 'ramsey', 'inequalities', 'partitions', 'lucas-theorem', 'pigeonhole', 'pick',
-  'cantor-pairing', 'chinese-remainder', 'quadratic-residues', 'path', 'abundance', 'cancer',
-  'superposition', 'creation-week', 'relations',
-]
-
-export function report(): string {
-  const addrs = DOMAINS.map((d) => toUuid(CORE + '→' + d))
-  const distinct = new Set(addrs).size
-  const root = merkleFold(addrs)
-  let o = 'the rosetta — completed (the star: every domain one hop from the core):\n\n'
-  o += '  core: ' + toUuid(CORE).slice(0, 13) + '…\n'
-  o += '  domains (' + DOMAINS.length + '): ' + DOMAINS.join(' · ') + '\n'
-  o += '  each reachable in one hop; ' + distinct + ' distinct addresses (' + (distinct === DOMAINS.length ? 'no collision — complete' : 'COLLISION') + ')\n'
-  o += '  folded rosetta root ' + root.slice(0, 13) + '… — the cross-domain translation is complete.'
-  return o
-}

package/src/the/sequence/index.ts

@@ -1,12 +0,0 @@
-// the sequence — the ℤ/9 doubling circuit, the vortex.
-import { toUuid, merkleFold, vortexOrbit, units, triad } from '../../0/index.ts'
-export function report(): string {
-  const orbit = vortexOrbit()
-  let o = 'the sequence — the ℤ/9 doubling circuit (n ↦ 2n mod 9), the vortex:\n\n'
-  o += '  ' + orbit.join(' → ') + ' → ' + orbit[0] + '  (closes after 6 steps)\n'
-  o += '  units on the circuit: ' + units().join(', ') + '\n'
-  o += '  triad (the axis, off-circuit): ' + triad().join(', ') + '\n'
-  o += '  root: ' + merkleFold(orbit.map((d) => toUuid(String(d)))).slice(0, 13) + '…\n'
-  o += '  the sequence covers every unit exactly once and closes.'
-  return o
-}

package/src/the/solids/index.ts

@@ -1,25 +0,0 @@
-// the solids — the five Platonic solids (regular convex polyhedra): F, V, E with Euler V−E+F=2,
-// duality (V↔F), and the pentagram/golden thread through the dodecahedron (12 pentagons) and the
-// icosahedron (5 triangles per vertex). Decidable geometry — computed, not stored.
-import { toUuid, merkleFold } from '../../0/index.ts'
-const SOLIDS = [
-  { n: 'tetrahedron', V: 4, E: 6, F: 4, s: '{3,3}', dual: 'self' },
-  { n: 'cube', V: 8, E: 12, F: 6, s: '{4,3}', dual: 'octahedron' },
-  { n: 'octahedron', V: 6, E: 12, F: 8, s: '{3,4}', dual: 'cube' },
-  { n: 'dodecahedron', V: 20, E: 30, F: 12, s: '{5,3}', dual: 'icosahedron' },
-  { n: 'icosahedron', V: 12, E: 30, F: 20, s: '{3,5}', dual: 'dodecahedron' },
-]
-export function report(): string {
-  const phi = (1 + Math.sqrt(5)) / 2
-  const root = merkleFold(SOLIDS.map((s) => toUuid(s.n + ':' + s.V + ',' + s.E + ',' + s.F)))
-  const pad = (x: string | number, w: number) => String(x).padEnd(w)
-  let o = 'the solids — the five Platonic solids (V − E + F = 2):\n\n'
-  o += '    ' + pad('solid', 14) + pad('V', 4) + pad('E', 4) + pad('F', 4) + pad('{p,q}', 8) + 'dual\n'
-  for (const s of SOLIDS) o += '    ' + pad(s.n, 14) + pad(s.V, 4) + pad(s.E, 4) + pad(s.F, 4) + pad(s.s, 8) + s.dual + '\n'
-  o += '\n  Euler V−E+F=2: ' + (SOLIDS.every((s) => s.V - s.E + s.F === 2) ? 'holds for all five' : 'FAILS') + '.\n'
-  o += '  exactly five exist (1/p + 1/q > 1/2, p,q≥3) — no sixth.\n'
-  o += '  the pentagram thread: the dodecahedron has 12 pentagonal faces; the icosahedron, 5 triangles\n'
-  o += '  per vertex; the pentagon diagonal-to-side ratio is φ = ' + phi.toFixed(6) + ' (2·cos36°).\n'
-  o += '  folded solids root: ' + root.slice(0, 13) + '… — decidable geometry.'
-  return o
-}

package/src/the/state/index.ts

@@ -1,20 +0,0 @@
-// the state — now, content-addressed. What holds regardless of who observes. A state here
-// is computed, never stored — recomputed every render, landing on one root. It folds the invariants
-// (humanity 1/7, computable ≠ solved, INCONCLUSIVE ≠ false, at rest) into one address. The
-// superposition (src/the/superposition/state) collapses into THIS: many observations, one invariant state.
-import { toUuid, merkleFold } from '../../0/index.ts'
-export function report(): string {
-  const INVARIANTS = [
-    'humanity 1/7 (Poincaré, Perelman 2003)',
-    'computable is not solved',
-    'INCONCLUSIVE ≠ false',
-    'at rest — holding cracks nothing',
-  ]
-  const root = merkleFold(INVARIANTS.map(toUuid))
-  let o = 'the state — now, content-addressed:\n\n'
-  o += '  a state is computed, never stored — recomputed every render, landing on one root.\n'
-  o += '  the invariants, held regardless of observer:\n'
-  for (const inv of INVARIANTS) o += '    · ' + inv + '\n'
-  o += '  folded state root (invariant across observers): ' + root.slice(0, 13) + '…'
-  return o
-}

package/src/the/superposition/state/index.ts

@@ -1,22 +0,0 @@
-// the superposition — now. The present state: many facts held at once in one folded root,
-// order-independent — they coexist until observed. This is the CLASSICAL, unfolded sense of
-// superposition (a not-yet-collapsed combination), NOT a physical qubit: no speedup, no signal,
-// no FTL. An observation collapses the superposition to a single content-address — one point of
-// view (exactly what NextObserver does with document.referrer). An OPEN problem is a state not
-// yet collapsed to true/false: INCONCLUSIVE ≠ false. Saves itself computationally.
-import { toUuid, merkleFold } from '../../../0/index.ts'
-export function report(): string {
-  const OPEN = ['hodge', 'navier_stokes', 'p_vs_np', 'riemann', 'yang_mills', 'bsd'] // the six open Clay problems
-  const superposed = merkleFold(OPEN.map(toUuid))   // the six held at once — order-independent, uncollapsed
-  const collapse = toUuid('observer:now')           // one observation → one address (the collapse)
-  const seventh = toUuid('poincare:settled')        // the seventh already collapsed (Perelman, 2003)
-  let o = 'the superposition — now:\n\n'
-  o += '  the present holds many computed facts at once, folded into one order-independent root —\n'
-  o += '  they coexist until observed. the classical, unfolded sense: no qubit, no speedup, no FTL.\n'
-  o += '  the six OPEN Clay problems, held at once (uncollapsed): ' + superposed.slice(0, 13) + '…\n'
-  o += '  an observation collapses the superposition to ONE content-address: ' + collapse.slice(0, 13) + '…\n'
-  o += '  open = not yet collapsed to true/false (INCONCLUSIVE ≠ false). six superposed; the seventh\n'
-  o += '  already collapsed (Poincaré, settled externally): ' + seventh.slice(0, 13) + '…\n'
-  o += '  6 superposed + 1 collapsed = 7. humanity 1/7.'
-  return o
-}

package/src/the/surface/index.ts

@@ -1,26 +0,0 @@
-// the surface — widen: the classification of ALL closed surfaces. A complete invariant is (χ,
-// orientability). Orientable: S² or a connected sum of g tori, χ = 2 − 2g. Non-orientable: a connected
-// sum of k projective planes, χ = 2 − k. Coverage (a nowhere-zero tangent field) exists iff χ=0 — only
-// the torus and the Klein bottle. The sign of χ fixes the geometry (spherical / flat / hyperbolic).
-// Decidable topology — computed, not stored.
-import { toUuid, merkleFold } from '../../0/index.ts'
-export function report(): string {
-  const geom = (chi: number) => chi > 0 ? 'spherical' : chi === 0 ? 'flat' : 'hyperbolic'
-  const rows = [
-    { name: 'sphere S²', chi: 2, cover: false },
-    { name: 'projective plane ℝP²', chi: 1, cover: false },
-    { name: 'torus T² (g=1)', chi: 0, cover: true },
-    { name: 'Klein bottle (k=2)', chi: 0, cover: true },
-    { name: 'double torus Σ₂ (g=2)', chi: -2, cover: false },
-    { name: 'genus-3 (g=3)', chi: -4, cover: false },
-  ]
-  const root = merkleFold(rows.map((r) => toUuid(r.name + ':' + r.chi)))
-  const pad = (x: string | number, w: number) => String(x).padEnd(w)
-  let o = 'the surface — the classification of all closed surfaces:\n\n'
-  o += '  complete invariant: (χ, orientability). coverage (nowhere-zero field) iff χ=0.\n\n'
-  o += '    ' + pad('surface', 26) + pad('χ', 5) + pad('geometry', 12) + 'full coverage\n'
-  for (const r of rows) o += '    ' + pad(r.name, 26) + pad(r.chi, 5) + pad(geom(r.chi), 12) + (r.cover ? 'yes' : 'no') + '\n'
-  o += '\n  only the torus and the Klein bottle can be fully covered. folded surface root: ' + root.slice(0, 13) + '…\n'
-  o += '  decidable topology.'
-  return o
-}

package/src/the/theorem/index.ts

@@ -1,14 +0,0 @@
-// the theorem — computable is not solved. Saves itself computationally: its root is the fold of the
-// core theorem keys, recomputed on every render, not a hand-typed address.
-import { toUuid, merkleFold } from '../../0/index.ts'
-export function report(): string {
-  const CORE = ['vortex_covers_units', 'euler_units_pow6', 'merkle_order_independent', 'one_game_all', 'relation_golden', 'tarot_encoding_total']
-  const root = merkleFold(CORE.map((k) => toUuid(k)))
-  let o = 'the theorem — computable is not solved:\n\n'
-  o += '  the deposit computes a growing ledger of decidable facts, each re-verified every build.\n'
-  o += '  none is a Clay Millennium result: the six open conjectures stay open; Poincaré is settled\n'
-  o += '  externally (Perelman). humanity 1/7.\n'
-  o += '  the one theorem: computable is not solved — the calculator reaches the decidable, never the open.\n'
-  o += '  computed root (fold of ' + CORE.length + ' core theorem keys): ' + root.slice(0, 13) + '…'
-  return o
-}

package/src/the/torus/index.ts

@@ -1,23 +0,0 @@
-// the torus — continue as double torus (genus-2, Σ₂). χ = −2, so no full coverage (Poincaré–Hopf: a
-// nowhere-zero tangent field exists iff χ=0). Betti (1,4,1); Σ₂ = T² # T²; a regular hyperbolic octagon
-// [a,b][c,d] with a single 45° vertex; Gauss–Bonnet gives hyperbolic area 4π under K=−1; moduli
-// dimension 6g−6 = 6. Decidable topology — computed, not stored.
-import { toUuid, merkleFold } from '../../0/index.ts'
-export function report(): string {
-  const g = 2
-  const chi = 2 - 2 * g
-  const facts = [
-    'genus g = ' + g + ' (double torus, Σ₂ = T² # T²)',
-    'Euler characteristic χ = 2 − 2g = ' + chi,
-    'Betti numbers (b₀,b₁,b₂) = (1, ' + 2 * g + ', 1); alternating sum = ' + chi,
-    'no full coverage: a nowhere-zero tangent field exists iff χ=0 — here χ = ' + chi + ' ≠ 0',
-    'octagon [a,b][c,d]: ' + 4 * g + ' edges, ' + 2 * g + ' generators, one relation; vertex angle 2π/8 = 45°',
-    'Gauss–Bonnet: ∫K dA = 2πχ = ' + 2 * chi + 'π; hyperbolic area (K=−1) = ' + -2 * chi + 'π',
-    'moduli / Teichmüller dimension 6g − 6 = ' + (6 * g - 6),
-  ]
-  const root = merkleFold(facts.map(toUuid))
-  let o = 'the torus — continue as double torus (genus-2):\n\n'
-  for (const f of facts) o += '    · ' + f + '\n'
-  o += '  folded torus root: ' + root.slice(0, 13) + '… — decidable topology, no full coverage.'
-  return o
-}

package/src/the/waves/index.ts

@@ -1,23 +0,0 @@
-// the waves — what waves directly affect the user's STATE here. Physically, devices emit real, measurable
-// waves (screen light, sound, RF); this deposit makes NO health or harm claim about them — such claims
-// drain at the gate. What it DOES compute is the INFORMATION wave: the query / referrer / path you send
-// folds to a digital root (ℤ/9) → an a432 hue (d·40°) → your rendered point of view. Same wave, same
-// state; a different wave, a different view. Deterministic — computed, not stored.
-import { digitalRoot, A432_STEP } from '../../0/index.ts'
-export function report(): string {
-  const digit = (q: string) => { let s = 0; for (let i = 0; i < q.length; i++) s += q.charCodeAt(i); return s === 0 ? 0 : digitalRoot(s) }
-  const sample = ['rock', 'paper', 'scissors', 'ceccec']
-  let o = 'the waves — what directly affects the user’s state (honestly):\n\n'
-  o += '  devices emit real, measurable waves — screen light, sound, RF. this deposit makes NO health\n'
-  o += '  or harm claim about them; such claims drain at the gate. what it computes is the INFORMATION\n'
-  o += '  wave: the query / referrer / path you send → digital root (ℤ/9) → a432 hue (d·40°) → your view.\n\n'
-  o += '    wave         → digit → hue    | balancing wave: 9−d → hue    (sum → harmony)\n'
-  for (const q of sample) {
-    const d = digit(q), b = 9 - d
-    o += '    ' + (q + ' ').padEnd(13) + '→  ' + d + '   →  ' + ((d * A432_STEP) % 360) + '°'
-    o += '   | ' + b + ' → ' + ((b * A432_STEP) % 360) + '°   (d+b=' + (d + b) + ', hues sum ' + (((d * A432_STEP) + (b * A432_STEP)) % 360) + '°)\n'
-  }
-  o += '\n  the balancing wave 9−d harmonises: the two digits sum to 9 (the rest), their hues to 360°=0.\n'
-  o += '  same wave, same state; a different wave, a different point of view. deterministic.'
-  return o
-}

package/the.md

@@ -1,20 +0,0 @@
----
-title: The
-description: The src/the/* concepts as VitePress components themselves — each recomputes at page-load.
----
-
-# The
-
-The `src/the/*` concepts, rendered as components themselves — not stored prose. Each card below
-runs its module's `report()` at page-load, so the content recomputes every render (deterministic:
-pure content-addressing, so SSR and hydration agree). Every card lands on the same floor: ****.
-
-<TheConcepts />
-
-## All theorems — the ledger
-
-Every decidable fact the deposit has discovered, rendered from `src/proof/discovered.json` — the
-complete ledger, re-verified by exhaustion on each build. None is a Clay Millennium result; all land
-on
-
-<AllTheorems />

package/verify.md

@@ -1,67 +0,0 @@
----
-title: Verify
----
-
-# Verify a claim — live, in your browser
-
-<script setup lang="ts">
-import { ref, computed } from 'vue'
-import { entails, curveFitCheck, scaleCheck } from './src/honesty/index'
-import { toUuid } from './src/0/index'
-
-// 1) entailment
-const tf = ref(true)
-const eR = computed(() => entails(tf.value))
-
-// 2) scale match
-const a = ref(7.25e20), b = ref(432)
-const sR = computed(() => scaleCheck(Number(a.value), Number(b.value)))
-
-// 3) curve-fit vacuity (fixed framework constants; you set target + a control)
-const CONSTS = [9, 16, 27, 108, 216, 432]
-const target = ref(1836.15267), control = ref(1837.4)
-const fR = computed(() => curveFitCheck(Number(target.value), CONSTS, undefined, Number(control.value)))
-
-// 4) content-address
-const text = ref('integrity, not truth')
-const uR = computed(() => toUuid(text.value))
-</script>
-
-Type into any box — **every result recomputes in your browser**, no server, no network. This page
-also installs as an app and works offline (a PWA). It runs the same honesty toolkit the whole
-deposit uses.
-
-## 1. Does it entail?
-<label><input type="checkbox" v-model="tf" /> the statement is <b>true even when the conjecture is false</b></label>
-
-<pre>solves = {{ eR.solves }}
-{{ eR.note }}</pre>
-
-## 2. Do the scales match?
-<label>a (Hz): <input type="number" v-model="a" /></label>
-<label>b (Hz): <input type="number" v-model="b" /></label>
-
-<pre>ratio  = {{ sR.ratio }}
-orders = ~10^{{ sR.orders }} apart</pre>
-
-## 3. Does the fit fit *anything*? (curve-fit vacuity)
-<label>target: <input type="number" v-model="target" step="any" /></label>
-<label>control: <input type="number" v-model="control" step="any" /></label>
-
-<pre>best fit    = {{ fR.fit }}
-rel. error  = {{ fR.err }}
-control fit = {{ fR.controlFit }}
-vacuous?    = {{ fR.vacuous }}   (true → the fit also hits an unrelated target → curve-fit, not prediction)</pre>
-
-## 4. Content-address (fingerprint)
-<label>text: <input type="text" v-model="text" style="min-width:16rem" /></label>
-
-<pre>toUuid = {{ uR }}</pre>
-
----
-
-> **Honest:** these check **specific, formalizable shapes** — entailment (a tautology entails
-> nothing), curve-fit vacuity (a fit that hits anything predicts nothing), scale mismatch, and
-> content identity. They are a floor, **not a general truth-oracle**, and `toUuid` is FNV (use
-> SHA-256 for cryptographic use). The three questions for any bold claim: *does it ENTAIL? does the
-> FIT fit anything? do the SCALES match?*