stimcircuit 0.1.0

This Rust crate provides a simple parser for stim circuit files.

Basic usage

use stimcircuit::{parse_string, Arg, Circuit, Gate, ParseError, Target};

fn main() {
    let input = r#"
    REPEAT 10 {
        X 0 # comment
        Y 1
    }
    "#;
    let result: Result<Circuit, ParseError> = parse_string(input);
    assert!(
        result.is_ok(),
        "Failed to parse simple stim file:\n{:}",
        result.unwrap_err().message
    );

    let circuit = result.unwrap();
    assert_eq!(circuit.instructions().len(), 1);
    assert_eq!(circuit.instructions()[0].gate(), Gate::REPEAT);
    assert_eq!(circuit.instructions()[0].args()[0], Arg::Index(10));

    let circuit1 = circuit.instructions()[0].block().unwrap();
    assert_eq!(circuit1.instructions().len(), 2);
    assert_eq!(circuit1.instructions()[0].gate(), Gate::X);
    assert_eq!(
        circuit1.instructions()[0].targets()[0],
        Target::Qubit(0, false)
    );
    assert_eq!(circuit1.instructions()[1].gate(), Gate::Y);
    assert_eq!(
        circuit1.instructions()[1].targets()[0],
        Target::Qubit(1, false)
    );

    println!("Stim circuit parsed successfully.");
}

Manual circuit construction and unrolling

use stimcircuit::{Circuit, Gate, Target};

fn main() {
    let mut circuit = Circuit::new();
    let mut block = Circuit::new();
    block.append(Gate::X, Box::new([Target::Qubit(0, false)]), Box::new([]));
    block.append(Gate::Y, Box::new([Target::Qubit(1, false)]), Box::new([]));
    let mut nested_block = Circuit::new();
    nested_block.append(Gate::Z, Box::new([Target::Qubit(2, false)]), Box::new([]));
    block.append_repeat(2, nested_block);
    circuit.append_repeat(3, block);
    circuit.append(Gate::H, Box::new([Target::Qubit(0, false)]), Box::new([]));

    let unrolled = circuit.unrolled();
    assert_eq!(unrolled.len(), 13);
    assert_eq!(unrolled.instructions()[0].gate(), Gate::X);
    assert_eq!(unrolled.instructions()[1].gate(), Gate::Y);
    assert_eq!(unrolled.instructions()[2].gate(), Gate::Z);
    assert_eq!(unrolled.instructions()[3].gate(), Gate::Z);
    assert_eq!(unrolled.instructions()[4].gate(), Gate::X);
    assert_eq!(unrolled.instructions()[5].gate(), Gate::Y);
    assert_eq!(unrolled.instructions()[6].gate(), Gate::Z);
    assert_eq!(unrolled.instructions()[7].gate(), Gate::Z);
    assert_eq!(unrolled.instructions()[8].gate(), Gate::X);
    assert_eq!(unrolled.instructions()[9].gate(), Gate::Y);
    assert_eq!(unrolled.instructions()[10].gate(), Gate::Z);
    assert_eq!(unrolled.instructions()[11].gate(), Gate::Z);
    assert_eq!(unrolled.instructions()[12].gate(), Gate::H);
}