Almost optimal geometrically local quantum LDPC codes in any dimension

Keeping Fragile Quantum Information in Line

Quantum computers promise to solve problems that overwhelm today’s machines, but their basic building blocks—qubits—are notoriously fragile. To keep information alive, researchers use quantum error-correcting codes, mathematical schemes that spread information across many qubits so that errors can be detected and fixed. This paper tackles a key obstacle to turning those abstract codes into hardware-ready designs: how to arrange them in real space so that each qubit only talks to its near neighbors, without sacrificing performance.

Why Local Connections Matter

Many of the best-known quantum error-correcting codes, called quantum LDPC (low-density parity-check) codes, look excellent on paper. They can store a lot of quantum information and protect it against many errors while using relatively few interactions per qubit. However, these codes are usually defined in an abstract way, where any qubit can, in principle, interact with any other. Real quantum devices do not work like that. On a chip or in an array of atoms, qubits can only reliably interact with nearby partners. Coding schemes such as surface codes and color codes already obey this “geometric locality” rule and have powered recent experimental breakthroughs—but they are not as efficient as the best abstract LDPC codes. Bridging that gap has been a long-standing goal.

From Abstract Networks to Structured Tiles

The authors present a general recipe for turning any good quantum LDPC code into a new code that is almost as powerful but also geometrically local in any chosen spatial dimension. Their key insight is to extract a two-dimensional structure from the original code, even if the code was defined in a purely algebraic way. They start from a standard representation of a code as a tripartite network of qubits and two types of “checks” that test for errors. Because of how these checks commute, qubits linked to both types of checks can be naturally grouped into square-shaped patterns. By systematically pairing such connections, the team builds what they call a square complex: a collection of vertices, edges, and square faces that captures the essential features of the code in a 2D layout.

Refining the Grid to Achieve Locality

Once the square complex is in place, the construction proceeds by subdividing each square into a fine grid, much like overlaying graph paper on a coarse tiling. New qubits and error checks are assigned to the grid points and edges in a carefully chosen repeating pattern, echoing how surface codes live on a lattice. This subdivision step creates a new code whose basic interactions are naturally tied to neighboring positions on the grid. The authors then invoke mathematical results about how such subdivided complexes can be embedded into ordinary Euclidean space—our familiar two- or three-dimensional world, or even higher dimensions—so that connected elements remain close together and no region becomes overcrowded. In this way, the abstract code is systematically reshaped into one that respects spatial locality.

Performance Close to the Theoretical Limits

Crucially, this geometric makeover does not come at a large cost. The new codes still store a robust amount of quantum information and retain strong protection against errors, coming close to known theoretical limits that relate how much information can be stored, how far apart errors can be spread, and how local the interactions must remain. Under mild technical conditions satisfied by all currently known good LDPC codes, the authors also show that their geometrically local versions have a large “energy barrier.” In physical terms, moving from one logical state of the memory to another by accident would require crossing many violated checks along any path, making spontaneous logical errors exceedingly unlikely.

What This Means for Quantum Hardware

For a general reader, the upshot is that this work provides a blueprint for taking some of the most powerful theoretical quantum codes and bending them into shapes that real devices can implement. Instead of having to choose between mathematically optimal codes and physically realistic layouts, hardware designers can now, in principle, start from any strong LDPC code and obtain an almost optimal, geometrically local variant suited to chips, ion traps, or atom arrays. Beyond this specific application, the authors’ method of extracting a two-dimensional geometric skeleton from abstract algebraic objects may inspire new approaches to simplifying codes, reducing hardware overhead, and exploring higher-dimensional quantum memories in the years to come.

Citation: Li, X., Lin, TC., Wills, A. et al. Almost optimal geometrically local quantum LDPC codes in any dimension. Nat Commun 17, 2389 (2026). https://doi.org/10.1038/s41467-026-69031-w

Keywords: quantum error correction, quantum LDPC codes, geometrically local codes, topological quantum memory, quantum computing hardware