Enum StandardGate 

#[repr(u8)]
pub enum StandardGate {
    I = 0,
    H = 1,
    RX = 2,
    RXX = 3,
    RXY = 4,
    RY = 5,
    RYY = 6,
    RZ = 7,
    RZX = 8,
    RZZ = 9,
    S = 10,
    SDG = 11,
    SWAP = 12,
    T = 13,
    TDG = 14,
    U = 15,
    X = 16,
    XY = 17,
    X2P = 18,
    X2M = 19,
    XY2P = 20,
    XY2M = 21,
    Y = 22,
    Y2P = 23,
    Y2M = 24,
    Z = 25,
    Phase = 26,
    GPhase = 27,
    CX = 28,
    CCX = 29,
    CY = 30,
    CZ = 31,
    CRX = 32,
    CRY = 33,
    CRZ = 34,
    FSIM = 35,
}

Represents the set of standard quantum logic gates supported natively by Cqlib.

This enum serves as the fundamental identifier for quantum operations that have a defined behavior and matrix representation within the core library. It includes:

• Pauli Gates: $I, X, Y, Z$
• Clifford Gates: $H, S, T, S^\dagger, T^\dagger$
• Parametric Rotations: $RX(\theta), RY(\theta), RZ(\theta), U(\theta, \phi, \lambda)$
• Two-Qubit Gates: $CX, CZ, SWAP, FSim$
• Multi-Controlled Gates: $CCX$ (Toffoli)

Design Note

StandardGate is designed to be lightweight (Copy, repr(u8)) for efficient storage and transmission.

Variants

I = 0

Identity gate (No-operation).

H = 1

Hadamard gate. Superposition creator.

RX = 2

Rotation around X-axis: $R_x(\theta) = e^{-i\theta X/2}$.

RXX = 3

Ising XX interaction gate (two-qubit parametric).

RXY = 4

Rotation around an axis in the X-Y plane.

RY = 5

Rotation around Y-axis: $R_y(\theta) = e^{-i\theta Y/2}$.

RYY = 6

Ising YY interaction gate.

RZ = 7

Rotation around Z-axis: $R_z(\theta) = e^{-i\theta Z/2}$.

RZX = 8

Ising ZX interaction gate.

RZZ = 9

Ising ZZ interaction gate.

S = 10

S gate (Phase gate, $\sqrt{Z}$).

SDG = 11

S-dagger gate ($S^\dagger$).

SWAP = 12

SWAP gate (exchanges states of two qubits).

T = 13

T gate ($\sqrt{S}$).

TDG = 14

T-dagger gate ($T^\dagger$).

U = 15

Generic single-qubit unitary $U(\theta, \phi, \lambda)$.

X = 16

Pauli-X gate (Bit-flip, NOT).

XY = 17

Single-qubit pi rotation about an axis in the XY plane.

X2P = 18

$\sqrt{X}$ gate (SX).

X2M = 19

$\sqrt{X}^\dagger$ gate (SXdg).

XY2P = 20

Positive half-pi single-qubit rotation about an axis in the XY plane.

XY2M = 21

Negative half-pi single-qubit rotation about an axis in the XY plane.

Y = 22

Pauli-Y gate (Bit-phase-flip).

Y2P = 23

$\sqrt{Y}$ gate.

Y2M = 24

$\sqrt{Y}^\dagger$ gate.

Z = 25

Pauli-Z gate (Phase-flip).

Phase = 26

Phase shift gate $P(\lambda)$.

GPhase = 27

Zero-qubit global phase marker.

GPhase is not applied to any qubit. Whole-circuit global phase should normally be represented by crate::circuit::Circuit::global_phase; GPhase operations are mainly useful as import or intermediate IR markers, including body-local phase inside control-flow operations.

CX = 28

Controlled-X gate (CNOT).

CCX = 29

Toffoli gate (Controlled-Controlled-X).

CY = 30

Controlled-Y gate.

CZ = 31

Controlled-Z gate.

CRX = 32

Controlled-RX rotation.

CRY = 33

Controlled-RY rotation.

CRZ = 34

Controlled-RZ rotation.

FSIM = 35

Fermionic Simulation gate (fSim).

Implementations

impl StandardGate

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

Returns the stable operation name used by circuit APIs and statistics.

pub fn all() -> &'static [Self]

Returns all standard gates in enum discriminant order.

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

Returns the unitary matrix representation of the gate.

The matrix is returned as a Cow<Array2<Complex<f64>>>.

• Returns Cow::Borrowed for static gates (like H, X, CX) to avoid allocation.
• Returns Cow::Owned for parametric gates (like RX, U) where the matrix is computed on the fly.

Arguments

• params - A slice of floating-point parameters associated with the gate. For non-parametric gates, this can be empty. For parametric gates, it must contain the correct number of values (e.g., 1 for RX, 3 for U).

Panics

Panics if params does not contain enough values for the specific gate type.

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

Computes the inverse (Hermitian conjugate) of the gate.

Arguments

• params - The parameters of the gate instance to be inverted.

Returns

Returns an Option containing a tuple:

• StandardGate: The type of the inverse gate.
• SmallVec<[Parameter; 3]>: The transformed parameters for the inverse gate.

Returns None if the inverse cannot be represented as a StandardGate (rare).

pub fn is_diagonal(&self) -> bool

Returns whether this gate is diagonal in the computational basis.

Diagonal standard gates preserve computational basis states and only change their phases. This is a structural property of the gate family, independent of concrete parameter values.

pub fn num_ctrl_qubits(&self) -> usize

Returns the number of control qubits defined for this gate.

For example:

• X -> 0
• CX -> 1
• CCX -> 2

pub fn num_qubits(&self) -> usize

Returns the total number of qubits this gate acts on (controls + targets).

For example:

• X -> 1
• CX -> 2 (1 control + 1 target)
• SWAP -> 2

pub fn num_params(&self) -> usize

Returns the number of floating-point parameters this gate accepts.

For example:

• H -> 0
• RX -> 1
• U -> 3

Trait Implementations

impl Clone for StandardGate

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StandardGate

impl Debug for StandardGate

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

Formats the value using the given formatter.

impl Default for StandardGate

fn default() -> Self

Returns the “default value” for a type.

impl Display for StandardGate

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

Formats the value using the given formatter.

impl Eq for StandardGate

impl From<StandardGate> for Instruction

fn from(g: StandardGate) -> Self

Converts to this type from the input type.

impl Hash for StandardGate

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for StandardGate

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for StandardGate

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for StandardGate

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for StandardGate