Struct GeneralizedTableau 

pub struct GeneralizedTableau<T: Config, IndexType = usize, SparseVectorType: SparseVector<Complex<T::Coeff>, IndexType> = Vec<(Complex64, IndexType)>> {
    pub tableau: Tableau<T>,
    pub coefficients: SparseVectorType,
    pub qubit_status: Vec<QubitStatus>,
    pub coefficient_threshold: T::Coeff,
    pub measurement_record: Vec<Option<bool>>,
    /* private fields */
}

A Tableau extended with sparse coefficient tracking to handle non-Clifford gates.

Non-Clifford gates (T, rotations) split a single tableau into a sum of weighted branches indexed by bitstrings. GeneralizedTableau stores those weights in a SparseVector keyed by an IndexType. Choose:

• IndexType = usize for up to 64 qubits,
• IndexType = u128 for up to 128,
• IndexType = bnum::types::U256 and friends for the very wide regime.

Per-qubit status (loss / leakage) is tracked in qubit_status; gates skip any qubit that is not QubitStatus::Live.

Examples

Prepare a Bell pair and sample one shot. With a fixed seed the two measurements are perfectly correlated on every shot:

use ppvm_pauli_sum::config::fxhash::ByteF64;
use ppvm_traits::traits::{Clifford, LossyMeasure};
use ppvm_tableau::data::GeneralizedTableau;

let mut tab: GeneralizedTableau<ByteF64<1>> =
    GeneralizedTableau::new_with_seed(2, 1e-12, 0);
tab.h(0);
tab.cnot(0, 1);

let r0 = LossyMeasure::measure(&mut tab, 0);
let r1 = LossyMeasure::measure(&mut tab, 1);
assert_eq!(r0, r1);

Non-Clifford gates work through the same interface — apply a T gate followed by T† and the state is unchanged:

use ppvm_pauli_sum::config::fxhash::ByteF64;
use ppvm_traits::traits::{Clifford, TGate};
use ppvm_tableau::data::GeneralizedTableau;

let mut tab: GeneralizedTableau<ByteF64<1>> =
    GeneralizedTableau::new_with_seed(1, 1e-12, 0);
tab.h(0);
tab.t(0);
tab.t_dag(0);
// T followed by T† is the identity; the |+⟩ state is restored.

Fields

tableau: Tableau<T>

Underlying Clifford tableau.

coefficients: SparseVectorType

Sparse coefficient vector indexed by bitstrings.

qubit_status: Vec<QubitStatus>

Per-qubit status relative to the computational subspace.

coefficient_threshold: T::Coeff

Coefficient-magnitude threshold below which branches are dropped.

measurement_record: Vec<Option<bool>>

Ordered log of every measurement performed (mirrors stim’s record).

Implementations

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> GeneralizedTableau<T, I, C>

where T::Coeff: One + Zero + Clone + Num, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + AddAssign + From<Complex64> + ComplexFloat + Copy, I: TableauIndex,

pub fn new(n_qubits: usize, coefficient_threshold: T::Coeff) -> Self

Construct a generalized tableau in the |0…0⟩ state.

Branches whose coefficient magnitude falls below coefficient_threshold are dropped during gate application.

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

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

pub fn reset_all(&mut self)

pub fn fork(&self, seed: Option<u64>) -> Self

Clone the quantum state but reinitialize the RNG, producing an independent simulation branch. If seed is Some, the new RNG is seeded deterministically; if None, it is seeded from OS entropy.

pub fn n_qubits(&self) -> usize

Number of qubits.

pub fn current_measurement_record(&self) -> &[Option<bool>]

All measurement outcomes recorded so far, in order.

pub fn append_measurement_record(&mut self, result: Option<bool>)

Append an externally defined measurement result to the record.

Used by Stim instructions such as MPAD, which append measurement record bits without measuring a qubit.

pub fn overwrite_last_measurement_record(&mut self, result: Option<bool>)

Replace the most recent measurement record entry.

Used by noisy measurement paths where the quantum state follows the true outcome but the public record should hold the reported bit.

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. Falls back to individual CZ calls if any qubit in the range is lost or leaked. Overlap (offset < count) is owned by Tableau::cz_block_pairs.

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 cross-word pairs. Controls at word_c, targets at word_t. Falls back to individual CZ calls if any qubit is lost or leaked.

pub fn cz_block( &mut self, control_base: usize, target_base: 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 count pairs with a constant offset, given in qubit-index terms: (control_base + i, target_base + i) for i in 0..count.

This is the high-level entry point for a fused block of CZs: it splits the run at storage-word boundaries internally and dispatches each segment to Self::cz_block_pairs (control and target in the same word) or Self::cz_block_pairs_cross_word (straddling two words), so callers never need to reason about the u64 packing. CZ is symmetric, so the two bases may be passed in either order.

Overlapping pairs — |target_base - control_base| < count, of which adjacent-pair brickwork cz_block(0, 1, n) is the extreme case — are handled: the same-word segments route through Self::cz_block_pairs into Tableau::cz_block_pairs, which falls back to the per-pair loop. A cross-word segment is always disjoint (its run never exceeds the offset), so the fused kernel stays live there.

pub fn compute_decomposition(&self, addr0: usize, pauli: Pauli) -> (u8, I, I)

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

Compute the decomposition of a pauli into stabilizer destabilizer products Any Pauli can be written as P_addr0 = phase * prod(d_k ^ gamma_k) * prod(s_l ^ lambda_l) where: gamma_k == 1 iff {P_addr0, s_k} = 0 lambda_l == 1 iff {P_addr0, d_l} = 0 Lemma 5. from T. J. Yoder (2012) NOTE: this is O(n^2)

The function returns (phase, stab_anticomm_bits, destab_anticomm_bits), where stab_anticomm_bits[k] = 1 iff P_addr0 anticommutes with stabilizer s_k, and destab_anticomm_bits[l] = 1 iff P_addr0 anticommutes with destabilizer d_l. Note that stab_anticomm_bits is equal to the shift of the index when branching (beta in Eq(4) of the SOFT paper).

pub fn odd_phase_destabilizer_mask(&self) -> I

Build a bitmask where bit i is set if destabilizer i has odd phase (phase % 2 != 0).

impl<T, I, C> GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

pub fn expectation<W: PauliWordTrait>(&self, word: &W) -> f64

⟨ψ|word|ψ⟩ for the multi-qubit Pauli word.

Conjugates word through the Clifford tableau (giving a Pauli on the canonical basis: an X-mask, Z-mask, and i^φ phase), then sums ⟨α|P_conj|β⟩ c_α* c_β over the sparse coefficient vector. Always returns a real number (Hermitian operator on a normalized state).

pub fn trace(&self, pattern: &PauliPattern) -> f64

Σ_{P matches pattern} ⟨ψ|P|ψ⟩.

Enumerates every PauliWord accepted by pattern via PauliPattern::enumerate_matches and sums their expectations. Star quantifiers (X*) panic — the pattern must be bounded; use counted repetition (Z?{n}) or positional anchors instead.

impl<T, I, C> GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

pub fn project_case_a( &mut self, outcome: bool, scratch: &mut MeasureScratch<I, T::Coeff>, phase_decomp: u8, stab_anticomm_bits: I, destab_anticomm_bits: I, addr0: usize, )

pub fn project_case_b( &mut self, entries: &[(Complex<T::Coeff>, I)], outcome: bool, phase_decomp: u8, destab_anticomm_bits: I, )

project state in case b (Z is a stabilizer) according to sampled outcome

impl<T, I, C> GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

pub fn measure_noisy(&mut self, addr0: usize, flip_prob: f64) -> Option<bool>

Measure qubit addr0 in Z basis with optional readout noise.

Behaves like measure, then with probability flip_prob flips the recorded bit. The qubit’s quantum state stays consistent with the true outcome — only the returned value flips. flip_prob = 0.0 is equivalent to measure.

If the qubit is lost, returns None regardless of flip_prob.

pub fn bernoulli(&mut self, p: f64) -> bool

Sample a Bernoulli(p) outcome using the tableau’s internal RNG. Used by Stim measurement-noise dispatch in ppvm-stim.

pub fn flip_with_prob(&mut self, bit: bool, p: f64) -> bool

Flip bit with probability p. Used by Stim MR/MPad readout-noise dispatch in ppvm-stim. Returns bit unchanged when p <= 0.0.

impl<T, I, C> GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

Measurement overlap helper functions, with optional rayon parallelism.

pub fn z_expectation(&self, addr0: usize) -> f64

⟨Z⟩ on qubit addr0, computed non-destructively (the state is not collapsed). Reuses the measurement overlap machinery; cost scales with the number of coefficients (and n²).

pub fn compute_overlap_case_b( entries: &[(Complex<T::Coeff>, I)], phase_decomp: u8, destab_anticomm_bits: I, ) -> f64

Case_b overlap: self-pairing (branch_index = idx), so overlap = ±|c|^2. Only even phases contribute to the real part. Divided by ⟨ψ|ψ⟩, since gate-time truncation leaves the state unnormalized.

pub fn compute_overlap_case_a( coeff_map: &HashMap<I, Complex<T::Coeff>>, phase_decomp: u8, destab_anticomm_bits: I, stab_anticomm_bits: I, odd_phase_mask: I, ) -> f64

Case_a overlap: cross-index pairing via HashMap lookup. Accumulates only the real part of z_overlap. Divided by ⟨ψ|ψ⟩, since gate-time truncation leaves the state unnormalized.

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> GeneralizedTableau<T, I, C>

pub fn is_inactive(&self, addr0: usize) -> bool

Whether qubit addr0 is outside the computational subspace — either lost or leaked. Gates skip such qubits.

pub fn is_lost(&self, addr0: usize) -> bool

Whether qubit addr0 is lost. Measurement of a lost qubit returns None.

pub fn is_leaked(&self, addr0: usize) -> bool

Whether qubit addr0 is leaked. Measurement of a leaked qubit returns the pinned computational bit.

impl<T, I, C> GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

pub fn measure_all_with_scratch( &mut self, scratch: &mut MeasureScratch<I, T::Coeff>, ) -> Vec<Option<bool>>

Same as LossyMeasureAll::measure_all, but the caller supplies a MeasureScratch that’s reused across the n per-qubit measurements (and, if the caller chooses, across many invocations / shots).

This is the entry point samplers should use when running many shots: initialize one scratch alongside the sampler and thread it through every shot to amortize the case-a HashMap and b_entries allocations.

pub fn measure_many_with_scratch( &mut self, indices: &[usize], scratch: &mut MeasureScratch<I, T::Coeff>, ) -> Vec<Option<bool>>

Measure the given qubit indices in order, reusing a caller-supplied MeasureScratch across the per-index measurements (and, if the caller chooses, across many invocations / shots) — the explicit-index analogue of measure_all_with_scratch. This is the scratch-reusing engine behind the tableau’s LossyMeasure::measure_many override (in measure.rs), which the Stim executor and the Python measure_many binding both go through.

Trait Implementations

impl<T: Config, I, C> AsymmetricLossChannel<T> for GeneralizedTableau<T, I, C>

where <<T as Config>::Storage as BitView>::Store: PrimInt, C: Debug + SparseVector<Complex<T::Coeff>, I>, T::Coeff: PartialOrd<f64> + One + Zero + Clone + Num + ToPrimitive + Debug + Send + Sync, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: Debug + TableauIndex + Send + Sync,

fn asymmetric_loss_channel(&mut self, addr0: usize, p0: T::Coeff, p1: T::Coeff)

State-dependent single-qubit loss (“asymmetric loss”).

Models a three-level atom whose |0⟩ and |1⟩ levels leak into a loss state |L⟩ at different rates: the qubit is lost from |0⟩ with probability p0 and from |1⟩ with p1. The total loss probability is state-dependent,

    p_tot = p0 * (1 + ⟨Z⟩)/2 + p1 * (1 - ⟨Z⟩)/2,

with ⟨Z⟩ the current Z-expectation of addr0. With probability p_tot the qubit is collapsed, reset to |0⟩, and marked lost (as in LossChannel::loss_channel); otherwise it is left unchanged.

Approximation

This is the trajectory approximation of the true loss channel. It reproduces the loss statistics (which qubits are flagged lost, and how often) and is exact in the symmetric limit p0 == p1, where it reduces to LossChannel::loss_channel. It does NOT apply the survival back-action K0 = sqrt(1-p0)|0⟩⟨0| + sqrt(1-p1)|1⟩⟨1|: for p0 != p1 the faithful channel reshapes the surviving qubit (population tilts toward the less-leaky level, coherences are damped), and this implementation skips that reshaping. The back-action is non-Clifford (it branches the coefficient vector like an rz), so it is omitted to keep the channel cheap enough to apply after every gate. See issue #39.

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> Clifford for GeneralizedTableau<T, I, C>

where Complex<<T as Config>::Coeff>: From<Complex<f64>>, <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, I, C: SparseVector<Complex<T::Coeff>, I>> CliffordBatch for GeneralizedTableau<T, I, C>

where Complex<<T as Config>::Coeff>: From<Complex<f64>>, <T::Storage as BitView>::Store: PrimInt,

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

Apply Pauli X to every qubit in indices.

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

Apply Pauli Y to every qubit in indices.

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

Apply Pauli Z to every qubit in indices.

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

Apply Hadamard H to every qubit in indices.

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

Apply phase gate S to every qubit in indices.

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

Apply CNOT to every (control, target) pair.

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

Apply CZ to every (control, target) pair.

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> CliffordExtensions for GeneralizedTableau<T, I, C>

where Complex<<T as Config>::Coeff>: From<Complex<f64>>, <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, I, C: SparseVector<Complex<T::Coeff>, I>> CliffordExtensionsBatch for GeneralizedTableau<T, I, C>

where Complex<<T as Config>::Coeff>: From<Complex<f64>>, <T::Storage as BitView>::Store: PrimInt,

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

Apply S† to every qubit in indices.

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

Apply √X to every qubit in indices.

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

Apply (√X)† to every qubit in indices.

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

Apply √Y to every qubit in indices.

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

Apply (√Y)† to every qubit in indices.

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

Apply CY to every (control, target) pair.

impl<T: Clone + Config, IndexType: Clone, SparseVectorType: Clone + SparseVector<Complex<T::Coeff>, IndexType>> Clone for GeneralizedTableau<T, IndexType, SparseVectorType>

where T::Coeff: 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: Config, I, C> CorrelatedLossChannel<T> for GeneralizedTableau<T, I, C>

where <<T as Config>::Storage as BitView>::Store: PrimInt, C: Debug + SparseVector<Complex<T::Coeff>, I>, T::Coeff: PartialOrd<f64> + One + Zero + Clone + Num + ToPrimitive + Debug + Send + Sync, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: Debug + TableauIndex + Send + Sync,

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

Apply a correlated loss channel to qubits at addr0 and addr1.

The three probabilities are:

• p[0]: The probability of losing both qubits simultaneously when both of them are in the qubit subspace.
• p[1]: The probability of losing a named one of the two qubits when both of them are in the qubit subspace, so the probability of losing exactly one is 2·p[1] and the both-present survivor keeps 1 − 2·p[1] − p[0] (which qubit is lost is 50/50). See ppvm_traits::traits::CorrelatedLossChannel for the normative statement.
• p[2]: The probability of losing one qubit when the other one has already been lost prior to the channel.

impl<T: Config, I: TableauIndex, C: SparseVector<Complex<T::Coeff>, I>> Depolarizing2<T> for GeneralizedTableau<T, I, C>

where T::Coeff: PartialOrd<f64>, Complex<T::Coeff>: From<Complex<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, I: TableauIndex, C: SparseVector<Complex<T::Coeff>, I>> Depolarizing<T> for GeneralizedTableau<T, I, C>

where T::Coeff: PartialOrd<f64>, Complex<T::Coeff>: From<Complex<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, I, C: SparseVector<Complex<T::Coeff>, I>> Display for GeneralizedTableau<T, I, C>

where Complex<T::Coeff>: Display, <T as Config>::Coeff: Num, I: TableauIndex + Display, <I as BitAnd<<I as Shl<usize>>::Output>>::Output: PartialEq<I>,

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

Formats the value using the given formatter.

impl<T: Config, I, C> LeakageChannel<T> for GeneralizedTableau<T, I, C>

where <<T as Config>::Storage as BitView>::Store: PrimInt, C: Debug + SparseVector<Complex<T::Coeff>, I>, T::Coeff: PartialOrd + PartialOrd<f64> + One + Zero + Clone + Num + ToPrimitive + Debug, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: Debug + TableauIndex,

fn leakage_channel(&mut self, addr0: usize, p0: T::Coeff, p1: T::Coeff)

Apply leakage to qubit addr0, with p0 / p1 the probabilities of leaking into |0⟩ / |1⟩.

impl<T: Config, I, C> LossChannel<T> for GeneralizedTableau<T, I, C>

where <<T as Config>::Storage as BitView>::Store: PrimInt, C: Debug + SparseVector<Complex<T::Coeff>, I>, T::Coeff: PartialOrd<f64> + One + Zero + Clone + Num + ToPrimitive + Debug + Send + Sync, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: Debug + TableauIndex + Send + Sync,

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

Apply a loss channel to qubit addr0 with loss probability p.

impl<T, I, C> LossyMeasure for GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

fn measure_many(&mut self, targets: &[usize]) -> Vec<Option<bool>>

Override the trait default (a per-target measure loop, which allocates a fresh MeasureScratch on every call) with a single scratch reused across the whole batch, amortizing the case-a HashMap / b_entries allocations and the cached odd-phase-destabilizer mask. Outcomes, the measurement record, and the RNG-draw order are identical to measuring each target individually — only the internal allocation pattern changes.

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

Measure qubit addr0. Returns Some(bit) for an in-subspace outcome, or None if the qubit has been lost.

impl<T, I, C> LossyMeasureAll for GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy, I: TableauIndex + Debug,

fn measure_all(&mut self) -> Vec<Option<bool>>

impl<T: Config, I: TableauIndex, C: SparseVector<Complex<T::Coeff>, I>> PauliError<T> for GeneralizedTableau<T, I, C>

where T::Coeff: PartialOrd<f64>, Complex<T::Coeff>: From<Complex<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, I, C> Reset for GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, I: TableauIndex + Debug, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy,

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, I, C> ResetLeakageChannel<T> for GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, I: TableauIndex + Debug, C: SparseVector<Complex<T::Coeff>, I> + Debug, T::Coeff: One + Zero + Clone + Num + ToPrimitive + Debug + Mul<f64> + PartialOrd<f64>, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + From<Complex64> + MulAssign + AddAssign + One + ComplexFloat + Copy,

fn reset_leakage_channel(&mut self, addr0: usize)

Clear leakage at addr0 and reset the qubit to |0⟩.

impl<T: Config, I: TableauIndex, C: SparseVector<Complex<T::Coeff>, I>> ResetLossChannel<T> for GeneralizedTableau<T, I, C>

fn reset_loss_channel(&mut self, addr0: usize)

Clear the loss bit at addr0.

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> RotXY<T> for GeneralizedTableau<T, I, C>

where GeneralizedTableau<T, I, C>: RotationOne<T>,

fn r(&mut self, addr0: usize, axis_angle: T::Coeff, theta: T::Coeff)

R(axis_angle, θ) on qubit addr0.

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> RotationOne<T> for GeneralizedTableau<T, I, C>

where <<T as Config>::Storage as BitView>::Store: PrimInt, T::Coeff: Zero + One + Send + Sync + Num + PartialOrd, I: TableauIndex + Send + Sync, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + AddAssign + From<Complex64> + ComplexFloat + Copy,

fn rotate_1(&mut self, axis: Pauli, addr0: usize, theta: <T as Config>::Coeff)

Rotate about axis (one of X, Y, Z) by angle theta.

fn rx(&mut self, addr0: usize, theta: impl Into<<T as Config>::Coeff>)

RX(θ) on one qubit.

fn ry(&mut self, addr0: usize, theta: impl Into<<T as Config>::Coeff>)

RY(θ) on one qubit.

fn rz(&mut self, addr0: usize, theta: impl Into<<T as Config>::Coeff>)

RZ(θ) on one qubit.

fn rx_many(&mut self, targets: &[usize], theta: impl Into<<T as Config>::Coeff>)

Explicit batched RX(θ).

fn ry_many(&mut self, targets: &[usize], theta: impl Into<<T as Config>::Coeff>)

Explicit batched RY(θ).

fn rz_many(&mut self, targets: &[usize], theta: impl Into<<T as Config>::Coeff>)

Explicit batched RZ(θ).

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> RotationTwo<T> for GeneralizedTableau<T, I, C>

where <<T as Config>::Storage as BitView>::Store: PrimInt, T::Coeff: Zero + One + Send + Sync + Num + PartialOrd, I: TableauIndex + Send + Sync, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + AddAssign + From<Complex64> + ComplexFloat + Copy,

fn rotate_2( &mut self, axis_a: [u8; 2], axis_b: [u8; 2], a: usize, b: usize, theta: <T as Config>::Coeff, )

Two-qubit Pauli rotation: exp(-i * theta/2 * P_a ⊗ P_b).

fn rxx(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · X_a X_b).

fn rxx_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [rxx].

fn rxy(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · X_a Y_b).

fn rxy_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [rxy].

fn rxz(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · X_a Z_b).

fn rxz_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [rxz].

fn ryx(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · Y_a X_b).

fn ryx_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [ryx].

fn ryy(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · Y_a Y_b).

fn ryy_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [ryy].

fn ryz(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · Y_a Z_b).

fn ryz_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [ryz].

fn rzx(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · Z_a X_b).

fn rzx_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [rzx].

fn rzy(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · Z_a Y_b).

fn rzy_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [rzy].

fn rzz(&mut self, a: usize, b: usize, theta: impl Into<<T as Config>::Coeff>)

exp(-i θ/2 · Z_a Z_b).

fn rzz_many( &mut self, pairs: &[(usize, usize)], theta: impl Into<<T as Config>::Coeff>, )

Explicit batched form of [rzz].

impl<T, I, C> TGate<T> for GeneralizedTableau<T, I, C>

where T: Config, <<T as Config>::Storage as BitView>::Store: PrimInt, C: SparseVector<Complex<T::Coeff>, I>, T::Coeff: One + Zero + Clone + Send + Sync + Num + PartialOrd, Complex<T::Coeff>: Mul<Output = Complex<T::Coeff>> + AddAssign + From<Complex64> + ComplexFloat + Copy, I: TableauIndex + Send + Sync, <I as BitAnd<<I as Shl<usize>>::Output>>::Output: PartialEq<I>,

fn t(&mut self, index: usize)

Apply T (diag(1, e^{iπ/4})) to one qubit.

fn t_dag(&mut self, index: usize)

Apply T† to one qubit.

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

Explicit batched T.

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

Explicit batched T†.

impl<T: Config, I: TableauIndex, C: SparseVector<Complex<T::Coeff>, I>> TableauLike for GeneralizedTableau<T, I, C>

where T::Coeff: PartialOrd<f64>, Complex<T::Coeff>: From<Complex<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, I: TableauIndex, C: SparseVector<Complex<T::Coeff>, I>> TwoQubitPauliError<T> for GeneralizedTableau<T, I, C>

where T::Coeff: PartialOrd<f64>, Complex<T::Coeff>: From<Complex<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.

impl<T: Config, I, C: SparseVector<Complex<T::Coeff>, I>> U3Gate<T> for GeneralizedTableau<T, I, C>

where GeneralizedTableau<T, I, C>: RotationOne<T>,

fn u3(&mut self, addr0: usize, theta: T::Coeff, phi: T::Coeff, lambda: T::Coeff)

Apply U3(θ, φ, λ) to qubit addr.