The significant effects of decoherence on quantum systems require that a fault-tolerant quantum computer appropriately encode logical quantum information and Guanyu Zhu: Current affiliation is IBM T.J. Watson Research Center, Yorktown Heights, NY 10598.
furthermore apply logical gates directly on the encoded qubits [47,51]. However it is currently an open question to understand the ultimate asymptotic resource costs required for performing quantum error correction and fault-tolerant quantum computation. In this work we improve upon the known optimal asymptotic space-time resource costs by proposing constant depth topologically protected unitary circuits that implement a universal set of logical gates for the Tuarev-Viro codes [34] defined on hyperbolic surfaces. Our protocols demonstrate that protected universal gate sets can be applied in parallel and with constant space overhead using constant depth unitary circuits.
A quantum error correcting code (QECC) encodes k logical qubits using n physical qubits, such that a logical error occurs if and only if errors occur on at least d/2 distinct physical qubits, where d is referred to as the code distance. The ratio k/n is called the encoding rate. If a family of [[n, k, d]] QECCs possess a finite error threshold p th and errors on physical qubits are independent and occur with probability p, then a logical error will occur with probability p L ∝ (p/p th ) d/2 . Therefore as long as p < p th , the logical error rate can be made exponentially small as d is increased. In order to achieve fault-tolerant quantum computation, it must further be possible to implement an accurate universal set of logical gates on the encoded qubits.
The fault-tolerant storage and processing of quantum information come at significant resource costs in both space overhead, n/k, and the time overhead for implementing logical gates. Families of QECCs that are known to possess a finite error threshold, code distance d growing with n, and constant space overhead, where n/k is a constant independent of code distance d, have been proposed through two basic constructions. The first is in terms of topological codes defined on the cellulation of hyperbolic space [26,29]. The second is the hypergraph product code construction [40,52] 1 .
1 Many other QECCs with constant space overhead are also known (see e.g. Ref. [10,17]), however it is not clear whether they possess a finite error threshold, as they are not low density parity check (LDPC) codes. The LDPC property guarantees that While constant space overhead is known to be possible, it is unclear what the fundamental time overhead must be for performing a universal set of logical gates. Universal logical gate sets on encoded qubits can in general be implemented through three known methods:
(1) state distillation and gate implementation through measurements [11,47], (2) code switching [48], and (3) braiding or Dehn twist operations in appropriate classes of topological codes [2,8,25,33,34,41,54].
The methods (1) -( 3) necessarily require either (a) measurements, which are non-trivial to take faulttolerantly, together with follow-up operations that depend on the results of those measurements, or (b) unitary circuits whose depth grows linearly with the code distance. An exception is the class of protocols recently introduced in Ref. [57,58], which demonstrate how universal gate sets can be applied through constant depth unitary circuits (with the depth independent of n and d).
To date, it has not been demonstrated how methods (2) or (3) can be combined with QECCs that have constant space overhead. Moreover, to our knowledge the optimal space-time overhead achieved using method ( 1) is due to a proposal of Gottesman [28], who showed that constant space and time overhead are simultaneously achievable for sequential quantum circuits. This means that a generic quantum circuit of depth D, which can be implemented in O(D) time using parallel gate operations, could take up to time O(kD) if implemented sequentially. Note that for quantum codes with constant encoding rate, k is proportional to n and as such, the circuit depth of the sequential implementation could grow linearly with the system size.
In this paper we consider the most general class of topological codes, which we refer to as Turaev-Viro codes. These are based on Turaev-Viro-Barrett-Westbury topological quantum field theories (TQFTs) [3,53] and are stabilized by the Levin-Wen string-net Hamiltonians [41]. This class of TQFTs include, as special cases, the theories that describe the Kitaev surface code and quantum double models [33]. The use of these TQFTs and the associated Levin-Wen Hamiltonians as quantum codes was discussed explicitly in Ref. [34].
Here we consider Turaev-Viro codes defined on triangulations of hyperbolic surfaces. As we review below, the constant negative curvature of the hyperbolic surface allows for a finite encoding rate and thus constant space overhead for the associated topological code [26]. Such hyperbolic codes can be implemented in a flat two-dimensional layout of physical qubits by allowing long-range couplings between the physical qubitsa stabilizer code with d ∼ n α for α > 0 will have finite error threshold. [36]. On the other hand, many quantum LDPC codes with bounded d in the limit of n → ∞ are also known.
a possibility allowed by a variety of quantum computing architectures (e.g. ion traps [39,42], modular architectures of superconducting cavity networks [1,18,19,37], Rydberg atoms [20,43,49,50] and silicon photonics [30]), and a necessary requirement for any QECC with constant space overhead. In particular, a recent experimental realization of hyperbolic circuit QED lattices [35] is achieved by utilizing the feature that the cavity quantum bus (used to connect superconducting qubits) can have a wide range of length scales.
The main result of our paper is an explicit protocol for implementing Dehn twist operations in hyperbolic Turaev-Viro codes through constant depth unitary circuits. Here constant depth refers to the fact that the depth of the circuit is independent of n and d. We note that throughout this paper, by constant depth unitary circuit, we assume implicitly that every gate in the circuit also acts on a constant number (independent of d and n) of physical qubits. In contrast to the proposal of Ref. [28] which implements logical gates sequentially via gate teleportation, our approach allows parallel gate operations on encoded qubits via unitary circuits. Our circuit takes the form of a permutation on qubits, followed by a constant depth circuit which is local with respect to the hyperbolic metric that abstractly defines the code. The permutation can be implemented with a depth-two circuit by applying long-range SWAP operations in parallel throughout the code. These results generalize our earlier work [56][57][58] demonstrating that braids and Dehn twists in general topological codes associated with triangulations of Euclidean space can be implemented by similar constant depth unitary circuits. The extension to hyperbolic space described here implies that these protocols are also compatible with having constant space overhead. Our results demonstrate explicitly an advantage in terms of space complexity for implementing the mapping class group of closed manifolds in topological codes, as compared with the more well-studied braid group of punctures [4,33,45].
Our protocols are inherently protected from errors in the sense that all error strings that are introduced to the system by faulty physical operations have O(1) length; moreover, all pre-existing error strings grow by at most an O(1) factor. Stated differently, our circuits map local operators to local operators: an operator with support in a local region R is mapped to an operator with support in a local region R , such that the area of R and R are related by a constant factor independent of d. However, since this constant factor is greater than unity, our circuits may grow error strings by a constant factor that is larger than unity. In the presence of syndrome measurement errors we thus require O(d) rounds of error correction for every O(log d) logical gates that are applied.
Our protocols demonstrate how to apply logical gate operations in hyperbolic codes without increasing the space overhead. For non-Abelian topological codes, this is the first example of such protocols. For Abelian topological codes, such as the Z 2 hyperbolic surface code (the extension of the Kitaev Z 2 toric code to hyperbolic space [14,15]), a measurement-based approach using twist defect ancillas was described in Ref. [38]. The constant depth logical gates developed here for the general hyperbolic Turaev-Viro code also be applied to the hyperbolic surface code as a specific case, where a subset of Clifford logical gates [56] can be implemented through constant depth unitary circuits. We note that Ref. [15] also discussed Dehn twists in hyperbolic stabilizer codes, however constant depth protocols that can preserve the constant space overhead were not presented.
As we discuss, our protocols have important implications for improving the asymptotic scaling of the space-time overhead required for fault-tolerant universal quantum computation. In particular, they suggest that universal fault-tolerant quantum computation with constant space overhead and a time cost of O(dD/ log d) is possible for a logical quantum circuit of depth D. For certain highly parallel logical quantum circuits, this yields the best asymptotic scaling known to date.
This paper is organized as follows. In Sec. 2, we review the construction of hyperbolic Turaev-Viro codes. In Sec. 3, we sketch the two key steps for how to implement logical operations corresponding to Dehn twists in hyperbolic Turaev-Viro codes. The first step requires explicit maps representing Dehn twists on hyperbolic surfaces, which we present in Sec. 4. The second step, explained in Sec. 5 demonstrates how Turaev-Viro codes associated with different triangulations of hyperbolic space can be related to each other through local constant depth circuits. In Sec. 6 we discuss the faulttolerance of these protocols and and their implications for asymptotic space-time resource costs for universal fault-tolerant quantum computation. We conclude with a discussion in Sec. 7.
The Turaev Viro code [34,41] is a quantum error correcting code which is defined based on a given unitary fusion category C and is constructed using qudits that reside on the edges of a triangulation Λ of a surface Σ. Below we briefly review the construction of such codes.
Consider a unitary fusion category [54] C with N simple objects. We associate a vector space V c ab to any triplet of simple objects (a, b, c), whose dimension cor- responds to the fusion rules:
We may write fusion rules formally as:
Associativity of the fusion rules gives a constraint on the fusion coefficients N c ab . In particular, the vector spaces e V e ab ⊗ V d ec and f V f bc ⊗ V d af are isomorphic. The unitary map between these two vector spaces are the F -symbols of the theory,
Consider a surface Σ together with a triangulation Λ (see Fig. 1) of Σ. The triangulation is also equipped with a branching structure (i.e. a local ordering of vertices). To each edge of the triangulation we assign an N -state qudit with states labeled |a i , where a i are the simple objects in C. For simplicity of the construction we assume that the fusion rules N c ab are 0 or 1, although this can be easily generalized by including additional degrees of freedom at the vertices.
To define the code, it is simpler to work with the cellulation dual to Λ, which we denote by Λ. Note that since Λ is a triangulation of the surface, Λ is a trivalent graph. If a qudit is in state |a , we say a type a string is passing through the corresponding edge on Λ and label the edge by a. The wave functions of the code space then can be seen as superpositions of string-net configurations that are consistent with certain string branching rules [41].
The code space H Λ (Σ) is a subspace of the full Hilbert space of the physical qudits. The topological nature of the code guarantees that different choices of triangulations Λ and branching structures yield isomorphic code subspaces.
In particular H Λ (Σ) corresponds to the ground state subspace of a local Levin-Wen Hamiltonian [41]:
where v and p sum over all vertices and plaquettes of Λ respectively (see Fig. 1). All Q v and B p operators commute with each other. One can think of this model as a generalization from the abelian surface code to arbitrary (abelian and non-abelian) non-chiral topological orders in 2D. We note that the Levin-Wen Hamiltonian as defined in Ref. [41] requires a certain tetrahedral symmetry for the F -symbols, which makes the branching structure of the triangulation unnecessary, although the construction can be generalized to relax this condition.
The vertex operator Q v is a local projection operator which ensures that the ground state wave function is consistent with the branching rules of the theory. The action of Q v on a state |ψ depends only on the states of qudits that reside on the edges which are incident to v and is defined as:
The action of the flux operator B p on a wave function depends only on the edges which are incident on the vertices of p and is defined using the F -symbols. It can be thought of as the generalization of the local plaquette operators in Z 2 surface codes. Its exact form is rather complicated and we refer the interested reader to References [34,41] for a complete and through review of the Turaev-Viro codes. Just like the surface code, the eigenstates of the Hamiltonian (4) can be realized in an active error correction approach by repeated measurement of all Q v and B p operators, each of which can be performed by a local constant depth circuit together with an ancilla. The measurement results are then used to detect and correct possible errors. Designing explicit quantum circuits for syndrome measurements and finding fault tolerant error correction schemes for specific variants of Turaev-Viro codes are subjects of ongoing research [9,16,24].
A hyperbolic Turaev-Viro code is a Turaev-Viro code which is defined on a triangulation of a closed hyperbolic surface Σ. A closed hyperbolic surface is a closed surface endowed with a Riemannian metric of constant curvature -1. Due to the Gauss-Bonnet theorem, the area of such a surface can be found from its genus g:
The number of logical qubits (i.e. log[dim H Λ (Σ)]) for a topological quantum code on a closed genus g surface is proportional to g. On the other hand, for a fine triangulation with bounded geometry, where by bounded geometry we mean that the edge lengths and angles are bounded from above and below, the number of physical qubits n is proportional to the surface area A Σ and the code distance d scales as log(n) [26]. Therefore, according to (6), by using hyperbolic surfaces of increasing genus we can construct a family of hyperbolic Turaev-Viro codes with constant encoding rate and increasing code distance. Note that the encoding rate for a quantum code defined on a Euclidean surface is O(1/d 2 ) and goes to 0 as one goes to large distances [13].
We further note that the existence of a lower bound on the angles in the fine triangulation also ensures that the associated error-correcting code is in essence a lowdensity parity check (LDPC) code, which has a lowweight (upper-bounded) plaquette syndrome B p on the dual trivalent graph Λ (the vertex operator Q v is always weight-3 due to the definition of a triangulation or equivalently the trivalent structure of its dual graph). As is the case with stabilizer codes [36], the LDPC property is important for the possibility of an error threshold in the presence of noise during the syndrome measurements. A particular type of triangulation satisfying this property is the Delaunay triangulation, which is a unique triangulation for a given set of vertices that maximizes the smallest angle among all possible triangulations [31]. The hyperbolic Delaunay triangulation can be constructed numerically starting from a randomly picked distribution of vertices with a given average density in hyperbolic space. Then standard classical computer algorithms generating a Delaunay triangulation, such as the radial-sweep algorithm, can be applied [31]. Some detailed studies of hyperbolic Delaunay triangulations can also be found in Ref. [5,6].
We note that numerical evidence for a finite error threshold in hyperbolic surface (stabilizer) codes was established in Ref. [14,15].
3 Geometric gate sets for hyperbolic Turaev-Viro codes Consider a Turaev-Viro code defined using a unitary fusion category C on a triangulation Λ of a closed surface Σ with genus g. It is well-known that the code space H Λ (Σ) forms a non-trivial representation of the mapping class group (MCG) of the surface Σ. In other words, elements of the MCG implement certain non-trivial operations on the code space. Recall that the MCG is the group of homeomorphisms of the surface modulo those homeomorphisms that are continuously connected to the identityfoot_1 . We call the set of such operations the geometric gate set. Gates corresponding to MCG operations are naturally topologically protected (and thus can be made fault-tolerant) and can be implemented through a variety of methods [2,34,45,54,56,57]. For certain codes, such as the Fibonacci Turaev-Viro code, the geometric gate set forms a universal gate set [25].
Here we consider a way of implementing MCG elements in terms of constant depth unitary circuits that is closely related to the method proposed in [57], although our presentation below is somewhat different and more general. This method can then be applied to the case of hyperbolic codes which yield constant space overhead.
Let U be a mapping class group element of the surface Σ. We denote its representation on the code space H Λ (Σ) by U . For a given U , one can implement U using the following procedure:
• (Step 1) Let f U : Σ → Σ be a specific homeomorphism representing U . We move the vertices of Λ using f U , and connect them as they were connected originally to get a new triangulation of Σ which we denote by Λ . This operation corresponds to a permutation of the physical qubits. If the qubits are mobile, this transformation can be carried out by shuttling the qubits around. Otherwise, it can be implemented as a depth-two circuit by using longrange SWAPs in parallel throughout the system [57].
• (Step 2) Since the Turaev-Viro code was defined using the triangulation Λ, after the first step the wave function of the system would no longer be in the original code space H Λ (Σ). Rather it would be associated to the code space H Λ (Σ) of a different triangulation Λ . To remedy this, we apply a local quantum circuit that effectively implements a local geometry deformation and transforms the code defined on the Λ triangulation back to the one defined on the original Λ triangulation. We will show in subsequent sections that this retriangulation can be performed via a constant depth local quantum circuit. If we regard this transformation as a homeomorphism of the surface Σ, it would be equivalent to the trivial element of MCG, which ensures that it will not result in another nontrivial transformation on top of the map U . Details of the geometry deformation circuit are explained in Section 5.
As an example, take Σ to be the torus T 2 with a regular triangulation Λ which is used to define the Turaev-Viro code. To construct the torus, we can take a square of side 1 and identify the opposite sides.
Alternatively, we can start with the complex plane C and identify points according to equivalence relations z ∼ z + 1 and z ∼ z + i. We can use these identification rules to define a universal covering map from C to T 2 . A triangulation of T 2 then translates to a triangulation of the complex plane (see Fig. 2a).
Let U = D α be the Dehn twist along α, the meridional loop of the torus(for a brief review of Dehn twists, see Appendix A). Consider the shearing map
It is easy to verify that this map respects the equivalence relations and corresponds to a Dehn twist along the α loop. If we move (permute) the qubits according to f D , we get the configuration shown in Fig. 2b. Note that as a result of this map, the string along the β loop now encircles both handles while the string along the α loop remains unchanged, as one would expect form a Dehn twist along α. As a result of the previous step, the triangulation of the torus has been changed, as one can see by comparing Fig. 2(c) and Fig. 2(a). To compensate for that, we will apply a local unitary circuit, which corresponds to the trivial element of the MCG, to restore the original triangulation without applying any further logical gate. The final result is shown in Fig. 2(d).
In Ref [57,58], the above procedure has been used extensively to implement MCG elements by finite depth quantum circuits in QECCs which are defined on Euclidean surfaces. The main result of this work is that the same basic idea can be used to implement logical gates in QECCs which are defined on a hyperbolic surface. In the following we are going to explain in detail how one can implement geometric gates in hyperbolic Turaev-Viro codes.
Let Σ denote a hyperbolic surface that is used to define the hyperbolic Turaev-Viro code. Since the MCG can be generated by the Dehn twists around the handles of Σ, to implement an arbitrary geometric gate it suffices to be able to implement Dehn twists around the handles of Σ [57]. In Section 4, we construct specific diffeomorphisms that correspond to the basic Dehn twists, which then can be used to carry out Step 1 of the above procedure. Next, in Section 5, we introduce the local finite depth quantum circuit that converts two given triangulations to one another. By combining the results of these two sections and following the above procedure, one can implement the representation of any basic Dehn twists on the code space H Λ (Σ), and hence implement any geometric gate by a constant depth unitary circuit.
First we concentrate on the g = 2 case. After developing the maps for the simplest case, we show how these maps can be generalized for a surface of arbitrary genus.
Let Σ2 be an arbitrary genus 2 surface. As a surface with negative Euler characteristic, χ( Σ2 ) = -2, it admits a hyperbolic metric, i.e. a complete finite area Riemannian metric of constant negative curvature -1.
One way to define a hyperbolic metric on Σ2 is to start with the regular hyperbolic octagon on H 2 whose interior angles sum to 2π, known as the Fricke canonical polygon [27,32]. If we identify every other edge as shown in Fig. 3a with the arrows specifying how the edges should be lined up, we obtain a genus g = 2 hyperbolic surface Σ 2 shown in Fig. 3b, which is homeomorphic to Σ2 . According to Ref. [44], the homeomorphism can be upgraded to a diffeomorphism and thus induces a hyperbolic metric on Σ2 . From now on, we concentrate on Σ 2 , knowing that our statements about Σ 2 can be generalized to the Σ2 surface using the aforementioned diffeomorphism.
If we instead consider moving the vertices of the octagon to more general locations on the hyperbolic plane to obtain an irregular octagon, we move through Teichmüller space, which is the space of hyperbolic metrics of the closed hyperbolic surface.
As a result of the identification scheme, all vertices of the canonical polygon represent a single point on Σ 2 and thus the sides of the polygon correspond to closed loops with a common base point on Σ 2 (see Fig. 3b). Conversely, if we start with the double torus in Fig. 3b and cut the surface along these loops, we will obtain the octagon in Fig. 3a. In fact, these loops can be taken as the generators of the fundamental group π 1 (Σ 2 ),
An element of the MCG will take these loops to some other loops on Σ 2 , and thus naturally induces a map over π 1 (Σ 2 ). More precisely, it can be shown [22,46] that the mapping class group is isomorphic to the group of outer automorphisms of the fundamental group,
where Aut(G) and Inn(G) denote the automorphism group and inner automorphism group of G respectively. The equivalence under Inn(π 1 (Σ 2 )) is related to the fact that in general, homeomorphisms of Σ 2 will not keep the base point of the loops in π 1 (Σ 2 ) fixed.
Let U denote an arbitrary element of the mapping class group and hence an equivalence class of homeomorphisms on Σ 2 . Due to Eq. ( 8), U also corresponds to an equivalence class of automorphisms of π 1 (Σ 2 ). In the rest of this paper, in an abuse of notation we use the same symbol U to denote both the equivalence classes of homeomorphisms and Out(π 1 (Σ 2 )) and also representatives of these classes.
Consider the canonical octagon on the hyperbolic plane. By attaching a copy of the octagon on each edge according to the identification rules and continuing this procedure indefinitely for the edges of the newly added octagons, one will end up with the {8, 8} tiling of the hyperbolic plane (see Fig. 3c). The result can be used to define a covering map p : H 2 -→ Σ 2 which along with H 2 makes up the universal cover of Σ 2 .
In what follows we provide explicit expressions for the homeomorphisms of Σ 2 to itself corresponding to the Dehn twists along the primary loops of Σ 2 .
We start with the Dehn twist along α 1 .
To find an element of Aut(π 1 (Σ 2 )) which represents D α1 , it is enough to see how it acts on the canonical loops of the Σ 2 surface. To this end we can use the Dehn surgery method described in Appendix A. However, for simplicity, first we push the α 1 slightly to the left to detach it from the α 2 and β 2 loops and consider the twist map along this new loop. Note that the Dehn twist D α1 depends only on the isotopy class of α 1 . Then, as one can verify by looking at Fig. 3b and using the Dehn surgery method, D α1 maps β 1 to β 1 α -1
and leaves all the other canonical loops invariant. Note that we use the left to right convention for loop multiplication; if f and g are two loops with a common base point, f g corresponds to a loop that traces f first and then g.
Instead of specifying D α1 , we provide an explicit form for its lift to the covering space D * α1 : H 2 -→ H 2 such that the diagram below commutes:
To this end, we define how D * α1 acts on the points of a fundamental domain. Its action on the other points of H 2 are defined accordingly to ensure commutativity of the diagram in Eq. (10).
We take the fundamental domain to be the canonical octagon (shaded region in Fig. 4a). The action of D * α1 on the fundamental domain gives the sheared octagon shown in Fig. 4b. As one can easily verify, it transforms the β 1 loop to β 1 α -1 1 as desired, while all the other loops remain unchanged. In particular note that the α 1 loop is mapped to itself and thus has not changed.
We define the map D * α1 more precisely as follows. We map ∆ABC in Fig. 4b to ∆ACE and ∆ACD to ∆AED, where ∆ABC denotes the hyperbolic triangle made by connecting A,B and C via geodesics on H 2 . All the other regions in the octagon are left untouched. Mapping ∆ABC to ∆ACE is done as follows. Consider an arbitrary point, x, inside ∆ABC (see Fig. 4c). To find its image x = D * α1 (x), first draw the geodesic line that passes through A and x, and continue it to find its crossing point M with the line BC. It is clear that this map is continuous for the points inside the fundamental domain. It is also straightforward to check that this map is consistent with edge identification rules and thus is continuous throughout the H 2 plane. Moreover, the diagram in Eq.( 10) commutes by construction and hence D α1 is continuous on Σ 2 . Furthermore, as we explicitly verify in Appendix B, this map does not change the area of any region by more than a constant factor. This is an important property which allows the second step of our Dehn twist protocol, as we explain in subsequent sections.
Dehn twists along β 1 , α 2 and β 2 are defined in a similar manner.
To generate all elements of the MCG we need the Dehn twist along the γ loop as well (see Fig. 5a). The canonical octagon which we used to define D α1 has two important features: first, D α1 only changes the β 1 sides while leaving other sides of the octagon invariant; second, α 1 and β 1 were neighboring sides of the octagon. However, since both β 1 and β 2 transform non-trivially under D γ and since the γ loop is not one of the polygon's sides, the action of D γ on the canonical octagon is not as simple as D α1 and looks rather complicated. Therefore to construct D γ , it is easier to work with a different fundamental domain. To find the appropriate fundamental domain, we cut Σ 2 along a new set of loops rather than the standard α's and β's.
Let αi denote the α i loop translated through
α1 is illustrated in Fig. 5a. Note that we can write γ as:
We also define δ as:
which represents a loop that encircles both holes of Σ 2 .
As was the case for the α 1 Dehn twist, to find an automorphism of π 1 (Σ 2 ) corresponding to D γ first we push the γ loop shown in Fig. 5a slightly to the right and then use the Dehn surgery method to find its action on various loops. We remark that if we used another loop, e.g. if we pushed the γ loop slightly to the left instead, we would find the same automorphism up to an action of Inn(π 1 ). Note that due to Eq. ( 8), all such maps represent the same element of the mapping class group.
The representative automorphism induced by D γ on π 1 (Σ 2 ) can then be summarized in the following four equations:
Note that D γ leaves the δ loop invariant. To find the appropriate fundamental domain, we trade the {α 1 , β 1 , α 2 , β 2 } loops with {γ, β 1 , α2 , δ}. The group relation in Eq.( 7) can be expressed in terms of these loops as well:
Note that {γ 1 , β 1 } as well as {α 2 , δ} have algebraic intersection 1 while the two sets are mutually detached, i.e. the algebraic intersection number of a loop from the first set and a loop from the second set is 0. So the {γ, β 1 , α2 , δ} loops could have been taken as the primary loops of Σ 2 in the first place. This in turn suggests using an octagon with its sides following the δ,α 2 ,β 1 and γ loops. Such an irregular octagon is shown in Fig. 5b. As one can easily verify, this can be taken as the fundamental domain of the mapping p. Moreover, it has the features we are looking for: under the action of D γ , only the β 1 loop gets deformed and, furthermore, the γ and β 1 loops are represented by neighboring sides of the polygon.
D * γ (the lift of D γ to H 2 ) shears the octagon shown in Fig. 5b to the one shown in Fig. 5c. More precisely, ∆F GA is mapped to ∆F AH and ∆F AB is deformed to ∆F HB. Mapping the triangles is done through the same procedure described in Section 4.1.1. The action of D * γ on the other points of H 2 is then defined according to the identification rules. It is straightforward to verify continuity of the map. Moreover, as we verify in Appendix B, these maps do not change the area of any region of the surface by more than a constant factor.
Any element of the MCG of the double torus can be generated using D αi , D βi and D γ . In the next section we discuss how these constructions generalize to higher genus surfaces.
A hyperbolic genus g surface can be obtained by identifying every other edge of a 4g-gon, whose angles sum to 2π, in hyperbolic space. The space of different hyperbolic metrics, Teichmüller space, corresponds to inequivalent choices of the locations of the vertices of the 4g-gon [23]. Here we consider the canonical 4g-gon, i.e. a regular 4g-gon on H 2 . The sides of the polygon can be used to generate the fundamental group of the Σ g surface:
The MCG of Σ g can be generated by Dehn twists along α i and
γ i can be written as,
where αi is defined as in (11). Since our maps for the Dehn twists on the double torus modify only a specific corner of the polygon while leaving the other parts of it fixed, they generalize naturally to maps on the 4ggons. Also as in the previous g = 2 case, to construct D γi , it is easier to work with an irregular g-gon. As an example, the g = 3 case is analyzed in more detail in the Appendix C.
Furthermore, in Appendix B we show that this map does not change the area of any region by more than a constant bounded factor, even in the limit g → ∞. As explained in the next section, this feature is important to ensure that the depth of the local geometry change circuit remains constant as one increases the code distance (see Sec 5).
As described in Sec. 3, step (1) of our protocol permutes the qubits by applying the continuous shear map of Sec. 4 to the triangulation Λ. After the permutation, the original triangulation Λ is changed to a sheared triangulation Λ . In order to return to the original Hilbert space H Λ and hence reach a non-trivial unitary map preserving the code space, we need to switch the triangulation back from Λ to Λ.
In this section, we devise a local unitary circuit to switch a Turaev-Viro code between two arbitrary triangulations Λ and Λ . We consider Λ and Λ to have the same number of vertices and edges for any given region, up to at most a constant factor, c [as illustrated in Fig. 6(a)]. Since the switching circuit can be parallelized by acting throughout the whole space at once, the depth of the circuit only depends on c. To present our algorithm it is more convenient to show the switch between the two dual trivalent graphs instead, as indicated by the thick blue lines in Fig. 6(a).
For clarity, we drop the branching structure (previously indicated by arrows on the edges) of the graphs in this section. Many theories of interest, such as the Ising code and the Fibonacci code, do not require the branching structure.
The elementary re-triangulation gadgets we use are associated with the 2-2 and 1-3 Pachner moves, shown in Fig. 6(b) and(c). They correspond to unitary transformations that take the wave function defined on a triangulation Λ I to the wave function defined on a different triangulation Λ II , which differs locally: where F abc def is the F-symbol that defines the Turaev-Viro code, andd c , d d , andd f are the quantum dimensions of anyons labeled by c, d and f . For the 2-2 Pachner move [Eq. ( 18)], the state labels on the four external legs (a,b,c and d) are fixed, while the internal edge is flipped (both in the triangulation and trivalent graph) with the state labels changing from e to f . The 2-2 Pachner move can be implemented by unitary gates acting on physical qubits as will be illustrated below. For the 1-3 Pachner move [Eq. ( 19)], the state labels on the three external legs (a,b,c and d) are fixed, while a triangle with three new edges (e, d and f ) is added at the center of the trivalent graph (from ΛI to ΛII ). Correspondingly, in the original triangulation, a threelegged vertex is added in the center of a triangle (from Λ I to Λ II ) [see Fig. 6(c)]. These new edges come from ancilla qubits initialized at |0 , which then get entangled into the code by the 1-3 Pachner move, which can be considered as a fine graining procedure. The reverse of this process is a coarse graining procedure. The 1-3 Pachner move can also be implemented by unitary gates, which can be decomposed into 2-2 Pachner moves and two other simple unitary gates (see Ref. [57,58] for details).
In the case of the Fibonacci Turaev-Viro code, we have two simple objects in the unitary fusion category, labeled 0 and 1, with fusion rules 1 × 1 = 0 + 1, and the only non-trivial F -matrix is:
where φ =
is the golden ratio. All other Fsymbols are either 1 or 0, depending on whether they are consistent with the fusion rules and Eq. (18). A specific quantum circuit implementing the 2-2 Pachner move (F -operations) in the Fibonacci code was presented in Ref. [9] and is shown in Fig. 6(d). The circuit inside the dashed box is composed of a 5-qubit Toffoli gate sandwiched by two single-qubit rotations, which implements the F -matrix in (20). Here, R y (±θ) = e ±iθσy/2 represents single-qubit rotations about the y-axis with angle θ=tan -1 (φ -1
2 ). All the other maps are taken care of by the rest of the quantum circuit in panel (d). For the other widely considered case, the Z 2 hyperbolic surface codes, the F-symbols and Pachner moves can be implemented via only CNOTs (see Ref. [57] for details).
Based on these gadgets, we introduce the following two lemmas about the trivalent graphs, which serve as additional gadgets for the main algorithm. Lemma 0.1 Two edge-sharing plaquettes on a trivalent graph can be merged into a single plaquette using s -2 steps of Pachner moves, where s is the number of edges in the smaller plaquette (i.e., plaquette with fewer edges).
An "edge-sweeping" algorithm implements the above statement as shown in Fig. 6(e) with s -3 steps of 2-2 Pachner moves and a 1 -3 Pahcner move in the end.
Using the above plaquette-merging gadget, we can also demonstrate the following lemma when considering merging many plaquettes in parallel, as illustrated in Fig. 6(f). In particular, one merges all mergeable neighboring pairs in each step.
Here, we present the main algorithm to switch between the triangulations Λ and Λ (and equivalently the dual graphs Λ and Λ ). For the clarity of presentation, we choose a particular order by switching from Λ to Λ , although the algorithm and corresponding quantum circuit are reversible. The detailed algorithm is as follows:
1. We first introduce a trivalent graph ΛC coarser than the two fine trivalent graphs Λ (starting graph) and Λ (target graph) we want to switch between. In particular, we consider a coarser graph ΛC that encircles at most m plaquettes of the starting finer graph Λ. We note that m needs to be bounded and independent of code distance d. We also require that any plaquette in the coarser graph ΛC contains at least one plaquette of the finer graphs, as illustrated in Fig. 7(a). Now the coarser graph ΛC also encircles at most m plaquettes of the target finer graph Λ . As discussed in Sec. 4 and Appendix B, the area ratio for a given infinitesimal code patch before and after the application of the shear maps (belonging to Λ and Λ respectively) is a bounded constant independent of d (and thus also independent of the number of physical qubits n). This ensures that the ratio m/m is also bounded and independent of d. Since m is bounded and independent of d, m is also a bounded constant independent of d. This is a crucial property to ensure the O(1) depth of the switching circuit and the logical gates. to match with multiple edges (e) on the starting graph, as shown in Fig. 7(c). In this way, each plaquette in the fine graph Λ is strictly enclosed in only one plaquette in the coarser graph ΛC . This step does not require any quantum operations and is done entirely in the classical software.
Note that the deformation of the coarser graph ΛC leads to a slight change of the maximal number of enclosed fine plaquettes in any coarser plaquette, i.e., m and m , into O(m) and O(m ).
3. We coarse grain the finer graph Λ into the coarser graph ΛC by using the parallel plaquette merging algorithms introduced in Lemma 0.2, as shown in Fig. 7(d). This procedure takes O(log 2 (m)) merging steps with O(l log 2 (m)) time steps of Pachner moves, where l is the largest number of edges among all plaquettes in the starting finer graph Λ.
4. We match vertices (v C ) and the edges (e C ) of the coarser graph ΛC with those (v and e ) in the finer graph Λ using the same procedure as above, as shown in Fig. 7(e).
5. We fine grain the coarser graph ΛC into the target finer graph Λ by reversing the parallel merging algorithms in Lemma 0.2, as shown in Fig. 7(f). This procedures takes O(log 2 (m )) splitting steps with O(l log 2 (m )) time steps of Pachner moves, where l is the largest number of edges among all plaquettes in the target finer graph Λ .
As we see the total time complexity of the switching algorithm is O[max(l log 2 (m), l log 2 (m ))], i.e., dominated by the larger complexity from the coarse graining and fine graining process. Since m, m , l, l can all be bounded values independent of the code distance d (or equivalently graph size), we reach the following theorem:
The depth of the circuit is independent of the area of the surface, and therefore independent of the code distance d.
We emphasize again that the requirement of the bounded ratios of vertices, edges and plaquettes per unit area is ensured by the bounded ratio of the areas corresponding to the infinitesimal code patches before and after the shearing maps, as discussed in Sec. 4 and Appendix B. We also note that in the above discussions, we focused on proving the existence of a constant depth local unitary circuit, rather than giving the most efficient switching algorithm. To be more efficient, one does not need to follow the fine→coarse→fine pattern, but can rather directly find the shortest circuit to directly switch between the two fine graphs via Pachner moves.
So far we have shown that a generating set of Dehn twists for the MCG of a genus g hyperbolic surface can be implemented by a constant depth unitary circuit, where the depth is independent of the code distance and therefore also the number of physical and logical qubits, n and k. In this section, we briefly discuss fault tolerance of these circuits.
Our circuit breaks up into two basic pieces: A permutation of the physical qubits and a local constant depth circuit that implements the retriangulation. Since local unitary circuits have a linear light cone, the latter, i.e. the local constant depth circuit, is intrinsically fault tolerant. So, to ensure the fault tolerance of our procedure, we concentrate on the first part which permutes the physical qubits.
The permutation in our maps requires qubits to be permuted over long distances. Due to its non-local nature, there are two main concerns in regard to the propagation of errors that we need to address: (1) What happens to the pre-existing local error strings? Is it possible for them to be enlarged to lengths of O(d)? (2) Is it possible to introduce new non-local (O(d) long) error strings by a noisy implementation of the permutation circuit, e.g. noisy SWAP gates?
For a generic non-local permutation, both issues mentioned above could possibly arise. Nevertheless the permutations that we utilize have a special structure. To address the first issue, note that the continuous maps introduced in Sec. 4, take two points which are O(1) apart to new points which are still O(1) apart. This can be seen from the analysis carried out in Appendix B as well. However, to enlarge a local error string to a large error string of length O(d) we have to separate its endpoints by a factor of O(d). Thus, we can conclude that after the permutation, all pre-existing local error strings would remain local; at worst their length will be increased by a constant factor independent of d. Stated differently, our constant depth circuits map any operator with support in a spatial region R to an operator with support in a spatial region R , where the area of R and R are related by a constant (independent of code distance) factor. Here the areas are with respect to the hyperbolic metric. In this sense, the whole circuit is also "locality-preserving," although strictly speaking the phrase "locality-preserving" is often reserved for the case where the constant factor is unity [4,12].. Now we consider the possibility of introducing new non-local error strings during a noisy implementation of the permutation. Let's say the permutation is implemented by a set of noisy long range SWAPs. The important point to note is that while the SWAP operations are long ranged, they are still low weight operators. In particular, each SWAP operation acts on 2 qubits. On the other hand, a logical error string is a high weight operator, consisting of O(d) single qubit errors. So, if we assume the errors occur independently on different SWAPs, the possibility of introducing a logical error by a set of noisy SWAPs is still exponentially small in d. Therefore the second question can be answered in the negative as well.
Therefore, our Dehn twists and the corresponding logical gates are inherently protected from errors, in the sense that they do not stretch error strings by more than a constant factor, nor can they introduce error strings that have length more than a constant, independent of code distance.
However, if we apply the same collection of Dehn twists (logical gates) repetitively in the same region of the manifold, in the worst case the length of error strings could grow exponentially with the number of logical gates being applied. In the absence of measurement noise, the error string can be decoded and corrected in O(1) time [16] immediately after the application of a single logical gate (here we have ignored the classical computation time of the decoder which still typically scales with system size). Hence the computation scheme will have an O(1) (constant) time overhead. However, in the presence of measurement noise, the error string cannot be immediately decoded and corrected in O(1) time, so the growth of such a string would be inevitable. After performing O(log d) logical gates in the same region without any measurement or error correction in between, the error string may grow to a length of O(d), which will cause the decoder to fail. Therefore, one has to insert O(d) rounds of measurements, decoding, and error corrections for every O(log d) of logical gates in the same region. This suggests a sub-linear overhead O(d/ log d) in the computational time when repetitively applying logical gates in the same region, if the measurement error is taken into account. It may be possible to further reduce such overhead by some additional tricks, at least for certain types of logical circuits, but there may still be such a sub-linear overhead in the most generic situation. We note that the above O(d/ log d) time overhead is an estimate suggested by the considerations stated above; further work is required to develop efficient decoders to concretely demonstrate the validity of this estimate.
The above statements for the asymptotic space-time resource costs have assumed that the codes have a finite error threshold and that an efficient decoder exists and requires O(d) rounds of syndrome measurements to decode errors. For the Ising anyon code, this has been confirmed in the recent theoretical study in the presence of measurement error [21]. For the Fibonacci anyon code, a decoding scheme showing a finite error threshold has only been developed for the case without measurement noise [16]. We expect that the Fibonacci anyon code can also be used for fault-tolerant quantum computation using O(d) rounds of error correction in the presence of measurement errors. However the development of concrete decoding algorithms, explicit demonstrations of a finite error threshold, and efficient error recovery operations for the Fibonacci anyon code requires further work.
We have shown that Dehn twists in hyperbolic Turaev-Viro codes, which are the most general types of topological codes, can be implemented by constant depth unitary circuits while preserving the constant space overhead of the codes. We have presented explicit representative maps for Dehn twists on hyperbolic surfaces, which we use to define the first step of our protocols, which correspond to the permutation of the qubits. As we explicitly verify, our maps do not increase or shrink any infinitesimal area by more than a constant factor even in the g → ∞ limit. This fact implies that the sec-ond step of our protocol, the local unitary circuit that implements the retriangulation back to the original code space, is of constant depth. Since generic permutations can be implemented as a depth-2 circuit consisting of long-range SWAP operations applied in parallel, it follows that our entire protocols are constant depth unitary circuits.
Because our circuits for a given Dehn twist only act within a local region associated with a given handle or pair of handles, they can be applied in different regions simultaneously, in parallel (again while still keeping the constant space overhead), which makes our protocols amenable to parallel quantum computation.
The simplest example of the codes that we study is the Z 2 hyperbolic surface code. Our results demonstrate that Dehn twists, which generate a subgroup of the Clifford group acting on the logical qubits in this case, can be implemented by constant depth unitary circuits. In Appendix D we demonstrate explicitly how our retriangulation circuit in this case can be implemented using CNOT operations on the physical qubits.
When applying our results to the Fibonacci Turaev-Viro code, our results imply that a universal set of gates can be implemented through constant depth unitary circuits in a code with finite encoding rate (constant space overhead). Recent numerical study has shown the existence of a finite error threshold for a decoding scheme in the Fibonacci anyon code without considering measurement noise [16]. We expect, though it has not yet been explicitly demonstrated, that the Fibonacci Turaev-Viro code possesses a finite error threshold, efficient decoding algorithms and error recovery procedures even in the presence of measurement noise (similar statements for other non-Abelian codes have been demonstrated [21]). Assuming this, and inserting O(d) rounds of error correction for every O(log d) logical gates to ensure fault-tolerance in the presence of noisy syndrome measurements, our results suggest that universal fault-tolerant quantum computation with constant space overhead and time overhead of O(d/ log d) per logical gate is possible. This suggests that a generic logical quantum circuit of depth D with k logical qubits would require O(dD/ log d) time steps and O(k) physical qubits.
To our knowledge, the only proposed scheme with comparable space-time overhead for universal quantum computation is the one proposed by Gottesman in Ref. [28] which also uses constant space overhead. In Gottesman's scheme, the time overhead per logical gate is constant for sequential quantum circuits, where one logical gate is applied at each time step. This means that a highly parallel circuit of depth D would take time O(kD) 3 .
In the regime of interest for large-scale universal faulttolerant quantum computation, k d, and therefore our scheme would have an order O(d/(k log d)) improvement over the proposal of Ref. [28] for parallel quantum circuits. We note that k d is also the natural setting for the hyperbolic code, since d ∼ log n ∼ log k suggests an exponential growth of logical qubit number k as a function of the code distance d.
Our protocols allowing for implementation of mapping class group elements via constant depth circuits should be straightforwardly generalizable to higher dimensional topological codes. We note that a number of codes in three and four dimensions (such as the fourdimensional toric code) allow for single-shot error correction [7]. This would potentially allow any number of our type of logical gates to be applied with constant time overhead, even in the presence of measurement errors.
In this paper we studied hyperbolic codes for twodimensional topological states, where d ∼ log n. However better codes exist, such as the hypergraph product codes [40,52] or homological codes associated with fourdimensional hyperbolic manifolds [29]. These codes also have constant space overhead (and finite error thresholds because they are LDPC), but with the improved scaling of d ∼ √ n for the hypergraph product codes and d ∼ n ( < 0.3) for the four-dimensional hyperbolic codes. However, due to Mostow rigidity, the mapping class group of higher dimensional hyperbolic manifolds is necessarily finite. It is therefore a fundamental question whether there exist codes with constant space overhead and d ∼ n α (with α > 0), and which also admit a universal logical gate set through constant depth unitary circuits.
Note that T is an orientation preserving homeomorphism which reduces to the identity map on the boundaries of A. Fig. 8b shows the image of a line in A under T . Now, let Σ denote an arbitrary oriented surface and let α be a simple closed curve on Σ. To define the Dehn twist around α, first we choose a regular neighborhood A of α on Σ which is homeomorphic to A. Let φ : A → A denote an orientation preserving homeomorphism from A to A. We define the twist map around α by the following homeomorphism
T α clearly depends on the choice of N , φ and α. We define the Dehn Twist around α, denoted by D α to be the isotopy class of T α , i.e. the class of homeomorphisms of Σ to itself that can be deformed continuously to T α . We remark that D α depends only on the isotopy class of α.
As an example, one can consider the Dehn twist around the α loop on the simple torus shown in Fig. 8c. A simple way to find the image of a given loop like β under the action of the Dehn twist around another loop like α, called the Dehn surgery, is as follows: We start by tracing out the β loop until we hit an intersection with the α loop. Then we turn left to trace out the α loop until we return to the intersection point, where we turn right to continue tracing out the β loop. We need to do the same at any intersection of α and β until we get back to the starting point. Note that with the above definition the Dehn twist around α does not depend on any direction that the α loop might have.
In this appendix we analyze the shearing maps introduced in Section 4 to see by how much they scale the area locally. Because these maps do not have any singularity on a genus g surface, the local area scaling is bounded from below and above as one considers a fixed g. But more importantly, we will show that if we consider a family of maps on surfaces with increasing genus g, the local area scaling remains finite and bounded from below. Note that this result is crucial for the retriangulation circuit described in Sec. 5 to be constant depth.
As in the rest of the paper, we use the Poincare disk model for H 2 , namely the open unit disk in C with the Reimannian metric:
In this model, the geodesics connecting two points would be either circular arcs perpendicular to the unit disk or straight lines passing through the origin. It would be useful to note that a line reflection in H 2 looks like circle inversion in the unit disk model. A genus g hyperbolic surface can be obtained by compactifying a canonical N -gon for N = 4g. A canonical N -gon plotted in the Poincare disk model and centered at the origin would have its vertices at points:
The length of the sides, as measured using the hyperbolic metric, would be (see Fig. 9a):
The {N, N }-tiling of H 2 can be obtained by reflecting the canonical N -gon with respect to its sides and repeating this procedure indefinitely.
We start by analyzing the α 1 Dehn twist in detail. With minor modifications, the same calculation applies to the other maps as well, so we will only mention the end results for the other maps.
For the points in the shaded region but outside the ABCD hyperbolic 4-gon in Fig. 4b, D α1 acts as identity and hence it is preserves area locally. Next we consider the points inside ∆ABC which are mapped to points inside ∆ACE (See Fig. 9).
We start by calculating some lengths and angles. As in the main text, | | denotes the hyperbolic length. |AC| can be obtained using the hyperbolic law of cosines (see Fig. 9a):
To make calculations simpler, we place the origin of the Poincarè disk on point A; by doing so, the geodesics that come out of the point A will look like straight lines on the disk. In Fig. 9b, ∆ABC and ∆ACE are plotted in this new coordinate frame. Consider an infinitesimal area element ds at x = (r, θ) inside ∆ABC which is mapped to the area element ds at x = (r , θ ) inside ∆ACE; r and r are the Euclidean distance from origin in Fig. 9b and the θ and θ angles are measured with respect the lines AB and AC respectively. we define λ(r, θ) as the scale factor of the area:
r dr rdr
where g(r) is the determinant of the hyperbolic metric:
We want to show that λ is bounded from above and below: for some real positive L and U . First, we need to find r and θ in terms of r and θ.
Using the law of cosines for the angles in ∆ABM (see
α1 is defined such that:
Note that in this case |BC| = |CE| and hence:
We can find |AM | by using the law of cosines in ∆ACM :
It is then straight forward to find r and θ . According to the way the map D * α1 is defined, we have:
Note that r = tanh(|Ax |/2) and |Ax| = 2 arctanh(r). So we have:
where ρ is equal to |AM | |AM | and depends only on θ(not r). By taking the derivative of ( 41) with respect to r we get:
θ can also be obtained by using the hyperbolic law of sines in ∆ACM :
By plugging (41), (42) and ( 31) into (30) we find:
First, we fix θ and see how λ changes as one varies r in the range [0, r max = tanh(|AM |/2)]. It is straight forward to show that tanh(ρ arctanh(r))/r is bounded by 1 and ρ. The second parentheses in (44), which is equal to (1+r)/(1+r ), also is bounded by 1/2 and 2. The third parenthesis in ( 44) is a monotonic function of r, as one can verify by taking the derivative, and so is bounded by So far, all expressions were exact. But, since we are interested in the N → ∞ limit, the calculation can be simplified greatly by computing the large N expansion of each expression. In particular, ( 25),( 26),( 28), (27) and (29) have the following asymptotic forms:
To find the asymptotic form of functions that involve θ, first we trade θ for η ≡ θ Φ . The reason is that θ varies in the range [0, Φ] and so has an implicit 1/N dependence because of Φ. By using η instead of θ, the only small parameter of our expressions would be 1/N . Note that 0 ≤ η ≤ 1. In terms of η, we get the following asymptotic forms for the expressions in 34,38 and 43:
The first two expressions are only valid for 0 < η < 1; for η = 0, 1 we have to use the expressions listed in ( 45
Let M be a point on the side CD and M its image which will be on ED. According to the definition of the map,
We define ρ, θ, θ , and η similar to the previous case: θ ≡ ∠M AC, θ ≡ ∠M AE, ρ(θ) ≡ |AM |/|AM | and η ≡ θ/Φ . As in the previous section, we only need to compute the corresponding limits listed in (49). The calculation follows the same steps and at the end we will find that:
lim
Since all of them are bounded for 0 ≤ η ≤ 1 it follows that the area elements in ∆ACD also expand or shrink by a finite factor under this transformation.
Putting everything together, we conclude that D * α1 has finite local area scaling over the entire polygon and this ends the proof. The situation for β Dehn twists are exactly the same up to some relabeling and needs no more analysis. One can also carry out similar calculations to check that the same remains true for the γ Dehn twists. Note that D * γ is essentially the same as D * α ; the only difference is that the polygon is no longer regular.
Although we used a g = 2 hyperbolic surface to describe our procedure, as we mentioned in the main text the protocols can be easily generalized to higher genus surfaces. In this section, we briefly explain how the generalization applies in the g = 3 case. The genus 3 surface Σ 3 , shown in Fig. 10, can be constructed by identifying every other edge of a 12-gon (see Fig. 11a). The space of possible hyperbolic metrics -Teichmüller space -corresponds to inequivalent choices for the locations of the vertices of the 12-gon. Here we consider a regular 12-gon for simplicity. The sides of the 12-gon then correspond to the canonical closed loops of the closed surface which generate the fundamental group of Σ 3 :
Similar to the genus 2 case, we can tile the hyperbolic plane by attaching copies of the standard 12-gon appropriately together, which then specifies a universal covering for Σ 3 . We can choose one of the standard 12gons as the fundamental domain of the covering. Such a tiling is plotted in Fig. 11a.
The mapping class group of Σ 3 can be generated by the Dehn twists around the α and β loops plus the Dehn twists along γ 1 and γ 2 loops, where:
and where αi is the α i but transported along
To implement the Dehn twists, it suffices to find appropriate shearing maps to permute the qubits accordingly. The subsequent step, which is the retriangulation, has already been described in the general case in Section 5. The representative maps for the Dehn twists along α and β loops are essentially the same as the ones described in Section 4 for the g = 2 case. As an example, Fig. 11b shows how the fundamental domain is transformed by D * α1 in this case. The representative maps for Dehn twists along γ i s are also straightforward generalizations of the map described in Section 4; the trick is to choose a 12-gon as the fundamental domain such that it has the γ i loop as two of its sides and only the sides neighboring γ i transform non-trivially by the representative Dehn twist map. Here we consider the Dehn twist along γ 1 . The Dehn twist along γ 2 follows similarly. The action of D γ1 on α 1 , α 2 , β 1 and β 2 follows from the expressions in ( 14) by replacing γ with γ 1 . Furthermore, it keeps α 3 and β 3 invariant. The loop δ 2 = β 2 β 1 also remains invariant under D γ1 . Just like (15) for the g = 2 case, we can rewrite the group relation in (56) as:
This form then suggests trading {α 1 , β 1 } with {γ 1 , β 1 } and {α 2 , β 2 } with {α 2 , δ 2 }. Fig. 11c shows these new set of loops on the surface of Σ 3 . If we cut Σ 3 along these loops, we end up with the the shaded irregular 12-gon shown in Fig. 11d, which can be taken as the fundamental domain of the covering map. Note that in this 12-gon all sides remain invariant by D γ1 except the two sides labeled by β 1 . Moreover, the β 1 sides are neighboring the γ 1 sides as was the case in g = 2.
Therefore a shearing map directly analogous to D * γ in Section 4 would work here as well.
In this appendix, we discuss the specific case of applying our logical gate sets to the hyperbolic Z 2 surface code, i.e. the code obtained by placing the Kitaev Z 2 toric code on a hyperbolic surface. This is the simplest abelian case of the general Turaev-Viro code. In this case, the continuous shear map is exactly the same as what discussed for the general Turaev-Viro code in Sec. 4 in the main text. The retriangulation part also implements the same sequence of 2-2 and 1-3 Pachner moves. The implementation of the Pachner moves in terms unitary gates on the physical qubits are even simpler than the Fibonacci code which we illustrated in the Fig. 7 in the main text. In the following, we show the concrete unitary circuits for the implementation of the 2-2 and 1-3 Pachner moves in the hyperbolic surface code.
We note that a number of previous discussions of the hyperbolic surface code considered the case of regular tilings of the hyperbolic surface [14,15,55]. Our protocols require us to consider the code defined on more general triangulations.
As a specific situation of the general Levin-Wen Hamiltonian Eq. ( 4), the Z 2 surface code is described by the following Hamiltonian defined on the trivalent graph Λ following the usual convention:
as illustrated by Fig. 12(a). Here, the 3-leg vertex operator Q ν =X ν,1 X ν,2 X ν,3 is a product of three Pauli-X operators due to the trivalent nature. The j-edge plaquette operator B p =Z ν,1 Z ν,2 • • • Z ν,j is a product of j Pauli-Z operators. Note that the number of edges j on a plaquette is in general arbitrary for an arbitrary trivalent graph, but remains valid for a well-behaved graph to ensure the low-weight condition in the LDPC code family. For example, on a honeycomb lattice, one has j = 6 as shown in Fig. 12(a). If we instead consider the dual description of the hamiltonian on the original triangulation Λ, Q ν =X ν,1 X ν,2 X ν,3 is located on the triangle plaquettes on Λ, while B p =Z ν,1 Z ν,2 • • • Z ν,j is located on the j-leg vertices of Λ.
In the following, we explicitly demonstrate the circuit implementation of the 2-2 and 1-3 Pachner moves, focusing on the description in the triangulation picture Λ for clarity. For the convenience of our discussion, we will use the stabilizer formalism to discuss the operator transformation in the Heisenberg picture. In particular, we will use the following relations on the transformations of the Pauli operators when conjugated by CNOTs: CNOT (X ⊗ I) CNOT =X ⊗ X, CNOT (I ⊗ X) CNOT =I ⊗ X, CNOT (Z ⊗ I) CNOT =Z ⊗ I,
where control is the first qubit and target the second one. The inverse of the above transformation generated by conjugating with CNOTs again on both sides will also be used.
As shown in Fig. 12(b), we want to implement a 2-2 Pachner move by flipping the edge e (pink) which redivides the diamond ♦ abcd into two triangles ∆ ead and ∆ bce , starting from the original partition with triangles ∆ ecd and ∆ abe . To achieve this, we apply two CNOTs indicated by the blue arrow where the arrowhead points towards the target qubit and the tail points towards the control qubit. In particular, the two CNOTs both start from qubit e and point towards the qubit c and a respectively. We start with a stabilizer X e X c X d in the original triangulation Λ I with eigenvalues +1. As shown by the quantum circuit at the bottom of Fig. 12(b), the CNOT from e to c makes the following transformation of the stabilizer:
where the qubit c is disentangled according to the inverse of the first relation in Eq. (61). Next, the CNOT from e and a leads to CNOT ea : X e X d -→ X e X a X d , (63) according to the first relation in Eq. (61). Therefore, we get the new stabilizer X e X a X d with eigenvalue +1 on the new triangle ∆ ead . Note that the diamond stabilizer on ♦ abcd is a product of the stabilizers on the two original triangles ∆ abe and ∆ ecd , i.e., X a X b X c X d = (X a X b X e )(X e X c X d ), having an eigenvalue +1 which is unchanged by the two CNOTs due to the second relations in Eq. (61). At the same time, this diamond stabilizer can be also written as a product of the stabilizers on the two new triangles ∆ bce and ∆ ead , i.e., X a X b X c X d = (X b X c X e )(X e X a X d ). Therefore, the other new triangle stabilizer X b X c X e should also have eigenvalue +1.
To check the consistency, one should also verify the corresponding transformation of the Z-stabilizers. As one can see from the quantum circuit in Fig. 12(b), the 6-body Z-stabilizer on top of the diamond is transformed by the CNOT from e to c according to the fourth relation in Eq. (61) as: (66)
Similarly, the CNOTs acting from f towards c and d create the triangular X-stabilizer on ∆ bed from a single Pauli-X on the ancilla e with eigenvalue +1:
In addition, the two CNOTs from e and f towards d makes sure the new Z-stabilizer is generated on the central vertex from the single Pauli-Z on qubit d with eigenvalue +1:
Finally, one can verify the other Z-stabilizers are also transformed accordingly by the CNOTs. Up to now, we have verified that the CNOTs in Fig. 12(c) indeed implement the 1-3 Pachner move in the surface code. Last but not least, we also note that the representation of the MCG on the hyperbolic surface code correspond to logical gates in a subset of the Clifford group. In the context of our scheme, this subset of logical gates can therefore be implemented effectively instantaneously with long-range SWAP operations implementing the permutations and a constant depth local quantum circuit implementing the subsequent retriangulation.
Accepted in Quantum 2019-07-22, click title to verify. Published under CC-BY 4.0.
The MCG can also be defined using diffeomorphisms; both definitions are equivalent[23].
Ref.[28] also proposed methods to reduce this time cost to O(k γ D) for γ > 0 arbitrarily small, at the cost of increasing the scaling of the space overhead.Accepted in Quantum 2019-07-22, click title to verify. Published under CC-BY
4.0.
Accepted in Quantum 2019-07-22, click title to verify. Published under CC-BY 4.0.