Reusable Quantum Programs

5.1 Circuit Interfaces

Suppose a computation needs the same \(R_y\) rotation in several places, at different angles. We could copy its lines each time, but every copy is a chance for a mistake. A component that can be reused needs two things: a way to produce it on demand, and a stated agreement about how it connects to the rest of a circuit. We take them in that order.

5.1.1 Python circuit factories

Why not build the rotation circuit once and reuse that one object everywhere? Recall that two Python names can refer to one circuit. Suppose two experiments share the object and the first appends a measurement to it. The second experiment now contains that measurement too, although nobody added it there. Its result depends on what ran before.

The cure is a function that builds a new circuit every time it is called. Such a function is called a circuit factory. In the companion, rotation(theta) creates a one-qubit circuit, applies \(R_y(\theta)\) and returns it. The input name="rotation" labels the circuit, so the label appears when it is drawn as a box. Because the caller receives the circuit rather than a result, the caller also decides where it is placed and when it is run.

5.1.2 Register contracts and composition

A factory returns a correct circuit. What can still go wrong when we plug it into a larger one? Consider a component that computes the AND of two bits into a third qubit, using a Toffoli gate. A function from input bits to one output bit is called a Boolean predicate. The component is correct only if the larger circuit attaches its wires as intended: inputs on the first two wires, the result qubit, called the target, on the third.

So the component needs a stated agreement, a contract, written beside the factory. For the AND component it reads: “wires 0 and 1 are inputs and are left unchanged; wire 2 is the target and is flipped exactly when both inputs are 1.” When we place the component with compose, its qubits argument must follow the contract. A component that is mathematically right but attached to the wrong wires is still a bug, and the bit-order convention makes such mistakes easy.

5.2 Reusable Operations

A factory gives us circuits. Algorithms ask more of a component: to act as one gate, to act only when a control qubit is 1, to run backwards, and to be evaluated at many angles. Each request has a trap. We take control first, because it reveals that a phase we called unobservable can matter, and then turn to inverses and symbolic angles.

5.2.1 Custom gates and controlled gates

Many algorithms need “apply \(U\) only if the control qubit is 1.” Could we write a host-language if around the append? No: at construction time the control qubit has no value, and in superposition it never has one. We need a single unitary that acts as \(I\) on the target when the control is \(\ket0\) and as \(U\) when it is \(\ket1\), the controlled \(U\).

Qiskit builds it in two steps. to_gate() packages a circuit as one gate object, and control(1) adds one control qubit. In qc.append(controlled, [0, 1]) the control comes first in the list, so qubit 0 controls and qubit 1 is the target. Control is not free. A controlled \(R_y\), for example, decomposes into two CNOTs and two one-qubit gates.

There is a subtler trap. Suppose a component’s circuit implements \(e^{i\varphi}I\), the identity up to a global phase. Alone, that phase changes no prediction. Is it still harmless when controlled? With the control on qubit 0, the controlled operation is \[\operatorname{diag}(1,\,e^{i\varphi},\,1,\,e^{i\varphi})=I\otimes P(\varphi),\] where \(P(\varphi)=\operatorname{diag}(1,e^{i\varphi})\) is a phase gate on the control. If the control is in \(\ket+\), it becomes \((\ket0+e^{i\varphi}\ket1)/\sqrt2\), a different state. So a global phase of the base operation becomes a relative phase on the control. A component that may be controlled must keep its global phase, and Qiskit records it in the circuit’s global_phase attribute.

5.2.2 Inverses and parameter binding

Suppose we need the rotation at 100 different angles. Must we build 100 circuits? Instead, we can build one circuit in which the angle is a symbol. Parameter("theta") creates such a symbol, and passing it to the factory gives a circuit with \(R_y(\theta)\) and \(\theta\) left open. To fix a value we call assign_parameters({angle: 0.7}). Its input is a dictionary from symbol to number, and it returns a copy of the circuit with the number in place, leaving the symbolic circuit unchanged.

Running backwards is the other request. inverse() reverses the order of the gates and replaces each by its adjoint, as for any product of unitaries. A circuit that contains measurement or reset has no such inverse, as we saw for reset.

The companion uses both. It binds the angle to 0.7, composes the bound circuit with its inverse, and checks that the product is the identity matrix. It then controls the bound rotation and draws the result.

"""Runnable companion for Quantum Programming, Chapter 5."""
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import Operator

angle = Parameter("theta")
def rotation(theta):
    qc = QuantumCircuit(1, name="rotation")
    qc.ry(theta, 0)
    return qc

component = rotation(angle)
bound = component.assign_parameters({angle: 0.7})
identity = bound.compose(bound.inverse())
assert np.allclose(Operator(identity).data, np.eye(2))
controlled = bound.to_gate().control(1)
qc = QuantumCircuit(2)
qc.append(controlled, [0, 1])
print(qc.draw(output="text"))

Companion script: chapter_05.py.

5.3 Workspace Contracts

Some components cannot be built from their inputs and target alone. Computing the AND of three bits with Toffoli gates, for instance, needs a qubit to hold an intermediate result. What must such an extra qubit contain when the component starts, and what must the component leave in it? We first state the starting requirement, then the cleanup requirement and how to test it.

5.3.1 Ancilla allocation

Suppose we want \(t\oplus(x_0\wedge x_1\wedge x_2)\) on a target \(t\). A Toffoli has only two controls, so we first compute \(x_0\wedge x_1\) into an extra qubit \(a\), then apply a Toffoli controlled by \(a\) and \(x_2\) onto \(t\). An extra qubit used as workspace is called an ancilla.

What must \(a\) start in? A Toffoli adds \(x_0x_1\) to \(a\), so \(a\) holds \(x_0\wedge x_1\) only if it started at 0. If it started at 1, the target would receive the wrong value. So the contract must say “one clean ancilla in \(\ket0\).” A qubit whose state is unknown, which must be handed back unchanged, is called a borrowed qubit. It is a different resource and needs a different construction.

An ancilla is a qubit, not a temporary Python variable. When a Python name stops referring to it, nothing physical happens. Whatever correlation it has with the data remains.

5.3.2 Uncomputation and cleanup checks

After the second Toffoli, \(a\) still holds \(x_0\wedge x_1\). Why not leave it there? On a basis input nothing seems wrong. On a superposition \(\sum_x\alpha_x\ket x\), however, the state becomes \(\sum_x\alpha_x\ket x\ket{t\oplus f(x)}\ket{x_0x_1}\). The ancilla now carries information about the inputs, so it is entangled with them. As with one half of a Bell pair, the inputs alone lose the off-diagonal entries that later interference needs.

So we apply the first Toffoli again. It adds \(x_0x_1\) a second time and returns \(a\) to 0 for every input. Undoing a computation to clear workspace is called uncomputation. The full state then factors as \(\left(\sum_x\alpha_x\ket x\ket{t\oplus f(x)}\right)\otimes\ket0_a\).

How do we test that? Checking basis inputs one at a time shows that \(a\) returns to 0 for each, which is necessary. It does not show that the useful registers keep the right relative phases. A test on a superposition of inputs does, by comparing the whole state with the factored form above. Measuring the ancilla and always seeing 0 is useful evidence, but it says nothing about the target’s action. A phase-sensitive test of this kind is exactly what an oracle needs, and we build one when we implement oracles.

Our components now have interfaces we can trust. Running them still gives us only counts or amplitudes. How does a program get from a circuit to the particular number, a probability or an average, that it actually needs?

Sources and further study: IBM, QuantumCircuit API.