dense-evolution 8.3.0__py3-none-win_amd64.whl

dashboard_core/mitigation.py

@@ -0,0 +1,343 @@
+"""
+Real Zero-Noise Extrapolation (ZNE) error mitigation, wired to the same
+engine and real noise channels (dense_evolution.NoiseModel) the rest of
+the Composer uses. Noise is scaled by running the real channel at
+noise_p, 2*noise_p, 3*noise_p and Richardson-extrapolating the measured
+Pauli expectation back to zero noise via dense_evolution's own
+zero_noise_extrapolation -- not a fabricated mitigated curve.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+import numpy as np
+
+import dense_evolution as de
+
+__all__ = [
+    'MitigationResult', 'run_zne_mitigation', 'DensityMatrixZNEResult', 'run_density_matrix_zne',
+    'CoherenceZNEResult', 'run_coherence_zne_mitigation',
+]
+
+_DEFAULT_NOISE_FACTORS = (1.0, 2.0, 3.0)
+# polynomial_extrapolate's own docstring: with exactly degree+1 points the
+# fit is the unique interpolating polynomial, IDENTICAL to
+# richardson_extrapolate -- the extra 2 points here (4x, 5x) are what
+# actually changes anything, trading a bit of interpolation bias for
+# averaging down statistical noise across more measured scales (verified
+# in that docstring against a real 5-seed sweep, not asserted here).
+_POLYNOMIAL_NOISE_FACTORS = (1.0, 2.0, 3.0, 4.0, 5.0)
+_POLYNOMIAL_DEGREE = 2
+
+
+@dataclass
+class MitigationResult:
+    n_qubits: int
+    pauli_string: str
+    ideal_expectation: float
+    noise_factors: list
+    noisy_expectations: list
+    zne_extrapolated: float
+    extrapolation_method: str = "richardson"
+    noisy_sems: list = None
+
+
+def run_zne_mitigation(
+    qasm_text: str,
+    pauli_string: str,
+    noise_model: str,
+    noise_p: float,
+    seed: Optional[int] = None,
+    noise_factors=None,
+    n_trials: int = 200,
+    extrapolation_method: str = "richardson",
+) -> MitigationResult:
+    """Real ZNE: <P> is measured at the real ideal state and at the real
+    channel applied at noise_p * each factor, then extrapolated to zero
+    noise -- either Richardson (dense_evolution.zero_noise_extrapolation,
+    the exact interpolating polynomial through 3 points, the default) or
+    a degree-2 least-squares polynomial fit through 5 points
+    (dense_evolution.polynomial_extrapolate) -- caller's choice, not
+    silently picked: noise_factors defaults to the 3- or 5-point set that
+    matches whichever method was requested, unless the caller overrides
+    it explicitly.
+
+    NoiseModel.apply_to_sv is a *stochastic single-shot* Kraus draw (one
+    random outcome per call, not the channel's averaged/ensemble
+    behavior) -- feeding a single draw straight into ZNE gives a
+    discontinuous, meaningless curve (verified: bitflip/depolarizing
+    jumped 1.0 -> 0.0 -> 0.0 across noise scales instead of decaying
+    smoothly). <P> under a Kraus channel is Tr(rho P) = mean over the
+    channel's trajectories, so each scale here averages n_trials
+    independent stochastic draws -- the actual expectation value ZNE is
+    defined against, not one random sample of it.
+
+    pauli_string uses dense_evolution's own qubit-0-is-position-0
+    convention (same as pauli_expectation), independent of Qiskit's
+    little-endian display convention used elsewhere on this page --
+    this function never touches a Qiskit-ordered array.
+
+    Examples
+    --------
+    >>> from dashboard_core.mitigation import run_zne_mitigation
+    >>> qasm = '''
+    ... OPENQASM 2.0;
+    ... include "qelib1.inc";
+    ... qreg q[1];
+    ... creg c[1];
+    ... x q[0];
+    ... measure q -> c;
+    ... '''
+    >>> result = run_zne_mitigation(qasm, pauli_string='Z', noise_model='bitflip',
+    ...                              noise_p=0.05, seed=0, n_trials=200)
+    >>> result.ideal_expectation
+    -1.0
+    >>> abs(result.zne_extrapolated - result.ideal_expectation) < abs(result.noisy_expectations[0] - result.ideal_expectation)
+    True
+    """
+    if extrapolation_method not in ("richardson", "polynomial"):
+        raise ValueError(
+            f"unknown extrapolation_method {extrapolation_method!r}, must be 'richardson' or 'polynomial'"
+        )
+    if noise_factors is None:
+        noise_factors = (
+            _POLYNOMIAL_NOISE_FACTORS if extrapolation_method == "polynomial" else _DEFAULT_NOISE_FACTORS
+        )
+
+    # Parsed with dense_evolution's own QASMParser, never Qiskit's --
+    # QuantumCircuit.from_qasm_str itself segfaults on macOS (see
+    # dashboard_core/engine.py's module docstring for the full story);
+    # this function never needs a Qiskit circuit object at all, only the
+    # ideal statevector, so there's no reason to build one here.
+    parsed = de.QASMParser().parse(qasm_text)
+    n_qubits = parsed.n_qubits
+    if len(pauli_string) != n_qubits:
+        raise ValueError(f"pauli_string length {len(pauli_string)} != n_qubits {n_qubits}")
+    if noise_model not in de.NoiseModel.MODELS:
+        raise ValueError(f"unknown noise model {noise_model!r}, must be one of {de.NoiseModel.MODELS}")
+
+    # Same real anti-OOM guard as dashboard_core.engine.run_circuit_from_qasm
+    # -- this kernel now runs on whatever machine a Composer visitor has,
+    # not just a dev laptop, and this function was the one real gap that
+    # never checked before allocating (engine.py's own functions always did).
+    required_mb = (2 ** n_qubits) * 16 / 1e6
+    de.chunk.SafeMemoryGuard().check_allocation(required_mb, context=f"{n_qubits}-qubit statevector")
+
+    sim = de.DenseSVSimulator(n_qubits, use_float32=False)
+    sim.run_circuit(parsed.to_tuples())
+    sv_ideal = np.asarray(sim.sv)
+    ideal_expectation = float(np.real(de.pauli_expectation(sv_ideal, pauli_string)))
+
+    rng = np.random.default_rng(seed)
+    noisy_expectations = []
+    noisy_sems = []
+    for factor in noise_factors:
+        scaled_p = min(noise_p * factor, 1.0)
+        trial_values = np.empty(n_trials)
+        for i in range(n_trials):
+            sv_noisy = de.NoiseModel.apply_to_sv(
+                sv_ideal.copy(), n_qubits, noise_model, scaled_p, rng=rng,
+            )
+            trial_values[i] = np.real(de.pauli_expectation(sv_noisy, pauli_string))
+        noisy_expectations.append(float(trial_values.mean()))
+        # Standard error of the mean (sample std / sqrt(n_trials)), not
+        # the per-trial spread itself -- this is the real Monte Carlo
+        # uncertainty on the plotted mean, from the n_trials draws
+        # already computed above, not a separate/approximate estimate.
+        noisy_sems.append(float(trial_values.std(ddof=1) / np.sqrt(n_trials)))
+
+    if extrapolation_method == "polynomial":
+        zne_value = float(de.polynomial_extrapolate(noisy_expectations, list(noise_factors), degree=_POLYNOMIAL_DEGREE))
+    else:
+        zne_value = float(de.zero_noise_extrapolation(noisy_expectations, list(noise_factors)))
+
+    return MitigationResult(
+        n_qubits=n_qubits,
+        pauli_string=pauli_string,
+        ideal_expectation=ideal_expectation,
+        noise_factors=list(noise_factors),
+        noisy_expectations=noisy_expectations,
+        zne_extrapolated=zne_value,
+        extrapolation_method=extrapolation_method,
+        noisy_sems=noisy_sems,
+    )
+
+
+@dataclass
+class DensityMatrixZNEResult:
+    n_qubits: int
+    noise_factors: list
+    fidelity_raw: float          # Uhlmann fidelity: ideal vs raw noisy (base scale) rho
+    fidelity_corrected: float    # Uhlmann fidelity: ideal vs ZNE-corrected rho
+
+
+def run_density_matrix_zne(
+    qasm_text: str,
+    noise_model: str,
+    noise_p: float,
+    seed: Optional[int] = None,
+    noise_factors=_DEFAULT_NOISE_FACTORS,
+    n_trials: int = 200,
+) -> DensityMatrixZNEResult:
+    """Density-matrix ZNE (dense_evolution.zne_density_matrix): builds a
+    real Monte-Carlo density-matrix estimate at each noise scale (the
+    mean of n_trials |psi_k><psi_k| projectors from independent
+    NoiseModel draws -- a real ensemble reconstruction, not a single
+    trajectory), extrapolates to zero noise, and projects onto the
+    nearest physical (PSD, trace-1) density matrix internally.
+
+    Graded (never fed back into the extrapolation) against the true
+    ideal density matrix via dense_evolution.uhlmann_fidelity, so the
+    reported improvement is an honest measurement of whether the
+    correction actually helped -- matches the pattern in
+    zne_density_matrix's own docstring (experiments/matrix_healing_zne.py:
+    raw ~0.865, corrected ~0.947 on a 2-qubit Bell state).
+
+    noise_factors defaults to the same 3-point set as run_zne_mitigation's
+    own Richardson default (prog.txt, dashboard_core audit point 5c: this
+    used to have no stated reason here, unlike that function's explicit
+    one) -- zne_density_matrix always fits via polynomial_extrapolate
+    (degree=2), which is mathematically IDENTICAL to exact Richardson
+    interpolation at exactly 3 points (its own "original design point")
+    but, unlike Richardson, stays well-behaved with MORE than 3 -- so a
+    caller can safely pass extra noise_factors here for more averaging,
+    without the interpolation degradation that would apply to
+    run_zne_mitigation's Richardson path at the same move (see
+    zne_density_matrix's own docstring for the measured numbers).
+
+    Examples
+    --------
+    >>> from dashboard_core.mitigation import run_density_matrix_zne
+    >>> qasm = '''
+    ... OPENQASM 2.0;
+    ... include "qelib1.inc";
+    ... qreg q[1];
+    ... creg c[1];
+    ... x q[0];
+    ... measure q -> c;
+    ... '''
+    >>> result = run_density_matrix_zne(qasm, noise_model='bitflip', noise_p=0.05, seed=0, n_trials=200)
+    >>> result.fidelity_corrected > result.fidelity_raw
+    True
+    """
+    # Same QASMParser-only parsing as run_zne_mitigation above -- see its
+    # comment for why a Qiskit circuit object is never built here.
+    parsed = de.QASMParser().parse(qasm_text)
+    n_qubits = parsed.n_qubits
+    if noise_model not in de.NoiseModel.MODELS:
+        raise ValueError(f"unknown noise model {noise_model!r}, must be one of {de.NoiseModel.MODELS}")
+
+    # Density matrices are dim x dim (dim = 2**n_qubits), not just dim --
+    # this holds rho_ideal, one rho per noise factor (rhos_at_scales, kept
+    # alive simultaneously so zne_density_matrix can extrapolate across all
+    # of them at once) and rho_corrected: (len(noise_factors) + 2) separate
+    # dim*dim complex128 arrays, quadratically worse than a plain
+    # statevector at the same qubit count. Same real anti-OOM guard as
+    # dashboard_core.engine.run_circuit_from_qasm, sized for what this
+    # function actually allocates -- this was the one real gap that never
+    # checked before allocating.
+    dim = 2 ** n_qubits
+    required_mb = dim * dim * 16 / 1e6 * (len(noise_factors) + 2)
+    de.chunk.SafeMemoryGuard().check_allocation(required_mb, context=f"{n_qubits}-qubit density matrix ZNE")
+
+    sim = de.DenseSVSimulator(n_qubits, use_float32=False)
+    sim.run_circuit(parsed.to_tuples())
+    sv_ideal = np.asarray(sim.sv)
+    rho_ideal = np.outer(sv_ideal, sv_ideal.conj())
+
+    rng = np.random.default_rng(seed)
+    rhos_at_scales = []
+    for factor in noise_factors:
+        scaled_p = min(noise_p * factor, 1.0)
+        rho_acc = np.zeros((dim, dim), dtype=complex)
+        for _ in range(n_trials):
+            sv_noisy = de.NoiseModel.apply_to_sv(
+                sv_ideal.copy(), n_qubits, noise_model, scaled_p, rng=rng,
+            )
+            rho_acc += np.outer(sv_noisy, sv_noisy.conj())
+        rho_acc /= n_trials
+        rhos_at_scales.append(rho_acc)
+
+    rho_corrected = np.asarray(de.zne_density_matrix(rhos_at_scales, list(noise_factors)))
+
+    fidelity_raw = float(de.uhlmann_fidelity(rho_ideal, rhos_at_scales[0]))
+    fidelity_corrected = float(de.uhlmann_fidelity(rho_ideal, rho_corrected))
+
+    return DensityMatrixZNEResult(
+        n_qubits=n_qubits,
+        noise_factors=list(noise_factors),
+        fidelity_raw=fidelity_raw,
+        fidelity_corrected=fidelity_corrected,
+    )
+
+
+@dataclass
+class CoherenceZNEResult:
+    n_qubits: int
+    noise_factors: list
+    fidelity_raw: float
+    fidelity_corrected: float
+
+
+def run_coherence_zne_mitigation(
+    qasm_text: str,
+    noise_model: str,
+    noise_p: float,
+    seed: Optional[int] = None,
+    noise_factors=_DEFAULT_NOISE_FACTORS,
+    n_trials: int = 200,
+) -> CoherenceZNEResult:
+    """Coherence-L1-predictive density-matrix ZNE
+    (dense_evolution.coherence_predictive_zne_density_matrix): identical
+    Monte-Carlo density-matrix construction to run_density_matrix_zne
+    above, but extrapolated via the coherence-L1 signal (sum of
+    off-diagonal density-matrix magnitudes, Baumgratz/Cramer/Plenio 2014)
+    instead of the classical-JSD one -- validated (dense_evolution's own
+    docstring, 200-seed phaseflip sweep) to catch phase-type noise
+    (phaseflip, dephasing) the JSD-predictive signal is structurally blind
+    to, since JSD only ever reads the density matrix's diagonal.
+
+    Same real anti-OOM guard, same Uhlmann-fidelity grading against the
+    true ideal density matrix as run_density_matrix_zne -- the two
+    functions differ in exactly one line (which dense_evolution
+    extrapolation function is called), by design, so a caller comparing
+    them is comparing the mitigation signal, not two different pipelines.
+    """
+    parsed = de.QASMParser().parse(qasm_text)
+    n_qubits = parsed.n_qubits
+    if noise_model not in de.NoiseModel.MODELS:
+        raise ValueError(f"unknown noise model {noise_model!r}, must be one of {de.NoiseModel.MODELS}")
+
+    dim = 2 ** n_qubits
+    required_mb = dim * dim * 16 / 1e6 * (len(noise_factors) + 2)
+    de.chunk.SafeMemoryGuard().check_allocation(required_mb, context=f"{n_qubits}-qubit coherence ZNE")
+
+    sim = de.DenseSVSimulator(n_qubits, use_float32=False)
+    sim.run_circuit(parsed.to_tuples())
+    sv_ideal = np.asarray(sim.sv)
+    rho_ideal = np.outer(sv_ideal, sv_ideal.conj())
+
+    rng = np.random.default_rng(seed)
+    rhos_at_scales = []
+    for factor in noise_factors:
+        scaled_p = min(noise_p * factor, 1.0)
+        rho_acc = np.zeros((dim, dim), dtype=complex)
+        for _ in range(n_trials):
+            sv_noisy = de.NoiseModel.apply_to_sv(
+                sv_ideal.copy(), n_qubits, noise_model, scaled_p, rng=rng,
+            )
+            rho_acc += np.outer(sv_noisy, sv_noisy.conj())
+        rho_acc /= n_trials
+        rhos_at_scales.append(rho_acc)
+
+    rho_corrected = np.asarray(de.coherence_predictive_zne_density_matrix(rhos_at_scales, list(noise_factors)))
+
+    fidelity_raw = float(de.uhlmann_fidelity(rho_ideal, rhos_at_scales[0]))
+    fidelity_corrected = float(de.uhlmann_fidelity(rho_ideal, rho_corrected))
+
+    return CoherenceZNEResult(
+        n_qubits=n_qubits,
+        noise_factors=list(noise_factors),
+        fidelity_raw=fidelity_raw,
+        fidelity_corrected=fidelity_corrected,
+    )

dashboard_core/native_hf_diagnostics.py

@@ -0,0 +1,62 @@
+"""
+Real Hartree-Fock SCF convergence diagnostics
+(dense_evolution.native_hf.scf.diagnose_convergence) for an arbitrary
+molecule, exposed as a thin Composer-kernel wrapper. Needs the `armor`
+extra (dense-armor) -- dense_evolution.native_hf.scf itself does not
+require it, but diagnose_convergence's Hampel/Tukey filters do.
+"""
+from dataclasses import dataclass
+
+from basis_set_exchange.lut import element_Z_from_sym
+
+from dense_evolution.native_hf.bridge import build_qubit_hamiltonian
+from dense_evolution.native_hf.scf import diagnose_convergence as _diagnose_convergence
+
+__all__ = ['NativeHfDiagnosticsResult', 'run_native_hf_diagnostics']
+
+
+@dataclass
+class NativeHfDiagnosticsResult:
+    n_qubits: int
+    converged: bool
+    n_iterations: int
+    electronic_energy_hartree: float
+    total_energy_hartree: float
+    n_anomalies_hampel: int
+    n_anomalies_tukey: int
+    anomaly_fraction_hampel: float
+    anomaly_fraction_tukey: float
+
+
+def run_native_hf_diagnostics(symbols, geometry, charge: int = 0,
+                               active_electrons=None, active_orbitals=None) -> NativeHfDiagnosticsResult:
+    """Run real Hartree-Fock SCF (dense_evolution.native_hf, not
+    PennyLane's own STO-3G table -- this is the fallback path used for
+    elements outside it, e.g. Silicon) on an arbitrary molecule, and run
+    Dense-Armor's Hampel/Tukey anomaly filters over the real per-iteration
+    energy trace instead of trusting the final `converged` flag alone.
+    Jordan-Wigner mapping only -- native_hf/bridge.py calls
+    qml.jordan_wigner directly, not a general mapper.
+
+    Raises ImportError with an actionable message if the `armor` extra
+    (pip install dense-evolution[armor]) isn't installed -- diagnostics
+    genuinely can't run without it, this doesn't silently skip them.
+    """
+    atomic_numbers = [element_Z_from_sym(s) for s in symbols]
+    n_electrons = sum(atomic_numbers) - charge
+    H, n_qubits, hf_result = build_qubit_hamiltonian(
+        atomic_numbers, geometry, n_electrons,
+        active_electrons=active_electrons, active_orbitals=active_orbitals,
+    )
+    diagnostics = _diagnose_convergence(hf_result)
+    return NativeHfDiagnosticsResult(
+        n_qubits=n_qubits,
+        converged=bool(hf_result.converged),
+        n_iterations=diagnostics["n_iterations"],
+        electronic_energy_hartree=float(hf_result.electronic_energy),
+        total_energy_hartree=float(hf_result.total_energy),
+        n_anomalies_hampel=diagnostics["n_anomalies_hampel"],
+        n_anomalies_tukey=diagnostics["n_anomalies_tukey"],
+        anomaly_fraction_hampel=diagnostics["anomaly_fraction_hampel"],
+        anomaly_fraction_tukey=diagnostics["anomaly_fraction_tukey"],
+    )

dashboard_core/noise_tools.py

@@ -0,0 +1,125 @@
+"""
+Composer-facing wrappers around dense_evolution.noise's standalone noise
+profiles and density-matrix channels -- the ones that take a formula and
+some parameters, not a circuit, so they don't fit run_circuit_from_qasm's
+shape.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+import numpy as np
+
+import dense_evolution as de
+
+__all__ = [
+    'CosmicRayBurstResult', 'run_cosmic_ray_burst',
+    'OscillatingNoiseResult', 'run_oscillating_noise',
+    'DensityMatrixChannelResult', 'run_density_matrix_channel',
+]
+
+
+@dataclass
+class CosmicRayBurstResult:
+    times_us: List[float]
+    baseline_gamma: float
+    decay_probabilities: List[float]
+    peak_ratio: float
+
+
+def run_cosmic_ray_burst(baseline_gamma: float, times_us: Optional[List[float]] = None) -> CosmicRayBurstResult:
+    """Real cosmic-ray/gamma-ray-induced quasiparticle burst profile
+    (dense_evolution.cosmic_ray_burst_profile), reproducing a real
+    measured event from arXiv:2104.05219 on a 26-qubit chip. Default
+    `times_us` samples the impact instant, the ~10us and ~1ms rise
+    checkpoints the paper describes, and a point well into the ~25ms
+    recovery."""
+    if times_us is None:
+        times_us = [0.0, 10.0, 1000.0, 50000.0]
+    times_arr = np.asarray(times_us, dtype=float)
+    profile = np.asarray(de.cosmic_ray_burst_profile(times_arr, baseline_gamma=baseline_gamma))
+    return CosmicRayBurstResult(
+        times_us=[float(t) for t in times_arr],
+        baseline_gamma=baseline_gamma,
+        decay_probabilities=[float(p) for p in profile],
+        peak_ratio=float(np.max(profile) / baseline_gamma),
+    )
+
+
+@dataclass
+class OscillatingNoiseResult:
+    base_p: float
+    freq: float
+    amp: float
+    factors: List[float]
+    p_eff: List[float]
+
+
+def run_oscillating_noise(base_p: float, freq: float, amp: float,
+                           factors: Optional[List[float]] = None) -> OscillatingNoiseResult:
+    """Noise strength that oscillates instead of scaling smoothly with
+    `factor` (dense_evolution.oscillating_p_eff) -- for checking whether a
+    mitigation technique that assumes smooth noise-vs-scale still works
+    when that assumption breaks. Default `factors` sample one full period
+    at `freq`."""
+    if factors is None:
+        factors = [0.0, 1.0, 2.0, 3.0]
+    p_eff = [float(de.oscillating_p_eff(base_p, f, freq, amp)) for f in factors]
+    return OscillatingNoiseResult(base_p=base_p, freq=freq, amp=amp, factors=list(factors), p_eff=p_eff)
+
+
+@dataclass
+class DensityMatrixChannelResult:
+    n_qubits: int
+    channel: str
+    param: float
+    ideal_diagonal: List[float]
+    noisy_diagonal: List[float]
+    trace: float
+
+
+def run_density_matrix_channel(qasm_text: str, channel: str, param: float) -> DensityMatrixChannelResult:
+    """Apply a density-matrix-level noise channel (as opposed to
+    NoiseModel's per-qubit statevector channels) to the ideal density
+    matrix of a QASM circuit.
+
+    channel: 'global_depolarizing' (dense_evolution.global_depolarizing_channel,
+    mixes the WHOLE register toward the fully mixed state as one unit --
+    a state-prep/measurement error reported as a single joint parameter)
+    or 'amplitude_damping' (dense_evolution.amplitude_damping_channel,
+    single-qubit only, asymmetric |1>->|0> energy relaxation)."""
+    if channel not in ('global_depolarizing', 'amplitude_damping'):
+        raise ValueError(f"channel must be 'global_depolarizing' or 'amplitude_damping', got {channel!r}")
+
+    parsed = de.QASMParser().parse(qasm_text)
+    n_qubits = parsed.n_qubits
+    # BUG FIX (prog.txt, dashboard_core audit point 3d): this function
+    # builds two full dim x dim density matrices (rho, rho_noisy) but,
+    # unlike engine.py's and mitigation.py's own equivalents, never
+    # checked SafeMemoryGuard before allocating -- the same class of OOM
+    # the rest of the dashboard already prevents. Same dim*dim*16-per-
+    # matrix estimate mitigation.py's own density-matrix guard uses.
+    dim = 2 ** n_qubits
+    required_mb = dim * dim * 16 / 1e6 * 2
+    de.chunk.SafeMemoryGuard().check_allocation(required_mb, context=f"{n_qubits}-qubit density matrix channel")
+
+    sim = de.DenseSVSimulator(n_qubits)
+    sim.run_circuit(parsed.to_tuples())
+    sv = np.asarray(sim.get_statevector())
+    rho = np.outer(sv, sv.conj())
+
+    if channel == 'global_depolarizing':
+        rho_noisy = de.global_depolarizing_channel(rho, param)
+    else:
+        if n_qubits != 1:
+            raise ValueError(f"amplitude_damping is single-qubit only, got a {n_qubits}-qubit circuit")
+        rho_noisy = de.amplitude_damping_channel(rho, param)
+
+    return DensityMatrixChannelResult(
+        n_qubits=n_qubits,
+        channel=channel,
+        param=param,
+        ideal_diagonal=[float(x) for x in np.diag(rho).real],
+        noisy_diagonal=[float(x) for x in np.diag(rho_noisy).real],
+        trace=float(np.trace(rho_noisy).real),
+    )