quipper-libraries- The standard libraries for Quipper.

Safe HaskellNone




This module contains the interface between the simplified circuit model and Quipper's internal circuit model. The main useful exported functions are:


Auxiliary functions

getListWire :: QData qc => qc -> [Wire] Source #

Extract the list of wires from a piece of quantum data.

Quipper circuits to simple circuits

quipperGateToMyGate :: (IntSet, IntMap Wire, Wire) -> Gate -> ((IntSet, IntMap Wire, Wire), Maybe Gate) Source #

Translates a Quipper circuit to a simple circuit. The only gates considered are initializations, terminations, and multi-controlled NOT gates. All other gates are ignored.

Note that simple circuits do not possess termination wires: these wires are simply not terminated, and all subsequent initializations using the same wire ID are sent to fresh wires.

The state of this function is a bit complex, as it keeps track of where the output wires are mapped to.

quipperGateInitW :: Gate -> Maybe Wire Source #

Get the wire initialized by the gate, if it is an initialization gate.

quipperGateFreshWire :: Wire -> [Gate] -> Wire Source #

Given a list of Quipper gates, get the smallest wire id not in use.

myCircErrMsg :: String -> String Source #

Generate a custom error message.

quipperFunToMyCirc :: (QData x, QData y) => (x -> Circ y) -> x -> (CircState, [Wire]) Source #

Given a Quipper circuit generating function and a shape argument, return a simple circuit together with the list of non-garbage circuit outputs.

Simple circuits to Quipper circuits

myGateToQuipperGate :: Gate -> Gate Source #

Translate a gate from the simple circuit model into a Quipper gate.

makeComment :: String -> String -> [Wire] -> Gate Source #

Generate a Quipper comment. The first argument is a comment string, and the second argument is a label to apply to the qubits in the third argument.

Algebraic optimization of Quipper circuits

quipperBCircuitSimpl :: BCircuit -> [Wire] -> (BCircuit, [Wire]) Source #

Optimize a Quipper BCircuit. The second argument is the list of non-garbage outputs. A corresponding list of outputs is also returned along with the circuit.

simplify_classical' :: (QData x, QData y) => (x -> Circ y) -> x -> (BCircuit, [Wire]) Source #

Optimize a Quipper circuit producing function (together with a shape argument). Return the optimized circuit as a Quipper BCircuit, along with a list of the non-garbage circuit outputs.

simplify_classical :: (QData x, QData y) => (x -> Circ y) -> x -> Circ y Source #

Optimize a Quipper circuit-producing function. This assumes that the function only consists of pseudo-classical quantum gates, i.e., initializations, terminations, and (possibly multiply controlled) NOT gates. The behavior on other kinds of circuits is undefined. The second argument is a shape parameter.

classical_to_reversible_optim :: (QData qa, QData qb) => (qa -> Circ qb) -> (qa, qb) -> Circ (qa, qb) Source #

Like classical_to_reversible, but also apply circuit optimization.

box_classical_to_reversible_optim :: (QData qa, QData qb) => String -> (qa -> Circ qb) -> (qa, qb) -> Circ (qa, qb) Source #

Like classical_to_reversible_optim, but insert the optimized circuit as a boxed subroutine.