Struct Circuit 

pub struct Circuit { /* private fields */ }

A quantum circuit where gates can be appended and then simulated to produce a SimulatedCircuit struct.

Implementations

impl Circuit

pub fn new(num_qubits: usize) -> Result<Circuit, QuantrError>

Initialises a new circuit.

The lifetime is due to the slices of control qubits for Gate::Custom. That is, the slice argument must outlive the circuit.

Example

use quantr::Circuit;

// Initialises a 3 qubit circuit.
let quantum_circuit: Circuit = Circuit::new(3).unwrap();

Examples found in repository

examples/post_select.rs (line 18)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 22)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

// A QFT implementation that can be used for other circuits. Note, the output is reveresed compared
// to usual conventions; swap gates are needed.
fn qft(input_state: ProductState) -> Option<SuperPosition> {
    let qubit_num = input_state.num_qubits();
    let mut mini_circuit: Circuit = Circuit::new(qubit_num).unwrap();

    for pos in 0..qubit_num {
        mini_circuit.add_gate(Gate::H, pos).unwrap();
        for k in 2..=(qubit_num - pos) {
            mini_circuit
                .add_gate(Gate::CRk(k as i32, pos + k - 1), pos)
                .unwrap();
        }
    }

    mini_circuit
        .change_register(SuperPosition::from(input_state))
        .unwrap();

    Some(mini_circuit.simulate().take_state().take())
}

examples/generalised_control_not_gate.rs (line 22)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 19)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 21)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn get_num_qubits(&self) -> usize

Returns the number of qubits in the circuit.

Example

use quantr::{Circuit, Gate};

let quantum_circuit: Circuit = Circuit::new(3).unwrap();
assert_eq!(quantum_circuit.get_num_qubits(), 3usize);

pub fn set_print_progress(&mut self, progress: bool)

Sets whether the simulation progress of the circuit shall be printed to the terminal.

Example

use quantr::{Circuit};

let mut quantum_circuit = Circuit::new(2).unwrap();
quantum_circuit.set_print_progress(true);

Examples found in repository

examples/post_select.rs (line 26)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 31)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/generalised_control_not_gate.rs (line 38)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 31)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 44)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn get_gates(&self) -> &[Gate]

Returns the slice of gates that have been added to the circuit.

It is a flattened vector which is buffered with identity gates.

Example

use quantr::{Circuit, Gate};

let mut quantum_circuit: Circuit = Circuit::new(3).unwrap();
quantum_circuit.add_gate(Gate::X, 2).unwrap();

assert_eq!(quantum_circuit.get_gates(), &[Gate::Id, Gate::Id, Gate::X]);

pub fn add_gate( &mut self, gate: Gate, position: usize, ) -> Result<&mut Circuit, QuantrError>

Adds a single gate to the circuit.

If wanting to add multiple gates, or a single gate repeatedly across multiple wires, see Circuit::add_gates_with_positions and Circuit::add_repeating_gate respectively.

Example

use quantr::{Circuit, Gate};

let mut quantum_circuit: Circuit = Circuit::new(3).unwrap();
quantum_circuit.add_gate(Gate::X, 0).unwrap();

// Produces the circuit:
// -- X --
// -------
// -------

Examples found in repository

examples/post_select.rs (line 21)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 26)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

// A QFT implementation that can be used for other circuits. Note, the output is reveresed compared
// to usual conventions; swap gates are needed.
fn qft(input_state: ProductState) -> Option<SuperPosition> {
    let qubit_num = input_state.num_qubits();
    let mut mini_circuit: Circuit = Circuit::new(qubit_num).unwrap();

    for pos in 0..qubit_num {
        mini_circuit.add_gate(Gate::H, pos).unwrap();
        for k in 2..=(qubit_num - pos) {
            mini_circuit
                .add_gate(Gate::CRk(k as i32, pos + k - 1), pos)
                .unwrap();
        }
    }

    mini_circuit
        .change_register(SuperPosition::from(input_state))
        .unwrap();

    Some(mini_circuit.simulate().take_state().take())
}

examples/generalised_control_not_gate.rs (lines 26-33)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 24)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 27)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn add_gates_with_positions( &mut self, gates_with_positions: HashMap<usize, Gate>, ) -> Result<&mut Circuit, QuantrError>

Add a column of gates specifying the position for each gate.

A HashMap<usize, Gate> is used to place gates onto their desired position. This is similar to Circuit::add_gate, however not all wires have to be accounted for.

Example

use quantr::{Circuit, Gate};
use std::collections::HashMap;

let mut quantum_circuit: Circuit = Circuit::new(3).unwrap();
// Adds gates on wires 0 and 2, implicitly leaving wire 1 bare.
quantum_circuit.add_gates_with_positions(
    HashMap::from(
        [(0, Gate::X), (2, Gate::H)]
    )
).unwrap();

// Produces the circuit:
// -- X --
// -------
// -- H --

pub fn add_gates(&mut self, gates: &[Gate]) -> Result<&mut Circuit, QuantrError>

Add a column of gates.

Expects the input vector to specify the gate that is added to each wire. That is, the length of the vector should equal the number of wires. To only add gates based on their positions, see Circuit::add_gates_with_positions and Circuit::add_gate.

Example

use quantr::{Circuit, Gate};

let mut quantum_circuit: Circuit = Circuit::new(3).unwrap();
let gates_to_add = [Gate::H, Gate::X, Gate::Y];

quantum_circuit.add_gates(&gates_to_add).unwrap();

// Produces the circuit:
// -- H --
// -- X --
// -- Y --

pub fn add_repeating_gate( &mut self, gate: Gate, positions: &[usize], ) -> Result<&mut Circuit, QuantrError>

Place a single gate repeatedly onto multiple wires.

For adding multiple different gates, refer to Circuit::add_gates and Circuit::add_gates_with_positions.

Example

use quantr::{Circuit, Gate};

let mut quantum_circuit: Circuit = Circuit::new(3).unwrap();
quantum_circuit.add_repeating_gate(Gate::H, &[1, 2]).unwrap();

// Produces the circuit:
// -------
// -- H --
// -- H --

Examples found in repository

examples/post_select.rs (line 20)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 25)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/generalised_control_not_gate.rs (line 25)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 23)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 24)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn simulate(self) -> SimulatedCircuit

Attaches the register, |0…0>, to the circuit resulting in a superposition that can be measured.

See SimulatedCircuit::get_state and SimulatedCircuit::measure_all for details on obtaining observables from the resulting superposition.

If you are not wanting the circuit to be consumed, please refer to Circuit::clone_and_simulate.

Example

use quantr::{Circuit, Gate};

let mut circuit = Circuit::new(3).unwrap();
circuit.add_gate(Gate::H, 2).unwrap();

circuit.simulate();

// Simulates the circuit:
// |0> -------
// |0> -------
// |0> -- H --

Examples found in repository

examples/post_select.rs (line 27)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 33)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

// A QFT implementation that can be used for other circuits. Note, the output is reveresed compared
// to usual conventions; swap gates are needed.
fn qft(input_state: ProductState) -> Option<SuperPosition> {
    let qubit_num = input_state.num_qubits();
    let mut mini_circuit: Circuit = Circuit::new(qubit_num).unwrap();

    for pos in 0..qubit_num {
        mini_circuit.add_gate(Gate::H, pos).unwrap();
        for k in 2..=(qubit_num - pos) {
            mini_circuit
                .add_gate(Gate::CRk(k as i32, pos + k - 1), pos)
                .unwrap();
        }
    }

    mini_circuit
        .change_register(SuperPosition::from(input_state))
        .unwrap();

    Some(mini_circuit.simulate().take_state().take())
}

examples/generalised_control_not_gate.rs (line 39)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 32)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 47)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn clone_and_simulate(&self) -> SimulatedCircuit

Attaches the register, |0…0>, to the circuit resulting in a superposition that can be measured, and will clone the contents of the register. This will duplicate the register, and so could lead to large memeory consumption for circuits with many qubits.

See SimulatedCircuit::get_state and SimulatedCircuit::measure_all for details on obtaining observables from the resulting superposition.

If you are wanting the circuit to be consumed, please refer to Circuit::simulate.

Example

use quantr::{Circuit, Gate};

let mut circuit = Circuit::new(3).unwrap();
circuit.add_gate(Gate::H, 2).unwrap();

let simulated_with_H = circuit.clone_and_simulate();

// Below would be impossible if Circuit::simulate was used instead
let simulated_with_H_and_X = circuit.add_gate(Gate::X, 1);

pub fn change_register( &mut self, super_pos: SuperPosition, ) -> Result<&mut Circuit, QuantrError>

Changes the register which is applied to the circuit when Circuit::simulate is called.

The default register is the |00..0> state. This method can be used before simulating the circuit to change the register. This is primarily helpful in defining custom functions, for example see examples/qft.rs.

Example

use quantr::{Circuit, Gate};
use quantr::states::{Qubit, ProductState, SuperPosition};

let mut circuit = Circuit::new(2).unwrap();
circuit.add_gate(Gate::X, 1).unwrap();

let register: SuperPosition =
    ProductState::new(&[Qubit::One, Qubit::Zero])
        .unwrap()
        .into();

circuit.change_register(register).unwrap();
circuit.simulate();

// Simulates the circuit:
// |1> -------
// |0> -- X --

Examples found in repository

examples/qft.rs (line 61)

fn qft(input_state: ProductState) -> Option<SuperPosition> {
    let qubit_num = input_state.num_qubits();
    let mut mini_circuit: Circuit = Circuit::new(qubit_num).unwrap();

    for pos in 0..qubit_num {
        mini_circuit.add_gate(Gate::H, pos).unwrap();
        for k in 2..=(qubit_num - pos) {
            mini_circuit
                .add_gate(Gate::CRk(k as i32, pos + k - 1), pos)
                .unwrap();
        }
    }

    mini_circuit
        .change_register(SuperPosition::from(input_state))
        .unwrap();

    Some(mini_circuit.simulate().take_state().take())
}