Struct roqoqo_mock::Backend

pub struct Backend { /* private fields */ }

Mocked backend to qoqo

Provides functions to run circuits and measurements. The mocked backend mock-simulates a quantum circuit on a given device by translating the roqoqo Circuit using the roqoqo_mocked interface. This interface produces random measurements coherent with the measured quantity. These results are then output from the run function in this backend and are accessible through the classical registers dictionary.

Arguments

• number_qubits - Number of qubits in the Backend

Implementations

impl Backend

pub fn new(number_qubits: usize) -> Self

Creates new Mocked backend

Arguments

• number_qubits - Number of qubits in the Backend

Returns

• Backend - The new instance of Backend with the specified number of qubits

Trait Implementations

impl Clone for Backend

fn clone(&self) -> Backend

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Backend

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

Formats the value using the given formatter.

impl EvaluatingBackend for Backend

Trait for Backends that can evaluate measurements to expectation values.

Example

use roqoqo::{Circuit, backends::EvaluatingBackend, operations::*};
use roqoqo_mock::Backend;

let backend = Backend::new(2_usize);
let mut circuit = Circuit::new();
circuit += DefinitionBit::new("ro".to_string(), 2, true);
circuit += RotateX::new(0, std::f64::consts::FRAC_PI_2.into());
circuit += PauliX::new(1);
circuit += PragmaRepeatedMeasurement::new("ro".to_string(), 20, None);
let (bit_registers, _float_registers, _complex_registers) =
    backend.run_circuit(&circuit).unwrap();
assert!(bit_registers.contains_key("ro"));
let out_reg = bit_registers.get("ro").unwrap();
assert_eq!(out_reg.len(), 20);
for reg in out_reg.iter() {
    assert_eq!(reg.len(), 2);
}

fn run_circuit_iterator<'a>( &self, circuit: impl Iterator<Item = &'a Operation> ) -> Result<(HashMap<String, BitOutputRegister>, HashMap<String, FloatOutputRegister>, HashMap<String, ComplexOutputRegister>), RoqoqoBackendError>

Runs a circuit with the backend.

A circuit is passed to the roqoqo-mock backend and executed. During execution values are written to and read from classical registers ([crate::registers::BitRegister], [crate::registers::FloatRegister] and [crate::registers::ComplexRegister]). To produce sufficient statistics for evaluating expectationg values, circuits have to be run multiple times. The results of each repetition are concatenated in OutputRegisters ([crate::registers::BitOutputRegister], [crate::registers::FloatOutputRegister] and [crate::registers::ComplexOutputRegister]).

Arguments

• circuit - The circuit that is run on the backend.

Returns

RegisterResult - The output registers written by the evaluated circuits.

fn run_circuit( &self, circuit: &Circuit ) -> Result<(HashMap<String, Vec<Vec<bool>>>, HashMap<String, Vec<Vec<f64>>>, HashMap<String, Vec<Vec<Complex<f64>>>>), RoqoqoBackendError>

Runs a circuit with the backend.

fn run_measurement_registers<T>( &self, measurement: &T ) -> Result<(HashMap<String, Vec<Vec<bool>>>, HashMap<String, Vec<Vec<f64>>>, HashMap<String, Vec<Vec<Complex<f64>>>>), RoqoqoBackendError>

where T: Measure,

Runs all circuits corresponding to one measurement with the backend.

fn run_measurement<T>( &self, measurement: &T ) -> Result<Option<HashMap<String, f64>>, RoqoqoBackendError>

where T: MeasureExpectationValues,

Evaluates expectation values of a measurement with the backend.

impl PartialEq for Backend

fn eq(&self, other: &Backend) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Backend

impl StructuralEq for Backend

impl StructuralPartialEq for Backend