⚛️ quantum physics

Wire Codes

The paper introduces "wire codes," a general method for transforming any quantum stabilizer code into a local subsystem code with weight and degree three on a given graph, thereby enabling the implementation of highly efficient quantum error-correcting codes on hardware with restricted connectivity while providing explicit overhead and distance trade-offs based on graph embeddings.

Original authors: Nouédyn Baspin, Dominic Williamson

Published 2026-04-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nouédyn Baspin, Dominic Williamson

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

The Big Problem: The "Fragile Quantum House"

Imagine you are trying to build a house out of glass (this is your quantum computer). Glass is incredibly fragile; a tiny breeze (noise) can shatter it. To protect the house, you need a security system (a quantum error-correcting code) that can detect when a window breaks and fix it immediately.

For a long time, scientists used a very simple security system called the "Surface Code." It's like a grid of guards standing next to each other. They only talk to their immediate neighbors. It's easy to build, but it's not very efficient—it requires a massive amount of glass to store even a tiny bit of information.

Recently, scientists discovered a "Super Code" (called qLDPC) that is incredibly efficient. It can store a lot of information with very little glass. However, there's a catch: in this Super Code, every guard needs to talk to everyone else in the building, not just their neighbors.

The Dilemma: Real quantum hardware is like a small apartment building. You can't run a wire from the top floor to the basement to let two guards talk; the wires would be too long, too expensive, and would tangle. We have a brilliant, efficient code that requires "all-to-all" connections, but our hardware only supports "neighbor-to-neighbor" connections.

The Solution: "Wire Codes"

The authors of this paper, Nou'edyn Baspin and Dominic Williamson, invented a clever trick called Wire Codes.

Think of it like this: You need to connect two people in a crowded room who are far apart, but you can't throw a long rope. Instead, you pass a message down a line of people standing between them.

The "Wire" Metaphor:
In their construction, they replace a single, long, impossible connection with a chain of short, local connections. They build a "wire" made of extra helper particles (called ancilla qubits).

The Original Problem: Check A needs to talk to Check B, but they are 100 steps apart.
The Wire Code Fix: They build a bridge of 100 small steps between them. Check A talks to Step 1, Step 1 talks to Step 2, and so on, until the message reaches Check B.

By doing this, they turn a "Super Code" that requires impossible connections into a "Local Code" that fits perfectly into standard hardware, without losing the efficiency benefits.

How It Works: The "Degree Reduction" Trick

The paper introduces two main problems they solve: Weight and Degree.

Weight (How many people a guard talks to):
- The Problem: In the Super Code, one guard might need to check 50 different windows at once. That's hard to do locally.
- The Fix: They break that one big check into a chain of smaller checks. Instead of Guard A checking 50 windows, Guard A checks Window 1, which checks Window 2, which checks Window 3... until the chain reaches Window 50. Now, everyone only talks to 2 or 3 neighbors.
Degree (How many guards a window talks to):
- The Problem: A single window might be monitored by 50 different guards. That's too many wires for one window.
- The Fix: They create "copy" windows. The original window talks to Copy 1, Copy 1 talks to Copy 2, and so on. The 50 guards are spread out along this line of copies. Again, no single window has to talk to more than 3 guards.

The Result: They take a complex, high-maintenance code and turn it into a simple, low-maintenance code where every interaction involves only 3 items (a "trivalent" system). This is the "sweet spot" for current hardware.

The "Holographic" Magic

The paper mentions that these codes are "holographic." Here is a metaphor for that:

Imagine you have a 3D sculpture (the efficient code) that you want to display on a 2D wall (your hardware). Usually, you can't fit a 3D object on a 2D wall without squishing it.

The Wire Code construction acts like a hologram. It takes the complex 3D structure of the efficient code and "projects" it onto the 2D wall using a series of wires (the bulk). The information is stored in the connections (the wires) running through the space, allowing the complex code to exist locally on the surface of your hardware.

Why This Matters (The "So What?")

It Works Everywhere: Whether your hardware is a flat 2D chip, a 3D cube, or a weirdly shaped network (like a spiderweb or an expander graph), Wire Codes can adapt to fit it.
It Saves Space: Before this, to get the efficiency of the "Super Code" on local hardware, you would have needed a massive amount of extra space (overhead). Wire Codes show you can get very close to the theoretical best performance with very little extra space.
It's a Universal Translator: It translates the "language" of highly connected, efficient codes into the "language" of restricted, local hardware.

Summary Analogy

Imagine you are trying to organize a massive, efficient dinner party where everyone needs to pass a dish to everyone else (the Super Code). But you are in a small kitchen where you can only pass dishes to the person standing right next to you (the Hardware).

Wire Codes are the solution: Instead of trying to throw dishes across the room, you set up a "conveyor belt" of waiters (the ancilla qubits) between the guests.

Guest A passes the dish to Waiter 1.
Waiter 1 passes it to Waiter 2.
...
Waiter 10 passes it to Guest B.

Now, everyone is only passing dishes to their immediate neighbor, but the dish still gets from A to B. The party runs efficiently, the kitchen doesn't explode, and everyone gets fed.

In short: Wire Codes are a general recipe to take the most powerful quantum error-correcting codes we know and make them fit into the physical limitations of real-world quantum computers.

1. Problem Statement

Quantum error correction (QEC) is essential for fault-tolerant quantum computing. While recent breakthroughs in Quantum Low-Density Parity-Check (qLDPC) codes have achieved optimal asymptotic performance (constant rate and relative distance), they suffer from a critical hardware limitation: they require high-weight checks (interactions involving many qubits) and high connectivity (qubits interacting with many others).

Most physical quantum hardware (e.g., superconducting qubits, trapped ions) is constrained by locality, typically allowing only nearest-neighbor interactions on a low-dimensional lattice (e.g., 2D or 3D grids). Existing methods to map high-connectivity codes to local hardware often incur massive overheads in qubit count or significantly degrade the code distance. Furthermore, standard subsystem codes (which allow for simpler syndrome extraction) often lack the optimal scaling parameters of modern qLDPC codes when restricted to local geometries.

The core challenge addressed is: How can we transform arbitrary, highly connected stabilizer codes (like qLDPC) into local subsystem codes with low-weight (weight $\le$ 3) and low-degree (degree $\le$ 3) checks, while minimizing overhead and preserving code distance?

2. Methodology: The Wire Code Construction

The authors introduce a general recipe called Wire Codes, which transforms any input stabilizer code into a subsystem code with local interactions on a given graph. The construction relies on two main mechanisms: Weight Reduction and Degree Reduction, mediated by ancillary qubits and gauge checks.

A. Core Concepts

Trivalent Resolution: The input Tanner graph (representing the code) is resolved into a trivalent (degree-3) graph. High-weight checks and high-degree qubits are broken down into chains of lower-weight interactions.
Ancillary "Wires": Long-range interactions between distant qubits in the original code are replaced by chains of ancillary qubits (the "wires").
Gauge Checks: The construction introduces gauge operators (which do not need to be measured for error correction but define the subsystem structure).
- Z-branches: Chains of qubits connected by $ZZ$ checks to propagate $Z$ -type information.
- X-branches: Single-site $X$ checks on ancillary qubits to eliminate logical errors on the ancilla subsystem.
- Y-branches: Combinations of the above to handle $Y$ operators.

B. Construction Steps

Degree Reduction: For a qubit connected to $\delta$ checks, the authors introduce "branches" of copy qubits. The original qubit interacts with a chain of copy qubits, and the original checks are redistributed to interact with different copy qubits. This reduces the degree of any single qubit to at most 3.
Weight Reduction: For a check of weight $\omega$ , the authors introduce ancillary qubits between the data qubits. The original high-weight check is replaced by a chain of 3-body checks (e.g., $P_1 Z_{anc} P_2$ , $Z_{anc} P_3 Z_{anc}'$ , etc.) that effectively simulate the original interaction.
Graph Embedding: The construction allows for flexible edge lengths. If the target hardware is a specific graph $G$ $G$ (e.g., a 2D lattice or an expander graph), the "wires" are routed through $G$ $G$ .
- If the target is a Euclidean lattice (e.g., 2D or 3D), the construction uses "branching" and "routing" strategies (leveraging edge-disjoint paths in hypercubes) to embed the Tanner graph with constant density.
- If the target is an Expander Graph, the construction utilizes the expansion properties to embed the code with minimal distortion.

3. Key Contributions

A. General Weight and Degree Reduction

The paper provides a theorem (Theorem 1.1) stating that any $[[n, k, d]]$ stabilizer code with max check weight $\omega$ and max degree $\delta$ can be transformed into a subsystem code with:

Max Check Weight: 3
Max Qubit Degree: 3
Qubit Overhead: $O(\delta n)$
Distance: $\Omega(d/\omega)$
This is achieved without requiring the input code to be local; the locality is imposed by the output construction.

B. Optimal Local Subsystem Codes in $D$ Dimensions

By applying the wire code construction to good qLDPC codes (which have $k \sim n$ and $d \sim n$ ) and embedding them into $D$ -dimensional Euclidean lattices, the authors derive codes that saturate the known bounds for local subsystem codes.

Result: They construct codes with parameters $[[n^{D/(D-1)}, \Theta(n), \Theta(n^{D/(D-1)})]]$ (or similar scaling depending on block size).
Significance: Previous local codes could not simultaneously achieve constant rate and optimal distance scaling in fixed dimensions. Wire codes bridge this gap by mapping non-local qLDPC codes to local geometries.

C. Codes on Expander Graphs

The authors extend the construction to arbitrary graphs with edge expansion (Definition 2.2).

Result: For an $\alpha$ -expander graph, they construct local subsystem codes with parameters $[[n, \Omega(\alpha n/\text{polylog}(n)), \Omega(\alpha n/\text{polylog}(n))]]$ .
Implication: The better the connectivity (expansion) of the hardware architecture, the better the achievable code parameters. This provides a theoretical framework for designing codes for non-Euclidean hardware (e.g., photonic interconnects or modular architectures).

D. Fault Tolerance Preservation

The paper argues that if the number of ancillary qubits added per original qubit/check is constant (as in the direct weight reduction of qLDPC codes), the fault-tolerance threshold is preserved. The overhead introduces a constant multiplicative increase in the effective error rate, but does not destroy the existence of a threshold.

4. Key Results and Theorems

Theorem 1.1 (Weight Reduction): Transforms $[[n, k, d]]$ to $[[O(\delta n), k, \Omega(d/\omega)]]$ with weight/degree 3.
Theorem 1.2 (Graph Embedding): Maps the code to a graph $G$ with overhead dependent on the embedding length $\ell_{max}$ .
Corollary 1.1: Existence of optimal local subsystem codes in any dimension $D \ge 2$ that saturate the bound $kd^{1/(D-1)} \le O(n)$ .
Corollary 1.3: Existence of local subsystem codes on expander graphs with parameters scaling linearly with the expansion factor $\alpha$ .

5. Significance and Impact

Bridging Theory and Hardware: Wire codes provide a practical "compiler" or "recipe" to take the theoretically optimal qLDPC codes (which are currently difficult to implement due to connectivity constraints) and map them onto realistic, restricted hardware architectures (like 2D/3D lattices) without losing their asymptotic advantages.
Optimality: The construction proves that the theoretical bounds for local subsystem codes (which were previously thought to be loose or unachievable for high-rate codes) can be saturated using wire codes derived from qLDPC inputs.
Flexibility: The framework is not limited to Euclidean lattices. It applies to any graph topology, making it highly relevant for emerging quantum architectures with non-standard connectivity (e.g., modular quantum computers, photonic networks).
Subsystem Advantage: By utilizing subsystem codes, the construction enables simpler syndrome extraction (measuring weight-3 checks) compared to the heavy measurement requirements of the original stabilizer codes, potentially lowering the circuit depth and error rates during readout.

In summary, Wire Codes represent a fundamental advancement in quantum error correction architecture, offering a scalable method to implement high-performance, non-local codes on local hardware by leveraging the flexibility of subsystem codes and graph embeddings.