Biased Gottesman-Kitaev-Preskill repetition code

Continuous-variable quantum computing architectures based upon the Gottesmann-Kitaev-Preskill (GKP) encoding have emerged as a promising candidate because one can achieve fault-tolerance with a probabilistic supply of GKP states and Gaussian operations. Furthermore, by generalising to rectangular-lattice GKP states, a bias can be introduced and exploited through concatenation with qubit codes that show improved performance under biasing. However, these codes (such as the XZZX surface code) still require weight-four stabiliser measurements and have complex decoding requirements to overcome. In this work, we study the code-capacity behaviour of a rectangular-lattice GKP encoding concatenated with a repetition code under an isotropic Gaussian displacement channel. We find a numerical threshold of $\sigma = 0.599$ for the noise's standard deviation, which outperforms the biased GKP planar surface code with a trade-off of increased biasing at the GKP level. This is all achieved with only weight-two stabiliser operators and simple decoding at the qubit level. Furthermore, with moderate levels of bias (aspect ratio $\leq 2.4$) and nine or fewer data modes, significant reductions in logical error rates can still be achieved for $\sigma \leq 0.3$, opening the possibility of using GKP-biased repetition codes as a simple low-level qubit encoding for further concatenation.


I. INTRODUCTION
Approaches to quantum computation based upon the continuous-variable (CV) formalism have recently seen promising developments within both experiment and theory.On the experimental front, large-scale CV cluster states have been generated optically [1][2][3][4][5].Furthermore, single-and two-mode Gaussian operations have also been demonstrated on these platforms as a proof of concept for CV measurement based quantum computation [6,7].Theoretical advances have reduced the problem of achieving universal, fault-tolerant computation [8][9][10] to that of probabilistically generating high quality Gottesman-Kitaev-Preskill (GKP) states [11].
In CV quantum computation, an approach to achieving fault-tolerance is through concatenating an inner bosonic code [12] with an outer qubit code [13].The bosonic code discretises the CV noise to produce effective qubits while taking advantage of redundancy in the Hilbert space to provide error resilience.Examples include cat [14], binomial [15] and GKP [11] codes.These encoded modes can then be used as input to a qubit-level code, provided the error rates for the inner layer fall below the qubit code threshold fault-tolerant computation can be achieved [16].
Within this approach, GKP codes are particularly attractive because once you have a supply of encoded resource states everything else is Gaussian [8,17], which is considerably easier to perform experimentally.A fur-ther benefit for optical architectures is that Gaussian operations can be performed at room temperature, and the overall system can take advantage of the intrinsic scalability offered through integrated photonic platforms [6,7,9,10].
The theoretical and experimental progress made so far is yet to coalesce due to the challenge in generating sufficiently high-quality GKP states.Square-lattice GKP states have been experimentally generated on superconducting [18] and trapped-ion [19,20] platforms.Although recent work has demonstrated GKP error correction beyond break-even [21], state quality currently does not meet the requirements for fault tolerance.In the optical domain, GKP states have not yet been produced, although several generation methods have been proposed [22][23][24][25][26][27].Lessening the experimental burden by reducing both the number of modes and quality of state required to successfully perform GKP error correction is therefore a vital and active area of research.
Recent work has shown that some codes, such as the original surface code [28] and, even better, the XZZX surface code [29], exhibit improved thresholds under biased noise [30,31].Therefore, having a bosonic code that produces an effective qubit with biased noise may be advantageous.Rectangular-lattice GKP codes produce biased logical noise when correcting an unbiased channel due to asymmetry in the lattice spacing.Concatenation with the surface code [32] and the XZZX code [33] have both shown an improved threshold under an isotropic Gaussian displacement channel (GDC).However, surface codes have complex decoding requirements and require weight-four stabiliser measurements that may have an undesirable effect on the overall system performance arXiv:2212.11397v2[quant-ph] 1 Dec 2023 when attempting to scale.
Just as the Shor code [34] is a concatenation of two repetition codes, each protecting against a single type of logical error, we ask, can we take a similar approach with a concatenated GKP code?At the GKP level, we can leverage rectangular-lattice codes to drastically reduce one type of logical error (for example, phase flips) even with a modest lattice aspect ratio (due to superexponential decay of the tails of the complementary error function).We can then concatenate with a repetition code on the outer layer to correct against the bitflip errors neglected by the biased GKP code.Not only would this considerably simplify the qubit-level decoder, but it also halves the required connectivity per ancilla for making syndrome measurements to two.Similar approaches have been taken with cat-repetition codes with promising results [35,36].If the same applies to a biased GKP-repetition code, we can combine the advantages of Gaussian computation with the simplicity of this code structure.This is the motivation for our study.
In this work, we consider the code-capacity performance of biased GKP-repetition codes under the isotropic GDC parameterised by variance σ 2 .We choose this noise model in order to provide the most direct comparison with the original GKP code, the biased GKPsurface [32] code, and the GKP-XZZX [33] code, all of which benchmark their performance against this type of noise.(We discuss possible extensions to other noise models in Sec.V D.) The term code capacity means we analyse the performance of an ideal GKP code under conditions where the only source of noise is the channel itself.The inner bosonic layer is a rectangular-lattice GKP code that biases the effective qubit to protect against phaseflip errors.Furthermore, the level of bias can be tuned by choosing an appropriate lattice aspect ratio.We then concatenate with a classical n-qubit repetition code to protect against bit flips.To assess the code performance, we begin by comparing it against a single-mode, squarelattice GKP state.We find the code successfully suppresses the logical error rate, providing the GKP biasing is optimised for both the noise severity (standard deviation σ) and number of modes, n.We then numerically study the threshold behaviour of the code and find a performance improvement for noise levels below σ ≈ 0.599, remarkably outperforming the GKP-surface code result [32] when decoding without the analogue methods proposed in [37].The cost is increased biasing in the GKP lattice.If we restrict the maximum biasing of our code to that considered in [32], we find improved code performance for σ < 0.588.However, with this restriction, error rates cannot be arbitrarily suppressed below the cutoff, and the threshold behaviour is lost.We then shift to analysing the code for resources more applicable to potential small-scale experimental implementations.With up to 9 data modes and modest biasing r ≤ 2.4, we can suppress error rates with moderate values of σ < 0.3 by approximately a factor of 60.With only a few more modes (n ≤ 31) and a maximum biasing aspect ratio of r = 4, we can further suppress error rates below those required for fault-tolerance levels when concatenating with a further code [38].
The paper is structured as follows.In Section II, we introduce our notation conventions and useful functions.In Section III, we introduce the inner rectangular-lattice GKP code and study its performance under the GDC.Readers familiar with the GKP code structure and GDC are may skip directly to Section IV, where the outer repetition code is discussed before the two layers are put together to give our GKP-repetition code.Key results and discussion presented in Section V. Finally, we summarise our findings and discuss potential extensions for future work in Section VI.

II. PRELIMINARIES
We begin by reviewing the notation used throughout this paper, following the conventions in [39,40].Throughout the work, operators acting at the CV, logical-GKP, and repetition-code levels are given by Ô, Ō and O L respectively.States will likewise be denoted |ψ⟩, | ψ⟩ and |ψ⟩ L .Working in units where ℏ = 1, the position and momentum quadratures for a single mode of a quantum harmonic oscillator with creation and annihilation operators (â † , â) are given by respectively, satisfying the commutation relation [q, p] = i Î.In these units, the observed vacuum variance for any quadrature is σ 2 vac = 1/2.Quadrature eigenstates are denoted q|s⟩ q = s|s⟩ q , p|s⟩ p = s|s⟩ p . ( We now define the single-mode Gaussian operations that will be used in this paper.Under a Gaussian unitary operation Ĝ, the quadrature operators x = (q, p) ⊺ transform according to where S Ĝ is the symplectic representation of the Heisenberg action of Ĝ on the quadrature operators x, along with c, which represents a linear displacement term.
where their action shifts the quadrature eigenstates by the argument X(g)|s⟩ q = |g + s⟩ q , Ẑ(h)|t⟩ p = |h + t⟩ p .A general displacement operator D(g, h) is given by1 D(g, h) := e ihq−ig p.
D(g, h) translates the quadrature operators in phase space according to The rotation operator R(θ) is a phase delay, which is given by R(θ) rotates the phase-space representation of the state counterclockwise by angle θ against the mode's direction of normal unitary time evolution (hence, a delay in the phase).For θ = π/2 this becomes the Fourier gate F .The quadrature squeezing operator Ŝ(s), given by Ŝ(s) := e i ln (s)(q p+ pq)/2 , (10) defined in terms of the squeezing factor s > 0. When s > 1, this operator reduces the variance in the position quadrature while simultaneously increasing it in the momentum quadrature, both by a factor of s.When 0 < s < 1, these effects are reversed.The squeezing factor s is the exponential of the usual squeezing parameter [41,42].Finally, the shear operator is given by This operator shears the state's Wigner function along the momentum direction, increasing (resp., decreasing) in momentum for positive (resp., negative) position values.Together, displacements, rotations and either squeezing or shearing are sufficient to enact any single-mode Gaussian operation [39].
A useful phase-space representation of a CV state ρ is the Wigner function, defined by which for a pure state ρ = |ψ⟩ ⟨ψ| becomes where ψ(s) = q ⟨s|ψ⟩ is the position-basis wavefunction of the state.For a physical state, W ρ(q, p) must integrate to one over all phase space.A convenient property of Wigner functions is that, under Gaussian operations, the function transforms according to that is, one just needs to update the coordinates of the function according to the inverse of the Heisenberg action of the operator, Eq. (3).

III. RECTANGULAR GKP CODE
GKP codes are a way to encode a discrete quantum system within a harmonic oscillator [11].These are designed to correct against small displacement errors on the oscillator.Since these errors form an operator basis, the GKP code is capable of protecting to some degree against all errors.Recently, they have shown particular resilience to photon loss [43].Another benefit of the GKP encoding is that it can act as both an error-correcting code and a non-Gaussian resource for universality [8].Clifford operations on GKP qubits can all be implemented with Gaussian operations, which are considered easier to perform experimentally.Furthermore, obtaining a magic state [44] required for universality can be achieved by performing GKP error correction on the vacuum [8].
In this section, we introduce and discuss the rectangular-lattice GKP codes that form the inner layer of our scheme.We begin by defining ideal square-and rectangular-lattice GKP states before discussing their error-correcting capability under displacements.The isotropic Gaussian displacement channel is then introduced, and we analyse the performance of the singlemode GKP states that produce our effective qubits for concatenation.We find that by changing the shape of the GKP lattice, we bias the logical outcome of the GKP error-correction process.
A. Square-lattice GKP states Ideal, square-lattice GKP-qubit computational-basis states are defined by FIG. 1. Wigner functions of ideal square (r = 1) and rectangular (r = 4) GKP | 0⟩ states.The functions are periodic arrays of weighted δ-functions.Considering displacement errors, phase space can be partitioned into cells that show the logical outcome of a displacement followed by a round of GKP error correction.Example displacement errors are represented by arrows on the plots.Grey arrows show correctable displacements that terminate in a green unhatched cell, while black displacements result in a logical error and end in one of the hatched cells.Under biasing, the state becomes more resilient to errors in the momentum quadrature at the expense of increased susceptibility to errors in the position quadrature.
they are an infinite superposition of position quadrature eigenstates spaced 2 √ π apart.These states cannot be normalised and are therefore unphysical.The factor of (2 √ π) 1/2 is included here to simplify the transformations to the conjugate basis.Due to their periodicity, they-and thus all GKP code states-are stabilised by the group generated by , by halving the magnitude of the stabiliser operators.An arbitrary pure GKP qubit is given by The position-basis wavefunctions for the logical states ψ j (s) = q ⟨s| j⟩ for j ∈ {0, 1} are given by these are Dirac combs of period 2 √ π, with j encoding the half-period shift required for | 1⟩.By taking the Fourier transform of Eq. ( 19) we obtain the momentum basis wavefunctions ψj (s) = p ⟨s| j⟩, which evaluate to 2 where the comb period has halved to √ π and now has an alternating phase term depending on the logical content of the state.The prefactor of this function also differs from that in Eq. ( 19) by a factor of √ 2, which preserves the norm of the state.

B. Generalising to rectangular lattices
While square-lattice GKP states are most widely studied due to their balanced protection in each quadrature, we are free to define alternative-lattice grid states as long as the stabiliser generators commute [11].Keeping the direction of each displacement but allowing the magnitude to be different, we have where d specifies the dimension of the logical subspace contained within the code. 3For qubits (d = 2), the generalisation from the square lattice to a rectangular one results from letting g = 2 π/r and h = 2 √ πr for r ∈ R > 0. The stabiliser generators become ⟨ X(2 π/r), Ẑ(2 √ πr)⟩ and the logical operators are given by X( π/r), Ẑ( √ πr).Setting r = 1 recovers the square-lattice GKP states.The position-and momentum-space wavefunctions, Eqs. ( 19) and ( 20), generalise to The Wigner function for the rectangular | 0⟩ state parameterised by r is given by shown in Figure 1(b) for r = 4.The periodicity of the state has gone from 2 √ π in both quadratures to 2 π/r in the position quadrature and 2 √ πr in the momentum quadrature.In this sense, r can be interpreted as the aspect ratio of the lattice.
An alternative way to consider rectangular-lattice states is by squeezing the corresponding ideal squarelattice state.As the squeezing operator, Eq. (10), is Gaussian, we can use the Wigner function update rule, Eq. (16).Applying Ŝ( √ r) to a square-lattice | 0⟩ state results in the rectangular-lattice Wigner function, Eq. (25).Here, we stress that this interpretation only applies to ideal GKP states.If we attempted this method with an approximate square-lattice GKP state, we would not obtain the equivalent approximate rectangular lattice state

C. Correcting displacement errors
While ideal GKP states are unphysical, it is still useful to study their error-correction capability in a codecapacity model.Specifically, this is the error model in which all states, operations and measurements are assumed to be ideal.This shows us in principle whether a code can suppress errors under a certain noise channel. 4he effect of the GKP decoding process is to discretise the continuous noise in each quadrature to a binary outcome.Correction always returns us to the original GKP codespace with either the identity (in the case of successful correction) or a logical Pauli operator applied to the state [11].To perform this correction in practice, one can either implement Steane-style [45,46] or Knill-style (i.e.teleportation-based) [47,48] error correction.
The GKP encoding has an inbuilt error-correction capability against small displacements, schematically shown in Figure 1.We begin by noting that any ideal GKP qubit only has Hilbert-space support on {|n π/r⟩ q | n ∈ Z} in position and {|m √ πr⟩ p | m ∈ Z} in momentum.Therefore, taking quadrature measurements modulo π/r for position and √ πr for momentum will always return zero.Let | ψ⟩ undergo an arbitrary displacement D(g, h).Disregarding global phase, the corrupted state is Ẑ(h) X(g) | ψ⟩.Measuring the quadratures will return g = n π/r + δ q , h = m √ πr + δ p , where we have split the result into the codespace and remainder terms, the latter satisfying |δ q | ≤ π/4r, |δ p | ≤ πr/4.In practice, we only have access to the remainder and therefore only have information about how far away the state is from the codespace.
To attempt to correct the displacement, we implement the typical nearest-lattice-point decoder [11], which assumes that smaller displacements are more likely to occur.We apply the correction X(−δ q ) Ẑ(−δ p ) that brings the state back to the centre of the nearest cell in Figure 1.
If n and m are both zero, then the correction returns the system to the original state and corrects the displacement error, indicated by the solid green region around the origin.If m or n is odd, then the correction operation does not return the system to the original state.Instead | ψ⟩ is displaced to the centre of a hatched red cell, and a logical error is introduced.Using this decoder, we see that the rectangular-lattice codes can tolerate displacement errors of magnitude Example displacements are shown in Figure 1, represented as arrows from the origin.If the displacement lies within a solid green cell, the GKP correction process will succeed, represented here by grey arrows.For the cases where the displacement is too large, shown here by black arrows, the state is moved out of the central region into one of the hatched red cells.The correction displaces the state to the centre of the cell in which the state now lies, resulting in a logical error being applied.For the r = 1 state in Figure 1(a), a Z error occurs.For the r = 4 state in Figure 1(b), failure results in the application of X.Here, we see that choosing an alternate lattice results in different error-correction outcomes.The r = 4 state is now much more resistant to Ẑ shift errors at the expense of becoming less tolerant to X displacements.
Finally, we consider the case where n and m are both even.Even though the original displacement is much larger than the correction operation, snapping back to the lattice results in even powers of X and Z being applied.These are stabilisers.Therefore, the code can correct for some large displacements, shown by the green regions of phase space not at the origin.For the squarelattice GKP code under typical noise models, these large displacements have a negligible contribution to the outcome probabilities and are therefore discarded.However, when considering rectangular-lattice states, we need to take these effects into account.

D. Noise model: isotropic Gaussian displacement channel
In this work, we consider the isotropic Gaussian displacement channel (GDC) as our noise model, given by where D(g, h) is the displacement operator, Eq. ( 6), whose the displacement amounts (g, h) are randomly drawn from the Gaussian distribution f (g, h).The channel output, N f (ρ), is a weighted average of these displacements applied to the input state ρ.Under this channel, the input state suffers from an unknown but definite displacement.The severity of the noise channel is characterised by the variance σ 2 .The effect of this channel on | 0⟩ is to convolve its ideal Wigner function [Eq.( 25) with j = 0] with the noise distribution, Eq. ( 28), resulting in each δ peak blurring into an isotropic Gaussian with variance σ 2 .An example of an r = 2 state under a GDC of σ = 0.2 is shown in Figure 2(a).In accordance with the literature, we can characterise the noise on each of the spikes relative to the vacuum using the GKP squeezing factor [32] which can be inverted to give Recall that in this work, σ 2 vac = 1/2.For reference, squeezing factors s GKP of 0 dB, 3 dB, 6 dB, and 9 dB correspond to standard deviations σ of 0.707, 0.501, 0.354, and 0.251, respectively.The negative sign in the definition sets the convention that σ decreases for increasing s GKP .
While the Wigner function is no longer singular, the state is still unphysical because it retains its original periodicity over all phase space.One cannot arrive at an approximate physical GKP state from blurring an ideal state, but such states are still a useful model of noisy GKP states in certain applications [9,16,40,49].The noisy Wigner function is normalised such that it integrates to one over a unit cell of the lattice, enclosed by the dashed region in Figure 2.
To analyse the performance of the GKP code under this channel we can abstract away the correction process and only consider f (g, h).As this distribution is separable we are free to study the quadratures independently.Each quadrature has a displacement probability given by and f (g, h) = f (g)f (h).Recalling the error-correction process in Section III C, we note that the outcome of the correction process is to snap the state to the nearest lattice point, located every π/r for the position quadrature in a rectangular code.This results in either a successful correction or X being applied.We bin the distribution, Eq. ( 31), about each lattice point according to the correction outcome.Figure 3(a) shows the binned outcomes for the position quadrature of an r = 2 code with σ = 1/ √ 2. These bins are centered around n π/r, n ∈ Z, which is the support of the ideal codespace.
When implementing GKP error correction, many different outcomes of measuring q or p all result in the same remainder δ q or δ p , respectively.These remainders are the quantities used in position-space GKP error correction [11].Thus, the probability density of any given value of a remainder is actually a sum of all physical outcomes that have that value as their remainder.To obtain this probability density, we must wrap the distribution of the physical outcomes onto itself, with a period T = 2 π/r centered about the origin, and sum the contributions.The resulting distribution is shown in Figure 3(b) for the position quadrature.In this case, the distribution is wrapped from −T /2 to T /2.The wrapping process is equivalent to summing a Gaussian pulse train of period T , shown by dashed lines in Figure 3(b).The wrapped probability distribution is where we now have all the outcome information within the domain [−T /2, T /2).When f is a zero-mean Gaussian distribution of the form of Eq. ( 31), f w becomes [40] where ϑ(z, τ ) is the Jacobi theta function of the third kind given by The wrapped distribution, Eq. ( 33), is shown in black on Figure 3(b) for r = 2, T = √ 2π.This is the outcome probability distribution for the noisy GKP mode.It is normalised such that To obtain the individual quadrature outcome probabilities, we integrate Eq. ( 33) over the bins where the notation q|p indicates two alternatives (in this case, q or p), p Ī q|p is the probability of successful correction, and p Ē q|p is the probability that a logical error Ē has occurred ( X| Z, respectively, for q|p).Since the distribution is symmetric about the origin, we need only integrate over half of each relevant bin and then double the outcome.For rectangular GKP codes, the wrapping periods for each quadrature are given by the stabiliser operators.When biased by r, we have T q = 2 π/r and T p = 2 √ πr.The period changes according to r, which, in turn, impacts the error probability for each quadrature.For r = 2, σ = 1/ √ 2, as shown in Figure 3, the positionerror rate is p X q = 0.37, and the momentum-error rate is p Z p = 0.08, clearly showing a bias towards bit-flip errors.Contrast this with the square-lattice state under the same channel, where the error rate is 0.21 in each quadrature.
To approximate the rate of error suppression in the momentum quadrature when increasing the aspect ratio of the lattice we first note that the Jacobi theta function in Eq. ( 33) can be well approximated by a Gaussian over a single period [−T /2, T /2) as T is increased for a fixed σ.This is due to there being less of a 'tail' in the original Gaussian of Eq. ( 31) to wrap.Increasing the biasing r does exactly this: the momentum wrapping period is scaled with a factor of √ r while the position period gets scaled by 1/ √ r.Approximating f w as a Gaussian in Eq. ( 37) and then taking the upper limit to be ∞ (which over-approximates the error) results in the error probability being given by the complementary error function (erfc) evaluated at T p /4 = √ πr/2.Increasing the biasing r for a fixed σ simply increases the argument of erfc, which decays super-exponentially.
The individual quadrature results from Eqs. ( 36) and (37) are then combined to give GKP qubit-level outcome probabilities.As the quadrature results are independent, the logical outcome rates are simply the intersection of individual quadrature outcomes Under this model, the overall noise and correction process on an encoded GKP qubit can be treated as an independent noise channel Figure 3(c) shows the outcome probabilities with increasing r.As the lattice aspect ratio r is increased, Z and Ȳ errors are suppressed at the expense of increasing the X error rate, resulting in a qubit suffering from biased noise.
FIG. 3. GKP error-correction outcomes for rectangular-lattice states under the Gaussian displacement channel, Eq. ( 27).Subfigures (a) and (b) show the position quadrature of an r = 2 GKP state under the GDC with σ = 1/ √ 2, corresponding to 0 dB of GKP squeezing.The noise distribution in (a) is binned according to the GKP correction outcome, with green (darker) indicating successful correction and red (lighter), the introduction of an X error.The ideal codespace support at every π/2 is represented by the dashed black stems.To obtain the overall outcome probabilities in (a), the contributions from all bins must be summed, which extend into the tails of the distribution.This is achieved by wrapping the distributioni.e., summing all periodically displaced replicas of the original distribution-with a period Tq = √ 2π, as shown in (b).Wrapping the distribution yields Eq. ( 33), shown by the dot-dashed black curve.All the outcome information is now contained within the domain − π/2, π/2 , shown schematically by the darker regions in (b).Integrating Eq. ( 33) over these new bins produces the quadrature outcome probabilities given by Eqs. ( 36) and (37).Subfigure (c) shows how the overall GKP qubitlevel outcomes, given by Eqs. ( 38)-( 41), change with the biasing: increasing r has the effect of suppressing Z and Ȳ errors at the expense of increasing the X error rate, therefore biasing the qubit.Note that without further concatenation, biasing the GKP code reduces its error correction performance, indicated by the decrease in the identity (no-error) outcome probability towards 0.5.
The level of bias can be tuned by choosing an appropriate aspect ratio, which we will find beneficial when concatenating with the repetition code.In the limit of infinite biasing, r → ∞, we see that the Z and Ȳ errors are completely suppressed, while the identity Ī and bitflip X outcomes approach 0.5 from above and below, respectively.The effective channel, Eq. ( 42), therefore approaches that of a bit-flip channel with equal probability.We note that when only considering a single mode, moving to a rectangular-lattice reduces the overall success probability as seen by the solid blue line-it approaches 0.5 from above with increasing r.

E. Formal equivalence to a biased noise channel
with a square-lattice GKP code So far, we have described our system as a rectangularlattice GKP code subject to an unbiased noise channel.An alternative way to bias a GKP qubit is through a biased GDC acting on a square-lattice code.While these are two distinct physical systems, we now show their GKP error correction outcomes are identical.To see this, consider a rectangular code whose wrapping periods are given by T q = 2 π/r and T p = √ πr for the position and momentum quadratures, respectively.The equivalence can be shown by a simple change of variables.As an example, the successful outcome probability in the position quadrature is given by = 2 where we have substituted in the square-lattice period T = 2 √ π in the second line.We now change integration variables to u ′ = u √ r to obtain The integrand is simply f w (u ′ , σ √ r, T ), which is exactly what is obtained when the square-lattice position quadrature is subject to Gaussian displacement noise with variance σ 2 q = σ 2 r.Equivalent results for the X outcome are obtained using the same method.For the momentum quadrature, the noise variance becomes σ 2 p = σ 2 /r.Therefore, in the code-capacity model, subjecting a rectangular-lattice GKP code to unbiased noise has the exact same outcome as a square-lattice code under a biased GDC.
Wigner functions for both cases are shown in Figure 2 for the σ = 0.2, r = 2 case.In (a), the rectangularlattice state undergoes an isotropic GDC.The equivalent interpretation with a biased channel is shown in (b)this state has a square lattice, but the Gaussian peaks themselves are now biased, showing increased position quadrature noise.While these are very different physical systems in terms of the state and noise channel, under GKP error correction, they are functionally equivalent.Furthermore, one can map between the two states by applying the squeezing operator, Eq. ( 10), and its inverse.We can also now see why one cannot obtain physical rectangular lattice GKP states from squeezing a noisy square states (Cf. the end of Sec.III B): The noise distribution would also scale with the squeezing, yielding no change in the GKP correction process outcomes.
This completes the discussion of the rectangular GKP code, which is the inner layer of our concatenated code.We have seen that under the Gaussian displacement channel, we can both discretise and bias the CV level noise by employing an appropriately shaped GKP lattice.Each mode can now be viewed as an effective qubit suffering from biased noise.In the next section, we turn our attention to the qubit repetition code for concatenation to further suppress logical error rates.

IV. CONCATENATED GKP-REPETITION CODE
Now that we have effective qubits from the GKP code, we can attempt to further suppress error rates through concatenation with an appropriate qubit code.Normally, a code that can provide protection against both bit-and phase-flip errors is chosen to suppress the overall error rate (as in Ref. [32]).We have seen, however, that by choosing an appropriate GKP lattice, we can bias the noise such that the mode is much more resilient to one type of error-in our case, phase flips.Just as the Shor code [34] is a concatenation of two classical repetition codes, each protecting against a single type of error, here we concatenate the biased GKP code, which already protects against phase flips through the lattice asymmetry, with a classical repetition code to handle the residual bitflip errors.In this section we review the repetition code and study its performance.
The n-qubit bit-flip repetition code is given by the encoding Eventually we will use GKP states to represent | 0⟩ and | 1⟩, but the calculations here apply to any type of qubit subject to fixed Pauli noise.The stabiliser generators for the code are given by the set of pairwise Z operators acting on adjacent modes, S = ⟨ Z1 Z2 , Z2 Z3 , ..., Zn−1 Zn ⟩.
The decoding process is a simple majority vote, so this code can detect up to ⌈(n − 1)/2⌉ bit-flip errors and correct up to ⌊(n − 1)/2⌋ bit-flip errors.Generally, one prefers odd values of n because then all detected errors can be corrected.(For even n, exactly n/2 flips are detectable as an error but cannot be corrected since either code state is equally likely.)For instance, both an n = 3 and n = 4 code can only correct at most a single bit flip, although the latter can detect (but not correct) two flips.Therefore, we will only consider odd-n codes.The code also does not have built-in protection against any phaseflip errors since they always commute with all elements of S, and this needs to be accounted for.We now proceed to analyse each error independently before combining to give the overall code performance.
Each data qubit may independently suffer a random bit-flip error, with error rate given by p X , with pĪ = 1 − p X (identical rate for all data qubits).Given the error probabilities for a Pauli channel are independent and identically distributed (i.i.d.) Bernoulli trials, the exact number of bit flips, j, on n total qubits, is a random variable following a binomial distribution, j ∼ B(n, p X ).The probability that the number of bit flips, denoted | X|, is exactly j is thus The repetition code can identify and correct for any combination of bit-flip errors on up to k := ⌊(n − 1)/2⌋ qubits.Therefore, the code's bit-flip success probability P (| X| ≤ k) is given by the binomial distribution's cumulative distribution function (CDF) evaluated at k, which is just a partial binomial sum containing all combinations of outcomes where at most ⌊(n − 1)/2⌋ qubits have suffered a bit flip.This CDF, Eq. ( 48), is well known to evaluate to where is the regularised incomplete beta function, with being the incomplete beta function, which becomes the complete beta function for x = 1.Thus, Eq. ( 49) is the success probability for correcting a bit-flip error, where we recall k = ⌊(n − 1)/2⌋.The bit-flip error rate is then just given by 1 − Pr | X| ≤ k .The code admits a threshold at p X = 0.5 for noise models that only consider bit-flip errors.We recall from Section III D that any biased GKP state under the GDC has a bit-flip error rate p X q < 0.5, which lies below the threshold.Therefore, a repetition code will always reduce the logical bit-flip error rate to some degree.However, as p X → 0.5, which happens with stronger biasing, more modes are required to gain an appreciable performance improvement.
While the repetition code has an extremely high bitflip threshold of 50%, it offers zero protection against phase-flips.We have already seen at the GKP level that we cannot completely bias away momentum quadrature displacement errors.There is always a non-zero phaseflip error rate for any finite amount of biasing, potentially resulting in an undetected Z operation.Any even number of phase flips, however, is the product of stabiliser generators and leaves the logical state unchanged, so we only need to be concerned with odd numbers of phaseflips.The number of phase flips | Z| is also binomially distributed, with | Z| ∼ B(n, p Z ).For an n-qubit code with an individual phase-flip error rate p Z , the probability that an even number of Z errors occurs is given by with the phase-flip error rate given by 1 − Pr(| Z| e ).As p Z approaches 0.5 from below (which occurs when σ increases in the GDC) or the number of modes, n, increases, the success probability Pr(| Z| e ) rapidly approaches 0.5, which limits the performance of the overall code.Therefore, it is vital to suppress p Z at the GKP level as much as possible.This results in a trade-off in the amount of biasing we choose to apply for our GKP code.We need to bias enough to stop p Z having a significant effect in Eq. ( 52), but if we bias too much, we approach the bitflip threshold, and more modes are required to observe an improvement in Eq. ( 49).This, in turn, places a stricter requirement on p Z .We shall see that optimising the aspect ratio r is key to observing improved performance with this code.Like the GKP layer, the bit-flip [Eq.( 49)] and phaseflip [Eq.( 52)] outcomes are combined to give the overall logical qubit probabilities for the repetition code (hence, 'rep', below) with i.i.d.Pauli noise: We now have all the machinery in place to analyse both layers of the biased GKP repetition code.In the next section, we construct the overall code and present key performance results.

V. RESULTS & DISCUSSION
We are now able to assess the overall performance of the biased-GKP-repetition code.The inner rectangularlattice GKP code takes the continuous GDC noise acting on a single mode and, through the GKP correction process described in Section III C, returns the state to the GKP codespace, resulting in either a successful correction or one of { X, Ȳ , Z} being applied to the state.This results in an effective qubit with error rates given by Eq. ( 37) for each of the quadratures.By increasing the lattice aspect ratio r, the Z error rate gets suppressed exponentially at the expense of increasing the X error rate, biasing the qubit.
The corrected GKP modes are then used as the data qubits in the repetition code.The GKP qubits are assumed to be identical and independent.The error rates calculated from Eq. ( 37) are used as inputs to the repetition code analysis, with p X q mapping to p X in Eq. ( 49) and p Z p mapping to p Z in Eq. ( 52).The overall code error rate is then given by 1 − P rep [I L ].We denote a concatenated n-qubit GKP-repetition code, with GKP biasing r, under the isotropic GDC of variance σ 2 , by n, r, σ .
Using this model, we first discuss the effects of bias r on the repetition code performance and find that r has to be optimised for each pair (n, σ) if one wishes to maximise code performance.We denote a code n, r, σ with optimised r by n, σ .We then move to discuss threshold behaviour and find that the biased-GKP-repetition code can suppress errors in the GDC for σ < 0.599.Finally, we discuss resource scaling for n and r.

A. Bias Optimisation
Within the model, we allow r to vary with the code size and noise.As an example, the performance of an n = 11, r, σ = 0.5 code under varying bias r is shown in Figure 4.The performance of a single GKP mode-i.e., a n = 1, r, σ = 0.5 code-is also included for comparison.Changing the bias of the underlying GKP mode has a significant effect on the repetition code performance, with an optimum at r opt ≈ 2.55 in this case, and thus n = 11, σ = 0.5 is shorthand for n = 11, r = r opt , σ = 0.5 for these values of n and σ.The repetition code's optimum error rate is also below that of the optimum for the single-mode code n = 1, σ = 0.5 , which is a square GKP state (r = 1), indicating that the biased repetition code can effectively suppress noise.
For r < r opt , phase-flip errors have not sufficiently been suppressed at the GKP layer and are still present in the repetition code.Since the code offers no protection against phase-flip errors, we see these dominate the overall error rate, indicated by the red double-dot-dashed line.As the bias is increased, the phase-flip error rate gets exponentially suppressed at the expense of introduc-FIG.4. Bias optimisation for the GKP repetition code under a GDC with σ = 0.5.The solid and dashed lines show overall code error rates given by 1−Prep[IL], using Eq. ( 53).For a single mode the error rate is minimised at r = 1, a square-lattice GKP code.Increasing n, we find the performance improves when using rectangular-lattice codes.The bias can be tuned to suit σ and number of modes available.If r < ropt, phaseflip errors are present at the GKP level, which impact performance in Eq. ( 52), indicated by the double-dot-dashed red line.For r > ropt, the bit-flip errors at the GKP level bring the repetition code closer to the threshold of 0.5, degrading the performance of Eq. ( 50), which is shown by the increase in the bit-flip error rate for the code in the dot-dashed green line.The performance of the optimised code n = 11, σ = 0.5 is shown by the blue star and used in the threshold calculations shown in Figure 5.For this example, we find the optimum performance is achieved at ropt ≈ 2.55.
ing GKP bit-flip errors.Provided the GKP bit-flip rate is below 50%, which is always the case for GKP states under the GDC, the repetition code will reduce this rate.However, as r increases, the bit-flip rate approaches the threshold, and the degree of improvement is limited.Bit flips come to dominate the overall performance, as shown by the dot-dashed green line closely matching the overall error rate.For any length code, in the limit of infinite bias, phase-flip errors are completely removed, but p X → 0.5 − , and the overall error rate tends to 0.5 from below, shown in Figure 4 by the asymptotic behaviour of both the n = 1 and n = 11 codes, which approach 0.5 far to the right of the values shown.The value of r opt varies with both the number of modes and noise.Therefore, for given n and σ, the bias must be re-optimised.The optimum performance, shown in Figure 4 by the star, is used for threshold estimation detailed in the next section.

B. Threshold Behaviour
A key metric in analysing the performance of a given code family is the threshold, defined as the point beyond which no code in the family can provide a reduction in the error rate compared to an unencoded data qubit.Threshold analysis for the biased repetition code is presented in Figure 5, where we estimate a threshold of σ ≈ 0.599.Numerical simulations are performed for σ ∈ [0.2, 0.62] at 0.02 intervals, ranging from n = 1 to n = 10 7 modes.Around the crossover and threshold points detailed in Figures 5(b) and (c), simulations are fine-grained at intervals of 0.001.For each data point, the optimum bias is selected by scanning over the range r ∈ [1,15], where an example is shown by the star in Figures 4 and 5 The code behaviour in Figure 5(a) can be categorised into three distinct regions.For σ < 0.538, an optimised repetition code of any length performs better than a single GKP mode, with the degree of error suppression increasing monotonically with n.When 0.538 < σ < 0.599, the repetition code initially performs worse for smaller n, shown in (b), where the n = 3 code now has a higher error rate than the single-mode code.When n is sufficiently large, however, the code will still outperform the single GKP mode.In this region, the code performance still improves with increased n.As the threshold is approached, larger codes are required to get beyond the break-even point and show an improvement, as shown in (c), where the crossover point moves to the right with increased n.Beyond the estimated threshold of σ ≈ 0.599, shown in (c), no repetition code does better than the singlemode GKP state.Furthermore, increasing n now makes the performance worse.While the results indicate that the threshold could be slightly higher than our estimate of 0.599, we have conservatively taken it as the point in which none of our simulation results outperform a single mode.
Remarkably, this threshold is higher than the result obtained for the biased-GKP surface code in Ref. [32], which quoted a maximum threshold of σ = 0.580 when decoding the GKP layer without using analogue techniques from Ref. [50] We cannot directly compare with the biased-GKP XZZX threshold of σ ≈ 0.67 in Ref. [33] because the authors only decode using analogue methods.We see no reason why analogue GKP decoding cannot also be employed with the GKP-repetition code to similarly boost the threshold.
The key difference between our result and that in Ref. [32] is how bias is employed within the code.For the surface-code result, rectangular-lattice states of fixed r are employed at the GKP level and then used on a square patch of surface code.The level of biasing remains fixed for all code distances and values of σ.In our biased repetition code, we tailor the level of bias for each optimised code n, σ .We also allow for much higher levels of bias than those used in the surface-code result, where they FIG. 5. Numerical threshold analysis for the biased GKP repetition code with an estimated threshold of σ ≈ 0.599, highlighted by the vertical dashed red (lighter) line towards the right of the main subfigures.Each point (σ, n) selects a code n, σ with optimised bias r.The n = 11, σ = 0.5 code, used in Figure 4, is indicated by the blue star in (a).There are three distinct behaviour regimes.For σ < 0.538, any length repetition code provides a performance increase over a single GKP state, which is shown in (b) with the crossover point highlighted by the vertical green dashed line.For 0.538 < σ < 0.599, shorter-length codes initially perform worse than a single, square-lattice GKP state, but by increasing n, the performance recovers and eventually outperforms the single-state case.This is shown by the crossing point shifting towards higher σ for larger n codes.Subfigure (c) shows an expanded view about the threshold.Beyond this, the code offers no improvement over a single GKP state, and performance degrades with increasing n.The black triangle indicates the crossing point of an n = 31 code, which is located at σ = 0.584.Subfigure (d) shows the code performance for a larger range of σ.Codes of n ≤ 11 data modes can still provide order-of-magnitude reductions in error rates for modest amounts of noise, such as for σ < 0.3.limited themselves to a maximum of r = 4.This suggests a trade-off between the two approaches.If one is able to create GKP states with higher levels of bias, then our method can get similar levels of performance to that of a surface code [32] but, crucially, without the decoder complexity and only needing to employ weight-two stabiliser measurements instead of weight-four.

C. Resource Scaling
The primary aim of this work is to study the biased-GKP-repetition code without considering resource restrictions to see if the code works in principle.Under these conditions, we have found that our code admits a threshold comparable to the biased-GKP surface code in Ref. [32].For the code to be of practical use, how-ever, we need to know how resources scale with the noise level.For the biased repetition code, we have two main resources to consider: the number of modes n and the amount of biasing r available per mode.
Unlike the work completed for the biased-GKP surface code, where r is fixed at regular intervals and limited to a maximum of r = 4, we do not impose any restriction beyond the numerical cutoff at r = 15.The arguments for doing this are twofold.
First, we have found that the optimum value of r varies with both σ and n.Therefore the most advantageous code implementation strategy is to characterise the noise channel, choose the number of data modes available for encoding into the repetition layer, and then generate states at the optimum bias level.
Second, the r = 4 limitation imposed in Ref. [32] is based on a maximum GKP squeezing level of s GKP = 11 dB which was argued as a realistic target for practical implementations.The 11 dB budget is split into ≈ 4.9 dB for a minimal choice of σ = 0.4 in their simulations and 6 dB corresponding to applying the squeezing operator, Eq. (10), with r = 4 to a square-lattice.This interpretation corresponds, however, with the biasing being implemented at the channel level and not through the lattice asymmetry discussed in Section III D. That is, the noise spikes of the Wigner function in Ref. [32] are distributed on a square lattice and have asymmetric variance.
In contrast, we are subjecting an ideal rectangularlattice GKP state to an isotropic GDC, where the noise spikes in both quadratures have an equal variance of σ 2 that is independent of the biasing r.The biasing of the logical GKP qubit comes solely from the spacing of the lattice and not the shape of the noise distribution.Restricting ourselves to the same 11 dB limit corresponds to the minimum noise of σ = 0.2 employed in our analysis.
The question remains open whether physical rectangular GKP states are intrinsically more difficult to generate than their square-lattice counterparts.Modifying existing generation protocols to include rectangular states and assessing their performance is suggested for future work.Assuming biased states are harder to produce, placing an upper limit on the level of bias available restricts the number of modes that can be effectively used in the repetition code, as shown in Figure 6(a).We see that as the code length n increases, a higher optimum bias r opt is required to effectively suppress error rates.If r is restricted and we continue to increase n, we will sit below the optimum shown in Figure 4, where phase-flip errors dominate the overall performance.Counterintuitively, increasing σ slightly reduces the bias requirements, but this doesn't become significant until large numbers of modes are used.Restricting to a maximum of r = 4 for comparison with the surface-code result [32], we see that only codes up to n ≈ 31 can be used at the optimum bias level, shown by the black dashed cutoff.This limit on the code length in turn caps the performance.Figure 6(b) shows logical errors rates with increasing n for a selection of noise levels, corresponding to vertical slices of Figure 5(d).As σ increases, more modes are required to effectively suppress the errors shown by the reduced gradient until the threshold is passed where no value of n yields a performance improvement.The cutoff limits us to the region left of the dashed line, meaning arbitrarily small error rates can no longer be achieved with the repetition code.However, significant reductions in error rates can still be achieved with these codes, as shown by the multiple orders of magnitude of improvements shown for σ ≤ 0.4.
By restricting the maximum level of biasing available, we are effectively capping the code length n available to us.This has two main effects on the overall code performance.First, the break-even point, where the repetition code crosses from performing better to worse compared to a single GKP mode, is reduced.For the n = 31 code the crossing point is located at σ = 0.584, shown by the black triangle in Figure 5(c).This is still higher than the FIG. 6. Resource Scaling for the biased GKP repetition code.(a) shows how the optimum bias ropt varies with n and σ.The required bias increases approximately linearly with an exponential increase in the code length.For smaller codes the noise severity has minimal effect on the optimum bias level, however as the code scales this becomes more significant as seen by the divergence of the plots.For fixed n, the optimum bias is actually reduced for increased σ.Enforcing an upper limit on the biasing r restricts the maximum n code that can be utilised.For example, limiting to r ≤ 4-to compare with [32]-only allows for codes of length up to n ≈ 31 to be used at their optimum bias, indicated here by the black dashed line.(b) shows how logical error rates scale when increasing the code length n.The scaling becomes more demanding with increased σ until the threshold, beyond which the code offers no reduction in the error rate.Limiting n, whether due to finite biasing or size of system places a ceiling on the degree of error suppression the code can offer.However, for a handful of modes (n ≤ 9, indicated by the blue dot-dashed line) error rates can still be significantly suppressed providing initial noise levels are low enough-σ ≤ 0.3 in this case.
surface-code result [32] of σ = 0.580, but the code family now no longer exhibits threshold behaviour, as errors can no longer be arbitrarily suppressed below the break-even point.Lack of a threshold is the second result of limiting the bias.Therefore, we conclude that the effectiveness of the biased repetition code will ultimately depend on the levels of biasing that can be generated in physical GKP states.
The upper limit on r significantly impacts the power of the biased repetition code around the threshold.Significant improvements can still be achieved, however, for moderate levels of biasing and noise.For example, consider noise level of σ = 0.3 / 7.4 dB.With only 9 data modes and a maximum bias of r = 2.4, shown by the blue dashed line in Figure 6, the logical error rate gets suppressed to approximately 10 −4 , a 60-fold improvement over the single GKP mode.The logical mode has an error rate comparable to that of an 8.7 dB square GKP mode.Furthermore, if we allow ourselves r = 4 states then choosing n = 31 improves the noise levels of a 7.4 dB channel to that of a 12.3 dB square-lattice state, which meets fault-tolerance thresholds for existing GKP qubit concatenation schemes [38], opening up the potential for using the biased-GKP repetition code as a low-level encoding scheme.This is all achieved with a fixed linear overhead, weight-two stabiliser operators, and parity checks at the repetition level.

D. Open Challenges
While promising, we reiterate that all results have been obtained studying code-capacity noise where all encoded states, operations, and measurements have been assumed to be ideal.To ensure the code can provide a practical benefit, analysis needs to be extended to account for imperfections throughout the correction process and be extended to more realistic noise models that more closely resemble physical implementations.Furthermore, this work has only studied the performance of the code as a quantum memory.This needs to be extended to performing universal logic on the encoded states.In such a context, bias preservation under gate operations will be a challenge.The below challenges we identify hold for any code that hopes to use biased-GKP states as a bosonic encoding.
The immediate challenge to address is the generation of physical biased GKP states.For ideal states, rectangular GKP | 0⟩ and | +⟩ states can be obtained by acting with the squeezing operator, Eq. ( 10), on a square-lattice state.However, this does not hold in the cases where the state is physical or suffering from GDC noise.In both of these cases, the Wigner peaks have been blurred to Gaussian distributions, so squeezing will both change the lattice spacing-which is desired-and squeeze the individual peaks as an unwanted side effect.Any GKP generation scheme will need to directly produce approximate rectangular states to see any advantage.It is assumed that directly generating rectangular states will be more challenging than generating those with a square lattice.Modifying existing GKP state-generation proposals and assessing their practicality for rectangular states is highlighted for potential future work.
Accounting for physical rectangular GKP states will naturally reduce the code performance under a Gaussian displacement channel, as the Gaussian noise from the physical state and channel are additive.However, if the total error variance of the channel and state is still below threshold, we anticipate that the biased GKP-repetition code will still be able to suppress logical errors.
Here, we provide some intuition as to what we expect under the more physically relevant case of photon loss.The effects of the photon-loss channel are twofold.First, each peak in the GKP state gets blurred just as a displacement channel.Second, the peaks are all pulled in towards the origin, with peaks further from the origin suffering larger shifts [51].Amplifying the state either before or after the loss results effectively in a Gaussian displacement channel [12,43], and more clever ways exist to deal with this noise in certain cases, including simply rescaling measurement outcomes under certain conditions [52].Since loss can be reduced to the GDC (at the expense of extra noise), this further justifies our focus on the latter noise model.We leave a detailed analysis of loss and other physically relevant channels to future work.
Once rectangular-lattice states have been generated, the next challenge to address is implementing logical operations at the GKP level that preserve the noise bias.This will be needed for any physical implementation of the GKP-repetition, biased GKP-Surface [32], and biased GKP-XZZX [33] codes, including quantum memory experiments.Furthermore, to provide a fair comparison to other schemes, such as the cat-repetition code [35,36] which is analysed in the finite energy regime, a full 'circuit-level' analysis of the code, where the whole correction circuit is simulated, is required.This in turn requires a set of bias preserving gates.Here, we give some thoughts about these considerations, while leaving a detailed analysis to future work.
One advantage of the GKP code is that all encoded logical Clifford gates can be realised with Gaussian operations.
This remains true for any lattice choice.
For a square-lattice GKP code, we can implement all single-mode Clifford gates using where Ŝ( √ r −1 ) first converts the rectangular state to the square-lattice encoding, R(π/2) applies the square-lattice Hadamard, and Ŝ( √ r) re-encodes the state back into the rectangular-lattice code.The standard Fourier rotation is recovered for r = 1.On the second line we pulled the squeezing operation through the π/2 rotation, which has the effect of rotating the squeezing axis by π/2 also.This combines with the original squeezer after the rotation, which results in a total squeezer that converts from the rotated rectangular-lattice code (with bias r −1 ) back to the original rectangular-lattice code (with bias r).This is another way to view the action of this gate.
Therefore, to implement a logical Hadamard for a rectangular state with bias r, total squeezing by a factor of r is required.Inline squeezing can be avoided by using a measurement-based model, in which any Gaussian operation can be realised by choosing appropriate homodyne measurements, provided the squeezing of the cluster-state nodes is high enough [39,47,53].Furthermore, to extend to universality at the GKP level, an encoded T gate is required.For the square-and hexagonallattice codes, this can be achieved by distilling magic states through error correcting the vacuum [8].These results are straightforwardly extendable to the rectangularlattice case using the methods described in that reference.
To take advantage of the biased nature of the code one needs to ensure that the GKP logical gate set is itself bias preserving.Without this, noise can be transferred from the position quadrature, which is protected by the repetition code, to the momentum quadrature which is completely unprotected.When the rectangular-lattice logical Hadamard, Eq. ( 59), acts on a noisy GKP state, it does exactly that through its combination of rotation and squeezing.Therefore, the standard Clifford plus T gate-set -generated by { H, S, T } -can no longer be used in the presence of biased noise and an alternative must be found.This has been achieved for physical [54,55] and cat qubits [35,36].Finding a universal bias-preserving gate set for GKP qubits remains an open question.
Finally, once we have rectangular-GKP states and bias-preserving operations, we can consider implementing logic at the repetition-code level.A consequence of the Eastin-Knill theorem [56] is that for a qubit errorcorrecting code, one cannot realise a universal encoded gateset transversally.For an n-qubit bit-flip repetition code, the encoded Pauli operators are given by Z L = Zi for any i ∈ {1, . . ., n}.
Keep in mind that these can also be multiplied by any stabiliser to give another logical operator that does the same thing-e.g., the Z L operation can also be implemented by applying Z on any odd number of qubits.These logical gates are transversal.Furthermore, any phase rotation can be implemented by just acting on a single data qubit, so the S L and T L gates can also be implemented transversally.Therefore, by Eastin-Knill the H L gate will not be transversal.Finding a full, bias-preserving gate set to upgrade the code from a quantum memory is left for future work.

VI. CONCLUSIONS & FUTURE OUTLOOK
In this work, we have introduced the biased-GKPrepetition code and studied its performance under the isotropic Gaussian displacement channel (GDC) in the code-capacity model.The inner layer of the code consists of a rectangular-lattice GKP code that both discritises and biases the continuous noise from the GDC to suppress GKP Z phase-flip errors.Concatenating with a bit-flip repetition code then allows for an overall reduction in the logical error rate.Under this model, we numerically estimate a threshold of σ ≈ 0.599 which outperforms the biased-GKP surface code in Ref. [32] at the expense of increased biasing.A key advantage of this code is that all stabiliser measurements at the qubit level are only weight two, as opposed to weight 4 for any surface code variety.Furthermore the decoding complexity is drastically reduced from that of the surface code by employing a simple repetition code.
We find that the main obstacle to effectively implementing this code as a quantum memory will be the degree of biasing available at the GKP level.The biasing level available limits the largest-length repetition code that can be used effectively.This, in turn, constrains the levels of error suppression available.Even with a moderate amount of biasing and just a handful of modes, however, significant reductions in error rates can still be achieved for channels of σ < 0.3 which corresponds to > 7.4 dB of GKP squeezing, opening up the possibility for using this code as a low-level encoding for future fault-tolerance schemes.
We also identify and outline a number of challenges to implementing the biased-GKP-repetition code that also hold for other proposals of concatenated rectangularlattice GKP codes, such as those in Refs.[32,33].These are mainly the generation of rectangular-lattice states, assessing the impact of using physical approximate GKP states, and implementing bias-preserving logical gates at the GKP level, all of which are suggested for future work.

FIG. 2 .
FIG. 2. (a) Wigner function for an r = 2 rectangular | 0⟩ GKP state after undergoing Guassian displacement noise, Eq. (27), with σ = 0.2, corresponding to GKP squeezing of approximately 11dB.Each of the δ peaks in the ideal Wigner function, Eq. (25), have now been blurred into a narrow Gaussian through convolution with the noise channel.A unit cell of the lattice is enclosed within the dashed rectangle, over which the Wigner function integrates to one.(b) A square-lattice state that has undergone a biased noise channel with σq = σ √ r, σp = σ/ √ r.While these two states are physically distinct, their GKP correction outcomes are identical.