Classical product code constructions for quantum Calderbank-Shor-Steane codes

,


Introduction
Quantum information processing offers promising new solutions to problems in computation, communication, and cryptography [45].The presence of noise in all quantum operations, however, results in the degradation of the quantum information present in a quantum system and is one of the major obstacles to the development and widespread application of quantum technologies.Calderbank-Shor-Steane (CSS) codes [11,57] and, more generally, stabilizer codes [23] can be employed to encode quantum information in a way that is resilient to errors affecting the physical qubits.Quantum error correction can then be applied to preserve the encoded quantum information in the presence of noise, with the ultimate goals of realising fully fault-tolerant quantum computation and robust encoders and decoders for quantum state transmission over noisy channels [30].
A quantum error correction approach that has gained prominence in the last few years is the use of quantum low-density parity-check (LDPC) codes [10], i.e., stabilizer codes having syndrome measurements of low weight.Low-weight stabilizers are considered favorable for fault-tolerance, since the quantum gates and measurements that implement them are also subject to noise.In the quantum information community LDPC is reserved to codes that furthermore feature a high encoding rate (i.e., a high ratio of logical qubits to physical qubits).In fact, many long-established stabilizer code families, such as the well-known toric code, only encode a constant number of logical qubits and thus their encoding rate is inversely proportional to the number of employed physical qubits.Recent works have showcased that, for realistic physical error rates and practically useful blocks sizes, LDPC codes achieve error correction performances similar to that of the toric code but with encoding rates around ten times higher [8].This demonstrates that the search for the best-performing stabilizer codes is far from concluded and that hitherto unexplored code families may still yield improvements for certain applications.
In this work we introduce a novel natural method to construct LDPC-like CSS codes based on classical product codes.The construction is very structured and yet flexible enough to produce codes exhibiting favourable properties.Our endeavour started from the observation that classical product codes were historically one of the first efficient coding constructions [19].In general, classical code construction methods cannot be directly applied in the quantum domain: the commutativity of all stabilizer generators must be enforced, which imposes additional constraints on the code structure.Prior to this work, the only CSS code based on classical product codes was proposed by Hivadi in [32]; however, Hivadi's construction was restricted to the two-fold product of single parity check (SPC) codes, yielding codes with minimum distance only equal to 4.

Comparison with other product code constructions
In the classical domain, product operations produce powerful codes from two (or more) weaker component codes.For two component codes, the code words can be represented as a rectangular array whose columns are code words of one code and rows are code words of the other, see Figure 1.A further construction, tensor product codes, was originally introduced in [60] with applications, e.g., to channels with burst errors.The code's parity-check matrix (PCM) is obtained by taking the tensor product of the PCMs of two codes.Tensor product codes were further generalized in [34] and extended to the construction of quantum error correcting codes in [20].
The first notion of product codes introduced in the quantum information literature has been that of hyper-graph product [58], which gave the first family of quantum LDPC codes having constant rate and minimum distance scaling as the square root of the block length.Later, it was realised that the hyper-graph product can be seen as a special case of the homological product of chain complexes [6], which can be leveraged, e.g., to construct quantum error correcting codes exhibiting single-shot error correction properties [52].Asymptotically superior codes have been built using so-called lifted products [47] and balanced products [9] constructions.These techniques have culminated in the seminal result of constructing the first known families of asymptotically good quantum LDPC codes, i.e. having constant stabilizer weight, constant rate, and linearly growing minimum distance [48].See also [10] for more details on quantum product code constructions.
These quantum product techniques are built to automatically satisfy the stabilizer commutativity condition and therefore are in spirit and in implementation very different from classical product codes.As far as the authors know, classical product codes remained unused in quantum error correction until Hivadi [32] showed that if H is the parity check matrix of the 2-fold product of the [4s, 4s − 1] single parity check code, then there exists a permutation π such that HπH T = 0.This gives a [[16s 2 , 16s 2 − 16s + 2, 4]] quantum CSS code for any s ∈ N, with the X and Z parity check matrices given by H and Hπ T respectively.

Classical product construction for CSS codes
This work introduces a new product code construction which greatly generalizes the one given by Hivadi in [32].We show that the construction does not apply uniquely to SPC codes, but actually to any family of codes which can be seen as tensor products of other codes.Equipped with this interpretation, for the first time we extend the construction to the D-fold product of codes, which allows us to obtain codes of arbitrarily large distances.
These codes do not technically satisfy the LDPC condition as the stabilizer weight grows unbounded under D-fold products for D → ∞, but in practice the growth is rather slow; on the positive side, the encoding rate converges to 1, as opposed to merely reaching a constant value.Crucially, we show that in the intermediate and practically relevant regime with block sizes involving a few hundred qubits, these codes exhibit superior performance compared to some other codes stemming from true LDPC code families.Furthermore, our codes come with so-called meta-checks naturally embedded in their structure.They are beneficial as they can be used to correct errors that occur in the syndrome measurement readouts, which are always present in practice.This is a step towards single-shot decoding and simplifies the route towards full fault-tolerance.We also show that it is possible to construct codes having different X and Z PCMs, which can yield codes having asymmetric protection against X and Z errors and which might be appealing for certain error models.
Within our general construction, we identify in particular a [[512, 174, 8]] code that is an especially promising candidate for quantum error correction in the near term.This code combines many desirable properties: high rate; high ability to correct errors; low weight of the syndrome measurements; parallelizable and hardware friendly syndrome measurement circuit; redundancy in the syndrome measurements that guarantees the correction of one syndrome read-out error (even under adversarial noise).We then numerically evaluate the practical performance of this code using the maximum likelihood decoder on the quantum erasure channel and Belief Propagation (BP) without any post-processing on the depolarising channel.This code achieves good performance in both cases, outperforming codes chosen from other well-known families.As far as the authors know, prior work on quantum error correction offers examples that have some of these desirable properties, but no prior example has all of them at the same time.
Finally, we believe that the codes from our product code families may be particularly good candidates to be experimentally implemented, in the near future, in quantum computers based on arrays of Rydberg atoms [4,27,2,33,62].In fact, there exists a good synergy with this quantum computing platform, as it can realise the transport of an array of atoms and, therefore, can implement a fast fully-parallelised implementation of the syndrome measurements defining our CSS product codes [63,5].

Paper organisation
Section 2 introduces required notation and preliminary information, followed by a description of the new code constructions in 3. A comparison with other codes from the literature is presented in Section 4, while the resilience to syndrome errors is discussed in Section 5, before concluding the paper in Section 6.

Classical codes
Let F 2 denote the field with two elements and F n 2 denote the vector space over F 2 of column vectors with n components, i.e., the set of bit strings of length n.Extending the notation further, let F m×n 2 denote the space of matrices having m rows and n columns with elements from F 2 .
Let C ⊆ F n 2 be a linear vector space which we interpret as the set of all valid code words.We say that C is a (binary linear) code.If the F 2 -linear dimension of C is k (there are 2 k total code words) we say that C encodes k bits in n bits, where n is the length of the code, k is the dimension of the code and R = k/n ≤ 1 is the rate of the code.The distance d of a code C is the minimum Hamming distance between any pair of distinct code words and, since C is linear, we also have d = min w∈C\{0} |w|, where | • | denotes the Hamming weight.We summarise the parameters of a classical code C with an ordered triple [n, k, d] giving the length, dimension, and minimum distance of the code.Sometimes we omit the code minimum distance and write only [n, k].
A linear code can be defined as the kernel of a PCM H ∈ F m×n 2 , i.e., C = {w ∈ F n 2 : Hw = 0}.For a bit string y ∈ F n 2 we call e = Hy the syndrome associated to y.A code can be also specified by a generator matrix G ∈ F n×k 2 so that the code space is given by the F 2 -linear combination of the columns of G, that is C = Im(G), and the equation HG = 0 holds.A PCM H may have linearly dependent rows, thus r = rank(H) ≤ m and the code dimension is given as Product code constructions typically result in a certain number m = m − r of linearly dependent (i.e., redundant) checks, which we call meta-checks.Product code constructions can result in the introduction of new meta-checks, besides the ones that may be already present in the components codes.
Given H we denote w c (w r ) the maximum Hamming weight of any given column (row) of H.We say that a family of PCMs is sparse when w c and w r are upper bounded by a constant or by a slowly growing function of the code size.
Figure 1: Array representation of the 54 bits of a code given by the product of a [9,6] and of a [6,4] systematic code.The final rate is R = (6/9)(4/6) = 4/9.The bits on white cells correspond to message bits, bits on hatched cells corresponds to parity-check bits, bits on doubly-hatched cells to checks-of-checks or meta-checks.

Classical product codes (C × )
Consider two classical codes . The corresponding 2-fold product code C × is defined [19] as the code associated to the following PCM H × , Above, I denotes identity matrices of appropriate dimensions, i.e., of dimension n 2 in the top block and n 1 in the bottom block, and ⊗ the tensor or Kronecker product.The resulting product code space C × is given by the tensor product of the component codes, i.e., The code dimension is k × = k 1 k 2 , the maximum weight by row and columns can be directly deduced from (1), while the code minimum distance is given by d × = d 1 d 2 (see Appendix A for a proof of the minimum distance).We refer to [50,Chapter 5.7] for further details on product codes.
Remark.A 2-fold product code is visualized in Figure 1.The n × = n 1 n 2 bits are placed in a 2-dimensional array having n 1 columns and n 2 rows.Errors in the product code word can be detected by measuring the syndromes.For each row one can apply the PCM H 1 in order to extract the associated syndrome, which is equivalent to applying a PCM given by H 1 ⊗ I to all the n bits.
Similarly, for each column, one can apply the PCM H 2 to extract the associated syndrome.For systematic codes (or more precisely systematic encoders), the code words w ∈ F n 2 are given by the concatenation of the message x ∈ F k 2 and a set of parity-check bits c ∈ F n−k 2 , i.e., w = (x, c).In the corresponding product code, errors are detected by checking whether the last m 1 = n 1 − k 1 bits of a row are valid linear combinations of the message bits.The same holds for the last m 2 = n 2 − k 2 bits in each column.There are m 1 m 2 bits that can be interpreted as checks-of-checks or metachecks (see Figure 1).Meta-checks can be useful in quantum error correcting codes as discussed in Section 5.
The properties of 2-fold product codes are summarised in the table below, where the subscripts 1 and 2 refer to properties of C 1 and of C 2 , respectively.

Classical binary tensor product codes (C ⊗ )
Let C 1 and C 2 be codes having associated PCMs H 1 ∈ F m1×n1  .The associated tensor product code C ⊗ is defined [60] as the code originating from the PCM ( Note that a tensor product code is not the tensor product of the component codes: we would obtain this result instead by taking the tensor product of the generator matrices of the codes.Using the fact that a code C and its dual C ⊥ := {w ∈ F n 2 | ⟨v, w⟩ = 0, ∀v ∈ C} (where ⟨•, •⟩ denotes the F 2 inner product) are obtained from each other by interchanging the roles of the parity check and of the generator matrix, we obtain From the defining properties of the tensor product it follows that r ⊗ = rank(H ⊗ ) is equal to r 1 r 2 = rank(H 1 ) rank(H 2 ), hence the dimension of the code is Moreover, one can immediately verify that the row and column weights of H ⊗ are simply given by the product of the individual row and column weights of the component codes.Tensor product codes do not have meta-checks, unless some are already present in the component codes.Finally, the distance of the code is d ⊗ = min(d 1 , d 2 ) which is discussed in Appendix A for completeness.See [61] for a short introduction to the topic and the extension to non-binary component codes.
In summary, tensor product constructions allow to create codes having higher rates than the component codes, at the cost of increasing the PCM weights and no improvement in the code distance.The properties of the tensor product code are summarised in the table below.

Quantum CSS codes
Let C(F n 2 ) ∼ = C 2 n be the complex Hilbert space associated to the space of n qubits, equipped with an orthonormal basis.Each of the 2 n basis vectors is indexed by an element of F n 2 .The Pauli operators are P = {I, X, Y, Z} (with Y = iXZ) and the n-qubit Pauli group P n acting on C(F n 2 ) is obtained by taking tensor products of n Pauli operators, together with a global phase α ∈ {±1, ±i}.That is, an element of P n has the form P = αP 1 ⊗ • • • ⊗ P n , where P j ∈ {I, X, Y, Z} for all j.stabilizer codes are defined by a commutative subgroup S ⊆ P n such that −I / ∈ S. The quantum code space is a C-linear subspace C ⊆ C(F n 2 ) defined as the set of quantum states that are stabilised by all the elements of S, that is The stabilizer group has 2 r elements, can be generated by r independent elements, and defines a quantum code C having C-dimension 2 n−r = 2 k .In analogy with the classical case, we say that k is the code dimension, n the code length, and R = k/n the code rate.
A CSS code is a stabilizer code where the stabilizer generators can be chosen to be either tensor products of I and X operators only, or tensor products of I and Z operators only.One can thus represent a CSS code with two binary PCMs: , which is associated to parity checks in the Z (computational) basis, and , which is associated to parity checks in the X (Hadamard) basis.For instance, the stabilizer elements X ⊗ X ⊗ I corresponds to the row vector (1, 1, 0) in H x and Z ⊗I ⊗Z to the row vector (1, 0, 1) in H z .The dimension of the resulting binary code is given by k Commutativity of the generators is equivalent to requiring H x (H z ) T = 0 mod 2. (5) Neglecting the global phase, an error pattern are sensitive to Z errors and that Z checks (specified via H z ) are sensitive to X errors.
For quantum CSS codes, one can distinguish different kinds of code minimum distance which we refer to as the pure distance δ and the code distance d.The pure distances for X and Z errors are given, respectively, by and we simply call δ := min(δ x , δ z ) the pure distance.By contrast, the code distances for X and Z errors are obtained by considering only errors patterns that do not leave the code-subspace invariant and thus do result in a logical error: We call d := min(d x , d z ) the code distance.Note that we always have d ≥ δ and d can be significantly larger than δ in certain cases1 .We summarise the parameters of a quantum code C with the notation

Main constructions
We first present a method for obtaining asymmetric and symmetric 2-fold products of CSS codes.Then, we generalise the symmetric construction to D-fold products.Classical product and tensor product constructions are employed in such a way that the commutativity condition for CSS codes is automatically fulfilled.

Asymmetric 2-fold product construction of CSS codes (C ⋉ )
Definition 1.Let C 1 and C 2 be CSS codes having, for ℓ ∈ {1, 2}, PCMs associated to X and Z checks given by and by . Because of the commutativity condition, these PCMs satisfy: We define the asymmetric 2-fold product quantum CSS code C ⋉ as the code associated to the following X and Z parity check matrices: We have given the definition of C ⋉ for two arbitrary CSS codes for sake of generality.We note that asymmetric product codes as here defined typically provide more protection against Z errors than X errors.This may be beneficial for error channels where Z errors occur more frequently than X errors [1,43,29,13].Alternatively, the construction methods for the X and Z PCMs may be reversed.This CSS code features meta-checks in the PCM based on the product code construction but no meta-checks in PCM based on the tensor-product code construction.Finally, the commutativity condition H x ⋉ (H z ⋉ ) T = 0 can be verified using Eq. ( 10) and the multi-linearity of tensor products (which implies 0 ⊗ M = 0 for any matrix M ).
Expressions for the pure distances can be easily derived from the distances of the underlying codes and the properties of the classical product and tensor product construction.The true code distances [see the definitions given in Eq. ( 8) and (9)] cannot be easily computed, but can only be lower bounded using d x ≥ δ x and d z ≥ δ z .In contrast to the classical case, the distance of C ⋉ can be smaller than the product of the distances of the component codes; for instance, In the table below, we report the properties of C ⋉ both for the general case (left column) and for the special case in which the two component codes are equal (right column).These properties can be straightforwardly derived from the classical product and tensor product constructions.The dimension of the CSS code C ⋉ is most easily expressed in terms of the quantities be a set of four CSS codes such that, for each ℓ ∈ {1, 2, 3, 4}, the PCMs associated to X and Z checks are . Because of the commutativity condition, these PCMs must satisfy: We define the symmetric 2-fold product quantum CSS code C ⊠ as the code associated to the following X and Z parity check matrices: Note that both the X parity checks and Z checks are given by classical product codes.Specifically, these are the products of component codes associated to . This implies, in particular, that H x ⊠ and H z ⊠ are not full-rank.One can immediately verify the commutativity condition H x ⊠ (H z ⊠ ) T = 0 using Eq. ( 13).The properties of the quantum CSS code C ⊠ are given in the table below, both for the general case and for the special case where the component codes are equal; the dimension of the code is computed via the equation k and expressed in terms of the quantities Remark.We note that there is some arbitrariness in our choice of how to present the PCMs of the product code.For instance, we may choose as Z PCM where P 1 , P 2 , P 3 , P 4 are permutation matrices of appropriate size, while keeping the X PCM unchanged.However, this definition is equivalent to the one given in Eq. ( 14), up to a re-labelling of the qubits and of the stabilizer generators.

Symmetric D-fold product construction of CSS codes (C (D) )
The construction of symmetric product CSS codes can be easily generalised to higher dimensions, by taking the product of D 2 CSS codes.For instance, by using the PCMs of a set of 9 CSS codes one can construct the PCMs of a 3-fold product code as follows: It is easy to check that it is a CSS code and its properties can be derived similarly as done for the case of a 2-fold product.The general definition of the symmetric D-fold product construction of CSS codes is as follows.
be the PCMs associated to X and Z checks, respectively.We define the symmetric D-fold product CSS code C (D) as the code associated to the following X and Z parity check matrices: where Stack denotes the operation of creating an m × n matrix (m = j m j ) by stacking m j × n matrices one above the other.
Other equivalent definitions of the code C (D) could be given by choosing different orderings of the matrices H x ℓ and H z ℓ in the tensor products.The properties of this code can be obtained with similar procedures as in the previous examples.For instance, we can compute the number of meta-checks m α (D) , for α ∈ {x, z}, by where k x (D) and k z (D) are the classical code dimensions associated to the X and Z PCMs.These can be computed as a function of n ℓ and r α ℓ using the definitions of H α (D) in ( 19) and (20), resulting in We summarise the properties of this family of codes for the special case where all the component codes are equal (the expressions for the general case are lengthy and can be derived straightforwardly).

Single-parity-check D-fold product CSS codes (C SPC(D) )
We now specialise the symmetric D-fold product construction to the case where the component codes are all given by single-parity-check (SPC) codes.The choice of SPC codes as component CSS codes is motivated by the fact that the length of D-fold product codes grows very fast in D (as n D 2 ), thus reasonably sized product codes can be obtained only for very small sizes of the component codes.A favourable choice is then H x ℓ = H z ℓ = 1 1 ∀ℓ, corresponding to the 2-qubit code having stabilizer generators X ⊗ X and Z ⊗ Z.Note that this CSS code has zero encoding rate, since the only quantum state in its code space is the Bell state Nonetheless, the D-fold product CSS codes obtained from it have a positive encoding rate for all D ≥ 2. We thus arrive at the following definition.
) otherwise (24) and employ them to construct a D-fold product CSS code as described in Definition 3. We call the resulting code a single-parity-check D-fold product CSS code and denote it either C SPC(D,s) or more simply C SPC(D) in the case s = 1.
Note that the codes associated to X and Z checks are the same up to permutations of the columns of H x and H z , and are isomorphic to the D-fold product of the [s2 D , s2 D − 1] SPC code.The free parameter s ∈ N may be used to increase the rate.The SPC(D, s) code family features a pure distance that grows asymptotically with D and, moreover, the distance is equal to the pure distance, d = δ = 2 D , as we prove in Appendix A.
The properties of this code family are summarised in the table below.
Properties of C SPC(D,s) X and Z row weight

Comparison with previous works
In this section, we compare the performance of our codes against the performance of other code families.
We start by selecting the SPC(3) code, i.e., the CSS code from the family described in Section 3.4 with parameters D = 3, s = 1.More explicitly, this is the CSS code associated to the following 3-fold product codes: where h = 1 1 and I = ( 1 0 0 1 ).This results in a [[512, 174, 8]] CSS code where all row weights are 8 and all column weights are 3; each matrix has 23 linearly dependent rows (i.e., meta-checks).

Previous code families participating in the comparison
Next, we search for codes from other families having similar parameters to the SPC(3) code.
Bicycle codes [42] were one of the first families of quantum LDPC codes to be proposed.A bicycle code is obtained by first randomly selecting a n/2 × n/2 cyclic matrix C, which in our case has row weight 8. Next, the matrix H 0 = C C T is constructed.Then, we proceed to remove k/2 rows from H 0 in order to obtain a matrix H 1 with (n − k)/2 rows.Finally, the PCM of the bicycle code is obtained by setting H x = H z = H 1 .Different strategies can be followed in order to remove rows from H 0 to obtain H 1 .In our case, we follow an approach that aims at obtaining a matrix H 1 whose column weights are as uniform as possible.In particular, we follow a greedy approach in which rows are removed one by one, and the row to be removed is always selected so as to keep the column weights as uniform as possible.A bicycle code with parameters [[512,174,2]] is then obtained.The block length and rate are chosen to be equal to those of the SPC(3) code, but for this high encoding rate we could not find codes having minimum distance larger than 2. [58] were introduced as a generalization of the surface code; thus the surface code can be viewed as a hypergraph product of a certain representation of the repetition code with itself.More generally, [58,Theorem 1] gives the following construction: if H is a full rank m × n PCM of a [n, k, d] classical linear code, then the quantum CSS code with parity check matrices

Hypergraph product codes
For the present comparison, we want a hypergraph product code with parameters as close as possible to [[512, 174]]; the closest that one can get within this family is for n = 21, m = 8, k = 13, giving a [[505, 169]] quantum CSS code.It is known that the distance of a [21,13] classical linear code is at most 4 [26].Using a computer search, we found a sparse [21,13,4] classical code that leads to a [[505, 169, 4]] hypergraph product code.The rows of the parity check matrices have weights between 9 and 13.Most of the columns have weight 3, but some have higher weights up to 10.
Quantum Tanner codes [37] were introduced as an asymptotically good family of quantum LDPC codes.Recently, [28,38,18,39] have discussed efficient decoders for these codes.There are slight variations in the construction of quantum Tanner codes between the various references.For the present comparison, we adopt the approach of [38,39] which avoids the total non-conjugacy constraint.
A quantum Tanner code is described by seven components: a finite group G, two subsets The group G and its two subsets A, B define an incidence structure with vertices, edges and squares called a left-right Cayley complex [17].In the approach of [38,39], the vertices are the edges are and the squares are Q = ((g, 0, 0), (ag, 0, 1), (agb, 1, 1), (gb, 1, 0) Qubits are placed on the squares and constraints are placed on the vertices.If i + j mod 2 = 0, vertex (g, i, j) imposes the x constraints with PCM H A ⊗ H B on the connected squares/qubits, and if i + j mod 2 = 1, then vertex (g, i, j) imposes the z constraints with PCM H ⊥ A ⊗ H ⊥ B on the connected squares/qubits.
The resulting quantum CSS code has ∆ 2 |G| qubits and 2m(∆ − m)|G| rows in each of its parity check matrices H x , H z .The quality of the code is determined by the spectral expansion properties of the left Cayley graph Cay L (A, G) and the right Cayley graph Cay R (G, B) (i.e. the second largest magnitude of an eigenvalue of the adjacency matrix should be as small as possible), as well as the distance and robustness properties of the classical linear codes with parity check matrices For the present comparison, we require a quantum Tanner code having length and dimension close to [[512, 174]].Observing that ∆ 3 ≤ ∆ 2 |G|, we see that the only possible choices are those with ∆ ≤ 8; out of these, only the combination ∆ = 5, m = 1 gives rate around 174/512.Further, given m = 1, we want the minimum distance of ker(H A ⊗ H B ), ker(H ⊥ A ⊗ H ⊥ B ) to be more than 1; this determines H A = H ⊥ B = 1 1 1 1 1 and therefore a natural choice is The last step is to choose G, A, B. Requiring a block size around 512 fixes |G| = 20 or 21.A computer search determines that the best spectral expansion properties are given by the choices G = ⟨s, t|s 4 = t 5 = 1, ts = st2 ⟩ (32) The resulting PCMs H x , H z have rank 156 each, so we obtain a [[500, 188]] quantum Tanner code.The row weights of the parity check matrices are all 10, and the column weights are either 2 or 4. By exhaustive search of low-weight code words we have determined that the minimum distance of this code is 4.

Decoding performance with the quantum erasure channel
The first error model we consider is the quantum erasure channel E β , which acts on a single qubit state ρ as where β is a parameter of the channel specifying the probability of erasure (see [30,Chapter 5] for an introduction to quantum channels).The rightmost qubit is interpreted as a "flag" which can be read-out deterministically (since |0⟩ and |1⟩ are orthogonal states) and which heralds whether an erasure has occurred.
The main reason for considering the erasure channel is that it has been observed in [16, Section III] that for any stabilizer code on the erasure channel it is possible to efficiently perform maximum likelihood decoding: it is sufficient to find any error pattern, e.g. by Gaussian elimination, supported on the erased positions that produces the same syndrome 2 .This allows to test the performance of the codes in an unbiased manner, that is, in a way that is decoupled from the performance of efficient but sub-optimal decoding algorithms, such as belief propagation.We note, however, that erasure errors do occur in certain quantum computation models or for concatenated codes where the inner decoder can signal a decoding failure.
The probability of decoding error as a function of the probability of erasure is shown in Figure 2 (left) for the bicycle, hypergraph product code (HPC), quantum Tanner code, our construction, and for a randomly chosen (not sparse) [[512, 174]] CSS code drawn from the probability distribution described in [46].In the present case, this means that a random 512 × 512 invertible matrix A is chosen, then the first 169 rows of A and the second 169 rows of (A −1 ) T are chosen as H x and H z , respectively.
Our product code showcases the lowest logical error rate, compared to the other practically implementable codes, over the entire range of erasure probability β that we have considered.This is mainly due to the fact that our code features a larger minimum distance: the minimum distances d of the bicycle, HPC, quantum Tanner and our SPC(3) construction are 2, 4, 4 and 8, respectively.This results in an logical error rate scaling approximately as β d .Furthermore, we have performed an exhaustive search to find the multiplicity of the minimum weight errors for the bicycle, HPC, quantum Tanner codes.The bicycle code has 28 weight-2 X errors and, being self-dual, each for each X error there exists a Y error and a Z error having the same support.The HPC has 861 weight-4 X errors, 861 weight-4 Z errors and no weight-4 Y errors.The quantum Tanner code has 250 weight-4 X errors, 250 weight-4 Z errors and no weight-4 Y errors.We remark that the lower number of weight-4 errors in the quantum Tanner code compared to the HPC results in a roughly constant offset in the logarithmic plots of their logical error rates.

Decoding performance with the depolarising channel
The second error model we consider is the depolarising channel D ϵ , which acts on a single qubit state ρ as where ϵ is a parameter of the channel.The first expression clarifies that X, Y and Z Pauli errors occur with equal probability, while the second expression is based on the identity 1 4 (ρ + XρX + Y ρY + ZρZ) = I/2 and shows that the completely depolarising channel is obtained for ϵ = 3/4.
On the depolarising channel, there is no known efficiently computable maximum likelihood decoder.Instead, we use a quaternary belief propagation decoder: the messages are indexed by values in F 4 or, equivalently, by a Pauli matrix.The advantage of using this decoder, instead of using two independent binary belief propagation decoders for X and Z checks is that it keeps into account the correlation between X and Z errors in the depolarising channel.Quaternary BP decoding was first introduced in [51] (and see [3] for a review of decoding algorithms for quantum LDPC codes).For completeness we describe our implementation of the quaternary belief propagation decoder in Appendix B. Further decoding improvement may be achieved using postprocessing techniques such as ordered-statistics decoding [47,56,59] and stabilizer inactivation [15], or by exploiting the soft syndrome information that is accessible in some quantum computing hardware [21,49,53].
The probability of decoding error as a function of the depolarising rate of the channel is shown in Figure 2 (right) for the bicycle code, the hypergraph product code, the quantum Tanner code, and the [[512, 174]] code from our 3-fold product construction; we also include the randomly chosen dense [[512, 174]] CSS code.We observe that our reference SPC(3) code surpasses all other considered codes, judging by the BP error correction performance, over the considered range of depolarising noise intensities (ϵ).
The decoding performance for the random CSS code is particularly poor.This is to be expected, since the code is non-sparse and therefore unsuitable for decoding via BP.In general, the maximum-likelihood decoding of quantum codes on the depolarising channel is a very hard problem (technically, #P-hard [35]).
The decoding performance of the four sparse codes can be heuristically explained as follows.In general, it is known that the performance of the BP decoder is very sensitive to the structure of the Tanner graph.However, in the present case, it can be plainly seen that the two plots in Figure 2 are qualitatively the same for the sparse codes.Therefore, it is reasonable to conjecture that the dominant factor explaining the superior performance of the SPC code on the depolarizing channel is the same as on the erasure channel: its larger minimum distance.

Meta-checks and correction of syndrome readout errors
In this section, we show how meta-checks can be used to mitigate the effect of syndrome read-out errors.In particular, the SPC(3, s) code has a distance with respect to syndrome errors that is equal to 3, allowing us to detect and locate one syndrome read-out error, which is a first step in the direction of fault-tolerance [24,25].

Meta-check matrix
Quantum read-out measurements are prone to errors, hence the syndrome outcomes may be faulty, i.e., incorrect.Fault-tolerant error correcting codes showcase the possibility of detecting and locating errors even in the face of syndrome read-out errors.The syndrome measurements are physically implemented via quantum circuits acting on both data and ancillary qubits and measuring out the ancillary qubits alone and thus correlated errors are typically present.Circuit-level noise simulations are therefore necessary to perform an accurate evaluation of the performance of a quantum error-correcting code [22].Nonetheless, a simplified but informative analysis can be obtained using a so-called phenomenological error model: data qubit errors and syndrome read-out errors are drawn independently at random, possibly with different error probabilities.
We now explain briefly how the presence of redundant checks helps to correct errors that occur during the syndrome read-out measurements.We start considering a generic CSS code and then we specialise to the SPC(3, s) code.Let H ∈ F m×n 2 be a matrix with rank r < m (so that m − r checks are redundant), H can be either the X or the Z PCM of the CSS code.Consider the subspace S = span(H) ⊂ F m 2 of dimension r.If the device performing the syndrome measurement was perfect, the measured syndrome would be an element of S.However, when the syndrome measurement is faulty, the measured syndrome is an element s ′ ∈ F m 2 that is not necessarily in S; we may write s ′ = He + e s , where e s represents a syndrome readout error.In that case, we regard S as a linear error-correcting code and try to correct the faulty s ′ to the subspace S = span(H).The faulty syndrome decoding works independently from any data-qubit error that may be present since the meta-checks, by construction, are insensitive to them.
The matrix H plays the role of a PCM for the quantum CSS code and of a generator matrix for S = span(H).We now want to find another matrix M , such that ker(M ) = span(H); we call M a meta-check matrix.A systematic way for obtaining M is the following: use Gaussian elimination to find an invertible where M ′ ∈ F r×m

Extended parity-check matrix
Note that syndrome read-out errors e s do not directly affect the data qubits, so there is no physical correction to be applied.Nonetheless, a meta-syndrome σ ∈ F m−r 2 containing information about the location of the faulty syndrome can be obtained as σ = M s and then forwarded to the decoder that is tasked with decoding the quantum CSS code associated to H, thus yielding a two-step decoding.However, as noted in [31, Section VII] the decoding performance typically improves if one uses a single stage BP decoder directly.To this end we define extended PCM, extended error and extended syndrome H, e, s via so that s = H e holds.The extended PCM H can be interpreted as adding one hidden variable for each syndrome which may flip the result of the measurements and adding a meta-check code M to correct the effect of these hidden variables.The single-stage BP decoder takes as input the extended syndrome s ∈ F m+(m−r) 2 and aims at reconstructing the e ∈ F n+m 2 employing H to specify the bipartite graph for the massage passing algorithm.It is also possible to extend the quaternary BP that simultaneously decodes the X and Z components of the CSS code to include the meta-checks, see Appendix B for further details.
A standard way for obtaining resilience to readout errors is to repeat all the measurements k times.This can be interpreted as protecting the readout data via a repetition code; a code with PCM H would be modified to is the PCM of the k-repetition code.Doing so results in a large overhead in the number of measurements, scaling linearly in the number of repetitions.Product codes can increase the meta-check distance much more efficiently.For instance, the SPC(3) code requires a minimum of 338 measurements to be stabilized, while the associated PCM defined in Eqs.(25) and (26) achieve a meta-check distance equal to 3 while requiring only 384 measurements, an increase of about 13.6% compared to the minimum.

Decoding performance including syndrome readout errors
We have benchmarked the resilience to syndrome readout errors of the SPC(3) code under extended quaternary BP decoding.The employed phenomenological error model is given by the depolarising channel of Eq. (36) acting on the data qubits, while each syndrome is subject to readout errors that may flip the outcome with probability p (i.e., it is a classical binary symmetric channel).The BP messages are passed along the edges of a bipartite graph implicitly defined by H as in Eq. (38), where the meta-check matrix M is the one provided in Appendix A. The results are presented in Figure 3.
As a preliminary step, we have verified that by fixing p = 0 and running the quaternary BP decoding over the graphs defined by H and H, respectively, yield results that are essentially indistiguishable (blue solid line in Figure 2, right, and in Figure 3, left).This shows that BP is neither impaired nor enhanced by the extension of the decoding graph for the SPC(3) code.
We have then assessed the decoding performance of the codes described in Section 4 in presence of readout errors, with the exclusion of the random CSS code, which cannot be decoded via BP.The simulation results are presented as dashed lines in Figure 3, left, for p = 10 −3 .This readout fidelity is comparable with what can be obtained, e.g., in state of the art quantum computers based on Rydberg atom arrays [5].As expected, the codes that do not feature meta-checks, are significantly affected by readout errors.In contrast, the SPC(3) logical error rate is essentially unaffected for depolarisation rates ϵ > 6 • 10 −4 , below which it converges to an error floor of around 3 • 10 −5 .
When increasing p to higher values, p = 10 −2 or p = 10 −1 , the performance of SPC(3) with quaternary BP decoding significantly degrades, see Figure 3, right.This means that repeating the syndrome measurements a few times may be required in order to increase the meta-check distance and thus counter the effect of readout errors.

Conclusions and outlook
In this work, we have introduced new methods for constructing families of CSS codes associated to classical product codes.Quantum CSS codes are challenging to construct (compared to classical ones) since a commutativity condition between X and Z checks must be satisfied, as given in Eq. (5).Our first construction for CSS product codes is asymmetrical, in the sense that X parity checks are constructed from a classical product code and Z parity checks from a classical tensor product code, with the goal of automatically satisfying Eq. (5).A second construction is more symmetrical, having both X and Z checks associated to classical product codes, while the component codes are in the form of classical tensor product codes; this second construction showcases an increased (pure) distance against both kinds of Pauli errors compared to the component CSS codes it is constructed from.The third construction is a multi-dimensional generalisation of the second one, allowing to obtain D-fold products of component CSS codes.
An advantage of our classically-inspired product code construction is that extensive parallelisation can be achieved in measuring the parity checks.Using the array representation of a 2-fold product code (see Figure 1) it is clear that the parity checks of the component codes can be applied in parallel over all the rows of the array and, in a second step, measured in parallel over all the columns of the array.The same is true for CSS product codes and, if the qubits are physically arranged in a 2-dimensional array, as in the quantum computing architectures based on Rydberg atom [4,27,2,33,62,63,5], this can result in simplified hardware implementations.A caveat is that the columns of the PCM associated to Z are permuted compared to the PCM associated to Z checks: this means that the Z syndrome measurements act on qubits that are no longer aligned along single rows or columns of the 2-dimensional array.
Product codes yield good performances when using SPC codes as the component codes (albeit other choices are possible [14,36,44]).The heuristic motivation is that SPC codes have high encoding rate (only one parity bit of overhead) but small distance (d = 2); the product construction allows to increase the distance at the expense of decreasing the rate and yields codes having good properties for intermediate code sizes.These good properties are retained also by the corresponding quantum CSS codes.For instance, we obtain a 3-fold product SPC code that can encode 174 logical qubits in 512 physical qubits (R = 174/512 ≃ 0.34) and having distance d = 8.This code has good performances both for erasure channels and for depolarising noise under BP decoding; for instance, the second best code in our comparison is a [[500, 188]] quantum Tanner code, which exhibits logical error rates that are around two orders of magnitude higher for realistic values of the depolarising noise.
Given the promising results of these product codes, we aim to further investigate their proper-ties.Open questions regard whether there are other good choices for the component codes, besides SPC codes.This could be especially true for the asymmetric product construction, where the fact that only two component CSS codes are needed (instead of the four required in the symmetric construction) gives leeway in the choice of larger component CSS codes.Another interesting question is the possibility of achieving better practical results via code concatenation, e.g., using a surface code for low-level error correction and a product code as a high-level code to further boost the fidelity of the encoded logical qubits [13,40,54,12].
Regarding the code minimum distance d, it would be interesting to find better lower bounds, since bounds based on the pure distance δ are in general not tight (but we have shown that for the special case of SPC product codes we have d = δ).The fault-tolerance properties of these codes could be further investigated, simulating the performance of decoders under realistic circuit-level noise [22].Finally, methods for implementing fault-tolerant Clifford gates [55] and magic-state distillation [7,41] within these code families should be ascertained for realising universal quantum computation with CSS product codes.

A.3 Examples of asymmetric CSS product codes having d
Let us construct an asymmetric product CSS codes where the two base codes are both the 9-qubit Shor code.The X and Z PCMs of the Shor code are given by, respectively, 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 and note that it is a CSS code having distances d x = 3, d z = 3 and pure distances δ x = 3, δ z = 2; for instance, Z ⊗2 ⊗ I ⊗7 (corresponding to the vector e 1 + e 2 ∈ F 9 2 ) is a weight 2 undetectable Pauli operator which acts as the identity on the logical subspace.We define the asymmetric product CSS code C Shor ⋉ via the PCMs: The weight-6 Pauli-Z operator associated to the vector is as undetectable logical error for C Shor

⋉
. First, notice that H x (e 1 + e 2 ) = H x (e 1 + e 4 + e 7 ) = 0, hence v z is undetected by X parity checks, H x ⋉ v z = 0. Second, let u = e 1 ⊗ 9 i=1 e i , and note that The pattern can be extended as follows.Let The generalised code Shor(D) has parity check matrices We then consider the asymmetric product CSS code C Shor(D) ⋉ using again Eq. (42).Let us consider the weight-2D Pauli-Z operator associated to the vector v z := e 1 ⊗ (e 1 + e 2 ) ⊗ 1 D ⊗ e 1 as well as the vector u We claim that the following vector corresponds to undetectable logical error of weight 2 D for both H x SPC(D) and H z SPC(D) : ) T for ℓ = (i − 1)D + i, i = 1, . . .D To see that w (D) is not in the image of (H x SPC(D) ) T or of (H z SPC(D) ) T consider the vector Now, note that A.5 Meta-check distance for SPC(3, s) codes: d M = 3 We now show that for a SPC(3, s) code the meta-check distance is exactly d M = w c = 3 and therefore it can be used to detect and locate one faulty syndrome.Up to a permutation of the columns, the PCMs for both X and Z checks of the SPC(3, s) have the form where is the PCM associated to a [8s, 8s − 1] SPC code.An associated meta-check matrix can be constructed as the following block matrix: we have (I ⊗ H s ⊗ 1)(e i ⊗ e j ⊗ 1) = e i ⊗ 1 ⊗ 1 and similarly for other permutations of the tensor components; note that e i ⊗ 1 ⊗ 1 is different from zero.It is then possible to determine from the position of the non-zero entries of M SPC(3,s) e whether the non-zero entry of the error e is located in the first, second or third block of 64s 2 bits.Supposing, without loss of generality, that the non-zero entry of e is located in one of the first 64s 2 bits means that e = 1⊗e i ⊗e j for some values i, j.Then the two meta-syndrome outcomes (1 ⊗ I ⊗ H s )e = 1 ⊗ e i ⊗ 1 and (1 ⊗ H s ⊗ I)e = 1 ⊗ 1 ⊗ e j contain sufficient information to determine the values i, j and thus locate the position of the syndrome error.

B Quaternary belief propagation decoding of stabiliser codes
We describe an efficient implementation of quaternary BP decoding used in this work.This is a message passing algorithm where information about the likelihood of a Pauli error P = {I, X, Y, Z} on a qubit is exchanged along the edges of a graph.

B.1 Preliminaries and notation
Stabiliser code representation Let S = {S 1 , . . ., S m } be a set of generators of a stabiliser group for a quantum linear code, where each generator is a n-qubit Pauli operator, S i ∈ P n .The set of generators S can be specified via a matrix H ∈ F m×n 4 where each matrix element H i,j is in F 4 = {I, X, Y, Z} and in one-to-one correspondence to a Pauli operator P = {I, X, Y, Z}.The rows of the matrix H correspond to different stabilisers while the columns correspond to different physical qubits.The matrix H is sufficient to fully specify a stabiliser code, in contrast with the notation used in the rest of the paper where two binary matrices (H x and H z ) are needed to define a CSS code.

Commutation and anti-commutation relations We define an inner product
i.e., the inner product ⟨•, •⟩ is equal to 0 if the corresponding Pauli matrices commute and is equal to 1 if the Pauli matrices anti-commute.The commutativity of the stabiliser generators then translates to which generalises the CSS commutativity condition in Eq. (5).Similarly, given a n-qubit Pauli error E ∈ P n having associated a vector E ∈ F n 4 , the corresponding syndrome outcomes s ∈ F m 2 are obtained as Let the set Z i,j and (Z i,j ) be In other words, Z i,j (Z i,j ) corresponds to the set of Pauli operators that stabiliser S i commutes with (anti-commutes with) at qubit j.

Quantum Tanner graph representation
See Figure 4 for a graphical representation.
Message passing Decoding can be cast as passing messages between VNs and CNs along the edges of the Tanner graph.In a successive manner, all CNs send messages to all the neighbouring VNs, and all VNs exchange messages with all the neighbouring CNs until a stopping criterion is reached.CNs and VNs process incoming messages according to certain rules.Messages are (for instance) quaternary probability vectors representing an estimate of the probability of a given value of E j .Observe that the inner product in Eq. (50) yields the same binary value for two distinct values of E j , i.e., ⟨H i,j , E j ⟩ is zero for E j ∈ Z i,j and one for E j ∈ Z i,j .Hence, we can add up the respective probabilities and apply the CN processing on a binary probability vector, rather than on a quaternary probability vector.
Log-domain decoding For numerical stability message passing decoders are often implemented using ratios of logarithmic probabilities, referred to as log-likelihood ratios (LLR).For probability estimates p 0 and p 1 = 1 − p 0 of binary outcomes we define the associated LLR as For quaternary outcomes with probabilities p I , p X , p Y , p Z we define an LLR vector as  Conversions between binary and quaternary message passing Consider a stabiliser S i and a qubit j.Quaternary messages from v j to c i are converted to binary messages by computing p 1 as the sum of the probabilities associated to operators in Z i,j and then p 0 = 1 − p 1 .Binary messages from c i to v j are converted to quaternary messages by equally splitting the probability p 1 among the operators in Z i,j and equally splitting p 0 among the other two Pauli operators (i.e., those in Z i,j ).See Figure 4 for an example.For conversion of quaternary to binary messages, we will make use of the soft-max operator (max * ) which is defined as The first expression makes it obvious that max * is symmetric and associative, the second expression is the one that shall be used for a numerically stable implementation.

B.2 Update rules
Let us focus on iteration number t.An iteration consists in messages sent from CNs to VNs followed by messages sent from VNs to CNs.Let the message received by CN c i from the VN v j be L (t−1) vj →ci .The message that the CN c i sends to VN v j , L (t) ci→vj , is obtained by using the standard update rule for binary message passing decoders (embedding the syndrome value s i ): Remark.There are a manifold of approximations of the check node (CN) update rule in the literature which permit a hardware-friendly implementation.
The LLR L (t) ci→vj is converted into a quaternary LLR l (t) ci→vj for further processing at the VNs: L (t,P) ci→vj = 0 for P ∈ Z i,j −L (t) ci→vj for P ∈ Z i,j (57) where P ∈ F 4 indexes the values of the message.The VN update operation is the standard one for quaternary message passing and yields the error probability estimates where L j is the channel message (a.k.a., prior LLR) and is a P-indexed vector which depends on the channel model.For the depolarising noise in Eq. (36) we have Remark.The evaluation of Eq. ( 58) can be simplified by avoiding to construct a quaternary LLR vector L (t)

B.3 Initialization and final decision
We give the message from VN v j to CN c i at the beginning of the very first decoding iteration.We have and from (60) we obtain A hard decision Êj on the value of E j is made according to Recall that for convenience the elements of quaternary LLR are indexed by P ∈ F 4 .The decoder returns this hard decision after a maximum number of decoding iterations is reached or when the estimated error vector Ê satisfies all parity-checks.

B.4 Inclusion of meta-checks
The Tanner graph can be expanded to include readout errors and meta-checks.In particular, a new VN is added for each CN, which represents the classical readout error channel.These new VN are therefore labelled as "binary" and will process the received messages differently from the "quaternary" representing the Pauli errors on the qubits.Furthermore, these new variable nodes are connected to a new set of CNs, corresponding to the meta-checks.The extended Tanner graph is associated to a labelled adjacency matrix of the form where the leftmost columns (comprising H and 0) have entries in F 4 and the rightmost columns (comprising I and M ) have entries in F 2 .The BP decoder then becomes hybrid, where either quaternary or binary messages are passed, depending on the VN type (F 4 -type or F 2 -type).
The BP update rules are modified as follows.The CN to VN messages are always binary and are directly given by Eq. (56), for the extended set of VN, CN and neighbourhoods N (c i ).The channel message for each new variable node v j is given by L j = log p 1−p , where p is the probability of flipping the readout value.Thus, the VN to CN are computed in two different ways, depending on the VN type:  (66)

Definition 4 .
Consider the following set of PCMs for the component codes C 1 , . . ., C D 2 :

Figure 2 :
Figure 2: Monte Carlo simulation of the logical error rates of 5 different CSS codes.Left: maximum likelihood decoding under erasure channel (E β ).Right: BP decoding under depolarising channel (Dϵ).See main text for details.

2 and M ∈ F (m−r)×m 2 are= 3
full rank matrices, and where E ∈ F r×n 2 is the reduced row echelon form of H. Then we have ker(M ) = span(H) as needed.Therefore M s ′ = M (He + e s ) = M e s and M is insensitive to the data-qubit error e, as claimed.The minimum distance d M of the meta-check matrix M can be upper bounded as d M ≤ w min c , where w min c is the minimum column weight of H.To see this, let H i a minimum-weight column of H; by assumption H i ∈ span(H) = ker(M ), meaning that H i is a code word of S having weight w min c , thus proving the claim.The proof that SPC(3, s) codes have meta-check distance d M = w min c can be found in Appendix A, where furthermore we provide an explicit construction for a meta-check matrix M .

Figure 3 :
Figure 3: Monte Carlo simulations of the logical error rates under BP decoding under a depolarizing channel with syndrome measurement errors.Left: all codes are subject to either no syndrome readout error (solid lines) or to a syndrome readout flip with probability p = 10 −3 (dashed lines).Right: performance of the SPC(3) code for different values of the syndrome readout error probability p.

2 D
we see that v z is an undetected logical error, therefore the distance of C Shor(D) ⋉ is upper bounded as d z ⋉ ≤ 2D.A.4 Single-parity-check D-fold product CSS code distance: d SPC(D,s) = We have shown in the main text that δ SPC(D,s) = 2 D , thus d SPC(D,s) ≥ 2 D .Here we show that there exist logical errors of weight 2 D , thus establishing d SPC(D,s) ≤ 2 D .

e 1 : 45 )
= (1, 0) T otherwise (For example, w (2) = u ⊗ e 1 ⊗ e 1 ⊗ u and w (3) = u ⊗ e 1 ⊗ e 1 ⊗ e 1 ⊗ u ⊗ e 1 ⊗ e 1 ⊗ e 1 ⊗ u.The vector w (D) is a tensor product of D copies of u and of vectors of Hamming weight one, hence it has weight 2 D .Note that exactly one PCM in the tensor products given in Eqs.(19) and (20) is in a position ℓ of the form (i − 1)D + i and therefore we obtain H x SPC(D) w (D) = H z SPC(D) w (D) = 0.

Figure 4 :
Figure 4: Example binary/quaternary inter-conversion in message passing for a quantum Tanner graph having 7 VNs (qubits) and 3 CNs (stabiliser generators).Edges transmitting messages to one CN cj (top) and to one VN vi (bottom) are highlighted and the edges are labelled (coloured) according to the Pauli operator measured by the stabiliser Si on qubit j.

F 2
-type VN (65)with the notation given in Section B.2.The hard decision for the data-qubit errors, Eq. (63), is unmodified, while the estimate ês of the readout errors e s is obtained via the hard decision(ê s ) j = argmax   L j + i:ci∈N (vj ) A, B ⊂ G of size ∆ each that are closed under inversion, two full rank m × ∆ parity check matrices H A , H ⊥ B and two full rank (∆ − m) × m parity check matrices H ⊥ A , H B , where H A , H ⊥ A are orthogonal, and so are H B , H ⊥ B , and where m ≤ ∆/2 is a parameter that determines a lower bound (1 − 2m/∆) 2 on the rate.

)
(p I , p X , p Y , p Z ) → (p I +p Z S 1 = Y 1 X 2 Z 3 Z 5 S 2 = Y 2 Y 4 Y 5 Y 6 S 3 = X 3 X 5 Z 6 Y 7 S 1 = Y 1 X 2 Z 3 Z 5 S 2 = Y 2 Y 4 Y 5 Y 6 S 3 = X 3 X 5 Z 6 Y 7 It is sufficient to add its two non-zero elements to the respective elements of L vj →ci ) F 4 -type VN L j + i ′ : c i ′ ∈N (vj )\ci L