Enum Instruction 

pub enum Instruction {
    Standard(StandardGate),
    McGate(Box<MCGate>),
    UnitaryGate(Box<UnitaryGate>),
    CircuitGate(Box<CircuitGate>),
    Directive(Directive),
    ClassicalData(ClassicalDataOp),
    ClassicalControl(ClassicalControlOp),
    Delay,
}

A unified representation of any operation in a quantum circuit.

This enum acts as a sum type for all possible instructions.

• Prefer Instruction::Standard for common gates to leverage simulator optimizations.
• Use Instruction::McGate for generalized controls over standard gates.
• Use Instruction::UnitaryGate or Instruction::CircuitGate for custom unitary behavior.
• Use Instruction::Directive for non-reversible actions such as measurement and reset.
• Use Instruction::ClassicalControl for expression-based dynamic control flow.

Variants

Standard(StandardGate)

A standard, natively supported quantum gate (e.g., H, CX).

McGate(Box<MCGate>)

An extended gate, such as a multi-controlled gate or a user-defined unitary.

UnitaryGate(Box<UnitaryGate>)

User-defined unitary gate backed by a matrix or circuit definition.

CircuitGate(Box<CircuitGate>)

Reusable gate defined by a frozen circuit body.

Directive(Directive)

A non-unitary operation, such as Measure, Barrier, or Reset.

ClassicalData(ClassicalDataOp)

Runtime classical data operation such as assignment or measurement into typed classical storage.

ClassicalControl(ClassicalControlOp)

Structured classical control flow.

This variant carries expression-based IR such as if, while, for, switch, break, and continue. It is a runtime control instruction, not a unitary gate: it has no fixed arity, cannot be represented as a matrix, has no static inverse, and cannot be promoted to a quantum-controlled instruction.

Delay

I gate in QCIS, represented here as Delay, unit is 0.5ns

Implementations

impl Instruction

pub fn name(&self) -> String

Returns the stable concrete operation name or user-defined gate label.

Unlike Self::instruction_type, this distinguishes individual gates. It is independent of Debug and of presentation-only formatting.

pub const fn instruction_type(&self) -> &'static str

Returns a stable category name for this instruction.

pub const fn is_standard(&self) -> bool

pub const fn is_mcgate(&self) -> bool

pub const fn is_unitary(&self) -> bool

pub const fn is_circuit_gate(&self) -> bool

pub const fn is_directive(&self) -> bool

pub const fn is_classical_data(&self) -> bool

pub const fn is_classical_control(&self) -> bool

pub const fn is_delay(&self) -> bool

pub const fn is_quantum_gate(&self) -> bool

Returns whether this instruction is a unitary quantum gate.

pub fn standard_gate(&self) -> Option<StandardGate>

Returns the standard gate represented directly by this instruction.

pub fn mc_gate(&self) -> Option<&MCGate>

Returns the multi-controlled gate when this is an McGate instruction.

pub fn unitary_gate(&self) -> Option<&UnitaryGate>

Returns the user-defined unitary gate when this is a UnitaryGate instruction.

pub fn circuit_gate(&self) -> Option<&CircuitGate>

Returns the circuit-backed gate when this is a CircuitGate instruction.

pub fn directive(&self) -> Option<Directive>

Returns the directive when this is a Directive instruction.

pub fn classical_data(&self) -> Option<&ClassicalDataOp>

Returns the classical data operation when this is a ClassicalData instruction.

pub fn classical_control(&self) -> Option<&ClassicalControlOp>

Returns the classical control operation when this is a ClassicalControl instruction.

pub fn has_measurement(&self) -> bool

Returns true when this instruction directly or recursively contains a measurement.

pub fn reads_value(&self, value: ClassicalValue) -> bool

Returns true when this instruction directly or recursively reads value.

pub fn gate_arity(&self) -> Option<(usize, usize)>

Returns the fixed (qubit_count, parameter_count) for gate-like instructions.

This method describes arity that is intrinsic to the instruction itself. It returns None for instructions whose qubit count is variable or context-dependent, such as barriers and classical control operations. Callers that need the qubits used by a classical control body should use ClassicalControlOp::used_qubits instead.

pub fn matrix(&self, params: &[f64]) -> Option<Cow<'_, Array2<Complex64>>>

Computes the unitary matrix representation of the instruction.

The first qubit argument is the most-significant bit of the local matrix for every supported gate, including circuit-backed UnitaryGate definitions. Full circuit matrices instead use an LSB-first basis.

Arguments

• params - A slice of floating-point parameters (e.g., rotation angles). CircuitGate values bind positionally to its declared signature.

Returns

• Some(Cow<Array2>): A numeric matrix for a supported gate instruction.
• None: If parameters are invalid or unresolved, or the instruction has no matrix (e.g., Measure, Barrier, Reset, or classical control).

pub fn inverse( &self, params: &[Parameter], ) -> Option<(Instruction, SmallVec<[Parameter; 3]>)>

Computes the inverse (Hermitian conjugate) of the instruction.

Arguments

• params - The parameters of the instruction instance.

Returns

• Some(...): The inverse instruction and its transformed parameters.
• None: If the instruction is non-invertible (e.g., Measure or classical control) or if the inverse cannot be symbolically determined (e.g., some custom unitaries).

pub fn control(&self, num_new_ctrls: usize) -> Option<Instruction>

Returns a new instruction that applies the current operation conditioned on extra control qubits.

This method employs a canonicalization strategy to return the most optimized gate representation:

1. Promotion: If adding controls to a StandardGate results in another StandardGate (e.g., $X \xrightarrow{+1} CX \xrightarrow{+1} CCX$), it returns the upgraded standard gate.
2. Fallback: If no standard equivalent exists (e.g., $C^3-X$), it returns an Instruction::McGate.
3. Aggregation: If the instruction is already an MCGate, the new controls are merged into it.

Arguments

• num_new_ctrls - The number of additional control qubits to add.

Returns

• Some(Instruction): The new controlled instruction.
• None: If the instruction cannot be controlled (e.g., Barrier, Measure, or classical control).

Trait Implementations

impl Clone for Instruction

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 Instruction

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

Formats the value using the given formatter.

impl Display for Instruction

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

Formats the value using the given formatter.

impl From<ClassicalControlOp> for Instruction

fn from(cf: ClassicalControlOp) -> Self

Converts to this type from the input type.

impl From<ClassicalDataOp> for Instruction

fn from(op: ClassicalDataOp) -> Self

Converts to this type from the input type.

impl From<Directive> for Instruction

fn from(d: Directive) -> Self

Converts to this type from the input type.

impl From<Instruction> for ValueInstruction

fn from(inst: Instruction) -> Self

Converts a non-control-flow Instruction into a ValueInstruction.

Panics

Panics in debug builds if the instruction is Instruction::ClassicalControl.

impl From<StandardGate> for Instruction

fn from(g: StandardGate) -> Self

Converts to this type from the input type.

impl PartialEq for Instruction

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Instruction