Rectangular Surface Code Overview

• Rectangular surface code is defined on a 2D rectangular lattice, offering geometric locality and flexible boundary conditions to encode logical qubits.
• Its encoding circuits employ iterative thickening and local CNOT sequences to achieve depth-optimal implementations that meet theoretical lower bounds.
• The design features robust syndrome extraction and adaptive techniques for hardware defects, ensuring reliable quantum error correction on planar and Majorana-based systems.

The rectangular surface code is a family of quantum error-correcting codes implemented on rectangular subregions of the 2D square lattice. Its defining features are geometric locality, high noise threshold, straightforward compatibility with planar and Majorana-based hardware, and flexible boundary conditions that encode one or more logical qubits. The rectangular variant generalizes the canonical planar (square) surface code to arbitrary rectangular lattice geometries, with explicit methodologies for optimal encoding circuits, boundary manipulation, and syndrome extraction protocols (Higgott et al., 2020, Grans-Samuelsson et al., 2023).

1. Lattice Geometry and Boundary Conditions

A rectangular surface code is defined on a $W \times H$ region of the square lattice, with $W, H \geq L$ and code distance $L = \min(W, H)$. Physical (data) qubits are placed on the edges of this rectangular grid. Horizontal edges are labeled by $(i+\tfrac{1}{2}, j)$ where $i=0$ … $W-1$ and $j=1$ … $H-1$, and vertical edges by $(i, j+\tfrac{1}{2})$ with $i=1$ … $W-1$ and $j=0$ … $H-1$.

The code employs two types of boundary segments:

• "Smooth" (X-type) boundaries placed along the top ($j=H$) and bottom ($j=0$)
• "Rough" (Z-type) boundaries along the left ($i=0$) and right ($i=W$)

This boundary configuration supports encoding one logical qubit, with explicit logical operators: $$\bar{Z} = \prod_{j=1}^H Z_{(x=1/2, j)}, \qquad \bar{X} = \prod_{i=1}^W X_{(i, y=1/2)}$$ The encoded logical operators traverse the full minimal dimension of the rectangle and transform as code distance $L$ increases (Higgott et al., 2020). This rectangular geometry enables tailoring the surface code to specific device constraints and supports flexible logical patch layouts.

2. Stabilizer Formalism and Ancilla Structure

The stabilizer group of the rectangular surface code is constructed from two sets of operators:

• Star (X-type) stabilizers acting at each vertex $v = (i, j)$:

$A_{i, j} = \bigotimes_{e \ni v} X_e$

Specifically,

$$A_{i, j} = X_{e_h(i-1/2, j)} X_{e_h(i+1/2, j)} X_{e_v(i, j-1/2)} X_{e_v(i, j+1/2)}$$

• Plaquette (Z-type) operators at each face $f = (i+1/2, j+1/2)$:

$$B_{i+1/2, j+1/2} = \bigotimes_{e \in \partial f} Z_e$$

Which expands to

$$B_{i+1/2, j+1/2} = Z_{e_h(i+1/2, j)} Z_{e_h(i+1/2, j+1)} Z_{e_v(i, j+1/2)} Z_{e_v(i+1, j+1/2)}$$

Ancilla qubits are used for both syndrome extraction and encoding:

• X-ancillas reside at each vertex for star checks.
• Z-ancillas reside at each plaquette for plaquette checks.

Each stabilizer generator is associated with either a vertex or face, ensuring geometric locality of all check operators (Higgott et al., 2020).

3. Encoding Circuits and Depth-Optimality

The optimal local-unitary encoding for a distance-$L$ rectangular code proceeds via iterative "thickening" of smaller seed codes. For even $L$, encoding begins with an $L=2$ seed, encodable in 4 constant-depth steps, while for odd $L$, an $L=3$ seed requiring 6 steps is used.

The main thickening gadget executes a four-step local CNOT sequence to expand the code from distance $\ell$ to $\ell+2$:

1. Prepare X-ancillas on north/south boundaries, apply CNOTs from ancilla to adjacent data qubits.
2. Apply CNOTs from vertical data qubits into new plaquette ancillas (east/west).
3. Repeat step 1 in the orthogonal direction.
4. Repeat step 2 in the orthogonal direction.

This process is repeated until the target distance is achieved, yielding a total circuit depth

$$T(W, H) = 2 \cdot \min(W, H) + 3 \cdot \lceil \lvert W - H \rvert / 2 \rceil = O(L + \lvert W-H \rvert)$$

Each layer applies only nearest-neighbour two-qubit gates, maintaining strict locality.

Any local encoding circuit for a topologically ordered code must have depth at least $\Omega(L)$ due to Lieb–Robinson bounds on information propagation. This circuit achieves depth $2L + O(1)$, saturating the asymptotic lower bound (Higgott et al., 2020).

4. Syndrome Extraction and Measurement-Based Realizations

Alternate realizations such as the "3aux" pairwise measurement-based rectangular surface code employ a design with data qubits at sites of a $L_x \times L_y$ rectangular grid and three ancilla per plaquette ($A, B, C$). There are distinct $Z$ and $X$ stabilizer plaquettes arranged in a checkerboard pattern. Each stabilizer is measured using only single- and nearest-neighbour two-qubit Pauli measurements ($M_X$, $M_Z$, $M_{XX}$, $M_{ZZ}$), optimizing compatibility with Majorana-based architectures (Grans-Samuelsson et al., 2023).

Syndrome extraction is performed through a pipelined 4-step circuit for each plaquette, achieving a short operation period and supporting parallelization. Hook error propagation is controlled by the choice of boundary conditions and stabilizer orientation, allowing restoration of full code distance or, with further circuit modification, complete elimination of hook errors at the cost of increased circuit depth.

5. Boundary Engineering and Fault-Tolerance

Boundary conditions on rectangular patches dictate not only logical operator orientation but also the resilience to hook-type correlated errors. Options include:

• Rotated boundary patches with “benign hooks,” aligning hook-prone error directions orthogonally to logical string operators and achieving full code distance.
• Unrotated (“planar”) patches using expanded 3-gon boundaries, increasing qubit cost but allowing logical strings to circumvent dominant hook axes.
• Circuit variants with increased cycle depth (7 steps) that prevent all hook errors, trading a reduced error threshold for maximal logical protection in challenging boundary layouts (Grans-Samuelsson et al., 2023).

These configurations enable tailored trade-offs between footprint, logical distance, and error threshold—a significant consideration for hardware-specific quantum memory and computation protocols.

6. Handling Hardware Defects and Code Robustness

For practical systems with dead components (defective qubits or measurement links), the "3aux" rectangular surface code supports a minimal protocol for adapting syndrome circuits:

1. Remove dead data qubits, reducing affected $n$-gons to $(n-1)$-gons.
2. Remove dead ancilla, splitting each affected $n$-gon into smaller cycles using only existing measurement primitives.
3. Remove dead connections by further splitting cycles.

These procedures utilize no new measurement types, maximally preserve code distance, and adapt the measurement schedule with minimal overhead, supporting high yields and robust syndrome extraction under realistic conditions (Grans-Samuelsson et al., 2023).

7. Comparative Features and Applications

Rectangular surface codes, especially in optimized measurement-based forms, combine several advantageous features relative to alternatives:

Code Type	Qubit Count	Typical Depth	Threshold (double-rail)
3aux rectangular	$\approx 4d_{\rm f}^2$	4	$\approx 0.66\%$
Double-ancilla pentagon	$\approx 3d^2$	10	$\approx 0.24\%$
Windmill code	$\approx 2d^2$	20	$\approx 0.15\%$
4.8.8 Floquet	$\approx 4d^2$	3	$\approx 1.3\%$

Rectangular surface code protocols support straightforward conversion between planar, rotated, and toric topologies, smooth expansion to larger codes via buffer expansion strategies, and are directly compatible with planar superconducting, semiconducting, and Majorana-based hardware platforms.

The overall combination of locality, flexibility, and optimized encoding and measurement strategies positions the rectangular surface code as a core method for scalable, hardware-adapted quantum error correction (Higgott et al., 2020, Grans-Samuelsson et al., 2023).