Quantum error correction with runtime trigger events

Abstract

A quantum computing system and a method of performing a quantum error correction code are disclosed. Syndrome data is received representative of an error state of a plurality of quantum devices. Occurrence of a runtime trigger event is determined. A hypergraph modification rule associated with the runtime trigger event is retrieved from a decoding hypergraph modification map data structure comprising a plurality of predefined hypergraph modification rules. A decoding hypergraph is modified in accordance with the hypergraph modification rule to generate a modified decoding hypergraph. A correction for the error state is determined by decoding the syndrome data with the modified decoding hypergraph.

Description

[0001] QUANTUM ERROR CORRECTION WITH RUNTIME TRIGGER EVENTS

[0002] Field of the invention

[0003] The invention relates to quantum computing.

[0004] Background

[0005] Quantum computers have the potential to perform computations that would be intractable on even the most powerful classical computers.

[0006] Instead of representing information using classical bits, quantum computers generally use qubits that can be in a simultaneous superposition of multiple quantum states. Qubits exhibit much higher error rates than the bits used in classical computers, and quantum computers therefore require the use of quantum error correction in order to identify and correct qubit errors. The inherently delicate nature of quantum states means that quantum error correction is likely to be necessary even once quantum computing technology matures.

[0007] Quantum decoding algorithms are employed to process error syndromes and determine likely error occurrences and / or corrections. These algorithms are typically deployed on classical computing hardware with restricted memory and / or processing capabilities. A faster or more accurate decoder will be more effective at determining corrections to physical qubit errors, which will result in lower logical error rates. The decoder is therefore a key element in the overall performance of the quantum computer.

[0008] For full quantum advantage to be realised, decoders will have to be capable of rapidly decoding errors in quantum systems that have a large number of qubits, which places onerous runtime requirements on decoder memory and processing capabilities. There is therefore a need for improved decoding methods with reduced decoder runtime processing requirements.

[0009] Summary of the invention

[0010] According to a first aspect of the invention, there is provided a quantum computing system comprising: a plurality of quantum devices; and a decoding system comprising memory storing: a decoding hypergraph for a quantum error correction code, the decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices; and a decoding hypergraph modification map data structure comprising a plurality of predefined hypergraph modification rules, wherein the decoding system is configured to: receive syndrome data representative of an error state of the plurality of quantum devices; determine occurrence of a runtime trigger event associated with at least one of: one or more of the plurality of quantum devices; and one or more hyperedges of the decoding hypergraph, retrieve, from the decoding hypergraph modification map data structure, a hypergraph modification rule associated with the runtime trigger event; modify the decoding hypergraph in accordance with the hypergraph modification rule to generate a modified decoding hypergraph; and determine a correction for the error state by decoding the syndrome data with the modified decoding hypergraph.

[0011] A quantum computing system (also referred to herein as a quantum computer) is a computing system that exploits quantum mechanical phenomena (i.e. using quantum devices). The quantum devices may be any quantum devices capable of storing quantum information (i.e. any devices suitable for encoding information using quantum computational states). The quantum devices may be qubits. Alternatively, the quantum devices may be other devices capable of storing quantum information, such as qudits or qutrits. While the description herein will primarily refer to qubits, any reference herein to qubits should be understood to also encompass other types of quantum devices unless explicitly stated otherwise.

[0012] Building a useful fault-tolerant quantum computer will require quantum error correction hardware that can receive and process enormous amounts of error information (i.e. syndrome data) in real-time almost instantaneously. A delay in decoding can lead to the creation of a backlog that grows exponentially with the size of the computation, which will ultimately lead to failure of the quantum computation. The speed of the decoder acts as a bottleneck to the number of qubits in a quantum error correction code (and therefore also as a bottleneck to reducing logical error rates). Improvements to decoding hardware and algorithms help to prevent this backlog, thereby enabling quantum computers with higher numbers of qubits and lower error rates because faster decoders can handle quantum error correction codes involving more data qubits, and using more data qubits leads to a reduction in logical error rates when performing fault-tolerant quantum computation.

[0013] The present invention utilises a hypergraph modification map data structure to facilitate fast runtime updates to the decoding hypergraph in response to runtime trigger events such as qubit leakage. Whilst there is an acceptance that decoding hypergraph configuration has a major impact upon decoding performance, no existing proposals offer a practical solution for implementing decoding hypergraph modifications at runtime on dedicated decoding hardware. Existing approaches are generally at the proof of concept stage and involve generating a completely new decoding hypergraph whenever the configuration of a decoding hypergraph is changed, which would be computationally infeasible in a real-time decoding scenario.

[0014] The present invention allows faster runtime modifications to decoding hypergraphs than existing methods, thereby increasing the size of error correction codes that can be implemented without creating a backlog of syndrome data, which in turn reduces logical error rates and increases logical fidelity (i.e. reduces noise) in practical quantum computing scenarios.

[0015] Quantum error correction occurs at a low level in the quantum stack, so the benefits of the present invention occur at the architecture level of the quantum computer (the error correction occurs at the architecture level and is independent of the data being processed / applications being run) and makes the quantum computer run more efficiently and effectively as a computer (due to reduced error rates compared to alternative approaches).

[0016] Decoding hypergraphs (especially decoding graphs) are used in many error correction codes (such as topological error correction codes including the surface code) 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).

[0017] A decoding hypergraph is a hypergraph (in the mathematical sense) comprising hyperedges representing error mechanisms, and nodes (or vertices) representing differences in successive syndrome measurements (or more generally, a decoding hypergraph 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 hypergraph may have one or more boundaries, which involve hyperedges extending beyond the hypergraph (e.g. to one or more virtual boundary nodes), i.e. the decoding hypergraph may be a sub-hypergraph of a larger hypergraph 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.

[0018] A syndrome (also referred to as syndrome data) 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 hypergraph location information for each syndrome value - e.g. a coordinate or index value. Syndrome data may be obtained by measuring a plurality of syndrome qubits (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). A defect (also referred to as an excitation or measurement event) generally represents the end of a chain (or hyperchain) of errors in the decoding hypergraph (the chain of errors may span both space-like and time-like dimensions of the decoding hypergraph). 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.

[0019] A decoding system (also referred to herein as a decoder or quantum error decoding system) 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 quantum devices. 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.

[0020] The quantum error correction code may be a surface code (e.g. planar code) error correction procedure. Alternatively, the quantum error correction code may be any other error correction code that utilises a decoding hypergraph (e.g. a decoding graph), such as other topological quantum error correction codes.

[0021] The decoding hypergraph may be a decoding graph, and the hyperedges may be edges. A hypergraph is a generalisation of a graph in which edges (“hyperedges”) can be connected to more than two nodes (graphs are a specific type of hypergraph in which each edge connects to two nodes). The methods of the present invention apply equally to decoding hypergraphs. Accordingly, any reference herein to decoding graphs and edges should be understood to also encompass decoding hypergraphs and hyperedges respectively.

[0022] Each of the plurality of predefined hypergraph modification rules may be associated with a respective runtime trigger event and may comprise instructions defining decoding hypergraph modifications to be made in response to the respective runtime trigger event. The instructions may be absolute modifications (e.g. an explicit list of edges and associated weights), relative modifications (e.g. a list of edge positions relative to a hyperedge associated with the trigger event) or a rule for determining modifications (e.g. a function that returns one or more edges and weights based on an input trigger event).

[0023] Determining occurrence of the runtime trigger event may comprise receiving the runtime trigger event, or it may alternatively comprise generating the runtime trigger event.

[0024] The quantum computing system may further comprise a control system arranged to transmit control signals to the plurality of quantum devices, and the runtime trigger event may be received from the control system. For example, the control system may detect a runtime leakage event associated with a quantum device and transmit a corresponding leakage runtime trigger event to the decoding system, e.g. as an event message with an event identifier and / or quantum device identifier. The control system may also generate other types of runtime trigger events.

[0025] Alternatively, the runtime trigger event may originate from another device, such as another component of the quantum computing system, or it may be generated within the decoding system itself.

[0026] A runtime trigger event is an event that occurs during the time in which a quantum computation is performed on the quantum computing system.

[0027] The runtime trigger event may comprise at least one of a leakage event and a decoding outcome. Decoding outcomes may include errors and / or corrections identified by the decoding system, e.g. a correction or error operation associated with a particular quantum device and / or hypergraph edge. Runtime trigger events may also be associated with other events that occur during runtime. For example, the runtime trigger event may be received at the decoding system in response to the detection of a cosmic ray incident upon the quantum devices (cosmic ray events can adversely affect quantum states and lead to localised spikes in error rates that necessitate modification of the decoding hypergraph).

[0028] The decoding system may be further configured to, subsequent to determining the correction, reverse modifications made to the decoding hypergraph made in accordance with the hypergraph modification rule. Reversing the modification allows the decoding hypergraph to be reused for a future round of error correction without having to reinitialise the decoding hypergraph.

[0029] The hypergraph modification rule may comprise at least one of: a hyperedge modification (e.g. changing one or more nodes that the hyperedge connects to); a hyperedge weight modification; a new hyperedge; a hyperedge removal; a node modification (e.g. a change in node metadata such as error or syndrome state); a new node; and a node removal. The hyperedge modification may additionally comprise including a hyperedge in a cluster / pre- cluster (i.e. for use by the decoding system when determining a correction using a clustering algorithm), marking the hyperedge (e.g. using a flag or mask) for inclusion in a cluster / pre- cluster, pre-growing the hyperedge or marking the hyperedge (e.g. use a flag or mask) as pre-grown.

[0030] In clustering algorithms, clusters are initialised on each defect. Without pre-clustering, each cluster contains one defect and no edges.

[0031] Pre-clustering involves expanding these clusters during (or immediately after) initialisation to include additional hyperedges and nodes (e.g. adjacent hyperedges potentially affected by leakage events); the clusters can effectively begin as larger clusters that may contain hyperedges and / or additional nodes.

[0032] Pre-growing involves setting the support of certain hyperedges that are to be modified (e.g. hyperedges potentially affected by leakage). Clusters are initialised with single nodes (unlike in pre-clustering), but will expand more quickly over pre-grown edges. In other words, the decoder will include any adjacent pre-grown hyperedges in a cluster in addition to hyperedges that are added as part of the normal growth stage.

[0033] The quantum computing system (e.g. a control system of the quantum computing system) may be further configured to measure a logical state encoded in the quantum devices and apply the correction to the measured logical state (the correction may be applied at the control system, at the decoding system or at some other subsystem of the quantum computing device, such as a device operating at the algorithmic / application layer of the quantum stack).

[0034] According to a second aspect of the invention, there is provided a computer-implemented method of performing a quantum error correction code at a quantum error decoding system, the quantum error correction code having an associated decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices, the method comprising: receiving syndrome data representative of an error state of a plurality of quantum devices of a quantum computing system; determining occurrence of a runtime trigger event associated with at least one of: one or more of the plurality of quantum devices; and one or more hyperedges of the decoding hypergraph, retrieving, from a decoding hypergraph modification map data structure comprising a plurality of predefined hypergraph modification rules, a hypergraph modification rule associated with the runtime trigger event; modifying the decoding hypergraph in accordance with the hypergraph modification rule to generate a modified decoding hypergraph; and determining a correction for the error state by decoding the syndrome data with the modified decoding hypergraph.

[0035] The second aspect of the invention provides the same benefits as the first aspect of the invention. Any feature described in combination with the first aspect of the invention may also be combined with the second aspect of the invention.

[0036] According to a third aspect of the invention, there is provided a computer-readable medium (such as a non-transitory computer readable medium) comprising instructions which, when executed by a quantum error decoding system, cause the quantum error decoding system to carry out the method of the second aspect of the invention. Brief description of the drawings

[0037] Examples of the present invention will now be described in detail with reference to the accompanying drawings, in which:

[0038] Fig. 1 is a schematic of a quantum computing system;

[0039] Fig. 2 show a syndrome extraction circuit;

[0040] Fig. 3 shows a decoding graph;

[0041] Fig. 4 shows part of the syndrome extraction circuit experiencing leakage;

[0042] Fig. 5 shows potential errors caused by leakage in the part of the syndrome extraction circuit;

[0043] Fig. 6 shows a modified decoding graph;

[0044] Fig. 7 shows a flowchart for a method of performing a quantum error correction code; and Fig. 8 shows a flowchart of another method of performing a quantum error correction code.

[0045] Detailed description

[0046] Quantum error correction (QEC) algorithms are used to detect and correct errors at the physical qubit level to mitigate against computational errors at the logical qubit level. QEC is expected to be essential for performing useful computations on early quantum computers, and the delicate nature of qubits means that QEC is likely to remain necessary even once quantum computing hardware matures.

[0047] The goal of QEC is to reduce the effect of noise within a quantum computer: building in redundancies to protect fragile quantum systems. This is achieved with QEC codes that encode a number of logical qubits (one or more) into a larger number of physical qubits. If the error rate of these physical qubits is below a certain threshold associated with the QEC code being used, the logical qubits will exhibit a reduced effective error rate compared to the error rate experienced by the physical qubits. Simply put, each logical qubit will outperform the sum of its parts.

[0048] The present disclosure focuses on quantum decoding. By interacting (non-destructively) with the encoded quantum state via auxiliary qubits (i.e. additional physical qubits that do not themselves encode logical states), it is possible to determine the signature of errors that have affected the logical state; this signature is known as the error syndrome. The process of obtaining this error syndrome, known as syndrome extraction, provides only partial information. As such, decoding algorithms are employed to determine most likely error occurrences and / or corrections (some decoding algorithms, such as some clustering algorithms, can determine a correction without determining likely error occurrences). These algorithms are typically deployed on classical computing hardware with restricted memory and / or processing capabilities. The output of a decoder is a probabilistic prediction. Given the syndrome observed, the decoder outputs a best guess for the error that caused it, or alternatively a likely correction that will correct the error. A given family of error correction codes may have a variety of decoding algorithms to choose from; selecting the decoder is a balance between accuracy, speed, and compute budget for decoding. A more accurate decoder will be more effective at producing a best guess for errors / corrections, and this will result in improved logical accuracy of the quantum computation. The decoder is therefore a key element in the performance of the QEC protocol (and therefore the quantum computation as a whole).

[0049] QEC codes require hardware that can receive and process enormous amounts of error information (i.e. syndrome data) in real-time almost instantaneously. A delay in decoding can lead to the creation of a backlog that grows exponentially with the size of the computation, which will ultimately lead to failure of the quantum computation. Improvements to decoding hardware and algorithms help to prevent this backlog, thereby enabling quantum computers with higher numbers of qubits and lower error rates (faster decoders can handle quantum error correction codes involving more data qubits, and using more data qubits leads to a reduction in logical error rates when performing fault-tolerant quantum computation).

[0050] A schematic of an exemplary quantum computing system 100 suitable for performing the method of the present disclosure is shown in Fig. 1. The quantum computing system 100 comprises a plurality of physical qubits 106 (unless specified otherwise, reference herein to qubits should be understood to refer to physical qubits rather than logical qubits). The qubits 106 may include data qubits used to encode logical qubit states, and auxiliary qubits (or syndrome qubits) used to perform syndrome measurements for QEC. While the exemplary quantum computing system 100 uses qubits 106, one skilled in the art will appreciate that the invention described herein is also applicable to quantum computing systems that use other quantum devices, such as qutrits and qudits. Accordingly, it should be understood that any reference herein to qubits is applicable to any type of quantum devices that can be used to encode quantum information.

[0051] The qubits 106 are controlled by a control system 104 having one or more classical processors. The control system 104 transmits control signals (e.g. RF pulses) to the qubits 106 for performing operations on the qubits 106 (including measurement operations) and receives measurement information from the qubits 106. The measurement information will generally be analogue data signals, although the analogue signals may alternatively be converted to digital signals before being transmitted to the control system 104 in some implementations (e.g. the qubits 106 may be provided with one or more analogue to digital converters). The control system 104 may receive high-level instructions from an algorithmic system or similar (not shown) and convert these high-level instructions (such as logic gates) into low- level qubit instructions (e.g. microwave pulses etc.), which may be in analogue format.

[0052] The quantum computing system 100 also comprises a decoding system 102 (also referred to herein as a decoder). The decoding system 102, which is generally a classical computing system, receives an error syndrome (also referred to as syndrome data) obtained from measurements of syndrome qubits. The error syndrome may comprise raw analogue measurement data, or it may alternatively be pre-processed (e.g. into digital format) by the control system 104. The decoding system 102 may be connected to the control system 104 and receive the error syndrome via the control system 104 as illustrated in Fig. 1 (potentially via one or more additional intermediary systems), or in alternative examples the decoding system 102 may be connected directly to the qubits 106 and receive the error syndrome from the qubits 106 (e.g. as raw analogue signals or digital measurement values). The decoding system 102 uses a decoding process / algorithm to decode the error syndrome to determine a correction for an error state of the qubits 106 associated with the error syndrome (i.e. an error state that causes the measured error syndrome).

[0053] One skilled in the art will appreciate that the quantum computing system 100 may also comprise additional intermediary components positioned between the illustrated components, and that the illustrated components may be connected in a different configuration (e.g. the decoding system 102 may be connected directly to the qubits 106 as previously described).

[0054] As stated above, QEC generally involves obtaining an error syndrome and implementing a decoding algorithm on a hardware or software decoder to identify errors and / or corrections. Fig. 2 shows an example of a quantum circuit 200 that can be used to obtain an error syndrome for three data qubits encoding a single logical qubit; this circuit 200 may be referred to as a syndrome extraction circuit 200. The illustrated circuit 200 can be used to detect and correct Pauli X errors (i.e. bit-flip errors) on the data qubits and provides a simple example of syndrome extraction for the purpose of the present disclosure. One skilled in the art will appreciate that other types of error, such as Pauli Z errors (i.e. phase-flip errors) and Pauli Y errors (combined bit-flip and phase-flip errors), can be protected using more complex syndrome extraction circuits and that the invention of the present disclosure can also be used in combination with such syndrome extraction circuits (e.g. surface code syndrome extraction and error correction).

[0055] The illustrated syndrome extraction circuit 200 uses standard quantum circuit notation; horizontal lines represent individual qubits (labelled q0-q4) and time progresses from left to right (i.e. the leftmost operations are performed before the rightmost operations, although one skilled in the art will appreciate that the order of certain operations can be changed and that some operations can be performed simultaneously even when not horizontally aligned in the circuit diagram).

[0056] Qubits qO, q2 and a4 are data qubits used to encode the logical qubit state and qubits q1 and q3 are syndrome qubits (which may also be referred to as auxiliary qubits or similar) that are used to infer error information about the data qubits. In the illustrated syndrome extraction circuit 200, Pauli X errors on qubits qO or q2 affect (e.g. flip from 0 to 1 or vice- versa) the state of syndrome qubit q1 , and Pauli X errors on qubits q2 or q4 affect the state of syndrome qubit q3.

[0057] The illustrated circuit involves three rounds 202a-c of syndrome extraction performed by measuring the syndrome qubits q1 , q3, followed by a further syndrome extraction performed by measuring the data qubits qO, q2, q4 directly; data qubits can only be measured in this manner at the end of a quantum error correction procedure (i.e. when measuring the logical state) because doing so collapses the quantum state of the qubits.

[0058] Reset operations 204, labelled R, act to prepare the qubits q0-q4 in known states (e.g. |0) states). Measurement reset operations 206, labelled MR, act to measure the state of a qubit and reset it to a known state (e.g. |0) state), and non-reset measurement operations 210, labelled M, measure the qubits without resetting them to a known state. The illustrated syndrome extraction circuit uses controlled-NOT (CNOT) gates 208 to perform two-qubit entangling operations between the data qubits and syndrome qubits.

[0059] Many QEC schemes utilise a decoding graph when decoding error syndromes. A decoding graph is a graph comprising edges representing error mechanisms and nodes representing syndrome measurement outcomes or differences between successive syndrome measurements. The syndrome data does not provide the exact location of errors, but it instead provides information that can be used to infer likely errors and / or corrections. For example, the syndrome data may indicate end points of strings / chains of errors. Non-trivial syndrome values (e.g. changes in value between successive syndrome measurements) are referred to as defects, excitations or measurement events; the location of these defects in the decoding graph acts as a (generally non-unique) symptom of the underlying qubit errors (i.e. errors in the data and syndrome qubits).

[0060] Decoding the syndrome data using a decoding graph generally involves grouping these defects. Examples of decoding algorithms include minimum-weight-perfect-matching, union find and collision clustering. Such decoding algorithms are common general knowledge to one skilled in the art, and any suitable decoding algorithm (i.e. any decoding algorithm that utilises a decoding graph or hypergraph) can be used in combination with the present invention to determine corrections with a decoding graph. The concept of decoding graphs can be extended more generally to hypergraphs, in which edges can be connected to more than two nodes (graphs are a specific type of hypergraph in which each edge connects to two nodes). The methods of the present invention apply equally to decoding hypergraphs. Accordingly, any reference herein to decoding graphs and edges should be understood to include decoding hypergraphs and hyperedges respectively.

[0061] Fig. 3 shows a decoding graph 300 for the syndrome extraction circuit 200 of Fig. 2. The decoding graph is formed of nodes 302 (labelled 0 to 7) connected by edges 304. Each edge 304 has an associated edge weight, labelled pO to p20. The edge weights may be associated with the probabilities of the error mechanisms represented by each edge 304 (i.e. lower weight edges are associated with higher error probabilities).

[0062] The nodes 302 labelled 0 and 1 are associated with the measurements of the syndrome qubits q1 and q3 respectively in the first round 202a of syndrome extraction. Assuming all qubits are initially prepared in a |0) state, the error-free state of these measurements will both be 0. Nodes 2 and 3 are associated with the measurements of the syndrome qubits q1 and q3 respectively in the second round 202b of syndrome extraction, and nodes 4 and 5 are similarly associated with the measurements of the syndrome qubits q1 and q3 respectively in the third round 202c of syndrome extraction (one skilled in the art will appreciate that the nodes may actually be associated with a joint parity / change in measurement value between successive measurements of the syndrome qubits). Node 6 is associated with the measurement outcomes of data qubits qO and q2 in the final round of syndrome extraction, and node 7 is associated with the measurement outcomes of data qubits q2 and q4 in the final round of syndrome extraction.

[0063] Generally speaking, vertical edges 304 of the decoding graph 300 represent error mechanisms affecting the syndrome qubits, horizontal edges 304 represent error mechanisms affecting data qubits in a single round of syndrome extraction, and diagonal edges 304 represent mid-circuit error mechanisms on the data qubits (these errors can arise due to the order of the gates in the syndrome extraction circuit 200).

[0064] Decoding graph structures and edge weights can be determined using various methods. A common approach is to decide upon an error model (e.g. a depolarising error probability associated with each gate in a syndrome extraction circuit) and identify which node(s) would be affected by an error at each location in the syndrome extraction circuit. An edge is added to the decoding graph between any two nodes that are affected by an error, and the weight of the edge is generally inversely proportional to the total error probability associated with that edge (i.e. inversely proportional to the combined error probability for all errors mechanisms related to that edge). For example, if there are two possible errors that affect the same pair of qubits, the total probability of an error for the associated decoding graph edge can be determined by combining the error probabilities, with the inverse of this value being used as the edge weight. One skilled in the art will appreciate that scaling all edges in a decoding graph by the same scale factor does not generally affect the decoding outcome, so the edge weights do not have to be exactly equal to the inverse of the error probabilities.

[0065] Alternatively, edge weights may be determined empirically, e.g. by using experimental data to estimate error probabilities associated with each possible edge of a decoding graph.

[0066] The illustrated decoding graph has some edges 304 that only connect to a single node; these edges represent boundaries of the decoding graph. The boundaries can conceptually be considered to all connect to one or more virtual nodes / boundary nodes. One skilled in the art will appreciate that the nuances of the decoding graph will depend upon the error correction code being implemented, and that some decoding graphs (e.g. those for toric codes) do not have boundaries. The concept of boundaries can be extended to hyperedges, in which hyperedges at a boundary may connect to a virtual node in addition to one or more nodes of the decoding hypergraph.

[0067] Conventional decoding algorithms primarily focus on error mechanisms that leave qubits in a computational basis state (e.g. some superposition of the |0) and |1) states), such as bitflip and phase-flip errors; such error mechanisms can be modelled using noise channels such as depolarising noise. However, it is also possible for other types of error to occur that leave qubits in non-computational states (e.g. a |2) state or similar). Such errors are referred to as leakage errors, because they cause the qubit to leak into a non-computational basisstate. In the present disclosure, the term “leakage” will be used to refer to any unintentional occupation of non-computational basis states by quantum devices.

[0068] Unlike depolarising errors, leakage errors can often be detected directly (i.e. decoding is not required to determine which qubits are affected by leakage). For example, leakage on the syndrome qubits q1 , q3 in the syndrome extraction circuit 200 of Fig. 2 can be detected during the measurement operations (the term “measurement operations” should be understood to include both reset measurement operations and non-reset measurement operations unless explicitly stated otherwise).

[0069] In general, leakage detection events (also referred to as heralded leakage) only inform that leakage has occurred: they do not inform exactly when it occurred. Whenever a leaked qubit interacts with other qubits (e.g. via a CNOT gate) it has the potential to cause undefined behaviour that may increase error rates on the other qubits. As such, the detection of leakage affects the probabilities of different error mechanisms, which in turn affects decoding graph edge weights. In particular, these error mechanisms have a relatively high probability, meaning that the associated decoding graph edges are of relatively low weight and are sharply differentiated from other edges in the graph that typically represent relatively improbable (high weight) error mechanisms.

[0070] As an example, consider the subset of syndrome extraction operations enclosed in the dashed box 212 of Fig. 2. This subset includes a measurement reset operation 206, which may be used to detect the occurrence of leakage on the syndrome qubit q1. However, if leakage is detected, there are three distinct regions of the syndrome extraction circuit during which it may have occurred, as illustrated in Fig. 4. The first possibility is that the syndrome qubit q1 leaked at some point between the initial reset operation and the first CNOT gate; this first region is indicated with the star 400 labelled 1 in Fig. 4. The second possibility is that the syndrome qubit q1 leaked at some point between the first CNOT gate and the second CNOT gate, this second region is indicated with the star 400 labelled 2. Alternatively, the syndrome qubit q1 may have leaked after the second CNOT gate; this third region is indicated with the star 400 labelled 3.

[0071] For the purpose of the present disclosure, it will be assumed that the probability of leakage occurring in the first region is 0. 1% and that the probability of leakage occurring in the second and third regions is 0. 2% for each region (one skilled in the art will appreciate that actual error probabilities, including leakage error probabilities, will vary depending upon the error model, operations and hardware in question and can be determined using various analytic, numerical and empirical methods). Using these error rates and the knowledge that the qubit leaked during one of these it can be inferred that the likelihood that the syndrome qubit leaked by the end of the first region was 0.2, the probability that the leakage occurred by the end of the second region was 0.6, and the probability that the leakage occurred by the end of the third region was 1.0.

[0072] As discussed above, leaked qubits have the potential to affect error rates of other qubits. In the following disclosure, it will be assumed that any qubit that interacts with a leaked qubit experiences depolarising errors with probability 1 (i.e. either an I, X, Y or Z operation is applied to the qubit with equal probability 0.25 - depolarising errors essentially randomise the error state of the qubit). However, one skilled in the art will appreciate that alternative leakage error models may also be used with the methods disclosed herein.

[0073] Accordingly, for the circuit shown in Fig. 4, leakage on the syndrome qubit q1 is modelled as causing a depolarising error on data qubit qO if the leakage occurs in the first region (probability 0.2) - this error is indicated by the cross 500 labelled A in Fig. 5. Leakage in the first or second regions is modelled as causing a depolarising error on the data qubit q2 with probability 0.6, as indicated by the cross 500 labelled B in Fig. 5. Leakage in any region can be modelled as a depolarising error on the syndrome qubit q1 with probability 1 as indicated by the cross 500 labelled C in Fig. 5, although one skilled in the art will appreciate that in practice leakage errors are distinct from depolarising errors.

[0074] The consequence of these additional depolarising errors is to affect the error probabilities associated with different error mechanisms (i.e. edges) on the decoding graph. In particular, the additional depolarising errors shown in Fig. 5 affect the probabilities of error mechanisms associated with three edges of the decoding graph 300 of Fig. 3, as shown by the dashed lines of the updated decoding graph 600 shown in Fig. 6. In the updated decoding graph 600, edge weights p2, p5 and p6 have been replaced with new edge weights p2*, p5* and p6* to reflect the changes in the probabilities of the error mechanisms associated with these edges.

[0075] It is possible to calculate exact weights for the edges affected by the leakage using the methods described above. However, it is often impractical to calculate and implement exact edge weight adjustments at runtime. In addition, the existing decoding graph weights capture the error probabilities accurately for edges that are not affected by leakage, so calculating or generating a completely new decoding graph is unnecessary.

[0076] Instead of using exact edge weights in response to leakage detection events, the weights associated with edges affected by leakage can be set to zero while maintaining high decoding accuracy. In other words, the edge weights p2*, p5* and p6* can be set to zero and all other edge weights left unaffected.

[0077] Alternative adjustments may also be used instead of setting the edge weights to zero. For example, the edge weights may be set to some other predetermined weight value that is low compared to other edge weights in the decoding graph.

[0078] Alternatively, an adjustment may be made using an error flag or mask. For example, a bit may be used as an error flag (e.g. a leakage error flag) to indicate that an edge is associated with a leakage event and / or has an increased error probability (the error flag may be stored in hyperedge data in the decoding hypergraph). Setting a mask for each edge may involve adding the edge to a mask data structure (e.g. a list) indicating edges that are associated with leakage events and / or have increased error probabilities. The error flag or mask may indicate that the edge should be included in a cluster / pre-cluster or pre-grown (i.e. for use by the decoding system when determining a correction using a clustering algorithm).

[0079] Compared to using exact edge weights, this approach has several advantages. Firstly, the approach disclosed herein avoids the need to perform complex recalculations of decoding graph edge weights. The approach disclosed herein also reduces space / memory overhead compared to existing approaches because there is no need to store a weight for each edge that is potentially affected by a given leakage event (a flag, list or mask can be used instead). Furthermore, unlike existing approaches, the approach disclosed herein is applicable in the context of unweighted decoders. When implemented using pre-clustering or pre-growing, the approach disclosed herein also avoids the need to buffer hyperedges that are affected by leakage events to reverse hypergraph modifications after each decoding cycle. These benefits make the invention especially well-suited to implementation in dedicated decoding hardware, which often has limited processing and / or memory capabilities.

[0080] As such, by improving runtime speed, the present invention enables the use of QEC codes with higher qubit numbers and improved logical fidelity (i.e. the present invention reduces noise in practical scenarios compared to existing approaches).

[0081] Compared to decoding approaches in which edges are not modified, the present approach increases logical fidelities (i.e. reduces noise) by multiple orders of magnitude.

[0082] Fig. 7 shows a flowchart of a method for performing quantum error correction with leakage errors. In step 701 , it is determined that a leakage event (e.g. a leakage error) has occurred at a quantum device (e.g. a qubit). The leakage event may be detected during syndrome measurement, or it may be detected at some other point during a quantum computation, e.g. a dedicated leakage detection operation. Leakage may be detected on any quantum device and is not limited to syndrome qubits (for example, leakage may also be detected on data qubits). In addition, leakage may be directly observed, or it may be detected indirectly, e.g. it may be determined that leakage has occurred based on a change in behaviour of nearby qubits.

[0083] In step 702, decoding graph edges potentially affected by the leakage event are determined. An edge is potentially affected by a leakage event if the leakage event increases the likelihood of the error mechanism represented by the edge. Various methods may be used to identify edges potentially affected by the leakage event. For example, qubits that interact with a leaked qubit can be identified (e.g. using a syndrome extraction circuit) or a new decoding graph edge weights can be calculated (e.g. in the vicinity of the leakage) and compared to the original values (any edge for which the edge weight decreases can be identified as affected by the leakage).

[0084] In one example, determining the decoding graph edges potentially affected by leakage may involve determining at least one possible source of the leakage event, determining one or more quantum operations affected by the at least one possible source of the leakage (i.e. any quantum operations that involve a qubit that would be in a leaked state as a consequence of the possible source of the leakage), identifying error mechanisms associated with the determined quantum operations and identifying the decoding graph edges associated with the identified error mechanisms. In an alternative example, determining the decoding graph edges potentially affected by leakage may involve generating a first decoding graph for a first error model (e.g. depolarising error channels or phenomenological noise model) excluding leakage events, generating a second decoding graph for a second error model including leakage events (i.e. the first error model with leakage), and identifying corresponding decoding graph edges that have different weights in each decoding graph.

[0085] In step 703, weights associated with the determined decoding graph edges affected by the leakage are adjusted in accordance with the leakage event. This can be achieved in various ways, including (but not limited to) setting an error flag or mask (e.g. indicating that the edge is to be included in a cluster / pre-cluster or pre-grown), adding the edge to a mask data structure, updating an edge weight value in memory, marking / flagging the edge as having zero weight (so that the decoder treats it as having zero weight, e.g. when using an unweighted graph in which all edges otherwise have the same effective edge weight), merging the nodes connected by the edge, creating a pre-cluster or pre-growing the edge (for decoding algorithms based on clustering) etc.

[0086] The resulting modified decoding graph can then be used to decode syndrome data as part of a quantum error correction procedure.

[0087] Beyond leakage scenarios discussed above, decoding graph modifications may also be required (among others) in scenarios when heralded erasures are detected, when handling soft information, and when using decoding approaches based on correlated matching. Conventional approaches to implementing changes to decoding graphs are computationally expensive and typically involve generating a new decoding graph to replace an existing decoding graph stored in memory and / or require complicated calculations to determine suitable modifications. Performing such operations during runtime is therefore impossible using conventional techniques because the new decoding graph can not be generated quickly enough to perform error correction. To date, no approaches have been proposed that are technically feasible to implement on dedicated decoding hardware.

[0088] An alternative approach for runtime decoding graph (or hypergraph) modifications is shown in Fig. 8. The method shown in Fig. 8 is performed by a decoding system and can be used to perform modifications in response to various runtime trigger events, including (but not limited to) leakage detection events, control system events, decoder events / outcomes (e.g. if additional information is obtained regarding qubit error states) etc.

[0089] In step 801 , syndrome data is received that is representative of an error state of a plurality of quantum devices (e.g. qubits) of a quantum computing system. In step 802, occurrence of a runtime trigger event is determined at the decoding system that is associated with at least one quantum device and / or at least one edge (or hyperedge). The runtime trigger event may be any event occurring during runtime of a quantum computation (i.e. during the time in which the quantum computation is performed / running on the quantum computing system) that necessitates modification of the decoding graph (or hypergraph). For example, the runtime trigger event may be a leakage detection event associated with a single qubit. The runtime trigger event may be generated by the decoding system (i.e. internally), or it may be received from another component of the quantum computing system (i.e. external from the decoder), e.g. from the control system.

[0090] In step 803, a modification rule is retrieved from a modification map data structure. The modification map data structure comprises a plurality of predefined modification rules, each of which may be associated with a respective runtime trigger event. Each modification rule comprises instructions defining decoding hypergraph modifications to be made in response to the respective runtime trigger event; example of modifications include changing edge weights, adding / removing edges / nodes etc.). The modification may be an absolute modification (e.g. may define exactly which edges and / or nodes in the decoding graph should be modified), or it may be a relative modification (e.g. it may define positions of modifications with respect to a given edge, such as the edge associated with the trigger event). Modifications may simply list which edges should be modified, or they may include additional information such as updated edge weights and / or a function that can be used to deduce which edges to modify (thereby negating the need to store specific edge sets). The modification rules may include leakage modification rules determined using the method shown in Fig. 7.

[0091] In step 804, a decoding graph stored in memory on the decoding system is modified in accordance with the modification rule to generate a modified decoding graph. The original decoding graph may be generated by, or provided to, the decoding system ahead of runtime.

[0092] In step 805, a correction is determined for the error state by decoding the syndrome data with the modified decoding graph.

[0093] One skilled in the art will appreciate that numerous decoding algorithms can be used depending upon performance requirements and available computing resources, and the methods of the present disclosure (e.g. those illustrated in Figs. 7 and 8) can be used with any decoding method that utilises a decoding graph (or decoding hypergraph). In addition, one skilled in the art will appreciate that it is generally not necessary to determine error locations and / or apply corrections to the qubits: it suffices to track (classically) how the encoded logical state (or states) of the qubits is affected by errors. The method may optionally further comprise measuring a logical state encoded in the quantum devices and applying the correction to the measured logical state. Once the correction has been determined, the modification may optionally be reversed (i.e. the decoding graph restored to its unmodified state) so that the decoding graph can be reused for a future round of error correction. Reversing the modification may be achieved in various ways, for example by storing the modification rule and / or original edge weights (e.g. by pushing the original decoding graph weights to a stack) when making the modification and using these to reverse the changes to the decoding graph made during the modification.

[0094] The modification map data structure may be stored in memory on the decoding system. The modification map data structure may be generated ahead of runtime (i.e. prior to performing the quantum computation) based on possible runtime trigger events (e.g. leakage), thereby reducing the complexity of calculations that need to be performed at runtime. The time taken to perform a modification using the method of Fig. 8 scales linearly with the number of edges affected by the modification. Using a modification map data structure and modification rules therefore provides a resource-efficient method to account for runtime trigger events (such as leakage), which in turn improves the performance of the decoding system, thereby reducing logical error rates (i.e. reducing noise in the quantum computer).

[0095] Pauli X, Y and Z operations may be referred to herein simply as X, Y and Z operations.

[0096] While the present disclosure uses the convention that the qubit measurement outcomes associated with |0) and |1) quantum states are referred to as 0 and 1 respectively (i.e. referring to the states themselves), one skilled in the art will appreciate that the disclosure is equally applicable when using the alternative nomenclature in which these measurement outcomes are referred to as -1 and +1 respectively (i.e. the eigenvalues associated with the |0) and |1) states respectively).

[0097] Any method described herein may be provided as a computer program product and / or on a computer readable medium such as a non-transitory computer readable medium.

[0098] It should be understood that any method of the present disclosure could include additional steps, and any device could include additional components. In addition, unless indicated otherwise or technically infeasible, the method steps disclosed herein may be performed in alternative orders, and any order described herein should be considered as exemplary rather than limiting. As a non-limiting example, the step of receiving the syndrome data in Fig. 8 need not occur at the start of the process but could occur any time prior to determining the correction. The illustrated steps and components could be split into multiple sub- steps / subcomponents.

[0099] Furthermore, one skilled in the art will appreciate that any computation that can be performed by a classical processing device can also be performed by a quantum computing device. Accordingly, any methods or described herein that is performed on a classical computing device (such as a CPU) can also be performed by a quantum processing device, such as a quantum processing unit (QPU) comprising a plurality of qubits.

Claims

CLAIMS1. A quantum computing system comprising: a plurality of quantum devices; and a decoding system comprising memory storing: a decoding hypergraph for a quantum error correction code, the decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices; and a decoding hypergraph modification map data structure comprising a plurality of predefined hypergraph modification rules, wherein the decoding system is configured to: receive syndrome data representative of an error state of the plurality of quantum devices; determining occurrence of a runtime trigger event associated with at least one of: one or more of the plurality of quantum devices; and one or more hyperedges of the decoding hypergraph, retrieve, from the decoding hypergraph modification map data structure, a hypergraph modification rule associated with the runtime trigger event; modify the decoding hypergraph in accordance with the hypergraph modification rule to generate a modified decoding hypergraph; and determine a correction for the error state by decoding the syndrome data with the modified decoding hypergraph.

2. The quantum computing system of claim 1 , wherein each of the plurality of predefined hypergraph modification rules is associated with a respective runtime trigger event and comprises instructions defining decoding hypergraph modifications to be made in response to the respective runtime trigger event.

3. The quantum computing system of claim 1 or claim 2, further comprising a control system arranged to transmit control signals to the plurality of quantum devices, wherein the runtime trigger event is received from the control system.

4. The quantum computing system of any preceding claim, wherein the decoding system is further configured to, subsequent to determining the correction, reverse modifications made to the decoding hypergraph made in accordance with the hypergraph modification rule.

5. The quantum computing system of any preceding claim, wherein the runtime trigger event comprises at least one of a leakage event and a decoding outcome.

6. The quantum computing system of any preceding claim, wherein the syndrome data comprises the trigger event.

7. The quantum computing system of any preceding claim, wherein the hypergraph modification rule comprises at least one of: a hyperedge modification; a hyperedge weight modification; a new hyperedge; a hyperedge removal; a node modification; a new node; and a node removal.

8. The quantum computing system of any preceding claim, wherein the quantum devices are qubits.

9. The quantum computing system of any preceding claim, wherein the decoding hypergraph is a decoding graph and wherein the hyperedges are edges.

10. The quantum computing system of any preceding claim, wherein the quantum computing system comprising is further configured to: measure a logical state encoded in the plurality of quantum devices to obtain a logical state measurement; and apply the correction to the logical state measurement.

11. A computer-implemented method of performing a quantum error correction code at a quantum error decoding system, the quantum error correction code having a decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices, the method comprising: receiving syndrome data representative of an error state of a plurality of quantum devices of a quantum computing system; determining occurrence of a runtime trigger event associated with at least one of: one or more of the plurality of quantum devices; and one or more hyperedges of the decoding hypergraph, retrieving, from a decoding hypergraph modification map data structure comprising a plurality of predefined hypergraph modification rules, a hypergraph modification rule associated with the runtime trigger event; modifying the decoding hypergraph in accordance with the hypergraph modification rule to generate a modified decoding hypergraph, and determining a correction for the error state by decoding the syndrome data with the modified decoding hypergraph.

12. The method of claim 11 , wherein each of the plurality of predefined hypergraph modification rules is associated with a respective runtime trigger event and comprises instructions defining decoding hypergraph modifications to be made in response to the respective runtime trigger event.

13. The method of claim 11 or claim 12, wherein the runtime trigger event is received from a control system arranged to transmit control signals to the plurality of quantum devices.

14. The method of any of claims 11 to 13, further comprising, subsequent to determining the correction, reversing modifications made to the decoding hypergraph made in accordance with the hypergraph modification rule.

15. The method of any of claims 11 to 14, wherein the runtime trigger event comprises at least one of a leakage event and a decoding outcome.

16. The method of any of claims 11 to 15, wherein the syndrome data comprises the trigger event.

17. The method of any of claims 11 to 16, wherein the hypergraph modification rule comprises at least one of: a hyperedge modification; a hyperedge weight modification; a new hyperedge; a hyperedge removal; a node modification; a new node; and a node removal.

18. The method of any of claims 11 to 17, wherein the quantum devices are qubits.

19. The method of any of claims 11 to 18, wherein the decoding hypergraph is a decoding graph and wherein the hyperedges are edges.

20. The method of any of claims 11 to 19, further comprising: measuring a logical state encoded in the plurality of quantum devices to obtain a logical state measurement; and applying the correction to the logical state measurement.

21. A computer-readable medium comprising instructions which, when executed by a quantum error decoding system, cause the quantum error decoding system to carry out the method of any of claims 11 to 20.

Images