Translation-invariant quantum low-density parity-check codes from compactified fracton models

This paper presents a unifying framework for translation-invariant quantum low-density parity-check codes, including fracton and Abelian Two-Block Group Algebra codes, by deriving them from compactified higher-dimensional hypergraph product fracton parent models, which also enables the extension of code-parameter bounds and offers insights into the limitations of their transversal gates and energy barriers.

The Gist

The Big Picture: Finding the "Family Tree" of Quantum Codes

Imagine you are trying to organize a massive library of strange, exotic books called Quantum Error-Correcting Codes. These books are special because they protect information from getting scrambled (like a noisy phone call) by using a system of checks and balances.

For a long time, scientists have found many different types of these "books," especially ones called Fracton Codes. These are like puzzles where the pieces (errors) are stuck in place and can't move easily. While we know these codes work well, they seem like a chaotic mess of unrelated inventions. Some are local (checks happen right next to each other), and some are long-range (checks happen far apart).

The main discovery of this paper is that these codes aren't random. The authors found a "Family Tree" that connects almost all of them. They showed that many complex, low-dimensional codes are actually just compactified versions (squished-down versions) of a single, giant, high-dimensional "Parent Code."

The Core Concept: The "Parent" and the "Child"

To understand how this works, think of a 3D Lego structure (the Parent Code).

1. The Parent (High-Dimensional): Imagine a massive, intricate Lego castle built in a 4D or 5D space. It has very specific rules about how the bricks connect. This is the "Hypergraph Product" (HGP) model. It's huge, complex, and exists in a dimension we can't easily visualize.
2. The Child (Low-Dimensional): Now, imagine you take that giant 4D castle and force it to fit onto a flat 2D table. You do this by twisting the edges of the table and gluing them together in a specific way. This process is called Compactification.
   • When you squish the 4D castle down, the rules change. The checks that were far apart in the 4D world might end up right next to each other on the 2D table.
   • The paper proves that almost all the "Fracton Codes" and "Bivariate Bicycle (BB) Codes" we use today are just different ways of squishing that same giant 4D Lego castle.

The "Fracton Family Trees"

The authors realized that these codes fall into three distinct "Family Trees" based on the math used to build them (specifically, whether the number of parts in their rules is even or odd).

• Tree A: Codes built from rules with an even number of parts.
• Tree B: Codes built from rules with an odd number of parts.
• Tree C: Codes built from a mix of even and odd.

Just like a biological family tree, if you know the "Parent" (the giant 4D code), you can predict the properties of all the "Children" (the specific codes we use in experiments). For example, all the "BB codes" (a popular type of code for near-term quantum computers) with the same check weight come from the exact same Parent.

Why Does This Matter? (The Paper's Claims)

The paper doesn't just organize the library; it uses this "Family Tree" idea to make three specific predictions about how these codes behave:

1. The "Distance" Limit (How far can an error travel?)
In quantum codes, "distance" is like the size of the smallest mistake you can make without breaking the code.

• The Claim: The paper shows that you can calculate the maximum possible "distance" for any of these codes by looking at their Parent. If the Parent code is local (checks are close together) in a high dimension, the Child code (even if it looks long-range) has a predictable limit on how well it can protect data. It's like saying, "No matter how you fold this map, the distance between two points can't be longer than the original paper."

2. The "Gate" Limit (What magic tricks can we do?)
Quantum computers need to perform logic gates (operations) to calculate. Some gates are easy (Clifford gates), and some are hard (non-Clifford gates, like the T-gate).

• The Claim: The authors conjecture that if the Parent code can only do the "easy" gates, then the Child code (the squished version) can only do the easy gates too. You can't gain the ability to do "hard" magic tricks just by squishing the code down. This is a big deal because it suggests these codes might have a hard ceiling on what they can compute without extra help.

3. The "Energy Barrier" Limit (How hard is it to break?)
Think of the code as a valley. To break the code (create an error), you have to climb a hill (energy barrier).

• The Claim: The paper suggests that the height of the hill for the Child code is limited by the height of the hill for the Parent. If the Parent code has a low hill (easy to break), the Child code won't magically become a mountain. This helps scientists understand which codes are truly "self-correcting" (able to fix themselves) and which are not.

Summary in a Metaphor

Imagine you have a master recipe for a giant, multi-layered cake (the Parent Code).

• You can bake this cake in a huge 5-story oven.
• But sometimes, you want a small, flat pancake (the Child Code) for a quick breakfast.
• This paper says: "All the different pancakes you've been making (Fracton codes, BB codes) are just this one giant cake recipe, but baked in different shaped pans and squished down."

Because they all come from the same master recipe:

• We know exactly how tall the pancake can get (Distance bounds).
• We know exactly what toppings it can hold (Gate restrictions).
• We know how hard it is to burn (Energy barriers).

The paper provides the "Master Recipe" that unifies a chaotic collection of quantum codes into a single, understandable family.

Technical Summary

Technical Summary: Translation-Invariant Quantum LDPC Codes from Compactified Fracton Models

Problem Statement
Quantum error-correcting (QEC) codes with translation symmetry and local checks have led to a diverse array of fracton codes in three or more dimensions. However, these codes currently lack a complete unifying framework. While recent studies have highlighted the impressive performance of translation-invariant codes with long-range checks (such as Bivariate Bicycle or BB codes) in two dimensions, the relationship between these long-range codes and local higher-dimensional fracton models remains unclear. The challenge is to provide a unifying picture that connects local fracton models, long-range qLDPC codes, and specifically the Abelian Two-Block Group Algebra (A2BGA) family, which includes BB codes, cubic codes, and fractal spin-liquid codes.

Methodology
The authors employ Haah's polynomial formalism to analyze translation-invariant stabilizer codes. The core methodology involves:

1. Hypergraph Product (HGP) Construction: Starting with simple, translation-invariant classical fractal codes, the authors construct a higher-dimensional "parent" quantum code using the HGP construction. This parent code is a local fracton model defined on a higher-dimensional hypercubic lattice.
2. Compactification via Twisted Boundary Conditions: The authors introduce a dimension-reduction technique called "compactification." By imposing twisted boundary conditions (equations of the form $\prod x_i^{v_i} = 1$) on the parent code, they derive lower-dimensional "descendant" codes.
3. Algebraic Unification: They demonstrate that families of A2BGA codes (including BB codes) with fixed check weights can be viewed as specific compactifications of a single higher-dimensional HGP parent code. This is achieved by mapping the monomials of the descendant code's generating polynomials to independent variables in the parent code and solving for the necessary twisted boundary conditions.
4. Indecomposability Analysis: The authors establish an algebraic criterion (Theorem 1) based on the monomial group generated by the code's polynomials to determine if a code is indecomposable. This condition is required for the unification method to hold, ensuring the code does not decouple into independent sub-lattices.

Key Contributions and Results

• Unifying Framework: The paper establishes that all A2BGA codes with the same fixed check weight on left and right qubits are compactifications of a single higher-dimensional HGP fracton model. This unifies local fracton models (like the cubic code) and long-range qLDPC codes (like BB codes) under a single structural origin.
• Fracton Family Trees: The authors classify these codes into three "fracton family trees" over the field $\mathbb{F}_2$, distinguished by the parity of the lengths of the generating polynomials of the parent HGP code.
  • Family 1: Parent generated by two even-length polynomials (includes Haah's code, Checkerboard, HHB-A).
  • Family 2: Parent generated by two odd-length polynomials (includes BB codes, Honeycomb color code).
  • Family 3: Parent generated by one even and one odd-length polynomial (includes Serpinski prism model).
• Distance Bounds: Building on previous work for generalized bicycle codes, the authors extend distance bounds to the broader class of A2BGA codes.
  • Upper Bound: They prove that an A2BGA code with fixed weight $w$ and $v \le w-2$ unique variables can be mapped to a code local in $D \le w-2$ dimensions. Consequently, the code distance $d$ scales as $d \le O(n^{1 - 1/D})$.
  • Lower Bound: By further compactifying to two dimensions, they show that if a code has no string-like operators in all but two directions, it is equivalent to a tensor product of toric codes, implying a distance lower bound of $d \ge O(n^{1/D})$.
• Conjectures on Code Properties:
  • Logical Gate Restrictions: The authors conjecture that if the parent HGP code has transversal gates restricted to the Clifford group (a known result for HGP codes), then all descendant A2BGA codes inherit this restriction. This would imply no A2BGA code admits non-Clifford transversal gates.
  • Energy Barriers: They conjecture that the energy barrier scaling of any A2BGA code family is upper-bounded by that of its HGP parent. For instance, since the Newman-Moore model has a logarithmic energy barrier, all codes in its family tree (including weight-six BB codes) would have energy barriers growing at most logarithmically.

Significance
The paper provides a "unifying picture" for a large family of translation-invariant codes, bridging the gap between local fracton models and long-range qLDPC codes. By showing that diverse codes like BB codes, cubic codes, and fractal spin liquids are merely different compactifications of a single parent structure, the work simplifies the classification of these models. This structural insight allows researchers to transfer known properties (such as distance bounds and potential gate restrictions) from well-understood higher-dimensional local parent codes to complex, lower-dimensional descendant codes. The proposed conjectures regarding transversal gates and energy barriers offer a new avenue for understanding the fault-tolerance and memory capabilities of these codes, suggesting that their fundamental limitations are dictated by their higher-dimensional origins.