zeropoint-node 1.0.4 → 1.0.6

package/src/thermo/wastewater-energy.ts

@@ -0,0 +1,204 @@
+/**
+ * Polluted water in, electricity and drinkable water out — the real version.
+ *
+ * The described machine exists. What makes it work is that the fuel is not the
+ * water: it is what is dissolved in it. H₂O carries no recoverable energy —
+ * `free-energy.ts` settles that, ΔG for splitting is +237 kJ/mol — but organic
+ * contamination does, and a litre of strong effluent can carry more chemical
+ * energy than it costs to clean the litre.
+ *
+ * So the architecture is:
+ *
+ *   polluted water → anaerobic digestion → biogas (mostly CH₄)
+ *                 → combustion engine (CHP) → ELECTRICITY
+ *   digester effluent → membrane treatment → DRINKABLE WATER
+ *
+ * The engine burns methane the bacteria made from the pollutants. Its exhaust
+ * is CO₂ and water vapour; the drinkable water comes from the membrane train,
+ * powered by part of the electricity. Everything you described happens, and
+ * nothing runs on the water itself.
+ *
+ * THE WHOLE QUESTION IS THE LOAD. Weak sewage does not carry enough energy to
+ * pay for its own treatment; strong industrial effluent carries several times
+ * over. There is therefore a THRESHOLD contamination, and this module computes
+ * it rather than asserting it. Below it the plant imports power; above it the
+ * plant exports.
+ *
+ * Distillation is deliberately not the water step. Evaporating a litre costs
+ * about 2.26 MJ in latent heat alone — far more than any realistic load carries
+ * — so a still cannot be paid for by the pollution. Membranes can.
+ *
+ * ARITHMETIC. Integers throughout, in decijoules per litre (dJ/L). No float
+ * literals; rounding happens once, where a value is rendered.
+ */
+
+// ============================================================================
+// CONSTANTS — measured quantities, not choices
+// ============================================================================
+
+/**
+ * Chemical energy per unit of COD (chemical oxygen demand): 13.9 J per mg.
+ * COD is the standard measure of oxidisable load, so this converts "how dirty"
+ * directly into "how much energy is in it". Held as tenths of a J/mg.
+ */
+const JOULES_PER_MG_COD_TENTHS = 139
+
+/**
+ * The same figure as J/mg, for prose that quotes it. Derived from the tenths
+ * above rather than written as 13.9 — a decimal literal here would be a second
+ * copy of the constant, and the ratchet counts those for exactly that reason.
+ */
+export const JOULES_PER_MG_COD = JOULES_PER_MG_COD_TENTHS / 10
+
+/**
+ * Fraction of COD that anaerobic digestion converts to methane, as a
+ * percentage. Well-run mesophilic digesters on soluble organics reach the
+ * mid-sixties; the rest becomes biomass or leaves undigested.
+ */
+const DIGESTION_CAPTURE_PERCENT = 65
+
+/**
+ * Electrical efficiency of a gas engine in CHP service, as a percentage.
+ * Reciprocating engines in the hundreds-of-kW class sit near this. Heat is
+ * recovered too, but heat is not what was asked for, so it is not counted.
+ */
+const ENGINE_ELECTRICAL_PERCENT = 38
+
+/**
+ * Electricity to bring digester effluent to drinking standard by membranes:
+ * ultrafiltration, reverse osmosis, then polishing. 4 kWh per m³ = 4 Wh/L =
+ * 14 400 J/L = 144 000 dJ/L. The conservative end of the RO range, because a
+ * dirty feed fouls membranes and costs more than a clean one.
+ */
+export const TREATMENT_DEMAND_DECIJOULES_PER_LITRE = 144000
+
+// ============================================================================
+// THE BALANCE
+// ============================================================================
+
+export interface WaterBalance {
+  /** Contamination as COD, mg/L — the input. */
+  readonly codMilligramsPerLitre: number
+  /** Chemical energy present in one litre, dJ/L. */
+  readonly energyInLoad: number
+  /** Electricity the engine actually delivers, dJ/L. */
+  readonly electricityGenerated: number
+  /** Electricity the membrane train consumes, dJ/L. */
+  readonly treatmentDemand: number
+  /** generated − demand. Positive means the plant exports power. */
+  readonly netElectricity: number
+  /** True when the water pays for its own cleaning and more. */
+  readonly selfPowering: boolean
+}
+
+/** Integer division rounded to nearest, ties away from zero, no Math.*. */
+function round(a: number, b: number): number {
+  const neg = a < 0
+  const x = neg ? -a : a
+  const q = (2 * x + b) / (2 * b)
+  const f = q - (q % 1)
+  return neg ? -f : f
+}
+
+/**
+ * Energy balance for one litre at a given contamination.
+ *
+ * `cod` is chemical oxygen demand in mg/L: roughly 300–800 for municipal
+ * sewage, 2 000–6 000 for dairy or brewery effluent, 20 000–80 000 for manure
+ * slurry or food-processing waste.
+ */
+export function balanceFor(cod: number): WaterBalance {
+  if (!Number.isInteger(cod) || cod < 0) {
+    throw new RangeError(`COD must be a non-negative integer in mg/L, got ${cod}`)
+  }
+
+  const energyInLoad = cod * JOULES_PER_MG_COD_TENTHS
+  const captured = round(energyInLoad * DIGESTION_CAPTURE_PERCENT, 100)
+  const electricityGenerated = round(captured * ENGINE_ELECTRICAL_PERCENT, 100)
+  const netElectricity = electricityGenerated - TREATMENT_DEMAND_DECIJOULES_PER_LITRE
+
+  return {
+    codMilligramsPerLitre: cod,
+    energyInLoad,
+    electricityGenerated,
+    treatmentDemand: TREATMENT_DEMAND_DECIJOULES_PER_LITRE,
+    netElectricity,
+    selfPowering: netElectricity > 0,
+  }
+}
+
+/**
+ * The lowest whole mg/L of COD at which the plant exports power.
+ *
+ * Found by scanning upward rather than by inverting the arithmetic, so the
+ * answer is the same quantity `balanceFor` reports and cannot drift from it.
+ */
+export function breakEvenCod(): number {
+  for (let cod = 0; cod <= 100000; cod++) {
+    if (balanceFor(cod).selfPowering) return cod
+  }
+  throw new Error('no break-even COD below 100 000 mg/L')
+}
+
+/** Typical loads, for locating a real stream against the threshold. */
+export const TYPICAL_LOADS: readonly { readonly name: string; readonly cod: number }[] = [
+  { name: 'municipal sewage, dilute', cod: 300 },
+  { name: 'municipal sewage, strong', cod: 800 },
+  { name: 'brewery effluent', cod: 3000 },
+  { name: 'dairy processing', cod: 5000 },
+  { name: 'manure slurry', cod: 40000 },
+]
+
+// ============================================================================
+// SELF-CHECK
+// ============================================================================
+
+/** Facts this module must satisfy. Returns failures. */
+export function selfTest(): string[] {
+  const fail: string[] = []
+
+  // Clean water carries nothing. This is the point: H2O is not the fuel.
+  const clean = balanceFor(0)
+  if (clean.energyInLoad !== 0) fail.push('clean water reports non-zero energy')
+  if (clean.electricityGenerated !== 0) fail.push('clean water generates electricity')
+  if (clean.selfPowering) fail.push('clean water reports as self-powering')
+  if (clean.netElectricity !== -TREATMENT_DEMAND_DECIJOULES_PER_LITRE) {
+    fail.push('clean water does not owe exactly the treatment demand')
+  }
+
+  // A threshold exists, is positive, and is unique — monotone in the load.
+  const t = breakEvenCod()
+  if (!(t > 0)) fail.push(`break-even COD is ${t}, expected positive`)
+  if (balanceFor(t).netElectricity <= 0) fail.push('break-even point does not export')
+  if (balanceFor(t - 1).netElectricity > 0) fail.push('a lower COD also exports — not a threshold')
+
+  // Monotone: more load never yields less electricity.
+  let previous = -1
+  for (let cod = 0; cod <= 20000; cod += 100) {
+    const e = balanceFor(cod).electricityGenerated
+    if (e < previous) { fail.push(`electricity fell between loads at COD ${cod}`); break }
+    previous = e
+  }
+
+  // Municipal sewage must sit below the threshold and strong effluent above,
+  // or the model has lost contact with the streams it claims to describe.
+  const municipal = TYPICAL_LOADS.find((l) => l.name === 'municipal sewage, strong')
+  const dairy = TYPICAL_LOADS.find((l) => l.name === 'dairy processing')
+  if (municipal && balanceFor(municipal.cod).selfPowering) {
+    fail.push('strong municipal sewage reports as self-powering')
+  }
+  if (dairy && !balanceFor(dairy.cod).selfPowering) {
+    fail.push('dairy effluent does not report as self-powering')
+  }
+
+  // No arrangement recovers more than the load contains: capture and engine
+  // efficiency are both below 100%, so electricity < energy present, always.
+  for (const { cod } of TYPICAL_LOADS) {
+    const b = balanceFor(cod)
+    if (cod > 0 && b.electricityGenerated >= b.energyInLoad) {
+      fail.push(`COD ${cod} yields electricity at or above the energy present`)
+    }
+  }
+
+  return fail
+}

package/src/verification/lean-bridge.test.ts

@@ -1,247 +1,128 @@
 /**
- * Lean Bridge Verification Tests
+ * Lean bridge — what is sealed, what is not, and why.
  *
- * Tests the integration of Lean formal proofs with quantum system
+ * This suite exists because the previous one asserted "Verified: 2/2" and
+ * "Confidence: 100.0%" against a predicate that could not return false. Every
+ * check here can fail.
+ *
+ * Two seals used to fail, and finding that was the point of writing them: the
+ * repetition seal caught raw LCG states being passed where `measureQubit`
+ * wants a unit in [0,1), and the Steane seal caught a generator list that was
+ * not a stabiliser group. Both defects are fixed, so both seals now hold, and
+ * this suite asserts that they hold - a regression would put them back.
  */
 
 import {
+  SEALS,
+  runSeal,
+  readLeanStatus,
+  computeProofHash,
+  verifyProofCertificate,
   generateGateCertificate,
   generateAlgorithmCertificate,
   generateECCertificate,
-  verifyProofCertificate,
-  verifyProofChain,
+  generateProofTranscript,
   verifyQuantumSystem,
   exportProofsForZenodo,
-  computeProofHash,
-  generateProofTranscript,
+  LEAN_PROOFS,
 } from './lean-bridge.ts'
 
-function testGateCertificates(): void {
-  console.log('Test: Gate proof certificates...')
-
-  const hadamard = generateGateCertificate('Hadamard')
-  const pauliX = generateGateCertificate('PauliX')
-
-  if (!verifyProofCertificate(hadamard)) {
-    throw new Error('Hadamard certificate invalid')
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  if (ok) console.log('  ok   ' + name)
+  else {
+    failures++
+    console.log('  FAIL ' + name + (detail ? ' - ' + detail : ''))
   }
-  if (!verifyProofCertificate(pauliX)) {
-    throw new Error('PauliX certificate invalid')
-  }
-
-  if (hadamard.theorem_name !== 'hadamard_unitary') {
-    throw new Error('Hadamard theorem name mismatch')
-  }
-  if (hadamard.property !== 'unitary') {
-    throw new Error('Hadamard property mismatch')
-  }
-
-  console.log(`  ✓ Hadamard certificate: ${hadamard.hash}`)
-  console.log(`  ✓ Hadamard theorem: ${hadamard.theorem_name}`)
-  console.log(`  ✓ PauliX certificate: ${pauliX.hash}`)
 }
 
-function testAlgorithmCertificates(): void {
-  console.log('Test: Algorithm proof certificates...')
-
-  const grover = generateAlgorithmCertificate('Grover')
-  const shor = generateAlgorithmCertificate('Shor')
-  const qft = generateAlgorithmCertificate('QFT')
-
-  if (!verifyProofCertificate(grover)) {
-    throw new Error('Grover certificate invalid')
-  }
-  if (!verifyProofCertificate(shor)) {
-    throw new Error('Shor certificate invalid')
-  }
-
-  if (grover.speedup_factor < 2) {
-    throw new Error(`Grover speedup too low: ${grover.speedup_factor}`)
-  }
-  if (shor.speedup_factor < 1000) {
-    throw new Error(`Shor speedup too low: ${shor.speedup_factor}`)
-  }
+console.log('Lean bridge: computational seals\n')
 
-  console.log(`  ✓ Grover speedup: ${grover.speedup_factor.toFixed(1)}x`)
-  console.log(`  ✓ Shor speedup: ${shor.speedup_factor.toFixed(0)}x`)
-  console.log(`  ✓ Grover complexity: ${grover.complexity_bound}`)
-  console.log(`  ✓ Shor complexity: ${shor.complexity_bound}`)
+// ------------------------------------------------------------ seal outcomes
+console.log('Seals (each decides a concrete instance)')
+const held: string[] = []
+const notHeld: string[] = []
+for (const name of Object.keys(SEALS)) {
+  const r = runSeal(name)
+  ;(r.seal === 'held' ? held : notHeld).push(name)
+  console.log('  ' + (r.seal === 'held' ? 'held  ' : 'FAILED') + ' ' + name)
 }
 
-function testECCertificates(): void {
-  console.log('Test: Error correction proof certificates...')
-
-  const repetition = generateECCertificate('Repetition[3,1,1]')
-  const steane = generateECCertificate('Steane[7,1,3]')
-  const surface = generateECCertificate('Surface')
-
-  if (!verifyProofCertificate(repetition)) {
-    throw new Error('Repetition certificate invalid')
-  }
-  if (!verifyProofCertificate(steane)) {
-    throw new Error('Steane certificate invalid')
-  }
-  if (!verifyProofCertificate(surface)) {
-    throw new Error('Surface certificate invalid')
-  }
-
-  if (repetition.threshold <= 0 || repetition.threshold >= 1) {
-    throw new Error(`Invalid repetition threshold: ${repetition.threshold}`)
-  }
-
-  console.log(`  ✓ Repetition [3,1,1]: threshold ${repetition.threshold}`)
-  console.log(`  ✓ Steane [7,1,3]: threshold ${steane.threshold}`)
-  console.log(`  ✓ Surface code: threshold ${surface.threshold}`)
-}
-
-function testProofChain(): void {
-  console.log('Test: Proof chain verification...')
-
-  const certs = [
-    generateGateCertificate('Hadamard'),
-    generateAlgorithmCertificate('Grover'),
-    generateECCertificate('Repetition[3,1,1]'),
-  ]
-
-  if (!verifyProofChain(certs)) {
-    throw new Error('Proof chain verification failed')
-  }
-
-  console.log(`  ✓ ${certs.length} certificates verified`)
-  console.log(`  ✓ Proof chain integrity: valid`)
+check('at least one seal holds', held.length > 0)
+check(
+  'seals that hold are the expected set',
+  held.length === Object.keys(SEALS).length - notHeld.length
+)
+
+// --------------------------------------------- the two formerly-broken seals
+console.log('\nSeals that used to fail, and what they caught')
+check(
+  'repetition_detects_error holds - syndrome extraction distinguishes clean from flipped',
+  runSeal('repetition_detects_error').seal === 'held',
+  'regressed: measureQubit is being handed a raw LCG state again'
+)
+check(
+  'steane_corrects_error holds - STEANE_CODE is a genuine stabiliser group',
+  runSeal('steane_corrects_error').seal === 'held',
+  'regressed: generator count, commutation or independence broke'
+)
+check('every seal holds', notHeld.length === 0, notHeld.join(', ') + ' failed')
+
+// ------------------------------------------------------------ falsifiability
+console.log('\nThe verifier can say no')
+const fake = { ...generateGateCertificate('Hadamard'), seal: 'failed' as const }
+check('a failed seal is not verified', verifyProofCertificate(fake) === false)
+check('a held seal is verified', verifyProofCertificate(generateGateCertificate('Hadamard')) === true)
+
+// --------------------------------------------------------------- lean status
+console.log('\nLean status is read from the script, not declared')
+check("a script containing sorry reads as 'sorry'", readLeanStatus('theorem t : X := by\n  sorry') === 'sorry')
+check("an axiom reads as 'axiom'", readLeanStatus('axiom a : P') === 'axiom')
+check("an empty script reads as 'absent'", readLeanStatus('   ') === 'absent')
+check("a complete script reads as 'script'", readLeanStatus('theorem t : X := by decide') === 'script')
+const sorryCount = Object.values(LEAN_PROOFS).filter((s) => readLeanStatus(s) === 'sorry').length
+check('the sorry scripts are reported, not hidden', sorryCount > 0, sorryCount + ' found')
+console.log('       ' + sorryCount + ' of ' + Object.keys(LEAN_PROOFS).length + ' Lean scripts end in sorry')
+
+// ---------------------------------------------------------------- hashing
+console.log('\nHash covers content, not the name')
+const h1 = computeProofHash('IsUnitary hadamard', 'theorem a := by decide')
+const h2 = computeProofHash('IsUnitary hadamard', 'theorem a := by sorry')
+const h3 = computeProofHash('IsUnitary pauliX', 'theorem a := by decide')
+check('changing the proof script changes the hash', h1 !== h2)
+check('changing the statement changes the hash', h1 !== h3)
+check('the same content hashes the same', h1 === computeProofHash('IsUnitary hadamard', 'theorem a := by decide'))
+
+// --------------------------------------------------------------- reporting
+console.log('\nReporting does not overstate')
+const report = verifyQuantumSystem()
+check('lean_machine_checked is false', report.lean_machine_checked === false)
+check('every theorem in the report is sealed', report.sealed_fraction === 1, String(report.sealed_fraction))
+check('nothing is left unsealed', report.unsealed.length === 0, report.unsealed.join(', '))
+console.log('       sealed ' + report.total_theorems + '/' + report.total_theorems)
+
+const zenodo = exportProofsForZenodo() as { ready_for_publication: boolean; caveats: string[] }
+// Still false, and correctly so: seals are computed instances, not Lean proofs.
+check('not marked ready for publication (no Lean toolchain runs here)', zenodo.ready_for_publication === false)
+check('caveats are attached', zenodo.caveats.length >= 3)
+
+const transcript = generateProofTranscript([
+  generateGateCertificate('Hadamard'),
+  generateAlgorithmCertificate('Shor'),
+  generateECCertificate('Steane[7,1,3]'),
+])
+check('transcript confidence counts held seals', transcript.confidence === 1, String(transcript.confidence))
+check('transcript lists no unsealed theorem', transcript.unsealed.length === 0)
+// The confidence number must still be able to move, or it is decoration.
+const withFailure = generateProofTranscript([
+  generateGateCertificate('Hadamard'),
+  { ...generateGateCertificate('PauliX'), seal: 'failed' as const },
+])
+check('a failed seal drags confidence down', withFailure.confidence === 1 / 2, String(withFailure.confidence))
+
+console.log('')
+if (failures > 0) {
+  console.error('lean-bridge: ' + failures + ' check(s) failed')
+  process.exit(1)
 }
-
-function testProofHash(): void {
-  console.log('Test: Proof hash computation...')
-
-  const hash1 = computeProofHash('hadamard_unitary')
-  const hash2 = computeProofHash('hadamard_unitary')
-  const hash3 = computeProofHash('pauliX_unitary')
-
-  if (hash1 !== hash2) {
-    throw new Error('Hash not deterministic')
-  }
-  if (hash1 === hash3) {
-    throw new Error('Different theorems have same hash')
-  }
-  if (hash1.length !== 16) {
-    throw new Error(`Hash wrong length: ${hash1.length}`)
-  }
-
-  console.log(`  ✓ Hash deterministic: ${hash1}`)
-  console.log(`  ✓ Hash collision-free`)
-}
-
-function testQuantumSystemVerification(): void {
-  console.log('Test: Complete quantum system verification...')
-
-  const report = verifyQuantumSystem()
-
-  if (report.total_theorems === 0) {
-    throw new Error('No theorems verified')
-  }
-  if (report.overall_confidence < 0.8) {
-    throw new Error(`Confidence too low: ${report.overall_confidence}`)
-  }
-  if (report.gates_verified.length === 0) {
-    throw new Error('No gates verified')
-  }
-  if (report.algorithms_verified.length === 0) {
-    throw new Error('No algorithms verified')
-  }
-  if (report.error_correction_verified.length === 0) {
-    throw new Error('No error correction verified')
-  }
-
-  console.log(`  ✓ ${report.total_theorems} theorems formalized`)
-  console.log(`  ✓ ${report.total_lines_of_proof} proof lines`)
-  console.log(`  ✓ Gates: ${report.gates_verified.join(', ')}`)
-  console.log(`  ✓ Algorithms: ${report.algorithms_verified.join(', ')}`)
-  console.log(`  ✓ Error correction: ${report.error_correction_verified.join(', ')}`)
-  console.log(`  ✓ Overall confidence: ${(report.overall_confidence * 100).toFixed(1)}%`)
-}
-
-function testProofTranscript(): void {
-  console.log('Test: Proof transcript generation...')
-
-  const certs = [
-    generateGateCertificate('Hadamard'),
-    generateAlgorithmCertificate('Grover'),
-  ]
-
-  const transcript = generateProofTranscript(certs)
-
-  if (!transcript.title) {
-    throw new Error('Transcript missing title')
-  }
-  if (transcript.theorems.length === 0) {
-    throw new Error('Transcript missing theorems')
-  }
-  if (transcript.verified_count === 0) {
-    throw new Error('Transcript has no verified theorems')
-  }
-  if (transcript.confidence < 0.5) {
-    throw new Error(`Transcript confidence too low: ${transcript.confidence}`)
-  }
-
-  console.log(`  ✓ Title: ${transcript.title}`)
-  console.log(`  ✓ Theorems: ${transcript.theorems.join(', ')}`)
-  console.log(`  ✓ Total proof lines: ${transcript.total_lines}`)
-  console.log(`  ✓ Verified: ${transcript.verified_count}/${certs.length}`)
-  console.log(`  ✓ Confidence: ${(transcript.confidence * 100).toFixed(1)}%`)
-}
-
-function testZenodoExport(): void {
-  console.log('Test: Zenodo publication export...')
-
-  const export_data = exportProofsForZenodo()
-
-  if (!export_data.system) {
-    throw new Error('Export missing system name')
-  }
-  if (!export_data.verification_framework) {
-    throw new Error('Export missing verification framework')
-  }
-  if (!export_data.formal_verification_report) {
-    throw new Error('Export missing verification report')
-  }
-  if (!export_data.ready_for_publication) {
-    throw new Error('Export not marked ready for publication')
-  }
-
-  const report = export_data.formal_verification_report as any
-  if (report.overall_confidence < 0.8) {
-    throw new Error('System confidence below publication threshold')
-  }
-
-  console.log(`  ✓ System: ${export_data.system}`)
-  console.log(`  ✓ Framework: ${export_data.verification_framework}`)
-  console.log(`  ✓ Confidence: ${(report.overall_confidence * 100).toFixed(1)}%`)
-  console.log(`  ✓ Ready for Zenodo: ${export_data.ready_for_publication}`)
-}
-
-// ============================================================================
-// TEST RUNNER
-// ============================================================================
-
-async function runTests(): Promise<void> {
-  console.log('🧪 Lean Bridge Verification Tests\n')
-
-  try {
-    testGateCertificates()
-    testAlgorithmCertificates()
-    testECCertificates()
-    testProofChain()
-    testProofHash()
-    testQuantumSystemVerification()
-    testProofTranscript()
-    testZenodoExport()
-
-    console.log('\n✅ All Lean bridge verification tests passed!')
-  } catch (error) {
-    console.error(`\n❌ Test failed: ${error instanceof Error ? error.message : String(error)}`)
-    process.exit(1)
-  }
-}
-
-runTests()
+console.log('lean-bridge ok - all seals hold, Lean scripts still not machine-checked')