Google: A Colorful Quantum Future

Error correction is a key component of tomorrow’s large scale quantum computers. Using error correction, we can combine many “physical qubits” (in our devices, these are small superconducting circuits that can store quantum information, but are sensitive to noise) into an ensemble that works together to store a single “logical qubit” that is more robust to noise. Just a few months ago, we announced that we had implemented a surface code quantum error correction experiment that exceeded the performance threshold required to get benefits from scaling up the system. This means that, in principle, we can now make a near-perfect logical qubit by “simply” adding more and more physical qubits.

Thinking ahead to the next steps in this journey raises the following questions:

1. How can we minimize the number of physical qubits per logical qubit?
2. How can we maximize the speed of logical operations and quantum algorithms?

One way to make progress on both these questions, exemplified by the release of our Willow chip, is to improve the quality of the physical qubits (i.e., lower physical error rates). This reduces the required code distance (i.e. the minimum number of simultaneous physical errors required to produce a logical error) leading to fewer physical qubits per logical qubit and faster logical operations, which generally scale with the code distance. However, another way is to make the error correction code more efficient.

Today, we are excited to report the experimental demonstration of a “color code” system that provides an advantageous alternative to the well studied surface code. In our latest Nature publication, “Scaling and logic in the color code on a superconducting quantum processor”, we implement the building blocks required for a resource efficient, fault-tolerant quantum computer based on the color code. Just like the surface code, the color code is a way to encode each logical qubit using many physical qubits in such a way that errors can be detected and corrected as they occur. However, the color code uses a different geometrical pattern of parity measurement (i.e., a triangular patch of hexagonal tiles) which requires fewer physical qubits and boasts more efficient logical gates than the surface code, but this comes at the expense of requiring deeper physical circuits and a different decoding algorithm.

Triangles are smaller than squares, but at what cost?

When evaluating an error correction code, a useful metric is the “distance” of the code, which tells us the number of physical errors that result in one logical error. In the surface code, we need to lay out our logical qubit in a square where edge length is equal to the distance of the code. The color code geometry is different, however, since it requires a hexagonal tiling into a triangular shape with edge length equal to the distance of the code. This means that the area of the color code is much less than that of a surface code of the same distance, which suggests that we need fewer physical qubits.

But there is a tradeoff! It turns out that implementing the error correction circuit and decoding the output is more difficult in the color code (e.g., because matching algorithms are not as accurate on this code). In practice, this means that it is harder to cross the error correction threshold (i.e., the level of performance required for error correction to work). Nevertheless, our recent publication shows that our Willow chip, in combination with recent decoding advances, is now capable of below-threshold performance using the color code.

Specifically, our result compares a color code with a distance of 3 and 5, and shows that the logical error rate is suppressed by a factor of 1.56× at the higher distance. While this initial result is smaller than the factor of 2.31× we’ve previously achieved using surface codes, we expect that the geometrical advantage may start to win out at larger scale and with additional device improvements.

Faster single qubit logical operations

Where the color code really starts to shine is when we take a look at logical operations. Here some single qubit operations become easier than in the surface code. In the color code, many logical operations can be implemented in a single step, while the surface code requires many cycles of error correction to do the same thing. For example, the logical Hadamard gate is expected to take ~20ns in the color code, whereas it can take 1000× longer to execute on a surface code in the same device. This makes it much faster to run logical gates and ultimately faster to run quantum algorithms. Moreover, since an algorithm would take many fewer error correction cycles, we can afford more error per cycle and hence fewer physical qubits.

Using this feature, we demonstrated that we could perform many single qubit logical operations and verified the results using “logical randomized benchmarking” (more in the paper).

Injecting arbitrary states

A key ingredient of quantum computing is the ability to generate a special state called the “magic state” (or T-state). “Magic states” are important because they are required to generate the critically important arbitrary qubit rotation. Without these arbitrary qubit rotations quantum algorithms would not outperform classical methods. The generation of this state was long presumed to be the most expensive part of practical quantum algorithms. However, recent theoretical advances have shown that, using the color code, one can construct an efficient circuit, called “cultivation”, to generate these magic states. This is great news for the future of quantum algorithms!

This reinforces the importance of implementing color codes on our devices. In our experiment, we demonstrated the first step of the “cultivation” protocol, which is to inject an “imperfect” magic state into a color code logical qubit with 99% fidelity.

Stitching patches to implement 2-qubit operations

Another critical operation needed to run quantum algorithms are 2-qubit gates. These operations are generally done by merging two separate logical qubits into one single patch and then pulling them apart. In our experiments, we were able to demonstrate this technique by successfully entangling two logical qubits and transferring information from one logical qubit to the other with a fidelity of 86% to 91%. It is interesting to note that the color code is also slightly more flexible in that respect since it allows the merge operation to act on 3 different bases (X, Y, and Z), rather than the two available in the surface code (X and Z).

What’s next

After years of focus on the surface code, these results show that there are viable alternatives that can efficiently be implemented below their error correction threshold on our superconducting quantum processors. While the surface code is still our main workhorse configuration, it now seems likely that the color code will also be part of our large scale quantum computer. First, it is a critical part of the “cultivation” protocol which should allow us to inject “magic states” more efficiently. Second, as our quantum hardware evolves, the color code may even become more efficient than the surface code, both from a space (physical qubits) and time (number of error correction cycles) perspective.