Error correction is a technique that is ubiquitous in every day's information processing. For example, when you want to transfer information from one hard disk to another one,

that is transferring lots of zeros and lots of ones, then you want to make sure that the one arrives in place securely as a one and the zero arrives in that place. In order to do that, because sometimes errors can occur, you actually use redundancy in coding, which really means instead of sending one zero, you send three times a zero,

or instead of sending one one, you send it three times. And in the end, if an error has appeared, has occurred during the transfer process, you make a majority decision, and when you see twice a one, it's decided that was a one, it's twice a zero, then it was decided it's a zero.

And that's routinely done in many transfer protocols. You would want to have that also for quantum information processing because, of course, quantum information is even more sensitive to any perturbations, so we want to undo any error that possibly can appear. Unfortunately, that is, of course, very tricky because quantum information is, of course, also hidden in superpositions.

And when we make now a measurement, and nothing else is that what we actually see in perturbations, then we reduce that state, we project it to its eigenstates, so we just find it in either one or zero, but not in a superposition. And that's the basic ingredient, the basic content of the so-called no-cloning theorem.

Because that no-cloning theorem applies, we cannot simply copy quantum information and use the redundancy code. For that very reason, we make use of the entanglement feature that quantum physics provides, and for this reason, we use, instead of using a single qubit, we use three qubits,

like in the redundancy code, but we put them in an entangled state. And in the end, when an error appears with a tricky quantum protocol, you can actually find out what the error syndrome is, and from the error syndrome, we can undo what happened to the first qubit that originally carried the quantum information.

This could either be done by measuring the so-called ancilla or helper qubits, or it could be done in a fully coherent way, and these are the kind of experiments that we have done in the recent experiment on error correction. We trap the ions in a trap like this with the help of electromagnetic fields. Each qubit is encoded in the electronic states of a single ion.

We will now manipulate the state of the qubit with the help of laser pulses. In the case of the error correction, we have one system qubit, which carries the information, and two ancilla qubits, which we use to generate a three qubit entangled state,

and which carries the information of all three qubits. We now let the system evolve, and due to interaction with the environment, the system undergoes an error. In a classical computer, one would now measure the information of all the bits involved.

In a quantum computer, this is not possible, because measuring the information would collapse the quantum state, and therefore destroy all information. We therefore designed a measurement in which we are not looking at the state of the qubits, but only if an error occurred or not. With the help of this measurement, we are now able to reconstruct the original quantum state.

The experiment that we just did, and was recently published, that is the error correction protocol that shows clearly that we can undo errors that appear during the quantum information processing, and we can really undo all of these errors.

In this case, we developed a protocol that coherently really undoes all these errors, and is able to correct for single errors that we have in the system. At this time, we are still suffering from the fact that the quality, we say the fidelity, of our gate operations are not sufficient

to eventually break even to keep, for example, quantum information forever. That's what we really want to have in the future. But at least this Lego block that we developed so far shows the procedure, how to do it, we can repetitively do it, and we can routinely do it in a very short sequence. So this is the first step towards quantum information processing

that is reliable in the future.