New error-correcting code boosts quantum computing by a factor of 10!

Last week, new simulations from two research groups reported that an emerging class of quantum error-correcting codes is an order of magnitude more efficient than the current "gold standard" (i.e., surface codes).

Quantum error-correcting codes work by converting a large number of error-prone quantum bits into smaller "protected" quantum bits that rarely make errors. In both simulations, however, low-density parity-check codes (LDPC codes) can generate protected quantum bits from 10 to 15 times fewer raw quantum bits than surface codes. Neither research group has made the leap to implementing these simulations in actual hardware, but experiments suggest that these codes, or similar ones, could accelerate the arrival of more capable quantum devices.

Classical computers run on bits and rarely misbehave. But quantum bits, the particle-like objects that power quantum computers, lose their "quantum magic" once they are squeezed by anything from the delicate state of their quantum state.

To make future quantum bits work, the researchers plan to use quantum error correction, a technique that encodes information redundantly using additional quantum bits. The principle of this method is similar to saying each word twice, spreading the information into more characters, thus protecting the information from static interference.

Quantum error-correcting surface codes were introduced in 1998 by Alexei Kitaev of the California Institute of Technology and Sergey Bravyi of the Landau Institute for Theoretical Physics in Russia.

The distance-3 surface code used in previous experiments

It organizes quantum bits into a square grid that performs a game similar to minesweeper: each quantum bit connects four neighboring quantum bits, so that checking a specified auxiliary quantum bit silently spies on the four data-carrying quantum bits. Depending on whether the check returns a 0 or a 1, scientists can deduce whether any of the neighbors are in error; by checking around the board, scientists can deduce where the error is and fix it.

These checks, along with more subtle tweaks to problematic quantum bits, can also hide a reliable quantum bit in a square block of data-carrying quantum bits, not exactly here or there - but everywhere. As long as the "suspect" quantum bit keeps the "minesweeping" operation running smoothly, the hidden quantum bit remains safe and can be manipulated to perform the operation. In this way, the surface code elegantly fuses many "shitty" quantum bits into a single quantum bit with few errors.

The code has long been the gold standard for quantum error correction; it is highly tolerant of misbehaving quantum bits, and the grid is easy to visualize. As a result, the surface code has influenced the design of quantum processors and quantum roadmaps.

The disadvantage of surface codes is that they are "insatiable" for quantum bits: in order to protect reliable quantum bits more strongly, a larger block of shoddy quantum bits is needed. To make multiple protected quantum bits, multiple blocks need to be spliced together; these are heavy burdens for researchers who dream of running quantum algorithms on many protected quantum bits.

In 2013, Gottesman saw a possible way out of the dilemma.

Researchers including Terhal and Bravyi found evidence that surface codes work as well as we could hope for planar codes that only connect neighboring bits to neighboring bits; but what if each checksum was allowed to connect quantum bits that are far apart? Quantum information theorists have begun to explore codes with such "non-local" connections, which are arbitrarily called LDPC codes. (Confusingly, a surface code is technically an LDPC code; in practice, however, the term usually refers to a member of a clan with a non-local checksum).

Gottesman then showed that some LDPC codes can be less "greedy": they can stuff multiple protected quantum bits into a single block, which will help avoid inflating the demand for quantum bits of larger algorithms by surface codes.

But Gottesman's study is highly idealized, considering an essentially infinite population of quantum bits. The practical challenge is whether researchers can scale down LDPC codes and make them suitable for real quantum devices while maintaining their robust performance.

Nikolas Breuckmann has been trying for years to go beyond surface codes - the gold standard for quantum error correction - and he thinks that LDPC codes may be the answer.

Over the past two years, Breuckmann and other researchers have begun to scrutinize the performance of LDPC codes that can run on ever-smaller systems. They hope that some LDPC codes will fit into today's devices: devices that can deliver about 100 raw bits.

Last week, a team of IBM researchers led by Breuckmann modeled the smallest, most specific LDPC blueprint yet, based on LDPC code from a little-known paper published in 2012. It starts with the four neighboring quantum bits of the surface code, and adds two carefully selected "non-local" quantum bits.

A small example of a quasi-cyclic LDPC code and its performance based on a circuit noise model.

Comparison of the quasi-cyclic LDPC code [[144, 12, 12]] with a surface code with 12 logical quantum bits and distance d ∈ {11, 13, 15}. The length of the distance-d surface code with 12 logic-quantum bits is n = 12d^2, since each logic-quantum bit is encoded into a separate d × d fragment of the surface code grid. The figure shows the logical error rate, pL, estimated by performing d syndrome loops on the distance-d code. due to sampling errors, the error bars are ≈ pL/10 for most data points.

https://arxiv.org/abs/2308.07915

They simulated the kinds of errors that could occur when running the code on real circuits, a process akin to putting a digital fighter jet into a digital wind tunnel to see how it flies. They found that their code protects its reliable quantum bits more effectively than a surface code. In one test run, the code extracted 288 raw quantum bits with a 0.1 percent failure rate and used them to create 12 protected quantum bits with a 10,000-fold lower failure rate. The team estimates that for the same task, the surface code would require more than 4,000 input quantum bits.

Andrew Cross, a researcher on the IBM team, said, "We were very surprised by this."

This simulation foreshadows future error-correcting capabilities today: for while no one has access to 4,000 quantum bits, devices with hundreds of them are just around the corner.

Gottesman commented, "You can see that devices with a number of quantum bits comparable to what we have today have considerable error tolerance."

A day after IBM's preprint was published, a multi-institutional collaboration of researchers led by Mikhail Lukin of Harvard and Liang Jiang of the University of Chicago published similar results. They cleaned up two other LDPC codes and modified them for simulation, and found that both codes also required only about one-tenth of the number of input bits to generate tens to hundreds of good bits compared to surface codes.

Link to preprint:

https://arxiv.org/abs/2308.08648

But it's harder to build an F-35 fighter than it is to simulate one, and it will be extremely challenging to build a device that can use the LDPC code.Gottesman explains that there are two main things that could prevent the practical application of these things:

- First, it's very difficult to make non-local connections between quantum bits, especially for companies like IBM that make them with fixed superconducting circuits. Connecting these circuits to their "neighbors" is natural, but making connections between distant quantum bits is not.

Connecting far-flung quantum bits may be easier for systems that rely on moving quantum bits, such as the free-roaming atoms used by a team to assemble this atomic Eiffel Tower (left) in 2018. For systems that use static quantum bits, such as the 16 superconducting quantum bits in the IBM chip (right), this would be a greater challenge.

- Second, LDPC codes excel when protected quantum bits are used for storage-as they are in IBM's simulations. But when computing with these fuzzy, overlapping quantum bits, the tangled, nonlocal code structure makes it much more difficult to select and steer the required quantum bits.

According to Gottesman, "It's possible in principle to do these computations, but we don't know if it's possible to do it in a really practical way."

The new experiments saw Lukin and colleagues take tiny steps toward addressing these major shortcomings. First, the team simulated end-to-end computation by combining an LDPC-protected quantum memory with a surface code-protected quantum processor. In this scheme, the saving of quantum bits reduces the computational burden to a large extent, but at the cost of longer computational runtimes.

In addition, Lukin's team tailored its simulations for a type of free-roaming quantum bit that is well suited for arranging long-distance connections. Unlike stationary superconducting circuits, their quantum bits are atoms immobilized by a laser beam. By moving the laser, they can bring distant quantum bits into contact - important for LDPC codes.

A fault-tolerant qLDPC-based quantum computer architecture using reconfigurable arrays of atoms.

Efficient implementation of quantum LDPC codes with atomic arrays.

qLDPC memory performance

Fault-tolerant stealth transitions from surface codes to qLDPC codes.

Indeed, it remains uncertain when or even if LDPC codes will be practical. Even with the most optimistic predictions, the demonstration of tens of reliable memory bits is likely to take at least a few years, and computation is still out of reach. But recent simulations make surface codes look more and more like stepping stones on the road to quantum computing, rather than the end of the road.

"There's a reason surface codes have been around for 20 years." The researchers involved in this experiment said, "It's hard to beat, but now we have evidence that we can indeed beat it."

Reference link:

[1]https://arxiv.org/abs/2308.03750

[2]https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.129.050504

[3]https://pme.uchicago.edu/faculty/liang-jiang

[4]https://www.quantamagazine.org/new-codes-could-make-quantum-computing-10-times-more-efficient-20230825/

[5]https://research.ibm.com/blog/error-correction-codes