XZZX Surface Code: Optimal Bias-Tailored QEC

• XZZX surface code is a two-dimensional quantum stabilizer code defined by an X–Z–Z–X pattern, optimized to handle strongly biased noise.
• It employs advanced decoding methods such as MWPM, tensor-network decoders, and belief propagation to significantly reduce logical error rates.
• The code offers practical advantages including reduced qubit overhead, compatibility with diverse quantum hardware, and thresholds approaching 50% under high bias.

The XZZX surface code is a two-dimensional quantum stabilizer code optimized for fault-tolerant quantum computation, particularly in environments with strongly biased noise. As a non-CSS (Calderbank-Shor-Steane) modification of the canonical surface code, XZZX exhibits distinct threshold phenomena, decoding strategies, and bias-tailored performance enhancements.

1. Code Structure and Stabilizer Construction

The XZZX code is defined on a planar or toric lattice, with data qubits on vertices (or equivalently, edges in some conventions) and a single weight-4 stabilizer generator per face. Each stabilizer $S_f$ acts on the four surrounding data qubits in a cyclic pattern as: $S_f = X_{v_1}\,Z_{v_2}\,Z_{v_3}\,X_{v_4}.$ The X–Z–Z–X pattern is repeated on all faces, leading to every data qubit participating in two XZZX-type checks (Ataides et al., 2020, Chen et al., 2024, Xu et al., 2022). In rectangular or rotated geometries, boundary checks may involve fewer qubits.

Logical operators correspond to minimal-length homologically nontrivial string operators traversing the code patch—typically pure-X (vertical) or pure-Z (horizontal/diagonal) strings, with weights $d_X$ and $d_Z$ determined by the code’s rectangle aspect and boundary types (Xu et al., 2022, Darmawan et al., 2021).

2. Noise Models and Bias-Tailored Thresholds

The code’s design leverages the XZZX stabilizer structure to exploit noise bias in the error model. For a Pauli channel with probabilities $p_X$, $p_Y$, $p_Z$, a bias parameter $\eta=p_Z/p_X$ can be defined.

• Depolarizing channel: $p_X=p_Y=p_Z=p/3$, $\eta=1$.
• Dephasing/bias channel: $p_Z=p\,\eta/(\eta+1)$, $p_X=p_Y=p/(2(\eta+1))$; $\eta\gg 1$ is strong $Z$-bias.
• Erasure/mixed models: Address specific hardware settings, e.g., biased erasure errors in neutral-atom qubits (Sahay et al., 2023).

Thresholds in the XZZX code are fundamentally elevated by this symmetry. Under depolarizing noise, the code-capacity threshold reaches $\approx 18.7\%$, matching the hashing bound; with increasing bias, the threshold approaches $50\%$—the theoretical maximum for Pauli channels (Ataides et al., 2020, Xiao et al., 2024, Kim et al., 2022).

Empirical results consistently show threshold enhancement with increasing bias across various platforms:

Noise Bias (η)	Code-Capacity Threshold
1	$\sim$11%–18.7%
10	$\sim$16%–20%
100+	$\sim$18.9%–50%

Depending on details of the architecture and error model, actual thresholds for heavy-hexagon lattices, Kerr-cat architectures, and neutral atom arrays fall into these ranges (Kim et al., 2022, Darmawan et al., 2021, Sahay et al., 2023).

3. Decoding Algorithms and Syndrome Processing

The XZZX code's non-CSS structure—each stabilizer couples both X and Z errors—renders independent X/Z matching decoders suboptimal, particularly under strong bias.

• Minimum-weight perfect matching (MWPM): Adapts via generalized edge weights, with path probabilities reflecting local bias. In the high-bias regime, syndrome graphs reduce to concatenated 1D repetition codes along code diagonals, allowing matching to decouple across strips and yielding significant improvements in decoding complexity (Ataides et al., 2020, Rowshan, 7 Jan 2026, Xu et al., 2022).
• Tensor-network decoders: Contract 2D tensor networks for maximum-likelihood decoding, converging to optimal thresholds even for large code distances (Ataides et al., 2020, Xiao et al., 2024).
• Belief propagation (BP) and machine-learning enhanced BP: Enhanced algorithms such as EWAInit-BP dynamically reweight priors using syndrome history, breaking trapping sets and achieving thresholds of $10\%$–$12.4\%$ under both unbiased and biased noise, with $O(1)$ hardware implementation complexity (Chen et al., 2024).
• Simulated annealing (SA) decoders: Highly parallelizable and bias-agnostic, SA provides near-optimal logical error rates for strongly non-Pauli-biased channels (notably, $Y$-bias), where MWPM fails (Sakashita, 22 Sep 2025).

A hallmark of the XZZX code under large bias is syndromic “strip-symmetry”: $Z$-type faults flip syndromes only along diagonal strips, analytically block-diagonalizing the matching problem and allowing for per-strip 1D decoding (Rowshan, 7 Jan 2026).

4. Analytical Performance and Finite-Size Scaling

The logical error rate $p_L$ under XZZX scaling is dictated by both the code distance $d$ and the effective bias $\eta$: $$p_L \sim \left(\frac{p}{\sqrt{\eta}}\right)^{d/2} \quad (\text{high bias, sub-threshold}).$$ The effective distance $d_\mathrm{eff}(\eta)$ generalizes minimum weight to the bias context: $$d_\mathrm{eff}(\eta) = \min_L \left( \sum_{p\in \text{supp}(L)} w'(\sigma_p) \right), \quad w'(Z)=1,~w'(X)=w'(Y)=\omega=\frac{\ln \eta}{\ln(1/p_Z)}.$$ This formalism recovers the fact that for $d \ll \eta$, the XZZX code in the repetition-code regime behaves as a 1D code with logical failure $p_f \simeq \exp(-d_{\mathrm{eff}}/\eta)$; only for $d \gg \eta$ does the code approach the threshold (Xiao et al., 2024). Closed-form asymptotic expressions for logical error rate use the undetectable-error weight enumerator and decoder fail fractions, yielding, e.g., $p_L \to 10 p^2$ (rotated-[[9,1,3]] XZZX) at $A=10$ (Forlivesi et al., 2023).

Empirical scaling at low physical error rates shows that, for a fixed target logical error rate, the XZZX code requires a smaller code distance and hence lower physical qubit overhead compared to standard CSS surface codes—by a factor scaling as $O(1+\frac{1}{2}\ln\eta/|\ln p|)$ (Ataides et al., 2020, Xu et al., 2022).

5. Hardware Implementations and Resource Overhead

The XZZX framework is applicable to a wide variety of quantum hardware:

• Silicon and spin qubits: Simulations under non-Markovian $1/f$ noise confirm quartic scaling of logical coherence time and equivalence with standard surface code when syndrome circuits are bias-mixing (Gravier et al., 11 Jul 2025).
• Kerr-cat qubits: Demonstrated fault-tolerance threshold $p_\mathrm{CX} \sim 6.5\%$ (dominant gate infidelity), almost an order of magnitude above baseline CSS surface code, with similar resource scaling and code performance matched to hardware bias (Darmawan et al., 2021).
• GKP concatenation: XZZX surface–GKP codes, particularly with rectangular (bias-tailored) GKP encoding, achieve code-capacity threshold $\sigma \approx 0.67$ (vs $\approx 0.60$ for standard surface–GKP), and enable order-of-magnitude reductions in bosonic mode overhead for fixed logical error (Zhang et al., 2022).
• Heavy-hexagon/IBM Q device compatibility: Code designs with as few as 13–63 data qubits and local connectivity yield thresholds increasing from $\sim$0.2% at no bias to $\sim$0.33% at infinite bias, surpassing untailored surface codes (Kim et al., 2022).
• Neutral atom qubits: Under biased-erasure error models, XZZX codes attain threshold $p_\mathrm{th} \approx 8.2\%$, i.e., $7.5\times$ the depolarizing value, with hybrid-fusion cluster constructs yielding thresholds up to $10.3\%$ (Sahay et al., 2023).

Qubit overhead for fault-tolerant logical encoding under XZZX is minimized: for effective distance $d_\mathrm{eff}$, required number of qubits $n \sim d^2 / (2\omega)$ ($\omega \sim \log\eta$), achieving $O(10\times)$ reduction for common values of bias (Xu et al., 2022, Ataides et al., 2020).

6. Fault-Tolerant Operations, Lattice Surgery, and Circuit Considerations

XZZX code structures are compatible with all standard and advanced fault-tolerant protocols:

• Syndrome extraction: Typically uses circuits of four two-qubit and single-qubit gates per check in a repeated schedule. Flag-ancilla designs (one flag per check) maintain high effective distance under circuit-level faults (Xu et al., 2022, Kim et al., 2022).
• Lattice surgery: Direct implementation of Clifford gates (e.g., logical XX and ZZ parity measurements) is natural via XZZX-based merge-and-split protocols. The code’s symmetry ensures minimal performance loss at defect sites and enables initialization and measurement in arbitrary Pauli bases (Ataides et al., 2020).
• Measurement-based QEC and 3D cluster states: Specialized XZZX-fusion cluster designs preserve code symmetry under bias and support robust performance in neutral-atom and photonic hardware (Sahay et al., 2023). For biased erasure, hybrid-fusion cluster constructs with adaptive fusion ancillae improve threshold and enable thin-patch (rectangular) coding to further reduce overhead.

The code’s decoding and stabilizer-measurement complexity is further reduced under strip decomposition in the infinite-bias regime, allowing $L$-fold acceleration of classical postprocessing (Rowshan, 7 Jan 2026).

7. Comparative Analysis and Design Considerations

XZZX surface codes universally outperform standard CSS surface codes for sufficiently large bias. Implementing both lattice rotation and XZZX on a rectangular patch can be detrimental: the code may lose its asymmetric distance advantage and degrade to the minimal chain length (Forlivesi et al., 2023). The balance of code geometry and bias orientation is thus central to resource optimization.

A comparison of variants at code distance $d=3$ and strong asymmetry ($A=10$) produces:

Code	Logical error rate as $p\to0$
Rotated [[9,1,3]] XZZX	$p_L \to 10\,p^2$
Rotated [[9,1,3]] surface	$p_L \to 16\,p^2$
Square [[13,1,3]] surface	$p_L \to 18.3\,p^2$

Implementing XZZX stabilizers on connectivity-constrained hardware (heavy-hex) remains favorable over the full range of bias (Kim et al., 2022).

---

In summary, the XZZX surface code stands out for its optimal bias-tailored thresholds, reduced overhead, decoding efficacy under nonstandard channels, direct compatibility with modular hardware architectures, and robust performance across practical and theoretically-motivated noise models. Its adoption as the leading two-dimensional stabilizer code for fault-tolerant quantum computing is substantiated by both analytic theory and numerical simulation across a broad spectrum of applied platforms (Ataides et al., 2020, Chen et al., 2024, Xu et al., 2022, Forlivesi et al., 2023, Rowshan, 7 Jan 2026).