zeropoint-node 1.0.5 → 1.0.7

package/src/verification/lean-bridge.ts

@@ -30,6 +30,32 @@
  */
 
 import { createHash } from 'node:crypto'
+import { digitalRoot, throughVoid, bearingForDigit, VORTEX_SEQUENCE, VORTEX_ORBIT, VORTEX_AXIS } from '../0/index.ts'
+import { angleForDigit } from '../0/3/6/9/1/2/4/8/7/5/1/a432.math.ts'
+import { foldToLean, leanIsFixed } from '../kernel/import-graph.ts'
+import {
+  GIBBS_FORMATION,
+  GIBBS_SPLITTING,
+  ENTHALPY_FORMATION,
+  ENTHALPY_SPLITTING,
+  reversiblePotentialMicrovolts,
+  thermoneutralPotentialMicrovolts,
+  roundTrip,
+  selfTest as thermoSelfTest,
+  SCALE,
+  ELECTRONS,
+  FARADAY,
+  reversiblePotentialExact,
+  thermoneutralPotentialExact,
+  energyFromPotential,
+} from '../thermo/free-energy.ts'
+import {
+  balanceFor,
+  breakEvenCod,
+  TYPICAL_LOADS,
+  TREATMENT_DEMAND_DECIJOULES_PER_LITRE,
+  selfTest as wastewaterSelfTest,
+} from '../thermo/wastewater-energy.ts'
 import {
   zeroState,
   applyGate1,
@@ -43,6 +69,9 @@ import {
   STEANE_CODE,
   symplecticProduct,
   estimateSurfaceCodeThreshold,
+  executeInSuperposition,
+  computeInterferencePattern,
+  describeQuantumExecution,
 } from '../quantum/index.ts'
 import { ML_KEM_768 } from '../crypto/ml-kem.ts'
 import { sqrt } from '../0/algebra.ts'
@@ -390,6 +419,361 @@ export const SEALS: Record<string, Seal> = {
       ML_KEM_768.decapsulationKeyBytes === 2400 &&
       ML_KEM_768.ciphertextBytes === 1088,
   },
+  doubling_avoids_the_triad: {
+    basis: 'VORTEX_ORBIT and VORTEX_AXIS are pinned to computation, not trusted. gcd(2,9) = 1, so every power of 2 is a unit mod 9 and can never be a multiple of 3; 2 is a primitive root, so its orbit is all six units {1,2,4,5,7,8}; 2^6 = 64 = 1 mod 9 gives period 6, which makes six cases exhaustive rather than sampled. Reflection through the void carries {1,4,7} onto {9,6,3}, so the triad is reachable only by reflecting.',
+    decide: () => {
+      // Bound to the kernel's own constants, not retyped here. VORTEX_AXIS had
+      // no reader anywhere in the repository before this seal, so nothing
+      // checked it was the triad at all.
+      const TRIAD: readonly number[] = VORTEX_AXIS
+
+      // Period 6, from 2^6 = 64 = 1 (mod 9). Without this the six cases below
+      // would be a sample; with it they are the whole sequence.
+      if (digitalRoot(64) !== digitalRoot(1)) return false
+
+      // The orbit of 2, generated by doubling and folded each step.
+      const orbit: number[] = []
+      let d = 1
+      for (let i = 0; i < 6; i++) {
+        orbit.push(d)
+        if (TRIAD.includes(d)) return false // a power of two landed on 3, 6 or 9
+        d = digitalRoot(d * 2)
+      }
+      // Six distinct values, and doubling returns to the start: a full cycle.
+      if (new Set(orbit).size !== 6 || d !== 1) return false
+
+      // Those six are exactly the units mod 9 — the residues coprime to 9.
+      // Everything else mod 9 is a multiple of 3, which is the triad.
+      const units = [1, 2, 4, 5, 7, 8]
+      if (orbit.slice().sort((a, b) => a - b).join() !== units.join()) return false
+
+      // VORTEX_ORBIT must BE the computed orbit, in doubling order — the
+      // constant is pinned to the computation rather than trusted.
+      if (VORTEX_ORBIT.join() !== orbit.join()) return false
+
+      // And VORTEX_AXIS must be exactly what the orbit cannot reach: the
+      // complement of the orbit in 1..9, in ascending order.
+      const complement = [1, 2, 3, 4, 5, 6, 7, 8, 9].filter((n) => !orbit.includes(n))
+      if (TRIAD.join() !== complement.join()) return false
+
+      // VORTEX_SEQUENCE reads orbit then axis, so it is not an arbitrary order.
+      if (VORTEX_SEQUENCE.slice(0, orbit.length).join() !== orbit.join()) return false
+      if (VORTEX_SEQUENCE.slice(orbit.length).join() !== TRIAD.join()) return false
+
+      // Reflection is where the triad enters: 1 -> 9, 4 -> 6, 7 -> 3.
+      if (throughVoid(1) !== 9 || throughVoid(4) !== 6 || throughVoid(7) !== 3) return false
+
+      // And it is an involution, so the reading is reversible, not a relabel.
+      for (let n = 0; n <= 9; n++) if (throughVoid(throughVoid(n)) !== n) return false
+
+      // Reflecting the orbit reaches every member of the triad.
+      const reflected = orbit.map(throughVoid)
+      return TRIAD.every((t) => reflected.includes(t))
+    },
+  },
+  superposition_reports_its_own_state: {
+    basis: "the superposition model's prose must follow its measurement, not assert simultaneity regardless. Collapse is decided by one comparison — interference against the threshold — and the description must claim 'all at once' exactly when that comparison says so. While anything is still open the sequence has not computed all at once, and the text must say that.",
+    decide: () => {
+      const execution = executeInSuperposition()
+      const interference = computeInterferencePattern()
+      const text = describeQuantumExecution()
+
+      // The reported verdict must be the comparison, not a stored string.
+      const collapsedByNumbers = interference.working_solution_probability > 85 / 100
+      const collapsedByReport = execution.system_correctness === 'collapsed_to_valid'
+      if (collapsedByReport !== collapsedByNumbers) return false
+
+      // The prose takes exactly one of the two branches — never both, never
+      // neither, which is what an unconditional closing slogan would do.
+      const claimsCollapse = text.includes('COLLAPSED.')
+      const admitsOpen = text.includes('STILL SUPERPOSED')
+      if (claimsCollapse === admitsOpen) return false
+
+      // And the branch it takes is the one the measurement licenses.
+      if (claimsCollapse !== collapsedByNumbers) return false
+
+      // When open, it must publish the shortfall rather than only naming it.
+      if (admitsOpen && !text.includes('NOT ALL AT ONCE')) return false
+      return true
+    },
+  },
+  merkaba_is_two_mirrored_tetrahedra: {
+    basis: "the residues mod 3 cut 1..9 into three triangles, each equilateral on the enneagram (120 degrees apart). Reflection through the void SWAPS {1,4,7} with {3,6,9} and fixes {2,5,8} setwise, with the void root 0 fixed throughout. So {3,6,9,0} and {1,4,7,0} are two tetrahedra sharing exactly the void and carried onto each other by the mirror — a merkaba, of which one tetrahedron is half. From 3 the four vertices are 3 with its two triangle partners and the void.",
+    decide: () => {
+      const RING = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      const cls = (r: number) => RING.filter((d) => d % 3 === r)
+      const up = cls(1)     // 1,4,7
+      const equator = cls(2) // 2,5,8
+      const down = cls(0)   // 3,6,9
+      const key = (a: readonly number[]) => [...a].sort((x, y) => x - y).join(',')
+
+      // Three classes of three, partitioning the ring.
+      if (up.length !== 3 || equator.length !== 3 || down.length !== 3) return false
+      if (key([...up, ...equator, ...down]) !== key(RING)) return false
+
+      // Each is equilateral on the enneagram: three gaps of 120 degrees.
+      for (const t of [up, equator, down]) {
+        const b = t.map(bearingForDigit).sort((x, y) => x - y)
+        const gaps = [b[1]! - b[0]!, b[2]! - b[1]!, 360 - (b[2]! - b[0]!)]
+        if (!gaps.every((g) => g === 120)) return false
+      }
+
+      // The mirror swaps the two tetrahedral bases and fixes the equator.
+      if (key(up.map(throughVoid)) !== key(down)) return false
+      if (key(down.map(throughVoid)) !== key(up)) return false
+      if (key(equator.map(throughVoid)) !== key(equator)) return false
+
+      // The void is the shared apex, and it is the mirror's fixed point.
+      if (throughVoid(0) !== 0) return false
+      const tetraDown = [...down, 0]
+      const tetraUp = [...up, 0]
+      if (tetraDown.length !== 4 || tetraUp.length !== 4) return false
+      const shared = tetraDown.filter((v) => tetraUp.includes(v))
+      if (key(shared) !== '0') return false
+
+      // The gateway triangle is the axis the kernel already declares, so this
+      // is the same structure the vortex constants describe, not a new one.
+      if (key(down) !== key(VORTEX_AXIS)) return false
+
+      // From 3: itself, its two triangle partners, and the void. Four keys.
+      const fromThree = [3, ...down.filter((d) => d !== 3), 0]
+      return fromThree.length === 4 && key(fromThree) === key(tetraDown)
+    },
+  },
+  agl_acts_on_the_three_triangles: {
+    basis: "AGL(1,Z/9) has order 54 and acts on the three triangles — the cosets of {0,3,6} in Z/9, which are the residue classes the merkaba seal uses. The action is transitive with stabiliser 18 and kernel 9, and the induced permutation group is AGL(1,Z/3) of order 6. So the count three is the index of {0,3,6}, derived from the group rather than assumed: orbit x stabiliser = 3 x 18 = 54.",
+    decide: () => {
+      const units = [1, 2, 4, 5, 7, 8] // the residues coprime to 9
+      const maps: ((x: number) => number)[] = []
+      for (const a of units) for (let b = 0; b < 9; b++) maps.push((x) => ((a * x + b) % 9 + 9) % 9)
+      if (maps.length !== 54) return false
+
+      // The three cosets of {0,3,6}. Written as residues, so 9 appears as 0.
+      const T = [[1, 4, 7], [2, 5, 8], [3, 6, 0]]
+      const key = (xs: readonly number[]) => [...new Set(xs)].sort((x, y) => x - y).join(',')
+      if (key([...T[0]!, ...T[1]!, ...T[2]!]) !== '0,1,2,3,4,5,6,7,8') return false
+
+      // The gateway triangle must be the axis the kernel declares, reduced mod 9.
+      if (key(T[2]!) !== key(VORTEX_AXIS.map((d) => d % 9))) return false
+
+      const index = new Map(T.map((t, i) => [key(t), i]))
+      const induced = new Set<string>()
+      let fixesAll = 0
+      let stabilisesFirst = 0
+      for (const f of maps) {
+        const image = T.map((t) => index.get(key(t.map(f))))
+        // Closure: an affine map must send a coset to a coset.
+        if (image.some((v) => v === undefined)) return false
+        const word = image.join('')
+        induced.add(word)
+        if (word === '012') fixesAll++
+        if (image[0] === 0) stabilisesFirst++
+      }
+
+      // Induced group is AGL(1,Z/3); kernel and stabiliser follow from it.
+      if (induced.size !== 6) return false
+      if (fixesAll !== 9) return false
+      if (stabilisesFirst !== 18) return false
+      // Transitive on three, so orbit x stabiliser recovers the whole group.
+      return 3 * stabilisesFirst === maps.length
+    },
+  },
+  digit_geometry_is_single_valued: {
+    basis: "the two independent digit geometries agree and are injective. a432.math.ts angleForDigit and the kernel's bearingForDigit are written separately — the a432 tree does not import the kernel — so this checks they place all nine digits identically and never put two digits at one bearing. angleForDigit used to map nine digits onto six angles, colliding 3 with 5, 2 with 6 and 8 with 9.",
+    decide: () => {
+      const RING = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      // Injective: nine digits, nine distinct bearings, all whole degrees.
+      const kernel = RING.map(bearingForDigit)
+      if (new Set(kernel).size !== RING.length) return false
+      if (!kernel.every((b) => Number.isInteger(b) && b >= 0 && b < 360)) return false
+
+      // The two definitions must agree digit for digit.
+      if (!RING.every((d) => angleForDigit(d) === bearingForDigit(d))) return false
+
+      // Evenly spaced: consecutive bearings differ by one ninth of a turn.
+      const sorted = [...kernel].sort((a, b) => a - b)
+      for (let i = 1; i < sorted.length; i++) {
+        if (sorted[i]! - sorted[i - 1]! !== 40) return false
+      }
+
+      // 9 at the top is what fixes the ring's phase; without it any rotation
+      // would satisfy the spacing check above.
+      return bearingForDigit(9) === 270 && bearingForDigit(3) === 30
+    },
+  },
+  free_energy_of_splitting_is_positive: {
+    basis: "ΔG = ΔH − TΔS for water, from tabulated standard-state values. Formation is −237 kJ/mol and splitting is +237, so splitting must be paid for; the reversible cell potential ΔG/(nF) is 1229 mV and the thermoneutral ΔH/(nF) is 1481 mV, the gap being TΔS. A split-then-burn cycle breaks even at perfect efficiency and loses otherwise — checked exhaustively over the efficiency grid, not sampled. This is the sign of ΔG, not an engineering limit.",
+    decide: () => {
+      if (thermoSelfTest().length > 0) return false
+
+      // The sign is the claim. Formation releases work; splitting costs it.
+      if (!(GIBBS_FORMATION < 0)) return false
+      if (!(GIBBS_SPLITTING > 0)) return false
+
+      // One ledger, read in two directions — so what splitting costs is
+      // exactly what burning returns, before any device takes its cut.
+      if (ENTHALPY_SPLITTING !== -ENTHALPY_FORMATION) return false
+      if (GIBBS_SPLITTING !== -GIBBS_FORMATION) return false
+
+      // Free energy is strictly less than enthalpy: TΔS is real and is owed.
+      if (!(GIBBS_SPLITTING < ENTHALPY_SPLITTING)) return false
+      const rev = reversiblePotentialMicrovolts()
+      const thermo = thermoneutralPotentialMicrovolts()
+      if (!(thermo > rev)) return false
+
+      // The perfect cycle breaks even EXACTLY — the boundary case, and the one
+      // most favourable to a closed loop.
+      const ideal = roundTrip(100, 100, 100)
+      if (ideal.net !== 0) return false
+
+      // And no cycle anywhere on the grid gains. Exhaustive over 5% steps in
+      // all three efficiencies: 8000 combinations, none of them sampled.
+      //
+      // The verdict is recomputed from the two energies rather than read off
+      // `gainsEnergy`. Trusting that flag let a mutant hardcode it to false and
+      // still pass — a seal must not accept the answer from the thing it is
+      // judging. `net` is cross-checked against its own definition for the same
+      // reason.
+      let checked = 0
+      for (let e = 5; e <= 100; e += 5) {
+        for (let m = 5; m <= 100; m += 5) {
+          for (let g = 5; g <= 100; g += 5) {
+            checked++
+            const r = roundTrip(e, m, g)
+            if (r.net !== r.outputRecovered - r.inputRequired) return false
+            if (r.outputRecovered > r.inputRequired) return false
+            if (r.gainsEnergy !== r.net > 0) return false
+          }
+        }
+      }
+      return checked === 8000
+    },
+  },
+  polluted_water_powers_its_own_cleaning_above_a_threshold: {
+    basis: "the described machine works, and the fuel is the pollution rather than the water. Clean water carries zero recoverable energy, so it can only owe the treatment demand; organic load carries 13.9 J per mg COD, and above a threshold of about 4200 mg/L the electricity generated exceeds what membrane treatment consumes. Municipal sewage sits below that line and dairy or manure effluent well above it. The threshold is found by scanning, so it is the same quantity the balance reports.",
+    decide: () => {
+      if (wastewaterSelfTest().length > 0) return false
+
+      // The water itself is not the fuel. At zero load there is nothing to
+      // burn, and the plant owes exactly the cost of cleaning.
+      const clean = balanceFor(0)
+      if (clean.energyInLoad !== 0) return false
+      if (clean.electricityGenerated !== 0) return false
+      if (clean.netElectricity !== -TREATMENT_DEMAND_DECIJOULES_PER_LITRE) return false
+
+      // A threshold exists and is a genuine boundary: it exports, and one
+      // milligram less does not.
+      const t = breakEvenCod()
+      if (!(t > 0)) return false
+      if (!(balanceFor(t).netElectricity > 0)) return false
+      if (balanceFor(t - 1).netElectricity > 0) return false
+
+      // Monotone in the load — more pollution never yields less electricity.
+      let previous = -1
+      for (let cod = 0; cod <= 20000; cod += 100) {
+        const e = balanceFor(cod).electricityGenerated
+        if (e < previous) return false
+        previous = e
+      }
+
+      // Conservation still binds: recovery is strictly below the energy the
+      // load contains, because capture and engine efficiency are each < 100%.
+      for (const { cod } of TYPICAL_LOADS) {
+        if (cod === 0) continue
+        const b = balanceFor(cod)
+        if (b.electricityGenerated >= b.energyInLoad) return false
+      }
+
+      // And the model must still place real streams where they actually fall.
+      const strongSewage = TYPICAL_LOADS.find((l) => l.name === 'municipal sewage, strong')
+      const dairy = TYPICAL_LOADS.find((l) => l.name === 'dairy processing')
+      if (!strongSewage || !dairy) return false
+      if (balanceFor(strongSewage.cod).selfPowering) return false
+      return balanceFor(dairy.cod).selfPowering
+    },
+  },
+  every_model_inverts: {
+    basis: "each quantitative result recomputes a second, independent way and the two agree. Entropy recovered from (ΔH − ΔG)/T must equal the tabulated ΔS exactly; ΔG recovered from the EXACT rational potential must return with zero drift, while the rounded microvolt form is separately held to half a microvolt's worth of energy; and the break-even COD found by SCANNING must equal the one obtained by INVERTING the arithmetic, which is a different computation reaching the same integer. Reflection through the void inverts too, being its own inverse.",
+    decide: () => {
+      // --- free energy: invert ΔG = ΔH − TΔS to recover the entropy --------
+      // The forward pass multiplied T by ΔS; dividing it back out must land on
+      // the tabulated figure exactly, with no rounding introduced anywhere.
+      const T_CENTIKELVIN = 29815
+      const TABULATED_ENTROPY_MILLI = -163305
+      const recovered =
+        ((ENTHALPY_FORMATION - GIBBS_FORMATION) * 1000 * 100) / (T_CENTIKELVIN * SCALE)
+      if (recovered !== TABULATED_ENTROPY_MILLI) return false
+
+      // --- cell potential: invert E = ΔG/(nF) to recover ΔG ----------------
+      // Exactly, from the rational form. This used to be a bounded check
+      // because the microvolt rounding made an exact inverse impossible; the
+      // exact potentials exist so that the demand can be equality.
+      if (energyFromPotential(reversiblePotentialExact()) !== GIBBS_SPLITTING) return false
+      if (energyFromPotential(thermoneutralPotentialExact()) !== ENTHALPY_SPLITTING) return false
+
+      // The ROUNDED form still cannot invert exactly, and must not pretend to.
+      // Its drift is held to half a microvolt's worth of energy — nF/20 in
+      // these units, a derived bound rather than an eyeballed tolerance.
+      const microvolts = reversiblePotentialMicrovolts()
+      const backToGibbs = (microvolts * ELECTRONS * FARADAY) / 10
+      const drift = backToGibbs - GIBBS_SPLITTING
+      const magnitude = drift < 0 ? -drift : drift
+      if (!(2 * magnitude <= (ELECTRONS * FARADAY) / 10)) return false
+      if (!(magnitude * 1000000 < GIBBS_SPLITTING)) return false
+
+      // --- break-even COD: scanning versus inverting ------------------------
+      // balanceFor rounds twice on the way up, so a closed form agreeing with
+      // the scan is a real check on both, not a restatement of one.
+      const scanned = breakEvenCod()
+      const numerator = TREATMENT_DEMAND_DECIJOULES_PER_LITRE * 10000
+      const denominator = 139 * 65 * 38
+      const exact = numerator / denominator
+      const inverted = exact % 1 === 0 ? exact + 1 : exact - (exact % 1) + 1
+      if (scanned !== inverted) return false
+
+      // --- reflection is its own inverse ------------------------------------
+      for (let d = 0; d <= 9; d++) if (throughVoid(throughVoid(d)) !== d) return false
+
+      return true
+    },
+  },
+  lean_is_a_fixed_point: {
+    basis: "LEAN is defined as the fixed point of the reachability fold, not as a number anyone chose: fold(fold(S)) = fold(S). This checks the fold on graphs whose answers are known by hand — a chain, a cycle, a disconnected node, an entry outside the graph — and checks idempotence on each. Cycles must terminate rather than reaching the answer by luck, and an unreachable node must stay out however many times the fold is applied.",
+    decide: () => {
+      const key = (s: Set<string>) => [...s].sort().join(',')
+
+      // A chain, a 2-cycle, and an isolated node, all in one graph.
+      const g = new Map<string, readonly string[]>([
+        ['a', ['b']], ['b', ['c']], ['c', []],
+        ['x', ['y']], ['y', ['x']],
+        ['z', []],
+      ])
+
+      // Reachability, by hand.
+      if (key(foldToLean(g, ['a'])) !== 'a,b,c') return false
+      // A cycle must terminate and include both nodes exactly once.
+      if (key(foldToLean(g, ['x'])) !== 'x,y') return false
+      // An isolated node is reachable only from itself.
+      if (key(foldToLean(g, ['z'])) !== 'z') return false
+      // Nothing is reachable from nothing.
+      if (foldToLean(g, []).size !== 0) return false
+      // An entry that is not in the graph contributes nothing rather than throwing.
+      if (foldToLean(g, ['absent']).size !== 0) return false
+      // z is outside the fold from a, and stays outside however often we fold.
+      if (foldToLean(g, ['a']).has('z')) return false
+
+      // The definition must be well founded on every one of these.
+      for (const entries of [['a'], ['x'], ['z'], [], ['a', 'x'], ['absent']]) {
+        if (!leanIsFixed(g, entries)) return false
+      }
+
+      // And on a graph where an entry reaches everything, lean is everything.
+      const full = new Map<string, readonly string[]>([['r', ['a', 'x', 'z']], ['a', ['b']], ['b', []], ['x', ['x']], ['z', []]])
+      if (key(foldToLean(full, ['r'])) !== 'a,b,r,x,z') return false
+      return leanIsFixed(full, ['r'])
+    },
+  },
 }
 
 // ============================================================================

package/src/zero-entropy-demo.ts

@@ -9,6 +9,7 @@
  * 3. Pure mathematical relationships (no randomness or entropy)
  */
 
+import { pathToFileURL } from 'node:url'
 import { min, sqrt } from './0/algebra.ts'
 import { 
   ZERO_ENTROPY_CONSTANTS, 
@@ -297,7 +298,20 @@ export class ZeroEntropyDemo {
 }
 
 // Run demo if this file is executed directly
-if (typeof require !== 'undefined' && require.main === module) {
+/**
+ * True when this file is the entry point Node was started with.
+ *
+ * ESM has no `require.main`. The CommonJS idiom did not merely fail to detect
+ * direct execution here — `require` is undefined in an ES module, so the guard
+ * THREW on import and made the whole module unloadable. Nobody importing this
+ * ever got far enough to notice the guard was wrong.
+ */
+function isMainModule(): boolean {
+  const entry = process.argv[1]
+  return entry !== undefined && import.meta.url === pathToFileURL(entry).href
+}
+
+if (isMainModule()) {
   ZeroEntropyDemo.runCompleteDemo();
 }