Fault-tolerant quantum computing with the Parity Code and noise-biased qubits

fault-tolerant parity quantum computing
The authors Valentin Torggler, Michael Fellner, Anette Messinger, Wolfgang Lechner and Berend Klaver

The ParityQC team is proud to present the new paper “Fault-tolerant quantum computing with the parity code and noise-biased qubits”, introducing a new approach to error correction in quantum computing that combines the Parity error correction code with noise-biased qubits. Read an introduction to the paper below.

In the current quantum computing era, there is a substantial effort going into tackling the challenges that prevent building fault-tolerant quantum computers. Quantum systems are extremely susceptible to errors caused by environmental noise and imperfect control mechanisms. In fault-tolerant quantum computation, the quantum state is redundantly encoded in an error correction code and fault-tolerant quantum operations are performed on the encoded quantum state. Extensive research has been conducted on fault- tolerant quantum computation using the surface code, which has a relatively high error threshold and can correct for phase-flip as well as bit- flip errors. As a downside, it requires a large qubit overhead, shifting implementations of complex problems to the far future.

In the current quantum computing landscape, a platform has emerged as particularly interesting for fault-tolerance: noise-biased qubits (e.g. “cat qubits”). This quantum computing platform allows for protecting against one error type (for instance bit-flips) on the level of the physical implementation of the qubit while the second error type (for instance phase-flips) can be corrected by a classical error correction code. Since error correction codes that are designed for (predominantly) correcting only a single error type have an improved encoding rate and simpler error correction cycles, a noise-biased implementation saves resources, bringing fault-tolerant quantum computing into reach for near-term application.

A new paper by our team, “Fault-tolerant quantum computing with the parity code and noise-biased qubits” focuses exactly on this topic. The authors (Anette Messinger, Valentin Torggler, Berend Klaver, Michael Fellner and Wolfgang Lechner) present strategies for fault-tolerant quantum computing using the ParityQC Architecture as a classical error correction code, in combination with noise-biased qubits. 

With the ParityQC Architecture, quantum information is always encoded into multiple physical qubits in a way that allows errors of one type to be detected and corrected through measurement of stabilizer operators. In contrast to other stabilizer code constructions, the stabilizer operators of the Parity Code are specifically chosen so that certain physical single-qubit operators map to logical multi-qubit operations, which allows an easy implementation for many entangling gates. In particular, any set of logical many-body rotations in one basis can be fully parallelized –  a feature which is almost impossible to obtain in other error correction codes. The authors show how to implement such operations in a fully fault-tolerant manner on noise-biased qubits using magic state distillation and gate teleportation methods.

The Parity Code can be classified as a Low Density Parity Check (LDPC) code with the unique advantage that error correction and quantum operations can be performed on a platform with only nearest-neighbor interaction on a 2D grid, while it still exhibits a high encoding rate. An encoding with the repetition code would need approximately twice as many qubits to obtain the same robustness against errors as the Parity Code.

This low qubit overhead, together with the tailoring of stabilizers to algorithmic requirements which lies at the core of the ParityQC Architecture, make the Parity Code a promising new candidate for fault-tolerant quantum computing applications on near-term devices. The method opens new possibilities for designing fast and efficient quantum algorithms.

Back to news