Circle notation for multi-qubit registers

How can we extend our circle notation to multiple qubits? If we were only ever interested in qubits that didn’t interact with one another, then we could simply employ the representation we used for a single qubits, but multiple times - using a pair of circles for the ∣0〉 and ∣1〉 states of each qubit. Although this naive representation allows us to describe a superposition of any one individual qubit, there’s are ways we might superpose groups of qubits that it cannot represent (as we’ll see below).

So how else could we represent the state of a register of multiple qubits? Just as is the case with conventional bits, a register of N qubits can be used to represent one of different values. For example, a register of three qubits, having qubits in the states ∣0〉∣1〉∣1〉 can represent a decimal value of 3. When talking about multi-qubit registers, we’ll often describe the decimal value that the register represents in the same quantum notation that we used for a single qubit. So whereas a single qubit can be in the states ∣0〉 and ∣1〉, a two-qubit register has possible states ∣0〉, ∣1〉, ∣2〉 and ∣3〉. Making use of the quantum nature of our qubits we can also create superpositions of these different values. This being the case, to represent N qubits, let’s use a separate circle for each of the 2^N different values that an N-bit number can assume.

Figure 3-1. Circle notation for various numbers of multiple qubits

In Figure 3-1, we see the familiar 2-circle ∣0〉, ∣1〉 representation for a single qubit. For two qubits we have circles for ∣0〉, ∣1〉, ∣2〉, ∣3〉. This is not “one pair of terms per qubit”; instead, it is one term for each possible two-bit number you may get by reading these qubits. For four qubits, the terms are ∣0〉 … ∣7〉. As shown above, this means that we can now associate a magnitude and relative phase with each of these 2^N values. In the case of the 3-qubit example, the magnitude of each of the circles represents the probability that a specific 3-bit value (0-7) will be observed when all three qubits are read.

You may be wondering what such a superposition of a registers value looks like in terms of the states of the individual qubits making up the register. In some cases we can easily see what the individual qubit states must be. For example, in Figure 3-2 the three-qubit register superposition of the states ∣0〉, ∣2〉, ∣4〉 and ∣6〉 can easily be expressed in terms of each individual qubit’s state.

Figure 3-2. Some multi-qubit quantum states can be understood in terms of single qubit states

In fact, this multiqubit state can be cenerated simply using two single-qubit HAD operations, as shown by the following code snippet:

So we can understand the multi-qubit state in Figure 3-2 in terms of its constituent qubits. But take a look at the state of a three-qubit register shown in Figure 3-3.

Figure 3-3. Quantum relationships between multiple qubits.

This represents the state of a three qubits in equal superposition of ∣0〉 and |7>. Can we visualize this state in terms of what each individual qubit is doing like we did in Figure 3-2? Since 0 and 7 are 000 and 111 in binary, we have a superposition of all three qubits being in the state ∣0〉 (∣0〉∣0〉∣0〉) and all three qubits being in state ∣1〉 (∣1〉∣1〉∣1〉)). Surprisingly, in this case, there is no way to write down circle representations for the individual qubits! Notice that for this three qubit state a readout of the qubits always results in us finding them to have the same values (with 50% probability that value will be 0, and with 50% probability it will be 1). So clearly the three qubits must, in some sense, be linked - to ensure that their outcomes are the same.

This link is the new and powerful entanglement phenomenon that we previously mentioned. Entangled states can’t be described only in terms of what the individual qubits are doing - although you’re welcome to try! The entanglement link is only describable in the configuration of the whole multi-qubit register. It also turns out to be impossible to produce entangled states from only single-qubit operations. So to explore entanglement in more detail, we’ll need to introduce multi-qubit operations, and for that we’ll need to be able to deftly apply everything we’ve learned so far to circuits containing registers of many qubits.

Drawing a Multi-Qubit Register

We now know how to describe the configuration of N qubits in circle notation using 2^N circles, but what about drawing multi-qubit quantum circuits? Since our multi-qubit circle notation considers each qubit to take a position in a length N bit-string, it will be convenient to label each qubit according to it’s binary value.

As an example, let’s take another look at the random qubyte circuit we introduced in Chapter 2. There we simply labelled the eight qubits as qubit 1, qubit 2, etc… But here’s how that circuit looks if we properly label each qubit with the binary value it represents. Note that we follow the standard memory addressing practise of using hexadecimal:

Figure 3-4. One random byte

Single-qubit Operations in Multi-Qubit Registers

Now we know how to draw circuits of multiple qubits, and how to represent them in circle notation, let’s start doing something with them. Starting with the operations we’ve already covered, what happens (in circle notation) when we apply single-qubit operations such as NOT, HAD and PHASE to a multi-qubit register? The operation is almost identical to the single-qubit case. The only difference is that the circles are operated on in certain operator pairs specific to the qubit that the operation acts on.

To identify a qubit’s operator pairs, match each circle with the one whose value differs by the qubit’s bit-value, as shown in Figure 3-5.

Once these operator pairs have been identified, the operation is performed on each pair, just as if the members of a pair were the ∣0〉 and ∣1〉 values of a single-qubit register. For a NOT operation, the circles in each pair are simply swapped as in Figure 3-5.

Figure 3-5. The NOT operation swaps terms in each of the qubit’s operator pairs.

For a single-qubit PHASE operation, the right-hand circle of each pair is rotated by the phase angle, as in Figure 3-6

Figure 3-6. Single-qubit phase in a multi-qubit register.

Thinking in terms of operator pairs is a good way to quickly visualize the action of single-qubit operations on a register. For a deeper understanding of why this works we need to think about the effect that an operation on a given qubit has on the binary representation of the whole register. For example, the circle-swapping action of a NOT on the second qubit in Figure 3-5 corresponds to simply flipping the second bit in each term’s binary representation. Similarly, a single-qubit PHASE operation on (for example) the third qubit rotates each circle for which the third bit is 1. A single-qubit PHASE will always cause exactly half of the terms to be rotated, and which half just depends on which qubit is the target of the operation.

The same kind of reasoning helps us think about the action of any other single qubit operation on qubits from larger registers.

Reading a qubit in a multi-qubit register

What should we expect when we perform a READ operation on a single qubit from a multi-qubit register? A READ operation also functions using operator pairs. If we have a multi-qubit circle representation then we can determine the probability of obtaining a “0” outcome for one single qubit by adding the magnitudes of all of the circles on the ∣0〉 (left-hand) side of that qubits operator pairs. Similarly we can determine the probability of “1” by adding the magnitudes of all of the circles on the ∣1〉 (right-hand) side of the qubits operator pairs.

Following a READ, the state of our multi-qubit register will change to reflect which outcome occurred. All circles which do not agree with the result, will be eliminated as shown in Figure 3-7 (following this elimination, the state will also have the remaining terms ‘renormalized’ so that their magnitudes add up to 100%). Figure 3-7 below illustrates how the READ operation affects a multi-qubit register in circle notation:

Figure 3-7. Reading one qubit in a multi-qubit register

To read more than one qubit, each single-qubit read operation can be performed individually according to this operator pair prescription.

Visualizing Larger Numbers of Qubits

Since N qubits require 2^N terms (circles in circle notation), each additional qubit we might add to our QPU doubles the number of terms (or circles) we need to keep track of. As Figure 3-8 shows, the number of terms quite quickly increases to the point where our circle notation circles become vanishingly small.

Figure 3-8. Circle notation for larger qubit counts

With so many tiny circles, the circle-notation visualization becomes useful for seeing patterns instead of individual values, and we can zoom in to any areas we want a more quantitative view of. Nevertheless, we can improve clarity in these situations by exaggerating the amplitudes, making the phase-needles bold, and also using differences in color or shading to emphasize differences in phase as shown in Figure 3-9.

Figure 3-9. Sometimes exaggeration is warranted

In the chapters ahead, we will sometimes make use of these techniques to illustrate aspects of quantum states. But even these eyeball-hacks are only useful to a point; for a 32-qubit system there are 4,294,967,296 circles. Displaying them in a 65,536x65,536 grid of circles is too much information for most displays and eyes alike.

Hands-on: Using Bell Pairs for shared randomness

The entangled state we created in Figure 3-14 is commonly referred to as a Bell pair¹. Let’s see a quick and easy way to put the powerful link within this state to use.

We saw in the previous chapter how simply measuring a qubit in superposition provides us with a Quantum Random Number Generator. Similarly, the reading out of a Bell pair acts like a QRNG, only now we will obtain agreeing random values on two qubits.

A surprising fact about entanglement is that the qubits involved remain entangled no matter how far apart we may move them. Thus we can easily use Bell pairs to generate correlated random bits at different locations. Such bits can be the basis for establishing secure shared randomness - something that critically underlies the modern internet.

The below code snippet shows how we can implement this prescription to generate shared randomness, by creating a Bell pair and then reading out a value from each qubit.

Figure 3-15. Bell Pair circuit

Constructing Any Conditional Operation

We’ve introduced CNOT and CPHASE operations, but is there such thing as a CHAD (conditional HAD), or a CRNOT (conditional RNOT)? There are, and even if a conditional version of some single qubit operation is missing from the instruction set of a particular QPU, there’s a process by which we can “convert” single qubit operations into a multi-qubit conditional ones.

The general prescription for conditioning a single qubit operation involves a little more mathematics than we want to cover here, but seeing a couple of examples will help us feel more comfortable with the idea (and also be useful to us later on). The key idea is breaking our single qubit operation into smaller steps. It turns out that it’s always possible to break a single qubit operation into a set of steps such that we can use CNOTs to conditionally undo our operation.

This is much easier to see with a simple example: suppose we are writing software for a QPU whose instruction set includes CNOT, CZ and PHASE, but no instruction to perform CPHASE. This is actually a very common case with modern QPUs, but fortunately we can easily add a CPHASE at the compiler stage.

Recall that the desired effect for a 2-qubit CPHASE is to rotate the phase for any term for which both qubits are take value ∣1〉 (in this example we consider CPHASE(90)):

Figure 3-20. Desired operation of a CPHASE(90) operation

We can easily break down a PHASE(90) operation into smaller pieces by rotating through smaller angles. For example, PHASE(90)=PHASE(45)PHASE(45). We can also undo a rotation by rotating in the opposite direction, for example the operation PHASE(45)PHASE(-45) is the same as doing nothing to our qubit. With these facts in mind, we can construct the CPHASE(90) operation described in Figure 3-20 as follows:

Figure 3-21. Constructing a CPHASE operation

theta = 90;

// Using two CNOTs and three PHASEs...
qc.phase( theta / 2, 0x2);
qc.cnot(0x2, 0x1);
qc.phase(-theta / 2, 0x2);
qc.cnot(0x2, 0x1);
qc.phase( theta / 2, 0x1);

// Builds the same operation as a 2-qubit CPHASE
qc.phase(theta, 0x1 | 0x2);

Following this circuit through for different possible inputs we can see how it works to only apply PHASE(90) when both qubits are 1 (an input of 11). To see this it helps to recall that PHASE has no effect on a qubit in the state ∣0〉. Alternatively, we can follow the action of Figure 3-22 using circle notation.

Figure 3-22. Step-by-step through the constructed CPHASE operation

Another example of conditioning a single qubit operation that will be useful to us in later chapters is ROTY…

[[ Example of conditioning ROTY to be added]]

Hands-on: Remote-controlled randomness

Armed with multi-qubit operations we’re now in a position to start making use of the power of quantum entanglement. We can explore some interesting and non-obvious properties of entanglement using a small QPU program for remote controlled random number generation. This program will generate two qubits, such that reading out one instantly affects the probabilities for obtaining a random bit read out from the other. Moreover, this effect occurs over any distance of space or time. This seemingly impossible task, enabled by a QPU, is surprisingly simple to implement.

Here’s how the remote control will work: We will manipulate a pair of qubits such that reading one qubit (either one) returns a 50/50 random bit which tells you the “modified” probability of the other. If the result is 0, then the other qubit will have 15% probability of being 1. Otherwise, if the qubit you read returns 1, then the other one will have 85% probability of being 1.

The sample code in Example 3-3 shows how to implement this remote controlled random number generator. As in Example 3-1 we make use of the QCEngine qint object to be able to properly address different qubits directly as objects:

We can follow the effect of each operation within this circuit in circle notation:

Figure 3-26. The remote-random sample, step by step

After these steps are completed we’re left with an entangled state of the two qubits shown at the end of Figure 3-26 - for which we have amplitudes in each possible state ∣0〉, ∣1〉, ∣2〉 and ∣3〉.

Let’s consider what would happen if we prepare this state and then read out qubit a. If qubit a were read out to have value 0 (as it will with 50% probability), then only the circles compatible with this state of affairs would remain. These are the terms for ∣0〉∣0〉 = ∣0〉 and ∣1〉∣0〉 = ∣2〉, and so the state of the two qubits becomes the following:

Figure 3-27. The state of one qubit in the remote control after the other is READ to be 0.

The two terms in this state have non-zero probabilities, both for obtaining 0 and for obtaining 1 when reading out qubit +b+. In particular, qubit a has 70%/30% probabilities of reading out 0/1:

However, suppose that our initial measurement on qubit a had yielded 1 (which also occurs with 50% probability). Then only the ∣0〉∣1〉=∣1〉 and ∣1〉∣1〉=∣3〉 terms will remain after the readout:

Figure 3-28. The state of one qubit in the remote control after the other is READ to be 1.

And the probabilities for reading out the 0/1 outcomes on qubit b are now 30%/70%.

Note that although we were able to change the probability distribution of readout values for qubit b instantaneously, we’re unable to do so with any intent - we can’t choose whether to cause the 70%/30% or the 30%/70% distribution - since the outcome we get when measuring qubit a is obtained randomly. It’s a good job too, since if we could make this change deterministically then we could send information instantaneously using entanglement - i.e. faster than light. Although sending signals faster than light sounds like fun, were this possible, bad things would happen². In fact one of the strangest things about entanglement is that although it allows us to change the states of qubits instantaneously across arbitrary distances, it always does so in such way that we can never use the effect to send intelligible, pre-determined information. It would seem that the universe isn’t a big fan of sci-fi.

Conclusions

We’ve seen how single and multi-qubit operations can allow us to manipulate the properties of superposition and entanglement in the qubits of a QPU. With these operations at our disposal we’re ready to see how they can really allow us compute with a QPU in new and powerful ways. In [Link to Come] we’ll see how fundamental digital logic can be re-imagined within a QPU, but first in the next chapter we take a hands-on exploration of quantum teleportation. Not only is quantum teleportation a fundamental component of many quantum applications, but exploring it will also put to the test everything we’ve learned so far about describing and manipulating registers of qubits.