Quantum computers are not like classical computers. I don't mean that in the sense that quantum computers perform calculations in a different manner, or that they might be faster, or more clever. No, I mean that quantum computers come with a whole set of issues (read: headache-inducing problems) that normal computers don't.
To reduce these problems, researchers have taken to hiding quantum information, albeit not very successfully. It turns out that using more than one type of qubit offers a bit more camouflage to quantum information.
Quantum hide and seek
Before we get to the latest results, let me paint a picture of pain for you. In a quantum computer, calculations are achieved by manipulating the value of a target qubit—the quantum computing equivalent of a bit—in a way that depends on the value of other qubits. The problem is doing this cleanly.
In most cases, any qubits in a system are identical, so if I have a tool that can change one qubit, the same tool will change the neighboring qubits. These tools are unavoidably blunt, so modifying one qubit has a good chance of changing its neighbors.
Let's look at a specific example: a quantum computer that consists of a string of ions sitting in a trap (an ion is an atom with a missing electron). The ions influence each other by the way they collectively rock back and forth in the trap.
This collective motion is used to couple qubits together, but it is very easy to disrupt. Imagine that I want to set the qubit state of the central ion. To do that, I have to shine a laser onto it; it will (eventually) absorb a photon, changing its state. But nothing says that it will absorb the first photon that hits it. A photon that is not absorbed will be scattered, like a pinball off a bumper. That recoil changes the motion of the ion in the trap, disrupting the collective motion of all ions. This reduces the effectiveness of (and eventually kills off) the collective behavior that's needed for quantum computation.
But wait—it gets worse. The scattered photon can hit a neighboring qubit and be absorbed. If that happens, you have introduced an error in your computation. You may have intended to set the state of qubit No.3, but you have also changed the state of qubit No.2 as well.
To solve this problem, a group of researchers has shown how to use a quantum bystander to maintain the state of the qubits for much longer. Instead of using a string of identical ions, the researchers use two different ions. Beryllium ions are used for computation, and, in between each beryllium ion, they place a calcium ion. This protects quantum information in several ways.
The photons scattered from the beryllium ions can't easily reach other beryllium ions because the calcium ion is in the way. The calcium ion requires an entirely different color of light, so the scattered light from the beryllium ion doesn't change the quantum state of the calcium ion, while light scattered from the calcium ion doesn't affect the beryllium ion.
Yet these neighbors are not completely isolated from each other. The qubits are still coupled through the motion of the ions in the trap. Here, the calcium ion also plays a role. When the ions absorb or scatter light, they get a kick that makes their motion in the trap more vigorous. This motion needs to be controlled so that the links between qubits remain under control. To do this, the researchers can slow the calcium ions down (using lasers, naturally). By slowing the calcium ion down, the researchers suck energy out of all the trapped ions, bringing them back under control.
But what is really cool is how the researchers brought it all together in a three-qubit demonstration system (two beryllium ions and one calcium ion). The researchers put the calcium ion in a known quantum state, then perform a set of operations on all three qubits. Imperfections mean that there will eventually be some difference between the intended quantum state (i.e., the quantum information) and the target quantum state. This difference will grow with time thanks to the ions all having a slightly different environment.
This difference is revealed (at least partially) by measuring the state of the calcium ion. This can be done without destroying the quantum state of the beryllium ions.
In response to the measured state of the calcium ion, the trap and the state of the beryllium ions are carefully adjusted. Then the calcium ion is cooled and its state is reset. From there, the entire operation of coupling the calcium ions with the beryllium ions can be repeated.
The researchers compared the reliability of their qubit state (including entangled states) with and without the trick of adjusting the trap and the state of the beryllium ions. Without adjustment, the quantum information stored in the beryllium ions quickly decays away. However, with these careful corrections, the researchers were able to perform 50 operations on the beryllium ions without losing the quantum state.
The researchers' control system is not perfect—the information still decays away, but the decay rate is a good 20 times slower than it would be if they were just using two beryllium ions.
The best bit, though, is that there is nothing stopping the researchers scaling up to more ions. Three qubits is puny compared to other quantum computers. But hitting nine-plus qubits should be possible, which is about state of the art for ion-based quantum computers. Furthermore, the cooling and control should allow for scaling to even larger numbers of qubits. It's all pretty exciting.