Struct Tableau 

pub struct Tableau<T: Config> {
    pub n_qubits: usize,
    pub data: Vec<PhasedPauliWord<T::Storage, T::BuildHasher, PauliWord<T::Storage, T::BuildHasher, false>>>,
    /* private fields */
}

A 2n-row stabilizer / destabilizer tableau.

Rows 0..n hold the destabilizers; rows n..2n hold the stabilizers. Each row is a PhasedPauliWord tracking both its X/Z bits and a phase in {±1, ±i}. Implements every Clifford-only operation natively (Hadamard, phase, CNOT, CZ, etc.).

Examples

use ppvm_pauli_sum::config::fxhash::ByteF64;
use ppvm_traits::traits::Clifford;
use ppvm_tableau::data::Tableau;

let mut tab: Tableau<ByteF64<1>> = Tableau::new(2);
tab.h(0);
tab.cnot(0, 1);
assert_eq!(tab.n_qubits, 2);
assert_eq!(tab.stabilizers().len(), 2);

Fields

n_qubits: usize

Number of qubits.

data: Vec<PhasedPauliWord<T::Storage, T::BuildHasher, PauliWord<T::Storage, T::BuildHasher, false>>>

Destabilizer / Stabilizer tableau

• Entries 0..n are the destabilizers
• Entries n..2n are the stabilizers

Implementations

impl<T: Config> Tableau<T>

pub fn new(n_qubits: usize) -> Self

Construct a fresh tableau initialised to |0…0⟩.

pub fn new_with_seed(n_qubits: usize, seed: u64) -> Self

Same as Tableau::new, but seed the RNG deterministically.

pub fn reset_all(&mut self)

pub fn stabilizers( &self, ) -> &[PhasedPauliWord<T::Storage, T::BuildHasher, PauliWord<T::Storage, T::BuildHasher, false>>]

View of the stabilizer rows (the upper half of the tableau).

pub fn stabilizers_mut( &mut self, ) -> &mut [PhasedPauliWord<T::Storage, T::BuildHasher, PauliWord<T::Storage, T::BuildHasher, false>>]

Mutable view of the stabilizer rows.

pub fn destabilizers( &self, ) -> &[PhasedPauliWord<T::Storage, T::BuildHasher, PauliWord<T::Storage, T::BuildHasher, false>>]

View of the destabilizer rows (the lower half of the tableau).

pub fn destabilizers_mut( &mut self, ) -> &mut [PhasedPauliWord<T::Storage, T::BuildHasher, PauliWord<T::Storage, T::BuildHasher, false>>]

Mutable view of the destabilizer rows.

pub fn cz_block_pairs(&mut self, base: usize, offset: usize, count: usize)

where <<T::Storage as BitView>::Store as TryFrom<usize>>::Error: Debug, <T::Storage as BitView>::Store: PrimInt + TryFrom<usize>,

Apply CZ to N pairs with constant offset: (base+i, base+offset+i) for i in 0..count. All pairs must be in the same u64 word. This replaces N individual CZ calls with a single word-level shift+XOR operation per row.

Preconditions

The fused kernel needs offset >= count, i.e. pairwise-disjoint supports (pairs i != j collide iff |i - j| == offset, which needs offset < count, or offset == 0). Both fused updates need it: the single count_ones() & 1 phase reads the pre-update z plane for every pair at once (Batch.lean::czSeq_phase proves it equal to the sequential loop only under pairwise disjointness, and czSeq_phase_needs_disjoint exhibits a counterexample), and the z delta ORs the two shifted planes, so a z bit written by two pairs is set once instead of XOR-cancelled.

Overlapping pairs (offset < count, including offset == 0) fall back to the per-pair cz loop, so this method is safe in release.

Panics

Debug-asserts that all bits are within the same word.

pub fn cz_block_pairs_cross_word( &mut self, word_c: usize, base_bit_c: usize, word_t: usize, base_bit_t: usize, count: usize, )

where <T::Storage as BitView>::Store: PrimInt,

Apply CZ to N pairs with constant offset across two different words. Controls at (word_c, base_bit_c+i) and targets at (word_t, base_bit_t+i) for i in 0..count. word_c and word_t must be different.

Trait Implementations

impl<T: Config> Clifford for Tableau<T>

where <T::Storage as BitView>::Store: PrimInt,

fn x(&mut self, index: usize)

Apply Pauli X to one qubit.

fn y(&mut self, index: usize)

Apply Pauli Y to one qubit.

fn z(&mut self, index: usize)

Apply Pauli Z to one qubit.

fn h(&mut self, index: usize)

Apply Hadamard H to one qubit.

fn s(&mut self, index: usize)

Apply phase gate S to one qubit.

fn cnot(&mut self, control: usize, target: usize)

Apply CNOT to one (control, target) pair.

fn cz(&mut self, control: usize, target: usize)

Apply CZ to one qubit pair.

fn cx(&mut self, control: usize, target: usize)

stim alias for cnot.

fn zcx(&mut self, control: usize, target: usize)

stim alias for cnot.

fn zcz(&mut self, addr0: usize, addr1: usize)

stim alias for cz.

impl<T: Config> CliffordBatch for Tableau<T>

where <T::Storage as BitView>::Store: PrimInt,

fn x_many(&mut self, indices: &[usize])

X is bit-preserving: phase flips for each masked qubit where z=1.

fn y_many(&mut self, indices: &[usize])

Y is bit-preserving: phase flips for each masked qubit where x⊕z=1.

fn z_many(&mut self, indices: &[usize])

Z is bit-preserving: phase flips for each masked qubit where x=1.

fn s_many(&mut self, indices: &[usize])

Forward S: phase flips where x&z=1, then z ^= x for masked qubits.

fn cnot_many(&mut self, pairs: &[(usize, usize)])

Apply CNOT to many pairs, operating on raw storage words to avoid per-bit bitvec addressing. Pairs are applied sequentially per row, so semantics match the per-pair cnot loop exactly.

fn h_many(&mut self, indices: &[usize])

Apply H to multiple qubits using combined bitmask operations. H swaps x<->z bits (same as sqrt_y) but with different phase: phase += 2 when x=1 & z=1 (Y goes to -Y).

fn cz_many(&mut self, pairs: &[(usize, usize)])

Apply CZ to many pairs on raw storage words. CZ is symmetric and touches only z-bits; pairs are applied sequentially per row, so semantics match the per-pair cz loop exactly.

impl<T: Config> CliffordExtensions for Tableau<T>

where <T::Storage as BitView>::Store: PrimInt,

fn s_dag(&mut self, index: usize)

Apply S† to one qubit.

fn sqrt_x(&mut self, index: usize)

Apply √X to one qubit.

fn sqrt_x_dag(&mut self, index: usize)

Apply (√X)† to one qubit.

fn sqrt_y(&mut self, index: usize)

Apply √Y to one qubit.

fn sqrt_y_dag(&mut self, index: usize)

Apply (√Y)† to one qubit.

fn cy(&mut self, control: usize, target: usize)

Apply CY to one (control, target) pair.

fn zcy(&mut self, control: usize, target: usize)

stim alias for cy.

impl<T: Config> CliffordExtensionsBatch for Tableau<T>

where <T::Storage as BitView>::Store: PrimInt,

fn s_dag_many(&mut self, indices: &[usize])

Backward S (i.e. S†): same bit mapping as S, phase rule differs. Phase flips where x&!z=1, then z ^= x for masked qubits.

fn cy_many(&mut self, pairs: &[(usize, usize)])

Apply CY to many pairs on raw storage words. Pairs are applied sequentially per row, so semantics match the per-pair cy loop exactly.

fn sqrt_y_many(&mut self, indices: &[usize])

Apply √Y to multiple qubits using combined bitmask operations. All qubits targeting the same word are merged into a single mask, reducing N individual operations to O(n_words) per row.

fn sqrt_y_dag_many(&mut self, indices: &[usize])

Apply (√Y)† to multiple qubits using combined bitmask operations.

fn sqrt_x_many(&mut self, indices: &[usize])

Apply √X to multiple qubits using combined bitmask operations.

fn sqrt_x_dag_many(&mut self, indices: &[usize])

Apply (√X)† to multiple qubits using combined bitmask operations.

impl<T: Clone + Config> Clone for Tableau<T>

where T::Storage: Clone, T::BuildHasher: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Config> Debug for Tableau<T>

where T::Storage: Debug, T::BuildHasher: Debug,

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

Formats the value using the given formatter.

impl<T: Config> Depolarizing2<T> for Tableau<T>

where T::Coeff: PartialOrd<f64>, <T::Storage as BitView>::Store: PrimInt,

fn depolarize2(&mut self, addr0: usize, addr1: usize, p: T::Coeff)

Depolarize one qubit pair with probability p.

fn depolarize2_many( &mut self, pairs: &[(usize, usize)], p: <T as Config>::Coeff, )

Explicit batched two-qubit depolarizing channel.

impl<T: Config> Depolarizing<T> for Tableau<T>

where T::Coeff: PartialOrd<f64>, <T::Storage as BitView>::Store: PrimInt,

fn depolarize1(&mut self, addr0: usize, p: T::Coeff)

Depolarize one qubit with probability p.

fn depolarize1_many(&mut self, targets: &[usize], p: <T as Config>::Coeff)

Explicit batched single-qubit depolarizing channel.

impl<T: Config> Display for Tableau<T>

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

Formats the value using the given formatter.

impl<T: Config> Measure for Tableau<T>

where <<T as Config>::Storage as BitView>::Store: PrimInt,

fn measure(&mut self, addr0: usize) -> bool

Measure qubit addr0 in Z basis

impl<T: Config> PauliError<T> for Tableau<T>

where T::Coeff: PartialOrd<f64>, <T::Storage as BitView>::Store: PrimInt,

fn pauli_error(&mut self, addr0: usize, p: [T::Coeff; 3])

Apply a Pauli-error channel [p_x, p_y, p_z] to one qubit.

fn x_error(&mut self, addr0: usize, p: <T as Config>::Coeff)

stim X_ERROR(p) — apply X with probability p to one qubit.

fn y_error(&mut self, addr0: usize, p: <T as Config>::Coeff)

stim Y_ERROR(p) — apply Y with probability p to one qubit.

fn z_error(&mut self, addr0: usize, p: <T as Config>::Coeff)

stim Z_ERROR(p) — apply Z with probability p to one qubit.

fn pauli_error_many(&mut self, targets: &[usize], p: [<T as Config>::Coeff; 3])

Explicit batched Pauli-error channel.

fn x_error_many(&mut self, targets: &[usize], p: <T as Config>::Coeff)

Explicit batched X_ERROR(p).

fn y_error_many(&mut self, targets: &[usize], p: <T as Config>::Coeff)

Explicit batched Y_ERROR(p).

fn z_error_many(&mut self, targets: &[usize], p: <T as Config>::Coeff)

Explicit batched Z_ERROR(p).

impl<T: Config> Reset for Tableau<T>

where <<T as Config>::Storage as BitView>::Store: PrimInt,

fn reset(&mut self, addr0: usize)

Reset one qubit to |0⟩ (stim R/RZ).

fn reset_z(&mut self, addr0: usize)

stim RZ alias — reset to |0⟩.

fn reset_x(&mut self, addr0: usize)

stim RX — reset to |+⟩.

fn reset_y(&mut self, addr0: usize)

stim RY — reset to |i⟩.

fn reset_many(&mut self, targets: &[usize])

Explicit batched reset to |0⟩.

fn reset_z_many(&mut self, targets: &[usize])

Explicit batched RZ alias.

fn reset_x_many(&mut self, targets: &[usize])

Explicit batched RX.

fn reset_y_many(&mut self, targets: &[usize])

Explicit batched RY.

impl<T: Config> TableauLike for Tableau<T>

where T::Coeff: PartialOrd<f64>, <T::Storage as BitView>::Store: PrimInt,

type Coeff = <T as Config>::Coeff

Coefficient type used for probabilities.

type Rng = SmallRng

RNG type backing the stochastic channels.

fn rng_mut(&mut self) -> &mut Self::Rng

Mutable access to the backend’s RNG.

fn is_qubit_lost(&self, _addr: usize) -> bool

Whether the qubit at addr is inactive (lost or leaked), so the Pauli noise channels skip it. Default: never inactive.

fn depolarize_impl(&mut self, addr0: usize, p: Self::Coeff)

Single-qubit depolarizing channel.

fn pauli_error_impl(&mut self, addr0: usize, p: [Self::Coeff; 3])

Single-qubit Pauli-error channel (X, Y, Z with given probabilities).

fn two_qubit_pauli_error_impl( &mut self, addr0: usize, addr1: usize, p: [Self::Coeff; 15], )

Two-qubit Pauli-error channel (15 non-identity Pauli combinations).

fn depolarize2_impl(&mut self, addr0: usize, addr1: usize, p: Self::Coeff)

Two-qubit depolarizing channel: spreads p over the 15 non-identity two-qubit Pauli errors.

impl<T: Config> TwoQubitPauliError<T> for Tableau<T>

where T::Coeff: PartialOrd<f64>, <T::Storage as BitView>::Store: PrimInt,

fn two_qubit_pauli_error( &mut self, addr0: usize, addr1: usize, p: [T::Coeff; 15], )

Apply a two-qubit Pauli-error channel to one pair. Probabilities are given in the order: {IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}.

fn two_qubit_pauli_error_many( &mut self, pairs: &[(usize, usize)], p: [<T as Config>::Coeff; 15], )

Explicit batched two-qubit Pauli-error channel.