# Gottesman-Kitaev-Preskill codes: A lattice perspective

Jonathan Conrad<EMAIL_ADDRESS>Dahlem Center for Complex Quantum
Systems, Physics Department, Freie Universität Berlin, Arnimallee 14, 14195
Berlin, Germany  Helmholtz-Zentrum Berlin für Materialien und Energie, Hahn-
Meitner-Platz 1, 14109 Berlin, Germany  Jens Eisert  Dahlem Center for Complex
Quantum Systems, Physics Department, Freie Universität Berlin, Arnimallee 14,
14195 Berlin, Germany  Helmholtz-Zentrum Berlin für Materialien und Energie,
Hahn-Meitner-Platz 1, 14109 Berlin, Germany  Francesco Arzani
<EMAIL_ADDRESS>Dahlem Center for Complex Quantum Systems, Physics
Department, Freie Universität Berlin, Arnimallee 14, 14195 Berlin, Germany

We examine general Gottesman-Kitaev-Preskill (GKP) codes for continuous-
variable quantum error correction, including concatenated GKP codes, through
the lens of lattice theory, in order to better understand the structure of
this class of stabilizer codes. We derive formal bounds on code parameters,
show how different decoding strategies are precisely related, propose new ways
to obtain GKP codes by means of glued lattices and the tensor product of
lattices and point to natural resource savings that have remained hidden in
recent approaches. We present general results that we illustrate through
examples taken from different classes of codes, including scaled self-dual GKP
codes and the concatenated surface-GKP code.

##  1 Introduction

It is known that quantum physics can be harnessed to speed-up certain
computational tasks. However, it seems challenging to take advantage of such
potential in practice. Arguably the biggest hindrance to achieving reliable
quantum information processing is the difficulty to control systems and
sufficiently isolate them from their environment. The field of _quantum error
correction (QEC)_ has been developed to cope with errors by choosing an
appropriate encoding to constrain the action of environmental noise on the
stored information and by repeated measurements of an associated stabilizer
group to remove entropy from the system. With advancing experimental control
over _superconducting_ and _integrated optical photonic_ circuits, recent
years have witnessed growing interest in bosonic quantum error correction,
where information is embedded into bosonic or continuous-variable (CV) systems
exploiting the redundancy available in the associate infinite dimensional
Hilbert space. In particular, so-called _Gottesman-Kitaev-Preskill (GKP)_
codes [1] have been increasingly studied as promising components towards
building a scalable quantum computer [2, 3, 4, 5, 6].

While the original proposal for the GKP code was made as early as in 2001,
only in recent years experimental efforts of realizing such codes have gained
momentum. Quantum error correction with single mode versions of the GKP code
has recently been demonstrated experimentally in ion-traps [7] and
superconducting hardware [8] while a growing number of theoretical proposals
investigate the possibility to concatenate such codes with known qubit codes
[9, 10, 11, 12, 4] to achieve exponential error suppression by increasing the
number of modes. Most works in this direction focus on understanding the
single mode GKP code as an effective encoded qubit, with an effective noise
channel, and proceed in their analysis using the well established toolbox of
qubit quantum error correction. While it allowed rapid progress, this approach
significantly limits the class of codes that can be considered and the
analytical grasp on the continuous nature of the underlying system. In
general, both the structure of the state and that of the stabilizer group of
GKP codes can be understood in terms of lattices in phase-space, which is
often used to introduce and visualize single-mode examples. But the deep
connection with lattices also holds in the multi-mode case, including but,
crucially, not limited to codes obtained from concatenating a single-mode GKP
code with qubit stabilizer codes. The description of (multi-mode) GKP codes in
terms of symplectic lattices was already formulated in the seminal work [1].
However, only a handful of examples can be found in the literature [12, 13,
14, 15] that attempt to use it for a better understanding of the structure and
properties of such codes, for constructing new codes or for devising decoding
algorithms.

In this work we present an introduction to lattice theory for quantum error
correction practitioners and show how the tools it provides can be fruitfully
put to use for the analysis and design of GKP codes. The upshot is that, since
lattices have long been studied in many branches of pure and applied
mathematics, from number theory to string theory, they provide us with a rich
toolbox whose potential remains largely untapped for quantum error correction.
By elaborating on the connection with lattices, we move some further steps in
this direction. We hope that this will motivate a wider adoption of lattice
techniques in the study of GKP- and general quantum error correcting codes.
The results in the present work suggest that this could lead to further
insight as well as potential practical advantages towards fault-tolerant
quantum computation with GKP codes.

To demonstrate the power of the lattice formalism, we derive a number of new
results relating the parameters of GKP codes, such as the distance and
encoding rate. We study the equivalence of codes under symplectic
transformations, formulate the general decoding problem in terms of lattice
quantities and provide two constructions leading to new codes that cannot be
described (to the best of our knowledge) within the usual concatenated GKP-
qubit paradigm. This highlights that the latter only captures very special
cases, that, while easy to conceive, have no _a priori_ reason to be
considered optimal in taking advantage of the underlying bosonic nature of the
system.

This article is structured as follows. In Section 2, we set the stage by
introducing the relevant notions from lattice theory that will be used in the
rest of this manuscript and we discuss their relation to GKP codes. Section 3
explores how the choice of the lattice basis corresponding to the stabilizer
generators influences the properties of the latter. We focus in particular on
suitable generalizations of _Calderbank-Shor-Steane (CSS)_ codes and _low-
density-parity-check (LDPC)_ codes to the GKP setting. We show that
significant savings in the number of stabilizer measurements with respect to
the procedure usually employed for concatenated GKP-qubit codes are possible
by measuring a minimal set of stabilizers at each error correction cycle.
Furthermore, we show that concatenation of qubit stabilizer codes with single
mode GKP codes provides a natural embedding of the qubit code into a lattice
through the so-called _Construction A_ [16], which leads to a no-go result
that impacts the complexity of the decoding problem, in particular exact
_minimum-energy-decoding_.

In Section 4, we prove a necessary and sufficient condition for two GKP codes
to be equivalent up to a symplectic transformation, extending the single mode
case mentioned in ref. [12]. This can be interpreted as code-switching by
means of a Gaussian unitary. Section 5 is focused on defining a notion of
_distance_ for GKP codes via the length of the shortest non-trivial dual coset
element of the lattice that describes the stabilizers. This definition is
motivated by the structure of common noise models used for GKP codes in the
literature. We discuss tradeoffs between the distance and other code
parameters, such as encoding rate and the “length” of stabilizers.
Furthermore, we show how to estimate the distance of a GKP code from the theta
functions of the corresponding lattice, which are central quantities in
lattice theory. Finally, we show that the distance of a CSS _qubit_ stabilizer
code is fully determined by the weight distribution of its stabilizer group,
i.e., the number of stabilizers of particular Hamming weight in their
representation by symplectic binary vectors. Although a similar statement can
be derived from the seminal work of Shor, Laflamme [17] and Rains [18], it
follows straightforwardly from the lattice theoretic concepts we introduce,
showcasing that a lattice theoretic standpoint can also benefit the
examination of qubit stabilizer codes.

Theta functions are central in the general formulation of the maximum
likelihood (coset) decoding problem for general GKP codes, as we detail in
Section 6. This hints at the existence of new decoding strategies that do not
rely on the concatenated code structure, and are hence more general than those
adapted from qubit codes. A detailed discussion of such strategies is beyond
the scope of the present work and is therefore postponed to a separate
publication.

Finally, we discuss in Section 7 two constructions, based on glued lattices
and the lattice tensor product operation, respectively, to obtain GKP codes
beyond scaled and concatenated codes, the two main code constructions featured
in previous works and the rest of this work. We foresee that such alternative
constructions may become of practical relevance in the near future, especially
in setups with limited locality constraints, such as photonic architectures.
Furthermore, we show that some properties of these codes can be computed
easily, potentially making them also useful examples to probe the limits of
GKP codes. Concluding remarks and future perspectives in Section 8 complete
this work.

##  2 Preliminaries and notation

In this section, we review the basic setup of GKP codes as proposed in ref.
[1] and introduce some basic concepts of lattice theory to analyze their
structure. Good introductions to lattice theory are found in refs. [19, 16],
from which many of the following definitions and lattice theoretic arguments
presented here are adapted. A _stabilizer code_ [20] embeds information into a
physical Hilbert space by defining the code-space as fixed point of a finitely
generated, abelian group $\mathcal{S}$, i.e., logical information is stored in
terms of state vectors

$\displaystyle\ket{\psi}:\;s\ket{\psi}=+1\ket{\psi}\,\forall s\in\mathcal{S}.$
(1)

The _GKP code_ [1] is a stabilizer code acting on the Hilbert space of $n$
bosonic modes, where stabilizers are given by displacement operators

$\displaystyle
D\left(\bm{\xi}\right)=\prod_{k}\exp\left\\{-i\sqrt{2\pi}u_{k}\hat{p}_{k}+i\sqrt{2\pi}v_{k}\hat{q}_{k}\right\\}=\exp\left\\{-i\sqrt{2\pi}\bm{\xi}^{\mathrm{T}}J\hat{\bm{x}}\right\\},\quad\bm{\xi}=\left(\begin{array}[]{c}\bm{u}\\\
\bm{v}\end{array}\right),\quad\bm{\hat{x}}=\left(\begin{array}[]{c}\hat{\bm{q}}\\\
\bm{\hat{p}}\end{array}\right),$ (6)

where

$\displaystyle J=J_{2n}=\begin{pmatrix}0&1\\\ -1&0\end{pmatrix}\otimes
I_{n}=\begin{pmatrix}0&I_{n}\\\ -I_{n}&0\end{pmatrix}$ (7)

is the _symplectic form_ and $\bm{\xi}\in\mathbb{R}^{2n}$ are phase-space
vectors that specify the displacement. When no index is specified, we follow
the convention $J=J_{2n}$ and $I=I_{2n}$. We also adopt the convention
$\hbar=1$, such that $[\hat{x}_{k},\hat{x}_{l}]=iJ_{k,l}$ for
$k,l=1,\dots,2n$. Throughout this work, we use bold symbols to denote (column)
vectors. _Displacement operators_ implement a shift of the $2n-$quadratures

$D^{\dagger}(\bm{\xi})\hat{\bm{x}}D(\bm{\xi})=\hat{\bm{x}}+\sqrt{2\pi}\bm{\xi},$
(8)

commute as

$D(\bm{\xi})D(\bm{\eta})=e^{-i2\pi\bm{\xi}^{T}J\bm{\eta}}D(\bm{\eta})D(\bm{\xi}),$
(9)

and satisfy

$D(\bm{\xi})D(\bm{\eta})=e^{-i\pi\bm{\xi}^{T}J\bm{\eta}}D\left(\bm{\xi}+\bm{\eta}\right).$
(10)

Given the metaplectic representation of a symplectic operator [21] $S\mapsto
U_{S},\,S^{T}JS=J$, we have

$U_{S}\hat{\bm{x}}U_{S}^{\dagger}=S\hat{\bm{x}},$ (11)

such that

$U_{S^{-1}}D(\bm{\xi})U_{S^{-1}}^{\dagger}=\exp\left(-i\bm{\xi}^{T}JS^{-1}\hat{\bm{x}}\right)=\exp\left(-i\bm{\xi}^{T}S^{T}JSS^{-1}\hat{\bm{x}}\right)=D(S\bm{\xi}).$
(12)

Displacement operators are orthogonal,

$\operatorname{Tr}\left[D^{\dagger}\left(\bm{\xi}\right)D(\bm{\eta})\right]=\delta^{(2n)}\left(\bm{\xi}-\bm{\eta}\right),$
(13)

and form a complete basis such that any operator
$\hat{O}\in\mathcal{L}\left(\mathcal{H}\right)$ can be resolved as111To be
precise, this must be restricted to trace-class operators and one should
formulate exceptions for operators such as $D\left(\beta\right)$ to satisfy
eq. (13).

$\hat{O}=\int d\bm{x}o(\bm{x})D\left(\bm{x}\right)=\int
d\bm{x}\operatorname{Tr}\left[D^{\dagger}\left(\bm{x}\right)\hat{O}\right]D\left(\bm{x}\right).$
(14)

We can now define the GKP stabilizer group.

######  Definition 1 (GKP stabilizer group [1]).

The stabilizer group of a GKP code is given by a set of displacements

$\mathcal{S}:=\langle
D\left(\bm{\xi}_{1}\right),\dots,D\left(\bm{\xi}_{2n}\right)\rangle,$ (15)

where $\left\\{\bm{\xi}_{i}\right\\}_{i=1}^{2n}$ are linearly independent and
we have $\bm{\xi}_{i}^{T}J\bm{\xi}_{j}\in\mathbb{Z}\forall\,i,\,j$.

Exploiting the structure of the displacement operators, the GKP construction
defines a stabilizer group isomorphic to a _lattice_ with generator matrix

$M=\begin{pmatrix}\bm{\xi}_{1}^{T}\\\ \vdots\\\
\bm{\xi}_{2n}^{T}\end{pmatrix},$ (16)

which is simply the set of integer linear combinations of basis elements

$\mathcal{L}=\mathcal{L}\left(M\right)=\left\\{\bm{\xi}\in\mathbb{R}^{2n}\big{|}\;\bm{\xi}^{T}=\bm{a}^{T}M,\,\bm{a}\in\mathbb{Z}^{2n\times
2n}\right\\}.$ (17)

We follow the convention of ref. [1] such that the basis vectors of the
lattice $\mathcal{L}$ constitute the rows of the generator matrix.

For $\mathcal{S}$ to constitute a stabilizer group, it needs to be (1.) a
group and (2. ) abelian. By construction in Definition 1, $\mathcal{S}$ is a
group and by means of eq. (9) it can be observed that $\mathcal{S}$ is abelian
if and only if the symplectic Gram matrix associated with any generator $M$ of
the lattice

$A:=MJM^{T}$ (18)

has only integer entries. We then say that the lattice $\mathcal{L}(M)$ is
symplectically integral. The symbol $A$ will be reserved to the symplectic
Gram matrix throughout the manuscript and although it depends on the
particular generator $M$ we will mostly leave this understood when the
generator is clear from the context.

Using eq. (10), it can be verified that each element of the stabilizer group
$\mathcal{S}$ can be written as

$\displaystyle\prod_{i=1}^{2n}D\left(\bm{\xi}_{i}\right)^{a_{i}}$
$\displaystyle=\prod_{i=1}^{2n}D\left(a_{i}\bm{\xi}_{i}\right)$ (19)
$\displaystyle=e^{i\pi\bm{a}^{T}A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\bm{a}}D\left((\bm{a}^{T}M)^{T}\right),$
(20)

where $\bm{a}\in\mathbb{Z}^{2n}$ is an integer vector and $A_{\leavevmode\hbox
to4.5pt{\vbox to4.5pt{\pgfpicture\makeatletter\hbox{\hskip
0.2pt\lower-0.2pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}:\;(A_{\leavevmode\hbox
to4.5pt{\vbox to4.5pt{\pgfpicture\makeatletter\hbox{\hskip
0.2pt\lower-0.2pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}})_{i,j}=A_{i,j}\,\forall\,i>j$
is the lower triangular matrix of $A$. The stabilizer group $\mathcal{S}$ is
hence given by

$\mathcal{S}=\left\\{e^{i\phi_{M}\left(\bm{\xi}\right)}D\left(\bm{\xi}\right)|\bm{\xi}\in\mathcal{L}\right\\},$
(21)

where

$\phi_{M}\left(\bm{\xi}\right)=\pi\bm{a}^{T}A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\bm{a},\;\bm{a}^{T}=\bm{\xi}^{T}M^{-1}$
(22)

denotes the phase-sector when we have chosen $M$ to be the _pivot basis_ ,
i.e. the set of basis vectors for which each associated displacement operator
is fixed to eigenvalue $+1$ by definition 1. We will also use the notation
$\mathcal{S}=\mathcal{S}(M,\phi_{M})$ to specify GKP stabilizer groups from
its generator $M$ when the phase-sector is relevant. The pair $(M,\phi_{N})$
specifies that the generator for the stabilizer group
$D\left(M_{i}^{T}\right)$ is fixed by eigenvalue
$e^{i\phi_{N}\left(M_{i}^{T}\right)}$ in code space. Consistently, we have
$(M,\phi_{M})=(M,0)$.

When $\mathcal{L}$ is symplectically integral, we also have
$e^{i\phi\left(\bm{\xi}\right)}=\pm 1\,\forall\,\bm{\xi}\in\mathcal{L}$, which
is also already apparent from eq. (10). The additional phases in front of the
displacement operators act trivially on the projective Hilbert space, such
that they are irrelevant when considering stabilizer operators $\mathcal{S}$
as symmetries of the effective code. However, they play a role in error
correction, where the goal is to fix each stabilizer $s\in\mathcal{S}$ to the
$+1$ eigenvalue to define a code space and the phases determine to which $\pm
1$ eigenvalue the associated displacement operator needs to be fixed.

######  Remark (Definition of the GKP stabilizer group).

We remark that the definition of the GKP stabilizer group we make here differs
from the one presented in ref. [1], which has been stated as
$\mathcal{S}^{\prime}=\left\\{D\left(\bm{\xi}\right)|\bm{\xi}\in\mathcal{L}\right\\}$,
where $\mathcal{L}$ is a symplectically integral lattice. Although this
defines a commuting set of stabilizers, $\mathcal{S}^{\prime}$ is in fact not
closed in general due to the extra phases appearing when combining two
displacement operators eq. (10) and would also not equal $\mathcal{S}$ as
defined above. Definition 1 follows more closely the practical reality, where
error correction is performed by measuring minimal generating set of the
stabilizer group and by fixing (correcting) their eigenvalues to $+1$.

The definition $\mathcal{S}^{\prime}$ is closed and identical to $\mathcal{S}$
in the special case where $A\in\left(2\mathbb{Z}\right)^{2n\times 2n}$, i.e.,
the associated lattice $\mathcal{L}$ is _symplectically even_. We found,
however, that this would restrict us too severely in the classes of codes to
analyze (e.g. the concatenated GKP - surface code introduced later is
described by a symplectically integral, but not symplectically even lattice).
We illustrate the difference between the sets $\mathcal{S}$ and
$\mathcal{S}^{\prime}$ using the stabilizer group for the sensor state [22],

$\mathcal{S}_{\text{sensor}}=\langle
D\left(\bm{e}_{1}\right),\,D\left(\bm{e}_{2}\right)\rangle=\left\\{(-1)^{mn}D\left(m\bm{e}_{1}+n\bm{e}_{2}\right),\;(m,n)\in\mathbb{Z}^{2}\right\\},$
(23)

where $\bm{e}_{j}$ are canonical basis vectors, so that code-states should
have eigenvalue $-1$ on displacement for which $mn$ is odd if they have
eigenvalue $+1$ on each generator
$D\left(\bm{e}_{1}\right),\,D\left(\bm{e}_{2}\right)$. Given the conventional
definition $\mathcal{S}^{\prime}$,
$D\left(\bm{e}_{1}\right)D\left(\bm{e}_{2}\right)=(-1)D\left(\bm{e}_{1}+\bm{e}_{2}\right)$
would formally not be included in the stabilizer group.

A system of $n$ bosonic modes can be associated with an infinite dimensional
Hilbert space and a $2n-$dimensional phase space, whose axes correspond to the
quadratures of the system, each corresponding to an observable taking
continuous values. To encode discrete quantum information, such as a qubit,
the state space needs to be fully “discretized” by introducing suitable
constraints. This is done by choosing a generating set for the stabilizer
group with $2n$ linearly independent generators. Each linearly independent
generator can be seen as “discretizing” one direction in phase space. This is
the reason why we require the lattice $\mathcal{L}$ to be full rank, that is,
we demand that $M$ has full row-rank. It is always possible to specify a
lattice in $\mathbb{R}^{2n}$ using more than $2n$ basis vectors, (we will see
an example of such a scenario later), but they can always be reduced to $2n$
linearly independent vectors, a process for which a number of (efficient)
algorithms are known [19]. We note that also non-full rank (or degenerate)
lattices had recently been explored to define effective GKP codes [23, 15].
The code space of such codes retains undiscretized quadratures which allows to
encode and perform error correction on general CV states. In this work we
focus on encoding qubits or qudits defined via full-rank lattices while
encoding of continuous information using degenerate lattices is briefly
explained in appendix B.

Given a lattice $\mathcal{L}$, the lattice basis is not unique. Rather, two
generator matrices $M,\,M^{\prime}$ generate the same lattice
$\mathcal{L}\left(M\right)=\mathcal{L}\left(M^{\prime}\right)$ if and only if
there exists a unimodular matrix $U\in
GL\left(2n,\,\mathbb{Z}\right),\,|\det(U)|=1$ such that

$M^{\prime}=UM.$ (24)

Such transformation also transforms

$A\mapsto A^{\prime}=UAU^{T}.$ (25)

Note that $A^{\prime}$ has even entries if and only if $A$ does. Due to the
phases appearing in eq. (21), when a different basis $M^{\prime}$ is used to
fix the stabilizer group as in Definition 1, the generating set for the
stabilizer group needs to be chosen as

$\left(M^{\prime},\,\phi_{M}\right)$ (26)

to yield the same stabilizer group and, effectively, the same code and fix the
same code-space. The symplectic Gram matrix is invariant under a symplectic
transformation

$M\mapsto MS^{T}=\begin{pmatrix}(S\bm{\xi}_{1})^{T}\\\ \vdots\\\
(S\bm{\xi}_{2n})^{T}\end{pmatrix}.$ (27)

Note that, unlike the change of basis, a symplectic transformation generally
changes the lattice but also leaves the symplectic Gram matrix invariant. As a
result, symplectic transformations can serve as useful tool to adapt the code
to the properties of the noise while keeping the same encoding rate, as we
will see in the following. When a GKP code is specified by its generator
$\mathcal{S}=\mathcal{S}(M,0)$, the corresponding phase sector transforms
under symplectic transformation as

$\phi_{M}\mapsto\phi_{MS^{T}}.$ (28)

Any basis $M$ of the full rank lattice $\mathcal{L}$ partitions
$\mathbb{R}^{2n}=\mathbb{R}^{2n}M$ into lattice translates of the fundamental
parallelepiped (note the row-vector convention adopted here),

$\mathcal{P}\left(M\right):=\left\\{\bm{x}^{T}M\,\big{|}\;\bm{x}\in[0,1)^{2n}\right\\}$
(29)

such that every point $\bm{x}^{T}\in\mathbb{R}^{2n}$ is uniquely associated to
a lattice point $\bm{x}^{T}\in\bm{a}^{T}M+\mathcal{P}\left(M\right)$.
Equivalently, one can choose to partition $\mathbb{R}^{2n}$ using the centered
fundamental parallelepiped

$\mathcal{C}\left(M\right):=\left\\{\bm{x}^{T}M\big{|}\;\bm{x}\in\left[-\frac{1}{2},\frac{1}{2}\right)^{2n}\right\\}.$
(30)

Any set that exactly partitions the space under lattice translations is called
_fundamental_ and has volume

$\det\left(\mathcal{L}\right):=|\det\left(M\right)|=|\sqrt{\det\left(A\right)}|=|\sqrt{\det\left(G\right)}|$
(31)

where $G:=MM^{T}$ is the euclidean Gram matrix associated to the generator
$M$. The determinant $\det\left(G\right)$ is a lattice invariant known as its
discriminant. The determinant (discriminant) can be geometrically interpreted
as measure of inverse density of lattice points.

A sublattice $\mathcal{L}^{\prime}\subseteq\mathcal{L}$ is a subset of
$\mathcal{L}(M)$ that is itself a lattice. A basis for any $d-$dimensional
sublattice of $\mathcal{L}(M)$, where $d<2n$, can be given by

$S=BM,$ (32)

where $B\in\mathbb{Z}^{d\times 2n}$ is an integer matrix of full row rank. The
symplectic dual (simply “dual” in the following) of a lattice $\mathcal{L}$ is
the lattice $\mathcal{L}^{\perp}$ that consists of all vectors that have
integer symplectic inner product with any vector from $\mathcal{L}$

$\mathcal{L}^{\perp}=\left\\{\mathcal{\bm{\xi}}^{\perp}\in\mathbb{R}^{2n}\ |\
\left(\bm{\xi}^{\perp}\right)^{T}J\bm{\xi}\in\mathbb{Z}\
\forall\bm{\xi}\in\mathcal{L}\right\\}.$ (33)

Within the GKP code construction vectors
$\mathcal{\bm{\xi}}^{\perp}\in\mathcal{L}^{\perp}$ correspond to the
displacement amplitudes that are associated to the centralizer of the
stabilizers within the set of displacement operators. A canonical choice of
basis $M^{\perp}$ for the symplectic dual is specified by fixing $M^{\perp}$
to satisfy

$M^{\perp}JM^{T}=I.$ (34)

Since we will focus on full rank lattices, for which $M$ is non-singular, we
obtain the canonical dual basis as

$M^{\perp}=(JM^{T})^{-1}=M^{-T}J^{T}.$ (35)

Together with the definition of $A$ it can be shown that

$M=AM^{\perp},$ (36)

that is, the symplectic Gram-matrix $A$ describes how the sublattice
$\mathcal{L}=\mathcal{L}\left(M\right)\subseteq\mathcal{L}^{\perp}=\mathcal{L}\left(M^{\perp}\right)$
associated to stabilizer operators embeds into the lattice associated to its
centralizer. The dual quotient (or glue group) of $\mathcal{L}$,
$\mathcal{L}^{\perp}/\mathcal{L}$ thus lists the logically distinct
displacements admitted by the GKP code $\mathcal{S}$. Since we are interested
in effective qubit encodings with logical dimension $d=2^{k}$, these
displacements form the effective logical Pauli group.

Finally, the number of logically distinct centralizer elements associated to
$\mathcal{S}$ is

$d^{2}=|\mathcal{L}^{\perp}/\mathcal{L}|=|\det\left(M\right)|/|\det\left(M^{\perp}\right)|=|\det{A}|=|\det\left(M\right)|^{2}.$
(37)

One can verify this formula geometrically by imagining the partition of
$\mathcal{P}\left(M\right)$ with patches $\mathcal{P}\left(M^{\perp}\right)$.
Under basis transformation of the direct lattice $M\mapsto UM$ the canonical
dual basis transforms as

$M^{\perp}\mapsto U^{-T}M^{\perp},$ (38)

and under symplectic transformations $M\mapsto MS^{T}$ we obtain

$M^{\perp}\mapsto M^{\perp}S^{T}=\begin{pmatrix}(S\bm{\xi}^{\perp})_{1}^{T}\\\
\vdots\\\ (S\bm{\xi}^{\perp}_{2n})^{T}\end{pmatrix}.$ (39)

The symplectic Gram matrix of the dual lattice can be shown to satisfy

$A^{\perp}:=M^{\perp}J\left(M^{\perp}\right)^{T}=A^{-1}=\frac{1}{|\det\left(A\right)|}\operatorname{adj}\left(A\right),$
(40)

where $\operatorname{adj}\left(A\right)$ is the adjugate of $A$. It is
similarly common to define the euclidean dual of a lattice $\mathcal{L}$ which
we shall denote by $\mathcal{L}^{*}$. This is the lattice in $\mathbb{R}^{2n}$
consisting of all vectors with integer euclidean inner product with every
vector in $\mathcal{L}$.

The euclidean dual is more common than the symplectic one in the lattice
theory literature, and hence often simply called dual. Similar to the
symplectic case, a canonical basis $M^{*}$ for the dual lattice can be fixed
to satisfy

$M^{*}M^{T}=I$ (41)

or equivalently (since we only deal with full rank lattices)

$M^{*}=M^{-T}.$ (42)

Since $J\in O(2n)$ is an orthogonal matrix, we can observe that the symplectic
dual is equivalent to the euclidean dual up to an orthogonal rotation. In
particular, the distribution of lengths of vectors in $\mathcal{L}^{\perp}$ is
equal to the distribution of lengths of vectors in $\mathcal{L}^{*}$. We will
take advantage of this fact when analyzing the code distance of GKP codes in
Section 5.

We close this section by introducing the two most studied classes of GKP
codes, which we will use for illustrations throughout this manuscript. The
first class, which we will refer to as scaled codes, have been thoroughly
examined in ref. [13] and build on symplectic self-dual lattices. A symplectic
self-dual lattice is a symplectically integral lattice for which
$|\det\left(M\right)|=|\det\left(A\right)|=1$ and, consequently,
$\mathcal{L}=\mathcal{L}^{\perp}$. The associated code-space is one-
dimensional.

#### Scaled GKP codes.

A scaled GKP code $\mathcal{L}(M)$ is obtained by rescaling a symplectically
self-dual lattice
$\mathcal{L}_{0}=\mathcal{L}\left(M_{0}\right)\subset\mathbb{R}^{2n}$ as

$M=\sqrt{\lambda}M_{0},\;\lambda\in 2\mathbb{Z}.$ (43)

The associated symplectic Gram matrix becomes $A=\lambda A_{0}$ and the
dimension of the code-space is $d=|\sqrt{\det\left(\lambda
A_{0}\right)}|=\lambda^{n}$. By e.g. choosing $\lambda=2$ this yields a code
with $k=n\log_{2}\left(\lambda\right)=n$. Let

$\lambda_{1}\left(\mathcal{L}_{0}\right):=\min\left\\{\|\bm{x}\|,\,\bm{x}\in\mathcal{L}_{0}\right\\}$
(44)

be the length of the shortest vector in
$\mathcal{L}_{0}=\mathcal{L}_{0}^{\perp}$. Note that throughout this
manuscript $\|\cdot\|=\|\cdot\|_{2}$ denotes the euclidean 2-norm. The
rescaling implies
$\lambda_{1}\left(\mathcal{L}\right)=\lambda^{\frac{1}{2}}\lambda_{1}\left(\mathcal{L}_{0}\right)$
and
$\lambda_{1}\left(\mathcal{L}^{\perp}\right)=\lambda^{-\frac{1}{2}}\lambda_{1}\left(\mathcal{L}_{0}\right)$.
For $\lambda>1$ the symplectic dual vector corresponding to
$\lambda_{1}\left(\mathcal{L}^{\perp}\right)$ cannot be in $\mathcal{L}$ and
hence constitutes the shortest logically non-trivial displacement, the length
of which decreases with the number of logical dimensions that are squeezed
into the code. Prominent examples of scaled GKP codes that have already been
discussed in ref. [1] are generated by

$M_{\square}=\sqrt{2}I_{2},$ (45)

also known as the square GKP code, that encodes $k=1$ qubit into $n=1$
oscillator and

$M_{\hexagon}=3^{-\frac{1}{4}}\begin{pmatrix}2&0\\\ 1&\sqrt{3}\end{pmatrix},$
(46)

which is known as the hexagonal GKP code, similarly with $k=n=1$ but with a
different lattice geometry that requires a slightly larger displacement
amplitude to implement a logical operator. Here we have
$\lambda_{1}\left(\mathcal{L}^{\perp}\right)=3^{-\frac{1}{4}}$ compared to
$\lambda_{1}\left(\mathcal{L}^{\perp}\right)=2^{-\frac{1}{2}}$ for the square
GKP code. Further symplectic self-dual lattices with larger
$\lambda_{1}\left(\mathcal{L}_{0}\right)$ and a numerical procedure to find
symplectic self-dual lattices are detailed in ref. [13].

#### Concatenated square GKP codes.

The second class that will be extensively discussed throughout this work is
that of concatenated codes built from the square GKP code and a qubit quantum-
error correcting code. Let $Q\subset\mathbb{Z}_{2}^{2n}$ be a set of binary
symplectic vectors222That is $q^{T}Jq^{\prime}=0\mod 2$ for all $q,\
q^{\prime}\in Q$ (considering addition over reals or in $\mathbb{Z}_{2}$ does
not make any difference). such that
$\mathcal{S}_{Q}=\left\\{Z^{q_{1}}_{1}Z^{q_{2}}_{2}\ldots
X_{n+1}^{q_{n+1}}\ldots X_{2n}^{q_{2n}}\big{|}\forall\bm{q}\in Q\right\\}$
describes the stabilizer group of a $[\\![n,k,d]\\!]$ qubit quantum error
correcting code. We can embed binary vectors in $\mathbb{R}^{2n}$ in the
trivial way. The lattice associated to the concatenated GKP code will be given
by

$\mathcal{L}=\Lambda\left(Q\right):=\left\\{\bm{x}\in\mathbb{R}^{2n}\big{|}\sqrt{2}\bm{x}\mod
2\in Q\right\\}$ (47)

and equally describes an encoding of $k$ logical qubits into $n$ modes. Such
lattices are known in the literature as Construction A lattices [16]. Given
$r=n-k$ symplectic vectors associated to a set of generators for
$\mathcal{S}_{Q}$ that we stack row-wise into a generator
$B_{Q}\in\mathbb{Z}_{2}^{r\times 2n}$, we can write down the generator for the
concatenated code

$M_{\mathrm{conc}}=\frac{1}{\sqrt{2}}\begin{pmatrix}B_{Q}\\\ \hline\cr
2I_{2n}\end{pmatrix}.$ (48)

This basis is overcomplete and can be row-reduced to only consist of $2n$
generators. We discuss basis choices in the next section.

##  3 Bases of GKP codes

The $2n$ rows of the generator matrix $M$ of a GKP code stand in one-to-one
correspondence with a minimal number of generators for the stabilizer group
which are measured to deduce the error syndrome for recovery. Hence the choice
of basis $M$ strongly influences the physical implementation of the code and
certain basis choices may be beneficial over others. Natural desiderata
include the following properties.

#### CSS property.

A _CSS code_ is known in qubit quantum error correction as a code for which
the set of stabilizer operators disjointly separates into one that only
contains Pauli-$Z$ type operators and one that only contains Pauli-$X$ type
operators (or any other pairing). In practice, this has the advantage that
ancillary qubits used to measure the stabilizers only need to come in two
different initial states and only need to couple with their associated data
qubits in one particular way, i.e., via a $CNOT$ or $CZ$ operations.
Furthermore, for sufficiently simple error models, decoding algorithms only
need to be tailored to the respective subcodes. The most studied quantum error
correcting codes are indeed CSS codes, such as homological codes [24]
including the celebrated _toric code_ [25] or planar versions of it [26],
which at the time of writing yield the best promise of protection from noise
and allow for geometrically local implementations. A natural generalization to
GKP codes is to call _CSS_ a code whose lattice admits a basis that can be
written as [1]

$M=M_{q}\oplus M_{p},$ (49)

where $M_{q},M_{p}\in\mathbb{R}^{n\times n}$ describe stabilizers that contain
only $\bm{\hat{p}}$ and $\bm{\hat{q}}$ quadrature operators, respectively.
Equivalentely, the corresponding lattice can be decomposed into the direct sum
of two disjoint sublattices

$\mathcal{L}=\mathcal{L}_{q}\oplus\mathcal{L}_{p}.$ (50)

A trivial example of GKP-CSS code is the single-mode square GKP code.
Concatenating a CSS qubit code with the square GKP code trivially preserves
the CSS property. The decomposition eq. (49) holds concretely for the Hermite
normal form [27, 28] of a lattice basis when $M$ is (or can be rescaled to)
integer, which is defined as follows.

######  Definition 2 (Hermite normal form (HNF)).

Let $M$ be the basis for a lattice as described in the main text. $M$ is in
Hermite normal form if

  1. 1.

$M$ is upper triangular and of positive diagonal, and

  2. 2.

$0\leq M_{i,j}\leq M_{j,j}\;\forall i,j$ , i.e., the pivot of each row is the
largest element of its column.

The Hermite normal form is special in that, for integer $M$, the HNF is unique
[29] and can be computed efficiently (see also ref. [19]). It can hence be
used to verify the CSS property or compare whether two stabilizer groups are
equivalent whenever we are given bases that can be scaled to be integer (and
scaled back after applying the preferred HNF algorithm). In particular, this
applies to concatenated square GKP codes such that we can always check whether
a given code is CSS by computing its HNF.

#### Short basis vectors.

Besides being CSS, the homological qubit codes mentioned above are low-
density-parity-check (LDPC) codes, meaning that they admit a choice of
generators such that the support of each generator is bounded and each qubit
only interacts with a bounded number of generators. Here “low” typically means
constant in the number of physical qubits. The LDPC property can be
generalized in two different ways. Analogous to the qubit picture we can ask
for the stabilizers of the GKP code to only act non-trivially on a low number
of modes and that each mode be only touched upon by a low number of
stabilizers. It is straightforward to see that this property is inherited
whenever a qubit LDPC code is concatenated with single mode bosonic codes such
as the square- or hexagonal-GKP code and can more generally be quantified by
counting the number of non-zero elements of a choice of generator $M$ per
row/column. On the other hand, in the bosonic case, it would also be natural
to demand for the lattice basis vectors to be short in the sense of the
euclidean norm. If one imagines that the stabilizer checks are implemented by
coupling in and subsequently measuring ancillary systems, the length of the
basis vectors depends both on the number of modes that each ancilla is coupled
to as well as on the interaction-strength/-time required. We will see shortly
how a minimal basis (that is, consisting of only $2n$ generators) with short
vectors can be constructed for concatenated GKP codes. In general, when no
extra structure is specified, short bases can also be computed by means of
lattice reduction algorithms, such as the Lenstra-Lenstra-Lovász (LLL)
algorithm [30], which efficiently finds a short and almost orthogonal basis.

#### Orthogonality.

On top of shortening the basis vectors, the LLL algorithm also attempts to
find a basis that is nearly orthogonal. A basis $M$ is orthogonal when
$MM^{T}$ is diagonal and we say a lattice $\mathcal{L}$ is orthogonal if such
a basis exists.

We will see later in Sections 5, 6 how orthogonality is useful when attempting
to quantify the distance of a GKP code or for the task of decoding. The
single-mode square and rectangular GKP codes correspond to orthogonal
lattices. However, when a qubit code is concatenated to the square-GKP code,
leading to Construction A lattices, this can only be the case if the qubit
stabilizer generators act disjointly on at most two quadratures at once [31],
i.e., if the qubit stabilizer code decomposes as

$Q=\bigoplus_{i}Q_{i},\hskip
28.45274ptQ_{i}=\\{0,1\\}\;\text{or}\;Q_{i}=\\{00,11\\}$ (51)

up to permutation of coordinates. Since stabilizer codes require stabilizer
generators to overlap non-trivially to achieve long-range entangled states, we
arrive at the following claim.

######  Claim 1 (Orthogonality of concatenated GKP codes).

Concatenated GKP codes with long-range entangled code states have a non-
orthogonal lattice $\mathcal{L}$.

Phrased differently, this means that codes associated to orthogonal lattices
cannot produce long-range entanglement. Finally, we can also relate the length
of stabilizer generators to the possibly admitted encoding rate.

######  Theorem 1 (Hadamard’s bound).

Let $M$ be a GKP code’s generator, $C=\max_{i}\;\|M_{i}\|$ with $M_{i}$ the
$i$th row of $M$, and $d=2^{k}=\sqrt{\det\left(A\right)}$ the logical
dimension. We have

$k\leq 2n\log_{2}C.$ (52)

###### Proof.

We have $\det(M^{\perp})=\det(M)^{-1}$, thus by $M=AM^{\perp}$ we have
$|\det(A)|=|\det(M)|/|\det(M^{\perp})|=\det(M)^{2}$. Hadamard’s inequality
implies

$|\det(M)|\leq\prod_{i=1}^{2n}\|M_{i}\|\leq C^{2n},$ (53)

which is also known as Hadamard’s bound. Taking the logarithm on both sides
yields the result. ∎

This simple inequality based on Hadamard’s bound constrains the encoding rate
of a GKP code by the maximum length of the stabilizers. For a fixed basis $M$,
$C$ quantifies the size of the displacement that needs to be measured to
extract the syndrome, which can loosely be interpreted as the “experimental
hardness” to implement a code with stabilizer generators described by the rows
of $M$. $C$ is large whenever many modes are involved in a single stabilizer
generator (compare with the LDPC property) or the displacement to be measured
is large (requiring stronger coupling). We note that the value of $C$ is
basis-dependent, while the LHS of the inequality is not. Hence any fixed basis
$M$ yields an upper bound on the encoding rate but the bound will only be
saturated when all $M_{i}$ are orthogonal and of similar length. We have
already observed in Claim 1 that interesting concatenated codes do not yield
orthogonal lattices, such that in these cases the bound will not hold tightly.

###  3.1 Minimal bases for concatenated GKP codes

As an example of an interesting application of lattice basis reduction, we
present a procedure to find a minimal basis for the lattice obtained as
concatenation of the single square-GKP code with the _Surface-17 code_ in Fig.
4. This basis is derived by first noting that $2n$ stabilizers suffice to
fully specify the code, in contrast to the usual $3n-k$ generators of the
union individual GKP stabilizers and concatenated stabilizers. Starting from
this set, it is clear that removing any of the $r=n-k$ independent qubit
stabilizers from the union of generators necessarily changes the dimension of
the code space. The redundant stabilizers, that can be omitted without
affecting the encoded subspace, must hence be found among the single-mode GKP
ones. We identify the redundant single-mode GKP stabilizers as follows.
Squaring the concatenated qubit code stabilizers $S_{i}^{Z/X}$ yields a
product of square GKP-code stabilizers, such that not all GKP stabilizer
overlapping on $\text{supp}\left(S_{i}^{Z/X}\right)$ need to be included on
that local region to generate the full local stabilizer group, e.g. in Fig. 4
one can obtain $S_{2}^{p}$ by multiplying $(S_{3}^{X})^{2}$ with $S_{3}^{p}$,
such that locally $S_{3}^{p}$ and $S_{3}^{X}$ suffice to reconstruct the full
$p-$type syndrome. We note that the pattern of the included local GKP-code
stabilizers depicted in Fig. 4 can be extended to larger surface code layouts.

In general, given a concatenated square GKP code we obtain a procedure to find
a minimal generating set as detailed in Figs. 4, 4, 4. Let
$B=B_{Q}\in\mathbb{Z}_{2}^{r\times 2n}$ be a minimal generator matrix for the
qubit code. We iterate through all GKP-stabilizer generators and check whether
they are already member of the lattice generated by $B$. If not, we append
this generator to the basis and proceed to the next. This algorithm will
terminate once $2n-r$ GKP stabilizer generators are added. Importantly, it
preserves the qubit stabilizers and hence the LDPC property. If the qubit code
had a generating set with maximal weight $w$, the longest basis vector will be
of length $\max\\{\sqrt{{w}/{2}},\sqrt{2}\\}$. Note that the membership test
outlined in Fig. 4, that applies when dealing with rational lattice (in which
case the lattice can be rescaled to integer, such that the HNF is unique), can
be executed in polynomial time. The above procedure can trivially be
generalized to the concatenation of a qubit code with a different single-mode
GKP code. In particular if we use single mode GKP codes that are locally
described by generator matrix $M_{\mathrm{GKP}}$, the algorithm outlined in
Fig. 4 is adapted by iterating through the rows of $M_{\mathrm{GKP}}^{\oplus
n}$ and matching the non-trivial entries in $B_{Q}$ to elements in
$\left(\mathcal{L}\left(M_{\mathrm{GKP}}\right)^{\perp}\right)^{\oplus n}$. A
python implementation of the algorithm can be found under ref. [32].

We conclude this section by noting a practical advantage following from the
existence of minimal bases. In the literature, an error correction cycle for
concatenated GKP codes typically contains two steps: first all single-mode GKP
stabilizers are measured and the state is corrected to the corresponding
sublattice. Then all qubit level stabilizers are measured and the syndrome is
fed to a modified qubit decoder, possibly taking into account the analogue
measurement information. The existence of a minimal set of $2n$ lattice basis
vectors implies that checking whether a given state is a code-state can be
done with only $2n$ measurements. This has to be contrasted with the usual
$2n+n-k$ measurements in typical two-step schemes. Using a minimal basis
foregoes measuring the GKP stabilizers whose eigenvalues are already fixed by
the results on the minimal set, and can thus lead to a reduction of about
$1/3$ in the number of (GKP) ancillas required for an error correction cycle.
Although the eigenvalues of the redundant, unmeasured, GKP stabilizers can be
deduced from the other measurements, in the presence of measurement errors
other strategies might be more effective.

Figure 1: The Surface-17 code with a minimal generating set. Multi qubit
stabilizer generators are indicated in the figure. The minimal number of
additional square-GKP stabilizer are given by
$S^{p}_{i}=e^{-2i\sqrt{\pi}\hat{p}_{i}}$ on the modes labeled by red filled
circles and $S^{q}_{i}=e^{i2\sqrt{\pi}\hat{q}_{i}}$ on the vertices drawn in
blue. It suffices to measure only one type of square GKP generator on most
modes, except for mode 5, where both $S_{5}^{q}$ and $S_{5}^{p}$ need to be
measured. The $\cdot^{\dagger}$’s are chosen such that all qubit stabilizers
commute on the full bosonic Hilbert space [10], i.e. such that
$B_{Q}JB_{Q}^{T}=0$. 44footnotemark: 4We follow the convention for the
stabilizers in ref. [11].

function LatticeCompletion($B_{Q}$)

set $B=B_{Q}$

for $i=1,\dots,2n$ do

if not Member$\left(2\bm{e}_{i}^{T};B\right)$ then

$B\leftarrow\begin{pmatrix}B\\\ \hline\cr 2\bm{e}_{i}^{T}\end{pmatrix}$

end if

end for

Return $\frac{1}{\sqrt{2}}B$

end function

Figure 2: Greedy lattice completion algorithm

function Member($\bm{x};\,B$)

Return $\exists\bm{x}\in\mathbb{Z}^{2n}:\;\bm{x}^{T}B=2\bm{e}_{i}^{T}$

end function

Figure 3: Membership test

function Member($\bm{x};\,B$)

Return $\operatorname{HNF}\begin{pmatrix}B\\\ \hline\cr
2\bm{e}_{i}^{T}\end{pmatrix}=\operatorname{HNF}\left(B\right)$

end function

Figure 4: Membership test (alternative)

##  4 Symplectic equivalence

By definiton of the symplectic Gram matrix, it remains invariant under
symplectic transformations of the GKP code $M\mapsto N=MS^{T}$. Symplectic
transformations are physically implemented by Gaussian unitaries which have a
special role in bosonic quantum information processing, for a number of
reasons, including the fact that they are often the easiest to implement in
the laboratory. As far as error correction is concerned, the fact that they
act linearly on the quadratures implies that potential errors, such as small
displacements on the modes, remain bounded in their amplitude. By construction
of the GKP code, the logical Clifford group can be implemented using only
symplectic transformations.555However, not every symplectic transformation
necessarily corresponds to a Clifford operation on the logical level. Here, we
show that two GKP codes are equivalent under symplectic transformations if and
only if their standard form (introduced below) is equal and show that every
code is symplectically equivalent to a standard form where each stabilizer
acts on a single mode. This is a generalization of the symplectic equivalence
of the square- and hexagonal GKP code noticed in ref. [12]. We say a
symplectic Gram matrix is in standard form if

$A=J_{2}\otimes D,$ (54)

where $D$ is a positive diagonal $n\times n$ integer matrix with non-
increasing diagonal elements. A symplectically integral matrix $A$ can always
be brought into standard form via basis transformation [1].

######  Theorem 2 (Symplectic equivalence).

Let $M,N\,\in\mathbb{R}^{2n\times 2n}$ be generators of full rank lattices
$\mathcal{L}\left(M\right),\,\mathcal{L}\left(N\right)\subset\mathbb{R}^{2n}$
. Without loss of generality, assume the bases $M,N$ are chosen such that
$A_{M}=MJM^{T}=J_{2}\otimes D_{M}$ and $A_{N}=NJN^{T}=J_{2}\otimes D_{N}$ are
in standard form. Then $M=NR^{T}$ for some symplectic matrix $R$ if and only
if $D_{N}=D_{M}=:D$.

###### Proof.

From the definition of $A$ it is clear that $M=NS^{T}$ for some symplectic
$S:S^{T}JS=J$ implies that $A_{N}=A_{M}$ or equivalently $D_{N}=D_{M}$. To
prove the converse, let

$Z:=I_{2}\otimes D^{-\frac{1}{2}},\hskip 14.22636pt\tilde{M}:=ZM,\hskip
14.22636pt\tilde{N}:=ZN.$ (55)

We have

$\tilde{M}J\tilde{M}^{T}=\tilde{N}J\tilde{N}^{T}=J,$ (56)

i.e., both $\tilde{M},\tilde{N}$ are symplectic. Since symplectic matrices are
invertible, we define $R^{T}:=\tilde{N}^{-1}\tilde{M}$ such that
$\tilde{M}=\tilde{N}R^{T}$. $R$ is symplectic since the symplectic group is
closed under transpose and inverse. Left-multiplying by $Z^{-1}$ we obtain
$M=NR^{T}$. ∎

It is important to note that since the symplectic equivalence above is
established using the bases $M,N$ chosen such that $A_{M},A_{N}$ are in
standard form, one needs to be careful in accounting for possible phases in
front of the associated stabilizer operators stemming from the basis
transformation. When the above assumptions of the theorem above are satisfied
we obtain that the stabilizer group $\mathcal{S}\left(N,\,0\right)$ can, by
symplectic transformation $R^{T}$, be transformed into
$\mathcal{S}\left(M,\,\phi_{NR^{T}}\right).$ I.e. code states $\ket{\psi}$ of
the code $\mathcal{S}\left(N,\,0\right)$ can be transformed into states
$U_{R^{-T}}\ket{\psi}$ by means of a Gaussian unitary (see eq. (12)) which are
stabilized by phased displacement operators

$e^{i\phi_{NR^{T}}\left(M_{i}^{T}\right)}D\left(M_{i}^{T}\right),\,i=1,\ldots,2n.$
(57)

Note that phases above are absent in the symplectic transformation between a
single-mode square GKP code and hexagonal GKP code shown in ref. [12], which
is because each of these codes have symplectically even lattices, such that
the overall phase factors are trivial. The same discussion on phase-
assignement is relevant for the application of the following immediate
corollaries.

######  Corollary 1 (Normal form of generators).

Let $M\in\mathbb{R}^{2n\times 2n}$ describe the basis of a full rank lattice
with integral $A=MJM^{T}$. W.l.o.g. assume $M$ is chosen such that
$A=J_{2}\otimes D$ is in standard form. The code specified by the generator

$N_{\square}=\oplus_{j=1}^{n}\sqrt{D_{jj}}I_{2}$ (58)

is symplectically equivalent to the one specified by $M$.

Note that here, we understand the direct sum as happening mode-wise, such that
it corresponds to the usual matrix direct sum if the quadratures are ordered
as $\left(\hat{q}_{1},\hat{p}_{1},\hat{q}_{2},\hat{p}_{2},\ldots\right)$ with
symplectic form $J_{2n}^{\prime}=I_{n}\otimes J_{2}$ but not if they are
ordered as
$\left(\hat{q}_{1},\hat{q}_{2},\ldots,\hat{p}_{1},\hat{p}_{2},\ldots\right)$
in the standard choice $J_{2n}=J_{2}\otimes I_{n}$. This convention will be
understood in the following whenever clear from the context. Note that
$N_{\square}$ is diagonal, so its stabilizers act each on a single quadrature
at a time. Since $N_{\square}$ decomposes into a direct sum over each mode, we
can always prepare a code state of $M$ by locally preparing a code state of
$N_{\square}$ and applying the corresponding symplectic transformation.

The same symplectically equivalent local decomposition can equally be done
using the hexagonal GKP code on each local mode and is based on the fact that
the square and hexagonal GKP code, as scaled GKP codes with scaling factor
$\lambda$, have both $A_{\square}=A=\lambda J_{2}$. Similarly, any other
scaled GKP codes can also be used. This is an example of code switching. Even
more generally, this implies code switching between two GKP codes
$\mathcal{L}\left(M\right)$ and $\mathcal{L}\left(N\right)$ on the same number
of modes is possible whenever $D_{N}=D_{M}$ in their respective standard
bases. Similarly, we can also deduce the following corollary.

######  Corollary 2 (Normal form in prime dimensions).

For $d=|\det(M)|$ prime, the lattice $\mathcal{L}\subset\mathbb{R}^{2n}$ is
symplectically equivalent to a code specified by

$N^{\prime}=\sqrt{d}I_{2}\oplus I_{2}^{\oplus(n-1)},$ (59)

###### Proof.

For a basis of $\mathcal{L}$ in standard form, we have

$d=\prod_{j=1}^{n}D_{j,j}.$ (60)

Since $D$ is a positive integer diagonal matrix, if $d$ is prime, the
eigenvalues of $D$ are uniquely specified by
$D=\operatorname{diag}(d,1,1,\ldots)$ up to permutations. Hence by Theorem 2
we have that $\mathcal{L}$ is symplectically equivalent to the code specified
by eq. (59). ∎

From the proof above one can also see that the number of symplectically
inequivalent classes of codes with given logical dimension $d$ corresponds to
the number of different factorizations of $d$. For example, for two modes
encoding two qubits there are two inequivalent choices:
$D=\mathrm{diag}\left(4,1\right)$ or $D=\mathrm{diag}\left(2,2\right)$,
corresponding to two symplectically inequivalent classes of codes.

##  5 Distance of a GKP code

We need a benchmark to assess how well the logical content of a GKP state is
protected from noise. In qubit codes, a simple standard assumption is that
noise is stochastic i.i.d. for each physical qubit, such that the likelihood
of an error decreases exponentially with its support or weight. This
assumption makes the definition of a code distance as weight of the shortest
non-trivial logical operator meaningful. This model no longer makes sense in
the bosonic setting. In the bosonic setting, a reasonable assumption about the
underlying error model is that weak coupling to the environment results in
effectively small displacements. Concrete examples are loss, thermal noise
[34], and to a limited extent, finite squeezing errors [35, 36, 2]. For
simplicity, we assume a stochastic displacement noise model such that small
displacements are more likely than large displacements, this is in particular
the case for the Gaussian displacement noise model

$\mathcal{N}\left(\rho\right)=\int
d\bm{x}\;P_{\tilde{\sigma}}\left(\bm{x}\right)D\left(\bm{x}\right)\rho
D^{\dagger}\left(\bm{x}\right),\;$ (61)

which we will analyse more in-depth later, where

$P_{\tilde{\sigma}}\left(\bm{x}\right)=G\left[0,\tilde{\sigma}^{2}I_{2n}\right]\left(\bm{x}\right)\propto
e^{-\frac{\|\bm{x}\|^{2}}{2\tilde{\sigma}^{2}}},$ (62)

that displaces the quadratures of the state by some random amplitude drawn
from a centered Gaussian distribution with variance $\tilde{\sigma}^{2}$.
Although this error model is widely used in the analysis of GKP codes [10, 11,
12] for its simplicity, one needs to be careful to note that in real
implementations of GKP error correction, this is not a physically accurate
model [2, 37] in general, but only reproduces the correct measurement
statistics in specific cases in practice, such as when the finite squeezing
error is applied to a perfect GKP state and interpreted as channel or when GKP
states undergo a $0-$photon loss event. The distance measure that we introduce
in the following merely assumes that larger phase-space displacements are more
likely than smaller ones, which is a natural choice and is sufficiently
meaningful to indicate the robustness of the code with respect to realistic
noise sources as also demonstrated in recent experiments [8].

######  Definition 3 (Euclidean distance of a GKP code).

The (euclidean) distance $\Delta$ of a GKP code given by lattice $\mathcal{L}$
is the euclidean length of the shortest non-trivial logical operator, i.e.,

$\Delta=\Delta\left(\mathcal{L}\right):=\min_{0\neq\bm{x}\in\mathcal{L}^{\perp}/\mathcal{L}}\|\bm{x}\|.$
(63)

For CSS GKP codes, i.e., for which we have
$\mathcal{L}=\mathcal{L}_{q}\oplus\mathcal{L}_{p}$ as specified earlier, we
can further distinguish

$\Delta_{q}:=\min_{0\neq\bm{x}\in\mathcal{L}_{p}^{*}/\mathcal{L}_{q}}\|\bm{x}\|,$
(64)
$\Delta_{p}:=\min_{0\neq\bm{x}\in\mathcal{L}_{q}^{*}/\mathcal{L}_{p}}\|\bm{x}\|.$
(65)

###  5.1 Tradeoffs and bounds for GKP codes

Before discussing how the distance of GKP codes can be computed in general, we
present a few results that relate the distance of GKP codes to other code
properties such as number of modes $n$ of the code, the encoded logical
dimension $d=2^{k}$ and size of stabilizers.

######  Lemma 1 (Distance bound).

Remember that $\lambda_{1}\left(\mathcal{L}^{\perp}\right)$ denotes the
shortest non-zero vector in the dual lattice. We have

$\Delta\geq\lambda_{1}\left(\mathcal{L}^{\perp}\right).$ (66)

###### Proof.

Because the lattice vector $0\neq\bm{x}\in\mathcal{L}^{\perp}/\mathcal{L}$ for
which $\|\bm{x}\|$ is minimal is also in $\mathcal{L}^{\perp}$ this holds
trivially. ∎

We have already seen in the previous section that for GKP codes obtained from
scaling a symplectically self-dual lattice
$\mathcal{L}_{0}=\mathcal{L}\left(M_{0}\right)$ to
$\mathcal{L}=\sqrt{\lambda}\mathcal{L}_{0}$ we have

$\Delta_{\mathrm{scaled}}=\lambda_{1}\left(\mathcal{L}^{\perp}\right)=\lambda^{-\frac{1}{2}}\lambda_{1}\left(\mathcal{L}_{0}\right),$
(67)

so the distance decreases while the size of the stabilizers and number of
encoded logical dimensions increases. In particular, scaled codes are not
straightforwardly scalable in the sense that we cannot increase the distance
by adding generators while keeping the encoded logical dimensions fixed. It
has been shown [38], however (see also ref. [13]), that symplectically self
dual lattices in $\mathbb{R}^{2n}$ with $\lambda_{1}\geq 2\sqrt{\frac{n}{\pi
e}}$ exist, implicating that it is possible to find sequences of codes that
can be scaled to _achieve_ rates $R=\log_{2}{\lambda}$,

$\lambda=\lfloor\frac{\hbar}{2\tilde{\sigma}^{2}}\rfloor$ (68)

for transmission through stochastic Gaussian displacement channels with
variance $\tilde{\sigma}^{2}$ [14]. On the other hand, for the concatenation
of a single mode GKP code into a $[\\![n,k,d]\\!]$ qubit quantum error
correcting code, we have

$\Delta_{\text{conc}}\geq\sqrt{d}\Delta_{\text{loc}},$ (69)

where $\Delta_{\text{loc}}$ is the distance of the local single mode GKP
codes, such as $\Delta_{\square}=2^{-\frac{1}{2}}$ for the square GKP code or
$\Delta=3^{-\frac{1}{4}}$ for the hexagonal GKP code. Equality in eq. (69)
holds when the code we consider is CSS or the local code is the hexagonal GKP
code (such that all shortest non-trivial logical vectors have the same
distance). Eq. (69) is verified by decomposing a shortest representative non-
trivial logical vector $\bm{L}=\oplus_{i=1}^{n}\bm{l}_{i}$ into $n$ local sub-
blocks, where $\bm{l}_{i}$ is a logical operator of the respective local code,
such that we have $\|\bm{L}\|^{2}\geq d\Delta_{\text{loc}}^{2}$.

The distance of a concatenated code is typically strictly larger than
$\lambda_{1}\left(\mathcal{L}^{\perp}\right)$, because the shortest dual
vectors would correspond to stabilizer displacements, in particular if the
input qubit stabilizer code is LDPC . This is e.g. the case for the
concatenation of the square GKP code with surface-17 (see Fig. 4), where we
have $\Delta=\sqrt{{3}/{2}}$, while
$\lambda_{1}\left(\mathcal{L}^{\perp}\right)=\lambda_{1}\left(\mathcal{L}\right)=1$.

The length of the shortest vector in a lattice
$\lambda_{1}\left(\mathcal{L}\right)$ is the first of $2n$ successive minima
of the lattice. Generally, the $i$th successive minimum
$\lambda_{i}\left(\mathcal{L}\right),\,i\leq 2n$ is defined to be the smallest
$r>0$, such that $\mathcal{L}$ contains $i$ linearly independent vectors of
length at most $r$. It holds that
$\mu\left(\mathcal{L}\right)\geq{\lambda_{2n}\left(\mathcal{L}\right)}/{2}$,
where $\mu\left(\mathcal{L}\right)$ is the covering radius of the lattice
$\mathcal{L}$, i.e., the minimum radius $\mu$, such that the union of closed
balls $\mathcal{B}_{\mu}\left(\bm{x}\right),\,\bm{x}\in\mathcal{L}$ centred
around each lattice point of $\mathcal{L}$ cover the entire space
$\mathbb{R}^{2n}$. A related quantity is the packing radius of the lattice
$\rho\left(\mathcal{L}\right)={\lambda_{1}\left(\mathcal{L}\right)}/{2}$.
Successive minima of the direct and dual lattice $\mathcal{L}^{*}$ are related
by so-called transference theorems, in particular we have

$\displaystyle
1\leq\lambda_{1}\left(\mathcal{L}\right)\lambda_{2n}\left(\mathcal{L}^{*}\right)\leq
2n.$ (70)

We have noticed earlier that $\mathcal{L}^{\perp}$ and $\mathcal{L}^{*}$
differ only by an orthogonal transformation, therefore it holds that

$\lambda_{i}\left(\mathcal{L}^{\perp}\right)=\lambda_{i}\left(\mathcal{L}^{*}\right)$
(71)

and we can apply eq. (70) to relate the distance to the length of stabilizer
vectors.

######  Theorem 3 (Distance bound).

For a GKP code with lattice $\mathcal{L}$, distance $\Delta$ and maximal
length $C$ of a basis vector for a fixed basis $M$ we have

$\Delta\geq\lambda_{1}\left(\mathcal{L}^{\perp}\right)\geq\lambda_{2n}^{-1}\left(\mathcal{L}\right)\geq
C^{-1},$ (72)

as well as

$\Delta\leq\lambda_{2n}\left(\mathcal{L}^{\perp}\right)\leq\frac{2n}{\lambda_{1}\left(\mathcal{L}\right)}.$
(73)

###### Proof.

The first bound follows immediately from Lemma 1 and eq. (70) by swapping the
roles of $\mathcal{L}^{\perp}$ and $\mathcal{L}$, which is possible because
$\left(\mathcal{L}^{\perp}\right)^{\perp}=\mathcal{L}$ and further from
$C\geq\lambda_{2n}\left(\mathcal{L}\right)$. Similar for the second bound. ∎

These bounds indicate an intimate relation between the lengths of the
stabilizers in $\mathcal{L}$ and the distance of the GKP code, which we will
expand on further in the next section.

###  5.2 Symplectic transformations

It is interesting to study how symplectic transformations change the code
distance. In particular, since we have seen in Theorem 2 that GKP codes with
equal standard form are symplectically equivalent, it is possible that for
specific noise models a symplectic transformation of the stabilizers $M\mapsto
MS^{T}$ can be used to improve the codes resilience to noise. It is clear that
orthogonal (symplectic) transformations $S$ satisfying $S^{T}S=I$ leave the
distance invariant.

This is not the case for squeezing. In particular if we consider a uniform
squeeze

$S=\eta I_{n}\oplus\eta^{-1}I_{n},\quad\eta\in(0,\infty)$ (74)

applied to a CSS code, we have

$\Delta_{q}\mapsto\Delta_{q,\eta}=\eta^{-1}\Delta_{q},\hskip
28.45274pt\Delta_{p}\mapsto\Delta_{p,\eta}=\eta\Delta_{p},$ (75)

so that we can adapt the squeezing to account for potential bias in the noise,
e.g. when

$P\left(\bm{x}\right)=G[0,\tilde{\sigma}^{2}\left(\eta^{-1}I_{n}\oplus\eta
I_{n}\right)]\left(\bm{x}\right).$ (76)

For concatenated CSS GKP codes, we generally have

$\Delta_{q}=\sqrt{d_{Z}}\Delta_{q,\mathrm{loc}},\hskip
28.45274pt\Delta_{p}=\sqrt{d_{X}}\Delta_{p,\mathrm{loc}},$ (77)

such that squeezing the local codes by $\eta$ is equivalent to increasing
(decreasing) the upper level $X/Z-$ distances $d_{X/Z}$ by a factor of
$\eta^{2}$. On the other hand, for natively unbiased noise it is also possible
to squeeze the local code and employ a qubit quantum error correcting codes
tailored towards biased noise such that $\Delta_{q}=\Delta_{p}$ remains
constant. Although such a setup leaves the distance invariant, it can still
lead to improvements in the error correction procedure when dedicated decoders
for the qubit error correcting codes are used, as was recently demonstrated in
ref. [12].

Corollary 2 can also be used to derive an upper bound on the distance of a
given code from symplectic equivalence as follows. Let us first consider a
code $\mathcal{L}$ with generator $M$, encoding a single qubit within $n$
modes. Suppose $M$ is in canonical form, such that

$A=MJM^{T}=J_{2}\otimes D\;\mathrm{with}\quad
D=\mathrm{diag}\left\\{2,1,\ldots,1\right\\}.$ (78)

Corollary 2 implies that there exists a symplectic matrix $S$ such that
$M=N_{\square}S^{T}$ with $N_{\square}$ the generator of the code in the
corollary with logical dimension two. Since $N_{\square}$ is diagonal, the
corresponding lattice $\mathcal{L}_{\square}$ is trivially orthogonal, and so
is the dual $\mathcal{L}_{\square}^{\perp}$. The shortest non-trivial logical
operators are thus immediately found as
$\bm{\eta}_{\square,1}^{T}=\left(1/\sqrt{2},\bm{0}_{2n-1}^{T}\right)$ and
$\bm{\eta}_{\square,2}^{T}=\left(0,-1/\sqrt{2},\bm{0}_{n-2}^{T},\right)$. We
can now recall that commutation relations for the displacements are related to
symplectic products of the corresponding phase space vectors and that $S$
preserves symplectic products. Hence the transformation $S$ maps all points in
$\mathcal{L}^{\perp}_{\square}$ that correspond to stabilizers,
$\bm{x}\in\mathcal{L}_{\square}\subset\mathcal{L}^{\perp}_{\square}$, to
direct lattice points $S\bm{x}\in\mathcal{L}$, which are stabilizers of
$\mathcal{L}$, and all non-trivial logical operators to non-trivial logical
operators. Therefore, we can readily write down two logical operators,
$\bm{\eta}_{1},\bm{\eta}_{2}\in\mathcal{L}^{\perp}\setminus\mathcal{L}$, as
$\bm{\eta}_{j}=S\bm{\eta}_{\square,j}$ whose lengths are

$\left|\left|\bm{\eta}_{j}\right|\right|=\left|\left|S\bm{\eta}_{\square,j}\right|\right|\geq\Delta.$
(79)

Note that the bound is not necessarily tight. One can further relate the
distance to the _squeezing_ contained in $S$. Applying the Bloch-Messiah or
Euler decomposition [39] we can write $S=R_{2}KR_{1}$ with $R_{j}$ symplectic
orthogonal matrices and
$K=\mathrm{diag}\left\\{k_{1},\ldots,k_{n},1/k_{1},\ldots,1/k_{n}\right\\}$
with $k_{l}\in(0,\infty)$ denoting an effective squeezing operation. Similar
to ref. [15], we denote by
$\mathtt{sq}\left(S\right)=\sqrt{\mathrm{EV}_{max}\left(S^{T}S\right)}$ the
root of largest eigenvalue of $S^{T}S$, or equivalently, the largest squeezing
factor in the Bloch-Messiah decomposition of the associated symplectic matrix.
Finally, we obtain

$\Delta\leq\|S\bm{\eta}_{\square,j}\|\leq\|K\|\|\bm{\eta}_{\square,j}\|=\frac{1}{\sqrt{2}}\mathtt{sq}\left(S\right).$
(80)

The bound presented above generalizes straightforwardly to codes with higher
logical dimension, such that we obtain the following bound.

######  Theorem 4 (Squeezing bound to the distance).

Let $\mathcal{L}=\mathcal{L}\left(M\right)$ specify a GKP code with symplectic
Gram matrix $A=J_{2}\otimes D$ in its canonical form. Further let $S$ denote
the symplectic matrix that transforms between $M$ and the generator
$N_{\square}$ as specified in Corollary 2. We have

$\Delta\leq\sqrt{\max_{j}D_{j,j}}^{-1}\mathtt{sq}\left(S\right).$ (81)

This bound is interesting since it, similar to the bound presented in ref.
[15], bounds a benchmark for error correcting capabilities of a code by the
squeezing measure of the Gaussian unitary necessary to prepare the code state.
In ref. [15] that bound implies a no-go theorem on the existence of thresholds
for oscillator into (many-) oscillator codes by the assumption that the
squeezing measure $\mathtt{sq}\left(S\right)$ is naturally bounded. Here, it
is already known that code families with increasing distance exist, e.g.,
given by concatenation of single mode GKP codes with the surface code which
have distance scaling as $\Delta\propto n^{1/4}$, where $n$ is the number of
modes. The crucial difference between our scenarios is, however, that ref.
[15] focuses on the channel coding setup such that each code state necessarily
is prepared by a Gaussian unitary encoding channel, while in the general
quantum error correction setting such as considered here, code states can be
formed by measurements of stabilizers (possibly of a LDPC code) and correction
via application of displacement operators, forgoing the absolute constraint
posed by the squeezing measure. Similar to the argument in ref. [15], Theorem
4, however, does restrict the possible effective protection a code state
prepared via a Gaussian unitary acting on code states obtained from the
associated normal form as in Corollary 2. Finally, it is worth mentioning
that, by the Bloch-Messiah decomposition, a non-trivial squeezing content
$\mathtt{sq}\left(S\right)$ as specified in Theorem 4 is a necessary
ingredient to obtain codes with non-orthogonal lattices and, effectively, non-
trivial distance scaling.

###  5.3 Computing the distance

In general, computing the distance of a GKP code given only the lattice
$\mathcal{L}$ or a corresponding basis $M$ is computationally hard. Given a
non-trivial logical displacement $\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}$, a
candidate for the distance is computed by fully reducing $\bm{\xi}^{\perp}$
with respect to the lattice $\mathcal{L}$, that is one needs to find the
length of the shortest representative of $\bm{\xi}^{\perp}$ modulo the lattice
$\mathcal{L}$. Equivalently, it is necessary to solve the optimization-closest
vector problem (optCVP) defined as

$\operatorname{optCVP}\left(\bm{x},\mathcal{L}\right):=\min_{\bm{\xi}\in\mathcal{L}}\|\bm{x}-\bm{\xi}\|=\operatorname{dist}\left(\bm{x},\mathcal{L}\right).$
(82)

A related problem is the (search) closest vector problem (CVP) that aims at
identifying the closest lattice vector to the input

$\operatorname{CVP}\left(\bm{x},\mathcal{L}\right):=\operatorname*{arg\,min}_{\bm{\xi}\in\mathcal{L}}\|\bm{x}-\bm{\xi}\|,$
(83)

which given inputs $\bm{\xi}^{\perp}$ and $\mathcal{L}$, outputs the shortest
representative of $\bm{\xi}^{\perp}$. These problems are known to be NP-hard.
Naively, one may be tempted to try to identify the shortest logical vectors by
going through the rows of $M^{\perp}_{i}=\bm{\xi}^{\perp\,T}_{i}$ and rounding
it element-wise to the closest element in $\mathcal{L}$, i.e.

$\left(\bm{\xi}^{\perp}_{i}/M\right)^{T}=\bm{\xi}^{\perp\,T}_{i}-\lfloor\bm{\xi}^{\perp\,T}_{i}M^{-1}\rceil
M,$ (84)

where $\lfloor x\rceil$ denotes the closest integer to $x$, 666acting element-
wise in other words identifying the shortest logical representatives with non-
zero rows of

$M^{\perp}/M=M^{\perp}-\lfloor M^{-T}J^{-1}M^{-1}\rceil M=M^{\perp}-\lfloor
A^{-1}\rceil M=\left(I-\lfloor A^{-1}\rceil A\right)M^{\perp}.$ (85)

Indeed, we have found numerically for the concatenated GKP code built on
Surface-17 with $M$ given in its HNF that this rounding method outputs the
shortest logical representatives. This is, however, a lucky coincidence. It is
known that the rounding method for solving CVP [40] perform poorly in general
and only returns an accurate solution if the lattice basis is sufficiently
well-behaved, e.g. when the rows of $M$ are orthogonal. This is consistent
with the fact that in general the solution of CVP is also hard to approximate
better than up to an exponential factor in the dimension. In addition, it is
not a priori granted that the basis for the symplectic dual $M^{\perp}$
consists of those vectors that correspond to the shortest logical
displacements only up to stabilizers. Hence while this method allows to upper
bound the distance $\Delta$ of a general GKP code by

$\Delta\leq\tilde{\Delta}:=\min_{i}\|\left(M^{\perp}/M\right)_{i}\|,$ (86)

the r.h.s. is not guaranteed to yield an accurate estimate of the code
distance. Here, we propose a different strategy to compute the distance that
is feasible in particular for scaled GKP codes and concatenated codes. We
introduce the theta function of a lattice [16]

$\Theta_{\mathcal{L}}(z)=\sum_{\bm{x}\in\mathcal{L}}q^{\bm{x}^{T}\bm{x}}=\sum_{\delta\in\mathcal{D}}N_{\delta}q^{\delta},$
(87)

where $q=e^{i\pi z}$.
$\mathcal{D}=\left\\{\|\bm{x}\|^{2}_{2},\,\bm{x}\in\mathcal{L}\right\\}$ is
the set of squared distances of $\mathcal{L}$. We have also introduced the
number of lattice vectors of a given length

$N_{\delta}=\\#\left\\{\bm{x}\in\mathcal{L}:\,\bm{x}^{T}\bm{x}=\delta\right\\}.$
(88)

For integral lattices, i.e., when the corresponding (euclidean) Gram matrix
satisfies $G=MM^{T}\in\mathbb{Z}^{2n\times 2n}$, we can set
$\mathcal{D}=\mathbb{N}$ and $N_{m}$ is given by the number of integer
solutions $\bm{n}\in\mathbb{Z}^{2n}$ to the equation $\bm{n}^{T}G\bm{n}=m$,
which is an example of a Diophantine equation. We call the pair
$(\mathcal{D},N_{\delta})$ the distance distribution of the lattice
$\mathcal{L}$. The theta function converges and is holomorphic for
$\operatorname{Im}(z)>0$. The first summands are given by

$\Theta_{\mathcal{L}}(z)=1+\tau q^{\lambda_{1}}+\ldots,$ (89)

where $\lambda_{1}=\lambda_{1}\left(\mathcal{L}\right)$ is the length of the
shortest vector of the lattice and $\tau$ is known as the kissing number, the
number of minimal-length vectors of $\mathcal{L}$. It is known that the theta
function for the (euclidean) dual of a lattice
$\mathcal{L}\subset\mathbb{R}^{2n}$ is given by

$\Theta_{\mathcal{L}^{*}}(z)=\det\left(\mathcal{L}\right)\left(\frac{i}{z}\right)^{n}\Theta_{\mathcal{L}}\left(-\frac{1}{z}\right),$
(90)

which follows from the Poisson summation formula (see also ref. [41]). In
particular, since we have seen that $\mathcal{L}^{*}$ and
$\mathcal{L}^{\perp}$ only differ by an orthogonal transformation, which does
not change the length of lattice vectors, and hence the theta function, we
also have

$\Theta_{\mathcal{L}^{\perp}}(z)=\Theta_{\mathcal{L}^{*}}(z),$ (91)

such that we can immediately obtain the theta function of
$\mathcal{L}^{\perp}$ whenever the the theta function of the direct lattice
$\Theta_{\mathcal{L}}(z)$ is known. By definition of the theta function, the
distance of a GKP code specified by $\mathcal{L}$ is given by the smallest
non-zero power of $q$ in

$Q_{\mathcal{L}}(z):=\Theta_{\mathcal{L}^{\perp}}(z)-\Theta_{\mathcal{L}}(z)=N_{\Delta^{2}}q^{\Delta^{2}}+\ldots,$
(92)

and furthermore since we have that $\Theta_{\mathcal{L}}(z)$ is uniquely
determined by the distance distribution $(\mathcal{D},N_{\delta})$ of
$\mathcal{L}$, which by eq. (90) also fully specifies
$\Theta_{\mathcal{L}^{\perp}}(z)$. Note that $Q_{\mathcal{L}}(z)>0$ since
$\mathcal{L}\subseteq\mathcal{L}^{\perp}$. We arrive at the following insight.

######  Theorem 5 (Code distance is specified by the distance distribution).

The distance of a GKP code specified by $\mathcal{L}$ is uniquely determined
by its distance distribution $(\mathcal{D},N_{\delta})$.

The theta function of a scaled lattice is

$\Theta_{\sqrt{\lambda}\mathcal{L}_{0}}(z)=\Theta_{\mathcal{L}_{0}}(\lambda
z).$ (93)

Many expressions of theta functions of symplectically self dual lattices, in
particular those that also correspond to euclidean self-dual lattices are
known in the literature [16] such that their corresponding distances can e.g.
be estimated from a logarithmic fit for small $q\ll 1$ of eq. (92), or by
expressing $Q$ in a basis for which the distance distribution is known. We
have verified that this method works numerically for some small examples
including single mode scaled codes and the concatenated GKP-repetition code
using the weight-distribution as outlined below.

For concatenated (square) GKP codes, where $\mathcal{L}=\Lambda\left(Q\right)$
is given by a Construction A lattice, we can express the theta function using
the weight enumerator. We first introduce the weight distribution of a linear
code $Q$, which is given by the numbers $\left\\{A_{i}\right\\}_{i=0}^{2n}$ of
codewords $q$ in $Q\subset\mathbb{Z}_{2}^{2n}$ with Hamming weight
$\operatorname{wt}(q)=i$. Crucially, the weight distribution
$\left\\{A_{i}\right\\}_{i=0}^{2n}$ here refers to the Hamming-weight
distribution of the symplectic representation of the qubit stabilizers. The
weight enumerator is given by

$W_{Q}\left(x,y\right)=\sum_{q\in
Q}x^{2n-\operatorname{wt}(q)}y^{\operatorname{wt}(q)}=\sum_{i=0}^{2n}A_{i}x^{2n-i}y^{i}.$
(94)

Using this definition, we can express the theta function of a construction A
lattice [16] by straightforward computation

$\Theta_{\Lambda(Q)}=W_{Q}\left(\theta_{3}(2z),\theta_{2}(2z)\right),$ (95)

where

$\displaystyle\theta_{3}(z)$
$\displaystyle=\Theta_{\mathbb{Z}}(z)=\sum_{m\in\mathbb{Z}}q^{m^{2}},$ (96)
$\displaystyle\theta_{2}(z)$
$\displaystyle=\Theta_{\mathbb{Z}+\frac{1}{2}}(z)=\sum_{m\in\mathbb{Z}}q^{\left(m+\frac{1}{2}\right)^{2}}.$
(97)

Since we see that we can find the theta function of a Construction A lattice
corresponding to a concatenated code by means of the (Hamming) weight
distribution of its (qubit) stabilizer group, we have similar to Theorem 5 and
by eq. (69),

######  Corollary 3 (Distance of CSS qubit stabilizer code from weight
distribution ).

The distance $d$ of a CSS qubit stabilizer code is fully determined by the
weight distribution $\left\\{A_{i}\right\\}_{i=0}^{2n}$ of its stabilizers.

We note that this corollary also follows from a quantum version of the weight
enumerators defined by Shor and Laflamme [17] and Rains [18], which through
their immediate relationship to the Quantum error correction conditions [42]
impose strong restrictions on possible quantum error correcting codes.
Generally, when $\mathcal{L}$ is integral (rational),
$\Theta_{\mathcal{L}}\left(z\right)$ is a modular form777if the lattice can be
scaled to be integral, we consider the scaled version before doing the
analysis and scale back accordingly afterwards., i.e., it remains invariant
under certain Möbius transformations

$z\mapsto\frac{az+b}{cz+d}$ (98)

and as a result can be expressed in a finite basis depending on the specific
symmetry group of the theta function [43, 41, 16]. This avenue is interesting
for the explicit computation of distances but extends beyond the scope of the
present article. We thus defer further analysis of a modular forms approach to
finding distances to future work.

##  6 Maximum likelihood decoding GKP codes

In this section, we discuss active quantum error correction and _maximum
likelihood decoding (MLD)_ for general GKP codes using the tools discussed in
this work. The introduction to MLD follows closely the discussion in ref.
[10]. We assume a stochastic Gaussian displacement noise channel as specified
in eq. (61) with variance $\tilde{\sigma}^{2}$. For comparison with the
literature, when the displacement operators are defined by a more “standard”
convention without the overall constant $\sqrt{2\pi}$, this corresponds to a
physical variance of $\sigma^{2}=2\pi\tilde{\sigma}^{2}$. Upon sampling an
error $\bm{e}$ and measuring the stabilizers, a syndrome vector of the form

$\bm{s}(\bm{e})=MJ\bm{e}\mod 1$ (99)

is obtained as the phases of the eigenvalues of the stabilizer generators
$\left\\{D\left(M_{i}^{T}\right)\right\\}_{i=1}^{2n}$ when acting on a code
state vector $\ket{\psi}$ displaced by an error vector $\bm{e}$,

$D\left(M_{i}^{T}\right)D\left(\bm{e}\right)\ket{\psi}=e^{i2\pi
M_{i}J\bm{e}}D\left(\bm{e}\right)\ket{\psi},$ (100)

where $M_{i}=\bm{\xi}_{i}^{T}$ is the i’th row of $M$.

Since we are dealing with full rank lattices, given the syndrome, we can
assign a pure error

$\bm{\eta}(\bm{s})=(MJ)^{-1}\bm{s}$ (101)

that has the same syndrome $\bm{s}$ as $\bm{e}$ as “initial guess” for the
correction. The net displacement of amplitude $\bm{e}-\bm{\eta}$ is
necessarily in the dual lattice, and hence maps the code space to itself, but
it may be logically non-trivial. It might thus be necessary to modify the
initial guess by a logical vector (leaving the syndrome invariant), such that
$\bm{e}-\bm{\eta}$ is a stabilizer. Note that any $\bm{\eta}+\bm{l}$ with
$\bm{l}\in\mathcal{L}^{\perp}$ will lead to the same syndrome, so the choice
of the additional logical displacement cannot be inferred from the syndrome
alone. Rather, it is necessary to take the noise model into account.

To find the appropriate logical post-correction, for every
$\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}/\mathcal{L}$ we evaluate the
probabilities that, given syndrome $\bm{s}$, the actual error is stabilizer
equivalent to $\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}$, which is given by

$P([\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}]|\bm{s})=P^{-1}(\bm{s})\sum_{\bm{\xi}\in\mathcal{L}}P_{\tilde{\sigma}}(\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}+\bm{\xi}),$
(102)

where
$\left[\bm{x}\right]=\left\\{\bm{x}+\bm{\xi},\bm{\xi}\in\mathcal{L}\right\\}$
and $P_{\tilde{\sigma}}$ is as specified in eq. (61). This can be rewritten as

$\displaystyle P([\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}]|\bm{s})$
$\displaystyle=P^{-1}(\bm{s})\sum_{\bm{\xi}\in\mathcal{L}+\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}}P_{\tilde{\sigma}}(\bm{\xi})$
(103)
$\displaystyle=\sqrt{2\pi\tilde{\sigma}^{2n}}^{-1}P^{-1}(\bm{s})\Theta_{\mathcal{L}+\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}}\left(\frac{i}{2\pi\tilde{\sigma}^{2}}\right),$
(104)

proportional to the theta series of the packing
$\mathcal{P}=\mathcal{L}+\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}$ evaluated in
$z=\frac{i}{2\pi\tilde{\sigma}^{2}}$ 888 $\mathcal{P}$ as the translate of a
lattice $\mathcal{L}$ is formally not a lattice, in particular $\mathcal{P}$
may not contain the origin. . Let
$\left(\tilde{\mathcal{D}},\,N_{\tilde{\delta}}\right)$ denote the distance
distribution of $\mathcal{P}$. We can write the coset probabilities above in a
small error or “low temperature expansion”. 999Note that in contrast to the
usual literature we do not distinguish a Nishimori line, such that these are
the same things.

$\Theta_{\mathcal{L}+\bm{\eta}(\bm{s})+\xi^{\perp}}\left(\frac{i}{2\pi\tilde{\sigma}^{2}}\right)=\sum_{\tilde{\delta}\in\tilde{\mathcal{D}}}N_{\tilde{\delta}}q^{\tilde{\delta}}.$
(105)

evaluated at $q=\exp\left(-1/2\tilde{\sigma}^{2}\right)$. Finally, MLD
decoding is implemented by applying the total correction

$\overline{\bm{\eta}}=\bm{\eta}(\bm{s})+\operatorname*{arg\,max}_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}/\mathcal{L}}P([\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}]|\bm{s}).$
(106)

Methods to evaluate or sample the theta function of a lattice have been
discussed in the literature [43]. Here, we find that, given an algorithm that
reliably estimates the theta function of a packing, we can also approximately
solve MLD decoding.

#### Minimum energy decoding (MED).

In the limit $\tilde{\sigma},q\rightarrow 0$ the sum (105) becomes sharply
distributed around solutions with minimal $\tilde{\delta}$. That is, the bulk
of the sum (105) is determined by

$\operatorname*{arg\,min}_{\xi\in\mathcal{L}}\|\xi+\bm{\eta}(\bm{s})+\xi^{\perp}\|.$
(107)

The MLD correction then becomes

$\displaystyle\overline{\bm{\eta}}$
$\displaystyle=\bm{\eta}(\bm{s})+\operatorname*{arg\,min}_{\xi^{\perp}\in\mathcal{L}^{\perp}/\mathcal{L}}\;\min_{\xi\in\mathcal{L}}\|\bm{\eta}(\bm{s})+\xi^{\perp}+\xi\|$
(108)
$\displaystyle=\bm{\eta}(\bm{s})+\operatorname*{arg\,min}_{\xi^{\perp}\in\mathcal{L}^{\perp}}\|\bm{\eta}(\bm{s})+\xi^{\perp}\|$
(109)
$\displaystyle=\bm{\eta}(\bm{s})-\operatorname*{arg\,min}_{\xi^{\perp}\in\mathcal{L}^{\perp}}\|\bm{\eta}(\bm{s})-\xi^{\perp}\|.$
(110)

The last line Eq (110) shows that this immediate version of MED requires
solving CVP on the lattice $\mathcal{L}^{\perp}$. In the special case of a
concatenated code, $\mathcal{L}=\Lambda\left(Q\right)$, we have that
$\mathcal{L}_{\mathrm{GKP}}:=\left\\{\bm{x}:\,\sqrt{2}\bm{x}\mod 2=0\right\\}$
with generator matrix $M_{\mathrm{GKP}}=\sqrt{2}I_{2n}$ is a sublattice of
$\mathcal{L}$ and its dual contains
$\mathcal{L}^{\perp}\subseteq\mathcal{L}_{\mathrm{GKP}}^{\perp}$. In the
literature, a common approach to solve MLD for concatenated GKP codes is to
apply the above outlined CVP decoder to the superlattice
$\mathcal{L}_{\mathrm{GKP}}^{\perp}$, which leaves a net qubit level syndrome
to be decoded with a standard qubit decoder [12, 11, 10]. Solving CVP on
$\mathcal{L}_{\mathrm{GKP}}^{\perp}$ is easy since it is an orthogonal lattice
and one can straightforwardly apply the rounding trick outlined in the
previous section. However, as we see below in such a two-step approach the
initial guess for the correction on the sublattice
$\mathcal{L}_{\mathrm{GKP}}$ is arbitrary.

#### MLD decoding concatenated codes.

For concatenated (square) GKP codes, we dissect the initial correction in two
components

$\bm{\eta}(\bm{s})=\bm{\eta}^{\mathrm{GKP}}+\bm{\eta}^{Q},$ (111)

such that

$\bm{\eta}^{\mathrm{GKP}}=(M_{GKP}J)^{-1}\bm{s}_{\mathrm{GKP}}$ (112)

reproduces the syndrome detected by the single-mode GKP stabilizers
$\mathcal{L}_{\mathrm{GKP}}$ and
$\bm{\eta}^{Q}\in\mathcal{L}_{\mathrm{GKP}}^{\perp}=\mathbb{Z}^{2n}/\sqrt{2}$
is such that the composite initial guess is consistent with the overall
syndrome. For notational clarity we suppress the explicit dependency on the
syndrome $\bm{s}$. The relevant theta function evaluates to

$\Theta_{\mathcal{L}+\bm{\eta}(\bm{s})+\bm{\xi}^{\perp}}\left(z\right)=\sum_{\bm{x}\in
Q}\prod_{i=1}^{2n}\sum_{v_{i}\in\mathbb{Z}}q^{\left[\left(\bm{x}+\sqrt{2}\bm{\eta}^{\mathrm{GKP}}+\sqrt{2}\bm{\eta}^{Q}+\sqrt{2}\bm{\xi}^{\perp}\right)_{i}+2v_{i}\right]^{2}},$
(113)

where we see that we can w.l.o.g. reduce
$\bm{\eta}^{Q},\bm{\xi}^{\perp}\in\frac{1}{\sqrt{2}}\mathbb{Z}_{2}^{2n}$ and
consider the sum in the exponent
$\bm{x}+\sqrt{2}\bm{\eta}^{Q}+\sqrt{2}\bm{\xi}^{\perp}$ to be carried out
modulo $2$. 101010Any other choice just permutes the sum. We interpret the
individual terms

$f\left(b_{i}|\eta^{\mathrm{GKP}}_{i}\right)\equiv\sum_{v_{i}\in\mathbb{Z}}q^{\left(\sqrt{2}\eta^{\mathrm{GKP}}_{i}+b_{i}+2v_{i}\right)^{2}}=e^{-\frac{1}{2\tilde{\sigma}^{2}}\left(\sqrt{2}\eta^{\mathrm{GKP}}_{i}+b_{i}\right)^{2}}\theta_{3}\left(\frac{i}{\tilde{\sigma}^{2}}\left(\sqrt{2}\eta^{\mathrm{GKP}}_{i}+b_{i}\right)\Big{|}\frac{2i}{\pi\tilde{\sigma}^{2}}\right)$
(114)

as proportional to an indicator for the likelihood of a local bit value
$b_{i}=x_{i}+\sqrt{2}\eta_{i}^{Q}+\sqrt{2}\xi_{i}^{\perp}\in\mathbb{Z}_{2}^{2n}$
where we have used the definition

$\theta_{3}\left(\xi|z\right)=\sum_{m\in\mathbb{Z}}e^{2mi\xi+\pi izm^{2}},\,\
\operatorname{Im}(z)>0.$ (115)

Overall, eq. (113) can then be rewritten as

$\Theta_{\mathcal{L}+\bm{\eta}(\bm{s})+\xi^{\perp}}\left(\frac{i}{2\pi\tilde{\sigma}^{2}}\right)=\sum_{\bm{x}\in
Q}\prod_{i=1}^{2n}f\left(b_{i}|\eta^{GKP}_{i}\right),$ (116)

reproducing a form for the MLD probability similar to those provided in ref.
[12] for the surface-GKP code. It is clear that this derivation can be carried
out similarly for the concatenation with other single-mode GKP codes or more
general codes, such as those derived from glued lattices discussed in the next
section. The MLD probability in eq. (116) can be expressed using a local
tensor network whenever the underlying qubit code is LDPC as has been
demonstrated in refs. [44, 12]. Although qualitatively similar, the effective
local error probabilities in this formulation are not exactly the same as in
refs. [11, 12] since normalization constants
$\sum_{b_{i}\in\mathbb{Z}_{2}}f\left(b_{i}|\eta^{\mathrm{GKP}}_{i}\right)$
cannot be immediately pulled in from the global normalization $P(s)$ below
each $f\left(b_{i}|\eta^{GKP}_{i}\right)$ term. Besides the generality of this
formulation of the MLD for GKP codes, it would be interesting to test whether
it also provides a quantitative advantage in decoding. We examine this
question more in-depth in a forthcoming publication.

##  7 Other constructions of GKP codes

In this section we present two constructions of GKP codes that go beyond the
scaled and concatenated GKP codes that are based on lattice glueing and the
lattice tensor product. We expect that such alternative constructions allow
for more flexibility in designing codes in the future, in particular when
noise varies in strength for different modes or when no physical locality
restrictions are present such as in photonic architectures. The following
constructions are adapted from the discussion of glued (euclidean) lattices
and the lattice tensor product in refs. [16, 45].

###  7.1 Glued codes beyond concatenation

We can understand concatenated GKP codes as GKP codes built on certain types
of glued lattices, which include those obtained through Construction A. Here,
we give a brief overview of glueing theory for symplectic lattices, leaning on
the description in ref. [16]. We begin by dissecting a (glued) symplectic
lattice with symplectic sublattice in a top-down approach to understand its
structure and then move to a bottom-up approach to construct a glued lattice
from a base lattice by appending an appropriate glue group. Let us assume that
we have a $2n-$dimensional symplectic lattice $\mathcal{L}$ that has a
(symplectic) sublattice $\mathcal{L}_{0}$ with direct sum structure

$\mathcal{L}_{0}=\bigoplus_{i=1}^{k}\mathcal{L}_{i}.$ (117)

Vectors $\bm{v}\in\mathcal{L}$ can be written as

$\bm{v}=\sum_{i}\bm{v}_{i},$ (118)

where $\bm{v}_{i}\in\mathbb{R}\otimes\mathcal{L}_{i}$. The symplectic inner
product of any $\bm{v}_{i}$ with any vector of $\mathcal{L}_{i}$ is integer,
such that it can be concluded that $\bm{v}_{i}\in\mathcal{L}_{i}^{\perp}$.
Moreover we can add to any $\bm{v}_{i}$ a vector from $\mathcal{L}_{i}$
without changing the fact that $\bm{v}$ has integer symplectic inner product
with any other vector of $\mathcal{L}$. It hence suffices to demand
$\bm{v}_{i}\in\mathcal{L}_{i}^{\perp}/\mathcal{L}_{i}$. Such vectors are
called glue vectors for $\mathcal{L}_{i}$, which in the coding language
correspond to logical representatives of a local code.
$\mathcal{L}_{i}^{\perp}/\mathcal{L}_{i}$ is also known as the (symplectic)
dual quotient or glue group for $\mathcal{L}_{i}$. We can thus obtain
symplectic lattices from a base lattice
$\mathcal{L}_{0}=\bigoplus_{i=1}^{k}\mathcal{L}_{i}$ by adding vectors
$\bm{v}$ of the form in eq. (118), where each
$\bm{v_{i}}\in\mathcal{L}_{i}^{\perp}/\mathcal{L}_{i}$. We also refer to the
set of extra vectors $\bm{v}$ as the glue group $G$. Let
$\mathcal{L}=\bigoplus_{i=1}^{k}\mathcal{L}_{i}\cup G$ be a glued lattice of
this form. It is clear that we have
$\mathcal{L}^{\perp}=\bigoplus_{i=1}^{k}\mathcal{L}_{i}^{\perp}\cap
G^{\perp}$.

Generally, whenever we have saturated sublattices
$\mathcal{L}_{0}\subset\mathcal{L}$, i.e.,
$\mathbb{R}\otimes\mathcal{L}_{0}=\mathbb{R}\otimes\mathcal{L}$, we have
$|\mathcal{L}_{0}|/|\mathcal{L}|\in\mathbb{Z}$. For $g\in\mathcal{L}$ we
consider the glue classes $[g]=g+\mathcal{L}_{0}$, which form an additive
group that we denote

$G=\langle g_{1},\dots,g_{r}\rangle.$ (119)

Conversely, in a bottom-up approach, a glued lattice $\mathcal{L}$ can be
constructed by considering a general glue group
$G\subseteq\mathcal{L}_{0}^{\perp}/\mathcal{L}_{0}$ and forming
$\mathcal{L}=\mathcal{L}_{0}[G]=\mathcal{L}_{0}\cup G$. $G$ is cyclic and
isomorphic to $\mathbb{Z}_{n_{1}}\times..\times\mathbb{Z}_{n_{r}}$ , where
$\mathbb{Z}_{n}$ is the cyclic group of order $n$, and each $n_{i}$ is the
order of the corresponding generator $g_{i}$, i.e the smallest positive
integer such that $n_{i}g_{i}\in\mathcal{L}_{0}$ . The determinant of the
glued lattice $\mathcal{L}_{0}[G]$ can be computed as [45]

$|\mathcal{L}_{0}[G]|=|\mathcal{L}_{0}|/|G|=|\mathcal{L}_{0}|/(\prod_{i=1}^{r}n_{i}).$
(120)

To construct a symplectic glued lattice from a symplectic base lattice
$\mathcal{L}_{0}$, it is important to take care that every $g_{i}$ has integer
symplectic inner product with every other $g_{j}$ – i.e., $G$ is itself a
finite symplectic group and that each $G$ has integer symplectic inner product
with each $x\in\mathcal{L}_{0}$, i.e., $G\subset\mathcal{L}_{0}^{\perp}$. It
is easy to see that the earlier considerations are reproduced for
$\mathcal{L}_{0}=\bigoplus_{i=1}^{k}\mathcal{L}_{i}$. Using (120) we can
obtain the logical dimension of GKP codes associated to glued lattices
$\mathcal{L}_{0}[G]$. E.g. for a concatenated GKP-qubit code,
$G\subset\mathcal{L}_{0}^{\perp}/\mathcal{L}_{0}$ is identified with the outer
code with, say, $r$ lineary independent generators, each with order $n_{i}=2$
in $\mathcal{L}_{0}$. $\mathcal{L}_{0}=\mathcal{L}(\sqrt{2}I_{2n})$, such that
we compute $|\mathcal{L}_{0}[G]|=2^{n-r}=2^{k}$, consistent with what we would
expect. Similar to the derivation for concatenated codes, we do not expect it
to be hard to derive the distance of a glued lattice $\mathcal{L}_{0}[G]$.
However, this quantity strongly depends on the specifications of the glue
group $\mathcal{L}_{0}^{\perp}/\mathcal{L}_{0}$ and $G$ which makes it
difficult to write down a general solution in closed form.

###  7.2 Tensor product codes

Aside from the glueing construction, it is also possible to obtain new codes
by taking outer products of lattices. The idea behind this construction is
akin to product constructions known for qubit quantum error correcting codes,
namely the _hypergraph product codes_ by Tillich and Zemor [46], where the
defining structure of the code is a hypergraph, and Homological product codes
by Bravyi and Hastings [47], where the code is defined via a cell complex. For
GKP codes, the defining structure of the codes is given by a lattices, such
that the tensor product for lattices serves as an immediate candidate for a
similar construction.

Let $\mathcal{L}_{1}=\mathcal{L}(M_{1})\subset\mathbb{R}^{2}$ be a symplectic
lattice with symplectic Gram matrix $A_{1}=M_{1}J_{2}M_{1}^{T}$ and
$\mathcal{L}_{2}=\mathcal{L}(M_{2})\subset\mathbb{R}^{n}$ an integral lattice
with euclidean Gram matrix $G_{2}=M_{2}M_{2}^{T}$. The tensor product lattice
is defined as $\mathcal{L}_{\otimes}=\mathcal{L}(M_{1}\otimes
M_{2})=\mathcal{L}_{1}\otimes\mathcal{L}_{2}\subset\mathbb{R}^{2n}$, i.e., a
basis for $\mathcal{L}_{\otimes}$ is given by
$\left\\{(M_{1})_{i}\otimes(M_{2})_{j},\;i=1,2,\;j=1,\ldots,n\right\\}$.
$\mathcal{L}_{\otimes}$ is a symplectic lattice due to the decomposition
$J_{2n}=J_{2}\otimes I_{n}$, and its symplectic Gram matrix reads

$A_{\otimes}=(M_{1}\otimes M_{2})J_{2n}(M_{1}\otimes M_{2})^{T}=A_{1}\otimes
G_{2},$ (121)

which is integral by construction. The canonical dual basis is given by

$M^{\perp}_{\otimes}=(J_{2n}M_{\otimes}^{T})^{-1}=M_{\otimes}^{-T}J_{2n}^{T}=M_{1}^{-T}J_{2}^{T}\otimes
M_{2}^{-T}=M_{1}^{\perp}\otimes M_{2}^{*},$ (122)

which forms a basis for the symplectically dual lattice
$\mathcal{L}_{\otimes}^{\perp}=\mathcal{L}_{1}^{\perp}\otimes\mathcal{L}_{2}^{*}$.
We have

$\displaystyle|A_{1}\otimes G_{2}|$ $\displaystyle=|A_{1}|^{n}|G_{2}|^{2},$
(123) $\displaystyle k_{\otimes}=\frac{1}{2}\log_{2}|A_{1}\otimes G_{2}|$
$\displaystyle=\frac{n}{2}\log_{2}|A_{1}|+\log_{2}|G_{2}|.$ (124)

######  Theorem 6 (Distance of tensor product codes).

The distance of the tensor product code

$\Delta_{\otimes}=\min_{0\neq
x\in\mathcal{L}_{\otimes}^{\perp}/\mathcal{L}_{\otimes}}\|x\|$

obeys

$\max\left\\{\frac{\Delta_{1}}{\lambda_{n}(\mathcal{L}_{2})},\frac{\Delta_{2}}{\lambda_{2}(\mathcal{L}_{1})}\right\\}\leq\Delta_{\otimes}\leq\Delta_{1}\Delta_{2},$
(125)

where

$\Delta_{1}=\min_{0\neq
x\in\mathcal{L}_{1}^{\perp}/\mathcal{L}_{1}}\|x\|,\hskip
28.45274pt\Delta_{2}=\min_{0\neq
x\in\mathcal{L}_{2}^{*}/\mathcal{L}_{2}}\|x\|.$ (126)

###### Proof.

The proof is analogous to that of Lemma 2 in ref. [47]. To prove the upper
bound, let
$x\in\mathcal{L}_{1}^{\perp}/\mathcal{L}_{1},\;y\in\mathcal{L}_{2}^{*}/\mathcal{L}_{2}$,
be minimal non-trivial logical representatives of each component codes. It is
clear that $x\otimes y\in\mathcal{L}_{\otimes}^{\perp}$. Further we have
$x\otimes y\notin\mathcal{L}_{\otimes}$ because we can pick
$a\in\mathcal{L}_{1}^{\perp},\;b\in\mathcal{L}_{2}^{*}$ such that
$a^{T}J_{2}x\in\mathbb{Q}_{1},\,b^{T}y\in\mathbb{Q}_{1}$, where
$\mathbb{Q}_{1}=\mathbb{Q}\cap(0,1)$, yielding $(a\otimes
b)^{T}J_{2n}(x\otimes y)\notin\mathbb{Z}$ (note that the symplectic inner
product sets the commutation phase for the associated displacement operators).
As such, we have obtained a non-trivial logical operator $x\otimes
y\in\mathcal{L}_{\otimes}^{\perp}/\mathcal{L}_{\otimes}$ and
$\Delta_{\otimes}\leq\|x\otimes y\|=\Delta_{1}\Delta_{2}$. Let
$0\neq\bm{\psi}\in\mathcal{L}_{\otimes}^{\perp}/\mathcal{L}_{\otimes}$ be a
minimal length non-trivial vector. We can always choose $0\neq
c\in\mathcal{L}_{1}^{\perp}/\mathcal{L}_{1}$ and $d\in\mathcal{L}_{2}$ such
that

$(c\otimes d)^{T}(J_{2}\otimes I_{n})\psi\notin\mathbb{Z}.$ (127)

Let $\mathit{vec}^{-1}(\psi)$ be the un-vectorization of $\psi$, i.e., if
$\psi=\sum_{i}x_{i}\otimes
y_{i},\,x_{i}\in\mathcal{L}_{1}^{\perp},\,y_{i}\in\mathcal{L}_{2}^{*}$ we have
$\mathit{vec}^{-1}(\psi)=\sum_{i}x_{i}y_{i}^{T}$. It holds that
$\mathit{vec}^{-1}(\psi)d\in\mathcal{L}_{1}^{\perp}$ and
$\mathit{vec}^{-1}(\psi)d\notin\mathcal{L}_{1}$ since otherwise $(c\otimes
d)^{T}(J_{2}\otimes
I_{n})\psi=c^{T}J_{2}\mathit{vec}^{-1}(\psi)d\in\mathbb{Z}$ for all choices of
$\bm{c},\bm{d}$, such that $\psi$ is logically trivial, which is not the case
by assumption. Hence, $\mathit{vec}^{-1}(\psi)d$ is a non-trivial
representative of $\mathcal{L}_{1}^{\perp}/\mathcal{L}_{1}$. Using Cauchy-
Schwartz we have
$\|\psi\|\|d\|=\|\mathit{vec}^{-1}(\psi)\|_{F}\|d\|\geq\|\mathit{vec}^{-1}(\psi)d\|\geq\Delta_{1}$,
where $\|\cdot\|_{F}$ is the Frobenius norm. We can always choose
$d\in\mathcal{L}_{2}$ with length at most the covering radius
$\lambda_{n}(\mathcal{L}_{2})$ that satisfies eq. (127). This is because any
$d\in\mathcal{L}_{2}$ can be written in a basis

$d=\sum_{i=1}^{n}a_{i}\xi_{i},\hskip 14.22636pta_{i}\in\mathbb{Z},\hskip
14.22636pt\xi_{i}\in\mathcal{L}_{2}:\;\|\xi_{i}\|\leq\lambda_{n}\left(\mathcal{L}_{2}\right).$
(128)

When $d$ satisfies eq. (127), we have

$\mathbb{Z}\not\ni\sum_{i=1}^{n}(c\otimes d)^{T}(J_{2}\otimes
I_{n})\psi=\sum_{i=1}^{n}a_{i}(c\otimes\xi_{i})^{T}(J_{2}\otimes I_{n})\psi.$
(129)

There must be at least one summand $i=x$, for which
$a_{x}(c\otimes\xi_{x})^{T}(J_{2}\otimes I_{n})\psi\not\in\mathbb{Z}$. Since
$a_{x}\in\mathbb{Z}$, it must hold that $(c\otimes\xi_{x})^{T}(J_{2}\otimes
I_{n})\psi\not\in\mathbb{Z}$. Finally, we obtain

$\|\psi\|\geq\frac{\Delta_{1}}{\lambda_{n}(\mathcal{L}_{2})}.$ (130)

Following the same procedure, we choose
$c\in\mathcal{L}_{1},d\in\mathcal{L}_{2}^{\perp}/\mathcal{L}_{2}$ such that
eq. (127) is satisfied to show that $\|\psi\|\|c\|\geq\Delta_{2}$. ∎

##  8 Conclusions and future work

In this work, we have shown how some of the core concepts of lattice theory
can be fruitfully used to analyse the structure of GKP codes. We have
introduced the notion of a euclidean code distance for GKP codes and shown its
relation with other relevant code parameters, in particular the trade-off with
the encoding rate and length of stabilizer operators. We have examined the
structure of particular GKP code constructions, such as scaled and
concatenated GKP codes and shown how extensions of those constructions can be
obtained using tools already present in the lattice theory literature. Using a
lattice theoretic perspective when discussing bounds on GKP code parameters,
we observed that the distance of the code is intimately related to the length
of the stabilizers. Leveraging the natural embedding of qubit codes in
$\mathbb{R}^{2n}$ provided by the concatenation with GKP codes we have shown
in Corollary 3 how this result leads to a new proof of a similar property for
qubit stabilizer codes, which is simpler than those found in the literature.
This highlights how concepts from lattice theory can also become valuable
tools to understand qubit stabilizer codes. Concerning the role of symplectic
operations, which are central both in the theory and experiments with bosonic
systems, we have clarified which GKP codes are related through a symplectic
transformation, extending previous results for the single-mode case. This can
also be interpreted as code-switching via Gaussian unitaries. In particular,
we have identified a necessary and sufficient condition in the equality of the
symplectic Gram matrix in standard form.

We have discussed how the GKP codes highlighted in this work can be decoded in
terms of a general maximum likelihood decoder for the GKP code, for which the
defining logical coset probability is given by the lattice theta function.
Algorithms to approximate or sample theta functions have been discussed in the
literature [43], which we identify as possible route forward to build general
purpose decoders for GKP codes. More details on the practical implementation
of decoders are, however, to appear in a separate publication.

The theta function of the GKP code lattice is also proven to encode
information about the distance of GKP codes. It is known that, depending on
the lattice, the theta function may possess certain symmetries under conformal
transformations, which allow it to be represented in a finitely generated
basis. In other words, if the theta function has certain symmetries (e.g.
invariance under $z\mapsto z+2$ for integral lattices) there exists a finite
basis classified by the symmetry which can be used to write the theta
function. This can also potentially be useful for decoding. In general, it
would be interesting to further investigate the connection between the code
distance and possible conformal symmetries of the theta function of the
lattice.

It is worth mentioning that the theta function of glued lattices also appears
in place of the partition function of certain string theories [45]. Given that
it represents the MLD probability discussed in the Section 6, which has also
been interpreted in the past as the partition function of a statistical
mechanics model [48, 10], it is an interesting open question whether a
rigorous connection between string theories and the statistical mechanics
model for decoding GKP codes can be leveraged to obtain a deeper understanding
for either.

Finally, we have discussed constructions of GKP codes beyond scaled- and
concatenated codes. We have seen that the toolbox of lattice theory allows for
a remarkably versatile set of code constructions which have great potential
for the search of good code families with potentially better parameters,
better performance tailored to particular physical implementations or allowing
for better decoders relying on the structure of the lattice, without reference
to an intermediate qubit decoder. Further generalizations of GKP code
constructions, such as subsystem variants by constructions on shifted lattices
[45] also seem possible. Overall, we hope that this work will stimulate
further interest in examining stabilizer codes, and in particular GKP codes,
through the lens of lattice theory and will provide a foundation to import
useful tools for the study of bosonic error correction.

J. C. thanks B. Terhal for asking whether product constructions for GKP codes
can be found and N. P. Breuckmann, A. Ciani and J.-P. Seifert for helpful
discussions. F. A. acknowledges the support of the Alexander von Humboldt
foundation. This work has been funded by the BMBF (RealistiQ, for which it
provides a key physics non-agnostic approach to quantum error correction,
PhoQuant, QPIC-1, and QSolid) and the DFG (CRC 183, project B04, on entangled
states of matter). We also gratefully acknowledge support from the Einstein
Research Unit on quantum devices.

##  Appendix A Code space of GKP codes

In this section, we show how the code space of a general GKP code can be
represented in terms of the Wigner function of the code space projector

$\Pi_{GKP}=\sum_{g\in\mathcal{S}}g.$ (131)

In particular, this illustrates in how far the code space is non-trivially
influenced by the choice of pivot basis for the GKP code and the phase-sector
$\phi_{M}$. Consistent with our non-standard definition of the displacement
operator, we define the generalized Wigner function of an operator $O$ [49,
50]

$W_{O}\left(\bm{x}\right)=\int_{\mathbb{R}^{2n}}d\bm{\eta}\,e^{-i2\pi\bm{x}^{T}J\bm{\eta}}\operatorname{Tr}\left[D\left(\bm{\eta}\right)O\right],$
(132)

such that we also have

$\int_{\mathbb{R}^{2n}}d\bm{x}W_{O}\left(\bm{x}\right)=\operatorname{Tr}\left[O\right].$
(133)

And we equip us with the following lemma.

######  Lemma 2 (Dirac comb representation).

Let $\mathcal{L}\subseteq\mathbb{R}^{2n}$ be a lattice with generator $M$ with
symplectic dual $\mathcal{L}^{\perp}$, we have

$\sum_{\bm{\xi}\in\mathcal{L}}e^{i2\pi\bm{\xi}^{T}J\bm{z}}=\frac{1}{\det\left(\mathcal{L}\right)}\sum_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}}\delta^{2n}\left(\bm{z}-\bm{\xi}^{\perp}\right).$
(134)

###### Proof.

We compute straightforwardly using one dimensional Poisson resummation
$\sum_{n\in\mathbb{Z}}e^{i2\pi
nx}=\sum_{k\in\mathbb{Z}}\delta\left(x-k\right)$

$\displaystyle\sum_{\bm{\xi}\in\mathcal{L}}e^{i2\pi\bm{\xi}^{T}J\bm{z}}$
$\displaystyle=\sum_{\bm{a}\in\mathbb{Z}^{2n}}e^{i2\pi\bm{a}^{T}MJ\bm{z}}$
(135) $\displaystyle=\prod_{j}\sum_{a_{j}\in\mathbb{Z}}e^{i2\pi
a_{j}\left(MJ\bm{z}\right)_{j}}$ (136)
$\displaystyle=\prod_{j}\sum_{b_{j}\in\mathbb{Z}}\delta\left(\left(MJ\bm{z}\right)_{j}-b_{j}\right)$
(137)
$\displaystyle=\frac{1}{\det\left(\mathcal{L}\right)}\sum_{\bm{b}\in\mathbb{Z}^{2n}}\delta^{2n}\left(\bm{z}-\left(\bm{b}^{T}M^{\perp}\right)^{T}\right)$
(138)
$\displaystyle=\frac{1}{\det\left(\mathcal{L}\right)}\sum_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}}\delta^{2n}\left(\bm{z}-\bm{\xi}^{\perp}\right).$
(139)

∎

We compute the Wigner function of the code space projector of a GKP code
defined with primal basis $M$

$\displaystyle W_{\Pi_{GKP}}\left(\bm{x}\right)$
$\displaystyle=\int_{\mathbb{R}^{2n}}d\bm{\eta}\,e^{-i2\pi\bm{x}^{T}J\bm{\eta}}\operatorname{Tr}\left[D\left(\bm{\eta}\right)\Pi_{GKP}\right]$
(140)
$\displaystyle=\sum_{\bm{\xi}\in\mathcal{L}}e^{i\phi_{M}\left(\bm{\xi}\right)}\int_{\mathbb{R}^{2n}}d\bm{\eta}\,e^{-i2\pi\bm{x}^{T}J\bm{\eta}}\operatorname{Tr}\left[D\left(\bm{\eta}\right)D\left(\bm{\xi}\right)\right]$
(141)
$\displaystyle=\sum_{\bm{\xi}\in\mathcal{L}}e^{i\phi_{M}\left(\bm{\xi}\right)}e^{i2\pi\bm{x}^{T}J\bm{\xi}}.$
(142)

When $\phi_{M}=0\mod 2\pi$, such as when the GKP code is defined with
symplectically even lattice, we can compute the sum using Lemma 2,

$W_{\Pi_{GKP}}\left(\bm{x}\right)=\frac{1}{\det\left(\mathcal{L}\right)}\sum_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}}\delta^{2n}\left(\bm{x}-\bm{\xi}^{\perp}\right),$
(143)

such that the Wigner function is precisely given by a generalized Dirac comb
over the dual lattice $\mathcal{L}^{\perp}$. When $\phi_{M}\neq 0\mod 2\pi$,
however, this is no longer true. The above expression will also be
substantially different from a mere shift of the Dirac comb over the lattice
since $\phi_{M}$ is generally a _quadratic_ function. We can express it
compactly using the general _Riemann theta function_ [51]

$\vartheta\left(\bm{u}\,|\,F\right)=\sum_{\bm{m}\in\mathbb{R}^{2n}}e^{i2\pi\left(\frac{1}{2}\bm{m}^{T}F\bm{m}+\bm{m}^{T}\bm{u}\right)},$
(144)

as

$W_{\Pi_{GKP}}\left(\bm{x}\right)=\frac{1}{\det\left(\mathcal{L}\right)}\vartheta\left(-MJ\bm{x}\,|\,A_{\leavevmode\hbox
to4.5pt{\vbox to4.5pt{\pgfpicture\makeatletter\hbox{\hskip
0.2pt\lower-0.2pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\right).$ (145)

Note, however, that $A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}$ does not have
positive definite imaginary part so that, similar to the Dirac comb above,
this expression does not converge. This is a general artefact of exact GKP
states discussed here which are unphysical as presented and, in practice, will
be endowed with particular regularizing functions depending on the concrete
physical implementation. When such regularization is present, the
corresponding sum can be expressed using the following generalization of
Poisson resummation.

######  Lemma 3 (Poisson resummation).

Let $\mathcal{L}\subseteq\mathbb{R}^{2n}$ be a lattice with symplectic dual
$\mathcal{L}^{\perp}$, we have for all Schwartz functions
$f:\,\mathbb{R}^{2n}\rightarrow\mathbb{C}$,

$\sum_{\bm{\xi}\in\mathcal{L}}f\left(\bm{\xi}\right)=\frac{1}{\det\left(\mathcal{L}\right)}\sum_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}}\hat{f}\left(\bm{\xi}^{\perp}\right),$
(146)

where

$\hat{f}\left(\bm{x}\right)=\int_{\mathbb{R}^{2n}}d\bm{y}f\left(\bm{y}\right)e^{i2\pi\bm{y}^{T}J\bm{x}}$
(147)

is the symplectic Fourier transform of $f$.

###### Proof.

We proof this fact following the analogous proof using the usual Fourier
transform provided in [41]. First define

$F\left(\bm{z}\right)=\sum_{\bm{\xi}\in\mathcal{L}}f\left(\bm{z}+\bm{\xi}\right).$
(148)

This function is invariant under transformations
$\bm{z}\mapsto\bm{z}+\mathcal{L}$, such that it descends to a function on
$\mathbb{R}^{2n}/\mathcal{L}$ and has Fourier expansion

$F\left(\bm{z}\right)=\sum_{\bm{y}\in\mathcal{L}^{\perp}}\hat{F}\left(\bm{y}\right)e^{i2\pi\bm{y}^{T}J\bm{z}},$
(149)

where

$\hat{F}\left(\bm{y}\right)=\frac{1}{\det\left(\mathcal{L}\right)}\int_{\mathbb{R}^{2n}/\mathcal{L}}d\bm{x}\,F\left(\bm{x}\right)e^{i2\pi\bm{x}^{T}J\bm{y}}.$
(150)

Using lemma 2 the correctness of the Fourier expansion can be
straightforwardly verified. Let $\mathcal{P}\sim\mathbb{R}^{2n}/\mathcal{L}$
be a fundamental domain of $\mathcal{L}$. We compute for
$\bm{y}\in\mathcal{L}^{\perp}$ (such that $e^{i2\pi\bm{x}^{T}J\bm{y}}$ is well
defined on $\bm{x}\in\mathbb{R}^{2n}/\mathcal{L}$)

$\displaystyle\det\left(\mathcal{L}\right)\hat{F}\left(\bm{y}\right)$
$\displaystyle=\sum_{\bm{\xi}\in\mathcal{L}}\int_{\bm{x}\in\mathcal{P}}d\bm{x}\,f\left(\bm{x}+\bm{\xi}\right)e^{i2\pi\bm{x}^{T}J\bm{y}}$
(151)
$\displaystyle=\sum_{\bm{\xi}\in\mathcal{L}}\int_{\bm{x}\in\mathcal{P}-\bm{\xi}}d\bm{x}\,f\left(\bm{x}\right)e^{i2\pi\bm{x}^{T}J\bm{y}}$
(152) $\displaystyle=\hat{f}\left(\bm{y}\right),$ (153)

such that we have

$F\left(\bm{z}\right)=\frac{1}{\det\left(\mathcal{L}\right)}\sum_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}}\hat{f}\left(\bm{y}\right)e^{i2\pi\bm{y}^{T}J\bm{z}}.$
(154)

Taking $z=0$ completes the proof. ∎

We use Lemma 3 to compute the Wigner function of a GKP code, where we include
generic Gaussian regularization parametrized by $\epsilon>0$.

$\displaystyle W_{\Pi_{GKP}}\left(\bm{x}\right)$
$\displaystyle=\left(\frac{\epsilon}{\pi}\right)^{n}\sum_{\bm{\xi}\in\mathcal{L}}e^{-\epsilon\bm{\xi}^{T}\bm{\xi}}e^{i\phi_{M}\left(\bm{\xi}\right)}e^{i2\pi\bm{x}^{T}J\bm{\xi}}$
(155)
$\displaystyle=\left(\frac{\epsilon}{\pi}\right)^{n}\sum_{\bm{\xi}\in\mathcal{L}}e^{-\bm{\xi}^{T}\left(\epsilon
I-iM^{-1}A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}M^{-T}\right)\bm{\xi}+i2\pi\bm{x}^{T}J\bm{\xi}}$
(156)
$\displaystyle=\frac{1}{\det\left(\mathcal{L}\right)}\frac{\epsilon^{n}}{\sqrt{\det\left(B\right)}}\sum_{\bm{\xi}^{\perp}\in\mathcal{L}^{\perp}}e^{-\pi^{2}\left(\bm{x}-\bm{\xi}^{\perp}\right)^{T}JB^{-1}J^{T}\left(\bm{x}-\bm{\xi}^{\perp}\right)}.$
(157)

where we have defined $B=\epsilon I-iM^{-1}A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}M^{-T}$. We observe
that for $A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}=0$ in the limit
$\epsilon\rightarrow 0$ we again obtain eq. (143). However, in general for odd
$A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}$ the Wigner function
is modified non-trivially. In this example the regularization was chosen
generically without reference to a clear physical motivation other than that
physical states need to be normalizable. It would be interesting to further
study how the structure of a physical model of the code space changes with
$A_{\leavevmode\hbox to4.5pt{\vbox
to4.5pt{\pgfpicture\makeatletter\hbox{\hskip 0.2pt\lower-0.2pt\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{
}\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{
}\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{
}\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox
to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {}{{}}{} {}{} {}{}
{}{}{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@lineto{4.09703pt}{0.0pt}\pgfsys@lineto{0.0pt}{4.09703pt}\pgfsys@lineto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{
} \pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope
}\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}$ in the Wigner
representation for alternative regularization schemes such as ones discussed
in ref. [52].

##  Appendix B GKP Codes from degenerate lattices

In this section we briefly discuss how degenerate symplectic lattices can be
used for encoding continuous degrees of freedom into a collection of $n$
oscillators, following the definition and analysis in [23, 15]. To simplify
the notation we will work in the convention where
$\bm{\hat{x}}=\left(\hat{q}_{1},\hat{p}_{1},\ldots,\hat{q}_{n},\hat{p}_{n},\right)$
and the symplectic form is $J=I_{n}\otimes J_{2}$. We encode a state vector
$\ket{\psi}\in\mathcal{H}^{\otimes k}$ describing $k$ oscillator modes into
$\mathcal{H}^{\otimes n}$ by appending it with the ancillary state vector
$\ket{A}=\ket{GKP}^{\otimes r}$, where $r=n-k$, and acting on the composite
state with a Gaussian unitary $U_{S}$ (see fig. 5). Each state vector
$\ket{GKP}$ is the unique code state of the GKP stabilizer group described by
$M_{GKP}=I_{2}$, the symplectic self-dual square lattice, such that the
overall ancillary state vector $\ket{A}$ is stabilized by a GKP stabilizer
group $\mathcal{S}_{A}$ associated to a lattice generated by $M_{A}=I_{2r}$
which we denote by $\mathcal{L}_{A}=\mathcal{L}\left(M_{A}\right)$. The code
state is hence described by

$\displaystyle\ket{\overline{\psi}}$
$\displaystyle=U_{S^{-1}}\left(\ket{\psi}\otimes\ket{A}\right)$
$\displaystyle=U_{S^{-1}}\left(\ket{\psi}\otimes
D\left(\bm{s}\right)\ket{A}\right)$
$\displaystyle=U_{S^{-1}}D\left(\bm{0}_{2k}\oplus\bm{s}\right)U_{S^{-1}}^{\dagger}\ket{\overline{\psi}}$
$\displaystyle=D\left(S\left(\bm{0}_{2k}\oplus\bm{s}\right)\right)\ket{\overline{\psi}}\hskip
14.22636pt\forall\bm{s}\in\mathcal{L}_{A}$ (158)

and is stabilized by displacements associated to the lattice
$\mathcal{L}_{osc}$ generated by the rows of

$M_{osc}=\left[0_{2k}\oplus M_{A}\right]S^{T},$ (159)

where we used $0_{2k}$ to denote the $2k\times 2k$ zero-matrix. We denote the
corresponding stabilizer group by $\mathcal{S}_{osc}$. It is immediate that
$M_{osc}$ is not a full rank matrix, such that there will be a continuum of
solutions $\bm{x}$ to

$MJ\bm{x}=0\mod 1.$ (160)

In particular, we can obtain logical displacements by propagating a logical
displacement $D\left(\bm{\alpha}\right)$ on the data mode through the encoding
unitary

$U_{S^{-1}}\left(D\left(\bm{\alpha}\right)\ket{\psi}\otimes\ket{A}\right)=D\left(S\left(\bm{\alpha}\oplus\bm{0}_{2r}\right)\right)\ket{\overline{\psi}}.$
(161)

Finally, we obtain that the centralizer of the stabilizer group
$\mathcal{S}_{osc}$ is given by displacements within

$\mathcal{L}_{osc}^{\perp}=\left\\{S\left(\bm{\alpha}\oplus\bm{0}_{2r}\right)+\bm{\xi}\big{|}\,\bm{\alpha}\in\mathbb{R}^{2k},\,\bm{\xi}\in\mathcal{L}_{osc},\right\\}.$
(162)

In contrast to the encoding of qubits and qudits, where logical operations are
encoded in the discrete collection of cosets of the quotient lattice, the
oscillator-to-oscillator encoding does not immediately inherit error
correction properties from an underlying notion of (euclidean) distance, where
displacements of amplitude below a certain threshold are guaranteed to not
harm the logical information. Instead, the protection stems from that fact
that the encoding unitary can be tailored to correlate error displacements
between the data- and the ancillary modes such that measuring the stabilizers
$\mathcal{S}_{A}$ of the ancillary system allows to diagnose the error that
incurred on the data modes. That is, when the error is promised to be
sufficiently small, the modular quadrature information gained from measuring
$\mathcal{S}_{A}$ reveals the actual displacement error value. Let
$\mathcal{N}$ denote the Gaussian displacement channel. We then have that
$\rho_{0}=\ket{\psi}\bra{\psi}\otimes\ket{A}\bra{A}$ undergoes the evolution

$\displaystyle\rho_{0}$ $\displaystyle\mapsto U_{S^{-1}}^{\dagger}\int
d^{2n}\bm{x}\,e^{-\frac{1}{2}\bm{x}^{T}\left(\frac{I}{\sigma^{2}}\right)\bm{x}}D\left(\bm{x}\right)U_{S^{-1}}\rho_{0}U_{S^{-1}}^{\dagger}D\left(\bm{x}\right)^{\dagger}\,U_{S^{-1}}$
$\displaystyle=\int
d^{2n}\bm{x}\,e^{-\frac{1}{2}\bm{y}^{T}\left(\frac{S^{T}S}{\sigma^{2}}\right)\bm{y}}D\left(\bm{y}\right)\rho_{0}D\left(\bm{y}\right)^{\dagger},$
(163)

that is $\rho_{0}$ effectively undergoes a Gaussian displacement channel with
covariance $\Sigma=\sigma^{2}\left(S^{T}S\right)^{-1}$. This scheme can be
understood as generalization and QEC application of the displacement-sensor
setup developed in [53]. For concrete examples and further details on the
oscillator-to-oscillator encoding we refer the reader to ref. [23] and for
analysis of the possibility of a threshold to ref. [15].

Figure 5: Oscillator-to-oscillator encoding of ref. [23]. $\tilde{s}_{A}$
denotes the Eigenvalues obtained from measuring the generating set of
stabilizers in $S_{A}$ and $h(\cdot)$ an estimator function that estimates the
logical shift based on $\tilde{s}_{A}$.

To go beyond the encoding of either continuous or discrete information into a
collection of oscillators, we remark that this scheme can be extended to host
both continuous and discrete information. One way to do so is by choosing as
input ancillary state vector $\ket{A}$ a code state of a non-trivial GKP code
described by a lattice $\mathcal{L}\left(M_{A}\right)$ with
$|\det\left(M_{A}J_{2r}M_{A}^{T}\right)|>1$ such as one discussed in the main
body of this work. Here, the ancillary state on the second register
$\mathcal{H}^{\otimes r}$ would host all the discrete information with the
addition that the errors applied to it may be (depending on the choice of $S$)
strongly correlated with the errors on the first register
$\mathcal{H}^{\otimes k}$ that hosts continuous information. The stabilizer
measurements $\mathcal{S}_{A}$ would hence also reveal information about the
exact displacement the first register $\mathcal{H}^{\otimes k}$ has undergone
where $\lambda_{1}\left(\mathcal{L}_{A}^{\perp}\right)$ sets the scale for the
variance up to which the modular measurement outcomes $\tilde{s}_{A}$ still
accurately estimate the exact shift on the first register (it needs to lie
inside the dual Voronoi cell $\mathcal{V}^{\perp}$ of
$\mathcal{L}_{A}^{\perp}$). As far as we know (see, e.g., Theorem 3) this does
not need to limit the euclidean distance $\Delta$ with which the discrete
information is protected. We note that this hybrid scheme is equivalent to a
setup where a GKP encoded discrete variable state is considered part of the CV
input $\ket{\psi}$. A more in-depth analysis of such hybrid scheme extends
beyond the scope of this work and is therefore deferred to future work.

## References

  * [1] D. Gottesman, A. Kitaev, and J. Preskill.  “Encoding a qubit in an oscillator”.  Phys. Rev. A 64, 012310 (2001).
  * [2] B. M. Terhal, J. Conrad, and C. Vuillot.  “Towards scalable bosonic quantum error correction”.  Quantum Science and Technology 5, 043001 (2020).
  * [3] A. L. Grimsmo and S. Puri.  “Quantum error correction with the Gottesman-Kitaev-Preskill code”.  PRX Quantum 2, 020101 (2021).
  * [4] J. E. Bourassa, R. N. Alexander, M. Vasmer, A. Patil, I. Tzitrin, T. Matsuura, D. Su, B. Q. Baragiola, S. Guha, G. Dauphinais, and et al.  “Blueprint for a scalable photonic fault-tolerant quantum computer”.  Quantum 5, 392 (2021).
  * [5] S. Bartolucci, P. Birchall, H. Bombin, H. Cable, C. Dawson, M. Gimeno-Segovia, E. Johnston, K. Kieling, N. Nickerson, M. Pant, F. Pastawski, T. Rudolph, and C. Sparrow.  “Fusion-based quantum computation” (2021).  arXiv:2101.09310.
  * [6] K. Noh, C. Chamberland, and F. G. S. L. Brandão.  “Low-overhead fault-tolerant quantum error correction with the surface-GKP code”.  PRX Quantum 3, 010315 (2022).
  * [7] C. Flühmann, T. L. Nguyen, M. Marinelli, V. Negnevitsky, K. Mehta, and J. P. Home.  “Encoding a qubit in a trapped-ion mechanical oscillator”.  Nature 566, 513–517 (2019).
  * [8] P. Campagne-Ibarcq, A. Eickbusch, S. Touzard, E. Zalys-Geller, N. E. Frattini, V. V. Sivak, P. Reinhold, S. Puri, S. Shankar, R. J. Schoelkopf, and et al.  “Quantum error correction of a qubit encoded in grid states of an oscillator”.  Nature 584, 368–372 (2020).
  * [9] K. Fukui, A. Tomita, and A. Okamoto.  “Analog quantum error correction with encoding a qubit into an oscillator”.  Phys. Rev. Lett. 119, 180507 (2017).
  * [10] C. Vuillot, H. Asasi, Y. Wang, L. P. Pryadko, and B. M. Terhal.  “Quantum error correction with the toric Gottesman-Kitaev-Preskill code”.  Phys. Rev. A 99, 032344 (2019).
  * [11] K. Noh and C. Chamberland.  “Fault-tolerant bosonic quantum error correction with the surface–Gottesman-Kitaev-Preskill code”.  Phys. Rev. A 101, 012316 (2020).
  * [12] L. Hänggli, M. Heinze, and R. König.  “Enhanced noise resilience of the surface–gottesman-kitaev-preskill code via designed bias”.  Phys. Rev. A 102 (2020).
  * [13] J. W. Harrington.  “Analysis of quantum error-correcting codes: Symplectic lattice codes and toric codes”.  PhD thesis.  California Institute of Technology.  (2004).
  * [14] J. Harrington and J. Preskill.  “Achievable rates for the Gaussian quantum channel”.  Phys. Rev. A 64, 062301 (2001).
  * [15] L. Hänggli and R. König.  “Oscillator-to-oscillator codes do not have a threshold”.  IEEE Transactions on Information Theory 68, 1068–1084 (2022).
  * [16] J. Conway and N. Sloane.  “Sphere packings, lattices and groups”.  Volume 290.  Springer, New York, NY (1988).
  * [17] P. Shor and R. Laflamme.  “Quantum analog of the macwilliams identities for classical coding theory”.  Phys. Rev. Lett. 78, 1600–1602 (1997).
  * [18] E. M. Rains.  “Quantum weight enumerators”.  IEEE Trans. Inf. Th. 44, 1388–1394 (1998).
  * [19] D. Micciancio.  “Cse 206a: Lattice algorithms and applications”.  url: http://cseweb.ucsd.edu/classes/wi10/cse206a/.
  * [20] D. E. Gottesman.  “Stabilizer codes and quantum error correction”.  PhD thesis.  California Institute of Technology.  (1997).
  * [21] Arvind, B. Dutta, N. Mukunda, and R. Simon.  “The real symplectic groups in quantum mechanics and optics”.  Pramana 45, 471–497 (1995).
  * [22] K. Duivenvoorden, B.M. Terhal, and D. Weigand.  “Single-mode displacement sensor”.  Phys. Rev. A 95, 012305 (2017).
  * [23] K. Noh, S. M. Girvin, and L. Jiang.  “Encoding an oscillator into many oscillators”.  Phys. Rev. Lett. 125, 080503 (2020).
  * [24] N. P. Breuckmann.  “Homological quantum codes beyond the toric code”.  PhD thesis.  RWTH Aachen University.  (2017).
  * [25] S. B. Bravyi and A. Yu. Kitaev.  “Quantum codes on a lattice with boundary” (1998).  arXiv:quant-ph/9811052.
  * [26] Y. Tomita and K. M. Svore.  “Low-distance surface codes under realistic quantum noise”.  Phys. Rev. A 90 (2014).
  * [27] D. Micciancio and B. Warinschi.  “A linear space algorithm for computing the Hermite normal form”.  In Proceedings of the 2001 International Symposium on Symbolic and Algebraic Computation.  Page 231–236.  ISSAC ’01New York, NY, USA (2001). Association for Computing Machinery.
  * [28] D. Micciancio.  “Improving lattice based cryptosystems using the Hermite normal form”.  In Lecture Notes in Computer Science.  Pages 126–145.  Springer Berlin Heidelberg (2001).
  * [29] C. Hermite.  “Sur l’introduction des variables continues dans la théorie des nombres.”.  J. Reine Angew. Math 1851, 191–216 (1851).