We define our own trace function that only calls trace if the boolean argument is true.

Gates that act on a single qubit can be defined by essentially a 2-by-2 matrix. A GateR is written by rows, such that a matrix:

would be written as (m00,m01,m10,m11).

Scalar multiplication of a 2-by-2 matrix by a given scalar.

The inverse of a GateR is its conjugate transpose.

A simple pattern matching function that gives each "gate name" a GateR representation. Adding (single qubit) quantum gates to this function will give them an implementation in the simulator. Any single qubit named quantum gate that needs to be simulated must have a clause in this function, along with a given GateR that is its matrix representation. Note that unitarity is not enforced, so defined gates must be checked manually to be unitary operators.

Example Gates:
gateQ "x" = (0,1,1,0)
gateQ "hadamard" = (h, h, h,-h) where h = (1/sqrt 2)

Like gateQ, but also conditionally invert the gate depending on InverseFlag.

The exponential function for Cplx numbers.

The constant π, as a complex number.

Like gateQ, but takes the name of a rotation and a real parameter.

Like rotQ, but also conditionally invert the gate depending on InverseFlag.

Return the matrix for the expZt gate.

Return the matrix for the GPhase gate.

Translate a classical gate name into a boolean function. Adding classical gates to this function will give them an implementation in the simulator.

Example Gate:
gateC "if" [a,b,c] = if a then b else c 

The type of vectors with scalars in n over the basis a. A vector is simply a list of pairs.

An amplitude distribution gives each classical basis state an amplitude.

A probability distribution gives each element a probability.

A QuantumTrace is essentially a probability distribution for the current state of the qubits that have been traced. We can represent this using a Vector. The list of Booleans is in the same order as the list of Qubits that was being traced.

Normalizing is used to make sure the probabilities add up to 1.

A QuantumState is the data structure containing the state that we update throughout the simulation. We need to keep track of the next available wire, and a quantum state in the form of a distribution of basis states. We also track a list of quantum traces, so that we have a "tracing" mechanism during the execution of quantum circuits.

When we start a simulation, we need an empty starting state.

It doesn't make sense having a quantum control on a classical gate, so we can throw an error if that is the case, and just collect the boolean result otherwise.

Map the classical_control function to all the controls, and take the and of the result

When we want a quantum control, we will be working with one "basis state" at a time, and can look up the qubit's value in that basis state to see whether the control firs.

Map the qc_control function to all the controls (under the given basis state), and take the and of the result.

We can calculate the magnitude of a complex number

The split function splits a Amplitude distribution, by partitioning it around the state of the given qubit within each basis state. It also returns the probability of the qubit being True within the given Amplitudes. This function is used when we want to measure a qubit.

A PMonad is a Monad enriched with a merge function that takes a probability, and two results, and returns a merged version of these results under the given monad. This idea is taken directly from QIO.

We can merge two measurement outcomes, and explicitly keep the first outcome as the True result, and the second as the False result.

The get_trace function returns a probability distribution of the state of a list of qubits within a given amplitude distribution.

Add an amplitude to an amplitude distribution, combining (adding) the amplitudes for equal states in the distribution.

The apply' function is used to apply a function on "basis states" to an entire amplitude distribution.

Lift a function that returns a single basis state, to a function that returns an amplitude distribution (containing a singleton).

apply the given function only if the controls fire.

performGateQ defines how a single qubit gate is applied to a quantum state. The application of a GateR to a qubit in a single basis state can split the state into a pair of basis states with corresponding amplitudes.

The simulation_transformer is the actual transformer that does the simulation. The type of the simulation_transformer shows that Qubits are kept as qubits, but Bits are turned into Boolean values, i.e., the results of the computation. We use a StateT Monad, acting over the IO Monad, to store a QuantumState throughout the simulation. This means we carry a state, but also have access to the IO Monad's random number generator (for probabilistic measurement).

The simulation_transformer is also Dynamic, as the simulated wire states can simply be used to perform dynamic liftings.

Apply the simulation_dynamic_transformer to a (unary) circuit generating function.

In order to simulate a circuit using an input basis vector, we need to supply each quantum leaf, with a concrete (i.e., not a dummy) qubit.

In order to simulate a circuit using an input basis vector, we need to supply the transformer with a concrete set of qubit bindings.

As a helper function, in order to simulate a circuit using an input basis vector, we need to be able to convert each basis into a map from concrete qubits to their value in the given basis.

In order to simulate a circuit using an input basis vector, we need to be able to convert the basis vector into a quantum state suitable for use by the simulator i.e. of type Amplitudes.

As a helper function, in order to simulate a circuit using an input basis vector, we need to be able to convert a map from concrete qubits to their value into a basis of the given concrete shape.

In order to simulate a circuit using an input basis vector, we need to be able to convert the quantum state (i.e. of type Amplitudes) into a basis vector.

Apply the simulation_dynamic_transformer to a (unary) circuit generating function, starting with the quantum state set to the given vector of base states and returning the resulting vector of base states.

Input a source of randomness, a quantum circuit, and an initial state (represented as a map from basis vectors to amplitudes). Simulate the circuit and return the final state. If the circuit includes measurements, the simulation will be probabilistic.

The type of this heavily overloaded function is difficult to read. It has, for example, the following types:

sim_amps :: StdGen -> (Qubit -> Circ Qubit) -> Map Bool (Cplx Double) -> Map Bool (Cplx Double)
sim_amps :: StdGen -> ((Qubit,Qubit) -> Circ Qubit) -> Map (Bool,Bool) (Cplx Double) -> Map Bool (Cplx Double)

and so forth. Note that instead of Double, another real number type, such as FixedPrec e, can be used.

Input a source of randomness, a real number, a circuit, and a basis state. Then simulate the circuit probabilistically. Measure the final state and return the resulting basis vector.

The real number argument is a dummy and is never evaluated; its only purpose is to specify the type of real numbers that will be used during the simulation.

Like run_unary, but return the list of QuantumTrace elements that were generated during the computation. This is useful for checking the intermediary state of qubits within a computation.

Like run_unary, but run in the IO monad instead of passing an explicit source of randomness.

Like run_unary_trace, but run in the IO monad instead of passing an explicit source of randomness.

Apply the simulation_transformer to a (unary) circuit, and then evaluate the resulting stateful computation to get a probability distribution of possible results

Quantum simulation of a circuit, for testing and debugging purposes. Input a source of randomness, a real number, and a quantum circuit. Output a corresponding probabilistic boolean function.

The inputs to the quantum circuit are initialized according to the given boolean arguments. The outputs of the quantum circuit are measured, and the boolean measurement outcomes are returned.

The real number argument is a dummy and is never evaluated; its only purpose is to specify the type of real numbers that will be used during the simulation.

The type of this heavily overloaded function is difficult to read. In more readable form, it has all of the following types (for example):

run_generic :: (Floating r, Random r, Ord r, RandomGen g, QCData qa) => g -> r -> Circ qa -> BType qa
run_generic :: (Floating r, Random r, Ord r, RandomGen g, QCData qa, QCData qb) => g -> r -> (qa -> Circ qb) -> BType qa -> BType qb
run_generic :: (Floating r, Random r, Ord r, RandomGen g, QCData qa, QCData qb, QCData qc) => g -> r -> (qa -> qb -> Circ qc) -> BType qa -> BType qb -> BType qc

and so forth.

Like run_generic, but also output a trace of the states of the given list of qubits at each step during the evaluation.

Like run_generic, but run in the IO monad instead of passing an explicit source of randomness.

Like run_generic_trace, but run in the IO monad instead of passing an explicit source of randomness.

A generic function to simulate Quipper circuits, returning a probability distribution of the possible results.

The type of this heavily overloaded function is difficult to read. In more readable form, it has all of the following types (for example):

sim_generic :: (Floating r, Ord r, QCData qa) => r -> Circ qa -> ProbabilityDistribution r (BType qa)
sim_generic :: (Floating r, Ord r, QCData qa, QCData qb) => r -> (qa -> Circ qb) -> BType qa -> ProbabilityDistribution r (BType qb)
sim_generic :: (Floating r, Ord r, QCData qa, QCData qb, QCData qc) => r -> (qa -> qb -> Circ qc) -> BType qa -> BType qb -> ProbabilityDistribution r (BType qc)

and so forth.