Enum EngineInstruction 

pub enum EngineInstruction {
    Gate1 {
        gate: Gate1Q,
        qubit: usize,
    },
    Gate2 {
        control: PauliBasis,
        target: PauliBasis,
        control_qubit: usize,
        target_qubit: usize,
    },
    Pauli {
        basis: PauliBasis,
        qubit: usize,
    },
    T {
        basis: PauliBasis,
        qubit: usize,
        adjoint: bool,
    },
    TPauli {
        axis: PauliString,
        adjoint: bool,
    },
    PauliRotation {
        axis: PauliString,
        kernel_angle: f64,
    },
    Measure(PauliString),
    MeasureWithReadoutError {
        observable: PauliString,
        probability: f64,
    },
    Record {
        value: bool,
        flip_probability: f64,
    },
    RandomPauli {
        probabilities: Vec<f64>,
        alternatives: Vec<PauliString>,
        heralded: bool,
    },
    Expectation(PauliString),
    Reset {
        basis: PauliBasis,
        qubit: usize,
    },
    ConditionalPauli {
        basis: PauliBasis,
        qubit: usize,
        control: usize,
    },
}

One step of a TableauSimulator::apply_batch program.

Examples

use ticit::{Gate1Q, Instruction};
use ticit::{Pauli, PauliBasis, PauliString, TableauSimulator};

// Prepare a Bell pair and read both halves out in the Z basis.
let bell = [
    Instruction::Gate1 {
        gate: Gate1Q::H,
        qubit: 0,
    },
    Instruction::Gate2 {
        control: PauliBasis::Z,
        target: PauliBasis::X,
        control_qubit: 0,
        target_qubit: 1,
    },
    Instruction::Measure(PauliString::single(2, 0, Pauli::Z)),
    Instruction::Measure(PauliString::single(2, 1, Pauli::Z)),
];

let mut sim = TableauSimulator::with_seed(2, 7);
let outcome = sim.apply_batch(&bell)?;
assert_eq!(outcome.records.len(), 2);
assert_eq!(outcome.records[0].outcome, outcome.records[1].outcome);

Variants

Gate1

A named single-qubit Clifford.

Fields

gate: Gate1Q

The gate to apply.

qubit: usize

Its operand.

Gate2

A two-qubit <A>C<B> gate: apply target on target_qubit when control_qubit is in the −1 eigenstate of control. CX is control: Z, target: X; CZ is Z, Z.

Fields

control: PauliBasis

The control qubit’s Pauli axis (A).

target: PauliBasis

The target qubit’s Pauli axis (B).

control_qubit: usize

Qubit the control axis is read on.

target_qubit: usize

Qubit the target axis acts on.

Pauli

A single-qubit Pauli.

Fields

basis: PauliBasis

Which Pauli.

qubit: usize

Its operand.

T

T/T† about a single-qubit basis axis.

Fields

basis: PauliBasis

The rotation axis.

qubit: usize

Its operand.

adjoint: bool

true selects T†.

TPauli

T/T† about an arbitrary Pauli axis.

Fields

axis: PauliString

The rotation axis.

adjoint: bool

true selects T†.

PauliRotation

exp(-i * kernel_angle * axis) for an arbitrary real angle.

Fields

axis: PauliString

Hermitian Pauli rotation axis.

kernel_angle: f64

Angle in radians under the kernel convention.

Measure(PauliString)

Measure a Pauli observable, appending its result to BatchOutcome::records.

MeasureWithReadoutError

Measure a Pauli observable and independently flip the recorded bit.

Fields

observable: PauliString

Hermitian observable to measure.

probability: f64

Probability of flipping the classical record after projection.

Record

Append a classical record, optionally flipped by Bernoulli noise.

Fields

value: bool

Record value before noise.

flip_probability: f64

Probability of flipping value.

RandomPauli

Sample at most one Pauli alternative and apply it.

Fields

probabilities: Vec<f64>

Absolute probability of each corresponding alternative.

alternatives: Vec<PauliString>

Pauli alternatives; remaining probability means no operation.

heralded: bool

Whether to append a record indicating that an alternative fired.

Expectation(PauliString)

Read a Pauli expectation value without changing the state.

Reset

Reset a qubit to the +1 eigenstate of basis.

Fields

basis: PauliBasis

The basis to reset into.

qubit: usize

Its operand.

ConditionalPauli

Apply a single-qubit Pauli if an earlier measurement in this batch came out −1.

control indexes BatchOutcome::records, so it counts measurements (not instructions) from the start of the batch. Corrections conditioned on anything outside the batch belong between batches, where the caller still owns the decision.

Fields

basis: PauliBasis

Which Pauli to apply.

qubit: usize

Its operand.

control: usize

Index into BatchOutcome::records of the gating measurement.

Implementations

impl Instruction

pub fn from_circuit(circuit: &Circuit) -> Vec<Instruction>

Translates a circuit once into instructions reusable by TableauSimulator::apply_batch.

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl PartialEq for Instruction

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Instruction