Quantum Codes with Arbitrary Z-Rotation logical Gates and Applications to Fault-Tolerant Code Switching

AI summary

Overview

Research area: Quantum error correction and fault-tolerant quantum computing, specifically quantum code construction (CSS codes, color codes, triorthogonal/self-orthogonal codes, rotated surface codes), transversal logical gates in the Clifford hierarchy, and fault-tolerant code switching.

Technical level: Advanced. The paper relies on binary linear algebra, divisibility and orthogonality conditions on stabilizer matrices, the Clifford hierarchy, and color-code/topological code geometry.

Scope (one sentence): The paper uses a modified "doubling" construction to build quantum codes admitting transversal logical Z-rotation gates of arbitrarily small angle, extends this to codes with the local geometry of rotated surface codes, and then extends fault-tolerant code switching based on transversal CNOTs to such rotations, demonstrated in a distance-three rotated surface code.

What This Paper Is About

Fault-tolerant code switching usually transfers logical information between a code with transversal Clifford gates and a code with a transversal non-Clifford gate, but existing protocols are essentially confined to color codes and to the logical T gate. The authors ask whether one can systematically construct codes that support arbitrary small Z-rotations R_Z(π/2^r) transversally, and whether such codes can be built with the same local geometry as rotated surface codes so that code switching works on the architectures people actually use. They answer both questions with an explicit recursive family of codes, an overhead-reduction scheme, and a small-footprint circuit-level demonstration.

Key Contributions

1. A recursive family of divisible color codes with arbitrary-order Z-rotation gates. Using a modification of the quantum doubling construction, the authors build a family of 2^r-divisible quantum (color) codes with parameters [[S_r(k), 1, 2k−1]], where S_r(k) = Σ_{i=0}^{r} 2^i · C(i+k−2, i), realizing the logical rotation R_Z(π/2^{r−1}) through transversal action on the data qubits.

2. The same framework beyond color codes, reproducing rotated surface code geometry. They construct a family with parameters [[S_r(k), 1, 2k−1]] that are r-orthogonal and preserve the local geometry of rotated surface codes, with S_r(k) = 2^{r+2}·C(k+r−1, r+1) + Σ_{i=0}^{r−1} 2^i·C(k+i−2, i), yielding self-orthogonal and triorthogonal codes in Table 3 of the paper.

3. An overhead optimization protocol. By carefully concatenating rotated surface codes with punctured rotated surface codes, they obtain more qubit-efficient codes with rotated-surface-code locality, including triorthogonal codes with parameters [[31,1,3]] and [[113,1,5]].

4. An extended fault-tolerant code switching protocol and a small-footprint demonstration. The protocol based on transversal CNOT gates is extended to realize Z-rotation gates at any level of the Clifford hierarchy for geometries compatible with rotated surface codes. The authors report the first demonstration of fault-tolerant magic state preparation by code switching in a distance-three rotated surface code with a total footprint of only 45 physical qubits, evaluated in a circuit-level simulation, preparing S|+⟩ as a proxy for the T|+⟩ magic state.

Main Findings

• Arbitrary-angle transversal rotations are achievable. For each desired rotation angle θ = π/2^r and minimum distance d, the paper provides a code whose logical R_Z(θ) gate is transversal; R_Z(π/2^r) sits at level r+1 of the Clifford hierarchy.

• Lower overhead than prominent color code families. Table 1 compares qubit counts at fixed distance d. The authors' 2D family uses [[(d²+2d−1)/2, 1, d]] qubits versus [[3(d²−1)/4 + 1, 1, d]] for traditional 2D color codes and [[3(d²−1)/2 + 3, 1, d]] for capped color codes; their 3D family uses [[(d³+6d²+5d−6)/6, 1, d]] versus [[(d³+5d²−d−9)/4, 1, d]] (Bravyi–Cross doubled color codes), [[(d³+d)/2, 1, d]] (traditional 3D color codes), [[(d³+3d²+3d−3)/4, 1, d]] (recursive capped color codes), and [[(3d³−3d²+d+3)/4, 1, d]] (stacked codes).

• Small instances match known optimal codes. The codes [[7,1,3]], [[17,1,5]], [[15,1,3]] and [[49,1,5]] appear as the first instances of color codes inside the family. All distance-3 codes presented in that part of the paper are stated to be optimal, having minimum length among all color codes with the property, coinciding with the codes of Koutsioumpas et al.

• Improvement over state-of-the-art triorthogonal codes. The authors report that the family improves upon the parameters of previously known triorthogonal codes and achieves lower qubit overhead than certain known color codes.

• Single-shot decoding of Z-syndromes. Every quantum code produced by the doubling construction is shown to possess Z-type meta-checks, making the family viable for single-shot decoding of Z-syndromes.

• A generalized doubling theorem. Theorem III.1 combines an [[n₁,1,d₁]] and an [[n₂,1,d₂]] code of odd length, both with the all-ones vector as logical X, into a code with parameters [[2n₁+n₂, 1, min{(d₁)_z, (d₂)_z+2}]]; if 2^{r−1} and 2^r divide the X-stabilizer weights of the two inputs, the result has a transversal π/2^{r−1} Z-rotation. Corollary III.2 specializes this to grow a self-orthogonal code from [[n,1,d]] to [[n+2(d+2), 1, d+2]], where d+1 stabilizer generators have weight four, one has weight 2d+2, and the rest inherit the weights of the original code.

• Parity structure is inherited. The new code from Corollary III.2 is doubly-even if and only if the input code is doubly-even.

• Distance-three demonstration feasibility. A complete circuit-level simulation of code switching in a d = 3 rotated surface code requires only 45 physical qubits. (The excerpt provided does not report the numerical error-rate or fidelity results of that simulation.)

Methodology in Plain English

The core tool is the doubling construction: take a smaller quantum code that already has the desired gate property, take a second, self-orthogonal code, and glue them together in a block-structured stabilizer matrix whose blocks are the original stabilizer generators, zero blocks, and all-ones blocks. Careful bookkeeping on the Hamming weights of these rows shows how the new distance grows and whether the new code supports a transversal rotation. By applying the gluing recursively, each round roughly doubles the divisibility of the stabilizer weights, which is exactly what is required to push the transversal gate one level deeper into the Clifford hierarchy.

The authors then prove the weight conditions needed for transversality from the criterion of Webster and Leitch (stated as Theorem II.5): the logical X operator must have odd weight, every X-stabilizer weight must be divisible by 2^r, and Schur products of up to r stabilizer/logical vectors must have weight divisible by 2^{r−s+1}. Divisible codes automatically satisfy this, which is why the construction targets divisibility.

To move from abstract color codes to hardware-relevant layouts, the authors modify the block structure so that the resulting stabilizers have the local connectivity of rotated surface codes, then reduce the qubit count by concatenating rotated surface codes with punctured rotated surface codes. Finally, they design a switching protocol that fault-tolerantly moves logical information between the two code geometries via transversal CNOTs, and simulate the whole process, including the state preparation, at circuit level for distance three.

Why This Matters

Impact on research. Code switching has been argued to offer the smallest qubit footprint and lowest single-attempt cost among non-Clifford resource methods, but it was bottlenecked by the near-exclusive reliance on color codes and on the T gate. This work supplies a systematic generator of ingredient codes at any Clifford-hierarchy level and, crucially, in rotated-surface-code geometry, opening code switching to the dominant experimental architecture. It also supports the Clifford+R_Z(θ) gate set, motivated by evidence that small Z-rotations may be substantially cheaper than assumed and that such decompositions need fewer elementary gates, shallower non-Clifford depth, and no extra ancillas.

Applications:

• Fault-tolerant preparation of magic states at low qubit cost (demonstrated at 45 physical qubits for d = 3).
• Efficient decomposition of multi-controlled Toffoli and other complex gates, which otherwise require ancillas and deep Clifford+T sequences.
• Supply of code families with tunable distance, geometry and rotation angle for magic state distillation and magic state cultivation pipelines.
• Deployment on surface-code hardware, since the constructed codes inherit rotated surface code locality.

Industry relevance. One author is affiliated with Hitachi Cambridge Laboratory, and the target geometry (rotated surface codes) is the architecture pursued by major quantum hardware programs, so the results are aimed at near-term device constraints rather than only asymptotic coding theory.

Future Directions

• Extending the switching protocol and the code families to other code geometries and local connectivities beyond color codes and rotated surface codes, as the authors suggest the idea generalizes to "other quantum codes of interest."
• Demonstrating the protocol at distances beyond d = 3; the reported simulation covers only the distance-three case with 45 physical qubits.
• Determining whether the overhead optimization via concatenated and punctured rotated surface codes can be pushed further to reduce the [[31,1,3]] and [[113,1,5]] footprints or to reach larger distances at competitive cost.
• Combining these ingredient codes with magic state cultivation and distillation, and carrying out the fair resource comparison across the three non-Clifford approaches that the paper notes is currently difficult because of differing noise models, decoders and post-selection assumptions.

Target Audience

Researchers in quantum error correction and fault-tolerant quantum computing, particularly those working on transversal gate constructions, triorthogonal and divisible codes, color codes, and code switching protocols. It is also relevant to architects and experimentalists planning surface-code-based hardware who need concrete qubit-footprint numbers for non-Clifford resource generation, and to graduate students with a coding-theory background who are entering fault-tolerant quantum computing. Readers without familiarity with CSS codes, stabilizer formalism and the Clifford hierarchy will find the main text demanding.

Authors’ abstract

A technique for realizing a universal set of fault-tolerant quantum operations is the code switching method, which leverages two quantum codes with complementary sets of transversal gates. To date, the application of this technique has been largely limited to families of color codes supporting a logical $T$ gate. No analogous code switching protocols exist for many other prominent families, such as rotated surface codes, or for finer $Z$-rotation gates. In this work, we first utilize the doubling technique as a unified framework to construct a class of quantum color codes encoding a single logical qubit with an arbitrarily large minimum distance, enabling the transversal realization of arbitrary small logical $Z$-rotation gates. We investigate the structural properties of this code family, demonstrating that they improve upon the parameters of state-of-the-art triorthogonal codes, achieve lower qubit overhead compared to certain known color codes, and admit single-shot decoding of $Z$-syndromes via meta-checks. Furthermore, we show that this framework extends beyond color codes; specifically, it enables the generation of $r$-orthogonal quantum codes, $r \ge 2$, that inherit the local geometry of rotated surface codes. We then provide an overhead optimization protocol alongside several candidate codes tailored for realizing logical $Z$-rotation gates within rotated surface codes. Finally, we extend the fault-tolerant code switching protocol based on transversal CNOT gates to incorporate fault-tolerant realization of $Z$-rotation gates at any level of the Clifford hierarchy for geometries compatible with rotated surface codes. We present the first demonstration of fault-tolerant magic state preparation by means of code switching within a distance-three rotated surface code using a total footprint of only 45 physical qubits, and evaluate its performance through a simulation.