rstim 0.4.0

Stim-aligned stabilizer circuit simulator and detector error model toolkit
Documentation
use super::*;
use rand::{RngCore, SeedableRng, rngs::SmallRng};
use std::io::Write;

struct NoCallerDraw;
impl RngCore for NoCallerDraw {
    fn next_u32(&mut self) -> u32 {
        panic!("recorded reference requested caller RNG")
    }
    fn next_u64(&mut self) -> u64 {
        panic!("recorded reference requested caller RNG")
    }
    fn fill_bytes(&mut self, _: &mut [u8]) {
        panic!("recorded reference requested caller RNG")
    }
    fn try_fill_bytes(&mut self, _: &mut [u8]) -> Result<(), rand::Error> {
        panic!("recorded reference requested caller RNG")
    }
}
fn emit(tag: &str, value: serde_json::Value) {
    println!("{tag} {value}");
    std::io::stdout().flush().unwrap();
}
fn fold_rows(rows: &[NearCliffordShot], observable: u32) -> NearCliffordPostselectedCounts {
    let mut out = NearCliffordPostselectedCounts {
        attempted: rows.len(),
        ..Default::default()
    };
    for row in rows {
        if row.detectors.iter().any(|v| *v) {
            continue;
        }
        out.accepted += 1;
        let logical = row
            .observables
            .iter()
            .filter(|(id, _)| *id == observable)
            .fold(false, |a, (_, b)| a ^ b);
        out.logical_errors += usize::from(logical);
    }
    out
}

#[test]
fn eager_original_packets_match_each_recorded_quantum_row_and_rng() {
    for (workload, text, seed) in [
        (
            "distillation",
            include_str!(
                "../../../benchmarks/near_clifford/application_counts/fixtures/distillation.stim"
            ),
            0x5ea6_0000_0000_0001u64,
        ),
        (
            "msc_d5",
            include_str!(
                "../../../benchmarks/near_clifford/application_counts/fixtures/msc_d5_inject_cultivate_p1e-3.stim"
            ),
            0x5ea6_0000_0000_0002u64,
        ),
    ] {
        for arithmetic in [
            CompiledRotationArithmetic::Strict,
            CompiledRotationArithmetic::Fused,
        ] {
            let plan = CompiledNearCliffordExecutor::compile_text_with_arithmetic(text, arithmetic)
                .unwrap();
            let mut eager = plan.prepare_eager_postselected_sampler().unwrap();
            eager.sampler.observe_lazy_error_producer = true;
            let mut rng = SmallRng::seed_from_u64(seed);
            let mut frozen = rng.clone();
            let tapes = scalar_prepared_tape_tests::draw_frozen_packet_rows(
                &plan.random_kinds,
                64,
                &mut frozen,
            );
            let cell = serde_json::json!({"workload":workload,"arithmetic":format!("{arithmetic:?}"),"seed":seed,"shots":64});
            emit("EAGER_BEGIN", cell.clone());
            let result = eager.sample_postselected_counts(64, 0, &mut rng);
            let observed = eager.sampler.last_packet_error_producer.as_ref();
            emit(
                "EAGER_PRODUCER",
                serde_json::json!({"cell":cell,"tapes":observed.map(|o|&o.rows),
                "lanes":observed.map(|o|o.lanes),"coherent":observed.map(|o|o.coherent),
                "noise_admitted":observed.map(|o|o.noise_admitted),"rejected_mask":eager.sampler.last_eager_rejected_mask,
                "result":result.as_ref().map(|r|serde_json::json!({"attempted":r.attempted,"accepted":r.accepted,"logical_errors":r.logical_errors})).map_err(|s|s.as_str())}),
            );
            let actual = result.unwrap();
            let observed = observed.unwrap();
            assert_eq!(observed.rows, tapes);
            assert_eq!(observed.lanes, 64);
            assert!(eager.predicate.get().unwrap().is_some());
            let reject = eager.sampler.last_eager_rejected_mask;
            assert_ne!(
                reject, 0,
                "new eager path must actually mark original-circuit lanes"
            );
            let mut reference = plan.prepare_sampler_with_cache_budget(0).unwrap();
            let mut rows = Vec::new();
            for (lane, tape) in tapes.iter().enumerate() {
                emit(
                    "EAGER_REFERENCE_BEGIN",
                    serde_json::json!({"cell":cell,"lane":lane}),
                );
                let mut no_rng = NoCallerDraw;
                let mut recorded = RowRandom::recorded(tape, &mut no_rng);
                let row = reference.row_with_random(&[], &mut recorded).unwrap();
                emit(
                    "EAGER_REFERENCE_ROW",
                    serde_json::json!({"cell":cell,"lane":lane,
                    "cursor":recorded.cursor,"proposed_reject":reject>>lane&1!=0,
                    "measurements":row.measurements,"detectors":row.detectors,"observables":row.observables}),
                );
                assert_eq!(recorded.cursor, plan.random_kinds.len());
                if reject >> lane & 1 != 0 {
                    assert!(
                        row.detectors.iter().any(|v| *v),
                        "{workload}/{arithmetic:?}/lane{lane}"
                    );
                }
                rows.push(row);
            }
            let expected = fold_rows(&rows, 0);
            assert_eq!(actual, expected);
            let a: Vec<_> = (0..16).map(|_| rng.next_u64()).collect();
            let b: Vec<_> = (0..16).map(|_| frozen.next_u64()).collect();
            emit(
                "EAGER_CELL_RESULT",
                serde_json::json!({"cell":cell,"rejected_mask":reject,
                "actual":{"attempted":actual.attempted,"accepted":actual.accepted,"logical_errors":actual.logical_errors},
                "reference":{"attempted":expected.attempted,"accepted":expected.accepted,"logical_errors":expected.logical_errors},
                "actual_next16":a,"frozen_next16":b}),
            );
            assert_eq!(a, b);
        }
    }
}

#[test]
fn eager_tail_mixed_output_zero_and_optional_decline_keep_success_streams() {
    let text =
        "X_ERROR(0.125) 0\nM 0\nDETECTOR rec[-1]\nH 1\nT 1\nMX 1\nOBSERVABLE_INCLUDE(0) rec[-1]\n";
    for arithmetic in [
        CompiledRotationArithmetic::Strict,
        CompiledRotationArithmetic::Fused,
    ] {
        let plan =
            CompiledNearCliffordExecutor::compile_text_with_arithmetic(text, arithmetic).unwrap();
        for cache in [0, DEFAULT_CACHE_BYTE_BUDGET] {
            let mut eager = plan
                .prepare_eager_postselected_sampler_with_cache_budget(cache)
                .unwrap();
            let mut original = plan.prepare_sampler_with_cache_budget(cache).unwrap();
            let mut a = SmallRng::seed_from_u64(0x5ea6_1000 + cache as u64);
            let mut b = a.clone();
            assert!(eager.sample_postselected_counts(0, 7, &mut a).is_err());
            assert!(eager.predicate.get().is_none());
            assert_eq!(
                eager
                    .sample_postselected_counts(0, 0, &mut a)
                    .unwrap()
                    .attempted,
                0
            );
            assert!(eager.predicate.get().is_none());
            for shots in [1, 17, 32, 63, 64, 65] {
                let expected = original
                    .sample_postselected_counts(shots, 0, &mut b)
                    .unwrap();
                let actual = eager.sample_postselected_counts(shots, 0, &mut a).unwrap();
                assert_eq!(actual, expected, "{arithmetic:?}/cache{cache}/shots{shots}");
                assert_eq!(a.clone().next_u64(), b.clone().next_u64());
                assert_eq!(
                    eager.sample_measurements_u8(3, &mut a).unwrap(),
                    original.sample_measurements_u8(3, &mut b).unwrap()
                );
                assert_eq!(a.clone().next_u64(), b.clone().next_u64());
            }
        }
        let mut declined = plan.clone();
        declined.counts_plan_budget = 0;
        let mut a = SmallRng::seed_from_u64(0x5ea6_2000);
        let mut b = a.clone();
        let mut eager = declined.prepare_eager_postselected_sampler().unwrap();
        let mut original = declined.prepare_sampler().unwrap();
        assert_eq!(
            eager.sample_postselected_counts(64, 0, &mut a).unwrap(),
            original.sample_postselected_counts(64, 0, &mut b).unwrap()
        );
        assert!(eager.predicate.get().unwrap().is_none());
        assert_eq!(a.next_u64(), b.next_u64());
    }
    emit(
        "EAGER_CONTROL_RESULT",
        serde_json::json!({"tail_sizes":[1,17,32,63,64,65],"cache_budgets":[0,DEFAULT_CACHE_BYTE_BUDGET],"modes":["Strict","Fused"],"zero_and_missing_observable":true,"mixed_count_records":true,"quota_decline":true,"performance_or_SOTA":false}),
    );
}