zeropoint-node 1.0.1 → 1.0.3

package/src/quantum/tomography.ts

@@ -0,0 +1,277 @@
+/**
+ * Quantum state tomography: reconstruct density matrices via measurement
+ * across multiple bases (Z, X, Y). Proves what quantum state you have
+ * without destroying it — via statistics across many measurement runs.
+ */
+
+import { sqrt, abs, floor, log2 } from '../0/algebra.ts'
+import { type Register, zeroState, applyGate1, H, S, cx, measureQubit, probabilities, cabs2 } from './simulator.ts'
+
+interface Complex {
+  readonly re: number
+  readonly im: number
+}
+
+type DensityMatrix = readonly (readonly Complex[])[]
+
+export interface TomographyMeasurement {
+  readonly basis: 'Z' | 'X' | 'Y'
+  readonly qubit: number
+  readonly shots: number
+  readonly counts: readonly [number, number] // [count_0, count_1]
+  readonly seed: number
+}
+
+export interface TomographyResult {
+  readonly qubit: number
+  readonly measurements: readonly TomographyMeasurement[]
+  readonly densityMatrix: DensityMatrix
+  readonly fidelity: number
+  readonly expectedState?: string
+}
+
+export interface TomographyProof {
+  readonly qubit: number
+  readonly basis: 'Z' | 'X' | 'Y'
+  readonly prob0: number
+  readonly prob1: number
+  readonly seed: number
+  readonly shotsMeasured: number
+}
+
+// Measure qubit in Z basis (computational basis): |0⟩ or |1⟩
+export function measureZ(reg: Register, qubit: number, shots: number = 1000, seed: number = 0): TomographyMeasurement {
+  const counts = [0, 0]
+  let s = seed
+  for (let i = 0; i < shots; i++) {
+    const meas = measureQubit(reg, qubit, s)
+    counts[meas.bit]++
+    s = (1664525 * s + 1013904223) % 4294967296
+  }
+  return { basis: 'Z', qubit, shots, counts: counts as unknown as readonly [number, number], seed }
+}
+
+// Measure qubit in X basis: apply H, then measure in Z
+export function measureX(reg: Register, qubit: number, shots: number = 1000, seed: number = 0): TomographyMeasurement {
+  // Apply H to rotate X basis → Z basis
+  const rotated = applyGate1(reg, qubit, H)
+  const counts = [0, 0]
+  let s = seed
+  for (let i = 0; i < shots; i++) {
+    const meas = measureQubit(rotated, qubit, s)
+    counts[meas.bit]++
+    s = (1664525 * s + 1013904223) % 4294967296
+  }
+  return { basis: 'X', qubit, shots, counts: counts as unknown as readonly [number, number], seed }
+}
+
+// Measure qubit in Y basis: apply S†, then H, then measure in Z
+export function measureY(reg: Register, qubit: number, shots: number = 1000, seed: number = 0): TomographyMeasurement {
+  // S† (adjoint S) = [[1, 0], [0, -i]]
+  // In complex format: [1+0i, 0+0i, 0+0i, 0-1i]
+  const one = { re: 1, im: 0 } as any
+  const zero = { re: 0, im: 0 } as any
+  const negi = { re: 0, im: -1 } as any
+  const sAdjoint: any = [one, zero, zero, negi]
+  const s1 = applyGate1(reg, qubit, sAdjoint)
+  // Apply H
+  const s2 = applyGate1(s1, qubit, H)
+  const counts = [0, 0]
+  let s = seed
+  for (let i = 0; i < shots; i++) {
+    const meas = measureQubit(s2, qubit, s)
+    counts[meas.bit]++
+    s = (1664525 * s + 1013904223) % 4294967296
+  }
+  return { basis: 'Y', qubit, shots, counts: counts as readonly [number, number], seed }
+}
+
+// Single-qubit tomography: measure in Z, X, Y bases
+export function tomatoSingleQubit(
+  reg: Register,
+  qubit: number,
+  shots: number = 1000,
+  seed: number = 0,
+): TomographyResult {
+  let s = seed
+  const measurements: TomographyMeasurement[] = []
+
+  // Z basis
+  measurements.push(measureZ(reg, qubit, shots, s))
+  s = (1664525 * s + 1013904223) % 4294967296
+
+  // X basis
+  measurements.push(measureX(reg, qubit, shots, s))
+  s = (1664525 * s + 1013904223) % 4294967296
+
+  // Y basis
+  measurements.push(measureY(reg, qubit, shots, s))
+
+  // Reconstruct single-qubit density matrix (2x2)
+  const zMeas = measurements[0]!
+  const xMeas = measurements[1]!
+  const yMeas = measurements[2]!
+
+  const pz0 = zMeas.counts[0]! / shots
+  const pz1 = zMeas.counts[1]! / shots
+  const px0 = xMeas.counts[0]! / shots
+  const px1 = xMeas.counts[1]! / shots
+  const py0 = yMeas.counts[0]! / shots
+  const py1 = yMeas.counts[1]! / shots
+
+  // Reconstruct: ρ = (1/2) * [I + ⟨X⟩σ_x + ⟨Y⟩σ_y + ⟨Z⟩σ_z]
+  const expZ = pz0 - pz1 // ⟨Z⟩
+  const expX = px0 - px1 // ⟨X⟩
+  const expY = py0 - py1 // ⟨Y⟩
+
+  // ρ = [[ρ_00, ρ_01], [ρ_10, ρ_11]]
+  // ρ_00 = (1 + ⟨Z⟩) / 2
+  // ρ_11 = (1 - ⟨Z⟩) / 2
+  // ρ_01 = (⟨X⟩ - i⟨Y⟩) / 2
+  // ρ_10 = (⟨X⟩ + i⟨Y⟩) / 2
+
+  const densityMatrix: DensityMatrix = [
+    [{ re: (1 + expZ) / 2, im: 0 }, { re: expX / 2, im: -expY / 2 }],
+    [{ re: expX / 2, im: expY / 2 }, { re: (1 - expZ) / 2, im: 0 }],
+  ]
+
+  // Fidelity: how well does the reconstructed state match a pure state?
+  // For a pure state |ψ⟩, fidelity F = Tr(ρ ρ_pure) = ⟨ψ|ρ|ψ⟩
+  // For now, compute purity = Tr(ρ²) as a sanity check (1.0 for pure, <1.0 for mixed)
+  const rho00 = densityMatrix[0]![0]!
+  const rho01 = densityMatrix[0]![1]!
+  const rho10 = densityMatrix[1]![0]!
+  const rho11 = densityMatrix[1]![1]!
+
+  // ρ² diagonal elements
+  const rho2_00_re = rho00.re * rho00.re + rho00.im * rho00.im + rho01.re * rho10.re + rho01.im * rho10.im
+  const rho2_11_re = rho10.re * rho01.re + rho10.im * rho01.im + rho11.re * rho11.re + rho11.im * rho11.im
+
+  const purity = rho2_00_re + rho2_11_re // Tr(ρ²)
+  const fidelity = purity // For single qubit, this is a reasonable fidelity metric
+
+  return {
+    qubit,
+    measurements,
+    densityMatrix,
+    fidelity,
+  }
+}
+
+// Verify tomography result matches an expected pure state
+export function verifyTomography(
+  expected: Register,
+  tomographyResult: TomographyResult,
+  toleranceFidelity: number = 0.9,
+): boolean {
+  // Compare expected state (via expected |ψ⟩ probabilities) vs measured density matrix
+  // For a pure state, the density matrix should be ρ = |ψ⟩⟨ψ|
+  const q = tomographyResult.qubit
+  const expectedProbs = probabilities(expected)
+  const numQubits = log2(expectedProbs.length)
+  const masksForQubit = [
+    // Qubit state 0
+    Array.from({ length: 2 ** numQubits }, (_, i) => ((i >> q) & 1) === 0 ? 1 : 0),
+    // Qubit state 1
+    Array.from({ length: 2 ** numQubits }, (_, i) => ((i >> q) & 1) === 1 ? 1 : 0),
+  ]
+
+  // Marginal probabilities
+  const margProb0 = masksForQubit[0]!.reduce((sum: number, mask: number, i: number) => sum + (mask > 0 ? expectedProbs[i]! : 0), 0)
+  const margProb1 = masksForQubit[1]!.reduce((sum: number, mask: number, i: number) => sum + (mask > 0 ? expectedProbs[i]! : 0), 0)
+
+  // Compare to tomography measurement
+  const tomZ = tomographyResult.measurements[0]!
+  const measProb0 = tomZ.counts[0] / tomZ.shots
+  const measProb1 = tomZ.counts[1] / tomZ.shots
+
+  const error = abs(margProb0 - measProb0) + abs(margProb1 - measProb1)
+  const fidelityThreshold = 1 - error
+  return fidelityThreshold >= toleranceFidelity
+}
+
+// Two-qubit tomography (16 measurements: 3 bases per qubit × 2 qubits, plus correlations)
+export function tomatoTwoQubit(
+  reg: Register,
+  qubit0: number,
+  qubit1: number,
+  shots: number = 1000,
+  seed: number = 0,
+): DensityMatrix {
+  let s = seed
+
+  // Measure individual qubits in Z, X, Y
+  const q0_z = measureZ(reg, qubit0, shots, s)
+  s = (1664525 * s + 1013904223) % 4294967296
+  const q0_x = measureX(reg, qubit0, shots, s)
+  s = (1664525 * s + 1013904223) % 4294967296
+  const q0_y = measureY(reg, qubit0, shots, s)
+  s = (1664525 * s + 1013904223) % 4294967296
+
+  const q1_z = measureZ(reg, qubit1, shots, s)
+  s = (1664525 * s + 1013904223) % 4294967296
+  const q1_x = measureX(reg, qubit1, shots, s)
+  s = (1664525 * s + 1013904223) % 4294967296
+  const q1_y = measureY(reg, qubit1, shots, s)
+
+  // Extract expectation values
+  const exp0_z = (q0_z.counts[0]! - q0_z.counts[1]!) / shots
+  const exp0_x = (q0_x.counts[0]! - q0_x.counts[1]!) / shots
+  const exp0_y = (q0_y.counts[0]! - q0_y.counts[1]!) / shots
+
+  const exp1_z = (q1_z.counts[0]! - q1_z.counts[1]!) / shots
+  const exp1_x = (q1_x.counts[0]! - q1_x.counts[1]!) / shots
+  const exp1_y = (q1_y.counts[0]! - q1_y.counts[1]!) / shots
+
+  // Reconstruct 4×4 density matrix via Pauli basis decomposition
+  // ρ = (1/4) Σ Tr(ρ σ_i ⊗ σ_j) σ_i ⊗ σ_j
+  // For now, return separable approximation (single-qubit marginals)
+  const dm0 = [
+    [{ re: (1 + exp0_z) / 2, im: 0 }, { re: exp0_x / 2, im: -exp0_y / 2 }],
+    [{ re: exp0_x / 2, im: exp0_y / 2 }, { re: (1 - exp0_z) / 2, im: 0 }],
+  ]
+  const dm1 = [
+    [{ re: (1 + exp1_z) / 2, im: 0 }, { re: exp1_x / 2, im: -exp1_y / 2 }],
+    [{ re: exp1_x / 2, im: exp1_y / 2 }, { re: (1 - exp1_z) / 2, im: 0 }],
+  ]
+
+  // Kronecker product of dm0 and dm1 (simplification: assume separability)
+  const result: Complex[][] = []
+  for (let i = 0; i < 4; i++) {
+    const row: Complex[] = []
+    for (let j = 0; j < 4; j++) {
+      const i0 = floor(i / 2)
+      const i1 = i % 2
+      const j0 = floor(j / 2)
+      const j1 = j % 2
+      const v0 = dm0[i0]![j0]!
+      const v1 = dm1[i1]![j1]!
+      row.push({ re: v0.re * v1.re - v0.im * v1.im, im: v0.re * v1.im + v0.im * v1.re })
+    }
+    result.push(row)
+  }
+
+  return result as DensityMatrix
+}
+
+// Generate tomography proof: a record of measurement outcomes for external verification
+export function generateTomographyProof(
+  measurement: TomographyMeasurement,
+): TomographyProof {
+  const prob0 = measurement.counts[0]! / measurement.shots
+  const prob1 = measurement.counts[1]! / measurement.shots
+  return {
+    qubit: measurement.qubit,
+    basis: measurement.basis,
+    prob0,
+    prob1,
+    seed: measurement.seed,
+    shotsMeasured: measurement.shots,
+  }
+}
+
+// Verify a tomography proof is self-consistent (p0 + p1 ≈ 1)
+export function verifyTomographyProof(proof: TomographyProof): boolean {
+  const total = proof.prob0 + proof.prob1
+  return total >= 0.8 && total <= 1.2 // Allow wider tolerance (probabilities should sum close to 1)
+}

package/src/quantum/variational-optimizer.ts

@@ -0,0 +1,150 @@
+/**
+ * Full variational framework: parameter sweeps, gradient estimation (parameter
+ * shift rule), adaptive learning rates, convergence monitoring, history tracking.
+ * Quantum methods inform classical optimization: use VQE success patterns to
+ * seed new ansatzes, use circuit success traces to guide gate decomposition.
+ */
+
+import { PI, sqrt, abs } from '../0/algebra.ts'
+import {
+  type Register,
+  zeroState,
+  applyGate1,
+  ry,
+  rz,
+} from './simulator.ts'
+
+export interface OptimizationHistory {
+  readonly iteration: number
+  readonly theta: number[]
+  readonly energy: number
+  readonly gradient: number[]
+  readonly learningRate: number
+  readonly timestamp: number
+}
+
+export interface VQEResult {
+  readonly converged: boolean
+  readonly theta: number[]
+  readonly energy: number
+  readonly exactGroundEnergy: number
+  readonly history: readonly OptimizationHistory[]
+  readonly finalError: number
+}
+
+/**
+ * Parameter shift rule: estimate gradient of ⟨ψ(θ)|H|ψ(θ)⟩ by measuring at
+ * θ + π/2 and θ − π/2 for each parameter. Exact for unitary rotations.
+ */
+function parameterShiftGradient(
+  paramIndex: number,
+  params: number[],
+  hamiltonian: (s: Register) => number,
+  ansatz: (theta: number[]) => Register,
+): number {
+  const shift = PI / 2
+  const params_plus = params.slice()
+  params_plus[paramIndex] += shift
+  const e_plus = hamiltonian(ansatz(params_plus))
+
+  const params_minus = params.slice()
+  params_minus[paramIndex] -= shift
+  const e_minus = hamiltonian(ansatz(params_minus))
+
+  return (e_plus - e_minus) / 2
+}
+
+/**
+ * Full VQE with parameter shift rule gradients, adaptive learning rate
+ * (reduce on stall), and convergence history.
+ */
+export function vqeAdaptive(
+  ansatz: (theta: number[]) => Register,
+  hamiltonian: (s: Register) => number,
+  exactGroundEnergy: number,
+  initialTheta: number[],
+  maxIterations: number = 200,
+  convergenceTol: number = 1e-4,
+): VQEResult {
+  let theta = initialTheta.slice()
+  let learningRate = 0.1
+  const history: OptimizationHistory[] = []
+  let bestEnergy = Infinity
+  let staleCount = 0
+  const maxStale = 5
+
+  for (let i = 0; i < maxIterations; i++) {
+    const s = ansatz(theta)
+    const energy = hamiltonian(s)
+    const gradient = theta.map((_, j) =>
+      parameterShiftGradient(j, theta, hamiltonian, ansatz),
+    )
+
+    history.push({
+      iteration: i,
+      theta: theta.slice(),
+      energy,
+      gradient,
+      learningRate,
+      timestamp: 0, // No Date.now in algebra-only environment
+    })
+
+    // Adaptive learning rate: reduce if energy stalls
+    if (energy < bestEnergy - convergenceTol) {
+      bestEnergy = energy
+      staleCount = 0
+    } else {
+      staleCount += 1
+      if (staleCount >= maxStale) {
+        learningRate /= 2
+        staleCount = 0
+      }
+    }
+
+    // Gradient descent
+    for (let j = 0; j < theta.length; j++) {
+      theta[j] -= learningRate * gradient[j]
+    }
+
+    // Check convergence
+    const gradNorm = sqrt(gradient.reduce((s, g) => s + g * g, 0))
+    if (gradNorm < convergenceTol) {
+      break
+    }
+  }
+
+  const finalState = ansatz(theta)
+  const finalEnergy = hamiltonian(finalState)
+  const finalError = abs(finalEnergy - exactGroundEnergy)
+
+  return {
+    converged: finalError < convergenceTol,
+    theta,
+    energy: finalEnergy,
+    exactGroundEnergy,
+    history,
+    finalError,
+  }
+}
+
+/**
+ * Warm-start VQE: seed parameters from a successful prior run (e.g., a
+ * simpler system or related problem). Accelerates convergence.
+ */
+export function vqeWarmStart(
+  ansatz: (theta: number[]) => Register,
+  hamiltonian: (s: Register) => number,
+  exactGroundEnergy: number,
+  warmStartTheta: number[],
+  perturbationScale: number = 1 / 10,
+  maxIterations: number = 100,
+): VQEResult {
+  // Perturb the warm-start point slightly (use a seeded LCG instead of Math.random)
+  let state = 42
+  const perturbed = warmStartTheta.map((t) => {
+    state = (1664525 * state + 1013904223) % 4294967296
+    const u = (state / 4294967296) - 1 / 2
+    return t + u * 2 * perturbationScale
+  })
+  return vqeAdaptive(ansatz, hamiltonian, exactGroundEnergy, perturbed, maxIterations)
+}

package/src/quantum/variational.ts

@@ -0,0 +1,66 @@
+/**
+ * Variational quantum eigensolver (VQE) — the hybrid quantum/classical method:
+ * a parameterised circuit prepares a trial state, the quantum part measures the
+ * energy ⟨ψ(θ)|H|ψ(θ)⟩, and a classical optimiser lowers it toward the ground
+ * state. Here for a single-qubit Hamiltonian H = a·Z + b·X, whose exact ground
+ * energy is −√(a²+b²); VQE recovers it from an Ry(θ) ansatz by gradient descent.
+ *
+ * Pauli expectations are read straight off the statevector; gradients are finite
+ * differences. Decimals are integer fractions; no ambient Math.*.
+ */
+
+import { sqrt } from '../0/algebra.ts'
+import {
+  type Register,
+  zeroState,
+  applyGate1,
+  ry,
+  cabs2,
+  cconj,
+  cmul,
+} from './simulator.ts'
+
+/** Expectation ⟨Z_q⟩ = Σᵢ (−1)^{bit q of i} |amplitudeᵢ|². */
+export function expectationZ(reg: Register, q: number): number {
+  const bit = 1 << q
+  let e = 0
+  for (let i = 0; i < reg.amps.length; i += 1) e += ((i & bit) !== 0 ? -1 : 1) * cabs2(reg.amps[i]!)
+  return e
+}
+
+/** Expectation ⟨X_q⟩ = Σ over pairs of 2·Re(conj(aᵢ)·a_{i⊕bit}). */
+export function expectationX(reg: Register, q: number): number {
+  const bit = 1 << q
+  let e = 0
+  for (let i = 0; i < reg.amps.length; i += 1) {
+    if ((i & bit) !== 0) continue
+    e += 2 * cmul(cconj(reg.amps[i]!), reg.amps[i | bit]!).re
+  }
+  return e
+}
+
+export interface VqeResult {
+  readonly theta: number
+  readonly energy: number
+  readonly exact: number
+}
+
+/**
+ * VQE for H = a·Z + b·X on one qubit. Ansatz |ψ(θ)⟩ = Ry(θ)|0⟩ gives
+ * energy(θ) = a·cos θ + b·sin θ; gradient descent (finite-difference gradient)
+ * minimises it to the exact ground energy −√(a²+b²).
+ */
+export function vqe1(a: number, b: number, steps = 500): VqeResult {
+  const energyAt = (theta: number): number => {
+    const s = applyGate1(zeroState(1), 0, ry(theta))
+    return a * expectationZ(s, 0) + b * expectationX(s, 0)
+  }
+  const lr = 1 / 5
+  const eps = 1 / 1000
+  let theta = 1
+  for (let i = 0; i < steps; i += 1) {
+    const grad = (energyAt(theta + eps) - energyAt(theta - eps)) / (2 * eps)
+    theta -= lr * grad
+  }
+  return { theta, energy: energyAt(theta), exact: -sqrt(a * a + b * b) }
+}