# Accessible quantum on classical stabilizer codes

Victor Barizien, Hugo Jacinto, Nicolas Sangouard

► To cite this version:

Victor Barizien, Hugo Jacinto, Nicolas Sangouard. Accessible quantum on classical stabilizer codes. Physical Review Letters, 2026, 136 (3), pp.030602. 10.1103/h741-4678. hal-05465638

HAL Id: hal-05465638

https://hal.science/hal-05465638v1

Submitted on 6 Feb 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
Accessible Quantum Gates on Classical Stabilizer Codes

Victor Barizien,¹ Hugo Jacinto,¹,² and Nicolas Sangouard¹

¹Institut de Physique Théorique, Université Paris-Saclay, CEA, CNRS, 91191 Gif-sur-Yvette, France

²Alice & Bob, 53 boulevard du Général Martial Valin, 75015 Paris, France

(Dated: February 4, 2026)

With the advent of physical qubits exhibiting strong noise bias, it becomes increasingly relevant to identify which quantum gates can be efficiently implemented on error-correcting codes designed to address a single dominant error type. Here, we consider $[n, k, d]$-classical stabilizer codes addressing bit-flip errors where $n, k$ and $d$ are the numbers of physical and logical qubits, and the code distance respectively. We prove that operations essential for achieving a universal logical gate set necessarily require complex unitary circuits to be implemented. Specifically, these implementation circuits either consists of $h$ layers of $r$-transversal operations on $c$ codeblocks such that $c^{h-1}r^h \ge d$ or of $h$ gates, each operating on at most $r$ physical qubits on the same codeblock, such that $hr \ge d$. Similar constraints apply not only to classical codes designed to correct phase-flip errors, but also to quantum stabilizer codes tailored to biased noise. This motivates a closer examination of alternative logical gate constructions using eg. magic state distillation and cultivation within the framework of biased-noise stabilizer codes.

**Introduction**— Fault-tolerant quantum computation refers to the ability to execute large-scale quantum algorithms reliably, despite the presence of errors [1]. It relies on quantum error correction codes that encode quantum information across multiple physical qubits, with repeated parity measurements used to identify errors. To process the encoded information, computationally universal gate sets are employed in a way that limits the propagation of errors. The algorithm execution proceeds through a sequence of these gates interleaved with parity checks, continuing until the full computation is completed.

Among possible error correction codes, stabilizer codes distinguish themselves by parity check operators that are tensor products of single Pauli operators [2, 3]. Although they are arguably among the most convenient to implement in practice [4–9], they come with inherent restrictions on the set of gates that can be implemented fault-tolerantly. The Bravyi-Koenig restriction [10] for example, applies to quantum stabilizer codes on a D-dimensional lattice with $D \ge 2$, having a maximum range of the parity checks smaller than the code distance at the power $1/D$. It states that the restriction to the codespace of any circuit for which the product of the circuit depth and the gate range is smaller than the code distance at the power $1/D$ can only implement unitaries belonging at most to the $D^{th}$ level of the Clifford hierarchy [11]. For the surface code family [12–17] ($D = 2$ geometry with the support of check operators of diameter $O(1)$), this means that constant-depth circuits made out of local gates can only implement encoded gates within the Clifford group. Since at least one non-Clifford gate is needed to get a universal gate set, fault-tolerance in surface codes cannot be realized using gates admitting constant-depth implementation alone. Consequently, alternative strategies, such as magic state distillation [18, 19] or cultivation [20–24], are necessary for implementing non-Clifford gates.

While several refinements and improvements of the Bravyi-Koenig bound have been proposed in the framework of quantum error correction codes [25, 26], analogous impossibility bounds on classical codes have not yet been explored. The value of such bounds is underscored by recent efforts to reduce the overhead of error correction by proposing physical qubit implementations exhibiting biased noise [27–33]. Specifically, dissipatively stabilized cat qubits exhibit a bit-flip error rate that is exponentially suppressed with the average number of photons, at the cost of a linearly increasing phase-flip error rate. This stark asymmetry leads to bit-flip errors that are many orders of magnitude less frequent than phase-flip errors [34–36]. As a result, long gate sequences can be executed reliably by focusing error correction solely on the dominant type of error. This reduces significantly the physical qubit number with respect to standard approaches driven by quantum codes to execute quantum algorithms [37]. Recent experimental results [38] demonstrating a logical qubit memory based on cat qubits, protected by an outer repetition code of distance $d = 5$ underscores the practical viability of concatenated bosonic codes. These results also highlight the pressing need to identify the set of quantum gates that can be implemented efficiently within classical stabilizer codes, in order to guide upcoming experimental efforts and solidify concatenated bosonic codes as a promising architecture for fault-tolerant quantum computation.

Here, we focus on stabilizer codes that address one type of error, say bit-flip (X-type) error for concreteness (the same results apply to phase-flip errors). We prove that the only logical operations that can be done efficiently on these classical codes are the ones that evolve every $Z$ operator into a sum of products of $Z$ operators. Other operations — essential for achieving a universal logical gate set — can still be performed at the logical level, but their implementation necessarily requires complex unitary cir-
cuits made either with $h$ layers of $r$-transversal operations operating on $c$ codeblocks such that $c^{h-1}r^h \ge d$ where $d$ is the code distance, or a sequence of $h$ gates, each acting on at most $r$ qubits on the same codeblock, with the constraint $hr \ge d$. Extensions of these bounds to quantum stabilizer codes designed to correct biased-noise are discussed. These practical constraints motivate a closer examination of constructions of logical gates not relying on unitary circuits, such as magic state distillation and cultivation within the framework of biased-noise stabilizer codes.

**Classical stabilizer codes**— Classical stabilizer codes can be characterized by a set of parameters $[n, k, d]$, where $n$ is the number of physical qubits, $k$ the number of logical qubits and $d$ the distance of the code. Each code is generated by a set of $\zeta$ commuting stabilizers $\{\sigma_t\}_{1\le t\le \zeta}$ that are products of Pauli $Z$ operators only, such that the codespace $\mathcal{C}$ is given by the intersection of the +1 eigenspace of all stabilizers. In general, the stabilizers are taken to be independent – none of them is a product of any others – implying that $k = \log_2(\dim \mathcal{C}) = n - \zeta$, and the codespace is isomorphic to a logical space $\mathcal{E} = (\mathbb{C}^2)^{\otimes k}$.

We say that a unitary operation $U$ on the physical space gives a logical operation if it preserves the codespace, i.e. that $U(\mathcal{C}) \subset \mathcal{C}$. In this case, we denote the corresponding logical operation with respect to a given isometry $S: \mathcal{E} \to \mathcal{C}$ to be $U_L = S^\dagger US$. Note that a given logical unitary operation $U_L$ can admit several implementations $U$ at the physical level.

**Logical Pauli implementations**— A class of logical operations of particular interest are those admitting an implementation as a product of physical Pauli operators. Let us first consider implementations involving products of Pauli $Z$ operators. For a given $\alpha \in \{0, 1\}^n$, we denote by $Z_\alpha = \bigotimes_{i=1}^n (Z^{(i)})^{\alpha_i}$ the physical operator acting with Pauli $Z$ on each qubit $i$ for which $\alpha_i = 1$, and the identity elsewhere. Since the stabilizers $\sigma_t$ involve only products of Pauli $Z$, $Z_\alpha$ commutes with every stabilizer and as such preserves the codespace $\mathcal{C}$. Thus, $Z_{L,\alpha} := SZ_\alpha S^\dagger$ is a valid logical operator.

Note that the isomorphism $S$ is not unique but a canonical expression can be chosen from the parity-check matrix of the associated classical code, see End Matter A. In particular, this choice, up to a relabeling of the physical qubits, ensures that the individual physical $Z$ operators acting on the first $k$ qubits correspond directly to the logical $Z$ operators on the $k$ qubits of the logical space $\mathcal{E}$. In other words, $Z_L^{(j)} := Z_{L, (\delta_{ij})} = SZ^{(j)}S^\dagger$, for $1 \le j \le k$, corresponds to a Pauli $Z$ on the $j$-th logical qubit for this canonical isometry, see End Matter B.

Let us now consider the logical operators obtained from implementation involving products of Pauli $X$ operators.

From the classical definition of the code distance $d$ as the minimal non-zero Hamming weight among the code-words, $d$ corresponds to the minimal number of bit-flips, that is physical Pauli $X$ operations, that must be applied to transform one logical codeword into another without being detectable by the stabilizers. This implies that any products of strictly less than $d$ physical $X$ operations would not preserve the codespace. Note that this definition is a coherent adaptation of the distance of quantum codes (the minimum number of physical qubits that need to be acted upon to produce a non-trivial logical operation) for cases where only $X$-errors are detected. This definition of the code distance implies that

$$ \forall I \subset [n] \text{ s.t. } |I| < d, \quad S^\dagger \left( \bigotimes_{i \in I} X^{(i)} \right) S = 0_L \quad (1) $$

for any choice of isometry $S$.

**Efficient logical operations**— In the following, we consider a classical stabilizer code defined on a lattice of physical qubits. We consider $c$ codeblocks of such a code, which are characterized by the parameters $[cn, ck, d]$ as each codeblock is associated to the parameters $[n, k, d]$. The physical Hilbert space $\mathcal{H}$ is thus naturally partitioned into the tensor product of $c$ Hilbert spaces $\mathcal{H} = \bigotimes_{m=1}^c \mathcal{H}_m$ each containing $n$ physical qubits.

Let's consider an arbitrary logical operation $U_L$ and suppose that it admits an implementation $U$. Our aim is to compute the commutation relation of the logical operation $U_L$ and an arbitrary logical operator $Z_L^{(j)}$. From its definition, $Z_L^{(j)}$ can be implemented from a single physical $Z$ operators on the $j$-th physical qubits, that is $Z_L^{(j)} = S^\dagger Z^{(j)} S$. We consider the operator $K = UZ^{(j)}U^\dagger$. The evolution $Z^{(j)} \to UZ^{(j)}U^\dagger$ enlarges the support of $Z^{(j)}$ from 1 to a given support which depends on the way $U$ is implemented. We will consider different implementations for $U$ below but for now, we simply denote by $\delta_m$ the support of $K$ on each codeblock, i.e. $\delta_m = \text{supp}(UZ^{(j)}U^\dagger) \cap \mathcal{H}_m$. We prove now that if $|\delta_m| < d$ for all $m$, then $U_L Z_L^{(j)} U_L^\dagger$ is a linear combination of product of logical Pauli $Z$ operators and the identity.

Indeed, for all $l$ the set of tensor products of all possible $l$ Pauli operators (including identity) forms a real orthogonal basis for the vector space of $2l \times 2l$ hermitian matrices, and thus the operator $K$ can be decomposed as $K = \sum_\alpha b_\alpha K_\alpha$, where $b_\alpha$ are real numbers and $K_\alpha$ are products of Pauli operators and the identity with support $\delta_m$ on each codeblock. Using the fact that $U(\mathcal{C}) \subset \mathcal{C}$, we have $S^\dagger U = U_L S^\dagger$, and thus $S^\dagger KS = U_L Z_L^{(j)} U_L^\dagger$. However $S^\dagger KS = \sum_\alpha b_\alpha S^\dagger K_\alpha S$. If we assume that, for all $m$, $|\delta_m| < d$, no term $K_\alpha$ has support on at least $d$ physical qubits in the same codeblock and thus Eq. (1) implies
<figure><img src="image_2.png" /><figcaption>FIG. 1. Illustration of a $r$-transversal partition of the physical space $\mathcal{H}$. The partition is given by three disjoint sets of physical qubits as $\mathcal{H} = \mathcal{G}_{\text{blue}} \sqcup \mathcal{G}_{\text{orange}} \sqcup \mathcal{G}_{\text{green}}$. The $c$ different codeblocks correspond to the circle area labelled by $\mathcal{H}_m$, and it holds that $|\mathcal{G}_q \cap \mathcal{H}_m| \le r$, for all $m \in [c]$ and $q \in \{\text{blue}, \text{green}, \text{orange}\}$. An implementation $U$ is called $r$-transversal if there exists a $r$-transversal partition for which one can write $U = \bigotimes_q U_q$, where $\text{supp}(U_q) \subset \mathcal{G}_q$. In this example, it would mean that $U = U_{\text{blue}} \otimes U_{\text{orange}} \otimes U_{\text{green}}$.</figcaption></figure>

that no logical $X$ nor logical $Y$ appears in the sum. As such, one has $U_L Z_L^{(j)} U_L^\dagger = \sum_\alpha b_\alpha Z_{L,\alpha}$.

If this property holds true for all possible $j$, then for any product $Z_{L,\alpha}$, one has $U_L Z_{L,\alpha} U_L^\dagger = \sum_{\alpha'} b_{\alpha'}^\dagger Z_{L,\alpha'}$. In other words, if one denotes by $V_Z$ the algebra spanned by the $Z_L^{(j)}$, $U_L$ must satisfy $U_L V_Z U_L^\dagger \subset V_Z$. We will use the contrapositive of this statement to derive lower bounds on the complexity of circuits implementing logical gate operations that do not preserve the structure of products of $Z$ and identity operators under conjugation.

Note that equivalent derivations can be made in more general situations. First, each codeblock can be built out of different codes and have different parameters $[n_m, k_m, d_m]$ for each $m \in [c]$, as long as $n = \sum_m n_m$, $k = \sum_m k_m$ and $d = \min_m d_m$. Second, the physical circuit $U$ can map the codespace $\mathcal{C}$ to the codespace of another code $\mathcal{C}_2$. In this case, one can choose isometries $S_1$ and $S_2$ for each code. An implementation $U$ of $U_L$ must satisfy $U(\mathcal{C}_1) \subset \mathcal{C}_2$ and $U_L = S_2^\dagger U S_1$. Since any logical $Z_L^{(j)}$ operation can be implemented with a physical Pauli $Z^{(j)}$ of support 1 on the first code, a similar derivation shows that $U_L V_Z U_L^\dagger \subset V_Z$ still holds as long as the support of $UPU^\dagger$ on each codeblock of the second code $\delta_m$ satisfies $|\delta_m| < d$ for all $m$.

In the following paragraphs, we consider different choices for possible physical implementations $U$ of logical gates $U_L$. We show how the property derived above translates into fine-grained bounds on the complexity of these physical implementations.

**$r$-transversal gates**— We here consider implementations $U$ made out of $r$-transversal operations. We start by reviewing the definitions of $r$-transversality, which are illustrated in Fig. 1.

**Definition 1** ($r$-transversal partition). A $r$-transversal partition of the physical space is a partition of $\mathcal{H}$ into sets each containing at most $r$ qubits of each codeblock.

**Definition 2** ($r$-transversal operation). A physical implementation $U$ is $r$-transversal if there exists a $r$-transversal partition of $\mathcal{H}$ such that $U$ only involves gates with support within the same set of the partition.

The case $r = 1$ corresponds to transversal operations, that is, gates operating on a disjoint ensemble of qubits, with each gate acting on at most one qubit on each codeblock. For example, a transversal CNOT gate between pairs of qubits belonging to two codeblocks of a repetition code is an example a 1-transversal operation. Transversal operations are of particular interest in the context of fault-tolerant quantum computation because gates having no share support do not spread Pauli errors within a codeblock. They can also be executed in parallel, hence avoiding noise on idle qubits.

If $U$ has a $r$-transversal implementation, it can be decomposed as a tensor product $U = \bigotimes_q U_q$ where each $U_q$ only acts within the same set of a $r$-transversal partition. For the rest of the paper, we label $P$ any physical $Z^{(j)}$ operator acting on a single qubit $j$. Since the support of $P$ is 1, there exists only one index $q$, labelled $q^*$, such that $\text{supp}(U_q) \cap \text{supp}(P) \ne \emptyset$. As such, one has $UPU^\dagger = U_{q^*}PU_{q^*}^\dagger$. Since the support of $U_{q^*}$ in each codeblock is at most $r$, the support of the evolution $P \to UPU^\dagger$ can be upper bounded as

$$ \forall m \in [c], |\delta_m| \le r. \qquad (2) $$

**$h$ layers of $r$-transversal gates**— We now consider a physical implementation of the form $U = \prod_{\ell=1}^h U_\ell$ where $U_\ell$ are $r$-transversal operations, that is $h$ layers of $r$-transversal operations. Note that each layer may involve a different $r$-transversal partition of the physical space. In any case, the support of $P \to UPU^\dagger$ within each codeblock is upper bounded as

$$ \forall m \in [c], |\delta_m| \le c^{h-1}r^h \qquad (3) $$

where $c$ refers to the number of codeblocks. This can be shown by induction on $h$. The case $h = 1$ holds according to Eq. (2). We assume that the result holds for implementations involving $h$ layers of $r$-transversal gates. Now, consider an implementation with $h+1$ layers $U = \prod_{\ell=1}^{h+1} U_\ell$. Since one has $UPU^\dagger = U_{h+1} \tilde{U} P \tilde{U}^\dagger U_{h+1}^\dagger$, where $\tilde{U}$ has $h$ layers of $r$-transversal gates, it suffices to look at how $U_{h+1}$ changes the support of $\tilde{U} P \tilde{U}^\dagger$ within each codeblock. Let's denote $\delta_h$ the support of $\tilde{U} P \tilde{U}^\dagger$, and $\delta_{m,h}$ its intersection with the codeblock $\mathcal{H}_m$. The worst-case scenario for support spreading is if every qubits in $\delta_h$ belongs to a different set of the partition associated to $U_{h+1}$. In this case, every qubits will be spread by the
$U_{h+1}$ evolution to at most $r-1$ qubits in their own code-block $m$. Any other codeblock $m' \neq m$ will bring at most $r$ new qubits for each of the $\delta_{m',h}$ qubits in codeblock $m$. In the end, we have

$$|\delta_{m,h+1}| \leq |\delta_{m,h}| + |\delta_{m,h}|(r-1) + \sum_{m' \neq m} |\delta_{m',h}| \cdot r.$$

Since the result holds for $h$ layers, we have for all $m$, $|\delta_{m,h}| \leq c^{h-1}r^h$, and as such

$$|\delta_{m,h+1}| \leq c \cdot r \cdot c^{h-1}r^h = c^h r^{h+1}.$$

**Consecutive gates**— We finally consider the case where $U$ is implemented with a sequence of $h$ successive gates $U = \prod_{\ell=1}^h U_\ell$, each gate $U_\ell$ having a support on at most $r$ qubits of each codeblock. Since every gate is applied successively, they can share support on common qubits. In this scenario, the support of $UPU^\dagger$ in each codeblock is enlarged by at most $r$ qubits at each layer, so that

$$\forall m \in [c], |\delta_m| \leq hr. \qquad (4)$$

Note that the first gate $U_1$ can actually be a $r$-transversal operation without modifying the bound as in the first layer, the support of $P$ is 1 in only one codeblock.

**No-go theorem for classical stabilizer codes**— The converse of the property described above together with the bound on the support of $UPU^\dagger$ leads to the following theorem:

**Theorem 1.** Consider codeblocks of a classical error-correcting stabilizer code that accounts for $X$ type errors with parameters $[n, k, d]$, together with an isometry $S: \mathcal{E} \to \mathcal{C}$. Then, for any logical operator $U_L$, if there exists $j \in [n]$ such that

$$U_L Z_L^{(j)} U_L^\dagger \neq \sum_\alpha b_\alpha Z_{L,\alpha} \qquad (5)$$

where $Z_L^{(j)} := SZ^{(j)}S^\dagger$ is the logical operator obtained from a Pauli $Z$ on physical qubit $j$, $b_\alpha$ are real numbers and $Z_{L,\alpha}$ are products of logical Pauli $Z$ operators, then $U_L$ cannot be implemented at the physical level:

1. with a circuit of $h$ layers of $r$-transversal operations such that $c^{h-1}r^h < d$.

2. nor with a circuit of $h$ gates, each operating on at most $r$ physical qubits in each code block, such that $hr < d$.

One can also directly study the size of the support of the implementation $U$ on each codeblocks. When using the decomposition of $U$ into Pauli strings and looking at the corresponding logical operations, it comes that if $U_L$ itself cannot be decomposed as a linear combination of

logical $Z_{L,\alpha}$ operators, it cannot be implemented with a sequence of consecutive gates such that $hr < d$. This is more restrictive than Theorem 1, point 2.

Naturally, a similar theorem can be formulated for classical stabilizer codes accounting for $Z$ errors, by simply swapping $X$ and $Z$ operators in the previous derivations.

Interestingly, Theorem 1 can be extended to quantum stabilizer codes accounting for both bit-flip and phase-flip errors. This shows that for all biased noise quantum codes, there exists gates that require either high connectivity or substantial depth.

**Theorem 2.** Consider codeblocks of a biased noise quantum error-correcting stabilizer code with parameters $[n, k, (d_X, d_Z)]$ where $d_Z$ and $d_X$ are the code distances for $Z$ and $X$ errors. Then, for any logical operator $U_L$, if there exists $j \in [n]$ such that

$$U_L Z_L^{(j)} U_L^\dagger \neq \sum_\alpha b_\alpha Z_{L,\alpha} \qquad (6)$$

where $Z_L^{(j)}$ is the $j$-th logical operator, $b_\alpha$ are real numbers and $Z_{L,\alpha}$ are products of logical Pauli $Z$ operators, then $U_L$ cannot be implemented at the physical level:

1. with a circuit of $h$ layers of $r$-transversal operations such that $d_Z c^{h-1} r^h < d_X$.

2. nor with a circuit of $h$ gates, each operating on at most $r$ physical qubits in each code block, such that $(d_Z - 1) + hr < d_X$.

The proof is analogous to the classical case, the only difference is that the logical operator $Z_L^{(j)}$ starts with a support of size $d_Z$ instead of 1. Those bounds are trivial for balanced error corrections ($d_Z = d_X$) but they remain very constraining for qubits subject to biased noises for which relevant codes satisfy $d_Z \ll d_X$. When choosing the canonical isometry for the encoding, operators $Z_L^{(j)}$ correspond to Pauli-$Z$ on the $j$-th logical qubit. In this case, examples of gates that fall under the no-go of Theorem 1 include $H$, $\sqrt{X}$ and $\sqrt{\sqrt{X}}$ since they verify $HZH^\dagger = X$, $\sqrt{X}Z\sqrt{X}^\dagger = -Y$ and $\sqrt{\sqrt{X}}Z\sqrt{\sqrt{X}}^\dagger = \cos\pi/41 + i\sin\pi/4Y$. More generally, this holds for every operator of the form $\sqrt{X}$ for $q \geq 1$. In particular, our work shows that for both classical stabilizer codes and biased-noise codes, even some Clifford gates can be hard to implement. This emphasizes the need of alternative methods such as magic state distillation. While distillation of such states were already used for practical architectures [32, 39], our work provides for the first time a clear mathematical understanding of why this is necessary.

Note that the property to evolve any $Z$ operator to a sum of products of $Z$ operators is preserved under composition. Thus, the operators that can be implemented with
either a circuit of *h* gates, each operating on at most *r* physical qubits, such that *hr* < *d* or with a circuit of *h* layers of *r*-transversal operations such that *c*<sup>*h*−1</sup>*r*<sup>*h*</sup> < *d* form a strict subgroup of all possible operators, and thus cannot lead to a universal gate set, see End Matter C.

**Conclusion**— We have established strong constraints on the implementation of universal logical operations on classical stabilizer codes and biased-noise quantum stabilizer codes. These results offer valuable guidance for the design of fault-tolerant gates on stabilized cat qubits protected by classical codes. When this approach is viewed through the lens of concatenated bosonic codes, the Eastin-Knill theorem [40] applies, ruling out the possibility of realizing a universal set of transversal gates. However, our results go further by providing a much more fine-grained characterization. They identify precisely which gates are hard to implement with unitary circuits and quantify, exactly rather than asymptotically, the circuit size required to realize them in various scenarios, including r-transversal layers and multi-qubit gate sequences. In particular, we show that relaxing strict transversality to r-transversality offers little advantage in terms of fault tolerance: achieving a universal gate set still requires exceeding the code's capacity $r \ge d_X/d_Z \sim d_X$. This highlights a clear need to explore alternative approaches to logical gate implementation, such as magic state distillation, within the framework of classical stabilizer codes and biased-noise quantum stabilizer codes.

**Acknowledgments**— We thank E. Gouzien, J. Guil- laud, and D. Ruiz for insightful discussions at an early stage of the project, and V. Savin for sug- gesting extensions to biased-noise codes and, more broadly, for providing valuable feedback on an earlier version of the manuscript. We acknowledge funding by Agence Nationale de la Recherche in the framework of France 2030 with the reference ANR-22-PETQ-0007 and project name EPiQ. This work was also partially supported by the French National program Programme d'investissement d'avenir, IRT Nanoelec, with the refer- ence ANR-10-AIRT-05.

[1] J. Preskill, Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences 454, 385-410 (1998).

[2] B. M. Terhal, Reviews of Modern Physics 87, 307-346 (2015).

[3] D. Gottesman, Stabilizer codes and quantum error correction (1997), arXiv:quant-ph/9705052 [quant-ph].

[4] C. Ryan-Anderson, J. G. Bohnet, K. Lee, D. Gresh, A. Hankin, J. P. Gaebler, D. Francois, A. Chernoguzov, D. Lucchetti, N. C. Brown, T. M. Gatterman, S. K. Halit, K. Gilmore, J. A. Gerber, B. Neyenhuis, D. Hayes, and R. P. Stutz, Phys. Rev. X 11, 041058 (2021).

[5] S. Krinner, N. Lacroix, A. Remm, A. Di Paolo, E. Genois, C. Leroux, C. Hellings, S. Lazar, F. Swiadek, J. Hermann, G. J. Norris, C. K. Andersen, M. Müller, A. Blais, C. Eichler, and A. Wallraff, Nature 605, 669-674 (2022).

[6] R. Acharya et al., Nature 614, 676 (2023).

[7] D. Bluvstein, S. J. Evered, A. A. Geim, S. H. Li, H. Zhou, T. Manovitz, S. Ebadi, M. Cain, M. Kalinowski, D. Hangleiter, J. P. Bonilla Ataides, N. Maskara, I. Cong, X. Gao, P. Sales Rodriguez, T. Karolyshyn, G. Semeghini, M. J. Gullans, M. Greiner, V. Vuletić, and M. D. Lukin, Nature 626, 58-65 (2023).

[8] A. Paetznick, M. P. da Silva, C. Ryan-Anderson, J. M. Bello-Rivas, J. P. C. III, A. Chernoguzov, J. M. Dreiling, C. Foltz, F. Frachon, J. P. Gaebler, T. M. Gatterman, L. Grans-Samuelsson, D. Gresh, D. Hayes, N. Hewitt, C. Holliman, C. V. Horst, J. Johansen, D. Lucchetti, Y. Matsuoka, M. Mills, S. A. Moses, B. Neyenhuis, A. Paz, J. Pino, P. Siegfried, A. Sundaram, D. Tom, S. J. Wernli, M. Zanner, R. P. Stutz, and K. M. Svore, Demonstration of logical qubits and repeated error correction with better-than-physical error rates (2024), arXiv:2404.02280 [quant-ph].

[9] R. Acharya et al., Nature 638, 920-926 (2024).

[10] S. Bravyi and R. König, Phys. Rev. Lett. 110, 170503 (2013).

[11] D. Gottesman and I. L. Chuang, Nature 402, 390-393 (1999).

[12] S. B. Bravyi and A. Y. Kitaev, Quantum codes on a lattice with boundary (1998), arXiv:quant-ph/9811052 [quant-ph].

[13] A. Kitaev, Annals of Physics 303, 2-30 (2003).

[14] E. Dennis, A. Kitaev, A. Landahl, and J. Preskill, Journal of Mathematical Physics 43, 4452-4505 (2002).

[15] H. Bombin and M. A. Martin-Delgado, Physical Review A 76, 10.1103/physreva.76.012305 (2007).

[16] A. G. Fowler, A. M. Stephens, and P. Groszkowski, Physical Review A 80, 10.1103/physreva.80.052312 (2009).

[17] A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, Physical Review A 86, 10.1103/physreva.86.032324 (2012).

[18] S. Bravyi and A. Kitaev, Physical Review A 71, 10.1103/physreva.71.022316 (2005).

[19] D. Litinski, Quantum 3, 205 (2019).

[20] E. Knill, R. Laflamme, and W. Zurek, Threshold accuracy for quantum computation (1996), arXiv:quant-ph/9610011 [quant-ph].

[21] C. Jones, P. Brooks, and J. Harrington, Phys. Rev. A 93, 052332 (2016).

[22] C. Chamberland and K. Noh, npj Quantum Information 6, 10.1038/s41534-020-00319-5 (2020).

[23] T. Itogawa, Y. Takada, Y. Hirano, and K. Fujii, Even more efficient magic state distillation by zero-level distillation (2024), arXiv:2403.03991 [quant-ph].

[24] C. Gidney, N. Shutty, and C. Jones, Magic state cultivation: growing t states as cheap as cnot gates (2024), arXiv:2409.17595 [quant-ph].

[25] F. Pastawski and B. Yoshida, Phys. Rev. A 91, 012305 (2015).

[26] M. Barkeshli, Y.-A. Chen, P.-S. Hsin, and R. Kobayashi, SciPost Phys. 16, 089 (2024).

[27] M. Mirrahimi, Z. Leghtas, V. V. Albert, S. Touzard, R. J. Schoelkopf, L. Jiang, and M. H. Devoret, New Journal of
Physics 16, 045014 (2014).

[28] S. Puri, S. Boutin, and A. Blais, npj Quantum Information 3, 10.1038/s41534-017-0019-1 (2017).

[29] J. Guillaud and M. Mirrahimi, Physical Review X 9, 10.1103/physrevx.9.041053 (2019).

[30] S. Puri, L. St-Jean, J. A. Gross, A. Grimm, N. E. Fratini, P. S. Iyer, A. Krishna, S. Touzard, L. Jiang, A. Blais, S. T. Flammia, and S. M. Girvin, Science Advances 6, 10.1126/sciadv.aay5901 (2020).

[31] J. Guillaud and M. Mirrahimi, Physical Review A 103, 10.1103/physreva.103.042413 (2021).

[32] C. Chamberland, K. Noh, P. Arrangoiz-Arriola, E. T. Campbell, C. T. Hann, J. Iverson, H. Putterman, T. C. Bohdanowicz, S. T. Flammia, A. Keller, G. Refael, J. Preskill, L. Jiang, A. H. Safavi-Naeini, O. Painter, and F. G. Brandão, PRX Quantum 3, 10.1103/prxquantum.3.010329 (2022).

[33] Q. Xu, J. K. Iverson, F. G. S. L. Brandao, and L. Jiang, Engineering fast bias-preserving gates on stabilized cat qubits (2021), arXiv:2105.13908 [quant-ph].

[34] R. Lescanne, M. Villiers, T. Peronnin, A. Sarlette, M. Delbecq, B. Huard, T. Kontos, M. Mirrahimi, and Z. Leghtas, Nature Physics 16, 509–513 (2020).

[35] C. Berdou, A. Murani, U. Réglade, W. Smith, M. Villiers, J. Palomo, M. Rosticher, A. Denis, P. Morfin, M. Delbecq, T. Kontos, N. Pankratova, F. Rautschke, T. Peronnin, L.-A. Sellem, P. Rouchon, A. Sarlette, M. Mirrahimi, P. Campagne-Ibarcq, S. Jezouin, R. Lescanne, and Z. Leghtas, PRX Quantum 4, 10.1103/prxquantum.4.020350 (2023).

[36] A. Marquet, A. Essig, J. Cohen, N. Cottet, A. Murani, E. Albertinale, S. Dupouy, A. Bienfait, T. Peronnin, S. Jezouin, R. Lescanne, and B. Huard, Physical Review X 14, 10.1103/physrevx.14.021019 (2024).

[37] E. Gouzien, D. Ruiz, F.-M. Le Régent, J. Guillaud, and N. Sangouard, Phys. Rev. Lett. 131, 040602 (2023).

[38] H. Putterman et al., Nature 638, 927–934 (2025).

[39] D. Ruiz, J. Guillaud, C. Vuillot, and M. Mirrahimi, Unfolded distillation: very low-cost magic state preparation for biased-noise qubits (2025), arXiv:2507.12511 [quant-ph].

[40] B. Eastin and E. Knill, Physical Review Letters 102, 10.1103/physrevlett.102.110502 (2009).

[41] S. Ling and C. Xing, *Coding theory: a first course* (Cambridge University Press, 2004).
END MATTER

A: ISOMETRY CHOICE FOR CLASSICAL
STABILIZER CODES

The isomorphism between the logical space $\mathcal{E}$ and the
codespace $\mathcal{C}$ is not unique but a convenient expression can
be chosen from the parity-check matrix of the associated
classical code. Indeed, the stabilizer codes of interest
account for bit-flip errors and thus involve only Z type
stabilizers that can be written as

$$
\sigma_t = \bigotimes_{i=1}^{n} (Z^{(i)})^{(h_t)_i} \qquad (7)
$$

where $h_t \in \mathbb{F}_2^n$ is a binary vector that encodes whether
the operator $Z^{(i)}$ appears in the product or not. As such,
there is a canonical isomorphism between the stabilizers
group $\langle \sigma_t, \cdot \rangle$ and the binary vectors group $\langle h_t, \oplus \rangle$. Since
the stabilizers are independent, the set $h_t$ itself forms a
free family of $\mathbb{F}_2^n$. They can thus be used to build the
parity-check matrix $H$ of a classical linear code as the
$(n-k) \times n$ matrix whose lines are made of the vectors
$\{h_t\}_{1 \le r \le n-k}$. This matrix is full-ranked and can there-
fore be written in the standard form $H = [-P^T | I_{n-k}] \in
\mathbb{F}_2^{(n-k) \times n}$ where $P^T$ is a $(n-k) \times k$ matrix and $I_{n-k}$ the
$(n-k)$ identity matrix [41]. The generating matrix of
this code is given by $G = [I_k | P] \in \mathbb{F}_2^{k \times n}$ such that the
following relation holds

$$
\bigoplus_{i=1}^{n} (g_s)_i (h_t)_i = 0, \quad (8)
$$

for all $s \in [k]$, $t \in [n-k]$ where $\{g_s\}_{1\le s \le k}$ denote the lines of $G$. Note that in the theory of classical linear codes, the distance $d$ of a code is given either by the minimal non-zero Hamming weight of the codewords.

The physical encoding of the logical words $|\epsilon_1\rangle \otimes \dots \otimes |\epsilon_k\rangle$ with $\epsilon_s \in \{0,1\}$ of the stabilizer code is specified by applying $G$ on $|\epsilon_1\rangle \otimes \dots \otimes |\epsilon_k\rangle$, specifically

$$
|G_{\epsilon}\rangle = \bigotimes_{i=1}^{n} \left| \bigoplus_{s=1}^{k} \epsilon_s(g_s)_i \right\rangle \quad (9)
$$

where $\epsilon$ denotes the vector $(\epsilon_s) \in \{0,1\}^k$. From the
choice of the parity-check matrix, we have $(g_s)_i = \delta_{si}$
for any $1 \le i \le k$. Therefore, the vectors $|G_\epsilon\rangle$ are of the
form

$$
|G_{\epsilon}\rangle = |\epsilon_1\rangle \otimes \dots \otimes |\epsilon_k\rangle \otimes \bigotimes_{i=k+1}^{n} \left| \bigoplus_{s=1}^{k} \epsilon_s(g_s)_i \right\rangle . \quad (10)
$$

The $2^k$ codewords $|G_\epsilon\rangle$ form a basis of the codespace $\mathcal{C}$, that is they are linearly independent and +1 eigenstates of the stabilizers. Indeed, one can verify that $\langle G_\epsilon | G_{\epsilon'} \rangle =$

$\delta_{\epsilon\epsilon'}$ from Eq. (10) and that the action of a stabilizer $\sigma_t$
is given by

$$
\begin{align*}
\sigma_t |G_\epsilon\rangle &= \left[ \bigotimes_{i=1}^n (Z^{(i)})^{(h_t)_i} \right] \bigotimes_{i=1}^n \left| \bigoplus_{s=1}^k \epsilon_s(g_s)_i \right\rangle \\
&= \bigotimes_{i=1}^n (-1)^{(h_t)_i} (\bigoplus_{s=1}^k \epsilon_s(g_s)_i) \left| \bigoplus_{s=1}^k \epsilon_s(g_s)_i \right\rangle \\
&= (-1)^{\bigoplus_{i=1}^n (h_t)_i} (\bigoplus_{s=1}^k \epsilon_s(g_s)_i) \bigotimes_{i=1}^n \left| \bigoplus_{s=1}^k \epsilon_s(g_s)_i \right\rangle \\
&= (-1)^{\bigoplus_{s=1}^k \epsilon_s} (\bigoplus_{i=1}^n (g_s)_i (h_t)_i) |G_\epsilon\rangle \\
&= |G_\epsilon\rangle
\end{align*}
$$

for any $t \in [n-k]$, $\epsilon \in \{0,1\}^k$, where we have used
Eq. (8).

This sets a simple form of the isomorphism from the log-
ical space $\mathcal{E}$ to the code space $\mathcal{C}$ as

$$
S = \sum_{\epsilon_1, \dots, \epsilon_k} |G_{\epsilon}\rangle \langle \epsilon_1| \otimes \dots \otimes \langle \epsilon_k|. \quad (11)
$$

One can verify that $S$ is an isometry – $S^\dagger S = \mathbb{1}_\mathcal{E}$ and $SS^\dagger$ is the orthogonal projection onto $\mathcal{C}$. For a classical stabilizer code, we call the isometry $S$ given in Eq. (11) the *canonical* isometry of the code.

In all generality, the isometry between the logical space
and the codespace is given by the canonical isometry
$S$ up to a change of basis on both physical and logi-
cal spaces. Therefore, one can write it in its most gen-
eral form to be $S' = VSW^{\dagger}$ where $V$ and $W$ denote
the basis change operations in the physical and logical
spaces respectively. In order for $S'$ to be a valid isome-
try, it must verify that $S'S^{\dagger}$ is the projection onto the
codespace, and therefore that $V(\mathcal{C}) \subset \mathcal{C}$. This means
that $V$ must preserve the codespace, and therefore, if
we write $V|_{\mathcal{C}} = \sum_{\epsilon, \epsilon'} V_{\epsilon\epsilon'} |G_{\epsilon}\rangle \langle G_{\epsilon'}|$ its restriction to the
codespace, one has

$$
S' = VSW^{\dagger} = V|_{C}SW^{\dagger} = S\tilde{W}^{\dagger} \quad (12)
$$

where we introduced $\tilde{W} := W \cdot \sum_{\epsilon, \epsilon'} V_{\epsilon\epsilon'} |\epsilon\rangle \langle \epsilon'|$. As such, any physical change of basis in the isometry can be properly regarded as a change of logical basis.

B : LOGICAL PAULI OPERATORS FOR THE
CANONICAL ISOMETRY

Considering the canonical isometry $S$ and any $1 \le j \le k$, the Z-Pauli operator on logical qubit $j$ admits an implementation $Z^{(j)}$ at the physical level from a single Z-
Pauli on qubit j, as we have

$$
\begin{align*}
S^\dagger Z^{(j)} S |\epsilon_1\rangle \otimes \dots \otimes |\epsilon_k\rangle &= S^\dagger Z^{(j)} |G_\epsilon\rangle \\
&= S^\dagger Z^{(j)} \bigotimes_{i=1}^n \left| \bigoplus_{s=1}^k \epsilon_s(g_s)_i \right\rangle \\
&= S^\dagger (-1)^{\bigoplus_{s=1}^k \epsilon_s(g_s)_j} \bigotimes_{i=1}^n \left| \bigoplus_{s=1}^k \epsilon_s(g_s)_i \right\rangle \\
&= (-1)^{\bigoplus_{s=1}^k \epsilon_s(g_s)_j} |\epsilon_1\rangle \otimes \dots \otimes |\epsilon_k\rangle \\
&= (-1)^{\epsilon_j} |\epsilon_1\rangle \otimes \dots \otimes |\epsilon_k\rangle
\end{align*}
$$

where we used $(g_s)_j = \delta_{sj}$ for $1 \le j \le k$. This implies that any product of logical $Z$ operators can be implemented by a product of physical $Z$ operators with support on at most $k$ qubits. Note that, reciprocally, the action of the physical Pauli $Z^{(i)}$ operator on qubit $i$ implements the logical operation acting as a Pauli-$Z$ on each qubits for which $(g_j)_i = 1$.

Finally, one implementation of the logical operator performing a Pauli-X operation on the j-th logical qubit is given by the j-th line of the generating matrix $G$, as the operation applying a physical $X$ on each qubits $i$ for which $(g_j)_i = 1$.

### C: NON-UNIVERSALITY OF GATES FALLING UNDER THEOREM 1

For any other isometry choice $S' = SW^\dagger$, the corresponding logical operations $U'_L$ are equivalent to $U_L$ obtained for the canonical isometry up to a basis change,

see Eq. (12). As such, a given $U_L$ with an implementation $U$ at the physical level for which the support of $UPU^\dagger$ is upper bounded by $d$ for any physical single Pauli $Z$ operation $Z^{(j)}$ satisfies $U'_L W Z_L^{(j)} W^\dagger U_L^\dagger = \sum_\alpha b_\alpha W Z_{L,\alpha} W^\dagger$, that is $U'_L(WV_Z W^\dagger) \subset WV_Z W^\dagger$ for the algebra $V_Z$ spanned by $Z_L^{(j)}$ corresponding to the canonical isometry. As such, to study universality, it suffices to focus on the canonical isometry, for which $V_Z$ is the subspace of all product of Pauli-$Z$ operations.

**Lemma 3.** For a given operator $U_L$ acting on an Hilbert space of $k$ qubits, one has:

$$ \left( \forall j \in [k], U_L Z_L^{(j)} U_L^\dagger = \sum_\alpha b_\alpha Z_{L,\alpha} \right) \iff U_L V_Z U_L^\dagger \subset V_Z \quad (13) $$

where $V_Z$ denotes the algebra spanned by the $Z_L^{(j)}$ operators.

**Lemma 4.** The subgroup $G$ of unitary operators verifying $U_L V_Z U_L^\dagger \subset V_Z$ is closed, and thus not universal.

*Proof.* We consider the standard operator norm $|||\cdot|||$, which is multiplicative, i.e. $|||A \cdot B||| \le |||A||| \times |||B|||$. Note that for any operator $U_L$, we have $|||U_L^\dagger||| = |||U_L|||$ and $|||U_L||| = 1$ iff $U_L$ is unitary.

Now we consider an arbitrary unitary operator $U_L$ that belongs to $\bar{G}$. For every $\varepsilon > 0$, there exists an operator $g_\varepsilon \in G$ such that $|||U_L - g_\varepsilon||| \le \varepsilon$. For every $P_L \in V_Z$ there exists $P'_L \in V_Z$ such that $g_\varepsilon P_L g_\varepsilon^\dagger = P'_L$. Then, it follows

$$
\begin{align}
|||P'_L - U_L P_L U_L^\dagger||| &= |||g_\varepsilon P_L g_\varepsilon^\dagger - U_L P_L U_L^\dagger||| \nonumber \\
&\le |||g_\varepsilon P_L g_\varepsilon^\dagger - U_L P_L g_\varepsilon^\dagger||| + |||U_L P_L g_\varepsilon^\dagger - U_L P_L U_L^\dagger||| \tag{14} \\
&\le |||P_L||| \times (|||g_\varepsilon^\dagger||| \times |||g_\varepsilon - U_L||| + |||U_L||| \times |||g_\varepsilon^\dagger - U_L^\dagger|||) \nonumber \\
&\le 2\varepsilon \nonumber
\end{align}
$$

Taking $\varepsilon \to 0$ in the above shows that $U_L P_L U_L^\dagger \in \bar{V}_Z$. Yet, $\bar{V}_Z = V_Z$ and thus $U_L P_L U_L^\dagger \in V_Z$ for all $P_L$, which is exactly $U_L \in G$. In the end, we proved that $G$ is closed, and since it does not contain every operators of $L(\mathcal{E})$ – such as $H$ for example – it cannot form a universal set of gates. $\square$