🔬 condensed matter

Toric code made subsystem: a framework for topological subsystem codes using anticommuting quantum spin liquids

This paper introduces a framework for constructing topological subsystem codes by modifying the toric code into anticommuting quantum spin liquids, which feature an extensive set of local conserved operators and undisturbed gauge qubits to enable robust quantum error correction on various lattice geometries.

Original authors: Vaibhav Sharma, Sumiran Pujari

Published 2026-06-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vaibhav Sharma, Sumiran Pujari

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 protect a precious secret (a "logical qubit") inside a room full of noisy, chaotic people (the "physical qubits"). In the world of quantum computing, this noise causes errors that can destroy your secret. To stop this, scientists build "error-correcting codes"—like a complex security system that constantly checks for intruders and fixes mistakes.

This paper introduces a new, clever way to build these security systems. The authors, Vaibhav Sharma and Sumiran Pujari, propose a framework they call "Toric code made subsystem."

Here is a breakdown of their idea using simple analogies:

1. The Old Way vs. The New Way

The Old Way (The Toric Code): Think of the classic Toric code like a rigid, high-security vault. It works great, but it requires very specific, heavy-duty locks (measurements) to check for errors. It's like a bank vault that needs four people to turn four different keys simultaneously to open a door. It's secure, but it's hard to build in some places.
The New Way (The ACC Code): The authors took the blueprint of that classic vault and modified it. They realized that if you arrange the "locks" (the quantum checks) in a slightly different, "corner-sharing" pattern, you create a system that is not a rigid vault, but a flexible, self-healing room.

2. The Magic Ingredient: "Quantum Spin Liquids"

The authors based their new code on a strange state of matter called an Anticommuting Quantum Spin Liquid.

The Analogy: Imagine a crowd of people in a room who are constantly shifting positions. In a normal room, if everyone stands still, the room is stable. In this "Spin Liquid" room, the people are so restless that they can't settle down; they are always jiggling.
The Twist: Usually, this restlessness is bad for storing secrets. However, the authors found that this specific type of restlessness creates a massive amount of "hidden space" (degeneracy). It's like the room has so many extra, unused chairs that you can shuffle people around without ever disturbing the person sitting in the "VIP seat" (your logical qubit).

3. The "Gauge Qubits": The Redundant Chairs

This is the most unique part of their discovery.

In a standard code, every single check you perform might accidentally disturb your secret if you aren't careful.
In this new code, there are extra "gauge qubits." Think of these as a large group of "decoy" people in the room.
When the security system (the check operators) measures the room to find errors, it can shake up these decoy people all it wants. They act as a shock absorber. They absorb the errors and the "noise" of the measurement process, leaving the VIP seat (your actual data) completely untouched.
The paper claims this is a distinct feature: unlike other codes, this system has an "extensive number" of these decoys that are left undisturbed by the checks, making the error correction much more efficient.

4. How They Built It (The Two Examples)

The authors didn't just talk about theory; they built two concrete examples to prove it works:

The Square Lattice (Weight-4): Imagine a grid like a chessboard. They placed their checks on the squares. To check for errors, they had to look at groups of 4 qubits at a time (like checking a 2x2 square). This is similar to the old Toric code but with the new "decoy" flexibility.
The Kagome Lattice (Weight-3): Imagine a grid made of interlocking triangles (like a honeycomb but with triangles). Here, they only needed to check groups of 3 qubits at a time. This is "lighter" and easier to implement on some hardware, while still keeping the same level of security.

5. Why Does This Matter?

The paper argues that this framework is a "template."

Flexibility: Just as you can build a house on a square plot or a triangular plot, this code can be built on different shapes (lattices) depending on what your quantum computer hardware looks like.
Hardware Friendly: Some quantum computers have qubits arranged in specific shapes (like the "heavy-hex" layout of IBM's processors). The authors show that their "Kagome" (triangle-based) code fits naturally onto these existing shapes, whereas older, rigid codes might not fit as well.

Summary

The paper claims to have found a new recipe for quantum error correction. By taking a restless, "liquid" state of matter and arranging it carefully, they created a code that:

Protects data using topology (the shape of the grid).
Uses decoy qubits (gauge degrees of freedom) to absorb errors without disturbing the data.
Can be built on different shapes (squares, triangles) to fit various quantum computers.

They call these "Anticommuting Charge (ACC) codes." The main takeaway is that they turned a "messy" quantum state into a highly organized, flexible, and robust way to protect quantum information.

Technical Summary: Toric Code Made Subsystem

Problem Statement
The paper addresses the challenge of designing fault-tolerant quantum error correction (QEC) codes that leverage the properties of many-body topological order while offering the hardware advantages of subsystem codes. While topological stabilizer codes (like the toric code) provide robustness against local noise, they often require high-weight stabilizer measurements. Conversely, subsystem codes (like the Bacon-Shor code) utilize gauge degrees of freedom to simplify syndrome extraction (e.g., using lower-weight check operators) but often lack the topological flexibility to encode multiple logical qubits dependent on lattice geometry.

The authors investigate a specific class of quantum spin liquid models known as anticommuting $Z_2$ quantum spin liquids (ac-Z2 QSLs). These models, recently proposed in condensed matter literature, possess many-body topological order but are characterized by an extensive ground state degeneracy arising from local conserved operators that mutually anticommute. A central question arises: Can these gapless, highly degenerate spin liquids serve as viable topological subsystem codes for QEC, given that standard topological codes typically rely on a gapped spectrum?

Methodology
The authors propose a general framework for constructing Topological Subsystem Codes directly from ac-Z2 QSL Hamiltonians. The construction follows a specific recipe:

Hamiltonian Selection: Start with an ac-Z2 QSL Hamiltonian defined on a lattice (e.g., square or kagome). These Hamiltonians consist of multi-spin interaction terms (plaquette operators) that share corners rather than edges, leading to anticommutation between neighboring terms.
Identification of Check Operators: The code's check operators (gauge operators) are identified as the minimal weight operators that commute with all local conserved quantities of the spin liquid. In the proposed models, these correspond to the plaquette operators of the Hamiltonian itself (or related Pauli products).
Construction of Stabilizers: Code stabilizers are generated by multiplying the local check operators along cardinal directions (rows and columns) of the lattice. These stabilizers are non-local but commute with all check operators.
Logical Operators: Logical qubit operators are identified as non-local operators that wind around the lattice topology. They must commute with all check operators and stabilizers but mutually anticommute with each other.
Subsystem Definition: The extensive ground state degeneracy of the spin liquid, driven by the anticommuting local conserved operators, defines the gauge degrees of freedom (redundant gauge qubits). These gauge qubits are left undisturbed by the check operator measurements, forming the subsystem aspect of the code.

Key Contributions and Results
The paper presents two concrete examples of this framework, termed Anticommuting Charge (ACC) codes:

Weight-4 Code on a Square Lattice:
- Geometry: Qubits reside on the vertices of a square lattice.
- Operators: The Hamiltonian involves 4-spin plaquette operators ( $X$ and $Z$ types) on corner-sharing plaquettes. The check operators are weight-4 Pauli $X$ , $Z$ , and $Y$ operators on specific plaquettes.
- Parameters: For an $L \times L$ lattice, the code encodes 2 logical qubits with a code distance of $L$ . It uses $L^2$ physical qubits, resulting in an $[L^2, 2, L]$ code.
- Subsystem Feature: The code possesses $n = L^2/2 - 2L + 1$ gauge qubits. The check operators do not commute with each other when sharing corners, allowing for the absorption of errors into the gauge subsystem without affecting logical information.
- Comparison: This construction requires half the physical qubits of the standard toric code for the same number of logical qubits and one-third of the subsystem surface code.
Weight-3 Code on a Kagome Lattice:
- Geometry: Qubits reside on the vertices of a kagome lattice.
- Operators: The Hamiltonian involves 3-spin triangular plaquette operators. The check operators are weight-3 Pauli $X$ and $Z$ operators.
- Parameters: For an $L \times L$ lattice, the code encodes 2 logical qubits with a code distance of $L$ . It uses $3L^2$ physical qubits, resulting in an $[3L^2, 2, L]$ code.
- Comparison: While requiring more physical qubits than the square lattice version, this code utilizes lower-weight (weight-3) check operators, which may be advantageous for specific hardware constraints.

Error Correction Mechanism
The authors detail the error detection and correction procedures for both lattices:

Syndrome Extraction: Non-local stabilizers are measured by sequentially measuring local check operators. Because check operators may anticommute, they are measured in specific sequences (e.g., all $X$ checks, then all $Z$ checks).
Single Qubit Errors: Errors are localized by the intersection of syndrome signals from different stabilizer sets. The presence of gauge qubits allows for multiple correction paths; some corrections may involve applying operators that act non-trivially on the gauge subsystem but leave the logical state invariant.
String Errors: Strings of errors are corrected using Minimum Weight Perfect Matching (MWPM) decoders. The code distance is limited by the lattice size $L$ , as error strings longer than $L/2$ can be misidentified as logical operators.

Significance and Claims
The paper claims that ac-Z2 QSL Hamiltonians provide a natural template for generating a new category of topological subsystem codes. The significance lies in the unification of two distinct concepts:

Topological Order: The number of logical qubits is determined by the global topology of the lattice (e.g., periodic boundary conditions), inheriting the fault tolerance of topological codes against local noise.
Subsystem Flexibility: The codes possess an extensive number of local gauge qubits that are "undisturbed" by check operator measurements. This feature, absent in standard subsystem codes like the Bacon-Shor code (which is not topological), allows for simplified error correction and potentially higher encoding rates.

The authors emphasize that this framework offers geometrical flexibility, allowing for code construction on various lattice types (square, kagome, or other graphs) to suit different quantum hardware connectivities (e.g., IBM's heavy-hex layout or Google's square lattice). They explicitly state that while these codes require weight-3 or weight-4 check operators (unlike weight-2 constructions on trivalent lattices), they offer a distinct advantage in qubit efficiency and topological robustness. The paper concludes by noting that the performance thresholds and specific excitation properties of these ACC codes remain open questions for future research.