Rotated Surface Code

• Rotated Surface Code is a planar CSS code obtained by a 45° rotation or puncturing, which reduces qubit counts while preserving a high code distance.
• It employs local weight-4 bulk checks with reduced boundary stabilizers and a tailored 4-layer CNOT schedule for efficient syndrome extraction and error suppression.
• Its resource-efficient design and compatibility with various decoding strategies make it ideal for hybrid architectures and fault-tolerant quantum computation.

The rotated surface code is a planar CSS surface code obtained either as a conceptual $45^\circ$ reorganization of the standard planar surface code or, from a coding-theoretic perspective, as a punctured version of it. In the square case it has parameters $[[d^2,1,d]]$; in the rectangular case it has parameters $[[d_X d_Z,1,d_X/d_Z]]$. Its bulk stabilizers are local weight-4 $X$-type and $Z$-type operators, its boundary stabilizers are reduced-weight operators, and its logical operators are strings connecting like boundaries. This combination of planar locality and reduced qubit footprint is the reason it has become a standard reference point for both architectural and algorithmic work on fault-tolerant quantum computation (O'Rourke et al., 2024, Forlivesi et al., 2023).

1. Geometric definition and code parameters

For the square family, the defining parameter relation is

$[[d^2,1,d]],$

so a distance-$d$ rotated patch encodes one logical qubit into $d^2$ data qubits. In the rectangular case, the corresponding family is

$[[d_X d_Z,1,d_X/d_Z]],$

with asymmetric $X$- and $[[d^2,1,d]]$0-distances $[[d^2,1,d]]$1 and $[[d^2,1,d]]$2 (Forlivesi et al., 2023).

The geometry can be described in two equivalent ways that both appear in the literature. One description starts from the standard planar surface code and removes corner qubits, leaving a diamond-shaped patch that is then redrawn as a $[[d^2,1,d]]$3-rotated lattice. Another description treats the rotated code as the planar code after a conceptual $[[d^2,1,d]]$4-style reorganization that realizes the same nominal distance with a denser patch (Higgott et al., 2020, O'Rourke et al., 2024).

A useful operational distinction from the unrotated planar code is the total qubit count at fixed distance when ancillas are included. The rotated code uses $[[d^2,1,d]]$5 data qubits and $[[d^2,1,d]]$6 auxiliaries, for a total of

$[[d^2,1,d]]$7

whereas the unrotated code uses $[[d^2,1,d]]$8 data qubits and $[[d^2,1,d]]$9 auxiliaries, for a total of

$[[d_X d_Z,1,d_X/d_Z]]$0

For the $[[d_X d_Z,1,d_X/d_Z]]$1 rotated code this gives $[[d_X d_Z,1,d_X/d_Z]]$2 data qubits and $[[d_X d_Z,1,d_X/d_Z]]$3 ancilla qubits, i.e. $[[d_X d_Z,1,d_X/d_Z]]$4 physical qubits (O'Rourke et al., 2024, Varsamopoulos et al., 2019).

The stabilizer structure is the standard CSS one. In the square case, generators have weight $[[d_X d_Z,1,d_X/d_Z]]$5 or $[[d_X d_Z,1,d_X/d_Z]]$6 rather than $[[d_X d_Z,1,d_X/d_Z]]$7 or $[[d_X d_Z,1,d_X/d_Z]]$8, with weight-4 bulk checks and weight-2 boundary checks. Logical $[[d_X d_Z,1,d_X/d_Z]]$9 is a chain of $X$0s connecting rough boundaries, and logical $X$1 is a chain of $X$2s connecting smooth boundaries on the dual lattice. Some works state the same content in boundary-language, others simply describe logical $X$3 and $X$4 as products of Pauli operators along connected paths joining opposite boundaries (Forlivesi et al., 2023, Haruna et al., 24 May 2025).

2. Syndrome extraction, locality, and circuit-level geometry

The rotated surface code is designed for local syndrome extraction. Data qubits are coupled to local ancillas that measure alternating $X$5- and $X$6-type checks, and a common implementation pattern uses a 4-layer CNOT schedule for one syndrome-extraction round. In compact rotated layouts, the $X$7-ancillas and $X$8-ancillas occupy different diagonal lines, a feature exploited directly in neutral-atom addressing schemes (Chen et al., 2024).

At circuit level, the CNOT order matters. A valid ordering must preserve mutual commutation of stabilizer measurements, allow parallel execution to avoid unnecessary idle errors, and, in the rotated code, avoid hook errors. Hook errors are propagated single faults that become weight-2 correlated data errors aligned with a logical direction; if the ordering is chosen badly, they can effectively halve the number of faults needed to form a logical operator. This dependence on schedule is a central difference between abstract code distance and circuit distance (O'Rourke et al., 2024).

Recent work has therefore focused on schedule design as a first-class component of rotated-surface-code fault tolerance. One proposal is the diagonal schedule, which orders ancilla-data interactions so that hook errors lie along plaquette diagonals instead of horizontal or vertical directions. On hardware supporting parallel measurement, reset, and gate operations, this gives a period of $X$9 time steps instead of $Z$0 for the traditional mixed $Z$1- and $Z$2-shaped approach, while preserving full circuit-level distance in memories and several surgery-like geometries (Kishony et al., 9 Feb 2026).

Interface geometry produces an analogous issue. For rotated patches, a naive straight boundary between modules can split a weight-4 stabilizer $Z$3–$Z$4 across the interface, creating dangerous boundary-parallel hook errors. A zigzag interface removes this pathology and allows direct noisy links, gate teleportation, and CAT-state gadgets to preserve full code distance for both $Z$5 and $Z$6, even when interface CNOTs are much noisier than bulk gates (Shalby et al., 6 Mar 2025).

3. Decoding and logical-error inference

Because the code is CSS, many decoding strategies treat $Z$7 and $Z$8 components independently. In the simplest picture, the syndrome is the collection of parity-check values from a surface-code cycle, or, under repeated extraction, the set of detection events formed by changes relative to the previous cycle (Varsamopoulos et al., 2019).

The standard circuit-level baseline in recent comparisons is minimum-weight perfect matching. In a detailed rotated-versus-unrotated comparison, memory experiments were simulated with Stim, decoded with PyMatching 2, and analyzed under circuit-level depolarizing and superconducting-inspired noise. That work showed that fair comparison requires matching at equal logical error rate rather than equal distance, because the unrotated code can have lower $Z$9 at fixed $[[d^2,1,d]],$0 even though the rotated code uses fewer qubits (O'Rourke et al., 2024).

A large decoder literature now specializes to the rotated code. One line uses neural-network methods. A distributed neural decoder decomposes a larger rotated lattice into overlapping $[[d^2,1,d]],$1 rotated tiles, computes local logical-class probabilities $[[d^2,1,d]],$2 on each tile, and then feeds those summaries into a global network. For $[[d^2,1,d]],$3, this gave decoding performance similar to Blossom and to an earlier full-lattice neural decoder while avoiding direct learning over exponentially large syndrome spaces (Varsamopoulos et al., 2019).

Another line targets hardware-friendly low-complexity decoding. Progressive-Proximity Bit-Flipping (PPBF) adapts bit-flipping to the rotated planar code by using a proximity heuristic, a degeneracy-aware matching post-processing stage, and virtual boundary checks for open boundaries. Under a binary symmetric channel with perfect syndrome measurements, it reports a threshold of $[[d^2,1,d]],$4 for the rotated planar code (Pacenti et al., 2024).

At the opposite end of the design space are hybrid or hierarchical decoders. In a confidence-gated decoder for the rotated surface code under circuit-level depolarising noise, a feed-forward neural network handles most syndromes while low-confidence cases are escalated to MWPM. At $[[d^2,1,d]],$5, routing only $[[d^2,1,d]],$6 of syndromes to the refinement stage at confidence threshold $[[d^2,1,d]],$7 gives end-to-end accuracy $[[d^2,1,d]],$8, while routing $[[d^2,1,d]],$9 at threshold $d$0 gives $d$1; the abstract summarizes the overall gain as an improvement from $d$2 to $d$3 while routing only $d$4 of syndromes to MWPM (Chongder, 7 Jul 2026).

The rotated code also appears as a soft-information front end for concatenated architectures. In a hierarchical construction with a distance-5 rotated inner code, the $d$5 patch is decoded exactly by lookup table, and the syndrome-conditioned logical error probability

$d$6

is passed upward as a prior for BP-OS decoding on a hypergraph-product outer code. That use of exact block-level soft information is specific to the small rotated patch and is one reason the inner code is fixed to $d$7 in that design (Haruna et al., 24 May 2025).

4. Resource tradeoffs and comparative performance

At fixed distance, the rotated code asymptotically uses about half as many qubits as the unrotated planar code, but equal distance is not the right engineering comparison. Under circuit-level noise and worst-case unrotated ordering, thresholds are essentially equal by inspection,

$d$8

yet the rotated code still wins at equal logical error rate because of its smaller qubit footprint (O'Rourke et al., 2024).

The headline equal-$d$9 comparison is concrete. At $d^2$0 and target $d^2$1, the rotated code uses $d^2$2 qubits under standard depolarizing noise versus $d^2$3 for the unrotated code, a ratio of $d^2$4. Under superconducting-inspired noise the corresponding numbers are $d^2$5 and $d^2$6, a ratio of $d^2$7. Rounded to realizable distances, the comparison is $d^2$8, $d^2$9 qubits for rotated versus $[[d_X d_Z,1,d_X/d_Z]],$0, $[[d_X d_Z,1,d_X/d_Z]],$1 qubits for unrotated, i.e. $[[d_X d_Z,1,d_X/d_Z]],$2 (O'Rourke et al., 2024).

Low-$[[d_X d_Z,1,d_X/d_Z]],$3 analytical work reaches a compatible conclusion from a different angle. For the rotated $[[d_X d_Z,1,d_X/d_Z]],$4 and standard $[[d_X d_Z,1,d_X/d_Z]],$5 surface codes under depolarizing noise, the rotated code has worse $[[d_X d_Z,1,d_X/d_Z]],$6 but a smaller block length. The asymptotic comparison ratio is

$[[d_X d_Z,1,d_X/d_Z]],$7

so the rotated $[[d_X d_Z,1,d_X/d_Z]],$8 is asymptotically better than the original $[[d_X d_Z,1,d_X/d_Z]],$9 on that channel (Forlivesi et al., 2023).

Under highly biased noise the rotated code acquires a stronger distinction. For odd rotated $X$0 codes under pure $X$1 noise, there is exactly one nontrivial $X$2-type logical operator,

$X$3

so

$X$4

The same work proves a $X$5 threshold for pure $X$6 noise, equivalent to the tailored-code pure-dephasing setting, and shows that the same logical failure rate achievable with a square surface code using $X$7 physical qubits can be obtained with a co-prime or rotated surface code using only $X$8 physical qubits (Tuckett et al., 2018).

The main caveat in biased-noise optimization concerns the XZZX modification on rectangular lattices. For square lattices, rotation plus XZZX can be highly effective; for rectangular rotated codes, however, adding XZZX can collapse

$X$9

to

$[[d^2,1,d]]$00

as illustrated by the rotated $[[d^2,1,d]]$01 code going from $[[d^2,1,d]]$02 to $[[d^2,1,d]]$03. On rectangular lattices designed to exploit asymmetry, the simultaneous use of rotation and XZZX can therefore be suboptimal (Forlivesi et al., 2023).

5. Encoding, logical gates, and experimental realizations

The rotated surface code has become a target for explicit low-depth encoders. An early local-unitary construction gives a rotated-code encoder with depth $[[d^2,1,d]]$04, built from a 4-step inductive rule that increases distance by $[[d^2,1,d]]$05 (Higgott et al., 2020). A later construction improves this substantially: it gives nearest-neighbor square-grid encoding circuits of depth

$[[d^2,1,d]]$06

using a depth-4 base encoder for $[[d^2,1,d]]$07, a depth-2 base encoder for $[[d^2,1,d]]$08, and a depth-2 growth circuit for each $[[d^2,1,d]]$09 step. Within the inductive-growth framework, the paper proves that depth $[[d^2,1,d]]$10 is optimal (Claes, 11 Sep 2025).

Nonlocal unitary encoding has also been formulated directly in terms of rotated patches. A code-conversion chain

$[[d^2,1,d]]$11

produces a depth-4 distance-doubling step and hence total depth

$[[d^2,1,d]]$12

for $[[d^2,1,d]]$13, while preserving compatibility with standard MWPM decoding after one perfect syndrome round (Tsai et al., 4 Jun 2025).

Logical Clifford gates have been worked out particularly explicitly on neutral-atom hardware. For the logical Hadamard, one applies transversal $[[d^2,1,d]]$14 to all data qubits and then rotates the patch by $[[d^2,1,d]]$15, implemented as two reflections using horizontal and diagonal 2D-AODs. For the logical $[[d^2,1,d]]$16 gate, the key observation is that after two CNOT layers of rotated-code syndrome extraction, the joint data-plus-ancilla state becomes an unrotated surface-code state at half-cycle; a fold-transversal $[[d^2,1,d]]$17 is inserted at that point, and the remaining two CNOT layers return the system to the rotated-code representation. Together with transversal logical CNOT, this yields a logical Clifford generating set $[[d^2,1,d]]$18 on rotated patches (Chen et al., 2024).

These constructions have begun to appear experimentally. On a 107-qubit superconducting processor, key elements of patch-based logical processing were demonstrated on distance-3 rotated XZZX surface-code patches with repeated syndrome extraction, neural-network decoding, and no post-selection. The primitive layer comprised merge and split, patch expansion and shrinkage, and deformations mediated by domain walls and twist defects; these were then composed into logical state routing, CNOT, Hadamard, and phase gates (Lin et al., 1 Jul 2026).

6. Rotated surface codes in hybrid architectures and current limitations

A striking recent role for the rotated surface code is as a hardware-local inner code inside higher-rate architectures. In a two-level concatenated construction with a random hypergraph-product outer code and a distance-5 rotated inner code, each outer-code qubit is replaced by one $[[d^2,1,d]]$19 rotated block. For upper-layer parameters $[[d^2,1,d]]$20, the full concatenated code has parameters

$[[d^2,1,d]]$21

The main practical regime identified is

$[[d^2,1,d]]$22

where the hierarchical code is reported to outperform a standalone rotated surface code in both qubit efficiency and logical error rate (Haruna et al., 24 May 2025).

A related but distinct architecture is the Hierarchical Logical Processor, which again keeps the rotated surface code as the level-0 substrate. Ordinary square rotated patches act as cores, while elongated rotated patches of width $[[d^2,1,d]]$23 and length $[[d^2,1,d]]$24 act as shuttle buses. These buses support hybrid-unit CNOTs between one bus and up to $[[d^2,1,d]]$25 cores, so long-range connectivity is needed only once every $[[d^2,1,d]]$26 rounds of level-0 error correction. At physical error rate $[[d^2,1,d]]$27, an HLP based on the $[[d^2,1,d]]$28 code achieves $[[d^2,1,d]]$29–$[[d^2,1,d]]$30 times higher qubit efficiency than the standard RSC, and compared with the yoked surface code on the same level-1 code it reduces space overhead per logical qubit by $[[d^2,1,d]]$31–$[[d^2,1,d]]$32 physical qubits and shortens the logical error-correction cycle time by a factor of $[[d^2,1,d]]$33–$[[d^2,1,d]]$34 (Chen et al., 21 Jun 2026).

Magic-state preparation has likewise been costed directly on rotated patches. A recursive implementation of 15-to-1 distillation on the rotated surface code gives $[[d^2,1,d]]$35 preparation on a $[[d^2,1,d]]$36-by-$[[d^2,1,d]]$37 grid of data qubits for up to $[[d^2,1,d]]$38 error-correction cycles, and $[[d^2,1,d]]$39 preparation on a $[[d^2,1,d]]$40-by-$[[d^2,1,d]]$41 grid for up to $[[d^2,1,d]]$42 cycles. The same analysis, however, shows that matching the output magic-state error to the logical error rate of the surrounding rotated-code computation at large distance requires a significantly lower physical error threshold than that of the underlying surface code itself (Moussa, 5 Mar 2026).

The modern literature also makes the limits of current evidence explicit. Some decoder and hierarchy studies still use perfect syndrome extraction or noiseless syndrome measurements, notably the distributed neural decoder, PPBF, and the hierarchical HGP–rotated construction (Varsamopoulos et al., 2019, Pacenti et al., 2024, Haruna et al., 24 May 2025). Conversely, circuit-level studies reveal schedule sensitivity, interface-specific hook effects, and basis-dependent anisotropies that do not appear in code-capacity models. This suggests that the rotated surface code should be understood not merely as a static $[[d^2,1,d]]$43 family, but as a patch-based computational substrate whose practical behavior is determined jointly by geometry, extraction schedule, decoder, and the surrounding architecture (O'Rourke et al., 2024, Kishony et al., 9 Feb 2026).