Quantum Teleportation¶

1. State preparation¶

Teleportation involves three qubits. Two of them are held by Alice, and the third by Bob. We’ll denote their states using subscripts:

1. $\vert\cdot\rangle_S,$ Alice’s first qubit that she will prepare in some arbitrary state

2. $\vert\cdot\rangle_A,$ Alice’s auxiliary (or “ancilla”) qubit that she will entangle with Bob’s qubit for communication purposes

3. $\vert \cdot\rangle_B,$ Bob’s qubit that will receive the teleported state

Together, their starting state is:

The first thing Alice does is prepare her first qubit in whichever state $\vert \psi\rangle$ that she’d like to send to Bob so that their combined state becomes:

We can use the following quantum function to do the state preparation step:

import pennylane as qml
import numpy as np


def state_preparation(state):
    qml.StatePrep(state, wires=["S"])

2. Shared entanglement¶

The reason why teleportation works is the use of an entangled state as a shared resource between Alice and Bob. You can imagine some process that generates a pair of entangled qubits, and sends one qubit to each party. For simplicity (and simulation!), we will represent the entanglement process as part of our circuit.

Entangling the qubits $A$ and $B$ leads to the combined state:

The $AB$ subsystem is now in what is known as a Bell state. There are four maximally entangled two-qubit Bell states, and they form the Bell basis:

In our experiment, because $AB$ started in the $\vert 00\rangle$ state, we create the $\vert \psi_+\rangle$ Bell state as is shown in equation (1).

def entangle_qubits():
    qml.Hadamard(wires="A")
    qml.CNOT(wires=["A", "B"])

From now on, the qubit subscripts will be removed from states for brevity.

3. Change of basis¶

This is where things get tricky, but also very interesting. The third step of the protocol is to apply a CNOT and a Hadamard to the first two qubits. This is done prior to the measurements, and labelled “change of basis”. But what basis is this? Notice how these two gates are the opposite of what we do to create a Bell state. If we run them in the opposite direction, we transform the basis back to the computational one, and simulate a measurement in the Bell basis.

After the basis transform, if we observe the first two qubits to be in the state $\vert 00\rangle,$ this would correspond to the outcome $\vert \psi_+\rangle$ in the Bell basis, $\vert 11\rangle$ would correspond to $\vert \phi_-\rangle,$ etc. Let’s perform this change of basis, one step at a time.

Suppose we write our initial state $\vert \psi\rangle$ as $\alpha\vert 0\rangle + \beta\vert 1\rangle,$ with $\alpha$ and $\beta$ being complex coefficients. Expanding out the terms from (1), we obtain:

Now let’s apply a CNOT between Alice’s two qubits:

And then a Hadamard on her first qubit:

Now we need to do some rearranging. We group the terms based on the first two qubits:

def basis_rotation():
    qml.CNOT(wires=["S", "A"])
    qml.Hadamard(wires="S")

4. Measurement¶

The last step of the protocol involves Alice performing a measurement on her qubits, and telling Bob to perform some operations depending on what she measured. But why exactly do we need to do this? In the previous step, we already performed a basis rotation back to the computational basis, so shouldn’t we be good to go? Not quite, but almost!

Let’s take another look at equation (2). If Alice measures her two qubits in the computational basis, she is equally likely to obtain any of the four possible outcomes. If she observes the first two qubits in the state $\vert 00 \rangle,$ she would immediately know that Bob’s qubit was in the state $\alpha \vert 0 \rangle + \beta \vert 1 \rangle,$ which is precisely the state we are trying to teleport!

If instead she observed the qubits in state $\vert 01\rangle,$ she’d still know what state Bob has, but it’s a little off from the original state. In particular, we have:

After obtaining these results, Alice could tell Bob to simply apply an X gate to his qubit to recover the original state. Similarly, if she obtained $\vert 10\rangle,$ she would tell him to apply a Z gate.

In the “traditional” version of quantum teleportation 1, this is, in fact, exactly what happens. Alice would call up Bob on the phone, tell him which state she observed, and then he would be able to apply an appropriate correction. In this situation, measurements are happening partway through the protocol, and the results would be used to control the application of future quantum gates. This is known as mid-circuit measurement, and such mid-circuit measurements are expressed in PennyLane using qml.measure. Mid-circuit measurement results can be used to control operations, and this is expressed in PennyLane using qml.cond.

def measure_and_update():
    m0 = qml.measure("S")
    m1 = qml.measure("A")
    qml.cond(m1, qml.PauliX)("B")
    qml.cond(m0, qml.PauliZ)("B")

We’ve now defined all the building blocks for the quantum teleportation protocol. Let’s put it all together!

def teleport(state):
    state_preparation(state)
    entangle_qubits()
    basis_rotation()
    measure_and_update()


state = np.array([1 / np.sqrt(2) + 0.3j, 0.4 - 0.5j])
_ = qml.draw_mpl(teleport, style="pennylane")(state)

There is a neat concept known as the principle of deferred measurement 2, and it basically states that we can push all our measurements to the end of our circuit. This can be useful for a variety of reasons, such as when working in a system that does not support mid-circuit measurements. In PennyLane, when you bind a circuit to a device that does not support them, it will automatically apply the principle of deferred measurement and update your circuit to use controlled operations instead. Note that you need to specify level="device" when calling draw_mpl so it runs the device pre-processing before drawing the circuit.

dev = qml.device("default.qubit", wires=["S", "A", "B"])


@qml.qnode(dev)
def teleport(state):
    state_preparation(state)
    entangle_qubits()
    basis_rotation()
    measure_and_update()
    return qml.density_matrix(wires=["B"])


_ = qml.draw_mpl(teleport, style="pennylane", level="device")(state)

Poof! Our classical signals have been turned into CNOT and CZ gates. This is exactly what the principle of deferred measurement gives us — we can apply a CNOT instead of Alice calling Bob and telling him to apply an X gate, and likewise for the CZ gate. This is incredibly useful, as it allows us to perform our correction before any measurements are made. Let’s evaluate the action of the CNOT and CZ on Bob’s qubit, and ensure that Alice’s state has been successfully teleported. Applying the CNOT yields:

Then, applying the CZ yields:

When Alice measures her two qubits at the end, no matter which outcome she gets, Bob’s qubit will be in the state $\alpha\vert 0\rangle + \beta \vert 1\rangle$. This means that our protocol has changed the state of Bob’s qubit into the one Alice wished to send him, which is truly incredible!

We can use qml.density_matrix to trace out and return Bob’s subsystem as a density matrix, which is a more general description of the state of his qubit. We will use this to verify that Alice’s state was successfully teleported to Bob’s qubit. Re-arranging equation (3), we can see that the final state of the system is:

Now, we can confirm that our implementation of the quantum teleportation protocol is working as expected by comparing Bob’s final density matrix to Alice’s original density matrix:

def teleport_state(state):
    teleported_density_matrix = teleport(state)
    original_density_matrix = qml.math.dm_from_state_vector(state)

    if not np.allclose(teleported_density_matrix, original_density_matrix):
        raise ValueError(
            f"Alice's state ({state}) not teleported properly. "
            f"Final density matrix of Bob's subsystem: {teleported_density_matrix}"
        )
    print("State successfully teleported!")


teleport_state(state)

State successfully teleported!