GKP Codes and Bosonic Error Correction

Every qubit code in the standard playbook fights errors by repetition: spread one bit of quantum information across many physical two-level systems and let redundancy do the work. Bosonic error correction takes the opposite bet. A single quantized harmonic oscillator — a microwave cavity, an optical mode, the motion of a trapped ion — already carries an infinite-dimensional Hilbert space, so the redundancy needed to hide a qubit is available for free inside one physical system. The question becomes not "how many qubits?" but "how do I carve a robust two-level codespace out of the continuum of phase space, and against which errors?" The Gottesman–Kitaev–Preskill (GKP) code answers with startling directness. It defends against the most natural noise an oscillator suffers — small random displacements in position and momentum — by making the codespace a lattice in phase space. Two commuting displacement operators, each translating the oscillator by a full lattice period, are declared stabilizers; their simultaneous $+1$ eigenstates form a two-dimensional codespace whose wavefunctions are periodic Dirac combs. Because any error expands in the displacement basis, and a small displacement merely slides the comb by a measurable fraction of a cell, GKP turns the analog problem of correcting continuous shifts into a digital one: measure the shift modulo the lattice, round to the nearest point. That single idea makes GKP the connective tissue of continuous-variable fault tolerance — cheap Gaussian Clifford gates, non-Gaussian magic, and a soft-information handshake with the surface code — and this article rebuilds the structure from the Weyl algebra up.

Key takeaways

Bosonic codes hide a logical qubit in the infinite-dimensional Hilbert space of one oscillator, drawing redundancy from continuous-variable phase space instead of many physical qubits.
The GKP code stabilizes a qubit with two commuting displacement operators of magnitude $2\sqrt{\pi}$ that impose a periodic grid in the quadrature plane, protecting against small shifts in $\hat q$ and $\hat p$ .
Correction is geometric: measure each quadrature modulo $\sqrt{\pi}$ , then displace to the nearest lattice point; any shift with $|\xi|<\sqrt{\pi}/2\approx0.886$ per quadrature is corrected exactly.
Ideal GKP codewords are Dirac combs with infinite energy; real devices use finite-energy, Gaussian-broadened states whose logical error rate is set by the squeezing $\Delta$ (in dB).
The intrinsic logical error floor falls exponentially, $P_L\sim e^{-\pi/(8\Delta^2)}$ : roughly $1\%$ at $10\ \mathrm{dB}$ and $\sim10^{-4}$ at $13\ \mathrm{dB}$ .
GKP Clifford gates are Gaussian (symplectic) operations; the non-Clifford $T$ gate needs non-Gaussian magic, and GKP concatenated with the surface code is a leading route to fault tolerance.
Key idea: encode a qubit as the joint eigenstate of two commuting displacement operators that tile phase space with a lattice, so any small error shifts the state by a measurable fraction of a cell and correction is just rounding to the nearest lattice point.

The core insight

Encode a qubit as the simultaneous eigenstate of two commuting displacement operators that tile phase space with a lattice; then any small error displaces the state by a measurable fraction of a cell, and correction is just rounding to the nearest lattice point.

Where this lives today

GKP has crossed from theory into the front rank of experimental quantum error correction. In superconducting hardware a high-Q microwave cavity holds the mode and a coupled transmon is the ancilla; with sharpened phase-estimation and reservoir engineering, cavity GKP qubits are stabilized in real time, and in 2020 a cavity experiment pushed the encoded lifetime past the best uncorrected component — the first active bosonic QEC to beat break-even against displacement noise. In trapped ions the motional mode is the oscillator, where grid states have been stabilized with full single-qubit Clifford control; in photonics, GKP modes are the nodes of continuous-variable cluster states, teleporting Clifford gates by homodyne measurement with injected magic states supplying non-Gaussianity. The deepest lever is concatenation: encode each physical qubit of a surface code as a GKP mode and feed the analog syndrome — the distance to the nearest lattice point — into the topological decoder. Treating near-threshold shifts as soft information rather than hard bits lifts the combined threshold against Gaussian noise dramatically, and this GKP-plus-surface-code stack, with GKP magic-state distillation for universality, is a leading route to fault tolerance.

The physical picture

Picture the oscillator's phase space as an infinite sheet of graph paper with axes $\hat q$ and $\hat p$ ; the GKP code lives on a square lattice of that paper. The two logical states are supported on interleaved sublattices whose points are spaced by the full stabilizer period $2\sqrt{\pi}$ , offset by one half-period $\sqrt{\pi}$ . A physical error is a rigid slide of the whole pattern by a vector $\xi=(\xi_q,\xi_p)$ . As long as the slide is shorter than half a grid step, you can read how far from the nearest grid line you are, modulo the spacing, and undo it — without ever learning which sublattice you started on. Syndrome and logical bit live in complementary parts of the same continuous coordinate.

Figure

Phase-space lattice of a square GKP qubit: same-logical points sit on a grid of spacing 2√π ≈ 3.545, the two logical sublattices are offset by √π ≈ 1.772, and the green correctable cell is the square of side √π — any shift ξ smaller than √π/2 ≈ 0.886 in each quadrature snaps back

The magic is that a continuous error is undone by a discrete operation: the code supplies its own metric — Euclidean distance in phase space — so the decoder is literally "snap to grid." Because every channel (loss, dephasing, thermal noise) can be written in the displacement basis, GKP protects against a universal random-displacement model to leading order — photon loss, after a recovery map, looks like a Gaussian random shift that GKP handles. Finite squeezing is the price of admission. Real codewords replace each Dirac peak with a Gaussian of width $\Delta$ under a Gaussian envelope, leaving residual tail overlap between neighbouring teeth — the intrinsic error floor, which shrinks exponentially with squeezing. The second figure is what a hardware designer reads off: logical error rate versus squeezing in decibels.

Figure

Intrinsic GKP logical error rate versus squeezing, P_L ≈ 2 erfc((√π/2)/(√2 Δ)) with Δ² = 10^(−dB/10): the floor falls from ≈ 9.5% at 7 dB through ≈ 1.0% at 10 dB to ≈ 1.5×10⁻⁴ at 13 dB — exponential suppression

The core equations

The whole code is fixed by choosing two displacement operators as stabilizers. On the square lattice they translate the oscillator by a full period $2\sqrt{\pi}$ in each quadrature, and — crucially — they commute, so they can be simultaneously diagonalized.

S_q = e^{\,i\,2\sqrt{\pi}\,\hat p},\qquad S_p = e^{-\,i\,2\sqrt{\pi}\,\hat q} \qquad (1)

where: $\hat q,\hat p$ — position and momentum quadratures with $[\hat q,\hat p]=i$ ; $S_q,S_p$ — translations of $\hat q$ and $\hat p$ by $2\sqrt{\pi}$ . Reading: the codespace is the joint $+1$ eigenspace of these two, a two-dimensional subspace holding one logical qubit. The logical Paulis are the smallest displacements that commute with both stabilizers without being stabilizers — half-period shifts, half of $S_q$ and $S_p$ .

\bar X = e^{\,i\,\sqrt{\pi}\,\hat p},\qquad \bar Z = e^{-\,i\,\sqrt{\pi}\,\hat q},\qquad \bar X^2 = S_q,\ \ \bar Z^2 = S_p \qquad (2)

where: $\bar Z,\bar X$ — logical Paulis, each a displacement of magnitude $\sqrt{\pi}$ . Reading: squaring a logical returns a stabilizer, so the logicals act faithfully on a two-dimensional quotient while anticommuting, $\bar X\bar Z=-\bar Z\bar X$ . In the position representation the ideal codewords are Dirac combs: $|\bar 0\rangle$ sits on even multiples of $\sqrt{\pi}$ , and $|\bar 1\rangle$ is the same comb shifted onto the odd multiples.

|\bar 0\rangle=\sum_{n\in\mathbb Z}|\hat q=2n\sqrt{\pi}\rangle,\qquad |\bar 1\rangle=\sum_{n\in\mathbb Z}|\hat q=(2n+1)\sqrt{\pi}\rangle \qquad (3)

where: $|\hat q=x\rangle$ — position eigenstate at $x$ ; $n$ — integer indexing the teeth. Reading: the tooth spacing $2\sqrt{\pi}$ is the stabilizer period; the $\sqrt{\pi}$ offset between combs is the logical $\bar X$ displacement mapping $|\bar 0\rangle\leftrightarrow|\bar 1\rangle$ . A physical error is a Weyl displacement by a real vector $\xi$ . Every completely-positive map on the mode expands in these displacements, which is why controlling displacement errors controls everything to leading order.

D(\xi)=e^{\,i(\xi_p\,\hat q-\xi_q\,\hat p)},\qquad |\psi\rangle\ \longrightarrow\ D(\xi)\,|\psi\rangle \qquad (4)

where: $\xi=(\xi_q,\xi_p)$ — displacement in position and momentum; $D(\xi)$ — Weyl displacement operator. Reading: $\xi_q$ threatens a $\bar X$ error, $\xi_p$ a $\bar Z$ error. The syndrome diagnoses $\xi$ without collapsing the logical state: each quadrature modulo the half-lattice spacing $\sqrt{\pi}$ , equivalently the phases of the two stabilizers.

s_q=\hat q \bmod \sqrt{\pi},\qquad s_p=\hat p \bmod \sqrt{\pi} \qquad (5)

where: $s_q,s_p$ — the fractional part of each quadrature relative to the grid. Reading: the moduli reveal the shift only up to a full lattice step, so the decoder assumes the smallest shift consistent with the syndrome. Ideal combs are non-normalizable, so real states replace each delta by a Gaussian of width $\Delta$ under an envelope of width $\sim1/\Delta$ ; the single squeezing parameter $\Delta$ controls both peak sharpness and energy.

|\widetilde{\bar\jmath}\,\rangle \ \propto\ \sum_{n} e^{-\pi\Delta^2 n^2}\; e^{-\frac{\left(q-(2n+j)\sqrt{\pi}\right)^2}{4\Delta^2}},\qquad \bar n \approx \frac{1}{2\Delta^2} \qquad (6)

where: $\Delta$ — squeezing parameter, defined throughout as the standard deviation of each peak's probability distribution in units of the vacuum quadrature width, so the amplitude carries $4\Delta^2$ (small $\Delta$ is high squeezing); $j\in\{0,1\}$ — logical value; $\bar n$ — mean photon number. Reading: smaller $\Delta$ sharpens the peaks and lowers the error, but raises the photon number you must engineer. Finally the logical error rate: a flip happens when the combined intrinsic ( $\Delta$ ) plus channel ( $\sigma$ ) displacement pushes a quadrature past the boundary $\sqrt{\pi}/2$ , a Gaussian tail over the two quadratures.

P_{L}\;\approx\; 2\,\mathrm{erfc}\!\left(\frac{\sqrt{\pi}/2}{\sqrt{2}\,\sqrt{\sigma^2+\Delta^2}}\right)\ \xrightarrow[\ \sigma\to0\ ]{}\ 2\,\mathrm{erfc}\!\left(\frac{\sqrt{\pi}/2}{\sqrt{2}\,\Delta}\right) \qquad (7)

where: $\sigma$ — channel displacement noise per quadrature (std); $\Delta$ — intrinsic peak width; $\mathrm{erfc}$ — complementary error function. Reading: the two variances add in convolution, and the factor $2$ counts the two ways ( $\bar X$ or $\bar Z$ ) to fail.

Derivation ACommuting stabilizers and the dimension of the codespace

The goal is to prove from the Weyl–Heisenberg algebra that the two GKP stabilizers commute, that the half-period logicals commute with both stabilizers while anticommuting with each other, and that squaring a logical returns a stabilizer — so the joint $+1$ eigenspace is a faithful two-dimensional representation of the Pauli algebra, exactly one logical qubit and not a qudit. Every claim reduces to a single Weyl phase, so we fix conventions once and let the arithmetic decide.

Step 1. Establish the fact every displacement identity rides on. With $[\hat q,\hat p]=i$ the commutator is central, so Baker–Campbell–Hausdorff terminates after one term and gives the Weyl braiding relation $e^{i a\hat p}\,e^{i b\hat q}=e^{i a b}\,e^{i b\hat q}\,e^{i a\hat p}$ . Why: reordering two displacements costs only a scalar phase $e^{iab}$ set by the product of shift magnitudes, so commutation reduces to arithmetic.

Step 2. Feed the stabilizers into it. For $S_q=e^{i2\sqrt{\pi}\hat p}$ and $S_p=e^{-i2\sqrt{\pi}\hat q}$ the product is $a\,b=(2\sqrt{\pi})(-2\sqrt{\pi})=-4\pi$ , so $S_qS_p=e^{-i4\pi}S_pS_q=S_pS_q$ . Why: the period was chosen so the self-phase is a multiple of $2\pi$ , and commuting operators share the joint $+1$ eigenspace.

Step 3. Test the logicals against the stabilizers. Pairing $\bar X=e^{i\sqrt{\pi}\hat p}$ with $S_p$ gives $a\,b=-2\pi$ , a phase $e^{-i2\pi}=1$ , and likewise $\bar Z$ against $S_q$ ; both logicals commute with both stabilizers. Why: commuting with every stabilizer means $\bar X,\bar Z$ act inside the code, not kicking states out of it.

Step 4. Test the logicals against each other and close the algebra. For $\bar X$ and $\bar Z$ , $a\,b=-\pi$ , giving $\bar X\bar Z=e^{-i\pi}\bar Z\bar X=-\bar Z\bar X$ , while $\bar X^2=e^{i2\sqrt{\pi}\hat p}=S_q$ and $\bar Z^2=e^{-i2\sqrt{\pi}\hat q}=S_p$ . Why: anticommuting square-roots of a stabilizer are exactly a qubit's $\bar X,\bar Z$ ; squaring to stabilizers (not new operators) pins the dimension at two. *The key check: the stabilizer product gives $ab=-4\pi$ , a trivial Weyl phase, while the logical product gives $ab=-\pi$ , the sign flip that makes $\bar X$ and $\bar Z$ anticommute.*

Go deeper · Derivation B · 1 minThe correctable displacement window

Derivation BThe correctable displacement window

The goal is to derive the sharp boundary $|\xi_q|,|\xi_p|<\sqrt{\pi}/2$ inside which the square GKP code corrects a displacement perfectly, and to show how correction fails the instant a shift crosses it, turning into a logical Pauli. The argument is geometric — nearest-lattice-point decoding for a lattice whose minimum distance is the logical spacing.

Step 1. Fix the length scale that governs failure. Neighbouring teeth of $|\bar 0\rangle$ and $|\bar 1\rangle$ are separated in $\hat q$ by the logical displacement $\sqrt{\pi}$ , so the code's minimum distance is $\sqrt{\pi}$ . Why: a shift of half that, $\sqrt{\pi}/2$ , sits equidistant between two codewords — the ambiguity point of any nearest-point decoder.

Step 2. Read what the syndrome tells you. Measuring $\hat q\bmod\sqrt{\pi}$ returns the shift only up to an unknown integer number of half-periods, $s_q=\xi_q\bmod\sqrt{\pi}$ , so the decoder must guess the integer. Why: the modular measurement reveals the error while hiding the logical bit, but large and small shifts with the same remainder are indistinguishable.

Step 3. Apply the maximum-likelihood guess and see where it breaks. The decoder assumes the smallest shift consistent with $s_q$ ; if $|\xi_q|<\sqrt{\pi}/2$ that is the true shift and correction is exact, but if $|\xi_q|>\sqrt{\pi}/2$ the true shift was the larger option and the decoder rounds the wrong way, applying one logical period — a $\bar X$ error. Why: this is why GKP failures are logical Paulis, not leakage — the code always returns a codeword, occasionally the wrong one.

Step 4. Repeat in the conjugate quadrature. The identical argument in $\hat p$ governs $\bar Z$ errors, so the correctable set is the open square of side $\sqrt{\pi}$ centred on a lattice point, $|\xi_q|,|\xi_p|<\sqrt{\pi}/2\approx0.886$ . Why: the square is the Voronoi cell of the code lattice, and correctability is exactly membership in that cell — the geometric heart of GKP.

Go deeper · Derivation C · 1 minThe finite-energy logical error floor

Derivation CThe finite-energy logical error floor

The goal is to estimate the residual logical error of a finite-energy GKP state from the overlap of neighbouring comb teeth, and to show it is exponentially small in the inverse squeezing — the quantitative content of "more squeezing buys more protection." We model each peak as a Gaussian of width $\Delta$ and compute the probability it is misread across the boundary at $\sqrt{\pi}/2$ ; this floor survives even a noiseless channel.

Step 1. Write the misidentification probability as a Gaussian tail. A peak of width $\Delta$ centred on a lattice point is misassigned when it lands beyond the boundary, $P_1=2\!\int_{\sqrt{\pi}/2}^{\infty}\frac{1}{\sqrt{2\pi}\,\Delta}\,e^{-x^2/2\Delta^2}\,dx$ . Why: the boundary lies at $\sqrt{\pi}/2$ on both sides of the peak, and either excursion flips the logical, hence the factor of two.

Step 2. Convert to a complementary error function. The substitution $u=x/(\sqrt{2}\,\Delta)$ gives $P_1=\mathrm{erfc}\!\left(\frac{\sqrt{\pi}/2}{\sqrt{2}\,\Delta}\right)$ , the exact per-quadrature floor. Why: $\mathrm{erfc}$ is the standard closed form for a Gaussian tail, letting a verifier read off numbers directly.

Step 3. Extract the asymptotic scaling. Using $\mathrm{erfc}(z)\sim e^{-z^2}/(z\sqrt{\pi})$ with $z^2=\dfrac{\pi}{8\Delta^2}$ , the floor decays as $P_1\sim e^{-\pi/(8\Delta^2)}$ . Why: the exponent is linear in $1/\Delta^2$ , i.e. in the squeezing in nepers, so each few dB multiplies the error by a fixed fraction — the exponential payoff.

Step 4. Combine the two quadratures. A logical error is a flip in $\hat q$ ( $\bar X$ ) or $\hat p$ ( $\bar Z$ ), so by a union bound $P_L\approx2P_1=2\,\mathrm{erfc}\!\left(\frac{\sqrt{\pi}/2}{\sqrt{2}\,\Delta}\right)$ . Why: at low rates the two failure modes are rare and nearly independent, so their probabilities add. *As a numerical check: at $\Delta^2=0.1$ ( $10\ \mathrm{dB}$ ), $z=\sqrt{\pi}/(2\sqrt{2}\cdot\sqrt{0.1})\approx1.98$ , giving $\mathrm{erfc}(1.98)\approx5.1\times10^{-3}$ and $P_L\approx1.0\times10^{-2}$ ; at $\Delta^2=0.2$ ( $\approx7\ \mathrm{dB}$ ), $z\approx1.40$ , $\mathrm{erfc}(1.40)\approx4.8\times10^{-2}$ , and $P_L\approx9.5\times10^{-2}$ .*

Limiting cases

GKP performance is controlled by the squeezing / envelope width $\Delta$ and by the lattice geometry. The important regimes:

Case	Result	Meaning
Ideal GKP limit	$\Delta\to 0$	Dirac-comb codewords, infinite energy, exact correction of any shift with $\vert\xi\vert<\sqrt{\pi}/2$ per quadrature. Unphysical, but the design target.
Finite-energy GKP	$\bar n \approx \tfrac{1}{2\Delta^2}$	Gaussian-broadened peaks under a Gaussian envelope; the photon number grows as squeezing rises and the logical error falls but never reaches zero.
High-squeezing asymptotics	$P_L\sim e^{-\pi/(8\Delta^2)}$	Residual error from comb-tail overlap decays exponentially in $1/\Delta^2$ , equivalently exponentially in dB.
Pure-displacement threshold	$\sigma \lesssim \sqrt{\pi}/2 \approx 0.886$	Per-quadrature noise std below half a cell is nominally correctable single-shot; optimal-decoding thresholds are lower ( $\sigma\approx0.5$ – $0.6$ ) and improve sharply under concatenation.

Common trapIdeal GKP states are real states you can just squeeze harder toward

They are not states of the oscillator at all. Ideal codewords are perfect Dirac combs — infinitely many, infinitely sharp peaks, hence infinite energy and no finite norm — living outside the Hilbert space, like a plane wave in ordinary quantum mechanics. Every quantitative claim about error rates, photon number, or gate fidelity must use finite-energy, Gaussian-regularized codewords, with $\bar n\approx1/(2\Delta^2)$ and a logical error bounded below by the $\mathrm{erfc}$ floor of equation (7). Conflating the two invites absurdities like perfect protection at zero cost. The honest statement is a tradeoff: protection improves exponentially in $\Delta$ , but so do the energy and squeezing you must generate, and no experiment reaches $\Delta=0$ .

Worked examples

1 · Syndrome extraction and snap-to-grid (fully worked)

An ideal square GKP qubit suffers a displacement $\xi=(\xi_q,\xi_p)=(+0.30,\,-0.62)$ . Show both components are correctable, compute the syndrome, and give the recovery.

Step 1. Compare each component with the boundary $\sqrt{\pi}/2\approx0.8862$ . Here $|\xi_q|=0.30$ and $|\xi_p|=0.62$ are both below $0.8862$ , so both shifts sit inside the correctable Voronoi cell and recovery is exact. Both components lie within $\pm\sqrt{\pi}/2$ , so the error is correctable.

Step 2. Compute the syndrome, the quadratures modulo the half-period $\sqrt{\pi}\approx1.7725$ . Since each shift is smaller than $\sqrt{\pi}$ , the remainders are the shifts themselves. Syndrome $s_q=+0.30$ , $s_p=-0.62$ .

Step 3. Decode by maximum likelihood: assume the smallest shift consistent with each syndrome and undo it. The decoder applies $D(-\xi)=D(-0.30,+0.62)$ , returning the state exactly to the original codeword — the true shift was the minimal one. Recovery $D(-0.30,\,+0.62)$ restores the codeword; no logical Pauli is applied.

Step 4. See how close this was to failure. Had $\xi_p$ been $-0.95$ , then $|\xi_p|>0.8862$ : the syndrome $s_p=\sqrt{\pi}-0.95\approx0.82$ reads as a small positive shift, the decoder rounds the wrong way, and the net operation is a logical $\bar Z$ . The margin is $\sqrt{\pi}/2-0.62\approx0.27$ in $\hat p$ ; beyond it a $\bar Z$ error results.

2 · Logical error rate versus squeezing (fully worked)

A finite-energy GKP memory is prepared at $10\ \mathrm{dB}$ of squeezing ( $\Delta^2=10^{-\mathrm{dB}/10}$ ). Find $\Delta$ , the mean photon number, and the intrinsic logical error rate; compare with $7\ \mathrm{dB}$ and add a channel with per-quadrature noise $\sigma=0.20$ .

Step 1. Convert dB to $\Delta$ . At $10\ \mathrm{dB}$ , $\Delta^2=10^{-1.0}=0.100$ , so $\Delta=0.3162$ , and the mean photon number is $\bar n\approx1/(2\Delta^2)=\mathbf{5.0}$ photons — the resource cost of this protection. $\Delta=0.316$ , $\bar n\approx5$ .

Step 2. Evaluate the intrinsic floor from equation (7) with $\sigma=0$ . The erfc argument is $z=\dfrac{\sqrt{\pi}/2}{\sqrt{2}\,\Delta}=\dfrac{0.8862}{1.4142\times0.3162}=1.982$ , so $P_L=2\,\mathrm{erfc}(1.982)=\mathbf{1.0\times10^{-2}}$ — a $10\ \mathrm{dB}$ GKP qubit has intrinsic logical error near one percent. $P_L\approx1.0\%$ at $10\ \mathrm{dB}$ .

Step 3. Repeat at $7\ \mathrm{dB}$ for the slope. Now $\Delta^2=10^{-0.7}=0.1995$ , $\Delta=0.4467$ , $z=1.403$ , and $P_L=2\,\mathrm{erfc}(1.403)=\mathbf{9.5\times10^{-2}}$ . Just $3\ \mathrm{dB}$ less squeezing worsens the error nearly tenfold, and pushing to $13\ \mathrm{dB}$ improves it to $\approx1.5\times10^{-4}$ . Roughly an order of magnitude per $3\ \mathrm{dB}$ .

Step 4. Add channel noise $\sigma=0.20$ to the $10\ \mathrm{dB}$ state. The variances add: $\sqrt{\sigma^2+\Delta^2}=\sqrt{0.140}=0.3742$ , so $z=\dfrac{0.8862}{1.4142\times0.3742}=1.675$ and $P_L=2\,\mathrm{erfc}(1.675)=\mathbf{3.6\times10^{-2}}$ . The channel roughly triples the memory's own floor — the per-mode number an outer code must suppress. Combined $P_L\approx3.6\%$ .

Physics of the portrait

The GKP code reads, in hindsight, as inevitable — yet it waited until 2001 and took three theorists thinking at once about oscillators, lattices, and fault tolerance.

Origins · 1 minGottesman, Kitaev & Preskill and how this was discovered

Gottesman, Kitaev & Preskill

2001 — Phys. Rev. A 64, 012310 · encoding a qubit in an oscillator

"Encoding a qubit in an oscillator" grew from a specific frustration: quantum error correction had been built for finite-dimensional systems, but much of the best hardware — optical modes, microwave cavities, trapped-ion motion — is natively an oscillator with a continuous spectrum. Daniel Gottesman had, in his 1997 thesis, recast codes in the stabilizer language, describing a code by the abelian group of operators that fix it; the leap here was to let that group be generated by displacement operators rather than Pauli strings, so the code became a lattice in phase space. Alexei Kitaev, already known for the toric code, supplied the lattice viewpoint in which correction is nearest-point decoding and code distance is a minimum-distance problem, and John Preskill anchored it in fault tolerance, showing Gaussian operations realize the Clifford group while the missing non-Gaussian element is exactly the magic needed for universality. For two decades the paper was admired and dismissed as impractical, demanding squeezing beyond any device; that verdict reversed only when trapped-ion and superconducting groups reached $6$ – $11\ \mathrm{dB}$ and stabilized grid states in real time, turning a theorist's lattice into a laboratory qubit.

History

1997

— Gottesman formulates the stabilizer formalism for quantum codes in his thesis

2001

— Gottesman, Kitaev and Preskill publish the GKP oscillator code

2006

— Menicucci and collaborators propose continuous-variable cluster states for measurement-based computing

2019

— Fluhmann and colleagues prepare and stabilize grid states in a trapped-ion motional mode

2020

— Campagne-Ibarcq and collaborators surpass break-even with a cavity GKP qubit

Going further

Texts. Gottesman, Kitaev and Preskill, "Encoding a qubit in an oscillator," Phys. Rev. A 64, 012310 (2001) — the source of every equation here. Nielsen and Chuang, Quantum Computation and Quantum Information, Ch. 10 (stabilizer codes) and Ch. 7 (oscillator and displacement conventions). Preskill, Lecture Notes on Quantum Computation, on error correction and fault tolerance. Wilde, Quantum Information Theory, 2nd ed., for the channel background. Terhal, Conrad and Vuillot, "Towards scalable bosonic quantum error correction," Quantum Sci. Technol. 5, 043001 (2020) — the modern review of finite-energy states, thresholds, and concatenation. The standard square-lattice convention used throughout has stabilizer displacement $2\sqrt{\pi}$ , logicals $\sqrt{\pi}$ , and $\bar X^2=S_q$ , $\bar Z^2=S_p$ ; the Weyl braiding relation uses $[\hat q,\hat p]=i$ ; the finite-energy mean photon number is $\bar n\approx1/(2\Delta^2)$ ; and the erfc floor evaluates to $\approx1.0\times10^{-2}$ at $\Delta^2=0.1$ and $\approx9.5\times10^{-2}$ at $\Delta^2=0.2$ . Note that the intrinsic floor scales as $e^{-\pi/(8\Delta^2)}$ , matching the erfc argument, not $e^{-\pi/(4\Delta^2)}$ as some secondary summaries state.

Prerequisites. Quantum harmonic oscillator and quadratures · Stabilizer formalism · Displacement operators and phase space · Magic-state distillation. Leads to. Measurement-based quantum computation · Cluster states and graph states · Toric code and topological order · Magic-state distillation.

Ask the tutor: Ask me to walk through the syndrome-and-recovery for a displacement you choose, or to derive why $10\ \mathrm{dB}$ of squeezing lands you at roughly one-percent logical error.

Why encode a qubit in an oscillator instead of just using more qubits?

An oscillator is a single physical object with an infinite-dimensional Hilbert space, so the redundancy error correction needs is already present without wiring many two-level systems. That is hardware-efficient: one cavity or trapped-ion mode plus an ancilla hosts a protected logical qubit, where a qubit surface code needs a large array. The catch is that protection is bought with squeezing and photon number rather than qubit count. GKP is attractive precisely because its natural error model — small displacements — matches the noise these oscillators actually suffer.

What is the difference between GKP and cat or binomial codes?

All three are bosonic codes, but they target different noise. Cat and binomial codes are engineered chiefly against photon loss, encoding the qubit in superpositions of coherent states (cats) or sparse Fock superpositions (binomial), so a lost photon maps the codespace to a detectable error space. GKP instead targets displacement noise directly, tiling phase space so small shifts in any direction are correctable. GKP has the highest correction power once enough squeezing is available and composes with outer codes via soft information, while cat and binomial codes have been easier to realize at modest photon numbers — complementary tools, not competitors.

What does the squeezing in dB actually measure?

It quantifies how far below the vacuum fluctuation each GKP peak has been narrowed. In the convention used here, squeezing in decibels is $-10\log_{10}\Delta^2$ , so $10\ \mathrm{dB}$ means $\Delta^2=0.1$ , a peak variance one-tenth of the reference. Because the floor $2\,\mathrm{erfc}(\sqrt{\pi}/(2\sqrt{2}\,\Delta))$ decays like $e^{-\pi/(8\Delta^2)}$ , each extra few dB multiplies the residual error by a fixed factor — roughly an order of magnitude per $3\ \mathrm{dB}$ . Experiments now reach $6$ – $11\ \mathrm{dB}$ .

If the stabilizers are measured, why is the logical qubit not disturbed?

Because the stabilizers commute with the logical operators. Measuring $S_q$ and $S_p$ projects onto a definite syndrome — the displacement modulo the lattice — but returns no information about which logical state you hold, since $\bar X$ and $\bar Z$ commute with both stabilizers. The syndrome lives in the fractional part of the quadratures while the logical bit lives in the integer part, complementary corners of the same continuous variable. This is the continuous-variable form of the general stabilizer-code fact that syndrome extraction reveals errors without measuring the encoded information — the basis of non-destructive, repeatable correction.

How does photon loss fit a code designed for displacements?

Photon loss is not literally a displacement — it is the annihilation operator acting through an amplitude-damping channel — so at first sight GKP looks mismatched to the dominant cavity error. But after an appropriate recovery or frame transformation (for instance a quantum-limited amplifier that restores the mean energy), the residual effect of loss looks, to leading order, like a Gaussian random displacement, which GKP corrects as usual. The mapping degrades at large loss, which is why real analyses track loss explicitly and concatenation handles the residual.

Why does concatenating GKP with the surface code work so well?

Two reasons stack. First, GKP turns an analog error into a nearly digital one, delivering a physical qubit whose residual failures are ordinary logical Paulis — the error model the surface code suppresses. Second, and more powerfully, the GKP layer emits soft information: the syndrome is a continuous distance to the nearest lattice point, a confidence value saying how close the shift came to the boundary. Feeding that confidence into the surface-code decoder, instead of collapsing it to a hard bit, lets it weight ambiguous qubits appropriately, and the combined threshold against Gaussian noise rises far above hard-decision decoding — among the most hardware-efficient fault-tolerance proposals known.