Enum QuantumGate 

pub enum QuantumGate {
    PauliX,
    PauliY,
    PauliZ,
    RotationX(Param),
    RotationY(Param),
    RotationZ(Param),
    Phase(Param),
    Hadamard,
}

The fundamental set of single-qubit quantum gates supported by the compiler.

Each variant corresponds to a standard gate from the universal gate set. Rotation gates carry a Param that encodes the rotation angle in radians.

Variants

PauliX

The Pauli-X (bit-flip) gate.

PauliY

The Pauli-Y gate.

PauliZ

The Pauli-Z (phase-flip) gate.

RotationX(Param)

Rotation about the X-axis by angle θ: Rx(θ) = exp(-i θ/2 · X).

RotationY(Param)

Rotation about the Y-axis by angle θ: Ry(θ) = exp(-i θ/2 · Y).

RotationZ(Param)

Rotation about the Z-axis by angle θ: Rz(θ) = exp(-i θ/2 · Z).

Phase(Param)

Phase gate: P(λ) = diag(1, e^{iλ}).

Hadamard

The Hadamard gate.

Implementations

impl QuantumGate

pub fn is_permutation(&self) -> bool

Returns true if the gate acts as a permutation of computational-basis states (including X-rotations by ±π).

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

Returns the parameter index and multiplier if this gate holds a Param::Ref (i.e., a symbolic variational parameter).

Returns Some((index, multiplier)) for RotationX, RotationY, RotationZ, and Phase variants whose parameter is a Param::Ref. Returns None for all other gates or when the parameter is a concrete Param::Value.

Used by the parameter-shift rule to identify which gate instructions correspond to a given parameter index.

pub const fn is_diagonal(&self) -> bool

Returns true if the gate is diagonal in the computational basis.

pub fn inverse(&self) -> Self

Returns the adjoint (Hermitian conjugate / inverse) of this gate.

pub fn propriety(&self) -> GatePropriety

Classifies the gate according to its action on the computational basis.

pub const fn s() -> Self

Constructs an S gate (Phase(π/2)).

pub fn sd() -> Self

Constructs an S† gate (Phase(-π/2)).

pub const fn t() -> Self

Constructs a T gate (Phase(π/4)).

pub fn td() -> Self

Constructs a T† gate (Phase(-π/4)).

pub const fn sqrt_t() -> Self

Constructs a √T gate (Phase(π/8)).

pub fn sqrt_td() -> Self

Constructs a √T† gate (Phase(-π/8)).

pub fn merge(&self, other: &Self) -> Option<Self>

Attempts to merge two consecutive same-type rotation gates into one.

Returns Some(merged) when both gates are the same rotation axis and their parameters can be added (see Param::add), or None otherwise.

pub fn is_near_zero(&self, epsilon: f64) -> bool

Returns true if the gate’s rotation angle is within epsilon of zero, making it effectively the identity.

Only parametric gates (Rotation* and Phase) can be near zero; non-parametric gates always return false.

pub fn set_parameter(&self, parameters: &[f64]) -> Self

Binds all symbolic parameters in this gate to their concrete values.

For non-parametric gates (PauliX, PauliY, PauliZ, Hadamard) this is a no-op and returns a copy of self. For parametric gates the Param is resolved via Param::set_parameter.

Trait Implementations

impl Clone for QuantumGate

fn clone(&self) -> QuantumGate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for QuantumGate

impl Debug for QuantumGate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QuantumGate

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for QuantumGate

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for QuantumGate

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 QuantumGate