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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.2.1
+Version: 8.2.2
 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.2}/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.2"
 
 __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.2}/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.2}/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.2}/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.2}/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.2/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.1 → dense_evolution-8.2.2}/dense_evolution.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.2.1
+Version: 8.2.2
 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.2}/dense_evolution.egg-info/SOURCES.txt

@@ -84,6 +84,7 @@ dense_evolution/noise/density_matrix_channels.py
 dense_evolution/noise/differentiable.py
 dense_evolution/noise/kraus_channels.py
 dense_evolution/noise/oscillating.py
+dense_evolution/noise/pink.py
 dense_evolution/noise/kraus/__init__.py
 dense_evolution/noise/kraus/amplitude_damping.py
 dense_evolution/noise/kraus/bitflip.py
@@ -119,13 +120,17 @@ tools/dashboard/core/_gate_tables.py
 tools/dashboard/core/band_structure.py
 tools/dashboard/core/circuit_builder_component.py
 tools/dashboard/core/circuit_diagram.py
+tools/dashboard/core/crypto_protocols.py
 tools/dashboard/core/engine.py
 tools/dashboard/core/graphical_builder.py
 tools/dashboard/core/hamiltonians.py
+tools/dashboard/core/mass_decomposition_tool.py
 tools/dashboard/core/mitigation.py
+tools/dashboard/core/native_hf_diagnostics.py
 tools/dashboard/core/noise_tools.py
 tools/dashboard/core/qasm_library.py
 tools/dashboard/core/qmmm.py
+tools/dashboard/core/rag_tool.py
 tools/dashboard/core/state_visuals.py
 tools/dashboard/core/system_limits.py
 tools/dashboard/core/vector_healing.py
@@ -145,8 +150,10 @@ tools/mcp_server/server.py
 tools/mcp_server/tools/__init__.py
 tools/mcp_server/tools/chemistry_tools.py
 tools/mcp_server/tools/circuit_tools.py
+tools/mcp_server/tools/crypto_tools.py
 tools/mcp_server/tools/mitigation_tools.py
 tools/mcp_server/tools/noise_tools.py
+tools/mcp_server/tools/retrieval_tools.py
 tools/mcp_server/tools/system_tools.py
 tools/mcp_server/tools/wormhole_tools.py
 tools/mcp_server/utils/__init__.py

{dense_evolution-8.2.1 → dense_evolution-8.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dense-evolution"
-version = "8.2.1"
+version = "8.2.2"
 description = "High-performance quantum simulation toolkit -- Statevector/MPS engines with JIT compilation, noise modeling, VQE, QEC, quantum chemistry, and agent-native tooling"
 readme = "README.md"
 requires-python = ">=3.9"

{dense_evolution-8.2.1 → dense_evolution-8.2.2}/research/local_site/app/server.py

@@ -606,6 +606,190 @@ def mitigate_matrix(req: MitigateMatrixRequest):
     }
 
 
+@app.post("/api/mitigate_coherence")
+def mitigate_coherence(req: MitigateMatrixRequest):
+    """Coherence-L1-predictive density-matrix ZNE
+    (dense_evolution.coherence_predictive_zne_density_matrix): same
+    Monte-Carlo construction as /api/mitigate_matrix, but extrapolated via
+    a signal that covers phase-type noise (phaseflip, dephasing) the
+    classical-JSD signal behind /api/mitigate_matrix is structurally blind
+    to (JSD only ever reads the density matrix's diagonal)."""
+    try:
+        result = dc.run_coherence_zne_mitigation(req.qasm, req.noise_model, req.noise_p, seed=req.seed)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {
+        "n_qubits": result.n_qubits,
+        "noise_factors": result.noise_factors,
+        "fidelity_raw": result.fidelity_raw,
+        "fidelity_corrected": result.fidelity_corrected,
+    }
+
+
+class Bb84Request(BaseModel):
+    n_rounds: int
+    p_channel: float = 0.0
+    eve: bool = False
+    seed: int | None = None
+
+
+@app.post("/api/crypto/bb84")
+def crypto_bb84(req: Bb84Request):
+    """BB84: prepare -> channel -> measure -> sift -> QBER
+    (dense_evolution.protocols.bb84)."""
+    try:
+        result = dc.run_bb84(req.n_rounds, req.p_channel, eve=req.eve, seed=req.seed)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {
+        "n_rounds": result.n_rounds, "p_channel": result.p_channel, "eve": result.eve,
+        "qber": result.qber, "sifted_key_length": result.sifted_key_length,
+    }
+
+
+class DiQkdGhzRequest(BaseModel):
+    n_rounds: int
+    p_dep: float = 0.0
+    seed: int | None = None
+
+
+@app.post("/api/crypto/di_qkd_ghz")
+def crypto_di_qkd_ghz(req: DiQkdGhzRequest):
+    """Three-party device-independent conference key agreement via GHZ(3)
+    (Ribeiro, Murta & Wehner 2018, arXiv:1708.00798;
+    dense_evolution.protocols.di_qkd_ghz)."""
+    try:
+        result = dc.run_di_qkd_ghz(req.n_rounds, req.p_dep, seed=req.seed)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {
+        "n_rounds": result.n_rounds, "p_dep": result.p_dep,
+        "win_rate": result.win_rate, "expected_win_rate": result.expected_win_rate,
+        "qber_b1": result.qber_b1, "qber_b2": result.qber_b2,
+    }
+
+
+class DickaRequest(BaseModel):
+    n_rounds: int
+    gamma: float
+    beta: float
+    p_dep: float = 0.0
+    seed: int | None = None
+
+
+@app.post("/api/crypto/dicka")
+def crypto_dicka(req: DickaRequest):
+    """Full multi-round DICKA structure (Appendix Protocol 2 of Ribeiro,
+    Murta & Wehner 2018; dense_evolution.protocols.dicka_protocol2). beta
+    must sit strictly between the classical bound (0.75) and the quantum
+    max (~0.8536) to meaningfully distinguish a device-independent
+    channel from a classically-bound one -- the underlying run_protocol
+    itself does not enforce this (any beta silently changes only the
+    abort decision), so it's checked here instead."""
+    from dense_evolution.protocols.dicka_protocol2 import CLASSICAL_BOUND, QUANTUM_MAX
+    if not (CLASSICAL_BOUND < req.beta < QUANTUM_MAX):
+        raise HTTPException(
+            status_code=400,
+            detail=f"beta must be strictly between {CLASSICAL_BOUND} and {QUANTUM_MAX}, got {req.beta}",
+        )
+    try:
+        return dc.run_dicka_protocol(req.n_rounds, req.gamma, req.beta, p_dep=req.p_dep, seed=req.seed)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+class NativeHfDiagnosticsRequest(BaseModel):
+    symbols: list
+    geometry: list
+    charge: int = 0
+    active_electrons: int | None = None
+    active_orbitals: int | None = None
+
+
+@app.post("/api/native_hf/diagnose")
+def native_hf_diagnose(req: NativeHfDiagnosticsRequest):
+    """Real Hartree-Fock SCF (dense_evolution.native_hf) plus Dense-Armor
+    anomaly diagnostics on the real per-iteration energy trace, instead of
+    trusting the final `converged` flag alone. Needs the `armor` extra."""
+    if len(req.symbols) != len(req.geometry):
+        raise HTTPException(
+            status_code=400,
+            detail=f"{len(req.symbols)} symbols but {len(req.geometry)} geometry rows",
+        )
+    try:
+        result = dc.run_native_hf_diagnostics(
+            req.symbols, req.geometry, charge=req.charge,
+            active_electrons=req.active_electrons, active_orbitals=req.active_orbitals,
+        )
+    except ImportError as exc:
+        raise HTTPException(status_code=400, detail=f"missing optional dependency: {exc}")
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {
+        "n_qubits": result.n_qubits, "converged": result.converged, "n_iterations": result.n_iterations,
+        "electronic_energy_hartree": result.electronic_energy_hartree, "total_energy_hartree": result.total_energy_hartree,
+        "n_anomalies_hampel": result.n_anomalies_hampel, "n_anomalies_tukey": result.n_anomalies_tukey,
+        "anomaly_fraction_hampel": result.anomaly_fraction_hampel, "anomaly_fraction_tukey": result.anomaly_fraction_tukey,
+    }
+
+
+class MassDecompositionRequest(BaseModel):
+    formula: str
+    target_mass: float
+    max_mass: float | None = None
+
+
+@app.post("/api/mass_decomposition")
+def mass_decomposition(req: MassDecompositionRequest):
+    """Check whether target_mass is a chemically valid, reachable
+    sub-formula mass of `formula` (dense_evolution.utils.mass_decomposition,
+    promoted from CASMI26 spectral-identification work)."""
+    try:
+        result = dc.run_mass_decomposition(req.formula, req.target_mass, max_mass=req.max_mass)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {
+        "formula_counts": result.formula_counts, "rdbe": result.rdbe,
+        "nearest_reachable_mass": result.nearest_reachable_mass,
+        "density_at_target": result.density_at_target,
+    }
+
+
+class RagSearchRequest(BaseModel):
+    documents: list  # [[text, source], ...]
+    query: str
+    top: int = 5
+    rerank: bool = True
+    exact: bool = False
+    regex: bool = False
+    max_hits: int = 10
+    context: int = 300
+
+
+@app.post("/api/rag_search")
+def rag_search(req: RagSearchRequest):
+    """Build an ephemeral index over the caller's own documents and search
+    it in one call (ia_utils.rag) -- nothing persists server-side between
+    requests. exact=True switches to substring/regex search over raw
+    chunk text instead of semantic search (no embedding, no reranker).
+    Needs the `rag` extra for semantic search; exact mode still needs it
+    to build the index (TF-IDF), but not to search once built."""
+    try:
+        documents = [(d[0], d[1]) for d in req.documents]
+    except (IndexError, TypeError):
+        raise HTTPException(status_code=400, detail="documents must be a list of [text, source] pairs")
+    try:
+        result = dc.run_rag_search(
+            documents, req.query, top=req.top, rerank=req.rerank,
+            exact=req.exact, regex=req.regex, max_hits=req.max_hits, context=req.context,
+        )
+    except ImportError as exc:
+        raise HTTPException(status_code=400, detail=f"missing optional dependency: {exc}")
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {"results": result.results}
+
+
 class CosmicRayBurstRequest(BaseModel):
     baseline_gamma: float
     times_us: Optional[List[float]] = None

{dense_evolution-8.2.1 → dense_evolution-8.2.2}/tools/dashboard/core/__init__.py

@@ -54,7 +54,14 @@ from .hamiltonians import (
 )
 from .mitigation import (
     MitigationResult, run_zne_mitigation, DensityMatrixZNEResult, run_density_matrix_zne,
+    CoherenceZNEResult, run_coherence_zne_mitigation,
 )
+from .crypto_protocols import (
+    Bb84Result, run_bb84, DiQkdGhzResult, run_di_qkd_ghz, run_dicka_protocol,
+)
+from .native_hf_diagnostics import NativeHfDiagnosticsResult, run_native_hf_diagnostics
+from .mass_decomposition_tool import MassDecompositionResult, run_mass_decomposition
+from .rag_tool import RagSearchResult, run_rag_search
 from .system_limits import max_safe_dense_qubits
 from .vqe import run_vqe, scan_hardware_efficient_energy_landscape
 from .qmmm import (
@@ -89,6 +96,11 @@ __all__ = [
     'linear_chain_geometry', 'ring_geometry', 'mix_hamiltonians',
     'MitigationResult', 'run_zne_mitigation',
     'DensityMatrixZNEResult', 'run_density_matrix_zne',
+    'CoherenceZNEResult', 'run_coherence_zne_mitigation',
+    'Bb84Result', 'run_bb84', 'DiQkdGhzResult', 'run_di_qkd_ghz', 'run_dicka_protocol',
+    'NativeHfDiagnosticsResult', 'run_native_hf_diagnostics',
+    'MassDecompositionResult', 'run_mass_decomposition',
+    'RagSearchResult', 'run_rag_search',
     'max_safe_dense_qubits',
     'run_vqe', 'scan_hardware_efficient_energy_landscape',
     'ATOMIC_MASSES_AMU',

dense_evolution-8.2.2/tools/dashboard/core/crypto_protocols.py

@@ -0,0 +1,77 @@
+"""
+Thin wrappers around dense_evolution.protocols (crypto-q, promoted from
+Dense-Evolution-Discovery issue #189) for the Composer kernel -- see
+docs/api/protocols.md for the real, validated numbers behind each
+protocol. Each function here just calls straight into the real protocol
+module and returns a plain dict; no new cryptographic logic lives here.
+"""
+from dataclasses import dataclass
+
+from dense_evolution.protocols import bb84 as _bb84
+from dense_evolution.protocols import di_qkd_ghz as _di_qkd_ghz
+from dense_evolution.protocols import dicka_protocol2 as _dicka
+
+__all__ = ['Bb84Result', 'run_bb84', 'DiQkdGhzResult', 'run_di_qkd_ghz', 'run_dicka_protocol']
+
+
+@dataclass
+class Bb84Result:
+    n_rounds: int
+    p_channel: float
+    eve: bool
+    qber: float
+    sifted_key_length: int
+
+
+def run_bb84(n_rounds: int, p_channel: float = 0.0, eve: bool = False, seed=None) -> Bb84Result:
+    """BB84: prepare -> channel -> measure -> sift -> QBER
+    (dense_evolution.protocols.bb84.bb84_run). QBER=0 on a perfect
+    channel, `2*p_channel/3` under isotropic depolarizing noise,
+    `0.25` under an intercept-resend attack (`eve=True`) -- see
+    docs/api/protocols.md for the validated numbers this reproduces."""
+    qber, sifted_key_length = _bb84.bb84_run(n_rounds, p_channel, eve=eve, seed=seed)
+    return Bb84Result(
+        n_rounds=n_rounds, p_channel=p_channel, eve=eve,
+        qber=float(qber), sifted_key_length=int(sifted_key_length),
+    )
+
+
+@dataclass
+class DiQkdGhzResult:
+    n_rounds: int
+    p_dep: float
+    win_rate: float
+    expected_win_rate: float
+    qber_b1: float
+    qber_b2: float
+
+
+def run_di_qkd_ghz(n_rounds: int, p_dep: float = 0.0, seed=None) -> DiQkdGhzResult:
+    """Three-party device-independent conference key agreement via GHZ(3)
+    (Ribeiro, Murta & Wehner 2018, arXiv:1708.00798;
+    dense_evolution.protocols.di_qkd_ghz). `win_rate` is the real,
+    simulated Parity-CHSH win rate over `n_rounds` test rounds;
+    `expected_win_rate` is the exact theoretical value at this `p_dep`
+    (quantum max `0.85355...` at `p_dep=0`) -- comparing the two directly
+    checks the simulation against the closed-form prediction, not just
+    against itself."""
+    win_rate = _di_qkd_ghz.parity_chsh_win_rate(n_rounds, p_dep, seed=seed)
+    qber_b1, qber_b2 = _di_qkd_ghz.key_qber(n_rounds, p_dep, seed=seed)
+    return DiQkdGhzResult(
+        n_rounds=n_rounds, p_dep=p_dep,
+        win_rate=float(win_rate), expected_win_rate=float(_di_qkd_ghz.expected_win_rate(p_dep)),
+        qber_b1=float(qber_b1), qber_b2=float(qber_b2),
+    )
+
+
+def run_dicka_protocol(n_rounds: int, gamma: float, beta: float, p_dep: float = 0.0, seed=None) -> dict:
+    """Full multi-round DICKA structure (Appendix Protocol 2 of Ribeiro,
+    Murta & Wehner 2018; dense_evolution.protocols.dicka_protocol2):
+    round selection, parameter estimation, and the abort decision.
+    Already returns a plain, JSON-safe dict -- see run_protocol's own
+    docstring for exactly what each field means. Deliberately does not
+    report a secure key length: Theorem 4's exact value depends on a
+    numerical optimization the source paper never reduces to closed form."""
+    result = _dicka.run_protocol(n_rounds=n_rounds, gamma=gamma, beta=beta, p_dep=p_dep, seed=seed)
+    result["aborted"] = bool(result["aborted"])
+    return result