Enum ExecError 

#[non_exhaustive]
pub enum ExecError {
    IdOverflow(&'static str),
    BoundaryBindingExpansionLimit {
        limit: usize,
    },
    UnflattenedRepeat,
    UnknownCoord(IVec2),
    InvalidCircuit(NodeTemplateInstanceMergeError),
    InvalidProgram(BloqValidationError),
    DetectorBundle(DetectorBundleError),
    LogicalSignatureTooLarge {
        outputs: usize,
    },
    InvalidInjectionPatch {
        port: IVec3,
    },
    UnknownPreparationInput {
        port: IVec3,
    },
    InvalidCczPreparation,
    MissingRecord(u32),
    MissingRecordRemap(u32),
    EmptyMppProduct,
    UnresolvedLoopState(u32),
    BloqFlatten(FlattenError),
    CoordinateOverflow(CoordinateOverflowError),
    Cycle(CycleDetected),
    MalformedGraph(&'static str),
    DecodeObservableNotClosed {
        decode: u32,
        observable: u32,
        instance: u32,
        later: u32,
    },
    IncompatibleEarlyOutputReads {
        first: u32,
        second: u32,
        before: u32,
    },
    EarlyOutputGateUnavailable {
        observable: u32,
        before: u32,
    },
    Engine(SimError),
}

Failures on the noiseless physical-verification path.

That path is the run_bloq family, CircuitExecutor, and the shared program-preparation and output-closure analysis in front of them — which lower() also runs, and reports as LowerError::Analysis.

The dynamic causal runtime is the other execution engine in this crate and reports RuntimeError instead. Neither type is a superset of the other: this one covers exact execution and the static analysis in front of it, RuntimeError covers timing, retries, and mock decoding.

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.

IdOverflow(&'static str)

Dense physical-verification identifiers exhausted u32.

BoundaryBindingExpansionLimit

Expanding a complete physical readout’s binding DAG exceeded the verifier’s budget.

Fields

limit: usize

Maximum recipe visits and operator occurrences for one query.

UnflattenedRepeat

The circuit still contains an Op::Repeat; call CoordCircuit::flatten first.

UnknownCoord(IVec2)

A coordinate referenced by an op is absent from the coordinate layout.

InvalidCircuit(NodeTemplateInstanceMergeError)

A raw CoordCircuit failed the same structural preflight used for template emission.

InvalidProgram(BloqValidationError)

A required Bloq IR emission plan could not be materialized.

DetectorBundle(DetectorBundleError)

A shared detector use has an invalid bundle or owner binding.

LogicalSignatureTooLarge

The full logical Pauli signature does not fit the platform’s index width.

Fields

outputs: usize

Number of logical outputs requested.

InvalidInjectionPatch

Compact surface code injection requires one physical seed at the unique intersection of the input patch’s logical X and Z axes.

Fields

port: IVec3

Input port with invalid injection geometry.

UnknownPreparationInput

A deferred resource preparation named a port not present in the compiled program’s logical-input table.

Fields

port: IVec3

Unknown input port.

InvalidCczPreparation

A CCZ resource must bind three different logical input ports.

MissingRecord(u32)

A conditional Pauli / detector referenced a measurement id that has not been produced yet in this shot.

MissingRecordRemap(u32)

A merged circuit record has no local-to-global identity in the prepared program.

EmptyMppProduct

An MPP product was empty (no Paulis).

UnresolvedLoopState(u32)

A detector referenced a loop-carried state term that the flattened circuit did not resolve to concrete measurement records.

BloqFlatten(FlattenError)

Flattening Bloq IR failed.

CoordinateOverflow(CoordinateOverflowError)

An instance offset moves a template qubit outside the global i32 coordinate lattice.

Cycle(CycleDetected)

The bloq node graph has a cycle, so no deterministic emit order exists.

MalformedGraph(&'static str)

The bloq graph is structurally invalid for execution.

DecodeObservableNotClosed

A Decode’s named observable folds an Output-face boundary operator whose support a quantum node scheduled AFTER the decode’s cut touches: the operator has no unresolved-but-modeled frontier, so the decoder estimate computed at the cut would refer to a face the later node reopens/consumes — a wrong-time boundary. Unlike the terminal read, which closure::plan_early_output_reads moves in front of the consuming node, a decode cut has no fixture and stays rejected up front by guard_decode_observable_closure. observable is the Observable node id, decode/later are node ids, instance the boundary operator’s instance.

Fields

decode: u32

Decode node reading the observable.

observable: u32

Observable node being read.

instance: u32

Boundary-owning template instance.

later: u32

Later node touching the boundary.

IncompatibleEarlyOutputReads

Incompatible partial observable reads cannot be split across output cuts without destroying their joint correlations.

Fields

first: u32

First incompatible observable.

second: u32

Second incompatible observable.

before: u32

Node before which both reads are required.

EarlyOutputGateUnavailable

An exported boundary’s condition is unavailable before its output is consumed.

Fields

observable: u32

Observable whose gate is unavailable.

before: u32

Node requiring the early read.

Engine(SimError)

The engine raised an error mid-shot.

Trait Implementations

impl Debug for ExecError

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

Formats the value using the given formatter.

impl Display for ExecError

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

Formats the value using the given formatter.

impl Error for ExecError

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 From<BloqValidationError> for ExecError

fn from(source: BloqValidationError) -> Self

Converts to this type from the input type.

impl From<CoordinateOverflowError> for ExecError

fn from(source: CoordinateOverflowError) -> Self

Converts to this type from the input type.

impl From<CycleDetected> for ExecError

fn from(source: CycleDetected) -> Self

Converts to this type from the input type.

impl From<DetectorBundleError> for ExecError

fn from(source: DetectorBundleError) -> Self

Converts to this type from the input type.

impl From<ExecError> for LowerError

fn from(source: ExecError) -> Self

Converts to this type from the input type.

impl From<FlattenError> for ExecError

fn from(source: FlattenError) -> Self

Converts to this type from the input type.

impl From<SimError> for ExecError

fn from(source: SimError) -> Self

Converts to this type from the input type.