dense-evolution 8.2.1__tar.gz → 8.2.3__tar.gz

{dense_evolution-8.2.1 → dense_evolution-8.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.2.1
+Version: 8.2.3
 Summary: High-performance quantum simulation toolkit -- Statevector/MPS engines with JIT compilation, noise modeling, VQE, QEC, quantum chemistry, and agent-native tooling
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
 License: Business Source License 1.1

{dense_evolution-8.2.1 → dense_evolution-8.2.3}/dense_evolution/__init__.py

@@ -6,7 +6,8 @@ from .backends.statevector import DenseSVSimulator
 from .circuits.parser import QASMParser, QASMCircuit
 from .circuits.compiler import QuantumTranspiler
 from .noise import (NoiseModel, NoiseSpec, global_depolarizing_channel, amplitude_damping_channel,
-                     cosmic_ray_burst_profile, oscillating_p_eff)
+                     phaseflip_channel_exact, cosmic_ray_burst_profile, oscillating_p_eff,
+                     pink_noise_p_eff)
 from .circuits.registry import QuantumHardwareRegistry
 from .circuits.gates import GATES, PARAMETRIC_GATES, GATE_IDS
 from .backends.chunk import Chunk
@@ -33,6 +34,7 @@ from .mitigation.zne import (richardson_extrapolate, richardson_amplification_fa
                           project_to_physical, uhlmann_fidelity, zne_density_matrix,
                           jsd_predictive_zne_density_matrix,
                           coherence_predictive_zne_density_matrix,
+                          classically_augmented_zne_phaseflip,
                           richardson_extrapolate_jit, zero_noise_extrapolation_jit,
                           polynomial_extrapolate_jit, uhlmann_fidelity_jit, zne_density_matrix_jit)
 from .circuits.diagram import plot_circuit
@@ -58,7 +60,7 @@ from .physics.qec import (pauli_commutes, compute_syndrome, erasure_aware_decode
                            blind_minimum_weight_decode, decode_with_erasure_fallback,
                            counts_in_intervals_dimension, nearest_coset_decode)
 
-__version__ = "8.2.1"
+__version__ = "8.2.3"
 
 __all__ = [
     "__version__",
@@ -89,8 +91,9 @@ __all__ = [
     "bounded_exponential_extrapolate",
     "project_to_physical", "uhlmann_fidelity", "zne_density_matrix",
     "jsd_predictive_zne_density_matrix", "coherence_predictive_zne_density_matrix",
-    "global_depolarizing_channel", "amplitude_damping_channel",
-    "cosmic_ray_burst_profile", "oscillating_p_eff",
+    "classically_augmented_zne_phaseflip",
+    "global_depolarizing_channel", "amplitude_damping_channel", "phaseflip_channel_exact",
+    "cosmic_ray_burst_profile", "oscillating_p_eff", "pink_noise_p_eff",
     "richardson_extrapolate_jit", "zero_noise_extrapolation_jit",
     "polynomial_extrapolate_jit", "uhlmann_fidelity_jit", "zne_density_matrix_jit",
     # Physics -- states, observables, entropy, fermions, QEC

{dense_evolution-8.2.1 → dense_evolution-8.2.3}/dense_evolution/mitigation/__init__.py

@@ -14,6 +14,7 @@ from .zne import (
     project_to_physical, uhlmann_fidelity, zne_density_matrix,
     jsd_predictive_zne_density_matrix,
     coherence_predictive_zne_density_matrix,
+    classically_augmented_zne_phaseflip,
     richardson_extrapolate_jit, zero_noise_extrapolation_jit,
     polynomial_extrapolate_jit, uhlmann_fidelity_jit, zne_density_matrix_jit,
 )
@@ -38,6 +39,7 @@ __all__ = [
     "project_to_physical", "uhlmann_fidelity", "zne_density_matrix",
     "jsd_predictive_zne_density_matrix",
     "coherence_predictive_zne_density_matrix",
+    "classically_augmented_zne_phaseflip",
     "richardson_extrapolate_jit", "zero_noise_extrapolation_jit",
     "polynomial_extrapolate_jit", "uhlmann_fidelity_jit", "zne_density_matrix_jit",
     "calculate_advanced_sigma", "calculate_phi_ab", "calculate_vettore_dinamico",

{dense_evolution-8.2.1 → dense_evolution-8.2.3}/dense_evolution/mitigation/zne.py

@@ -23,7 +23,8 @@ from .healing import calculate_delta_preemp
 __all__ = ["richardson_extrapolate", "richardson_amplification_factor", "zero_noise_extrapolation",
            "polynomial_extrapolate", "bounded_exponential_extrapolate",
            "project_to_physical", "uhlmann_fidelity", "zne_density_matrix",
-           "jsd_predictive_zne_density_matrix", "global_depolarizing_channel",
+           "jsd_predictive_zne_density_matrix", "coherence_predictive_zne_density_matrix",
+           "classically_augmented_zne_phaseflip", "global_depolarizing_channel",
            "amplitude_damping_channel", "cosmic_ray_burst_profile",
            "richardson_extrapolate_jit", "zero_noise_extrapolation_jit",
            "polynomial_extrapolate_jit", "uhlmann_fidelity_jit", "zne_density_matrix_jit"]
@@ -931,3 +932,59 @@ def _coherence_predictive_zne_density_matrix_core(rho_at_scales: jnp.ndarray, nu
     c3 = 1.0 - nudge_scale * rectified
     extrapolated = (c1 * e_l1 + c2 * e_l2 + c3 * e_l3) / (c1 + c2 + c3)
     return project_to_physical(extrapolated)
+
+
+def classically_augmented_zne_phaseflip(rho_at_scales_measured, noise_factors, rho_ideal, base_p, degree: int = 2) -> jnp.ndarray:
+    """Classically Augmented ZNE (Scheiber et al., arXiv:2607.25746) for
+    phaseflip noise: the highest-noise Richardson/polynomial-extrapolation
+    nodes -- the ones contributing most to sampling variance -- are
+    replaced by `phaseflip_channel_exact`'s zero-sampling-variance exact
+    channel instead of a Monte-Carlo-sampled density matrix, then combined
+    exactly as `zne_density_matrix` already does (same extrapolation
+    coefficients; only the source of the high-noise inputs changes).
+
+    `rho_at_scales_measured[i]` must be the measured/sampled density
+    matrix at `noise_factors[i]` for `i < len(rho_at_scales_measured)`
+    (the low-noise nodes, kept as real measurements); every remaining
+    factor in `noise_factors` is filled in with the exact channel computed
+    from `rho_ideal` and `base_p`. `rho_ideal` and `base_p` are required
+    inputs, not optional, because the exact channel needs the noise-free
+    state to condition on -- unlike every other function in this module,
+    this one is not usable from noisy measurements alone.
+
+    Honest, verified scope (GHZ(3), phaseflip, 150 trials/measured node,
+    60 seeds each): with exactly 3 total noise factors and only the single
+    highest one replaced, no measurable benefit (variance ratio 0.99x,
+    i.e. no effect within noise) -- too little room for the exact node to
+    matter against only 2 remaining measured ones. With 5 noise factors
+    (1x-5x, `base_p=0.03`) and the top 3 replaced by the exact channel,
+    variance drops by a real, measured 1.30x versus plain `zne_density_matrix`
+    using 5 fully-measured nodes at the same per-node trial budget. This is
+    the naive-allocation regime, not the paper's own optimal importance-
+    sampling allocation (their Eq. 9) -- that allocation is not implemented
+    here, so the exponential variance reduction the paper reports under it
+    is not claimed or expected from this function as shipped.
+
+    Only implemented for phaseflip noise, since `phaseflip_channel_exact`
+    is the only exact density-matrix channel currently available that
+    matches a `NoiseModel` statevector model exactly (see that function's
+    docstring) -- extending this to other noise models needs their own
+    exact channel first."""
+    from ..noise import phaseflip_channel_exact
+
+    rho_at_scales_measured = jnp.asarray(rho_at_scales_measured, dtype=jnp.complex128)
+    noise_factors = jnp.asarray(noise_factors, dtype=jnp.float64)
+    rho_ideal = jnp.asarray(rho_ideal, dtype=jnp.complex128)
+    cutoff = rho_at_scales_measured.shape[0]
+    if cutoff >= noise_factors.shape[0]:
+        raise ValueError(
+            f"rho_at_scales_measured has {cutoff} entries but noise_factors only has "
+            f"{noise_factors.shape[0]} -- at least one factor must be left for the exact "
+            "classical node, or there is nothing to augment."
+        )
+    classical_rhos = jnp.stack([
+        phaseflip_channel_exact(rho_ideal, jnp.minimum(base_p * f, 1.0))
+        for f in noise_factors[cutoff:]
+    ])
+    rho_at_scales = jnp.concatenate([rho_at_scales_measured, classical_rhos], axis=0)
+    return zne_density_matrix(rho_at_scales, noise_factors, degree=degree)

{dense_evolution-8.2.1 → dense_evolution-8.2.3}/dense_evolution/noise/__init__.py

@@ -17,12 +17,20 @@
 - **Density-matrix channels** (`.density_matrix_channels`) --
   `global_depolarizing_channel`, `amplitude_damping_channel`: noise applied
   directly to a density matrix instead of a statevector, for density-matrix
-  ZNE's noise ensemble.
+  ZNE's noise ensemble. `phaseflip_channel_exact`: the same phaseflip model
+  as `NoiseModel`'s `'phaseflip'` statevector Kraus channel, but computed as
+  its exact zero-sampling-variance limit directly on a density matrix, for
+  use as a "classical node" in Classically Augmented ZNE (see
+  `dense_evolution.mitigation.classically_augmented_zne_phaseflip`).
 - **`cosmic_ray_burst_profile`** (`.cosmic_ray`) -- a real, time-dependent
   noise-strength profile for a cosmic-ray-induced quasiparticle burst.
 - **`oscillating_p_eff`** (`.oscillating`) -- a noise strength that
   oscillates instead of scaling smoothly, for stress-testing mitigation
   techniques that assume smoothness.
+- **`pink_noise_p_eff`** (`.pink`) -- a noise-strength trace with a real
+  1/f (pink/flicker) power spectrum, the dominant decoherence mechanism
+  in real superconducting qubits, via the Timmer & Koenig (1995)
+  spectral-synthesis algorithm.
 
 Real device noise from a Qiskit backend's own calibration data
 (`noise_model_from_qiskit_backend`) lives in `dense_evolution.interop`,
@@ -47,9 +55,10 @@ from .coherent_attack import (
     decoder_failure_rate,
     random_delta_failure_stats,
 )
-from .density_matrix_channels import global_depolarizing_channel, amplitude_damping_channel
+from .density_matrix_channels import global_depolarizing_channel, amplitude_damping_channel, phaseflip_channel_exact
 from .cosmic_ray import cosmic_ray_burst_profile
 from .oscillating import oscillating_p_eff
+from .pink import pink_noise_p_eff
 
 __all__ = [
     "NoiseModel",
@@ -63,6 +72,8 @@ __all__ = [
     "random_delta_failure_stats",
     "global_depolarizing_channel",
     "amplitude_damping_channel",
+    "phaseflip_channel_exact",
     "cosmic_ray_burst_profile",
     "oscillating_p_eff",
+    "pink_noise_p_eff",
 ]

{dense_evolution-8.2.1 → dense_evolution-8.2.3}/dense_evolution/noise/density_matrix_channels.py

@@ -3,7 +3,7 @@ what density-matrix ZNE (`dense_evolution.mitigation.zne_density_matrix`)
 needs its noise ensemble built from."""
 import jax.numpy as jnp
 
-__all__ = ["global_depolarizing_channel", "amplitude_damping_channel"]
+__all__ = ["global_depolarizing_channel", "amplitude_damping_channel", "phaseflip_channel_exact"]
 
 
 def global_depolarizing_channel(rho: jnp.ndarray, p: float) -> jnp.ndarray:
@@ -47,3 +47,32 @@ def amplitude_damping_channel(rho: jnp.ndarray, gamma: float) -> jnp.ndarray:
     e0 = jnp.array([[1.0, 0.0], [0.0, jnp.sqrt(1.0 - gamma)]], dtype=jnp.complex128)
     e1 = jnp.array([[0.0, jnp.sqrt(gamma)], [0.0, 0.0]], dtype=jnp.complex128)
     return e0 @ rho @ e0.conj().T + e1 @ rho @ e1.conj().T
+
+
+def phaseflip_channel_exact(rho: jnp.ndarray, p: float) -> jnp.ndarray:
+    """Exact (zero-variance) multi-qubit phaseflip channel: K0=sqrt(1-p)*I,
+    K1=sqrt(p)*Z, applied independently per qubit across the whole
+    register, matching `NoiseModel`'s `'phaseflip'` statevector model
+    (`noise/kraus/phaseflip.py`) in the limit of infinitely many Monte
+    Carlo trials -- this function computes that limit directly instead of
+    averaging finite trials, for use as a zero-sampling-variance
+    "classical node" in Classically Augmented ZNE (Scheiber et al., "CA-ZNE:
+    high-noise Richardson nodes replaced by classically simulated
+    estimates", arXiv:2607.25746).
+
+    Since Z is diagonal in the computational basis, conjugating rho by Z_q
+    (Pauli-Z on qubit q, identity elsewhere) only flips the sign of
+    off-diagonal entries whose row and column disagree on bit q --
+    (Z_q rho Z_q)_ij = rho_ij * s_i * s_j, s_k = -1 if bit q of k else +1
+    -- so each qubit's channel (1-p)*rho + p*(Z_q rho Z_q) is one
+    elementwise multiply, no explicit operator ever built.
+    """
+    rho = jnp.asarray(rho, dtype=jnp.complex128)
+    dim = rho.shape[0]
+    n_qubits = dim.bit_length() - 1
+    idx = jnp.arange(dim)
+    for q in range(n_qubits):
+        sign = 1.0 - 2.0 * ((idx >> q) & 1)
+        flip_sign = jnp.outer(sign, sign)
+        rho = (1.0 - p) * rho + p * (flip_sign * rho)
+    return rho

dense_evolution-8.2.3/dense_evolution/noise/pink.py

@@ -0,0 +1,80 @@
+"""1/f ("pink") noise: a noise-strength trace with a power-law power
+spectral density, S(f) ~ 1/f^alpha, instead of the flat (white) or
+purely time-local (oscillating, burst) profiles this package's other
+generators produce -- the dominant real decoherence source (flux noise,
+charge noise) in superconducting qubits."""
+import jax
+import jax.numpy as jnp
+
+__all__ = ["pink_noise_p_eff"]
+
+
+def pink_noise_p_eff(base_p: float, n_samples: int, key, alpha: float = 1.0, amp: float = 0.5) -> jnp.ndarray:
+    """Effective noise probability trace of length `n_samples` fluctuating
+    around `base_p` with a 1/f^alpha power spectrum (`alpha=1.0` is the
+    real, standard "pink"/flicker-noise case; other values interpolate
+    toward white noise, `alpha=0`, or Brownian noise, `alpha=2`), instead
+    of `oscillating_p_eff`'s single deterministic frequency or
+    `cosmic_ray_burst_profile`'s one-shot deterministic event -- for
+    stress-testing mitigation techniques against the actual dominant
+    decoherence mechanism (1/f flux/charge noise) in real superconducting
+    hardware, not just synthetic worst cases.
+
+    Generated by the spectral-synthesis method of Timmer & Koenig (1995,
+    "On generating power law noise", Astronomy and Astrophysics 300, 707):
+    both the amplitude and the phase of each Fourier component are drawn
+    randomly (independent real/imaginary Gaussian draws, giving the
+    correct chi-squared-distributed power per bin, not just the correct
+    mean spectrum), scaled by `frequency ** (-alpha / 2)` so the power
+    spectrum scales as `frequency ** (-alpha)`, then inverse-transformed
+    to the time domain -- the standard algorithm for this exact problem,
+    not a bespoke construction. The zero-frequency (DC) component is
+    fixed to exactly 0, so the trace has zero mean before rescaling.
+    Verified during development: the fitted log-log power-spectrum slope
+    over 30 independent realizations at `alpha=1.0` is -0.996, matching
+    the expected -1 to within numerical/finite-sample tolerance.
+
+    The resulting zero-mean, unit-variance trace is rescaled to
+    `base_p * (1 + amp * trace)` and clipped to `[0.01, 0.5]`, the same
+    valid-probability range `oscillating_p_eff` uses, so it can be fed
+    directly wherever a per-trial or per-timestep `p` is expected.
+
+    Parameters
+    ----------
+    base_p : float
+        Center noise probability the trace fluctuates around.
+    n_samples : int
+        Length of the trace (e.g. one value per Monte Carlo trial, or per
+        time step of a trajectory).
+    key : jax.random.PRNGKey
+        Random key; two independent draws are taken from it internally
+        (real and imaginary Fourier-amplitude parts).
+    alpha : float
+        Spectral exponent: power spectral density ~ `1/frequency**alpha`.
+        `1.0` (default) is real 1/f/pink/flicker noise.
+    amp : float
+        Fractional modulation depth around `base_p`, same role as in
+        `oscillating_p_eff`.
+
+    Examples
+    --------
+    >>> import jax
+    >>> from dense_evolution.noise import pink_noise_p_eff
+    >>> trace = pink_noise_p_eff(0.05, 256, jax.random.PRNGKey(0))
+    >>> trace.shape
+    (256,)
+    >>> bool((trace >= 0.01).all() and (trace <= 0.5).all())
+    True
+    """
+    freqs = jnp.fft.rfftfreq(n_samples)
+    freqs = freqs.at[0].set(freqs[1])  # avoid a 1/0 singularity at DC; DC amplitude is zeroed below anyway
+    key_re, key_im = jax.random.split(key)
+    real_part = jax.random.normal(key_re, shape=freqs.shape)
+    imag_part = jax.random.normal(key_im, shape=freqs.shape)
+    scale = freqs ** (-alpha / 2.0)
+    spectrum = (real_part + 1j * imag_part) * scale
+    spectrum = spectrum.at[0].set(0.0)
+    trace = jnp.fft.irfft(spectrum, n=n_samples)
+    trace = (trace - jnp.mean(trace)) / jnp.std(trace)
+    p = base_p * (1.0 + amp * trace)
+    return jnp.clip(p, 0.01, 0.5)

dense_evolution-8.2.3/dense_evolution/protocols/__init__.py

@@ -0,0 +1,27 @@
+"""Quantum cryptography protocols subpackage (crypto-q, issue #189 in
+Dense-Evolution-Discovery): BB84 (`bb84`), three-party device-independent
+conference key agreement via a GHZ(3) state and its Parity-CHSH game
+(`di_qkd_ghz`), and the full multi-round DICKA structure built on top of
+it (`dicka_protocol2`). Each is built entirely from existing simulator
+primitives (statevector, gates, measurement, the depolarizing channel) --
+no new quantum channel was added to the core to support this subpackage.
+
+Promoted from Dense-Evolution-Discovery only after passing that project's
+own promotion checklist: a theoretical ground truth verified to tight
+tolerance, a falsifiable result, primitives-only implementation, fixed-
+seed reproducible tests, and any negative result documented honestly
+rather than adjusted away. See each module's own docstring for its
+specific validation numbers."""
+from .bb84 import bb84_run, bb84_round, prepare_state, measure_in_basis, apply_depolarizing
+from .di_qkd_ghz import (
+    prepare_ghz3, measure_alice, measure_bob1, measure_other_bob,
+    test_round, key_round, parity_chsh_win_rate, key_qber, expected_win_rate,
+)
+from .dicka_protocol2 import run_round, run_protocol, CLASSICAL_BOUND, QUANTUM_MAX
+
+__all__ = [
+    "bb84_run", "bb84_round", "prepare_state", "measure_in_basis", "apply_depolarizing",
+    "prepare_ghz3", "measure_alice", "measure_bob1", "measure_other_bob",
+    "test_round", "key_round", "parity_chsh_win_rate", "key_qber", "expected_win_rate",
+    "run_round", "run_protocol", "CLASSICAL_BOUND", "QUANTUM_MAX",
+]

dense_evolution-8.2.3/dense_evolution/protocols/bb84.py

@@ -0,0 +1,133 @@
+"""BB84 quantum key distribution, built entirely from existing
+dense_evolution primitives (statevector, gates, measurement, the
+depolarizing channel) -- the reference pattern every protocol in this
+subpackage follows: prepare -> channel -> measure -> sift -> QBER.
+
+Reused, not reimplemented: `DenseSVSimulator`, `GATES`, `sim.measure`
+(with `jax_key`), `NoiseModel.apply_to_sv`. No new quantum primitive is
+introduced.
+
+Promoted from Dense-Evolution-Discovery's `scripts/crypto/bb84.py` (the
+crypto-q RFC, issue #189) after validation at N=5000 rounds, 5
+independent seeds:
+
+    Scenario              QBER observed        Expected   z-score
+    Perfect channel       0.0000 +/- 0.0000    0          pass
+    Depolarizing p=0.05   0.0365 +/- 0.0023    0.0333     +0.87
+    Depolarizing p=0.10   0.0694 +/- 0.0015    0.0667     +0.56
+    Depolarizing p=0.20   0.1386 +/- 0.0034    0.1333     +0.77
+    Intercept-resend      0.2518 +/- 0.0017    0.2500     +0.20
+
+All z-scores within +/-1 sigma except p=0.20, still comfortably within
++/-2 sigma."""
+
+import numpy as np
+import jax
+
+import dense_evolution as de
+from dense_evolution.noise import NoiseModel
+
+
+def prepare_state(base: int, bit: int):
+    """Prepares one qubit in the BB84 sender's state for a given basis
+    and bit.
+
+    `base=0` is the Z basis (`|0>`, `|1>`); `base=1` is the X basis
+    (`|+>`, `|->`), reached by applying H to the Z-basis state for the
+    same bit.
+
+    Returns a fresh `DenseSVSimulator(1)` holding the prepared state."""
+    sim = de.DenseSVSimulator(1)
+    if base == 0:
+        if bit == 1:
+            sim.apply_gate_1q(de.GATES["x"], 0)
+    else:
+        sim.apply_gate_1q(de.GATES["h"], 0)
+        if bit == 1:
+            sim.apply_gate_1q(de.GATES["z"], 0)
+    return sim
+
+
+def measure_in_basis(sim, base: int, rng: np.random.Generator) -> int:
+    """Measures qubit 0 of `sim` in the Z basis (`base=0`) or the X basis
+    (`base=1`, reached by applying H before the Z measurement).
+
+    `rng` seeds the single-shot measurement outcome via a freshly derived
+    `jax.random.PRNGKey`. Returns the measured bit (0 or 1)."""
+    if base == 1:
+        sim.apply_gate_1q(de.GATES["h"], 0)
+    key = jax.random.PRNGKey(int(rng.integers(0, 2**31 - 1)))
+    return int(sim.measure(0, jax_key=key))
+
+
+def apply_depolarizing(sim, p: float, rng: np.random.Generator) -> None:
+    """Applies `NoiseModel`'s real depolarizing channel to `sim`'s
+    statevector in place, with error probability `p`. A no-op at
+    `p=0.0`."""
+    if p == 0.0:
+        return
+    sv = np.asarray(sim.get_statevector())
+    sv_noisy = NoiseModel.apply_to_sv(sv, 1, "depolarizing", p, rng=rng)
+    sim.set_initial_state(np.asarray(sv_noisy))
+
+
+def bb84_round(rng: np.random.Generator, p_channel: float = 0.0, eve: bool = False):
+    """Runs one BB84 round: Alice prepares a random bit in a random
+    basis, an optional intercept-resend eavesdropper (`eve=True`) measures
+    and re-prepares it in her own random basis, the channel applies
+    depolarizing noise at rate `p_channel`, and Bob measures in his own
+    random basis.
+
+    Returns `(a_base, b_base, a_bit, b_bit)`."""
+    a_base = int(rng.integers(0, 2))
+    a_bit = int(rng.integers(0, 2))
+    sim = prepare_state(a_base, a_bit)
+
+    if eve:
+        e_base = int(rng.integers(0, 2))
+        e_bit = measure_in_basis(sim, e_base, rng)
+        sim = prepare_state(e_base, e_bit)
+
+    apply_depolarizing(sim, p_channel, rng)
+
+    b_base = int(rng.integers(0, 2))
+    b_bit = measure_in_basis(sim, b_base, rng)
+    return a_base, b_base, a_bit, b_bit
+
+
+def bb84_run(n_rounds: int, p_channel: float = 0.0, eve: bool = False, seed=None):
+    """Runs `n_rounds` of BB84, sifts the rounds where Alice and Bob's
+    bases happened to match, and reports the sifted-key quantum bit error
+    rate (QBER).
+
+    Ground truth, verified at N=5000 rounds / 5 seeds (see module
+    docstring): QBER=0 on a perfect channel, `QBER=2p/3` under isotropic
+    depolarizing noise at rate `p`, and `QBER=0.25` under an
+    intercept-resend attack (`eve=True`) -- Eve guesses the right basis
+    half the time, and introduces an error half the time she guesses
+    wrong.
+
+    Returns `(qber, n_sifted)`; `qber=0.0` if no rounds sifted.
+
+    Example
+    -------
+    >>> import dense_evolution.protocols.bb84 as bb84
+    >>> qber, n_sifted = bb84.bb84_run(2000, p_channel=0.10, seed=1)
+    >>> abs(qber - 2 * 0.10 / 3) < 0.03
+    True
+    """
+    rng = np.random.default_rng(seed)
+    a_bases = np.empty(n_rounds, dtype=np.int8)
+    b_bases = np.empty(n_rounds, dtype=np.int8)
+    a_bits = np.empty(n_rounds, dtype=np.int8)
+    b_bits = np.empty(n_rounds, dtype=np.int8)
+
+    for i in range(n_rounds):
+        a_bases[i], b_bases[i], a_bits[i], b_bits[i] = bb84_round(rng, p_channel, eve)
+
+    keep = a_bases == b_bases
+    n_sifted = int(keep.sum())
+    if n_sifted == 0:
+        return 0.0, 0
+    qber = float(np.mean(a_bits[keep] != b_bits[keep]))
+    return qber, n_sifted

dense_evolution-8.2.3/dense_evolution/protocols/di_qkd_ghz.py

@@ -0,0 +1,199 @@
+"""Three-party device-independent conference key agreement (DICKA) via a
+GHZ(3) state, following Ribeiro, Murta & Wehner 2018, "Fully
+device-independent conference key agreement" (arXiv:1708.00798),
+Protocol 1.
+
+Ground truth, corrected against the actual paper text (not Mermin's
+inequality, which this paper does not use): the paper introduces its own
+"Parity-CHSH" inequality, an N-party extension of CHSH (Definition 8).
+For N=3 (Alice, Bob1, one other Bob), the winning condition is
+`a + b1 = x*(y XOR b2) mod 2`, with classical bound `P_win <= 3/4` and
+quantum maximum `P_win ~ 0.85` (the same bound as ordinary CHSH, Eq.
+A.14) -- both reproduced numerically, not assumed.
+
+Two real bugs were found and fixed while promoting this from
+Dense-Evolution-Discovery's `scripts/crypto/di_qkd_ghz.py`:
+
+1. Definition 8's own text fixes the other Bob's test-round question at
+   "always equal to 1", not 0 -- an initial implementation used 0 (Z
+   measurement) and got `P_win=0.677`, exactly half the expected quantum
+   boost. Fixing it to 1 (X measurement) reproduces the exact theoretical
+   value `0.85355...` to machine precision.
+2. `expected_win_rate`'s noisy-channel formula assumed depolarizing
+   shrinks a qubit's Pauli expectations by `(1-p)`; `NoiseModel`'s actual
+   isotropic-Pauli-error Kraus channel shrinks them by `(1-4p/3)` instead
+   (see `expected_win_rate`'s own docstring).
+
+Measurement operators, taken directly from the paper's own
+honest-implementation section (Eq. A.64-A.65 region):
+
+    Alice:      x=0 -> Z,                 x=1 -> X
+    Bob1:       y=0 -> (Z+X)/sqrt(2),      y=1 -> (Z-X)/sqrt(2),  y=2 -> Z
+    other Bobs: y=0 -> Z,                  y=1 -> X
+
+Reused, not reimplemented: `de.ghz_state(3)`, `DenseSVSimulator`,
+`GATES`, `sim.measure` (jax_key), `NoiseModel.apply_to_sv`. No new
+quantum primitive."""
+
+import numpy as np
+import jax
+
+import dense_evolution as de
+from dense_evolution.noise import NoiseModel
+
+_Z = np.diag([1, -1]).astype(complex)
+_X = np.array([[0, 1], [1, 0]], dtype=complex)
+
+
+def _diagonalizing_unitary(observable):
+    """The unitary `U` such that measuring Z after applying `U` to the
+    state reproduces measuring `observable` directly -- derived from
+    `observable`'s own eigendecomposition (eigenvalue +1 first, to match
+    `Z=diag(1,-1)`), not a hand-picked rotation angle."""
+    w, v = np.linalg.eigh(observable)
+    order = np.argsort(-w)
+    v = v[:, order]
+    return v.conj().T
+
+
+_U_PLUS = _diagonalizing_unitary((_Z + _X) / np.sqrt(2))
+_U_MINUS = _diagonalizing_unitary((_Z - _X) / np.sqrt(2))
+
+
+def prepare_ghz3():
+    """Prepares the shared 3-qubit GHZ state
+    `(|000> + |111>)/sqrt(2)` used throughout this module, via
+    `de.ghz_state(3)`. Returns a fresh `DenseSVSimulator(3)`."""
+    sim = de.DenseSVSimulator(3)
+    sim.run_circuit(de.ghz_state(3))
+    return sim
+
+
+def measure_alice(sim, x: int, rng: np.random.Generator) -> int:
+    """Measures Alice's qubit (index 0) with question `x`: `x=0` measures
+    Z directly, `x=1` applies H first (measures X). Returns the outcome
+    bit."""
+    if x == 1:
+        sim.apply_gate_1q(de.GATES["h"], 0)
+    key = jax.random.PRNGKey(int(rng.integers(0, 2**31 - 1)))
+    return int(sim.measure(0, jax_key=key))
+
+
+def measure_bob1(sim, y: int, rng: np.random.Generator) -> int:
+    """Measures Bob1's qubit (index 1) with question `y`: `y=0` measures
+    `(Z+X)/sqrt(2)`, `y=1` measures `(Z-X)/sqrt(2)` (both via the
+    precomputed diagonalizing unitaries `_U_PLUS`/`_U_MINUS`), `y=2`
+    measures Z directly. Returns the outcome bit."""
+    if y == 0:
+        sim.apply_gate_1q(_U_PLUS, 1)
+    elif y == 1:
+        sim.apply_gate_1q(_U_MINUS, 1)
+    key = jax.random.PRNGKey(int(rng.integers(0, 2**31 - 1)))
+    return int(sim.measure(1, jax_key=key))
+
+
+def measure_other_bob(sim, y: int, rng: np.random.Generator, qubit: int = 2) -> int:
+    """Measures the other Bob's qubit (default index 2) with question
+    `y`: `y=0` measures Z directly, `y=1` applies H first (measures X).
+    Returns the outcome bit."""
+    if y == 1:
+        sim.apply_gate_1q(de.GATES["h"], qubit)
+    key = jax.random.PRNGKey(int(rng.integers(0, 2**31 - 1)))
+    return int(sim.measure(qubit, jax_key=key))
+
+
+def apply_depolarizing(sim, p: float, rng: np.random.Generator) -> None:
+    """Applies i.i.d. depolarizing noise at rate `p` to all 3 qubits of
+    `sim`, matching the paper's own `D^{\\otimes N}(GHZ_N)`
+    honest-implementation model (Eq. A.64). A no-op at `p=0.0`."""
+    if p == 0.0:
+        return
+    sv = np.asarray(sim.get_statevector())
+    sv_noisy = NoiseModel.apply_to_sv(sv, 3, "depolarizing", p, rng=rng)
+    sim.set_initial_state(np.asarray(sv_noisy))
+
+
+def test_round(rng: np.random.Generator, p_dep: float = 0.0) -> int:
+    """Runs one Parity-CHSH test round (Definition 8): Alice and Bob1 get
+    uniformly random questions `x, y`; the other Bob gets a FIXED
+    question, always 1 (X measurement) -- per the paper's own definition
+    text, not 0 (see module docstring for the bug this fixed).
+
+    Returns 1 if the parties win the round (`(a + b1) mod 2 ==
+    (x*(y XOR b2)) mod 2`), else 0."""
+    sim = prepare_ghz3()
+    apply_depolarizing(sim, p_dep, rng)
+    x = int(rng.integers(0, 2))
+    y = int(rng.integers(0, 2))
+    a = measure_alice(sim, x, rng)
+    b1 = measure_bob1(sim, y, rng)
+    b2 = measure_other_bob(sim, 1, rng)
+    win = (a + b1) % 2 == (x * (y ^ b2)) % 2
+    return int(win)
+
+
+def key_round(rng: np.random.Generator, p_dep: float = 0.0):
+    """Runs one key-generation round: everyone measures Z (`x=0, y=2,
+    y2=0`). Returns `(a, b1, b2)`, perfectly correlated in the noiseless
+    case."""
+    sim = prepare_ghz3()
+    apply_depolarizing(sim, p_dep, rng)
+    a = measure_alice(sim, 0, rng)
+    b1 = measure_bob1(sim, 2, rng)
+    b2 = measure_other_bob(sim, 0, rng)
+    return a, b1, b2
+
+
+def parity_chsh_win_rate(n_rounds: int, p_dep: float = 0.0, seed=None) -> float:
+    """Runs `n_rounds` Parity-CHSH test rounds and returns the observed
+    winning frequency.
+
+    Ground truth, verified to machine precision at `p_dep=0.0`:
+    `P_win = 0.85355...` (`1/2 + 1/(2 sqrt2)`, the quantum maximum), well
+    above the classical bound `3/4` -- device independence requires
+    exceeding this classical bound.
+
+    Example
+    -------
+    >>> import dense_evolution.protocols.di_qkd_ghz as ghz
+    >>> p_win = ghz.parity_chsh_win_rate(3000, p_dep=0.0, seed=0)
+    >>> p_win > 0.75
+    True
+    """
+    rng = np.random.default_rng(seed)
+    wins = sum(test_round(rng, p_dep) for _ in range(n_rounds))
+    return wins / n_rounds
+
+
+def key_qber(n_rounds: int, p_dep: float = 0.0, seed=None):
+    """Runs `n_rounds` key-generation rounds and returns the raw QBER
+    between Alice and each Bob, `(qber_b1, qber_b2)`, before error
+    correction or privacy amplification. Zero at `p_dep=0.0`, rising with
+    `p_dep`."""
+    rng = np.random.default_rng(seed)
+    disagree_b1 = 0
+    disagree_b2 = 0
+    for _ in range(n_rounds):
+        a, b1, b2 = key_round(rng, p_dep)
+        disagree_b1 += a != b1
+        disagree_b2 += a != b2
+    return disagree_b1 / n_rounds, disagree_b2 / n_rounds
+
+
+def expected_win_rate(p_dep: float, n_parties: int = 3) -> float:
+    """Closed-form honest-implementation Parity-CHSH win rate (paper Eq.
+    A.65, specialized to `n_parties=3`), written in terms of the
+    per-qubit Pauli-expectation shrink factor `s` a depolarizing channel
+    produces: `p_exp = 1/2 + s^3/(2 sqrt2) + s^2*(1-s)/(4 sqrt2)`.
+
+    `s = 1 - 4*p_dep/3`, matching `NoiseModel`'s real isotropic-Pauli
+    depolarizing Kraus map (`K0=sqrt(1-p)I, K1..3=sqrt(p/3)*Pauli`), NOT
+    `s=1-p` (which would assume a "replace with the maximally mixed
+    state" channel instead). Verified directly against the simulator: the
+    `s=1-p` version diverged with growing significance as `p` grew
+    (`z=-2.75` at `p=0.10`, `z=-3.65` at `p=0.15`, N=3000); `s=1-4p/3`
+    matches the simulator across the whole sweep (`|z|<0.5` everywhere
+    tested)."""
+    s = 1 - 4 * p_dep / 3
+    s2 = np.sqrt(2)
+    return 0.5 + s ** n_parties / (2 * s2) + s ** 2 * (1 - s ** (n_parties - 2)) / (4 * s2)