q-rust 0.1.1

A modular quantum transpiler and QASM 2.0 parser written in Rust.
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
78
79
80
81
82
83

# Q-Rust

A **quantum transpiler** written in Rust, designed to parse, analyze, and optimize quantum circuits.

[![Crates.io](https://img.shields.io/crates/v/q-rust.svg)](https://crates.io/crates/q-rust)
[![Build Status](https://github.com/Arturacu/Q-Rust/workflows/Rust/badge.svg)](https://github.com/Arturacu/Q-Rust/actions)

## Features

- **Robust QASM 2.0 Support**: Parse OpenQASM 2.0 files with full support for standard gates, parameterized rotations, and measurements.
- **Modular Intermediate Representation (IR)**: A flexible, type-safe IR built for easy analysis and transformation.
- **Graph-Based Backend Topology**: Define custom hardware backends with arbitrary connectivity using efficient graph structures (`petgraph`).

## Error Handling

Q-Rust enforces strict **OpenQASM 2.0** compliance. It will explicitly reject:

- **OpenQASM 3.0**: Files starting with `OPENQASM 3.0;` will trigger an `Unsupported OpenQASM version` error.
- **Missing Headers**: Files must start with a valid `OPENQASM 2.0;` header.
- **Missing Measurements**: The `Circuit::validate()` method warns if a circuit has no measurements, as it will not produce output on real hardware.

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
q-rust = "0.1"
```

## Usage

### Parsing QASM

```rust
use q_rust::parser::parse_qasm;

fn main() {
    let qasm_code = r#"
        OPENQASM 2.0;
        include "qelib1.inc";
        qreg q[2];
        creg c[2];
        h q[0];
        cx q[0], q[1];
        measure q[1] -> c[1];
    "#;

    match parse_qasm(qasm_code) {
        Ok(circuit) => {
            println!("Successfully parsed circuit with {} operations.", circuit.operations.len());
            println!("Qubits: {}, Classical Bits: {}", circuit.num_qubits, circuit.num_cbits);
        }
        Err(e) => eprintln!("Error parsing QASM: {}", e),
    }
}
```

### Defining a Backend

```rust
use q_rust::backend::Backend;

fn main() {
    let mut backend = Backend::new("MyQuantumMachine".to_string(), 5);
    
    // Define connectivity (0 -> 1 -> 2)
    backend.set_coupling_map(vec![(0, 1), (1, 2)]);
    
    println!("Backend {} has {} qubits.", backend.name, backend.num_qubits);
}
```

## References

This project adheres to the **OpenQASM 2.0** specification:

- **Specification**: [OpenQASM 2.0 on GitHub](https://github.com/openqasm/openqasm/tree/OpenQASM2.x)
- **Paper**: Andrew W. Cross, Lev S. Bishop, John A. Smolin, Jay M. Gambetta, *"Open Quantum Assembly Language"*, [arXiv:1707.03429](https://arxiv.org/abs/1707.03429)

## License

MIT or Apache-2.0