Struct qip::builder::LocalBuilder

pub struct LocalBuilder<P: Precision> { /* private fields */ }

A local circuit builder for constructing circuits out of standard gates. LocalBuilder breaks complicated multi-register gates, like toffoli, into combinations of simple gates like CNOT.

Implementations

impl<P: Precision> LocalBuilder<P>

pub fn apply_global_phase(&mut self, r: Qudit, theta: P) -> Qudit

Applies a phase to a qubit. This has no effect by default but has an impact if conditioned.

pub fn apply_global_phase_ratio(&mut self, r: Qudit, theta: Rational64) -> Qudit

Applied a global phase to a qubit, expressed as a ratio rather than a float.

pub fn apply_global_phase_pi_by(&mut self, r: Qudit, m: i64) -> Qudit

Apply a global phase of pi/m for integer m.

pub fn pipeline_depth(&self) -> usize

Returns the depth of the current circuit (pipeline).

Trait Implementations

impl<P: Precision> AdvancedCircuitBuilder<P> for LocalBuilder<P>

fn basic_toffoli( &mut self, cr: Self::Register, r: Self::Register ) -> Result<(Self::Register, Self::Register), CircuitError>

Applies a NOT gate to r for the two qubit control state cr = 11.

fn toffoli( &mut self, cr: Self::Register, r: Self::Register ) -> Result<(Self::Register, Self::Register), CircuitError>

Applies NOT to r if all qubits in cr are 1.

impl<P: Precision> CircuitBuilder for LocalBuilder<P>

type Register = Qudit

The register type used for the circuit.

type CircuitObject = BuilderCircuitObject<P>

The struct used to represent circuit objects.

type StateCalculation = (Vec<Complex<P>, Global>, Measurements<P>)

Return type for state calculations.

fn n(&self) -> usize

Number of qubits in circuit.

fn register(&mut self, n: NonZeroUsize) -> Self::Register

Construct a register with multiple qubits.

fn merge_two_registers( &mut self, r1: Self::Register, r2: Self::Register ) -> Self::Register

Merge two registers into a single register with first the r1 indices, then the r2 indices.

fn split_register_relative<It>( &mut self, r: Self::Register, indices: It ) -> SplitResult<Self::Register>where It: IntoIterator<Item = usize>,

Split a register into two, selecting the relative indices from the indices iterator.

fn apply_circuit_object( &mut self, r: Self::Register, c: Self::CircuitObject ) -> CircuitResult<Self::Register>

Apply a circuit object to the circuit directly.

fn calculate_state_with_init<'a, It>( &mut self, it: It ) -> Self::StateCalculationwhere Self::Register: 'a, It: IntoIterator<Item = (&'a Self::Register, usize)>,

Calculate the state at the end of the circuit using an initial state given by each register and the classical state in that register.

fn qubit(&mut self) -> Self::Register

Construct a single qubit.

fn qudit(&mut self, n: usize) -> Option<Self::Register>

Construct a register with multiple qubits. Fails if n=0.

fn try_register(&mut self, n: usize) -> Option<Self::Register>

Construct a register with multiple qubits. Fails if n=0.

fn merge_registers<It>(&mut self, rs: It) -> Option<Self::Register>where It: IntoIterator<Item = Self::Register>,

Merge multiple registers together into a single register, returns None if none given.

fn split_register_absolute<It>( &mut self, r: Self::Register, indices: It ) -> SplitResult<Self::Register>where It: IntoIterator<Item = usize>,

Split a register into two, selecting the indices from the indices iterator.

fn split_all_register(&mut self, r: Self::Register) -> Vec<Self::Register>

Split the register into r.n() individual registers of 1 qubit each.

fn split_first_qubit( &mut self, r: Self::Register ) -> (Option<Self::Register>, Self::Register)

Split off the first qubit from the register, returns the optional remaining registers and the first qubit.

fn split_last_qubit( &mut self, r: Self::Register ) -> (Self::Register, Option<Self::Register>)

Similar to [split_first_qubit] but the last qubit.

fn split_relative_index_groups<It: IntoIterator<Item = Itt>, Itt: IntoIterator<Item = usize>>( &mut self, r: Self::Register, indices: It ) -> SplitManyResult<Self::Register>

Split into multiple qubits, each with relative indices given by the sub-iterators.

fn calculate_state(&mut self) -> Self::StateCalculation

Calculate the quantum state at the end of the circuit, using |0> as input.

impl<P: Precision> CliffordTBuilder<P> for LocalBuilder<P>

fn make_x(&self) -> Self::CircuitObject

Make a circuit object representing the X gate on a single qubit. Equivalent to calling matrix_to_circuitobject with [0, 1, 1, 0]

fn make_y(&self) -> Self::CircuitObject

Make a circuit object representing the Y gate on a single qubit. Equivalent to calling matrix_to_circuitobject with [0, -i, i, 0]

fn make_z(&self) -> Self::CircuitObject

Make a circuit object representing the Z gate on a single qubit. Equivalent to calling matrix_to_circuitobject with [1, 0, 0, -1]

fn make_h(&self) -> Self::CircuitObject

Make a circuit object representing the H gate on a single qubit. Equivalent to calling matrix_to_circuitobject with [1, 1, 1, -1]/sqrt(2)

fn make_s(&self) -> Self::CircuitObject

Make a circuit object representing the S (phase) gate on a single qubit. Equivalent to calling matrix_to_circuitobject with [1, 0, 0, -i]

fn make_t(&self) -> Self::CircuitObject

Make a circuit object representing the T gate on a single qubit. Equivalent to calling matrix_to_circuitobject with [1, 0, 0, e^{i pi / 4} ]

fn make_cnot(&self) -> Self::CircuitObject

Make a circuit object representing the CNOT gate on a pair of qubits Equivalent to calling matrix_to_circuitobject with [ I, 0, 0, X ] where I is the identity matrix and X is the x-gate.

fn not(&mut self, r: Self::Register) -> Self::Register

Create and apply an NOT (or X) gate circuit object.

fn x(&mut self, r: Self::Register) -> Self::Register

Create and apply an X (or NOT) gate circuit object.

fn y(&mut self, r: Self::Register) -> Self::Register

Create and apply a Y gate circuit object.

fn z(&mut self, r: Self::Register) -> Self::Register

Create and apply a Z gate circuit object.

fn h(&mut self, r: Self::Register) -> Self::Register

Create and apply an H gate circuit object.

fn t(&mut self, r: Self::Register) -> Self::Register

Create and apply a T gate circuit object.

fn t_dagger(&mut self, r: Self::Register) -> Self::Register

Create and apply a T^\dagger gate circuit object.

fn s(&mut self, r: Self::Register) -> Self::Register

Create and apply an S gate circuit object.

fn s_dagger(&mut self, r: Self::Register) -> Self::Register

Create and apply an S^\dagger gate circuit object.

fn cnot( &mut self, cr: Self::Register, r: Self::Register ) -> Result<(Self::Register, Self::Register), CircuitError>

Create and apply a CNOT gate circuit object.

fn swap( &mut self, ra: Self::Register, rb: Self::Register ) -> Result<(Self::Register, Self::Register), CircuitError>

Apply the SWAP gate to a pair of registers of equal sizes.

impl<P: Precision> Conditionable for LocalBuilder<P>

fn try_apply_with_condition( &mut self, cr: Self::Register, r: Self::Register, co: Self::CircuitObject ) -> Result<(Self::Register, Self::Register), CircuitError>

Attempt to condition a circuit object co applied to r with the register cr.

fn condition_with(&mut self, cr: Self::Register) -> Conditioned<'_, Self>

Construct a new circuitbuilder which conditions all unitaries with cr.

impl<P: Precision> ConditionableSubcircuit for LocalBuilder<P>

fn apply_conditioned_subcircuit( &mut self, sc: Self::Subcircuit, cr: Self::Register, r: Self::Register ) -> Result<(Self::Register, Self::Register), CircuitError>

Apply sc to register r using condition cr.

impl<P: Debug + Precision> Debug for LocalBuilder<P>

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

Formats the value using the given formatter.

impl<P: Default + Precision> Default for LocalBuilder<P>

fn default() -> LocalBuilder<P>

Returns the “default value” for a type.

impl<P: Precision> Invertable for LocalBuilder<P>

type SimilarBuilder = LocalBuilder<P>

A similar circuit builder which can be used to construct circuits for the parent.

fn new_similar(&self) -> Self

Make a similar circuit builder.

fn invert_subcircuit(sc: Self::Subcircuit) -> CircuitResult<Self::Subcircuit>

Take the output of the similar circuit builder and invert it.

fn apply_inverted_subcircuit( &mut self, sc: Self::Subcircuit, r: Self::Register ) -> CircuitResult<Self::Register>

Apply the inverted subcircuit to a register.

impl<P: Precision> MeasurementBuilder for LocalBuilder<P>

type MeasurementHandle = MeasurementHandle

Handle which points to measurements.

fn measure( &mut self, r: Self::Register ) -> (Self::Register, Self::MeasurementHandle)

Take a measurement of r, return r and a handle to fetch the result later.

impl<P: Precision> RecursiveCircuitBuilder<P> for LocalBuilder<P>

type RecursiveSimilarBuilder = <LocalBuilder<P> as Invertable>::SimilarBuilder

The similar builder which also implements the recursive circuit builder, it may be the same type or different.

impl<P: Precision> RotationsBuilder<P> for LocalBuilder<P>

fn rz(&mut self, r: Self::Register, theta: P) -> Self::Register

Rotate around z.

fn rz_pi_by( &mut self, r: Self::Register, m: i64 ) -> CircuitResult<Self::Register>

Rotate around z by pi/m

fn rx(&mut self, r: Self::Register, theta: P) -> Self::Register

Rotate around x.

fn ry(&mut self, r: Self::Register, theta: P) -> Self::Register

Rotate around y.

fn rz_ratio( &mut self, r: Self::Register, theta: Rational64 ) -> CircuitResult<Self::Register>

Rotate around z.

fn rx_ratio( &mut self, r: Self::Register, theta: Rational64 ) -> CircuitResult<Self::Register>

Rotate around z.

fn ry_ratio( &mut self, r: Self::Register, theta: Rational64 ) -> CircuitResult<Self::Register>

Rotate around z.

fn rx_pi_by( &mut self, r: Self::Register, m: i64 ) -> CircuitResult<Self::Register>

Rotate around x by pi/m

fn ry_pi_by( &mut self, r: Self::Register, m: i64 ) -> CircuitResult<Self::Register>

Rotate around y by pi/m

impl<P: Precision> StochasticMeasurementBuilder for LocalBuilder<P>

type StochasticMeasurementHandle = StochasticMeasurementHandle

Handle which points to measurements.

fn measure_stochastic( &mut self, r: Self::Register ) -> (Self::Register, Self::StochasticMeasurementHandle)

Take a measurement of r, return r and a handle to fetch the result later.

impl<P: Precision> Subcircuitable for LocalBuilder<P>

type Subcircuit = Vec<(Vec<usize, Global>, <LocalBuilder<P> as CircuitBuilder>::CircuitObject), Global>

The export type for the circuit.

fn make_subcircuit(&self) -> CircuitResult<Self::Subcircuit>

Export the circuit as a subcircuit if able.

fn apply_subcircuit( &mut self, sc: Self::Subcircuit, r: Self::Register ) -> CircuitResult<Self::Register>

Append the subcircuit to the register r.

impl<P: Precision> TemporaryRegisterBuilder for LocalBuilder<P>

fn make_zeroed_temp_qubit(&mut self) -> Self::Register

Make a temporary qubit, initialized to zero.

fn return_zeroed_temp_register(&mut self, r: Self::Register)

Return a register which has been reset to zero.

fn make_zeroed_temp_register(&mut self, n: NonZeroUsize) -> Self::Register

Make a register of multiple qubits, initialized to zero.

impl<P: Precision> UnitaryBuilder<P> for LocalBuilder<P>

fn vec_matrix_to_circuitobject( n: usize, data: Vec<Complex<P>> ) -> Self::CircuitObject

Make a circuit object out of an arbitrary matrix Single Qubit matrix is organized as |0><0|, |0><1|, |1><0|, |1><1|

fn apply_vec_matrix( &mut self, r: Self::Register, data: Vec<Complex<P>> ) -> CircuitResult<Self::Register>

Apply an arbitrary matrix to the circuit given by a vector.

fn apply_matrix<const N: usize>( &mut self, r: Self::Register, data: [Complex<P>; N] ) -> CircuitResult<Self::Register>

Apply an arbitrary matrix to the circuit given by an array.

fn broadcast_single_qubit_matrix( &mut self, r: Self::Register, data: [Complex<P>; 4] ) -> Self::Register

Single qubit matrices can be applied to each qubit in a register unambiguously. Matrix is organized as |0><0|, |0><1|, |1><0|, |1><1|

fn matrix_to_circuitobject<const N: usize>( n: usize, data: [Complex<P>; N] ) -> Self::CircuitObject

Make a circuit object out of an arbitrary matrix Single Qubit matrix is organized as |0><0|, |0><1|, |1><0|, |1><1|