Struct StabilizerTableau 

pub struct StabilizerTableau { /* private fields */ }

Stabilizer tableau representation

The tableau stores generators of the stabilizer group as rows. Each row represents a Pauli string with phase.

Phase encoding (Stim-compatible):

• 0 = +1
• 1 = +i
• 2 = -1
• 3 = -i

Implementations

impl StabilizerTableau

pub fn new(num_qubits: usize) -> Self

Create a new tableau in the |0…0⟩ state

pub fn with_format(num_qubits: usize, stim_format: bool) -> Self

Create a new tableau with specified Pauli string format

Arguments

• num_qubits - Number of qubits
• stim_format - Use Stim format (_ for identity) if true, standard format (I) if false

pub fn set_stim_format(&mut self, stim_format: bool)

Set the Pauli string format

pub const fn is_stim_format(&self) -> bool

Get the Pauli string format

pub fn apply_h(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply a Hadamard gate

H: X → Z, Z → X, Y → -Y Phase tracking: HYH = -Y, so Y component contributes i^2 = -1

pub fn apply_s(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply an S gate (phase gate)

S conjugation rules (SPS†):

• S: X → Y (no phase change, Pauli relabeling)
• S: Y → -X (phase negation due to SYS† = -X)
• S: Z → Z (no change)

Note: The i in Y = iXZ is a matrix identity, not relevant to stabilizer conjugation. In stabilizer formalism, X, Y, Z are atomic Pauli labels.

pub fn apply_cnot( &mut self, control: usize, target: usize, ) -> Result<(), QuantRS2Error>

Apply a CNOT gate

pub fn apply_x(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply a Pauli X gate

X anticommutes with Z and Y, commutes with X Phase: adds -1 when Z or Y is present on the qubit

pub fn apply_y(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply a Pauli Y gate

Y = iXZ, anticommutes with X and Z (separately), commutes with Y Phase: adds -1 when X XOR Z is present (pure X or pure Z, not Y)

pub fn apply_z(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply a Pauli Z gate

Z anticommutes with X and Y, commutes with Z Phase: adds -1 when X or Y is present on the qubit

pub fn apply_s_dag(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply S† (S-dagger) gate

S† conjugation rules (S†PS):

• S†: X → -Y (phase becomes -1)
• S†: Y → X (no phase change)
• S†: Z → Z (no change)

pub fn apply_sqrt_x(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply √X gate (SQRT_X, also called SX or V gate)

Conjugation rules:

• √X: X → X (no change)
• √X: Y → -Z (phase becomes -1)
• √X: Z → Y (no phase change)

pub fn apply_sqrt_x_dag(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply √X† gate (SQRT_X_DAG)

Conjugation rules:

• √X†: X → X (no change)
• √X†: Y → Z (no phase change)
• √X†: Z → -Y (phase becomes -1)

pub fn apply_sqrt_y(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply √Y gate (SQRT_Y)

Conjugation rules:

• √Y: X → Z (no phase change)
• √Y: Y → Y (no change)
• √Y: Z → -X (phase becomes -1)

pub fn apply_sqrt_y_dag(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Apply √Y† gate (SQRT_Y_DAG)

Conjugation rules:

• √Y†: X → -Z (phase becomes -1)
• √Y†: Y → Y (no change)
• √Y†: Z → X (no phase change)

pub fn apply_cz( &mut self, control: usize, target: usize, ) -> Result<(), QuantRS2Error>

Apply CZ (Controlled-Z) gate

CZ: X_c → X_c Z_t, X_t → Z_c X_t, Z_c → Z_c, Z_t → Z_t When both qubits have X component (product of X or Y), phase picks up -1

pub fn apply_cy( &mut self, control: usize, target: usize, ) -> Result<(), QuantRS2Error>

Apply CY (Controlled-Y) gate

pub fn apply_swap( &mut self, qubit1: usize, qubit2: usize, ) -> Result<(), QuantRS2Error>

Apply SWAP gate

pub fn measure(&mut self, qubit: usize) -> Result<bool, QuantRS2Error>

Measure a qubit in the computational (Z) basis Returns the measurement outcome (0 or 1)

For phases with imaginary components, we project onto real eigenvalues:

• Phase 0 (+1) or 1 (+i) → eigenvalue +1 → outcome 0
• Phase 2 (-1) or 3 (-i) → eigenvalue -1 → outcome 1

pub fn measure_x(&mut self, qubit: usize) -> Result<bool, QuantRS2Error>

Measure a qubit in the X basis (Stim MX instruction)

Equivalent to: H · measure_z · H

pub fn measure_y(&mut self, qubit: usize) -> Result<bool, QuantRS2Error>

Measure a qubit in the Y basis (Stim MY instruction)

Equivalent to: S† · H · measure_z · H · S

pub fn reset(&mut self, qubit: usize) -> Result<(), QuantRS2Error>

Reset a qubit to |0⟩ state (Stim R instruction)

Performs measurement and applies X if outcome is |1⟩

pub fn get_stabilizers(&self) -> Vec<String>

Get the current stabilizer generators as strings

Phase encoding in output:

• + for phase 0 (+1)
• +i for phase 1 (+i)
• - for phase 2 (-1)
• -i for phase 3 (-i)

Identity representation depends on stim_format:

• Standard format: I for identity
• Stim format: _ for identity

pub fn get_destabilizers(&self) -> Vec<String>

Get the current destabilizer generators as strings

Same format as get_stabilizers() but for destabilizers

Trait Implementations

impl Clone for StabilizerTableau

fn clone(&self) -> StabilizerTableau

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StabilizerTableau

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

Formats the value using the given formatter.