Struct Circuit 

pub struct Circuit {
    pub n_qubits: u8,
    pub ops: Vec<Gate>,
}

A quantum circuit: n_qubits and an ordered op-log. This is the transportable object — compact, linear in gate count.

Fields

n_qubits: u8

ops: Vec<Gate>

Implementations

impl Circuit

pub fn new(n_qubits: u8) -> Self

Examples found in repository

examples/bell.rs (line 10)

fn main() {
    let mut c = Circuit::new(2);
    c.h(0).cx(0, 1); // a Bell pair

    let sv = c.simulate().expect("simulate");

    println!("circuit    {} qubits, {} gates", c.n_qubits, c.ops.len());
    let (backend, why) = qt::recommend_backend(&c);
    println!("backend    {backend:?} — {why}");

    println!("outcomes");
    for (state, p) in qt::top_outcomes(&sv, 4) {
        if p > 0.0 {
            println!("  |{state:02b}>  {p:.6}");
        }
    }

    // Not "a hash of this run" — the reconstruction is byte-exact, so this is the
    // same value natively, in a browser, and in a WASI component at the edge.
    let h = sv.statevector_hash();
    print!("state-hash ");
    for b in h {
        print!("{b:02x}");
    }
    println!();
}

pub fn x(&mut self, q: u8) -> &mut Self

pub fn y(&mut self, q: u8) -> &mut Self

pub fn z(&mut self, q: u8) -> &mut Self

pub fn h(&mut self, q: u8) -> &mut Self

Examples found in repository

examples/bell.rs (line 11)

fn main() {
    let mut c = Circuit::new(2);
    c.h(0).cx(0, 1); // a Bell pair

    let sv = c.simulate().expect("simulate");

    println!("circuit    {} qubits, {} gates", c.n_qubits, c.ops.len());
    let (backend, why) = qt::recommend_backend(&c);
    println!("backend    {backend:?} — {why}");

    println!("outcomes");
    for (state, p) in qt::top_outcomes(&sv, 4) {
        if p > 0.0 {
            println!("  |{state:02b}>  {p:.6}");
        }
    }

    // Not "a hash of this run" — the reconstruction is byte-exact, so this is the
    // same value natively, in a browser, and in a WASI component at the edge.
    let h = sv.statevector_hash();
    print!("state-hash ");
    for b in h {
        print!("{b:02x}");
    }
    println!();
}

pub fn s(&mut self, q: u8) -> &mut Self

pub fn t(&mut self, q: u8) -> &mut Self

pub fn p(&mut self, k: u16, q: u8) -> &mut Self

P(k) = diag(1, e^{2πi/2^k}) on qubit q.

pub fn cx(&mut self, c: u8, t: u8) -> &mut Self

Examples found in repository

examples/bell.rs (line 11)

fn main() {
    let mut c = Circuit::new(2);
    c.h(0).cx(0, 1); // a Bell pair

    let sv = c.simulate().expect("simulate");

    println!("circuit    {} qubits, {} gates", c.n_qubits, c.ops.len());
    let (backend, why) = qt::recommend_backend(&c);
    println!("backend    {backend:?} — {why}");

    println!("outcomes");
    for (state, p) in qt::top_outcomes(&sv, 4) {
        if p > 0.0 {
            println!("  |{state:02b}>  {p:.6}");
        }
    }

    // Not "a hash of this run" — the reconstruction is byte-exact, so this is the
    // same value natively, in a browser, and in a WASI component at the edge.
    let h = sv.statevector_hash();
    print!("state-hash ");
    for b in h {
        print!("{b:02x}");
    }
    println!();
}

pub fn cz(&mut self, c: u8, t: u8) -> &mut Self

pub fn cp(&mut self, k: u16, c: u8, t: u8) -> &mut Self

Controlled P(k) — the QFT’s rotation gate.

pub fn ccx(&mut self, c0: u8, c1: u8, t: u8) -> &mut Self

Toffoli (CCX).

pub fn swap(&mut self, a: u8, b: u8) -> &mut Self

SWAP(a,b) as three CX (kept in the op-log as gates, not a new opcode).

pub fn qft(n: u8) -> Circuit

The Quantum Fourier Transform over all n qubits — the “quantum FFT”, transported as a circuit (Hadamard + controlled-phase ladder + bit-reversal swaps) and reconstructed byte-exact. Uses the pinned dyadic phases.

pub fn validate(&self) -> Result<(), QuantumError>

Validate qubit indices, control/target distinctness, and P(k) range.

pub fn simulate(&self) -> Result<StateVector, QuantumError>

Classically simulate the circuit from |0…0⟩, returning the fixed-point state vector. Pure i64: byte-identical on every machine.

Examples found in repository

examples/bell.rs (line 13)

fn main() {
    let mut c = Circuit::new(2);
    c.h(0).cx(0, 1); // a Bell pair

    let sv = c.simulate().expect("simulate");

    println!("circuit    {} qubits, {} gates", c.n_qubits, c.ops.len());
    let (backend, why) = qt::recommend_backend(&c);
    println!("backend    {backend:?} — {why}");

    println!("outcomes");
    for (state, p) in qt::top_outcomes(&sv, 4) {
        if p > 0.0 {
            println!("  |{state:02b}>  {p:.6}");
        }
    }

    // Not "a hash of this run" — the reconstruction is byte-exact, so this is the
    // same value natively, in a browser, and in a WASI component at the edge.
    let h = sv.statevector_hash();
    print!("state-hash ");
    for b in h {
        print!("{b:02x}");
    }
    println!();
}

pub fn simulate_from(&self, start: usize) -> Result<StateVector, QuantumError>

Simulate starting from computational basis state |start⟩.

Trait Implementations

impl Clone for Circuit

fn clone(&self) -> Circuit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Circuit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Circuit

impl PartialEq for Circuit

fn eq(&self, other: &Circuit) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Circuit