Generating Fault-Tolerant Cluster States from Crystal Structures

Measurement-based quantum computing (MBQC) is a promising alternative to traditional circuit-based quantum computing predicated on the construction and measurement of cluster states. Recent work has demonstrated that MBQC provides a more general framework for fault-tolerance that extends beyond foliated quantum error-correcting codes. We systematically expand on that paradigm, and use combinatorial tiling theory to study and construct new examples of fault-tolerant cluster states derived from crystal structures. Included among these is a robust self-dual cluster state requiring only degree-3 connectivity. We benchmark several of these cluster states in the presence of circuit-level noise, and find a variety of promising candidates whose performance depends on the specifics of the noise model. By eschewing the distinction between data and ancilla, this malleable framework lays a foundation for the development of creative and competitive fault-tolerance schemes beyond conventional error-correcting codes.

Most proposals for fault-tolerant MBQC are based on a topological approach, whereby quantum circuits are woven into resource states via adaptive measurement choices [25,26].The ambient space on which this topological pattern occurs is commonly referred to as the 3D cluster state vacuum, and represents the error-resilient stitching that protects the computation.The essential property of this state is that it can both propagate highly non-local correlations, which carry the logical information being manipulated, while supporting local correlations, which act as consistency checks to catch errors.This permits the sharing of long-range entanglement in the presence of noise, which is essential for any fault-tolerance scheme [27].
Early on, a fundamental connection was observed between 3D cluster states and surface codes [8], which was later extended to CSS codes [28,29] and eventually all stabilizer codes [30].This connection has been termed foliation, which according to its name, maps a stabilizer code to a cluster state representing the evolution of that code in time.In particular, each data qubit of the code is replaced by a time-like 1D cluster state, so that the foliated code maintains the error-correction properties of the base code in a naturally phenomenological error model.
Recently, pioneering work by Nickerson and Bombín studied cluster states that cannot be realized as the foliation of any quantum code [31].The central insight is that fault-tolerant cluster states need not behave as time-like error-correcting codes to maintain their essential property: the coexistence of long-range logical correlations with local consistency checks.At the circuit level, this manifests as constantly measuring and reinitializing all of the qubits, so that each plays a role in both propagating logical information and catching errors.This stands in contrast to a quantum error-correcting code, in which the logical information is held statically in data qubits that remain unmeasured until the end of the computation, while only the ancilla qubits search for errors.Relaxing this division of labor opens up a new design space to explore, and [31] employed a splitting technique reminiscent of approaches in network theory [32,33] to construct new cluster states that were resilient to both dephasing and erasure noise [34].
In this work, we use tools from combinatorial tiling theory [35] to study and construct a broad range of robust fault-tolerant cluster states.The central idea is to use a discrete analogue of orbifold covers to turn the geometric problem described in [31] into an algebraic problem on groups [36].Although we focus on cluster states that are built from periodic crystal structures, we also discuss how these techniques can apply more generally.To illustrate the power of this algebraic approach, we construct a self-dual fault-tolerant cluster state that is optimally local, requiring only a 3-regular underlying graph state.See Figure 1 for a high-level description of the main idea.
Figure 1: Finding a degree-3 self-dual fault-tolerant cluster state, which necessarily cannot be realized as the foliation of any code.This is optimally local, as any degree-2 chain cannot fill space, and so cannot correct any type of error.More generally, a cluster state inherits properties affecting fault-tolerance from the chosen graph heuristic.
In addition, we benchmark these cluster states in the presence of circuit-level noise with varying relative parameters.We do so using a minimum-weight perfect matching decoder, which is less efficient than the union-find decoder [37,38] utilized in [31], but which exhibits higher performance and relates to the zero-temperature phase transition of associated statistical mechanical models with quenched disorder [9,39].We find a variety of competitive cluster states whose robustness depends on the specifics of the noise parameters.
The paper is organized as follows.In Section 2, we discuss the general formulation of faulttolerant cluster states in terms of chain complexes, and introduce their relevant circuit-level noise models.In Section 3, we review the foundations of combinatorial tiling theory, and use it to identify interesting fault-tolerant cluster states based on crystal structures.In Section 4, we provide numerics on examples drawn from an extensive classification of self-dual tilings as well as our numerical search to both benchmark promising candidates, and to probe the effects of circuit-level noise.Finally, we discuss avenues for future development in Section 5.
2 Fault-Tolerant Cluster States

CSS codes as chain complexes
To understand fault-tolerant cluster states, it is instructive to first review quantum CSS codes.In particular, there is a well-established interpretation of CSS codes as chain complexes [40][41][42].Throughout, we implicitly work with coefficients in Z 2 , reflecting the use of qubits.Definition 1.A chain complex C is a sequence of vector spaces {C i } and linear maps between them {∂ i } called boundaries: Every such complex has an associated cochain complex C * comprised of vector spaces {C i := Hom(C i , Z 2 )} and linear maps between them {∂ i (•) := (•) We sometimes refer to C * as the dual of C, and we call the length of the chain complex.
One important characteristic of a chain complex relevant to the associated quantum code is its homology.This measures the failure of each sequence of boundary maps to be exact.

Definition 2.
The homology groups of the chain complex C are the quotient spaces The cohomology groups of the chain complex C are the quotient spaces Representatives of elements in these quotient spaces are referred to as cycles and cocycles, respectively.
It turns out that chain complexes and their homology provide a natural language for describing and building CSS codes.

Definition 3. An [[n, k]
] CSS code can be identified with a length-2 chain complex C: In particular, we have the following correspondence:

{Z-syndromes} {X-errors} {X-stabilizers}
The boundary condition ∂ 1 • ∂ 2 = 0 ensures the commutativity of the X-and Z-type stabilizers.By construction, the class of Z-type (X-type) logical operator representatives can be identified with nontrivial cycles (cocycles) in Logical qubits can be identified with pairs of X-and Z-type logical operators {X i , Z i }, and so it should be the case that dim(H 1 (C)) = dim(H 1 (C)).Furthermore, these logical operators should satisfy canonical anti-commutativity relations X i Z j = (−1) δij Z j X i .This correspondence manifests as a structure theorem on chain complexes [43].

Theorem 4 (Universal Coefficient Theorem
).There is a well-defined isomorphism Thus, for any nontrivial cycle x ∈ C 1 representing a logical Z-type operator, there is a nontrivial cocycle f ∈ C 1 representing a logical X-type operator that intersects x with odd parity when identified with its dual in C 1 .Furthermore, this element will intersect any equivalence class of cycles [y] = [x] with even parity.Consequently, the factorization of the logical subspace into logical qubit subsystems is captured by the structure of the chain complex.

∂2 ∂1
Figure 2: A toric code (left) and color code (right) regarded as chain complexes.For the toric code, the boundary maps between chain complexes are given by the geometric boundary maps in the periodic lattice.For the color code, the boundary maps between chain complexes are given by a pair of abstract Tanner graphs, which are not defined by geometric boundary maps.
In the language of chain complexes, error-correction in the code capacity model can be rephrased as the following problem: Colloquially, this reads: given X-and Z-type syndromes, determine corrections that, taken together with the errors, apply the logical identity.For many error models, this problem can be treated independently in each coordinate without significant loss in performance [7,52].In the presence of depolarizing noise, it is then optimal to choose code families for which these two problems are symmetric, as the threshold will be determined by the worse of the two.These include families like the toric and color codes, while asymmetric families like Shor's code [18] will be bottlenecked by one type of error [53].
The chain complex formulation of error-correction can be extended to phenomenological noise as well.In particular, recent work has studied redundant syndromes checks in the context of length-4 chain complexes in order to characterize single-shot error-correction [48,49].It is then apt that faulttolerant cluster states, which eschew the distinction between data and ancilla, meet in the middle between length-2 and length-4 chain complexes.

Fault-tolerant cluster states as chain complexes
Having described CSS codes in the chain complex framework, we turn to describing fault-tolerant cluster states.Despite their similarities, fault-tolerant cluster states afford an extra degree of freedom that is useful in the construction of robust quantum processes [31].As with most measurementbased schemes, our fault-tolerant cluster states will be built from a particular class of stabilizer states associated to graphs.Definition 5.For a graph G = (V, E), the associated graph state |G is the unique state stabilized by the set of operators Informally, cluster states refer to particular families of graph states that are used as a resource for MBQC.
Defining a complete fault-tolerant MBQC scheme involves several considerations, including details describing the implementation of a universal gate set.For existing proposals, this information requires the specification of additional structures, such as input/output surfaces and their relation to defects [25,30].
In this work, we focus on the error-resilience of the vacuum.Consequently, we consider a distilled problem: the preservation of long-range correlations in the presence of errors.As was noted in [31], the fault-tolerance schemes we discuss can be readily adapted to universal fault-tolerant MBQC using the topological techniques in [25].However, this simplified perspective allows for a concise description of error-resilient vacuums.Definition 6.A fault-tolerant cluster state can be identified with a length-3 chain complex C: The underlying graph state is given by the bipartite graph (C 2 , C 1 ) with biadjacency matrix ∂ 2 .We refer to qubits indexed by C 2 as dual, and qubits indexed by C 1 as primal.
We emphasize that the underlying graph state is entirely determined by the map ∂ 2 , which encodes a single bipartite graph; the maps ∂ 3 and ∂ 1 serve to distinguish the correlations used for error-correction.
There is an intrinsic asymmetry in cluster states, indicated by the presence of X-type symmetries and absence of Z-type symmetries, introduced by the asymmetric definition of a graph state.This asymmetry also manifests in the construction and processing of a fault-tolerant cluster state.Following the prescription in [25], for a cluster state on n qubits with underlying graph state G = (V, E), this proceeds in three steps.
(ii) For each (v, w) ∈ E, apply CZ v,w in some specified order.
(iii) Measure each qubit in the X-basis.
In particular, we have the following correspondence: For any v ∈ C 2 indexing dual qubits, there is a corresponding symmetry of the form i: vi=1 where the X i are supported on dual qubits and the Z j are supported on primal qubits.The reverse relation holds for v ∈ C1 in the cochain complex.Thus, when we identify C 2 (C 1 ) with dual (primal) X-symmetries, we mean symmetries whose restriction to dual (primal) qubits is of X-type.Just as the structure of a length-2 chain complex can be interpreted naturally in terms of the properties of a CSS code, so too can the structure of a length-3 chain complex be interpreted naturally in terms of the properties of a fault-tolerant cluster state. 1 Note that this chain complex is also related to the ungauging complex introduced for quantum codes, and more specifically for 3D surface codes when the cluster state is built from a tiling [54].In the table below, the left-hand side represents either an object associated to or property of the chain complex.The right-hand side represents how that object or property plays a role in the protected computation within the MBQC model.

Chain Complex
Fault-tolerant Cluster State Indexes equivalence classes of dual logical symmetries.
Primal Z-errors equivalent to dual X-errors are undetectable.
Indexes equivalence classes of primal logical Z-errors.
Indexes equivalence classes of primal logical symmetries.
Dual Z-errors equivalent to primal X-errors are undetectable.
Indexes equivalence classes of dual logical Z-errors.
Equivalence classes of dual (primal) logical symmetries are defined up to dual (primal) stabilizer equivalence, while equivalence classes of undetectable dual (primal) Z-errors are defined up to primal (dual) X-error equivalence.Such errors are trivial, as they commute with our X-measurements.Theorem 4 ensures that there are canonical isomorphisms so that for every logical symmetry, there is a corresponding undetectable error that negates it.
One subtlety is that, without specifying input/output surfaces, there is no explicit correspondence between primal and dual symmetries emulating a logical qubit [27,30].This correspondence is explicit for foliated codes, as measuring the bulk of the lattice generates an encoded long-range Bell pair between these surfaces [28].We focus on fault-tolerant cluster states realized by periodic cellulations of 3-space, for which the notions of input/output surfaces, defects, and topologically protected gates can be introduced directly [25,31].However, fault-tolerant cluster state families need not be geometrically defined, as the chain complex structure need not stem from cellulations of a manifold.Foliations of more general quantum low-density parity check code families are examples of such states, and faulttolerant cluster states can be more general still.
Having established the parallels between length-3 chain complexes and fault-tolerant cluster states, error-correction in the fault-tolerant MBQC model can be rephrased as the following problem: Once again, this can be read colloquially as: given primal and dual syndromes, determine primal and dual corrections that, taken together with the errors, preserve the primal and dual logical symmetries.Mirroring CSS codes, this problem can be treated independently in each coordinate, and so it is often optimal to choose a fault-tolerant cluster state for which these two problems are symmetric.In particular, both primal and dual symmetries are required to perform universal fault-tolerant computation [25].
Although the problems of error-correction in CSS codes and error-correction in fault-tolerant cluster states appear similar, comparing problems (1) and ( 2), there are key differences between them (see Figure 3).There is a mapping between these two problems that associates to any stabilizer code a fault-tolerant cluster state called the foliation of that code.The key insight made in [31] is that this mapping is too restrictive; there is an extra degree of freedom in problem (2) that can be exploited to construct more robust fault-tolerant protocols.To highlight this difference, we review foliation in the case of CSS codes, which has also been extended to all stabilizer codes [30].Z-errors on dual (primal) qubits are detected by correlations about cubes (vertices).(b) In the 3D surface code, there are code qubits (green), Z-ancilla (blue), and X-ancilla (red).X-errors (Z-errors) are caught by Z-ancilla (X-ancilla), producing point-like (string-like) syndromes.However, measurements themselves can fail, which is captured in (a) but not (b).In particular, vertices play a role in (a) but not (b), highlighting the difference between the underlying length-3 and length-2 chain complexes.

Foliated quantum codes
Foliated quantum codes are not codes per se, but rather fault-tolerant cluster states that are closely related to codes.In particular, foliation is a map that takes any CSS (or more generally stabilizer) code and constructs a corresponding fault-tolerant cluster state that emulates that code evolving in time for some number of time steps [28].The most famous example is the 3D cluster state on a cubic lattice, which can be seen as a foliated 2D surface code.Given a CSS code presented as a length-2 chain complex and a number of time-steps T , its T -time-step foliation is the following fault-tolerant cluster state, presented as a length-3 chain complex: Let id V denote the identity on V , and for f : V → W , let f i,j : V ⊕T → W ⊕T denote the map that applies f from V i to W j and is zero everywhere else.Then the corresponding boundary maps are Intuitively, the above prescription assembles 1D cluster states of length 2T for each data qubit.Then, Z-type and X-type ancilla qubits are introduced in alternating layers, and connected via CZ gates to the data qubits in their associated stabilizers.Commutativity of the stabilizers ensures that this chain complex is well-defined, and the corresponding fault-tolerant cluster state inherits the properties of the underlying CSS code [28,30].This picture recovers the 3D cluster state as a foliated surface code, depicted in Figure 4. We include the 2-time-step foliated [ [4,2,2]] code, along with its associated chain complexes, as another leading example in Figure 5. Foliated quantum codes are closely related to their corresponding CSS codes in a phenomenological model; indeed the space-time decoding processes for each can be nearly identical [7,8].Foliated codes also yield a prescription for building fault-tolerant cluster states: a priori, building length-3 chain complexes with desirable properties like high distance, high encoding rate, or locality can be a difficult task.Generally, foliation allows one to port existing constructions of quantum error-correcting codes to the MBQC framework, making it a powerful tool.
However, it is also restrictive.There are chain complexes corresponding to fault-tolerant cluster states that cannot be realized as the foliation of any quantum code [31].The broadened framework of length-3 chain complexes permits a wide variety of robust cluster states that often outperform their foliated cousins.In some sense, this generalizes the notion of quantum error-correction in a phenomenological error model.Mirroring the construction of the toric code, one good prescription for building sparse chain complexes corresponding to robust cluster states is by cellulating manifolds.However, before building cluster states from cellulations, it will be helpful to first interpret the effects of different types of noise on such states.In what follows, we describe a circuit-level error model and identify which cluster states should be robust to which parameter regimes of noise.] code and its associated length-3 chain complex.Dual (primal) qubits are colored green (red).For clarity, the four data qubits in a particular time-slice are grouped together.Each time-slice is further subdivided into two steps, which is encoded by the location of the group of four in either C2 or C1.

Circuit-based error model and its effects
We consider a simple circuit-level Pauli error model that captures the correlated errors that may occur due to gate failures.Decoding will be performed independently on primal and dual qubits, and so we describe errors that manifest as Z-type on primal qubits; errors on dual qubits can be treated analogously.We consider three types of errors.
(i) Measurement errors occur with probability p m .This can also account for preparation errors.
(ii) X-type errors occur on the dual qubit support of a CZ gate with probability p X after the gate.
(iii) Z-type errors occur on the primal qubit support of a CZ gate with probability p Z after the gate.
Although X-errors commute with our measurements, X-errors occurring on dual qubits during the construction of the cluster state will result in correlated Z-errors on primal qubits.Note that this is not the standard depolarizing model, in which each two-qubit gate would ordinarily be followed by a depolarizing channel on its support.For example, we do not include idling errors, and each two-qubit gate has two independent chances to fail, so that the probability of having no errors is This atypical model is more damaging, and leads to lower thresholds than the standard error model.However, it allows us to sample errors directly as edges on the decoder graph, which simplifies numerical simulations over a wide range of complicated lattices significantly.In order to draw some comparison between this model and the standard model, we include benchmarks of the usual 3D cluster state as a point of reference [8].
For fault-tolerant cluster states constructed as cellulations, we build the underlying graph state face-by-face.In each face, the CZ gates are applied in consecutive order about the face so that the resulting correlated errors are string-like. 2An augmented 1-skeleton of the cellulation will then serve as the decoder graph, see Figure 6.We elaborate on the unit cell of each lattice, along with the decoder graph, and the gate scheduling in Appendix A.
There are three broad design principles discussed in [31] relevant to the construction of fault-tolerant cluster states built as cellulations of manifolds:  6: On the left, part of a cluster state, with dual (primal) qubits in green (red).The cell complex is defined by solid lines, while the underlying graph state is defined by dashed lines.The cluster state is constructed by applying CZ gates in each face beginning with the bottom edge and proceeding clockwise.In the center, each black edge represents a Z-error occurring on a primal qubit immediately following a CZ gate.Each red edge represents a correlated Z-error resulting from an X-error on a dual qubit immediately following a CZ gate.Measurement errors are omitted for clarity.On the right, a collection of highlighted gate errors resulting in a trivial cycle.Like the foliated repetition code, this 2D cluster has no checks on dual qubits.However, this partial protection extends to more general cluster phases defined on 2D lattices supporting one-form symmetries [55].
(i) Low average vertex degree: heuristically, lower degree vertices yield more information about the surrounding errors, resulting in more robust error-correction.In the limiting case, the repetition code in a code capacity model can be thought of as having a degree-2 decoder graph.This is particularly important when p m dominates, as measurement errors are indifferent to the construction cost of the cluster state.Consequently, choosing the most robust error-correction is optimal.
(ii) Few edges in each face: a face with many edges may result in long-range correlated errors.This is particularly important when p X dominates, as X-errors on dual qubits cause such errors.
(iii) Few faces incident to each edge: to first order in p Z , the effective error rate each qubit experiences is given by the number of CZ gates it participates in.This is determined by the number of faces its corresponding edge belongs to, and so is particularly important when p Z dominates.
As correlated errors on two-qubit gates tend to commute with the gates themselves [56][57][58], we generally expect p Z > p X with p m varying; however, we consider a variety of noise models.Additionally, for self-dual complexes, principles (ii) and (iii) become identical.A final heuristic worth following is increasing the symmetry of the underlying graph states, as homogeneous structures tend to perform better.Broadly, we expect that given different relative error strengths, different fault-tolerant cluster states appropriately balancing robust error-correction with locality become viable.

Combinatorial tiling theory
Building quantum codes from manifolds has been enormously profitable, resulting in some of the best known local codes [41,42,45,46,[59][60][61].However, we do not focus on the topological properties of a fault-tolerant cluster state, but rather the way in which its vacuum is stitched together.Correspondingly, the objects of interest are no longer manifolds but rather certain orbifolds, 3 and in particular, their underlying simplicial structures.These admissible triangulations are encoded into dressed graphs known as extended Schläfli symbols, and their study is broadly known as combinatorial tiling theory [35,36,[62][63][64][65][66][67][68][69][70][71].Put simply for our purposes, it is the algebraic study of ways to periodically tile space.Following [31], we focus on building fault-tolerant cluster states from such tilings, forming a length-3 chain complex in the usual way.The underlying graph state is constructed by placing qubits on faces and edges, with graph state edges determined by ∂ 2 .The 2-skeleton of the tiling will determine the robustness of primal error-correction, with a decoder graph that is an augmented version of the 1-skeleton.The same holds for dual qubits in the dual tiling, and so we focus on self-dual complexes to realize symmetric thresholds.

Constructing tilings
We next review the foundations of combinatorial tiling theory, following the prescription of [36] towards the construction and recognition of tilings.Definition 7. A tiling is a regular CW-complex4 C realizing a simply connected d-dimensional manifold.Its symmetry group Γ is the group of all automorphisms that respect the induced CW-filtration.
Informally, a tiling is a partition of space, with each tile glued face-to-face in such a way that the entire space is filled.It determines a group of symmetries that respect the partition.These are reflections, rotations, and translations that map the tiles back to themselves in such a way that the new tiling is the same as the old.There is a notion of equivalence between tilings that depends on both their topological structure and their symmetry group.This will determine the level of granularity at which we will consider tilings, with two equivalent tilings sharing the same combinatorial structure.Definition 8. Two tilings C 1 , C 2 with respective symmetry group Γ 1 , Γ 2 are equivariantly equivalent if there exists a homeomorphism f : To study tilings, it is useful to break them down into elemental combinatorial objects called flags.These will be defined in terms of objects of different dimensions.We refer to such objects C i as cells, where i denotes the dimension of the cell.For example, C 0 is a point, C 1 an edge, and so on.The set of all cells of dimension ≤ i is called the i-skeleton, and when i = d, it represents the entire CW-complex.Definition 9. A flag is an increasing sequence of cells (C 0 , C 1 , . . ., C d ) with C i ⊆ C i+1 and where each C i belongs to the i-skeleton, but not the (i − 1)-skeleton.
Geometrically, flags can be visualized as d-simplices obtained in the following way.For each i-cell in a complex, associate a vertex at its barycenter.Then, connect the vertices of the cells comprising a flag to form its corresponding i-simplex.For example, a square has 8 flags corresponding to triangles obtained from the barycentric subdivision of its faces and edges, while a cube has 48 flags corresponding to tetrahedra.
Let F denote the set of all flags.A central insight of [62] is to study two relevant group actions on F. The first is induced by Γ, as each automorphism respects the filtration.The second is by the free Coxeter group.Definition 10.The free Coxeter group generated by d + 1 reflections is the group For each flag F = (C i ) i and each index j ∈ {0, . . ., d}, there is a unique flag F = (C i ) i satisfying C i = C i for all i = j and C j = C j .This yields a well-defined action given by r j (F ) := F .Geometrically, this action can be visualized as reflecting the d-simplex corresponding to F about the face opposite the vertex corresponding to C j .This new d-simplex corresponds to F .
The actions of Γ and R commute, and so the R-action descends to an action on the set of flag orbits {Γ • F : F ∈ F}.Specifying the free Coxeter group action, in terms of its generators and relations, on each flag orbit carries all relevant information about a tiling.The objects representing this information are known as extended Schläfli symbols (or Delaney symbols, see [72]).Definition 11.A d-dimensional extended Schläfli symbol is a set S equipped with a transitive R-action along with, for each s ∈ S and for all 0 ≤ i, j ≤ d, positive natural numbers m ij (s) satisfying The symbol is further called regular if m ij = 2 for all |i − j| > 1.
We will generally refer to these as symbols S, leaving implicit the extra information carried by the set.There is also a notion of maps between symbols called coverings, analogous to covering maps between orbifolds.
Informally, coverings are simply maps between symbols that preserve the structure of the symbol, namely the labeled adjacency relations and the vertex labels.We will often be concerned with self-dual cluster states, as our thresholds will be limited by error-correction on the worse of the two lattices.Fortunately, the corresponding notion of duality on symbols is quite simple.Definition 13.The dual of a d-dimensional extended Schläfli symbol is the symbol obtained by interchanging Thus, for the purposes of building fault-tolerant cluster states, we will mostly be concerned with selfdual symbols.For a d-dimensional tiling C with symmetry group Γ, we can associate a d-dimensional symbol in the following way.
(ii) For each flag orbit Γ • F , for any flag F ∈ Γ • F , and for any 0 ≤ i, j ≤ d, let m ij denote the order of the action about r i r j , namely m ij := min{k : (r i r j ) k F = F }.This is independent of the choice of representative F .
Note that for a tiling, the ith cell of r i (F ) depends only on the (i − 1)-and (i + 1)-cells of F .Consequently, any symbol associated to a tiling must be regular, as the corresponding r i ,r j must commute.
To summarize, a symbol has a vertex for each unique flag, up to symmetries of the tiling.For example, the symbol for a regular tiling like that of the plane by squares has a single vertex.In contrast, the 4.8.8 tiling of the plane has three vertices corresponding to flags (triangles) within squares, flags that border two octagons, and flags that border both a square and an octagon; see Figure 7. Extended Schläfli symbols provide a sharp invariant for characterizing equivariant equivalence classes of tilings.Theorem 14 ([62]).Two tilings are equivariantly equivalent if and only if their associated extended Schläfli symbols are isomorphic.
Symbols are often presented as dressed graphs [36].The vertex set is given by S, with each vertex labeled by its corresponding m i,j .For regular symbols associated to tilings, the order of the necessarily commuting reflections is typically omitted, so that each vertex is only labeled by m i,i+1 .The edge set is determined by the R-action, with each edge labeled by the corresponding reflection generator.For tilings, these can be visualized by barycentrically subdividing the tiling into d-simplices representing flags, with the R-action represented by reflections about facets; see Figure 7.
Just as we can create a symbol from a tiling, so too can we construct the underlying space Top(S) of an orbifold encoded by a symbol S.This is done by associating to each s ∈ S a simplex with  Dissimilar to a regular tiling, not all of these reflections are themselves symmetries.For example, any edge corresponding to a reflection mapping between flags of different colors cannot be a symmetry of the tiling, as it maps between two symmetry inequivalent flags.Each flag orbit is labeled with m01/m12; in dimension 2, this corresponds to the number of edges in the face containing the flag, and the degree of the vertex incident to the flag, respectively.The nodes of the dressed graph are colored for clarity.As the 4.8.8 tiling is not self-dual, the two symbols are not isomorphic.
(d + 1)-facets, and then identifying the ith facets of two simplices if the corresponding elements of S are exchanged by r i . 5Coverings can also be realized as continuous maps that identify simplices.
To summarize, we can map from tilings to symbols, and from symbols to topological spaces, where the equivariant equivalence class of a tiling is determined by its associated symbol. 6We would like to construct tilings from symbols directly in order to turn the former geometric problem into a (dressed) graph problem.To do so, we must determine which symbols can be used to realize tilings of Euclidean 3-space.
In order to construct tilings from symbols, we can use a covering space theory of symbols inherited from the covering space theory of orbifolds [36,70].This will further transform the problem on dressed graphs into an algebraic problem on their associated fundamental groups.

Definition 15.
Let S be an extended Schläfli symbol with basepoint s.Up to isomorphism, there is a unique symbol S with basepoint s and a covering u S : S → S with u S (s) = s such that for any other covering f : S → S and any s ∈ f −1 (s), there is a unique u S : S → S through which u S factors: u S = f • u S with u S (s) = s [70].We call S the universal cover of S.
Informally, a symbol is an encoding of a topological space with some symmetry 'packed away'.The larger the symbol, the more flags it has, the more triangles glued together it represents, and the less of its symmetry is packed away.To come back to the square tiling example, a 2-torus corresponds to a square, which can be constructed from a symbol with eight vertices.There is an implicit translational symmetry in the x-and y-directions.The square tiling is its universal cover, obtained from 'unfurling' these symmetries; this is constructed from an infinite symbol that has no symmetries packed away.Each of its triangles is explicitly defined by the symbol, rather than implicitly defined by a symmetry.These implicit symmetries of a symbol are described by the fundamental group of the symbol, and to obtain the fundamental group of a symbol, we must construct its universal cover.
An explicit presentation for the universal cover of S can be constructed according to the prescription in [36].Namely, fix a basepoint s ∈ S and identify S with cosets in R of the normal subgroup where the R-action is inherited from the group, and define m ij (r • U ) := m ij (r • s).As U s ⊆ Stab R (s), this defines a valid cover with covering map r • U → r • s, where the information about S is passed to U s through the group action in the exponent of r i r j .In fact, opposite to the universal cover S of S, there also exists a final (or minimal) cover S. Up to basepoints, this is defined as the unique symbol with covering f S : S → S such that, for any other covering f : S → S , there is a unique f S : S → S through which f S factors: Given the universal cover of a symbol S, we can define the fundamental group of S as the group of deck transformations in the usual way.Definition 16.Let S be an extended Schläfli symbol with basepoint s, and let S be its universal cover with covering map u S .Then the fundamental group of S is given by the subgroup of automorphisms of S annihilated by u S , π 1 (S, s) := {φ ∈ Aut(S) : Following the construction of the universal cover, the fundamental group can be constructed explicitly as π 1 (S, s) = Stab R (s)/U s with a finite presentation [73].If this symbol is covered by a tiling, then the fundamental group corresponds to a subgroup of the symmetries of that tiling.For example, only reflections r i that map between symmetry equivalent flags are themselves symmetries of the tiling.Correspondingly, these are exactly the reflections that belong to Stab R (s).More generally, we have the usual correspondence between subgroups G ⊆ π 1 (S, s) and covers of S, given by G ↔ S/G and pictured below.
On the left, we have a sequence of inclusions of groups, and on the right, a corresponding sequence of coverings of symbols.From top to bottom, the sizes of the objects on the left increase, while the sizes of the objects on the right decrease.We can regard moving up the diagram as unfurling the symmetries of a symbol; the final cover has a maximal group of symmetries π 1 (S, s) and the universal cover is a complete unfurling of those symmetries.In particular, the final cover is the symbol we associate to a tiling, while the universal cover is the symbol that we extract in order to construct a tiling. 7or now, we are interested in determining which symbols S correspond to (unfurled) periodic tilings of Euclidean 3-space.Such an S should be covered by R 3 with deck transformations realizing Euclidean isometries, up to homeomorphism.As symbols also carry the underlying orbifold structure, we also insist that the R 3 cover carry a trivial orbifold structure free of local group actions.Correspondingly, the universal cover must satisfy 8 Symbols satisfying these two properties are called flat, and it suffices to test flatness on any symbol covered by S.
Theorem 17 ([36]).If S and S are 3-dimensional symbols with S covering S , then S is flat if and only if S is flat.
This implies that no matter which symbol in a sequence of coverings we choose, we can check for flatness directly on that symbol.This is important because, by design, we are looking for infinite universal covers (corresponding to a tiling).Fortunately, by Theorem 17, we can instead restrict our attention to finite symbols S corresponding to compact orbifolds that are covered by tilings.Any finite flat symbol must use an infinite translational symmetry group of finite index [74,75].Thus, one can enumerate over finite index subgroups of π 1 (S, s) until identifying one isomorphic to Z 3 , and then construct the corresponding finite cover.If the symbol is free of local group actions, then one can check algorithmically whether its simplicial topological realization is homeomorphic to a 3-torus [76].If so, then the symbol encodes a tiling by unfurling these final translational symmetries.For a complete description of how to perform this check efficiently, see [36].In practice, we perform these tests using the open-source software Gavrog [77], but have included a summary of the internal sequence of checks below for completeness.In summary, in order to construct a fault-tolerant cluster state with desirable properties like selfduality and locality, one begins by constructing valid symbols with those desired properties.There are several necessary conditions one can impose to narrow this search, such as demanding regularity and positive curvature on tiles, as they themselves must be spherical.Then, one can follow the above prescription to construct the associated fundamental group explicitly, and search for a subgroup of spanning translational symmetries.If found, the corresponding finite cover encodes a tiling realizing the desired cluster state, which can be built from translations of the unit cell represented by this symbol.

Checking symbols
It is worth noting that, instead of building fault-tolerant cluster states based on tilings of 3-space, we could instead try and build CSS codes based on tilings of 2-space.In the 2D setting, the Euler characteristic provides a simple invariant for detecting the zero-curvature of a flat 2D symbol S, which must satisfy s m 01 (s) + m 12 (s) = (#s)/2.However, this limits the average degree of a self-dual tiling to 4, which also determines the locality of the code, and so the toric code is essentially optimal with symmetric noise.The central insight in [31] is that this limitation is relaxed in 3D (where the Euler characteristic is zero) due to the increased length of the chain complex.However, fault-tolerant cluster states still incur a tradeoff between the graph state degree and decoder graph degree in a self-dual lattice, as we will see shortly.

An optimally local fault-tolerant cluster state
Before detailing a large class of self-dual fault-tolerant cluster states, presented in terms of their corresponding symbols, we begin with a single fully-realized and optimally local example.Broadly, we have discussed two design principles from [31] for building a robust fault-tolerant cluster state: low average degree of the underlying 1-skeleton, contributing to robust error-correction, and underlying graph-state locality, contributing to a low effective error-rate and minimal correlated errors.
Mirroring the 2D case, these two parameters experience a tradeoff.For example, any spanning surface in a 3D tiling must itself obey the zero-curvature of a 2D tiling.As described in Section 2.4, we expect the performance of fault-tolerant cluster states to vary based on the relative strength of different noise sources.In Figures 8 and 9, we depict four highly symmetric self-dual fault-tolerant cluster states spanning this tradeoff.While the first three are well-known, the last one generates an optimally local (regular) graph state, and was found from our search.In particular, the underlying graph state requires only degree-3 connectivity.
The cubic, diamond, and triamond [31] lattices are carried by special self-dual tilings.Up to a maximal group of symmetries, they only have one type of volume, face, edge, and vertex, although only the cubic tiling has a single type of flag.It has been conjectured that, among a subclass of tilings called natural, these are the only self-dual tilings with this property [67]. 9However, the degree-3 self-dual fault-tolerant cluster state described in Figure 8 is also highly symmetric: both the graph state and the decoder graph are regular.In fact, up to a maximal group of symmetries, it has only two types of volumes, faces, edges, and vertices. 10Although the decoder graph is relatively dense, the graph state locality can make it robust to particular noise processes.

Families of degree-3, -4, and -5 self-dual fault-tolerant cluster states
Next, we describe how simple heuristics, combined with the prescription in Section 3.1, can yield a wealth of robust self-dual fault-tolerant cluster state candidates.Although one should ideally choose a cluster state that is optimal for a particular noise model, we focus on only 3-, 4-, and 5-regular graph state families for simplicity.Very broadly, we would expect local families to perform better in the presence of stronger correlated errors, and denser families to perform better in the presence of stronger independent errors.In particular, this search yielded the aforementioned optimally local example, among many others.The duality isomorphism is the identity.
Figure 8: Two self-dual fault-tolerant cluster states that balance locality of the decoder graph and the graph state, built from the well-studied cubic and diamond lattices, and their corresponding final covers.The first represents the usual 3D cluster state originally introduced in [25], while the second was studied in [31] (figures rendered with Gavrog [77]).
To begin the search, we must write down a family of valid, regular, self-dual symbols corresponding to n-regular graph states.This can be tricky given the many conditions they must satisfy.However, here is one prescription for doing so.
(i) For a desired n, choose any k|n or k = 2n.
(ii) Form a k × k matrix of nodes defining the vertex set of S.
(iii) Indexing the nodes from (x, y) = (1, 1) in the bottom-left corner to (k, k) in the top-right corner,  insert the following edges.
(a) For every i = k, connect (i, j) and (i + 1, j) with an r 0 -edge if i is even, or with an r 1 -edge if i is odd.(b) For every j = k, connect (i, j) and (i, j + 1) with an r 3 -edge if j is even, or with an r 2 -edge if j is odd.  Figure 10: Visualizing the tradeoff between the degree of a graph state (top) and the degree of its corresponding decoder graph (bottom).We comment that locality often plays a role in mitigating errors that may not appear in a gate error model [79], with recent work constructing a 2D quantum code on a degree-3 graph for this purpose [80,81].(v) For every r 1 , r 2 -orbit lying either below or intersecting the diagonal, and for all s in the orbit, choose m 12 (s) ∈ {2, 4, 6, 8, 12} if the orbit size is greater than one, else choose m 12 (s) ∈ {1, 2, 3, 4, 6}.This limitation is imposed by the crystallographic restrictions on rotational symmetries.
One example with k = n = 3 appears in Figure 8.These are valid regular symbols, as for |i − j| > 1, each r i , r j -orbit forms a cycle of length 1, 2, or 4. If the choice of the m 12 (s) yields a tiling of 3space, then the underlying graph state will be an (m 01 , m 23 )-biregular graph.Thus, if this algorithm succeeds, it yields an n-regular graph state.By construction, the symbol is self-dual, with reflection about y = x inducing the duality isomorphism.From this definition, S and its associated R-action are fixed.The only free parameters are the m 12 (s), which lie in restricted sets, forming 5 ( ) potential configurations to check for flatness. 11avrog is an open-source software built explicitly for analyzing tilings [77,[83][84][85][86]. Using its internal methods (and more generally GAP [87]), which apply an optimized version of the construction in Section 3.1, we search over these symbols to identify self-dual fault-tolerant cluster states with nregular underlying graph states.Among the 10 9 candidates we searched over, the vast majority generated by k = 10, we found 475 unique symbols realizing self-dual cluster states.The search results are summarized in Table 1, which are complete for all but (n, k) = (5,10).Rendering these can be difficult, depending on the complexity of the symmetry group.However, to fully translate from algebraic representations to concrete tilings, we graph the two examples described by (n, k) = (3, 3) in Figure 12.In summary, we can search for fault-tolerant cluster states with desired properties by defining a heuristic on graphs representing symbols that satisfy those properties.Then, one can convert this to a computational problem on groups, and identify candidates whose geometric realization gives the desired cluster state.Finally, one can construct this cluster state from its graphical representation, and study robustness of the resulting state.
Although we stop at degree-5, we could continue this search to higher degree graph states.However, at higher degrees, one might also look for more symmetric tilings using other heuristics.Alternatively, one could search for low degree decoder graphs, rather than low degree graph states, although this constraint is not as straightforward to impose on a symbol.Figure 12: The two self-dual tilings found by searching (n, k) = (3, 3) according to Section 3.2.2.To obtain the corresponding graph states, qubits are placed on faces and edges, with an edge between them if they are adjacent (an edge within a face) in the tiling.For example, the purple objects on the left have ten associated qubits: four face qubits and six edge qubits.

Benchmarking crystalline cluster states
Crystals are of fundamental importance in chemistry, and so there are also an abundance of crystals carried by self-dual tilings already in the literature.In addition to building fault-tolerant cluster states from symbols, we can search over existing databases for promising candidates.One example is the RCSR database, which has indexed 38 self-dual tilings [89].Each lattice is labeled with a three-letter identifier, which we adopt to refer to each tiling. 15n [31], the cubic (pcu), diamond (dia), double-edged cubic, and triamond (srs) lattices were benchmarked with a union-find decoder [37] in weighted phenomenological and weighted erasure error models [34].Although the union-find decoder is highly efficient, it is often suboptimal when compared with the less efficient minimum-weight perfect matching (MWPM) decoder [38,90,91].In this section, we extend this analysis in three ways.First, we benchmark additional examples from the aforementioned set of self-dual fault-tolerant cluster states, along with the optimally local example constructed in Section 3.2.In total, we benchmarked three degree-3 lattices drawn from our search; the one included was the top-performer among the three.Second, we perform these simulations in a circuit-level noise model that captures the tradeoff between robust error-correction and cluster state preparation.Our simulations span four different relative parameter regimes in order to better characterize the effects of this tradeoff.Finally, we use the high-performance MWPM decoder to obtain a closer estimate of the maximum thresholds achievable using this approach.
In fact, we can say more using a well-established connection between thresholds for quantum errorcorrection and statistical mechanical models.For each of these crystal lattices with cell complex C, we can associate a Z 2 -lattice gauge theory with quenched disorder mirroring the random-plaquette Z 2 -gauge model on the cubic lattice [7,9,10].The corresponding Hamiltonian is given by assigning spins to edges and defining where τ f ∈ {±1} is a quenched random variable and the local Z 2 -symmetry is obtained by flipping the spins on all edges incident to a vertex.The optimal phenomenological threshold for each lattice then corresponds to a phase transition of its corresponding model along the Nishimori line [7,39,92,93].
The MWPM decoder selects, for each syndrome, an error class with the most likely individual error.While this is generally suboptimal, it can be viewed from the statistical mechanics perspective as the decoder that chooses a recovery string minimizing the free energy at zero temperature.Correspondingly, up to the relative weighting of edges, our dephasing thresholds can be interpreted as estimates for zero temperature phase transitions for lattice gauge theories with disorder defined on a variety of crystal lattices, whose behavior may be of independent interest.The circuit-level thresholds can also be interpreted similarly according to extensions of this model to correlated errors [39].However, we emphasize that these should only be regarded as rough estimates, as degeneracy among minimum-weight strings for a syndrome can cause such Monte Carlo estimates to be imprecise [94].
To simulate our noise model on a particular lattice, we first embed the lattice on a 3-torus of linear-size L. We choose a translation-invariant ordering of CZ gates in each face, and then form an augmented 1-skeleton with edges corresponding to Z-error gate failures on the primal qubit support and X-error gate failures on the dual qubit support (see Appendix A).For this initial comparative benchmarking, we make this choice arbitrarily.On the one hand, this gate ordering is likely suboptimal.On the other, we do not benchmark the dual lattice, for which the gate ordering may be worse.The effects of this choice will grow with p X , and we leave further optimization to future work.
For each edge e, let z e (x e ) be the number of Z-type (X-type) gate failures that could excite e.Then the probability of exciting edge e with a Z-type gate failure is given by and the probability of exciting that edge due to an X-type gate failure P e,X is given analogously.The total probability of exciting an edge e is then given by ) (1−v3) .
In each trial, we excite edges according to P e and form the resulting syndrome.To choose a recovery string, we run MWPM [90,91,95,96] with edges weighted according to − ln(P e ) [8,15,25,97].We declare failure if we have introduced a homologically nontrivial cycle after recovery.For each data point we ran 10 6 trials, adding up to approximately 40, 000 computational hours in total, and observed good agreement with previous benchmarks [9,34].We reemphasize that this a non-standard error model which is very severe.In particular, the threshold for the 3D cluster state in a standard depolarizing model is ≈ 0.75% [8].Consequently, these numbers should be used only comparatively: while our error model allows us to more efficiently simulate these lattices, we leave benchmarking in standard models to future work.
We simulate seven different lattices, referring to them by their three-letter RCSR identifiers. 16We denote the degree-3 cluster state by bst for bipyramid-star with triangular faces, and because it is best with respect to locality.Our simulation sizes span L = 4 through L = 12, depending on the lattice.Although we do observe some finite size effects, it is important to note that several of the lattices have many vertices in their fundamental cell, so that their distance is much greater than L. The additional three lattices were chosen from the RCSR database to validate our hypotheses on the effects of noise; we expect there are many more robust candidates.Renderings of these new lattices, along with a short summary of the self-dual tilings available in the database, are given in Appendix A. In addition, we run four noise models in which p Z , p X , and p m are weighted differently.The resulting threshold estimates are summarized in  Supporting the discussion in Section 2.4, the performance of each cluster state generally reflects the tradeoff between the degree of the graph state and of the decoder graph with respect to the relative strength of X-errors and Z-errors.One can see the peak performer moving from right to left as correlated errors become more prevalent, and so we would expect the degree-3 cluster state to be a top performer in an entirely correlated error model.However, as cluster states are constructed entirely from CZ gates, we believe that the noise regime in which p Z dominates but p X and p m remain significant warrants the most interest [16,56,57].Indeed, this reflects the growing effort to take advantage of biased models [53,[99][100][101][102][103][104][105].However, even when noise is symmetric, there are several candidates competitive with the surface code, and it appears that some lattices are generally more robust than others.
Unsurprisingly, the MWPM decoder performs better than the union-find decoder.While this improvement is noticeable across all three compared lattices, the difference in performance only ranges from ≈ 0.1% − 0.2%.Mirroring the results in [37] on the cubic lattice, we interpret this as positive evidence that the union-find decoder may be a promising alternative to MWPM, given its essentially linear-time efficiency.However, it could be the case that this performance gap increases in the presence of correlated errors, for which the matching decoder can be tailored.
One outlier for symmetric and Z-biased noise is the degree-3 cluster state.Although the trend suggests that it may be a top-performer in a fully X-type error model, for more realistic models its thresholds are lower.Generally, achieving fault-tolerance with degree-3 connectivity or 3-local interactions comes with difficult assumptions, or reductions in threshold.However, the sacrifice is often worth the cost, as locality is more valuable than it might appear at the level of gate errors [80,81,106].Consequently, we believe that the performance of the degree-3 cluster state, whose threshold is only a factor of 2 away from the top-performing surface code in our simplified error model, is very encouraging.

Conclusions
Although there are many similarities between them, fault-tolerant MBQC has certain freedoms that CBQC with error-correcting codes lacks.We can take advantage of these freedoms to build more robust fault-tolerance protocols beyond those based on error-correcting codes.At the circuit level, this freedom manifests as passing logical information between qubits which are regularly measured and reinitialized, without a distinction between data and ancilla.This stands in stark contrast to the more restrictive CBCQ fault-tolerance model, where logical information is held statically within the code qubits until a final measurement.
Using combinatorial tiling theory, we gave a prescription for building fault-tolerant cluster states.Different types of errors have different effects, and one must balance locality of both the decoder graph and the graph state according to different relative error strengths and architectural considerations.We also expect many of these cluster states to be particularly resilient to measurement errors, as their relative error strength does not scale with the construction cost of the underlying graph state.Finally, we analyzed several examples of fault-tolerant cluster states in a variety of noise models emulating circuit-level errors, and benchmarked them with the high-performing MWPM decoder.These results draw closer to optimal thresholds for topological MBQC, and relate to statistical mechanical models defined on different crystal structures.
There are several immediate extensions worth exploring.It would be interesting to consider more varied noise models; for example, we expect local graph state constructions to perform well in the presence of correlated noise.Additionally, this framework is naturally robust to leakage, as no qubit is long-lived.In comparison, thresholds of quantum error-correcting codes require additional teleportation gadgets which lower thresholds [107].Further understanding these cluster states' resilience to hybridized loss and Pauli models would also be of interest [31,108].While we have tested only a few examples to take a snapshot of their performance, a more thorough investigation of promising tilings and their robustness is warranted.
There are also several broader avenues worth exploring.Following [31], we have restricted ourselves to geometrically defined cluster states.While this immediately extends to a universal fault-tolerance scheme, it is not required by the underlying homological problem of preserving distinguished primal and dual symmetries.It would be interesting to study non-foliated codes that are not geometrically defined, although it may be difficult to build abstract sparse chain complexes with the desired properties.
To this end, in the prescription for building fault-tolerant cluster states from simplicial structures on orbifolds, we discarded those whose symmetries were not compatible with a Euclidean metric.However, for computational devices with all-to-all connectivity, there is no need to restrict ourselves to periodic tilings of Euclidean 3-space.Candidates with a Z 3 subgroup in their fundamental group are particularly interesting, as this subgroup serves the role of growing the cluster state in the Euclidean case.One could additionally look at generalized notions of periodicity which have less restrictive symmetries.
There has also been significant work aimed at constructing high rate codes in hyperbolic geometries [59,60].Often, the encoding rate can be described as a function of the combinatorics of an associated regular tiling [109].It would be interesting to try to algorithmically construct non-regular self-dual tilings with higher rates, although recognizing symbols corresponding to tilings with negative curvature would likely prove more difficult.
Finally, there is no fundamental barrier to extending this approach to build fault-tolerant cluster states from tilings of higher dimensional spaces.For example, a fault-tolerant cluster state built from a 5D cubic lattice will inherit string-like excitations as a foliation of the 4D toric code.This comes with a number of favorable properties, including high phenomenological thresholds and local decoders, stemming from the 4D toric code's thermodynamic stability [110][111][112].However, it also requires higher degree graph states due to the 4D toric code's weight-6 stabilizers, which are damaging at the circuitlevel [110].Analogous to dimension-3, could we use a similar prescription in higher dimensions to construct low-degree fault-tolerant cluster states that exhibit string-like excitations?We could also take the opposite approach, and try minimizing the degree of the decoder graph by constructing a higher-dimensional analogue of the triamond lattice, similar to the hypercubic lattice.Understanding this tradeoff in higher dimensions, which allows for richer symmetry, would be of significant interest.

A Additional tiling information
Here, we include renderings of the tilings used in our benchmarking simulations.For completeness, we also include a summary of self-dual tilings appearing in the RCSR database.This information can be found at http://rcsr.anu.edu.au/.The code used to construct and perform matching on these lattices, along with additional lattice benchmarks, can be found at https://github.com/leoadec/crystal-thresholds.In particular, unit cells and gate orderings for each lattice can be found in the lib/doc subdirectory.See Figure 14 for a description.Table 3: A list of the self-dual 3D nets in the RCSR database, along with their relevant average degrees.We have also included the degree-3 bst lattice, which does not appear in the RCSR database to the best of our knowledge.
(a) The 3D cluster state.(b)The 3D surface code.

Figure 3 :
Figure 3: A comparison of error-correction in the superficially similar (a) 3D cluster state and (b) 3D surface code on a cubic lattice.Z-errors (X-errors) are denoted by enlarged circles (cubes), and their syndromes are represented as red lines.(a) In the 3D cluster state, only Z-errors are damaging, as X-errors commute with the X-measurements.Each qubit is measured, and syndromes are processed as correlations between outcomes.Z-errors on dual (primal) qubits are detected by correlations about cubes (vertices).(b) In the 3D surface code, there are code qubits (green), Z-ancilla (blue), and X-ancilla (red).X-errors (Z-errors) are caught by Z-ancilla (X-ancilla), producing point-like (string-like) syndromes.However, measurements themselves can fail, which is captured in (a) but not (b).In particular, vertices play a role in (a) but not (b), highlighting the difference between the underlying length-3 and length-2 chain complexes.

Figure 4 :
Figure4: A 3D cluster state regarded as a foliated surface code.Dotted green lines (abbreviated for clarity) represent time-like 1D cluster states, dotted blue lines represent Z-type ancilla interactions, and dotted red lines represent X-type ancilla interactions.The time-like 1D cluster states can be regarded as Hadamard clocks, with Z-and X-type information available at alternating time steps, with time moving from left to right.

Figure 5 :
Figure 5: (a) A standard representation of the [[4, 2, 2]] code and its associated length-2 chain complex.(b) The underlying graph state of the 2-time-step foliated [[4, 2, 2]] code and its associated length-3 chain complex.Dual (primal) qubits are colored green (red).For clarity, the four data qubits in a particular time-slice are grouped together.Each time-slice is further subdivided into two steps, which is encoded by the location of the group of four in either C2 or C1.

Figure
Figure6: On the left, part of a cluster state, with dual (primal) qubits in green (red).The cell complex is defined by solid lines, while the underlying graph state is defined by dashed lines.The cluster state is constructed by applying CZ gates in each face beginning with the bottom edge and proceeding clockwise.In the center, each black edge represents a Z-error occurring on a primal qubit immediately following a CZ gate.Each red edge represents a correlated Z-error resulting from an X-error on a dual qubit immediately following a CZ gate.Measurement errors are omitted for clarity.On the right, a collection of highlighted gate errors resulting in a trivial cycle.Like the foliated repetition code, this 2D cluster has no checks on dual qubits.However, this partial protection extends to more general cluster phases defined on 2D lattices supporting one-form symmetries[55].
(a) The 4.8.8 tiling.(b) The dual of the 4.8.8 tiling.

Figure 7 :
Figure 7: The 4.8.8 tiling and its corresponding extended Schläfli symbol, represented as a dressed graph, along with their duals.The edges of the original lattice are solid, while edges introduced by the barycentric subdivision are dashed, with the added vertices shown.Up to symmetry, there are three unique flags colored red, blue, and green.Each triangle represents a flag, with its vertices corresponding to a face, edge, and vertex.The action of ri corresponds to reflecting about the facet opposite the vertex representing an i-cell.Examples of each reflection generator appearing in the symbol are shown.Dissimilar to a regular tiling, not all of these reflections are themselves symmetries.For example, any edge corresponding to a reflection mapping between flags of different colors cannot be a symmetry of the tiling, as it maps between two symmetry inequivalent flags.Each flag orbit is labeled with m01/m12; in dimension 2, this corresponds to the number of edges in the face containing the flag, and the degree of the vertex incident to the flag, respectively.The nodes of the dressed graph are colored for clarity.As the 4.8.8 tiling is not self-dual, the two symbols are not isomorphic.
(a) 10-regular graph state, 3-regular decoder graph.The duality isomorphism swaps pairs in each corner and the pair opposite each other along the equator.(b) 3-regular graph state, 12-regular decoder graph.The duality isomorphism is given by reflecting about the line y = x.

Figure 9 :
Figure 9: Two self-dual fault-tolerant cluster states which optimize locality of the decoder graph or the graph state, respectively, and their final covers.The first represents the triamond cluster state studied in [31].The second is new, and was generated by our search.It corresponds to a fault-tolerant degree-3 graph state.
(c) If k is odd, complete the symbol with self-loops along the boundary.If k = 2n, complete the symbol with periodic boundaries.If k = 2n is even, complete the symbol with either self-loops along the boundary or with periodic boundaries.(iv) Define m 01 (s) = m 23 (s) = n for all s ∈ S.

Figure 11 :
Figure 11: The decoder graph of the triamond lattice both with (right) and without (left) correlated errors.Red bonds correspond to X-type errors during the construction of the state.One must carefully balance the robustness of error-correction against the cost of construction (figures rendered in VESTA [82]).

Table 1 :
A brute-force search for self-dual cluster states with n-regular underlying graph states.The nodes of the k × k matrix are ordered alphabetically from left-to-right, and then from bottom-to-top.The components of the m12-vectors represent m12 for each orbit r1, r2 • s with respect to this ordering, determining the symbol.When possible, a pair of random examples are chosen from each search.

Figure 13 :
Figure13: The benchmarked lattices from the RCSR database, ordered from left to right by increasing (decreasing) graph state (decoder graph) degree.For a summary of their parameters, see Table3.

Figure 14 :
Figure 14: A guiding example for reading the gate orderings in lib/doc taken from the 14th face of the decoder graph of the diamond (dia) lattice.Here, the green is overlayed on the actual decoder graph shown in lib/doc.Qubits and CZ gates (green) are placed on edges and faces.The red dotted lines indicate correlated errors due to X-type errors.The gate ordering always begins with a CZ gate supported on a qubit causing a weight one error, and ends with a CZ gate supported on a qubit causing a weight one error.The ordering proceeds either clockwise or counter-clockwise (the choice of which, in our error model, will not have an effect); in this case, it is labeled clockwise.The unit cell vertices and edges of the tiling are depicted in and black and grey, respectively.
Check if the reduced symbol belongs to a known list of simplified symbols.If yes, declare success; the tiling and its corresponding desired graph state exist.If no, continue from Step 4. If there are no more subgroups isomorphic to Z 3 , declare failure.
1. Write down valid regular symbol according to Definition 11, chosen so that the corresponding graph state (if it exists) has desirable properties like locality, self-duality, etc. 2. Check if locally Euclidean [36].If yes, 3. Construct orbifold graph and orbifold invariants [69] to determine space group.If it corresponds to one of the 219 classified space groups, 4. From fundamental group constructed according to Definition 16 and [73], enumerate over finite index subgroups.Test if the next group isomorphic to Z 3 .If yes, 5. Construct the corresponding (possibly toroidal) cover of the symbol as quotient of universal cover by that subgroup.6. Perform symbol reductions [36] to simplify symbol.Once simplified, 7.

Table 2
, and the raw data is available in Appendix B.

Table 2 :
[8]]shold estimates for seven different lattices in four different noise regimes.The graph state (decoder graph) degree increases (decreases) from left to right.The relative impact of Z-type (X-type) errors decreases (increases) from top to bottom.We include the corresponding union-find thresholds from[31]for comparison.The total error-rate p is defined as the largest individual error-rate among pZ , pX , and pm.The lower thresholds reflect the harsh noise model due to our definition of pX , pZ and the the double sampling of errors for each two-qubit gate described in Section 2.4.By comparison, the 3D cluster state has a standard depolarizing threshold of ≈ 0.75%[8].