The Circ monad encapsulates the type of quantum operations. For example, a quantum operation that inputs two Qubits and outputs a Qubit and a Bit has the following type:

 (Qubit, Qubit) -> Circ (Qubit, Bit)

The type of qubits.

The type of run-time classical bits (i.e., boolean wires in a circuit).

Synonym for a qubit list, for convenience.

Synonym for a bit list, for convenience.

A time step is a small floating point number used as a parameter to certain gates, such as rotation gates or the [exp −iZt] gate.

Apply a NOT gate to a qubit.

Apply a Hadamard gate.

An alternate name for the Hadamard gate.

Apply a Pauli X gate.

Apply a Pauli Y gate.

Apply a Pauli Z gate.

Apply a Clifford S-gate.

Apply the inverse of an S-gate.

Apply a T = √S gate.

Apply the inverse of a T-gate.

Apply a Clifford E = HS[sup 3]ω[sup 3] gate.

[image E.png]

This gate is the unique Clifford operator with the properties E³ = I, EXE⁻¹ =Y, EYE⁻¹ =Z, and EZE⁻¹ =X. It is a convenient gate for calculations. For example, every Clifford operator can be uniquely written of the form

• E[sup a]X[sup b]S[sup c]ω[sup d],

where a, b, c, and d are taken modulo 3, 2, 4, and 8, respectively.

Apply the inverse of an E-gate.

Apply the scalar ω = [exp iπ/4], as a single-qubit gate.

Apply a V = √X gate. This is by definition the following gate (see also Nielsen and Chuang, p.182):

[image V.png]

Apply the inverse of a V-gate.

Apply an [exp −iZt] gate. The timestep t is a parameter.

Apply a rotation by angle 2πi/2[sup n] about the z-axis.

[image rGate.png]

Apply a W gate. The W gate is self-inverse and diagonalizes the SWAP gate.

[image W.png]

The arguments are such that

 gate_W |0〉 |0〉 = |00〉
 gate_W |0〉 |1〉 = (|01〉+|10〉) / √2
 gate_W |1〉 |0〉 = (|01〉-|10〉) / √2
 gate_W |1〉 |1〉 = |11〉.

In circuit diagrams, W[sub 1] denotes the "left" qubit, and W[sub 2] denotes the "right" qubit.

Apply an iX gate. This gate is used similarly to the Pauli X gate, but with two advantages:

• the doubly-controlled iX gate can be implemented in the Clifford+T gate base with T-count 4 (the doubly-controlled X gate requires T-count 7);
• the iX-gate has determinant 1, and therefore an n-times controlled iX gate can be implemented in the Clifford+T gate base with no ancillas.

In particular, the iX gate can be used to implement an additional control with T-count 8, like this:

[image iX.png]

Apply a −iX gate. This is the inverse of gate_iX.

Apply a global phase change [exp iπt], where typically t ∈ [0,2]. This gate is uninteresting if not controlled; however, it has non-trivial effect if it is used as a controlled gate.

Like global_phase, except the gate is also "anchored" at a qubit, a bit, or more generally at some quantum data. The anchor is only used as a hint for graphical display. The gate, which is a zero-qubit gate, will potentially be displayed near the anchor(s).

Negate all qubits in a quantum data structure.

Apply a NOT gate to a classical bit.

Apply a swap gate to two qubits. More generally, apply swap gates to every corresponding pair of qubits in two pieces of quantum data.

Apply a NOT gate to a qubit.

Apply a Hadamard gate.

An alternate name for the Hadamard gate.

Apply a Pauli X gate.

Apply a Pauli Y gate.

Apply a Pauli Z gate.

Apply a Clifford S-gate.

Apply the inverse of an S-gate.

Apply a T = √S gate.

Apply the inverse of a T-gate.

Apply a Clifford E = HS[sup 3]ω[sup 3] gate.

[image E.png]

This gate is the unique Clifford operator with the properties E³ = I, EXE⁻¹ =Y, EYE⁻¹ =Z, and EZE⁻¹ =X. It is a convenient gate for calculations. For example, every Clifford operator can be uniquely written of the form

• E[sup a]X[sup b]S[sup c]ω[sup d],

where a, b, c, and d are taken modulo 3, 2, 4, and 8, respectively.

Apply the inverse of an E-gate.

Apply the scalar ω = [exp iπ/4], as a single-qubit gate.

Apply a V = √X gate. This is by definition the following gate (see also Nielsen and Chuang, p.182):

[image V.png]

Apply the inverse of a V-gate.

Apply an [exp −iZt] gate. The timestep t is a parameter.

Apply a rotation by angle 2πi/2[sup n] about the z-axis.

[image rGate.png]

Apply a W gate. The W gate is self-inverse and diagonalizes the SWAP gate.

[image W.png]

The arguments are such that

 gate_W |0〉 |0〉 = |00〉
 gate_W |0〉 |1〉 = (|01〉+|10〉) / √2
 gate_W |1〉 |0〉 = (|01〉-|10〉) / √2
 gate_W |1〉 |1〉 = |11〉.

In circuit diagrams, W[sub 1] denotes the "left" qubit, and W[sub 2] denotes the "right" qubit.

Apply an iX gate. This gate is used similarly to the Pauli X gate, but with two advantages:

• the doubly-controlled iX gate can be implemented in the Clifford+T gate base with T-count 4 (the doubly-controlled X gate requires T-count 7);
• the iX-gate has determinant 1, and therefore an n-times controlled iX gate can be implemented in the Clifford+T gate base with no ancillas.

In particular, the iX gate can be used to implement an additional control with T-count 8, like this:

[image iX.png]

Apply a −iX gate. This is the inverse of gate_iX_at.

Negate all qubits in a quantum data structure.

Apply a NOT gate to a classical bit.

Apply a swap gate to two qubits. More generally, apply swap gates to every corresponding pair of qubits in two pieces of quantum data.

Initialize a qubit from a boolean parameter. More generally, initialize a data structure of qubits from a corresponding data structure of boolean parameters. Examples:

 q <- qinit False
 (q0, q1) <- qinit (True, False)
 [q0, q1, q2] <- qinit [True, False, True]

Terminate a qubit, asserting its state to equal the boolean parameter. More generally, terminate a data structure of qubits, asserting that their state is as given by a data structure of booleans parameters. Examples:

 qterm False q
 qterm (False, False) (q0, q1)
 qterm [False, False, False] [q0, q1, q2]

In some cases, it is permissible for some aspect of the parameter's shape to be underspecified, e.g., a longer than necessary list, or an integer of indeterminate length. It is therefore possible, for example, to write:

 qterm 17 qa          -- when qa :: QDInt,
 qterm [False..] qa   -- when qa :: [Qubit].

The rules for when a boolean argument can be "promoted" in this way are specific to each individual data type.

Discard a qubit, ignoring its state. This can leave the quantum system in a mixed state, so is not a reversible operation. More generally, discard all the qubits in a quantum data structure. Examples:

 qdiscard q
 qdiscard (q0, q1)
 qdiscard [q0, q1, q2]

Initialize a Bit (boolean input) from a Bool (boolean parameter). More generally, initialize the a data structure of Bits from a corresponding data structure of Bools. Examples:

 b <- cinit False
 (b0, b1) <- cinit (True, False)
 [b0, b1, b2] <- cinit [True, False, True]

Terminate a Bit, asserting its state to equal the given Bool. More generally, terminate a data structure of Bits, asserting that their state is as given by a data structure of Bools. Examples:

 cterm False b
 cterm (False, False) (b0, b1)
 cterm [False, False, False] [b0, b1, b2]

In some cases, it is permissible for some aspect of the parameter's shape to be underspecified, e.g., a longer than necessary list, or an integer of indeterminate length. It is therefore possible, for example, to write:

 cterm 17 ca          -- when ca :: CInt,
 cterm [False..] ca   -- when ca :: [Bit].

The rules for when a boolean argument can be "promoted" in this way are specific to each individual data type.

Discard a Bit, ignoring its state. This can leave the system in a mixed state, so is not a reversible operation. More generally, discard all the Bits in a data structure. Examples:

 cdiscard b
 cdiscard (b0, b1)
 cdiscard [b0, b1, b2]

Heterogeneous version of qinit. Please note that the type of the result of this function cannot be inferred from the type of the argument. For example,

 x <- qc_init False

is ambiguous, unless it can be inferred from the context whether x is a Bit or a Qubit. If the type cannot be inferred from the context, it needs to be stated explicitly, like this:

 x <- qc_init False :: Circ Qubit

Alternatively, qc_init_with_shape can be used to fix a specific type.

A version of qc_init that uses a shape type parameter. The first argument is the shape type parameter, and the second argument is a data structure containing boolean initializers. The shape type argument determines which booleans are used to initialize qubits, and which ones are used to initialize classical bits.

Example:

 (x,y) <- qc_init_with_shape (bit,[qubit]) (True, [False,True])

This will assign to x a classical bit initialized to 1, and to y a list of two qubits initialized to |0〉 and |1〉, respectively.

Heterogeneous version of qterm.

Heterogeneous version of qdiscard.

Measure a Qubit, resulting in a Bit. More generally, measure all the Qubits in a quantum data structure, resulting in a corresponding data structure of Bits. This is not a reversible operation. Examples:

 b <- measure q
 (b0, b1) <- measure (q0, q1)
 [b0, b1, b2] <- measure [q0, q1, q2]

Prepare a Qubit initialized from a Bit. More generally, prepare a data structure of Qubits, initialized from a corresponding data structure of Bits. Examples:

 q <- prepare b
 (q0, q1) <- prepare (b0, b1)
 [q0, q1, q2] <- prepare [b0, b1, b2]

Heterogeneous version of measure. Given a heterogeneous data structure, measure all of its qubits, and leave any classical bits unchanged.

Heterogeneous version of measure. Given a heterogeneous data structure, prepare qubits from all classical bits, and leave any qubits unchanged.

Return the "exclusive or" of a list of bits.

Test equality of two bits, and return True iff they are equal.

Return the negation of its input. Note that unlike cnot or cnot_at, this gate does not alter its input, but returns a newly created bit.

Return the conjunction of a list of bits.

Return the disjunction of a list of bits.

If a is True, return a copy of b, else return a copy of c. Here b and c can be any data structures consisting of Bits, but b and c must be of the same type and shape (for example, if they are lists, they must be of equal length). Examples:

 output <- cgate_if a b c
 (out0, out1) <- cgate_if a (b0, b1) (c0, c1)
 [out0, out1, out2] <- cgate_if a [b0, b1, b2] [c0, c1, c2]

circ_if is an if-then-else function for classical circuits. It is a wrapper around cgate_if, intended to be used like this:

 result <- circ_if <<<condition>>> (
   <<then-part>>>
   )(
   <<<else-part>>>
   )

Unlike cgate_if, this is a meta-operation, i.e., the bodies of the "then" and "else" parts can be circuit building operations.

What makes this different from the usual boolean "if-then-else" is that the condition is of type Bit, i.e., it is only known at circuit execution time. Therefore the generated circuit contains both the "then" and "else" parts, suitably controlled. Precondition: the "then" and "else" parts must be of the same type and shape.

Define a new functional-style gate of the given name. Usage:

 my_unary_gate :: Qubit -> Circ Qubit
 my_unary_gate = named_gate "Q"

 my_binary_gate :: (Qubit, Qubit) -> Circ (Qubit, Qubit)
 my_binary_gate = named_gate "R"

This defines a new unary gate and a new binary gate, which will be rendered as Q and R, respectively, in circuit diagrams.

Define a new imperative-style gate of the given name. Usage:

 my_unary_gate_at :: Qubit -> Circ ()
 my_unary_gate_at = named_gate_at "Q"

 my_binary_gate_at :: (Qubit, Qubit) -> Circ ()
 my_binary_gate_at = named_gate_at "R"

This defines a new unary gate and a new binary gate, which will be rendered as Q and R, respectively, in circuit diagrams.

Define a new functional-style gate of the given name, and parameterized by a real-valued parameter. This is typically used for rotations or phase gates that are parameterized by an angle. The name can contain '%' as a place holder for the parameter. Usage:

 my_unary_gate :: Qubit -> Circ Qubit
 my_unary_gate = named_rotation "exp(-i%Z)" 0.123

 my_binary_gate :: TimeStep -> (Qubit, Qubit) -> Circ (Qubit, Qubit)
 my_binary_gate t = named_rotation "Q(%)" t

Define a new imperative-style gate of the given name, and parameterized by a real-valued parameter. This is typically used for rotations or phase gates that are parameterized by an angle. The name can contain '%' as a place holder for the parameter. Usage:

 my_unary_gate_at :: Qubit -> Circ ()
 my_unary_gate_at = named_rotation "exp(-i%Z)" 0.123

 my_binary_gate_at :: TimeStep -> (Qubit, Qubit) -> Circ ()
 my_binary_gate_at t = named_rotation "Q(%)" t

Define a new functional-style gate of the given name. Like named_gate, except that the generated gate is extended with "generalized controls". The generalized controls are additional inputs to the gate that are guaranteed not to be modified if they are in a computational basis state. They are rendered in a special way in circuit diagrams. Usage:

 my_new_gate :: (Qubit,Qubit) -> Qubit -> Circ (Qubit,Qubit)
 my_new_gate = extended_named_gate "Q"

This defines a new gate with name Q, two inputs, and one generalized input.

Like extended_named_gate, except defines an imperative style gate. Usage:

 my_new_gate_at :: (Qubit,Qubit) -> Qubit -> Circ ()
 my_new_gate_at = extended_named_gate_at "Q"

This defines a new gate with name Q, two inputs, and one generalized input.

Convert a Bit (boolean circuit output) to a Bool (boolean parameter). More generally, convert a data structure of Bits to a corresponding data structure of Bools.

For use in algorithms that require the output of a measurement to be used as a circuit-generation parameter. This is the case, for example, for sieving methods, and also for some iterative algorithms.

Note that this is not a gate, but a meta-operation. The input consists of classical circuit endpoints (whose values are known at circuit execution time), and the output is a boolean parameter (whose value is known at circuit generation time).

The use of this operation implies an interleaving between circuit execution and circuit generation. It is therefore a (physically) expensive operation and should be used sparingly. Using the dynamic_lift operation interrupts the batch mode operation of the quantum device (where circuits are generated ahead of time), and forces interactive operation (the quantum device must wait for the next portion of the circuit to be generated). This operation is especially expensive if the current circuit contains unmeasured qubits; in this case, the qubits must be preserved while the quantum device remains on standby.

Also note that this operation is not supported in all contexts. It is an error, for example, to use this operation in a circuit that is going to be reversed, or in the body of a boxed subroutine. Also, not all output devices (such as circuit viewers) support this operation.

Generate a new qubit initialized to |+〉 when b=False and |−〉 when b=True.

Generate a new qubit initialized to one of |0〉, |1〉, |+〉, |−〉, depending on a character c which is '0', '1', '+', or '-'.

Generate a list of qubits initialized to a sequence of |0〉, |1〉, |+〉, |−〉, defined by a string argument e.g. "00+0+++".

Apply a Hadamard gate to every qubit in a quantum data structure.

Imperative version of map_hadamard.

Apply a controlled-not gate to every corresponding pair of quantum or classical bits in two pieces of QCData. The first argument is the target and the second the (positive) control.

For now, we require both pieces of QCData to have the same type, i.e., classical bits can be controlled only by classical bits and quantum bits can be controlled only by quantum bits.

Example:

 ((a',b'), (x,y)) <- controlled_not (a,b) (x,y)

is equivalent to

 a' <- qnot a `controlled` x
 b' <- qnot b `controlled` y

Imperative version of controlled_not. Apply a controlled-not gate to every corresponding pair of quantum or classical bits in two pieces of QCData. The first argument is the target and the second the (positive) control.

A version of controlled_not where the control consists of boolean data. Example:

 bool_controlled_not (q, r, s) (True, True, False)

negates q and r, but not s.

A version of controlled_not_at where the control consists of boolean data. Example:

 bool_controlled_not_at (q, r, s) (True, True, False)

negates q and r, but not s.

Create a fresh copy of a piece of quantum data. Note: copying is performed via a controlled-not operation, and is not cloning. This is similar to qc_copy_fun, except it returns only the copy, and not the original.

"Uncopy" a piece of quantum data; i.e. terminate copy, assuming it's a copy of orig. This is the inverse of qc_copy, in the sense that the following sequence of instructions behaves like the identity function:

 b <- qc_copy a
 qc_uncopy a b

Initialize a new piece of quantum data, as a copy of a given piece. Returns both the original and the copy.

Given two pieces of quantum data, assumed equal (w.r.t. the computational basis), terminate the second piece (and return the first, unmodified). This is the inverse of qc_copy_fun, in the sense that the following sequence of instructions behaves like the identity function:

 (orig, copy) <- qc_copy_fun orig
 orig <- qc_uncopy_fun orig copy

Map a single qubit gate across every qubit in the data structure.

Map a binary gate across every corresponding pair of qubits in two quantum data structures of equal shape.

Like mapBinary, except the second data structure is classical.

Heterogeneous version of mapBinary. Map a binary gate f across every corresponding pair of qubits, and a binary gate g across every corresponding pair of bits, in two quantum data structures of equal shape.

A "control source" is anything that can be used as a control on a gate. The most common way to construct a control source is by using the .==., ./=., and .&&. operators. In addition, we provide the following instances:

• Bool. A boolean condition that is known at circuit generation time can be used as a control, which is then either trivial (the gate is generated) or inconsistent (the gate is not generated).
• Wire. This includes the type Bit (for a classical execution-time control) and Qubit (for a quantum control). A wire can be used as a shorthand notation for a positive control on that wire.
• ControlList. A control list is Quipper's internal representation of a control condition, and is trivially a control source.
• A list of control sources can be used as a control source.

A ControlList is Quipper's internal representation of the type of conjunctive controls, i.e., controls that can be constructed using the .==., ./=., and .&&. operators.

This is an infix operator to concatenate two controls, forming their logical conjunction.

(qx .==. x): a control which is true just if quantum data qx is in the specified state x.

The notation (q ./=. x) is shorthand for (q .==. not x), when x is a boolean parameter.

Unlike .==., which is defined for any shape of quantum data, ./=. is only defined for a single control bit or qubit.

An infix operator to apply the given controls to a gate:

 gate `controlled` <<controls>>

It also works with functional-style gates:

 result <- gate `controlled` <<controls>>

The infix operator is left associative, so it can be applied multiple times:

 result <- gate `controlled` <<controls1>> `controlled` <<controls2>>

The latter is equivalent to

 result <- gate `controlled` <<controls1>> .&&. <<controls2>>

A signed item of type a. Signed x True represents a positive item, and Signed x False represents a negative item.

When used with wires in a circuit, a positive sign is used to represent a positive control, i.e., a filled dot, and a negative sign is used to represent a negative control, i.e., an empty dot.

Extract the underlying item of a signed item.

Extract the sign of a signed item: True is positive, and False is negative.

Insert a comment in the circuit. This is not a gate, and has no effect, except to mark a spot in the circuit. How the comment is displayed depends on the printing backend.

Label qubits in the circuit. This is not a gate, and has no effect, except to make the circuit more readable. How the labels are displayed depends on the printing backend. This can take several different forms. Examples:

Label q as q and r as r:

 label (q,r) ("q", "r")

Label a, b, and c as a, b, and c, respectively:

 label [a,b,c] ["a", "b", "c"]

Label q as x[0] and r as x[1]:

 label (q,r) "x"

Label a, b, and c as x[0], x[1], x[2]:

 label [a,b,c] "x"

Combine comment and label in a single command.

Disable labels and comments for a block of code. The intended usage is like this:

 without_comments $ do {
   <<<code block>>>
 }

This is sometimes useful in situations where code is being re-used, for example when one function is implemented in terms of another, but should not inherit comments from it. It is also useful in the definition of recursive function, where a comment should only be applied at the outermost level. Finally, it can be used to suppress comments from parts of circuits for presentation purposes.

Labelable a s means that a is a data structure that can be labelled with the format s. A "format" is a string, or a data structure with strings at the leaves.

A generic interface for wrapping a circuit-generating function into a boxed and named subroutine. This takes a name and a circuit-generating function, and returns a new circuit-generating function of the same type, but which inserts a boxed subroutine instead of the actual body of the subroutine.

It is intended to be used like this:

 somefunc :: Qubit -> Circ Qubit
 somefunc a = do ...
 
 somefunc_boxed :: Qubit -> Circ Qubit
 somefunc_boxed = box "somefunc" somefunc

Here, the type of somefunc is just an example; this could indeed be a function with any number and type of arguments, as long as the arguments and return type are quantum data.

It is also possible to inline the box operator directly, in which case it should be done like this:

 somefunc :: Qubit -> Circ Qubit
 somefunc = box "somefunc" $ \a -> do ...

Note: The box operator wraps around a complete function, including all of its arguments. It would be incorrect to apply the box operator after some quantum variables have already been defined. Thus, the following is incorrect:

 incorrect_somefunc :: Qubit -> Circ Qubit
 incorrect_somefunc a = box "somefunc" $ do ...

It is the user's responsibility not to use the same name for different subroutines. If box is called more than once with the same name and shape of input, Quipper assumes, without checking, that they are subsequent calls to the same subroutine.

The type of the box operator is overloaded and quite difficult to read. It can have for example the following types:

 box :: String -> (Qubit -> Circ Qubit) -> (Qubit -> Circ Qubit)
 box :: String -> (QDInt -> QDInt -> Circ (QDInt,QDInt,QDInt)) -> (QDInt -> QDInt -> Circ (QDInt,QDInt,QDInt))

A version of box with iteration. The second argument is an iteration count.

This can only be applied to functions of a single argument, where the input and output types are the same.

A version of nbox with same type as loopM.

A version of loopM that will be boxed conditionally on a boolean condition. Typical usage:

 loopM_boxed_if (s > 1) "name" s x $ \x -> do
   <<<body>>>
   return x

Convenient wrapper around qinit and qterm. This can be used to introduce an ancilla with a local scope, like this:

 with_ancilla $ \h -> do {
   <<<code block using ancilla h>>>
 }

The ancilla will be initialized to |0〉 at the beginning of the block, and it is the programmer's responsibility to ensure that it will be returned to state |0〉 at the end of the block.

A block created with with_ancilla is controllable, provided that the body is controllable.

Like with_ancilla, but creates a list of n ancillas, all initialized to |0〉. Usage:

 with_ancilla_list n $ \a -> do {
   <<<code block using list of ancillas a>>>
 }

Execute a block with local ancillas. Opens a block, initializing an ancilla with a specified classical value, and terminates it with the same value when the block closes. Note: it is the programmer's responsibility to return the ancilla to its original state at the end of the enclosed block. Usage:

 with_ancilla_init True $ \a -> do {
   <<<code block using ancilla a initialized to True>>>
 }

 with_ancilla_init [True,False,True] $ \a -> do {
   <<<code block using list of ancillas a initialized to [True,False,True]>>>
 }

with_computed_fun x f g: computes x' := f(x); then computes g(x'), which should be organized as a pair (x',y); then uncomputes x' back to x, and returns (x,y).

Important subtlety in usage: all quantum data referenced in f, even as controls, must be explicitly bound and returned by f, or the reversing may rebind it incorrectly. g, on the other hand, can safely refer to anything that is in scope outside the with_computed_fun.

with_computed computation code: performs computation (with result x), then performs code x, and finally performs the reverse of computation, for example like this:

[image with_computed.png]

Both computation and code may refer to any qubits that exist in the current environment, and they may also create new qubits. computation may produce arbitrary garbage in addition to its output.

This is a very general but relatively unsafe operation. It is the user's responsibility to ensure that the computation can indeed be undone. In particular, if computation contains any initializations, then code must ensure that the corresponding assertions will be satisfied in computation[sup −1].

Related more specialized, but potentially safer, operations are:

• with_basis_change, which is like with_computed, but assumes that computation is unitary, and
• classical_to_reversible, which assumes that computation is classical (or pseudo-classical), and code is a simple copy-by-controlled-not operation.

with_basis_change basischange code: performs a basis change, then the code, then the inverse of the basis change. Both basischange and code are in imperative style. It is the user's responsibility to ensure that the image of code is contained in the image of basischange, or else there will be unmet assertions or runtime errors. Usage:

 with_basis_change basischange $ do
   <<<code>>>

 where
   basischange = do
     <<<gates>>>

A syntax for "if"-style (classical and quantum) controls. This can be used as follows:

 gate1
 with_controls <<controls>> $ do {
   gate2
   gate3
 }
 gate4

The specified controls will be applied to gate2 and gate3. It is an error to specify a control for a gate that cannot be controlled (such as measurement).

Classical control on a function with same shape of input and output: if the control bit is true the function is fired, otherwise the identity map is used. Note: the constraint on the types is dynamically checked.

Apply a block of gates while temporarily suspending the application of controls. This can be used to omit controls on gates where they are known to be unnecessary. This is a relatively low-level function and should not normally be called directly by user code. Instead, it is safer to use a higher-level function such as with_basis_change. However, the without_controls operator is useful in certain situations, e.g., it can be used to preserve the NoControlFlag when defining transformers.

Usage:

 without_controls $ do 
   <<code block>>

or:

 without_controls (gate)

Note that all controls specified in the surrounding code are disabled within the without_controls block. This is even true if the without_controls block appears in a subroutine, and the subroutine is later called in a controlled context. On the other hand, it is possible to specify controls inside the without_controls block. Consider this example:

 my_subcircuit = do
   gate1
   without_controls $ do {
     gate2
     gate3 `controlled` <<controls1>>
   }
   gate4

 my_circuit = do
   my_subcircuit `controlled` <<controls2>>

In this example, controls 1 will be applied to gate 3, controls 2 will be applied to gates 1 and 4, and no controls will be applied to gate 2.

Apply without_controls if NoControlFlag is True, otherwise do nothing.

A "for" loop. Counts from a to b in increments of s.

Standard notation:

 for i = a to b by s do
   commands             
 end for

Our notation:

 for a b s $ \i -> do
   commands
 endfor

Mark the end of a "for"-loop. This command actually does nothing, but can be used to make the loop look prettier.

Iterate a parameter over a list of values. It can be used as follows:

 foreach [1,2,3,4] $ \n -> do
   <<<loop body depending on the parameter n>>>
 endfor

The loop body will get executed once for each n ∈ {1,2,3,4}.

Iterate a function n times. Example:

 loop 3 x f = f (f (f x))

Like loop, but also pass a loop counter to the function being iterated. Example:

 loop_with_index 3 x f = f 2 (f 1 (f 0 x))

Monadic version of loop.

Monadic version of loop_with_index. Thus,

 loop_with_indexM 3 x0 f

will do the following:

 do
   x1 <- f 0 x0
   x2 <- f 1 x1
   x3 <- f 2 x2    
   return x3

Reverse a circuit-generating function. The reversed function requires a shape parameter, given as the input type of the original function.

The type of this highly overloaded function is quite difficult to read. It can have for example the following types:

 reverse_generic :: (QCData x, QCData y) => (x -> Circ y) -> x -> (y -> Circ x) 
 reverse_generic :: (QCData x, QCData y, QCData z) => (x -> y -> Circ z) -> x -> y -> (z -> Circ (x,y)) 

Like reverse_generic, but only works at simple types, and therefore requires no shape parameters. Typical type instances:

 reverse_simple :: (QCData_Simple x, QCData y) => (x -> Circ y) -> (y -> Circ x)
 reverse_simple :: (QCData_Simple x, QCData_Simple y, QCData z) => (x -> y -> Circ z) -> (z -> Circ (x,y))

Like reverse_generic, but specialized to endomorphic circuits, i.e., circuits where the input and output have the same type (modulo possibly currying) and shape. In this case, unlike reverse_generic, no additional shape parameter is required, and the reversed function is curried if the original function was. Typical type instances:

 reverse_generic_endo :: (QCData x) => (x -> Circ x) -> (x -> Circ x)
 reverse_generic_endo :: (QCData x, QCData y) => (x -> y -> Circ (x,y)) -> (x -> y -> Circ (x,y))

Like reverse_generic_endo, but applies to endomorphic circuits expressed in "imperative" style. Typical type instances:

 reverse_generic_endo :: (QCData x) => (x -> Circ ()) -> (x -> Circ ())
 reverse_generic_endo :: (QCData x, QCData y) => (x -> y -> Circ ()) -> (x -> y -> Circ ())

Like reverse_generic, but takes functions whose output is a tuple, and curries the reversed function. Differs from reverse_generic in an example such as:

 f                         :: (x -> y -> Circ (z,w))
 reverse_generic f         :: x -> y -> ((z,w) -> Circ (x,y))
 reverse_generic_curried f :: x -> y -> (z -> w -> Circ (x,y))

Note: the output must be a n-tuple, where n = 0 or n ≥ 2. Applying this to a circuit whose output is a non-tuple type is a type error; in this case, reverse_generic should be used.

Like reverse_simple, but takes functions whose output is a tuple, and curries the reversed function. Typical type instance:

 reverse_simple_curried :: (QCData_Simple x, QCData y, QCData z) => (x -> Circ (y,z)) -> (y -> z -> Circ x)

Note: the output must be a n-tuple, where n = 0 or n ≥ 2. Applying this to a circuit whose output is a non-tuple type is a type error; in this case, reverse_generic should be used.

Conditional version of reverse_generic_endo. Invert the endomorphic quantum circuit if the boolean is true; otherwise, insert the non-inverted circuit.

Conditional version of reverse_generic_imp. Invert the imperative style quantum circuit if the boolean is true; otherwise, insert the non-inverted circuit.

Available output formats.

A data type that holds all the customizable parameters.

A mapping from lower-case strings (to be used, e.g., with command line options) to available formats.

Print a circuit generating function to the specified format; this requires a shape parameter.

Print a circuit generating function to the specified format. Unlike print_unary, this can be applied to a circuit-generating function in curried form with n arguments, for any n >= 0. It then requires n shape parameters.

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

 print_generic :: Format -> Circ qa -> IO ()
 print_generic :: (QCData qa) => Format -> (qa -> Circ qb) -> a -> IO ()
 print_generic :: (QCData qa, QCData qb) => Format -> (qa -> qb -> Circ qc) -> a -> b -> IO ()

and so forth.

Like print_generic, but only works at simple types, and therefore requires no shape parameters.

Print a document to the requested format, which must be one of PS, PDF, EPS, or Preview.

Like print_of_document, but also takes a Custom data structure.

Translate all classical gates in a circuit into equivalent controlled-not gates.

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

 classical_to_cnot :: (QCData qa) => Circ qa -> Circ qa
 classical_to_cnot :: (QCData qa, QCData qb) => (qa -> Circ qb) -> (qa -> Circ qb)
 classical_to_cnot :: (QCData qa, QCData qb, QCData qc) => (qa -> qb -> Circ qc) -> (qa -> qb -> Circ qc)

and so forth.

Replace all classical gates in a circuit by equivalent quantum gates.

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

 classical_to_quantum :: (QCData qa) => Circ qa -> Circ (QType qa)
 classical_to_quantum :: (QCData qa, QCData qb) => (qa -> Circ qb) -> (QType qa -> Circ (QType qb))
 classical_to_quantum :: (QCData qa, QCData qb, QCData qc) => (qa -> qb -> Circ qc) -> (QType qa -> QType qb -> Circ (QType qc))

and so forth.

Generic function for turning a classical (or pseudo-classical) circuit into a reversible circuit. The input is a classical boolean function x ↦f(x), given as a not necessarily reversible circuit (however, the circuit should be one-to-one, i.e., no "garbage" should be explicitly erased). The output is the corresponding reversible function (x,y) ↦ x,y ⊕ f(x)). qa and qb can be any quantum data types. The function classical_to_reversible does not itself change classical bits to qubits; use classical_to_quantum for that.

A circuit transformer is specified by defining a function of type Transformer m a b. This involves specifying a monad m, semantic domains a=⟦Qubit⟧ and b=⟦Bit⟧, and a semantic function for each gate, like this:

 my_transformer :: Transformer m a b
 my_transformer (T_Gate1 <parameters> f) = f $ <semantic function for gate 1>
 my_transformer (T_Gate2 <parameters> f) = f $ <semantic function for gate 2>
 my_transformer (T_Gate3 <parameters> f) = f $ <semantic function for gate 3>
 ...

The type T_Gate is used to define case distinctions over gates in the definition of transformers. For each kind of gate X, it contains a constructor of the form (T_X f). Here, X identifies the gate, and f is a higher-order function to pass the translation of X to.

The identity transformer. This just maps a low-level circuits to the corresponding circuit-generating function. It can also be used as a building block in other transformers, to define "catch-all" clauses for gates that don't need to be transformed.

Apply the given transformer to a circuit. Unlike transform_unary, this function can be applied to a circuit-generating function in curried form with n arguments, for any n ≥ 0.

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

 transform_generic :: (QCData x) => Transformer Circ Qubit Bit -> Circ x -> Circ x
 transform_generic :: (QCData x, QCData y) => Transformer Circ Qubit Bit -> (x -> Circ y) -> (x -> Circ y)
 transform_generic :: (QCData x, QCData y, QCData z) => Transformer Circ Qubit Bit -> (x -> y -> Circ z) -> (x -> y -> Circ z)

and so forth.

Like transform_generic, but applies to arbitrary transformers of type

 Transformer m a b

instead of the special case

 Transformer Circ Qubit Bit.

This requires an additional shape argument.

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

 transform_generic :: (QCData x) => Transformer m a b -> Circ x -> m (QCData a b x)
 transform_generic :: (QCData x, QCData y) => Transformer m a b -> (x -> Circ y) -> x -> (QCData a b x -> m (QCData a b y))
 transform_generic :: (QCData x, QCData y, QCData z) => Transformer m a b -> (x -> y -> Circ z) -> x -> y -> (QCData a b x -> QCData a b y -> m (QCData a b z))

and so forth.

A flag that, if True, indicates that the gate is inverted.

A flag that, if True, indicates that the gate is controllable, but any further controls on the gate should be ignored. This is used, e.g., for circuits consisting of a basis change, some operation, and the inverse basis change. When controlling such a circuit, it is sufficient to control the middle operation, so the gates belonging to the basis change and its inverse will have the NoControlFlag set.

An endpoint is either a qubit or a bit. In a transformer, we have ⟦Endpoint Qubit Bit⟧ = ⟦Qubit⟧ + ⟦Bit⟧. The type Endpoint a b is the same as Either a b, but we use more suggestive field names.

An endpoint in a circuit. This is either a Qubit or a Bit.

A list of signed values of type ⟦Endpoint⟧. This type is an abbreviation defined for convenience.

Lift a list of declarations. The first argument is the name of the monad to lift into.

Lift an expression. The first argument is the name of the monad to lift into.

Lifted version of '(:)' :: a -> [a] -> [a].

Lifted version of '[]' :: [a].

Lifted version of init :: [a] -> [a].

Lifted version of last :: [a] -> [a].

Lifted version of '(++)' :: [a] -> [a] -> [a].

Lifted version of zip3.

lifted version of foldl

lifted version of reverse

lifted version of zipWith

Lifted version of fold_right_zip

Lifted version of the combinator $.

Lifted version of error :: String -> a. Using it will make the circuit generation fail with the error described in String.

Lifted version of snd :: (a,b) -> b

The QShape class allows the definition of generic functions that can operate on quantum data of any "shape", for example, nested tuples or lists of qubits.

In general, there are three kinds of data: quantum inputs (such as Qubit), classical inputs (such as Bit), and classical parameters (such as Bool). For example, a Qubit can be initialized from a Bool; a Qubit can be measured, resulting in a Bit, etc. For this reason, the type class QShape establishes a relation between three types:

qa

A data structure having Qubit at the leaves.

ca

A data structure of the same shape as qa, having Bit at the leaves.

ba

A data structure of the same shape as qa, having Bool at the leaves.

Some functions input a classical parameter for the sole purpose of establishing the "shape" of a piece of data. The shape refers to qualities of a data structure, such as the length of a list, which are not uniquely determined by the type. For example, two different lists of length 5 have the same shape. When performing a generic operation, such as reversing a circuit, it is often necessary to specify the shape of the inputs, but not the actual inputs.

In the common case where one only needs to declare one of the types qa, ca, or ba, one of the simpler type classes QData, CData, or BData can be used.

The QData type class contains homogeneous data types built up from leaves of type Qubit.

The CData type class contains homogeneous data types built up from leaves of type Bit.

The BData type class contains homogeneous data types built up from leaves of type Bool.

The QCData type class contains heterogeneous data types built up from leaves of type Qubit and Bit. It is the basis for several generic operations that apply to classical and quantum data, such as copying, transformers, simulation, and heterogeneous versions of qterm and qdiscard.

QCData and QData are interrelated, in the sense that the following implications hold:

 QData qa   implies   QCData qa
 CData ca   implies   QCData ca

Implications in the converse direction also hold whenever qc is a fixed known type:

 QCData qc   implies   QData (QType qc)
 QCData qc   implies   CData (CType qc)
 QCData qc   implies   BData (BType qc)

However, the type checker cannot prove the above implication in the case where qc is a type variable; for this, the more flexible (but more computationally expensive) QCDataPlus class can be used.

The QCDataPlus type class is almost identical to QCData, except that it contains one additional piece of information that allows the type checker to prove the implications

 QCDataPlus qc     implies   QShape (BType qc) (QType qc) (CType qc)
 QCDataPlus qc     implies   QData (QType qc)
 QCDataPlus qc     implies   CData (CType qc)
 QCDataPlus qc     implies   BData (BType qc)

This is sometimes useful, for example, in the context of a function that inputs a QCData, measures all the qubits, and returns a CData. However, the additional information for the type checker comes at a price, which is drastically increased compilation time. Therefore QCDataPlus should only be used when QCData is insufficient.

A dummy term of type Bit. It can be used in shape parameters (e.g., qc_init), as well as shape type parameters (e.g., qcdata_mapM).

A dummy term of type Qubit. It can be used in shape parameters (e.g., qc_init), as well as shape type parameters (e.g., qcdata_mapM).

Return a quantum data structure of the given boolean shape, with every leaf initialized to the undefined dummy value qubit.

Return a boolean data structure of the given shape, with every leaf initialized to False.

This is a quantum analogue of Haskell’s Eq type class. Default implementations are provided; by default, equality is bitwise equality of the underlying data structure. However, specific instances can provide custom implementations. In this case, q_is_equal is a minimal complete definition.

This is a quantum analogue of Haskell's Ord type class. Its purpose is to define a total ordering on each of its instances. The functions in this class are assumed dirty in the sense that they do not uncompute ancillas, and some of the inputs may be returned as outputs. The functions are also assumed to be non-linear safe, i.e., they apply no gates to their inputs except as control sources. Minimal complete definition: q_less or q_greater. The default implementations of q_max and q_min assume that both arguments are of the same shape (for example, numbers of the same length).

q_lt qx qy: test whether qx < qy. A functionally typed wrapper for q_less.

q_gt qx qy: test whether qx > qy. A functionally typed wrapper for q_greater.

q_le qx qy: test whether qx ≤ qy. A functionally typed wrapper for q_leq.

q_ge qx qy: test whether qx ≥ qy. A functionally typed wrapper for q_geq.