EP4562559A1

EP4562559A1 - Splitting decoder for floquet codes

Info

Publication number: EP4562559A1
Application number: EP23734803.2A
Authority: EP
Inventors: Adam Edward Paetznick; Matthew Benjamin Hastings; Jeongwan Haah; Marcus Palmer Da Silva; Nicolas Guillaume DELFOSSE
Original assignee: Microsoft Technology Licensing LLC
Current assignee: Microsoft Technology Licensing LLC
Priority date: 2022-07-28
Filing date: 2023-05-30
Publication date: 2025-06-04
Also published as: WO2024025653A1

Abstract

An apparatus and method are provided for decoding syndromes for an error correction code. For faults triggering more than two checks, the faults can be split using either a decomposition approach or a recursive-splitting approach, resulting in a new noise model for the faults. This new noise model is then used with a decoder, such as the union find decoder or the minimum wight perfect matching decoder, which is capable of decoding primitive faults, which are faults satisfying the assumptions of (1) edge-like faults and (2) check linearity. When an encoded system has noise model with both primitive and non-primitive faults, the new noise model is generated, which includes the primitive faults of the original noise model. And the non-primitive faults are incorporated into the new noise model by splitting them using either the decomposition approach or the recursive-splitting approach.

Description

SPLITTING DECODER FOR FLOQUET CODES

FIELD

The field of the disclosure relates to quantum error correction and decoding faults from measured checks.

BACKGROUND

Quantum computing and information processing have great potential, but to achieve this potential several unique challenges must be overcome. Among these unique challenges is decoherence of quantum states arising from coupling between qubits and their environment. This decoherence can be addressed is several ways, each of which have relative advantages and disadvantages.

One approach is quantum error correction, which is used in quantum computing to protect quantum information from errors due to decoherence and other quantum noise. Quantum error correction can be important to achieve fault-tolerant quantum computation that can reduce the effects of noise on stored quantum information, faulty quantum gates, faulty quantum preparation, and faulty measurements.

Generally, quantum error correction includes a series of measurements providing a syndrome that indicates whether a fault (or error) has occurred. Decoding the results for the syndrome measurements may provide information about which fault occurred and regarding which unitary operator can be performed to correct the fault. Some decoders including the Minimum Weight Perfect Matching (MWPM) decoder and the union find (UF) decoder are capable of decoding faults when the syndromes correspond to faults triggering two or fewer checks. The MWPM decoder is discussed in E. Dennis et al., “Topological quantum memory,” Journal of Mathematical Physics, 43(9):4452-4505, 2002. The Union-Find (UF) decoder for surface codes was disclosed in N. Delfosse et al., “Almost-linear time decoding algorithm for topological codes,” Quantum, vol. 5, p. 595 (2021). Generalization to other classes of quantum codes were disclosed in N. Delfosse et al., “Union-Find decoder for homological product codes,” Quantum, vol. 5, p. 406 (2021) and N. Delfosse et al., “Toward a Union-Find decoder for quantum LDPC codes,” IEEE Transactions on Information Theory, vol. 68, Issue 5 (2022).

An improved decoder is desired to decode faults that trigger three or more syndromes.

The subject matter claimed herein is not limited to embodiments that solve any disadvantages or that operate only in environments such as those described above. Rather, this background is only provided to illustrate one exemplary technology area where some embodiments described herein may be practiced.

SUMMARY

One embodiment illustrated herein includes a device that includes a processor that receives a first noise model comprising faults, and receives an effect of the faults on checks of an error correction scheme, wherein the faults of the first noise model including primitive faults and non-primitive faults. The processor adds the primitive faults to a second noise model. The processor determines, for the one of the non-primitive faults, a set of the primitive faults that together have a same set of checks as the one of the non-primitive faults. The processor adds the set of primitive faults to the second noise model.

Another embodiment illustrated herein is a method of decoding faults. The method includes receiving a first noise model comprising faults, the faults of the first noise model including primitive faults and non-primitive faults. The method includes receiving an effect of the faults on checks of an error correction scheme. The method includes adding the primitive faults to a second noise model. The method includes determining, for the one of the non-primitive faults, a set of the primitive faults that together have a same set of checks as the one of the non-primitive faults. The method includes adding the set of primitive faults to the second noise model.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

Additional features and advantages will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the teachings herein. Features and advantages of the invention may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. Features of the present invention will become more fully apparent from the following description and appended claims, or may be learned by the practice of the invention as set forth hereinafter.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features can be obtained, a more particular description of the subject matter briefly described above will be rendered by reference to specific embodiments which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments and are not therefore to be considered to be limiting in scope, embodiments will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:

Figure 1A illustrates an encoded system that includes checks for an error correction codes, according to one embodiment;

Figure IB illustrates faults in the encoded system, according to one embodiment;

Figure 1C illustrates non-trivial checks triggered by the faults in the encoded system, according to one embodiment; Figure ID illustrates a decoding graph of a noise model superimposed on the encoded system, according to one embodiment;

Figure IE illustrates non-trivial checks together with the decoding graph, according to one embodiment;

Figure IF illustrates a distance graph for a syndrome of the non-trivial checks, according to one embodiment;

Figure 2A illustrates a lattice of qubits for a surface code, according to one embodiment;

Figure 2B illustrates an additional vertex for the surface code, according to one embodiment;

Figure 2C illustrates a decoding of an X fault on the surface code, according to one embodiment;

Figure 2D illustrates decoding of Z faults on the surface code, according to one embodiment;

Figure 2E illustrates a Y fault on the surface code, according to one embodiment;

Figure 3 illustrates a hexagonal lattice of qubits for a honeycomb code, according to one embodiment;

Figure 4A illustrates measurements and checks applied to the hexagonal lattice, according to one embodiment;

Figure 4B illustrates a portion of the hexagonal lattice, according to one embodiment;

Figure 4C illustrates XX measurements on the hexagonal lattice, according to one embodiment;

Figure 4D illustrates XX measurements together with YY measurements on the hexagonal lattice, according to one embodiment;

Figure 4E illustrates XX+YY checks derived from the XX and YY measurements, according to one embodiment;

Figure 4F illustrates YY+ZZ checks derived from the YY and ZZ measurements, according to one embodiment;

Figure 4G illustrates ZZ+XX checks derived from the ZZ and XX measurements, according to one embodiment;

Figure 4H illustrates decoding an X fault on the hexagonal lattice, according to one embodiment; Figure 5 illustrates a flow diagram of a minimum weight perfect matching (MWPM) decoder method, according to one embodiment;

Figure 6 illustrates a flow diagram of a single fault splitting method, according to one embodiment;

Figure 7A illustrates a flow diagram of a first example of a noise model splitting method, according to one embodiment;

Figure 7B illustrates a flow diagram of a second example of a noise model splitting method, according to one embodiment;

Figure 8 illustrates a flow diagram of a third example of a noise model splitting method, according to one embodiment;

Figure 9 illustrates a flow diagram of a recursive splitting method, according to one embodiment; and

Figure 10 illustrates computing environment for implementing the methods disclosed herein, according to one embodiment.

DETAILED DESCRIPTION

The following discussion now refers to a number of methods and method acts that may be performed. Although the method acts may be discussed in a certain order or illustrated in a flow chart as occurring in a particular order, no particular ordering is required unless specifically stated, or required because an act is dependent on another act being completed prior to the act being performed.

An apparatus and method are disclosed herein that uses a splitting decoder that is capable of decoding faults in an error correction system where some faults trigger more than two syndromes. Previous decoding methods are not generally capable of decoding faults that trigger more than two syndromes. One motivation for this novel decoder is that in Floquet codes the gauge-outcome- flip triggers four syndromes. However, the method and apparatus disclosed herein is not limited to decoding syndromes from Floquet codes, and the method and apparatus disclosed herein are generally applicable to decode syndromes from any error correction code, especially those that include faults triggering more than two syndromes.

According to certain embodiments, the syndromes from an error correction code are decoded by splitting the faults into primitive faults (e.g., linear faults triggering two or fewer checks that cannot be composed into two faults each triggering one check) and non-primitive faults (e.g., all other faults). A split noise model is initialized to include the primitive faults. Next, a decoder capable of decoding primitive faults are applied to the primitive faults to generate a first noise model. Examples of decoders that are capable of decoding primitive faults include the Minimum Weight Perfect Matching (MWPM) decoder or the union find (UF) decoder. Then, the non- primitive faults are decomposed into disjoint paths and added/concatenated/joined to the split noise model to generate a graph-like noise model that can be used with a decoder for primitive faults. This family of noise splitting methods using a decomposition approach.

According to certain alternative embodiments, the syndromes from an error correction code are decoded by removing the primitive parts from non-primitive faults until nothing remains. This recursive-splitting approach complements the decomposition approach discussed above because some non-primitive faults can only be decoded using the recursive-splitting approach, whereas other non-primitive faults can only be decoded using the decomposition approach. Consequently, a hybrid approach can be used by combining the recursive-splitting approach with the decomposition approach. For example, the hybrid approach can apply the recursive-splitting approach to all non-primitive faults, and for all remaining non-primitive faults (i.e., those not removed by the recursive-splitting approach) the decomposition approach can be applied.

Figure 1A illustrates an encoded system 100. The encoded system 100 has several checks 110, which are illustrated as squares within the system. The checks 110 are used for error detection. Errors are detected by performing the checks 110. When the checks are trivial, no errors are detected. FIG. IB shows two faults 120 are present in the encoded system 100. In FIG. 1C, non- trivial checks 110’ result from the faults 120. To decode which faults 120 occurred, a decoder uses the information of the non-trivial checks 110’ together with the information of the syndromes for the respective faults. For each fault, a syndrome is the set of checks that are triggered by the fault. For example, in classical error correction, a repetition code could be using in which each bit is repeated n times. In this case, the checks for each bit A bit or 1 is encoded in a bit string (x,x, ...,x) with n repetitions. It comes with n — 1 checks that compute the parities of two consecutive bits: Thus, the syndrome for a bit flip of x_t where would be indicated by two nontrivial faults in which 1 and . If two consecutive bit flips occurred for the bits and , then there would also be two nontrivial checks in which and c These two non-trivial faults would also occur if all the bits except for had flipped. The decoder could be programed to recognize that, when the nontrivial faults in which occur, the more likely scenario is that bit flips occurred for the bits rather than for all the bits except for x, and x_i+1. Thus, setting aside the first bit x₀ and the last bit x_n, the segment or path between checks Cj, ... , c_k correspond to faults

Thus, the decoder can be visualized as a graph of n line segments (edges e₀, ... , e_n) corresponding to the faults where the end points for are vertices corresponding to checks The vertices do not have corresponding checks. Because the probability of a bit flip is assumed to be small and is assumed to be the same for all bits, the most likely fault scenarios correspond to the shortest paths between non-trivial checks/vertices on the graph (i.e., the fewest faults). If there is an odd number of non-trivial checks, either vertex v₀ or vertex can be marked as a non-trivial vertex (i.e., a vertex corresponding to a non-trivial check), depending on which vertex is more probable (e.g., corresponds to a fewer number of bit flips. Additionally, even for an even number non-trivial, a scenario may occur in which non-trivial checks are located near the respective end points and the most probable scenario may be represented by marking both vertices and v_n+1 as being non-trivial such that the edges on the graph indicate faults including f₀ and f_n.

The graphical visualization of the decoding process can be applied to the encoded system 100 shown in FIGs. 1A-C. FIG. ID shows edges 140 between vertices corresponding to the checks 110. In FIG. ID there is only one connected component. That is, all the checks are connected either directly or indirectly by the edges of the decoding graph 105. More generally, however, the decoding graph 105 could have multiple connected components. For example, if the edge 140(1) were absent, then there would be two connected components in the decoding graph 105 for the encoded system 100.

FIGs. 1E-F show a scenario with non-trivial check 110’ in addition to the trivial checks. Here, four non-trivial checks 110’(l), 11O’(2), 11O’(3), and 11O’(4) have been triggered. In FIG. IF, paths corresponding to a highest fault probability have been determined. A first path consisting of edge 150(1) is shown between the vertices corresponding to the non-trivial checks 110’(l) and 11O’(2). A second path consisting of edges 150(2) and 150(3) is shown between the vertices corresponding to the non-trivial checks 110’(3) and 110’(4). Thus the decoding for these checks 110’(l), 11O’(2), 110’(3), and 110’(4) would return the faults corresponding to edges 150(2) and 150(3). This discussion illustrates a nonlimiting example of using a Minimum Weight Perfect Matching (MWPM) decoder. A more rigorous description and example of the MWPM decoder is provided below, and a person of ordinary skill in the art would understand how to implement the MWPM decoder to an arbitrary decoding scenario involving only syndromes of two or fewer checks.

So far, only faults having syndromes of two or fewer non-trivial checks have been discussed. However, faults exist that have more than two syndromes, as is illustrated now. FIG. 2A shows a lattice 200 of qubits (circles) 210 for a surface code. Again, the checks are represented by squares. FIG. 2A shows X checks 230 and Y checks 220. As shown, between each pair of Z checks 220 is an edge 225 of a decoding graph. Similarly, the decoding graph includes an edge 235 between each pair of X checks 220. FIG. 2B shows an additional vertex 240 added to the decoding graph. FIG. 2C shows the scenario for an X fault occurring at qubit 210(1). The edge 225(1) passing through the qubit 210(1) corresponds to an X fault having syndrome consisting of two checks (i.e., two non-trivial X checks at the two vertices of the edge 225(1)). Thus, the X faults can be decoded using a decoding graph and the approach discussed above.

FIG. 2D shows the scenario in which Z faults occur at qubit 210(2) and qubit 210(3), respectively. Like the case of the X fault in FIG. 2D, for a qubit 210, the Z faults each have a syndrome with two or fewer checks and the faults can be decode using a decoding graph and the approach discussed above. For the Z fault at qubit 210(3), the additional vertex 240 is marked as a non- trivial vertex and is used in the decoding. FIG. 2E shows the scenario of the Y fault for qubit 210(4). The Y fault has a syndrome the includes four checks indicated by the filled-in squares. For decoding purposes, the Y fault, which is a non- primitive fault can be decomposed into two primitive faults the X fault and the Z fault. For example, primitive faults can be removed from a non-primitive fault. The primitive faults (X fault and the Z fault) are subsets of the non-primitive fault (Y fault). By subtracting the X fault from the Y fault, the remainder is the Z fault. Then the Z fault can be removed, and only the empty set remains (i.e., there is nothing left). This is discussed in greater detail below with reference to Algorithm 4 and method 900.

FIG. 3 illustrates another nonlimiting example of a Floquet honeycomb code that requires a method that is capable of decoding faults with syndromes of more than two checks. The honeycomb code uses a hexagonal lattice 300. Qubits are located at vertices. The plaquettes 310, 315, and 320 are labeled “0,” “1,” and “2,” respectively. That is, the plaquettes 310, 315, and 320 are labeled according to a three-coloring. Edges 340, 345, and 350 are also respectively labeled according to the types “0,” “1,” and “2,” where a type r edge, for r G {0, 1, 2} is such that if you slightly extended the edge, the endpoints would lie in a plaquette of type r, as shown in FIG. 3. Each edge is defined according to some check, which is a product of two Pauli operators, one on each qubit in that edge. The checks are chosen so that the three measurements acting on a given qubit use the three different Pauli operators on that qubit, i.e., X, Y, Z on that qubit each appear in one check. For example, the measurements may be chosen to be XX, YY, ZZ, and for concreteness this convention is adopted here. Then, the XX, YY, ZZ measurements are measured in a sequence of discrete rounds, measurements of type r mod 3 are performed on round r. The checks are provided by combinations of the measurements.

FIG. 4A represents the qubits as circles and the checks as hexagons, wherein different shades of grey represent the XX measurements 410 (dark grey), YY measurements 412 (light grey), and ZZ measurements 414 (medium grey). Again, the checks are represented as squares, wherein different shades of grey represent the XX+YY checks 420 (medium grey), YY+ZZ checks 422 (dark grey), and ZZ checks 424 (light grey). The decoding graph is generated by defining edges between nearest neighbor checks. For example, edge 430, which extends between a ZZ+XX check and a YY+ZZ check, has a syndrome consisting of the checks at the respective vertices, and edge 430 corresponds to a Z fault. Each of the X faults, Y faults, and Z faults correspond to a respective edge of the graph and has a syndrome of two (or fewer) checks. In contrast, gauge-outcome-flip faults trigger four checks, as discussed below. FIG. 4B shows a same honeycomb lattice as in FIG. 3, wherein the honeycomb lattice has the same size as illustrated in FIG. 4 A. Before discussing the gauge-outcome-flip faults, FIGs. 4C-H are discussed to provide additional details about the honeycomb code. For the honeycomb code, the sequence of measurement and the resultant checks are illustrated in FIGs. 4C-G. According to one nonlimiting embodiment, FIG. 4C shows a first step (r=0) of the honeycomb code in which XX measurements are performed. In second step (r=l) of the honeycomb code, YY measurements are performed, and FIG. 4D shows both the XX measurements and the YY measurements combined together. FIG. 4E shows that the XX+YY checks are determined using the combination of the XX measurements together with the YY measurements.

In a third step (r=2), YY measurements are performed. FIG. 4F shows a combination of the YY measurements together with the ZZ measurements, and FIG. 4F shows the YY+ZZ checks derived from said combination.

The honeycomb then repeats starting again at step r=0, performing the XX measurements. FIG. 4G shows a combination of the XX measurements together with the XX measurements, and FIG. 4G shows the ZZ+XX checks derived from said combination.

FIG. 4H shows an example of decoding an X fault. Here, two non-trivial checks 450 are generated. The shortest path (e.g., highest probability path) is the edge 430, which extends between a XX+YY check and a ZZ+XX check. The edge 430 corresponds to a X fault 440. As discussed below, the X fault 440 occurring after time step t triggers the checks corresponding to the (at most two) incident plaquette at time step t + 1. In contrast, the gauge-outcome-flip is a flip of the outcome of plaquette i at time step t triggers the checks (i, t) and (i, t + 1). Because checks are triggered at two steps, as opposed to one time step, the syndrome for the gauge-outcome-flip includes four checks. To visualize this, the decoding graph can have an additional spatial dimension representing the times of the checks.

In view of the above examples for decoding faults in the surface code and the honeycomb code, it is desirable to have a decoder method capable of decoding faults with syndromes having more than two checks. Now a discussion is provided of such a decoder method, but first some definitions and notation are introduced.

FAULTS AND SYNDROME

Assume a system equipped with a set of checks whose role is to detect faults. In the absence of faults, all the checks return a trivial outcome. To detect and correct faults, the checks are measured, and the set of triggered checks (checks returning a non-trivial outcome) are used to identify the faults which occur.

In what follows, C denotes the set of checks of the system. A fault is an unwanted modification of the system. Consider a noise model given by a set of independent faults where each fault occurs with probabilit

Any fault configuration is defined to be a subset We denote a fault configuration as a formal sum with binary coefficients where otherwise. The sum of two fault sets , is defined to be the fault configuration where refers to the addition modulo 2. We can see that the sum of two fault configurations corresponds to their symmetric difference.

Any fault configuration triggers a set of checks. The set of checks is denoted . The set of checks is called the syndrome of the fault configuration Like fault configurations, a syndrome is represented as formal sum of checks and the addition of syndromes is defined similarly.

Without loss of generality, it can be assumed that the faults have distinct syndromes. If two faults have the same syndrome, then the fault can be removed from and replace It may happen that and have the same syndrome but have a different action on the system. In this case, the set of checks is not good enough to distinguish f_t and f_j, and good error correction performance cannot be expected. If this is the case, a different set of checks should be designed. Similarly, it is assumed that all faults trigger at least one check otherwise some faults are undetectable.

MINIMUM WEIGHT PERFECT MATCHING (MWPM) DECODER

Now the MWPM decoder is discussed. In this disclosure, the Minimum Weight Perfect Matching (MWPM) decoder is reviewed for surface codes, and a modification of this decoder is described. This modification of the MWPM decoder also applies to Floquet codes.

First, the MWPM decoder is reviewed, and then the MWPM decoder is applied to a set of faults such that each fault triggers at most two checks. In the case of Floquet codes, some faults trigger up to four checks. Two methods to split faults that triggers more than two checks are disclosed (i.e., the decomposition approach and the recursive-splitting approach). One or both these two methods can be used to realize a splitting of the noise model. This splitting is performed as a preprocessing step, after which the newly derived noise model from the splitting is used with a MWPM (or other) decoder for Floquet codes (or other error correction code).

Table 1 discloses pseudocode for the MWPM decoder, which is also referred to as Algorithm 1. To better understand the MWPM decoder, consider a noise model satisfying the two following assumptions. First, assumptions #1 is that, for edge-like faults, each fault f_t triggers at most two checks. Second, assumptions #2 is regarding the linearity of the checks, namely, assumptions #2 is that, for all the checks and are linear A noise model that satisfies these two assumptions is said to be a graph-like noise model. In what follows, only linear checks are considered. The MWPM decoder (the UF decoder) is compatible with a graph-like noise model. Thus, once a graph-like noise model has been generated, the MWPM decoder (the UF decoder) can be used to decode the faults based on the graph-like noise model.

The decoding graph of the noise model is constructed in two steps. First, a graph is built for which the vertices correspond to respective checks. And two checks are connected by an edge, if there exists a fault that triggers these two checks. For each connected component of this graph, an extra vertex (or vertices) is added. The extra vertex (or vertices) is referred to as the boundary vertex of the component. Then, for each fault hat triggers a single check c, we add an edge connecting c with the boundary vertex of its connected component. By construction, there is a one-to-one correspondence between the faults and the edges of the decoding graph. The edge associated with is denoted The decoding graph is a weighted graph and we define the weight to be

The decoding graph associated with is denoted

A key technical ingredient in the MWPM decoder is the distance graph of a subset of vertices of the decoding graph. The distance graph is the graph whose vertices corresponds to the elements of Two vertices o are connected by an edge if and only if they live in the same connected component of the decoding graph . Moreover, the weight of this edge is given by the distance between these vertices in The MWPM decoder takes as an input a syndrome and returns a most likely fault configuration by computing a Minimum Weight Matching M in the distance graph

With these assumptions, the MWPM decoder (Algorithm 1) takes as an input that is a syndrome and returns a most likely fault configuration. The Union-Find (UF) decoder can be built from the same decoding graph. Informally, it can be seen as an approximation of the MWPM decoder with a more favorable complexity.

Le be a set of faults that satisfies assumption #1 and assumption #2. The MWPM decoder and the UF decoder associated with are denoted Given a syndrome the fault configuration returned by the decoder is denoted

FIG. 5 illustrates a flow diagram of a MWPM decoder method 500 (e.g., Algorithm 1). The method 500 begins by accessing/receiving the inputs 505, which include a syndrome (e.g., a set of checks is denoted and a decoding graph (e.g., the decoding graph associated with .

In step 510 of method 500, a subset of vertices is defined by assigning it a value(s) corresponding to the input syndrome a.

In step 520 of method 500, a loop is performed that adds an additional vertex (or vertices) to the decoding graph as needed. The loop is repeated for each connected component C of the decoding graph . For each iteration of the loop, if the connected component C contains an odd number of vertices of o, add the boundary vertex of the component to

In step 530 of method 500, a distance graph _s is constructed. The distance graph is the graph whose vertices corresponds to the elements o Two vertices of are connected by an edge if and only if they live in the same connected component of the decoding graph

In step 540 of method 500, a minimum weight perfect matching M in the distance graph (e.g., paths in the distance graph for the highest probab ility fault configuration).

In step 550 of method 500, the fault set is initialized by setting the fault set (i.e., the fault set is set to be the trivial fault set).

In step 560 of method 500, a loop is performed that adds faults to the fault set of the syndrome a. Each iteration of the loop is performed for a respective edge defined by the vertices {u, v} that is a member of the minimum weight perfect matching M. For each set of vertices {u, v} a set of edges is computed such that form a shortest path in the decoding graph from vertex u to vertex v. Then, the fault set is concatenated to include the faults corresponding to the set of edges

Finally, method 500 outputs the result 575, which is the fault set p with the syndrome Now, examples of decoding system are discussed, including additional information about the classic repetition code, the surface code, and the honeycomb code, which were discussed above. As discussed above, a classical memory encoded with the repetition code which suffers from independent bit flips is an example which satisfies these two assumptions. A bit x — 0 or 1 is encoded in a bit string (x,x, ... ,x) with n repetitions. It comes with n — 1 checks that compute the parities of two consecutive bits: mod 2 for i = 0, ..., n — 2. By definition, checks are linear and a single bit flip triggers either one or two checks.

The surface code with perfect measurements with X faults or Z faults is another example. Each plaquette measurement defines a check. The plaquette outcomes are linear and each X fault triggers the two incident Z plaquettes (only one for boundary qubits).

The phenomenological measurement noise also satisfies assumption #1 and assumption #2. When measurements are noisy, we repeat plaquette measurements to correct their outcomes. Assume that we run T consecutive rounds of measurement and that each round of measurement is followed by a round of independent X faults on the code qubits. A check is not anymore the outcome of a single plaquette. Instead, there is a check for each plaquette i and each time step t = 0 ... T — 1. The value of the check (i, t). is defined to be 1 if and only if the outcome of plaquette i changes between time step t — 1 and t. To define the check value for t = 0, we assume that the outcomes at time step t = — 1 are all 0. An X fault occurring after time step t triggers the checks corresponding to the (at most two) incident plaquettes at time step t + 1. The flip of the outcome of plaquette i at time step t triggers the checks (i, t) and (i, t + 1). Such a flip triggers only one check when t = 0 or T — 1.

The circuit noise model with X faults for the surface code with standard plaquette measurement circuits based on CNOT gates or joint measurements also satisfies assumptions #1 and assumptions #2.

For the standard syndrome extraction circuits, the only type of fault that is problematic for MWPM decoding of surface codes is T faults because they triggers either three or four checks. However, each Y fault naturally decomposes as a product of an X fault and a Z fault. One can correct all Pauli faults and outcome flips with the surface codes by correcting independently X faults and Z faults. This leads to a MWPM decoder that achieves the full distance of the surface code. One can improve this strategy using the correlations between X and Z.

SPLITTING NOISE MODELS

Floquet codes are more difficult to decode because some faults induce weight four syndrome and do not have a natural decomposition into edge-like faults as Y faults in surface codes. Consider for instance Floquet codes defined on a toric lattice. There are four types of faults: X faults, Y faults, Z faults and measurement outcome flips. The three types of single qubit Pauli faults trigger two checks but measurement flips trigger fours checks. In the case of surface codes, there is a natural split of T faults into faults that satisfy assumption #1. This is not the case for Floquet codes with outcome flips. Here, a splitting strategy is described that applies to both surface codes and Floquet codes. Combined with the MWPM decoder or the UF decoder this leads to an efficient decoder that reaches the largest achievable PRIMITIVE FAULTS

Define a w- fault to be a fault that triggers w checks. Clearly, 0-faults are undetectable and therefore not correctable. It is assumed that none of the faults defining the noise model is a 0-fault.

Given a noise model with independent faults , a fault f_t is said to be primitive if it is a 1 -fault or if it is a 2-fault and if its syndrome is not the sum of the syndromes of two 1 -faults of The set of primitive faults is denoted .

Primitive faults satisfy the two assumptions required for the standard MWPM decoder. We can therefore build a decoding graph from the set of primitive faults and define a MWPM decoder or a UF decoder using this graph.

The set of primitive faults does not contain all the faults of which satisfy assumption #1. For surface codes, a Y fault at the comer of the lattice is a 2-fault but is not a primitive fault because it is a product of an X fault and a Z fault which are 1 -faults. This Y fault is not included in the set of primitive faults because it would reduce the effective distance of the decoder by creating a shortcut in the decoding graph.

DECODER-BASED SPLITTING

The primitive graph is used in combination with the standard MWPM decoder to split non- primitive faults as explained in Algorithm 2, which is outlined in Table 2. The whole procedure is represented in FIGs. 7A, 7B, and 8. A non-primitive fault f is decomposed by calling the MWPM decoder associated with primitive faults. This produces a set of fault configurations D_f = such that each fault is either a 1 -fault or a 2-fault. Each fault orresponds to a path in the decoding graph. Moreover the syndrome of the sum is the syndrome of f. To speed up the fault decomposition, we could replace y by the Union-Find decoder in Algorithm 2.

Table 2

Given a noise model with independent faults , a split noise model is constructed with independent fault " as explained in Algorithm 3. First, all the primitive faults of are add to . Then, the non-primitive faults are looped over, and for each non-primitive fault f with probability p, we compute the decomposition D_f of f using Algorithm 2 and we add each fault of with corresponding probability p. The resulting set of faults satisfies assumptions #1 and assumptions #2. We can therefore define a MWPM decoder or a UF decoder based on the split noise model

This strategy can be used to decode the Floquet codes, and it has been observed numerically that it achieves the maximum distance achievable for the hexagon and square-octagon lattice. This idea also leads to decoders that achieve the code distance for the surface codes with circuit level noise and for the repetition code.

This idea only applies to codes with a specific structure. For example, it does not work with color codes on a torus with perfect measurements because in this case the set of primitive faults is empty. It may also happen that some non-primitive faults cannot be decomposed into primitive faults by Algorithm 2 because some checks triggered by this fault are not triggered by any of the primitive faults.

FIG. 6 shows a flow diagram of a single fault splitting method 600, corresponding to Algorithm 2. Method 600 begins by accessing/receiving the inputs 605, which include a fault set f with syndrome and decoder based on primitive fault. In method 600, A non-primitive fault f is decomposed by calling the MWPM decoder associated with primitive faults. This produces a set of fault configurations such that each fault is either a 1 -fault or a 2-fault. Each fault corresponds to a path in the decoding graph.

In step 610 of method 600, a fault configuration f is computed using the input syndrome as the input to the decoder based on primitive fault.

In step 620 of method 600, a subset of vertices is defined by assigning it a value(s) corresponding to the input syndrome similar to step 510 of method 500.

In step 630 of method 600, the fault configuration f is partitioned into disjoint paths whose endpoints are the vertices of

In step 640 of method 600, the fault configurations Df is initialized by setting Df = {}.

In step 650 of method 600, a loop is performed that adds faults for the respective disjoint paths to the fault configurations Each iteration of the loop is performed for each of path of the disjoint paths . In the i^th iteration computing the fault set for path be the edges of the path then add fault

Finally, method 600 outputs the result 675, which is the fault configurations

FIGs. 7A and 7B show flow diagrams of respective implementations of a noise model splitting method 700, corresponding to Algorithm 3. FIG. 8 also shows a flow diagram of a third implementations of the noise model splitting method 700.

The input 705 of method 700 is a noise model with independent faults . Given the noise model with independent faults metho 700 constructs a split noise model with independent faults (also referred to as a Graph-like noise model).

In step 710 of method 700, a set of primitive faults is computed from the set of faults

In step 720 of method 700, the MWPM decoder is constructed based on the of primitive faults

In step 730 of method 700, the noise mode is initialized as

In step 740 of method 700, fault sets for the non-primitive faults are added to the noise mode . This is realized in step 750 by using the method 600 (i.e., Algorithm 2) to determine the decomposition of the non-primitive faults and then adding the fault sets in the fault configuration to the noise mod . More particularly, step 740 iterates non-primitive faults, using steps 745 and 770. For each non-primitive fault f, step 750 calls method 600 to compute the decomposition Then, in step 760, for each fault in the decomposition the fault with the probability is added to the noise mode

Finally, method 700 outputs the result 775, which is the noise mode

In FIG. 7B, step 708 applies a splitting step 1, which separates the primitive faults to the upper branch and the non-primitive faults f with the probability are maintained on a lower branch. Steps 710, 720, and 730 are discussed above. At step 735, the two branches recombine, and step 740 is performed as discussed above, yielding the result 775, which is the noise mode

In FIG. 8, method 700 is again illustrated according to another embodiment. Here, steps 708, 710, 720, 732, 735, and 740 are performed as described above. Step 740 is combined with step 735. Notably, steps 708, 710, 720, 732, 735, and 740 are indicated as precomputation. That is, these steps to generate the noise mode are performed prior to operating the encoded system and receiving information of non-trivial checks to decode. Accordingly, in step 780, the noise mode is provided to a MWPM decoder or UF decoder, for example, and the decoder uses the noise mod from the precomputation together with a syndrome of non-trivial checks from the encoded system to decode which fault configuration of the syndrome.

RECURSIVE SPLITTING

Here, an alternative splitting strategy is described, which is referred to as Algorithm 4, and pseudocode for Algorithm 4 is provided in Table 4. Its main advantage over Algorithm 3 is that it is simpler, and it does not need a decoder. Neither strategy is strictly better than the other in the sense that there exist faults that can be split by one of the algorithms and not by the other. These two splitting algorithms can be combined together to extend the range of application of the MWPM decoder.

Table 4

The basic idea of Algorithm 4 is to split a fault f by removing the primitive parts of f until nothing remains. In general, it provides the same decomposition of Y faults in the surface codes and outcome flips in Floquet codes as the previous strategy. However, Algorithm 2 fails to decompose a 3-fault whose syndrome is of the form {a, b, c} where a and b appear in the syndrome of primitive faults but c does not. On the contrary Algorithm 4 succeeds to split this fault. The main limitation Algorithm 4 is that it cannot always split faults that are product of paths where each path contains at least two primitive faults. Algorithm 2 works well in this case.

One could consider different variant of Algorithm 4. For example, instead of a while loop, we could use a heap to prioritize the faults with minimum syndrome weight and update the position of a fault after the removal of a component g of a fault f.

It seems natural to combine our two splitting methods by first generating primitive faults using the strategy of Algorithm 4 and then splitting the remaining non-primitive faults using Algorithm 3.

Finally, splitting a noise mode may produce a split model which includes multiple copies of the same fault. These copies of the same fault can be combined.

FIG. 9 shows a flow diagram of a recursive splitting method, corresponding to Algorithm 4.

The input 905 of method 900 is a noise model with independent faults . Given the noise model with independent faults , method 900 constructs a split noise model with independent faults (also referred to as a Graph-like noise model).

In step 910, the noise mod is initialized to be empty and the loop index w is initialized to zero (i.e., w = 0). The loop index w also represents the order of the syndromes. For example, a w-fault is defined to be a fault that triggers w checks (i.e., the syndrome for a w-fault has w checks).

In step 930, for each w-fault f of the following steps are performed: (1) if/is a 1 -fault, then /is removed from and / is added to "; (2) if/ is a 2-fault and the syndrome of f ) is not the sum of the syndromes of two 1 -faults of , then /is removed from nd / is added t and (3) if there exists a fault such that them define the fault h with and with probability remove / from , and add h to

Finally, method 900 outputs the result 975, which is the noise mode

With reference to FIG. 10, an exemplary system for implementing the disclosed technology includes computing environment 1000. The computing environment 1000 is configured to perform one for more of the methods (algorithms) disclosed herein, including the various precomputation and decoding methods. For example, the computing environment 1000 is programed to execute one or more of method 500, method 600, method 700, and/or method 900. After precomputation processes are executed to generate the noise model , computing environment 1000 receives measurement information from the readout device(s) 1008 from which information the classical processor 1010 assembles a syndrome of non-trivial checks derived from the measurements. Based on this syndrome nd the noise model , the classical processor 1010 applies a decoder to determine the fault set of the syndrome Using the determined fault set , error correction can then be applied to the quantum processor(s) 1002.

The environment 1000 includes one or more quantum processors 1002 and one or more readout device(s) 1008. The quantum processor(s) 1002 execute quantum circuits/measurements). The processes executed by the quantum processor(s) 1002 can be precompiled. The quantum processor(s) 1002 can be a topological quantum architecture (e.g., a topological quantum computing device using Majorana zero modes).

The computing environment 1000 can execute instructions to perform the quantum computing techniques described herein, including, e.g., causing the quantum computer circuitry described herein to execute a Floquet code, such as the honeycomb code, or execute a surface code, for example. Further, the quantum computer circuitry can implement the coding techniques for a quantum architecture (e.g., Majorana-based systems).

The precompiled quantum circuits/measurements (including, for example, selections of any of the codes and checks) can be sent into (or otherwise applied to) the quantum processor(s) 1002 via control lines 1006 at the control of quantum processor controller 1020. The control lines 1006 can be a bus, for example, which conveys signals among the components of the computing environment 1000. The quantum processor controller (QP controller) 1020 can operate in conjunction with a classical processor 1010 to implement the desired quantum computing process. In the illustrated example, the QP controller 1020 further implements the desired quantum coding process (i.e., application of the checks and confirming measurements) via one or more QP subcontrollers 1004 that are specially adapted to control a corresponding one of the quantum processor(s) 1002. For instance, in one example, the quantum controller 1020 facilitates implementation of the compiled quantum circuit by sending instructions to one or more memories (e.g., lower-temperature memories), which then pass the instructions to low-temperature controllers (e.g., QP subcontroller(s) 1004) that transmit, e.g., pulse sequences representing the measurements/unitary operations on the quantum processors) 1002. In other examples, the QP controller(s) 1020 and QP subcontroller(s) 1004 operate to provide appropriate magnetic fields, encoded operations, or other such control signals to the quantum processor(s) to implement the operations of the compiled quantum computer circuit description. The quantum controller(s) can further interact with readout devices 1008 to help control and implement the desired quantum computing process (e.g., by reading or measuring out data results from the quantum processors once available, etc.)

With reference to FIG. 10, compilation is the process of translating a high- level description of a quantum algorithm into a quantum computer circuit description comprising a sequence of quantum operations or gates, which can include the coding methods as disclosed herein. The quantum computer circuit description can include a set of faults that have been decoded from a syndrome of non-trivial checks, which are based on measurements of the qubits in the quantum processor(s) 1002. The compilation can be performed by a compiler 1022 using a classical processor 1010 of the environment 1000 which loads the high-level description from memory or storage devices 1012 and stores the resulting quantum computer circuit description in the memory or storage devices 1012.

In other embodiments, compilation and/or code generation/implementation can be performed remotely by a remote computer 1000 (e.g., a computer having a computing environment as described above) which stores the resulting quantum computer circuit description in one or more memory or storage devices 1062 and transmits the quantum computer circuit description and/or training instructions to the computing environment 1000 for implementation in the quantum processor(s) 1002. Still further, the remote computer 1000 can store the high-level description and/or Majorana fermion code generating (or implementing) instructions in the memory or storage devices 1062 and transmit the high-level description and/or instructions to the computing environment 1000 for compilation and use with the quantum processors). In any of these scenarios, results from the computation performed by the quantum processor(s) can be communicated to the remote computer after and/or during the computation process. Still further, the remote computer can communicate with the QP controller(s) 1020 such that the quantum computing process (including any compilation, error correction, and/or QP processor control procedures) can be remotely controlled by the remote computer 1060. In general, the remote computer 1060 communicates with the QP controller(s) 1020 and/or compiler/synthesizer 1022 via communication connections 1050.

Further, the methods may be practiced by a computer system including one or more processors and computer-readable media such as computer memory. In particular, the computer memory may store computer-executable instructions that when executed by one or more processors cause various functions to be performed, such as the acts recited in the embodiments.

Embodiments of the present invention may comprise or utilize a special purpose or general- purpose computer including computer hardware, as discussed in greater detail below. Embodiments within the scope of the present invention also include physical and other computer- readable media for carrying or storing computer-executable instructions and/or data structures. Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer system. Computer-readable media that store computer- executable instructions are physical storage media. Computer-readable media that carry computer- executable instructions are transmission media. Thus, by way of example, and not limitation, embodiments of the invention can comprise at least two distinctly different kinds of computer- readable media: physical computer-readable storage media and transmission computer-readable media.

Physical computer-readable storage media includes RAM, ROM, EEPROM, CD-ROM or other optical disk storage (such as CDs, DVDs, etc), magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer.

A “network” is defined as one or more data links that enable the transport of electronic data between computer systems and/or modules and/or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a transmission medium. Transmissions media can include a network and/or data links which can be used to carry or desired program code means in the form of computer- executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. Combinations of the above are also included within the scope of computer-readable media. Further, upon reaching various computer system components, program code means in the form of computer-executable instructions or data structures can be transferred automatically from transmission computer-readable media to physical computer-readable storage media (or vice versa). For example, computer-executable instructions or data structures received over a network or data link can be buffered in RAM within a network interface module (e.g., a “NIC”), and then eventually transferred to computer system RAM and/or to less volatile computer-readable physical storage media at a computer system. Thus, computer-readable physical storage media can be included in computer system components that also (or even primarily) utilize transmission media.

Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. The computer-executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, or even source code. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the described features or acts described above. Rather, the described features and acts are disclosed as example forms of implementing the claims.

Those skilled in the art will appreciate that the invention may be practiced in network computing environments with many types of computer system configurations, including, personal computers, desktop computers, laptop computers, message processors, hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, mobile telephones, PDAs, pagers, routers, switches, and the like. The invention may also be practiced in distributed system environments where local and remote computer systems, which are linked (either by hardwired data links, wireless data links, or by a combination of hardwired and wireless data links) through a network, both perform tasks. In a distributed system environment, program modules may be located in both local and remote memory storage devices.

Alternatively, or in addition, the functionality described herein can be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that can be used include Field-programmable Gate Arrays (FPGAs), Program-specific Integrated Circuits (ASICs), Program-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc.

The present invention may be embodied in other specific forms without departing from its spirit or characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope.

Claims

1. An apparatus, comprising: a processor that: receives a first noise model comprising faults, and receives an effect of the faults on checks of an error correction scheme, wherein the faults of the first noise model including primitive faults and non-primitive faults; adds the primitive faults to a second noise model; determines, for the one of the non-primitive faults, a set of the primitive faults that together have a same set of checks as the one of the non-primitive faults; and adds the set of primitive faults to the second noise model.

2. The apparatus according to claim 1, wherein the processor repeats for each of the non-primitive faults the steps of (1) determining a respective set of the primitive faults that together have a same set of checks as the each of the non-primitive faults and (2) adding the respective set of the primitive faults to the second noise model.

3. The apparatus according to claim 1 or claim 2, wherein the processor adds the primitive faults to the second noise model by adding all 1 -faults in the first noise model to the second noise model, and adding to the second noise model all 2-faults that have syndromes that are not a sum of syndromes of two 1- faults, and the processor removes from the first noise model all faults that have been added to the second noise model.

4. The apparatus according to any one of claims 1-3, wherein the processor determines the set of the primitive faults that together have the same set of checks as the one of the non-primitive faults by

(i) finding a first fault in the second noise model that is a subset of the one of the non- primitive faults,

(ii) defining a residual fault having a syndrome given by removing checks of a syndrome of the first fault from a syndrome of the one of the non-primitive faults, such that the residual fault is the one of the non-primitive with the first fault removed,

(iii) in the first noise model, replacing the one of the non-primitive faults from with the residual fault, such that the one of the non-primitive faults is replaced by the second fault, which is the one of the non-primitive faults with the first fault removed, and then repeating steps (i), (ii), and (iii) on the residual fault thereby removing additional faults from the residual fault, the additional faults being faults in the second noise model that are respectively subsets of the residual fault, which is a subset of the one of the non-primitive faults, and the repeating of steps (i), (ii), and (iii) continuing until no more additional faults can be found in the second noise model that are subsets of the residual fault.

5. The apparatus according to claim 1 or claim 2, wherein the processor determines the set of the primitive faults that together have the same set of checks as the one of the non- primitive faults by decomposing the non-primitive faults into configurations of faults, each of the non- primitive faults being decomposed into a respective set of fault configurations, and, adding faults of the respective set of fault configurations and associated probabilities to the second noise model.

6. The apparatus according to claim 5, wherein the processor decomposes the non- primitive faults into configurations of faults by, for a respective non-primitive fault, using a decoder of primitive faults to decode the one of the non-primitive faults into a first set of faults, partitioning the first set of faults into disjoint paths, and, for a given path of the disj oint paths, ( 1 ) determining edges of the given path and (2) adding a fault configuration to the set of fault configurations of the respective non-primitive fault, wherein the fault configuration is a summation of respective faults corresponding to the edges of the given path.

7. The apparatus according to any one of claims 1-6, wherein the processor uses the second noise model as an input to a decoder to decode a syndrome generated by applying an error correction code to an encoded system, the decoder used by the processor is either a minimum weight perfect matching decoder or a union find decoder, and the encoded system is a lattice of qubits in a quantum processor and the error correction code is either a surface code or a Floquet code.

8. The apparatus according to any one of claims 1-7, wherein the primitive faults are faults that satisfy a first assumption and a second assumption, the first assumption being that each of the primitive faults triggers at most two checks, and the second assumption being that the checks are linear for the primitive faults.

9. A method, comprising: receiving a first noise model comprising faults, the faults of the first noise model including primitive faults and non-primitive faults; receiving an effect of the faults on checks of an error correction scheme; adding the primitive faults to a second noise model; determining, for the one of the non-primitive faults, a set of the primitive faults that together have a same set of checks as the one of the non-primitive faults; and adding the set of primitive faults to the second noise model.

10. The method according to claim 9, further comprising repeating for each of the non- primitive faults the steps of (1) determining a respective set of the primitive faults that together have a same set of checks as the each of the non-primitive faults and (2) adding the respective set of the primitive faults to the second noise model.

11. The method according to claim 9 or claim 10, wherein the step of adding the primitive faults to the second noise model comprises: adding all 1 -faults in the first noise model to the second noise model, and adding to the second noise model all 2-faults that have syndromes that are not a sum of syndromes of two 1- faults, and the method further comprises removing from the first noise model all faults that have been added to the second noise model.

12. The method according to any one of claims 9-11, wherein the step of determining the set of the primitive faults that together have the same set of checks as the one of the non- primitive faults comprises:

13. The method according to claim 9, wherein the step of determining the set of the primitive faults that together have the same set of checks as the one of the non-primitive faults comprises: decomposing the non-primitive faults into configurations of faults, each of the non- primitive faults being decomposed into a respective set of fault configurations, and, adding faults of the respective set of fault configurations and associated probabilities to the second noise model.

14. The method according to claim 13, wherein, for a respective non-primitive fault, the step of decomposing the non-primitive faults into configurations of faults comprises: using a decoder of primitive faults to decode the one of the non-primitive faults into a first set of faults, partitioning the first set of faults into disjoint paths, and, for a given path of the disj oint paths, ( 1 ) determining edges of the given path and (2) adding a fault configuration to the set of fault configurations of the respective non-primitive fault, wherein the fault configuration is a summation of respective faults corresponding to the edges of the given path.

15. The method according to any one of claims 9-14, further comprising using the second noise model as an input to a decoder to decode a syndrome generated by applying an error correction code to an encoded system, wherein the decoder is either a minimum weight perfect matching decoder or a union find decoder, and the encoded system is a lattice of qubits in a quantum processor and the error correction code is either a surface code or a Floquet code.