⚛️ quantum physics

Beyond transversality: structure of Clifford circuits for CSS codes

This paper characterizes the structure of code-preserving Clifford circuits for CSS codes by decomposing them into specific diagonal and permutation layers, defining a "two-fold transversal" group that generates the full logical Clifford group for numerous code families, and demonstrating that even larger logical groups can be achieved through depth-one two-local circuits.

Original authors: Victor V. Albert

Published 2026-08-07

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Victor V. Albert

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 Quantum Puzzle: Why We Need Better Locks and Keys

Imagine you are trying to build a computer that can solve problems impossible for any machine today. This is the dream of quantum computing. But there's a catch: the tiny particles (qubits) that hold the information are incredibly fragile. A sneeze, a temperature change, or even a stray cosmic ray can scramble the data, causing the computer to crash. To fix this, scientists use "error correction," wrapping a single piece of logical information inside a massive, redundant web of physical particles. This web is called a "code."

However, there's a second problem. To do math, you need to perform operations (gates) on these logical pieces of information. But if you touch the physical particles to do the math, you might accidentally introduce the very errors you are trying to fix. The holy grail of quantum engineering is finding "fault-tolerant" operations: ways to do math that naturally keep errors contained, like a fireproof room that stops a spark from becoming a blaze. For a long time, the only reliable way to do this was to use "transversal" gates, where you touch every physical particle exactly once, in a very strict, one-to-one pattern. But this method is like trying to build a skyscraper using only a hammer; it's safe, but it can only build very simple shapes. It turns out that for many codes, this strict method simply cannot perform all the necessary math.

The Paper's Discovery: Unlocking the Quantum Toolbox

In this paper, Victor V. Albert explores a new way to build these fault-tolerant operations. Instead of sticking to the strict "one-touch" rule, the author asks: What if we allow ourselves to touch pairs of particles at the same time, but only in a single, organized layer? He calls this the "two-fold transversal" approach. Think of it like a dance floor. The old "transversal" rule said everyone must dance alone, never touching a partner. The new "two-fold" rule allows everyone to find a partner and dance a two-step, as long as they don't get tangled up in a complex, multi-layered routine.

The paper's main finding is a set of "recipes" (mathematical structures) that describe exactly which of these partner-dances are allowed without breaking the code. The author proves that for a huge class of quantum codes (called CSS codes), you don't need a magic wand to perform any logical operation. Instead, you only need to combine three simple types of moves:

Z-diagonal circuits: A specific type of phase-shifting move.
X-diagonal circuits: The mirror-image version of the first move.
CNOT circuits: A swapping or flipping move between pairs.

The author shows that by mixing these three ingredients, you can generate every possible logical operation needed for a quantum computer. It's like discovering that you don't need a thousand different tools to build a house; you just need a hammer, a saw, and a screwdriver, used in the right combinations.

The "Full" Codes and the Search for the Perfect Match

The paper doesn't just stop at theory; it goes on a massive numerical treasure hunt. The author wrote a computer program to test 136 different quantum codes to see which ones could perform the "full" set of logical operations using these new partner-dance rules. The results were exciting: they found 78 codes that are "full," meaning they can do any logical Clifford operation (the standard set of quantum math) using just these simple, single-layer partner moves.

These 78 codes are a mix of sizes and shapes. Some are small, like the [[10, 2, 3]] code, while others are much larger. The paper lists specific examples, such as the [[16, 6, 4]] "tesseract" code and the [[18, 4, 4]] color code. For these codes, the author provides the exact "generators" (the starting moves) needed to build the entire library of operations. This is a big deal because it proves that we don't need to invent complex, multi-step circuits to get powerful quantum computers; sometimes, a single, well-organized layer of two-qubit interactions is enough.

When the Dance Floor Gets Crowded: Permutations and Automorphisms

The paper also tackles a trickier scenario: what if you are allowed to physically move the qubits around (swap their positions) while you are doing the math? In some quantum computers, moving particles is cheap and easy. The author introduces a new group called the "two-fold automorphism group." This group allows for circuits that might break the code unless you immediately swap the qubits to fix it.

The author finds that this new group is even more powerful than the standard "two-fold transversal" group. In fact, for some codes, the standard group cannot perform certain operations, but the new group can, simply by adding a permutation (a swap) to the mix. The paper provides a "normal form" (a standard way to write down these operations) for this group, showing that any such operation can be broken down into a specific sequence: a partial swap (Hadamard), a permutation, and two diagonal circuits.

The Limits and the Future

While the paper is a success story, it also sets clear boundaries. The author explicitly rules out the idea that every code can be made "full" just by adding these two-qubit moves. Some codes simply don't have the right structure. The paper also clarifies that while the "two-fold transversal" group can generate all logical operations for the 78 codes found, it is not the same as the group of all possible code-preserving circuits. There are still some complex, deep circuits that cannot be compressed into a single layer of these moves.

The author also notes that for some codes, like the "gross code" (a large [[144, 12, 12]] code), the group of operations is huge but not "full." It contains at least 460,800 distinct logical gates, which is a massive number, but still far smaller than the total number of possible gates for that code. Similarly, for a "clustered-cyclic" code, the number of reachable gates is roughly 10^26. These numbers are impressive, but they show that we are still exploring the landscape, not that we have mapped the entire continent.

The Big Picture

In summary, this paper provides a map and a toolkit for building fault-tolerant quantum computers. It proves that for a wide variety of codes, the complex problem of performing quantum math can be reduced to combining three simple types of moves. It identifies 78 specific codes that can do everything we need using these moves, and it shows how to expand our toolkit by allowing qubit swaps. The work is a mix of rigorous mathematical proof (showing why these moves work) and extensive computer simulation (showing which codes work). It doesn't claim to have solved quantum computing, but it gives engineers a much clearer path forward, suggesting that the key to powerful, error-free quantum computers might lie in simple, organized layers of interaction rather than complex, deep circuits.

Technical Summary: Beyond Transversality: Structure of Clifford Circuits for CSS Codes

Problem Statement

Fault-tolerant quantum computation relies heavily on Calderbank–Shor–Steane (CSS) codes due to their naturally fault-tolerant syndrome extraction and logical gates. While transversal gates (depth-one, one-local operations) are the most fault-tolerant, they are severely restricted in the set of logical operations they can realize. Increasing locality to depth-one two-local gates (two-fold transversal) or increasing circuit depth allows for richer gate sets, potentially realizing the full logical Clifford group. However, the structural relationship between these specific circuit constructions and the full group of code-preserving Clifford circuits has remained under-characterized. There is a need to determine the minimal set of generators for these groups, understand their decomposition, and identify which CSS codes admit the full logical Clifford group via restricted locality circuits.

Methodology

The paper employs a symplectic formalism to analyze Clifford circuits modulo Pauli operators and global phases. A CSS code is defined by two orthogonal classical binary codes, $C_X$ and $C_Z$ , which form the "label space" $C = (C_X | 0) \oplus (0 | C_Z)$ within the $2n$ -dimensional symplectic space.

The author organizes code-preserving circuits into four distinct families based on their symplectic block structure and physical gate ingredients:

Z-diagonal circuits ( $S_Z$ ): Circuits composed of $\sqrt{Z}$ and CZ gates, corresponding to the upper-right block of the symplectic matrix.
X-diagonal circuits ( $S_X$ ): Circuits composed of $\sqrt{X}$ and $CZH$ (Hadamard-conjugated CZ) gates, corresponding to the lower-left block.
CNOT circuits ( $L$ ): Networks of CNOT and SWAP gates, corresponding to the diagonal blocks of the symplectic matrix.
Partial dualities ( $W$ ): Circuits involving Hadamard gates on subsets of qubits followed by permutations.

The analysis proceeds by:

Deriving linear conditions on the parameters of these families (e.g., symmetric matrices $S$ and $T$ ) required to preserve the code.
Utilizing results from symplectic geometry and representation theory to prove generation theorems.
Defining specific subgroups: the transversal group ( $N_\emptyset$ ), the two-fold transversal group ( $N_{2\text{fold}}$ ) generated by depth-one two-local layers over arbitrary matchings, and the automorphism group ( $\text{Aut}(C)$ ) including permutations.
Conducting numerical experiments on 136 CSS codes (including QLDPC families) to determine the logical image of the two-fold transversal group.

Key Contributions

1. Structural Decomposition of Code-Preserving Groups

The paper establishes that for any non-trivial CSS code (where $C_X, C_Z \neq 0$ ), the entire group of code-preserving Clifford circuits ( $N$ ) is generated solely by the Z-diagonal and X-diagonal families.

Theorem: $N = \langle S_Z, S_X \rangle$ .
This implies that any code-preserving Clifford operation, regardless of depth or locality, can be decomposed into a product of these two diagonal families. Since the conditions for these families are linear, the entire group is efficiently determinable via Gaussian elimination.

2. Normal Forms and Decompositions

The author provides explicit normal forms for various circuit groups:

Transversal Group ( $N_\emptyset$ ): Every transversal gate can be expressed as a product of at most three diagonal layers ( $Z$ - $X$ - $Z$ ). For connected, non-self-dual codes, two layers suffice.
Two-Fold Transversal Group ( $N_{2\text{fold}}$ ): Every code-preserving depth-one two-local layer on a fixed matching is generated by diagonal circuits and CNOT layers supported on that matching. Consequently, $N_{2\text{fold}}$ is generated by the union of these families over all possible matchings.
Automorphism Group ( $\text{Aut}(C)$ ): The group of single-qubit Cliffords and permutations has a normal form consisting of one partial duality (Hadamard + permutation) followed by two transversal diagonal circuits.

3. Numerical Identification of "Full" Codes

The author performed numerical searches to identify CSS codes where the two-fold transversal group realizes the full logical Clifford group ( $\text{Sp}(2k)$ ).

Results: They identified 78 indecomposable CSS codes with this property. These include codes with distances $d \in \{3, 4, 5, 6, 8, 12\}$ and rates up to $3/4$ .
Addressable Gates: Several of these codes allow for the implementation of canonical logical gates (e.g., logical $\sqrt{Z}$ , $\sqrt{X}$ , CZ) using a single depth-one two-local physical layer without compilation.
Infinite Families: The paper constructs and analyzes six infinite families of codes (including middle Reed–Muller, quantum logic, symplectic doubles, cut-complements, bipartite grids, and quadric towers) that contain many full-Clifford codes.

4. Logical Image Lower Bounds

For codes that do not realize the full logical Clifford group, the paper provides lower bounds on the size of the logical image of the two-fold transversal group.

The bounds span 41 orders of magnitude.
Notable examples include the gross code ( $[[144, 12, 12]]$ ) with a logical image of at least $460,800$, and a clustered-cyclic code with a logical image of roughly $10^{26}$ .

5. The Two-Fold Automorphism Group

The paper defines a new group, the two-fold automorphism group, where depth-one two-local circuits are allowed to compensate for qubit permutations. The author shows this group can be strictly larger than the union of the automorphism group and the two-fold transversal group, offering a new avenue for fault-tolerant gates in architectures where permutations are cheap.

Significance and Claims

The paper claims to provide a fundamental structural understanding of fault-tolerant logical operations for CSS codes. Its primary significance lies in:

Unification: It unifies disparate circuit constructions (transversal, fold-transversal, CNOT networks) under a single algebraic framework generated by diagonal circuits.
Efficiency: It demonstrates that the complex problem of finding code-preserving circuits can be reduced to solving linear systems (Gaussian elimination) for diagonal parameters.
Feasibility of Full Clifford Groups: It provides concrete evidence that the full logical Clifford group is accessible via depth-one two-local circuits for a wide variety of practical CSS codes, including low-density parity-check (QLDPC) codes, challenging the notion that full Clifford groups require deep circuits or non-Clifford resources.
Optimization Potential: By characterizing the "fiber" of physical circuits mapping to a single logical gate (via stabilizer relabeling and padding), the paper outlines a resource for optimizing circuit depth and volume without altering the logical operation.

The author explicitly states that while they characterize the groups and provide generators, the optimization of specific circuits for gate count, depth, and fault propagation remains a task for future platform-dependent analyses. They also note that their generation results rely on the CSS structure (split label space) and may not directly generalize to non-CSS stabilizer codes without modification.