Struct SimulatedCircuit 

pub struct SimulatedCircuit { /* private fields */ }

Contains the resulting state vector produced from the simulation of a circuit.

Implementations

impl SimulatedCircuit

pub fn measure_all( &self, shots: usize, ) -> Measurement<HashMap<ProductState, usize>>

Returns a HashMap that contains the number of times the corresponding state was observed over n measurements of the superpositions (shots).

Explicitly, this performs repeated measurements where a register is attached to the circuit, the resulting superposition measured in the computational basis, and then the reduced state recorded. If the HashMap does not include a product state, then it was not observed over the n measurements.

For efficiency, this will use the cached register from the simulated circuit. If your circuit contains mixed states, then most likely the circuit will have to be simulated again for each shot. To achieve this, use SimulatedCircuit::measure_all_without_cache.

Example

use quantr::{states::SuperPosition, Circuit, Measurement::Observable, Gate};

let mut circuit = Circuit::new(3).unwrap();

circuit.add_gate(Gate::H, 2).unwrap();
let simulated_circuit = circuit.simulate();

// Measures 500 superpositions.
println!("State | Number of Times Observed");
if let Observable(bin_count) = simulated_circuit.measure_all(500) {
    for (state, observed_count) in bin_count {
        println!("|{}>   : {}", state, observed_count);
    }
}

// State | Number of Times Observed
// |000> : 247
// |001> : 253

Examples found in repository

examples/generalised_control_not_gate.rs (line 42)

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 35)

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 52)

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 measure_all_without_cache( self, shots: usize, ) -> Measurement<HashMap<ProductState, usize>>

Similar to SimulatedCircuit::measure_all, however for every shot it will simulate the circuit, where the input register is reset to the zero state.

This potentially allows for mixed states to be simulated, through the implementation of Gate::Custom. In doing so will dramatically increase the simulation time, as a new circuit will be simulated for each shot.

pub fn get_state(&self) -> Measurement<&SuperPosition>

Returns the resulting superposition after the circuit has been simulated using super::Circuit::simulate.

This is a non-physical observable, as the superposition would reduce to a single state upon measurement.

Example

use quantr::{states::SuperPosition, Circuit, Measurement::NonObservable, Gate};

let mut circuit = Circuit::new(3).unwrap();

circuit.add_gate(Gate::H, 2).unwrap();
circuit.add_gate(Gate::Y, 2).unwrap();
let simulated_circuit = circuit.simulate();

println!("State | Amplitude of State");
if let NonObservable(super_pos) = simulated_circuit.get_state() {
    for (state, amplitude) in super_pos.into_iter() {
        println!("|{}>   : {}", state.to_string(), amplitude);
    }
}

// State | Amplitude of State
// |000> : 0 - 0.71...i
// |001> : 0 + 0.71...i

Examples found in repository

examples/post_select.rs (line 29)

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 35)

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/grovers.rs (line 60)

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 print_warnings(&mut self, printing: bool)

Sets if the printer should display warnings.

pub fn get_circuit_gates(&self) -> &Vec<Gate>

The slice of gates that composed the circuit, equivalent to Circuit::get_gates.

pub fn get_num_qubits(&self) -> usize

The number of qubits that composed the circuit, equivalent to Circuit::get_num_qubits.

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

Sets whether the simulation progress of the circuit will be printed to the terminal. This value is inherited from the circuit this struct was derived from.

pub fn take_state(self) -> Measurement<SuperPosition>

Takes ownership of the state that the SimulatedCircuit wraps around, that is the state that resulted from a circuit simulation.

Examples found in repository

examples/qft.rs (line 64)

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())
}