Quantum LDPC Codes: Beyond Surface Code Performance

Hello! Welcome to the second lesson in our module on recent advances in quantum error correction.

In our last lesson, we established the core principles of classical Low-Density Parity-Check (LDPC) codes. We saw that their defining feature is a sparse parity-check matrix, which allows for highly efficient, iterative decoding algorithms that operate on a local graph structure. This classical foundation is crucial for what comes next.

Today, we will transition these ideas into the quantum domain. Our goal is to analyze the properties of quantum LDPC codes and their potential for improved distance-rate tradeoffs compared to surface codes. We will investigate how the concept of "low-density" is realized in the stabilizer formalism and, through recent research papers, explore the significant advantages these codes offer in reducing the qubit overhead required for fault-tolerant computation.

1. From Classical to Quantum LDPC Codes

Recall that a classical LDPC code is defined by a parity-check matrix $H$ where each row (check) and each column (bit) has a small, constant number of non-zero entries. This sparsity is the key.

In the quantum world, we use the stabilizer formalism. A quantum stabilizer code is defined by a set of commuting Pauli operators $\{S_i\}$, the stabilizer generators. The codespace is the simultaneous +1 eigenspace of all these generators.

A Quantum Low-Density Parity-Check (QLDPC) code is a stabilizer code where the stabilizer generators are sparse. This means:

1. Each stabilizer generator $S_i$ acts non-trivially on a small number of qubits (low check weight).
2. Each physical qubit is involved in a small number of stabilizer generators (low qubit degree).

This is the direct quantum analogue of a sparse classical parity-check matrix and a sparse Tanner graph.

This property is what sets QLDPC codes apart from many other code families. To understand the motivation for studying them, particularly as an alternative to the well-studied surface code, let's look at the introduction of a recent paper on the topic.

As the paper highlights, while the surface code is a strong contender due to its high error threshold and compatibility with 2D hardware, its scaling is a major bottleneck. Let's formalize this.

2. The Rate-Distance Tradeoff

For a quantum code with parameters $[[n,k,d]]$, where $n$ is the number of physical qubits, $k$ is the number of logical qubits, and $d$ is the code distance, we are interested in two key figures of merit:

• Encoding Rate (R): $R=k/n$, the ratio of logical to physical qubits.
• Relative Distance ($\delta$): $\delta =d/n$, the code distance as a fraction of the block size.

For the surface code, the parameters scale as $k=\mathcal{O}(1)$ (typically 1 or 2) and $d=\mathcal{O}(\sqrt{n})$. This implies:

• The encoding rate $R=\mathcal{O}(1/n)\to 0$ as $n\to \infty$.
• The relative distance $\delta =\mathcal{O}(1/\sqrt{n})\to 0$ as $n\to \infty$.

This scaling is considered poor. Protecting more logical qubits requires a linear increase in physical qubits (e.g., making separate surface code patches), and achieving higher distance requires a quadratic increase in qubits. This massive overhead makes scaling up to thousands of logical qubits a daunting challenge.

The primary motivation for QLDPC codes is to overcome this limitation. The theoretical goal is to construct "good" QLDPC codes that simultaneously achieve:

• A constant encoding rate, $k=\Omega (n)$, so $R>0$.
• A linear distance, $d=\Omega (n)$, so $\delta >0$.

Such codes would represent an exponential saving in qubit resources compared to surface codes. The following reading provides more context on this pursuit.

3. The Challenge: Non-Local Connectivity

If "good" QLDPC codes exist, why aren't they the default choice? The answer lies in the structure of their stabilizers. The very properties that give them good distance and rate (related to the expansion properties of their Tanner graphs) typically require non-local connections between physical qubits. This stands in stark contrast to the surface code, whose main appeal is its geometrically local stabilizers on a 2D grid, a feature well-matched to many leading hardware platforms.

This creates the central tension in QLDPC research: a tradeoff between a code's theoretical performance (rate, distance) and its practical implementation cost (hardware connectivity).

A recent paper on "La-cross codes" frames this issue very clearly.

The key takeaway is that the "best" QEC code is not an absolute; it's a co-design problem between code properties and hardware capabilities. Much of current research focuses on finding QLDPC families that strike a favorable balance—offering significant overhead reduction without demanding impossibly complex hardware.

4. Case Studies: QLDPCs vs. The Surface Code

To make the potential of QLDPCs concrete, let's analyze the performance comparisons presented in these two papers. Both studies simulate their respective code families under circuit-level noise and compare the logical error rate against that of a surface code using a similar number of physical resources.

Case Study 1: Bivariate Bicycle (BB) Codes

The paper by Bravyi et al. introduces a family of QLDPCs called Bivariate Bicycle (BB) codes. While their construction is based on bivariate polynomials (as briefly described in their Methods section), we will focus on the results of their performance analysis.

The result is remarkable: to achieve a logical error rate of $\sim 10^{-7}$ with a physical error rate of $10^{-3}$ for 12 logical qubits, the BB code requires about 288 physical qubits, while the surface code would need nearly 3,000. This is a direct illustration of the improved distance-rate tradeoff in action.

Case Study 2: La-cross Codes

The paper by Dalin et al. analyzes a family of QLDPC codes constructed using the Hypergraph Product (HGP). This is a powerful technique you may recall from our CSS codes module, where two classical codes are combined to create a quantum code. Here, they are built from classical cyclic codes to yield QLDPCs with some non-local stabilizers.

Let's analyze their performance comparison, which introduces the important concept of a "crossing point."

This analysis reveals a crucial insight:

• The QLDPC code has a steeper slope on the log-log plot. This is a consequence of its higher code distance $d$ for a given $n$, leading to better error suppression (logical error $\propto p^{d/2}$).
• However, the surface code often has a higher error threshold and performs better at high physical error rates.
• There exists a crossing physical error probability, $p^{\ast }$, below which the QLDPC code's superior scaling allows it to achieve a lower logical error rate than the surface code.

The existence of this crossing point, and the fact that it is within reach of current or near-term hardware ($p^{\ast }\sim 10^{-3}$), is what makes QLDPC codes so compelling. The analysis showing that $p^{\ast }$ converges to a non-zero value as $n\to \infty$ is particularly significant, as it guarantees that for a fixed number of qubits, the LDPC code will always be better, provided the physical error rate is low enough.

Test your understanding!

A research group is building a quantum computer. They can choose between implementing a surface code or a specific QLDPC code. Their current physical two-qubit gate error rate is $p=0.5\%$. The crossing point for this QLDPC code family against the surface code is known to be $p^{\ast }=0.2\%$. Which code should they choose to implement for now to get the best logical qubit performance, and why? What should be their long-term goal regarding their hardware?

Show answer

For now, they should implement the surface code. Their current physical error rate ($p=0.5\%$) is above the crossing point ($p^{\ast }=0.2\%$). In this regime, the surface code provides a lower logical error rate.

Their long-term goal should be to improve their hardware to reduce the physical gate error rate to be significantly below $p^{\ast }=0.2\%$. Once they achieve this, switching to the QLDPC code will allow them to take advantage of its superior scaling and achieve much lower logical error rates for the same number of physical qubits.

Conclusion

In this lesson, we have bridged the gap from classical to quantum LDPC codes and analyzed their significant potential for building more efficient fault-tolerant quantum computers.

Key Takeaways:

• Definition: A QLDPC code is a stabilizer code whose generators are sparse, meaning each generator acts on few qubits, and each qubit participates in few generators.
• Distance-Rate Tradeoff: QLDPC codes offer a path to overcoming the poor scaling of the surface code. While the surface code has a rate $R\to 0$ and relative distance $\delta \to 0$, QLDPC codes can potentially achieve constant rate and linear distance, leading to an exponential reduction in qubit overhead.
• The Challenge of Non-Locality: The superior properties of most QLDPC codes come at the cost of requiring non-local stabilizer checks, a significant hardware engineering challenge.
• Performance Crossover: In practice, QLDPC codes outperform surface codes only when the physical error rate is below a characteristic "crossing point" ($p^{\ast }$). Below this point, their superior distance provides much stronger error suppression.

Preview of the next lesson:
We have seen how designing new code families like QLDPCs is one major direction of research in error correction. Another complementary direction is to design codes that are tailored to the specific noise present in a real device. In the next lesson, we will begin exploring this by asking: What happens to the standard surface code under a biased noise model where dephasing errors are much more likely than bit-flip errors? This will set the stage for understanding codes that are specifically designed to exploit such noise biases.