Tailored cluster states with high threshold under biased noise

Abstract

Fault-tolerant cluster states form the basis for scalable measurement-based quantum computation. Recently, new stabilizer codes for scalable circuit-based quantum computation have been introduced that have very high thresholds under biased noise where the qubit predominantly suffers from one type of error, e.g. dephasing. However, extending these advances in stabilizer codes to generate high-threshold cluster states for biased noise has been a challenge, as the standard method for foliating stabilizer codes to generate fault-tolerant cluster states does not preserve the noise bias. In this work, we overcome this barrier by introducing a generalization of the cluster state that allows us to foliate stabilizer codes in a bias-preserving way. As an example of our approach, we construct a foliated version of the XZZX code which we call the XZZX cluster state. We demonstrate that under a circuit-level-noise model, our XZZX cluster state has a threshold more than double the usual cluster state when dephasing errors are more likely than errors that cause bit flips by a factor of order ~100 or more.

Introduction

Measurement-based quantum computing (MBQC) is an alternative to the circuit model of quantum computing¹. Depending on the physical primitives available on the underlying quantum hardware, MBQC can provide a more natural framework for composing quantum algorithms, and has been considered for photonic^2,3,4,5,6, trapped-ion^7,8, quantum dot^9,10,11,12, superconducting^12,13,14, and neutral atom¹⁵ architectures. In MBQC, computation is performed by preparing an entangled resource state, known as a cluster state, and then performing measurements on the cluster state to realize quantum gates^{1,16,17,18,19,20}. One can make MBQC fault-tolerant using 3D cluster states, which are cluster states whose measurement outcomes obey constraints that can be used to detect errors. These fault-tolerant cluster states are a universal resource for MBQC, as they can be modified to perform arbitrary computations via braiding^21,22, lattice surgery²³, or other code deformation techniques²⁴.

In circuit model quantum computing, there has recently been intense interest in developing error-correcting codes for qubits with biased noise; an example of biased noise is a scenario in which the errors which can cause bit flips are far less likely than those which cause only phase-flips^{25,26,27,28,29,30}. By modifying the stabilizers of the surface code^31,32 by local Pauli frame change, one can generate the tailored^25,26,27 or XZZX^28,33,34 surface codes (see Fig. 1) as well as other Clifford-deformed surface codes³⁵, all of which have much higher thresholds than the standard surface code in the presence of biased noise^{25,26,27,28,35}. The XZZX code is particularly notable for having a high threshold even when using a simple and efficient decoder. Realizing these high thresholds for biased noise requires all operations be bias-preserving, i.e. they do not convert high-probability errors to low-probability errors. Bias-preserving controlled-not (CX) gates for stabilizer measurement have been proposed in multiple qubit platforms^36,37,38, allowing the practical possibility of realizing these surface codes on biased-noise qubits²⁹.

Fig. 1: Examples of surface codes.

a The standard surface code has alternating plaquettes with X and Z stabilizers. b The XZZX surface code has the same stabilizer on every plaquette, the product of two X and two Z operators. The XZZX surface code can be obtained from the standard surface code via local Pauli frame changes.

However, extending these advances in error-correcting codes to the design of fault-tolerant cluster states for biased-noise qubits remains an open challenge. The standard approach to realize a fault-tolerant cluster state, called foliation, is based on performing repeated measurements of the stabilizers of a 2D stabilizer code via teleportation^21,22,24,39. Indeed, the typical cluster state is created by foliating the standard surface code^21,22,40,41. This cluster state is known as either the Raussendorf–Harrington–Goyal (RHG) or Raussendorf–Bravyi–Harrington cluster state; we will refer to it as the RHG cluster state in this paper. However, we will see below that the process of foliation does not preserve the noise bias, as it effectively converts high-probability pure phase-flip errors into low-probability bit-flip errors. Thus, foliating the tailored or XZZX surface code will not result in a high-threshold cluster state even if the underlying qubits have biased noise.

In this paper, we introduce a generalized cluster state as a tool for fault-tolerant MBQC. Our generalized cluster state is built by preparing qubits in the $\left\vert 0\right\rangle$ and $\left\vert +\right\rangle$ states, and then entangling pairs of qubits using both CZ and CX gates. Using our generalized cluster state, we can construct a foliation protocol that preserves the noise bias. This key property allows us to use the generalized cluster state to build high-threshold foliated versions of stabilizer codes designed for biased noise. While our method could be applied to any stabilizer code, we focus on foliating the XZZX surface code as we can decode it efficiently with a minimum-weight perfect matching (MWPM) decoder^32,42,43. Under biased circuit-level noise, we demonstrate that our new cluster state, the XZZX cluster state, has a much higher threshold than the RHG cluster state. Indeed, the threshold for the XZZX cluster state exceeds 2.0% gate-error rate compared to under 1.0% for the usual RHG cluster state when dephasing errors are more likely than errors that cause bit flips by a factor of order ~100 or more, which is an experimentally realistic amount of noise asymmetry^29,36. This work provides a systematic procedure for designing cluster states that are highly effective at correcting structured noise to gain a significant threshold advantage, thus opening up an additional direction for realizing near-term practical fault-tolerant quantum technologies ranging from universal MBQC to one-way repeaters for quantum networking and communications using noisier hardware than would otherwise have been possible.

Prior to this work, there has been recent research into non-foliated cluster states^44,45, which cannot be viewed as foliated versions of some 2D stabilizer code. Examples of non-foliated codes with improved thresholds against pure phase-flip errors were found in refs. ^44,45. However, the best-performing of these cluster states require high-degree (8–10) qubit connectivity and have thresholds ~1.93%, which is lower than what is achieved with the XZZX cluster state with only degree-4 connectivity. The low qubit connectivity of the XZZX cluster state makes it much more desirable for practical implementation. In addition,⁴⁶ has previously proposed creating high-threshold cluster states by concatenating a base-level repetition code to correct phase-flip errors with the usual RHG lattice. This is similar to the approach of ref. ⁴⁷ to correct biased errors in the circuit-model picture, where they concatenate a repetition code with the usual surface code. The advantage of our approach is similar to the advantage the tailored and XZZX surface codes have over⁴⁷, namely concatenating with a repetition code results in a higher qubit overhead and an enhanced rate of bit-flip errors.

Our paper is structured as follows. First, we review how to construct the RHG cluster state by foliating the surface code. This construction is representative of the more general protocols^24,39 for foliating stabilizer codes. Next, we explain why foliation effectively unbiases the qubits, and thus does not give high thresholds when applied to the tailored or XZZX surface codes. We then introduce the generalized cluster state, a simple modification of the usual cluster state that allows us to foliate the XZZX code in a bias-preserving way. We call this the bias-preserving XZZX cluster state. We demonstrate higher thresholds for our XZZX cluster state using a biased circuit-level-noise model and minimum weight perfect matching (MWPM) decoder. We conclude with some discussion of experimental platforms that may benefit from our approach. Details of our circuit-level-noise model and decoder are presented in the Methods section.

Results

The standard fault-tolerant cluster state

Foliation is a flexible approach to build fault-tolerant cluster states from stabilizer codes^24,39; here, we will follow the presentation of folation given in ref. ²⁴. The essential idea is to replace each qubit in a stabilizer code with a 1D cluster state that can be used to teleport a single logical degree of freedom, and couple these 1D cluster states so that the stabilizers of the code are repeatedly measured during teleportation. These cluster states can then be used to fault-tolerantly store some initial encoded state. While the cluster states we construct will not apply logical gates during the teleportation, there are standard methods to modify the basic fault-tolerant cluster state to enable universal fault-tolerant MBQC^{21,22,23,24,48}.

To illustrate the idea of foliation and motivate our generalized cluster state construction, we will review how to build the RHG cluster state by foliating the surface code. We will begin by constructing the 1D cluster state that can teleport a single qubit. We then replace each surface code qubit with a 1D teleportation cluster state, and demonstrate how to couple them to measure the surface code stabilizers during teleportation. Finally, we will explain how the resulting RHG cluster state detects errors.

The standard 1D teleportation cluster state is illustrated in Fig. 2a, b. To prepare the cluster state, we begin with an arbitrary state $\left\vert \psi \right\rangle$ on the first qubit and a $\left\vert +\right\rangle$ state on the remaining qubits. We then entangle neighboring qubits by applying controlled-phase or CZ gates to all pairs of neighbors (Fig. 2a). Importantly, the CZ gates are mutually commuting and may be applied in any order.

Fig. 2: The standard foliation.

a Filled black circles denote qubits initialized in the $\left\vert +\right\rangle$ state, filled red circles denote qubits initialized in an arbitrary state. Qubits connected by a line have a CZ gate applied between them. b Left: The logical operators (red) and stabilizers (blue) of the 1D cluster state. Right: By multiplying the logical operators by stabilizers, we can rewrite them to involve only X operators on the first 2n qubits. Measuring the first 2n qubits in the X basis teleports logical information to qubits {2n + 1, 2n + 2}. c By coupling ancilla qubits (bold) to a set of 1D cluster states, we can measure multi-qubit logical operators during teleportation. Here, measuring the X operator on the ancilla qubits attached at even (odd) numbered sites measures the logical product of the Z (X) operators of the neighboring qubits. We thus measure the stabilizers of the surface code as we teleport. d The unit cell of the resulting cluster state, the RHG cluster state. One can verify that the product of X operators on the highlighted qubits is a stabilizer of the RHG cluster state. There is one such stabilizer associated with each cell of the lattice. e A Z error on a qubit flips the stabilizers of the neighboring cells, allowing us to detect errors.

The stabilizer formalism can now be used to describe the cluster state. Before the CZ gates, the logical Pauli operators on $\left\vert \psi \right\rangle$ are given by X_L = X₁ and Z_L = Z₁, and the state is stabilized by {X₂, X₃, … }. After applying the CZ gates, the new logical operators and stabilizers are obtained from the old by conjugating with the CZ gates. This sends

$${Z}_{i}\to {Z}_{i}\,\,\,\,{X}_{i}\to {X}_{i}\mathop{\prod}\limits_{j\in {{{{\mathcal{N}}}}}_{i}}{Z}_{j}$$

(1)

where ${{{{\mathcal{N}}}}}_{i}$ denotes the neighbors of site i. We thus have X_L = X₁Z₂ and Z_L = Z₁, with stabilizers {Z₁X₂Z₃, Z₂X₃Z₄, … } (Fig. 2b). By multiplying the logical operators by stabilizers, we can put them in a form involving only X operators on the first 2n qubits:

$${X}_{{{{\rm{L}}}}}=\left(\mathop{\prod}\limits_{\begin{array}{c}i\le 2n\\ i\,{{{\rm{odd}}}}\end{array}}{X}_{i}\right){X}_{2n+1}{Z}_{2n+2}$$

(2)

$${Z}_{{{{\rm{L}}}}}=\left(\mathop{\prod}\limits_{\begin{array}{c}i\le 2n\\ i\,{{{\rm{even}}}}\end{array}}{X}_{i}\right){Z}_{2n+1}$$

(3)

The case of n = 3 is illustrated in Fig. 2b. This form makes it clear that if we measure the first 2n qubits in the X basis, the logical operators will be teleported to qubits {2n + 1, 2n + 2}. For example, in the case n = 3, if we measure qubits 1 − 6 and get outcomes {x₁, x₂, x₃, x₄, x₅, x₆} with x_i = ± 1, Eqs. (2) and (3) imply that the logical operators are given by

$${X}_{{{{\rm{L}}}}}={x}_{1}{x}_{3}{x}_{5}{X}_{7}{Z}_{8},\,\,\,\,{Z}_{{{{\rm{L}}}}}={x}_{2}{x}_{4}{x}_{6}{Z}_{7}.$$

(4)

To construct a fault-tolerant cluster state, we combine individual 1D teleportation cluster states, and modify the cluster to measure the check operators of some stabilizer code as we teleport. This construction was first realized for the surface code^21,22,41, but has been adapted to arbitrary CSS codes³⁹ and non-CSS codes²⁴. To generate the surface code, we replace each qubit of the surface code shown in Fig. 1a with a 1D teleportation chain. For each X-stabilizer plaquette of the surface code, we attach an ancilla qubit to each set of odd sites of the teleportation chain, and for each Z-stabilizer plaquette we attach an ancilla to each set of even sites of the teleportation chain, as shown in Fig. 2c. These ancillas are also initialized in $\left\vert +\right\rangle$ and entangled with their neighbors with CZ gates. One can easily verify that measuring an ancilla qubit in the X basis results in measuring the surface code stabilizer of the corresponding plaquette during the teleportation.

The resulting 3D cluster state, the RHG cluster state^21,22,40, is illustrated in Fig. 2d, where we display two overlapping cells of the cluster. To fault-tolerantly teleport information through this state, we simply measure both the data qubits and ancilla qubits in the X basis. One can check that for an RHG cluster state without errors, the product of the X operators on the faces of a cell (the highlighted qubits in Fig. 2d) is a stabilizer of the state, so the product of the X measurements around the faces of a cell should be (+1). To see the effects of errors, we can consider applying a single Pauli error. A Z or Y error on a face qubit flips the syndromes of the two neighboring cells, allowing us to detect these errors (Fig. 2e). Multi-qubit Pauli errors can be detected similarly, by considering the syndromes they flip. Note that X errors on the final cluster state have no effect, although X errors occurring between two CZ gates will propagate to Z errors on neighboring qubits. Errors can be corrected by pairing (−1) syndromes to each other using a minimum weight perfect matching (MWPM) decoder^32,42, and under this decoder the RHG cluster has a threshold for local Pauli noise^21,22.

This method of creating fault-tolerant cluster states can also be used to generate cluster states that realize the tailored^25,26,27 or XZZX²⁸ surface codes (Fig. 1b). However, these codes only offer improved thresholds over the usual surface code when the effective probability of bit-flip errors is suppressed compared to phase-flip errors. Unfortunately, the 1D teleportation procedure outlined above unbiases the noise, converting physical Z errors into logical X errors. We can understand these phenomena in two ways. Firstly, as seen from Eq. (3) the Z_L operator we use includes physical X operators on qubits 2, 4, …, 2n so that Z errors on these qubits anticommute with Z_L, and are therefore equivalent to an X_L error. Alternatively, if we consider teleporting the logical information from qubits 1 and 2 to, e.g., qubits 7 and 8, we see from Eq. (4) that to recover the logical information about the state we require accurate measurements x₁, …, x₆. A Z error on qubits 2, 4, or 6 would cause us to measure the wrong sign of x₂, x₄, or x₆. This results in the replacement of Z_L with −Z_L, which is equivalent to an X_L error.

From either viewpoint, we see that physical Z noise converts to logical X noise. Consequently, the effective error channel of the 1D teleportation chains, which are subsequently combined to measure the check operators of an error-correcting code, is not biased. Thus, the resulting fault-tolerant cluster state will not have an improved threshold even if the measured stabilizers correspond to a code that is specifically designed for biased noise, such as the XZZX surface code. In fact, we find that the XZZX cluster state produced by this approach does not perform better than the standard RHG at any bias (at the level of circuit-level noise it actually does worse; more details can be found in the supplementary results⁴⁹).

Naively, one might assume that while the RHG lattice is not robust to Z-biased noise, it should be robust to X-biased noise, since X errors on the RHG cluster state have no effect on the teleportation. However, even if physical qubits only experience X errors, applying CZ_c,t, where c denotes the control and t the target, propagates an X_c error to X_cZ_t. Thus, if X errors occur during the construction of the RHG lattice, they propagate to Z errors on the final cluster, and we cannot assume we have X-biased noise after the construction of the cluster state. By contrast, CZ gates commute with Z errors, so Z-biased noise is compatible with constructing the cluster state.

Building the bias-preserving XZZX cluster state

Based on the discussion above, we see that in order to build a cluster state that realizes the XZZX code with high-threshold, we must start with a 1D teleportation cluster state in which Z_L contains only physical Z operators. To achieve this, we construct our generalized cluster state with two types of qubits, X-type and Z-type. X-type qubits are initialized in $\left\vert +\right\rangle$ and measured in the X basis, as in the usual cluster state, while Z-type qubits are initialized in $\left\vert 0\right\rangle$ and measured in the Z basis. We’ll denote X-type qubits by ● and Z-type qubits by ○. To entangle neighboring qubits, we will apply different gates depending on the types of qubits we are entangling. To entangle two X-type qubits, we apply the usual CZ gate, while to entangle an X- and a Z-type qubit, we apply the CX gate, where the X-type qubit is the control qubit and the Z-type qubit is the target qubit (Fig. 3a). Importantly, the entangling gates are still mutually commuting, and may be applied in any order. We note that previous cluster states are a subset of our generalized cluster state, in which all qubits are X-type. In this construction, both the CX and CZ gate must be bias-preserving. CX gates that preserve Z-bias have already been proposed in multiple qubit platforms^36,37,38, while CZ gates naturally preserves Z-bias since Z errors naturally commute with CZ. Note that we are assuming that Z errors are dominant: CZ gates would not preserve X-bias, as they convert X errors to Z errors.

Fig. 3: Our bias-preserving foliation.

a Filled black circles denote X-type qubits initialized in the $\left\vert +\right\rangle$ state, open black circles denote Z-type qubits initialized in the $\left\vert 0\right\rangle$ state, while filled/open red circles denote X/Z-type qubits initialized in an arbitrary state. Two X-type qubits connected by a line have a CZ gate applied between them, while an X-type and Z-type qubit connected by a line have a CX gate applied between them as shown. b Left: The logical operators (red) and stabilizers (blue) of the X-start 1D cluster state. Right: By multiplying the logical operators by stabilizers, we can rewrite the logical operators to involve only X operators on the first nX-type qubits and Z operators on the first nZ-type qubits. Measuring the first nX-type qubits in the X basis and the first nZ-type qubits in the Z basis teleports logical information to qubits {2n + 1, 2n + 2}. c Same, for Z-start qubits. d By coupling ancilla X-type qubits (bold) to an alternating grid of X-start and Z-start 1D cluster states, we can measure multi-qubit logical operators during teleportation. Here, measuring the X operator on the ancilla qubits measures the XZZX operators of the neighboring qubits. We thus measure the stabilizers of the XZZX code as we teleport. e The unit cell of the resulting cluster state, the bias-preserving XZZX cluster state. One can verify that the product of X operators on the highlighted X-type qubits and Z operators on the highlighted Z-type qubits is a stabilizer of the XZZX cluster state. There is one such stabilizer associated to each cell of the lattice. f A Z error on an X-type qubit or an X error on a Z-type qubit flips the stabilizers of the neighboring cells, allowing us to detect errors. Importantly, Z errors create error chains that are restricted to 2D planes, allowing for improved decoding.

Our generalized construction allows us to build two distinct 1D teleportation cluster states, which are illustrated in Fig. 3b,c. The first, the X-start cluster state, begins with a state $\left\vert \psi \right\rangle$ on the first qubit, followed by alternating Z-type and X-type qubits. While we don’t initialize the first qubit in $\left\vert +\right\rangle$, we treat it as an X-type qubit during entanglement and measurement. The second, the Z-start cluster state, begins with a state $\left\vert \psi \right\rangle$ on the first qubit, followed by alternating X-type and Z-type qubits. Here, we treat the first qubit as a Z-type qubit during entanglement and measurement.

After applying the entangling gates, the new logical operators and stabilizers are obtained from the old by conjugating with the entangling gates. This sends

$${Z}_{i}\to {Z}_{i}\,\,\,\,{X}_{i}\to {X}_{i}\mathop{\prod}\limits_{\begin{array}{c}j\in {{{{\mathcal{N}}}}}_{i}\\ j\in {{{\mathcal{X}}}}\end{array}}{Z}_{j}\mathop{\prod}\limits_{\begin{array}{c}k\in {{{{\mathcal{N}}}}}_{i}\\ k\in {{{\mathcal{Z}}}}\end{array}}{X}_{k},\,\,\,\,i\in {{{\mathcal{X}}}}$$

(5)

$${X}_{i}\to {X}_{i}\,\,\,\,{Z}_{i}\to {Z}_{i}\mathop{\prod}\limits_{\begin{array}{c}j\in {{{{\mathcal{N}}}}}_{i}\\ j\in {{{\mathcal{X}}}}\end{array}}{Z}_{j},\,\,\,\,i\in {{{\mathcal{Z}}}}$$

(6)

where ${{{\mathcal{X}}}}$ and ${{{\mathcal{Z}}}}$ denote the set of X-type and Z-type qubits, respectively, and ${{{{\mathcal{N}}}}}_{i}$ denotes the neighbors of site i. For X-start cluster states, we thus have logical operators X_L = X₁X₂ and Z_L = Z₁ with stabilizers {Z₁Z₂Z₃, X₂X₃X₄, … }, while for Z-start we have logical operators X_L = X₁ and Z_L = Z₁Z₂ with stabilizers {X₁X₂X₃, Z₂Z₃Z₄, … }. By multiplying the logical operators by stabilizers, we can put them in a form that involves only X operators on the first nX-type qubits and only Z operators on the first nZ-type qubits. In the case of the X-start cluster state, we have

$${X}_{{{{\rm{L}}}}}=\left(\mathop{\prod}\limits_{\begin{array}{c}i\le 2n\\ i\,{{{\rm{odd}}}}\end{array}}{X}_{i}\right){X}_{2n+1}{X}_{2n+2}$$

(7)

$${Z}_{{{{\rm{L}}}}}=\left(\mathop{\prod}\limits_{\begin{array}{c}i\le 2n\\ i\,{{{\rm{even}}}}\end{array}}{Z}_{i}\right){Z}_{2n+1}$$

(8)

while in the case of the Z-start cluster state, we have

$${X}_{{{{\rm{L}}}}}=\left(\mathop{\prod}\limits_{\begin{array}{c}i\le 2n\\ i\,{{{\rm{even}}}}\end{array}}{X}_{i}\right){X}_{2n+1}$$

(9)

$${Z}_{{{{\rm{L}}}}}=\left(\mathop{\prod}\limits_{\begin{array}{c}i\le 2n\\ i\,{{{\rm{odd}}}}\end{array}}{Z}_{i}\right){Z}_{2n+1}{Z}_{2n+2}$$

(10)

The case of n = 3 for both clusters is illustrated in Fig. 3b, c. This form makes it clear that if we measure the first nX-type qubits in the X basis and the first nZ-type qubits in the Z-basis, the logical operators will be teleported to qubits {2n + 1, 2n + 2}. For example, in the case n = 3 for the X-start cluster state, if we measure qubits 1 − 6 and get outcomes {x₁, z₂, x₃, z₄, x₅, z₆} with x_i, z_i = ± 1, Eqs. (9) and (10) imply that the logical operators are given by

$${X}_{{{{\rm{L}}}}}={x}_{1}{x}_{3}{x}_{5}{X}_{7}{X}_{8},\,\,\,\,{Z}_{{{{\rm{L}}}}}={z}_{2}{z}_{4}{z}_{6}{Z}_{7}.$$

(11)

Importantly, in this cluster state Z_L is the product of physical Z operators and X_L is the product of physical X operators, meaning that physical Z errors cannot cause a logical X_L error. Thus, both teleportation clusters preserve the noise bias.

Crucially, these bias-preserving teleportation clusters can be used to foliate any biased-noise stabilizer code to gain large threshold advantage which was impossible with the conventional approach. This recipe follows the framework in²⁴ wherein each qubit in the stabilizer code is replaced with a 1D teleportation cluster state, and ancillas are added to measure the stabilizers. The main difference is now the 1D teleportation cluster is the bias-preserving cluster of Fig. 3b rather than the usual cluster of Fig. 2b. For any stabilizer code, there is some freedom in deciding how to foliate it. One can replace the qubits of the stabilizer code with X-start cluster states, Z-start cluster states, or a mixture of the two. In addition, one can couple either X-type or Z-type ancilla qubits to the teleportation cluster to measure the code stabilizers. However, switching between an X- and Z-start cluster is equivalent to shifting the teleportation cluster one unit to the left or right, so either type of teleportation cluster can be used provided the ancilla bonds are appropriately shifted. In addition, if an ancilla qubit is coupled to any Z-type qubits, the ancilla must be X-type, as there is no bias-preserving way to connect two Z-type qubits (they would have to be entangled with an X-controlled-X gate, which is not bias-preserving). Thus, in practice is it straightforward to determine a good bias-preserving foliation.

To build a bias-preserving cluster state realizing the XZZX code, it is most convenient to use an alternating grid of X-start and Z-start cluster states, as shown in Fig. 3d. While this choice is not essential, it results in simpler connectivity diagrams for the resulting cluster state. For each plaquette of the XZZX code, we add an X-type ancilla qubit as shown in Fig. 3d. These ancillas are also initialized in $\left\vert +\right\rangle$ and entangled with their neighbors following Fig. 3a. One can easily verify that measuring an ancilla qubit in the X basis results in measuring the XZZX code stabilizer of the corresponding plaquette during the teleportation. The resulting cluster state, the XZZX cluster state, is shown in Fig. 3e. The XZZX cluster state can be obtained from the usual RHG cluster state by applying Hadamard (H) gates at the site of Z-type qubits, just as the XZZX surface code can be obtained from the usual surface code by conjugating the stabilizers by H on alternating qubits. However, it is important to physically build the XZZX cluster state with CX and CZ gates rather than applying H gates to the RHG lattice, as an H operation does not preserve the bias.

Each cell of the XZZX cluster state has four X-type qubits and two Z-type qubits on its faces, highlighted in Fig. 3e; it is straightforward to show that for an XZZX cluster state without errors, the product of the X operators on the X-type qubits and the Z operators on the Z-type qubits is a stabilizer of the state, so the product of the corresponding X and Z measurements should be (+1). A Z or Y error on an X-type qubit flips the syndromes of the neighboring cells, as does an X or Y error on a Z-type qubit (Fig. 3f). Note that X errors on the overall cluster state have no effect on X-type qubits and Z errors on the overall cluster state have no effect on Z-type qubits, although Z errors on Z-type qubits occurring between two CX gates will propagate to Z error on neighboring X-type qubits, and similar for X errors on X-type qubits. Using a bias-preserving CX gate ensures that Z errors do not propagate to X or Y errors. Overall, errors can again be corrected by pairing (−1) syndromes to each other using a MWPM decoder. Importantly, we observe that in the XZZX cluster state Z errors create error chains that are restricted to disconnected 2D planes, while in the RHG cluster state Z errors create error chains that may meander in 3D. Intuitively, this makes decoding the XZZX cluster state easier in the presence of biased noise. This effective reduction in dimensionality of the matching graph in the case of biased noise has previously been noted⁵⁰ as a mechanism for increased thresholds in the tailored²⁶ and XZZX²⁸ surface codes.

Comparing the thresholds

To demonstrate the advantage of the XZZX cluster state in the presence of biased noise, we perform full circuit-level-noise simulations for both the XZZX cluster state and the usual RHG cluster state. We do not present results on the cluster obtained by applying the standard foliation approach to the XZZX surface code, as this yields worse thresholds than the RHG state (see the supplemental material⁴⁹). We use a physically well motivated biased noise model^29,36,51,52, although we do not expect the details of the noise model to significantly affect our conclusions. In this model, CZ_c,t gates experience errors ${{\mathbb{1}}}_{c}{Z}_{t}$ and ${Z}_{c}{{\mathbb{1}}}_{t}$ with probability p_z, Z_cZ_t with probability ${p}_{z}^{2}$, and all other errors with probability p_z/η. In addition, CX_c,t gates experience errors ${{\mathbb{1}}}_{c}{Z}_{t}$ and Z_cZ_t with probability p_z/2, ${Z}_{c}{{\mathbb{1}}}_{t}$ with probability p_z, and all other errors with probability p_z/η. Finally, during both preparation and measurement, each qubit experiences Z errors with probability p_z and X and Y errors with probability p_z/η.

In addition, we simulate the RHG cluster state under X-biased noise, to verify our earlier argument that the RHG cluster state should not have a notably higher threshold under X-biased noise. For X-biased noise in the RHG cluster state, we use a physically-motivated error model based on a specific implementation of CZ gates. Note that even when we assume X-biased noise on the physical qubits, we do not expect the noise of the CZ gates to be X-biased as CZ gates do not preserve X-bias. In our model, after applying a CZ_c,t gate errors I_cX_t, X_cI_t, Z_cX_t and X_cZ_t occur with probability 0.375p_x, I_cY_t, Y_cI_t, Z_cY_t and Y_cZ_t occur with probability 0.125p_x, and all other errors occur with probability p_x/η. In addition to errors during the CZ gates, during both preparation and measurement X errors occur with probability p_x and Y and Z errors with probability p_x/η. We do not simulate the XZZX cluster state with X-biased noise since we expect it to perform worse than the XZZX cluster state with Z-biased noise, as CZ gates do not preserve the X-bias. However, if the physical qubits available are X-biased, one can always perform a Pauli frame change to ensure the noise on the XZZX cluster is Z-biased.

In the Z-biased noise model, the total error probability of CZ is $2{p}_{z}+{p}_{z}^{2}+12{p}_{z}/\eta$ and of CX gate is 2p_z + 12p_z/η. We emphasize that η is a parameter of our error model, and does not represent the ratio of the probability of dephasing errors to the probability of errors which cause bit flips. This ratio, which is often quoted as the bias, is η/6, so that e.g. η = 1000 corresponds to a ratio of probabilities equal to 166.67. In the X-biased noise model, the total error probability of CZ is 2p_x + 7p_x/η. To compare the cluster states, we will measure the threshold in terms of the error probability of CZ, although we note that the CX gate in the XZZX cluster state has a near-identical error rate to the CZ gate for low p_z. For each noise model, we use a MWPM decoder for circuit-level-noise to correct the errors^32,42,43,53. We explain the details of the noise model and our decoder in the Methods section.

We show our results in Fig. 4, where we plot the threshold for 1≤η≤10000. We see that at η = 1 the threshold for all three are similar. As we increase η, the threshold of the RHG cluster state with X-biased noise modestly outperforms the RHG cluster state with Z-biased noise; however, as expected, the threshold of our XZZX cluster state strongly outperforms both. For high bias η≥1000, the threshold of the XZZX cluster state has p_th > 2.0%, more than doubling the RHG cluster state with Z-biased noise which has p_th < 1.0%. Our results also compare favorably to the non-foliated clusters in⁴⁵. At infinite bias where our noise models become equivalent, the XZZX cluster state moderately outperforms the best non-foliated cluster state, which has a threshold of 1.93%. The non-foliated cluster state requires degree-10 connectivity between qubits, while our cluster state maintains the degree-4 connectivity of the usual RHG cluster state. Note that the best cluster state under infinite bias is labeled “srs" in⁴⁵ and has a threshold of 1.16% under their error model; this translates to a threshold of 1.93% in our error model. We also remark that even if high qubit connectivity is achievable, the thresholds of the non-foliated clusters of^44,45 can likely be improved further using our method to selectively replace some of the X-type qubits with Z-type qubits.

Fig. 4: The threshold error rate p_th as a function of bias η for the three cluster states we consider, the XZZX and RHG cluster states with Z-biased noise and the RHG cluster state with X-biased noise.

Here p_th refers to the total error rate of the CZ gate in the corresponding noise model. We see that the XZZX cluster state strongly outperforms both RHG cluster states, although the RHG cluster state has a modestly improved threshold for X-biased noise as compared to Z-biased. The error bars (standard deviation) are smaller than the marker size in the figure.

Discussion

Given the significant increase in threshold of the XZZX cluster state under biased noise, the next step is to consider what qubit platforms might naturally take advantage of the increased threshold. Detailed investigations of the structure of errors for specific qubit platforms are beyond the scope of this paper. However, in this section, we make some preliminary suggestions for quantum computing approaches that may benefit from realizing the XZZX cluster state rather than another form of error correction. Each of our proposals uses a two-step strategy, in which we start with small cluster states, and fuse X-type qubits with Z-type qubits using Bell measurements to create the XZZX cluster state. Importantly, such fusions are bias-preserving: Z errors on qubits involved in the fusion result in Z errors on the final cluster state. Furthermore, as we’ll demonstrate for specific platforms below, the additional errors introduced during the fusions are also Z-biased. Thus, our constructions all result in a final cluster state with Z-biased noise. Note that our constructions of the XZZX cluster state can likely be further optimized to require fewer operations and qubits, for example, by using the ideas in ref. ⁴⁸.

Dual-rail photons with linear optics

A prime candidate for realizing the XZZX cluster state is dual-rail encoded photonic qubits, in which a qubit is represented by a photon being in one of two photonic modes. Denoting the qubit state by $\left\vert \bar{0}\right\rangle$ and $\left\vert \bar{1}\right\rangle$, we have $\left\vert \bar{0}\right\rangle := \left\vert 10\right\rangle$ and $\left\vert \bar{1}\right\rangle := \left\vert 01\right\rangle$. Using only standard linear-optical elements, one can apply arbitrary single-qubit gates to dual-rail qubits, but entangling operations are inherently probabilistic^2,3,54,55. Modern architecture proposals for dual-rail photonic qubits involve building a cluster state from smaller resource states using probabilistic destructive Bell measurements ("fusions")^2,3,48,56. To correct errors, these protocols use the RHG cluster state^48,56, but by using modified resource states one can instead realize the XZZX cluster states. Building the XZZX cluster state from the resource states requires the same number of fusion measurements as the RHG cluster state. See Fig. 5, where we illustrate how to build the XZZX cluster state with fusions. Starting from 3-qubit GHZ resource states $(\left\vert \bar{0}\,\bar{0}\,\bar{0}\right\rangle +\left\vert \bar{1}\,\bar{1}\,\bar{1}\right\rangle )/\sqrt{2}$ and $(\left\vert \bar{+}\,\bar{+}\,\bar{+}\right\rangle +\left\vert \bar{-}\,\bar{-}\,\bar{-}\right\rangle )/\sqrt{2}$, we fuse these states into 5-qubit resource states, postselecting on Bell measurement success. From here, the 5-qubit resource states are fused into the XZZX cluster state, the center qubits of the 5-qubit resource states becoming the qubits of the XZZX cluster state.

Fig. 5: Building the XZZX cluster state with fusion measurements.

a The XZZX cluster state can be built from three-qubit GHZ cluster states $(\left\vert \bar{0}\,\bar{0}\,\bar{0}\right\rangle +\left\vert \bar{1}\,\bar{1}\,\bar{1}\right\rangle )/\sqrt{2}$ and $(\left\vert \bar{+}\,\bar{+}\,\bar{+}\right\rangle +\left\vert \bar{-}\,\bar{-}\,\bar{-}\right\rangle )/\sqrt{2}$ using only destructive Bell measurements. b Larger five-qubit cluster states built from the three-qubit cluster states. When fusing small cluster states using Bell measurements, the measurement outcomes determine Pauli corrections we must apply to get the correct final state. Importantly, a Z error on a qubit involved in a Bell measurement only results in an erroneous Z correction on the final cluster state, so that Bell fusions are bias-preserving. Note that to get the third cluster state, we apply a Hadamard $\hat{H}$ to one of the qubits. This converts Z errors to X errors on that qubit, but does not result in X errors on the final XZZX cluster state. c The five-qubit clusters can be fused with Bell measurements to form the XZZX cluster state. Here, we illustrate the fusion measurements for the three qubits highlighted in the inset.

Errors on the final XZZX cluster state come from three sources: photon loss, probabilistic Bell measurement failures, and stochastic Pauli errors induced by errors during preparation. Photon loss results in qubit erasure in the XZZX cluster state, and can be corrected by modifying the weights in the MWPM decoder just as in the usual RHG cluster state^57,58. For pure loss, the XZZX and RHG cluster states have identical thresholds. However, in the presence of biased noise, we expect the XZXX cluster state to be able to tolerate higher rates of photon loss.

In the simplest fusion scheme the Bell measurement fails 50% of the time³, but the success probability can be boosted by the use of ancilla photons^59,60 or more complicated “snowflake" resource states⁵⁶. In the case of Bell measurement failure, the fusion measurement instead measures each of the qubits in the single-qubit Z basis, which leads to unwanted Z-measurements on the ultimate XZZX cluster state. These unwanted Z-measurements apply the channel

$$\rho \to \left(\frac{1+Z}{2}\right)\rho \left(\frac{1+Z}{2}\right)+\left(\frac{1-Z}{2}\right)\rho \left(\frac{1-Z}{2}\right)$$

(12)

$$=\frac{1}{2}\left(\rho +Z\rho Z\right)$$

(13)

act thus as Z-errors with 50% probability, at locations heralded by the Bell measurement failure. Given the XZZX cluster state’s enhanced threshold to Z errors, we expect this construction to lead to a higher threshold to bond failure than has been previously established for the RHG cluster state⁶¹.

Finally, stochastic errors during preparation can propagate to Pauli errors on the final cluster state. While there are many potential sources of stochastic errors in dual-rail qubits, two frequently considered sources of error are relative phase errors and mode mismatch. Relative phase errors occur when certain paths in an optical network cause unexpected phase evolution^48,55. Mode mismatch may occur due to timing errors, causing wavepackets to arrive at a beamsplitter at mismatched times^62,63,64,65. It can be shown that mode mismatch between the modes entering a fusion measurement causes an effective Z error⁶³, although mode mismatch during construction of the resource state can have other effects. Provided the relative phase errors and timing errors primarily occur during the storage/routing that occurs after building the resource states but before fusing them, the noise on the final XZZX cluster state will be biased towards Z errors. However, precisely quantifying the effect of these errors versus other sources of non-idealities will depend on the specific hardware.

Overall, then, we expect the XZZX cluster state to have a similar tolerance to qubit loss, an improved tolerance to fusion failure, and an improved tolerance to stochastic noise provided the noise is biased. Detailed investigation of the structure of noise for specific hardware is required to determine to what extent this noise is biased. Quantifying the threshold improvements for error models incorporating photon loss and fusion failure will be left to future work.

Dual-rail photons with linear optics and weak cross-Kerr nonlinearities

If we go beyond linear optics and allow for the possibility of weak cross-Kerr nonlinearities, then a deterministic nondestructive Z₁Z₂ parity measurement can be made by interacting two dual-rail qubits with a large coherent state $\left\vert \alpha \right\rangle$^{66,67,68,69,70}, and a probabilistic nondestructive Z₁Z₂Z₃ measurement can similarly be made on three dual-rail qubits⁷⁰. These operations, along with single-qubit rotations, are sufficient to build the XZZX cluster state, and the stochastic noise introduced by the measurements is highly biased.

Briefly, a cross-Kerr nonlinearity between two modes b and c results in an interaction $\chi {\hat{n}}_{b}{\hat{n}}_{c}$, where χ is typically small. If we denote the two modes of the dual-rail qubit by a and b and the mode of the coherent state by c, the cross-Kerr interaction between b and c realizes the transformation

$$\begin{array}{ll}\left[{\psi }_{0}{\left\vert 10\right\rangle }_{ab}+\right.\,\left.{\psi }_{1}{\left\vert 01\right\rangle }_{ab}\right]{\left\vert \alpha \right\rangle }_{c}\\ \qquad\qquad\to {\psi }_{0}{\left\vert 10\right\rangle }_{ab}{\left\vert \alpha \right\rangle }_{c}+{\psi }_{1}{\left\vert 01\right\rangle }_{ab}{\left\vert \alpha {e}^{-i\theta }\right\rangle }_{c}.\end{array}$$

(14)

Here, θ = χt, where t is the time of the interaction. This nonlinear interaction has been realized for θ ≈ 0.28 and θ ≈ 0.7 in different platforms^71,72.

If we sequentially repeat this interaction between mode c and the second mode of N dual-rail qubits, the resulting transformation is

$$\mathop{\sum}\limits_{\bar{z}\in {\{\bar{0},\bar{1}\}}^{N}}{\psi }_{\bar{z}}\left\vert \bar{z}\right\rangle {\left\vert \alpha \right\rangle }_{c}\to \mathop{\sum}\limits_{\bar{z}}{\psi }_{\bar{z}}\left\vert \bar{z}\right\rangle {\left\vert \alpha {e}^{-i\theta | \bar{z}| }\right\rangle }_{c}$$

(15)

where $| \bar{z}|$ is the number of $\bar{1}$s in $\bar{z}$. Focusing for a moment on the N = 2 case, the state after the interaction is

$$\begin{array}{ll}{\psi }_{\bar{0}\,\bar{1}}&\left\vert \bar{0}\,\bar{1}\right\rangle {\left\vert \alpha {e}^{-i\theta }\right\rangle }_{c}+{\psi }_{\bar{1\bar{0}}}\left\vert \bar{1}\,\bar{0}\right\rangle {\left\vert \alpha {e}^{-i\theta }\right\rangle }_{c}\\ &+{\psi }_{\bar{0}\,\bar{0}}\left\vert \bar{0}\,\bar{0}\right\rangle {\left\vert \alpha \right\rangle }_{c}+{\psi }_{\bar{1\bar{1}}}\left\vert \bar{1}\,\bar{1}\right\rangle {\left\vert \alpha {e}^{-2i\theta }\right\rangle }_{c}.\end{array}$$

(16)

Performing a homodyne measurement of the $\hat{X}\cos (\theta )-\hat{P}\sin (\theta )$ quadrature on mode c doesn’t distinguish between $\left\vert \bar{0}\,\bar{1}\right\rangle$ and $\left\vert \bar{1}\,\bar{0}\right\rangle$, or between $\left\vert \bar{0}\,\bar{0}\right\rangle$ and $\left\vert \bar{1}\,\bar{1}\right\rangle$. However, for αθ sufficiently large, the measurement distinguishes between $| \bar{z}| \,{{\mathrm{mod}}}\,\,2=0$ and $| \bar{z}| \,{{\mathrm{mod}}}\,\,2=0$; thus, it measures the parity ${\hat{Z}}_{1}{\hat{Z}}_{2}$⁶⁶. Importantly, χ can be very weak as long as α is sufficiently large.

The N = 3 case is similar, but in this case a homodyne measurement of the $\hat{X}\cos (\theta )-\hat{P}\sin (\theta )$ quadrature can’t distinguish between $| \bar{z}| =0$ and $| \bar{z}| =2$, but it can distinguish $| \bar{z}| =1$ and $| \bar{z}| =3$. If one measures the outcome corresponding to $| \bar{z}| \,{{\mathrm{mod}}}\,\,2=0$, we have successfully performed a ${\hat{Z}}_{1}{\hat{Z}}_{2}{\hat{Z}}_{3}$ measurement, and otherwise the measurement fails⁷⁰.

These two-qubit and three-qubit parity measurements are sufficient prepare the two GHZ states shown in Fig. 5. In addition, by performing a nondestructive ${\hat{Z}}_{1}{\hat{Z}}_{2}$ measurement followed by two single qubit ${\hat{X}}_{1}$ and ${\hat{X}}_{2}$ measurements, we can perform a deterministic Bell measurement. Thus, we can build the cluster state using the same strategy as in Fig. 5, with the additional benefit that the fusions always succeed.

The dominant error in the multi-qubit Z measurement is photon loss. Photon loss on the qubit modes results in erasure errors on the final cluster state, which as we noted above can be corrected by modifying the MWPM decoder^57,58. Photon loss on the coherent state leads to dephasing errors⁶⁷. As a simple example, we can consider the final state in Eq. (14); a photon loss on a coherent state results in the transformation (ignoring normalization)

$$\begin{array}{ll}{\psi }_{0}\,{\left\vert 10\right\rangle }_{ab}{\left\vert \alpha \right\rangle }_{c}+{\psi }_{1}{\left\vert 01\right\rangle }_{ab}{\left\vert \alpha {e}^{-i\theta }\right\rangle }_{c}\\ \qquad\qquad\qquad\to \alpha \left[{\psi }_{0}{\left\vert 10\right\rangle }_{ab}{\left\vert \alpha \right\rangle }_{c}+{\psi }_{1}{e}^{-i\theta }{\left\vert 01\right\rangle }_{ab}{\left\vert \alpha {e}^{-i\theta }\right\rangle }_{c}\right].\end{array}$$

(17)

Photon loss during the cross-Kerr interaction or at other points in building the cluster state similarly results in dephasing errors. In addition, other work has shown that the effect of a finite cross-Kerr response time leads to dephasing as well⁷³.

Coherent states with linear optics

An alternative qubit encoding for linear-optical quantum computation represents the qubit using coherent states $\left\vert \bar{0}\right\rangle := \left\vert \alpha \right\rangle$ and $\left\vert \bar{1}\right\rangle := \left\vert -\alpha \right\rangle$, respectively^74,75,76. This encoding has the advantage that for large α, destructive Bell measurements can be carried out deterministically using linear optics⁷⁴. In addition, the dominant source of error is photon loss, which causes dephasing.

We can use the same strategy as in Fig. 5 to build the XZZX cluster state, with deterministic fusions, provided we can prepare the GHZ resource states. The state $(\left\vert \bar{0}\,\bar{0}\,\bar{0}\right\rangle +\left\vert \bar{1}\,\bar{1}\,\bar{1}\right\rangle )/\sqrt{2}$ can be prepared by sending the state $\left\vert \bar{+}\right\rangle \left\vert 0\right\rangle \left\vert 0\right\rangle$ through a three-way beamsplitter⁷⁴ (here $\left\vert 0\right\rangle$ is the vacuum state, not to be confused with $\left\vert \bar{0}\right\rangle$), and this preparation does not convert Z errors to X or Y errors. Preparing the state $(\left\vert \bar{+}\,\bar{+}\,\bar{+}\right\rangle +\left\vert \bar{-}\,\bar{-}\,\bar{-}\right\rangle )/\sqrt{2}$ in a bias-preserving way is more challenging. In the supplemental material, we outline a procedure to prepare this GHZ state from five Bell pairs in a bias-preserving way⁴⁹. This procedure is likely too resource-intensive for practical purposes, but illustrates that there is no no-go theorem forbidding the construction of this state in a bias-preserving way. We note that if the majority of photon loss happens after building the GHZ states, we will still have biased noise on the final cluster even if the GHZ preparation is not bias-preserving.

Other biased-noise qubits

While optical platforms are typically considered for MBQC, our cluster state may also prove useful for qubits that are typically considered in the circuit model. Several platforms, such as superconducting fluxonium⁷⁷, quantum-dots⁷⁸, Rydberg atoms³⁸, continuous-variable or bosonic qubits^79,80, and many others, exhibit a biased-noise channel. So far, these qubits have been mostly considered for realizing the circuit model of fault-tolerant topological codes, which will require native bias-preserving CX gates in order to take advantage of the bias (a bias-preserving gate is one which does not convert a dominant error to a less dominant error and hence does not destroy the noise bias in the underlying hardware). Unlike a diagonal gate such as CZ which is trivially bias-preserving, a native bias-preserving CX gate is unphysical in finite-dimensional systems due to a no-go result^37,81. Recent works have shown that in some platforms, it is possible to circumvent this no-go result and implement CX gates in a bias-preserving manner^36,38. Nonetheless, the schemes proposed so far are experimentally challenging and it is unclear how well they will perform in practice.

Remarkably, the XZZX cluster state can be generated with only bias-preserving CZ gates, nondestructive Z ⊗ Z and Z ⊗ Z ⊗ Z measurements, and destructive Bell measurements (see Fig. 6). Nondestructive Z ⊗ Z and Z ⊗ Z ⊗ Z measurements can be performed with a single ancilla qubit and CZ gates, although we need to repeat the measurement in order to avoid converting Z errors to X errors at a high rate. Alternatively, we can use multiple ancilla qubits to partially parallelize the repeated measurement⁸¹. One may worry that by repeating the measurement to suppress X errors, we are multiplying the rate of Z errors. However, in some qubit architectures such as Kerr cats and dissipative cats, increasing the bias of the qubit also increases the fidelity of CZ gates, so that the probability of CZ gates introducing Z errors decreases as we increase the bias (see²⁹, Tables I and II,⁵¹, Appendix D2). Destructive Bell measurement can be performed by making a nondestructive Z ⊗ Z measurement followed by single-qubit X measurements on each qubit. Overall, this strategy is distinct from earlier work on realizing biased-noise error correction without CX gates, which relies on concatenating an inner repetition code with an outer CSS code⁸¹. Thus, MBQC with the XZZX cluster state may be an avenue for higher threshold fault-tolerant error correction for biased noise architectures without bias-preserving CX gates. This opens up a new opportunities to develop high-threshold universal MBQC with a plethora of biased-noise qubits ranging from superconducting qubits to Rydberg atoms.

Fig. 6: Building the XZZX cluster state with simple bias-preserving operations.

a The XZZX cluster state can be built from a product of $\left\vert +\right\rangle$ states using only nondestructive Z₁ ⊗ Z₂ and Z₁ ⊗ Z₂ ⊗ Z₃ measurements, destructive X₁ ⊗ X₂ measurements, and CZ gates. Note that bias-preserving multi-qubit Z measurements can generally be realized nondestructively in biased-noise architectures⁸¹. b Two elementary cluster states. The left cluster state is constructed by preparing three qubits in the $\left\vert +\right\rangle$ state and performing the three-qubit Z measurement. The right cluster state is constructed by preparing four qubits in the $\left\vert +\right\rangle$ state and performing two-qubit Z measurements as shown. c From the elementary cluster states, we can generate larger five-qubit cluster states. The first cluster is formed by fusing three-qubit cluster states using nondestructive Z ⊗ Z followed by destructive X ⊗ X measurements. The second cluster is formed from the four-qubit cluster state by preparing an additional qubit in the $\left\vert +\right\rangle$ state and applying a CZ gate as shown. From these five-qubit resource states, we can build the XZZX cluster state as in Fig. 5c.

We have demonstrated that in the presence of biased noise, the XZZX cluster state offers significant threshold improvements over the usual RHG cluster state. Moreover, this cluster state can be prepared using a similar strategy as the standard RHG state. Just like the latter, the entire 3D XZZX cluster state need not be prepared at once and at most two layers of the state need to exist simultaneously at a given time⁴¹.

While the most direct preparation route is to initialize the Z-type and X-type qubits in $\left\vert 0\right\rangle$ and $\left\vert +\right\rangle$ states respectively and then apply the entangling CZ and CX gates as described in Fig. 3, we have illustrated that for some qubit architectures it may be more desirable to build the XZZX cluster state from smaller resource states using Bell measurements.

Future directions

While we have focused on the impact of circuit-level Pauli errors in this paper, in some architectures, e.g. photonic, qubit loss is an additional source of error. Fortunately, it is known that the RHG cluster state can simultaneously correct both Pauli errors and qubit loss^57,58. Similarly, in linear-optical photonic architectures the entangling fusions only succeed probabilistically³, but the RHG cluster state is resilient to these errors as well⁶¹. In both cases, there is a tradeoff between the Pauli noise the threshold can tolerate and the amount of qubit loss or gate failure that can occur; at higher rates of loss or gate failure, the thresholds against Pauli noise are lower. We can use similar strategies to deal with loss and fusion failure for the XZZX cluster state. Preliminary simulations indicate that the XZZX cluster states retains its higher threshold to biased noise in the presence of loss and bond failure. Quantifying the threshold improvement for realistic values of bias, loss probability, and gate failure rate will be left to future work.

Finally, while we constructed our high-threshold fault-tolerant cluster state by foliating the XZZX surface code, we have not addressed the possibility of high-threshold non-foliated cluster states. Current versions of non-foliated cluster states are made entirely of X-type qubits, which leave every qubit vulnerable to Z errors^44,45. It is likely that replacing certain X-type qubits with Z-type qubits would lead to higher thresholds, by limiting the qubits where Z errors can affect the cluster. This could allow for the low-degree cluster states of refs. ^44,45 to have a much higher threshold under biased noise, and may further increase the already-high thresholds of their high-degree cluster states under biased noise. We leave this question open for future exploration.

Methods

Circuit-level-noise model

For Z-biased noise in both the RHG and XZZX cluster state, we use the circuit-level-noise model introduced in²⁹ for biased-noise Kerr cat qubits, although we do not expect the specific error model to noticeably affect our results. We assume the CZ_c,t gates are implemented by evolving under some interaction that is diagonal in the Z-basis, e.g. evolving under an interaction of the form $\chi \left[({I}_{c}+{Z}_{t}){{\mathbb{1}}}_{t}/2+({I}_{c}-{Z}_{c}){Z}_{t}/2\right]$ for time π/2χ. If we let p_z be the probability of any qubit experiencing a Z error during the operation of this gate, then a CZ_c,t gate experiences ${{\mathbb{1}}}_{c}{Z}_{t}$ and ${Z}_{c}{{\mathbb{1}}}_{t}$ errors with probability p_z and a Z_cZ_t error with probability ${p}_{z}^{2}$. Because the underlying qubits are biased, we assume all other errors occur with probability p_z/η. A CX_c,t gate experiences ${{\mathbb{1}}}_{c}{Z}_{t}$ and Z_cZ_t errors with probability p_z/2, a ${Z}_{c}{{\mathbb{1}}}_{t}$ error with probability p_z, and all other errors with probability p_z/η; justification for this error model can be found in^29,36. Finally, during both preparation and measurement, each qubit experiences Z errors with probability p_z and X and Y errors with probability p_z/η.

For X-biased noise in the RHG cluster state, we use a physically-motivated error model based on a specific implementation of CZ gates. Let p_x be the probability of an X error occurring on a qubit at any point in the CZ gate operation, and assume CZ_c,t is implemented by evolving under an interaction of the form $\chi \left[({I}_{c}+{Z}_{c}){{\mathbb{1}}}_{t}/2+({I}_{c}-{Z}_{c}){Z}_{t}/2\right]$ for time π/2χ. Then X errors during the evolution result in an error channel whose Pauli-terms are ${p}_{x}^{{\prime} }{I}_{c}{X}_{t}\rho {I}_{c}{X}_{t}+{p}_{x}^{{\prime} }{X}_{c}{I}_{t}\rho {X}_{c}{I}_{t}+{p}_{x}^{{\prime} }{Z}_{c}{X}_{t}\rho {Z}_{c}{X}_{t}+{p}_{x}^{{\prime} }{X}_{c}{Z}_{t}\rho {X}_{c}{Z}_{t}+{p}_{x}^{{\prime}{\prime}}{I}_{c}{Y}_{t}\rho {I}_{c}{Y}_{t}+{p}_{x}^{{\prime}{\prime}}{Y}_{c}{I}_{t}\rho {Y}_{c}{I}_{t}+{p}_{x}^{{\prime}{\prime}}{Z}_{c}{Y}_{t}\rho {Z}_{c}{Y}_{t}+{p}_{x}^{{\prime}{\prime}}{Y}_{c}{Z}_{t}\rho {Y}_{c}{Z}_{t}$, with ${p}_{x}^{{\prime} }:= (2{p}_{x}/\pi )\int\nolimits_{0}^{\pi /2}{\cos }^{4}(\phi )d\phi =0.375{p}_{x}$ and ${p}_{x}^{{\prime}{\prime}}:= (2{p}_{x}/\pi )\int\nolimits_{0}^{\pi /2}{\cos }^{2}{\sin }^{2}(\phi )d\phi =0.125{p}_{x}$. We assume every other Pauli error occurs with probability p_x/η. Note that even if the qubits only experience X errors, evolving under the CZ interaction converts X errors into Z errors. Indeed, it does not appear that an X-bias-preserving CZ gate is physical. In addition to errors during the CZ gates, during both preparation and measurement X errors occur with probability p_x and Y and Z errors with probability p_x/η.

To build the cluster state, we apply our entangling gates in the order shown in Fig. 7 for both the RHG and XZZX cluster states, although we expect other orderings to perform similarly. This gate ordering determines the overall form of our noise model, as Pauli errors associated with one gate are propagated through subsequent gates. Note that the structure of the cluster state ensures that a Pauli error on one qubit never propagates further than that qubit’s immediate neighbors. Our ordering is compatible with building the cluster state layer-by-layer in time, as we can measure the leftmost qubits as soon as they are entangled with their neighbors without waiting for the rightmost qubits to be initialized. Our ordering also ensures that qubits can be initialized, entangled, and measured without ever sitting idle.

Fig. 7: The order in which we apply our entangling gates to build the both the RHG and XZZX cluster state.

Red edges are gates that are performed at that timestep, red vertices are qubits that are initialized for that timestep, and black edges/vertices are gates/qubits that have already been introduced in a previous timestep. We construct our cluster state layer-by-layer, so our gate order is compatible with only a 2D layer of the cluster state existing at any point in time. Note that timesteps 7 and 8 coincide with timesteps 1 and 2 for the next layer. Our choice of gate order ensures that each qubit can be initialized, entangled with its four neighbors, and then measured without ever being idle.

The MWPM decoder

To match error syndromes in a circuit-level-noise model, we use the approach originally developed in Ref. ⁵³. Given error syndrome locations {e₁, . . . , e_n}, we want to determine the most likely pairing of the error syndromes. This can be done via a MWPM algorithm, which takes as input the weights ${W}_{{e}_{i},{e}_{j}}$ between all pairs of error syndromes, and outputs a matching that minimizes the weights between them^42,43.

We determine the weights between two syndromes ${W}_{{e}_{i},{e}_{j}}$ by approximating $-\log ({P}_{{e}_{i},{e}_{j}})$, where ${P}_{{e}_{i},{e}_{j}}$ is the probability that e_i and e_j were connected by a string of errors. We generate ${W}_{{e}_{i},{e}_{j}}$ by iterating through all possible errors. For each possible preparation, measurement, or gate error during the creation of the cluster state, we determine the effect of that error on the syndromes. We illustrate a representative case in Fig. 8. We consider only errors that result in exactly two error syndromes. Each time two locations s₁ and s₂ are connected by such an error, we increment the probability ${p}_{{s}_{1}{s}_{2}}$ associated with that connection by the probability of that error. We then define the local weight between two syndrome locations to be ${w}_{{s}_{1}{s}_{2}}=-\log ({p}_{{s}_{1}{s}_{2}})$, with ${w}_{{s}_{1}{s}_{2}}=\infty$ if s₁ and s₂ are not connected by any error. The true weight ${W}_{{e}_{1}{e}_{2}}$ between two syndrome locations e_i and e_j is then defined to be the smallest sum of local weights for all paths connecting e_i and e_j:

$${W}_{{e}_{i}{e}_{j}}=\mathop{\min }\limits_{\{s\}}\left[{w}_{{e}_{i}{s}_{1}}+{w}_{{s}_{1}{s}_{2}}+\cdots +{w}_{{s}_{m}{e}_{j}}\right].$$

(18)

The weights W can be efficiently determined from the local weights w. Standard pathfinding algorithms⁸² compute a weight ${W}_{{e}_{i}{e}_{j}}$ in time $O(n\log (n))$, where n is the number of qubits.

Fig. 8: An example of propagating errors in the RHG cluster state.

If an X ⊗ X error occurs after the CZ gate highlighted in red while building the RHG state, subsequent CZ gates spread X errors to Z errors on neighboring qubits. The X ⊗ X error on the CZ gate results in a Pauli error on the final state that involves three Z operators and two X operators. When we measure the qubits in the X basis, the X errors do nothing, while the Z errors result in erroneous measurements on the red highlighted qubits. Overall, the X ⊗ X error results in the error syndrome shown.

Determining the threshold

To determine the threshold, we use the method of⁸³. For a given η, we simulate a cluster state of size d experiencing errors at a physical error rate p_z and determine the logical error probability p_L; we repeat this procedure for various values of d and p_z. Near threshold p_th and for large values d, the logical error rate has the scaling form

$${p}_{L}=f\left((p-{p}_{{{{\rm{th}}}}}){d}^{1/\nu }\right)$$

(19)

for some scaling parameter ν. Expanding f(x) ≈ A + Bx + Cx² for small x, we fit the values of A, B, C, ν, and p_th to give an estimate of p_th.

The error bars in our estimate for p_th come from the uncertainty in this fit. The uncertainty originates from statistical uncertainty in our estimate for p_L, but does not include possible systematic errors from our approximation to f(x) or finite-size effects, as is standard when using the method of ref. ⁸³.

For each threshold estimate, we take data at four different distances d and 12 − 15 different values of p_CZ within 20% of our threshold value. For the XZZX cluster state with η≥100 we use an asymmetric cluster state with distance 3d in the time- and Z-directions, and distance d in the X-direction for d = 5, 6, 7, 8. For all other simulations, we consider a cluster state with distance d in all directions for d = 12, 13, 14, 15. We assume perfect stabilizer measurements on the time boundaries, so that error strings only end on the X- and Z-boundaries. For each value of d and p_CZ we estimate the value of p_L through some number n_S of Monte Carlo samples, which ranges from n_S = 68, 000 for our smallest systems to n_S = 1600 for our largest system. When performing the fits, we weight the data according to the statistical uncertainty, so that data points with less uncertainty are weighted more highly in the fit. We include more details of the distances d and the values p_CZ we consider in the supplemental material⁴⁹.