Struct ZNEMitigation 

pub struct ZNEMitigation { /* private fields */ }

Zero-noise extrapolation (ZNE) mitigation helper.

This mirrors the Python ZNEMitigation data model and currently implements only circuit folding.

Example

use cqlib_core::circuit::gate::{Instruction, StandardGate};
use cqlib_core::circuit::{Circuit, Qubit};
use cqlib_core::error_mitigation::ZNEMitigation;

let q0 = Qubit::new(0);
let q1 = Qubit::new(1);

let mut circuit = Circuit::new(2);
circuit.h(q0).unwrap();
circuit.cx(q0, q1).unwrap();

// Build ZNE with fold levels [0, 1, 2], noise factors [1, 3, 5].
let zne = ZNEMitigation::new(circuit, vec![0, 1, 2]);

// Global folding for each level.
let folded_all = zne.fold_circuits(None).unwrap();
assert_eq!(folded_all.len(), 3);

// Selective folding for H only.
let folded_h_only = zne
    .fold_circuits(Some(&[Instruction::Standard(StandardGate::H)]))
    .unwrap();
assert_eq!(folded_h_only.len(), 3);

Implementations

impl ZNEMitigation

pub fn new(circuit: Circuit, fold_levels: Vec<i32>) -> Self

Creates a new ZNE mitigation helper.

noise_factors follow the Python implementation: 2 * level + 1.

pub fn circuit(&self) -> &Circuit

Returns the original (unfolded) circuit.

pub fn fold_levels(&self) -> &[i32]

Returns configured fold levels.

pub fn noise_factors(&self) -> &[i32]

Returns noise factors corresponding to fold levels.

Each factor is 2 * level + 1 due to unitary folding.

pub fn fold_circuits( &self, gate_set: Option<&[Instruction]>, ) -> Result<Vec<Circuit>, CircuitError>

Fold the circuit for each configured level using unitary folding.

If gate_set is None, this performs global folding: U -> U (U^† U)^level.

If gate_set is provided, only operations whose instruction name matches one of the instruction names in gate_set are folded.

pub fn run_em_sequence( &self, gate_set: Option<&[Instruction]>, hamiltonian: &Hamiltonian, estimator: &Estimator<'_>, ) -> Result<Vec<f64>, ErrorMitigationError>

Run the error-mitigation sequence and return expectation-value estimates.

This method folds the circuit at each configured level and computes one expectation value per folded circuit.

• gate_set: optional selective gate set for folding. None means global folding.
• hamiltonian: a qis::Hamiltonian describing the observable to estimate.
• estimator: a shared estimator that receives the folded circuit, Some(hamiltonian), and an optional shot count. run_em_sequence currently passes None for the shot count.

pub fn run_em_sequence_with_shots( &self, gate_set: Option<&[Instruction]>, hamiltonian: &Hamiltonian, shots: Option<usize>, estimator: &Estimator<'_>, ) -> Result<Vec<f64>, ErrorMitigationError>

Run the error-mitigation sequence with an optional shot count.

pub fn extrapolate( &self, noisy_results: &[f64], method: ExtrapolateMethod, degree: usize, ) -> Result<f64, ErrorMitigationError>

Unified extrapolation API.

• method = ExtrapolateMethod::Polynomial: uses degree and delegates to ZNEMitigation::poly_extrapolate.
• method = ExtrapolateMethod::Exponential: ignores degree and delegates to ZNEMitigation::exp_extrapolate.

pub fn poly_extrapolate( &self, noisy_results: &[f64], degree: usize, ) -> Result<f64, ErrorMitigationError>

Given the noisy results, extrapolate the expectation value using a polynomial fit.

• noisy_results: the noisy results to extrapolate.
• degree: the degree of the polynomial to use for extrapolation.

Returns the extrapolated expectation value.

pub fn exp_extrapolate( &self, noisy_results: &[f64], ) -> Result<f64, ErrorMitigationError>

Given the noisy results, extrapolate the expectation value using an exponential-decay model:

y(x) = A * exp(-x / tau).

The fit is performed in log-space by linear regression on:

ln(y) = ln(A) + m * x, where m = -1 / tau.

Returns A, which is the extrapolated value at x = 0.

Trait Implementations

impl Clone for ZNEMitigation

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ZNEMitigation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.