# The No-Cloning Theorem

Our next-to-last key concept is the *no-cloning theorem*. Simply put,
if you are holding a qubit that is in an unknown state, it is
impossible to make a *perfect, independent (unentangled) copy* of the
qubit in all cases.

## Cloning

We would like to “copy” a qubit, but what does it mean to do so?
There are two types of copies: *dependent* ones and *independent*
ones. Dependent copies are entangled with the original qubit: making
one copy, goes to (which we write
) and similarly, .

Actually, more correctly, we would start with one qubit in our data
state (presumably some interesting superposition we would like to
share or copy), and one that’s in a “blank” state to be the target of
our copy, so that *and*
.

Using our dials, this kind of copy keeps the number of dials with vectors that aren’t zero the same, including the length and phase (direction) of the vectors. However, which states have those non-zero vectors changes – it shuffles them a bit. Let’s see what happens when we have the state in one qubit and we try to copy it. We also have to start with the qubit we are going to copy onto, so let’s put that in the state, so we are starting with . This means that the effect looks like this:

(As always, the entries in the set of dials are 00, 01, 10, and 11, starting from the top.)

This logic applies for two, three or more copies, and also maintains the phase. Let’s look at copying the state into two other qubits:

Making an independent copy, in contrast, would *increase* the number
of non-zero dials:

Mathematically, the difference is that the dependent state can’t be factored, while the independent one can, just like in ordinary algebra:

Recall that there are limitations to the kinds of operations we can
execute on qubits. With the exception of measurement, everything we
do has to be reversible. We can create the dependent (entangled) copy
using the CNOT gate we discussed earlier. However, *there is no way
to make an unentangled copy* of an unknown qubit state. This is known
as the **no-cloning theorem**.

(If you are particularly astute, you may be guessing that there must
be *some* way to increase the number of dials with non-zero vectors,
and in fact many gates do. Our non-working example above could, in
fact, be emulated by using a Hadamard gate. But that’s only true
because we know exactly how the state we want to copy was made.
Rather than *copying* it, that would be *recreating* it – like
printing the same file twice, rather than photocopying a handmade
drawing.)

## Trying to Communicate Faster than the Speed of Light

When we discussed entanglement, we saw that completing the teleportation of a single qubit requires Alice to transmit two classical bits that are used as “corrections” to the state of Bob’s qubit. This is how Nature prevents faster-than-light movement of arbitrary data.

But can Alice and Bob use the “spooky action a distance” of a Bell pair to communicate faster than light? Let’s try.

First, Alice and Bob share a Bell pair. Then, if Alice wants to send a zero, she measures her qubit along the Z axis of the Bloch sphere. This will give a 50% of the time and a 50% of the time, of course, and the superposition of Bob’s qubit will now collapse and his qubit matches Alice’s. If Alice wants to send a one, she measures her qubit along the X axis, which collapses Bob’s qubit along the X axis also. If Bob’s qubit points along the X axis, that’s a superposition along the Z axis. Bob is now holding a different state than the one he is holding after Alice’s Z measurement. Is there a way that Bob can tell those two states apart? If so, he and Alice can communicate faster than the speed of light!

Let’s look at what happens when Bob measures his qubit. Of course, he doesn’t know which axis Alice used to measure her qubit, so the best he can do is just stick with measuring on the Z axis. If Alice is sending zero, Bob’s qubit matches Alice’s. However, her qubit is random, either or . If Bob measures his qubit, he gets only a random bit that matches Alice’s. If Alice is sending one, Bob’s qubit is a 50/50 superposition before he measures it. When he measures, he randomly gets or . In both cases, Bob sees only a random bit, and has learned nothing.

So, just using Bell pairs doesn’t appear to allow us to communicate faster than the speed of light. But what if we can use cloning?

## Cloning Would Allow Faster-than-Light Communication

If it were possible to clone a qubit, Alice and Bob would still have a way to communicate faster than light. If Bob can clone his qubit before measuring it, he can tell whether Alice measured along the Z or X axis using basic statistics.

After Alice has measured her qubit, but before measuring his own, Bob clones his qubit. Let’s say, for example, that he makes nine copies, so he has ten qubits. He measures them all.

If Alice measured her qubit on the Z axis, Bob’s qubit collapsed to zero or one before he cloned it, and Bob’s ten qubits will all be the same. They may be all zero or all one, but they will agree. On the other hand, if Alice measured along the X axis, Bob’s qubit is still in a zero/one superposition when he clones it.

If the clones are *independent*, each one will independently collapse,
and Bob will find about five zeros and five ones in his ten qubits.
Now he knows that Alice used X. He can tell what Alice was doing
before a message can arrive!

Fortunately, the fact that cloning is impossible saves us: Bob can
make copies of his qubit, but they won’t be independent. They will
*all* collapse to the same state, either zero or one – exactly the
same as if Alice had measured in Z. No communication takes place.

## Cloning and Error Correction

This same behavior of entangled qubits makes it difficult for us to correct errors. Classical computer systems create redundancy in the information, such as by copying the data, and check it frequently to see if the data has changed. For example, if we start with 0, we can make the state 000, or if we we start with 1 we can make 111, and check to see if the bits are all the same.

But with quantum states, we want to check the state of qubits that are
in superposition. But, we have already learned that measuring the
qubit collapses the state and destroys our entanglement. Your first
thought for a way around this might be to copy a qubit, then check the
copy. Unfortunately, due to the no cloning theorem, we can’t make an
independent copy. If we look at one of the qubits, we collapse the
state of *all* of them.

However, there is a way around this, extracting the parity of a group of qubits without looking at any individual qubit to determine if it is zero or one. We will study this more in the activity on quantum error correction.

## History

Although the concept is relatively new and its history is well documented, in mid-2017, a suggestion arose that it was discovered quite a bit earlier.

The common form of the history has it that W. K. Wootters and W. H. Zurek as a team and D. Dieks independently recognized that quantum mechanics forbids copying, in reaction to a paper that purported to show how such a copying machine could be used to communicate faster than the speed of light.

Recently, however, J. Ortigoso has discovered that J. L. Park
published a paper in 1970, in the first issue of a journal called
*Foundations of Physics*, that demonstrated the same principle!
*Foundations of Physics* is now one of the most important journals in
the field, but at the time was brand new, and received little
attention. Researchers are in the process of incorporating this new
recognition into their histories of quantum information.

© Keio University