use std::collections::HashSet;
#[cfg(test)]
use std::collections::{BTreeSet, HashMap};
use std::fs::{self, File};
use std::hash::{DefaultHasher, Hash, Hasher};
use std::io::{BufReader, BufWriter, Write};
use std::path::{Path, PathBuf};
use std::time::Instant;
use rstim::m2d::{CompiledLossAwareM2d, LossAwareDetectorShot};
use rstim::output::{OutputFormat, write_shots_b8};
use rstim::result_stream::ResultBlockReader;
use rstim::sim::bit_table::BitTable;
use serde::Serialize;
#[cfg(feature = "benchmark-tools")]
pub(crate) mod benchmark;
mod compiler;
mod dataset;
mod matching;
#[cfg(feature = "ilp")]
mod mle;
use compiler::compile_circuit;
#[cfg(test)]
use compiler::normalize_supported_circuit;
#[cfg(test)]
use dataset::{CircuitManifest, FileManifest, PublicManifest, RowManifest, sha256_hex};
use dataset::{Dataset, read_dataset};
#[cfg(test)]
use matching::EdgeKind;
#[cfg(test)]
use matching::validate_unambiguous_parallel_edges;
use matching::{CompiledMatching, GraphEdge};
#[cfg(feature = "ilp")]
use mle::CompiledMle;
pub const COMMAND: &str = "decode";
pub const STATS_SCHEMA_VERSION: &str = "rustqec.decode-stats.v1";
const BATCH_SIZE: usize = 1024;
const MAX_ENVELOPE_CANDIDATES: usize = 100_000;
const MAX_PRIMITIVE_PROBES: usize = 100_000;
const MAX_PRIMITIVE_SYMPTOM_TERMS: usize = 10_000_000;
const MAX_CONDITIONED_DECODER_ARTIFACTS: usize = 1_024;
const MAX_CONDITIONED_DECODER_ITEMS: usize = 100_000;
const MAX_CONDITIONED_DECODER_WORK: usize = 10_000_000;
const MAX_EXACT_LOSS_PATTERNS: usize = 4_096;
const MAX_EXACT_LOSS_PATTERN_TERMS: usize = 65_536;
const LOSS_PATTERN_HLL_PRECISION: u32 = 14;
const LOSS_PATTERN_HLL_REGISTERS: usize = 1 << LOSS_PATTERN_HLL_PRECISION;
#[cfg_attr(not(feature = "ilp"), allow(dead_code))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DecoderKind {
EnvelopeMatching,
EnvelopeMle,
}
impl DecoderKind {
pub fn name(self) -> &'static str {
match self {
Self::EnvelopeMatching => "envelope-matching",
Self::EnvelopeMle => "envelope-mle",
}
}
}
#[derive(Debug)]
pub struct DecodeOptions {
pub decoder: DecoderKind,
pub dataset: PathBuf,
pub predictions_out: PathBuf,
pub stats_out: PathBuf,
pub shot_timeout_ms: Option<u64>,
}
#[derive(Debug)]
pub struct DecodeFailure {
pub code: &'static str,
pub message: String,
}
impl DecodeFailure {
fn new(code: &'static str, message: impl Into<String>) -> Self {
Self {
code,
message: message.into(),
}
}
}
fn conditioned_cache_needs_eviction(
existing_artifacts: usize,
cached_work: usize,
artifact_work: usize,
) -> Result<bool, String> {
if artifact_work > MAX_CONDITIONED_DECODER_WORK {
return Err("conditioned decoder artifact work limit exceeded".to_string());
}
let total = cached_work
.checked_add(artifact_work)
.ok_or_else(|| "conditioned decoder cache work overflow".to_string())?;
Ok(existing_artifacts >= MAX_CONDITIONED_DECODER_ARTIFACTS
|| total > MAX_CONDITIONED_DECODER_WORK)
}
#[derive(Debug, Serialize, PartialEq)]
pub struct DecodeStats {
pub schema_version: &'static str,
pub decoder: String,
pub circuit_sha256: String,
pub shot_count: usize,
pub attempted_shot_count: usize,
pub compile_seconds: f64,
pub decode_seconds: f64,
pub distinct_loss_patterns: usize,
pub distinct_loss_patterns_exact: bool,
pub cache_hits: usize,
pub timeout_count: usize,
pub infeasible_shot_count: usize,
pub circuit_compilations: usize,
pub primitive_probe_count: usize,
pub primitive_symptom_terms: usize,
pub loss_envelope_candidate_count: usize,
pub matching_graph_builds: usize,
pub mle_model_builds: usize,
pub mle_detector_rows: usize,
}
#[derive(Debug)]
enum DistinctLossPatternState {
Exact {
patterns: HashSet<Vec<usize>>,
retained_terms: usize,
},
Approximate {
registers: Box<[u8]>,
},
}
#[derive(Debug)]
struct DistinctLossPatternCounter {
state: DistinctLossPatternState,
observations: usize,
}
impl Default for DistinctLossPatternCounter {
fn default() -> Self {
Self {
state: DistinctLossPatternState::Exact {
patterns: HashSet::new(),
retained_terms: 0,
},
observations: 0,
}
}
}
impl DistinctLossPatternCounter {
fn observe(&mut self, pattern: &[usize]) {
self.observations = self.observations.saturating_add(1);
let should_promote = match &mut self.state {
DistinctLossPatternState::Exact {
patterns,
retained_terms,
} => {
if patterns.contains(pattern) {
return;
}
match retained_terms.checked_add(pattern.len()) {
Some(total)
if patterns.len() < MAX_EXACT_LOSS_PATTERNS
&& total <= MAX_EXACT_LOSS_PATTERN_TERMS =>
{
patterns.insert(pattern.to_vec());
*retained_terms = total;
return;
}
_ => true,
}
}
DistinctLossPatternState::Approximate { registers } => {
hll_insert(registers, loss_pattern_fingerprint(pattern));
return;
}
};
if should_promote {
self.promote_to_approximate();
let DistinctLossPatternState::Approximate { registers } = &mut self.state else {
unreachable!("promotion must install the approximate counter")
};
hll_insert(registers, loss_pattern_fingerprint(pattern));
}
}
fn promote_to_approximate(&mut self) {
let previous = std::mem::replace(
&mut self.state,
DistinctLossPatternState::Approximate {
registers: vec![0; LOSS_PATTERN_HLL_REGISTERS].into_boxed_slice(),
},
);
let DistinctLossPatternState::Exact { patterns, .. } = previous else {
return;
};
let DistinctLossPatternState::Approximate { registers } = &mut self.state else {
unreachable!("promotion must install the approximate counter")
};
for pattern in patterns {
hll_insert(registers, loss_pattern_fingerprint(&pattern));
}
}
fn count(&self) -> usize {
match &self.state {
DistinctLossPatternState::Exact { patterns, .. } => patterns.len(),
DistinctLossPatternState::Approximate { registers } => {
hll_estimate(registers).min(self.observations)
}
}
}
fn is_exact(&self) -> bool {
matches!(self.state, DistinctLossPatternState::Exact { .. })
}
}
fn loss_pattern_fingerprint(pattern: &[usize]) -> u64 {
let mut hasher = DefaultHasher::new();
pattern.hash(&mut hasher);
hasher.finish()
}
fn hll_insert(registers: &mut [u8], fingerprint: u64) {
let index = (fingerprint >> (64 - LOSS_PATTERN_HLL_PRECISION)) as usize;
let remaining = fingerprint << LOSS_PATTERN_HLL_PRECISION;
let rank = (remaining.leading_zeros() + 1).min(64 - LOSS_PATTERN_HLL_PRECISION + 1) as u8;
registers[index] = registers[index].max(rank);
}
fn hll_estimate(registers: &[u8]) -> usize {
let register_count = registers.len() as f64;
let alpha = 0.7213 / (1.0 + 1.079 / register_count);
let harmonic_sum: f64 = registers
.iter()
.map(|&rank| 2.0_f64.powi(-i32::from(rank)))
.sum();
let raw = alpha * register_count * register_count / harmonic_sum;
let zero_registers = registers.iter().filter(|&&rank| rank == 0).count();
let estimate = if raw <= 2.5 * register_count && zero_registers > 0 {
register_count * (register_count / zero_registers as f64).ln()
} else {
raw
};
estimate.round().min(usize::MAX as f64) as usize
}
#[cfg_attr(not(feature = "ilp"), allow(dead_code))]
#[derive(Clone, Debug)]
struct Effect {
id: String,
detectors: Vec<usize>,
observables: Vec<usize>,
weight: f64,
}
#[derive(Clone, Debug)]
struct LossEnvelope {
id: String,
candidates: Vec<Effect>,
}
#[cfg_attr(not(feature = "ilp"), allow(dead_code))]
struct CompiledCircuit {
loss_aware_m2d: CompiledLossAwareM2d,
loss_flags: Vec<usize>,
independent_effects: Vec<Effect>,
envelopes: Vec<LossEnvelope>,
graph_edges: Vec<GraphEdge>,
loss_edges: Vec<Vec<usize>>,
unmapped_loss_primitives: Vec<Vec<String>>,
num_observables: usize,
primitive_probe_count: usize,
primitive_symptom_terms: usize,
}
pub fn run(options: &DecodeOptions) -> Result<DecodeStats, DecodeFailure> {
validate_output_paths(options)?;
let dataset = read_dataset(&options.dataset)?;
let compile_started = Instant::now();
let circuit = compile_circuit(&dataset, options.decoder)?;
let mut decoder = match options.decoder {
DecoderKind::EnvelopeMatching => DecoderState::Matching(CompiledMatching::new(&circuit)?),
#[cfg(feature = "ilp")]
DecoderKind::EnvelopeMle => {
DecoderState::Mle(CompiledMle::new(&circuit, options.shot_timeout_ms)?)
}
#[cfg(not(feature = "ilp"))]
DecoderKind::EnvelopeMle => {
return Err(DecodeFailure::new(
"feature_disabled",
"envelope-mle requires the rustqec-cli `ilp` feature",
));
}
};
let compile_seconds = compile_started.elapsed().as_secs_f64();
let prediction_parent = parent_dir(&options.predictions_out);
let stats_parent = parent_dir(&options.stats_out);
fs::create_dir_all(prediction_parent).map_err(|error| {
DecodeFailure::new(
"output_error",
format!("failed to create {}: {error}", prediction_parent.display()),
)
})?;
fs::create_dir_all(stats_parent).map_err(|error| {
DecodeFailure::new(
"output_error",
format!("failed to create {}: {error}", stats_parent.display()),
)
})?;
let mut prediction_temp = tempfile::NamedTempFile::new_in(prediction_parent)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
let mut writer = BufWriter::new(prediction_temp.as_file_mut());
let shots = File::open(&dataset.shots_path).map_err(|error| {
DecodeFailure::new(
"missing_dataset_file",
format!("failed to open {}: {error}", dataset.shots_path.display()),
)
})?;
let mut reader = ResultBlockReader::new(
BufReader::new(shots),
dataset.manifest.row.bits,
dataset.manifest.shots as u64,
OutputFormat::B8,
BATCH_SIZE,
)
.map_err(|error| DecodeFailure::new("invalid_dataset", error.to_string()))?;
let decode_started = Instant::now();
let mut patterns = DistinctLossPatternCounter::default();
let mut shot_offset = 0usize;
while let Some(measurements) = reader
.next_block()
.map_err(|error| DecodeFailure::new("invalid_dataset", error.to_string()))?
{
let loss_aware = circuit.loss_aware_syndromes(&measurements)?;
let losses = circuit.loss_patterns(&measurements);
let mut predictions = BitTable::try_new(circuit.num_observables, measurements.num_minor())
.map_err(|error| DecodeFailure::new("decode_error", format!("{error:?}")))?;
for shot in 0..measurements.num_minor() {
patterns.observe(&losses[shot]);
match decoder.decode(&loss_aware[shot], &losses[shot]) {
Ok(bits) => {
for observable in bits {
predictions.set(observable, shot, true);
}
}
Err(ShotFailure::Timeout) => {
let stats = build_stats(
options,
&dataset,
compile_seconds,
decode_started.elapsed().as_secs_f64(),
&patterns,
&decoder,
&circuit,
shot_offset + shot + 1,
1,
0,
);
persist_stats_atomic(&options.stats_out, stats_parent, &stats)?;
return Err(DecodeFailure::new(
"decode_timeout",
format!("envelope-mle timed out at shot {}", shot_offset + shot),
));
}
Err(ShotFailure::Infeasible) => {
let stats = build_stats(
options,
&dataset,
compile_seconds,
decode_started.elapsed().as_secs_f64(),
&patterns,
&decoder,
&circuit,
shot_offset + shot + 1,
0,
1,
);
persist_stats_atomic(&options.stats_out, stats_parent, &stats)?;
return Err(DecodeFailure::new(
"decode_infeasible",
format!("shot {} has no feasible correction", shot_offset + shot),
));
}
Err(ShotFailure::Other(message)) => {
return Err(DecodeFailure::new("decode_error", message));
}
}
}
write_shots_b8(&predictions, &mut writer)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
shot_offset += measurements.num_minor();
}
writer
.flush()
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
drop(writer);
let decode_seconds = decode_started.elapsed().as_secs_f64();
let stats = build_stats(
options,
&dataset,
compile_seconds,
decode_seconds,
&patterns,
&decoder,
&circuit,
dataset.manifest.shots,
0,
0,
);
let mut stats_temp = tempfile::NamedTempFile::new_in(stats_parent)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
serde_json::to_writer_pretty(stats_temp.as_file_mut(), &stats)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
stats_temp
.as_file_mut()
.write_all(b"\n")
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
stats_temp
.as_file_mut()
.flush()
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
prediction_temp
.persist(&options.predictions_out)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
if let Err(error) = stats_temp.persist(&options.stats_out) {
let _ = fs::remove_file(&options.predictions_out);
return Err(DecodeFailure::new("output_error", error.to_string()));
}
Ok(stats)
}
#[allow(clippy::too_many_arguments)]
fn build_stats(
options: &DecodeOptions,
dataset: &Dataset,
compile_seconds: f64,
decode_seconds: f64,
patterns: &DistinctLossPatternCounter,
decoder: &DecoderState,
circuit: &CompiledCircuit,
attempted_shots: usize,
timeout_count: usize,
infeasible_shot_count: usize,
) -> DecodeStats {
DecodeStats {
schema_version: STATS_SCHEMA_VERSION,
decoder: options.decoder.name().to_string(),
circuit_sha256: dataset.manifest.circuit.sha256.clone(),
shot_count: dataset.manifest.shots,
attempted_shot_count: attempted_shots,
compile_seconds,
decode_seconds,
distinct_loss_patterns: patterns.count(),
distinct_loss_patterns_exact: patterns.is_exact(),
cache_hits: decoder.cache_hits(),
timeout_count,
infeasible_shot_count,
circuit_compilations: 1,
primitive_probe_count: circuit.primitive_probe_count,
primitive_symptom_terms: circuit.primitive_symptom_terms,
loss_envelope_candidate_count: circuit
.envelopes
.iter()
.map(|envelope| envelope.candidates.len())
.sum(),
matching_graph_builds: decoder.graph_builds(),
mle_model_builds: decoder.model_builds(),
mle_detector_rows: decoder.mle_detector_rows(),
}
}
fn persist_stats_atomic(
path: &Path,
parent: &Path,
stats: &DecodeStats,
) -> Result<(), DecodeFailure> {
let mut temp = tempfile::NamedTempFile::new_in(parent)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
serde_json::to_writer_pretty(temp.as_file_mut(), stats)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
temp.as_file_mut()
.write_all(b"\n")
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
temp.as_file_mut()
.flush()
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
temp.persist(path)
.map_err(|error| DecodeFailure::new("output_error", error.to_string()))?;
Ok(())
}
fn validate_output_paths(options: &DecodeOptions) -> Result<(), DecodeFailure> {
if options.decoder == DecoderKind::EnvelopeMatching && options.shot_timeout_ms.is_some() {
return Err(DecodeFailure::new(
"invalid_arguments",
"--shot-timeout-ms is supported only by envelope-mle",
));
}
if options.predictions_out == options.stats_out {
return Err(DecodeFailure::new(
"invalid_arguments",
"--out and --stats-out must be different paths",
));
}
for path in [&options.predictions_out, &options.stats_out] {
if path.exists() {
return Err(DecodeFailure::new(
"output_error",
format!("output already exists: {}", path.display()),
));
}
}
Ok(())
}
#[cfg_attr(not(feature = "ilp"), allow(dead_code))]
#[derive(Debug)]
enum ShotFailure {
Timeout,
Infeasible,
Other(String),
}
enum DecoderState {
Matching(CompiledMatching),
#[cfg(feature = "ilp")]
Mle(CompiledMle),
}
impl DecoderState {
fn decode(
&mut self,
syndrome: &LossAwareDetectorShot,
losses: &[usize],
) -> Result<Vec<usize>, ShotFailure> {
match self {
Self::Matching(decoder) => decoder.decode(syndrome, losses),
#[cfg(feature = "ilp")]
Self::Mle(decoder) => decoder.decode(syndrome, losses),
}
}
fn graph_builds(&self) -> usize {
match self {
Self::Matching(decoder) => decoder.graph_builds(),
#[cfg(feature = "ilp")]
Self::Mle(_) => 0,
}
}
fn model_builds(&self) -> usize {
match self {
Self::Matching(_) => 0,
#[cfg(feature = "ilp")]
Self::Mle(decoder) => decoder.model_builds(),
}
}
fn cache_hits(&self) -> usize {
match self {
Self::Matching(decoder) => decoder.cache_hits(),
#[cfg(feature = "ilp")]
Self::Mle(decoder) => decoder.cache_hits(),
}
}
fn mle_detector_rows(&self) -> usize {
match self {
Self::Matching(_) => 0,
#[cfg(feature = "ilp")]
Self::Mle(decoder) => decoder.detector_rows(),
}
}
}
fn parent_dir(path: &Path) -> &Path {
path.parent()
.filter(|parent| !parent.as_os_str().is_empty())
.unwrap_or(Path::new("."))
}
pub(crate) fn validate_public_bundle(dir: &Path) -> Result<Vec<usize>, DecodeFailure> {
let dataset = read_dataset(dir)?;
let compiled = compile_circuit(&dataset, DecoderKind::EnvelopeMatching)?;
Ok(compiled.loss_flags)
}
pub(crate) fn write_public_bundle(
dir: &Path,
circuit_text: &str,
shots_b8: &[u8],
shots: usize,
) -> Result<(), DecodeFailure> {
dataset::write_public_bundle(dir, circuit_text, shots_b8, shots)
}
#[cfg(test)]
mod tests {
#[cfg(feature = "ilp")]
use renvelope::{
AtomLossCase, DecodeOutcome, EdgeKind as ReferenceEdgeKind, Effect as ReferenceEffect,
EnvelopeMatchingCase, EnvelopeMatchingEdge, EnvelopeMatchingShot, LossEdgeMap,
LossEnvelope as ReferenceLossEnvelope, decode as decode_reference_mle,
decode_matching as decode_reference_matching,
};
use super::*;
const PERSISTENT_CIRCUIT: &str = concat!(
"QUBIT_COORDS(0,0) 0\n",
"QUBIT_COORDS(1,0) 1\n",
"R 0 1\n",
"X_ERROR(0.1) 0\n",
"X_ERROR(0.01) 1\n",
"LOSS(0.1) 0\n",
"H 0\n",
"H 0\n",
"CX 0 1\n",
"X_ERROR(0.02) 0\n",
"LOSS(0.1) 1\n",
"ML 0 1\n",
"DETECTOR(0,0,0) rec[-3]\n",
"DETECTOR(1,0,0) rec[-1]\n",
"OBSERVABLE_INCLUDE(0) rec[-3]\n",
);
#[test]
fn conditioned_cache_requests_eviction_instead_of_rejecting_valid_artifacts() {
assert!(!conditioned_cache_needs_eviction(0, 0, 1).unwrap());
assert!(conditioned_cache_needs_eviction(MAX_CONDITIONED_DECODER_ARTIFACTS, 0, 1).unwrap());
assert!(conditioned_cache_needs_eviction(1, MAX_CONDITIONED_DECODER_WORK, 1).unwrap());
assert!(conditioned_cache_needs_eviction(0, 0, MAX_CONDITIONED_DECODER_WORK + 1).is_err());
}
#[test]
fn distinct_loss_pattern_counter_is_exact_within_its_budgets() {
let mut counter = DistinctLossPatternCounter::default();
counter.observe(&[1, 3]);
counter.observe(&[1, 3]);
counter.observe(&[2]);
assert_eq!(counter.count(), 2);
assert!(counter.is_exact());
}
#[test]
fn distinct_loss_pattern_counter_does_not_retain_an_oversized_pattern() {
let mut counter = DistinctLossPatternCounter::default();
let pattern = vec![0; MAX_EXACT_LOSS_PATTERN_TERMS + 1];
counter.observe(&pattern);
assert_eq!(counter.count(), 1);
assert!(!counter.is_exact());
let DistinctLossPatternState::Approximate { registers } = &counter.state else {
panic!("oversized pattern must switch to fixed-memory counting")
};
assert_eq!(registers.len(), LOSS_PATTERN_HLL_REGISTERS);
}
#[test]
fn distinct_loss_pattern_counter_bounds_many_unique_patterns() {
let mut counter = DistinctLossPatternCounter::default();
let pattern_count = MAX_EXACT_LOSS_PATTERNS * 4;
for pattern in 0..pattern_count {
counter.observe(&[pattern]);
}
assert!(!counter.is_exact());
assert!(counter.count().abs_diff(pattern_count) < pattern_count / 10);
let DistinctLossPatternState::Approximate { registers } = &counter.state else {
panic!("unique-pattern stream must switch to fixed-memory counting")
};
assert_eq!(registers.len(), LOSS_PATTERN_HLL_REGISTERS);
}
fn dataset_for(circuit_text: &str) -> Dataset {
let instrs = rstim::validation::parse_and_validate(circuit_text).unwrap();
let stats = rstim::stats::summarize(&instrs);
Dataset {
manifest: PublicManifest {
schema_version: 1,
dataset_id: None,
mode: "measurements_blinded".to_string(),
shots: 0,
row: RowManifest {
kind: "measurements".to_string(),
bits: stats.num_measurements,
encoding: "b8".to_string(),
bit_order: "lsb_first".to_string(),
bytes_per_shot: stats.num_measurements.div_ceil(8),
},
circuit: CircuitManifest {
file: "circuit.stim".to_string(),
sha256: sha256_hex(circuit_text.as_bytes()),
measurements: stats.num_measurements,
detectors: stats.num_detectors,
observables: stats.num_observables,
sweep_bits: stats.num_sweep_bits,
},
shots_file: FileManifest {
file: "shots.b8".to_string(),
sha256: String::new(),
bits: stats.num_measurements,
bytes_per_shot: stats.num_measurements.div_ceil(8),
},
},
circuit_text: circuit_text.to_string(),
shots_path: PathBuf::new(),
}
}
fn compiled(circuit_text: &str) -> CompiledCircuit {
compile_circuit(&dataset_for(circuit_text), DecoderKind::EnvelopeMle).unwrap()
}
#[cfg(feature = "ilp")]
fn observed(bits: &[u8]) -> Vec<usize> {
bits.iter()
.enumerate()
.filter_map(|(index, &bit)| (bit != 0).then_some(index))
.collect()
}
#[cfg(feature = "ilp")]
fn mask(indices: &[usize]) -> u64 {
indices.iter().fold(0, |value, &index| value | (1 << index))
}
fn singleton_syndrome(bits: &[u8]) -> LossAwareDetectorShot {
LossAwareDetectorShot {
lost_measurements: Vec::new(),
detector_valid: vec![true; bits.len()],
checks: bits
.iter()
.enumerate()
.map(|(detector, &bit)| rstim::m2d::LossAwareDetectorCheck {
source_detectors: vec![detector],
value: bit != 0,
})
.collect(),
canonical_detector_values: bits.iter().map(|&bit| bit != 0).collect(),
}
}
#[cfg(feature = "ilp")]
fn reference_effect(effect: &Effect) -> ReferenceEffect {
ReferenceEffect {
id: effect.id.clone(),
detectors: effect.detectors.clone(),
observables: effect.observables.clone(),
weight: effect.weight,
}
}
#[cfg(feature = "ilp")]
fn reference_case(
circuit: &CompiledCircuit,
observed_detectors: Vec<usize>,
losses: &[usize],
) -> AtomLossCase {
AtomLossCase {
schema_version: "atom-loss-envelope.v0".to_string(),
num_detectors: circuit.loss_aware_m2d.layout().num_detectors(),
num_observables: circuit.num_observables,
observed_detectors,
independent_effects: circuit
.independent_effects
.iter()
.map(reference_effect)
.collect(),
loss_envelopes: losses
.iter()
.map(|&loss| ReferenceLossEnvelope {
loss_id: circuit.envelopes[loss].id.clone(),
candidates: circuit.envelopes[loss]
.candidates
.iter()
.map(reference_effect)
.collect(),
})
.collect(),
}
}
#[cfg(feature = "ilp")]
fn reference_mle(circuit: &CompiledCircuit, syndrome: &[u8], losses: &[usize]) -> u64 {
let case = reference_case(circuit, observed(syndrome), losses);
match decode_reference_mle(&case).unwrap() {
DecodeOutcome::Optimal(result) => mask(&result.predicted_observables),
DecodeOutcome::Infeasible(_) => panic!("reference MLE unexpectedly infeasible"),
}
}
#[cfg(feature = "ilp")]
fn project_reference_effect(
effect: &ReferenceEffect,
checks: &[rstim::m2d::LossAwareDetectorCheck],
) -> ReferenceEffect {
ReferenceEffect {
id: effect.id.clone(),
detectors: checks
.iter()
.enumerate()
.filter_map(|(row, check)| {
(check
.source_detectors
.iter()
.filter(|detector| effect.detectors.contains(detector))
.count()
% 2
== 1)
.then_some(row)
})
.collect(),
observables: effect.observables.clone(),
weight: effect.weight,
}
}
#[cfg(feature = "ilp")]
fn project_reference_case(
canonical: &AtomLossCase,
checks: &[rstim::m2d::LossAwareDetectorCheck],
) -> AtomLossCase {
AtomLossCase {
schema_version: canonical.schema_version.clone(),
num_detectors: checks.len(),
num_observables: canonical.num_observables,
observed_detectors: checks
.iter()
.enumerate()
.filter_map(|(row, check)| check.value.then_some(row))
.collect(),
independent_effects: canonical
.independent_effects
.iter()
.map(|effect| project_reference_effect(effect, checks))
.collect(),
loss_envelopes: canonical
.loss_envelopes
.iter()
.map(|envelope| ReferenceLossEnvelope {
loss_id: envelope.loss_id.clone(),
candidates: envelope
.candidates
.iter()
.map(|effect| project_reference_effect(effect, checks))
.collect(),
})
.collect(),
}
}
#[cfg(feature = "ilp")]
fn issue_679_native_reference_cases() -> (AtomLossCase, AtomLossCase, Vec<usize>, usize, usize)
{
let fixture = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/current_rstim_atom_loss/midswap_canonical_mle");
let dataset = read_dataset(&fixture).unwrap();
let circuit = compile_circuit(&dataset, DecoderKind::EnvelopeMle).unwrap();
let shots = File::open(&dataset.shots_path).unwrap();
let mut reader = ResultBlockReader::new(
BufReader::new(shots),
dataset.manifest.row.bits,
dataset.manifest.shots as u64,
OutputFormat::B8,
BATCH_SIZE,
)
.unwrap();
let measurements = reader.next_block().unwrap().unwrap();
let mut syndromes = circuit.loss_aware_syndromes(&measurements).unwrap();
let losses = circuit.loss_patterns(&measurements).pop().unwrap();
let syndrome = syndromes.pop().unwrap();
let canonical = reference_case(
&circuit,
syndrome
.canonical_detector_values
.iter()
.enumerate()
.filter_map(|(detector, &value)| value.then_some(detector))
.collect(),
&losses,
);
let projected = project_reference_case(&canonical, &syndrome.checks);
(
canonical,
projected,
losses,
syndrome.canonical_detector_values.len(),
syndrome.checks.len(),
)
}
#[cfg(feature = "ilp")]
fn issue_679_reference_fixture() -> serde_json::Value {
let (canonical, projected, losses, detector_count, check_count) =
issue_679_native_reference_cases();
serde_json::json!({
"source_shot_index": 134,
"expected_observables": [0],
"active_loss_indices": losses,
"original_detector_count": detector_count,
"surviving_check_count": check_count,
"canonical_case": canonical,
"surviving_check_case": projected,
})
}
#[cfg(feature = "ilp")]
fn reference_matching(circuit: &CompiledCircuit, shots: &[(&[u8], &[usize])]) -> Vec<u64> {
let edge_ids: Vec<_> = (0..circuit.graph_edges.len())
.map(|index| format!("edge-{index}"))
.collect();
let case = EnvelopeMatchingCase {
schema_version: "atom-loss-envelope-matching.v0".to_string(),
num_detectors: circuit.loss_aware_m2d.layout().num_detectors(),
num_observables: circuit.num_observables,
edges: circuit
.graph_edges
.iter()
.enumerate()
.map(|(index, edge)| EnvelopeMatchingEdge {
id: edge_ids[index].clone(),
node1: edge.node1,
node2: edge.node2,
observable_indices: edge.observables.clone(),
weight: edge.weight,
kind: match edge.kind {
EdgeKind::TimeLike => ReferenceEdgeKind::TimeLike,
EdgeKind::SpaceLike => ReferenceEdgeKind::SpaceLike,
EdgeKind::Boundary => ReferenceEdgeKind::Boundary,
},
})
.collect(),
loss_edge_map: circuit
.loss_edges
.iter()
.enumerate()
.map(|(loss, edges)| LossEdgeMap {
loss_id: circuit.envelopes[loss].id.clone(),
edge_ids: edges.iter().map(|&edge| edge_ids[edge].clone()).collect(),
})
.collect(),
shots: shots
.iter()
.map(|(syndrome, losses)| EnvelopeMatchingShot {
observed_detectors: observed(syndrome),
observed_losses: losses
.iter()
.map(|&loss| circuit.envelopes[loss].id.clone())
.collect(),
})
.collect(),
};
decode_reference_matching(&case).unwrap().predictions
}
#[cfg(feature = "ilp")]
#[test]
fn compiled_batch_matches_explicit_reference_kernels() {
let circuit = compiled(PERSISTENT_CIRCUIT);
let shots: Vec<(&[u8], &[usize])> = vec![
(&[1, 0], &[]),
(&[0, 0], &[0]),
(&[0, 0], &[0]),
(&[0, 0], &[]),
];
let mut mle = CompiledMle::new(&circuit, None).unwrap();
let mle_predictions: Vec<_> = shots
.iter()
.map(|(syndrome, losses)| {
mask(&mle.decode(&singleton_syndrome(syndrome), losses).unwrap())
})
.collect();
let expected_mle: Vec<_> = shots
.iter()
.map(|(syndrome, losses)| reference_mle(&circuit, syndrome, losses))
.collect();
assert_eq!(mle_predictions, expected_mle);
assert_eq!(mle_predictions, [1, 0, 0, 0]);
let mut matching = CompiledMatching::new(&circuit).unwrap();
let matching_predictions: Vec<_> = shots
.iter()
.map(|(syndrome, losses)| {
mask(
&matching
.decode(&singleton_syndrome(syndrome), losses)
.unwrap(),
)
})
.collect();
assert_eq!(matching_predictions, reference_matching(&circuit, &shots));
assert_eq!(matching_predictions, [1, 0, 0, 0]);
assert_eq!(matching.cache.len(), 2);
}
#[cfg(feature = "ilp")]
#[test]
fn imported_measurement_rows_match_the_canonical_reference_mle() {
let circuit = compiled(PERSISTENT_CIRCUIT);
let rows = ["0100", "1000", "1000", "0000"];
let mut measurements = BitTable::new(4, rows.len());
for (shot, row) in rows.iter().enumerate() {
for (measurement, value) in row.bytes().enumerate() {
measurements.set(measurement, shot, value == b'1');
}
}
let syndromes = circuit.loss_aware_syndromes(&measurements).unwrap();
let losses = circuit.loss_patterns(&measurements);
let mut mle = CompiledMle::new(&circuit, None).unwrap();
let actual: Vec<_> = syndromes
.iter()
.zip(&losses)
.map(|(syndrome, losses)| mask(&mle.decode(syndrome, losses).unwrap()))
.collect();
let expected: Vec<_> = syndromes
.iter()
.zip(&losses)
.map(|(syndrome, losses)| {
let canonical: Vec<_> = syndrome
.canonical_detector_values
.iter()
.map(|&value| u8::from(value))
.collect();
reference_mle(&circuit, &canonical, losses)
})
.collect();
assert_eq!(actual, expected);
assert_eq!(actual, [1, 1, 1, 0]);
}
#[cfg(feature = "ilp")]
#[test]
fn issue_679_reference_fixture_matches_the_native_compiler() {
let fixture = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/current_rstim_atom_loss/midswap_canonical_mle");
let pinned =
zstd::decode_all(File::open(fixture.join("reference_cases.json.zst")).unwrap())
.unwrap();
let reference: serde_json::Value = serde_json::from_slice(&pinned).unwrap();
let _: AtomLossCase = serde_json::from_value(reference["canonical_case"].clone()).unwrap();
let _: AtomLossCase =
serde_json::from_value(reference["surviving_check_case"].clone()).unwrap();
let current = serde_json::to_vec_pretty(&issue_679_reference_fixture()).unwrap();
assert_eq!(
sha256_hex(¤t),
sha256_hex(&pinned),
"the pinned canonical reference and negative control are stale; run the ignored regenerator"
);
}
#[cfg(feature = "ilp")]
#[test]
#[ignore = "regenerates /tmp/issue679-reference_cases.json.zst"]
fn regenerate_issue_679_reference_cases() {
let fixture = issue_679_reference_fixture();
let json = serde_json::to_vec_pretty(&fixture).unwrap();
let compressed = zstd::encode_all(json.as_slice(), 19).unwrap();
let output = Path::new("/tmp/issue679-reference_cases.json.zst");
fs::write(output, &compressed).unwrap();
eprintln!(
"wrote {} sha256={}",
output.display(),
sha256_hex(&compressed)
);
}
#[cfg(feature = "ilp")]
#[test]
fn all_no_loss_reduces_to_ordinary_pauli_decoding() {
let circuit = compiled(PERSISTENT_CIRCUIT);
let shots: Vec<(&[u8], &[usize])> = vec![
(&[0, 0], &[]),
(&[1, 0], &[]),
(&[0, 1], &[]),
(&[1, 1], &[]),
];
let expected = [0, 1, 0, 1];
let mut mle = CompiledMle::new(&circuit, None).unwrap();
let actual_mle: Vec<_> = shots
.iter()
.map(|(syndrome, losses)| {
mask(&mle.decode(&singleton_syndrome(syndrome), losses).unwrap())
})
.collect();
assert_eq!(actual_mle, expected);
assert_eq!(
actual_mle,
shots
.iter()
.map(|(syndrome, _)| reference_mle(&circuit, syndrome, &[]))
.collect::<Vec<_>>()
);
let mut matching = CompiledMatching::new(&circuit).unwrap();
let actual_matching: Vec<_> = shots
.iter()
.map(|(syndrome, losses)| {
mask(
&matching
.decode(&singleton_syndrome(syndrome), losses)
.unwrap(),
)
})
.collect();
assert_eq!(actual_matching, expected);
assert_eq!(actual_matching, reference_matching(&circuit, &shots));
assert_eq!(matching.cache.len(), 1);
}
#[cfg(feature = "ilp")]
#[test]
fn delayed_erasure_decoders_ignore_the_lost_measurement_placeholder() {
let circuit = compiled(concat!(
"QUBIT_COORDS(0,0) 0\n",
"R 0\n",
"X_ERROR(0.1) 0\n",
"LOSS(0.1) 0\n",
"MRL 0\n",
"X_ERROR(0.02) 0\n",
"LOSS(0.1) 0\n",
"ML 0\n",
"DETECTOR(0,0,0) rec[-3]\n",
"DETECTOR(0,0,1) rec[-3] rec[-1]\n",
"OBSERVABLE_INCLUDE(0) rec[-1]\n",
));
let mut measurements = BitTable::new(4, 2);
measurements.set(0, 0, true);
measurements.set(0, 1, true);
measurements.set(1, 1, true);
measurements.set(3, 0, true);
measurements.set(3, 1, true);
let syndromes = circuit.loss_aware_syndromes(&measurements).unwrap();
let losses = circuit.loss_patterns(&measurements);
assert_eq!(losses, [vec![0], vec![0]]);
assert_eq!(syndromes[0].checks, syndromes[1].checks);
assert_eq!(syndromes[0].checks.len(), 1);
assert_eq!(syndromes[0].checks[0].source_detectors, [0, 1]);
let mut mle = CompiledMle::new(&circuit, None).unwrap();
let mle_zero = mle.decode(&syndromes[0], &losses[0]).unwrap();
let mle_one = mle.decode(&syndromes[1], &losses[1]).unwrap();
assert_eq!(mle_zero, [0]);
assert_eq!(mle_zero, mle_one);
assert_eq!(mle.model_builds(), 1);
let mut matching = CompiledMatching::new(&circuit).unwrap();
let matching_zero = matching.decode(&syndromes[0], &losses[0]).unwrap();
let matching_one = matching.decode(&syndromes[1], &losses[1]).unwrap();
assert_eq!(matching_zero, [0]);
assert_eq!(matching_zero, matching_one);
assert_eq!(matching.cache.len(), 1);
let mut inconsistent = syndromes[0].clone();
inconsistent.checks[0].source_detectors = vec![0];
assert_eq!(mle.decode(&inconsistent, &losses[0]).unwrap(), mle_zero);
assert_eq!(
matching.decode(&inconsistent, &losses[0]).unwrap(),
matching_zero
);
inconsistent.canonical_detector_values.pop();
let error = mle.decode(&inconsistent, &losses[0]).unwrap_err();
assert!(matches!(error, ShotFailure::Other(message) if message.contains("inconsistent")));
let error = matching.decode(&inconsistent, &losses[0]).unwrap_err();
assert!(matches!(error, ShotFailure::Other(message) if message.contains("inconsistent")));
}
#[test]
fn early_loss_envelope_propagates_beyond_pre_readout_sensitivity() {
let early = compiled(PERSISTENT_CIRCUIT);
assert!(
early.envelopes[0]
.candidates
.iter()
.any(|candidate| candidate.detectors.contains(&1)),
"an onset before H/H/CX must be able to affect the target-wire detector"
);
let immediate_text = PERSISTENT_CIRCUIT.replacen(
"LOSS(0.1) 0\nH 0\nH 0\nCX 0 1\n",
"H 0\nH 0\nCX 0 1\nLOSS(0.1) 0\n",
1,
);
let immediate = compiled(&immediate_text);
assert!(
immediate.envelopes[0]
.candidates
.iter()
.all(|candidate| !candidate.detectors.contains(&1)),
"an onset immediately before q0 readout cannot affect q1"
);
}
#[test]
fn cx_target_contributes_implicit_basis_sites_and_observables_are_padded() {
let instrs =
rstim::validation::parse_and_validate("R 0 1\nLOSS(0.1) 1\nCX 0 1\nML 1\n").unwrap();
let flat = rstim::transforms::flattened(&instrs);
let normalized = normalize_supported_circuit(&flat).unwrap();
assert_eq!(normalized.probes[0].basis_sites.len(), 2);
let mut matching = CompiledMatching {
edges: vec![GraphEdge {
node1: 0,
node2: None,
observables: Vec::new(),
weight: 1.0,
kind: EdgeKind::Boundary,
}],
loss_edges: Vec::new(),
mean_weight: 1.0,
num_observables: 2,
cache: HashMap::new(),
cache_order: std::collections::VecDeque::new(),
cached_work: 0,
graph_builds: 0,
cache_hits: 0,
};
assert_eq!(
matching.decode(&singleton_syndrome(&[1]), &[]).unwrap(),
Vec::<usize>::new()
);
}
#[test]
fn multi_round_mrl_preserves_flag_value_order_and_reopens_after_reset() {
let instrs = rstim::validation::parse_and_validate(concat!(
"R 0 1\n",
"LOSS(0.1) 0 1\n",
"MRL 0 1\n",
"LOSS(0.1) 0\n",
"MRL 0\n",
"LOSS(0.1) 0\n",
"ML 0\n",
))
.unwrap();
let flat = rstim::transforms::flattened(&instrs);
let normalized = normalize_supported_circuit(&flat).unwrap();
assert_eq!(normalized.loss_flags, [0, 2, 4, 6]);
assert_eq!(
normalized
.probes
.iter()
.map(|probe| (probe.flag_measurement, probe.qubit))
.collect::<Vec<_>>(),
[(0, 0), (2, 1), (4, 0), (6, 0)]
);
let q0: Vec<_> = normalized
.probes
.iter()
.filter(|probe| probe.qubit == 0)
.collect();
assert!(
q0.windows(2)
.all(|pair| pair[1].onset_sites.last() > Some(&pair[0].readout_site))
);
}
#[test]
fn hand_specified_single_wire_envelope_and_loss_edge_are_exact() {
let circuit = compiled(concat!(
"QUBIT_COORDS(0,0) 0\n",
"R 0\n",
"X_ERROR(0.1) 0\n",
"LOSS(0.1) 0\n",
"ML 0\n",
"DETECTOR(0,0,0) rec[-1]\n",
"OBSERVABLE_INCLUDE(0) rec[-1]\n",
));
let actual: BTreeSet<_> = circuit.envelopes[0]
.candidates
.iter()
.map(|candidate| (candidate.detectors.clone(), candidate.observables.clone()))
.collect();
assert_eq!(
actual,
BTreeSet::from([(Vec::new(), Vec::new()), (vec![0], vec![0])])
);
assert_eq!(circuit.graph_edges.len(), 1);
assert_eq!(circuit.loss_edges, [vec![0]]);
}
#[test]
fn parallel_matching_edges_require_identical_labels() {
let compatible = vec![
GraphEdge {
node1: 0,
node2: Some(1),
observables: vec![0],
weight: 1.0,
kind: EdgeKind::SpaceLike,
},
GraphEdge {
node1: 1,
node2: Some(0),
observables: vec![0],
weight: 2.0,
kind: EdgeKind::SpaceLike,
},
];
assert!(validate_unambiguous_parallel_edges(&compatible).is_ok());
let mut ambiguous = compatible;
ambiguous[1].observables.clear();
let error = validate_unambiguous_parallel_edges(&ambiguous).unwrap_err();
assert_eq!(error.code, "unsupported_circuit");
assert!(error.message.contains("ambiguous observable labels"));
}
#[test]
fn matching_accepts_composites_but_rejects_unmapped_primitives_and_empty_edge_sets() {
let mut unmapped = compiled(PERSISTENT_CIRCUIT);
unmapped.envelopes[0].candidates = vec![Effect {
id: "composite".to_string(),
detectors: vec![0, 1, usize::MAX],
observables: vec![0],
weight: 0.0,
}];
unmapped.unmapped_loss_primitives[0] = vec!["X_ERROR at site 1".to_string()];
let error = CompiledMatching::new(&unmapped).err().unwrap();
assert_eq!(error.code, "unsupported_circuit");
assert!(error.message.contains("primitive loss effect"));
unmapped.unmapped_loss_primitives[0].clear();
assert!(CompiledMatching::new(&unmapped).is_ok());
let mut empty_map = compiled(PERSISTENT_CIRCUIT);
empty_map.envelopes[0].candidates = vec![Effect {
id: "identity".to_string(),
detectors: Vec::new(),
observables: Vec::new(),
weight: 0.0,
}];
empty_map.loss_edges[0].clear();
let error = CompiledMatching::new(&empty_map).err().unwrap();
assert_eq!(error.code, "unsupported_circuit");
assert!(error.message.contains("loss envelope"));
let mut time_like = CompiledMatching {
edges: vec![GraphEdge {
node1: 0,
node2: Some(1),
observables: vec![0],
weight: 2.0,
kind: EdgeKind::TimeLike,
}],
loss_edges: vec![vec![0]],
mean_weight: 2.0,
num_observables: 1,
cache: HashMap::new(),
cache_order: std::collections::VecDeque::new(),
cached_work: 0,
graph_builds: 0,
cache_hits: 0,
};
assert_eq!(
time_like
.decode(&singleton_syndrome(&[1, 1]), &[0])
.unwrap(),
[0]
);
}
#[test]
fn compile_and_decode_boundaries_report_structured_errors() {
let mut mismatched = dataset_for(PERSISTENT_CIRCUIT);
mismatched.manifest.circuit.detectors += 1;
let error = compile_circuit(&mismatched, DecoderKind::EnvelopeMatching)
.err()
.unwrap();
assert_eq!(error.code, "invalid_dataset");
assert!(error.message.contains("circuit counts"));
let no_observable = dataset_for(concat!(
"R 0\n",
"LOSS(0.1) 0\n",
"X_ERROR(0.1) 0\n",
"ML 0\n",
"DETECTOR(0,0,0) rec[-1]\n",
));
let error = compile_circuit(&no_observable, DecoderKind::EnvelopeMatching)
.err()
.unwrap();
assert_eq!(error.code, "unsupported_circuit");
assert!(error.message.contains("1..=64 observables"));
let circuit = compiled(PERSISTENT_CIRCUIT);
let wrong_width = BitTable::try_new(1, 1).unwrap();
let error = circuit.loss_aware_syndromes(&wrong_width).unwrap_err();
assert_eq!(error.code, "invalid_dataset");
assert!(error.message.contains("width"));
}
#[test]
fn output_paths_must_be_distinct_and_new() {
let root = tempfile::tempdir().unwrap();
let shared = root.path().join("shared");
let mut options = DecodeOptions {
decoder: DecoderKind::EnvelopeMatching,
dataset: root.path().join("dataset"),
predictions_out: shared.clone(),
stats_out: shared,
shot_timeout_ms: None,
};
let error = validate_output_paths(&options).unwrap_err();
assert_eq!(error.code, "invalid_arguments");
assert!(error.message.contains("different paths"));
fs::write(&options.predictions_out, b"occupied").unwrap();
options.stats_out = root.path().join("stats.json");
let error = validate_output_paths(&options).unwrap_err();
assert_eq!(error.code, "output_error");
assert!(error.message.contains("already exists"));
}
#[cfg(feature = "ilp")]
#[test]
fn stim_generated_fixture_compiles_and_matches_reference_kernels() {
const FIXTURE: &str =
include_str!("../tests/fixtures/stim_rotated_memory_z_d3_r2_loss_visible.stim");
let circuit = compiled(FIXTURE);
assert_eq!(circuit.envelopes.len(), 25);
assert!(
circuit
.envelopes
.iter()
.all(|envelope| !envelope.candidates.is_empty())
);
assert!(circuit.envelopes.iter().any(|envelope| {
envelope
.candidates
.iter()
.any(|candidate| !candidate.detectors.is_empty())
}));
CompiledMatching::new(&circuit).unwrap();
let zero_syndrome = vec![0u8; circuit.loss_aware_m2d.layout().num_detectors()];
let shots: Vec<(&[u8], Vec<usize>)> = vec![
(&zero_syndrome, vec![]),
(&zero_syndrome, vec![0]),
(&zero_syndrome, vec![7]),
(&zero_syndrome, vec![15]),
(&zero_syndrome, vec![24]),
(&zero_syndrome, vec![0, 12, 24]),
];
let mut mle = CompiledMle::new(&circuit, None).unwrap();
for (syndrome, losses) in &shots {
let actual = mask(&mle.decode(&singleton_syndrome(syndrome), losses).unwrap());
assert_eq!(actual, reference_mle(&circuit, syndrome, losses));
}
let shot_refs: Vec<(&[u8], &[usize])> = shots
.iter()
.map(|(syndrome, losses)| (*syndrome, losses.as_slice()))
.collect();
let mut matching = CompiledMatching::new(&circuit).unwrap();
let actual: Vec<_> = shot_refs
.iter()
.map(|(syndrome, losses)| {
mask(
&matching
.decode(&singleton_syndrome(syndrome), losses)
.unwrap(),
)
})
.collect();
assert_eq!(actual, reference_matching(&circuit, &shot_refs));
}
#[test]
fn native_benchmark_depth_midswap_circuits_compile_persistent_envelopes() {
for distance in [3, 5] {
let rounds = distance;
let text = rstim::codegen::rotated_memory_z_midswap(rstim::codegen::MidSwapConfig {
distance,
rounds,
before_round_data_depolarization: 0.001,
before_round_data_loss_probability: 0.0,
after_clifford_depolarization: 0.001,
before_measure_flip_probability: 0.001,
after_reset_flip_probability: 0.001,
operation_loss_probability: 0.002,
measurement_loss_probability: 0.003,
})
.unwrap();
let circuit = compiled(&text);
let loss_flags = rounds * (distance * distance - 1) + distance * distance;
assert_eq!(circuit.loss_flags.len(), loss_flags);
assert_eq!(circuit.envelopes.len(), loss_flags);
assert!(
circuit
.envelopes
.iter()
.all(|envelope| !envelope.candidates.is_empty())
);
assert!(circuit.envelopes.iter().any(|envelope| {
envelope
.candidates
.iter()
.any(|candidate| candidate.detectors.len() > 1)
}));
CompiledMatching::new(&circuit).unwrap();
}
}
}