Majorana loop stabilizer codes for error correction of fermionic quantum simulations

TL;DR

This paper introduces the Majorana loop stabilizer code (MLSC), a new geometric locality-preserving fermionic error-correcting code that corrects all single-qubit errors on 2D lattices and is suitable for quantum simulations.

Contribution

The paper presents the MLSC, a novel error-correcting code that improves error correction capabilities and operator weight reduction for fermionic quantum simulations.

Findings

MLSC corrects all single-qubit errors on 2D square lattices.

MLSC maps fermionic operators to lower-weight qubit operators.

MLSC is compatible with quantum chemistry simulation algorithms.

Abstract

Fermion-to-qubit mappings that preserve geometric locality are especially useful for simulating lattice fermion models (e.g., the Hubbard model) on a quantum computer. They avoid the overhead associated with geometric non-local parity terms in mappings such as the Jordan-Wigner transformation and the Bravyi-Kitaev transformation. As a result, they often provide quantum circuits with lower depth and gate complexity. In such encodings, fermionic states are encoded in the common +1 eigenspace of a set of stabilizers, akin to stabilizer quantum error-correcting codes. Here, we discuss several known geometric locality-preserving mappings and their abilities to correct/detect single-qubit errors. We introduce a geometric locality-preserving map, whose stabilizers correspond to products of Majorana operators on closed paths of the fermionic hopping graph. We show that our code, which we refer to as the Majorana loop stabilizer code (MLSC) can correct all single-qubit errors on a 2-dimensional square lattice, while previous geometric locality-preserving codes can only detect single-qubit errors on the same lattice. Compared to existing codes, the MLSC maps the relevant fermionic operators to lower-weight qubit operators despite having higher code distance. Going beyond lattice models, we demonstrate that the MLSC is compatible with state-of-the-art algorithms for simulating quantum chemistry, and can offer those simulations the same error-correction properties without additional asymptotic overhead. These properties make the MLSC a promising candidate for error-mitigated quantum simulations of fermions on near-term devices.

Figures

Equations

$$f_{2k}=c_k^{†}+c_k,f_{2k+1}=i(c_k^{†}-c_k),$$

$$f_k^{†}=f_k,\{f_j,f_k\}=2{\delta }_{j,k},$$

$$\phi f_A,f_A=\prod _{k\in A}{f}_k,$$

$$f_A{f}_B=(-1{)}^{|A|\cdot |B|+|A\cap B|}{f}_B{f}_A.$$

$$\displaystyle c_{k}^{\dagger}c_{k}=\frac{1}{2}\Big{(}\openone+if_{2k}f_{2k+1}\Big{)}\,,$$

$$\displaystyle c_{j}^{\dagger}c_{k}+\mathrm{h.c.}=\frac{i}{2}\Big{(}f_{2j}f_{2k+1}-f_{2j+1}f_{2k}\Big{)}\,.$$

$${\eta }_k=i{f}_{2k}{f}_{2k+1},$$

$${\xi }_{jk}=i{f}_{2j}{f}_{2k},$$

$$\displaystyle c_{k}^{\dagger}c_{k}=\frac{1}{2}\big{(}\openone+\eta_{k}\big{)}\,,$$

$$\displaystyle c^{\dagger}_{j}c_{k}+\mathrm{h.c.}=-\frac{i}{2}\big{(}\xi_{jk}\eta_{k}+\eta_{j}\xi_{jk}\big{)}\,.$$

$${\eta }_j{\eta }_k={\eta }_k{\eta }_j,$$

$${\eta }_l{\xi }_{jk}=(-1{)}^{{\delta }_{jl}+{\delta }_{kl}}{\xi }_{jk}{\eta }_l,$$

$${\xi }_{lm}{\xi }_{jk}=(-1{)}^{{\delta }_{jl}+{\delta }_{kl}+{\delta }_{jm}+{\delta }_{km}}{\xi }_{jk}{\xi }_{lm}.$$

$$(-i{)}^{\ell }{\xi }_{k_0{k}_1}{\xi }_{k_1{k}_2}\cdots {\xi }_{k_{\ell -1}{k}_0}=\text{openone},$$

$${\eta }_k\mapsto {\tilde{\eta }}_k=\prod _{j:(j,k)\in E}{Z}_{jk},$$

$${\xi }_{jk}\mapsto {\tilde{\xi }}_{jk}={ϵ}_{jk}{X}_{jk}\prod _{\begin{array}{c}l:(l,k)<(j,k);\\ (l,k)\in E\end{array}}{Z}_{lk}\prod _{\begin{array}{c}m:(m,j)<(k,j);\\ (m,j)\in E\end{array}}{Z}_{mj},$$

$$S_{k_0{k}_1\cdots k_{\ell -1}}=(-i{)}^{\ell }{\tilde{\xi }}_{k_0{k}_1}{\tilde{\xi }}_{k_1{k}_2}\cdots {\tilde{\xi }}_{k_{\ell -1}{k}_0},$$

$$|\psi ⟩\in \mathcal{C},\text{if and only if}{S}_{k_0{k}_1\cdots k_{\ell -1}}|\psi ⟩=|\psi ⟩,$$

$$\prod _{k=0}^{N_V-1}{\tilde{\eta }}_k=\text{openone},$$

$${\tilde{\eta }}_k\mapsto (-1{)}^{{\delta }_{k,0}}\prod _{j:(j,k)\in E}{Z}_{jk}.$$

$$S_{mnqp}$$

$$=X_{mn}{X}_{nq}{Z}_{nq}{X}_{qp}{Z}_{qp}{X}_{pm}{Z}_{jm}{Z}_{lm}$$

$$=-X_{mn}{Y}_{nq}{Y}_{qp}{X}_{pm}{Z}_{jm}{Z}_{lm},$$

$$\displaystyle\mathcal{S}=\big{\{}S_{k_{0}\hskip 0.4ptk_{1}\hskip 0.4ptk_{2}\hskip 0.4ptk_{3}}\;|\;\text{for all plaquettes}\big{\}}\,.$$

$$S_{mnqp}$$

$$M=\prod _{(j,k)\in E_M}{\tilde{\xi }}_{jk}\prod _{l\in V_M}{\tilde{\eta }}_l,$$

$$X_{mp}:S_{10},S_{13},$$

$$X_{lm}:S_4,S_5,S_6,S_9,$$

$$X_{mn}:S_5,S_{10},$$

$$X_{jm}:S_2,S_5,S_6,S_9,$$

$$B_{\alpha }=i{A}_{\alpha }{C}_{\alpha },\text{for α=0,1,…,15}.$$

$$\{A_{\alpha },A_{\alpha +1}\}=0,\{C_{\alpha },A_{\alpha +1}\}=0,$$

$$[A_{\alpha },C_{\alpha +1}]=0,[C_{\alpha },C_{\alpha +1}]=0.$$

$$S_{\ell }|{\psi }_{\det }⟩=|{\psi }_{\det }⟩,\text{for all}\ell \in L,$$

$${\tilde{\eta }}_k|{\psi }_{\det }⟩=z_k|{\psi }_{\det }⟩,\text{for all}k\in V,$$

$$Z_{jk}|{\psi }_{\mathrm{prod}}⟩=z_{jk}|{\psi }_{\mathrm{prod}}⟩,$$

Full text

I Introduction

We are closer to realizing the potential of quantum computation Feynman (1982); Lloyd (1996); Georgescu et al. (2014) with the recent rapid advances in quantum computing devices such as trapped ions Cirac and Zoller (1995); Kielpinski et al. (2002); Häffner et al. (2008) and superconducting qubits Devoret et al. (2004); Wendin (2017). While performing fault-tolerant quantum computation Fowler et al. (2012) is widely regarded as the ultimate goal, the daunting overheads prevent it from being implemented in the immediate future Devitt et al. (2013); O’ Gorman and Campbell (2017). In the meantime, error-mitigation schemes are likely to be an essential component of near-term quantum algorithms Gottesman (2016); Roffe et al. (2018); McClean et al. (2017); Colless et al. (2018); Temme et al. (2017); Harper and Flammia (2019); McArdle et al. (2019); Bonet-Monroig et al. (2018).

Fermionic systems must be mapped to spin systems before they can be simulated on a digital quantum computer Ortiz et al. (2001). When the spatial dimension is greater than one, mappings such as the Jordan-Wigner (JW) transformation introduce non-local parity terms that act on a large number of qubits. These parity terms add considerable overhead to quantum simulations of local fermionic systems. Clever circuit compilation methods have been introduced to reduce the overhead of the parity terms on digital quantum computers with all-to-all connections Hastings et al. (2015); Wecker et al. (2015). On the other hand, mappings such as the Bravyi-Kitaev (BK) transformation Bravyi and Kitaev (2002) reduces such overheads considerably. However, the resulting qubit operators of the BK transformation are still geometrically non-local. This problem becomes prominent on near-term quantum devices where only short-range qubit-qubit interactions are available Houck et al. (2012); Barends et al. (2016). One way to tackle this problem is to use the fermionic SWAP network to bring together fermionic modes encoded far apart in the JW transformation Bravyi and Kitaev (2002), which offers asymptotically optimal solution to simulating quantum chemistry problems in terms of circuit depth Babbush et al. (2018); Kivlichan et al. (2018); Motta et al. (2018). For other problems, such as the two-dimensional (2D) fermionic Fourier transformation, the fermionic SWAP network is not optimal; this transformation can be implemented with a circuit depth that is quadratically lower in the problem size Jiang et al. (2018).

Fermion-to-qubit mappings that preserve geometric locality avoid the overhead of the fermionic SWAP networks, which is suitable for simulating fermionic systems with short range interactions. Bravyi and Kitaev Bravyi and Kitaev (2002) described a way to map fermionic hopping Hamiltonians defined on a graph $G$ to qubit operators on the edges of $G$ (or more precisely, the vertex-to-edge dual graph of $G$); two qubits can interact with each other if and only if their corresponding edges in $G$ share a common vertex. A stabilizer operator (also called gauge operator in the literature Ball (2005a); Chen et al. (2018)) is introduced for each closed path in the graph $G$, and the fermionic state is encoded in the common $+1$ eigenspace of these stabilizers. This mapping is called the Bravyi-Kitaev superfast (BKSF) transformation Whitfield et al. (2016) or “superfast” encoding Setia et al. (2019), referring to “superfast simulation of fermions on a graph.” This is distinct from the more widely known Bravyi-Kitaev transformation introduced in the same paper Bravyi and Kitaev (2002); the BK transformation does not preserve geometry locality and requires no more qubits than the number of fermionic modes.

Geometric locality-preserving maps are closely related to lattice gauge theories. Levin and Wen Levin and Wen (2003); Wen (2003) showed that particular fermionic lattice models can be described in terms of gauge fields in lattice spin models. Ball Ball (2005b) extended the Levin-Wen result to general fermionic hopping Hamiltonians by introducing auxiliary Majorana modes; Verstraete and Cirac Verstraete and Cirac (2005) discussed a similar map for fermions on $d$-dimensional square lattices, where $d-1$ auxiliary qubits are introduced for each fermionic mode. This approach is called the Ball-Verstraete-Cirac (BVC) transformation or the auxiliary fermion approach. Chen et al. introduced a map similar to the one by BKSF with examples from free fermions on square and honeycomb lattices to the Hubbard model Chen et al. (2018). Recently, Steudtner and Wehner Steudtner and Wehner (2019) also constructed a class of locality-preserving fermion-to-qubit mappings by concatenating the JW transformation with some quantum codes. Applications of locality-preserving maps to quantum simulation were discussed in Whitfield et al. (2016); Setia and Whitfield (2018).

We expect error-mitigation methods to be useful in near-term quantum algorithms, such as the variational quantum eigensolver (VQE) McClean et al. (2016). A crucial step in either VQE or phase estimation is to prepare the initial state, which is often taken to be the ground state of a mean-field approach such as Hartree-Fock. In chemistry, the difference between the mean-field energy and the exact energy is referred to as the “correlation energy”, and despite determining essential elements of chemical bonding, it often only amounts to a few percent of the total energy Helgaker et al. (2002); Hammond et al. (1994). Physically, this is because a large fraction of the energy comes from core electrons that contribute very little directly to chemical bonding. However, because of the energy scale difference, even small errors in this part of the calculation can overwhelm any refinements a quantum computer can provide. Therefore, even a 1% error in the preparation of the mean-field state could render any correlations added by the rest of the circuit fruitless. One can drastically reduce the error rate in state preparation by using an error-detecting code and post selecting the measurement outcomes McArdle et al. (2019); Bonet-Monroig et al. (2018); McClean et al. (2017); Colless et al. (2018). An error detecting code can only detect errors but not correct them; simply knowing that an error has occurred, is much less useful than also being able to fix it. Furthermore, error-detecting codes can also be used for quantum error suppression by creating an energy gap between the code subspace and the orthogonal subspace Young et al. (2013); Bookatz et al. (2015); Jiang and Rieffel (2017).

Recently, Setia et al. Setia et al. (2019) discussed a generalized version of the BKSF transformation and their relations to error-correcting codes. A no-go theorem was also proven in Setia et al. (2019) showing that the BKSF defined on graphs with vertex degree $d\leq 6$ cannot correct all single-qubit errors. Here, we introduce a type of geometric locality-preserving mappings based on the BKSF, called Majorana loop stabilizer code (MLSC). The MLSC on a square lattice (vertex degree 4) can correct all single-qubit errors while the BKSF can only detect single-qubit errors. It is usually harder to implement codes with higher distances due to the higher weights of the logical operators. One the contrary, the logical operators relevant to fermionic simulations in a MLSC typically have lower weights than those in BKSF, making it easier to implement. The stabilizers in the MLSC, however, usually have higher weights than those in the BKSF. This is less of a problem in near-term experiments, where stabilizer measurements should only be implemented sparsely due to the large overhead (time and fidelity) associated with measurements and classical feedback loops. The complication of syndrome measurements can also be mitigated using a method recently introduced by the authors in McClean et al. (2020), where syndrome detection is achieved by classical post processing; the drawback of this approach is that it can only be applied to the very last round of stabilizer measurements. Even without the error-correction properties, the circuits associated with simulating lattice models using MLSC are as small as the best circuits in any prior work. The MLSC is reasonably practical to implement in experiment, and perhaps more importantly, develop schemes on encoded quantum simulations of fermions that offer an advantage over unencoded approaches.

Previously, mappings which preserve geometric locality had only seemed practical as a strategy for simulating lattice fermion models. While one could apply BKSF and MLSC directly to the Hamiltonians of arbitrary fermion models, such as those encountered in quantum chemistry, doing that is highly impractical as the number of qubits required would scale like the number of terms in a fully connected one-body fermion operator, which scales generically $O(N^{2})$ for arbitrary electronic structure models with $N$ orbitals). However, here we describe a simple technique which allows one to perform quantum chemistry simulations within the MLSC (or BKSF) so that one can benefit from the error-correction properties of the MLSC, without any asymptotic increase in the spatial complexity or gate complexity. The essential insight is that one can implement certain Hamiltonian simulation algorithms within these codes without explicitly encoding the actual Hamiltonian being simulated. Rather than encoding the quantum chemistry Hamiltonian, we propose that one use the MLSC to encode a two-dimensional lattice of fermions. Then, using techniques from Motta et al. (2018) one can decompose the quantum chemistry Hamiltonian into a representation that can be efficiently simulated with only nearest-neighbor gates Kivlichan et al. (2018). Because only nearest-neighbor fermionic interactions are required, the MLSC on a lattice is sufficient to encode all of the required gates. This makes our techniques as applicable for chemistry as for lattice models.

In Sec. II, we review some properties of the Majorana fermions that are crucial to the rest of paper. In Sec. III, we review the BKSF and how it can be used to detect single-qubit errors. In Sec. IV, we introduce the Majorana loop stabilizer code and discuss how to use them to correct single-qubit errors. In Sec. V, we discuss how to construct MLSC with open boundary conditions. In Sec. VI, we discuss how to encode a single Slater determinant with locality preserving mappings. In Sec. VII, we discuss how these encodings may be useful for simulating fermion models with high degree connectivity, such as those encountered in quantum chemistry. In Sec. VIII, we conclude the paper. In App. A, we briefly review quantum error-correcting codes. In Apps. B and C, we discuss how to construct quantum error-correcting/detecting codes from the auxiliary fermion approaches. In Apps. D, we discuss how to construct general MLSCs.

II Majorana operators

In this section, we review some properties of the Majorana operators which will be used to construct the mappings in the later sections. The Majorana operators have the advantage of being Hermitian and unitary at the same time (self-inverse). They also allow for treating all the fermionic operators on an equal footing. The single-mode Majorana operators are defined as linear combinations of the fermionic ladder operators

[TABLE]

where $c_{k}^{\dagger}$ and $c_{k}$ are the fermionic creation and annihilation operators, respectively. They satisfy the simple relations

[TABLE]

where $\{\cdot\,,\,\cdot\}$ is the anticommutator and $\delta$ the Kronecker delta function.

The single-mode Majorana operators $f_{0},f_{1},\ldots,f_{2n-1}$, together with the phase factor $i$, generate a group $\mathcal{M}_{2n}$. An arbitrary element in $\mathcal{M}_{2n}$ takes the form

[TABLE]

where $\varphi\in\{\pm 1,\pm i\}$ is an overall phase factor. The set $A\subseteq\{0,1,\ldots,2n-1\}$ is the support of the Majorana operator. The order of the operators in the product $f_{A}$ matters, and we follow the convention that the index $k$ increases monotonically from left to right. The weight of a Majorana operator equals the number of fermionic modes that it acts non-trivially on, i.e., the weight of $f_{A}$ is $\lvert A\rvert$. Two Majorana operators $f_{A}$ and $f_{B}$ either commute or anticommute,

[TABLE]

The commutation relationship is determined by the parity of the overlap $\lvert A\cap B\rvert$ when either $\lvert A\rvert$ or $\lvert B\rvert$ is even.

In terms of Majorana operators, the fermionic occupation operator reads

[TABLE]

where $\openone$ is the identity operator. The fermionic hopping term takes the form

[TABLE]

For now we will focus on problems where fermions can only hop between neighboring vertices of a undirected graph $G(V,E)$, with vertices $V$ and edges $E$ (later we will explain how these techniques can be used to simulate models with arbitrary interactions, such as those in quantum chemistry). Consider the following set of quadratic Majorana operators

[TABLE]

The occupation term (5) and the hopping term (6) can be expressed as

[TABLE]

The operators in Eq. (7) generate a group $\mathcal{M}_{2n}^{\mathrm{even}}$, consisting of Majorana operators of even weights. Any physical fermionic Hamiltonian can be written as a sum of elements in the group $\mathcal{M}_{2n}^{\mathrm{even}}$.

The quadratic Majorana generators in Eq. (7) are both Hermitian and unitary. They satisfy the commutation relations Bravyi and Kitaev (2002)

[TABLE]

In addition to Eq. (9), we introduce the following condition on any closed path in the graph $G$ to close the algebra,

[TABLE]

where $\ell$ is the length of the path. This relation implies that the generators in Eq. (9) are not independent. The total number of independent closed paths is $N_{E}-N_{V}+1$, where $N_{V}$ ($N_{E}$) is the total number of vertices (edges) of the graph $G$. In the next section, we will see that the condition (10) is not automatically satisfied when the fermion operators are mapped to qubit operators.

III The Bravyi-Kitaev superfast transformation

In this section, we review the fermion-to-qubit mapping introduced by Bravyi and Kitaev that conserves geometry locality Bravyi and Kitaev (2002). This mapping was called Bravyi-Kitaev superfast (BKSF) transformation Whitfield et al. (2016) or superfast encoding Setia et al. (2019), referring to “superfast simulation of fermions on a graph.” Concerning the Hubbard model, it was shown that the BKSF has an advantage over the JW transformation and the BK transformation in terms of total number of gates Havlíček et al. (2017). Here, we also show how to use the BKSF to detect (but not correct) all single-qubit errors on a 2D square lattice.

Bravyi and Kitaev considered fermionic hopping problem defined on a graphs $G$, where fermions can hop between neighboring vertices. One qubit is introduced for each edge of the graph $G$, and the fermionic state is encoded in a subspace of the qubits, see Fig. 1.

The goal is to find qubit operators that share the same algebra as the fermionic operators, e.g., Eqs. (9) and (10). To achieve that, we first choose an arbitrary ordering of the incident edges for each vertex of $G$, e.g., $(l,k)<(j,k)$ means that the edge $(l,k)$ is placed before $(j,k)$ among all the incident edges of the vertex $k$. The quadratic Majorana operators in Eq. (9) can be mapped to the qubit operators by

[TABLE]

where the antisymmetric coefficients $\epsilon_{jk}=-\epsilon_{kj}=\pm 1$ can be chosen arbitrarily for each edge $(j,\,k)$. The qubit operators $\tilde{\eta}_{k}$ and $\tilde{\xi}_{jk}$ satisfy the same commutation relations as those of the fermionic operators in Eq. (9).

The qubit operator corresponding to the conserved quantity in Eq. (10) is

[TABLE]

which remains unchanged under any cyclic permutation of the indices $k_{0},k_{1},\ldots,k_{\ell-1}$. These loop operators form an Abelian group, and the fermionic state is encoded in their common $+1$ eigenspace. We refer these operators as stabilizer operators. They are also called gauge operators in the literature, not to be confused with the noncommuting gauge operators in subsystem quantum error-correcting codes Bacon (2006). As a consequence of the commutation relations (9), the stabilizers commute with all the logical operators $\tilde{\eta}_{k}$ and $\tilde{\xi}_{jk}$. They also commute with each other, and their common $+1$ eigenspace define the code subspace $\mathcal{C}$,

[TABLE]

for all closed paths $(k_{0},k_{1},\ldots,k_{\ell-1},k_{0})$ in the graph $G$. Hence, the restriction of the closed loop stabilizers to the code space act as the identity, as in the case of the Majorana operators.

The mapping (11) artificially introduces an extra conserved quantity,

[TABLE]

which corresponds to the even-parity subspace of the original fermionic system. To simulate the odd-parity subspace, one can change the sign in the mapping (11) for a particular value of $k$, say $k=0$,

[TABLE]

The stabilizer operators in the BKSF can be used for quantum error detection/correction if implemented properly. This idea was also discussed recently in Setia and Whitfield (2018), where a no-go theorem was proved: the BKSF cannot correct all single-qubit errors if $d\leq 6$, where $d$ is the vertex degree of the graph $G$. Here, we show that BKSF can detect all single-qubit errors on a 2D square lattice by properly choosing the orders of the incident edges.

Consider the BKSF encoding of spinless fermionic modes on a 2D lattice, see Fig. 2; the ordering of the edges associated with a vertex is indicated by the numbers next to it.

We use the convention that $\epsilon_{jk}=1$ if the site $k$ is to the right or below the site $j$; under this convention, we have $\epsilon_{k_{0}k_{1}}\epsilon_{k_{1}k_{2}}\cdots\epsilon_{k_{\ell-1}k_{0}}=1$ for any closed path. The closed paths containing the smallest number of edges are plaquettes. The stabilizer operator corresponding to the plaquette $(m,n,q,p,m)$ is the product of the corresponding edge operators, see Fig 3,

[TABLE]

where we used the condition $\epsilon_{mn}\hskip 0.4pt\epsilon_{nq}\hskip 0.4pt\epsilon_{qp}\hskip 0.4pt\epsilon_{pm}=+1$.

These plaquette operators generate the stabilizer group,

[TABLE]

The syndrome of a Pauli error can be described by the set of plaquette stabilizers with which it anticommutes. The single-qubit error $Z_{lm}$ anticommutes with two stabilizers, $S_{i\hskip 0.4ptj\hskip 0.4ptm\hskip 0.4ptl}$ and $S_{l\hskip 0.4ptm\hskip 0.4ptp\hskip 0.4pto}$. In general, a Pauli-$Z$ error anticommutes with all the stabilizers involving the edge on which it acts. The single-qubit error $X_{lm}$ anticommutes with only two stabilizers, $S_{i\hskip 0.4ptj\hskip 0.4ptm\hskip 0.4ptl}$ and $S_{m\hskip 0.4ptn\hskip 0.4ptq\hskip 0.4ptp}$. The same holds true for the single-qubit error $X_{jm}$; therefore, these two errors have the same syndrome and can only be detected but not corrected. The Pauli error $Y_{lm}$ anticommutes with $S_{l\hskip 0.4ptm\hskip 0.4ptp\hskip 0.4pto}$ and $S_{m\hskip 0.4ptn\hskip 0.4ptq\hskip 0.4ptp}$, which has the same syndrome as $Z_{mp}$. In App. G, we list the syndromes of all the single qubit errors for the BKSF on an infinite lattice with the specific edge ordering in Fig. 2. These results show that all single-qubit errors can be detected, but some of them share the same syndromes and cannot be corrected. One has to be careful for open-boundary conditions; for example, the Pauli-$Y$ errors at the bottom of an open lattice commute with all stabilizers and cannot be even detected.

IV Majorana loop stabilizer codes

A natural question to ask is whether the BKSF on a square lattice can correct all single-qubit errors. The no-go thereom in Setia et al. (2019) implies that the BKSF on a 2D (or even 3D) square lattice cannot correct all single-qubit errors. An example was also given in Setia et al. (2019) to get around the no-go theorem lattice by introducing extra ancillary vertices and edges, which increase the degree of the original vertices from $4$ to $8$ on 2D square lattices. Here, we introduce a geometric locality-preserving fermion-to-qubit map that correct all single-qubit errors on 2D square lattices, without introducing any additional vertices or edges. Compared to the BKSF, logical operations can also be implemented with lower-weight Pauli operators with our code. In Apps. D, we discuss two methods to construct these codes in general.

Similar to the BKSF, the logical operators in our code satisfy the commutation relations of the quadratic Majorana operators in Eq. (9). The stabilizers (13) of the code also correspond to the products of Majorana operators on a loop. Therefore, we call our construction the Majorana loop stabilizer code (MLSC); the BKSF is a special case of the MLSC. The logical operators are allowed to be more general, e.g., non-uniform with respect to vertices and may involve Pauli-$Y$ operators. This modification allows the MLSC to evade the no-go theorem in Setia et al. (2019). We discuss the code using the 2D square lattice as an example, see Fig. 4;

each circle therein represents a vertex (fermionic mode), and its color indicates the type of the vertex. There is one stabilizer operator associated with each plaquette (4 vertices), and its color indicates the type of the stabilizer.

The logical operators and the stabilizer related to a red plaquette, e.g., the one consisting of the vertices $m$, $n$, $q$, and $p$, are plotted in Fig. 5.

The Pauli operators $X$, $Y$, and $Z$ therein act on the qubits on the corresponding edges. Each quadratic Majorana operator in Eq. (7) is mapped to a product of single-qubit Pauli operators linked by a line. The vertex operator $\eta_{m}$ is mapped to a product of three Pauli-$Z$ operators linked by a curved dashed line around the site $m$, and similar for the other vertex operators. The edge operator $\xi_{mn}$ is mapped to the Pauli operator $Z\otimes X\otimes Y\otimes Z$ on the upper dotted line, where the only Pauli-$X$ operator acts on the edge $(m,n)$. The same rule applies to the remaining edge operators $\xi$, where the Pauli-$X$ operator always acts on the corresponding edge of $\xi$. These operators satisfy the commutation relations from (9), which is easily verified numerically. The stabilizer associated with the plaquette is plotted in Fig. 5b, up to an overall minus sign.

[TABLE]

where we use the same definition (13) and convention as in the BKSF example; $\epsilon_{jk}=1$ if the site $k$ is to the right of, or below the site $j$. For nomenclature purpose, we refer terms such as $\xi_{mn}$, $\xi_{mn}\eta_{m}$, $\xi_{mn}\eta_{n}$, or $\xi_{mn}\eta_{m}\eta_{n}$ as generalized edge operators. The weight of any generalized edge operator in the red plaquette is greater or equal to three. This is a necessary condition for correcting all single-qubit errors. The BKSF violates this condition on a 2D lattice no matter how the incident edges are ordered.

The entire code can be constructed by putting together the four types of vertices illustrated in Fig. 5a, where each Pauli-$X$ operator is shared by two neighboring vertices. For clarity, we plot the logical operators in the green plaquette consisting of the vertices $l$, $m$, $o$, and $p$ in Fig. 6;

the logical operators and the stabilizer of the yellow plaquette consisting of the vertices $i$, $j$, $l$, and $m$ are plotted in Fig. 7;

the logical operators of the blue plaquette consisting of the vertices $j$, $k$, $m$, and $n$ are plotted in Fig. 8.

Any generalized edge operator in the green, yellow, or blue plaquette also has weight $w\geq 3$.

We now go a step further to argue that any logical operator $M\not\in\mathcal{S}$ must have weight $w\geq 3$. Up to an overall sign such an operator can be specified as

[TABLE]

where $E_{M}$ and $V_{M}$ are the sets of edges and vertices that determines $M$. Without loss of generality, we assume that for any vertex $j\in V_{M}$ there must be an edge $(j,k)\in E_{M}$ for some vertex $k$; otherwise, the weight of $M$ can be reduced by removing $j$ from $V_{M}$ (the only exception is that removing $\tilde{\eta}_{k}$ from $\tilde{\eta}_{j}\tilde{\eta}_{k}\tilde{\eta}_{m}$ in Fig. 8 increases its weight from 5 to 6). We refer to a vertex $j$ as a single-paired vertex if exactly one of its incident edges is in $E_{M}$; at least one Pauli-$Z$ operator on the other three incident edges of $j$ contributes to $M$ no matter whether $j\in V_{M}$ or not. If there are more than one single-paired vertex in $V_{M}$, the weight of $M$ must be greater than, or equal to three; this is because there must be some Pauli-$X$ or $Y$ components in $M$ to make it anticommute with the vertex operators on the single-paired vertices, besides at least two Pauli-$Z$ operators associated with the single-paired vertices. When $V_{M}$ contain two edges, the only case with less-than-two single-paired vertices is two parallel edges sitting next to each other. One can check that the weights of such logical operators are always greater than, or equal to three in Figs. 5-8. The specific choice of the vertex layout in Fig. 4 is important to preventing the opposite from happening.

To make the discussion of the syndromes of the single-qubit errors easier, we label the stabilizers in Fig. 9.

The syndrome of a single-qubit error can be described by the stabilizer operators which anticommute with it. Here, we list the syndromes of the single-qubit errors on all the incident edges of the vertex $m$ in Fig. 9,

[TABLE]

These single-qubit errors (Pauli-$Y$ errors not listed) have different syndromes. We have checked that all the single-qubit errors have different syndromes on an $8\times 8$ lattice with periodic boundary conditions (128 qubits).

To simulate lattice fermion problems, we often need to implement the hopping term $c_{j}^{\dagger}c_{k}+c_{k}^{\dagger}c_{j}$ and the occupation term $c_{k}^{\dagger}c_{k}$, see Eqs. (8a) and (8b). With the 2D BKSF in Fig. 2, both the vertical and horizontal hopping terms are mapped to qubit operators of weight $6$. With our code, the hopping terms are mapped to qubit operators of weight no more than $4$ (sometimes $3$); the occupation terms can also be implemented with lower-weight qubit operators. Being able to implement logical operations with low-weight Pauli operators while correcting all single-qubit errors is a desired feature for near-term quantum error-mitigating schemes. The weights of the stabilizers in our code range from $4$ to $10$. Measurements are often the bottleneck in error-corrected quantum computation implemented on near-term devices. For example, it can take up to $\sim 1$\mathrm{\SIUnitSymbolMicro s} to readout the state of a superconducting qubit with fidelity $\sim 0.95$, while the typical two-qubit gate time is $\sim 40$\mathrm{ns} with fidelity $\sim 0.995$. Syndrome readouts should only be performed sparsely on these near-term devices, e.g, per syndrome readout cycle for at least tens of logical gate cycles. The total number of gates, therefore, is dominated by the logical operations and not the syndrome readout. In a recent work by some of the authors, a scheme is proposed to decipher syndromes using classical post-processing McClean et al. (2020). This scheme avoids both complicated syndrome measurements and additional ancilla qubits for the measurements, and can be used to readout the higher-weight stabilizers.

In Fig. 10, we summarize the differences between our code and the BKSF on a 2D lattice.

V Open-boundary conditions

In the last section, we discussed MLSCs defined on lattices with periodic boundary conditions. In realistic experimental setups, however, periodic boundary conditions are usually unavailable or very costly to have. In this section, we provide a procedure to construct MLSCs with open boundary conditions that correct all single-qubit errors.

Boundary effects are significant for lattices of modest sizes; for instance, most of the vertices are located at the boundaries in a $4\times 4$ square lattice. Errors on the boundary qubits are more difficult to correct, because they are involved in a smaller number of stabilizers, i.e., less syndromes can be used to correct/detect the errors. This problem is especially prominent for qubits around the corners of a lattice, where two boundary edges meet. For this reason, using the MLSC introduced in the last section on lattices with open boundary conditions results in uncorrectable single-qubit errors. Here, we discuss how to circumvent that using an example where dangling boundary edges are added to a $4\times 4$ square lattice, see Fig. 11.

Just like the bulk of the code, we put one physical qubit on each dangling boundary edge (dashed red). The logical operators, including all the vertex operators and edge (black solid) operators, are defined using the same rules as the MLSC introduced in the last section. This is possible because any vertex (edge) operator of a MLSC only involves the Pauli operators on the edges incident on that vertex (edge), i.e, logical operators in the bulk of the code has no support beyond the dangling edges. Therefore, the commutation relations (9) are satisfied, and the stabilizers in the bulk of the code $S_{0}\,,S_{1}\,,\ldots,S_{8}$ remain the same as those in the periodic boundary case. Introducing the dangling edges adds extra degrees of freedom, which allow us to construct additional stabilizers $B_{0}\,,B_{1}\,,\ldots,B_{15}$ to correct errors at the boundaries. Since the number of boundary stabilizers is equal to the number of dangling edges, the extra degrees of freedom are eliminated. Because each qubit at (or close to) the boundary is involved in more stabilizers, errors on them are more likely to be correctable.

To define the boundary stabilizers, we first introduce the edge operators associated with the dangling edges. We denote these operators as $D_{0}\,,D_{1}\,,\ldots,D_{15}$ starting with the vertical dangling edge of the vertex $i$ and counting clockwise along the boundaries. These operators are defined using a similar rule as the edge operators in the bulk of the code, but Pauli operators on edges beyond the dangling edges are neglected. For example, the operator $D_{0}$ associated with the vertical dangling edge incident on vertex $j$ is plotted in Fig. 12.

Each dangling edge operator anticommutes with the vertex and edge operators incident on it. As a consequence, the dangling edge operators commute with all the stabilizers in the bulk of the code $S_{0}\,,S_{1}\,,\ldots,S_{8}$.

We then introduce the operators $A_{0}\,,A_{1}\,,\ldots,A_{15}$, defined as the products of all the edge operators in a boundary plaquette. For example, $A_{0}$ is the product of the two dangling edge operators incident on vertex $i$ ($D_{0}$ and $D_{15}$), while $A_{1}$ is the product of the edge operators on $(i,\,j)$ and the two vertical dangling edge operators incident on vertices $i$ and $j$ ($D_{0}$ and $D_{1}$). These operators commute with all the logical operators, because each logical operator anticommutes with either zero or two edge operators in $A_{\alpha}$. However, neighboring operators $A_{\alpha}$ and $A_{\alpha\pm 1}$ (mod 16) anticommute with each other. For example, $D_{0}$ anticommutes with $A_{1}$, while $D_{15}$ commute with $A_{1}$; therefore, $A_{0}=D_{0}D_{15}$ anticommutes with $A_{1}$.

To construct boundary stabilizers that commute with each other, we introduce the conjugate operator for each dangling edge; these are denoted as $C_{0}\,,C_{1}\,,\ldots,C_{15}$, starting with the vertical dangling edge of the vertex $i$ and counting clockwise along the boundary. The conjugate operator $C_{\alpha}$ anticommutes with $D_{\alpha}$, but commutes with all the logical operators and $D_{\beta}$ for $\beta\neq\alpha$. The conjugate operators also commute with each other $[C_{\alpha},\,C_{\beta}]=0$ for all $\alpha,\beta=0,\ldots,15$. When all of the edge operators incident on a dangling edge only have the Pauli-$Z$ component on it, the conjugate operator is simply the single-qubit Pauli-$Z$ operator on the corresponding dangling edge. For example, $C_{15}$ is equal to the Pauli-$Z$ operator on the horizontal dangling edge incident on vertex $i$. The situation is more complicated when some edge operator has a Pauli-$Y$ component on the dangling edge. For example, $C_{0}$ is the product of the Pauli-$Z$ operators on the edge $(i,\,j)$ and the two vertical dangling edges incident on $i$ and $j$. In general, these operators are defined as the product of Pauli-$Z$ operators on the dangling edge, a second edge whose edge operator has a Pauli-$Y$ component on the dangling edge, and a neighboring dangling edge (if it exists) whose edge operator has a Pauli-$Y$ component on the second edge.

We now define the boundary stabilizers as

[TABLE]

These operators commute with all the logical operators and the stabilizers in the bulk. They also commute with each other; e.g., we have $[B_{\alpha},\,B_{\alpha+1}]=0$ using the commutation relations

[TABLE]

In Figs. 13-15, we plot the boundary stabilizers $B_{0}$, $B_{1}$, and $B_{2}$.

We have checked numerically that any Pauli operator with weight one or two anticommutes with at least one of the stabilizers; therefore, the code distance is three and all single-qubit errors are correctable.

The types of corner vertices have to be chosen very carefully: the upper-left vertex has to be red, the upper-right vertex has to be green…Any choice of corner vertices different from those in Fig. 11 leads to single-qubit errors with colliding syndromes. One can construct open boundary MLSCs of larger sizes using the same procedure discussed here for the $4\times 4$ lattice.

VI Encoding a Slater determinant

In this section, we discuss how to encode a single Slater determinant with MLSC in circuit depth $O(1)$. For simplicity, we only consider Slater determinants in the computational basis; arbitrary Slater determinants can be prepared by applying single-particle basis transformations to these determinants. The encoded Slater determinant is a common eigenstate of the stabilizers and the vertex operators,

[TABLE]

where $L$ consists of a complete set of independent closed paths in $G$, and $z_{k}=\pm 1$ indicates whether the $k$th fermionic site is unoccupied or occupied. We start from a product state in the computational basis

[TABLE]

where $Z_{jk}$ is the Pauli-$Z$ operator on the edge $(j,k)$.

We first consider the case of BKSF. The eigenvalues $z_{jk}=z_{kj}$ are chosen such that

[TABLE]

There are some freedoms in assigning the values $z_{jk}$; one for each independent closed paths in $G$. The constraints in Eq. 31 can be converted to a system of linear equations over $GF(2)$ by mapping $z_{jk}\pm 1$ to the binary values [math] and $1$. When a Hamiltonian path $(0,1,\ldots,\ell-1)$ of the graph $G$ is known, we can assign the values of $z_{jk}$ in the Hamiltonian path according to

[TABLE]

where $k=1,2,\ldots,\ell-2$. We then assign the value $+1$ to all of the remaining $z_{jk}$, and the condition (31) is satisfied. More generally, we can assign values to $z_{jk}$ with the following three steps.

Find a spanning tree $T$ of the graph $G$, which takes time linear in $\lvert V\rvert$. 2. 2.

Assign the values in $T$ starting from the leaves towards the root; if $j$ is a parent node of $k$, let $z_{jk}$ be the product of $z_{k}$ and $z_{kl}$ for all the children $l$ of $k$. 3. 3.

Set the value of the remaining edges that are not in $T$ to $+1$.

This algorithm requires that the total parity of the vertex operators be even as each Pauli-$Z$ on the edges of the spanning tree appears in two vertex operators. In App. E, we also present an algorithm to assign values to $z_{jk}$ without using a Hamiltonian path or a spanning tree.

With the MLSC in Sec. IV, not all the incident edges participate in the vertex operator $\tilde{\eta}_{k}$, and the condition (31) is modified to

[TABLE]

where $E_{k}$ is the set of edges that are involved in $\tilde{\eta}_{k}$. We use the notion $E^{\prime}$ to denote the set of edges $(j,k)$ such that $(j,k)\in E_{j}$ and $(j,k)\in E_{k}$. One can assign values to $z_{jk}$ with the following four steps.

Check the total parity of the vertex operators for each connected part of the graph $(V,E^{\prime})$. 2. 2.

If the parity is odd, find an edge $(j,k)$ in the connected part such that $(j,k)$ is involved in $\tilde{\eta}_{j}$ but not $\tilde{\eta}_{k}$, set the value of $z_{jk}$ to $-1$. 3. 3.

Find a spanning tree of the connected part and use the algorithm for BKSF to assign the values to the edges in the spanning tree, 4. 4.

after going through all the connected parts, set the values of the remaining edges to $+1$.

The resulting state $\lvert\,\psi_{\mathrm{prod}}\,\rangle$ is an eigenstate of all the vertex operators with the prescribed eigenvalues,

[TABLE]

We then measure the values of the stabilizer operators $S_{\ell}$ and record the measurement results as $s_{\ell}$. Since the stabilizers commute with the operators $\tilde{\eta}_{j}$, the post-measurement state satisfies

[TABLE]

Generally, some of the measurement results of the stabilizers will be $-1$. One simple way to resolve this problem is to reassign the values $\epsilon_{jk}$ in Eq. (12), and the signs of the stabilizers change accordingly. This procedure corresponds to encoding the fermionic state in a different subspace of the stabilizers; the signs of logical operators change accordingly. The reassignment is straightforward when there is a known Hamiltonian path in $G$. We keep $\epsilon_{jk}$ unchanged for all the edges $(j,k)$ in the Hamiltonian path. Any remaining edge $\epsilon_{lm}$ along with a section in the Hamiltonian path form an independent closed path. We flip the value of $\epsilon_{lm}$ if the measurement outcome of the corresponding stabilizer is $-1$. More generally, the reassignment of $\epsilon_{jk}$ can be achieved with three final steps.

Find a spanning tree $T$ of the graph $G$. 2. 2.

Assign the original value $\epsilon_{jk}$ to all of the edges $(j,k)$ in the spanning tree $T$. 3. 3.

Flip the sign of any remaining term if the measurement outcome of the stabilizer is $-1$.

VII Extension to more general fermion models

In a more general context than the lattice models discussed thus far, one may wish to consider the quantum simulation of interacting fermion models with a high degree of connectivity. For example, the molecular electronic structure Hamiltonian, central to quantum chemistry, can be expressed as

[TABLE]

where the scalars $h_{pq}$ and $h_{pqrs}$ are obtained by integrating the Coulomb and kinetic operators over a discrete basis set Helgaker et al. (2002). This Hamiltonian has ${O}(N^{2})$ terms in the one-body operator where $N$ is the number of orbitals (basis functions) into which the system is discretized. Thus, directly applying the MLSC or BKSF to (37) would require $O(N^{2})$ qubits, which is an unacceptable overhead in most contexts.

However, rather than directly encoding the Hamiltonian for the system we wish to simulate, we might instead consider encoding the algorithm that we would use to perform the simulation. Specifically, if we can realize a simulation of (37) (or more generally, any algorithm) using only a gate set defined in terms of evolution under fermionic operators on a lattice, then we can encode that algorithm into the MLSC or BKSF representation with only a constant factor increase in the number of qubits, thus making the error-correction properties of these encodings practical to utilize in a much more general context. In fact, some of the most efficient algorithms for simulating the Hamiltonian of (37) already meet these requirements. We will now discuss one such algorithm.

Without loss of generality one can perform a tensor factorization of the Coulomb operator to express the Hamiltonian $H$ of (37) as

[TABLE]

where $f_{p}$ and $g_{pq}^{(\ell)}$ are scalars, $L=O(N)$ for chemistry but $L=N^{2}$ in general, and $R_{\ell}$ is a unitary rotation of the single-particle orbital basis. The work of Motta et al. (2018) suggests simulating the chemistry Hamiltonian in this representation by performing a Trotter step of time-evolution $e^{-i\delta tH}$ for short duration $\delta t$ as

[TABLE]

Key to this approach are algorithms introduced in Kivlichan et al. (2018) which enable exact realization of both $R_{\ell}$ and time-evolution under $\sum_{pq}g_{pq}n_{p}n_{q}$, each using $O(N^{2})$ applications of nearest-neighbor gates from a set generated only by the following nearest-neighbor fermion terms: $n_{p}$, $n_{p+1}$, $n_{p}n_{p+1}$, and $(a^{\dagger}_{p}a_{p+1}+a^{\dagger}_{p+1}a_{p})$. Crucially, all of these fermion terms are represented within the BKSF or MLSC applied to a planar lattice. Thus, the entire Trotter step requires only ${O}(LN^{2})$ gates within either the BKSF or MLSC (which translates to ${O}(N^{3})$ gates in the case of chemistry, matching the lowest known gate complexity of a Trotter step of this Hamiltonian Motta et al. (2018)) and requires only $2N$ qubits. One would use the BKSF or MLSC encoding on a 2D lattice and then snake a 1D path through this lattice over which these nearest-neighbor algorithms are implemented in the code.

While physical fermionic particles only exhibit one- and two-body interactions (and thus can always be simulated with the approach mentioned above), certain effective models may involve 3-body or higher fermion interactions. These models can also be efficiently simulated within the MLSC or BKSF representation with only $2N$ qubits. For this, one can use the higher order fermionic swap network strategies introduced recently in O’Gorman et al. (2019) which generalize the results of  Kivlichan et al. (2018) to enable Trotter steps of time-evolution under arbitrary $k$-body fermion models using a number of nearest-neighbor gates scaling as ${O}(N^{2k})$. In this approach, the total number of gates required for quantum chemistry ($k=2$) would be ${O}(N^{4})$ which is less efficient than the method described above.

Esssentially, by encoding a lattice fermion Hamiltonian whose individual terms generate all of the gates in these algorithms we are able to leverage the error-correction properties of the MLSC and BKSF in a more general context than lattice models. While it seems reasonable that leveraging these error-correction properties could improve prospects for simulating high degree fermion models such as quantum chemistry in the NISQ era, the practical performance of these codes is still an open question, which should be analyzed in more detail and ultimately, tested experimentally.

VIII Conclusion

While hardware that supports full fledged fault-tolerant schemes is still unavailable, error mitigation schemes are likely to be an essential part of quantum algorithms in the NISQ era Preskill (2018). A merit of these near-term quantum error-mitigating schemes is to be flexible to the hardware and the problem being implemented. We consider error correction/detection in quantum simulation of many-body fermonic systems with geometrically local interactions (short range), e.g., the Hubbard model. The geometric locality of the fermion Hamiltonian is often lost when they are mapped to qubits using conventional methods, such as the Jordan-Wigner transformation. Locality-preserving fermion-to-qubit maps prevent this by encoding the original fermions into a subspace of the qubit operators corresponding to the common $+1$ eigenstates of a set of stabilizer operators. This makes sure that parity is conserved when fermions transit around closed paths.

Geometric locality-preserving mappings also allow for quantum error correction/detection, and one of the leading candidates is the superfast encoding presented by Bravyi and Kitaev Bravyi and Kitaev (2002). Indeed, we demonstrate that the Bravyi and Kitaev encoding can detect all single-qubit errors on a 2D square lattice when the orders of the incident edges are chosen properly. Very recently, it was proved that the Bravyi-Kitaev superfast encoding cannot correct all single-qubit errors on graphs with vertex degree less or equal to six Setia et al. (2019). We get around this no-go theorem by introducing a mapping that is more general than the original Bravyi-Kitaev superfast encoding. We call it a Majorana loop stabilizer code, meaning that the stabilizers are constructed from products of Majorana fermion operators on closed paths. We show that these codes can correct all single-qubit errors on 2D square lattices with vertex degree four. The logical operators in our code can also be implemented with Pauli-operators with lower weights compared to the Bravyi-Kitaev superfast encoding. We also discuss how to encode a single Slater determinant with the Majorana loop stabilizer code in circuit depth $O(1)$. Finally, we were able to show that these codes are actually useful for performing quantum chemistry simulations without any additional asymptotic overhead and that the error-correcting properties of these codes can be realized for any algorithm that can be realized in terms of fermionic operations on a lattice.

Future work will include generalizing the code to other lattices, designing fast gate sequences to implement the logical operators, simplifying syndrome measurements, and making the code more robust to errors.

Acknowledgments

The authors would like to acknowledge the enlightening and helpful discussions with Dave Bacon, Sergio Boixo, Yu-An Chen, William Huggins, Eleanor Rieffel, Vadim Smelyanskiy, and Kevin Sung. ZJ would also like to extend the deepest gratitude to Ben Reichardt, whose comments and examples were extremely helpful in constructing MLSC codes for open boundary conditions.

Appendix A A brief review of quantum error-correcting codes

Quantum devices are vulnerable to decoherence due to interactions with environments. It was once believed that decoherence sets an upper limit on time and size for quantum computation Unruh (1995). Such a limitation was later overcome, at least in theory, with the invention of quantum error-correcting codes Shor (1995); Steane (1996); Calderbank and Shor (1996). It was shown that quantum computation can be made robust against errors when the error rate is smaller than a constant threshold Kitaev (1997); Aharonov and Ben-Or (1997). The surface code approach is a natural choice for fault-tolerant quantum computation, which requires only nearest-neighbor couplings and modest gate fidelity Fowler et al. (2012); Barends et al. (2014).

The error threshold of fault-tolerant protocols are derived by bounding an operator norm such as the diamond norm Aliferis et al. (2006), which translates to a stringent requirement when the amplitudes of coherent errors add together. For example, if one gate has over-rotation $\theta$, then a sequence of $N$ gates could produce an over-rotation of $N\theta$ and an error probability proportional to $N^{2}$. In order to get this worst case behavior, however, the errors have to add together in a coherent way. This is unlikely to happen in practice, therefore, coherent errors may be no worse for fault-tolerance than incoherent ones. Indeed, Pauli- or Clifford-twirling may be used to convert any noise channel into a simple mixture of Pauli errors or depolarizing noise Wallman and Emerson (2016); Li and Benjamin (2017).

A quantum $[[\hskip 0.4ptn,\hskip 0.4ptk,\hskip 0.4ptd\hskip 0.4pt]]$ code specifies a $2^{k}$-dimensional subspace of $n$ physical qubits, with which $k$ logical qubits can be encoded. The distance $d$ of a quantum error-correcting code is the minimum weight of a Pauli error by which an element of the code space can be transformed into an orthogonal element of the code space, i.e., a logical error happens. The weight of a Pauli error is the number of qubits on which a non-identity Pauli transformation acts. An $[[\hskip 0.4ptn,\hskip 0.4ptk,\hskip 0.4ptd\hskip 0.4pt]]$-quantum code can detect up to weight $d-1$ errors, and can correct errors of weight up to $t$ satisfying $2t<d$.

A large class of quantum error-correcting codes can be described by the stabilizer formalism. Consider the Pauli group ${\cal P}_{n}$ of an $n$ qubit system, and let $\cal S$ be its subgroup generated by $r$ commuting, independent generators (the stabilizers). The common $+1$ eigensubspace of all the elements in $\cal S$ defines the code subspace of dimension $2^{k}$ where $k=n-r$. Let $\cal C(\cal S)$ be the centralizer of $\cal S$, the set of elements in ${\cal P}_{n}$ that commute with all elements of $\cal S$. The logical operators can be specified by using the elements in $\cal C(\cal S)$ that satisfy the commutation relations of Pauli operators.

Appendix B The auxiliary fermion approach

In this appendix, we take a different approach to construct locality-preserving fermion-to-qubit mappings that can also detect/correct single-qubit errors. This approach is based on the auxiliary fermion method introduced by Ball Ball (2005b), and by Verstraete and Cirac Verstraete and Cirac (2005). We show that the map itself is not particularly good for detecting/correcting errors. In the next appendix, we improve this by combining two unit cells as a block.

Consider fermions hopping between neighboring sites on a 2D lattice; one auxiliary fermionic mode is introduced for each data fermionic mode. Each vertical hopping term is accompanied with a quadratic Majorana operator on the two corresponding auxiliary modes. We then map the fermions to qubits using the Jordan-Wigner transformation with row-major order, snake shape, and data modes interleaved with the corresponding auxiliary modes. The parity terms from the quadratic Majorana operator cancel the ones from the vertical hopping terms, and this makes the resulting Hamiltonian local. To reproduce the original physics, the state of the auxiliary subsystem is restricted to the common $+1$ eigenspace of the quadratic Majorana operators.

We use $f_{2k}$ and $f_{2k+1}$ ($\gamma_{2k}$ and $\gamma_{2k+1}$) to denote the two Majorana operators associated with the $k$th data (auxiliary) mode. Using the JW transformation, the Pauli operators of the data qubits can be expressed as

[TABLE]

where the parity operator is the product of all the Majorana operators in a particular interval,

[TABLE]

The parity operator anticommutes with any single-mode Majorana operator in its support. Similarly, the Pauli operators of the auxiliary qubits take the form

[TABLE]

The horizontal hopping term can be implemented with local qubit operators,

[TABLE]

The vertical fermionic hopping term takes the form

[TABLE]

where $j$ and $k$ are neighboring qubits in the same column. To get rid of the non-local parity operator in Eq. (44), we introduce the gauge operator of the auxiliary modes,

[TABLE]

where $j$ and $k$ are neighboring sites in the same column. The hopping term can be implemented locally by attaching the gauge operator to it,

[TABLE]

To retain the same physics, we restrict the state to be a common $+1$ eigenstate of the gauge operators,

[TABLE]

This constraint can be made local by combining two neighboring gauge operators together,

[TABLE]

The introduction of the stabilizer operators allows for correcting/detecting certain kinds of errors. The syndrome of a Pauli error can be described by the set of gauge operators that anticommute with it. Any Majorana operator anticommutes with a gauge operator if and only if it contains exactly one of the two single-mode Majorana operators in the gauge operator. The code cannot detect Pauli-$Z$ errors on the data qubits as they are logical operations and commute with all gauge operators. It can detect any single-qubit Pauli-$X$ or -$Y$ error on the data qubits and to correct any single-qubit error on the auxiliary qubits. The original auxiliary fermion approach is not especially efficient in correcting errors which occur on the data qubits.

Appendix C Combining two unit cells in BVC

In the last example, the Pauli operators of the physical qubits are expressed in terms of the Majorana fermion operators of the data modes and the auxiliary modes. Here, we use the same gauge operators defined in Eq. (45), but we encode four data Majorana modes and four auxiliary Majorana modes into a block of 4 physical qubits. This allows for correcting 10 out of 12 single-qubit errors in the block and detecting the remaining two.

For simplicity of notation, we omit the block indices in the operators, e.g., $f_{2k+2}$ is denoted as $f_{2}$. The Pauli operators on the $k$th block are constructed from the Majorana operators,

[TABLE]

where $P$ is a shorthand of the parity operator $P_{0}^{k-1}$, i.e., the product of all the preceding Majorana operators. These operators commute with any single-mode Majorana operator on the first $k-1$ blocks and the corresponding Pauli operators. These operators satisfy the commutation relations of the Pauli matrices. Inversely, the Majorana operators take the form

[TABLE]

The logical fermionic operators within the cell are

[TABLE]

which correspond to the horizontal hopping terms and the occupation terms. The inter-block horizontal hopping terms can be constructed by using the inverse relations (53-56); the weight of the corresponding logical operators is seven. All the terms containing one data Majorana operator and one auxiliary Majorana operator from the same block are three local, e.g.,

[TABLE]

Vertical hopping terms can be implemented by a 6-local Pauli operator corresponding to the product of two pairs of such operators. The stabilizer can be either 6 local or 14 local depending whether they are intra-block or inter-blocks.

There are 4 auxiliary Majorana operators $\gamma_{0,1,2,3}$ associated with a block, each of which form a gauge operator with another auxiliary Majorana operator from the block above or below. To analyze the syndromes of the single-qubit errors, we first look at the parity term $P_{0}^{k-1}$. The parity term anticommutes with gauge operators that share one common single-mode Majorana operator with it. This set includes two kinds of gauge operators:

1. those consist of one auxiliary Majorana operator to the left (right) of the $k$th block and an auxiliary Majorana operator below it,

2. those consist of one auxiliary Majorana operator to the right (left) of the $k$th block, including the $k$th block, and an auxiliary Majorana operator above it.

One can determine the block $k$, based on the syndromes of $P$, if a Pauli-$X$ or $Y$ error has occurred. Any single-qubit Pauli-$X$ or $Y$ error contains a unique combination of the auxiliary Majorana operators in the block $k$, see Eqs. (49)-(52). Therefore, their syndromes are different.

The Pauli-$Z$ errors do not involve the parity term. For example, the Pauli operator $Z_{0}$ and $Z_{1}$ contain the auxiliary Majorana operators $\gamma_{0}\gamma_{1}$ and $\gamma_{2}\gamma_{3}$ in the block. These syndromes allows one to identify the block where the error has happened. Both of the Pauli errors $Z_{2}$ and $Z_{3}$ contain the same product $\gamma_{0}\gamma_{1}\gamma_{2}\gamma_{3}$ and have the same syndrome. Therefore, the code can correct 10 out of the 12 single-qubit errors in the block and detect the remaining two single-qubit errors $Z_{2}$ and $Z_{3}$.

Appendix D Constructing general MLSC codes

In this appendix, we introduce a systematic procedure to construct general MLSC codes on a graph $G$. Geometric locality is inevitably lost in the most general settings; we comment on the conditions when geometric locality can be retained. Starting from a particular MLSC code, e.g., the BKSF, we modify the logical operators without changing the commutation relations (9). Depending on whether the stabilizer group is changed, we discuss two different methods to generalize MLSCs. Combining these two methods, one can construct arbitrary MLSCs.

In the first method, we introduce a new set of logical operators that also belong to the centralizer of the stabilizer group $\mathcal{C}(\mathcal{S})$, i.e., the stabilizer group remains the same. This can be achieved by a transformation that retains the standard anticommutation relations of the Majorana operators, similar to applying unitaries in the Clifford group to Pauli operators. Any multi-mode Majorana operator (up to a sign) acting on $n$ fermionic modes can be represented by a $2n$-dimensional vector over $\mathrm{GF}(2)$. For example, the Majorana operator $if_{0}f_{1}f_{2}$ acting on two fermonic modes can be represented (up to the overall phase factor $i$) by the vector $(1\;1\;1\;0)$, where $1$ ([math]) indicates the presence (absence) of the corresponding single-mode Majorana operator in the product. We introduce a matrix $M$, whose rows correspond to the new Majorana operators in terms of the old ones. A specific example of $M$ for $n=2$ takes the form

[TABLE]

where the new Majorana operators satisfy the standard anticommutation relations (2). Since the overall parity is conserved by any quadratic Majorana operator, the Hamming weights of all the row vectors in $M$ have to be all odd or all even. The four-Majorana transformation (60) plays a similar role as the two-qubit gate in the Clifford group, whereas permutations of the Majorana modes are similar to single-qubit Clifford operations. A general transformation matrix $M$ on $2n$ Majorana modes can be decomposed into a sequence of the four-Majorana transformation $M_{4}$ and row permutation matrices. Any two rows of $M$ are orthogonal to each other due to the anticommutation relations of Majorana operators (2). To retain geometric locality, one can restrict themself to transformations between neighboring Majorana modes.

In the second method, we modify the logical operators and then update the stabilizer group based on the modified logical operators. A general procedure is:

Find a Pauli operator $\Delta$ that anticommutes with at least one of the stabilizer operators, say $S$. 2. 2.

Chose a logical operator $L$ and update it $L\mapsto L\Delta$, 3. 3.

Find the set of logical operators $\{L^{\prime}\}$, $L$ excluded, that anticommute with $\Delta$. 4. 4.

Update these logical operators by multiplying them with the stabilizer operator $L^{\prime}\mapsto L^{\prime}S$. 5. 5.

Update the stabilizer operators using the new logical operators based on Eq. (10). 6. 6.

Repeat the procedure for the remaining logical operators.

This procedure produces a new MLSC with modified logical operators and stabilizers. In order for the resulting MLSC code to be geometrically local, the choice of $\Delta$ should also be geometrically local.

Appendix E Algorithms to set initial qubit values

In this appendix, we give an algorithm to assign initial values to the qubits for preparation of a Slater determinant. This algorithm requires neither a Hamiltonian path nor a spanning tree.

Appendix F Code on single open plaquette

F.1 BKSF

Here we work out the simple example of the BKSF stabilizer in a $2\times 2$ graph of vertices, labeled $i$, $j$, $k$, $l$. In this case, there are $4$ vertices, and $4$ edges representing the physical qubits. There is one stabilizer following the general relation $N_{E}-N_{V}+1$ for independent closed paths on the graph. That reduces the total logical space to $3$ qubits, representing a parity conserving subspace. A number of different stabilizers can result from different edge orderings, however the most convenient for our purposes follows a cycle such that the stabilizer is

[TABLE]

From this, we see that any individual $X$ or $Z$ error on a physical qubit of this code anti-commutes with this stabilizer. As a result, it’s possible to detect and post-select on any single qubit $X$ or $Z$ error, and more generally any odd number of $X$ or $Z$ errors. However it is easy to see that the code fails to detect a $Y$ error on any single qubit and by extension we cannot correct arbitrary single qubit errors with this encoding.

Appendix G Code on BKSF infinite lattice

Here we consider the properties of a BKSF encoding of a square regular lattice of fermions that extends in each direction. For this code, the physical qubits on an edge always participate in two generating plaquettes, and each edge is treated identically to all others from symmetry.

The following $4$ stabilizers involve vertex $m$, and can be read directly from Fig 3 as

[TABLE]

where we have labeled the off figure indices by $i^{\prime}$ for ones to the left of $i$ and $i^{\prime\prime}$ for ones above $i$. These $4$ plaquettes constitute the complete set of stabilizers that act on the physical edge qubits $E_{mj}$ and $E_{ml}$. We characterize the syndromes of each of these errors in Table 16.

To determine the possibility of error correction, one should verify that for any $\mathcal{E}_{a}^{\dagger}\mathcal{E}_{b}$ where $\mathcal{E}_{p}\in\{X_{mj},Y_{mj},Z_{mj},X_{ml},Y_{ml},Z_{ml}\}$ there is a stabilizer operator that anti-commmutes with it. This is sufficient for a recovery operation to exist for that set of errors. From Table 16, we see this is not the case for all errors. Hence the BKSF transformation on an infinite square lattice with the given ordering is capable of detecting single qubit errors, but not correcting them in general.

Appendix H Code on BKSF torus

Here we look at a patch of the BKSF code under periodic boundary conditions so that it forms a torus. For a lattices of size $3\times 3$ or larger, symmetries suggest it is again acceptable to look at the representative stabilizers that involve the vertex $m$ in the figure pictured in the main text. From the infinite lattice, we can get the corresponding stabilizers from appropriate assignment of the indices with periodic boundary conditions corresponding to a 2D-torus. This yields the stabilizers involving vertex $m$ as

[TABLE]

which from inspection we see are qualitatively the same as the case for the infinite lattice. That is, we expect the same commutation relations for the stabilizers and the representative edges $E_{ml}$ and $E_{mj}$.

Appendix I Code on BKSF open section

Considering now a finite square lattice with open boundary conditions with the standard ordering in this work, we may again work from Fig 3. In this case, all the plaquettes except those on the left or upper boundaries of the graph are the same, where the dangling $Z$ operators are truncated.

For interior edges more than 1 plaquette from a boundary, the same detection and correction results from the infinite case apply. However, at the boundary, there are generally edges that are covered by only 1 or 2 plaquettes instead of 3, as in the interior cases. As a result, even error detection at the edges can become problematic. For example, in the bottom-left plaquette of a square lattice with open boundary conditions, one is incapable of detecting a single $X$ error on that edge. This means that we expect there are a number of undetectable errors in this case as well, especially at boundaries. This may still allow for the mitigation of some errors, but is less powerful than the periodic case for this choice of ordering. For a finite graph, it may be possible to devise a custom or non-uniform ordering that restores the power to detect errors, however we do not investigate that here.