Hands-On Quantum Machine Learning with Python/

...

/

The No-Cloning Theorem

The No-Cloning Theorem

Get introduced to the concept of the no-cloning theorem.

We'll cover the following...

Quantum computing is fundamentally different from classical computing. To master quantum computing, you must unlearn what you have learned.

It starts with the quantum superposition. Unlike a classical bit, a quantum bit (qubit) is not 0 or 1. Unless we measure it, the qubit is in a complex linear combination of 0 and 1. But when we measure it, the quantum superposition collapses, and the qubit is either 0 or 1, as a classical bit.

It continues with quantum entanglement. Two qubits can share a state of superposition. Once we measure one qubit, its entangled fellow instantly jumps to a different state of superposition. Even if it’s light-years away, it seems to know a measurement has taken place and takes on a state that acknowledges the measured value.

When starting with quantum computing, it can be tempting to focus on the possibilities that arise from superposition and entanglement. But quantum computing does not simply add new features we can use. Instead, it is a fundamentally different way of computing and requires different kinds of programs.

Classically, we think about input, transformational boolean logic, and output, but this line of thought isn’t the most helpful when it comes to quantum computing.

Let’s take one of the simplest operators in classical computing, the assignment.

Copying a variable

Press + to interact
my_var = 1
copy_of_my_var = my_var
print (my_var, copy_of_my_var)

We can use the assignment operator to create a copy of a variable. The value of the variable doesn’t matter. We can create a copy of it.

In a classical program, we frequently rely on this ability to copy data. In a classical circuit, this is the fan-out operation. In electrical engineering, we have wires. If there is a voltage at a particular time, we interpret it as 1. If there is no voltage, it is 0. We can connect another wire to it. We will receive the same output at both ends.

Copying data is helpful in manifold ways. First, we can use copies as inputs to different operators. For instance, in the half-adder, we copy the input to use it in two other operators.

Secondly, we can use the copies to evaluate the state at different program parts at other times. This would be particularly useful in quantum computing.

In the lesson Gamble with Quantum Computing, we learned how to change a qubit’s measurement probabilities by rotating it around the y-axis. We got to know the angle θ\theta, which controls the probability of measuring the qubit as 0 or 1 but we struggled with the problem that θ\theta is the angle between the vector ∣ψ⟩|\psi\rangle and the basis state vector ∣0⟩|0\rangle. However if the qubit is not in the basic state ∣0⟩|0\rangle, then the same value of θ\theta represents a different probability change. The gradients of trigonometric functions (such as sine and arcsine) are not constant. The probability an angle represents at the top of the circle (state ∣0⟩|0\rangle) is another probability that the same angle represents at the horizontal axis, such as the state ∣+⟩|+\rangle. To calculate the correct angle, we need to consider the state the qubit is currently in.

Measuring the qubit state collapses it to either 0 or 1. So, measuring destroys the qubit superposition. But if we’re not allowed to measure the qubit, how should we specify the prior probability?

We could create a copy of the qubit before we measure it. That way, we can measure one copy of the qubit while simultaneously working with the other copy.

Let’s look at the respective operator, the fan-out. In a classical circuit, one input wire connects to two output wires. It copies a bit. In quantum computing, we use transformation gates and the word cloning for the analogous idea of copying a qubit.

The following figure depicts the diagram of a cloning transformation gate.

The gate (let’s call it GG) takes an arbitrary qubit ∣ψ⟩|\psi\rangle and a fixed ∣0⟩|0\rangle (an ancilla bit) input. It outputs two copies of ∣ψ⟩|\psi\rangle. Here are three examples of cloning transformations.

  1. It clones a qubit in the state ∣0⟩|0\rangle.

G(∣0⟩∣0⟩)=∣0⟩∣0⟩G(|0\rangle|0\rangle)=|0\rangle|0\rangle

  1. It clones a qubit in the state ∣1⟩|1\rangle.

G(∣1⟩∣0⟩)=∣1⟩∣1⟩G(|1\rangle|0\rangle)=|1\rangle|1\rangle

  1. It clones an arbitrary qubit ∣ψ⟩|\psi\rangle.

G(∣ψ⟩∣0⟩)=∣ψ⟩∣ψ⟩G\left(|\psi\rangle|0\rangle\right)=|\psi\rangle|\psi\rangle ...