Enum Instruction 

pub enum Instruction {
    Quantum(QuantumTask),
    Eval(BoolOp),
    Accumulate(RecordParity),
    Bind(Box<[BoundaryBinding]>),
    ReadoutRecipe {
        bits: Box<[BitId]>,
        bindings: Box<[TaskId]>,
    },
    Observable {
        index: u32,
        bits: Box<[BitId]>,
        bindings: Box<[TaskId]>,
    },
    Decode(DecodeRequest),
    Discard(BoolOp),
    Rus {
        body: Stream,
        restart: BoolOp,
        owned_qubits: Box<[QubitId]>,
        attempt_bits: Box<[BitId]>,
        attempt_records: Box<[RecordId]>,
        resource: ResourceId,
        retry_prepare: QuantumStream,
        decoder_hold: Box<[MemoryCycle]>,
        cultivation_exits: Box<[TaskId]>,
    },
    WaitFor {
        until: Box<[TaskId]>,
        memory: Box<[MemoryCycle]>,
    },
    SignalReady {
        resource: ResourceId,
    },
    MemoryRounds {
        rounds: u32,
        stream: QuantumStream,
        detectors: Box<[RecordParity]>,
    },
    Idle {
        duration: f64,
        noise_ratio: f64,
        operations: Box<[QuantumOp]>,
    },
}

VM instruction set. Structured bodies refer to the shared task arena.

Variants

Quantum(QuantumTask)

Eval(BoolOp)

Accumulate(RecordParity)

Bind(Box<[BoundaryBinding]>)

ReadoutRecipe

Shared bit parity and boundary bindings; only a complete Observable reads them.

Fields

bits: Box<[BitId]>

bindings: Box<[TaskId]>

Observable

Fields

index: u32

bits: Box<[BitId]>

bindings: Box<[TaskId]>

Decode(DecodeRequest)

Publish one observable’s corrected parity or decoder flip.

Discard(BoolOp)

Rus

Repeat a source-isolated body without rolling back global state or time.

Fields

body: Stream

restart: BoolOp

owned_qubits: Box<[QubitId]>

attempt_bits: Box<[BitId]>

attempt_records: Box<[RecordId]>

resource: ResourceId

retry_prepare: QuantumStream

Optional explicit preparation before attempts after the first. Compiled factories replay authored body resets and leave this empty.

decoder_hold: Box<[MemoryCycle]>

Exact terminal seam cycles used while attempt decoders are pending.

cultivation_exits: Box<[TaskId]>

Physical cultivation exits after which GAP rounds begin.

WaitFor

Hold a live patch until every task in until is ready. Execute as many whole syndrome rounds as fit, then idle only for a sub-round remainder.

Fields

until: Box<[TaskId]>

Sibling producer exits whose active work must finish.

memory: Box<[MemoryCycle]>

SignalReady

Fields

resource: ResourceId

MemoryRounds

Statically requested memory rounds. The stream already contains the exact full rounds circuit and executes once; rounds is inspection metadata.

Fields

rounds: u32

stream: QuantumStream

detectors: Box<[RecordParity]>

Idle

A physical hold shorter than one available syndrome round.

Fields

duration: f64

noise_ratio: f64

operations: Box<[QuantumOp]>

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl PartialEq for Instruction

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Instruction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Instruction