@ceccec/millennium-solutions 0.1.1

package/src/the/sequence/index.ts

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

package/src/the/solids/index.ts

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

package/src/the/state/index.ts

@@ -0,0 +1,21 @@
+// the state — now, content-addressed. What holds regardless of who observes: the floor. A state here
+// is computed, never stored — recomputed every render, landing on one root. It folds the invariants
+// (0/7, 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 floor.
+import { toUuid, merkleFold } from '../../0/index.ts'
+export function report(): string {
+  const INVARIANTS = [
+    'floor: this deposit 0/7',
+    '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 floor.\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) + '… entails → 0/7.'
+  return o
+}

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

@@ -0,0 +1,22 @@
+// 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; this deposit 0/7.'
+  return o
+}

package/src/the/surface/index.ts

@@ -0,0 +1,26 @@
+// 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 — this deposit 0/7.'
+  return o
+}

package/src/the/theorem/index.ts

@@ -0,0 +1,14 @@
+// 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; this deposit 0/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) + '… entails → 0/7.'
+  return o
+}

package/src/the/torus/index.ts

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

package/src/the/waves/index.ts

@@ -0,0 +1,23 @@
+// 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 — this deposit 0/7.'
+  return o
+}

package/the.md

@@ -0,0 +1,20 @@
+---
+title: The
+description: The src/the/* concepts as VitePress components themselves — each recomputes at page-load, every card landing on the same floor 0/7.
+---
+
+# 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: **`0/7`**.
+
+<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 `0/7`.
+
+<AllTheorems />

package/verify.md

@@ -0,0 +1,67 @@
+---
+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('entails → 0/7')
+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?* `entails → 0/7`.