1 Introduction↩︎

Over the last thirty years, many QEC techniques have been developed, which use redundant physical qubits for the detection and correction of errors in such quantum systems. The framework almost universally employed to construct a QECC is that of stabilizer codes, which stands as the quantum equivalent of classical linear codes [1]. The best-known approach for obtaining stabilizer codes is the CSS construction [2], [3]. In a CSS code, the stabilizer generators can be divided into two sets: generators containing only \(X\)-type operators, up to identities, and generators containing only \(Z\)-type operators, up to identities. These two sets are derived from two classical codes that are mutually orthogonal.

Many widely used and extensively studied QECCs belong to CSS families. Notable examples include Shor’s 9-qubit code, the first proposed QECC [4], as well as several topological codes [5], [6], such as the toric code [7] and surface codes [8]. Topological codes in two dimensions are fundamentally limited in the achievable minimum distance \(d\) and coding rate \(R=k/n\) (where \(n\) is code length and \(k\) the number of encoded qubits), since the quantity \(d^2k/n\) is at most constant [9]. Thus, motivated by the need to improve the rate–distance tradeoff, the efforts of the research community have shifted towards QLDPC codes, which are codes whose stabilizer generators are sparse, or equivalently have low weight, but for which geometric locality is not imposed. This flexibility has motivated a line of work on QLDPC code constructions with progressively improved tradeoffs between minimum distances and coding rates [10]–[12]. However, asymptotic scaling does not necessarily predict finite-length performance: at short code lengths, specific instances from asymptotically weaker families may outperform instances from asymptotically stronger ones.

Most known QLDPC constructions live within the CSS framework. A question which arises naturally is what happens if this restriction is relaxed and Pauli-\(Y\) operators are also employed in the definition of the stabilizer generators. This idea is at the basis, for example, of XYZ product codes, first introduced in [13] as a generalization of HP codes [10], and further investigated in [14], [15], where the authors show that specific instances can achieve an almost-linear minimum distance and constant rate. A further example of a topological code involving \(Y\)-type stabilizers is the XYZ\(^2\) hexagonal stabilizer code [16].

In this work, we investigate a structured extension of the CSS framework that is related to, but structurally distinct from, the constructions discussed above. Unlike XYZ product codes, our framework does not impose a specific three-fold product structure; instead, we define the stabilizer PCM directly from three binary classical PCMs associated with pure \(X\)-, \(Y\)-, and \(Z\)-type stabilizer generators and satisfying pairwise orthogonality conditions. In other words, the CSS code is enriched with an additional set of pure \(Y\)-type checks. We call the resulting codes quantum XYZ stabilizer codes. The proposed framework therefore occupies an intermediate position between CSS and stabilizer codes: it allows genuinely non-CSS stabilizer structures, while its description through three classical codes allows us to use classical coding-theoretic arguments for their construction and distance analysis. However, the presence of all three Pauli types alone does not guarantee that the XYZ code is genuinely non-CSS. Characterizing the conditions under which this occurs is one of the main objectives of this work.

1.1 Main Motivation↩︎

The CSS framework offers a particularly convenient algebraic structure, but it also restricts the stabilizer configurations available for constructing a code with given parameters. Relaxing this restriction enlarges the code-design space and may provide additional freedom to exclude low-weight logical operators when designing codes with a given block length and rate. This possibility is especially relevant at finite block lengths, where the detailed structure of individual code instances can be more important than the asymptotic scaling of the underlying family. Motivated by this observation, we investigate the following conjecture: quantum XYZ stabilizer code families can achieve larger minimum distance than comparable CSS code families at the same block length and rate. In this work, we investigate this conjecture in the finite-length regime. To formalize the comparison, let \(d_{\mathcal{S}}(n,k)\) and \(d_{\mathrm{CSS}}(n,k)\) denote the largest minimum distance achievable by, respectively, stabilizer and CSS codes with parameters \(\llbracket n,k \rrbracket\). Since CSS codes form a subclass of stabilizer codes, it trivially holds that \(d_{\mathrm{CSS}}(n,k) \leq d_{\mathcal{S}}(n,k)\). Conversely, by the stabilizer-to-CSS mapping of [17], any stabilizer code \(\llbracket n,k,d \rrbracket\) can be mapped to a CSS code \(\llbracket 2n,2k,d' \rrbracket\) with \(d \leq d' \leq 2d\) and stabilizer generator weights at most doubled². Hence, we get \[\begin{align} d_{\mathrm{CSS}}(n,k) \leq d_{\mathcal{S}}(n,k) \leq d_{\mathrm{CSS}}(2n,2k). \end{align}\] Therefore, defining the asymptotic relative distances as a function of the rate \(R = k/n\), we get \[\begin{align} d_{\ast}^{\mathrm{rel}}(R) &:= \limsup_{n\to\infty} \frac{1}{n} d_{\ast}(n,\lfloor Rn\rfloor), \end{align}\] with \(\ast\in\{\mathcal{S}, \mathrm{CSS}\}\). As a consequence, we obtain \[\begin{align} \label{eq:rel95d} d_{\mathrm{CSS}}^{\mathrm{rel}}(R) \leq d_{\mathcal{S}}^{\mathrm{rel}}(R) \leq 2 d_{\mathrm{CSS}}^{\mathrm{rel}}(R). \end{align}\tag{1}\] Eq. 1 shows that relaxing the CSS restriction cannot yield more than a constant-factor improvement in the asymptotic relative distance. It does not, however, preclude substantial improvements for specific finite-length parameters. Although this comparison concerns general stabilizer codes, quantum XYZ stabilizer codes provide a structured non-CSS setting in which such a finite-length advantage can be investigated using convenient analytical tools. Our objective is therefore to determine whether the additional design freedom offered by quantum XYZ stabilizer codes can produce better distance–rate tradeoffs in the short-block-length regime. Although a larger minimum distance does not necessarily imply better performance under every decoder and noise model, the numerical results presented later show that the proposed QLDPC XYZ instances can achieve lower LER than representative CSS instances under low-complexity BP decoding.

1.2 Our Contribution↩︎

As anticipated, our main contribution is the introduction of quantum XYZ stabilizer codes, a class of stabilizer codes whose PCM is specified by three binary classical codes satisfying pairwise orthogonality conditions.

We first provide a structural characterization of this construction. We show how the row spans associated with the \(X\)-, \(Y\)-, and \(Z\)-type stabilizers decompose into reducible and irreducible components, thereby separating the part that is already generated by an underlying CSS structure from the part that is genuinely XYZ. This leads to necessary and sufficient conditions for an XYZ code to be (or not to be) CSS, and to rank criteria for detecting when the \(Y\)-type checks do not introduce a genuinely new stabilizer structure. We also discuss the stronger notions of genuineness under uniform and local Pauli relabeling, clarifying that the presence of \(X\)-, \(Y\)-, and \(Z\)-type generators is not sufficient to obtain a genuinely quantum XYZ stabilizer code.

Then, we perform a theoretical analysis of the distance properties of XYZ codes. We derive upper bounds by restricting the logical-operator search to pure \(X\)-, \(Y\)-, and \(Z\)-type logical operators. We then derive lower bounds by associating to every XYZ code a collection of CSS codes obtained by removing one irreducible Pauli component at a time. Since these CSS codes contain the original XYZ codespace, their distances provide lower bounds on the XYZ minimum distance. Finally, we refine this analysis for mixed Pauli logical operators, obtaining a bound that explicitly uses the interaction between the three classical component codes. These results explain, at the level of logical operators, how additional \(Y\)-type stabilizer constraints can increase the minimum distance with respect to the CSS structures from which the construction is derived.

We also provide a constructive contribution. We first show that a known topological non-CSS code, namely the XYZ\(^2\) hexagonal code [16], fits naturally within the proposed XYZ framework. Then, we use our framework to design two new sparse finite-length QLDPC XYZ code families, one based on IS codes [19] and one on QD codes [20].

Finally, we evaluate the proposed QLDPC XYZ instances over the depolarizing code-capacity channel using BP4 decoding. The simulations compare the new XYZ codes with representative CSS QLDPC codes of comparable block length, rate, and stabilizer generator weight. The results provide finite-length evidence that the additional \(Y\)-type constraints can translate the distance improvements suggested by our analysis into improved LER performance under iterative decoding.

1.3 Paper Organization↩︎

The remainder of the paper is organized as follows. Section 2 introduces the notation and preliminary material used throughout the paper. Section 3 defines quantum XYZ stabilizer codes from three pairwise orthogonal classical codes and studies their relation with CSS codes. In particular, it introduces the reducible and irreducible components of the XYZ check spaces and derives algebraic and rank criteria for identifying genuinely non-CSS instances. Section 4 investigates the minimum distance of XYZ codes by deriving upper bounds from pure logical operators and lower bounds from CSS codes imposed by the XYZ stabilizer structure, including bounds for mixed logical operators. Section 5 discusses families of stabilizer codes that fit the XYZ framework, including a known topological code instance and novel finite-length QLDPC constructions based on IS and QD codes. Section 6 presents numerical simulations over the code-capacity noise model using a BP4 decoder and compares the proposed XYZ QLDPC instances with representative CSS QLDPC codes of comparable parameters. Finally, Section 7 concludes the paper and outlines possible directions for future work.

2 Notation and Preliminaries↩︎

For \(a \in \mathbb{N}\), let \([a] := \{1,2,\dots,a\} \subset \mathbb{N}\). We use calligraphic uppercase letters to denote tuples, sets of subsets, and groups, e.g., \(\mathcal{S}\). Given a group \(\mathcal{G}\), the normalizer of a subgroup \(\mathcal{S}\subseteq \mathcal{G}\) is denoted by \(\mathcal{N}(\mathcal{S})\). Column vectors, e.g., \(\mathbf{a}\), \(\mathbf{b}\), and matrices, e.g., \(\mathbf{A}\), \(\mathbf{B}\), are denoted by bold lowercase and uppercase letters, respectively. Unless otherwise specified, the operations that involve binary vectors and matrices are performed over the binary field \(\mathbb{F}_2\). We denote transposition by \((\cdot)^{\top}\). The \(m \times m\) identity matrix is denoted as \(\mathbf{I}_m\), and the subscript is omitted when it is clear from the context. Similarly, the the all-zero and all-one matrices (vectors) are denoted by \(\mathbf{0}\) and \(\mathbf{1}\), respectively. Given a matrix \(\mathbf{A} \in \mathbb{F}_2^{m\times n}\), we denote by \(\mathrm{rk}(\mathbf{A})\) its rank over \(\mathbb{F}_2\), while using \(\mathrm{ker}(\mathbf{A}):=\{\mathbf{v}\in\mathbb{F}_2^n:\mathbf{A}\mathbf{v}=\mathbf{0}\}\), \(\mathrm{span}(\mathbf{A}) := \{\mathbf{A} \mathbf{v} \in \mathbb{F}_2^m \mid \mathbf{v} \in \mathbb{F}_2^n \}\) and \(\mathrm{row}(\mathbf{A}) = \mathrm{span}(\mathbf{A}^\top)= \{(\mathbf{w}^\top \mathbf{A})^\top \in \mathbb{F}_2^n \mid \mathbf{w} \in \mathbb{F}_2^m \}\) to indicate the null space, (column) span, and row span of \(\mathbf{A}\), respectively; with this convention, a vector in the row span of \(\mathbf{A}\), \(\mathbf{v} \in \mathrm{row}(\mathbf{A})\), is a column vector. Moreover, we write \(\mathbf{A} \!\overset{\mathrm{row}}{\sim}\!\mathbf{B}\) to indicate \(\mathrm{row}(\mathbf{A}) = \mathrm{row}(\mathbf{B})\). We omit round parentheses for functions of block matrices, e.g., \(\mathrm{span}[\mathbf{A} \, \mathbf{B}] = \mathrm{span}([\mathbf{A} \, \mathbf{B}])\). The Hamming weight (or simply weight) of the vector \(\mathbf{a}\), i.e., the number of its non-zero entries, is denoted by \(\left\lVert{\mathbf{a}}\right\rVert\).

2.1 Classical Linear Codes↩︎

A classical binary linear code \(C\) with code length \(n\), encoding \(k\) bits, and having minimum (Hamming) distance \(d\) is a \(k\)-dimensional linear subspace of \(\mathbb{F}_2^{n}\), where the minimum distance \(d\) is equal to the weight of a minimum-weight non-zero codeword \(\mathbf{c} \in C\). The coding rate of \(C\) is \(R := k/n\). A linear code is defined as the null space of a PCM \(\mathbf{H}\in\mathbb{F}_2^{m \times n}\), with \(m \geq n-k = \mathrm{rk}(\mathbf{H})\) (where the PCM may have linearly dependent rows), that is, \(C := \mathrm{ker}(\mathbf{H}) = \left\{\mathbf{c} \in\mathbb{F}_2^n\mid \mathbf{H}\mathbf{c} = \mathbf{0}\right\}\), where \(\mathbf{c} \in C\) is a codeword. Alternatively, we can define \(C := \mathrm{span}(\mathbf{G})\), where \(\mathbf{G} \in \mathbb{F}_2^{n \times k}\) satisfying \(\mathbf{H} \mathbf{G} = \mathbf{0}\) is a (full-rank) generator matrix of the code. We denote the dual code of \(C\) by \(C^\perp[n, n - k, d^\perp]\), that is, \(C^\perp := \left\{\mathbf{w} \in\mathbb{F}_2^n \mid \mathbf{c}^\top\mathbf{w} = 0, \, \forall \, \mathbf{c} \in C \right\}\). With \(C_1 + C_2\) we denote the linear subspace obtained by vector spaces addition, namely \(C_1 + C_2 = \{ c_1 + c_2 \, | \, c_1 \in C_1, c_2 \in C_2 \}\) and with \(C_1 \oplus C_2\) their direct sum, corresponding to the addition of linearly independent subspaces.

2.2 Quantum Information↩︎

We denote the single-qubit Pauli group as \[\begin{align} \mathcal{P}_1 := \{\phi\,\mathbf{P} \mid \phi\in\Phi,\;\mathbf{P}\in\{\mathbf{I},\mathbf{X},\mathbf{Y},\mathbf{Z}\}\}, \Phi := \{\pm 1, \pm i\}, \end{align}\] where \(\mathbf{Y}=i\mathbf{X}\mathbf{Z}\).³ We define a Pauli operator on \(n\) qubits as the \(n\)-fold tensor product of \(n\) elements of \(\mathcal{P}_1\), which can be expressed as \(\mathbf{P} = \phi \, \mathbf{P}_1 \otimes \, \dots \, \otimes \mathbf{P}_{n} \in (\mathbb{C}^{2 \times 2})^{\otimes n}\), where \(\phi\in\Phi\) is the global phase, and \(\mathbf{P}_i \in \{ \mathbf{I}, \mathbf{X}, \mathbf{Y}, \mathbf{Z} \}\). Then, the Pauli operators act on \(n\) qubits and form the so-called n-qubit Pauli group \(\mathcal{P}_{n}\). In Pauli tensor products, the symbol \(\otimes\) and identities will be omitted, and we will just indicate the qubit on which each Pauli is acting (e.g., \(\mathbf{P} = \mathbf{X}_2\mathbf{Y}_5\) acts with \(\mathbf{X}\) on qubit 2 and \(\mathbf{Y}\) on qubit 5). We also denote with \(\text{wt}(\mathbf{P})\) the weight of a Pauli operator \(\mathbf{P} \in \mathcal{P}_{n}\), which consists of the number of non-trivial, i.e., non-identity, elements in its associated tensor product decomposition.

Next, we consider the quotient Pauli group \(\mathcal{P}_n/\Phi\), where Pauli operators differing only by a global phase are regarded as equivalent, on which we define the bijective map: \[\begin{align} \label{eq:mapping} \notag \mathbf{I} \mapsto [0 \, | \, 0], & \quad \mathbf{X} \mapsto [1 \, | \, 0], \quad \mathbf{Z} \mapsto [0 \, | \, 1], \quad \mathbf{Y} \mapsto [1 \, | \, 1], \\ & \mathbf{P} \mapsto \left[ \mathbf{u}^\top \, | \, \mathbf{v}^\top \right] = [u_1 \dots u_n \, | \, v_1 \dots v_n], \end{align}\tag{2}\] where \(u_i, v_i \in \mathbb{F}_2\) and the index \(i\) represents the \(i\)-th qubit. This induces a group isomorphism between \({\mathcal{P}}_n/\Phi\), with the group operation inherited from multiplication in \(\mathcal{P}_n\), and the additive group \(\mathbb{F}_2^{2n}\) and a non-invertible (many-to-one) mapping from \(\mathcal{P}_n\) to \(\mathbb{F}_{2}^{2n}\). Note that \[\begin{align} \label{eq:weight95identity} \text{wt}(\mathbf{P}) = \left\lVert{\mathbf{u} \vee \mathbf{v}}\right\rVert = \tfrac{1}{2}(\left\lVert{\mathbf{u}}\right\rVert+\left\lVert{\mathbf{v}}\right\rVert+\left\lVert{\mathbf{w}}\right\rVert), \end{align}\tag{3}\] where \(\vee\) denotes the bit-wise OR and \(\mathbf{w}=\mathbf{u}+\mathbf{v}\). The last equality follows from \(\left\lVert{\mathbf{u} \vee \mathbf{v}}\right\rVert = \left\lVert{\mathbf{u}}\right\rVert + \left\lVert{\mathbf{v}}\right\rVert - \left\lVert{\mathbf{u} \wedge \mathbf{v}}\right\rVert\) and \(\left\lVert{\mathbf{u} + \mathbf{v}}\right\rVert = \left\lVert{\mathbf{u}}\right\rVert + \left\lVert{\mathbf{v}}\right\rVert - 2\left\lVert{\mathbf{u} \wedge \mathbf{v}}\right\rVert\), where \(\wedge\) denotes the bit-wise AND.

We call pure \(X\)-, \(Y\)-, and \(Z\)-type Pauli operators the \(n\)-qubit Pauli operators whose non-identity tensor factors are, respectively, only \(\mathbf{X}\), only \(\mathbf{Y}\), or only \(\mathbf{Z}\), independently of the global phase, and mixed otherwise. Two \(n\)-qubit Pauli operators \(\mathbf{P}_1, \mathbf{P}_2 \in \mathcal{P}_n\) either commute (\(\mathbf{P}_1 \mathbf{P}_2 = \mathbf{P}_2 \mathbf{P}_1\)) or anti-commute (\(\mathbf{P}_1 \mathbf{P}_2 = -\mathbf{P}_2 \mathbf{P}_1\)). Using the mappings \(\mathbf{P}_1 \mapsto [\mathbf{u}_1^\top | \mathbf{v}_1^\top]\) and \(\mathbf{P}_2 \mapsto [\mathbf{u}_2^\top | \mathbf{v}_2^\top]\), we say that \(\mathbf{P}_1\) and \(\mathbf{P}_2\) commute iff \(\mathbf{u}_1 \cdot \mathbf{v}_2 + \mathbf{v}_1 \cdot \mathbf{u}_2 = 0\).

2.3 Stabilizer Codes↩︎

Qubit stabilizer codes are the quantum analogue of classical binary linear codes [1].

By leveraging the isomorphism in 2 we can rewrite the stabilizer formalism in matrix form as follows.

Note that, in the binary representation, the set \(\Phi\mathcal{S}\) corresponds to \(\mathrm{row}(\mathbf{H}_{\mathcal{S}})\), while the scalar subgroup \(\Phi\{\mathbf{I}\}\) corresponds to the zero vector.

A special subclass of such stabilizer codes, in which the stabilizer generators consist exclusively of \(X\)-type or \(Z\)-type Pauli operators, is given by the so-called CSS codes [2], [3].

As a consequence, CSS codes allow correcting \(X\)-type and \(Z\)-type errors separately. In particular, the classical code \(C_{\mathrm{X}}\) with associated PCM \(\mathbf{H}_{\mathrm{X}}\) is used to correct \(Z\)-type errors, and similarly for \(C_{\mathrm{Z}}\) and \(\mathbf{H}_{\mathrm{Z}}\) with \(X\)-type errors.

See, e.g., [2] for a proof.

2.4 Error Model and Syndromes↩︎

In this paper, we benchmark our codes using a code capacity noise model which is based, specifically, on the depolarizing channel. In this quantum channel, each qubit is affected by a \(\mathbf{X}\), \(\mathbf{Z}\), or \(\mathbf{Y}\) Pauli operator with probability \(p/3\) each, and remains unaffected with probability \(1 - p\), where \(p\) is the depolarizing probability. The syndromes associated to these errors are obtained as follows.

Note that with the block-diagonal structure of the PCM of CSS codes the syndrome outcome decouples as \[\begin{align} \label{eq:CSS95syn} \mathbf{s}_{\mathrm{X}} = \mathbf{H}_{\mathrm{X}}\mathbf{e}_{\mathrm{Z}}, \quad \mathbf{s}_{\mathrm{Z}} = \mathbf{H}_{\mathrm{Z}}\mathbf{e}_{\mathrm{X}}, \end{align}\tag{7}\] so that \(X\)- and \(Z\)-type errors can be corrected separately. This does not hold for the quantum XYZ stabilizer codes considered here, motivating the decoding strategy described in Section 3.1.

2.5 Quantum LDPC Codes↩︎

A quantum stabilizer code is referred to as QLDPC when its PCM is sparse. Its Tanner graph [23] contains one variable node per qubit and one check node per stabilizer generator, with an edge whenever the generator acts nontrivially on the corresponding qubit. For non-CSS codes, each edge is additionally labeled by its Pauli type. We denote the uniform stabilizer weight by \(w_{\text{r}}\) (which is the row weight of the corresponding PCM) and the girth of the Tanner graph associated with \(\mathbf{H}_\sigma\) by \(g_\sigma\), with \(\sigma \in \{ X, Y, Z \}\).

3 Quantum XYZ Stabilizer Codes↩︎

In this Section, we introduce a novel framework for non-CSS stabilizer codes, which includes an additional PCM associated with stabilizers composed exclusively of \(I\)- and \(Y\)-type operators.

3.1 Logical Operators and Syndromes of XYZ Codes↩︎

Observe that CSS codes can be chosen to have PCM consisting only of \(X\)- and \(Z\)-type operators as in 5 and logical generators consisting only of \(X\)- and \(Z\)-type operators as in 6 . For quantum XYZ stabilizer codes, the PCM is extended by adding \(Y\)-type stabilizers to 5 .⁶ For XYZ codes, unlike in the CSS case, representatives of the logical Pauli generators need not be \(X\)-type or \(Z\)-type up to identities; in general, they may mix \(X\), \(Y\), and \(Z\) components, as in ?? . Furthermore, for XYZ codes the syndrome vector \(\mathbf{s}\) is given by the horizontal stack of \[\begin{align} \mathbf{s}_{\mathrm{X}} = \mathbf{H}_{\mathrm{X}} \mathbf{e}_{\mathrm{Z}}, \; \mathbf{s}_{\mathrm{Z}} = \mathbf{H}_{\mathrm{Z}} \mathbf{e}_{\mathrm{X}}, \; \text{and} \; \mathbf{s}_{\mathrm{Y}} = \mathbf{H}_{\mathrm{Y}} (\mathbf{e}_{\mathrm{X}} + \mathbf{e}_{\mathrm{Z}}). \end{align}\] Unlike in CSS codes, \(X\)- and \(Z\)-type errors are mixed in \(\mathbf{s}_{\mathrm{Y}}\) and thus they must be decoded jointly.

3.2 Matrix Decomposition of XYZ Codes↩︎

Notice that a \(Y\)-type operator can be expressed as the sum of \(X\)- and \(Z\)-type operators. Therefore, the \(Y\)-type checks that can be obtained from \(X\)- and \(Z\)-type stabilizers are redundant. These operators produce what we call the reducible-XYZ component; the complementary part cannot be reduced to a CSS code and will be denoted as the irreducible-XYZ component. More precisely, for an XYZ code \(\mathcal{C}_{\mathrm{XYZ}}(C_{\mathrm{X}}, C_{\mathrm{Y}}, C_{\mathrm{Z}})\) having PCM as in ?? we give some definitions. In particular, the following decomposition isolates the part of the \(Y\)-type checks that is already generated by the \(X\)- and \(Z\)-type checks.

By exploiting the above definition, the PCM of an XYZ code can be rewritten as: \[\begin{align} \label{eq:red95irred} \mathbf{H}_{\mathrm{XYZ}} \!\overset{\mathrm{row}}{\sim}\! \begin{bmatrix} [c|c] \mathbf{H}_{\mathrm{X}}' & \mathbf{0} \\ \mathbf{H}_{\mathrm{X} \cap \mathrm{Y}} & \mathbf{0} \\ \mathbf{H}_{\mathrm{X} \cap \mathrm{Z}} & \mathbf{0} \\ \mathbf{0} & \mathbf{H}_{\mathrm{Z}}' \\ \mathbf{0} & \mathbf{H}_{\mathrm{Y} \cap \mathrm{Z}} \\ \mathbf{0} & \mathbf{H}_{\mathrm{X} \cap \mathrm{Z}} \\ \mathbf{H}_{\mathrm{Y}}' & \mathbf{H}_{\mathrm{Y}}' \\ \mathbf{H}_{\mathrm{Y} \cap \mathrm{Z}} & \mathbf{H}_{\mathrm{Y} \cap \mathrm{Z}} \\ \mathbf{H}_{\mathrm{X} \cap \mathrm{Y}} & \mathbf{H}_{\mathrm{X} \cap \mathrm{Y}} \end{bmatrix} \!\overset{\mathrm{row}}{\sim}\! \left[ \begin{array} {c|c} \mathbf{H}_{\mathrm{X}}' & \mathbf{0} \\ \mathbf{0} & \mathbf{H}_{\mathrm{Z}}' \\ \mathbf{H}_{\mathrm{Y}}' & \mathbf{H}_{\mathrm{Y}}' \\ \hline \mathbf{H}_\cap & \mathbf{0} \\ \mathbf{0} & \mathbf{H}_\cap \end{array} \right] . \end{align}\tag{9}\] Notice that the two lowest blocks contain the same matrix \(\mathbf{H}_\cap\) in both the \(X\) and the \(Z\) components, so these can be interpreted simultaneously as \(X\)-, \(Y\)-, and \(Z\)-type checks. In contrast, the row spans of the matrices \(\mathbf{H}_{\sigma}'\) are mutually linearly independent and each generates \(\sigma\)-type checks separately, meaning that, e.g., \(Y\)-type checks cannot be obtained by combining together \(X\)-type checks generated by \(\mathbf{H}_{\mathrm{X}}'\) and \(Z\)-type checks generated by \(\mathbf{H}_{\mathrm{Z}}'\). This matrix decomposition will be useful to identify when an XYZ code is genuine and to study the minimum distance bounds of XYZ codes, respectively in Section 3.3 and in Section 4.

3.3 Genuine XYZ Codes↩︎

In this section, we explore the connection between CSS and XYZ codes. Although the PCM of an XYZ code is built from three Pauli types, it may be a CSS code in disguise, since it is possible that its stabilizer group is generated using only two Pauli types. This could be done either directly or after the application of a LC unitary, i.e., a Clifford gate that acts on each single-qubit as a relabeling of the Pauli operators. These notions are formalized as follows.

With the next theorem, we show a necessary and sufficient condition for an XYZ code to be a CSS code.

The rank condition ?? can also be obtained directly from [24].

We now consider the notion of genuine and non-genuine XYZ codes under uniform Pauli relabeling.

3.4 Complexity of LC-equivalence to CSS Codes↩︎

A natural question raised by the above examples is whether it is possible to efficiently determine if a given stabilizer code is LC-equivalent to a CSS code as per Definition 12. To the best of our knowledge, the computational complexity of this decision problem is open. It is known that deciding the pairwise LC-equivalence of stabilizer states (that is, stabilizer codes with null rate, \(k=0\)) can be done efficiently [25], [26], but we are not aware of either a polynomial-time algorithm or a hardness result for deciding whether a stabilizer code is LC-equivalent to some CSS code. Related hard problems on graph states (such as the vertex-minor problem [27]) do not seem to be directly applicable.

In conclusion, the presence of \(X\)-, \(Y\)-, and \(Z\)-type generators in the PCM is not sufficient to guarantee a genuinely non-CSS code. The rank criteria derived above identify when the additional \(Y\)-type constraints are essential. We next study how these additional constraints affect the minimum distance.

4 Minimum Distance Bounds for XYZ codes↩︎

In this section, we derive upper and lower bounds on the quantum minimum distance of XYZ codes. The upper bound follows by restricting the logical-operator search to pure Pauli types. Lower bounds are obtained from CSS codes whose stabilizer groups are contained in the XYZ stabilizer group, and are subsequently refined for mixed logical operators using the weight identity in 3 .

We begin by deriving an upper bound by studying \(d^\sigma\), the minimum-weight logical errors consisting solely of \(\sigma\)-type operators for \(\sigma\in\{X,Y,Z\}\).⁷ This yields the following result.

Analogous results hold for \(d^{\mathrm{Y}}\) and \(d^{\mathrm{Z}}\). Summarizing, \[\begin{align} d^{\mathrm{X}} & = \min\bigl\{\left\lVert{\mathbf{v}}\right\rVert\,\big|\, \mathbf{v}\in(C_{\mathrm{Y}}\cap C_{\mathrm{Z}})\setminus(C_{\mathrm{X}}^{\perp}+C_\cap^{\perp})\bigr\}, \\ d^{\mathrm{Y}} & = \min\bigl\{\left\lVert{\mathbf{v}}\right\rVert\,\big|\, \mathbf{v}\in(C_{\mathrm{X}}\cap C_{\mathrm{Z}})\setminus(C_{\mathrm{Y}}^{\perp}+C_\cap^{\perp})\bigr\}, \\ d^{\mathrm{Z}} & = \min\bigl\{\left\lVert{\mathbf{v}}\right\rVert\,\big|\, \mathbf{v}\in(C_{\mathrm{X}}\cap C_{\mathrm{Y}})\setminus(C_{\mathrm{Z}}^{\perp}+C_\cap^{\perp})\bigr\}, \end{align}\] are the minimum-weights of logical errors consisting solely of \(X\)-, \(Y\)- and \(Z\)-type operators, respectively. Since each \(d^{\sigma}\) is the minimum weight of the set of logical operators restricted to a single Pauli type, the upper bound follows.

We now derive a lower bound on the minimum distance by considering three CSS codes whose codespaces contain the XYZ codespace. These are obtained by removing some stabilizer generators and exploiting the decomposition 9 to obtain a CSS code.

By applying the same construction after a uniform Pauli relabeling, we also use the analogous notation for the imposed CSS codes \(\mathcal{C}(\tilde{C}_{\mathrm{X}},\tilde{C}_{\mathrm{Y}})\) and \(\mathcal{C}(\tilde{C}_{\mathrm{Y}},\tilde{C}_{\mathrm{Z}})\). In particular, we set \(\tilde{\delta}_{\mathrm{Y}} := d(\tilde{C}_{\mathrm{Y}})\), and, for every ordered pair of distinct Pauli labels \(\sigma,\sigma'\in\{\mathrm{X},\mathrm{Y},\mathrm{Z}\}\), we define \(\tilde{d}_{\sigma\setminus\sigma'}:=d(\tilde{C}_{\sigma}\setminus\tilde{C}_{\sigma'}^{\perp})\) and \(\tilde{d}_{\sigma,\sigma'}:=\min\{\tilde{d}_{\sigma\setminus\sigma'},\tilde{d}_{\sigma'\setminus\sigma}\}\).

The specialization of Proposition 4 to the CSS code of Definition 13 directly results in the following propositions.

The same derivation applies to \(\mathcal{C}(\tilde{C}_{\mathrm{X}},\tilde{C}_{\mathrm{Y}})\) and \(\mathcal{C} (\tilde{C}_{\mathrm{Y}}, \tilde{C}_{\mathrm{Z}})\), which are CSS codes (up to uniform Pauli relabeling) obtained from the XYZ code by removing the stabilizers associated to \(\mathbf{H}_\mathrm{Z}'\) and to \(\mathbf{H}_\mathrm{X}'\), respectively. Thus we have \(\tilde{d}_{\mathrm{X},\mathrm{Y}}\leq d\) and \(\tilde{d}_{\mathrm{Y},\mathrm{Z}}\leq d\), that is, every non-trivial XYZ logical operator is also a non-trivial logical operator of each of these CSS codes. The lower bound below then follows.

Next, we prove a second lower bound, based on the identity in 3 for mixed Pauli operators.

Since each Pauli operator is either of pure type or mixed type, the minimum distance is also attained by a logical operator that is either of pure or mixed, which leads to the following Corollary.

Eq. ?? shows that every XYZ logical operator must also be logical for each imposed CSS code, and hence cannot be lighter than the largest imposed CSS distance. Eq. ?? , instead, captures genuinely mixed logical operators and can be stronger when the three component codes have large classical distances. Together, these bounds explain why adding \(Y\)-type stabilizers can increase the minimum distance relative to the underlying CSS constructions.

The proposed bounds require computing minimum-weight vectors in a code while excluding a given subspace. We formulate each problem as a MILP with a candidate vector \(\mathbf{x}\), linearized parity constraints enforcing \(\mathbf{x}\in\mathcal{C}\), and auxiliary syndrome variables enforcing \(\mathbf{x}\notin\mathcal{D}\), where \(\mathcal{D}\subseteq\mathcal{C}\). The objective is to minimize \(\|\mathbf{x}\|\). When the solver certifies optimality, the resulting value is exactly \(d(\mathcal{C}\setminus\mathcal{D})\). These formulations involve one \(n\)-bit candidate vector, whereas computing the exact quantum distance requires the two binary components of a Pauli operator. Therefore, the bounds are expected to be easier to compute.

5 Families of XYZ Stabilizer Codes↩︎

In this section, we use the XYZ construction to identify three families of quantum stabilizer codes. More precisely, we show how a topological code family already known in the literature, the XYZ\(^2\) code [16], is LC-equivalent to XYZ codes. Furthermore, we construct two novel families (and as many instances) of QLDPC XYZ codes: one based on IS codes [19], [28] and one based on QD codes [20], [29]–[31].

5.1 Topological Construction based on the XYZ\(^2\) Code↩︎

The XYZ\(^2\) code introduced in [16] is a 2D topological code family with parameters \(\llbracket 2d^2, 1, d \rrbracket\), obtained by placing qubits in a rhombus-shaped patch of the hexagonal lattice. Its mixed stabilizer generators are weight-\(6\) plaquette operators with type \(X Y Z X Y Z\), together with weight-\(2\) links with type \(X X\) on the vertical edges, and weight-\(3\) half-plaquette operators on the boundary. Via local Pauli relabeling, every stabilizer generator can be homogenized to a pure one and the resulting family \(\mathcal{C}_\mathrm{XYZ-2D}\llbracket 2d^2,1,d \rrbracket\) is XYZ, in the sense of Definition 8, where the code parameters are invariant under LC operations and thus inherited from the XYZ\(^2\) code. In particular, each plaquette becomes a pure \(X\)-, \(Y\)-, or \(Z\)-type stabilizer, and so does each vertical link⁸. The Tanner graph of the \(\mathcal{C}_\mathrm{XYZ-2D}\) code for \(d = 5\) is shown in Fig. 1.

It was proven that the XYZ\(^2\) codes have \(d^{\mathrm{X}} = d\) and \(d^{\mathrm{Y}} = d^{\mathrm{Z}}= 2d^2\), resulting in excellent resilience against \(Z\)- and \(Y\)-biased noise; however, these properties are not LC-invariant [16]. Preliminary investigations indicate that the minimum-weight pure-type logical operators of \(\mathcal{C}_\mathrm{XYZ-2D}\) are strings joining the two opposite corners of the rhombus (see Fig. 1), which would force \(d^\sigma = 2d-1\). This conjecture implies that minimum-weight logical operators must be mixed and would provide an explicit example of a family for which the pure-type upper bound \(U=2d-1>d\) is asymptotically loose by a factor approaching two; finally, this would endow the code with resilience against any unknown biased noise. However, such an unknown bias is a rather contrived error model, and for conventional noise channels, this code is suboptimal with respect to the XYZ\(^2\) code, whose pure \(Y\)-type and \(Z\)-type distances scale as \(n\). We therefore do not analyze the \(\mathcal{C}_\mathrm{XYZ-2D}\) family further.

5.2 XYZ Codes based on Intersecting Subset Codes↩︎

IS codes [19] stand as a generalization of the classical product code construction for CSS codes [28] and of quantum Reed-Muller codes [32]. To generalize the definition IS codes to the XYZ framework, we need to add a further PCM, associated with \(Y\)-type stabilizer generators.

In particular, the vector \(\mathbf{h}\) satisfies \(\mathbf{h} \mathbf{h}^{\top} = 0\) which, together with the intersecting subset condition ?? , guarantees that the three PCMs \(\mathbf{H}_{\mathrm{X}}\), \(\mathbf{H}_{\mathrm{Y}}\), \(\mathbf{H}_{\mathrm{Z}}\) are pairwise orthogonal⁹.

The original CSS version of the IS codes are shown to be quantum GRM codes, also known as decreasing monomial codes [33]; using this correspondence, it is possible to determine the quantum (coset) minimum distance in \(\mathrm{poly}(n)\) time [19]. The identification with GRM codes does not hold for XYZ-IS codes, and we could not find other polynomial-time algorithms to compute the minimum distance. However, it is possible to efficiently evaluate the bounds of Section 4 by exploiting the closure of CSS IS codes under sum, intersection, and orthogonal complements. These closures can be shown by representing the codes \(C_\sigma^\perp = \mathrm{row}(\mathbf{H}_{\sigma})\) with the tuple \(\mathcal{S}_\sigma\) and through this with the sets \(\mathcal{F}_\sigma := \mathcal{G}(C_\sigma^\perp) = \mathcal{F}(\mathcal{S}_\sigma)\), where \[\begin{align} \mathcal{F}(\mathcal{S}) := \{ F \subseteq[\ell] \mid F \cap S = \varnothing \text{ for some } S \in \mathcal{S} \} . \end{align}\] The correspondence is given explicitly by: \[\begin{align} C_\sigma^\perp = \mathrm{row}\! \left( \Pi[\mathcal{F}_\sigma] \begin{bmatrix} 1 & 1\\ 0 & 1 \end{bmatrix}^{\otimes \ell} \right) \end{align}\] where \(\Pi[\mathcal{F}_\sigma] \in \mathbb{F}_2^{|\mathcal{F}_\sigma| \times 2^\ell}\) is a matrix with a one in each row, in the position indexed by the corresponding element of \(\mathcal{F}_\sigma\). Sums and intersections of the codes \(C_\sigma^\perp\) correspond, respectively, to unions and intersections of the associated \(\mathcal{F}_\sigma\), while the dual code \(C_\sigma\) corresponds to \(\mathcal{G}(C_\sigma)=\{ F^c \mid F \in 2^{[\ell]} \setminus \mathcal{G}(C_\sigma^\perp)\}\), where \((\cdot)^c\) denotes set complement in \([\ell]\). Since these families are downward closed with the partial order given by set inclusion, a generating tuple for a set \(\mathcal{F}\) is recovered via \(\mathcal{S}(\mathcal{F}) = \{ F^{c} \mid F \in \max(\mathcal{F}) \}\). Hence, each \(C_\sigma^\perp\), their duals \(C_\sigma\), the pairwise intersections \(C_\sigma\cap C_{\sigma'}\), the reducible component \(C_\cap^{\perp}\), and the imposed codes \(\tilde{C}_{\mathrm{X}},\tilde{C}_{\mathrm{Y}},\tilde{C}_{\mathrm{Z}}\) of Definition 13, are all IS codes whose \(\mathcal{F}\) sets are computed explicitly from \(\mathcal{S}_{\mathrm{X}}, \mathcal{S}_{\mathrm{Y}}, \mathcal{S}_{\mathrm{Z}}\). E.g., we have \[\begin{align} \mathcal{G}(C_\cap^\perp) = (\mathcal{F}_{\mathrm X}\cap\mathcal{F}_{\mathrm Y})\cup(\mathcal{F}_{\mathrm Y}\cap\mathcal{F}_{\mathrm Z})\cup(\mathcal{F}_{\mathrm X}\cap\mathcal{F}_{\mathrm Z}). \end{align}\] Therefore, since \(\tilde{C}_{\mathrm X}^{\perp}=C_{\mathrm X}^{\perp}+C_\cap^\perp\), we obtain \[\begin{align} \mathcal{G}(\tilde{C}_{\mathrm X}^{\perp})=\mathcal{F}_{\mathrm X}\cup\bigl(\mathcal{F}_{\mathrm Y}\cap\mathcal{F}_{\mathrm Z}\bigr). \end{align}\]

As an example, we construct an XYZ code \(\mathcal{C}_{\mathrm{XYZ}-\text{IS}}\llbracket 512, 9, d \rrbracket\), with \(12\leq d \leq 16\), choosing \(\ell = 9\) and the following three tuples \[\begin{align} \begin{aligned} \mathcal{S}_{\mathrm{X}} &\!=\! \left( \begin{array}{@{}c@{}} \{1,2,3\}\\ \{4,5,6\}\\ \{7,8,9\} \end{array} \right), \; \mathcal{S}_{\mathrm{Y}} \!=\! \left( \begin{array}{@{}c@{}} \{1,5,9\}\\ \{2,6,7\}\\ \{3,4,8\}\\ \{3,5,7\}\\ \{2,4,9\}\\ \{1,6,8\} \end{array} \right), \; \mathcal{S}_{\mathrm{Z}} \!=\! \left( \begin{array}{@{}c@{}} \{1,4,7\}\\ \{2,5,8\}\\ \{3,6,9\} \end{array} \right), \end{aligned} \end{align}\] satisfying the intersection condition given in ?? . We have verified that this code is genuine, also under uniform relabeling, while extending this verification to arbitrary local relabelings would require evaluating \(6^{512}\) cases, which is computationally infeasible. We have bounded the quantum minimum distance using the closed-form distance equations of [19] for CSS IS codes to compute the bounds of Section 4. In particular, the distances with pure-type operators are \(d^\mathrm{X} = d^\mathrm{Z} = 32\) and \(d^\mathrm{Y} = 16\), giving \(U = 16\) from Corollary 2. The three CSS codes of Definition 13 have \(\tilde{\delta}_\sigma = 8\) and \(\tilde{d}_{\sigma \setminus \sigma'} = 8\) for all \(\sigma \neq \sigma'\) with \(\sigma, \sigma' \in \{ X, Y, Z \}\), hence \(L = 8\) from Corollary 3; finally, Proposition 8 yields \(B_\mathrm{X} = B_\mathrm{Y} = B_\mathrm{Z} = 12\), so that Corollary 4 gives the final result \(12 \leq d \leq 16\). This is a concrete instance in which the bound ?? is strictly stronger than the one in ?? .

5.3 XYZ Codes based on Quasi-Dyadic Codes↩︎

We first recall the definitions of dyadic and QD matrices.

Dyadic matrices are reproducible matrices [34], i.e., it is possible to determine the entire matrix only using its first row, called signature.

We construct CSS QLDPC codes using the affine construction method of [20], that allows to have CSS codes suitable for the CAMEL framework [35]. Let us briefly recall how to build the binary PCM of the component QD codes. A classical QD code is described by an exponent matrix \(\mathbf{E}' \in \mathbb{F}_{2^\ell}^{u \times 2^{\ell}}\), with \(u \le 2^\ell\). Each entry \(p_{i,j}\) of the exponent matrix, where \(i,j \in \mathbb{F}_{2^\ell}\), is associated to a (not necessarily distinct) DPM. Each row of \(\mathbf{E}'\) is generated as an affine permutation \(p_{i,j} = a_i j + b_i\), with distinct non-zero multipliers \(a_i \in \mathbb{F}_{2^\ell}^{\times}\) and \(b_i \in \mathbb{F}_{2^\ell}\) with a multiplication over the field \(\mathbb{F}_{2^\ell}\). Then, we lift the exponent matrix, i.e., we replace each element \(p_{i,j} \in \mathbb{F}_{2^{\ell}}\) with the corresponding DPM.

As an example, the XYZ code \(\mathcal{C}_{\mathrm{XYZ}-\text{QD}} \llbracket 257, 116, 16 \rrbracket\)¹⁰ \(\ell = 4\), \(2^{\ell} = 16\), \(u_{\mathrm{X}} = u_{\mathrm{Y}} = u_{\mathrm{Z}} = 5\). We have verified that this code instance is genuine and remains genuine under uniform Pauli relabeling. As in Section 5.2, we avoid the verification for the local Pauli relabeling due to complexity constraints.

Regarding the minimum-distance bounds, we use the tool available in [36] to numerically estimate the distances \(\tilde{d}_{\mathrm{X},\mathrm{Y}}\), \(\tilde{d}_{\mathrm{Y},\mathrm{Z}}\), and \(\tilde{d}_{\mathrm{X},\mathrm{Z}}\), as well as the coset distances \(\tilde{d}_{\sigma\setminus\sigma'}\) for all distinct \(\sigma,\sigma' \in \{X,Y,Z\}\). These computations yield the numerical estimate \(L=12\), according to Corollary 3. To evaluate the mixed-operator bound (Corollary 4), we additionally estimate the classical distances \(\tilde{\delta}_{\mathrm{X}}\), \(\tilde{\delta}_{\mathrm{Y}}\), and \(\tilde{\delta}_{\mathrm{Z}}\) using the tool available in [37], obtaining \(B=18\). Finally, the MILP formulation solved with the Gurobi optimizer finds a pure logical operator for each \(\sigma\)-type, with \(\sigma \in \{ X, Y, Z \}\), with weight \(16\). The numerical estimation of the upper bound is thus \(U = 16\) (Corollary 2). Together, these numerical results suggest that the minimum distance is \(d=16\) (Corollary 4).

6 Numerical Results↩︎

In this section, we show the LER performance of the proposed XYZ QLDPC codes, one based on IS and the other on QD codes, through finite-length Monte Carlo simulations, over a code-capacity noise model, with depolarizing probability \(p\). The two presented instances of XYZ codes are compared with representative state-of-the-art CSS QLDPC codes having comparable lengths, stabilizer generator weights, and rates. We employ a BP4 decoder, relying on the sum-product algorithm (SPA). We used a CN serialized schedule for message passing. The decoder runs at most for \(50\) iterations, and the simulation continues with the same \(p\) until \(100\) logical errors are detected.

We compare the proposed XYZ codes with several CSS codes, namely: a QD code (\(\mathcal{C}_{\text{QD}}\)) [20], an IS code (\(\mathcal{C}_{\text{IS}}\)) [28], bicycle codes (\(\mathcal{C}_{\text{Bic}}\)) [38], GB codes (\(\mathcal{C}_{\text{GB}}\)) [17], HP codes (\(\mathcal{C}_{\text{HP}}\)) [10], a QM code (\(\mathcal{C}_{\text{QM}}\)) [39], and a BB code (\(\mathcal{C}_{\text{BB}}\)) [40]. For each tested code instance (be it CSS or XYZ) the code parameters \(n\), \(k\), \(R\), and \(d\), the stabilizer generator weight \(w_{\text{r}}\) (which is uniform for all the codes), and the girth \(g_{\sigma}\), of each classical code \(C_{\sigma}\) with \(\sigma \in \{ X, Y, Z \}\), are reported in Table 1. All tested CSS codes are directly available in the literature, with the exception of the bicycle codes \(\mathcal{C}_{\text{Bic,}1}\) and \(\mathcal{C}_{\text{Bic,}2}\), constructed with the same method of [38], and the GB codes \(\mathcal{C}_{\text{GB,}1}\) and \(\mathcal{C}_{\text{GB,}2}\), designed as in [41]¹¹. Since instances simultaneously matched in length, dimension, stabilizer weight, are generally not available, we select the benchmark codes to match the parameters most relevant to each comparison.

In Fig. [fig:QD95XYZ95SOTA], we compare the performance of \(\mathcal{C}_{\mathrm{XYZ}-\text{QD}}\), defined in Section 5.3, against some state-of-the-art CSS QLDPC codes instances with \(n \approx 257\), \(w_{\mathrm{r}} \approx 16\) and \(R \approx 0.45\). We observe that the proposed \(\mathcal{C}_{\mathrm{XYZ}-\text{QD}}\) behaves better than \(\mathcal{C}_{\text{Bic,}1}\) and \(\mathcal{C}_{\text{GB,}1}\), consistently with their smaller minimum distance, namely \(d_{\text{Bic,}1} = 5\) and \(d_{\text{GB,}1} = 8\), even though the latter exhibits a larger girth, equal to \(6\). As a benchmark, we report also the performance of \(\mathcal{C}_{\text{QD}}\) (dashed line with empty squares), which is the state-of-the-art code instance of QD codes, for these specific length and rate. Such a code has been devised for a joint code and BP4 decoder framework, namely CAMEL [35], and therefore it has been decoded with the corresponding CAMEL decoder. The latter significantly improves the code LER with respect to a standard BP4 [20]. Despite this, the performance of \(\mathcal{C}_{\mathrm{XYZ}-\text{QD}}\), decoded with a conventional BP4 decoder, is superior to that of \(\mathcal{C}_{\text{QD}}\). This comparison is informative because both codes have the same length, stabilizer generator weight and nearly equal rates. It therefore isolates, to a substantial extent, the effect of replacing the CSS structure with the proposed XYZ construction.

Moreover, in Fig. [fig:IS95XYZ95SOTA], we report the behavior of \(\mathcal{C}_{\mathrm{XYZ}-\text{IS}}\) against several state-of-the-art CSS QLDPC codes instances, with \(n \approx 512\), \(w_{\mathrm{r}} \approx 8\), and \(R \approx 0.02\). We remark that the performance of \(\mathcal{C}_{\mathrm{XYZ}-\text{IS}}\) is better than \(\mathcal{C}_{\text{Bic,}2}\), \(\mathcal{C}_{\text{HP,}1}\), and \(\mathcal{C}_{\text{HP,}2}\), which is consistent with their smaller minimum distances, namely, \(d_{\text{Bic,}2} = d_{\text{HP,}1} = 6\), \(d_{\text{HP,}2} = 8\). We observe that, for \(p > 0.09\), \(\mathcal{C}_{\text{GB,}2}\) exhibits poorer performance than the proposed XYZ code. Instead, we note that, for \(p < 0.09\), the performance curve of \(\mathcal{C}_{\text{QM}}\) exhibits an error floor. Eventually, for \(p>0.05\), the XYZ code shows better performance than the latter code. Moreover, we also include the LER performance of \(\mathcal{C}_{\text{BB}}\), which is the instance with the biggest \(n\) and (estimated) \(d\) among the family of BB codes [40]. In particular, for \(p>0.07\), the BB code achieves a lower LER than the XYZ code. Below this crossover point, however, the XYZ code performs better. Finally, Fig. [fig:IS95XYZ95SOTA] includes the performance of \(\mathcal{C}_{\text{IS}}\), namely the CSS IS code constructed using only the tuples \(\mathcal{S}_{\mathrm{X}}\) and \(\mathcal{S}_{\mathrm{Z}}\) of Section 5.2. This comparison is not rate matched, since \(\mathcal{C}_{\text{IS}}\) has a substantially larger dimension than \(\mathcal{C}_{\mathrm{XYZ}-\text{IS}}\). Rather, it illustrates the effect of adding the \(Y\)-type constraints within the same underlying IS construction. Over the simulated range, the resulting XYZ code achieves a lower LER, at the cost of a reduced coding rate.

7 Conclusions↩︎

We introduced quantum XYZ stabilizer codes as a generalization of the CSS framework obtained by including \(Y\)-type stabilizer generators. We characterized when these additional generators produce a genuinely non-CSS code and derived bounds on the resulting minimum distance. Moreover, we show that the topological XYZ\(^2\) code fits in the proposed XYZ framework. The constructions based on IS and QD codes show that this framework can yield sparse finite-length codes, while the numerical results confirm that the proposed instances can outperform comparable CSS codes under BP4 decoding.

Future work should focus on the joint design of the three component codes and on decoders tailored to the full XYZ structure. It would also be relevant to extend the analysis beyond the code-capacity setting and to clarify the complexity of recognizing LC equivalence to CSS codes.

Acknowledgments↩︎

Davide Orsucci acknowledges support in preliminary technical and conceptual work from Dr.Francesco Gautieri.

References↩︎