stimcircuit 0.1.0

A Rust library for parsing quantum circuits in the Stim format.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

This Rust crate provides a simple parser for [stim](https://github.com/quantumlib/Stim) circuit files.

## Basic usage

```rust
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

```rust
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);
}
```