No-Cloning Theorem and Quantum Error Correction

1. What is "Cloning" a Quantum State?

First, it's important to be precise about what we mean by "cloning" in physics. We're not talking about biological cloning, where an organism has the same DNA but develops independently. In quantum mechanics, cloning means creating a perfect, indistinguishable copy of a system's exact quantum state—every position, momentum, and superposition amplitude—while leaving the original intact.

The short video below provides a fun and clear definition of what a perfect physical clone would be.

The key idea is that a perfect clone would be so identical to the original that you couldn't tell them apart, even in principle. As you'll soon see, the laws of quantum mechanics forbid the existence of a universal machine that can achieve this.

2. The No-Cloning Theorem: Proof by Contradiction

The no-cloning theorem states that it is impossible to create an identical copy of an arbitrary, unknown quantum state. This isn't just a technical challenge; it has been mathematically proven to be impossible in principle.

The proof relies on a core feature of quantum mechanics that you're familiar with from your work with circuits: linearity. Just as in a linear electrical circuit where the output for a sum of inputs is the sum of the individual outputs, quantum operations (which are unitary transformations) are also linear. This property leads to a direct contradiction with the premise of a universal cloning machine.

The MinutePhysics video provides an excellent conceptual walk-through of this proof by contradiction.

The video shows that if a cloning machine existed, (A+B) cloned would have to equal A cloned + B cloned. However, the first case gives (A+B)x(A+B) = A² + AB + BA + B², while the second gives A² + B². Since these are not equal, our initial assumption—that a universal cloning machine can exist—must be false.

The Mathematical Proof

Now, let's formalize this same logic using the linear algebra of quantum mechanics. This will be a good application of the properties of unitary operators.

Let's break down the argument from the article step-by-step:

1. Assume a Cloning Machine Exists: We hypothesize there is a unitary operator $U_{clone}$ that can copy any arbitrary quantum state $|\psi ⟩$ onto a blank state $|0⟩$. Its operation would be:

   $$U_{clone}(|\psi ⟩\otimes |0⟩)=|\psi ⟩\otimes |\psi ⟩$$

2. Consider Two Different States: Let's see what this machine would do to two different arbitrary states, $|\psi ⟩$ and $|\varphi ⟩$.

   • $U_{clone}(|\psi ⟩\otimes |0⟩)=|\psi ⟩\otimes |\psi ⟩$
   • $U_{clone}(|\varphi ⟩\otimes |0⟩)=|\varphi ⟩\otimes |\varphi ⟩$

3. Use the Property of Unitary Operators: A crucial property of any unitary operator $U$ is that it preserves the inner product (the geometric "angle") between states. If we apply $U$ to two states, the inner product of the resulting states is the same as the inner product of the original states. Mathematically:

   $$(⟨a|U^{†})(U|b⟩)=⟨a|(U^{†}U)|b⟩=⟨a|I|b⟩=⟨a⟩b$$

4. Apply this Property to our Cloning Machine:

   • The inner product of the initial states is: $$(⟨\varphi |\otimes ⟨0|)\cdot (|\psi ⟩\otimes |0⟩)=⟨\varphi ⟩\psi ⟨0⟩0=⟨\varphi ⟩\psi$$
   • The inner product of the final (cloned) states is: $$(⟨\varphi |\otimes ⟨\varphi |)\cdot (|\psi ⟩\otimes |\psi ⟩)=⟨\varphi ⟩\psi ⟨\varphi ⟩\psi =(⟨\varphi ⟩\psi {)}^2$$

5. The Contradiction: Since the unitary cloning operation must preserve the inner product, the initial and final inner products must be equal:

   $$⟨\varphi ⟩\psi =(⟨\varphi ⟩\psi {)}^2$$

   This equation is only true if $⟨\varphi ⟩\psi =0$ (the states are orthogonal, like $|0⟩$ and $|1⟩$) or $⟨\varphi ⟩\psi =1$ (the states are identical). It does not hold for an arbitrary superposition. Therefore, a universal unitary cloning machine cannot exist.

3. The Implication for Quantum Error Correction

Now we can see the direct consequence for fixing errors caused by decoherence. The classical method of creating multiple copies of our data and using a "majority vote" to fix flips is off the table.

So, how do we protect quantum information? The no-cloning theorem forces us to be more creative. We cannot clone the state, but we can distribute the information of a state across multiple qubits in a way that doesn't violate the theorem.

This next short video clip makes this crucial distinction.

This is the central implication of the no-cloning theorem for error correction:

• Forbidden: Taking an arbitrary state $|\psi ⟩=\alpha |0⟩+\beta |1⟩$ and creating three independent copies: $|\psi ⟩\otimes |\psi ⟩\otimes |\psi ⟩$. This is cloning.
• Allowed: Taking the same state $|\psi ⟩$ and applying a unitary operation (a circuit) that produces an entangled state: $\alpha |000⟩+\beta |111⟩$.

This second approach is not cloning. The three qubits are not independent copies of $|\psi ⟩$; they are now part of a single, larger entangled system that encodes the original amplitudes $\alpha$ and $\beta$. This method of spreading information across multiple qubits, rather than copying it, is the foundation of all quantum error correction codes. By measuring properties of this entangled state (without measuring the data qubits directly), we can detect errors and fix them.

Conclusion

In this lesson, we established a fundamental rule of quantum information. We've seen that the linearity of quantum mechanics leads directly to the no-cloning theorem, which has a game-changing effect on how we approach the problem of errors.

Key Takeaways:

• The no-cloning theorem states that it is impossible to create a perfect copy of an arbitrary, unknown quantum state.
• This is a direct consequence of the linearity of quantum mechanics. A hypothetical cloning machine would violate this principle when acting on a superposition.
• The primary implication for quantum error correction is that we cannot use the classical strategy of making redundant copies of a qubit's state.
• Instead, quantum error correction must rely on encoding the information of a single logical qubit into a larger entangled state of multiple physical qubits.

Preview of the Next Lesson:

Now that we know what we need to do—distribute information instead of copying it—the next step is to see how it's done. In the next lesson, we will explore the 3-qubit bit-flip code, the simplest quantum error correction code. We will see exactly how the encoding $\alpha |0⟩\to \alpha |000⟩$ and $\beta |1⟩\to \beta |111⟩$ allows us to detect and correct a bit-flip error on one of the qubits without destroying the original quantum information.