Quantum decoder

Abstract

A quantum error correction method and apparatus are disclosed. A decoder of a quantum computer system receives syndrome data representative of an error state of qubits in the quantum computer system, the syndrome data comprising defects each associated with a location in a decoding graph. The decoder initialises a size value of a region surrounding each defect in the decoding graph. The decoder then identifies clusters of defects and increases the size values of identified defects. A correction for the error state is determined based on the clusters of defects.

Description

[0001] QUANTUM DECODER

[0002] BACKGROUND

[0003] The present disclosure relates to apparatus, systems, methods and data structures for use in decoding quantum error correction codes.

[0004] SUMMARY OF THE INVENTION

[0005] According to a first aspect of the invention, there is provided a computer-implemented quantum error correction method comprising: (a) receiving, at a decoder of a quantum computer system, syndrome data representative of an error state of qubits in the quantum computer system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective location in a decoding graph; (b) initialising, at the decoder, a respective size value associated with each respective defect of the plurality of defects, the respective size value representative of a respective size of a respective region surrounding the respective defect in the decoding graph; (c) identifying, at the decoder, clusters of defects, wherein a pair of defects of the plurality of defects is included in a same cluster if a shortest distance between the pair of defects in the decoding graph is less than a sum of the respective size values associated with each respective defect of the pair of defects; (d) identifying, at the decoder, defects in clusters that (i) contain an odd total number of defects (this may include defects that are not in any cluster yet, i.e. isolated defects may be treated as a cluster containing a single defect) and (ii) do not contain any respective defects having a respective size value larger than a shortest distance between the respective defect and any boundary of the decoding graph (the method is applicable to decoding graphs with no boundary, e.g. toric code decoding graphs: if the decoding graph does not have a boundary, none of the defects will have a size value larger than a shortest distance between the respective defect and any boundary of the decoding graph); (e) if any defects are identified: determining, at the decoder, an increment value based on a minimum distance between the respective region surrounding any respective identified defect and one of (i) any boundary of the decoding graph (if the decoding graph has a boundary), and (ii) the respective region surrounding another defect in a different cluster ; and, increasing, at the decoder, the respective size value associated with each identified defect by the increment value and repeating steps (c), (d) and (e) (until no defects are identified in step (d)); (f) otherwise, determining, at the decoder and based on the clusters of defects, a correction for the error state. The present invention provides an improved implementation of union-find decoding (an introduction to union-find decoding can be found in Delfosse & Nickerson, arXiv: 1709.06218v3 [quant-ph]). Quantum error correction codes generally involve decoding a "syndrome", which can be considered to be a signature associated with an error state of the physical qubits in the code (two different errors can potentially have the same syndrome). A "decoder" is then used to identify an error which could have caused the syndrome (or possibly instead just a correction operation that can be used to correct logical qubit states encoded in the code, e.g. a single bit representing whether the eventual logical measurement outcome needs to be flipped).

[0006] In certain error correction codes, such as topological error correction codes including the surface code, a "decoding graph" can be used to facilitate decoding of the syndrome by pairing "defects" in the syndrome (these defects generally provide an indication of end points of chains of errors on physical data qubits in the error correction code).

[0007] Union find algorithms decode syndromes by clustering defects into groups. A cluster of decoding graph edges is formed around each defect (defects are located at a subset of nodes of the decoding graph), and these clusters are grown by including additional edges until all defects are included in a cluster containing an even number of defects (or the cluster touches a boundary of the decoding graph), with overlapping clusters being merged after each growth stage. Correction(s) to the encoded logical state can then be determined based on the clustering of defects.

[0008] Conventional union-find decoding methods track all of the decoding graph edges contained in each cluster. Fault-tolerant quantum computation will likely involve millions of physical data qubits, with the number of edges in the decoding graph being orders or magnitude larger still. The size of the decoding graph therefore imposes extremely high memory requirements upon the decoding hardware (potentially prohibitively high), and there is therefore a need to reduce this memory overhead.

[0009] The present invention overcomes this memory problem by implementing union-find decoding (and therefore operating the quantum computer as a whole) in a new way. Rather than tracking the edges that form each cluster in the decoding graph, the present invention instead associates a size value (also referred to as a radius) with each defect in the error syndrome. Clusters are formed by comparing the distance between defects with the sum of their size values: if the distance between two defects is less than the sum of their size values then they are grouped into the same cluster. In this way, the only information that the decoder needs to store for each defect is (i) the location of the defect, and (ii) the size value associated with that defect (for comparison, conventional union-find decoding methods may need to store details of hundreds of edges for each defect). Alternatively, a counter could be used to track the number of times the size value has increased for each node, and this could be used to dynamically infer the size value as needed (instead of storing the size value itself).

[0010] The increment value is the amount by which each size value (and therefore each respective region) increases during step (e) (step (e) may also be referred to herein as the growth stage). Using an increment value that is too small requires additional growth steps to reach the final growth state (i.e. decoding will take longer than it needs to). Using an increment value that is too large causes the accuracy of the decoding to be reduced because some clusters will grow larger than they need to. The use of a variable increment value in the first aspect (i.e. an increment value that changes for each growth stage based on defect region spacings) allows the number of growth stages (and therefore the time taken to decode) to be minimised without sacrificing accuracy. The method of the first aspect therefore optimises decoding performance by avoiding unnecessary growth stages while ensuring that the clusters do not grow more than they need to (i.e. the method of the first aspect provides a balance between decoding accuracy and decoding speed).

[0011] The distance between the respective regions surrounding two respective defects is equal to the difference between the shortest distance between the respective defects and the sum of the respective size values associated with the respective defects (this value will be negative if the regions overlap, i.e. if the sum of the size values is larger than distance between the defects).

[0012] Because quantum error correction takes place below the algorithm level in the quantum stack (i.e. at the architecture level of the quantum computer), the technical effect of the present invention is produced irrespective of the data being processed or the applications being run. That is, the present invention provides a substantial memory reduction and improved decoding performance for all applications performed on the quantum computer. In addition, the reduced memory requirements and improved decoding performance enable the use of more robust (e.g. higher code distance) error correction algorithms with lower logical error rates, meaning that the present invention results in the quantum computer operating with a lower logical error rate for given decoding hardware (i.e. running more efficiently and effectively as a quantum computer). A decoding graph is a graph (in the mathematical sense) comprising edges representing error mechanisms and nodes (or vertices) representing differences in successive syndrome measurements (or more generally, a decoding graph comprises nodes representing detectors, which are measurement results that sum to zero (e.g. modulo 2 sum) during perfect (i.e. error-free) operation of the quantum computing system). The decoding graph may have one or more boundaries, which involve edges that only connect to a single node in the decoding graph (the other end of these boundary edges may either be unconnected, or they may connect to one or more virtual boundary nodes, i.e. the decoding graph may be a subgraph of a larger graph including the virtual boundary node(s)). Conventionally, some error correction literature has referred to "rough" boundaries and "smooth boundaries". However, the "smooth" boundaries in such literature are not actually boundaries in the above sense, and they will not be referred to as boundaries in the present disclosure. Accordingly, the boundaries referred to herein are synonymous with the "rough" boundaries in such literature.

[0013] A syndrome is a collection of values (e.g. measurement values, generally based on qubit measurements - in particular syndrome qubit measurement) representative of an error state of physical data qubits in the quantum computer. The syndrome may also include decoding graph location information for each syndrome value - e.g. a coordinate or index value.

[0014] A defect (also referred to as an excitation or measurement event) generally represents the end of a chain of errors in the decoding graph (the chain of errors may span both space-like and time-like dimensions of the decoding graph). Defects are non-trivial syndrome values, and they may correspond to a change in value of a syndrome qubit measurement outcome between successive rounds of syndrome measurement.

[0015] A decoder is a classical computing system that decodes syndromes and provides one or both of (i) possible error locations (i.e. which data qubits may have experienced an error), and (ii) a correction for the qubit error state. It is possible to determine a correction during decoding without determining error locations, and the correction may be a single bit representing whether a logical error has occurred. The correction can generally be tracked by a classical computer (e.g. by the decoder or a control system) and does not generally need to be applied to the qubits. The decoder may be a dedicated hardware device (e.g. implemented using an FPGA or ASIC or similar) or it may be a software component implemented using a CPU. The initial value of the size value may be predetermined based on a standard value (e.g. a distance between two nodes of the decoding graph) or it may be based on empirical data (e.g. trial an error may be used to determine initial values that provide the best performance in previous or simulated scenarios).

[0016] The size value may increase by a constant amount each time (e.g. by an amount equal to the initial size value), or it may increase by a different amount each time (e.g. it may be doubled each time, or use any other scaling).

[0017] The clusters may also be referred to as sets / groups / collections, or any similar term that refers to a grouping of defects.

[0018] The increment value may be equal to the minimum distance between the respective region surrounding any respective identified defect and one of (i) the any boundary of the decoding graph, and (ii) the respective region surrounding another defect in a different cluster, or it may be otherwise based on this minimum distance (e.g. a linear function of the minimum distance, such as some multiple of the minimum distance). One skilled in the art will appreciate that there are various ways that the increment value could be based on this minimum distance depending upon the desired performance (e.g. accuracy and speed) of the decoder.

[0019] The method may further comprise obtaining, at a quantum processing unit (QPU) of the quantum computer system, the syndrome data by measuring a plurality of syndrome qubits of the QPU.

[0020] For example, the syndrome data may be obtained by measuring a plurality of syndrome qubits at the QPU (e.g. surface code stabiliser measurements). The decoder may receive the syndrome data as raw (e.g. analogue) measurement data, or the syndrome data may be pre-processed (e.g. processed into digital form by a control system).

[0021] The quantum error correction method may be a surface code (e.g. planar code) error correction procedure. Alternatively, the quantum error correction may be any other error correction procedure that can be decoded by grouping defects on a decoding graph, such as other topological quantum error correction codes.

[0022] One skilled in the art will appreciate that the details of how the correction is identified, and how it is based on the clusters of defects, will depend upon the configuration of the error correction method in question. For example, identifying the correction for the error state may comprise: identifying a logical operator for the quantum error correction method involving physical qubits of the quantum computer system that are associated with the boundary of the decoding graph; determining a parity of a total number of clusters that the logical operator intersects that contain an odd total number of defects, wherein an even parity indicates that the logical operator is in a correct logical state and an odd parity indicates that the logical operator is in an incorrect logical state.

[0023] Determining the increment value may optionally comprise determining a minimum cluster separation value of the identified defects, wherein the minimum cluster separation value is equal to the minimum value of: (i) half of a shortest distance between the respective regions of any two defects identified in step (d) that are not in same cluster, (ii) a shortest distance from the respective region of any defect identified in step (d) to the respective region of any defect not identified in step (d), and (iii) a shortest distance from any defect identified in step (d) to any boundary of the decoding graph; and setting the increment value to at least the minimum cluster separation value.

[0024] Setting the increment value to at least the minimum cluster separation value ensures that at least one cluster is modified (i.e. merges with another cluster or a decoding graph boundary) when step (c) is repeated. This ensures that the decoding algorithm progresses after each growth stage.

[0025] According to a second aspect of the invention, there is provided a computer program product comprising instructions which, when the program is executed by a decoder of a quantum computing system, cause the decoder to carry out the method of the first aspect.

[0026] According to an third aspect of the invention, there is provided a (non-transitory) computer-readable medium comprising the computer program product of the second aspect.

[0027] According to a fourth aspect of the invention, there is provided a quantum computing system comprising a decoder configured to perform the method of any of the first aspect.

[0028] BRIEF DESCRIPTION OF THE DRAWINGS Examples of the present invention will now be described in detail with reference to the accompanying drawings, in which:

[0029] Figure 1 shows an example of patches of surface code;

[0030] Figure 2 shows an example of patches of surface code containing errors;

[0031] Figure 3 shows an example of patches of surface code containing equivalent errors;

[0032] Figures 4a-e show an example of a process for decoding a patch of surface code using a Union-Find decoder;

[0033] Figures 5a-e show cluster representations for a decoding example equivalent to that of Figures 4a-e;

[0034] Figure 6 shows an example of how memory can be used for a random scattering of edges corresponding to a typical memory state and a contrasting ordered state corresponding to Union-Find decoding;

[0035] Figure 7 shows an example of a data structure of the present disclosure and an associated graph representation of a surface code patch;

[0036] Figures 8a-d show an example of a decoding method, applied to the surface code patch of Figure 7, and the associated data structures;

[0037] Figure 9 shows an example of a rotated surface code patch;

[0038] Figure 10 shows an example of a 3D unrotated surface code graph with measurement noise;

[0039] Figure 11 shows an example of a 3D rotated surface code graph with full circuit level noise;

[0040] Figure 12 shows a method for use in decoding syndromes of a quantum error correction code;

[0041] Figure 13 shows an example embodiment of a quantum computer system;

[0042] Figure 14 shows an example embodiment of a computer program product; and Figure 15 shows an example of determining minimum cluster separation.

[0043] DETAILED DESCRIPTION

[0044] Quantum computing holds out the prospect of making possible computations that are, and will always remain, impossible using conventional classical computing technology. However, to enable quantum computers to solve practical computational problems that would otherwise be insoluble it will be necessary to perform quantum error correction, since the appearance of errors in quantum computers is essentially inevitable. Quantum computers that can do this may be described as fault tolerant. A quantum processor unit can contain a combination of data qubits, used to store and manipulate the quantum information, and syndrome qubits that can be used to determine the presence or absence of errors that occur on the data qubits at any time, including during quantum data processing, and also measurement errors that occur during the syndrome qubit measurement process. Measurement of these syndrome qubits can generate a very large (potentially Terabytes per-second), real-time, flow of error correction data that needs to be processed to make quantum computing possible.

[0045] The data obtained from measuring syndrome qubits is called the 'syndrome'. The process of decoding includes using the syndrome to determine which data qubits have been affected by errors and what types of error. Only then, is it possible to implement the necessary error corrections required for fault tolerant quantum computing. Decoding is therefore a critical process required to make practical quantum computing technically possible.

[0046] Decoding sufficiently quickly to keep pace with the flow of syndrome data is one of the key limiting factors for achieving fault tolerant quantum computation. Decoders that work by grouping syndrome bits into clusters, such as "Union-Find", are one of the leading proposals for fast and scalable decoders. There exist implementation proposals for these "clustering" decoders in dedicated hardware, in order to decode in real-time at the very high speeds required. The present disclosure provides a significant improvement to data structures that can be used in many clustering decoders, together with apparatus and methods for generating and using this new data structure to enable practical quantum computing.

[0047] In the following disclosure, the surface code will be used to provide specific examples of a quantum error correction code. However, it will be appreciated that many other types of quantum error correction code are possible, such as other topological quantum codes, bosonic codes, etc., which may also benefit from using the data structures and methods of the present disclosure.

[0048] Figure 1 shows two examples of surface code patches 100, 110 represented as graphs. Surface code decoding is a graph problem, and a decoding graph such as the graph in Figure 1 is generally used when decoding error syndromes. In Figure 1, edges 102, 112 correspond to data qubits. Vertices 104, 114 correspond to syndrome measurement qubits. As explained in more detail below, while the graph in Figure 1 can be used as a basic decoding graph, it is also possible to use more complex decoding graphs (e.g. with an extra dimension representing time) in which there is not necessarily a one-to-one correspondence between data qubits and decoding graph edges. One skilled in the art will appreciate that the physical qubits do not necessarily need to be physically arranged as shown in Figure 1. However, the connectivity of the physical qubits will preferably correspond to the graph structure shown in Figure 1 in order to facilitate surface code operations.

[0049] With no errors, syndrome qubits are in the |0) state, as illustrated in the first surface code patch 100. An error on a data qubit edge flips the states of its endpoints from |0) to 11), or vice-versa. The end result is that syndrome measurement vertices are | 1) if there are an odd number of errors on the incident data qubit edges, and |0) otherwise. The second surface code patch 110 shows five vertices 116a-e in the | 1) state.

[0050] Syndrome measurement vertices with the value | 1) may be referred to as error syndrome bits, which can arise where they are adjacent to an odd number of data qubits on which errors are present. The syndrome measurement data can be processed to identify the error syndrome bits contained therein and that identification can be used to determine 'identified syndrome qubits', being the actual physical qubits that have the | 1) value that indicates that an error has occurred somewhere in the system.

[0051] The description of error correction presented immediately above involves a perfect set of stabiliser measurements, decoding of the resulting syndrome, then physical correction of the determined Pauli errors. However, it will be appreciated by person skilled in the art that this describes a somewhat idealized picture and that error correction in practice can involve further subtleties as discussed below.

[0052] The reality of error correction can differ in that (i) measurements are not perfect, and (relatedly) (ii) that typically physically correcting errors after every round (if at all) is not necessarily required. This means that an error which flips the result of some stabiliser measurements will continue to flip the results of those measurements in subsequent measurement rounds. Decoding the resulting syndrome would result in a whole sequence of errors in the same place, repeating across time, which would need to be identified and corrected later. It is more efficient for errors to only affect the syndrome once. This can be achieved elegantly by only reporting differences in the syndrome (often called the difference syndrome which identifies difference syndrome bits). This means that a single data error will appear in only a single time slice of the decoding graph. This also means that a single measurement error will produce changes at two consecutive time steps, the first when the measurement error is made initially and the second when a subsequent correct measurement is made.

[0053] This has two delicate consequences. The first is that it is no longer really true that marked / identified vertices correspond to a particular measurement result such as a -1 eigenvalue or a 11 > state. In this picture, they represent changes in that measurement from one state to the other. For this reason " | 1> vertex" is not necessarily the best name for this idea, when the more complex picture of error correction is considered. A relatively standard name for a marked vertex in a decoding graph is a defect. Errors thus create a pair of defects, and the objective is to match them up. In some examples, an odd number of defects may exist in the code, in which case the matching process can be completed using a so-called 'artificial' defect, which exists at the boundary of the code. It will be appreciated that artificial defects are particular examples of defects.

[0054] The second consequence is that time slices of vertices no longer correspond to a time at which measurements were made: vertices are between consecutive rounds of measurement; equivalently, rounds of measurement are between layers of vertices, i.e. are associated with vertical edges of the graph. However, it will be appreciated that embodiments of the present invention can advantageously be applied to both simplified and more complex error correction scenarios. In the latter, more complex scenario, error syndrome bits are examples of difference syndrome bits.

[0055] The decoding problem does not generally have a unique solution, therefore the objective is to find the most likely explanation for an observed set of syndrome measurements. An explanation looks like a set of edge-disjoint paths connecting pairs of syndrome vertices that measured 11), as shown in a first example pair 116a-b of vertices and a second example pair 116c-d of vertices. The most likely explanation is the set of paths with shortest total length. Finding the shortest set of paths connecting pairs of syndrome vertices that measured | 1) can be expressed as a minimum weight perfect matching problem, so this approach is known as 'MWPM' decoding.

[0056] The edges (data qubits) along the boundary of the surface code are only measured by one syndrome measurement qubit. The other endpoint of these edges is an abstract boundary vertex 120 (the same vertex for every boundary edge) whose state is not measured physically but can be inferred from the requirement that the total number of | 1) measurements must be even. Figure 2 shows three further surface code patches 200, 210, 220. Some sets of errors are undetectable. A closed loop of errors 202, 204 has an even number of errors at every vertex, so every syndrome qubit will be measured as 10>, which would also be consistent with the absence of any errors. These errors are called stabilisers because they are not really errors at all, rather they can be said to fix the state of the data.

[0057] A continuous path of errors 212, 222 stretching from the left boundary to the right boundary also has an even number of errors at every measured vertex. These errors are called logical operations, and do affect the state of the data. The number of edges on the shortest path between the boundaries is called the distance of the code, which is 5 in the case of the surface code patches 200, 210, 220 of Figure 2.

[0058] Figure 3 shows three surface code patches 300, 310, 320. The existence of stabilisers means that there is not one unique correction for any given error because any two corrections that differ by stabilisers are equivalent. For example, a first interpretation 302 of a pair of | 1) vertices (defects) is equivalent to a second interpretation 312 of the same pair of | 1) vertices (defects), because these interpretations differ by a stabiliser 322. This means that MWPM is not solving exactly the right problem; a perfect decoder would find the most likely explanation of a syndrome where the probabilities of all the equivalent explanations that differ by stabilisers are summed. However, when the physical error rate is small the dominant terms in that sum come from the shortest corrections, so MWPM can provide a good approximation. There are polynomial time algorithms for solving MWPM, but they are too slow to perform decoding in practice, for a real-world quantum computer.

[0059] Union-Find is an alternative decoding algorithm that runs in almost linear time (using a so-called "union-find" data structure) and has comparable accuracy to MWPM. The idea of Union-Find is to group 11) vertices (defects) into local clusters. How a correction is implemented within a cluster is unimportant, as different choices only differ by stabilisers.

[0060] Figures 4a-e show a series of graphs 410, 420, 430, 440, 450 of unrotated surface code with | 1) vertices (defects, illustrated as enlarged crosshatched dots at the relevant vertices) at the same positions for each graph (where each position is given a similar reference numeral in successive graphs). Each graph shows the evolution of a clustering process, conducted according to the Union-Find algorithm, designed to cluster the | 1) vertices (defects) together into a set of decodable clusters. Figure 4a shows a first graph 410. The Union-Find algorithm begins by placing each 11) vertex (defect) in its own individual cluster 412a-f. For a cluster to be correctable, it needs to contain an even number of | 1) vertices (defects, which can include the artificial boundary defects described above). In each iterative round of the process, each cluster containing an odd number of | 1) vertices (defects) is extended outwards by a half-edge of the graph.

[0061] Figure 4b shows a second graph 420, in which the algorithm extends vertices 422a and 422b by a half-edge in all directions which results in these clusters growing into each other and merging to form a clustered pair of vertices. Similarly, vertices 422c and 422d merge to form a pair. However, vertices 422e and 422f remain isolated and thus remain part of cluster containing only the single vertex concerned.

[0062] Figure 4c shows a third graph 430 in which the process is repeated, with half-edge growth steps applied to the odd parity clusters 432e and 432f to enable clusters to merge until all clusters are even, although, at this step, neither of these vertices 432e, 432f merge with any others. The even parity clusters formed at the second graph 420 do not grow in the third graph 430 because they contain an exactly even number of 11) vertices (defects).

[0063] The boundary vertex (artificial vertex / defect) on each side is an optional | 1) vertex / defect (the abstract boundary vertex whose state can be inferred from parity can be considered as the sum of the left and right boundary vertices, so nothing need be determined about either of them individually). Therefore, the cluster 432f that has reached a boundary will not grow further because it has reached the boundary.

[0064] Figure 4d shows a fourth graph 440 in which a remaining single vertex cluster 442e grows and merges to form an enlarged cluster also including the existing cluster 442c, 442d.

[0065] Figure 4e shows a fifth graph 450 in which all | 1) vertices (defects) have been formed into a first even cluster 452 of exactly four | 1) vertices (defects) and a second even cluster 454 of exactly two | 1) vertices (defects). The clustered vertices can now be decoded by any conventional means. For example, the error can be decoded by defining a logical operator involving edges at a boundary of the decoding graph (e.g. the boundary edges on either the left or the right side of the decoding graph in Figure 4a-e) and counting how many clusters this logical operator intersects that contain an odd total number of defects. If the parity of this count is even, then the defined logical operator is considered to be free from error. However, if the parity is odd then the defined logical operator is considered to be in an error state, and its logical value should be flipped when it is measured. In this way, a single bit can be used to track the error state of the defined logical operator (i.e. it is not necessary to determine physical qubit error locations and physical qubit corrections).

[0066] Figures 5a-e show cluster representations of the Union-Find procedure discussed above in relation to Figure 4. Corresponding features have been given corresponding reference numerals and may not necessarily be discussed further here. A first cluster representation 510 shows | 1) vertices (defects) 512a-e distributed as in Figure 4. Each square of the cluster representation 510 can be represented in a memory using a single bit, which records either the presence or absence of vertex relevant to forming clusters.

[0067] A second cluster representation 520 shows two single-vertex clusters 522e, and 522f and two two-vertex clusters (comprising 522a, 522b and 522c, 522d respectively) that exist after a single growth step. A further grow step shows, in a third cluster representation 530, that the clustering of the previous step remains unchanged. A yet further growth step, shown at a fourth cluster representation 540, shows that the clustering procedure has evolved to include a three vertex cluster 542c-e while the other cluster remain unchanged. The three vertex cluster 542c-e will grow at the next step since it contains an exactly odd number of vertices (defects). A final cluster representation 550 shows that the clustering process is complete, with all | 1) vertices (defects) belonging to one of two even clusters, a cluster of four 11) vertices (defects) 542 and a cluster of two | 1) vertices (defects) 544.

[0068] Standard union-find data structures record the geometry of each cluster as shown at each step of Figure 5a-e. The conventional approach is to use memory to record whether or not there has been any growth along each half-edge adjacent to each vertex, as discussed above (subsequent to which a traversal algorithm can be used to determine which half-edges belong to which clusters). This leads to a memory requirement scaling in accordance with the total number of vertices, i.e., the total number of syndrome qubits. However, using one bit of classical memory to represent each half-edge is wasteful, as explained further below.

[0069] Figure 6 shows two surface code patches 600 where most possible states of a memory using a standard Union-Find method represent random scatterings of half-edges on the left that do not correspond to running a Union-Find decoder with maximum efficiency, while a conventional Union-Find decoder approach is shown on the right. By contrast, a Union-Find cluster can be conceptualized, according to the present disclosure, as a union of balls centred at each | 1) vertex (defect), the radius (in the graph metric) of each ball being determined by the number of times that each | 1) vertex (defect) was included in a cluster that has grown because it contained an odd number, in total, of | 1) vertices (defects) at any given iteration of the cluster identification process. According to the present disclosure, clusters can be represented using precisely this information, i.e., co-ordinates (or more generally a location) and a radius for each | 1) vertex (defect) in a given cluster.

[0070] For each | 1) vertex (defect), it is possible to record the number of times that it is present in a cluster that grows in size. Growing a cluster means incrementing the length of the radii for each vertex in that cluster. Detecting whether initially separate clusters have merged as a result of a single incremental increase requires checking pairs of | 1) vertices (defect) to determine if their respective balls have grown into each other or are touching each other; that is, if the first radius plus the second radius is at least twice the graph distance (on the decoding graph) between the respective | 1) vertices (defects), then they are touching or overlapping and hence part of the same cluster. Advantageously, this means that the method of the present disclosure does not require that the actual shape of the balls be known when determining whether two balls are touching or overlapping (simply a radius value, which is compared to the distance between defects). In Figures 7 and 8a-c (discussed below) all of the radius growth amounts are scaled by 0.5 so that the comparison is against the graph distance between nearest neighbor vertices, which is 1.

[0071] Figure 7 shows an unrotated surface code patch in graph form 700 and a corresponding data structure 702. The graph shows the locations for | 1) vertices (defects) 710, 712, 714, 716, 720, 722 (which are depicted as enlarged crosshatched vertex dots). The data structure 702 records the location of each vertex, for example the first | 1) vertex (defect) 710 has location (2,4) in the graph. It will be appreciated that any system may be used to encode the location, such as a co-ordinate system that indexes the graph (as here) or any other co-ordinate system or any means of encoding values within any co-ordinate system. Further, in other examples, the location could refer to the actual physical location in 2- or 3-dimensional space of the relevant qubits.

[0072] The data structure 702 also records the radius of the ball surrounding each vertex, which in this initial state is 0 for all cases. Hence, for the first vertex 710 the data structure records the entry "(2,4):0" (the other | 1) vertices (defects) being recorded correspondingly).

[0073] Figures 8a-d show the evolution of the present cluster determination method as applied to the | 1) vertices (defects) illustrated in Figure 7.

[0074] Figure 8a shows a surface code patch 800a after a first iteration in which each cluster (of Figure 7) is grown by a single unit, corresponding to a half-edge of the graph. Each ball that surrounds each | 1) vertex (defect) is shown as a square shape as the norm used to define the shape of each ball is the Li norm on a vector space corresponding to the graph (which may equivalently be described as the graph metric on the square grid).

[0075] It will be appreciated that if the conventional Euclidean L2 norm was used instead, then each ball would be circular, and further that the term 'ball' is used in its standard mathematical sense of being an N-dimensional region of an N-dimensional space or graph, the region being within a constant distance (or radius) from a single point, the distance measured using any appropriate norm defined on the N-dimensional space or graph (the term 'ball' used herein also encompasses higher dimensional 'n-balls' or 'hyperballs'). Accordingly, the 'balls' described herein need not be circular / spherical in nature when visualised on a decoding graph where all edges are illustrated with the same length. The visual shape of the balls will depend upon the 'weight' of the edges in the graph, wherein the weights on the edges are used to calculate distances within the graph based on the chosen norm.

[0076] After the first increase in radius the code patch 800a has four clusters: two single vertex clusters 810a, 812a and two (even) two-vertex clusters 814a, 820a. The associated data structure 802a records the location in the graph of each vertex around which each ball is constructed and its associated radius, which after only one iteration is 0.5 for each ball. The balls surrounding the vertices of the first two-vertex cluster 814a can be said to touch in this case as they coincide half way between vertex positions (3,2) and (3,3). In other examples, balls may instead overlap by coinciding throughout a finite volume rather than simply coinciding at a point, or as a further alternative they may meet along a line within a three-dimensional graph.

[0077] Balls are only grown for (i) defects that are not in a cluster and have a ball that does not touch a boundary (i.e. where the radius associated with the defect is not larger than the shortest distance between the defect and a boundary of the decoding graph), and (ii) defects that are in an odd parity cluster (i.e. a cluster containing an odd total number of defects (or an individual defect that is not in a cluster), wherein none of the balls / regions surrounding the defects in the cluster (or the ball / region surrounding the individual defect if not in a cluster) touches a boundary(i.e. has a size value that is larger than the shortest distance between the defect and a boundary)).

[0078] Figure 8b shows the surface code patch 800b after a second iteration. The previously established even clusters 814b, 820b do not increase in radius. However, the single vertex clusters 810b, 812b both increase in radius to a length of 1. The number of clusters remains the same at this iteration and the data structure 802b records the state of the clusters.

[0079] Figure 8c shows the surface code patch 800c after a third iteration. The previously established even clusters 820c do not increase in radius but the previous single vertex cluster 810c increases in radius to 1.5 and thereby form an odd-cluster of three | 1) vertices (defects) with the formerly even two-vertex cluster 814c. Conversely, the single vertex cluster 812c does not increase in size as it has reached the boundary of the graph at co-ordinate 0,2 and will, similarly, not increase in future iterations for the same reason.

[0080] Figure 8d shows the surface code patch 800d after a fourth iteration. Each vertex ball of the former three-vertex cluster has increased in radius by a half-edge resulting in a single cluster 810d of exactly four vertices. The previously formed two-vertex cluster 820d remains unchanged. This completes the clustering process by forming all | 1) vertices into even clusters, the locations and geometries of which are efficiently recorded in the associated data structure 802d. The data structure 802d can now be used to decode the syndromes of the quantum error correction code (i.e. to identify a correction for an error state of the qubits in the error correction code), that is the surface code patch 800d, by any suitable method, which can ultimately enable the performance of quantum error correction. The identified correction may provide a correction to the qubits, or it may simply be two bits of information (for each logical qubit) that indicate whether logical 'X' and 'Z' measurements should be flipped for a given logical qubit (in other words, the correction does not necessarily need to identify where errors have occurred, nor does the correction need to be applied to the qubits: it can instead by tracked classically in software, e.g. by a decoder or control system).

[0081] The standard union-find data structure is an efficient way to represent the current state of a sequence of merge operations on an initial set of objects, here the initial single- vertex clusters. To update, or determine, in which cluster a vertex belongs, such standard union-find data structures can be used. The Clustering Union-Find data structures disclosed herein 802a-d can efficiently represent the internal structure of the clusters.

[0082] Any Union-Find type decoding algorithm can move back and forth between updating the standard union-find data structure and the Clustering Union-Find data structure. Thus, these two data structures evolve together in parallel, each informing how the other should change at each step.

[0083] It will be appreciated that, as a matter of generality, if a single, or any odd number of | 1) vertices (defects) join an existing even cluster, then that newly formed cluster will have an odd number of | 1) vertices (defects) and consequently all of the balls surrounding the vertices of that newly formed odd-cluster will increase in radius at the next iteration (unless any ball in the cluster has already reached a boundary).

[0084] The memory requirement of the present cluster representation scales with the number of 11) vertices (defects) in the syndrome, and not with the number of syndrome qubits, as per previous representations. Consequently, the effect of using this representation is to provide a more efficient data structure to store information about the shape of clusters. This advantageously enables simplification of hardware used to implement a decoder based on this data structure. This simplification of hardware improves performance, lowers memory requirements and enables parallelism by reducing contention to memory, which all provide clear technical advantages for performing fault-tolerant quantum computing.

[0085] The representation and associated data structures of the present disclosure can advantageously be used independently of the underlying graph. The graphs presented in Figures 7 and 8a-c, discussed above, are for the unrotated surface code. Other graphs for which this technique can be useful include the rotated surface code, such as that shown schematically by the graph 900 in Figure 9.

[0086] Figure 10 shows a three-dimensional version of a decoding graph for the unrotated surface code 1000, which includes multiple rounds of syndrome measurement to detect measurement errors (the surface code itself is two-dimensional, and the third dimension represents the repeated rounds of syndrome measurements, i.e. the time evolution of the two-dimensional surface code). Each round occurs at a separate time and thus the surface code 1000 in this case forms a spatio-temporal graph. Each round extends horizontally with successive rounds indexed on the vertical (time) axis 1002 from 0 to 5. The syndrome extraction circuitry is otherwise assumed to be perfect in the sense of exhibiting "phenomenological noise" only.

[0087] Figure 11 shows a three-dimensional decoding graph for the rotated surface code that includes additional edges to account for full circuit level noise 1100. The diagonal edges represent other error processes that can be visible in the syndrome, e.g., "hook errors" arising from circuit-level noise, which is a noise model in which the errors introduced by the circuitry for measuring syndromes are included. Similar edges could be added to the graph in Figure 10.

[0088] By default, the metric on a decoding graph may define that all edges have length 1. However, it will be appreciated that different graph edges in the decoding graph can have different lengths (also referred to as weights), which can represent the probability of an error being present on each edge. More likely error locations can be represented by shorter edges (lower weights), such that the probability of those errors occurring may increase more rapidly. These variable weights could be represented by integers or floating point numbers. The amount that a radius can grow in each iteration can therefore be an integer or floating point number. In all of these cases, the data structure of the present disclosure and the associated methods and apparatus can advantageously be employed to enable fault tolerant quantum computing to be implemented in practice.

[0089] Furthermore, because different edges can have different lengths / weights, the 'balls' described herein will not necessarily be circular / spherical when illustrated on a regular surface code grid even when using an L2 norm. As such, the term 'radius' used herein can more generally be referred to as a size value, r, associated with a given defect. The term 'ball' may be generally understood generally to refer to the region of the decoding graph that is within distance 'r' of the given defect.

[0090] While the above examples show the size values (radii) increasing uniformly (i.e. by the same fixed amount) during each growth stage, this will not necessarily result in optimal decoding performance. If the chosen increment value (the amount by which the size value (and therefore the region / ball) associated with the defects increases) is too small then it will take additional growth steps to reach the final growth state (i.e. decoding will take longer than it needs to). If the chosen increment value is too large then the accuracy of the decoding will be reduced because some clusters will grow larger than they need to. Accordingly, improved performance can be obtained by using a dynamic growth value that is recalculated during each growth stage based on the shortest separation from balls associated with defects in odd parity clusters to balls associated with defects in other clusters (or to a boundary of the decoding graph).

[0091] For optimal accuracy, the increment value during each growth stage should be equal to the lowest value that results in either two (or more) clusters merging or a cluster touching the boundary for the first time. This value, also referred to herein as the "minimum cluster separation value" is equal to whichever is smallest of:

[0092] (i) half of the shortest distance between regions surrounding any two defects in different odd parity clusters (the factor of a half applies because defects in different odd parity clusters will grow towards each other in the next growth stage);

[0093] (ii) the shortest distance from the region surrounding any defect in an odd parity cluster to the region surrounding a defect not in an odd parity cluster; and

[0094] (iii) the shortest distance from the region surrounding any defect in an odd parity cluster to any boundary of the decoding graph.

[0095] The minimum cluster separation is illustrated in Fig. 15, which shows an abstract surface code 1500 with boundaries 1502a and 1502b. Defects 1506 are clustered into three clusters 1504a, 1504b and 1504c (the lines around each cluster represent the boundary of the combined regions surrounding the defects 1506 in each cluster (not to scale)). Clusters 1504a and 1504b contain an odd number of defects 1506 and the regions surrounding the defects 1506 in these clusters do not touch the boundaries, so these are odd parity clusters (i.e. the size values (and therefore the regions) associated with these defects will grow during the next growth stage). Cluster 1504c contains an even number of defects and will not grow during the next growth stage (although it may still merge with another cluster that does grow).

[0096] The shortest distance between regions surrounding defects in two different odd parity clusters is shown by line B. Because both of these odd parity clusters will grow, this distance is halved when determining the minimum cluster separation value.

[0097] The shortest distance from the region surrounding any defect in an odd parity cluster to the region surrounding a defect not in an odd parity cluster is shown by line C. Only cluster 1504b will grow (not the even cluster 1504c), so this value is not halved. The shortest distance from the region surrounding any defect in an odd parity cluster to a boundary is given by line A. Once again, only cluster 1504b will grow (not the boundary), so this value is not halved.

[0098] The minimum cluster separation value will then be given by whichever is smaller of A, B / 2 and C. The increment value should therefore be set at least each to the smaller of A, B / 2 and C to ensure that at least one cluster merges with another cluster or the boundary during the subsequent round of clustering.

[0099] The minimum cluster separation value may be determined using any suitable technique, e.g. by using a pathfinding algorithm such as Dijkstra's algorithm or Euclidean distance between defects.

[0100] In some scenarios, it may be desirable to set the increment value to a value based on (e.g. proportional to or a linear function of) the minimum cluster separation value rather than exactly equal to the minimum cluster separation value.

[0101] In general it is desirable to set the increment value to at least the minimum cluster separation value (otherwise no clusters will merge in the next step). However, there may be scenarios in which it is desirable to set the increment value to some value larger than the minimum cluster separation value in order to reduce the total number of growth rounds during the decoding process (e.g. where lower decoding accuracy is acceptable). The actual relationship between the minimum cluster separation value and the increment value can be selected by a person skilled in the art dependent upon the desired performance of the decoder.

[0102] Figure 12 shows another method for use in decoding syndromes of a quantum error correction code. At step 1201, a decoder receives syndrome data representative of an error state of qubits in the quantum computer system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective location in a decoding graph. At step 1202, the decoder initialises a respective size value associated with each respective defect of the plurality of defects, the respective size value representative of a respective size of a respective region surrounding the respective defect in the decoding graph. At step 1203, the decoder identifies clusters of defects, wherein a pair of defects of the plurality of defects is included in a same cluster if a shortest distance between the pair of defects in the decoding graph is less than (or optionally equal to, in the case of balls / regions that touch but do not overlap) a sum of the respective size values associated with each respective defect of the pair of defects. At step 1204, the decoder identifies defects in odd parity clusters, which are clusters that (i) contain an odd total number of defects (this may include defects that are not in any cluster yet, i.e. isolated defects may be treated as a cluster containing a single defect) and (ii) do not contain any respective defects having a respective size value larger than a shortest distance between the respective defect and any boundary of the decoding graph (i.e. defects with respective regions that touch a boundary of the decoding graph). At step 1205, the decoder determines whether any defects were identified in step 1204. If one or more defects were identified in step 1204, the method proceeds to step 1206 in which the decoder determines an increment value (based on a minimum distance between the respective region surrounding any respective identified defect and one of (i) any boundary of the decoding graph, and (ii) the respective region surrounding another defect in a different cluster) and increases the respective size value associated with each identified defect by the increment value. If no defects were identified in step 1204, the method instead proceeds to step 1207 in which the decoder determines, based on the clusters of defects, a correction for the error state.

[0103] Figure 13 shows a quantum computer system 1300, having a quantum processor unit (QPU) 1302 which contains a plurality of data and syndrome qubits. The quantum computer system 1300 also has a decoder 1306, which may either be a software decoder or hardware decoder and is preferably implemented using a classical processor (e.g. a CPU, or a classical FPGA or ASIC). The QPU 1302 generates syndrome data 1304 which is sent to the decoder 1306, for decoding. The decoding can include processing of the syndrome data 1304 as described herein, to generate the data structure required to enable efficient decoding for quantum error correction. The quantum computer system 1300 can therefore be configured to execute quantum error correction to enable fault tolerant quantum computing. The quantum computer system 1300 may also include a classical control system (not shown), which could be a component of the QPU 1302 or a standalone system.

[0104] Figure 14 shows an example computer program product 1400 that contains instructions which, when executed, cause an apparatus, as described in Figure 13, to at least perform steps of any method described above. Equivalently, there may also be provided a computer readable memory medium corresponding to the computer program product 1400.

Claims

CLAIMS1. A computer-implemented quantum error correction method comprising:(a) receiving, at a decoder of a quantum computer system, syndrome data representative of an error state of qubits in the quantum computer system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective location in a decoding graph;(b) initialising, at the decoder, a respective size value associated with each respective defect of the plurality of defects, the respective size value representative of a respective size of a respective region surrounding the respective defect in the decoding graph;(c) identifying, at the decoder, clusters of defects, wherein a pair of defects of the plurality of defects is included in a same cluster if a shortest distance between the pair of defects in the decoding graph is less than a sum of the respective size values associated with each respective defect of the pair of defects;(d) identifying, at the decoder, defects in clusters that (i) contain an odd total number of defects and (ii) do not contain any respective defects having a respective size value larger than a shortest distance between the respective defect and any boundary of the decoding graph;(e) if any defects are identified in step (d): determining, at the decoder, an increment value based on a minimum distance between the respective region surrounding any respective identified defect and one of (i) any boundary of the decoding graph, and (ii) the respective region surrounding another defect in a different cluster; and, increasing, at the decoder, the respective size value associated with each identified defect by the increment value and repeating steps (c), (d) and (e);(f) otherwise, determining, at the decoder and based on the clusters of defects, a correction for the error state.

2. The method of claim 1, further comprising obtaining, at a quantum processing unit (QPU) of the quantum computer system, the syndrome data by measuring a plurality of syndrome qubits of the QPU.

3. The method of claim 1 or claim 2, wherein the quantum error correction method is a surface code error correction procedure.

4. The method of any preceding claim, wherein identifying the correction for the error state comprises: identifying a logical operator for the quantum error correction method involving physical qubits of the quantum computer system that are associated with the boundary of the decoding graph; determining a parity of a total number of clusters that the logical operator intersects that contain an odd total number of defects, wherein an even parity indicates that the logical operator is in a correct logical state and an odd parity indicates that the logical operator is in an incorrect logical state.

5. The method of any preceding claim, wherein determining the increment value comprises: determining a minimum cluster separation value of the identified defects, wherein the minimum cluster separation value is equal to the minimum value of:(i) half of a shortest distance between the respective regions of any two defects identified in step (d) that are not in same cluster,(ii) a shortest distance from the respective region of any defect identified in step (d) to the respective region of any defect not identified in step (d), and(iii) a shortest distance from any defect identified in step (d) to any boundary of the decoding graph; and setting the increment value to at least the minimum cluster separation value.

6. A computer program product comprising instructions which, when the program is executed by a decoder of a quantum computing system, cause the decoder to carry out the method of any preceding claim.

7. A computer-readable medium comprising the computer program product of claim 6.

8. A quantum computing system comprising a decoder configured to perform the method of any of claims 1 to 5.

Images