zeropoint-node 1.0.4 → 1.0.5

package/src/quantum/error-correction.ts

@@ -9,14 +9,45 @@
  */
 
 import { floor, abs, max, min, round } from '../0/algebra.ts'
-import { type Register, zeroState, applyGate1, cnot, H, X, Z, probabilities, measureQubit } from './simulator.ts'
+import { type Register, zeroState, applyGate1, cnot, H, X, Z, probabilities, measureQubit, unitOf } from './simulator.ts'
 
 export interface StabilizerCode {
   readonly name: string
   readonly logicalQubits: number // Number of encoded logical qubits
   readonly physicalQubits: number // Number of physical qubits
   readonly distance: number // Minimum weight of logical operator
-  readonly generators: readonly (readonly number[])[] // Stabilizer generators
+  /**
+   * Stabiliser generators in SYMPLECTIC form: each row is 2n bits,
+   * [x_0..x_{n-1} | z_0..z_{n-1}].
+   *
+   * The previous n-bit form could not express a CSS code at all. An X-type and
+   * a Z-type generator over the same support are different operators but
+   * identical bit patterns, so the Steane code's six generators collapsed to
+   * three distinct rows — and the list that was there had seven rows, of which
+   * 13 of the 21 pairs anticommuted. A stabiliser group needs its generators to
+   * commute pairwise; that one was not a group.
+   *
+   * Two rows commute iff their symplectic product is even:
+   *   <g,h> = x_g . z_h + z_g . x_h  (mod 2)
+   */
+  readonly generators: readonly (readonly number[])[]
+  /** X-type supports, n bits each. */
+  readonly xGenerators: readonly (readonly number[])[]
+  /** Z-type supports, n bits each. */
+  readonly zGenerators: readonly (readonly number[])[]
+}
+
+/** Build a symplectic generator row from separate X and Z supports. */
+function symplectic(x: readonly number[], z: readonly number[]): number[] {
+  return [...x, ...z]
+}
+
+/** Symplectic product mod 2 — zero exactly when the two operators commute. */
+export function symplecticProduct(g: readonly number[], h: readonly number[]): 0 | 1 {
+  const n = g.length / 2
+  let acc = 0
+  for (let i = 0; i < n; i++) acc += g[i]! * h[n + i]! + g[n + i]! * h[i]!
+  return (acc % 2) as 0 | 1
 }
 
 export interface SyndromeResult {
@@ -42,28 +73,50 @@ export interface CorrelationValue {
 }
 
 // Simple 3-qubit repetition code: encode 1 logical qubit in 3 physical qubits
+const REPETITION_Z: number[][] = [
+  [1, 1, 0], // Z0 Z1
+  [0, 1, 1], // Z1 Z2
+]
+
 export const REPETITION_3_CODE: StabilizerCode = {
   name: 'Repetition [3,1,1]',
   logicalQubits: 1,
   physicalQubits: 3,
+  // Distance 1 as a QUANTUM code: it detects bit flips and is blind to phase
+  // flips, so a single Z is an undetectable logical error.
   distance: 1,
-  generators: [[1, 1, 0], [0, 1, 1]], // Z1 Z2, Z2 Z3
+  xGenerators: [],
+  zGenerators: REPETITION_Z,
+  generators: REPETITION_Z.map((z) => symplectic([0, 0, 0], z)),
 }
 
 // Steane code [7,1,3]: 7 physical qubits, 1 logical, distance 3
+/**
+ * The three parity checks of the classical [7,4,3] Hamming code. Steane's code
+ * is the CSS construction over them, so the SAME three supports appear once as
+ * X-type generators and once as Z-type — six in total, which is n - k = 7 - 1.
+ *
+ * Each pair overlaps in exactly two positions, so every X row commutes with
+ * every Z row.
+ */
+const HAMMING_CHECKS: number[][] = [
+  [0, 0, 0, 1, 1, 1, 1], // qubits 3,4,5,6
+  [0, 1, 1, 0, 0, 1, 1], // qubits 1,2,5,6
+  [1, 0, 1, 0, 1, 0, 1], // qubits 0,2,4,6
+]
+
+const ZERO7 = [0, 0, 0, 0, 0, 0, 0]
+
 export const STEANE_CODE: StabilizerCode = {
   name: 'Steane [7,1,3]',
   logicalQubits: 1,
   physicalQubits: 7,
   distance: 3,
+  xGenerators: HAMMING_CHECKS,
+  zGenerators: HAMMING_CHECKS,
   generators: [
-    [1, 1, 0, 1, 0, 0, 0], // Z stabilizers
-    [1, 0, 1, 0, 1, 0, 0],
-    [0, 1, 1, 0, 0, 1, 0],
-    [1, 1, 0, 0, 0, 0, 1],
-    [1, 0, 1, 0, 0, 1, 0],
-    [0, 1, 1, 0, 1, 0, 0],
-    [1, 0, 0, 1, 1, 0, 0],
+    ...HAMMING_CHECKS.map((x) => symplectic(x, ZERO7)),
+    ...HAMMING_CHECKS.map((z) => symplectic(ZERO7, z)),
   ],
 }
 
@@ -102,15 +155,15 @@ export function measureSyndromeRepetition(
 
   // Syndrome 0: Z1 Z2 (correlation between qubits 0 and 1)
   // In computational basis, this is even/odd parity of (q0, q1)
-  const m0 = measureQubit(reg, 0, s)
+  const m0 = measureQubit(reg, 0, unitOf(s))
   s = (1664525 * s + 1013904223) % 4294967296
-  const m1 = measureQubit(reg, 1, s)
+  const m1 = measureQubit(reg, 1, unitOf(s))
   s = (1664525 * s + 1013904223) % 4294967296
   const parity01 = (m0.bit + m1.bit) % 2
   syndrome.push(parity01 as 0 | 1)
 
   // Syndrome 1: Z2 Z3 (correlation between qubits 1 and 2)
-  const m2 = measureQubit(reg, 2, s)
+  const m2 = measureQubit(reg, 2, unitOf(s))
   const parity12 = (m1.bit + m2.bit) % 2
   syndrome.push(parity12 as 0 | 1)
 
@@ -136,11 +189,11 @@ export function correctRepetition(reg: Register, syndrome: SyndromeResult): Regi
 // Decode logical qubit (majority vote for repetition code)
 export function decodeLogicalRepetition(reg: Register, seed: number = 0): 0 | 1 {
   let s = seed
-  const m0 = measureQubit(reg, 0, s)
+  const m0 = measureQubit(reg, 0, unitOf(s))
   s = (1664525 * s + 1013904223) % 4294967296
-  const m1 = measureQubit(reg, 1, s)
+  const m1 = measureQubit(reg, 1, unitOf(s))
   s = (1664525 * s + 1013904223) % 4294967296
-  const m2 = measureQubit(reg, 2, s)
+  const m2 = measureQubit(reg, 2, unitOf(s))
 
   // Majority vote
   const vote = m0.bit + m1.bit + m2.bit

package/src/quantum/hybrid.ts

@@ -9,7 +9,7 @@
  */
 
 import { sqrt, abs, floor, log2, max, min, round } from '../0/algebra.ts'
-import { type Register, zeroState, applyGate1, ry, rz, cnot, measureQubit, probabilities } from './simulator.ts'
+import { type Register, zeroState, applyGate1, ry, rz, cnot, measureQubit, probabilities, unitOf } from './simulator.ts'
 import { type VQEResult, vqeAdaptive } from './variational-optimizer.ts'
 import { AdaptiveOptimizer } from './adaptive.ts'
 
@@ -72,7 +72,7 @@ export function ansatzRotationEntangle(
 
 // Classify via measurement: measure qubit 0, output 0/1
 export function classifyMeasurement(reg: Register, seed: number = 0): ClassificationResult {
-  const meas = measureQubit(reg, 0, seed)
+  const meas = measureQubit(reg, 0, unitOf(seed))
   const probs = probabilities(reg)
   const confidence = max(probs[0]!, probs[1]!)
   const circuitDepth = 0 // Placeholder; actual depth from circuit analysis

package/src/quantum/simulator.ts

@@ -182,6 +182,25 @@ export function measure(reg: Register, unit: number): { outcome: number; collaps
  * renormalised state. On an entangled state this is where the correlation
  * bites — measuring one qubit of a Bell pair fixes the other.
  */
+/**
+ * The modulus of the LCG these modules use for deterministic sampling.
+ */
+export const RNG_MODULUS = 4294967296
+
+/**
+ * Map an LCG state onto the unit interval `measureQubit` expects.
+ *
+ * `measureQubit` takes a UNIT in [0, 1), not a seed. Four call sites passed the
+ * raw LCG state instead, which is an integer up to 2^32. Since the outcome test
+ * is `unit < 1 - pOne`, any state of 1 or more forced the outcome to 1 — so
+ * `measureZ` on |0> returned 999 ones in 1000 shots, and repetition-code
+ * syndrome extraction reported a clean codeword as an error.
+ */
+export function unitOf(seed: number): number {
+  const m = seed % RNG_MODULUS
+  return (m < 0 ? m + RNG_MODULUS : m) / RNG_MODULUS
+}
+
 export function measureQubit(reg: Register, q: number, unit: number): { bit: 0 | 1; collapsed: Register } {
   const bit = 1 << q
   let pOne = 0

package/src/quantum/tomography.ts

@@ -5,7 +5,7 @@
  */
 
 import { sqrt, abs, floor, log2 } from '../0/algebra.ts'
-import { type Register, zeroState, applyGate1, H, S, cx, measureQubit, probabilities, cabs2 } from './simulator.ts'
+import { type Register, zeroState, applyGate1, H, S, cx, measureQubit, probabilities, cabs2, unitOf } from './simulator.ts'
 
 interface Complex {
   readonly re: number
@@ -44,7 +44,7 @@ export function measureZ(reg: Register, qubit: number, shots: number = 1000, see
   const counts = [0, 0]
   let s = seed
   for (let i = 0; i < shots; i++) {
-    const meas = measureQubit(reg, qubit, s)
+    const meas = measureQubit(reg, qubit, unitOf(s))
     counts[meas.bit]++
     s = (1664525 * s + 1013904223) % 4294967296
   }
@@ -58,7 +58,7 @@ export function measureX(reg: Register, qubit: number, shots: number = 1000, see
   const counts = [0, 0]
   let s = seed
   for (let i = 0; i < shots; i++) {
-    const meas = measureQubit(rotated, qubit, s)
+    const meas = measureQubit(rotated, qubit, unitOf(s))
     counts[meas.bit]++
     s = (1664525 * s + 1013904223) % 4294967296
   }
@@ -79,7 +79,7 @@ export function measureY(reg: Register, qubit: number, shots: number = 1000, see
   const counts = [0, 0]
   let s = seed
   for (let i = 0; i < shots; i++) {
-    const meas = measureQubit(s2, qubit, s)
+    const meas = measureQubit(s2, qubit, unitOf(s))
     counts[meas.bit]++
     s = (1664525 * s + 1013904223) % 4294967296
   }

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')