Linear-Time Maximum Likelihood Decoding of Surface Codes over the Quantum Erasure Channel

TL;DR

This paper introduces a linear-time maximum likelihood decoder for surface codes over the quantum erasure channel, enabling fast and optimal error correction crucial for fault-tolerant quantum computing.

Contribution

It presents the first linear-time decoding algorithm for surface codes over the quantum erasure channel, achieving optimal performance and speed.

Findings

Decoding algorithm operates in linear time.

Achieves maximum likelihood decoding performance.

Suitable for real-time error correction in quantum computers.

Abstract

Surface codes are among the best candidates to ensure the fault-tolerance of a quantum computer. In order to avoid the accumulation of errors during a computation, it is crucial to have at our disposal a fast decoding algorithm to quickly identify and correct errors as soon as they occur. We propose a linear-time maximum likelihood decoder for surface codes over the quantum erasure channel. This decoding algorithm for dealing with qubit loss is optimal both in terms of performance and speed.

Equations

$$-\sum _{v\in V}{X}_v-\sum _{f\in F}{Z}_f,$$

$$-\sum _{v\in \mathring{V}}{X}_v-\sum _{f\in F}{Z}_f$$

Full text

Introduction— Surface codes Kitaev (2003); Dennis et al. (2002) are one of the leading candidates to ensure the fault-tolerance of a quantum computer. Error correction is based on the measurement of local operators on a lattice of qubits. The measurement outcome, called the syndrome, is then processed by the decoding algorithm which uses this information to infer the error which occurred. In order to avoid the accumulation of errors during computation, it is essential for the decoder to be fast. Any speed-up of the decoder leads indirectly to a reduction of the noise strength, since a shorter time between two rounds of correction induces the appearance of fewer errors.

The quantum erasure channel Grassl et al. (1997); Bennett et al. (1997) is the noise model that represents photon loss or leakage outside the computational space in multi-level systems. The loss of a qubit is equivalent to applying a random Pauli error to this qubit, while giving, as additional data, the position of the error. For stabilizer codes, this extra information reduces the decoding problem to solving a linear system, which can be done with cubic complexity. In the particular case of surface codes, the syndrome of an error is a set of vertices of a lattice and decoding amounts to finding a set of paths connecting these vertices by pairs. One could pick two vertices and connect them by a path and repeat until all the syndrome vertices are matched. This would lead to a quadratic complexity. This strategy was adopted by Dennis et al. to decode Pauli errors Dennis et al. (2002) or by Barrett and Stace in the case of a combination of Pauli errors and erasures Barrett and Stace (2010).

In the present work, we propose a linear-time maximum likelihood decoder for erasures over surface codes. This is optimal both in terms of performance and in terms of complexity. Our algorithm can be used with any surface code, with arbitrary genus, and any type of boundary Freedman and Meyer (2001); Bravyi and Kitaev (1998); Delfosse et al. (2016), including hyperbolic codes Freedman et al. (2002); Zémor (2009); Breuckmann and Terhal (2016). In comparison, in the case of Pauli errors the efficient algorithm for maximum likelihood decoding over surface codes obtained by Bravyi, Suchara and Vargo Bravyi et al. (2014), only applies to a restricted set of surfaces.

In the rest of the paper, we describe our decoding algorithm and we prove that it is a maximum likelihood decoder. To illustrate the decoding strategy, we first consider Kitaev’s surface codes, then we generalize the approach to surfaces with boundaries, which are more relevant for practical purposes Freedman and Meyer (2001); Bravyi and Kitaev (1998); Delfosse et al. (2016).

Kitaev’s surface codes – Kitaev’s surface codes Kitaev (2003) are obtained by imposing local constraints on qubits placed on a closed surface. Since only the combinatorial structure of the surface matters, we denote by $(V,E,F)$ such a surface with vertex set $V$, edge set $E$ and face set $F$. These three sets are assumed to be finite. An edge $e\in E$ is a pair of distinct vertices $e=\{u,v\}$. A face is a region of the surface homeomorphic to a disc and delimited by a set of edges. We represent a face by the set of edges lying on its boundary. We assume that the graph $(V,E)$ has neither loops nor multiple edges. We also suppose that its dual is well defined and satisfies the same properties.

Consider the Hilbert space $\mathcal{H}=(\mathbb{C}^{2})^{E}$. Each qubit is indexed by an egde $e$ and the Pauli operator acting on this qubit as the matrix $X,Y$ or $Z$ and acting trivially elsewhere is denoted respectively by $X_{e},Y_{e}$ or $Z_{e}$. Kitaev’s surface code is defined to be the ground space of the Hamiltonian

[TABLE]

where $X_{v}=\prod_{v\in e}X_{e}$ and $Z_{f}=\prod_{e\in f}Z_{e}$. The operators $X_{v}$ and $Z_{f}$ generate a group $S$, the stabilizer group, which fixes the code space. Elements of $S$ are called stabilizers. The $Z$-stabilizers, that are products of face operators $Z_{f}$, are the operators of $\{I,Z\}^{\otimes E}$ whose support is a trivial cycle of $G$. By cycle, we mean here a subset of edges of $G$ which meets every vertex an even number of times. A cycle is said to be trivial if it lies on the boundary of a set of faces. In the same way, $X$-stabilizers correspond to trivial cycles of the dual graph. The correction of Pauli errors is based on the measurement of the generators $X_{v}$ and $Z_{f}$ which tells us whether or not the error commutes with these operators. The outcome of this measurement is called the syndrome of the error. Errors with a trivial syndrome, meaning that commute with all the stabilizers, can be seen as operators acting on the code space and are called logical operators. For instance, stabilizers are trivial logical operators. Non-trivial logical operators correspond to non-trivial cycles in the graph $G$ or its dual.

Maximum likelihood decoding for qubit loss – The quantum erasure channel is one of the most simple noise models. Each qubit is lost, or erased, independently with probability $p$. Such a loss can be detected and the missing qubit is then replaced by a totally mixed state ${\mathcal{I}}/2$. Writing ${\mathcal{I}}/2=\frac{1}{4}(\rho+X\rho X+Y\rho Y+Z\rho Z)$, we see that this new qubit can be interpreted as the original state which suffers from a Pauli error $I,X,Y$ or $Z$ chosen uniformly at random. The set of lost qubits is denoted by ${\mathcal{E}}$. The encoded state is subjected to a random uniform Pauli error $P$ whose support is included in ${\mathcal{E}}$. Denote this condition by $P\subset{\mathcal{E}}$.

Just like when dealing with Pauli noise, one can then measure the stabilizer generators $X_{v}$ and $Z_{f}$ and try to recover the error $P$ from its syndrome. The main difference with Pauli channels is the additional knowledge of the erasure pattern ${\mathcal{E}}$. Since operators of $S$ act trivially on the code space, the goal of the decoder is to identify the coset $P\cdot S$ of the error, knowing the set ${\mathcal{E}}$ and the syndrome $\sigma$ of $P$. The optimal strategy, called maximum likelihood decoding, is to maximize the conditional probability ${\mathbb{P}}(P\cdot S|{\mathcal{E}},\sigma)$.

To illustrate how the knowledge of the erasure ${\mathcal{E}}$ simplifies the decoding problem, assume that we found an error $\tilde{P}\subset{\mathcal{E}}$ whose syndrome matches $\sigma$. Both errors $P$ and $\tilde{P}$ have the same syndrome, hence $\tilde{P}$ and $P$ differ in a logical operator $L\subset{\mathcal{E}}$, trivial or not. Due to the fact that errors $Q\subset{\mathcal{E}}$ are uniformly distributed, ${\mathbb{P}}(Q\cdot S|{\mathcal{E}},\sigma)$ is proportional to the number $|Q\cdot S\cap{\mathcal{E}}|$ of Pauli errors of that coset that are included in ${\mathcal{E}}$. This number depends only on the number $|S\cap{\mathcal{E}}|$ of stabilizers having support inside ${\mathcal{E}}$, which shows that all the cosets are equiprobable. Therefore, maximum likelihood decoding consists simply of returning an error coset $\tilde{P}\cdot S$ such that $P\subset{\mathcal{E}}$ and the syndrome of $P$ is equal to a given $\sigma$. This proves that

The same argument can be applied to any stabilizer code.

A linear-time maximum likelihood decoder – We now propose a fast algorithm that returns such a most likely coset for Kitaev’s surface codes. We detail the construction of the $Z$-part of the error. The same algorithm will be applied to the dual graph to recover the $X$-part of the error.

Only measurements of operators $X_{v}$ can detect a $Z$-error. The syndrome of a $Z$-error $P$ is thus the subset $\sigma(P)\subset V$ of vertices $v$ such that $X_{v}$ anti-commutes with this error. Equivalently, it is the set of vertices surrounded by an odd number of qubits supporting an error $Z$. In order to translate our decoding problem into a graphical language, denote by $\partial(A)$ the set of vertices that a subset $A\subset E$ encounters an odd number of times and call it the boundary of $A$. The syndrome of the $Z$-error pattern supported on $A$ is exactly $\partial(A)$. Given ${\mathcal{E}}\subset E$ and $\sigma\subset V$, we are looking for a subset of edges $A\subset{\mathcal{E}}$ such that $\partial(A)=\sigma$.

We now describe Algorithm 1 which is illustrated on Fig. 1.

Paradoxically, an obstacle to a linear-time complexity is the presence of cycles in ${\mathcal{E}}$. Although cycles increase the number of paths from a vertex to another and potentially make it easier to find one, they also make it easier to make suboptimal choices. Our basic idea is not to try to sequentially find paths that pair the syndrome vertices together but instead to shrink recursively the set of edges on which we have yet to make a decision. To this end we select a spanning forest $F_{\mathcal{E}}$ inside ${\mathcal{E}}$, that is a maximal subset of edges of ${\mathcal{E}}$ that contains no cycle and spans all the vertices of ${\mathcal{E}}$. If ${\mathcal{E}}$ is a connected graph, then $F_{\mathcal{E}}$ is also connected and is called a spanning tree. Such a forest can be found in linear time.

Equipped with the forest $F_{\mathcal{E}}$ that contains all the syndrome vertices, we can now find the required subset $A$ very efficiently. Starting with the empty set, we construct $A$, by applying recursively the following rules.

(R1) Pick a leaf, that is an edge $e=\{u,v\}$ connected to the forest through only one of its 2 endpoints, say $v$. The vertex $u$ is called a pendant vertex. Assume first that $u\in\sigma$, then we add the edge $e$ to the set $A$ and we flip the vertex $v$. By flipping, we mean that $v$ is added to the set $\sigma$ if $v\notin\sigma$ and it is removed from $\sigma$ in the case $v\in\sigma$. Then, $e$ is removed from the forest $F_{\mathcal{E}}$.

(R2) In the case when $u\notin\sigma$, this edge is simply removed from $F_{\mathcal{E}}$ and $A$ is kept unchanged.

Through these 2 steps, we peel the forest $F_{\mathcal{E}}$ until only an empty set remains. The construction of the set $A$ is then complete. This procedure relies on the following obvious remark, stated as a lemma to emphasize the role of the two rules applied in Algorithm 1.

This strategy is guaranteed to end after a finite number of steps. It remains to show that it returns the expected set $A$. We must verify that such a set $A$ exists and that the peeling process does not depend on the order in which leaves of the forest are removed. This is done in the proof of Theorem 1.

During step 3 of the algorithm, a naive approach would be to look for a leaf by running over the forest at each round but this strategy would lead to a super-linear complexity. However, we can ensure linear complexity by running over the whole forest and precomputing a list of leaves. For a bounded degree graph, this list can then be updated in constant time at each round when an edge is removed from the forest.

There exists a subset $B$ such that $B\subset{\mathcal{E}}$ and $\partial(B)=\sigma$ since $\sigma$ is the syndrome of an error. We will reroute the paths contained in $B$ to squeeze this subset inside $F_{\mathcal{E}}$ without changing its boundary. Let $x_{1},\dots,x_{m}$ be the edges of $B\backslash F_{\mathcal{E}}$. By maximality of the forest $F_{\mathcal{E}}$, adding any extra edge $x_{i}$ to $F_{\mathcal{E}}$ creates a cycle $\gamma_{i}\subset F_{\mathcal{E}}\cup\{x_{i}\}$. In order to remove $x_{1}$ from the set $B$, replace $B$ by $B_{1}=B\Delta\gamma_{1}$ where $\Delta$ denotes the symmetric difference of these two sets of edges. Then, $x_{1}\notin B_{1}$, only edges of $F_{\mathcal{E}}$ are added to $B$ and $x_{2},\dots,x_{m}$ are untouched. By repeating this transformation, one creates a sequence $B_{i+1}=B_{i}\Delta\gamma_{i}$ such that $B_{i+1}\subset T_{\mathcal{E}}\cup\{x_{i},\dots,x_{m}\}$ for $i=1,\dots,m$. The last set, $B_{m}$, is included in $F_{\mathcal{E}}$. Taking the symmetric difference with a cycle $\gamma_{i}$ preserves the boundary, i.e. $\partial(B_{i})=\partial(B)$ for all $i$. This proves that the set $B_{m}$ satisfies both conditions $B_{m}\subset F_{\mathcal{E}}$ and $\partial(B_{m})=\sigma$. This is our set $A$.

This set $A$ is unique. Indeed if there exists two such subsets $A$ and $A^{\prime}$, their symmetric difference $A\Delta A^{\prime}$ is a subset of the forest which has a trivial boundary $\partial(A\Delta A^{\prime})=\emptyset$ meaning that $A\Delta A^{\prime}$ is a cycle. Since this cycle is in a forest, it can only be the empty set, proving that $A=A^{\prime}$.

Now that existence and unicity of $A$ are established, we see that the alternative offered by Lemma 2 can only end with the set $A$. The result of our algorithm is independent of the order in which we pick the leaves in step 3 by unicity of $A$. The existence of $A$ garanties that our algorithm finds this set after peeling the whole forest. ∎

Surfaces with boundaries – Kitaev’s construction of surface codes can be generalized to surfaces with boundaries, that is closed surfaces punctured with holes. Introducing boundaries leads to a key simplification for the experimental realization of topological codes. One can obtain non-trivial surface codes based on planar lattices. This motivates the generalization of our decoding algorithm to such surface codes. Two kinds of codes based on surfaces with boundaries have been suggested. First, Freedman and Meyer noticed that one can consider a surface with boundaries Freedman and Meyer (2001). Algorithm 1 can be immediately adapted to these codes. Secondly, Bravyi and Kitaev introduced two different types of stabilizers supported on two types of boundaries Bravyi and Kitaev (1998). Adapting our decoding algorithm to these codes presents two difficulties. First, the syndrome depends on the type of boundary and second, the spanning forest has to be grown in a way that depends on the boundary type.

We use the formalism of Delfosse et al. (2016) that encompasses both generalizations of Kitaev’s codes. We consider a surface $G=(V,E,F)$ with boundary, which means that some edges belong to a unique face. On the boundary, some edges and their endpoints are declared to be open. We denoted by $\partial_{O}E$ (resp. $\partial_{O}V$) these open sets and by $\mathring{V}=V\backslash\partial_{O}V$ and $\mathring{E}=E\backslash\partial_{O}E$ the non-open sets. Qubits are placed on non-open edges and the generalized surface code is defined as the ground space of the Hamiltonian

[TABLE]

where $X_{v}=\prod_{v\in e,e\in\mathring{E}}X_{e}$ and $Z_{f}=\prod_{e\in f,e\in\mathring{E}}Z_{e}$. No qubit is placed on an open edge and open vertices do not support any operator $X_{v}$.

Consider an erasure ${\mathcal{E}}\subset\mathring{E}$ which comes with a Pauli error affecting erased qubits. Again, it suffices to focus on the correction of the $Z$-part of the error. Open vertices do not support any measurement $X_{v}$. Hence, the syndrome of a $Z$-error of support $A\subset\mathring{E}$ is given by the restriction of $\partial(A)$ to non-open vertices. Denote by $\mathring{\partial}(A)\subset\mathring{V}$ this restricted boundary. The missing information on open vertices makes it impossible to reconstruct the error starting from those vertices. We must find a way to peel the whole forest using only non-open vertices. In order to be sure that the peeling algorithm is not stuck before removing all the edges of the forest, we will grow the forest starting from open vertices and peel it the other way round as depicted in Figure 2.

Let us explain Algorithm 2. An example is depicted in Fig. 2. We must adapt the way the spanning forest is obtained. First, let us explain a simple strategy to find a spanning tree of a connected graph $H=(V,E)$. For a general graph, applying this method to all the connected components produces a spanning forest. Our starting point is a tree $T$ that contains only a single arbitrary vertex $v$ of $H$ and no edge. We grow $T$ by adding edges incident to the tree that connect $T$ with a vertex of $H$ that does not already belong to $T$. After adding $|V|-1$ edges, one gets our spanning tree.

In algorithm 2, we will grow a spanning forest of a graph $H=(V,E)$ equipped with a marked subset of vertices $O\subset V$ that we call the seed. The spanning tree of a connected component containing a vertex $v_{O}\in O$ is constructed starting with this vertex $v_{O}$. Then, just as before we add edges that reach new vertices but we also require that these newly reached vertices do not belong to $O$. If the connected component does not contain any seed vertex, the previous method applies.

Then, Lemma 2, which provides the recursive construction of the error, is used in an identical way. We only need to make sure that the pendant vertices $u$ picked in step 3 are not open. Our algorithm picks these vertices by reversing the construction of the forest with open vertices as a seed. This guarantees that one can peel the whole forest and we end up with the correct set $A$ which provides the support of this error. ∎

Concluding remarks – In this work, we considered the decoding problem of surface codes over the quantum erasure channel. Despite the presence of inconvenient short cycles, we managed to design an optimal decoding algorithm that runs in linear time. Our basic idea is to remove these short cycles by decoding within a spanning forest. In the case of classical error correction, studying linear-time decoding from erasures paved the way for better and better linear (or quasi-linear) decoders in the case of more complicated channels. We may hope that in the quantum setting, solving the decoding problem for the erasure channel may similarly lead towards improved decoders for more complicated noise models and other families of codes. In particular, a serious obstacle to decoding quantum LDPC codes is also the presence of short cycles in their Tanner graph. How to deal with them in general remains widely open MacKay et al. (2004); Poulin and Chung (2008); Delfosse and Zémor (2013); Delfosse and Tillich (2014). It is crucial to consider such generalizations that may allow for fault-tolerant universal quantum computation with a considerably reduced overhead Gottesman (2014). One could also consider the correction of losses assuming imperfect gates and measurements Whiteside and Fowler (2014); Suchara et al. (2015) or in the context of linear optical quantum computing where photon losses are a major obstacle Knill et al. (2001); Nielsen (2004); Browne and Rudolph (2005); Kieling et al. (2007).

Acknowledgement – ND thanks Jonas Anderson for his comments on a preliminary version of this work. ND acknowledges funding provided by the Institute for Quantum Information and Matter, an NSF Physics Frontiers Center (NSF Grant PHY-1125565) with support of the Gordon and Betty Moore Foundation (GBMF-2644).