Enum SimError 

#[non_exhaustive]
pub enum SimError {
    InvalidProbability(f64),
    InvalidProbabilityDistribution,
    InvalidRotationAngle(f64),
    EmptyStateAfterPruning {
        epsilon: f64,
    },
    RankOverflow {
        rank: usize,
        cap: usize,
    },
    PostselectImpossible {
        outcome: bool,
        probability: f64,
    },
    RepeatedQubit(usize),
    NonCommutingControlledPaulis,
    InvalidControlledPauli,
    NonHermitianPauli,
    MissingBatchRecord {
        index: usize,
    },
    QubitIndexOutOfRange {
        index: usize,
        num_qubits: usize,
    },
}

Errors returned by TableauSimulator operations.

Every variant models a condition the caller can provoke and reasonably handle; internal invariants (a decomposed net phase that is not real, a partner label missing from the amplitude map) are enforced with debug_assert! rather than surfaced here.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InvalidProbability(f64)

A probability was NaN or outside the inclusive unit interval.

InvalidProbabilityDistribution

A categorical channel had mismatched alternatives or total mass above one.

InvalidRotationAngle(f64)

A Pauli rotation angle was not finite.

EmptyStateAfterPruning

Pruning removed every amplitude and would produce a zero state.

Fields

epsilon: f64

The pruning threshold that erased the state.

RankOverflow

A Pauli rotation or measurement pushed the live-label count past the cap.

Stabilizer rank grows by at most a factor of two per T, so this bounds the exponential blow-up of magic-heavy circuits.

Fields

rank: usize

Live-label count that triggered the overflow.

cap: usize

The live-label ceiling in force.

PostselectImpossible

A forced measurement outcome has (numerically) zero probability, so the requested post-selection is unreachable from the current state.

Fields

outcome: bool

The requested (impossible) outcome.

probability: f64

Probability the engine computed for it.

RepeatedQubit(usize)

A multi-qubit gate or Clifford support received one qubit more than once.

NonCommutingControlledPaulis

A controlled-Pauli operation requires commuting control and target axes.

InvalidControlledPauli

A controlled Pauli carries a sign or phase this API does not represent: conditioning on −P is a different operation, not a global phase.

NonHermitianPauli

A measurement or rotation axis has an imaginary coefficient, so it is not an observable.

MissingBatchRecord

A batched conditional Pauli named a measurement its own batch has not produced. Records are indexed from the start of the batch, so this is a malformed instruction stream rather than a state the run reached.

Fields

index: usize

The out-of-range record index.

QubitIndexOutOfRange

A read-only observable names a qubit outside the live register.

Fields

index: usize

Largest out-of-range support index.

num_qubits: usize

Live simulator width.

Trait Implementations

impl Clone for SimError

fn clone(&self) -> SimError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimError

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

Formats the value using the given formatter.

impl Display for SimError

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

Formats the value using the given formatter.

impl Error for SimError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl PartialEq for SimError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SimError