The Eastin–Knill theorem is one of the first walls anyone designing a fault-tolerant quantum computer runs into: no quantum code that detects single-qubit errors can have a universal set of transversal logical gates. That is why practical architectures lean on extra machinery such as magic-state factories, lattice surgery or code switching. A new paper by Arpit Dua, Adam Holmes, Michael J. Gullans and Victor V. Albert points out that the theorem constrains one fixed partition of the qubits at a time, and builds a large catalogue of codes that exploit exactly that loophole.
This article was drafted with Claude and fact-checked against the cited primary sources.
What the paper does
The authors construct qubit CSS codes in which every generator of a universal logical gate set is a single depth-one layer of few-qubit gates, followed by ordinary error correction of the same stabilizer code. In their words, there is no magic-state distillation, code switching, gauge fixing or lattice surgery in the generating set. They call such codes depth-one universal.
A layer of disjoint gates that each touch at most ℓ qubits is called ℓ-fold transversal; the usual transversal gate is the case ℓ = 1, where only one partition exists. With ℓ = 2 or more, different layers can respect different partitions of the qubits. The paper notes that layers on any single partition (with parts smaller than the distance) generate only a finite logical group, but layers on several partitions together can generate a universal one. This does not contradict Eastin–Knill; it uses a case the theorem does not cover.
The concrete output is a catalogue of 110 codes, provided as an ancillary JSON file, with 12 to 1369 physical qubits, 1 to 210 logical qubits, distances from 3 to 49 and gate widths from 2 to 10. According to the abstract, 47 of them have depth-one generating sets that tolerate at least one faulty gate per layer, including a [[37,1,7]] and a [[59,1,9]] code with stabilizer checks of weight at most eight.
The key idea: turn seed qubits into parities
The non-Clifford gate is the hard part, and the paper explains where it comes from with a seed–kernel construction. Start with a small “seed” code that already has a non-Clifford logical gate that is diagonal in the computational basis — for example, transversal T on the 15-qubit quantum Reed–Muller code. Add a second “kernel” code (often just qubits in |+⟩ or a few GHZ states) and couple the two with a CNOT circuit.
The CNOTs write each seed qubit’s bit into the parity of a small set of physical qubits. Because a diagonal gate only multiplies basis states by phases that depend on those bits, the same gate evaluated on the parities has exactly the same logical action. A seed’s single-qubit T gates therefore become small multi-qubit gates acting on parities, still in one depth-one layer, while the kernel raises the code distance.
How it works in practice
Two small examples anchor the construction. The 16-qubit tesseract code, a [[16,6,4]] code, gets a universal set from four two-qubit layers on four different partitions: three Clifford layers plus a non-Clifford layer that implements a logical CCZ. The authors show it inherits that layer from the [[8,3,2]] “cube” color code via exactly this parity mechanism. The [[12,2,4]] Carbon code arises from a distance-two seed coupled to a four-qubit kernel; its non-Clifford layer becomes a set of three-qubit gates implementing a logical controlled-S (up to Clifford gates). Both codes only detect a faulty native gate, so they need post-selection.
The construction comes with exact limits. The code distance is at most the gate width times the Z distance of the seed, so the 15-qubit seed with width-three gates caps out at distance 9 — which the [[59,1,9]] codes reach. More importantly for fault tolerance, the partition distance of the parity layer (how many faulty gates it takes to cause a logical error) can never exceed the seed’s Z distance, however large the overall code distance becomes. A distance-three seed thus gives a non-Clifford layer that can correct at most one faulty gate.
The flagship example is a [[37,1,7]] code built from the 15-qubit Reed–Muller seed and a 22-qubit kernel of four GHZ triples and ten |+⟩ qubits. Its generators are a T† parity layer (seven three-qubit and eight two-qubit gates), an S† layer, an X-rotation layer on seven disjoint triples, and a bitwise CNOT between two code blocks. The authors give a flagged syndrome-extraction round on 88 qubits with 192 CNOTs in 12 layers and prove it preserves the circuit distance of 7.
They then simulate this code with Stim and the Tesseract decoder under a neutral-atom-style circuit noise model at two-qubit error rate p = 10−3, with coherence times T1 = 30 s and T2 = 10 s. Reported failure rates are about 3.1 × 10−7 per memory round, 1.0 × 10−6 per CNOT cycle, 3.1 × 10−6 for the X-rotation layer, 2.6 × 10−5 for S† and 2.5 × 10−4 for T†. The single-block S† and T† layers fail roughly 80 and 800 times as often as a memory round, which the authors attribute to their partition distance of only three.
Why it matters
If a computation’s logical gates are each one physical layer plus a syndrome round on a fixed code, the overhead of computing begins to look like the overhead of storing data. That is the long-standing appeal of transversal gates, and this paper shows it is achievable for a universal gate set on concrete, reasonably small codes, with full generating circuits published for reproduction. The paper also offers an intermediate path: if the direct non-Clifford layer is too noisy, the same code can prepare magic states by post-selection. For the [[37,1,7]] code at p = 10−3, about half of the attempts are accepted, and an accepted state is estimated to fail with probability 5.8 × 10−12. The authors stress that this estimate includes fault sets of up to four faults and is not a like-for-like comparison with magic-state cultivation.
Technical perspective (interpretation)
My reading is that the most durable contribution is the bookkeeping, not any single code. The parity picture makes clear why the non-Clifford layer and the code distance can be pulled apart: the kernel buys distance for memory and transversal CNOT, while the seed’s Z distance alone limits the non-Clifford layer. The simulations show exactly this pattern, with memory and CNOT improving markedly from the 37- to the 59-qubit code while the S† and T† layers stay within a factor of three. To make the direct non-Clifford layer competitive, one would therefore need seeds with larger Z distance and low-weight checks at the same time, which is a cleaner target for future searches than “find a better code”.
Limitations and open questions
The direct non-Clifford layer of the 37-qubit code fails at about 2.5 × 10−4 per cycle in simulation, far above its memory error. Any distance-three seed limits the layer to correcting one faulty gate.
The noise model is optimistic by the authors’ own account: three-qubit gates are assumed to fail as often as CNOTs, and the assumed coherence times exceed those measured in the cited experiment. Atom loss, heating during moves, crosstalk, leakage and correlated readout errors are not modelled.
The T† layer requires a classical controller to decode before each layer and apply corrections; in the simulations it misjudges at least one set in about one layer in ten, which dominates the remaining failure.
The [[59,1,9]] results are labelled preliminary. The six codes whose every layer corrects two faulty gates have checks of weight 36 to 96 and have not yet been simulated under circuit-level noise.
All codes with 35 or more logical qubits have checks of weight 32 or more. Whether high-rate, low-weight (qLDPC) depth-one universal families exist is left open.
Paper information
Title: Qubit CSS codes with Universal Transversal Gates
Authors: Arpit Dua (QuEra Computing), Adam Holmes (NVIDIA), Michael J. Gullans (QuEra Computing), Victor V. Albert (Joint Center for Quantum Information and Computer Science, NIST/University of Maryland)
arXiv: 2610.06730v1 [quant-ph], submitted 5 October 2026
Length: 25 pages, 5 figures, 6 tables; ancillary JSON listing all 110 codes with stabilizers, logical operators, depth-one generators, seed and kernel codes, and coupling circuits
Primary sources
Abstract page: arxiv.org/abs/2610.06730
Full text (HTML): arxiv.org/html/2610.06730v1
Ancillary code catalogue: depth_one_universal_codes.json