Quantum Computing library leveraging graph building to build efficient quantum circuit simulations.
See all the examples in the examples directory of the Github repository.
Here's an example of a small circuit where two groups of qubits are swapped conditioned on a third. This circuit is very small, only three operations plus a measurement, so the boilerplate can look quite large in compairison, but that setup provides the ability to construct circuits easily and safely when they do get larger. ```rust use qip::*;
// Make a new circuit builder. let mut b = OpBuilder::new();
// Make three logical groups of qubits of sizes 1, 3, 3 (7 qubits total). let q = b.qubit(1)?; let qa = b.qubit(3)?; let qb = b.qubit(3)?;
// We will want to feed in some inputs later, hang on to the handles // so we don't need to actually remember any indices. let ahandle = qa.handle(); let bhandle = qb.handle();
// Define circuit // First apply an H to q1 let q = b.hadamard(q); // Then run this subcircuit conditioned on q, applied to qa and qb let (q, _) = condition(&mut b, q, (qa, qb), |c, (qa, qb)| { c.swap(qa, qb) })?; // Finally apply H to q again. let q = b.hadamard(q);
// Add a measurement to the first qubit, save a reference so we can get the result later. let (q, m_handle) = b.measure(q);
// Now q is the end result of the above circuit, and we can run the circuit by referencing it.
// Make an initial state: |0,000,001>
let initialstate = [ahandle.makeinitfromindex(0)?,
bhandle.makeinitfromindex(1)?];
// Run circuit with a given precision.
let (, measured) = runlocalwithinit::
// Lookup the result of the measurement we performed using the handle. let (result, p) = measured.getmeasurement(&mhandle).unwrap();
// Print the measured result println!("Measured: {:?} (with chance {:?})", result, p); ```