use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
#[cfg(feature = "ilp")]
use renvelope::{
AtomLossCase, DecodeOutcome, Effect as ReferenceEffect, LossEnvelope as ReferenceLossEnvelope,
decode as decode_reference_mle,
};
use rstim::decoder_dataset::{
DecoderDatasetMode, ExportDecoderDatasetLogicalFlipConfig, LogicalFlip, LogicalPauli,
export_decoder_dataset_with_logical_flip,
};
use serde_json::Value;
const STIM_CIRCUIT: &str = include_str!("fixtures/stim_rotated_memory_z_d3_r2.stim");
const STIM_DEM: &str = include_str!("fixtures/stim_rotated_memory_z_d3_r2.dem");
const LOSS_VISIBLE_CIRCUIT: &str =
include_str!("fixtures/stim_rotated_memory_z_d3_r2_loss_visible.stim");
fn rustqec() -> Command {
Command::new(env!("CARGO_BIN_EXE_rustqec"))
}
fn available_decoders() -> &'static [&'static str] {
#[cfg(feature = "ilp")]
return &["envelope-matching", "envelope-mle"];
#[cfg(not(feature = "ilp"))]
&["envelope-matching"]
}
fn run_decode(dataset: &Path, decoder: &str, root: &Path) -> std::process::Output {
rustqec()
.args([
"decode",
"--decoder",
decoder,
"--dataset",
dataset.to_str().unwrap(),
"--out",
root.join(format!("{decoder}.b8")).to_str().unwrap(),
"--stats-out",
root.join(format!("{decoder}.json")).to_str().unwrap(),
])
.output()
.unwrap()
}
#[cfg(feature = "ilp")]
fn run_decode_with_timeout(
dataset: &Path,
decoder: &str,
root: &Path,
shot_timeout_ms: u64,
) -> std::process::Output {
rustqec()
.args([
"decode",
"--decoder",
decoder,
"--dataset",
dataset.to_str().unwrap(),
"--out",
root.join(format!("{decoder}.b8")).to_str().unwrap(),
"--stats-out",
root.join(format!("{decoder}.json")).to_str().unwrap(),
"--shot-timeout-ms",
&shot_timeout_ms.to_string(),
])
.output()
.unwrap()
}
fn sha256_hex(bytes: &[u8]) -> String {
use sha2::{Digest, Sha256};
Sha256::digest(bytes)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn current_rstim_fixture(family: &str) -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/current_rstim_atom_loss")
.join(family)
}
#[cfg(feature = "ilp")]
fn measurement_table(bytes: &[u8], bit_count: usize) -> rstim::sim::bit_table::BitTable {
let mut table = rstim::sim::bit_table::BitTable::try_new(bit_count, 1).unwrap();
for bit in 0..bit_count {
if bytes[bit / 8] & (1 << (bit % 8)) != 0 {
table.set(bit, 0, true);
}
}
table
}
#[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 reference_prediction(case: &AtomLossCase) -> Vec<usize> {
match decode_reference_mle(case).unwrap() {
DecodeOutcome::Optimal(result) => result.predicted_observables,
DecodeOutcome::Infeasible(_) => panic!("reference MLE unexpectedly infeasible"),
}
}
fn assert_current_rstim_atom_loss_decodes(family: &str) {
let dataset = current_rstim_fixture(family);
let circuit = fs::read_to_string(dataset.join("circuit.stim")).unwrap();
assert!(circuit.contains("QUBIT_COORDS"), "{family}");
if family == "conventional" {
assert!(circuit.contains("SHIFT_COORDS"), "{family}");
}
let manifest: Value =
serde_json::from_slice(&fs::read(dataset.join("manifest.json")).unwrap()).unwrap();
let root = tempfile::tempdir().unwrap();
let output = run_decode(&dataset, "envelope-matching", root.path());
assert!(
output.status.success(),
"{family}: {}",
String::from_utf8_lossy(&output.stderr)
);
let predictions = fs::read(root.path().join("envelope-matching.b8")).unwrap();
let shots = manifest["shots"].as_u64().unwrap() as usize;
let observables = manifest["circuit"]["observables"].as_u64().unwrap() as usize;
assert_eq!(
predictions.len(),
shots * observables.div_ceil(8),
"{family}"
);
if observables % 8 != 0 {
let padding_mask = !((1u8 << (observables % 8)) - 1);
assert!(
predictions
.chunks_exact(observables.div_ceil(8))
.all(|row| row.last().unwrap() & padding_mask == 0),
"{family}: prediction padding bits must be zero"
);
}
let stats: Value =
serde_json::from_slice(&fs::read(root.path().join("envelope-matching.json")).unwrap())
.unwrap();
assert_eq!(stats["shot_count"], manifest["shots"], "{family}");
assert_eq!(
stats["circuit_sha256"], manifest["circuit"]["sha256"],
"{family}"
);
assert_eq!(stats["primitive_probe_count"], 15_345, "{family}");
assert_eq!(
stats["primitive_symptom_terms"],
if family == "conventional" {
29_360
} else {
29_128
},
"{family}"
);
assert_eq!(stats["loss_envelope_candidate_count"], 0, "{family}");
}
#[test]
fn current_rstim_atom_loss_conventional_decodes_unmodified() {
assert_current_rstim_atom_loss_decodes("conventional");
}
#[test]
fn current_rstim_atom_loss_midswap_decodes_unmodified() {
assert_current_rstim_atom_loss_decodes("midswap");
}
#[cfg(feature = "ilp")]
#[test]
fn current_rstim_atom_loss_midswap_envelope_mle_decodes_unmodified() {
let dataset = current_rstim_fixture("midswap");
let root = tempfile::tempdir().unwrap();
let original_out = root.path().join("original");
let output = run_decode_with_timeout(&dataset, "envelope-mle", &original_out, 2_000);
assert!(
output.status.success(),
"{}",
String::from_utf8_lossy(&output.stderr)
);
let predictions = fs::read(original_out.join("envelope-mle.b8")).unwrap();
assert_eq!(predictions.len(), 2);
let stats: Value =
serde_json::from_slice(&fs::read(original_out.join("envelope-mle.json")).unwrap()).unwrap();
assert_eq!(stats["decoder"], "envelope-mle");
assert_eq!(stats["shot_count"], 2);
assert_eq!(stats["timeout_count"], 0);
assert_eq!(stats["mle_model_builds"], 2);
let circuit = fs::read_to_string(dataset.join("circuit.stim")).unwrap();
let instrs = rstim::validation::parse_and_validate(&circuit).unwrap();
let transform = rstim::m2d::CompiledLossAwareM2d::new(&instrs).unwrap();
let mut shots = fs::read(dataset.join("shots.b8")).unwrap();
let row_bytes = shots.len() / 2;
let pair = transform
.layout()
.loss_visible_measurements()
.iter()
.find(|pair| shots[pair.flag / 8] & (1 << (pair.flag % 8)) != 0)
.expect("fixture must contain a flagged measurement in its first shot");
assert!(pair.value < row_bytes * 8);
shots[pair.value / 8] ^= 1 << (pair.value % 8);
let mutated_dataset = root.path().join("mutated-dataset");
fs::create_dir(&mutated_dataset).unwrap();
fs::write(mutated_dataset.join("circuit.stim"), &circuit).unwrap();
fs::write(mutated_dataset.join("shots.b8"), &shots).unwrap();
let mut manifest: Value =
serde_json::from_slice(&fs::read(dataset.join("manifest.json")).unwrap()).unwrap();
let shots_sha = sha256_hex(&shots);
manifest["shots_file"]["sha256"] = Value::String(shots_sha.clone());
let dataset_id_material = format!(
"format=rstim_decoder_dataset\nschema_version={}\nmode={}\ncircuit_sha256={}\nshots={}\nrow_bits={}\nshots_b8_sha256={}\n",
manifest["schema_version"].as_u64().unwrap(),
manifest["mode"].as_str().unwrap(),
manifest["circuit"]["sha256"].as_str().unwrap(),
manifest["shots"].as_u64().unwrap(),
manifest["row"]["bits"].as_u64().unwrap(),
shots_sha,
);
manifest["dataset_id"] = Value::String(sha256_hex(dataset_id_material.as_bytes()));
fs::write(
mutated_dataset.join("manifest.json"),
serde_json::to_vec_pretty(&manifest).unwrap(),
)
.unwrap();
let mutated_out = root.path().join("mutated");
let output = run_decode_with_timeout(&mutated_dataset, "envelope-mle", &mutated_out, 2_000);
assert!(
output.status.success(),
"{}",
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(
fs::read(mutated_out.join("envelope-mle.b8")).unwrap(),
predictions,
"a flagged measurement's paired value is an arbitrary placeholder"
);
}
#[cfg(feature = "ilp")]
#[test]
fn current_rstim_atom_loss_midswap_envelope_mle_uses_canonical_detectors() {
let dataset = current_rstim_fixture("midswap_canonical_mle");
let manifest: Value =
serde_json::from_slice(&fs::read(dataset.join("manifest.json")).unwrap()).unwrap();
let provenance: Value =
serde_json::from_slice(&fs::read(dataset.join("provenance.json")).unwrap()).unwrap();
let circuit = fs::read_to_string(dataset.join("circuit.stim")).unwrap();
let measurements = fs::read(dataset.join("shots.b8")).unwrap();
let bit_count = manifest["row"]["bits"].as_u64().unwrap() as usize;
let instrs = rstim::validation::parse_and_validate(&circuit).unwrap();
let transform = rstim::m2d::CompiledLossAwareM2d::new(&instrs).unwrap();
let original = transform
.convert(&measurement_table(&measurements, bit_count))
.unwrap()
.shots
.pop()
.unwrap();
let original_detector_count = provenance["original_detector_count"].as_u64().unwrap() as usize;
let surviving_check_count = provenance["surviving_check_count"].as_u64().unwrap() as usize;
assert_eq!(
original.canonical_detector_values.len(),
original_detector_count
);
assert_eq!(original.checks.len(), surviving_check_count);
assert_eq!(original_detector_count, manifest["circuit"]["detectors"]);
assert!(surviving_check_count < original_detector_count);
let active_loss_indices: Vec<_> = transform
.layout()
.loss_visible_measurements()
.iter()
.enumerate()
.filter_map(|(loss, pair)| {
(measurements[pair.flag / 8] & (1 << (pair.flag % 8)) != 0).then_some(loss)
})
.collect();
assert_eq!(
active_loss_indices,
provenance["active_loss_indices"]
.as_array()
.unwrap()
.iter()
.map(|value| value.as_u64().unwrap() as usize)
.collect::<Vec<_>>()
);
let reference_bytes =
zstd::decode_all(fs::File::open(dataset.join("reference_cases.json.zst")).unwrap())
.unwrap();
assert_eq!(
sha256_hex(&fs::read(dataset.join("reference_cases.json.zst")).unwrap()),
provenance["reference_cases_sha256"]
);
let reference: Value = serde_json::from_slice(&reference_bytes).unwrap();
assert_eq!(
reference["source_shot_index"],
provenance["source_shot_index_zero_based"]
);
assert_eq!(
reference["active_loss_indices"],
provenance["active_loss_indices"]
);
assert_eq!(
reference["original_detector_count"],
provenance["original_detector_count"]
);
assert_eq!(
reference["surviving_check_count"],
provenance["surviving_check_count"]
);
let canonical_case: AtomLossCase =
serde_json::from_value(reference["canonical_case"].clone()).unwrap();
let surviving_case: AtomLossCase =
serde_json::from_value(reference["surviving_check_case"].clone()).unwrap();
assert_eq!(canonical_case.num_detectors, original_detector_count);
assert_eq!(
canonical_case.observed_detectors,
original
.canonical_detector_values
.iter()
.enumerate()
.filter_map(|(detector, &value)| value.then_some(detector))
.collect::<Vec<_>>()
);
assert_eq!(
project_reference_case(&canonical_case, &original.checks),
surviving_case,
"the negative control must be the old projection of the same effects"
);
let expected = provenance["expected_observables"]
.as_array()
.unwrap()
.iter()
.map(|value| value.as_u64().unwrap() as usize)
.collect::<Vec<_>>();
assert_eq!(reference_prediction(&canonical_case), expected);
assert_ne!(
reference_prediction(&surviving_case),
expected,
"the pinned row must distinguish the old surviving-check formulation"
);
let root = tempfile::tempdir().unwrap();
let native_out = root.path().join("native");
let output = run_decode(&dataset, "envelope-mle", &native_out);
assert!(
output.status.success(),
"{}",
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(fs::read(native_out.join("envelope-mle.b8")).unwrap(), [1]);
let stats: Value =
serde_json::from_slice(&fs::read(native_out.join("envelope-mle.json")).unwrap()).unwrap();
assert_eq!(stats["mle_detector_rows"], manifest["circuit"]["detectors"]);
let mut flipped_measurements = measurements.clone();
let mut flipped_count = 0usize;
for pair in transform.layout().loss_visible_measurements() {
if measurements[pair.flag / 8] & (1 << (pair.flag % 8)) != 0 {
flipped_measurements[pair.value / 8] ^= 1 << (pair.value % 8);
flipped_count += 1;
}
}
assert_eq!(
flipped_count, 2,
"the fixture must retain both observed losses"
);
let flipped = transform
.convert(&measurement_table(&flipped_measurements, bit_count))
.unwrap()
.shots
.pop()
.unwrap();
assert_eq!(
flipped.canonical_detector_values, original.canonical_detector_values,
"canonical detectors must ignore every flagged value placeholder"
);
let mutated_dataset = root.path().join("mutated-dataset");
fs::create_dir(&mutated_dataset).unwrap();
fs::write(mutated_dataset.join("circuit.stim"), &circuit).unwrap();
fs::write(mutated_dataset.join("shots.b8"), &flipped_measurements).unwrap();
let mut mutated_manifest = manifest.clone();
let shots_sha = sha256_hex(&flipped_measurements);
mutated_manifest["shots_file"]["sha256"] = Value::String(shots_sha.clone());
let dataset_id_material = format!(
"format=rstim_decoder_dataset\nschema_version=1\nmode=measurements_blinded\ncircuit_sha256={}\nshots=1\nrow_bits={}\nshots_b8_sha256={}\n",
manifest["circuit"]["sha256"].as_str().unwrap(),
bit_count,
shots_sha,
);
mutated_manifest["dataset_id"] = Value::String(sha256_hex(dataset_id_material.as_bytes()));
fs::write(
mutated_dataset.join("manifest.json"),
serde_json::to_vec_pretty(&mutated_manifest).unwrap(),
)
.unwrap();
let mutated_out = root.path().join("mutated");
let output = run_decode(&mutated_dataset, "envelope-mle", &mutated_out);
assert!(
output.status.success(),
"{}",
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(
fs::read(mutated_out.join("envelope-mle.b8")).unwrap(),
[1],
"flipping every flagged placeholder must preserve the native prediction"
);
}
#[cfg(feature = "ilp")]
#[test]
fn current_rstim_atom_loss_conventional_envelope_mle_rejects_candidate_explosion() {
let dataset = current_rstim_fixture("conventional");
let root = tempfile::tempdir().unwrap();
let output = run_decode_with_timeout(&dataset, "envelope-mle", root.path(), 2_000);
assert!(!output.status.success());
let error: Value = serde_json::from_slice(&output.stderr).unwrap();
assert_eq!(error["error"]["code"], "unsupported_circuit");
assert!(
error["error"]["message"]
.as_str()
.unwrap()
.contains("exceeds candidate limit")
);
assert!(!root.path().join("envelope-mle.b8").exists());
assert!(!root.path().join("envelope-mle.json").exists());
}
#[test]
fn current_rstim_atom_loss_rejects_non_metadata_without_outputs() {
let root = tempfile::tempdir().unwrap();
let dataset = root.path().join("unsupported-dataset");
fs::create_dir(&dataset).unwrap();
let circuit = fs::read_to_string(
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/current_rstim_atom_loss/unsupported_non_metadata.stim"),
)
.unwrap();
let stats = rstim::stats::summarize_text(&circuit).unwrap();
let shots = vec![0u8; stats.num_measurements.div_ceil(8)];
fs::write(dataset.join("circuit.stim"), &circuit).unwrap();
fs::write(dataset.join("shots.b8"), &shots).unwrap();
let circuit_sha = sha256_hex(circuit.as_bytes());
let shots_sha = sha256_hex(&shots);
let dataset_id = sha256_hex(
format!(
"format=rstim_decoder_dataset\nschema_version=1\nmode=measurements_blinded\ncircuit_sha256={circuit_sha}\nshots=1\nrow_bits={}\nshots_b8_sha256={shots_sha}\n",
stats.num_measurements
)
.as_bytes(),
);
let manifest = serde_json::json!({
"format": "rstim_decoder_dataset",
"schema_version": 1,
"dataset_id": dataset_id,
"mode": "measurements_blinded",
"shots": 1,
"row": {
"kind": "measurements",
"bits": stats.num_measurements,
"encoding": "b8",
"bit_order": "lsb_first",
"bytes_per_shot": shots.len()
},
"circuit": {
"file": "circuit.stim",
"sha256": circuit_sha,
"measurements": stats.num_measurements,
"detectors": stats.num_detectors,
"observables": stats.num_observables,
"sweep_bits": stats.num_sweep_bits
},
"shots_file": {
"file": "shots.b8",
"sha256": shots_sha,
"bits": stats.num_measurements,
"bytes_per_shot": shots.len()
}
});
fs::write(
dataset.join("manifest.json"),
serde_json::to_vec_pretty(&manifest).unwrap(),
)
.unwrap();
let output = run_decode(&dataset, "envelope-matching", root.path());
assert!(!output.status.success());
let error: Value = serde_json::from_slice(&output.stderr).unwrap();
assert_eq!(error["error"]["code"], "unsupported_circuit");
assert!(error["error"]["message"].as_str().unwrap().contains("S"));
assert!(!root.path().join("envelope-matching.b8").exists());
assert!(!root.path().join("envelope-matching.json").exists());
}
#[test]
fn stim_generated_memory_z_decodes_end_to_end() {
let root = tempfile::tempdir().unwrap();
let public = root.path().join("public");
let private = root.path().join("private");
export_decoder_dataset_with_logical_flip(ExportDecoderDatasetLogicalFlipConfig {
circuit_text: LOSS_VISIBLE_CIRCUIT.to_string(),
shots: 16,
mode: DecoderDatasetMode::MeasurementsBlinded,
logical_flip: Some(LogicalFlip {
pauli: LogicalPauli::X,
qubits: vec![1, 8, 15],
}),
public_out: public.clone(),
private_out: private.clone(),
seed: Some(42),
error_trace: false,
})
.unwrap();
let answers = fs::read(private.join("answers.b8")).unwrap();
for &decoder in available_decoders() {
let output = run_decode(&public, decoder, root.path());
assert!(
output.status.success(),
"{decoder}: {}",
String::from_utf8_lossy(&output.stderr)
);
let predictions = fs::read(root.path().join(format!("{decoder}.b8"))).unwrap();
assert_eq!(predictions.len(), answers.len(), "{decoder}");
assert!(
predictions.iter().all(|byte| byte & 0xfe == 0),
"{decoder}: padding bits must be zero"
);
let stats: Value =
serde_json::from_slice(&fs::read(root.path().join(format!("{decoder}.json"))).unwrap())
.unwrap();
assert_eq!(stats["shot_count"], 16, "{decoder}");
assert_eq!(stats["circuit_compilations"], 1, "{decoder}");
assert!(
stats["distinct_loss_patterns"].as_u64().unwrap() > 1,
"{decoder}: dataset must exercise several loss patterns"
);
if decoder == "envelope-mle" {
for shot in 0..answers.len() {
assert_eq!(
predictions[shot] & 1,
answers[shot] & 1,
"envelope-mle shot={shot}"
);
}
}
}
}
#[test]
fn rstim_dem_matches_stim_on_fixture_circuit() {
let instrs = rstim::validation::parse_and_validate(STIM_CIRCUIT).unwrap();
let dem = rstim::error_analyzer::ErrorAnalyzer::circuit_to_dem(&instrs).unwrap();
let expected = rstim::dem::DetectorErrorModel::parse(STIM_DEM).unwrap();
assert_eq!(dem.num_detectors(), expected.num_detectors());
assert_eq!(dem.num_observables(), expected.num_observables());
assert_eq!(
error_signature(&dem.to_string()),
error_signature(&expected.to_string()),
"rstim and Stim disagree on the fixture circuit's DEM"
);
}
fn error_signature(dem_text: &str) -> Vec<(i128, Vec<Vec<String>>)> {
use rstim::dem::{DemInstruction, DemTarget};
let dem = rstim::dem::DetectorErrorModel::parse(dem_text).unwrap();
let mut signature = Vec::new();
for instruction in dem.instructions() {
let DemInstruction::Error {
probability,
targets,
} = instruction
else {
continue;
};
let mut components: Vec<Vec<String>> = Vec::new();
let mut current: Vec<String> = Vec::new();
for target in targets {
match target {
DemTarget::Separator => {
current.sort();
components.push(std::mem::take(&mut current));
}
DemTarget::Detector(index) => current.push(format!("D{index}")),
DemTarget::Observable(index) => current.push(format!("L{index}")),
}
}
current.sort();
components.push(current);
components.sort();
let quantized = (probability * 1e15).round() as i128;
signature.push((quantized, components));
}
signature.sort();
signature
}
#[test]
fn spec_invariant_violations_are_rejected_on_the_fixture() {
let broken = format!("{LOSS_VISIBLE_CIRCUIT}H 1\n");
let root = tempfile::tempdir().unwrap();
let stats = rstim::stats::summarize_text(&broken).unwrap();
let row_bytes = stats.num_measurements.div_ceil(8);
let shots = vec![0u8; row_bytes];
let dataset = root.path().join("dataset");
fs::create_dir(&dataset).unwrap();
fs::write(dataset.join("circuit.stim"), &broken).unwrap();
fs::write(dataset.join("shots.b8"), &shots).unwrap();
let circuit_sha = sha256_hex(broken.as_bytes());
let shots_sha = sha256_hex(&shots);
let dataset_id = sha256_hex(
format!(
"format=rstim_decoder_dataset\nschema_version=1\nmode=measurements_blinded\ncircuit_sha256={circuit_sha}\nshots=1\nrow_bits={}\nshots_b8_sha256={shots_sha}\n",
stats.num_measurements
)
.as_bytes(),
);
let manifest = serde_json::json!({
"format": "rstim_decoder_dataset",
"schema_version": 1,
"dataset_id": dataset_id,
"mode": "measurements_blinded",
"shots": 1,
"row": {
"kind": "measurements",
"bits": stats.num_measurements,
"encoding": "b8",
"bit_order": "lsb_first",
"bytes_per_shot": row_bytes
},
"circuit": {
"file": "circuit.stim",
"sha256": circuit_sha,
"measurements": stats.num_measurements,
"detectors": stats.num_detectors,
"observables": stats.num_observables,
"sweep_bits": stats.num_sweep_bits
},
"shots_file": {
"file": "shots.b8",
"sha256": shots_sha,
"bits": stats.num_measurements,
"bytes_per_shot": row_bytes
}
});
fs::write(
dataset.join("manifest.json"),
serde_json::to_vec_pretty(&manifest).unwrap(),
)
.unwrap();
let output = run_decode(&dataset, "envelope-matching", root.path());
assert!(!output.status.success());
let value: Value = serde_json::from_slice(&output.stderr).unwrap();
assert_eq!(value["error"]["code"], "unsupported_circuit");
assert!(
value["error"]["message"]
.as_str()
.unwrap()
.contains("ML must be terminal"),
"{}",
value["error"]["message"]
);
}
#[test]
fn fixture_annotation_is_applied_consistently() {
let mut loss_visible_readouts = 0usize;
for line in LOSS_VISIBLE_CIRCUIT.lines() {
if line.starts_with("MRL ") || line.starts_with("ML ") {
loss_visible_readouts += line.split_whitespace().count() - 1;
}
}
assert_eq!(
loss_visible_readouts, 25,
"every one of the 25 readouts is loss-visible"
);
let annotated = rstim::stats::summarize_text(LOSS_VISIBLE_CIRCUIT).unwrap();
assert_eq!(
annotated.num_measurements, 50,
"flag+value interleave doubles the record count"
);
assert_eq!(annotated.num_detectors, 16);
assert_eq!(annotated.num_observables, 1);
let original = rstim::stats::summarize_text(STIM_CIRCUIT).unwrap();
assert_eq!(original.num_measurements, 25);
}