Error-correcting codes for fermionic quantum simulation

Utilizing the framework of $\mathbb{Z}_2$ lattice gauge theories in the context of Pauli stabilizer codes, we present methodologies for simulating fermions via qubit systems on a two-dimensional square lattice. We investigate the symplectic automorphisms of the Pauli module over the Laurent polynomial ring. This enables us to systematically increase the code distances of stabilizer codes while fixing the rate between encoded logical fermions and physical qubits. We identify a family of stabilizer codes suitable for fermion simulation, achieving code distances of $d=2,3,4,5,6,7$, allowing correction of any $\lfloor \frac{d-1}{2} \rfloor$-qubit error. In contrast to the traditional code concatenation approach, our method can increase the code distances without decreasing the (fermionic) code rate. In particular, we explicitly show all stabilizers and logical operators for codes with code distances of $d=3,4,5$. We provide syndromes for all Pauli errors and invent a syndrome-matching algorithm to compute code distances numerically.

1 Introduction Error-correcting codes were initially developed to correct quantum errors on noisy quantum devices and have found further applications in condensed matter physics and highenergy physics.The cornerstone of quantum error correction is the stabilizer formalism [1], which defines the codewords in the common eigenspace of elements in an Abelian group, referred to as the stabilizer group.A stabilizer code is labeled [[n, k, d]] when it uses n physical qubits to encode k logical qubits with code distance d.The code distance is the minimum weight of an operator that commutes with all elements in the stabilizer group but is not in the stabilizer group itself.The ratios k n and d n determine the quality of codes.Recent developments show the existence of "good" quantum low-density parity-check (LDPC) codes, i.e., with the number of logical qubits k and the code distance d both scaling linearly with the number of physical qubits n [2][3][4][5].In this paper, our focus is on a different objective.Instead of encoding logical qubits, we aim to encode logical fermions using physical qubits.This motivation comes from the need to simulate fermions on quantum computers since most models of matter involve electrons, which are, in fact, fermions [6][7][8][9][10][11][12][13][14].While fault-tolerant quantum computation [15,16] is the ultimate goal, current devices still have limited resources and suffer from noise, so error-mitigation schemes are crucial.Therefore, we seek an effective design such that when we implement fermions with qubits on a quantum computer, certain physical qubit errors can be corrected directly in this protocol without having to encode the underlying qubits further.Thus, we want to systematically increase the code distance d in a fermion-to-qubit mapping with a fixed code rate (between logical fermions and physical qubits). 1  When a fermionic Hamiltonian consists of geometrically local terms, they can be mapped to local qubit operators by the Bravyi-Kitaev superfast encoding and its variants [8,17], by the auxiliary methods [18][19][20][21][22][23], or by exact bosonization [24][25][26].The mappings between fermionic Hamiltonians and higher-spin Hamiltonians are also studied in Refs.[27][28][29][30].There are also proposals that utilize defects of surface codes for fermionic quantum simulation [31][32][33], and those defects are recently implemented by Google Quantum AI [34].Variants of these mappings have been studied to optimize different costs [35][36][37][38][39][40][41][42][43][44][45][46][47][48].In the context of quantum many-body physics, these mappings also reveal the deep connections between fermion and spin systems [49,50].There is another exact fermion-flux lattice duality derived from the Z 2 gauge theory [51].Aside from the investigation of constructing new mappings, fermion-to-qubit mappings have been studied in the context of variational quantum circuits [52,53].In all the above-mentioned methods, extra qubits are required, e.g., the number of qubits is twice the number of fermions on a 2d square lattice.This is the price for the locality-preserving property. 2hese methods can be thought of as stabilizer codes.Given N fermions with the Hilbert space dimension 2 N , they are mapped to 2N qubits with space dimension 2 2N , which is an enlarged space.After N gauge constraints (stabilizer conditions) are imposed, the gauge-invariant subspace (code space) has dimension 2 N , which matches the dimension of the logical fermions.It has been shown that gauge constraints can be utilized for error correction [54], and code distances can be studied for these stabilizer codes.Ref. [17] demonstrates that an improved Bravyi-Kitaev superfast encoding can correct any singlequbit error in a graph where each vertex has degree d ≥ 6.In Ref. [55], another version of the Bravyi-Kitaev superfast encoding is proposed, called the "Majorana loop stabilizer code," which is designed to have code distance d = 3 such that any single-qubit error can be corrected.However, it is not known how to generalize the Bravyi-Kitaev superfast encoding to produce codes with higher and higher code distances.An alternative approach is code concatenation, where logical qubits in error-correcting codes replace physical qubits in the fermion-to-qubit mappings.However, code concatenation will decrease the code rate between logical fermions and physical qubits, increasing the overhead of fermionic simulation.In this work, we present a method that increases the code distances of the fermion-to-qubit mappings while preserving the code rate.
In this paper, we conjugate an existing stabilizer code with a Clifford circuit. 3This produces a new stabilizer code.Since the new code is obtained via conjugation by a unitary operator, the algebra of the logical operators is preserved.If we choose the circuit wisely, the new stabilizer code will have a larger code distance (d ≥ 3), compared to the code distance d = 2 of the original exact bosonization.To study Clifford circuits systematically, we utilize the Laurent polynomial method introduced in Refs.[56,57] and further extended in Ref. [58], which shows that any Pauli operator can be written as a vector in a symplectic space.For a system with translational symmetry, e.g., the 2d square lattice, the space of Pauli operators becomes a module over a polynomial ring.Furthermore, this polynomial method can be used to formulate the 2d bosonization concisely [59].The commutation relations of Pauli operators are determined by the symplectic form.Ref. [60] shows that there is a one-to-one correspondence (up to a translation operator on the lattice): Automorphism of the symplectic form ⇐⇒ Clifford circuit on a 2d square lattice.
Therefore, the problem of finding new codes turns into a problem of searching for "good"4 automorphisms of the Pauli module with the symplectic form, which can be achieved efficiently by exhaustive numerical search.
In this work, we use the Laurent polynomial method to construct bosonizations on a 2d square lattice.Table 1 is the summary of our results.In Section 2, we review the original 2d bosonization method [24] in Section 2.1 and then pictorially construct 2d bosonizations with distances of 3, 4, and 5 in Section 2.2, 2.3, and 2.4, respectively.We review the Laurent polynomial method in Section.3.1.In Section.3.2, we describe all these bosonizations within the framework of the Laurent polynomial method.In addition, in Section. 3 [8] and to the Majorana loop stabilizer code [55] on a 2d square lattice.The d = 2 exact bosonization is equivalent to the Bravyi-Kitaev superfast encoding with a specific choice of the ordering of edges [48].
We list the code distance, as well as the weights (after mapping to qubits) of a fermion occupation term (local fermion parity term), of a hopping term, and of a density-density interaction between nearest neighbors.The weights of the stabilizers are also shown.
describe a computerized method to search for bosonizations.In Appendix A, we discuss the "syndrome matching" method used to compute the code distance of a given bosonization.In Appendix B, we describe the generators of the symplectic group and choose sixteen elementary automorphisms for our numerical search algorithm.In Appendix C, we show the polynomial representations of an automorphism with a distance of 6 and another with a distance of 7.

Results
In Section 2.1, we begin by reviewing the original 2d bosonization on a square lattice from Ref. [24].Then we demonstrate a new way to perform bosonization with code distances of d = 3, d = 4, and d = 5 in Section 2.2, Section 2.3, and Section 2.4, respectively.[24].We put Pauli matrices X e , Y e , and Z e on each edge and one complex fermion c f , c † f on each face.We will work in the Majorana basis

Review of the original bosonization
We first describe the Hilbert space in Fig. 1.The elements associated with vertices, edges, and faces will be denoted by v, e, and f , respectively.On each face f of the lattice, we place a single pair of fermionic creation-annihilation operators c f , c † f , or equivalently a pair of Majorana fermions γ f , γ ′ f .The even fermionic algebra consists of local observables with trivial fermionic parity, i.e., local observables that commute with the total fermion parity (−1) F ≡ f (−1) c † f c f where F = f c † f c f is the total fermion number. 5The even algebra is generated by [24]: 1. On-site fermion parity (occupation): 2. Fermionic hopping term: where L(e) and R(e) are faces to the left and right of e, with respect to the orientation of e in Fig. 1.
The bosonic dual of this system involves Z 2 -valued spins on the edges of the square lattice.For every edge e, we define a unitary operator U e that squares to 1. Labeling the faces and vertices as in Fig. 1, we define: where X e , Z e are Pauli matrices acting on a spin at edge e: Operators U e for the other edges are defined by using translation symmetry.Pictorially, operator U e is depicted as corresponding to the vertical or horizontal edge e.In Ref. [24], U e and S e are shown to satisfy the same commutation relations.We also map the fermion parity P f at each face f to the "flux operator" W f ≡ e⊂f Z e , the product of Z e around a face f : The bosonization map is or pictorially The condition P a P c S 58 S 56 S 25 S 45 = 1 on fermionic operators gives a gauge (stabilizer) constraint G v = W fc e⊃v 5 X e = 1 for bosonic operators, or generally The gauge constraint Eq. ( 9) can be considered as the stabilizer (G v |Ψ⟩ = |Ψ⟩ for |Ψ⟩ in the code space), which forms the stabilizer group G.The operators U e and W f generate all logical operators. 7The weight of a Pauli string operator O is the number of Pauli matrices in O, denoted as wt(O).For example, we have wt(U 56 ) = wt(U 58 ) = 2, wt(W f ) = 4, and wt(G v ) = 6.The code distance d is defined as the minimum weight of a logical operator excluding stabilizers: The code distance of this original bosonization is d = 2 as U e has weight 2 and any single Pauli matrix violates at least one G v , which implies that there is no logical operator with weight 1.
There are four types of nearest-neighbor hopping terms ( When mapped to Pauli matrices, their weights wt i are in the range 2 ≤ wt i ≤ 6.The maximum weight corresponds to the worst case to simulate the fermion hopping term or the fermion occupation term.A good stabilizer code requires a balance between the minimum weight and the maximum weight.A high minimum weight guarantees the error-correcting property, while a low maximum weight implies that the cost of simulation is low.We label the minimum and maximum weights of the hopping terms as wt min and wt max .In this example, (wt min , wt max ) = (2, 6).

Bosonization with code distance d = 3
We now introduce a new way to map the fermionic operators S e and P f to Pauli matrices.For simplicity, we present the mapping in a pictorial way: The stabilizer on the bosonic side is Notice that there is a minus sign coming from ZXZ = −X. 8We can manually check that the logical operators defined in Eq. ( 11) do commute with the stabilizer in Eq. ( 12).We will prove that this mapping preserves the fermionic algebra in Section.3.
Given the stabilizer, we can provide the syndromes for all single-qubit Pauli errors, as shown in Fig. 2. We see that all single-qubit Pauli matrices have different syndromes, which means that we do not have any logical operators with weight 2. This implies a code distance of d ≥ 3. Eq. ( 11) shows logical operators with weight 3, so we conclude that the code distance is d = 3.Based on the syndrome measurements, we can always correct any single-qubit error according to Fig. 2.
The four types of nearest-neighbor hopping terms, and γ ′ L γ R have weights wt i in the range 3 ≤ wt i ≤ 5. Therefore, the modified bosonization has (wt min , wt max ) = (3, 5) and a fermionic occupation term of weight 4. Compared to the original bosonization with (wt min , wt max ) = (2, 6), the minimum weight is increased such that error correction can be performed, while the maximum weight of the hopping terms is decreased implying a reduction in the simulation cost.
Here we present the spinless Fermi-Hubbard Hamiltonian in 2d square lattice for d = 3 encoding as a concrete example.The 2d spinless Fermi-Hubbard Hamiltonian is where ⟨i, j⟩ represents the nearest-neighbor pair of vertices in the square lattice.We can write individual terms in Majorana basis such as ). Next, we map the hopping terms and density-density interaction term to Pauli operators as follows where two terms on the right-hand side correspond to vertical and horizontal (i, j).The hopping terms have weights ranging from 3 to 5, and the interaction term has a weight 6.

Bosonization with code distance d = 4
In this subsection, we provide a construction of an exact bosonization with code distance d = 4 as an intermediate step toward d = 5.Since its code distance is d = 4, which is even, this code (like the d = 3 code) can only correct the ⌊ d−1 2 ⌋ = 1 Pauli error.However, for error defection, Pauli errors up to weight 3 can be observed from the stabilizer syndrome measurements.
The mapping can be described as The stabilizer becomes We can check that the logical operators in Eq. ( 15) commute with the stabilizer in Eq. ( 16).
The proof of the equivalence between the even fermionic algebra and this stabilizer code will be shown in Section.3.
The syndromes for all single-qubit Pauli errors are provided in Fig. 3. From the generators of the logical operators in Eq. ( 15), we may be tempted to conclude that the code distance is d = 5 because the minimum weight is 5.However, based on the syndromes in Fig. 3, we find that the following operator is logical: Since it does not commute with the terms in Eq. ( 15), this operator does not belong to the stabilizer group.Therefore, the code distance for this stabilizer code is d ≤ 4. In Appendix A, we introduce the "syndrome matching" method to provide a lower bound for the code distance for a given stabilizer code.With this method, we check that the stabilizer code defined by Eq. ( 16) has a code distance of d = 4.The minimum and maximum weights of the nearest-neighbor terms are (wt min , wt max ) = (5, 6) and the fermionic occupation term has weight 6, which means that all the operations are quite well-balanced.This code has an error-correcting property for any single-qubit error.

Bosonization with code distance d = 5
The bosonization map with code distance d = 5 is provided in this subsection.The generators of the even fermionic algebra are mapped to Pauli matrices as shown below: The stabilizer is The minimum and maximum weights of the nearest-neighbor terms are (wt min , wt max ) = (5, 9) and the weight of the fermionic occupation term is 8.We use the "syndrome matching" method in Appendix A to confirm that d = 5.This code has an error-correcting property for any two-qubit error.

Stabilizer codes and the Pauli module
This section discusses the stabilizer code formalism and the Pauli module representation via Laurent polynomials.The Laurent polynomial method is reviewed in Section.3.1.

Review of the Laurent polynomial method for the Pauli algebra
We start by reviewing how any Pauli operator can be expressed as a vector over the Laurent polynomial ring R = F 2 [x, y, x −1 , y −1 ]9 as set out in Ref. [56].First, we define X 12 , Z 12 , X 14 , and Z 14 in Fig. 1 as column vectors: The Pauli Y can be written as a vector which is a sum of corresponding vectors of X and Z, such as We express the vector representation of the Pauli Y operator on an edge e as XZ along the same edge.It is important to note that in this representation, we quotient out the phase factor ±1, ±i associated with Pauli operators.For instance, we equate Y, −Y, iY, −iY with Y .Our primary focus is on the commutation and anti-commutation properties of Pauli operators; thus, quotienting out the phase factor ±1, ±i does not impede our calculations.In practical applications, the phase factor can be efficiently tracked, as demonstrated in the Gottesman-Knill theorem [61,62].
All the other edges can be defined with the help of translation operators as follows.We use polynomials of x and y to represent translation in the x and y directions, respectively.For example, More examples are included in Fig. 5. Next, we introduce the antipode map that is an F 2 -linear map from R to R defined by To determine whether two Pauli operators represented by vectors v 1 and v 2 commute or anti-commute, we define the dot product as where T is the transpose operation on a matrix and is the matrix representation of the standard symplectic bilinear form.Notice that −1 is the same as 1 because we are working over the Z 2 field.For simplicity, we denote ( The two operators v 1 and v 2 commute if and only if the constant term of v 1 • v 2 is zero.For example, we calculate the dot products and, therefore, X 12 and Z 12 anti-commute, whereas X 58 and Z 14 commute (their dot product only has a non-constant term x −1 y −1 ).Furthermore, the physical meaning of X 58 • Z 14 = x −1 y −1 is that the shifting of X 58 in −x and −y directions by 1 step will anticommute with Z 14 .A translationally invariant stabilizer code forms an R-submodule10 V such that We now study the automorphisms A of the symplectic form Λ: This is equivalent to A † ΛA = Λ.All matrices A satisfying this equation form the symplectic group.We divide Examples of the automorphism A are Mat 2 [R] consists of all 2×2 matrices with entries in R = F 2 [x, y, x −1 , y −1 ].The generators of the symplectic group are discussed in Appendix B. We have selected sixteen elementary automorphisms, denoted as A 1 , A 2 , • • • , A 16 , from the symplectic group.These automorphisms can be expressed by the conjugation of a unitary operator, i.e., the effect of the automorphism is The corresponding unitary circuits for the sixteen elementary automorphisms are illustrated in Fig. 6.

New stabilizer codes developed from automorphisms
First, we reformulate the original bosonization introduced in Section 2.1 and incorporate it into the Pauil module.For simplicity, we will write x −1 and y −1 as x and y, respectively.The original hopping operators U e in Eq. ( 5) can be written as where U 1 represents U e on the horizontal edge and U 2 represents U e on the vertical edge.The flux term W f in ( 6) is written as The stabilizer G v in Eq. ( 9) corresponds to the vector Now, we will apply automorphisms on these vectors to generate new stabilizer codes.

Automorphism for code distance d = 3
We consider the simplest automorphism which modifies the Pauli operator X e as Pictorially, this is equivalent to Notice that Z e is unchanged under this automorphism.This automorphism corrsponds to the Clifford circuit shown in Fig. 7. Now we apply A 1 on the logical operators U 1 , U 2 , and W and the stabilizer G: The automorphism A 1 applied on U e can be visualized as The flux term Eq. ( 6) is unchanged.The automorphism A 1 applied on the stabilizer G v is This is the bosonization with code distance d = 3 introduced in Section 2.2.Since we applied the automorphism of the Pauli module on the original bosonization, the logical operators satisfy the same algebra.Therefore, we conclude that this new stabilizer code is a valid way to simulate fermions.

Automorphism for code distance d = 4
In this section, we consider a slightly more complicated automorphism A ′11 : One can easily check that A ′ indeed satisfies the condition in Eq. ( 31) for being an automorphism.Applying A ′ on the logical operators U 1 , U 2 , and W and the stabilizer G, we get The operators A ′ (U e ) can be depicted as The stabilizer The logical operator U e and the stabilizer G v are mapped on the bosonization with code distance d = 4 introduced in Section 2.3.Finally, the flux term under the automorphism A ′ becomes This term can be simplified by multiplying it by A ′ (G v ), which does not change the effective logical operation.The resulting flux term is which matches Eq. ( 15) in Section 2.3.

Automorphism for code distance d = 5
We introduce another automorphism A ′′12 : Again it is easy to check that it satisfies the condition in Eq. ( 31) for being an automorphism.Applying A ′′ on the logical operators U 1 , U 2 , and W and the stabilizer G, we get The A ′′ (U e ) operators can be depicted as Eq. ( 18) and ( 19).Here, we choose A ′′ (W + G) as our flux operator shown in Eq. ( 20) because it has a lower weight wt[A ′′ (W + G)] < wt(A ′′ W ). The pictorial representation of stabilizer A ′′ G is Eq. ( 21).

Searching algorithm for automorphisms
In this subsection, we describe how we find automorphisms with code distances d = 3, 4, 5, 6, and 7.The automorphisms A 1 in Eq. ( 37), A ′ in Eq. ( 43), and A ′′ in Eq. ( 49) correspond to the examples for d = 3, d = 4, and d = 5, respectively.We will show other examples with different code distances.First, we consider sixteen elementary automorphisms A 1 , A 2 , • • • , A 16 (shown in Appendix B), which attach no more than one new Pauli matrix to the original Pauli matrix.For example, the A 1 automorphism attaches one Z to X e , as shown in Eq. (38).Given the sixteen elementary automorphisms, their product is also an automorphism.(We note that these elementary automorphisms do not generate all automorphisms.)We find that the product of five elementary automorphisms ; therefore, we focus on products with five or fewer elementary automorphisms.We now describe how we search for automorphisms with large code distances: 4. We apply the syndrome matching method shown in Appendix A to the candidate automorphisms.By applying syndrome matching, we find a lower bound of their code distances.
5. We apply the syndrome matching method for distance d + 1 to an automorphism A with a lower bound d.If syndrome matching for distance d + 1 returns a logical operator with no syndrome, we conclude that A is a bosonization with code distance d.

Code distance Automorphisms
Table 2: The possible automorphisms for different code distances.The numbers inside parentheses are the minimum and maximum weights of the logical operators for the nearest-neighbor terms.For example, A 9 A 3 A 7 A 14 has the minimum logical weight 5 and the maximum logical weight 9.

Discussion
This work introduces a method that employs Laurent polynomials and symplectic automorphisms as efficient classical computational tools in the search for fermion-to-qubit mappings with error correction capabilities.One significant advantage of this method lies in its ability to generate equivalent mappings with higher code distances while preserving the code rates.This is possible due to the established equivalence between various 2d fermion-to-qubit mappings, as shown in Ref. [48].
In recent years, it has been shown that Laurent polynomials do not only serve as an analytical tool to design and characterize quantum code [56,57,60,[63][64][65], numerical algorithm inspired by Laurent polynomials are also proposed, for example, searching 3d fracton phases [66].In this work, we demonstrate the effectiveness of the Laurent polynomial in searching quantum error-correcting codes.The Laurent polynomials and symplectic automorphisms serve a dual purpose in our method: They are instrumental in the analytical derivation of quantum codes and valuable for the numerical studies of these codes.To illustrate the effectiveness of our approach, we demonstrate this method through examples of codes with distances d = 3, 4, 5 and further extend our constructions up to d = 7.Additionally, we present general algorithms designed to systematically search for and verify fermion-to-qubit mappings with elevated code distances.It is noteworthy that our proposed method is not exclusive to fermion-to-qubit mappings; it is also applicable to regular qubit stabilizer codes, which are utilized to encode logical qubits.
In the context of implementing higher-distance error-correcting codes, which are realized through exact bosonization (with d = 2) by Clifford deformations, we can prepare the codewords for these codes.This is achieved by applying the appropriate Clifford circuit to the codewords of the exact bosonization (d = 2).The process involves the following steps: 1. Generating a product state in the fermionic Fock basis from the toric code ground state by exciting fermions ϵ = e × m.This state is a codeword of the exact bosonization (d = 2).
2. Transforming this codeword using the Clifford unitary corresponding to the automorphism A.
3. The result is the codeword for the higher-distance exact bosonization, preserving the same logical information.In particular, the Clifford circuit used is geometrically local and translationally invariant, ensuring that a shallow, O(1)-depth, geometrically local Clifford circuit does not spread errors.
This method provides a framework for developing higher-distance error-correcting codes essential for fermionic quantum simulation, simultaneously underscoring the necessity of efficient decoders for effective error correction.Given that exact bosonization originates from the toric code, we anticipate that the minimum weight perfect matching approach still works.Apart from quantum error correction, which includes code construction and decoder development, optimizing efficient and fault-tolerant logical operations remains a critical challenge.Exploring efficient decoders and fault-tolerant operations is left for future research.

B Elementary automorphisms
This section demonstrates the transformation rules of Pauli matrices for sixteen elementary automorphisms used in our numerical search algorithm.First, according to Ref. [65], the symplectic group of vectors over the Laurent polynomial ring R = F 2 [x, y, x −1 , y −1 ] is generated by the following 4 × 4 matrices, which form the elementary symplectic group.Below a ∈ R × is any monomial in R.
The diagonal blocks of A 1 are identities, and its nontrivial part is the lower left block which attaches an extra Z to X 1 and X 2 .By multiplying the polynomial vectors of X 1 , X 2 , Z 1 , and Z 2 by automorphism A 1 , we get the following terms: Similarly, we may multiply X 1 , X 2 , Z 1 , and Z 2 by A 2 , thereby obtaining Following the same argument, we can obtain pictorial representations for the rest of the automorphisms: A 3 : C Automorphisms for code distances d = 6 and d = 7 In this section, we show the explicit form of automorphisms A d=6 and A d=7 found by syndrome matching.The automorphism A d=6 = A 1 A 5 A 14 A 1 has a code distance of 6: (86) By applying A d=7 on logical operatrs U 1 , U 2 , W , and stabilizer G, we can write down their polynomial representations as follows: .

4 10 3
Bosonization with code distance d = 5 Stabilizer codes and the Pauli module 11 3.1 Review of the Laurent polynomial method for the Pauli algebra 12 3.2 New stabilizer codes developed from automorphisms 14 3.2.1 Automorphism for code distance d = 3 16 3.2.2Automorphism for code distance d = 4 17 3.2.3Automorphism for code distance d = 5 19 3.3 Searching algorithm for automorphisms 19

Figure 1 :
Figure1: Bosonization on a square lattice[24].We put Pauli matrices X e , Y e , and Z e on each edge and one complex fermion c f , c † f on each face.We will work in the Majorana basisγ f = c f + c † f and γ ′ f = −i(c f − c † f ) for convenience.

Figure 2 :
Figure 2: Syndromes of single-qubit errors for the bosonization with code distance d = 3.The red vertices v represent locations where the single-qubit error does not commute with the stabilizer G v .

Figure 3 :
Figure 3: Syndromes of single-qubit errors for the bosonization with code distance d = 4.The red vertices v represent locations where the single-qubit error does not commute with the stabilizer G d=4 v .

Figure 5 :
Figure 5: Examples of polynomial expressions for Pauli strings.The flux term (i.e., fermionic occupation) on a plaquette and the hopping term on an edge are both shown.The factors such as x 2 y 2 and x 2 represent the locations of the operators relative to the origin.

Figure 6 :
Figure 6: The circuit representations of sixteen elementary automorphisms.Red lines represent the CZ gates, green lines represent the H ⊗2 (CZ)H ⊗2 gates, and blue lines represent the CN OT gates.

Figure 7 :
Figure 7: Clifford circuit corresponding to automorphism A 1

) 14 A
way to check if a Pauli string operator O belongs to the stabilizer group is by computing O • (AW ) and O • (AU1,2), where AW and AU1,2 generate the full logical space since W and U1,2 are the original generators in the exact bosonization and we apply an automorphism A on them.O•(AW ) = O•(AU1,2) = 0 if and only if the operator O commutes with all logical operators, which means O ∈ G (G is the stabilizer group).