Quantum spherical codes

Codewords of qubit codes  are quantum superpositions of bit-strings. By analogy, we start with a spherical code, which is a set, or constellation, of points on the unit sphere. To construct a quantum spherical code, or QSC, we take a collection $\{\mathcal{C}_{k}\}_{k=0}^{K-1}$ of logical constellations, each of which gives rise to a codeword of the QSC obtained by taking a quantum superposition of all points $\mathbf{x}\in\mathcal{C}_{k}$. We consider uniform superpositions here, leaving more general codes to future work. Taken together, the logical constellations yield the code constellation, $\mathcal{C}=\bigcup_{k=0}^{K-1}\mathcal{C}_{k}$.

In the electromagnetic setting, spherical codes protect classical information against signal fluctuations during transmission, which correspond to small shifts acting on points in the constellation. A code’s ability to protect against such errors can be quantified by the minimum (squared) Euclidean distance $d_{E}$ between any pair of distinct points. QSCs naturally inherit $d_{E}$ as a figure of merit for protecting against such “bit-flip” noise.

Since QSCs store quantum information, they also suffer from “phase” noise, which comes from, e.g., fiber attenuation. Such noise can be expressed in terms of “potential-energy” functions on the sphere whose evaluation can be used to distinguish logical constellations (cf. [26, Sec. VI.B; 33]). If the average of a function over points in a constellation ${\cal C}_{k}$ depends on $k$, then the function’s underlying physical process causes an undetectable “phase” error.

An $(n,K,d_{E})$ spherical code contains $K$ points on the $n$-dimensional unit sphere such that the squared Euclidean distance between any two points is at least $d_{E}$. An $(\!(n,K,d_{E},\dots)\!)$ QSC is a $K$-dimensional subspace of a quantum system’s vector space whose states are labeled by points on an $n$-dimensional (real or complex) unit sphere, and whose protection against rotations is quantified by $d_{E}$. Protection against “phase” noise is designated by the proxy “$\dots$” because the notion of a “phase-flip” distance depends on the physical system embedding the QSC.

In principle, the above framework applies to any quantum state space parameterized by points on a sphere. CV systems [34, 35] admit several such spaces, and there exist examples of QSCs expressed using ordinary [29, 30, 36], squeezed [37, 38, 39], and pair-coherent states [40]. Collective atomic systems described by spin-coherent states as well as rotational state spaces of diatomic molecules also admit QSCs, namely, various large-spin codes  [41] and diatomic molecular codes [26, Sec. VI], respectively. We focus on coherent-state QSCs because such codes naturally generalize the cat codes, and error-correction procedures for these new multimode cat codes require a similar type of overhead as what has already been realized [1, 2, 3, 4, 5]. We note that the discussion below can be modified to apply to other manifestations of QSCs.

A single-mode coherent state is a quantum representation of a standing wave of a fixed-frequency signal. An $n$-mode coherent state $|\bm{\alpha}\rangle$ is parameterized by a complex $n$-dimensional point $\bm{\alpha}$. The point’s norm $\|\bm{\alpha}\|^{2}$ corresponds to the state’s energy, and points of all states with a fixed energy $\bar{\textsc{n}}$ form a complex $n$-sphere, $\Omega_{n}=\{\bm{\alpha}\in\mathbb{C}^{n}\,,\,\|\bm{\alpha}\|^{2}=\textnormal{$\bar{\textsc{n}}$}\}$.

Coherent-state QSCs consist of disjoint logical constellations $\mathcal{C}_{k}$ of $|\mathcal{C}_{k}|$ points picked from the $n$-sphere and superimposed to form logical codewords,

where we restrict logical constellations to lie on the unit $n$-sphere and delegate the overall scaling of the sphere’s radius to $\bar{\textsc{n}}$. An example to keep in mind is the four-component cat code defined by $\mathcal{C}_{0}=\{(1),(-1)\}$ and $\mathcal{C}_{1}=\{(\mathrm{i}),(-\mathrm{i})\}=\mathrm{i}\mathcal{C}_{0}$.

The normalization in Eq. (1) is only valid asymptotically as $\textnormal{$\bar{\textsc{n}}$}\to\infty$ because coherent states are not quite orthogonal due to the uncertainty principle,

The above “quantum corrections” for two coherent states of a code are suppressed exponentially with the energy $\bar{\textsc{n}}$ and the minimum distance between two points in the code’s constellation $\mathcal{C}=\bigcup_{k}\mathcal{C}_{k}$,

Since $d_{E}$ sets the scale of resolution of the constellation points, we refer to it as the resolution from now on.

Coherent states are subjected to two essentially different types of distortion — angular dephasing due to fluctuations in a mode’s frequency and changes in the mode’s excitations [42, Sec. II.A]. These induce “bit” and “phase” noise on QSCs, respectively. The corresponding relevant noise operators are passive linear-optical transformations and products of modal ladder operators $\{a_{j},a_{j}^{\dagger}\}_{j=1}^{n}$, whose commutator is $[a_{j},a_{\ell}^{\dagger}]=\delta_{j\ell}$. Products of transformations and ladder operators can be used to express any physical noise channel [43, Eq. (39)].

Transformations on $n$ modes are parameterized by the unitary group $\mathsf{U}(n)$ [35, Sec. 5.1.2]. A transformation $U_{\bm{R}}$ corresponding to the $n$-dimensional unitary matrix $\bm{R}$ rotates a coherent state $|\bm{\alpha}\rangle$ into $|\bm{R}\bm{\alpha}\rangle$. If the rotation satisfies $\|\bm{R}\bm{\alpha}-\bm{\alpha}\|^{2}<d_{E}$, the transformation is detectable in the $\textnormal{$\bar{\textsc{n}}$}\to\infty$ limit. Codes with larger resolution protect against larger sets of transformations.

A general ladder error,

is a monomial in the operators $(a_{1},a_{2},\cdots,a_{n})=\bm{a}$ and their adjoints. It is parameterized by non-negative integer vectors $\bm{p}=(p_{1},p_{2},\cdots,p_{n})$ and $\bm{q}=(q_{1},q_{2},\cdots,q_{n})$ quantifying how many energy carriers (e.g., photons or phonons) are gained and lost in each mode, respectively.

Lowering operators $a_{j}$ are “diagonal” in the coherent-state basis, satisfying $a_{j}|\bm{\alpha}\rangle=\alpha_{j}|\bm{\alpha}\rangle$, where $\alpha_{j}$ is the $j$th component of $\bm{\alpha}$. This “diagonality” relation and its adjoint imply that the expectation value of a ladder error over the $k$th codeword (1) reduces to the average of the operator’s corresponding monomial over $\mathcal{C}_{k}$,

where the one-norm $|\bm{p}+\bm{q}|$ is the degree of $L_{\bm{p},\bm{q}}(\bm{\alpha}^{\star},\bm{\alpha})$. A ladder error can be detected whenever the above average is independent of $k$ [44].

We have found numerous QSCs whose constellations form vertices of real [45] or complex [46, 47] polytopes . Polytope vertices are both sufficiently well-separated and uniform, providing protection against both types of noise. Code and polytope tables for the two cases are in Appxs. A and B, respectively.

We characterize ladder-error protection of polytope QSCs with three “distances”: $d_{\downarrow}$, $t_{\downarrow}$, and $d_{\updownarrow}$. The first is the number of detectable losses (plus one), signifying that any pure-loss ladder error $L_{\bm{p}=\bm{0},\bm{q}}$ with $|\bm{q}|<d_{\downarrow}$ is detectable. Similarly, $t_{\downarrow}$ is the number of correctable losses (plus one), signifying that any ladder error with $|\bm{p}|,|\bm{q}|<t_{\downarrow}$ is detectable. The degree distance $d_{\updownarrow}$ signifies that the code detects ladder errors with degree $|\bm{p}+\bm{q}|<d_{\updownarrow}$. These three parameters satisfy

and can vary quite significantly.

Our notation for an $n$-mode polytope QSC with $K$ logical codewords is $(\!(n,K,d_{E},d_{\updownarrow})\!)$ or, more generally, $(\!(n,K,d_{E},\langle t_{\downarrow},d_{\updownarrow},d_{\downarrow}\rangle)\!)$. The four-component cat code is a $(\!(1,2,2.0,\langle 2,2,2\rangle)\!)$ QSC, detecting $d_{\downarrow}-1=1$ loss error while sporting the relatively high resolution of $2.0$. Since it can detect one gain simultaneously with one loss, this code also corrects $t_{\downarrow}-1=1$ loss error.

Each logical constellation of the four-component cat code is a line segment, and the code constellation forms the vertices of a square. More generally, logical constellations of the $2p$-component $(\!(1,2,4\sin^{2}\frac{\pi}{2p},\langle p,p,p\rangle)\!)$ cat code are two $p$-gons whose vertices interleave for maximal resolution. There is a tradeoff between loss protection and resolution, with the latter of order $O(1/p^{2})$ for a large number $p-1$ of correctable losses. Utilizing higher dimensions, we pick other complex polytopes that maintain the same resolution while offering increased loss protection over the cat codes.

A simple code straddling the $p=2,3$ cat codes in terms of performance is the $(\!(2,2,1.5,\langle 2,3,3\rangle)\!)$ simplex code,

where $\omega=e^{i\frac{2\pi}{5}}$. This code admits a lower resolution than the $p=2$ cat code, but detects one more loss in any of the two modes. Equivalently, it admits a higher resolution than the $p=3$ cat code’s resolution of unity, but corrects one fewer loss. Simplices exist in any dimension, yielding the infinite $(\!(n,2,2-1/n,3)\!)$ QSC family that approaches the resolution of the $p=2$ cat code with increasing $n$ while detecting one more loss in any mode.

The Möbius-Kantor $(\!(2,3,1.0,\langle 3,4,4\rangle)\!)$ code maintains the resolution of the $p=3$ cat code while adding one more logical state and detecting one more loss. Each of its three logical constellations form the 8 vertices of a Möbius-Kantor polygon ($3\{3\}3$ in Coxeter notation; see Appx. B), and such polygons combine to form the 24 vertices of a $3\{4\}3$ polygon. This code corrects one more loss than the $\mathsf{2T}$-qutrit  [36], a $(\!(2,3,1.0,\langle 2,4,4\rangle)\!)$ QSC whose logical constellations each make up the 8 vertices of a complex octagon $2\{4\}4$. These two codes differ despite the fact that both code constellations map to the vertices of the same real 4D polytope via the mapping $(x+iy,z+iw)\to(x,y,z,w)$, demonstrating subtleties in using real polytopes to define complex QSCs.

Logical constellations of the powerful $(\!(3,2,1.0,\langle 4,5,9\rangle)\!)$ Hessian code consist of the 27 vertices of a Hessian polytope,

where $\eta=e^{i\frac{2\pi}{3}}$, and “perms.” is shorthand for the two cyclic permutations of the vector to the left for each $\mu,\nu$. This code corrects as many losses as the $p=4$ cat code, but has the resolution of the $p=3$ cat code. Moreover, it can detect up to 8 losses, a feature available only to the $p\geq 9$ cat codes.

There is a $(\!(2,2,2-\sqrt{2},\langle 5,6,12\rangle)\!)$ code that maintains the same resolution as the $p=4$ cat code, but corrects one more and detects 8 more losses. Its logical constellations each form the 24 vertices of a $4\{3\}4$ polygon, combining into a 48-vertex $2\{6\}4$ polygon.

An overachieving cousin of the above code is the $(\!(4,2,2-\sqrt{2},\langle 6,8,12\rangle)\!)$ Witting code, consisting of two Witting polytopes with 240 vertices each. This code corrects as many losses as a $p=6$ cat code, has the resolution of a $p=4$ cat code, and detects up to 11 losses. It is the first member of the infinite $(\!(2^{r},2,2-\sqrt{2},8)\!)$ family of codes that are based on orbits of the real Clifford group  [48, 49, 50, 51].

A lower bound on $d_{\updownarrow}$ for Clifford, simplex, or other QSCs can be obtained whenever their logical constellations form designs [52]. A constellation $\mathcal{C}_{k}$ is a complex spherical design [53, 54] of strength $\tau$ if averages of monomials $L_{\bm{p},\bm{q}}$ of total degree $|\bm{p}+\bm{q}|\leq\tau$ over $\mathcal{C}_{k}$ (1) are equal to those over the entire unit $n$-sphere,

Design strength is preserved under unitary rotations $\bm{R}$, so logical constellations $\mathcal{C}_{k}=\bm{R}_{k}\mathcal{C}_{0}$ consisting of rotated versions of a complex spherical $\tau$-design $\mathcal{C}_{0}$ yield a QSC whose degree distance is at least $\tau+1$. In this way, construction of good QSCs can be accomplished by finding well-separated spherical designs $\mathcal{C}_{0}$ of high strength coupled with a choice of rotations $\{\bm{R}_{k}\}_{k=0}^{K-1}$ (with $\bm{R}_{0}$ the identity) that permits to control the resolution $d_{E}$ of the code constellation $\bigcup_{k}\bm{R}_{k}\mathcal{C}_{0}$ while achieving high logical dimension $K$.

Corroborating our parameter-based analysis, we numerically compare the performance of multi- and single-mode codes using the channel fidelity [55, 56, 57, 58, 59]. We observe that, for quKit encodings (for $K>2$), even simple multi-mode constellations, such as the simplex (7), are able to utilize the extra dimensions efficiently and outperform single-mode constellations over a range of loss rates (see Appx. D). The more non-trivial $K=6$ Möbius-Kantor $\subset 2\{8\}3$ encoding (see Table B.1) consistently outperforms various combinations of cat codes for a wide range of energies and noise parameters.

Concatenations of CSS codes  [60, 61, 62] with the two-component cat code  [29], $\mathcal{C}_{0}=\{(+1)\}=-\mathcal{C}_{1}$, can also be interpreted as QSCs, albeit with a weight-based notion of ladder-error protection. Such codes are actively studied [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], but have so far been interpreted in the framework of the outer qubit code and not in terms of underlying modal degrees of freedom. Our interpretation parallels a standard way to construct (classical) spherical codes by mapping binary codes to the (real) sphere [31, Sec. 2.5; 32, Sec. 1.2].

A $[[n,k,(d_{X},d_{Z})]]$ qubit CSS code is constructed from two binary linear codes with distances $d_{X}$ and $d_{Z}$, guaranteeing detection of Pauli $X$-type and $Z$-type errors with weights less than the distances, respectively. Its codewords are equal superpositions of multi-qubit states labeled by binary strings. Concatenation is equivalent to mapping each binary string into a point on the $n$-sphere via the coordinate-wise antipodal mapping $0\to+1$ and $1\to-1$. This yields an $(\!(n,2^{k},d_{E}=4d_{X}/n,w_{\updownarrow}=d_{Z})\!)$ QSC that detects all errors $L_{\bm{p},\bm{q}}$ with Hamming weight $\Delta(\bm{p}+\bm{q})<w_{\updownarrow}$ (see Appx. C). Asymptotically good qubit CSS codes thus yield QSCs whose distances $d_{E},w_{\updownarrow}$ are both separated from 0 as $n\to\infty$.

Rotations on the $n$-sphere provide groups of $X$-type logical gates and stabilizers for QSCs. Elements of a logical group $\mathsf{G}$ permute logical constellations. Elements of a stabilizer subgroup $\mathsf{H}\subset\mathsf{G}$ permute points within each constellation, thereby leaving codewords invariant. Rotations are realized by passive linear-optical transformations using [35, Eq. (3.24)]. Rotation-based gates are noise-bias preserving [63] in that they do not convert rotations into losses.

For cat codes with $2p$ components, $\mathcal{C}_{0}=\{(\zeta^{2j})\,|\,j\in\mathsf{\mathbb{Z}_{p}}\}=\zeta\mathcal{C}_{1}$ with $\zeta=e^{\mathrm{i}\frac{\pi}{p}}$, the 1D rotation $\zeta$ permutes the two constellations, while powers of $\zeta^{2}$ leave each constellation invariant. These rotations generate $\mathsf{H}=\mathsf{\mathbb{Z}_{p}}\subset\mathsf{G}=\mathsf{\mathbb{Z}_{2p}}$ and are realized by transformations $\zeta^{a^{\dagger}a}$ and $\zeta^{2a^{\dagger}a}$.

Simplex constellations (7) can be permuted with the $-\left(\begin{smallmatrix}1&0\\ 0&1\end{smallmatrix}\right)$ rotation and are invariant under powers of $\omega\left(\begin{smallmatrix}1&0\\ 0&\omega\end{smallmatrix}\right)$, corresponding to the groups $\mathsf{\mathbb{Z}_{5}}\subset\mathsf{\mathbb{Z}_{5}}\times\mathsf{\mathbb{Z}_{2}}$, respectively. The latter group is generated by the two-mode transformations $(-1)^{a_{1}^{\dagger}a_{1}+a_{2}^{\dagger}a_{2}}$ and $\omega^{a_{1}^{\dagger}a_{1}+2a_{2}^{\dagger}a_{2}}$.

A stabilizer group for the Hessian code (8) is $\mathsf{He_{3}}=\langle\eta,X,Z\rangle$, the 27-element qutrit Pauli/$\mathsf{He}$isenberg group consisting of powers of $\eta$ and the $X,Z$ qutrit Pauli matrices. Appending by the logical-$X$ rotation $-I$, where $I$ is the 3-by-3 identity, yields the logical group $\mathsf{He_{3}\times\mathbb{Z}_{2}}$. These groups are realized by phase-shifters and SWAP gates. Larger $\mathsf{H}\subset\mathsf{G}$ can be picked using the fact that all constellations form polytopes. The largest such groups are the 648-element and 1296-element symmetry groups of the corresponding Hessian and double-Hessian polytopes, respectively. These offer other ways to implement the logical-$X$ Pauli gate, but do not yield other gates.

Qudit QSCs offer larger logical-gate groups. The two groups are $\mathsf{\mathbb{Z}_{2}}\subset\mathsf{2I}$ for the 24-cell $(\!(2,5,0.382,\langle 4,6,8\rangle)\!)$ real polytope code, with the former generated by the 5-by-5 matrix $-I$, and the latter the binary icosahedral group $\mathsf{2I}$. Since the stabilizer group acts trivially, the logical group acts on the 5 codewords as a 5D permutation representation of the icosahedral group $\mathsf{I}=\mathsf{2I/\mathbb{Z}_{2}}$.

CSS-based QSCs inherit logical-$X$ stabilizers (gates) by mapping each $X$-type stabilizer (logical Pauli) to a transversal linear-optical transformation via the component-wise mapping $\sigma_{x}\to(-1)^{a^{\dagger}a}$. For example, the $\sigma_{x}^{\otimes 4}$ stabilizer of the $[[4,2,2]]$ code  is mapped to the joint parity $\bigotimes_{j=1}^{4}(-1)^{a_{j}^{\dagger}a_{j}}$.

The $Z$-type “stabilizer” for $2p$-component cat codes is $F(a)=a^{2p}-\textnormal{$\bar{\textsc{n}}$}^{p}$, which annihilates each point in the dilated code constellation $\sqrt{\textnormal{$\bar{\textsc{n}}$}}\mathcal{C}$. The corresponding polynomial $F(\alpha)$ can be thought of as a potential on the sphere that is minimized only at the code-constellation points [64].

Polytope QSCs can require multiple polynomials to be stabilized. Simplex codes (7) are stabilized by $F_{1}=a_{1}^{2}a_{2}^{4}-\textnormal{$\bar{\textsc{n}}$}^{3}$ and $F_{2}=a_{1}^{3}a_{2}-\textnormal{$\bar{\textsc{n}}$}^{2}$. Hessian codewords (8) are stabilized by the $F_{1}=a_{1}a_{2}a_{3}$, $F_{2}=a_{1}^{3}+a_{2}^{3}+a_{3}^{3}$, and $F_{3}=a_{1}^{6}+a_{2}^{6}+a_{3}^{6}-\textnormal{$\bar{\textsc{n}}$}^{3}/4$. The degree of $F_{1,2}$ is lower than the code’s degree distance ($d_{\updownarrow}=5$) and detectable-loss distance ($d_{\downarrow}=9$), unlike for the cat codes. This property makes this code similar to degenerate stabilizer codes , i.e., codes whose check-operator weight is smaller than their distance.

Stabilizer polynomials commute with logical transformations $U_{\bm{R}}$ for any $\bm{R}$ in the logical group and can be obtained by averaging ladder operators (4) over the symmetry group of the code constellation’s polytope.

Other polynomials act as logical gates on QSCs, evaluating to the same value for all points in $\mathcal{C}_{k}$ in a way that depends on $k$. For the cat codes, $G=a^{p}$ evaluates to $\pm\textnormal{$\bar{\textsc{n}}$}^{p/2}$ on the two codewords, respectively, yielding a logical-$Z$ gate. The monomial $G=a_{1}a_{2}^{2}$ projects to a logical-$Z$ gate within the simplex codespace. The smallest loss-only $Z$-gate of the Hessian code is $G_{1}=a_{1}^{3}a_{2}^{6}$ or its two cyclic permutations, and only a permutation-symmetric combination of all three operators commutes with the stabilizer group. A lower-degree monomial $G_{2}=a^{\dagger}_{1}a_{1}a_{2}^{3}$ realizes another $Z$-gate with the help of gain operators. Combinations $G_{j}+G_{j}^{\dagger}$ generate logical $Z$-rotations within the $F$-annihilated subspace [64], and have been realized for $p=2$ cat codes [4].

CSS-based QSCs inherit gates/stabilizers by mapping each $Z$-type gate/stabilizer to a monomial via the component-wise mapping $\sigma_{z}\to a$. For example, the $[[4,2,2]]$ code’s $\sigma_{z}\otimes\sigma_{z}\otimes I\otimes I$ gate is mapped to $a_{1}a_{2}$. These codes also require stabilizers $a_{j}^{2}-\textnormal{$\bar{\textsc{n}}$}/n$ on each mode $j$ in order to stabilize the inner cat-code constellation.

Protection against rotation-based noise for $2p$-component cat codes is done passively using a Lindbladian whose jump operator is the $Z$-type stabilizer $F$ [64] and/or a Hamiltonian $F^{\dagger}F$ [65, 66]. Both techniques have been realized for $p=2$ [3, 5]. General QSCs admit the same type of passive protection but require several $F_{j}$’s.

Microwave cavities coupled to superconducting circuits [67] provide a fertile ground for realizing such passive protection, and we outline how an existing superconducting circuit element called an “ATS” [68] can be tuned to realize the more complicated jump operators of several QSCs (see Appx. E). In particular, we show that a recent surface-cat concatenated-code proposal [17] can be readily modified with a $Z$-type surface-code stabilization scheme, thereby utilizing the full power of the code against $Z$-type noise in exclusively passive fashion.

Ladder errors (4) map the $k$th codeword (1) into error states in $\text{span}\{|\bm{\alpha}\rangle,\bm{\alpha}\in\mathcal{C}_{k}\}$. The stabilizer group $\mathsf{H}$ splits up into several irreducible representations (irreps) acting on this span. Ladder-error protection is done by measuring syndromes associated with irreps and mapping back into the codespace. In order for correction to be possible, the stabilizer group has to be able to resolve all error spaces associated with a given error set.

The $4$-component cat-code stabilizer is the parity $(-1)^{a^{\dagger}a}$. Its eigenvalues correspond to the two irreps of $\mathsf{H}=\mathsf{Z_{2}}$, distinguishing between no error and a single loss $a$. This technique [1] led to the first demonstration of break-even QEC using $p=2$ cat codes [2]. Similar multimode parities detect $X$-errors for CSS-based QSCs.

For the simplex code (7), eigenvalues of the two-mode stabilizer $\omega^{a_{1}^{\dagger}a_{1}+2a_{2}^{\dagger}a_{2}}$ label the five irreps of $\mathsf{Z_{5}}$. They allow for correction of $\{a_{1},a_{2},a_{1}a_{2},a_{2}^{2}\}$, falling short of correcting all two-mode losses due to $a_{1}^{2}$ not being simultaneously correctable with $a_{2}$.

For the Hessian code (8), the transformations realizing $\mathsf{He_{3}}$ can be measured to resolve the group’s 11 irreps. The general procedure for this and other non-Abelian codes resembles that of molecular codes [26, Sec. V.D].

We introduce a framework for constructing quantum analogs of the classical spherical codes, encapsulating several physically relevant quantum coding schemes for bosonic, spin, and molecular systems. We apply our framework to obtain multi-mode coherent-state codes based on polytopes, CSS codes, and classical codes. These QSCs outperform previous cat-code constructions [29, 30, 36] both in terms of code parameters and a numerical performance comparison. We show how passive protection of several instances of these QSCs can be realized in microwave cavities.

There are many other ways of constructing spherical codes, e.g., as group-orbit codes  [69, 70, 71], as spherical embeddings of association schemes [32], through computer searches [72, 73], and many others [74, 31, 32, 75], as well as ways of constructing spherical designs [76, 77, 78]. As such, we anticipate that this work will pave the way for many novel, well-protected, and experimentally feasible logical qubits.