Quantum Error Correction with the Gottesman-Kitaev-Preskill Code

The Gottesman-Kitaev-Preskill (GKP) code was proposed in 2001 by Daniel Gottesman, Alexei Kitaev, and John Preskill as a way to encode a qubit in an oscillator. The GKP codewords are coherent superpositions of periodically displaced squeezed vacuum states. Because of the challenge of merely preparing the codewords, the GKP code was for a long time considered to be impractical. However, the remarkable developments in quantum hardware and control technology in the last two decades has made the GKP code a frontrunner in the race to build practical, fault-tolerant bosonic quantum technology. In this Perspective, we provide an overview of the GKP code with emphasis on its implementation in the circuit-QED architecture and present our outlook on the challenges and opportunities for scaling it up for hardware-efficient, fault-tolerant quantum error correction.


I. INTRODUCTION
In 2001, Gottesman, Kitaev, and Preskill published a proposal to encode discrete quantum information in a continuous variable quantum system, or in other words, "a qubit in an oscillator" [1]. The encoding is designed such that it is possible to correct small shifts in the position and momentum quadratures of the oscillator. This remarkable idea can safely be said to have been ahead of its time: It took almost twenty years before the first experimental realization of their proposal was made by the Home group using an oscillating trapped ion [2]. It was almost immediately followed by the experimental realization in the Devoret group, using a microwave cavity and a circuit quantum electrodynamics (cQED) approach [3]. More broadly, these two experiments are part of a flourishing effort to demonstrate robust encoding of quantum information using bosonic degrees of freedom, with the ultimate long term goal of building a fault-tolerant quantum computer [4][5][6][7][8][9][10].
The idea of encoding information in a continuous variable quantum system is in many ways very natural. Quantum harmonic oscillators abound in nature, and well-defined bosonic modes can be isolated from environmental noise in many quantum technology platforms. Early proposals for bosonic error correcting codes were made already in the late 90s [11,12]. The core idea behind these proposals is to encode k logical qubits into n bosonic modes, and attempt to exploit the large Hilbert space of each bosonic mode to achieve an efficient encoding with good error correcting properties for a small n. Successful bosonic codes are referred to as hardware efficient. Remarkably, interesting bosonic codes, and the Gottesman-Kitaev-Preskill (GKP) code in particular, exist even for k = n = 1.
The primary requirement for implementing bosonic codes, and also why it took two decades of technological developments before the GKP states were realized, is control of a hiqh-quality harmonic oscillator mode with a sufficiently strong and high-quality ancillary non-linearity. This nonlinearity can be a discrete two-level system. In case of trapped-ions, a bosonic state is encoded in the harmonic motion of a single trapped ion by exploiting the strong coupling with the ancillary atomic pseudospin states. In case of cQED, the ancillary levels of a transmon have been used to realize a bosonic encoding in the microwave fields of a superconducting cavity or resonator. Harmonic modes with high quality factors, combined with easy access to strong non-linearities with minimal dissipation, lead to an unprecedented coherent control over the oscillator Hilbert space in these platforms [2-7, 10, 13].
Optical systems are also researched actively in the context of GKP codes [14][15][16][17]. Some proposals are based on using optical nonlinearities or interaction between atoms and light to generate photonic GKP states [18,19]. Several other proposals rely on photon number resolving detectors as the ancillary nonlinear resource [20,21]. However, because of photon loss, weak optical nonlinearities, and the need for complex multiplexing with high efficiency number resolving detectors, generation of the highly non-Gaussian GKP states have not yet been demonstrated in the optical domain.
Given that preparation of GKP encoded states has now been demonstrated in the lab-and it is not a big leap to imagine that gates between two encoded GKP qubits are right around the corner-it is natural to ask whether GKP encodings can become a competitive approach to large-scale, fault-tolerant quantum computing. While the GKP code can correct for small quadrature shifts in the oscillator, realistic noise in an experimental platform is more complex and can introduce uncorrectable errors. Therefore, in practice the suppression in the logical error rate with a single-mode GKP code will be limited. A natural approach to "scale up" is to reduce errors as much as possible in the single-mode encoding and then concatenate a number of encoded GKP qubits to a second error correcting code, for example a surface code, for a total of one logical qubit across n physical modes [22][23][24][25]. If this approach leads to a substantially lower logical error rate than using a comparable number 2 of un-encoded physical qubits, one may achieve a better encoding with a similar hardware cost.
A first milestone towards this goal of resource-efficient fault-tolerance would be to demonstrate basic operations on the encoded GKP states, used to compose errorcorrection circuits, with fidelities that are comparable or better than the best physical qubits to date. These operations include state preparation, entangling gates between two GKP-encoded modes, and measurement. This is a challenging goal considering the high fidelity qubit operations in both trapped ions and superconducting qubits today.
A fundamental obstacle to achieving high-fidelity operations on encoded GKP states is that practical constructions of the required interactions can ruin the protection offered by the bosonic encoding. For example, if a two-level system is used to control the oscillator mode, a single error on the two level system may propagate to a logical error on the mode [2,3,10]. This can prohibit the fidelity of encoded operations on the GKP states from being significantly better those of the unencoded two-level ancilla. How to best achieve fault-tolerance against such ancilla errors in a bosonic code architecture is an important open question, and we will touch on some of the possibilities that have been put forth towards this goal.
In this Perspective, we will discuss the prospect of scalable, fault-tolerant quantum computing with GKP codes with special emphasis on its implementation in a cQED architecture. While there are several excellent review articles on GKP and other bosonic codes [24,[26][27][28], here we provide an application-level perspective highlighting the outstanding practical challenges. We focus on cQED partly because the two authors are working in this field, but also because we believe the flexibility and scalability of superconducting circuits make this a particularly promising platform for the long term goal of constructing a large scale quantum computer based on bosonic encodings.
With this in mind we begin with an overview of the GKP code in Section II, go on to discuss state preparation and error correction in Section III, and address the question of fault-tolerant, scalable quantum computing with GKP codes in Section IV. Throughout this article, we emphasize not only the advances made towards GKP error correction but also the challenges that must be overcome to make practical fault-tolerance with GKP codes possible. These challenges and opportunities for future research are summarized in V.

A. Basic definitions
In general, GKP codes encode a d dimensional logical subspace in n bosonic modes [1]. We will here focus exclusively on the simplest nontrivial case d = 2 and n = 1, i.e., a single logical qubit encoded in a single bosonic mode. To define a GKP code, it is first convenient to introduce the displacement operatorsD(α) = e αâ † −α * â , where [â,â † ] = 1 are the usual ladder operators of a harmonic oscillator and α is a complex number. The displacement operators satisfy the propertŷ In other words, displacements commute "up to a phase." In particular, if the two operators anti-commute, while if αβ * −αβ * = 2iπ they commute.
To define a GKP code, we first choose logical Pauli operatorsX =D(α) andZ =D(β), where α and β are any two complex numbers that satisfy Eq. (2). This ensures thatXZ = −ZX. To ensure thatX,Z, and Y = iXZ =D(α + β) behave like the usual two-by-two Pauli matrices, they should also square to the identity on any state in the code subspace (codespace). We therefore define the GKP logical codespace to be the simultaneous +1 eigenspace of the two operatorŝ It follows from Eq. (1) that these two operators commute with each other, and the logical Paulis. The set {Ŝ k X ,Ŝ l Z } for k, l ∈ Z form the stabilizer group of the GKP code.
We can write the GKP codewords explicitly in terms of sums of quadrature eigenstates. To this end, first define two generalized quadraturesQ = i(β * â − βâ † )/ √ π,P = −i(α * â − αâ † )/ √ π, such that [Q,P ] = i and It is straight forward to check that are ±1 eigenstates ofZ, respectively, and +1 eigenstates ofŜ X andŜ Z . Here we use a notation where |x Ô is an eigenstate ofÔ with eigenvalue x. We have analogous expressions in the dual basis: An alternative expression for the codewords can be found by noting that the state |0 L ∝ ∞ k,l=−∞Ŝ k XZ l |0 , is a simultaneous +1 eigenstate of the two stabilizer gen-eratorsŜ X ,Ŝ Z and logicalZ (in fact, the vacuum state |0 can be replaced by an arbitrary state |ψ with nonzero overlap with |0 L in this expression). With the help 3 of Eq. (1), it follows that the logical states can be written where the kets on the right hand side are coherent states |ζ =D(ζ) |0 . Analogous expressions can be found for the ±1 eigenstates ofX following the same approach.
Since any pair α, β that satisfy Eq. (2) is valid choice, there is an infinity of different GKP codes. The three most common choices are square, rectangular, and hexagonal codes, defined respectively by Note that for the square code, the generalized quadratures introduced above are just the usual position and momentum quadraturesQ =q = (â +â † )/ The square and hexagonal GKP lattices are illustrated in Fig. 1.

B. Approximate GKP codewords
The GKP codespace is a rather abstract construction. The codewords in Eq. (5) are non-normalizable, and in general there is no physical process that can prepare a state lying entirely in the GKP codespace. In practice we have to make do with some type of approximation to Eqs. (5) and (6). Colloquially, we refer to any pair of normalized states |μ L , µ = 0, 1 that satisfyŜ P |μ L → |μ L andZ |μ L → (−1) µ |μ L for P = X, Z, in some meaningful limit, as an approximate GKP code.
One natural way to define such an approximate code is [30] where we ignore normalization constants, for simplicity. The ideal limit corresponds to ∆ → 0. Equation (8) introduces a Gaussian envelope over the infinite sums in Eq. (6), such that each coherent state |ζ is replaced by with logical operators defined analogously,P ∆ = e −∆ 2â †âP e ∆ 2â †â forP =X,Z [31]. Another common approximate form is found by applying weighted displacements to the ideal codewords where [31]. We can use Eq. (5) in Eq. (10) and perform the integral over v to find yet another approximation [1] where N µ = √ π/2 + O e −π/∆ 2 as ∆ → 0. This form 4 has the physical interpretation of a comb of squeezed states with an overall Gaussian envelope. It is convenient to introduce a metric to quantify how close an arbitrary stateρ is to an ideal GKP state. To this end, we introduce a modular "squeezing" parameter for each of the two stabilizersŜ X,Z [32] The squeezing parameters satisfy ∆ X,Z ≥ 0, and are zero if and only if the state is an eigenstate of the corresponding stabilizer. For the approximate GKP codewords introduced above, we have ∆ X,Z = ∆ as ∆ → 0. It is also conventional to measure the modular squeezing in dB For example, the square (hexagonal) approximate codeword shown in Fig. 1 has S X = S Z = 10.1 dB (9.48 dB), corresponding to an average photon number of approximately n = 4.6. We will from now on drop the subscript X, Z and simply write ∆ and S when the two quadratures are approximately equally squeezed and the distinction is unimportant.

C. Error correcting properties
The purpose of encoding a logical qubit in a GKP code is that it provides protection from noise through error correction. To see this, consider first an error model consisting of small displacements applied to the oscillator. For an arbitrary displacementD(ζ) we can write ζ = (uα + vβ)/ √ π, where u, v are real, and consequentlŷ From Eq. (5) it is clear that the quantum error correction criteria [33] are formally satisfied for the ideal GKP code for the set of displacement errorsD(ζ) such that |u|, |v| < √ π/2.
This also gives us some insight into why the approximate GKP codewords introduced in the previous section are "good" approximations. As long as η ∆ (u, v) in Eq. (10) is sufficiently localized around zero, the "error" introduced in the approximate codewords is small, and as long as we ensure that all the logical operations used in our quantum computation do not amplify these errors too badly, i.e., they are "fault-tolerant," then we can expect to perform quantum computation with these approximate GKP codewords with high accuracy (see Section II D 4 for a more precise discussion around what we mean by not "too badly").
For physical GKP codes and realistic error models, we expect that the error correction criteria are at best only approximately satisfied. Realistic error models for oscillators typically include loss, heating, dephasing, unitary errors due to imperfect implementation of control Hamiltonians, etc. Since the displacement operators form an operator basis, any single-mode noise channel can be expanded in terms of displacements Again, as long as f (ζ, ζ ) is sufficiently concentrated around zero, it is in principle possible to remove the noise with high fidelity. Realistic error models, however, typically have some finite support on displacements larger than √ π/2, which means that the error can not be corrected perfectly, even in the limit ∆ → 0. In Fig. 2 we illustrate how the quantum error correction properties of the GKP code manifest for a practically relevant noise channel consisting of simultaneous loss and dephasing. More precisely, the noise model is given by the solution to a Lindblad master equatioṅ with 2ρÂ †Â , integrated up to a fixed time t. The noise strength in this model is thus characterized by two dimensionless numbers, κt and κ φ t, describing pure loss and dephasing, respectively. The noise is then followed by the optimal recovery channel that maximises the average gate fidelity [34] with the identity channel. This optimal error correction map can be found numerically [35], but does not represent a practical error correction procedure-it merely puts an upper bound on the fidelity that can be achieved and illustrates the intrinsic error correction properties of the code.
The results in Fig. 2 shows that the GKP code has an excellent potential to correct loss errors [35], but is rather poor against dephasing (there are other bosonic codes that perform far better against this latter type of noise [29]). The sensitivity to dephasing is not surprising, as a rotation of phase space by a small angle gives a large displacement for large amplitudes. In practice, dephasing might arise not only due to the intrinsic frequency fluctuations of the oscillator used to encode the GKP code (which can be made very small), but also due to off-resonant coupling to ancilliary quantum systems used to control the oscillator [3][4][5]. It is therefore crucial to minimize such residual couplings in practical implementations of GKP codes. A similar issue is likely to arise if there are over-rotations and/or unwanted residual Hamiltonian terms due to miscalibrated unitary gates, and very precise quantum control is therefore important for GKP codes.

D. Logical operations on GKP codes
One of the attractive properties of GKP codes is that, apart from state preparation, all logical Clifford operations can be performed using only Gaussian operations, Average gate fidelity for an approximate square GKP code as a function of photon number n code = ( 0L|n|0L + 1L|n|1L )/2, for simultaneous loss and dephasing quantified by κt and κ φ t, followed by optimal error correction. The GKP code outperforms the "trivial encoding" in Fock states |0 and |1 whenever the fidelity dips below the gray shaded region.
that is, interactions that are at most quadratic in creation and annihilation operators and homodyne measurements on the oscillator. In this section we describe how to perform logical Pauli measurements and unitary Clifford gates, leaving the more difficult topic of state preparation and error correction to Section III.

Pauli quadrature measurements
Destructive logical measurements in any Pauli basis (M X,Y,Z ) can be performed by measuring one of three respective quadratures and rounding the outcome to the nearest multiple of √ π.
If the result is an even multiple, report a +1 outcome, and if the result is an odd multiple, report −1. That this gives a logical Pauli measurement follows from Eq. (4). An attractive feature of this measurement scheme is that it is robust to small displacement errors-precisely the type of errors the GKP code is meant to be robust againstand can in this sense be said to be fault-tolerant. The procedure is illustrated for an M Z measurement on an approximate square GKP code in Fig. 3  measurements on an encoded GKP qubit is, however, not as straight forward. In the context of cQED and other approaches where the GKP state is encoded in a localized high-quality mode, such as the standing modes of a cavity, the ability to rapidly perform quadrature measurements contradicts the requirement of the oscillator mode to be long-lived. It is therefore necessary to either tune the oscillator decay rate κ from a small to a large value prior to measurement, or to map the encoded information from a high-Q to a low-Q mode (with Q ∼ 1/κ the quality factor) [36].
The situation is further complicated by the fact that the measurement efficiency for homodyne detection is limited in practice. The ability to distinguish the codewords deteriorates rapidly with decreasing measurement efficiency, as shown in Fig. 3 (b). A measurement efficiency η below unity means that the GKP state shrinks towards vacuum, and it is important to compensate for this (assuming that η itself is known) by rescaling the measurement bins [white and pink in Fig. 3 (a)] appropriately. More precisely, we now round to the nearest integer multiple of √ ηπ [37]. To produce the numerical results in Fig. 3 (b) we took an approximate |0 L state, apply a pure loss channel with η = e −κt , followed by an ideal measurement of the position quadrature and bin the result.
In the microwave domain, state-of-the-art measurement efficiencies are well below 90%, even with the use of near quantum-limited amplifiers [38,39]. The results in Fig. 3 (b) show that measurement efficiencies will have to be improved for this approach to be promising for distinguishing GKP codewords with high fidelity. For example, at η = 75%-a high but not unreasonable value for a microwave measurement chain-the error probability is about p err 5.6% (4.1%) for ∆ = 0.3 (0.2). For comparison, at η = 90% we find 0.61% (0.15%). Note that rather large measurement efficiencies are required to have a substantial benefit from lowering ∆.
The measurement efficiency may be improved if we can amplify the quadrature information prior to releasing the GKP state to a standard microwave measurement chain [40]. Although most theoretical work on GKP codes assume high efficiency quadrature measurements [22][23][24][25], it is an open question whether the stringent demands required for scalable, fault-tolerant quantum computing can be met with this approach. We return to this question in Section IV where we discuss concatenation with topological codes.

Pauli phase estimation
An alternative, and non-destructive, way to do logical Pauli measurements is by performing phase estimation using an ancillary system. In the simplest case this task can be performed using a discrete two-level system as an ancilla, removing the need to perform direct quadrature measurements on an encoded GKP state.
Since the logical GKP-Paulis are unitary displacement operators,X =D(α),Z =D(β), their eigenvalues are of the form e iθ with θ ∈ [0, 2π). The task of estimating an eigenvalue of a unitary operator, or equivalently the "phase" θ, is generally known as phase estimation. A variety of different phase estimation protocols exist, with tradeoffs in terms of efficiency and complexity [31,41,42]. We here focus on a simple non-adaptive scheme using a single two-level ancilla. Specifically we consider the scheme that was used in the experiments in Refs. [2,3], illustrated in Fig. 4 (a), as well as a modified version that has theoretically been shown to give better performance, shown in Fig. 4 (b) [31,43].
The central component of these schemes is a controlleddisplacement gate CD(ζ) which applies a displacement on the GKP modeD(±ζ/2) conditioned on the state of the two-level ancilla. See Fig. 9 for possible implementations of this gate in cQED. At the end of the circuit, the ancilla is measured in the X-basis. Consider first the simplest scheme in Fig. 4 (a). The probability of getting an X = ± outcome for the ancilla measurement is given by One round of phase estimation. The controlled displacement is defined as CD(ζ) =D(ζ/2) ⊗ |0a 0a| + D(−ζ/2) ⊗ |1a 1a|, with |0a/1a the state of the ancilla. ForX measurement ζ = α and forZ measurement ζ = β.
(b) Improved phase estimation scheme. Here, is a small displacement orthogonal to ζ, i.e., arg = arg ζ + π/2. For X measurement we setD( /2) = e −iλQ and forZ measure-mentD( /2) = e iλP , with λ ∈ R. TheRx gate is defined asRx = e −iπσx/4 . Note that with this definition of the controlled displacement gate, the state is displaced by ζ/2 from the code space after the measurement. This can be corrected for with another displacement if necessary.
To be concrete, let us takeD(ζ) =Z. For an ideal GKP code we have µ L |Z|µ L = ±1 for µ = 0, 1, and thus P (+) = 1, P (−) = 0 for the |0 L state. For an approximate |0 L state, on the other hand, there is a non-zero probability of getting a −1 outcome. Using Eq. (11) one can show that 0 L |Z|0 L e −π∆ 2 /4 for small ∆, such that the measurement error becomes Interestingly, the performance can be improved significantly using the scheme shown in Fig. 4 (b). Here, a small controlled displacement orthogonal to the logical displacement is performed first. In the case of ā Z = e i √ πQ measurement we setD( /2) = e iλP with λ real. The intuition behind the scheme is that this gives a better approximation to a measurement of the approximate logical Pauli operatorZ ∆ introduced in Section II B [31]. In this case, one can show that the measurement error becomes We can treat λ as a free parameter to be optimized. In the small ∆ limit p err is minimized for λ √ π∆ 2 /2 in which case one finds p err 0.4∆ 6 , a significant improvement over Eq. (19) [43]. In Fig. 3 (c) we show p err for a majority vote over n rounds of ideal phase estimation with a noiseless twolevel ancilla for the two respective schemes. For the simple scheme in Fig. 4 (a) and ∆ = 0.3 (0.2) we find p err 3.7%, 1.0% and 0.4% (1.6%, 0.2% and 0.05%) for n = 1, 3, and 5 measurements, respectively. For the improved scheme in Fig. 4 (b) we find p err 2.6 × 10 −4 , 1.6 × 10 −4 and 1.5 × 10 −4 (1.9 × 10 −5 , 6.2 × 10 −6 and 2.5 × 10 −6 ) for the same parameters. These results were produced by numerically computing the probability of a −1 measurement outcome on a |0 L state for the circuits in Fig. 4, and in the case of the scheme in panel (b) optimizing over the parameter λ.
These results show that phase estimation, modified to better distinguish the approximate Pauli operators of a physical GKP code, can lead to very small measurement errors when the ancilla is noiseless. In Section III we will discuss how this approach can form the basis for a state preparation scheme, by measuring stabilizer operators in place of logical Paulis. A fundamental obstacle to this approach, however, is that errors on the ancilla qubit can propagate back to the GKP mode. In particular, a bit-flip of the ancilla qubit during the controlled displacement gate CD(ζ) leads to a large, random displacement of the GKP code. In Section III B we discuss a potential way to make these schemes robust to such ancilla errors.

Clifford gates and Clifford frames
As already mentioned, Clifford gates can be performed using interactions that are at most quadratic in the creation and annihilation operators. Specifically, the Clifford group can be generated, for example, from the Hadamard (H), phase (S) and CNOT (C X ) gates [1] where we use the generalized (code-dependent) quadra-turesQ,P introduced in Section II A. For theC X gate the first mode is the control and the second mode the target. Together with logical basis measurements M Z and preparation of encoded states |0 L and |A L = 1 √ 2 (|0 L + e iπ/4 |1 L ), this forms a universal set. It should be emphasized, however, that the gates in Eq. (21) are in general only approximate logical gates on approximate GKP codes, and, despite being unitary operations, may reduce the quality of the encoded information by making the codewords harder to distinguish [this can be seen from the fact that the gates do not commute with the envelope operator introduced in Eq. (8)] [21,37].
Due to the approximate nature of the logical gates on physical GKP codewords, it is desirable to minimize the number of Clifford gates in a given quantum circuit. An elegant solution to this problem is to make use of a so-called Clifford frame, where single qubit Cliffords are tracked "in software" [44,45]. The idea of the (singlequbit) Clifford frame is as follows: An arbitrary quantum circuit C, written in terms of preparation of |0 L and |A L states, gates from the set {H, S, C X }, and Pauli measurements M Z , can be replaced by an equivalent circuit C , where the state preparation is identical, the measurements are in any Pauli basis, and all the gates are from the set where σ i,j ∈ {X, Y, Z} runs over the usual Pauli operators. Moreover, the number of qubits, two-qubit gates, and measurements in the new circuit C is the same as in C, while all single-qubit gates have been removed.
Constructing C from C is straight forward. One simply commutes the H and S gates through all the C X gates, mapping them to new gates from the set Eq. (22) (and by-product single-qubit Pauli gates) in the process, and finally absorb any single-qubit Cliffords and Paulis into the measurements, mapping M Z to general Pauli measurements [46]. An example is given in Fig. 5. For GKP-encoded qubits, the gate set Eq. (22) is particularly attractive, because switching between gates in this set is essentially a "free" operation in many physical platforms. More precisely, an encoded version of the gateset for GKP codes is realized by [37] whereŝ 1 = −P ,ŝ 2 =Q−P ,ŝ 3 =Q are the three quadratures corresponding to logicalX,Ȳ andZ, respectively. Any gate from the set Eq. (23) can be generated from an interaction of the formĤ θ,φ ∝ e iθâb † + e iφâb + H.c., whereâ andb are annihilation operators for the two respective modes. In turn,Ĥ θ,φ can be realized, for example, from a three-wave mixing interaction with a classical pump with two pump tone frequencies at the sum and difference of the two GKP modes, respectively, and θ and φ set by the two corresponding pump phases, see Fig. 6(a). Alternatively, it can be realized from a four-wave mixing interaction, using four pump tones, as shown in Fig. 6(b). Updating the Clifford frame thus simply amounts to updating the programming of classical pump phases. Albeit  23), may be realized in a cQED architecture. The two GKP resonators, shown in orange and blue, have frequencies ωc,1 and ωc,2, respectively. In (a), a Superconducting Nonlinear Asymmetric Inductive eLement (SNAIL) is used for the coupling [51]. At an appropriate flux-bias, the SNAIL exhibits a strong third order nonlinearity. Two microwave drives are applied at frequencies ω1 and ω2 so that ω1 = |ωc,1 − ωc,2| and ω2 = ωc,1 + ωc,2. Because of the third-order nonlinearity, a single photon at ω1 is consumed to convert a photon at ωc,1 to that at ωc,2. This leads to an interaction of the formâ †b e iθ +H.c., where the strength of the interaction and θ depend on the strength of the microwave drive at ω1 and its phase, respectively. Similarly, a single photon at ω2 is consumed to create two photons, one at ωc,1 and the other at ωc,2. This leads to an interaction of the formâ †b † e iφ +H.c., where, again, the strength of the interaction and φ is set by the drive strength and phase, respectively. Alternatively, it is possible to engineerĤ θ,φ using a transmon as shown in (b). In this case, four pump tones can be used to generate the interaction. Due to the fourth-order nonlinearity of the transmon, a photon each from the pumps at ω3 and ω4 such that ω3 + ω4 = ωc,1 + ωc,2, are consumed to generate two photons at ωc,1 and ωc,2. On the other hand, photons from the pumps at ω1 and ω2 such that |ω1 − ω2| = |ωc,1 − ωc,2|, convert a photon at ωc,1 to ωc,2 via four-wave mixing.
logical gates between two GKP qubits have not yet been demonstrated at the time of writing, the ability to engineer interactions of the formĤ θ,φ have already been used for other applications in cQED [36,[47][48][49][50].

Error spread through gates
An important consequence of the fact that Clifford gates on GKP codes can be generated by quadratic Hamiltonians is that this guarantees that errors are not amplified in a bad way by the gates. Consider, for example, theC X ≡C ZX = e −iQ⊗P gate from the set Eq. (23) (the other gates in the set behave analogously), and assume that a small displacement error e −iuP e ivQ [c.f. Eq. (14)] is present on the first (control) mode prior to performing the gate. The factor e ivQ commutes with theC X gate, but since we see that theC X gate spreads a displacement error e iuP to the second (target) mode. Even though the error has spread, small displacements spread to small displacements, and the error can be corrected by a subsequent round of error correction. This is exactly analogous to a transversalC X = C ⊗n X between two binary code blocks of n qubits, where, say, t X errors on the control block can spread to t X errors on the target block.
In this sense the Clifford gates on GKP codes are faulttolerant. This is, however, only a statement about an ideal implementation of a gate such as Eq. (23). In a realistic implementation, where the quadratic interaction H θ,φ stems from an underlying nonlinearity (c.f. Fig. 6), there will unavoidably be spurious higher order terms present as corrections toĤ θ,φ . Such terms might amplify and spread errors in a bad way, and it is therefore crucial that they are made as small as possible. Again, it is not expected that GKP codes can suppress errors arbitrarily. The goal is to suppress errors to sufficiently low levels that the resource overhead for the next level of protection is reduced, as discussed further in Section IV.

III. STATE PREPARATION AND ERROR CORRECTION
A. State preparation using two-level ancilla One way to prepare a GKP state is to nondestructively measure the stabilizers and a corresponding logical Pauli. For example, a measurement ofŜ X andZ, both with +1 outcomes, would correspond to a preparation of the ideal |0 L state. We discussed how logical Paulis can be measured using phase estimation in Section II D 2. These ideas can be extended to measuring the stabilizersŜ X ,Ŝ Z , and introducing feedback displacements to steer the state towards the code space of an approximate GKP code.
Several protocols have been developed to this end [2,3,10,31,41,42]. To keep the discussion concrete, we here focus on the scheme illustrated in Fig. 7, which is the scheme used in the experimental demonstrations of GKP codewords in Ref. [3]. Let us first consider in more detail the circuit labeled "Sharpen". This is simply a version of the standard phase estimation circuit we introduced in Fig. 4 (a) with a feedback displacement used 7. "Sharpen" and "Trim" protocols used to prepare approximate GKP codestates, the controlled displacement gate is defined as in Fig. 4. The parameter is small with arg = arg ζ + π/2, such thatD( ) is a small displacmeent orthogonal toD(ζ). TheŜ = diag(1, i) gate is the usual phase gate on the ancilla.
to steer the state towards a +1 eigenstate ofD(ζ). The probability of getting ± outcomes here are respectively P π/2 (±) = 1 2 1 ± Im D (ζ) . To prepare a state with a target phase value θ = 0, we introduce a measurement dependent displacement ofD(± /2) along a direction orthogonal toD(ζ), so that for a ± outcome an eigenstate state with eigenvalue e iθ is mapped to one with e i(θ∓ζ ) . This ensures that θ = 0 (mod 2π) is a stable fixed point, while θ = π (mod 2π) is unstable, for sufficiently small . Of course, for a fixed , we can not prepare a phase arbitrarily close to zero using the above procedure, but this is also not desirable. In practice, the scheme will be limited by experimental imperfections, such as unwanted nonlinearities and dephasing, as the photon number of the state increases. It is therefore better to directly target an approximate GKP state as defined in Section II B, where the choice of ∆ should be optimized based on experimental considerations.
It was shown in Ref. [31] that by alternating the phase estimation ofD(ζ) ("Sharpen" in Fig. 7) with phase estimation of a small orthogonal displacementD( ) ("Trim" in Fig. 7) one can prepare an approximate GKP state of the form Eq. (8), with ∆ ∼ √ . The intuition behind the scheme is that the first step "sharpens the peaks" of the target GKP state by bringing it closer to a +1 eigenstate ofD(ζ), while the second step "trims the envelope" of the state by weakly measuring the orthogonal quadrature [31].
To prepare a logical state, say |0 L , one can first alternate many Sharpen-and-Trim cycles of the two stabiliz-ersŜ X ,Ŝ Z to project the state onto the logical subspace. Once in the codespace, a single phase estimation round ofZ =D(β) suffices to project onto one of the two logical Z-basis states. This can be done using, for example, either of the two circuits in Fig. 4. The full protocol is illustrated in Fig. 8. Alternatively, one can repeat the logicalZ measurement a few times and postselect on getting identical outcomes, to increase the preparation fidelity [3,31] (see also Fig. 3). Finally, a Pauli correction FIG. 8. Preparation of a logical state can be done by alternating "Sharpen" ("S") and "Trim" ("T") cycles for the two stabilizersŜX ,ŜZ to project onto the codespace, and finally perform a non-destructiveZ measurement ("M") using, e.g., one of the two circuits in Fig. 4. can be applied if necessary to prepare |0 L .
Various optimizations of the "Sharpen-Trim" scheme are possible, as well as measurement free versions. We refer the reader to Refs. [10,31,52] for further details. We also note that optimal control methods have successfully been used to prepare other bosonic codes [4,5], and that similar techniques may prove useful for GKP state preparation as well.

B. Fault-tolerance in state preparation
An issue with the scheme illustrated in Fig. 7 (as well as the Pauli measurement schemes in Fig. 4) is that ancilla errors can propagate to the GKP code and lead to uncorrectable errors. In particular, an ancilla bit flip at a random time during the controlled displacement of the "Sharpen" step leads to a, potentially large, random displacement error. (A bit-flip during the controlled displacement of the "Trim" step is much less serious as it only leads to a displacement error of magnitude ∼ | |.) These simple circuits are, in other words, not fault-tolerant to the dominant error channels, such as relaxation, on the ancilla qubit.
It is noteworthy, however, that there is a certain amount of built-in robustness in the phase estimation circuits, in that phase flips on the ancilla qubit are relatively benign: Z errors on the ancilla commute with the gates and thus only lead to measurement errors. For the "Sharpen" circuit a measurement error only leads to a small displacement of magnitude | /2| in the wrong direction. This will broaden the GKP peaks, but is not very harmful as long as it does not happen too often. For the "Trim" circuit, a measurement error will lead to a large displacementD(±ζ/2) in the wrong direction, however, these displacements are equivalent up to the stabilizerD(∓ζ), and thus does not lead to a logical error. A measurement error in the final "Measure" step illustrated in Fig. 8 is more serious, as it leads to a logical error. However, as already mentioned, we may repeat this measurement to suppress such measurement errors. In the following we outline a potential approach to increase the robustness of these circuits by exploiting the natural robustness against phase flips of the phase estimation protocols. Kerr-cat realized in a SNAIL (b). The frequencies of the resonator, transmon, and SNAIL are ωc, ωt and ωs respectively. The desired effective interaction for CD gate is ∝ (â † +â)Ẑ, whereẐ is the Pauli operator of the transmon or Kerr-cat qubit. The scheme shown in (a) is from Ref. [3] and uses the cross-Kerr coupling between the transmon and the resonator = χâ †âẐ . The underlying principle of the scheme is as follows. In the presence of the microwave pulse Ec(t), the Hamiltonian of the system (in a frame rotating at ωc) iŝ H = χâ †âẐ + Ec(t)(â † +â). In a displaced frame the effective Hamiltonian becomesD(α)ĤD † (α) = χâ †âẐ + χ(âα * + a † α)Ẑ + χ|α| 2Ẑ , where α = Ec(t)dt. Clearly, we have obtained the important interaction for the CD(ζ) gate given by the second term in this equation. In order to cancel the effect of the other terms, the qubit can be flipped in the middle using the resonant π pulse Et. For more details see Ref. [3]. In (b), a Kerr-cat qubit is realized in the SNAIL flux biased at a point where both third and fourth order nonlinearities are large. To realize the qubit Hamiltonian, a microwave drive Es of frequency 2ωs is applied to the SNAIL. Another microwave drive at frequency |ωc − ωs| is applied to generate Eq. (25). Due to the three-wave mixing, a photon from the latter drive is consumed to convert a photon at the SNAIL to that in the the resonator. This effectively creates the desired coupling ∝ (â † +â)Ẑ between the resonator and the Kerr-cat qubit [53].

Biased noise ancilla
A few different protocols can be applied for more robust phase estimation. For example, the approach considered in [54] is based on using an extra flag qubit to prevent a single ancilla error from introducing a large displacement error in the GKP state. More hardwareefficient robustness against single transmon ancilla error can also be achieved by applying the technique known as χ−matching [55]. In this approach, the transmon's |g and |f levels are used as computational states and the transmon-cavity coupling is engineered so that the GKP resonator is transparent to a single relaxation error from state |f to |e in the transmon. The approach we outline here for robust phase estimation is based on using a biased-noise ancilla qubit [53].
Biased-noise qubits couple asymmetrically with the environment so that one type of error, such as phase-flips or Pauli-Z errors, is more common than others, such as bit-flips or Pauli-X, Y errors. In such qubits it is convenient to define a quantity called the bias, which is the ratio of the dominant error and the sum of all other errors η = p z / (p x + p y ). For pure-Z noise the bias η = ∞, while for isotropic or depolarizing noise η = 0.5. Many examples of such biased-noise qubits exists, including the heavy fluxonium qubit [56], the soft 0-π qubit [57], and the Kerr [49] and dissipative [58] cat qubits. In the trapped ion implementation of GKP codes [2], the ancillary pseudo-spin states used to control the motional mode naturally has such a strong bias.
Thanks to the robustness against phase errors, a possible path towards creating a fault-tolerant state preparation scheme is to use a biased-noise ancilla qubit where bit-flip errors are heavily suppressed [53]. To be able to implement the circuits in Figs. 4 and 7 fault-tolerantly, it is however crucial that we can perform the required controlled-displacement gates while preserving a strong suppression of bit-flip errors. While there are several candidates for strongly biased noise qubits in the superconducting circuit platform [56,57,59], here we focus on the Kerr cat qubit as an illustrative example, as this provides a particularly straight forward, hardware-efficient, realization of the operations required for the phase estimation protocols.
In the Kerr cat qubit the logical states are superpositions of coherent states |± ∝ |α ± |−α (|0/1 |±α ) of the electromagnetic field stored in a nonlinear oscillator. More precisely, these states are eigenstates of a Kerr-nonlinear oscillator in the presence of a twophoton pump:Ĥ cat = −Kâ †2â2 + Kα 2 (â †2 +â 2 ), where we are working in the rotating frame of the oscillator where the two-photon pump is resonant [60]. The cat states are separated from the closest eigenstates by a gap ω gap 4Kα 2 , and we take α to be real for simplicity. Crucially, realistic noise channels for this system, including photon loss, heating and dephasing, are highly unlikely to cause transitions between the |0 and |1 states. More precisely, bit-flips are exponentially suppressed in α 2 compared to phase-flips leading to an exponentially large bias in α 2 [60].
Returning to the circuits in Fig. 7, we first note that preparation and measurement in the X-basis, as well as theŜ,Ŝ † phase gates, are bias-preserving operations, i.e., the effective error channel remains biased towards Z errors when performing these operations. These operations have already been demonstrated experimentally for the Kerr-cat qubit [49]. On the other hand, a controlled displacement can be implemented with a beam splitter in- where the subscript refers to the cat and GKP mode, respectively, and g is an (in general complex) interaction strength. To show that this approximately leads to a conditional displacement, we project the Hamiltonian onto the logical cat subspaceP cat = |α α| + |−α −α|: P catĤCD P cat = iα(gâ † gkp −g * â gkp )Z cat +O * (e −2α 2 ), with Z cat the logical Pauli-Z operator for the cat qubit (we use the O * [f (x)] notation to suppress polynomial factors in x [61]). Evolution under this interaction for a time t thus leads to a controlled-displacement CD(ζ), with ζ = gαt. Interestingly, the controlled displacement gate becomes both faster and more accurate as we increase α, and thus the bias of the ancilla.
We note that to implement the optimized measurement circuit in Fig. 4 (b), as well as the optimized stabilizer protocols in Ref. [31], one also requires a rotation gate of the formR x = exp(−iπσ x /2). This gate is conveniently very simple to implement for a Kerr-cat qubit. One simply turns off the two-photon pump used to stabilize the Kerr-cat logical subspace, and let the cat evolve freely under the Kerr HamiltonianĤ K = −Kâ †2â2 for a time π/2K [49,62]. One might worry that this gate is not bias-preserving: A phase flip prior to, or during, this gate, can be rotated to a bit-flip error. However, the circuit in Fig. 4 (b) is constructed such that the error that propagates back to the GKP mode is precisely the logical operator we are trying to measure. Similarly, for the protocols in Ref. [31] the error is a stabilizer. This is acceptable, and we therefore expect that these improved measurement and stabilizer protocols also benefit from a biased noise qubit.
Physically, the Kerr-cat qubit can be implemented in a tunable nonlinear element such as capacitively shunted SNAIL, or "SNAILmon" [49]. With an external magnetic flux, the SNAIL exhibits both three-wave and four-wave mixing capabilities. Moreover, the controlleddisplacement Eq. (25), which requires a three wave mixing interaction between the cat, GKP and a microwave pump, can also be activated using the same nonlinear element, thus requiring only capacitive coupling between the SNAIL device and the GKP mode [see Fig. 9(b)]. Such an interaction between a Kerr-cat and an unencoded oscillator has been demonstrated [49]. This proof-of-principle demonstration strongly suggests that the Kerr-cat in a SNAILmon can be used for faulttolerant GKP state preparation. Nonetheless, the viability of this approach depends on the effect of magnetic flux, required to bias the SNAIL, on the lifetime of 3D cavities and requires more experimental exploration [63]. Alternatively, an approach based on high-Q oscillators in a 2D architecture must be developed. Finally, we note that this is exactly the same type of interaction required for two-qubit gates between GKP mode, as discussed in Section II D 3 [c.f. Eq. (23)]. It is thus be possible to repurpose the same piece of hardware for both gates and state preparation [see also Fig. 6(a)].

C. Error correction with GKP ancillae
In Section II C we briefly discussed the ability of the GKP code to correct against realistic noise processes in principle by looking at the quantum error correction criteria for displacement errors and performing numerical simulations using an optimal recovery map. Performing error correction in practice requires a fault-tolerant and non-destructive way to measure the stabilizers of the GKP code. One way to do this is to perform phase estimation using a two-state ancilla, as we have already outlined above. However, this approach has the disadvantage that a single bit of information is obtained per ancilla measurement, such that several measurements is required to obtain the continuous variable GKP syndrome information with high accuracy. An alternative approach, which is the approach that has been studied most extensively in the theoretical literature on GKP codes [1,22,23,25], is to use ancillae that are themselves prepared in GKP states. Here, phase estimation can be performed in a single-shot (assuming we can perform high-efficiency homodyne detection), with an accuracy set by the quality of the encoded GKP ancilla states (and the measurement efficiency).
There are two canonical ways to perform "singleshot" GKP error correction using GKP encoded ancillae. These are essentially bosonic versions of Steane [64] and Knill [65] error correction, respectively. The two schemes are illustrated in Fig. 10. As shown in the figure, the propagation of displacement errors through the two circuits are essentially equivalent, but the Knill circuit does not require any active recovery. Here, the measurements, which contain the syndrome information, are simply used to determine whether a logical Pauli operator has been applied to the GKP state in the process of teleporting from the top to the bottom rail of the circuit [29]. It is not necessary to physically apply any Pauli correction, as it can be tracked in a Pauli frame [65]. We also note that a version of the Knill circuit can be performed using beam splitter interactions in place ofC X gates [15], and that it was shown in Refs. [17,25] that this leads to a lower probability of logical error.
Although the "single-shot" GKP error correction schemes are highly efficient in principle, they also have two clear practical drawbacks: They require preparation of two additional GKP states per round of error correction, and they require very high efficiency quadrature measurement to be useful. The former itself requires repeated stabilizer measurements using a two-level ancilla as discussed in Section III A, unless some other method is developed, and as discussed in Section II D, the latter is a highly nontrivial task that has not yet been demonstrated on a GKP state. In the next section we discuss different approaches to quantum error correction with GKP codes in a large scale architecture.

IV. THE BIG PICTURE: SCALABILITY AND FAULT-TOLERANCE
So far, we have seen that either due to finite squeezing, environmental noise, or backaction from the ancilla used in state preparation, the logical error rate in the GKP codespace cannot be decreased arbitrarily. In order to correct for residual errors, the GKP code can be concatenated with another binary quantum error correcting code. A particularly popular approach is concatenation of GKP code to the topological surface code [66]. Faulttolerant error correction with GKP-surface codes are being studied in the context of both gate-based [22][23][24][25] and measurement-based quantum computing [16,30,[67][68][69][70]. Here, we will limit our discussion to the former as it is more commonly used in the context of the superconducting-circuit and trapped ion platforms.
In this approach, each data qubit of the surface code is replaced by a single-mode GKP code. Such concatenation provides two-layers of protection. In the first layer (referred from henceforth as the inner code and denoted C GKP ), the stabilizersŜ X andŜ Z are measured for each GKP mode M times using additional ancillae. These additional ancillae can also be GKP-encoded, as in Section III C, or discrete qubits such as transmons or Kerrcats, as discussed in Sections III and III B. The ancilla measurement record and details of the underlying noise model are used to estimate and correct, as accurately as possible, the noise on each GKP data mode [22,23,25].
Of course, this procedure will not perfectly remove all errors. The remaining errors are instead corrected by interspersing the stabilizer measurements of C GKP with the GKP concatenated to surface code FIG. 11. Building blocks of CGKP C surface with All-GKP surface code and Hybrid-GKP surface code. Of the required operations, only the controlled-displacement gate between a discrete qubit and a GKP-encoded qubit have been demonstrated experimentally [2,3]. Not shown in the figure above are single-qubit gates and measurement of the regular ancilla qubits that may be required. We assume these are readily available.
parity checks of the surface code (referred to henceforth as the outer code, and denoted C surface ). The surface code ancillae used to measure these parity checks can themselves GKP-encoded or discrete qubits.
This approach of concatenating C GKP C surface may seem contrary to the hardware efficiency of GKP codes argued in the Introduction. After all, at the end we are resorting to a binary surface code which incurs a substantial hardware overhead (the surface code has a vanishing code rate). Nevertheless, if it becomes possible to suppress the probability of error during logical operations far below the threshold of C surface , a modest code distance might suffice to reach a target logical error rate required for useful quantum computation [25]. In this case, the resource overhead of quantum hardware and software controls may be significantly lighter than if C surface is directly implemented with conventional qubits such as transmons.
With this overview, we now give more details on two possible constructions of the concatenated C GKP C surface code. In one approach, which is also the most widely studied in the theoretical literature, and is referred to as All-GKP surface code, all the data qubits and ancillae used for error correction are GKP-encoded [22,23,25]. The other approach takes a hybrid route where the ancillae are replaced by discrete qubits (e.g., transmons or Kerr-cats), and will be referred to as Hybrid-GKP surface code (the two schemes were referred to as Only-Surface-Code-GKP-Ancilla and All-Regular-Qubit-Ancilla, respectively, in Ref. [24]). Figure 11 outlines the building blocks of the two schemes.

13
A. All-GKP surface code A possible layout of C GKP C surface with GKP-encoded data and ancilla modes in the cQED architecture is illustrated in Fig. 12(a). Steane or Knill based error correction circuits may be used for C GKP (c.f. Fig. 10), although the former is studied more widely. To be concise, we focus on the square lattice GKP code, where the probability of X errors equals that ofZ errors, concatenated with the CSS surface code with the "rotated" layout of Ref. [71].
The parity check operators for C surface are of two types: allX-type to detectZ errors and allZ-type to detectX errors. In order to minimize amplification of displacement errors, the surface code check operators can be modified as shown in Fig. 12)(b) [23]. EachX-type parity check involves twoX and twoX † , while eachZ-type parity check only involvesZ. (Note in contrast to regular discrete qubits we do not haveX =X † andZ =Z † outside the GKP codespace). The parity checks of C surface are performed simultaneously using the circuit shown in Fig. 12(b). As illustrated, each GKP ancilla (shown in blue in Fig. 12) interacts with four neighboring GKP modes viaC Z = e iQ⊗Q gates for the Z-checks and a mix ofC X = e −iQ⊗P andC † X = e iQ⊗P for the X-checks. As discussed earlier, these gates can be implemented via a nonlinear coupler such as a transmon or SNAIL.
Standard techniques of decoding, for example minimum-weight perfect matching (MWPM), can be used for error-correction in the surface code layer. Moreover, the accuracy of the decoder can be enhanced by using analog information from the continuous variable measurement outcomes [22][23][24][25][67][68][69][70]. For example, one can incorporate the conditional probabilities for Pauli errors given analog measurement outcomes into the edge weights of the MWPM problem, resulting in a dynamic matching graph.
Various independent studies have been performed for estimating the performance of the All-GKP surface code under slightly different assumptions about noise [22][23][24][25]. A common feature of most of these studies is that, in order to simplify numerical analysis, noise in approximate GKP states as well as errors introduced during error-correction operations are modelled as independent Gaussian displacements with standard deviation σ, represented by the channel Compared to a general noise channel as in Eq. (15), this channel is strictly diagonal in the displacement operator basis. An arbitrary noise channel can be brought closer to diagonal form in the displacement basis using displacement twirling (but not necessarily following a Gaussian distribution) [72]. Equation (26) describes, for example, a noise process with equal loss and heating rates, given by a master equationρ = κ D[â]ρ + D[â † ]ρ [23,35]. However, in a realistic system special engineering is required to make these noise process equal. The Gaussian displacement channel does not in general represent physical noise commonly encountered in oscillator systems, such as loss, dephasing or heating at arbitrary rates. The standard deviation σ in Eq. (26) determines the amount of noise in the system. Similarly to how we introduced a squeezing parameter to quantify the quality of approximate GKP states in Section II B, we can introduce a squeezing parameter S = −10 log 10 (2σ 2 ) (with the identification ∆ 2 = 2σ 2 ) to quantify the noise in Eq. (26), with large S meaning low noise. In the numerical studies in Refs. [22,23,25], approximate GKP states with squeezing ∆ were modeled by applying the noise channel Eq. (26) with σ = ∆/ √ 2 to an ideal GKP state. This was done in order to make the numerics tractable, but the noisy GKP states defined in this manner are still unphysical (there is no "envelope" in phase space). In Ref. [24] it was shown that this model with incoherent displacements underestimates the logical error compared to the coherent superposition in Eq. (10) with ∆ 2 = 2σ 2 .
When the Gaussian displacement channels introducing errors in the GKP codewords and every element (i.e., gates and measurements) of the error-correction circuits are assumed to be equally noisy, and Steane-based errorcorrection is used for C gkp , then the threshold standard deviation for displacement errors has been found to be S = 18.6 dB. That is, it becomes possible to realize a logical qubit with arbitrarily small probability of error with C GKP C surface as long as the standard deviation for displacement errors is smaller than ∼ 0.09. On the other hand, if the Gaussian displacement channel is only applied to the data and ancilla GKP codewords, while all other operations are assumed to be noiseless, this threshold is reduced to S = 11.2 dB [23].
Further optimizations are possible, and a recent study showed that the latter threshold with only state preparation noise can be reduced to S = 9.9 dB through better decoding and an optimized error correction protocol [25]. Beyond improving the threshold, it was shown that a decoding strategy that makes better use of the analog syndrome information can have a dramatic effect on the overhead cost to reach a certain logical error rate.
The largest GKP state prepared experimentally so far has a squeezing of ∼ 10 dB and experimental limitations on the performance of two-qubit gates and measurement (c.f. Fig. 3) is largely an open question. Thus, there is opportunity for theoretical and experimental innovations in developing scalable quantum control methods for practical implementation of the GKP-surface code architecture.
One possible path towards easing the threshold requirements is by tailoring the GKP code and the surface code to exploit structure in the noise. In particular, the more recently tailored surface code (TSC) [73,74] and the XZZX surface code [75] exhibit ultra-high thresholds when the noise channel of the underlying elementary qubits is biased. Recall the rectangular-lattice GKP states introduced in section II A and defined in Eq. (7b). Due to the phase-space structure of the rect- angular lattice, the resulting Pauli errors become asymmetric even if the translation errors from the environment are isotropic resulting in a biased noise channel. If λ > 1 in Eq. (7b), then displacements along the momentum quadratureP is more likely to be misidentified than displacement along the position quadratureQ. Consequently, after M rounds of GKP error-correctionX,Ȳerrors will be far less likely thanZ errors. Thus, the error channel after C gkp with a rectangular-GKP state will be biased with the bias increasingly exponentially with λ [76]. Now, the biased noise can be more accurately corrected if C gkp is concatenated to the TSC or the XZZX surface code. A recent work has studied the rectangular-GKP concatenated to the TSC under a simplistic noise model where only the data GKP codewords are subject to a Gaussian displacement channel, while the ancillas and error-correction circuits are perfect [76]. It is known that with such a simplistic noise model, the threshold standard deviation when using the square lattice GKP code is 2.3 dB. If instead a rectangular GKP code is used with r= λ 2 = 3, then as shown in [76], the threshold standard deviation increases and corresponds to a squeezing of ∼1.7 dB. Here, r = 3, corresponds to a single-mode squeezing of 10 log 10 (r) ∼ 4.8 dB. For the regular CSS surface code, another study in contrast found only a marginal improvement in logical error when the ancilla (but not data) qubits are rectangular [25]. However, more theoretical work is required to predict if the rectangular-GKP concatenated to the TSC, XZZX, or another code optimized to exploit noise-bias, provides a practical advantage when realistic circuit-level noise is considered.

B. Hybrid-GKP surface code
The All-GKP surface code scheme may become resource intensive because auxiliary qubits are required to prepare the GKP data and ancilla modes, and additional tunable nonlinear couplers are required to implement two-qubit gates between these GKP modes. Each C GKP and C surface syndrome measurement moreover requires preparation of fresh GKP ancilla states, which is a slow process [3]. Such extra space-time costs can overwhelm savings in overheads that one may have otherwise expected. A more efficient approach may be to replace some or all of the ancillae with discrete qubits such as a transmon or a biased Kerr-cat qubit (see Section III B). As an illustrative example, consider Fig. 12 for counting hardware resources. In this set-up a distance d surface code requires 3d 2 − 1 high-Q resonators, and 5d 2 − 4d nonlinear couplers. Contrast this with d 2 high-Q cavities and 2d 2 − 1 nonlinear couplers that would be required to build a Hybrid-GKP surface code with GKP-encoded data qubits and discrete qubit (Kerr-cat or transmon) ancillae.
Let us now look at the operations required to implement such a Hybrid-GKP surface code. Recall that the controlled-displacement gate CD(ζ) is required to measure the GKP stabilizers. The same gate can also be used to implement the controlled-Pauli gates between the regular qubit ancilla and GKP codewords required for surface code parity measurements.
Consider, for example, theZ-type check operators. It can be measured with a discrete ancilla qubit initialized in the |+ state, followed by CD(ζ) gates between the GKP data modes and the ancilla with ζ = β, and finally an X-basis measurement of the ancilla. This can also be understood as one phase-estimation round of the surface code stabilizer, and in analogy with Eq. (18), the probability to get an X = ±1 outcome is Clearly, for ideal GKP states [Eq. (6)], P (+) = 1, 0 and P (−) = 0, 1 when ZZZZ = ±1 respectively, and hence this procedure can be used forZ-parity checks. In case of approximate GKP states however, a single round of phase estimation cannot perfectly estimate ZZZZ , which leads to measurement errors even when the ancilla is noiseless. For small ∆ (see Section II B) this measurement error is p err ∼ (1 − e −π∆ 2 )/2 π∆ 2 /2 [24]. TheX-type parity checks are measured analogously using the CD(ζ) gate with ζ = α. This measurement error can in principle be reduced using the same approach as discussed in Section II D 2 [see Fig. 4 (b)] to give p err ∼ 0.8∆ 6 (in the small ∆ limit) [31,43].
Compared to the All-GKP scheme, where GKPencoded ancillae are used, the discrete-qubit ancillae may lead to higher fidelity parity checks when a realistic homodyne measurement efficiency is taken into account. To illustrate, consider a GKP state with ∼ 14 dB of squeezing (∆ = 0.2). In section II D 1 we saw that with a measurement efficiency of η = 75% (which is still optimistically high for cQED), the error in the direct homodyne measurement of the ancilla GKP state is ∼ 4%. On the other hand, with a discrete qubit ancilla and modified phase estimation circuit of Ref. [43], we have p err ∼ 0.0025%. Of course, the ancilla readout itself is not perfect, and errors must be added to p err to estimate the total error in the surface code parity check. For an ancilla such as a transmon, readout error probability < 2% is standard, even with η < 75% [39,77,78]. Thus, the total measurement infidelity with the discrete qubit ancilla (∼ 0.0025% + 2% 2%) can still be lower than that with a GKP-encoded ancilla.
The hardware simplicity of the Hybrid-GKP surface code architecture, which requires only CD(ζ) gates and standard qubit operations, makes this approach very attractive. Nonetheless, a challenge with the hybrid-GKP approach is to prevent fatal propagation of errors from the standard qubit ancilla to the encoded GKP states. Indeed, due to this effect, the current performance of the controlled-displacement gate, the building block of the hybrid scheme, is limited by the relaxation time, T 1 of the transmon ancilla [3,62]. This limitation indicates that it will not be possible to increase the lifetime of a GKP codeword much beyond the T 1 of the transmon. Fortunately, it is possible to overcome this challenge by replacing the transmon with a biased-noise ancilla such as a Kerr-cat, as we discussed in Section III B. This promises a hardware-efficient solution to the problem of ancillainduced errors and motivates further study to quantify the performance of the hybrid setup.
Finally, it is not necessary that all the ancillae in the GKP-surface code are of the same kind, that is, all GKPencoded or all discrete qubit ancillae. Another possibility is that both the data and syndrome qubits of C surface are GKP-encoded, while discrete qubit ancillae are used to perform the C GKP stabilizer measurements and phase estimation on the GKP-encoded syndrome qubits. Depending on the properties and performance of operations, we may have an optimized code where some ancillae are discrete qubits while the others are GKP-encoded.

C. Universality
So far, we have restricted the discussion to error correction in the C GKP C surface code, but have not discussed how universal computation may be performed in this concatenated architecture. An attractive feature of the surface code is that all logical Clifford operations can be implemented via lattice surgery requiring only (single or two-qubit) logical Pauli measurements [16,79,80]. In surface codes with regular qubits, these measurements require nearest-neighbour, physical controlled-Pauli gates between ancilla and data qubits [80]. We have seen how to implement controlled-Pauli gates between two GKP 13. One-bit teleportation circuit to teleport an arbitrary state from a two-level ancilla (bottom) to an encoded GKP state (top). TheĈX gate is implemented by a controlled displacement CD(α). This can be used for preparation of arbitrary states, including magic states, assuming we have universal control over the ancilla.
codewords or between a GKP codeword and a discrete qubit [see Eq. (23), Fig. 6, and Fig.9]. Hence, we can also employ lattice surgery for implementing logical Clifford gates in the C GKP C surface code. Combined with state preparation of GKP magic states |A L =T |+ L , logical injection and distillation [81,82] (both of which only require error correction and Clifford gates) provides the ability to perform universal quantum computation in the GKP-concatenated surface code. There are several ways to prepare GKP magic states, including using only GKP Pauli states and vacuum as a resource by exploiting the continuous variable nature of the state space [83], but the simplest approach is to use a one-bit teleportation circuit as shown in Fig. 13, which allows us to teleport an arbitrary state from a two-level ancilla to the GKP code.

V. SUMMARY AND OUTLOOK
Implementation of the GKP code was once considered, by many, to be beyond impossible. As pointed out by Daniel Gottesman at the Byron Bay Quantum Workshop in 2020-a workshop dedicated to the 20th anniversary of the GKP code-the authors were aware that the main challenge was going to be the first step of realizing the codewords themselves and the subsequent steps of realizing gates, measurements, etc. would be comparatively simpler. Technological developments since 2001 have made error correction with the GKP code a reality, and this success has inspired more exotic strategies for error correction [84,85]. Keeping current and near-future technology in mind, in this perspective article we have explored the prospect of scalable, fault-tolerant quantum error correction with GKP states in a cQED architecture. The most intriguing open question in this direction is whether error correction with GKP states can be made more resource efficient in practice compared to schemes based on conventional qubits. Below we summarize some open theoretical and experimental challenges that must be addressed to answer this question.
One must develop high-fidelity operations, including state-preparation, multi-qubit gates, and measurement for GKP states. The fidelity must be better than those of conventional un-encoded qubits in the same platform. At the very least, the fidelity should not be limited by decoherence in the auxiliary discrete qubits used for initialization or couplers used for gates. We identify three central challenges in this respect, that can serve as milestones on the path towards a scalable and hardware efficient quantum computer with GKP-encoded qubits: 1. State preparation: One must be able to prepare approximate GKP codewords with a sufficiently small ∆, and ensure that the probability of logical errors on the GKP code, e.g. propagating from the ancilla qubit used in the state preparation, is exceedingly low. Since the goal is to outperform the best physical qubit alternatives, specifically transmons and trapped ions, the probability of a logical error in state preparation must be low compared to error rates in these systems. In our view, a biased noise ancilla, such as a Kerr-cat qubit, is promising in this respect, but further analysis is needed to quantify the quality of the GKP states that can be prepared with this approach.
2. Gates: To be able to implement high fidelity gates as discussed in Section II D 3 in practice, there are several targets that must be met simultaneously. One must be able to implement pristine two-mode Hamiltonians of the formĤ θ,φ ∝ e iθâb † + e iφâb + H.c., while keeping any spurious non-linear terms minimal, and moreover, the twomode interaction must be switched from near zero to a sufficiently large value such that the gates are fast compared to all decoherence rates. It is crucial that performing these gates does not introduce errors that the GKP code is poor against. In particular, while the GKP is expected to be excellent against loss (and heating), this is not necessarily true for other natural types of noise, such as dephasing (c.f. Fig. 2) and spurious nonlinearities.
3: Measurements: As we have shown in Section II D 1, a standard homodyne measurement is unlikely to be sufficiently high-fidelity to give GKP codes an advantage. Here, new ideas are needed. Either the effective homodyne measurement efficiency has to be increased (probably past 90%) using an amplification step prior to release to a standard microwave measurement chain, or one can follow the route of performing phase estimation with a discrete qubit ancilla. It remains to be seen how low the GKP measurement error can be made in practice.
Along with measurement and control, efforts must be devoted to developing technology for scaling up either a 3D cQED architecture, or an architecture based on high-Q resonators on chip. There are also open theoretical questions about how to design such a large-scale architecture. We have discussed two different approaches at a high-level, the All-GKP surface code and the Hybird-GKP surface code. Several numerical studies have been performed on the All-GKP surface code, showing promising thresholds and sub-threshold behavior [22][23][24][25]. However, the noise models used in these studies are rather unrealistic, and more work is needed to model realistic noise accurately. For the Hybrid-GKP surface code, although we think it is quite promising in terms of hardware efficiency, very little quantitative analysis has been done, and its potential is largely unexplored at this stage.
Arguably, the most pertinent question here is whether one will ultimately be limited by the discrete qubit ancillae used to stabilize the GKP-encoded qubits and perform syndrome extraction, and consequently whether the Hybrid-GKP approach can have a significant advantage over a more conventional scheme using only discrete qubits everywhere. For example, if biased noise qubits are used as ancillae, one should note that an approach based on using such qubits as both ancillae and data qubits also appears very promising [86][87][88].
There are further avenues of research we have not touched on in this Perspective, but that nonetheless seem very promising. Alternatively to active GKP errorcorrection, it may be advantageous to explore passive error-correction techniques where the GKP states are stabilized via Hamiltonian engineering [72,89,90]. One can also consider alternative concatenation schemes. For example, surface code variants tailored to the specific noise structure of the GKP codewords may be used. In particular, biased-noise tailored surface code such as the XZZX surface code [75] or tailored surface code [73,74,76], are promising candidates for a rectangular-lattice or squeezed GKP code. More work is required to estimate the performance of such an architecture when realistic circuit level noise is considered. Other topological codes might offer some advantages over the surface code when it comes to logical gates. For example, the 2D color code has a transversal set of single-qubit Clifford gates. As we have shown that single-qubit Clifford gates on GKP codes can be done in software, this implies that logical single-qubit Clifford gates on the color code level can be done in software as well. This may lead to some overhead savings for lattice surgery [80,91]. In general, one should follow the design principle of tailoring the overall faulttolerant scheme to exploit the strengths of the underlying elementary qubits, and further research in this direction is warranted. Finally, concatenation with conventional quantum error correcting codes is not the only path towards scalability. It is possible that there is a better scheme where k logical qubits are encoded in n physical modes more directly, i.e., without concatenation with a binary code. Only a small number of works have explored this avenue so far [1,92,93].
With challenges, come opportunities and with the accelerating pace of technological and theoretical developments the future looks bright for practical quantum computation with GKP codes.