Circuit Construction

3.1 Registers and Gates

The Bell pair comes from H on one qubit followed by a CNOT. To write it as a program we must name the qubits, name the bits that receive their measurements, and put the gates in order. Only equal bits should appear when we measure, but a symmetric result can hide an ordering mistake, so we will need an asymmetric test before trusting the program. We begin with the names.

3.1.1 Quantum and classical registers

What does QuantumCircuit(2) actually create? It creates two quantum wires, numbered 0 and 1. A group of qubits addressed together is called a quantum register. Qubits carry quantum states, but measurement results are ordinary bits, and they need somewhere to go. A classical register is a row of classical bits that receives measurement records.

Gates refer to qubits by number. In bell.h(0) followed by bell.cx(0, 1), the first argument of cx is the control and the second is the target. So qubit 0 gets the H and controls the CNOT, and qubit 1 is flipped when qubit 0 is 1.

That fixes what each instruction does. It does not yet fix how a two-qubit state or a measured string is written down. When we computed the Bell state by hand, we wrote qubit 0 as the first label. Whether Qiskit does the same is a question we will settle by experiment.

3.1.2 Gate order and circuit composition

Each method call appends its gate after the ones already there, so the program lists gates in the order they happen. How does that order appear in the matrix of the whole circuit?

Suppose we apply \(U\) and then \(V\). The state becomes \(V(U\ket\psi)=(VU)\ket\psi\). The gate applied last stands on the left. So a program that appends \(U_1,U_2,\dots,U_k\) has the matrix \(U_k\cdots U_2U_1\), the reverse of the reading order.

Programs also need to join circuits. The method compose places one circuit after another and returns the combined circuit. Its qubits argument says which wires of the larger circuit receive the smaller circuit’s wires. Writing qubits=[1, 0], for instance, sends the small circuit’s qubit 0 to wire 1. Without such a mapping, a component built for one wire order would be silently attached in another.

A composed circuit may also appear as one labelled box. A box can stand for many elementary gates, and its size on the page says nothing about that number. The method decompose() replaces each box by its contents, one level at a time, so we can see what it costs.

3.2 Measurement

The gates are now in order, but the result of a program is a string of classical bits. Two choices stand between a qubit and a character of that string: which bit stores the qubit’s measurement, and where that bit appears in the printed string. We make the first choice explicit, then use an asymmetric experiment to discover the second.

3.2.1 Mapping qubits to classical bits

Who decides which classical bit receives which qubit’s outcome? We do, or a default does. The coin program used measure_all(), which adds a register named meas and measures qubit \(j\) into bit \(j\). The method measure(qubit, clbit) instead names one qubit and one classical bit, so we can choose any mapping.

Suppose we measure qubit 0 into bit 1 and qubit 1 into bit 0. The quantum state is unchanged, yet every result string now describes the qubits in the swapped order. A count string describes classical storage, not wires. So decoding a result requires knowing the measurement mapping.

3.2.2 Bit strings and tensor-product ordering

With the default mapping, which character of a printed string belongs to qubit 0? The Bell pair cannot tell us, because 00 and 11 read the same in both directions. So we need a state that is not symmetric. Suppose we apply X to qubit 0 alone. Then qubit 0 is 1 and qubit 1 is 0. If Qiskit wrote qubit 0 first, as we did by hand, we would see 10.

The companion asks for the probabilities of this state, and the answer is {"01": 1.0}. So qubit 0 is the rightmost character. Qiskit reads a bit string as a binary number, with qubit 0 as the least significant digit, just as the ones digit of an ordinary number sits on the right. A two-qubit basis state is written \(\ket{q_1q_0}\), and its position in the state vector is \(k=q_0+2q_1\). Our state is \(\ket{01}\), at index 1.

The tensor product follows the same convention. The state vector is \(\ket{q_1}\otimes\ket{q_0}\), so a gate \(A\) on qubit 0 alone has the matrix \(I\otimes A\), with \(A\) on the right. The Bell state \((\ket{00}+\ket{11})/\sqrt2\) is the same in both conventions, which is why the Bell test could not catch a mistake. A drawing with qubit 0 at the top does not change any of this. It is a picture, not a reordering of the mathematics.

3.3 Circuit Inspection

We now know what every index means. Can we confirm that the program we wrote is the circuit we meant? Two kinds of evidence are available: what the circuit looks like, and what it computes. We take the picture first, then compare the computed results with our prediction.

3.3.1 Drawing and decomposing circuits

The quickest check is to look. draw(output="text") prints a drawing made of characters, so it needs no plotting software. We read its wires from left to right in time, and qubit 0 is the top wire. The returned bit strings still follow the classical register order, with qubit 0 on the right. So the top-to-bottom order of the drawing is the right-to-left order of a result string.

A drawing can mislead in one way. A familiar-looking box may hide arithmetic or gates with many controls. When a box appears, decompose() shows what it contains, and count_ops() counts the gates of each kind. A compact picture is not a small circuit.

3.3.2 Comparing code with predicted evolution

What should the program’s numbers be? The Bell state is \((\ket{00}+\ket{11})/\sqrt2\), so ideal measurements give 00 and 11, each with probability one half, and never 01 or 10. The exact split between 00 and 11 fluctuates from run to run, so the test cannot demand it. What it can demand is that no other string ever appears.

The companion repeats the steps of the coin program on one line. Each dot applies to the result of everything to its left. The expression set(counts) makes a set, a collection without order or repeats, holding the keys of the dictionary. The test <= between sets asks whether the first is contained in the second. So the first check says that every observed string is 00 or 11. The second check is the asymmetric experiment, computed exactly with probabilities_dict().

"""Runnable companion for Quantum Programming, Chapter 3."""
from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
from qiskit.quantum_info import Statevector

bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
counts = StatevectorSampler(seed=8).run([bell], shots=1024).result()[0].data.meas.get_counts()
assert set(counts) <= {"00", "11"}
# An asymmetric check is essential: a Bell state hides reversed bit order.
asymmetric = QuantumCircuit(2)
asymmetric.x(0)
assert Statevector.from_instruction(asymmetric).probabilities_dict() == {"01": 1.0}
print(bell.draw(output="text"))
print(counts)

Companion script: chapter_03.py.

With seed 8, the run printed 533 counts of 00 and 491 of 11, and no other strings. Is that enough to show that the two qubits are entangled?

Not yet. Consider a device that prepares \(\ket{00}\) half the time and \(\ket{11}\) otherwise. Such a random choice between states is a classical mixture. It gives exactly the same measured counts. To tell the two apart, we apply H to both qubits before measuring. On the Bell state, H on both qubits gives \((\ket{{+}{+}}+\ket{{-}{-}})/\sqrt2\). Expanding, \(\ket{{+}{+}}=(\ket{00}+\ket{01}+\ket{10}+\ket{11})/2\) and \(\ket{{-}{-}}=(\ket{00}-\ket{01}-\ket{10}+\ket{11})/2\), so the 01 and 10 terms cancel and the Bell state returns. We still see only 00 and 11. But H on both sends \(\ket{00}\) to \(\ket{{+}{+}}\) and \(\ket{11}\) to \(\ket{{-}{-}}\), and each of these gives all four strings with probability one quarter. Testing in this second basis exposes the difference.

Sampled counts gave us only indirect evidence about the state. Since a simulator computes the full state anyway, could we compare a circuit with its vector and its matrix directly?

Sources and further study: IBM, bit ordering.