Partial Syndrome Measurement for Hypergraph Product Codes

Hypergraph product codes are a promising avenue to achieving fault-tolerant quantum computation with constant overhead. When embedding these and other constant-rate qLDPC codes into 2D, a significant number of nonlocal connections are required, posing difficulties for some quantum computing architectures. In this work, we introduce a fault-tolerance scheme that aims to alleviate the effects of implementing this nonlocality by measuring generators acting on spatially distant qubits less frequently than those which do not. We investigate the performance of a simplified version of this scheme, where the measured generators are randomly selected. When applied to hypergraph product codes and a modified small-set-flip decoding algorithm, we prove that for a sufficiently high percentage of generators being measured, a threshold still exists. We also find numerical evidence that the logical error rate is exponentially suppressed even when a large constant fraction of generators are not measured.


Introduction
Quantum computers have the theoretical potential to solve problems intractable for classical computers.However, realizing this potential requires dealing with the noise inherent in nearand far-term devices.One way of doing this is to redundantly encode the quantum information in a quantum error-correcting code (QECC) and manipulate the encoded states to do computation.The threshold theorem [1][2][3] guarantees that such a procedure can work for arbitrarily long circuits as long as the noise rate of the sys-Noah Berthusen: nfbert@umd.edutem is below some threshold.Although polylogarithmic overhead is needed in the general case, it was later shown that the use of asymptotically good quantum low-density parity-check (qLDPC) codes could reduce the overhead to a constant [4].The question of whether such codes existed was unanswered until recently [5][6][7][8]; however, these constructions are currently more theoretical than practical.
When implementing QECCs on hardware it is especially advantageous to use one that is qLDPC, as its stabilizer generators act on a constant number of qubits, and its qubits are involved in a constant number of stabilizer generators.For certain architectures, such as nuclear magnetic resonance or superconducting qubits, another desirable code property is locality.A code is considered local in Z 2 if, when embedded in a grid of size √ n × √ n, its generators act on qubits within a ball of constant radius.Recently, a popular choice when implementing a code family with these properties has been the surface code and its variations [9,10].While it has local, weight-four generators and a favorable Θ( √ n) distance scaling, the surface code has a rate, k/n, which tends to zero as n approaches infinity.A qLDPC code family that avoids this issue is hypergraph product (HGP) codes [11].This construction has the same Θ( √ n) distance scaling, but now with a constant rate; the tradeoff, however, is that the stabilizer generators of HPG codes are very nonlocal.It was shown in Refs.[12,13] that there is an intimate relationship between locality and the corresponding code parameters.In particular, the distance d for a local code in Z 2 is bounded above by O( √ n), and the number of logical qubits k obeys the relation kd 2 = O(n).As such, the surface code saturates these bounds.Later work [14,15] more precisely quantified the amount of nonlocality required to surpass them., each stabilizer generator has a parameter γ that denotes the radius of the ball containing the qubits in its support.(b) Two possible distributions of γ over the set of generators.The most advantageous distributions for this scheme are those where the relative frequency decays exponentially with increasing γ (red curve).(c) An example schedule for the generator measurements.The syndrome extraction circuits for the smaller generators are able to be prepared quickly, and so their syndromes are available during every round of error correction (red dashed lines).The larger generators require more time to build their syndrome extraction circuits, so this is done over a period of time that may stretch over several error correction rounds.More practically, priority is given to the smaller generators, and after completing them, the larger generators are worked on using any remaining time before an error correction round.
In this paper, we show through analytic and numerical evidence that repeated quantum error correction with HGP codes still provides a threshold even when a constant fraction of generators are measured only after many rounds of error correction.This result suggests that it may be possible to build a fault-tolerant quantum computer with nonlocal qLDPC codes on architectures restricted to 2D local gates with a procedure based on the stacked model [14].After embedding a QECC in a grid of size √ n × √ n, the stabilizer generators are partitioned into a stack of layers based on the radius of the ball containing the qubits they act on.The bottom layer of the stack contains local generators, and as we move up the stack, the interaction radius increases while the number of generators of that size decreases.Ideally, we can use codes which when embedded into Z 2 have the property that the number of generators decreases exponentially with increasing radius; that is, a (large) constant fraction of the generators act on qubits within a support of constant radius.It was also shown in Ref. [14] that any code constrained to the above model has a distance that is bounded by O(n 2/3 ) and obeys the relation k 3 d 4 = O(n 5 ).HGP codes satisfy this trade-off. 1he stacked model has a natural application when performing fault-tolerant quantum compu-tations.To convert a quantum circuit into a fault-tolerant version, the qubits are first encoded in some QECC, and then each operation in the original circuit is replaced with a fault-tolerant gadget.Errors may still occur in the individual gates, so after each time step of the circuit, a round of fault-tolerant error correction is performed.To do this, the eigenvalues of the stabilizer generators of the code are measured to learn the syndrome, which is then used by a decoder to deduce and correct the error.Measurement of the generators at the bottom of the stack takes constant time, since they are local.The corresponding syndrome information is then available during every round of error correction.As we move up the stack, the interaction radius increases.The important distinction to make is that while the generators are nonlocal, we are still measuring them with only 2D local gates, and so extracting these syndromes takes longer than for local generators.These nonlocal generators are measured less frequently than those lower in the stack, and their syndrome is not always available.This scheme is depicted in Fig. 1.
Several recent works have provided evidence against the possibility of doing error correction on architectures restricted to 2D local gates.Delfosse et al. [16] investigated the problem of performing syndrome extraction circuits of HGP codes using 2D local gates and classical communication and presented numerical simulations suggesting that the resulting overhead was pro-hibitive.However, when considering the same problem in the context of the stacked model, it is possible that significant reductions in overhead could be gained by not measuring the generators with a large interaction radius every error correction cycle, since most of the work required is due to these very nonlocal generators.
We can roughly approximate the amount of work required to perform syndrome measurement using 2D local gates by estimating the number of SWAP gates in the extraction circuits.For a generator with interaction radius γ, the total number of SWAP gates needed to perform the syndrome measurement is proportional to γ.As a concrete example, consider a qLDPC code on n = 100, 000 qubits which when embedded into Z 2 results in a generator distribution where the number of generators decays exponentially with increasing γ.Drawing O(n) generators from this distribution and summing the radii of the smallest 90% is ∼ 3% of the total sum across all generators.Thus, we can estimate that the syndrome of these smallest 90% of generators can be obtained using only ∼ 3% of the SWAP gates required to perform all of the syndrome measurements.Obtaining the remaining 10% of the syndromes requires the majority of the work, but these circuits are built up over time (see Fig. 1(c)), allowing for a significant portion of the full error correction capabilities to be available during each error correction round.Although the resulting logical error rates will be strictly larger than when using a full syndrome, the reductions in overhead may outweigh the increases in the logical error rate.A rigorous investigation of this question is the focus of further research [17].
Baspin et al. [18] provide further evidence against 2D local implementations of qLDPC codes by deriving bounds on the amount of overhead needed to perform error correction at a given logical error rate.They show that the restriction to 2D local gates incurs polynomial overhead.However, they also note that their definition of error rate is very restrictive and that computations not satisfying this definition might not obey the overhead bound.It therefore remains possible that the stacked model could be used to perform these computations with constant overhead.Apart from this brief discussion, we do not rigorously prove the feasibility of the stacked model as a whole or refute the claims put forth by these authors.This work only addresses the question of partial syndromes and their effect on performing error correction in the phenomenological noise model.
The remainder of the work is structured as follows.In Section 2 we give a brief review of classical and quantum coding theory and introduce the families of codes relevant to this work.Section 3 introduces the idea of masking and contextualizes it with respect to the stacked model.In Section 4, we apply previous results to provide some analytical bounds on using masking during multi-round error correction.Section 5 provides empirical evidence to suggest that the analytical thresholds are better in practice.Finally, we conclude in Section 6 with a summary and discussion of the remaining problems.
where H is a full rank binary matrix of size (n − k) × n called the parity check matrix.The distance d of a linear code is the minimum Hamming weight of a nonzero codeword.We can also represent the code C with its Tanner graph, a bipartite graph G = (V ⊔ C, E) whose biadjacency matrix is H.
An [[n, k, d]] quantum error correcting code Q encodes k logical qubits into a 2 k -dimensional subspace of the n qubit, 2 n -dimensional Hilbert space, (C 2 ) ⊗n = C 2 n .A commonly used class of QECCs are stabilizer codes [19,20].A stabilizer code is defined by its stabilizer S, consisting of elements of the Pauli group whose action is the identity on the codewords of Q.To have a codespace at all, we require that −I / ∈ S and that S forms an abelian subgroup of P n .Denote by N (S) the normalizer of S, the set of Paulis that commute with everything in the stabilizer, The distance d of Q is then defined to be the minimum weight of an operator in N (S) \ S. S is generated by m = n − k independent stabilizer generators S = ⟨S 1 , ..., S m ⟩, which when measured provide an error syndrome of length m used to deduce the error.We note that the syndrome labels the 2 m cosets of P n /N (S).
The binary symplectic representation of a Pauli P ∈ P n /{±1, ±i} is a bitstring consisting of two n-bit binary vectors, (x|z) ∈ F 2n 2 .The ith component of x is 0 if P acts on qubit i with I or Z and 1 if P acts on qubit i with X or Y .Similarly, the ith component of z is 0 if P acts on qubit i with I or X and 1 if P acts on qubit i with Z or Y .This transformation allows us to use techniques from classical coding theory on QECCs.In particular, we can represent the stabilizer generators as a m × 2n binary parity check matrix, H.If we consider then some error E = (x|z) ∈ F 2n 2 , the corresponding syndrome is σ(E) = H • E, where multiplication and addition are performed over F 2 .
CSS codes [21] are a subclass of stabilizer codes where the stabilizer generators consist entirely of tensor products of X and I or Z and I.As such, these codes have parity check matrices of the symplectic form In this form, it can be seen that decoding CSS codes can be broken down into decoding the two classical codes with parity check matrices H Z and H X separately, where H Z corrects bit-flip errors and H X corrects phase-flip errors.In this case, separate syndromes are needed to decode an error E = (x|z), In this work, it may be unclear with respect to which stabilizer generators a syndrome is measured.Where clarification is needed, we slightly abuse notation and write a syndrome taken from a subset of the stabilizer U ⊆ S as σ U (E).Using this notation, we do not explicitly specify the type of error we are measuring, but in all cases we will only consider one type.We let the Tanner graph of a CSS code, G = (V ⊔ C X ⊔ C Z , E), to be the bipartite graph defined by its parity check matrix in symplectic form.The two disjoint sets of check nodes, C X , C Z , correspond to the X− and Z−type stabilizer generators, respectively.
A classical or quantum code is considered a low density parity check code if the weights of the rows and columns of its parity check matrix are bounded by a constant.Specifically, an for some constants ∆ V and ∆ C , each qubit is involved in at most ∆ V stabilizer generators and each generator measures at most ∆ C qubits.We can equivalently say that the Tanner graph has bit node degree bounded by ∆ V and check node degree bounded by ∆ C .

Quantum Expander Codes
Hypergraph product (HGP) codes [11] are CSS type codes made by taking the graph product of two classical codes C 1 , C 2 .When C := C 1 = C 2 is a binary linear code with parameters [n, k, d] and a full-rank parity check matrix, the parameters of the resulting hypergraph product code are Furthermore, when the base code is replaced with a classical expander code [22], the resulting quantum code is deemed a quantum expander code and is equipped with a linear time decoding algorithm which we now describe.
The small-set flip (SSF) decoding algorithm [23] aims to imitate the classical flip decoding algorithm used to decode classical expander codes.Let F be the set of powersets of qubits in X−type generators and let E be the initial X−type error.A single round takes as input a guessed error Êi and the syndrome of the remaining error σ i := σ Z (E ⊕ Êi ).The decoder then goes through all 'small-sets' f ∈ F and finds the one that when flipped maximizes the decrease in syndrome weight, which is then applied to the guessed error for the next round.The algorithm succeeds if the final error has zero syndrome and is not a logical operation; otherwise, it fails.In other words, decoding is considered a success if the guessed error Ê is equivalent to the actual error E, that is E ⊕ Ê belongs to the stabilizer group.The success of the decoder is guaranteed for errors of size less than the distance, as well as random errors of linear size [24] provided the underlying classical codes are sufficiently expanding.
The complete decoding procedure is listed as pseudo-code in Algorithm 1.It takes as input a tuple (E, D), where E ⊆ V is an X−type error, and D ⊆ C Z is a potential syndrome error-that is the algorithm runs instead on the syndrome where some values have been flipped, σ Z (E) ⊕ D. We make one small change to the algorithm for the purposes of using it in the context of the Algorithm 1: Small-set flip decoding algorithm [23] Require: (E, D) stacked model.Specifically, we exchange using the full syndrome for one taken from some subset of the stabilizer generators U ⊆ S. We still search through every opposite type generator when looking for small-sets F to flip; however, the effect of flipping will only be visible on the restricted set of generators σ U (F ).We overload the meaning of having the input (E, D) when D ⊆ C Z is interpreted as a mask, in which case the available syndrome is σ D (F ).The chosen interpretation will be clear from context.

Fault-Tolerance
A quantum circuit is considered fault-tolerant if it prevents errors from propagating throughout the circuit; in this way, it keeps the size of the error manageable for the QECC.We can convert a circuit into a fault-tolerant version by replacing each element of the original circuit with a faulttolerant gadget performing an equivalent operation on the encoded state.Fault-tolerant circuits can be naturally broken down into time steps, where a single time step consists of gadgets applied in parallel followed by error correction.
To investigate how an error propagates throughout a fault-tolerant circuit, we abstract the above model and instead work with the procedure described in Algorithm 2. For the purposes of analysis and simulation, we condense all gadgets, except error correction, into a single event that has an error with probability p phys .We also assume that the error correction itself is ideal and that there is no syndrome error, except the artificially imposed error coming from the generators that have been masked with probability p mask , which we now define.We later discuss how to Algorithm 2: A simplified faulttolerance scheme Apply a mask D with probability p mask for t = 1, ..., τ do Generate an error F t with probability p phys and apply F t to the current error: Run Algorithm 1 on the input (E t , D) and correct using the decoded error Êt : Generate an error F t with probability p phys and apply to the current error: Run Algorithm 1 on the input (E T , ∅) make this scheme more realistic, but for the purposes of determining the effects of performing error correction with partial syndromes this simplified model is sufficient.

Syndrome masking
The notion of masking has recently been introduced as a way of describing fault-tolerant protocols for space-time codes [25].We use the same idea here, although in a different context.An element of the stabilizer is considered masked if we cannot measure its eigenvalue during an error correction round.We follow the definition from [25] and define two subgroups of the stabilizer, U and T , where U ⊆ T ⊆ S. The always unmasked subgroup, U , are the stabilizers whose eigenvalues can be measured in a constant number of rounds, whereas the temporarily unmasked subgroup, T , are the stabilizers whose eigenvalues can be measured in a number of rounds that can scale with the size of the code, n.In general, it could be the case that T ⊊ S where the set S\T contains stabilizers that cannot be measured on any time scale.
In this work, we consider the case U ⊂ T = S.
The subgroups form valid stabilizer codes, and as such can be described by their parameters.Defining k for these codes has no real meaning since logical information is not being stored in the subspace; however, we can define the corresponding distances, where In other words, d U (d T ) is the weight of the smallest Pauli operator outside of the full group that has zero syndrome when measuring only the stabilizer generators of U (T ).We call d U and d T masked distances, whereas d is the unmasked distance.Note that Since not every generator is measured, the resulting syndrome may have less information about the error than would otherwise be available if the full set of stabilizer generators were measured.For any number of masked generators, there is a set of invisible errors that have zero syndrome on the generators of U (or T ) while having a nonzero syndrome in S. In particular, the new normalizer N (U ) contains N (S) as well as all cosets of P n /N (S) labeled with undetectable error syndromes.Furthermore, errors that were previously correctable may no longer be uniquely identifiable with the syndrome of U or T .Note that errors with a zero syndrome for U do not immediately cause logical errors, unlike errors with a zero syndrome for all of S. If an error has a nonzero syndrome for T , it will eventually be detected, once the generators of T \U are unmasked.The risk is that such errors will accumulate over time and become logical errors before they can be corrected.

Masking and the Stacked Model
Identifying which layers of the stack are available during an error correction round corresponds to specifying the temporarily unmasked subgroup, T t , at each time step in the circuit, t = 1, ..., τ .The always unmasked subgroup, U ⊂ T t , is static over the execution of the circuit and so can be specified at the beginning.This set contains all local generators, as their eigenvalues can be measured in constant time.T t will contain U as well as any additional layers that have completed syndrome extraction between time t−1 and t.Since, in general, we want to measure all generators throughout the course of the circuit, t T t = S; however, it may not be the case that any one time step has all generators available.An equivalent interpretation is to specify S \T t , the set of generators whose eigenvalues are not available during time step t.For the remainder of the work, we consider 'applying' a mask D to be specifying this set, S \ T t .

Analytic results
In this section, we consider previous results on HGP codes and the SSF decoder in the context of masking in a multi-round error correction procedure.We consider qubit errors and syndrome masks that follow a local stochastic noise model.

Definition 1. (Local stochastic error model).
We say that an error (E, D) is local stochastic if there are error parameters (p phys , p synd ) such that for any F and L, HGP codes in conjunction with the SSF decoder have several desirable properties that make them a strong contender for fault-tolerance with constant overhead.Most relevant to us is the fact that they can tolerate random qubit errors and syndrome errors of linear size, as stated in the following theorem.Theorem 1. (modified from Fawzi, Grospellier, Leverrier [26]).There exists a non-zero constant p 0 > 0 such that the following holds.Suppose that the error (E, D) each satisfy a local stochastic noise model with parameters p phys and p synd where p phys < p 0 and p synd < p 0 .If we run Algorithm 1 on the input (E, D) then there exists a random variable E ls ⊆ V with a local stochastic distribution with parameter p ls := p synd such that: In the analysis for the above theorem, Fawzi et al. consider an error D in the syndrome to be a subset of the stabilizer generators whose measurement results have been flipped.Very briefly, the argument requires that the syndrome error does not form clusters on the syndrome adjacency graph [4] for it to be tolerable.As such, p 0 must be below the percolation threshold of the syndrome adjacency graph of Q.This value is a constant that depends only on ∆ V and ∆ C of the code.We can turn the result of a masked measurement into the above form by randomly assigning measurement outcomes to the generators included in the mask.Thus, in this context, we can say that Theorem 1 holds when a mask-turned syndrome error-D satisfies a local stochastic noise model with parameter p mask < p 0 .
The above analysis is sufficient in the case where we do a single round of masked error correction; however, when we use the same mask over several rounds, we have to be more careful about accounting for the correlations between error sources.Following the notation of Algorithm 2, in each round t we have the syndrome error from the mask D, any error that was not fully corrected in the previous round E t−1 , and a new error F t .When considered individually, all three error sources are local stochastic described by parameters p mask , p res , and p phys , respectively.When looked at together, the new error and the syndrome error are bounded by and similarly for the residual error and the new error, as per the definition of a locally stochastic error.However, we would expect to see correlations arise between the residual error and the syndrome error over the rounds, and so together they no longer obey a local stochastic noise model.Instead, they are bounded by: When max{p res , p mask } < p 0 , the threshold from Theorem 1, we can say that the probability of clustering is at most e −Θ( √ N ) by plugging the error bound in Eq. (6) into Theorem 17 ([24]).With this, we can apply Lemma 26 ([26]) to bound the probability of the residual error obeying a local stochastic distribution, Pr[S ⊆ E ls ].Besides the requirement that E ∪ D forms clusters with low probability, we need that Pr Since we assumed that the mask was chosen according to a local stochastic error model, this statement is satisfied for all rounds t ≤ τ.We are then able to apply Theorem 1 in an iterative manner, yielding the following result.[27]).Let p 0 be the threshold of Theorem 1, and let p mask and p phys be such that:

Theorem 2. (Grospellier
and Then Algorithm 2 fails with probability at most If the conditions for Theorem 2 are satisfied, then we can make the failure probability for the procedure arbitrarily small by using larger codes.This result is perhaps surprising given the following two claims: Claim 1. Applying a random mask D with parameter p mask to a qLDPC code Q results in a code Q ′ = Q(S\D) whose Tanner graph has the following degree distribution: Here, we use the notation deg(Q |v ) to mean the degree of node v in Q.Since we assume Q to be LDPC, deg(v) is bounded by a constant ∆ V for all v, but the values may differ between vertices.= Ω(1) for all qubits.In this case, an error on such a qubit has zero syndrome on the remaining unmasked generators, U .As this error would not be an element of the stabilizer, d U = 1.

Corollary 1. Randomly masking a constant fraction of generators results in a masked distance of d
Although the always unmasked subgroup U has a bad distance d U with high probability, it is capable of performing enough error correction in the intermediate steps to prevent the accumulation of errors.When the full set of stabilizer generators are unmasked at the end of the multi-round decoding procedure, it is then likely able to correct any residual errors.As we will now show, we see similar behavior at masking percentages well above what is guaranteed analytically.

Numerical simulations
In this section, we report on the results of numerical simulations of a multi-round decoding protocol as described in Section 2.3.Previous work has investigated the single-round performance of HGP codes using a variety of decoders [28-  and gives evidence for thresholds at near-stateof-the-art error rates.Here, we provide alternative evidence of exponential error suppression in both masked and unmasked cases following the methodology of Ref. [32].
We investigate a family of HGP codes constructed from a single classical expander code family and decode them using the small-set flip decoding algorithm.HGP codes-being CSS codes-can have bit-and phase-flip errors decoded independently.Furthermore, HGP codes constructed from a single base code have equivalent parity check matrices H X , H Z , and therefore, without loss of generality, we focus on the problem of decoding X−type errors.The specific quantum code family considered is constructed from a base (5, 6)-LDPC code family, resulting in (12,11)-qLDPC codes.These codes have a rate of 1/61 ≈ 0.016.The results presented here correspond to a specific (un)masking schedule, which is a potential modification of Algorithm 2 and a way of specifying when and by how much to apply a mask to the syndrome.In particular, we study the following two models: • Simple scheduling.Apply a mask D with a masking percentage of p mask to use for all τ error correction rounds.After τ rounds, remove the mask completely and perform one error correction round with the fully unmasked syndrome.
• Iterative scheduling.Apply a mask D with masking percentage p mask .After a multiple of 10 t−1 rounds, for t > 0, remove 1 − 10 −(t−1) % of the mask.For each of these instances, remove the same portion of the mask each time.On rounds 10 t−1 + 1, all generators that were temporarily unmasked in the previous round are re-masked until another 10 t−1 rounds have passed.After τ rounds, again remove the mask completely and perform one round of error correction.
In Fig. 2(a) we show the logical error rate, p log , as a function of the number of rounds for a [[3904, 64, 16]] code and the simple unmasking schedule.Data is obtained by running Algorithm 2 for a fixed number of rounds with an error rate of p = 0.001 while varying the masking percentage, p mask , and then recording the percentage of samples that end with a logical error.A sample is considered to end with a logical error if the final state is not equal to the initial state, up to stabilizer elements.We extract the logical error per round, ϵ L , by fitting the data to the exponential The error bars on the fits are taken from the standard error of sampling a binomial distribution, p log (1 − p log )/N .In the bottom panel of Fig. 2, we now fix p mask = 0.1 and show the performance of the simple unmasking schedule across the code family.The codes are labelled with their parameters as described in Section 2.2.While finding the distance of a code is generally hard, we are able to exhaustively search through the codewords of the base classical code to determine the distance of it, as well as the corresponding HGP code.Here, we observe even spacing between curves on the semilog plot showing exponential error suppression with code size.This behavior is more easily seen as the linear downwards trend in Fig. 3, which we now more precisely quantify.We can relate a code family and values for logical error per round with an exponential error suppression factor Λ. For simple models, the equation where C is a fitting constant and d is the distance of the code, heuristically describes this relationship well.In Fig. 3(a) and (b), we show the logical error per round as a function of code distance for the simple and iterative schedules, respectively.For each masking percentage, we fit a linearized Eq. (10) with log ϵ L to obtain Λ.These values are listed in Table 1.A value of Λ > 1 is a clear indication of operating below the threshold, as increasing the code size gives an exponential de-crease in the logical error rate per round.For simple scheduling, we find that for masking percentages below 50%, Λ is in this regime.Increasing p mask decreases Λ, and between 40% and 50% we see a transition where Λ < 1.In this case, it is no longer advantageous to increase the code size, as it actually causes more logical errors to occur.
The results of the iterative unmasking schedule are shown in Fig. 3(b), where we find that it outperforms the simple schedule.For smaller masking percentages, it is not as advantageous to use a schedule with more unmasking, as there is less difference in performance between small masking percentages and completely unmasking (see Fig. 2(a)).However, larger masking percentages appear to benefit more from using a more frequent unmasking schedule.In fact, with iterative scheduling, it is now the case that 50% masked is back in the Λ < 1 regime, although with very little error suppression.Fig. 3(c)-(f), highlights this difference between schedules.
In both cases, we find that the results exceed the guarantees provided by Theorem 2. We find that the percolation threshold of this family of (12, 10)−qLDPC codes is around 2%; however, we see exponential error suppression at error rates up to ∼ 50%, well above this threshold.

2D Hyperbolic Surface Codes
As a comparison, we benchmark the performance of a 2D hyperbolic surface code on the multi-round decoding protocol.Although codes based on tilings of closed hyperbolic surfaces have a comparatively poor asymptotic distance, d = Θ(log n), they have a constant encoding rate.These parameters violate the Bravyi-Poulin-Terhal bounds [13], and therefore embedding these codes in 2D Euclidean space is not possible without nonlocal connections.However, they are in some sense close to being local, and so they make a good candidate for the stacked model.For the construction and threshold simulations of these codes, we point the interested reader to Ref. [33].As the SSF decoder is not known to work for 2D hyperbolic surface codes, we instead use the minimum-weight perfect matching (MWPM) decoder [34].While we no longer have the guarantees of Theorem 2, the MWPM decoder can be modified to work with masked stabilizer generators.To do this, we set the nodes corresponding to masked generators as boundaries in the matching graph and set the corresponding syndrome bits to zero.Decoding normally, it is then possible to match unpaired syndrome nodes to the boundary.Note that the standard solution to decoding with syndrome noise of building a 3D matching graph with a time dimension does not work since the mask is fixed from round to round, and the repeated measurements provide no additional information.
The code we investigate comes from a family of {5, 4}-codes with an asymptotic rate of 1/10 and has parameters [[360, 38, 8]].In Fig. 4 we show the results of running Algorithm 2 with this code and an error rate of p = 0.003 for several iterative unmasking schedules.We compare completely unmasked decoding (blue markers) with a schedule that alternates between performing no error correction and 0% masked each round (yellow markers) and one where the masking percentage alternates between 10% and 0% masked each round (red markers).For these codes and decoder, we find that it is actually better to do nothing and let the errors accumulate rather than try to correct the errors with the partial syndrome.We note that we did not observe this behavior for HGP codes, even at the higher error rate.This result is interesting as it seems to imply that the masking behavior for HPG codes is non-trivial.One possible explanation for the difference is the single-shot [35,36] property of the SSF decoder, a property not found in the MWPM decoder.Intuitively, this means that the syndrome has redundancies that make it more resilient to syndrome errors and masks.Over a multi-round decoding procedure, the single-shot property also ensures that the size of any residual error is proportional to the size of the syndrome error.Consequently, misdiagnosing an error cannot have immediate effects throughout the system, since the size of the resulting error is bounded.This is not the case with the MWPM decoder, where a wellplaced syndrome error could result in a long error chain across the lattice.

Discussion
In this paper, we investigated the feasibility of performing error correction with partial syndromes and found reasonable performance while masking a large constant fraction of the generators.With these results, we have motivated a new practical protocol based on the stacked model for implementing nonlocal qLDPC codes on quantum hardware restricted to 2D local gates.We note that while this limitation has been the main motivation for this work, it is possible that architectures where connectivity is not as much of a constraint might still benefit from such a protocol.Even for architectures like neutral atoms or trapped ions with effectively all-to-all connectivity, nonlocal gates are still costly in the sense that transport of the qubits is required to perform them.Limiting the number of these operations could provide overhead improvements.There are a number of questions that need to be answered to determine whether this procedure is feasible in general.
• What families of codes are amenable to the stacked model?Theoretically, the parameters for HGP codes built from classical expander codes are allowable in this model.
In the preparation of this work, some effort was given to find specific embeddings in Z 2 that yielded good generator size distributions; however, the resulting distributions instead often favored mid-sized generators.The consequence of this is that the largest p mask % of generators take roughly p mask % of the work to measure.To take full advantage of the stacked model, we would instead want those largest generators to take ≫ p mask % of the work to measure.It is possible that other code families fit better into this model.One option are codes based on tessellations of closed, 4D hyperbolic manifolds [37] which are equipped with an efficient, single-shot decoder [38,39].Another option are generalized bicycle codes [40,41], which might have favorable embeddings.
• What do the syndrome extraction circuits look like for the stacked model?The central idea of the stacked model is that the nonlocal generators are being prepared while the local generators are being used for decoding.
Careful thought has to be put into the syndrome extraction circuit to ensure that we do not fall into the same pitfall of accumulating too many errors while the nonlocal generators are being prepared.A naïve syndrome extraction circuit consisting of SWAP gates will take ω(1) time to prepare generators of size ω(1), which is prohibitively long.Alternatively, one could use the syndrome extraction circuits of Ref. [16]; this method solves the scaling issue by utilizing ancilla qubits to perform long-range CNOT gates in constant depth.Remaining technicalities include the use of entanglement distillation [42,43] to ensure the resulting long-range CNOT gates are of high enough fidelity.
• How long does it take to perform a set of masked syndrome measurements?As discussed in the previous question, performing the syndrome extraction of a single generator can be accomplished in constant time.However, when restricted to O(n) ancilla qubits, the same cannot be said for a growing number of nonlocal generators.Bounds on the depth of 2D local circuits needed to measure the full syndrome of a stabilizer code were developed in Ref. [16].Extending these bounds to include specifying generator size distributions will help inform explicit unmasking schedules, which may provide better performance than the arbitrarily chosen ones studied in this work.These three questions form the basis for a practical implementation of the stacked model and are the focus of future work [17].
Several decoders for HGP codes including belief propagation [31] and ordered statistic decoding [30,44] have been shown to perform better than the SSF decoder.An interesting question is whether these decoders work as well with the addition of masked generators.Further improvements to the simulation can be gained by using a more realistic fault-tolerance model; in general, the error correction itself can be noisy and result in errors on the qubits and syndrome.Ultimately, performing noisy, circuit-level simulations of the syndrome extraction similar to those done in Ref. [16] will determine whether this protocol is possible as a whole.at https://github.com/noahberthusen/hgp_partial_syndrome.

Figure 1 :
Figure 1: Overview of the stacked model.(a) After embedding a quantum code into Z2 , each stabilizer generator has a parameter γ that denotes the radius of the ball containing the qubits in its support.(b) Two possible distributions of γ over the set of generators.The most advantageous distributions for this scheme are those where the relative frequency decays exponentially with increasing γ (red curve).(c) An example schedule for the generator measurements.The syndrome extraction circuits for the smaller generators are able to be prepared quickly, and so their syndromes are available during every round of error correction (red dashed lines).The larger generators require more time to build their syndrome extraction circuits, so this is done over a period of time that may stretch over several error correction rounds.More practically, priority is given to the smaller generators, and after completing them, the larger generators are worked on using any remaining time before an error correction round.

Figure 2 :
Figure 2: (a) Semilog plot of logical error rate as a function of the number of rounds for a [[3904, 64, 16]] code and the simple unmasking schedule.(b) Logical error rate as a function of rounds across the (12, 11)-qLDPC code family with fixed p mask = 10% and the simple unmasking schedule.Both panels include fits of Eq. (9), for which we only include data with t ≥ 300.

Figure 3 :
Figure3: (a) Semilog plot of logical error rate per round, ϵ L , as a function of code distance for the simple unmasking schedule and an error rate of p = 0.001.The fits are of a linearized Eq. (10) with log ϵ L .(b) Similar results for iterative scheduling.Note that we do not include 0% masking in this case because it is equivalent to the simple schedule.Panels (c)-(f) plot the same data from panels (a)-(b) and provide easier comparisons between the simple (dot markers) and iterative (x markers) scheduling for p mask = {10%, 20%, 30%, 50%}, respectively.The shaded region for all panels indicates error bars for C and Λ.

Table 1 :
Extracted values of Λ for different masking percentages and schedules.