⚛️ quantum physics

A 67%-Rate CSS Code on the FCC Lattice: [[192,130,3]] from Weight-12 Stabilizers

This paper presents a high-rate 3D CSS stabilizer code on the Face-Centered Cubic lattice with uniform weight-12 stabilizers, achieving a 67% encoding rate and distance-3 protection through a structural surplus of logical degrees of freedom, alongside a tailored decoding algorithm demonstrating significant coding gains.

Original authors: Raghu Kulkarni

Published 2026-03-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Raghu Kulkarni

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to store a massive amount of information in a room full of fragile glass marbles. In the world of quantum computing, these "marbles" are qubits, and they are incredibly fragile. A tiny breeze (noise) can knock them over, corrupting your data. To protect them, scientists use error-correcting codes, which act like a safety net, constantly checking if a marble has fallen and fixing it before the information is lost.

For a long time, the best safety nets (like the famous "Surface Code") were very heavy. To store just one piece of useful information (a "logical qubit"), you needed hundreds of fragile marbles. It was like building a fortress with a 100-foot wall just to protect a single gold coin. The "encoding rate" (how much useful data you get for the effort) was tiny—around 3%.

Enter the FCC Code: The "High-Density Apartment" of Quantum Computing.

This paper introduces a new way to build that safety net using a specific 3D shape called the Face-Centered Cubic (FCC) lattice. Think of this not as a simple grid of boxes (like a standard cube), but as the most efficient way to stack oranges in a grocery store. This is the densest packing possible in 3D space.

Here is the magic trick of this new code:

1. The "Orange Stack" Geometry

In a standard cube grid, every point touches 6 neighbors. In this new FCC grid, every point touches 12 neighbors.

The Old Way: Imagine a city where every house is connected to only 6 neighbors. To check if a house is safe, you need a lot of police officers (stabilizers) relative to the number of houses.
The New Way: In this FCC city, every house is connected to 12 neighbors. Because the connections are so dense, the "police officers" (the checks) are incredibly efficient. They can watch over many houses at once without needing a huge army.

2. The Result: A Massive Data Boost

The authors tested this on a small scale (a "block" of 192 physical qubits).

Old Standard (Cubic Lattice): You might get 3 useful logical qubits out of 108 physical ones. (Rate: ~3%)
New FCC Code: You get 130 useful logical qubits out of 192 physical ones. (Rate: 67%)

The Analogy:
Imagine you have a suitcase.

The old method is like packing the suitcase with 100 empty boxes just to fit 3 shirts inside.
The FCC method is like using a vacuum-seal bag. You fit 130 shirts into a suitcase that is only slightly larger than the one holding 3 shirts.

You get 24 times more data for roughly the same amount of physical space.

3. The Trade-off: Speed vs. Armor

Is there a catch? Yes, but it's a calculated one.

The Old Codes are like a tank. They have thick armor (high "distance"). If a few bullets hit, they can still survive. But they are heavy and slow to build.
The FCC Code is like a high-speed sports car. It has thinner armor (lower "distance"). It can only survive a few small hits before it needs a repair.
Why take the risk? Because in many modern quantum tasks (like running simulations or training AI), we don't need one perfect, super-safe qubit. We need many qubits working together, even if they are a little noisy. The FCC code gives us a "fleet" of 130 cars instead of a single tank.

4. How It Works (The "Checkers" Game)

The code works by placing "checkers" on the edges of the lattice.

Z-Checks: Look at the corners (vertices).
X-Checks: Look at the empty spaces in the middle (octahedral voids).
Every single checker looks at exactly 12 qubits. This uniformity makes it easier to build with real hardware.

The authors proved mathematically and with computer simulations that this structure works perfectly. They found that for every 3 physical qubits, you effectively get 2 logical qubits of storage.

5. Can We Build It?

The paper suggests this isn't just a math fantasy. It could be built on:

Neutral Atoms: Using lasers to trap atoms in this specific 3D "orange stack" pattern.
Photonic Networks: Using light beams to connect nodes in this shape.
Superconducting Chips: Stacking layers of chips to mimic the 3D structure.

The Bottom Line

This paper is a breakthrough because it solves the "scaling problem." We can't just keep building bigger and bigger tanks (the old codes) because they become too expensive. Instead, this new code shows us how to build high-density data centers for quantum computers.

It trades the ability to survive many errors for the ability to store many more qubits. For the next generation of quantum computers that need to run complex, noisy algorithms, this "high-rate" code might be the key to unlocking the technology's true potential.

In short: They found a way to pack 24 times more information into the same quantum space, turning a slow, heavy fortress into a bustling, high-capacity city.

1. Problem Statement

Fault-tolerant quantum computing faces a critical scaling bottleneck regarding the encoding rate (the ratio of logical qubits $k$ to physical qubits $n$ ).

Current Limitations: Standard topological codes, such as the 2D surface code and 3D cubic toric code, offer excellent error suppression (growing distance $d$ ) but extremely low encoding rates ( $k/n \sim 1/d^2$ or constant $k$ ). For example, the 3D cubic toric code achieves only a ~2.8% rate at distance $d=4$ .
The Gap: While classical coding theory utilizes dense parity check matrices (LDPC) to approach Shannon limits, quantum constructions achieving high rates have largely relied on abstract algebraic graphs (hypergraph products) that are difficult to fabricate physically. There is a need for a high-rate quantum code that can be implemented on a physically realizable 3D lattice.

2. Methodology

The authors propose a new Calderbank-Shor-Steane (CSS) stabilizer code constructed on the Face-Centered Cubic (FCC) lattice.

Lattice Geometry:
- The lattice is defined on integer points $(x, y, z)$ where $x+y+z \equiv 0 \pmod 2$ .
- Qubit Placement: Physical qubits are placed on the edges of the lattice. Each node has a coordination number $K=12$ (the maximum for a monatomic 3D lattice).
- Periodic Boundaries: The lattice is wrapped on a 3-torus of side length $L$ (where $L$ is even).
Stabilizer Definitions:
- Z-Stabilizers: Defined on each vertex (node). A $Z$ operator acts on all 12 incident edges.
- X-Stabilizers: Defined on each octahedral void (interstitial sites surrounded by 6 nodes). An $X$ operator acts on the 12 edges connecting these 6 surrounding vertices.
- Uniform Weight: Every stabilizer check has a weight of exactly 12.
Verification: The authors developed a Python-based computational framework (using numpy and scipy) to construct the parity check matrices ( $H_X$ and $H_Z$ ), verify the CSS commutation condition ( $H_X H_Z^T = 0$ ), and perform exhaustive searches for logical operators to determine the minimum distance.

3. Key Contributions

High-Rate Code Construction: The paper introduces a CSS code family on the FCC lattice with parameters $[[3L^3, 2L^3+2, 3]]$ .
Structural Insight: It identifies that the high encoding rate stems from a "structural surplus." The FCC lattice has $3L^3$ edges but only $L^3$ independent stabilizer constraints (split between vertices and octahedral voids), leaving a massive surplus of degrees of freedom for logical qubits.
Exact Distance Proof: Unlike many theoretical codes where distance is bounded, the authors provide an exact proof of the minimum distance $d=3$ for finite sizes ( $L=4, 6$ ) by exhaustively eliminating all weight-1 and weight-2 logical operators and constructing weight-3 logical codewords.
Decoder Implementation: A Minimum-Weight Perfect Matching (MWPM) decoder adapted to the $K=12$ FCC geometry is proposed and tested.

4. Results

The computational verification yielded the following specific results:

Code Parameters:
- At $L=4$ : $n=192$ $n = 192$ physical qubits, $k=130$ $k = 130$ logical qubits, $d=3$ $d = 3$ .
  - Encoding Rate: 67.7%.
- At $L=6$ : $n=648$ $n = 648$ physical qubits, $k=434$ $k = 434$ logical qubits, $d=3$ $d = 3$ .
  - Encoding Rate: 67.0%.
- Asymptotic Limit: As $L \to \infty$ , the rate approaches $2/3$ (66.7%) while the distance remains fixed at $d=3$ .
Comparison:
- The FCC code achieves a rate 24 times higher than the cubic 3D toric code (2.8% at $d=4$ ).
- It packs 43 times more logical qubits than the cubic toric code for comparable lattice sizes, albeit at a lower distance ( $d=3$ vs. $d=4$ ).
Decoder Performance (Monte Carlo Simulations):
- At physical error rate $p=0.001$ , the MWPM decoder achieves a 10× coding gain over bare qubits (98.8% success rate for all 130 logical qubits).
- At $p=0.0005$ , the gain increases to 63× (99.9% success).
Logical Operator Localization: The authors conjecture that the $2L^3+2$ logical qubits are localized within the tetrahedral voids of the lattice (2 logical qubits per void), plus 2 global homological qubits.

5. Significance and Implications

New Regime in Rate-Distance Tradeoff: The FCC code occupies a qualitatively different region in the quantum error correction landscape. It prioritizes high encoding rate over scalable error suppression (growing distance).
Hardware Feasibility: Unlike abstract hypergraph product codes, this code is defined on the FCC lattice, which is the densest sphere packing in 3D. This makes it potentially implementable on:
- Neutral Atom Arrays: Using 3D optical lattices with Rydberg interactions.
- Photonic Networks: Via programmable waveguide meshes.
- Superconducting Qubits: Using multi-layer flip-chip packaging.
Application Niche: While not a replacement for the surface code in applications requiring arbitrarily low logical error rates (due to fixed $d=3$ $d = 3$ ), it is highly valuable for:
- Variational quantum algorithms.
- Quantum simulation.
- Scenarios where having many "noisy" logical qubits is preferable to having a few "clean" ones.
Future Directions: The paper highlights open questions regarding single-shot error correction (whether weight-12 checks satisfy confinement conditions) and methods to increase the distance $d$ while maintaining the high rate (e.g., adding tetrahedral stabilizers).

In conclusion, this work demonstrates that by leveraging the unique geometry of the FCC lattice, it is possible to construct a physically realizable quantum code with an unprecedented 67% encoding rate, offering a new tool for near-term quantum hardware architectures.