Struct ErrorMitigation 

pub struct ErrorMitigation { /* private fields */ }

Unified facade over supported error-mitigation methods.

The workflow is always sequential:

1. create an ErrorMitigation instance with one mitigation method,
2. call ErrorMitigation::run to construct and execute the required circuits,
3. call ErrorMitigation::get_mitigated to post-process the stored raw data.

Example

Zero-noise extrapolation:

use cqlib_core::circuit::{Circuit, Qubit};
use cqlib_core::error_mitigation::{
    ErrorMitigation, ExtrapolateMethod, MitigationMethod, ProcessArgs, RunArgs, ZneConfig,
};
use cqlib_core::qis::{Hamiltonian, Pauli, PauliString};
use num_complex::Complex64;

let q0 = Qubit::new(0);
let mut circuit = Circuit::new(1);
circuit.h(q0).unwrap();

let mut pauli = PauliString::new(1);
pauli.set_pauli(0, Pauli::Z);
let hamiltonian = Hamiltonian::from_list(vec![(pauli, Complex64::new(1.0, 0.0))]).unwrap();

let mut mitigation = ErrorMitigation::new(
    circuit,
    MitigationMethod::Zne(ZneConfig {
        fold_levels: vec![0, 1, 2],
    }),
)
.unwrap();

// A portal to real quantum device or classical simulation backend that calculates <h> and its variance
let estimator = |circuit: &Circuit, hamiltonian: Option<&Hamiltonian>, shots: Option<usize>| {
    assert!(hamiltonian.is_some());
    assert_eq!(shots, Some(1024));
    (circuit.operations().len() as f64, 0.0)
};

mitigation
    .run(
        &hamiltonian,
        RunArgs::Zne {
            gate_set: None,
            shots: Some(1024),
        },
        &estimator,
    )
    .unwrap();

let mitigated = mitigation
    .get_mitigated(ProcessArgs::Zne {
        method: ExtrapolateMethod::Polynomial,
        degree: Some(1),
    })
    .unwrap();

assert!(mitigated.variance.is_none());

Virtual distillation:

use cqlib_core::circuit::Circuit;
use cqlib_core::error_mitigation::{
    ErrorMitigation, MitigationMethod, ProcessArgs, RunArgs, VirtualDistillationConfig,
};
use cqlib_core::qis::{Hamiltonian, Pauli, PauliString};
use num_complex::Complex64;

let circuit = Circuit::new(1);

let mut pauli = PauliString::new(1);
pauli.set_pauli(0, Pauli::Z);
let hamiltonian = Hamiltonian::from_list(vec![(pauli, Complex64::new(1.0, 0.0))]).unwrap();

let mut mitigation = ErrorMitigation::new(
    circuit,
    MitigationMethod::VirtualDistillation(VirtualDistillationConfig { copies: 2 }),
)
.unwrap();

// A portal to real quantum device or classical simulation backend that calculates <h> and its variance
let estimator = |_circuit: &Circuit, hamiltonian: Option<&Hamiltonian>, _shots: Option<usize>| {
    // Both the numerator and the denominator carry a Hamiltonian: the
    // numerator additionally acts on the first copy (qubit 0 here).
    let term = &hamiltonian.unwrap().terms[0].0;
    if term.x[0] || term.z[0] {
        (1.5, 0.25)
    } else {
        (2.0, 1.0)
    }
};

mitigation
    .run(
        &hamiltonian,
        RunArgs::VirtualDistillation {
            shots_numerator: 512,
            shots_denominator: 512,
        },
        &estimator,
    )
    .unwrap();

let mitigated = mitigation
    .get_mitigated(ProcessArgs::VirtualDistillation)
    .unwrap();

assert!(mitigated.variance.is_some());

Implementations

impl ErrorMitigation

pub fn new( circuit: Circuit, method: MitigationMethod, ) -> Result<Self, ErrorMitigationError>

Creates a new unified mitigation pipeline for the given circuit and method.

Example

use cqlib_core::circuit::Circuit;
use cqlib_core::error_mitigation::{
    ErrorMitigation, MitigationMethod, VirtualDistillationConfig,
};

let mitigation = ErrorMitigation::new(
    Circuit::new(1),
    MitigationMethod::VirtualDistillation(VirtualDistillationConfig { copies: 2 }),
);

assert!(mitigation.is_ok());

pub fn run( &mut self, hamiltonian: &Hamiltonian, run_args: RunArgs, estimator: &Estimator<'_>, ) -> Result<(), ErrorMitigationError>

Executes the configured mitigation pipeline and stores raw results.

This method does not return the final mitigated value directly. Call ErrorMitigation::get_mitigated afterwards to perform the method-specific post-processing step.

Example

use cqlib_core::circuit::Circuit;
use cqlib_core::error_mitigation::{
    ErrorMitigation, MitigationMethod, RunArgs, VirtualDistillationConfig,
};
use cqlib_core::qis::{Hamiltonian, Pauli, PauliString};
use num_complex::Complex64;

let mut pauli = PauliString::new(1);
pauli.set_pauli(0, Pauli::Z);
let hamiltonian = Hamiltonian::from_list(vec![(pauli, Complex64::new(1.0, 0.0))]).unwrap();

let mut mitigation = ErrorMitigation::new(
    Circuit::new(1),
    MitigationMethod::VirtualDistillation(VirtualDistillationConfig { copies: 2 }),
)
.unwrap();

// A portal to real quantum device or classical simulation backend that calculates <h> and its variance
let estimator = |_circuit: &Circuit, hamiltonian: Option<&Hamiltonian>, _shots: Option<usize>| {
    // Both the numerator and the denominator carry a Hamiltonian: the
    // numerator additionally acts on the first copy (qubit 0 here).
    let term = &hamiltonian.unwrap().terms[0].0;
    if term.x[0] || term.z[0] {
        (1.0, 0.1)
    } else {
        (2.0, 0.2)
    }
};

mitigation
    .run(
        &hamiltonian,
        RunArgs::VirtualDistillation {
            shots_numerator: 256,
            shots_denominator: 256,
        },
        &estimator,
    )
    .unwrap();

pub fn get_mitigated( &self, process_args: ProcessArgs, ) -> Result<MitigatedResult, ErrorMitigationError>

Produces the final mitigated result from the stored raw execution outputs.

run() must be called first. The provided ProcessArgs must match the configured mitigation method. This method can be called repeatedly with different processing arguments; it does not consume data or rerun the estimator.

Example

use cqlib_core::circuit::Circuit;
use cqlib_core::error_mitigation::{
    ErrorMitigation, ExtrapolateMethod, MitigationMethod, ProcessArgs, RunArgs, ZneConfig,
};
use cqlib_core::qis::{Hamiltonian, Pauli, PauliString};
use num_complex::Complex64;

let mut pauli = PauliString::new(1);
pauli.set_pauli(0, Pauli::Z);
let hamiltonian = Hamiltonian::from_list(vec![(pauli, Complex64::new(1.0, 0.0))]).unwrap();

let mut mitigation = ErrorMitigation::new(
    Circuit::new(1),
    MitigationMethod::Zne(ZneConfig {
        fold_levels: vec![0, 1, 2],
    }),
)
.unwrap();

// A portal to real quantum device or classical simulation backend that calculates <h> and its variance
let estimator = |circuit: &Circuit, _hamiltonian: Option<&Hamiltonian>, _shots: Option<usize>| {
    (circuit.operations().len() as f64, 0.0)
};

mitigation
    .run(
        &hamiltonian,
        RunArgs::Zne {
            gate_set: None,
            shots: None,
        },
        &estimator,
    )
    .unwrap();

let mitigated = mitigation
    .get_mitigated(ProcessArgs::Zne {
        method: ExtrapolateMethod::Polynomial,
        degree: Some(1),
    })
    .unwrap();

assert!(mitigated.expectation.is_finite());

Trait Implementations

impl Clone for ErrorMitigation

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 ErrorMitigation

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

Formats the value using the given formatter.