Mirror codes: High-threshold quantum LDPC codes beyond the CSS regime

This paper introduces "mirror codes," a versatile family of non-CSS quantum LDPC codes constructed from group parameters that, when paired with provably fault-tolerant syndrome extraction circuits, achieve competitive error thresholds around 0.2% for near-term fault-tolerant quantum memory applications.

The Gist

Imagine you are trying to send a fragile, priceless message across a stormy ocean. The message is written on a piece of paper (a qubit), but the waves (noise) are constantly trying to tear it apart or change the words. If you just send one piece of paper, it will likely be destroyed.

To solve this, you don't just send one paper; you send a whole fleet of papers arranged in a specific, clever pattern. This is Quantum Error Correction. You spread the information out so that if a few papers get wet or torn, you can still reconstruct the original message by looking at the remaining ones.

This paper introduces a new, flexible way to arrange these "fleet of papers," called Mirror Codes, and a new set of tools to check if the papers are still intact without ruining them.

Here is the breakdown of their discovery using everyday analogies:

1. The Problem: The "Surface Code" is Too Big

Currently, the most popular way to protect quantum information is called the Surface Code. Think of this like a giant, rigid brick wall. It's very strong and reliable, but it's huge. To store even a tiny bit of information, you need hundreds of bricks (physical qubits).

• The Issue: We are currently building small boats (near-term quantum computers) that don't have room for a giant brick wall. We need a protection method that is strong but fits in a smaller space.

2. The Solution: Mirror Codes (The "Dancing Partners")

The authors created a new type of code called Mirror Codes.

• The Analogy: Imagine a dance floor with $N$ dancers (qubits). In the old "Surface Code," the dancers stand in a rigid grid. In Mirror Codes, the dancers are arranged based on a set of rules derived from a mathematical "group" (like a specific pattern of movement).
• How it works: You pick a group of people (a mathematical group) and two specific subsets of dancers (let's call them the Green Team and the Red Team).
  • Every dancer holds a sign.
  • The rule is: "If you are in the Green Team's spot, hold a 'Z' sign. If you are in the Red Team's spot, hold an 'X' sign."
  • Because the teams are chosen carefully, the signs "mirror" each other perfectly across the floor. If one dancer makes a mistake, the pattern of signs reveals exactly who messed up, allowing you to fix it.
• The Twist: Unlike previous methods that required the "Green Team" and "Red Team" to be completely separate (like two different classes of students), Mirror Codes allow them to mix. This flexibility allows them to pack more information into fewer dancers.

3. Breaking the "CSS" Rule

For a long time, scientists believed that to make these codes work, they had to follow a strict rule called CSS (named after the inventors).

• The Analogy: Think of CSS like a rule that says, "You can only use Red crayons for the left side of the drawing and Blue crayons for the right side. Never mix them."
• The Discovery: The authors realized that by breaking this rule and allowing Red and Blue crayons to mix (creating non-CSS codes), they could create much more efficient patterns. They found codes that are smaller and stronger than the previous "best" codes, specifically for the small quantum computers we have right now.

4. The "Syndrome Extraction" (Checking the Papers)

Knowing the pattern is broken is one thing; checking it without making things worse is another. To check if the papers are intact, you have to ask the dancers questions. But asking questions can sometimes disturb the dancers and cause new errors.

• The Old Way: You ask one question at a time using one helper (ancilla qubit). It's fast, but if the helper sneezes (makes an error), it might knock over two dancers.
• The New Way: The authors built three new "inspection circuits" (tools to check the code):
  1. The Bare Circuit: Fast, but risky. (Like checking the papers with your eyes only).
  2. The Loop Circuit: Adds a "flag" helper. If the main helper sneezes, the flag waves a red flag so you know to ignore that check. (Like having a security guard watching the checker).
  3. The Superdense Circuit: Pairs up checks to watch each other.
  4. The Heavy-Duty Circuit: Uses 6 helpers to be absolutely sure no errors slip through, but it's expensive (uses more resources).

5. The Results: Small but Mighty

The authors ran simulations (virtual experiments) with these new Mirror Codes.

• The Finding: They found that Mirror Codes can protect information just as well as the giant Surface Code, but they do it with fewer qubits.
• The Threshold: They found a "tipping point" (about 0.2% error rate). If the physical hardware is better than this, the Mirror Codes can successfully protect the data. This is a huge deal because it means we might be able to build useful, error-corrected quantum computers sooner than we thought, using the smaller machines we have today.

Summary

Think of Mirror Codes as a new, flexible blueprint for building a fortress.

• Old Blueprint: A massive, heavy stone wall (Surface Code). Great protection, but needs a huge army to build.
• New Blueprint (Mirror Codes): A clever, interlocking chain-link fence. It's lighter, fits in smaller spaces, and is just as good at keeping the bad guys (errors) out.
• The Bonus: They also invented better "security guards" (syndrome extraction circuits) to patrol this fence, ensuring that the act of patrolling doesn't accidentally let the bad guys in.

This work suggests that we don't need to wait for massive, perfect quantum computers to start doing error correction. We can start now with smaller devices, using these new, efficient "Mirror" patterns.

Technical Summary

Here is a detailed technical summary of the paper "Mirror codes: High-threshold quantum LDPC codes beyond the CSS regime" by Khesin and Lu.

1. Problem Statement

The realization of fault-tolerant quantum computing relies on Quantum Error Correction (QEC) protocols that can suppress logical error rates below physical error rates. Current leading approaches face significant trade-offs:

• Surface Codes: While robust and geometrically local, they have low coding efficiency (encoding few logical qubits per physical qubit), requiring massive hardware overhead.
• Quantum LDPC Codes: Recent high-efficiency codes (e.g., Bivariate Bicycle codes) offer better rates but are typically restricted to the CSS regime (where stabilizers are purely $X$ or purely $Z$).
• Hardware Constraints: Near-term devices have limited qubit counts and connectivity. Many high-performance LDPC codes require non-local connectivity or large overheads for syndrome extraction, making them unsuitable for smaller-scale architectures (e.g., $n \le 250$).

The authors identify a gap: there is a lack of high-performance, non-CSS quantum LDPC codes that are flexible enough for near-term hardware and offer high thresholds without the strict structural constraints of CSS codes.

2. Methodology

A. Mirror Code Construction

The authors introduce Mirror Codes, a new family of quantum stabilizer codes constructed from a finite group $G$ and two subsets $A, B \subseteq G$.

• Definition: For a group $G$ of order $n$, the code is defined by $n$ stabilizers labeled by $g \in G$:
  $$S(g) = Z(Ag)X(Bg^{-1})$$
  (Symmetric version) or $S(g) = Z(Ag)X(g^{-1}B)$ (Asymmetric version).
• Key Feature: Unlike CSS codes, every stabilizer in a mirror code generally contains a mixture of $X$ and $Z$ operators (potentially forming $Y$ operators where they overlap). This places them outside the CSS regime.
• LDPC Property: The check weight is bounded by $w = |A| + |B|$. By choosing small subsets $A$ and $B$, the authors ensure the codes are Low-Density Parity Check (LDPC).
• Generalization: This construction generalizes Two-Block Group Algebra (2BGA) codes and includes all Bivariate Bicycle (BB) codes as a subset (when $G$ is abelian and specific conditions are met). However, mirror codes are not limited to abelian groups or CSS structures.

B. Fault-Tolerant Syndrome Extraction

Recognizing that syndrome extraction circuits are a major source of errors, the authors design a hierarchy of circuits trading overhead for provable fault tolerance:

1. Bare Circuit: 1 ancilla per check. No fault tolerance guarantees.
2. Loop Circuit: 2 ancillas per check. Partially fault-tolerant.
3. CSS-FT6: 3 ancillas per check. Proven fault-tolerant for weight-6 CSS codes.
4. FT6 (General): 6 ancillas per check (reducible to 4). Proven fault-tolerant for all weight-6 stabilizer codes (including non-CSS mirror codes).
5. Superdense: 1 ancilla per check (pairing stabilizers). Heuristic fault tolerance.

C. Code Search and Benchmarking

• Search Strategy: The authors performed an (almost) exhaustive search for abelian and non-abelian mirror codes with $n \le 300$ (for $|A|=|B|=3$) and up to $n \le 150$ for non-abelian groups. They utilized gauge symmetries (permutations and local Cliffords) to prune the search space and identify canonical forms.
• Simulation: They conducted end-to-end numerical simulations under the SI1000 circuit-level noise model using a general-purpose quantum stabilizer decoder.

3. Key Contributions

1. Novel Code Family: Introduction of Mirror Codes, a flexible construction that breaks the CSS barrier while maintaining LDPC properties. They contain all 2BGA codes (under specific conditions) but extend beyond them.
2. High-Performance Non-CSS Codes: Discovery of several high-rate, high-distance codes that are not CSS. Notable examples include:
   • $[[60, 4, 10]]$ (Check weight 6)
   • $[[36, 6, 6]]$ (Check weight 6)
   • $[[48, 8, 6]]$ (Check weight 6)
   • $[[85, 8, 9]]$ (Check weight 6)
   • Several weight-7 codes with $kd > n$.
3. Fault-Tolerant Circuits: Development of a suite of syndrome extraction circuits, specifically the FT6 circuit, which provides provable fault tolerance for general weight-6 stabilizer codes (a class previously difficult to handle without CSS assumptions).
4. Theoretical Characterization:
   • Provided necessary and sufficient conditions for mirror codes to be well-defined (commuting stabilizers) using group algebra and kernel functions.
   • Classified gauge symmetries (permutations and Local Cliffords) to define canonical forms and reduce search redundancy.
   • Derived conditions under which mirror codes are "equivalently CSS" (transformable to CSS via Hadamards) using graph bipartiteness on coset constraint graphs.

4. Results

• Threshold Performance: Under the SI1000 circuit-level noise model, the discovered mirror codes achieved a pseudothreshold of approximately 0.2%. This performance is comparable to the state-of-the-art $[[144, 12, 12]]$ Bivariate Bicycle code under the same model.
• Trade-off Analysis:
  • Overhead vs. Threshold: More fault-tolerant circuits (e.g., FT6) introduce more ancillas, which increases the space for errors and slightly lowers the pseudothreshold. However, once the physical error rate drops below this threshold, the logical error rate drops much more steeply compared to less fault-tolerant circuits.
  • Scalability: Mirror codes are shown to be versatile for devices with varying qubit counts. Smaller codes (e.g., $n < 100$) can be used on near-term devices, while larger codes can be deployed as hardware scales.
• Non-Abelian vs. Abelian: The exhaustive search revealed that for the parameters explored, abelian mirror codes consistently outperformed non-abelian ones in terms of rate and distance. The authors conjecture that abelian groups are sufficient for optimal mirror codes.
• CSS vs. Non-CSS: The results challenge the intuition that CSS codes are always superior at small scales. The non-CSS mirror codes found in this work demonstrated competitive or superior performance to known CSS counterparts of similar size.

5. Significance

• Near-Term Viability: Mirror codes offer a promising path for near-term fault-tolerant quantum memory, particularly for architectures with limited qubit counts ($n \le 250$) where the $[[144, 12, 12]]$ BB code is too large or the surface code is too inefficient.
• Breaking the CSS Barrier: The work demonstrates that high-threshold, high-efficiency QEC is achievable outside the CSS regime. This expands the design space for quantum codes, allowing for the use of non-local connectivity (suitable for neutral atoms and trapped ions) without sacrificing performance.
• Hardware Agnosticism: The proposed syndrome extraction circuits are general-purpose and do not rely on specific code symmetries, making them applicable to a wide range of quantum LDPC codes beyond just mirror codes.
• Future Directions: The paper opens new avenues for studying logical operations via code automorphisms and optimizing scheduling algorithms to further improve thresholds.

In summary, this work provides a robust theoretical framework and practical code families that bridge the gap between small-scale experimental devices and large-scale fault-tolerant quantum computing, proving that non-CSS LDPC codes can achieve state-of-the-art performance.