Sometimes you get to eat your words—this is one of those occasions ("however" tastes kind of bland and overused). In nearly every quantum computing article, particularly those involving atomic gases, I end with something along the lines of "It's great work, and demonstrates a much needed proof of principle, but atomic vapors are never going to scale-up conveniently enough to provide the number of bits required for realistic quantum computing." I can now say that this is probably wrong, dead wrong, which just goes to show that gainsaying the folks at JILA and Innsbruck is really stupid.

Quantum computing takes advantage of the quantum properties of superposition and entanglement to obtain, in some cases, a speed up in computation. Superposition allows quantum bits, called qubits, to be both one and zero simultaneously. When you ask the qubit its value, it will always return either a one or a zero, but the probability of a particular value depends on the details of its superposition.

Entanglement, on the other hand, allows the values of multiple qubits to be correlated: if qubit A is determined to be a one, then an entangled partner qubit B must be a zero. No operations are required to keep A and B entangled, so changes to the superposition state of one qubit are automatically reflected in changes to the superposition states of all the other entangled qubits.

Unfortunately, entanglement is delicate, and even the smallest amount of noise in the environment can strip the correlations out of the system. Entanglement between two superconducting quantum interference devices typically lasts a 100ns or so, while dilute alkali gases can remain entangled for several seconds. Photons can be entangled for even longer, but you rapidly run out of lab space when your qubit is traveling at 300 million meters per second.

This highlights the biggest problem in quantum computing: control. Ions, for instance, can be stored individually and individually addressed by laser pulses. But ions are difficult to work with because they are charged and will try and interact with everything—control gets lost despite your best efforts. Neutral atoms, which interact far less strongly with their environment, only help a little. Addressing individual atoms is difficult because they are generally all in the same quantum state, so any action performed on one atom is performed on them all.

The latest research out of UCLA, JILA, and Innsbruck has figured out the technical details of a scheme that could overcome this problem. To appreciate the solution, we need to describe the problem in more detail. To start with, all the atoms are fermions, which means that, given a population of atoms, they will stack up in terms of quantum states—starting from lowest energy to highest, the atoms fill each available state. To make quantum computing manageable, we would prefer them to be occupying just a few quantum states.

To separate each atom from its neighbor, two laser beams, traveling in opposite directions, are passed through the very cold atomic gas (note that the laser has to have the right color). This creates a lattice of regions with high intensity and low intensity—the atoms move into the dark spots, and the electromagnetic potential shields them from the other atoms, allowing them to all occupy identical quantum states. This also has the advantage of spatially separating each atom so that they can be individually addressed by other lasers.

To perform an operation, atoms are moved so that they end up in the same lattice site and interact with each other. This can be done by changing the color of one of the laser beams slightly so that the entire lattice starts to move. I think you can see the problem here: all the atoms move, not just the ones that we want.

This new research has looked at the possibility of using two atomic states instead of one. The idea is that the atoms you want to shift around go into one state (call it state A), while the atoms you want to keep still stay in the second state (we name thee state B). You can then use two different color lasers to create two lattices, each storing a different group of atoms. Normally this won't work. Although laser one and state A might be tuned to each other so that they interact strongly, the neighboring state B will still see the laser light and interact with it. This weaker interaction destroys these prepared states, leaving your qubits with a random value.

To get around this, the researchers have looked carefully at how strontium atoms respond to various colors of light. Under the right conditions, the color used to control state A has two interactions with state B that exactly cancel, meaning that state A can be controlled without destroying state B. Likewise a second color that controls state B doesn't effect state A. The team has also worked out how to transfer atoms selectively between the two states and how to perform collisional qubit operations. This essentially gives them a register, a bus, and arbitrary gates—sounds like everything you might need for quantum computing. Things are made even easier by the fact that these states have life times on the order of tens of seconds, while operations take only a few milliseconds.

Although this is a theoretical paper—based on the properties of a real atom though—the real kicker comes when you think about scalability. The systems that cool atoms to just a few microkelvin can usually manage to capture between 100,000 and one million atoms. Optical lattices can usually hold between a few hundred and a few thousand atoms. Suddenly, we are looking at going from 8 qubits to several hundred—that is what I call scalability.

Before I head off to eat my hat, I'll just mention that this system will still not be out-of-the-lab, desktop friendly. However, that doesn't mean it won't find plenty of applications in relatively cheap facilities-based computers, much like the supercomputing centers we use today. Now, where did I put that hat?

Physical Review Letters, 2008, DOI: 10.1103/PhysRevLett.101.170504