Parallel decoding of quantum error correction codes

Abstract

Methods, systems, and devices for parallel decoding of quantum error correction codes. In one aspect, a classical computer system is configured to implement a decoding process of measurement data received from a quantum computing system to determine errors in quantum computing. A classical computing system implements a main thread, multiple worker threads, and a data structure common to each worker thread. The data structure stores data for a dynamic system of disjoint node clusters of a detector graph of a decoding process, where the data includes compressed logical flipping information for child nodes in each node cluster. During execution of the decoding process, the plurality of worker threads are configured to, in parallel, obtain a cluster of nodes and modify the cluster of nodes, where, for each modification, the worker thread updates data in the data structure corresponding to the cluster under an atomic primitive.

Description

Background Art

[0001] This specification relates to quantum computing.

[0002] Quantum computing provides a means to solve certain problems that cannot be solved in a reasonable period of time using conventional classical computers. These problems include factoring very large numbers into their prime factors and searching large unstructured data sets. Many physical systems are being explored for use in quantum computing, including ions, spins in semiconductors, and superconducting circuits. However, these systems do not perform well enough to be used directly as computational qubits. For example, a single two-state physical system that could be used as a physical qubit cannot reliably encode and retain information long enough to be useful, for example due to noise.

[0003] Quantum error correction is a technique that can enable quantum computers to reliably execute quantum algorithms despite noise affecting their qubits. The decoder is a key component of the quantum error correction scheme, and its role is to identify errors faster than they accumulate in the quantum computer. The decoder takes as input a syndrome, which is measurement data extracted from a quantum parity check measurement, and returns an estimate of the error as output. Given this estimate, the effects of the error can be reversed. The decoder should be implemented with minimal hardware resources in order to scale to practical applications of quantum computing. Summary of the invention

[0004] This specification describes methods, systems, and devices for parallel decoding of quantum error correcting codes.

[0005] One innovative aspect of the subject matter described in this specification can be implemented in a classical computer system configured to implement a decoding process for measurement data received from a quantum computing system to determine errors in quantum computing implemented by the quantum computing system, wherein the classical computing system implements: a main thread; a plurality of worker threads; and a data structure common to each of the plurality of worker threads, wherein the data structure stores data of a dynamic system of disjoint node clusters of a detector graph for the decoding process, wherein: each node cluster includes a root node without an ascending node and one or more descending child nodes, wherein the child nodes include leaf nodes without descending nodes or one or more descending child nodes; and the data includes compressed logical flip information of the child nodes in each node cluster; wherein during execution of the decoding process, each of the plurality of worker threads is configured to, in parallel with each of the other worker threads: obtain one or more node clusters in the detector graph from the main thread, wherein each node cluster includes one or more detection events in the measurement data; and execute the decoding process to modify the one or more node clusters, wherein for each modification of the cluster, the worker thread performs an atomic primitive (atomicity primitive) to modify the one or more node clusters. The data corresponding to the cluster is updated in the data structure under the primitive.

[0006] A classical computer system may be configured to perform specific operations or actions by having software, firmware, hardware, or a combination thereof installed on the system, which in operation causes the system to perform the actions. One or more computer programs may be configured to perform specific operations or actions by including instructions that, when executed by a data processing device, cause the device to perform the actions.

[0007] The foregoing and other implementations may each optionally include one or more of the following features, either individually or in combination. In some implementations, the data structure stores data at the root node of each node cluster that specifies one or more of the following: a node type specifier, the parity of detection events in the node cluster, the total size of the node cluster, the boundary nodes of the node cluster, a minimum time coordinate, and a maximum time coordinate.

[0008] In some implementations, the classical computing system further includes one or more memory regions external to the data structure, wherein each memory region stores a boundary map of a corresponding node cluster.

[0009] In some implementations, data objects in a memory region are stored according to a conservation law, wherein the data in the data object is popped from a child node memory before a push update adds the data to an object associated with a root node.

[0010] In some implementations, compressed logical flip information of child nodes included in a corresponding node cluster is stored at the child nodes.

[0011] In some implementations, the compressed logical flip information for a child node includes the parity of logical flips along a decoding graph path from the child node to its parent node, and wherein the compressed logical flip information is used together with the cluster parity information to determine the parity flip applied to a logical observable by a fusion of two clusters.

[0012] In some implementations, the classical computing system is further configured to recover a decoded output of the decoding process, including using the data in the data structure to: for each node in the detector graph associated with the detection event, calculate a net logical flip on a path to a corresponding root node of the node; and calculate a total parity of the net logical flips.

[0013] In some implementations, the decoding process includes a union-find or minimum weight perfect match decoding process.

[0014] In some implementations, the data structure is lock-free.

[0015] In some implementations, the atomic primitive includes a compare-and-swap atomic primitive or an atomic pool allocator with reference counting.

[0016] In some implementations, data updates in the data structure corresponding to respective modifications of the cluster are packed into a single word, optionally wherein the single word includes a pointer to the external atomic data.

[0017] In some implementations, during execution of the decoding process, the main thread is configured to: identify detection events in the measurement data; for each detection event, seed node clusters with non-zero parity in the detector graph; and place the seeded node clusters into a central list structure, where multiple worker threads obtain corresponding node clusters from the central list structure.

[0018] Another innovative aspect of the subject matter described in this specification can be implemented in a system combining a classical computer system and a quantum computing system of the above aspects, wherein the classical computer system is configured to receive measurement data from the quantum computing system to determine errors in quantum computations performed by the quantum computing system.

[0019] Another innovative aspect of the subject matter described in this specification can be implemented in a method for performing a decoding process on measurement data received from a quantum computing system to determine errors in quantum computing implemented by the quantum computing system. The method may include: instantiating a data structure common to each of a plurality of worker threads, wherein the data structure stores data of a dynamic system of disjoint node clusters of a detector graph for a decoding process, wherein: each node cluster includes a root node without an upper node and one or more lower child nodes, wherein the child node includes a leaf node without a lower node or one or more lower child nodes; and the data includes compressed logical flip information of the child nodes in each node cluster; for each of a plurality of worker threads, and in parallel with each of the other worker threads: obtaining one or more node clusters in the node cluster from a main thread, wherein each obtained node cluster includes one or more detection events in the measurement data; performing a decoding process on the detector graph to modify the obtained one or more node clusters, including updating data corresponding to the cluster in the data structure under an atomic primitive for each modification of the cluster; and using the updated data in the data structure to restore the decoding output of the decoding process.

[0020] According to another innovative aspect of the subject matter described in this specification, a method for determining errors in quantum computing is provided, comprising: performing one or more measurements at a quantum computing system that implements quantum computing to generate measurement data; receiving the measurement data from the quantum computing system at a classical computer system; and performing the method of the previous paragraph at the classical computer system.

[0021] Other implementations of these aspects include corresponding computer systems, devices, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the method. A system of one or more classical computers may be configured to perform specific operations or actions by means of software, firmware, hardware, or a combination thereof installed on the system, which software, firmware, hardware, or a combination thereof causes the system to perform actions in operation. One or more computer programs may be configured to perform specific operations or actions by means of including instructions, which, when executed by a data processing device, causes the device to perform an action.

[0022] The foregoing and other implementations may each optionally include one or more of the following features, alone or in combination. In some implementations, restoring a decoded output of a decoding process using the updated data in the data structure includes: for each node in the detector graph associated with a detection event, calculating a net logical flip on a path to a corresponding root node of the node; and calculating a total parity of the net logical flip.

[0023] In some implementations, the data structure stores data at the root node of each node cluster that specifies one or more of: a node type specifier, the parity of detection events in the node cluster, the total size of the node cluster, the boundary nodes of the node cluster, a minimum time coordinate, and a maximum time coordinate.

[0024] In some implementations, the compressed logical flip information of a child node includes a parity flip applied to a logical observable by an operator having a zero bound that includes the child node and a parent node in a corresponding graph tree.

[0025] In some implementations, the decoding process includes a union-find or minimum weight perfect match decoding process.

[0026] In some implementations, the atomic primitive includes a compare-and-swap atomic primitive or an atomic pool allocator with reference counting.

[0027] In some implementations, updating data in the data structure corresponding to respective modifications to the cluster includes packing the updates into a single word, optionally wherein the single word includes a pointer to the external atomic data.

[0028] In some implementations, the method further includes: identifying, by a main thread, detection events in the measurement data; seeding, by the main thread, node clusters having non-zero parity in a detector graph for each detection event; and placing, by the main thread, the seeded node clusters into a central list structure, wherein a plurality of worker threads obtain corresponding node clusters from the central list structure.

[0029] The subject matter described in this specification can be implemented in a specific way to achieve one or more of the following advantages.

[0030] A challenging sub-problem that arises when implementing quantum error correction is the real-time decoding of quantum error correction codes. In real-time decoding, a classical algorithm called a decoder processes a classical bit stream from a quantum computer and outputs a prediction of the logical state of the quantum algorithm being executed by the quantum computer in real time. It may be difficult for the decoder to meet the high throughput and low latency requirements of real-time decoding while maintaining a sufficient level of accuracy. Ideally, the decoder should process the classical bit stream at a fast enough speed to keep up with the clock speed of the quantum computer. For example, a surface code superconducting quantum computer with one million physical qubits can generate measurement data at a rate of about 1 trillion bits per second. The decoder should process this data at least as fast as the generated data to prevent exponentially growing data backlogs in the T-gate depth of the calculation. Further, the delay of the decoder (the time it takes for the decoder to complete the decoding after the last measurement) should be minimized, because longer delays will slow down the logical clock rate of the quantum computer.

[0031] The present disclosure solves this problem and provides a method for parallelizing the execution of accurate decoders for a large class of useful and practical topological quantum error correction codes, including surface codes. Multiple workers decode the measurement data in parallel while tracking the global state of the decoder in an atomic data structure referred to herein as a compressed logic flip tracking table. Therefore, no final coordination step is required at the end of decoding - unlike conventional techniques that, for example, divide the spatiotemporal region of the detector map to be processed in parallel by multiple worker threads. Therefore, the decoding process is faster and has lower latency than conventional techniques.

[0032] Additionally, the presently described techniques do not require any special-purpose hardware and can be implemented using relatively cheap CPUs, which in turn may reduce the costs associated with decoding and improve the performance of, for example, future quantum data centers.

[0033] The details of one or more implementations of the subject matter of this specification are set forth in the accompanying drawings and the following description. Other features, aspects, and advantages of the subject matter will become apparent from the specification, drawings, and claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1 is a block diagram of an example computing system for parallel execution of quantum error correction codes.

[0035] Figure 2 is a block diagram of an example classic processor decoder.

[0036] Figure 3 is a schematic block diagram of data stored in a compressed logic flip tracking table for a particular node cluster in a detector graph.

[0037] Figure 4is a schematic block diagram of a tree including nodes in a forest including a compressed logic rollover tracking table.

[0038] Figure 5 is a flow chart of an example process for performing a decoding process on measurement data received from a quantum computing system to determine errors in quantum computations performed by the quantum computing system.

[0039] Like reference numbers and designations in the various drawings indicate like elements. DETAILED DESCRIPTION

[0040] This specification describes a technique for parallel decoding of measurement data obtained from a quantum computer implementing a quantum error correction code. The measurement data may indicate a physical condition of a quantum computing system. For example, the measurement data may indicate the state of one or more qubits of the quantum computing system. The decoder implements a main thread and multiple worker threads. The main thread provides corresponding clusters for multiple worker threads in a detector graph. The worker threads process the corresponding clusters in parallel and mostly independently, requiring coordination only when two or more clusters grow to meet each other. The decoder maintains an atomic data structure that tracks the global state of the decoder to maintain thread safety and correctly coordinate cluster growth between threads.

[0041] Figure 1 1 is a block diagram of an example computing system 100 for parallel execution of quantum error correction codes. The example computing system 100 is an example of a system implemented as classical and quantum computer programs on one or more classical computers and quantum computing devices in one or more locations in which the systems, components, and techniques described herein may be implemented.

[0042] The example computing system 100 includes a quantum computing device 102 and a classical processor 104. For purposes of illustration, Figure 1 The quantum computing device 102 and the classical processor 104 shown in FIG. 1 are shown as separate entities, however, in some implementations, the classical processor 104 may be included in the quantum computing device 102. For example, in some implementations, the quantum computing device 102 may be directly connected to the classical processor 104. In other implementations, the quantum computing device 102 may be connected to the classical processor 104 through a network (e.g., a local area network (LAN), a wide area network (WAN), the Internet, or a combination thereof).

[0043] The quantum computing device 102 includes components for performing quantum computations, such as physical qubits. For example, the quantum computing device 102 may include: a quantum data plane, which in turn includes a plurality of physical qubits; a control and measurement plane, which is configured to perform operations and measurements on the physical qubits; a control processor plane, which is configured to determine the sequence of operations and measurements required by the quantum algorithm being executed by the quantum computing system; and a classical computer that communicates data with the control processor and facilitates user interaction and access to a network or storage. The specific type of quantum computing device 102 may depend on the type of qubit used. In some implementations, the qubit may be a superconducting qubit, a semiconductor qubit, a photonic qubit, or an atom-based qubit. For example, the qubit may include an Xmon qubit, a flux qubit, a phase qubit, a CAT qubit, or a qubit with frequency interaction.

[0044] Typically, quantum computations performed by quantum computing device 102 will be noisy due to the inevitable presence of errors caused by, for example, unwanted interactions between qubits, unwanted interactions with the environment (causing decoherence), faulty quantum gates or operations, or errors in state preparation or measurement processes. Example types of errors include coherent errors acting on a single qubit, such as Pauli X-type errors known as bit flip errors that map qubit ground states X|0>=|1> and X|1>=|0>, and Pauli-Z errors known as phase flip errors that map qubit ground states Z|0>=|0> and Z|1>=-|1>. Noise in a quantum computing device can be represented by an error model, such as the independent error model described in more detail below. If left unchecked, errors can destroy quantum information and render the quantum computation performed by quantum computing device 102 useless.

[0045] Therefore, the quantum computing device 102 can be configured to execute a quantum error correction code 106 when performing quantum computing. The quantum error correction code encodes a first number k qubits (a Hilbert space of dimension 2k) into a second number n qubits (a Hilbert space of dimension 2n), where the second number is greater than the first number, i.e., n>k. The k qubits are data qubits that store logical information and are to be protected from errors. The additional n-k qubits are auxiliary qubits for detecting errors. Example quantum error correction codes include stabilizer codes, such as surface codes 108.

[0046] The surface code 108 encodes logical qubits as patches of multiple physical qubits on a grid (e.g., a square or hexagonal grid). The grid includes alternating data qubits and auxiliary qubits, where the qubits are placed on each side of the grid. The code is defined as the Hamiltonian H = -Σ v∈V X v -Σ f∈F Z f The ground state space of , where V represents the vertices of the mesh, F represents the faces defined by the edges connecting the vertices of the mesh, and the operator X v The product of the Pauli-X matrices associated with vertex v and acting on the edges attached to v, and the operator Z f is associated with face f and is the product of the Pauli-Z matrices acting on all edges of v. The code space is defined as the operator X v and Z f 's eigenstate. These operators (or the product of these operators) are called stabilizers of the code. When an error has affected a qubit of the code, any stabilizer that anti-commutes with the error will return a "-1" measurement result. The subset of vertices with -1 measurement results is called a syndrome σ. The syndrome σ can be used to determine a correction operator that, when applied to the code, corrects the error up to the stabilizer.

[0047] During execution of the quantum error correction code 106, the quantum computing device 102 is configured to provide measurement data 110 to the classical processor 104. The measurement data 110 can be received as a batch of data or a data stream. The measurement data 110 includes, for example, classical measurement result bits corresponding to stable sub-measurements. In the present disclosure, the detector is the parity of the measurement result bit, which is deterministic in the absence of errors. If the observed parity is different from the expected parity of the noise-free calculation, the result of the detector measurement is 1, otherwise it is 0. If the inclusion of a Pauli-type error P in the circuit changes the result of the detector D, it is said that P will flip d, and the detection event is a detector with a result of 1. A logical observable is a linear combination of measurement bits, the result of which corresponds to the measurement of a logical Pauli operator.

[0048] The classical processor 104 includes components for performing classical computing. For example, the classical processor 104 can be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a tangible, non-transitory storage medium for execution by a data processing device or to control the operation of the data processing device. The computer storage medium can be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, or a combination of one or more of them.

[0049] The classical processor 104 implements a decoder 112 that is configured to process the measurement data 110 received from the quantum computing device 102 to decode the measurement data, i.e., predict which errors may have occurred during the quantum computation performed by the quantum computing device 102. To process the measurement data 110, the decoder 104 is configured to execute a decoding algorithm 114 (also referred to herein as a decoding process) that maps the decoding problem onto a graph problem using a graph-like error model of the quantum error correction code 106.

[0050] A graphical error model is an independent error model, i.e., a set of m independent error mechanisms, where error mechanism i occurs with probability p[i] (where p∈R m is a prior vector), and flips a set of detectors and observables. In the graph-like error model, each error mechanism flips at most two detectors. The graph-like error model can be used to approximate common noise models for many important classes of quantum error correction codes, including surface codes, for which both type-X and type-Z Pauli errors are graph-like.

[0051] A graph error model is represented by a detector graph G = (V, E) of nodes and edges, such as detector graph 116. Each node v∈V in the detector graph corresponds to a detector. Each edge e∈E is a set of detector nodes of cardinality one or two, representing an error mechanism that flips the set of detectors. The set of edges E can be decomposed into E=E1∪E2, where for each edge e in E1, |e|=1, and for each edge e in E2, |e|=2. A normal edge e=(u,v)∈E2 flips a pair of detectors u, v∈V, while a half-edge (u,)∈E1 flips a single detector u∈V. A half-edge can be connected to the boundary of the detector graph, in which case the edge can be defined as (u,v b ), where v b is a virtual border node (which does not correspond to any detector). In some implementations, such as when solving graph problems using minimum weight perfect matching, each edge can be assigned a weight, such as w(e i ) = loglog(1-p[i]) / p[i]. Each edge can also be labeled with a set of logical observables that are flipped by an error mechanism for e i =(u, v)∈E by l(e i ) or l(u, v). The distance D(u, v) between two nodes u and v in the detector graph is equal to the length of the shortest path between them.

[0052] Example decoding algorithms include minimum weight perfect matching (MWPM) and union-find. The MWPM decoding process determines the most likely physical error consistent with the syndrome in the measurement data. The detection events in the measurement data are identified and marked in the detector graph. Then the minimum weight embedded matching of the detection events in the detector graph is determined, where the embedded matching of a set of detection events is a set of edges in the detector graph, where each node corresponding to the detection event in the set of detection events is attached to an odd number of edges in the set of edges, and each node not corresponding to the detection event in the set of detection events is attached to an even number of edges in the set of edges. In a conventional implementation of the MWPM decoding process, an embedded matching is determined using Edmond's blossom algorithm, for example, by seeding a node cluster in the detector graph with a detection event, and growing, shrinking or freezing the cluster until a minimum weight embedded matching is obtained. The embedded matching is used to determine a prediction of which logical observable measurements have been flipped, which can then be used to determine a correction operator that corrects errors when applied to the quantum error correction code 106.

[0053] The union-find decoding process can be viewed as an approximation of the minimum weight perfect matching decoding process. The union-find decoding process identifies detection events in the measurement data and uses the detection events to seed node clusters in the detector graph. The cluster then grows iteratively in the detector graph until the parity of the cluster changes. A so-called peeling step is then performed. A spanning tree is generated for each growing cluster, and an estimate of the error is calculated by traversing the spanning tree in reverse order. A correction operator that corrects the error when applied to the quantum error correction code 106 is then determined.

[0054] return Figure 1 , the decoder 112 implements a main thread 202, a plurality of worker threads 204, and a compressed logic flip tracking table 206. The main thread 202 is configured to manage the plurality of worker threads 204 and coordinate the execution of the decoding algorithm 114. The main thread 202 is configured to receive the measurement data 110 from the quantum computing device 102 and generate a detector graph for the measurement data. The main thread 202 uses the detection events in the measurement data to seed node clusters with non-zero parity in the detector graph and places the seeded node clusters into a central list structure.

[0055] The plurality of worker threads 204 are each configured to pull the seeded clusters from the central list structure. Each of the plurality of workers 204 then modifies (e.g., grows by adding some or all nodes from the cluster border according to the cluster growth rule), shrinks, or freezes their seeded clusters according to the decoding algorithm 114. Each worker thread is configured to modify its cluster in parallel and independently of each other, requiring coordination only when two or more clusters grow to meet each other.

[0056] The plurality of workers 204 are configured to modify the seeded clusters while tracking the global state of the decoder 112 in an atomic data structure referred to herein as a compressed logic flip tracking table 206. Thus, no final coordination step is required at the end of the decoding algorithm 114 - unlike conventional techniques such as partitioning a spatiotemporal region of the detector graph to be processed in parallel by multiple worker threads. Note that in these conventional parallelizations of finite decoders, a final coordination step is necessary because the finite decoding algorithm is designed to operate on the entire decoding graph, while the parallel version can only access a restricted spatiotemporal region (or block) of the decoding graph. During the final coordination step, the solutions in each block must be cross-referenced to find and resolve any inconsistencies. The cross-reference may include, for example, determining whether an error predicted within one block is consistent with an error predicted within another block. The difficulty / overhead of the final coordination cross-reference may increase with the size of the block, or remain constant. In either case, the number of blocks must increase with the number of rounds of syndrome extraction to maintain bounded latency, so the amount of work to be done during this final coordination step must also increase (with the number of blocks). In such conventional parallel decoders, simply ignoring this additional coordination step at the end of decoding will typically result in an output that is different from the decoding algorithm of the underlying single-threaded decoder and will not be able to suppress errors to the greatest extent possible for the chosen code distance. In contrast, the decoding algorithm presented in this article incrementally tracks the decoded predictions and cross-references during decoding to resolve inconsistencies between worker threads, so no final coordination step is required. Incrementally tracking net logical flips differs from the final coordination step because incrementally tracking net logical flips is performed incrementally during decoding, rather than after decoding is complete. Therefore, it does not contribute to decoder latency. Refer to the following Figures 2 to 5 Example operations performed by the components of decoder 112 are described in further detail.

[0057] After the decoder 112 has completed the decoding algorithm 114, the classical processor 104 is configured to output a correction operator 118. The correction operator 118 may be applied to the quantum error correction code 106 to correct the errors identified by the decoder 112.

[0058] Figure 22 is a block diagram 200 of an example classical processor decoder 112. The decoder 112 may be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a tangible, non-transitory storage medium for execution by a data processing apparatus or to control the operation of the data processing apparatus. The computer storage medium may be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, or a combination of one or more of them.

[0059] As referenced above Figure 1 As described, the decoder 112 implements a main thread 202, a plurality of worker threads 204a-204d, and a compressed logic flip tracking table 206. For convenience, Figure 2 The example decoder 112 shown in includes four worker threads 204a-204d, however, in some implementations, the decoder 112 may include a different number of worker threads, such as a larger number of worker threads. The components of the decoder 112 may be connected via a network (e.g., a local area network (LAN), a wide area network (WLAN), the Internet, or a combination thereof), which may be accessed via a wired and / or wireless communication link.

[0060] As referenced above Figure 1 As described, the main thread 202 is configured to manage multiple worker threads 204a-204d and coordinate the execution of the decoding process. The main thread 202 is configured to receive measurement data from a quantum computing device and generate a detector map of the measurement data. The main thread 202 identifies detection events in the measurement data (which are caused by, for example, noise affecting hardware qubits in the quantum computing device) and uses the detection events to seed node clusters with non-zero parity in the detector map. The main thread 202 is configured to place the seeded clusters into a central list structure 212.

[0061] Each of the plurality of worker threads 204a-204d is configured to access the central list structure 212 and pull the corresponding seeded clusters from the central list structure 212. Each worker organizes the seeded clusters pulled from the central list structure 212 into a private sorted data structure that implements the overall job allocation strategy.

[0062] In some implementations, the job allocation strategy can be based on dividing the annular spatiotemporal buffer into areas owned by tilings of worker threads 204a-204d. Alternatively, in some implementations, the job allocation can be random, based on the load of individual worker threads, or it can be a combination of multiple heuristics. For example, in some implementations, excited clusters (clusters with non-zero parity) extending earlier in time can be prioritized over new clusters confined to later time windows. This job allocation strategy is intended to reduce delays in real-time decoding. In some implementations, growth can be prohibited from extending to excited clusters that are too close to the future horizon (i.e., the earliest time coordinates of all measurements that the decoder does not know). In some implementations, modifications to smaller excited clusters can be prioritized over modifications to larger excited clusters, where the size of the cluster is based on the size of the boundary (which can be measured by the number of adjacent vertices or the number of attached edges in the graph drawn from the cluster), based on the number of graph nodes included in the cluster, or a combination of these quantities.

[0063] Each worker thread is configured to modify the clusters stored in its private sorted data structure according to the heuristic specified by the decoding process being performed by decoder 112. As a non-limiting example, in some implementations, the decoding process can be a union-find decoding process. In these implementations, each worker thread can grow the clusters stored in its private sorted data structure, for example, until each cluster has even parity or encounters the boundary of the detector map. As another non-limiting example, in some implementations, the decoding process can be a minimum weight perfect matching decoding process. In these implementations, each worker thread can grow, shrink or crush the clusters stored in its private sorted data structure, for example, until each cluster has even parity or encounters the boundary of the detector map.

[0064] In some implementations, one or more of the worker threads 204a-204d may be configured to calculate the current cluster modification priority of the clusters in their private sorted data structure before each modification step. The worker threads 204a-204d may then determine whether the current cluster modification priority is different from the expected modification priority (e.g., calculated in a previous modification step). If the worker thread determines that the current cluster modification priority is different from the expected modification priority, the worker thread may adjust the order in which the clusters will be processed. Typically, the priority of a cluster will only decrease as the cluster grows, so that traversing the once sorted list of clusters while reinserting (in the correct sorted position) each cluster whose recalculated priority does not match the previously calculated value constitutes an effective iteration through all clusters in priority order.

[0065] The compressed logic flip tracking table 206 is shared by the worker threads 204a-204d, that is, it is common to each worker thread. When the worker threads 204a-204d perform the decoding process and modify their corresponding clusters, they update the data corresponding to their corresponding clusters in the compressed logic flip tracking table 206 under atomic primitives (e.g., compare and exchange atomic primitives or atomic pool allocators with reference counting). The atomic primitives enable each worker thread to track whether another worker thread has modified its cluster, and thus achieve thread safety. The compressed logic flip tracking table 206 therefore avoids the need for locks and can be lock-free.

[0066] For example, a first worker thread may work on a first cluster (e.g., cluster 222), and a second worker thread may work on a second cluster (e.g., cluster 224). During the decoding process, the first worker and the second worker may grow their respective clusters so that the first cluster and the second cluster meet and are fused into one cluster 226 under the decoding process. Under the atomicity primitive, the first worker thread (or the second worker thread) may determine that they should stop modifying their cluster, and allow the second worker thread (or the first worker thread) to continue modifying the fused cluster 226. The first worker thread (or the second worker thread) may then pull the new cluster to be modified from its private sorted data structure.

[0067] Thus, the compressed logic flip tracking table 206 tracks the dynamic system of (disjoint) clusters as the clusters are seeded by the main thread 202 and modified by the worker threads 204a-204d. In other words, the compressed logic flip tracking table 206 tracks the global state 220 of the decoder 112, e.g., tracks each cluster and how it is modified during the decoding process.

[0068] The compressed logical flip tracking table 206 stores data for each cluster included in the detector graph. During the decoding process (e.g., after the cluster has been seeded and one or more modifications have been made), each cluster includes a root node (with no upper node) and one or more lower child nodes (where the child nodes include leaf nodes with no lower nodes or with one or more lower child nodes). That is, each cluster is represented by a connected tree, and the entire set of clusters in the detector graph is a forest of such trees.

[0069] The data stored in the compressed logical flip tracking table 206 for a particular cluster includes data associated with the entire cluster, such as data specifying properties of the cluster, such as the parity of detection events included in the cluster, the size of the cluster, and the boundary nodes of the cluster. Figure 3 and Figure 4 Described in more detail, the data may be stored at the root node of the cluster.

[0070] The data also includes compressed logical flip (CLF) information for the child nodes in the cluster. Each edge in the decoding graph has a bit for each observable that indicates whether the error mechanism associated with the edge causes the logical observable to be flipped. Note that the decoder (whether UF or MWPM) will select a subset of edges associated with the subset of errors for which it predicts that an error has occurred; the decoded prediction is then the bit-by-bit sum of these logical flips across all edges selected in that subset. In the compressed logical flip (CLF) scheme, the selected edges are split across clusters, and the CLF of each child node is the bit-by-bit sum of the logical flips across the edges to its parent node (or zero in the case of a root node). In MWPM decoding, the CLF bit of a node is the bit-by-bit sum of the logical flips along the edges to its matching node (if the node has been matched). In UF decoding, the CLF bit of the root node is always 0, and the CLF information of a child node includes a parity flip, which is applied to a logical observable by an operator whose 0 boundary consists of the nodes of the child node and the nodes of the parent node in the tree / cluster (i.e., the net flip of parity along the edge between the child node and the parent node in the decoding graph). CLF information for multiple logical observables can be tracked in parallel and updated incrementally during decoding. In addition, the CLF can be used to incrementally track the net predicted flip of the logical observable during decoding along with the net parity of each cluster. As described below with reference to Figure 3 and Figure 4 Described in more detail, the CLF information of the child node may be stored at the child node.

[0071] In some implementations, the master thread 202 may be configured to assign seeded clusters in the central list structure 212 to corresponding worker threads. To avoid contention, the scheduling policy should primarily assign activated clusters to be grown by distinct worker threads. However, this may be problematic because in order for the decoder 112 to not need to wait (e.g., a desirable property for real-time decoding), all worker threads should be able to continue to complete work even when one worker thread is stopped.

[0072] This can be achieved through so-called work stealing, which can be achieved due to the atomicity of the compressed logical flip tracking table 206. For example, in some implementations, when a worker thread reads the list of available clusters in the central list structure 212 maintained by the main thread 202, the worker thread can record clusters that are not specifically assigned to the worker thread. Then, when the worker thread has finished modifying the clusters it pulled from the central list structure 212, the worker thread can steal (e.g., obtain) other clusters from other domains (e.g., other worker threads). The worker thread can then perform the decoding process and modify the "stolen" clusters.

[0073] When a cluster is assigned to a worker thread 204a-204d, the decoder 112 can be configured to implement work stealing with minimal overhead using a separate data structure that tracks the cluster. The separate data structure only needs to be updated when the main thread 202 seeds a new cluster or when a worker thread performs work stealing, minimizing the overhead of tracking this information.

[0074] When a worker thread has cycled through all queued clusters in its private sorted data structure, the worker thread can be configured to extract new clusters from the central list structure 212. If no excited clusters remain in the central list structure 212, the worker thread can be configured to wait for a new round of measurement data to become available (e.g., wait for the main thread to seed new clusters with new measurement data). Alternatively or in addition, the worker thread can perform operations with the main thread 202 to complete cleanup or reset tasks, such as freezing and deleting old clusters that are no longer excited. Alternatively or in addition, as described above, a worker thread can steal clusters from other worker threads.

[0075] When all clusters have been processed by multiple worker threads 204a-204d, for example, all clusters have been modified to have zero parity, the decoder 112 can be configured to use the processed clusters to recover the decoded output. The specific operations performed by the decoder 112 to recover the decoded output depend on the underlying decoding process. For example, in some implementations, the decoder 112 can recover the decoded output by calculating the net logical flip on the path from the child node corresponding to the detection event in the cluster to the root node of the cluster for each processed cluster. The decoder 112 can then calculate the total parity of all net logical flips on each cluster in the processed cluster. The total parity of all net logical flips provides an overall prediction of whether the logical observable has flipped due to an error during the quantum computation. The total parity of all net logical flips does not need to be calculated at the end, but can instead be incrementally kept up to date as the worker modifies the data structure. When two clusters A and B are fused and A becomes a subcluster of B, at this time, if A has non-zero parity and the CLF bit on the path from the root of A to the root of B is non-zero, the net flip is changed. This procedure generalizes straightforwardly to the case with more than one observable.

[0076] As referenced above Figure 1 As described, the decoder 112 (or more generally, the classical processor 104) may be configured to use the prediction to determine a correction operator that corrects errors when applied to a quantum error correction code executed by a quantum computing device.

[0077] Figure 3 is a schematic block diagram 300 of data stored in a compressed logic flip tracking table for a particular node cluster in a detector graph. Figure 2 As described, the data stored in the compressed logical flip tracking table for a particular cluster includes data associated with the entire cluster, for example, data specifying the properties of the cluster. The data can be stored at the root node 302 of the cluster and kept up to date as modifications to the cluster are made. The data stored in the compressed logical flip tracking table for a particular cluster also includes compressed logical flip (CLF) information for each child node in the cluster. The CLF information of a child node can be stored at the child node, for example, the CLF information 320 of the child node 304 can be stored at the child node 304.

[0078] The stored data may include a node type specifier 306, for example, an indication of whether each node in the compressed logical rollover tracking table corresponds to a root node or a child node. Figure 3 In the example shown, the node type specifier "1" indicates that the node is a root node, and the node type specifier "0" indicates that the node is a child node. When two clusters are merged, the root node of one of the original clusters needs to be modified to point to the root node of the new combined cluster. This requires determining whether a given node is actually a root node. This is why the node type specifier bit is stored in the stored data of each node. There are other ways to do this. For example, each node can instead have a pointer to its parent node, where a null (zero) value indicates that the node is actually a root node that has no parent node. One advantage of the scheme in which a single bit is used instead is that it allows the space originally used to store null values ​​at the root node to be used instead to store additional data.

[0079] The stored data may also include data specifying the parity of the detection events 308 included in the cluster. This data is a property of the cluster (rather than a specific child node included in the cluster) and is therefore stored at the root node 302. When the cluster is first seeded, the parity of the detection event 308 is non-zero, such as 1. When the cluster is modified (e.g., grows) and merged with another cluster, the parity of the detection event 308 is updated to 0 because the cluster will then include two detection events. In some implementations, updating the parity of the detection event 308 from 1 to 0 can "freeze" the cluster so that the worker thread will not make further modifications to the cluster unless and until another cluster with non-zero parity grows to meet and merge with the zero parity cluster. If this happens, the parity can be used to incrementally update the net logical flip information according to the net logical flip tracking protocol described above.

[0080] The stored data may also include data specifying boundary information 310 of the cluster. This data is a property of the cluster (rather than a specific child node included in the cluster) and is therefore stored at the root node 302. The boundary information 310 may include data specifying whether the cluster has reached the boundary of the decoding graph of the code. Once connected to the boundary, the parity of the cluster is set to zero and the cluster will not grow again during decoding. The boundary information 310 may also include data specifying which nodes in the detector graph currently form the boundary of the cluster. This information can be used by the worker thread to determine the current size of the cluster, for example, which can then be used to prioritize the processing of some clusters over other clusters.

[0081] The stored data may also include data specifying a minimum time coordinate 312 and a maximum time coordinate 314. This data is a property of the cluster (rather than a specific child node included in the cluster) and is therefore stored at the root node 302. The time coordinates may be used to prioritize cluster growth. For example, in one implementation, an excited cluster extending to an earlier time coordinate may be prioritized over a cluster confined to a later time coordinate to reduce delays in RT decoding. The time coordinates may also be used to prohibit growth of an excited cluster extending to a horizon that is too close to the future (i.e., the earliest time coordinate for which the decoder does not know all measurements).

[0082] The stored data also includes CLF information for each child node, such as CLF information 320 for child node 304. The CLF information for a child node is stored at the child node. The CLF information can be used by the decoder together with the net parity information to incrementally calculate the number of net logic flips on the path including the corresponding child node during decoding.

[0083] The stored data also includes a parent node index for each child node, for example, parent node index 322 for child node 304. The parent node index points to the parent (superior) node of the child node. The parent node index of a child node is stored at the child node. The parent node index can be used by the decoder to identify a path from a child node in a cluster corresponding to a detection event to a root node of the cluster, for example, when the decoder generates a decoder output and calculates a net logical flip on the path from the detection event to the root node.

[0084] In some implementations, the stored data may also include data specifying neighbor nodes of the cluster that are not yet included in the cluster. These neighbor nodes encode the graph structure as a boundary map from a node to a CLF bit (if the edge flip logical observable is traversed from the cluster to reach the node, the CLF bit is equal to one). The boundary map may be very large, and therefore a pointer 316 pointing to an external memory area storing external atomic data 318 may be stored at the root node 202, and the boundary map may be stored in the external memory area. That is, the most important data (data stored at the root node and child nodes) may be compressed to fit a fixed-size word, such as 64 bits, and the remaining data may be stored in the external memory area. In some implementations, the external memory area storing external atomic data 318 may use a memory managed by an atomic allocator with reference counting to ensure that the memory is reallocated only after all references to it are released, thereby avoiding memory access violations. The boundary map is used to find the next node to be added to the growing cluster during cluster growth.

[0085] In some implementations, one or more optimizations may be implemented to improve the performance of the compressed logic flip tracking table, which may be particularly beneficial because the compressed logic flip tracking table is a core shared global data structure of the decoder 112. For the compressed logic flip tracking table, it is naively necessary to perform atomic comparison and exchange on large (multi-word) data objects. This can be implemented using the hardware transaction memory (HTM) on some processors. However, on most central processing units, only single-word comparison and exchange (e.g., x86 cmpxchg) is available as a hardware instruction. Even on a chip that supports HTM, transactions may sometimes fail for no reason and need to fall back to simpler atomic primitives. In order to build multi-word comparison and exchange from single-word comparison and exchange, some conventional techniques suggest constantly allocating new memory, and using an indirect layer together with a single-word comparison and exchange to simulate multi-word comparison and exchange. However, this results in unlimited memory usage, and may impair performance due to many additional reads and writes to memory caused by too many copies and indirect layers.

[0086] Therefore, one or more of the following techniques may be implemented in combination to protect the required node data in an atomic manner with better performance than the naive solution described above.

[0087] For example, if the data to be updated is packed into a single word, no new memory needs to be allocated. Multiple pieces of data, such as parent node designators and cluster parity, can be non-trivially packed into a 64-bit word along with pointers to external atomic data if needed. Updates to packed data do not require any load / store to external memory, thereby improving performance.

[0088] As another example, a memory region storing an external atomic data object cannot be recycled in a naive implementation, because a stalled worker thread that obtains a pointer to the memory may eventually dereference the memory, leading to an inconsistent state if the memory has been recycled. However, this can be overcome by using an atomic pool allocator with reference counting.

[0089] As another example, when an atomic data object in external storage is needed, the naive method for reducing this data to the root of the tree is to copy a copy to a new external memory, and then compare and exchange to update the pointer in the node word. Performance can be improved by implementing a pop-up / push technique instead. The core problem of updating the members of the root node in situ is that even when the update to the external data can succeed, the node may no longer be a root node due to the action of the second "interfering" worker thread. The naive solution would be to let the updating worker thread check whether the node is still a root node after updating the external memory to detect this situation. If the worker thread detects such a situation, the worker thread will not see the change, and the external memory update can be considered complete. If the worker thread does detect a change, the worker thread will determine to climb the tree (cluster) and continue to update the external data at the new root. However, there is ambiguity about how the worker thread should mediate the original modified data. This ambiguity occurs because the interference worker thread itself reads from the external memory to propagate it up the tree may occur before the first thread successfully updates the external memory, or it may occur after it. One example approach to avoid this ambiguity is to impose conservation laws on externally stored atomic data objects. Specifically, data from these objects can be atomically "popped" from the child node's memory before an atomic "push" update adds the data to the object associated with the root node.

[0090] For example, an integer size counter (using summation as a reduction operation) can be set to zero using compare and swap before adding its value to the root node using an atomic add instruction. By enforcing conservation laws for data stored in externally allocated memory pointed to from the root node, any mistakes caused by interfering threads can be detected and clearly corrected. For example, if a worker thread pushes data into an object of a root node, only to find that it is no longer a root node, this push can be reversed by popping. Next, the worker thread can climb up the tree to a new root node, and finally, the worker thread can push into the object pointed to by the new root node. In this case, there is no ambiguity about which worker thread can add this data to the root, because this is determined by which worker thread's atomic pop is successful. The pop-and-push paradigm provides a general incremental method for guaranteeing the atomicity of the reduction operation performed on each group in the system without the need for additional reads and writes. In addition to integer counters, any atomic data structure (such as a linked list that can be "popped from" and "pushed to" in an atomic manner) can be used in an atomic external data object pointed to by a root node. For example, as a general policy for any 63-bit payload, a "deleted" bit could be appended to indicate that it has been "popped", and the pool allocator's reference counting could be used to recycle dead memory locations.

[0091] Figure 4 is a schematic block diagram of a tree 400 including nodes in a forest including a compressed logic flip tracking table. Figure 2 As described, the compressed logical flip tracking table stores data for each cluster included in the detector map. Each cluster includes a root node 402 (without an upper node) and one or more lower child nodes 404a-404f (wherein the child nodes include leaf nodes without lower nodes, such as child nodes 404a, 404c, 404d, and 404f, or child nodes with one or more lower child nodes, such as child nodes 404b and 404e). That is, each cluster is represented by a connected tree 400, and the entire set of clusters in the detector map is a forest of such trees.

[0092] Figure 5 is a flow chart of an example process 500 for performing a decoding process on measurement data received from a quantum computing system to determine errors in quantum computations performed by the quantum computing system. For convenience, process 500 will be described as being performed by components of a classical computing system. For example, a suitably programmed classical decoder (e.g., Figure 1 and Figure 2 The decoder 112) can perform the example process 500.

[0093] The system obtains measurement data from a quantum computing system and generates a detector graph for the decoding process. The system then identifies one or more detection events in the measurement data and, for each identified detection event, seeds a node cluster with non-zero parity in the detector graph (step 502). The system places the seeded node clusters into a central list structure.

[0094] The system instantiates a data structure common to each of the plurality of worker threads (step 504). The data structure stores data of the node clusters of the detector graph during the decoding process, for example, data of a dynamic system of clusters during the decoding process. Each node cluster includes a root node having no upper node and may include one or more lower child nodes, wherein the child nodes include a leaf node having no lower node or one or more lower child nodes. The number of child nodes included in each cluster may vary as the decoding process is performed, for example, as the cluster grows or shrinks, which is why the system of clusters is referred to as a dynamic system of clusters.

[0095] The data stored in the data structure includes compressed logical flip information for child nodes in each node cluster. The compressed logical flip information for a child node includes the parity of the logical flips along a decoding graph path from the child node to its parent node, and wherein the compressed logical flip information is used together with the cluster parity information to determine the parity flips applied to the logical observable by the fusion of the two clusters. The compressed logical flip information for a child node includes the parity flips applied to the logical observable by an operator with a zero bound that includes the child node and the parent node in the tree (i.e., the net flip of the parity along the edge between the child node and the parent node within the decoding graph). The compressed logical flip information for a child node can be stored in the data structure at the child node.

[0096] The data stored in the data structure may also include data specifying the properties of each cluster. For example, for a particular cluster, the data may include data specifying one or more of the following: a node type specifier, the parity of detection events in the node cluster, the total size of the node cluster, the boundary nodes of the node cluster, the minimum time coordinate, and the maximum time coordinate. The data may be stored in the data structure at the root node of the particular cluster.

[0097] The system performs a decoding process on the detector graph to modify the seeded node clusters in the detector graph. Each of the multiple worker threads obtains one or more of the seeded node clusters (step 506), and performs a decoding process on the detector graph to modify the obtained one or more node clusters (step 508). Multiple worker threads can perform steps 506 and 508 in parallel. For each cluster modification, the worker thread that implements the modification updates the corresponding data in the data structure under the atomic primitive. In some implementations, the atomic primitive can be a compare and exchange atomic primitive or an atomic pool allocator with reference counting. The system uses the updated data in the data structure to restore the decoded output of the decoding process (step 510). For example, the system can use the data stored in the data structure to calculate the net logical flip on the path to the corresponding root node of the node for each node associated with the detection event in the detector graph. The system can then calculate the total parity of the net logical flip (a calculation that can be performed during decoding, and the corresponding result is stored incrementally) to obtain a prediction of whether the logical observable in the quantum computing has been flipped due to an error. The system can use this prediction to determine a correction operator that, when applied to a quantum computing system, corrects the error.

[0098] The embodiments and all functional operations described in this specification may be implemented in a digital electronic circuit system or in computer software, firmware or hardware (including the structures disclosed in this specification and their structural equivalents), or in a combination of one or more of them. The embodiments may be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer-readable medium for execution by a data processing device or for controlling the operation of a data processing device. The computer-readable medium may be a machine-readable storage device, a machine-readable storage substrate, a memory device, a material composition that affects a machine-readable propagation signal, or a combination of one or more of them. The term "data processing device" encompasses all devices, devices, and machines for processing data, including, by way of example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the device may also include code that creates an execution environment for the computer program in question, for example, code that constitutes a processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them. A propagation signal is an artificially generated signal (e.g., a machine-generated electrical, optical, or electromagnetic signal) that is generated to encode information for transmission to a suitable receiver device.

[0099] A computer program (also referred to as a program, software, software application, script, or code) can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program may be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple collaborative files (e.g., files that store portions of one or more modules, subroutines, or codes). A computer program may be deployed to execute on one computer or on multiple computers, with the computers being located at one site or distributed across multiple sites and interconnected by a communication network.

[0100] The processes and logic flows described in this specification can be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by, and the device can also be implemented as, a special purpose logic circuit system, such as an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit).

[0101] Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory, or both.

[0102] The basic elements of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Typically, a computer will also include one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks, or optical disks, or be operably coupled to receive data from or transfer data to the one or more mass storage devices or both. However, a computer need not have such devices. In addition, a computer may be embedded in another device, such as a tablet computer, a mobile phone, a personal digital assistant (PDA), a mobile audio player, a global positioning system (GPS) receiver, to name a few. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and memory devices, including, by way of example, semiconductor memory devices (such as EPROM, EEPROM, and flash memory devices), magnetic disks (such as internal hard disks or removable disks), magneto-optical disks, and CD ROM and DVD-ROM disks. The processor and memory may be supplemented by or incorporated into a dedicated logic circuit system.

[0103] To provide interaction with a user, embodiments may be implemented on a computer having a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user, and a keyboard and pointing device (e.g., a mouse or trackball) through which the user can provide input to the computer. Other kinds of devices may also be used to provide interaction with the user, for example, the feedback provided to the user may be any form of sensory feedback, such as visual feedback, auditory feedback, or tactile feedback; and input from the user may be received in any form, including sound, voice, or tactile input.

[0104] Embodiments may be implemented in a computing system that includes a back-end component (e.g., as a data server), or includes a middleware component (e.g., an application server), or includes a front-end component (e.g., a client computer with a graphical user interface or a web browser through which a user can interact with the implementation), or any combination of one or more such back-end, middleware, or front-end components. The components of the system may be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include local area networks ("LANs") and wide area networks ("WANs"), such as the Internet.

[0105] A computing system may include clients and servers. Clients and servers are generally remote from each other and typically interact through a communication network. The relationship of client and server is created by computer programs running on the respective computers and having a client-server relationship to each other.

[0106] Although this specification contains many details, these details should not be interpreted as limitations on the scope of the present disclosure or the scope that may be claimed, but should be interpreted as descriptions of features peculiar to a particular embodiment. Certain features described in the context of a separate embodiment in this specification may also be implemented in combination in a single embodiment. Conversely, the various features described in the context of a single embodiment may also be implemented in multiple embodiments individually or in any suitable sub-combination. In addition, although features may be described above as acting in certain combinations and even initially claimed as such, in some cases, one or more features from the claimed combination may be deleted from the combination, and the claimed combination may involve a sub-combination or a variation of the sub-combination.

[0107] Similarly, although operations are depicted in a particular order in the accompanying drawings, this should not be understood as requiring that such operations be performed in the particular order shown or in a sequential order, or that all of the illustrated operations be performed, in order to achieve the desired results. In some cases, multitasking and parallel processing may be advantageous. In addition, the separation of various system components in the above-described embodiments should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.

[0108] In each instance where an HTML file is mentioned, other file types or formats may be substituted. For example, an HTML file may be replaced by XML, JSON, plain text, or other types of files. In addition, where a table or hash table is mentioned, other data structures (such as a spreadsheet, a relational database, or a structured file) may also be used.

[0109] Thus, particular embodiments have been described. Other embodiments are within the scope of the following claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results.

Claims

1. A system comprising: A classical computer system configured to implement a decoding process of measurement data received from a quantum computing system to determine errors in a quantum computation implemented by the quantum computing system, wherein the classical computing system implements: Main thread; Multiple worker threads; as well as a data structure common to each of the plurality of worker threads, wherein the data structure stores data of a dynamic system of disjoint node clusters of a detector graph for the decoding process, wherein: Each node cluster includes a root node without an upper node and one or more lower child nodes, wherein the child nodes include a leaf node without a lower node or one or more lower child nodes; and The data includes compressed logical flip information of child nodes in each node cluster; Wherein during the execution of the decoding process, each worker thread of the plurality of worker threads is configured to, in parallel with each worker thread of the other worker threads: Obtaining from the main thread one or more node clusters in the detector graph, wherein each node cluster includes one or more detection events in the measurement data; and The decoding process is performed to modify the one or more node clusters, wherein for each modification of a cluster, the worker thread updates data corresponding to the cluster in the data structure under atomic primitives.

2. A system according to claim 1, wherein the data structure stores data specifying one or more of the following at the root node of each node cluster: a node type specifier, the parity of detection events in the node cluster, the total size of the node cluster, the boundary nodes of the node cluster, a minimum time coordinate, and a maximum time coordinate.

3. A system according to claim 1 or claim 2, wherein the classical computing system further includes one or more memory areas external to the data structure, wherein each memory area stores a boundary map of a corresponding node cluster.

4. A system according to claim 3, wherein the data objects in the memory area are stored according to a conservation law, wherein according to the conservation law, before a push update adds the data in the data object to an object associated with a root node, the data is popped from the child node memory. 5 . The system according to claim 1 , wherein the compressed logical flip information of a child node included in a corresponding node cluster is stored at the child node.

6. The system of any of the preceding claims, wherein the compressed logic flip information of a child node comprises the parity of the logic flips along a decoding graph path from the child node to its parent node, and wherein, The compressed logical flip information is used together with the cluster parity information to determine the parity flip applied to the logical observable by the fusion of the two clusters.

7. The system of any one of the preceding claims, wherein the classical computing system is further configured to recover a decoded output of the decoding process, including using the data in the data structure to: For each node in the detector graph associated with a detection event, computing a net logical flip on a path to a corresponding root node of the node; and The total parity of the net logical flips is calculated.

8. The system of any one of the preceding claims, wherein the decoding process comprises a union-find or minimum weight perfect match decoding process.

9. The system of any preceding claim, wherein the data structure is lock-free.

10. The system of any one of the preceding claims, wherein the atomic primitive comprises a compare-and-swap atomic primitive or an atomic pool allocator with reference counting.

11. A system according to any preceding claim, wherein updates of data in the data structure corresponding to respective modifications of clusters are packed into a single word, optionally wherein, The single word includes a pointer to the external atomic data.

12. The system of any one of the preceding claims, wherein during execution of the decoding process, the main thread is configured to: identifying a detection event in the measurement data; For each detection event, seeding a cluster of nodes in the detector graph having non-zero parity; and The seeded node clusters are placed into a central list structure, wherein the plurality of worker threads obtain corresponding node clusters from the central list structure.

13. A system comprising a quantum computing system and a classical computer system according to any one of the preceding claims, wherein the classical computer system is configured to receive the measurement data from the quantum computing system to determine errors in quantum computations performed by the quantum computing system.

14. A computer-implemented method for performing a decoding process on measurement data received from a quantum computing system to determine errors in a quantum computation performed by the quantum computing system, the method comprising: Instantiating a data structure common to each of a plurality of worker threads, wherein the data structure stores data of a dynamic system of disjoint node clusters of a detector graph for the decoding process, wherein: Each node cluster includes a root node without an upper node and one or more lower child nodes, wherein the child nodes include a leaf node without a lower node or one or more lower child nodes; and The data includes compressed logical flip information of child nodes in each node cluster; For each worker thread in the plurality of worker threads, and in parallel with each worker thread in the other worker threads: Obtaining one or more node clusters among the node clusters from a main thread, wherein each of the obtained node clusters includes one or more detection events in the measurement data; performing the decoding process on the detector graph to modify the obtained one or more node clusters, including updating data corresponding to the cluster in the data structure under atomic primitives for each modification of the cluster; and The decoded output of the decoding process is restored using the updated data in the data structure.

15. The method of claim 14, wherein restoring the decoded output of the decoding process using the updated data in the data structure comprises: For each node in the detector graph associated with a detection event, computing a net logic flip on a path to a corresponding root node of the node; as well as The total parity of the net logical flips is calculated.

16. A method according to claim 14 or claim 15, wherein the data structure stores data specifying one or more of the following at the root node of each node cluster: a node type specifier, the parity of detection events in the node cluster, the total size of the node cluster, the boundary nodes of the node cluster, the minimum time coordinate, and the maximum time coordinate.

17. The method of any one of claims 14 to 16, wherein the compressed logical flip information of a child node comprises a parity flip applied to a logical observable by an operator having a 0-bound, the 0-bound comprising the child node and a parent node in a corresponding graph tree.

18. The method according to any one of claims 14 to 17, wherein the decoding process comprises a union-find or minimum weight perfect match decoding process.

19. The method of any one of claims 14 to 18, wherein the atomic primitive comprises a compare-and-swap atomic primitive or an atomic pool allocator with reference counting.

20. A method according to any one of claims 14 to 19, wherein updating data in the data structure corresponding to respective modifications of clusters comprises packing the updates into a single word, optionally wherein, The single word includes a pointer to the external atomic data.

21. The method of claim 17, further comprising: identifying, by the main thread, a detection event in the measurement data; The main thread seeding, for each detection event, a node cluster having non-zero parity in the detector graph; as well as The main thread puts the seeded node clusters into a central list structure, wherein the plurality of worker threads obtain corresponding node clusters from the central list structure.

22. A method for determining errors in quantum computing, comprising: performing one or more measurements at a quantum computing system implementing said quantum computing to generate measurement data; receiving, at a classical computer system, the measurement data from the quantum computing system; as well as The method according to any one of claims 14 to 21 is performed at the classical computer system.

Images