Struct GateInstruction 

pub struct GateInstruction {
    pub gate: QuantumGate,
    pub target: usize,
    pub control: BTreeSet<usize>,
    pub control_locked: bool,
    pub is_approximated: bool,
    pub decomposed: Option<Vec<DecomposedGate>>,
}

A fully-specified gate instruction applied to one or more logical qubits.

A GateInstruction bundles a QuantumGate with its target qubit index and a set of control qubit indices. It also tracks whether new controls may still be added (control_locked), whether approximate decomposition algorithms may be used (is_approximated), and the optional pre-computed gate decomposition (decomposed).

Fields

gate: QuantumGate

The quantum gate to apply.

target: usize

The index of the target qubit.

control: BTreeSet<usize>

The set of control qubit indices.

control_locked: bool

When true, no additional control qubits may be added to this instruction.

is_approximated: bool

When true, the gate decomposition may use relative-phase decompostion that reduce the gate count.

decomposed: Option<Vec<DecomposedGate>>

The gate decomposed into primitive (CNOT + single-qubit) operations.

Implementations

impl GateInstruction

pub const fn new(gate: QuantumGate, target: usize) -> Self

Creates a new uncontrolled gate instruction for gate applied to target.

pub fn inverse(&self) -> Self

Returns the adjoint (inverse) of this gate instruction.

The control set and lock status are preserved. If the instruction has already been decomposed, the decomposition is reversed and each constituent gate is individually inverted.

pub fn control(&self, control_qubits: &[usize]) -> Result<Self, KetError>

Adds control_qubits to the control set of this instruction.

Errors

• KetError::DuplicateControlQubit: one of control_qubits is already present in the control set.
• KetError::ControlTargetConflict: one of control_qubits is the same qubit as self.target.

If the instruction’s controls are locked (GateInstruction::control_locked is true), the call is a no-op and Ok(self.clone()) is returned.

pub fn enable_approximated_decomposition(&mut self)

Enable approximate decomposition.

When is_approximated is true, decomposition algorithms use a smaller circuits are permitted.

pub fn lock_control(&mut self)

Lock the control set.

A locked instruction will silently ignore any subsequent calls to GateInstruction::control, returning a clone of itself unchanged.

pub fn commutes_with(&self, other: &Self) -> bool

Returns true if this instruction commutes with other.

Two instructions commute when both are diagonal, or when they apply the same gate to the same target.

pub fn decompose(&mut self, clean_auxiliary_range: (usize, usize))

Decomposes a multi-controlled gate into primitive two-qubit operations.

The decomposition is written into self.decomposed. If the instruction has no control qubits, or if decomposed is already populated, this method is a no-op.

clean_auxiliary_range is a half-open range (start, end) of qubit indices that are guaranteed to be in the |0⟩ state (clean auxiliary).

Trait Implementations

impl Clone for GateInstruction

fn clone(&self) -> GateInstruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GateInstruction

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

Formats the value using the given formatter.

impl From<&DecomposedGate> for GateInstruction

fn from(value: &DecomposedGate) -> Self

Converts to this type from the input type.

impl PartialEq for GateInstruction

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for GateInstruction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GateInstruction