Struct QecProgram 

pub struct QecProgram { /* private fields */ }

Native QEC program expressed as measurement-record operations.

Implementations

impl QecProgram

pub fn detector_error_model(&self) -> Result<DetectorErrorModel>

Derive the detector error model implied by the program’s Pauli-noise annotations, detectors, and observables.

Every annotation expands into its Pauli fault branches per fault site (one branch per target for X_ERROR / Z_ERROR, three per target for DEPOLARIZE1, fifteen per target pair for DEPOLARIZE2). Each branch is propagated through the circuit to the set of detectors and observables it flips. Mutually exclusive branches at one fault site with the same symptom sum; independent fault sites (distinct targets of one annotation included) with the same symptom compose as p = p1(1-p2) + p2(1-p1). Faults that flip no detector and no observable are omitted. Mechanisms are independent in the model, so its joint statistics agree with the sampler to second order in the branch probabilities.

Errors

Requires the compiled Clifford path: non-Clifford gates and reuse of a measured qubit without reset are rejected.

Examples

use prism_q::QecProgram;

let program = QecProgram::from_text(
    "X_ERROR(0.05) 0 1 2
     CX 0 3 1 3 1 4 2 4
     M 3 4
     DETECTOR rec[-2]
     DETECTOR rec[-1]",
)?;
let model = program.detector_error_model()?;
assert_eq!(model.num_detectors(), 2);
assert_eq!(model.num_mechanisms(), 3);

impl QecProgram

pub fn new(num_qubits: usize) -> Self

pub fn with_options(num_qubits: usize, options: QecOptions) -> Self

pub fn from_ops( num_qubits: usize, options: QecOptions, ops: Vec<QecOp>, ) -> Result<Self>

Create a program from operations, validating record references as operations are appended.

pub fn from_text(input: &str) -> Result<Self>

Parse a native measurement-record QEC program.

pub fn num_qubits(&self) -> usize

pub fn options(&self) -> QecOptions

pub fn set_options(&mut self, options: QecOptions)

pub fn ops(&self) -> &[QecOp]

pub fn num_measurements(&self) -> usize

Number of measurement records produced by the operation stream.

pub fn num_detectors(&self) -> usize

pub fn num_observables(&self) -> usize

Observable slot count, max included index + 1.

pub fn num_expectation_values(&self) -> usize

Number of EXP_VAL ops.

pub fn expectation_value_ops(&self) -> Vec<(&[QecPauli], f64)>

The EXP_VAL ops in op order as (terms, coefficient).

pub fn push_op(&mut self, op: QecOp) -> Result<()>

pub fn push_gate(&mut self, gate: Gate, targets: &[usize]) -> Result<()>

pub fn reset(&mut self, basis: QecBasis, qubit: usize) -> Result<()>

pub fn measure(&mut self, basis: QecBasis, qubit: usize) -> Result<usize>

Append a single-qubit measurement and return its record index.

pub fn measure_z(&mut self, qubit: usize) -> Result<usize>

Append a Z-basis measurement and return its record index.

pub fn measure_x(&mut self, qubit: usize) -> Result<usize>

Append an X-basis measurement and return its record index.

pub fn measure_pauli_product(&mut self, terms: &[QecPauli]) -> Result<usize>

Append a Pauli-product measurement and return its record index.

pub fn detector(&mut self, records: &[QecRecordRef]) -> Result<usize>

Append a detector and return its detector index.

pub fn detector_with_coords( &mut self, records: &[QecRecordRef], coords: &[f64], ) -> Result<usize>

Append a detector with coordinates and return its detector index.

pub fn observable_include( &mut self, observable: usize, records: &[QecRecordRef], ) -> Result<()>

pub fn expectation_value( &mut self, terms: &[QecPauli], coefficient: f64, ) -> Result<()>

pub fn postselect( &mut self, records: &[QecRecordRef], expected: bool, ) -> Result<()>

pub fn noise(&mut self, channel: QecNoise, targets: &[usize]) -> Result<()>

pub fn feedforward( &mut self, records: &[QecRecordRef], expected: bool, body: Vec<QecOp>, ) -> Result<()>

Append a feed-forward correction: body runs iff the parity over records equals expected.

See QecOp::Feedforward for what the body admits.

pub fn detector_rows(&self) -> Result<Vec<Vec<usize>>>

Resolve detector rows to absolute measurement record indices.

pub fn observable_rows(&self) -> Result<Vec<Vec<usize>>>

Resolve observable rows to absolute measurement record indices.

pub fn postselection_rows(&self) -> Result<Vec<(Vec<usize>, bool)>>

Resolve postselection rows to absolute measurement record indices.

pub fn empty_result(&self) -> QecSampleResult

Create an empty result with the program’s current record shape.

Trait Implementations

impl Clone for QecProgram

fn clone(&self) -> QecProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QecProgram

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

Formats the value using the given formatter.

impl PartialEq for QecProgram

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for QecProgram