Quantum computing and quantum communication require a different way of thinking about handling information. Not only are quantum states extremely delicate, but you can't copy a quantum state. To put it in perspective. If I want to send a qubit from a lab in Europe to somewhere in New York, that qubit has to make it all the way by itself—you can't read and replace it along the way. To get around this limitation, you have to make use of quantum mechanics: teleporting quantum states from one place to another.

To do that in a flexible way that allows computation, you need to store quantum states as they arrive. That means you need some sort of register that stacks qubits on top of each other. This is quite challenging. But, it seems that ions embedded in a crystal might be able to do the job. Before we journey into the heart of ions, crystals, and qubits, let's see why we can't just take ideas from classical computing and bolt them onto quantum computing.

Qubits are not bits

A very simple example that comes up in normal computing is sending one bit to two gates at the same time. All I need to do is to have a branch in a wire so that the branches terminates at two different gates. The bit is then sent to both gates. This can be done because the bit consists of many charges, so the junction simply sends half the charge to one gate and half to the other. Of course there are limits to that approach but, even if I needed to branch many more times, I could simply increase the amount of charge in each copy of the bit through some kind of amplifier.

In a similar vein, consider a logical AND gate. This gate takes in two bits and outputs a single bit, with a value that is based on the two input bits. You can think of this as destroying two bits and creating one bit. You don't have to worry about what happens to bits or where they come from—they can be created and destroyed at will.

The rules change when you're using quantum states for information processing. A qubit consists of a single photon, or charge, or atomic state. It is indivisible. Qubits cannot be divided. If something happens to disrupt the qubit state, that qubit is lost. Qubits cannot be copied either, though the reason for that is rather abstract: any operation that can use two qubits and copy the state of one qubit to the other turns out to be mathematically inconsistent.

So if a qubit is required for more than one operation, it has to be used in both of them sequentially. Accordingly, it can only be used in a subsequent operation if the first gate does not modify the qubit. Complicating matters further, quantum gates can not make qubits; they can only perform operations on pre-existing qubits.

So a classical gates produce a new bit in response to the input of bits. But for a quantum gate, this doesn't work. The equivalent of a logical AND gate might take in two qubits, but it can't output a third. Instead, it has to modify the state of one qubit based on the input values of the other qubits (this is not technically an AND operation). That means that only one of the input qubits retains its original value for subsequent computations, so, if you need to use both of them later, then your logical AND gate has to take in three qubits, and modify the value of a third based on the state of the other two.

The consequences of qubits lying in wait

And that produces a problem. Imagine a computation that, over its entire course, requires ten qubits. But, for the first five steps, the computation only needs three qubits. That means at the start of the computation, you have to initialize ten qubits, and then store seven of them until they are needed. You might organize your circuit such that qubits are recycled, but that means that they have to be disentangled and returned to some pre-defined state. You can't just reinitialise them without disrupting the entire calculation. You have to undo the computations that were performed on them to return them to their initial state.

This all requires a reliable way to store and retrieve multiple qubits. And that brings us to this latest paper.

A good storage device shouldn't just store a single qubit, it should store multiple qubits. It would also be useful if the qubits could arrive at different times and still be accessed. To achieve some of this, a group of researchers has made use of an imperfect crystal.

A crystal is a repeating arrangement of atoms. If you start at a certain position in the crystal and move in any direction, then you will eventually find yourself in what looks like exactly the same place. That means that the atoms at those repeated locations respond to applied forces and light fields in exactly the same way.

So, let us imagine that in every repeat, there is one atom that has just the right properties to store a qubit. But that storage is distinctly quantum. When a single photon is absorbed, we shouldn't think of it as been absorbed by a single atom in the crystal. Instead, the photon has been partially absorbed by all the atoms—well, more correctly, you should think of them as having absorbed and not absorbed a photon at the same time.

Because the atoms are all in the same environment, they all respond the same way to the partial absorption of the photon. So, some time later, we can read that state out quite nicely. Even better, because the qubit is stored across a population of atoms, it is more difficult to disrupt it, since knocking a single atom only causes a teeny tiny change to the qubit state.

Sounds great, right? Well, the problem is that you can only store one qubit. Any subsequent qubit that you try to store gets mangled together with the original qubit and neither can be read out.

Storing light in crystals

To overcome this, researchers have made use of some really cool quantum physics. They use a crystal that is doped with ions. The ions can be thought of as having just three energetic states, which we call the ground state, the storage state, and the excited state. The ground state is home for our ion: it always wants to return there. The storage state is actually very similar to the ground state, so the ion doesn't mind staying there either. These two states are mainly connected via the excited state, which the ion will only enter if it is given energy in the form of a photon.

Our ions start in the ground state. A photon, which is our qubit, hits the ions, and is absorbed, sending one ion to the excited state. But, just like the case above, we have to think of all the ions as having a chance of absorbing the photon, so the photon is stored in all the ions. The ion emits a slightly redder photon and enters the storage state. This is great because we can detect that photon and know that the qubit has been successfully stored.

To get the information back out again, we shine a laser into the crystal, sending the ions from the storage state back to the excited state. From there, the originally stored photon is re-emitted, and the ion returns to the ground state. And there you have it, a single qubit memory.

But we want to store more qubits.

Luckily, crystals are never perfect. The crystals the researchers used were even more so. The ions that they add are scattered randomly through the crystal—some are close together, while others are quite isolated. Which means that each ion has a slightly different environment. That causes each ion to absorb a slightly different color of photon. More specifically, the ions are divided into a series of populations that each have similar properties.

Hiding qubits from each other

These properties are not so different that they can be treated separately. So the researchers use the Power of LasersTM to separate the ion populations from each other.

The energy of the photon/qubit should be chosen to match the energy required to drive the ion from the ground state to the excited state. That energy difference can be changed by applying a strong laser field. Under these circumstances, the excited state is split by the oscillating electric field of the photons—it becomes two states, one at a lower energy and one at a higher energy.

In fact, in a perfect crystal, with everything behaving itself, the laser field would cause the entire population of ions to see their excited state cycle continuously between the higher energy value and the lower energy value. That means that a photon, tuned to the energy of the single, normal excited state is highly likely to be absorbed only at the time that the excited state's cycling brings it through the correct energy. For the rest of the time, the photon ignores the ion.

But remember that the crystal ain't perfect. Instead, the ions are separated into a bunch of different populations that cycle separately between between a maximum and minimum energy near the normal excited state energy. And each population cycles at a different rate. So, now two qubits that arrive at the crystal at different times will be stored in different ion populations. To read out the correct qubit, you have to fire the read laser at just the right time.

There are some complications, because the qubits can still talk to each other in the storage state. That is undesirable. But the researchers showed that, by careful manipulation with microwave radiation, the qubit state can be nicely preserved for a reasonable length of time.

The end result is a reasonably robust memory that interfaces photonic qubits and solid state qubits. This is really nice because it's pretty easy to generate lots and lots of light-based qubits. Gates for operations on light-based qubits are relatively simple and have high accuracy. But light moves really fast and, quite often, you want a qubit to sit still for a while so that you can perform operations on other qubits. This memory is part of the solution to that problem.

The researchers will also be thinking quite carefully about quantum key distribution. At the moment, practical quantum cryptography is limited to transmission distances of single photons down an optical fiber: about 70-100km. If a qubit can be stored, then researchers can start thinking seriously about key distribution over the entire globe through the use of entanglement.

Exciting stuff, but probably still ten years away from leaving the lab.

Physical Review Letters, 2017, DOI: 10.1103/PhysRevLett.118.210501