open-standards/wai/wai-web/src/quantum_qdata.rs

//! Learning from quantum data in the browser (`wai.quantum.qdata`) — the
//! exponential sample-complexity separation for Pauli-channel learning. Simulate
//! both estimators and watch the two-copy Bell strategy resolve all `2^n`
//! fidelities with `n`-independent copies while the entanglement-free strategy is
//! starved. This is the advantage that survives dequantization, and why the
//! deployed `wai.quantum.cal.noise_learn` (Bell / Cycle-Benchmarking sampling) is
//! data-efficient.

use wai::quantum_qdata as qd;
use wasm_bindgen::prelude::*;

/// A fixed geometric budget grid (channel uses) shared by both strategies.
const GRID: [u64; 12] = [
    64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072,
];

#[wasm_bindgen]
pub struct QDataSeparation {
    n: u32,
    points: Vec<qd::SepPoint>,
}

#[wasm_bindgen]
impl QDataSeparation {
    /// Simulate the separation for an `n`-qubit demo channel over the copy grid.
    #[wasm_bindgen(constructor)]
    pub fn new(n: u32, seed: f64) -> QDataSeparation {
        let n = n.clamp(2, 10);
        let points = qd::separation_curve(n, seed as u64, &GRID);
        QDataSeparation { n, points }
    }

    /// `2^n` — the number of Pauli fidelities to learn (the conventional cost floor).
    pub fn dim(&self) -> f64 {
        (1u64 << self.n) as f64
    }

    /// The copy budgets (x-axis).
    pub fn copies(&self) -> Vec<f64> {
        self.points.iter().map(|p| p.copies as f64).collect()
    }
    /// Worst-case fidelity error of the two-copy **Bell** (quantum-memory) estimator.
    pub fn bell_err(&self) -> Vec<f64> {
        self.points.iter().map(|p| p.bell_err).collect()
    }
    /// Worst-case fidelity error of the **entanglement-free** (conventional) estimator.
    pub fn conv_err(&self) -> Vec<f64> {
        self.points.iter().map(|p| p.conventional_err).collect()
    }

    /// Smallest Bell copies to reach worst-case error `≤ eps` (0 = grid ceiling
    /// insufficient).
    pub fn bell_copies_for(&self, eps: f64, seed: f64) -> f64 {
        qd::copies_to_epsilon(self.n, seed as u64, eps, 8_000_000).0 as f64
    }
    /// Smallest conventional copies to reach `≤ eps`.
    pub fn conv_copies_for(&self, eps: f64, seed: f64) -> f64 {
        qd::copies_to_epsilon(self.n, seed as u64, eps, 8_000_000).1 as f64
    }
    /// The copies ratio `conventional / Bell ≈ 2^n` — the exponential price of no
    /// quantum memory.
    pub fn ratio_for(&self, eps: f64, seed: f64) -> f64 {
        let (b, c) = qd::copies_to_epsilon(self.n, seed as u64, eps, 8_000_000);
        if b == 0 {
            return 0.0;
        }
        c as f64 / b as f64
    }
}