This module provides a user-friendly interface to building quantum circuits out of classical functions on booleans. It is based on lower-level functionality provided by Libraries.Template.

Technically, the only functions to be used in this module are decToCircMonad, a specialized version of decToMonad, and unpack. The only useful datatype here is BoolParam.

One should not have to directly use the other things: they are only for the internal use of Template Haskell to build quantum circuits out of classical computation on booleans.

Note: in the following, we write circuits in ASCII form. The following conventions are used. They are extended in obvious ways when applicable (e.g. when writing a ternary gate).

 ---- : wire
 
 0 |-- : initialize an ancilla |0>
 
 --| 0 : terminate an ancilla, asserting it was |0>
 
   +--+
  -|  |- : a unary gate
   +--+
 
   +--+
  -|  |- 
   |  |  : a binary gate
  -|  |- 
   +--+

  -- --
    X   : swap gate
  -- --
 
  --x-- 
    |   : controlled-not, applying NOT on the bottom wire if the top one is |1>
  --N-- 

  --o-- 
    |   : controlled-not, applying NOT on the bottom wire if the top one is |0>
  --N-- 

Using the tool decToMonad designed in Libraries.Template, we can easily generate quantum circuits. Indeed, suppose that we are given the classical oracle

 toyOracle :: Bool -> Bool
 toyOracle a = f (g a) (h a)

for some g,h :: Bool -> Bool and f :: Bool -> Bool -> Bool. If g and h are given by quantum circuits of the form

          +-----+
 input ---|     |-- input wire, assumed to be not modified by the box
          |     |
      0 |-|     |--- output (was ancilla wire)
          +-----+

and if f is given by

          +-----+
 input ---|     |-- was input 1, assumed to be not modified
          |     | 
 input ---|     |-- was input 2, assumed to be not modified
          |     |
     0 |--|     |-- output (was ancilla wire),
          +-----+

we can compositionally generate a circuit C for toyOracle as follows.

          +---+                    +---+
 input ---|   |-- -----------------|   |-- (output of g)
          | g |  X  +---+          |   |
     0 |--|   |-- --|   |--- ------| f |-- (output of h)
          +---+     | h |   X      |   |                   (I)
     0 |------------|   |--- - ----|   |-- (output of f)
                    +---+     X    +---+
                          0 |- ----------- (input of g)

Note that the resulting circuit is a classical, reversible circuit (more precisely, the circuit defines a one-to-one function). In order to obtain a reversible quantum circuit, one should then apply the function classical_to_reversible to get the following (we keep the same convention of wires as in the definition of C):

        +---+     +---+
 input--|   |-----|   |-- still the input
        |   |     |   |
   0 |--|   |-----|   |--| 0
        | C |     | D |                                    (II)
   0 |--|   |--x--|   |--| 0
        |   |  |  |   |
   0 |--|   |--|--|   |--| 0
        +---+  |  +---+
               |
 output wire---N--------------.

Here D is the inverse of C. We now have a circuit of the canonical form, computing and then uncomputing its ancillas:

     +-----------+
 a --|           |- a
     | toyOracle |
 z --|           |- z + (f (g a) (h a))
     +-----------+

During the construction of a quantum circuit from classical code, the type Bool is mapped to the type Qubit. However, it is also sometimes useful to specify boolean parameters to be used during circuit generation (for example, in the BWT algorithm, the color is a parameter). For this purpose, we provide a new type BoolParam, which is identical to Bool in most respects, except that it is not mapped to Qubit during circuit generation.

The main tool for transforming a classical computation into a quantum circuit is the function decToCircMonad. It inputs the syntax tree of a classical function, and outputs the syntax tree of a corresponding quantum circuit. The type Bool is mapped to Qubit; the type BoolParam is unchanged; and each function f : a

Quipper comes equipped with syntactic sugar to ease the use of the decToCircMonad function.

Although the code

 $( decToCircMonad [d| f x = ... |] )

is valid, it is possible to use the special keyword build_circuit, as follows:

 build_circuit
 f x = ...

This code is equivalent to

 f x = ...
 $( decToCircMonad [d| f x = ... |] )

In other words, it generates both a function f of type a -> ... and an object template_f of type Circ (a -> Circ ...).

The following spellings are recognized:

 build_circuit f x y z = ...

 build_circuit
 f x y z = ...

 build_circuit
 f :: a -> ...
 f x y z = ...

The last term we need to build is template_if, a term describing the if-then-else construct as a circuit.