Riding bosonic qubits towards fault-tolerant quantum computation
A guide to bosonic codes and error correction in a photonic platform
Ilan Tzitrin, J. Eli Bourassa, and Krishna Kumar Sabapathy
You and two of your friends, Judit and Gary, are on a long-awaited trip in southern India. On a leg of your journey, you find yourselves on a luxurious train ride through the Deccan Plateau, about to meander through the breathtaking Western Ghats. Before the scenery captures your attention, your friends decide to entertain themselves with a game of chess, while you continue to devour Carl Sagan’s Contact.
A half hour into an intensive game, Judit and Gary agree they could use a break to refresh, and they head to the dining car for some samosas and chai. At this very moment, the train begins a gentle ascent up a mountain, and all the chess pieces slide a little in one direction. The board ends up looking like this:
Wanting to ensure that your friends’ game continues uninterrupted, you look up from your book and centre all the pieces on the square they mostly lie on, resulting in the original layout. Judit and Gary return shortly and continue from where they left off.
In the evening, during a rematch, you find yourself in a similar situation. But now the climb is a little steeper, and the outcome a little more dramatic. The pieces position themselves in the following way:
You’ve stumbled on an interesting conundrum: Which squares should you centre the pieces on now?
It might not be obvious, but what you’ve faced are two instances of continuous error correction. In both cases you’ve detected a displacement error, but the second time around you could not correct it.
Something similar happens in photonic systems, with the chess pieces along with their layout on the board being kind of like a quantum state. To explain what we mean, let us first tell you about some basic properties of quantum light.
Qubits in phase space
In a previous blog post, you learned about how the physical state of light can be described in a mathematical construction known as phase space. Phase space is an infinite flat surface; different distributions residing on this surface correspond to different physical states of light.
Light emerging from a good laser — a coherent state — corresponds to a circular blob with the smallest area allowed by the Heisenberg uncertainty principle. Using Xanadu’s integrated photonic chips, we can also squeeze these circles into ellipses of the same area, creating so-called squeezed states of light. Both of these are examples of Gaussian states, owing to the shape of their distribution in phase space.
You may wonder where qubits enter the picture. Well, since phase space is infinite, it can house a qubit with lots of room to spare. The qubit can be encoded into light by carefully manipulating squeezed states.
To build a quantum computer, we need to pass multiple qubits through quantum gates to modify and entangle the qubits with one another. Then, we need to extract the logical information from the qubits by way of measurements. Realistically, qubits in any physical platform will always be subject to noise, so we also require a way to correct errors that enter into our computation:
To encode a qubit in light, that is, to create a bosonic qubit, we will need a distribution in phase space that we can call 0, and a distinct non-overlapping pattern we can call our 1. The utility of these qubits depends on our ability to (i) manipulate them through the application of physical gates in the encoded space, (ii) measure these patterns, and (iii) negate experimental imperfections and noise that will distort the patterns:
Of the infinitely many ways we can encode our qubit into light — this is the power of phase space — a particularly nice one is provided by the grid or GKP states. Named after their discoverers Gottesman, Kitaev, and Preskill, GKP encoding offers a consolidated way to implement gates, conduct measurements, and correct errors. Better yet, all this can be achieved using photonic architectures. To better understand these special states of light, we can go back to our chessboard.
Playing on an infinite chessboard
Picture phase space as a playing surface stretched to infinity in all directions. We can paint this surface however we please, but in our case we’ll make it a chessboard. Then we can place tiny pieces in a special pattern to get our logical 0 (on the left) and logical 1 (on the right):
We see that these two patterns are non-overlapping: the 0 is a lattice of dots centred on only the blue squares, while the 1 is a lattice of dots centred on only the white squares. Out of all the ways we could have painted the board, and all the ways we could have arranged the pieces, why did we do it like this?
Let’s return to Judit and Gary’s chess game. After the board gets disturbed, if each piece were still mostly within its original square, you could correctly guess what its position was, and return the game to its correct state. However, were it displaced so that half or more of the piece was on the neighbouring square, then you are likely to make a correction that results in a completely different layout.
The same idea is exploited in error correction with grid states. Due to their lattice structure in phase space, small displacements of a single GKP state that keep the dots within squares of the correct colour can be perfectly corrected.
Better yet, larger displacements can be corrected too with the help of more GKP states. This is like playing identical games on many chess boards: if any one board gets a big bump, you can use the information from all the other boards to correct the corrupted game.
The ability to correct displacement errors in phase space is incredibly powerful as it can be extended to tackle even the loss of photons, probably the most challenging type of error in photonic quantum computing.
We can thus use GKP states to both encode qubits and perform error correction. The remaining ingredients for a fault-tolerant quantum computer are gates and measurements, which also happen to be straightforward to implement.
Building a quantum computer using GKP qubits
Certain fundamental one- and two-qubit gates known as Clifford gates can be effected with an easily accessible class of operations in optics known as Gaussian gates, that preserve the form of Gaussian states. For example, the bit-flip gate that takes 0 to 1 and 1 to 0 can be implemented by simply displacing the grid state in phase space, taking all the pieces on blue squares to white squares and vice versa.
To measure the logical information, all one needs is the colour of a square that a piece is positioned on. If the colour is blue, we know the state to be 0, and if it’s white, we know the state to be 1. Measuring states over phase space coordinates (also known as field quadratures) is achievable with homodyne detection of the light, a mature technology.
If we also prepare a few special superpositions of the 0 and 1 GKP states called magic states, we can even implement non-Clifford gates, completing all the requirements for a universal quantum computer:
With access to GKP states, a universal and fault-tolerant quantum computer would be within our reach, as the other components are readily available. However, we encounter a problem: creating ideal GKP states — infinitely many pieces, each infinitely small — requires infinite energy. The best we can do in the lab is to create approximations to the ideal states, such as the following:
You can see that the distribution of this imperfect state is highly non-Gaussian. For the curious, it’s the negative (red) regions that make this state a resource for universal and fault tolerant quantum computation. The projection of this distribution onto the plane at the bottom is reminiscent of the chessboard picture we’ve talked about.
We can see why the state in the plot is an approximation. In place of the ideal state, we now have only a finite number of circular patterns with an appreciable width, so they can overflow a little bit to the neighbouring squares. This means that a single board can no longer tolerate the train moving along sharper slopes, that is, larger displacement errors.
Importantly, approximate GKP states like this are physically realizable, and, luckily for us, can still be useful for near-term applications on NISQ (Noisy Intermediate Scale Quantum) era devices. Understanding these NISQ devices would eventually provide directions on how to build universal fault-tolerant machines.
In our recent paper we do a thorough analysis of imperfect GKP states to see how good they are for encoding information, going through a basic set of gates, and correcting errors. We introduce many useful figures of merit to characterize the states and track errors induced by these fundamental building blocks of powerful machines.
With the formalism of the grid states out of the way, we can move on to how we can actually create them in photonic systems.
Sculpting phase space distributions using photonic chisels and hammers
We can prepare grid states in the lab with a photonic circuit using light from a coherent source along with a sequence of photonic elements. The parallel branches of the circuit are called its modes.
Some of the elements at our disposal transform the phase space distributions of single modes; these are the squeezers, which stretch or compress the distributions, and displacers, which shift the distributions around. Then there is the interferometer, which is an array of beam splitters that entangle the distributions across different modes. We’ll also need measurement devices such as homodyne detectors, which can help us reconstruct the distributions.
Using these photonic elements we can prepare any Gaussian state. But Gaussian gates acting on Gaussian states are insufficient for universal computation; we’ll need our GKP states, which are the non-Gaussian resources in our architecture. To prepare those, we use photon-number-resolving detectors (PNRs), which measure the number of photons residing in a circuit mode. In a sense, the PNRs probabilistically carve out parts of the Gaussian distribution, so that what is left is generally non-Gaussian.
With this in mind, a general state-preparation circuit begins with a set of squeezers, one for each mode. The squeezed light then enters an interferometer made up of beam splitters. This creates a Gaussian distribution stretched across the phase spaces of all the modes of light in the device. If we then use PNRs to measure all but the last mode of what the circuit has produced, with some success probability, a non-Gaussian state will emerge in the last mode.
By varying the configurations of the photonic components, we are able to generate any non-Gaussian state, including an approximate GKP state.
The cost of this method of state preparation is the trade-off between the quality of the states and the likelihood of their generation. In our paper, we delegate the task of finding a practical sweet-spot in this trade-off to machine learning algorithms.
The challenge of non-Gaussian state preparation is also compounded by lossy circuits. But as system losses are minimized and the technology behind non-Gaussian operations matures, one can expect the efficiency of GKP state preparation to increase dramatically.
We are now moving in two parallel research avenues: understanding how to implement quantum algorithms on NISQ devices using bosonic qubits, and devising fault-tolerant bosonic codes in conjunction with scalable photonic architectures, a long term goal.
Our ultimate destination is a practical quantum computer shielded from any error. Bosonic qubits can clear the spiny path that leads us there!
