Quantum error correction with independent decoding windows

Abstract

A quantum error correction method and quantum computing system are disclosed. The quantum computing system receives syndrome data and sets defect states of nodes in a decoding hypergraph according to defects identified in the syndrome data. The quantum computing system determines a plurality of decoding windows associated with logical observable subsets of a logical observable and independently decodes the decoding windows to determine partial corrections. The partial corrections are then combined by the quantum computing system to determine an aggregate correction for an error state of quantum devices in the quantum computing system.

Description

[0001] QUANTUM ERROR CORRECTION WITH INDEPENDENT DECODING WINDOWS Field

[0002] The present disclosure relates to quantum error correction.

[0003] Background

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

[0005] 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. Fault-tolerant quantum computation requires errors to be decoded with low latency and at a rate equal to (or faster than) the rate at which they occur. Decoding errors at the rate at which they occur avoids errors accumulating, and reducing decoding latency (i.e. , reducing the time between error detection being performed and a correction being returned) increases the rate at which quantum operations can be performed, thereby reducing the total time required to complete a given computation.

[0006] As quantum computing hardware improves, decoding speed risks becoming a bottleneck to the overall speed of quantum computations. There is a need for low-latency decoding techniques that enable fault-tolerant quantum computers to achieve maximum performance.

[0007] Summary

[0008] According to a first aspect of the present disclosure, there is provided a quantum error correction method comprising: receiving syndrome data representative of an error state of quantum devices in a quantum computing system, the syndrome data identifying a plurality of defects, each defect associated with a respective node in a decoding hypergraph; setting defect states of nodes in the decoding hypergraph according to the plurality of defects identified in syndrome data; identifying a plurality of elements of the decoding hypergraph associated with a logical observable of a quantum error correction code; determining a plurality of decoding windows of the decoding hypergraph, wherein each decoding window of the plurality of decoding windows is associated with a logical observable subset of a plurality of logical observable subsets, each of the plurality of logical observable subsets comprising a subset of the plurality of elements of the decoding hypergraph associated with the logical observable; independently decoding the plurality of decoding windows todetermine a corresponding plurality of partial corrections; and combining the partial corrections to determine an aggregate correction for the error state.

[0009] A partial correction for a given decoding window may comprise an indication of whether the logical observable subset associated with the given decoding window is affected by the error state.

[0010] The indication of whether the logical observable subset associated with the given decoding window is affected by the error state may comprise a probability that the logical observable subset associated with the given decoding window is affected by the error state.

[0011] The aggregate correction may comprise an indication of whether the logical observable is affected by the error state.

[0012] The indication of whether the logical observable is affected by the error state may comprise a probability that the logical observable is affected by the error state.

[0013] Combining the partial corrections may comprise combining probabilities that each given decoding window is affected by the error state to determine the probability that the logical observable is affected by the error state.

[0014] Combining the partial corrections may comprise determining a parity of the partial corrections, and wherein the aggregate correction comprises the parity of the partial corrections.

[0015] Th method may further comprise maintaining a running aggregate correction state, and combining the partial corrections may comprise combining the partial corrections with the running aggregate correction state.

[0016] At least two adjacent decoding windows may be decoded in parallel by separate decoder instances.

[0017] Each decoding window may comprise all decoding hypergraph elements within a predetermined distance of the elements in the logical observable subset associated with that decoding window, and the predetermined distance may be based on a code distance of the quantum error correction code.

[0018] Each logical observable subset may comprise a contiguous subset of the plurality of elements of the decoding hypergraph associated with the logical observable.

[0019] The logical observable subsets may be non-overlapping.

[0020] Determining the plurality of decoding windows may comprise partitioning the logical observable into the logical observable subsets.

[0021] Independently decoding the plurality of decoding windows may comprise decoding the plurality of decoding windows consistently such that defects in overlapping sections ofadjacent decoding windows are decoded such that they affect the same logical observable subset in each of the adjacent decoding windows.

[0022] The method may further comprise obtaining a logical readout value for the logical observable; and applying the aggregate correction to the logical readout value.

[0023] Independently decoding the plurality of decoding windows may comprise independently decoding the plurality of decoding windows using a plurality of decoder instances, and the method may further comprise distributing subsets of syndrome data to the plurality of decoder instances.

[0024] According to a second aspect, of the present disclosure, there is provided a quantum computing system comprising: a plurality of quantum devices; and one or more classical processing components configured to: receive syndrome data representative of an error state of the quantum devices, the syndrome data identifying a plurality of defects, each defect associated with a respective node in a decoding hypergraph; set defect states of nodes in the decoding hypergraph according to the plurality of defects identified in syndrome data; identify a plurality of elements of the decoding hypergraph associated with a logical observable of a quantum error correction code; determine a plurality of decoding windows of the decoding hypergraph, wherein each decoding window of the plurality of decoding windows is associated with a logical observable subset of a plurality of logical observable subsets, each of the plurality of logical observable subsets comprising a subset of the plurality of elements of the decoding hypergraph associated with the logical observable; independently decode the plurality of decoding windows to determine a corresponding plurality of partial corrections; and combine the partial corrections to determine an aggregate correction for the error state.

[0025] A partial correction for a given decoding window may comprise an indication of whether the logical observable subset associated with the given decoding window is affected by the error state.

[0026] The indication of whether the logical observable subset associated with the given decoding window is affected by the error state may comprise a probability that the logical observable subset associated with the given decoding window is affected by the error state.

[0027] The aggregate correction may comprise an indication of whether the logical observable is affected by the error state.

[0028] The indication of whether the logical observable is affected by the error state may comprise a probability that the logical observable is affected by the error state.Combining the partial corrections may comprise combining probabilities that each given decoding window is affected by the error state to determine the probability that the logical observable is affected by the error state.

[0029] Combining the partial corrections may comprise determining a parity of the partial corrections, and the aggregate correction may comprise the parity of the partial corrections. The one or more classical processing components may be further configured to maintain a running aggregate correction state, and combining the partial corrections may comprise combining the partial corrections with the running aggregate correction state.

[0030] At least two adjacent decoding windows may be decoded in parallel by separate decoder instances.

[0031] Each decoding window may comprise all decoding hypergraph elements within a predetermined distance of the elements in the logical observable subset associated with that decoding window, and the predetermined distance may be based on a code distance of the quantum error correction code.

[0032] Each logical observable subset may comprise a contiguous subset of the plurality of elements of the decoding hypergraph associated with the logical observable.

[0033] The logical observable subsets may be non-overlapping.

[0034] Determining the plurality of decoding windows may comprise partitioning the logical observable into the logical observable subsets.

[0035] Independently decoding the plurality of decoding windows may comprise decoding the plurality of decoding windows consistently such that defects in overlapping sections of adjacent decoding windows are decoded such that they affect the same logical observable subset in each of the adjacent decoding windows.

[0036] The one or more classical processing components may be further configured to: obtain a logical readout value for the logical observable; and apply the aggregate correction to the logical readout value.

[0037] Independently decoding the plurality of decoding windows may comprise independently decoding the plurality of decoding windows using a plurality of decoder instances, and the one or more classical processing components may be further configured to distribute subsets of syndrome data to the plurality of decoder instances.

[0038] According to a third aspect of the present disclosure, there is provided a computer program product comprising instructions which, when the program is executed by a quantum computing system, cause the quantum computing system to carry out the method of the first aspect.According to a fourth aspect of the present disclosure, there is provided a computer-readable medium comprising instructions which, when executed by a quantum computing system, cause the quantum computing system to carry out the method of the first aspect.

[0039] Brief description of the drawings

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

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

[0042] Fig. 2a is a decoding graph with defect locations marked;

[0043] Fig. 2b is the same decoding graph with corrections marked;

[0044] Figs. 3a-d show a sliding window decoding technique on the decoding graph;

[0045] Figs. 4a-d show a parallel window decoding technique on the decoding graph;

[0046] Figs. 5a-f show an independent window decoding technique on the decoding graph;

[0047] Fig. 6 shows an alternative independent decoding window technique;

[0048] Fig. 7 is a process diagram for the independent window decoding technique; and

[0049] Fig. 8 is a flowchart of an independent window decoding method.

[0050] Detailed description

[0051] 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.

[0052] 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 the physical qubits is below a certain threshold associated with the QEC code being used, the logical qubits exhibit a reduced effective error rate compared to the error rate experienced by the physical qubits. Simply put, each logical qubit outperforms the sum of its parts.

[0053] The present disclosure focuses on quantum decoding. By interacting non-destructively with the encoded quantum state, e.g., via auxiliary qubits (additional physical qubits that do not themselves encode logical states), it is possible to determine the signature of errors affecting the physical qubits; this signature is known as an error syndrome (also referred to herein as a syndrome or syndrome data). The process of obtaining this error syndrome, known as syndrome extraction, provides only partial information (that is, it does not explicitly identify which errors have occurred). As such, decoding algorithms are employed to determine most likely error occurrences and / or corrections (some decoding algorithms,such as certain clustering algorithms, determine a correction without determining likely error occurrences). These decoding algorithms are typically deployed on classical computing hardware with restricted memory and / or processing capabilities.

[0054] The output of a decoder may be a probabilistic prediction. Given the syndrome observed, the decoder may output an error with high associated probability that explains the syndrome, or alternatively a likely correction that will correct the error. A given family of error correction codes be implemented in combination with a variety of decoding algorithms, and selecting a suitable decoder is a balance between accuracy, speed, and compute budget for decoding; a more accurate decoder will generally be more effective at determining errors / corrections, thereby improving the logical accuracy of the quantum computation. The decoder is a key element in the performance of the QEC protocol, and therefore a key element in the performance of the quantum computation as a whole.

[0055] QEC codes require hardware that can receive and process enormous amounts of error information (e.g., syndrome data) in real-time almost instantaneously. A delay in decoding can lead to the creation of a backlog of syndrome data 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).

[0056] Quantum error correction occurs at a low level in the quantum computing stack, so the benefits of the present disclosure 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 logical error rates compared to alternative approaches).

[0057] A schematic of an exemplary quantum computing system 100 suitable for performing the methods of the present disclosure is shown in Fig. 1. 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) to perform computational operations. The quantum devices may be any quantum devices capable of storing quantum information (e.g., 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 beunderstood to also encompass other types of quantum devices unless explicitly stated otherwise.

[0058] The quantum states of a qubit may for instance include electronic states, polarization states, vibrational states, rotational states, or spin states. For example, qubits may be superconducting qubits, neutral atom qubits or any other type of qubit. In some cases, a qubit may be a logical qubit formed from multiple physical qubits, such as a superconducting resonator coupled to an ancilla superconducting charge qubit.

[0059] In the case of superconducting qubits, quantum information may be represented by the presence or absence of an electronic charge (e.g., the presence of absence of a Cooperpair, which is a pair of bound electrons). The quantum state of a superconducting qubit can be manipulated through the application of shaped microwave pulses, which can effect operations such as quantum logic gates and state readout.

[0060] In the case of neutral atom qubits, quantum information may be represented by occupation of different electron energy levels. For example, a first energy level (e.g., the ground state or some excited state) may represent a first quantum state, and a different energy level may represent a different quantum state. The quantum state of a neutral atom qubit can be manipulated through the application of laser pulses, whereby the frequency and duration of the pulse can be carefully controlled to cause transitions between select energy levels. Neutral atom qubits can be measured by detecting photon emission (i.e., electromagnetic radiation, which may be in the visible spectrum) when the atom is irradiated with suitable laser pulses.

[0061] Unlike classical bits (which can be in either a zero or one state), qubits exploit the phenomenon of quantum superposition in order to enable them to exist in multiple states at once. Quantum superposition allows a quantum mechanical system to simultaneously occupy multiple different quantum states; only when the state of the system is observed / measured does the system “collapse” into a single definite state.

[0062] For example, a quantum zero state (denoted |0)) may correspond to the absence of a Cooper pair (in the case of superconducting qubits) or occupation of a first electron energy level (in the case of neutral atom qubits), and a quantum one state (denoted |1)) may correspond to the presence of a Cooper pair or occupation of a second energy level. Quantum mechanics allows qubits to simultaneously be in a combination of the |0) and |1) states until they are observed (at which point they “collapse” into a single one of these states).

[0063] This combination of the |0) and |1) basis states for a single qubit may be represented as a quantum wavefunction \ (J) = a|0) + 11), where \ (J) represents the qubit state and a and ft represent amplitudes of the |0) and |1) states respectively. The amplitudes may be positiveor negative, and they may have complex components. Conceptually, a single qubit state can be visualized as a position on a unit sphere known as a “Bloch sphere”. Some qubits can also be controlled to be in other states, such as higher or lower energy states than the |0) and |1) basis states, for the purposes of computation, such as the Rydberg state in neutral atoms.

[0064] In addition to superposition, qubits can also exploit the phenomenon of quantum entanglement, which allows the states of different (potentially spatially separated) quantum mechanical systems to become dependent upon one another. For example, when a first and a second quantum mechanical system are entangled, observation / measurementof one of the systems may cause the other to instantaneously collapse into a state dependent upon the outcome of said observation / measurement. Entanglement between qubits can be realised by applying control signals (e.g., microwave or laser pulses) to a qubit in such a way that the effect upon that qubit is dependent upon the state of one or more other qubits. In the example of neutral atoms, qubits can be entangled by making use of the “Rydberg blockade” effect.

[0065] While there are several different (and equivalent) models of quantum computation, the most prominent model is the circuit model, in which quantum computations are described using quantum logic circuits that are similar to logic circuits used in classical (i.e. , non-quantum) computation.

[0066] For example, quantum circuit operations include (among others) an X (or NOT) gate, which flips a |0) state to a |1) state (and vice-versa), a Z (or phase) gate (which flips the sign of the amplitude of the |1) state), and a CNOT (or controlled-NOT) gate, which performs an X gate on a target qubit dependent upon a control qubit being in a |1) state. As one skilled in the art will appreciate, the CNOT gate can be used to entangle qubits when the control qubit is in a superposition of the |0) and |1) states (conceptually, the CNOT gate is activated by the part of the superposition that is in the |1) state but not by the part of the superposition that is in the |0) state, so the state of the target qubit becomes dependent upon the state of the control qubit).

[0067] Because the amplitudes of quantum states can vary continuously, the number of possible quantum states is unrestricted (i.e., infinite). As such, quantum gates are similarly not restricted to analogues of classical logic operations. Instead, quantum gates can perform arbitrary manipulations of the quantum state, which can be visualised as rotations of the quantum state in the Bloch sphere picture. A quantum gate may therefore be any unitary operation. In practice, arbitrary unitary operations may be approximated by using a finite set of logic gates (e.g., a group of quantum operations known as the “Clifford group” in combination with one other gate that is not an element of the Clifford group). Furthermore,these operations may be performed on groups of physical qubits that encode logical qubits as part of an error correction code.

[0068] Quantum logic gates may conveniently be represented as matrices, and quantum states may be represented as vectors (normally column vectors).

[0069] For example, a quantum state \ (J) = a|0) + ?|1> may be represented as:

[0070] w = ©- X, Z and CNOT gates may be represented as:

[0071] "

[0072]

[0073] where the CNOT gate acts upon two quantum states, which can be represented as a column vector (e.g., the tensor product of two quantum states).

[0074] Quantum logic gates can be implemented on physical qubits by applying control pulses (e.g., microwave or laser pulses, depending upon the qubit architecture). In addition to the logic gates described above, other quantum computing operations include state initialisation (e.g., preparing qubits in an initial state, such as a |0) state) and state measurement (e.g., measuring whether a qubit is in a |0) or |1) state - as discussed above, a qubit may be in a superposition of both of these states and collapses into one state when it is measured). The state of a qubit can be determined by performing a readout operation (also referred to as a measurement) on that qubit, e.g., detecting the absence / presence of a Cooper pair for a superconducting qubit or detecting whether a given atomic energy level is occupied for a neutral atom qubit. Different measurement bases can be used: common measurement bases include the Pauli Z basis (which detects whether a qubit is in a |0) or |1) state) and the Pauli X basis (which detects whether a qubit is in a |+) = |0) + |1) or |-) = |0) - |1) state).

[0075] The terms readout and measurement may be used interchangeably herein to refer to the process of obtaining a readout value for a quantum observable. One skilled in the art will appreciate that qubit measurement outcomes (also referred to herein as readout outcomes, readout values, or measurement values) may conventionally be referred to in terms of the observed quantum state (e.g., the qubit measurement outcomes associated with |0) and |1) quantum states may be referred to as 0 and 1 respectively) and in terms of the eigenvalues associated with the observed quantum state (e.g., the qubit measurement outcomes associated with |0) and |1) quantum states may be referred to as +1 and -1 respectively); each of these nomenclatures is equally valid, and both may be used interchangeably in the present disclosure.Quantum computers can perform quantum logic gates that cannot be efficiently simulated by a classical computer, which means that quantum computers can perform calculations that would be infeasible on classical computers. For example, the behaviour of quantum mechanical systems can be described by unitary matrices, so quantum computers can simulate these quantum mechanical systems by decomposing these unitary matrices into quantum logic gates that can be performed on the quantum computer. This allows quantum computers to determine molecular properties (such as energy levels) and has applications in areas such as materials development and drug discovery. The output of a quantum computation (e.g., the result of the computation / calculation) is determined by measuring the qubits; when simulating quantum mechanical systems, this measurement may encode a physical parameter, such as an energy level or similar. Quantum computers also have applications outside of quantum simulations, such as factoring numbers (which can be used to decipher encrypted information).

[0076] The illustrated quantum computing system 100 comprises a logical layer 102, quantum computing hardware 104 (which includes a control system 106 and qubits 108), and a decoding system 110. Unless specified otherwise, reference herein to qubits should be understood to refer to physical qubits rather than logical qubits.

[0077] The qubits 108 may include data qubits used to encode logical qubit states, and auxiliary qubits (or syndrome qubits) used to facilitate operations such as syndrome measurements for QEC. While the illustrated quantum computing system 100 uses qubits 108, one skilled in the art will appreciate that the present disclosure 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 , and that the qubits 108 in Fig. 1 could be replaced with other types of quantum device without loss of generality.

[0078] The qubits 108 are controlled by the control system 106, which has one or more classical processors; the control system 106 may also be referred to as a quantum control system. The control system 106 transmits control signals (e.g., RF pulses) to the qubits 108 for performing operations on the qubits 108 (including measurement operations) and receives measurement information from the qubits 108, generally in the form of analogue data signals. The control system 106 may perform state discrimination on the measurement information in order to obtain measurement values associated with the qubits 108, these measurement values may be discretised (e.g., into 0 or 1 values representing different measurement outcomes) and / or may comprise other information, such as a probability / confidence value associated with different measurement outcomes.The control system 106 may receive instructions from the logical layer 102 and convert these instructions (such as physical qubit gate instructions) into low-level qubit instructions (e.g., microwave pulses etc.), which may be in analogue format. The logical layer 102 may be implemented on separate classical processing hardware and may be responsible for tasks such as converting quantum logic circuits to fault-tolerant / QEC primitives (e.g., compiling a quantum circuit from its high-level operations into the operations required to implement that circuit with QEC, e.g., using lattice surgery operations) and converting fault-tolerant / QEC primitives into physical gates (e.g., compiling lattice surgery operations into physical qubit gates). While many of the tasks performed by the logical layer 102 can be performed ahead of runtime (e.g., at compile time), the logical layer 102 may also provide runtime instructions (e.g., when using “just in time” compilation and / or when making runtime decisions / branching).

[0079] The logical layer may also send instructions (e.g., QEC logic mapping) to the decoding system 110; these instructions may either be sent directly to the decoding system 110 or they may be sent via the quantum computing hardware 104 (e.g., via the control system 106). During runtime, the control system 106 may transmit syndrome data obtained from measurements of syndrome qubits to the decoding system 110. The syndrome data may comprise analogue measurement data (often referred to as “soft information”), or it may alternatively be pre-processed (e.g., into “hard” syndrome measurement outcome values or similar) by the control system 106.

[0080] The decoding system 110 (also referred to herein as a decoder), which is generally a classical computing system, receives the syndrome data and uses a decoding process / algorithm to decode the syndrome data to determine a correction for an error state of the qubits 108 associated with the syndrome data (e.g., a correction for an error state that causes the measured syndrome data). The decoding system 110 decodes syndrome data and provides one or both of (i) possible error locations (e.g., 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 (e.g., whether the value of a logical observable is affected / flipped). The correction can generally be tracked by a classical computer (e.g., by the decoding system 110 or control system 106) and does not generally need to be applied to the qubits 108 or other quantum devices. The decoding system 110 may be a dedicated hardware device (e.g., implemented using one or more FPGAs or ASICs or similar) or it may be a software component implemented using one or more CPUs.The correction may provide the locations of physical qubits affected by errors, such that these qubits can either be corrected during the computation (e.g., by applying a quantum gate to reverse the error) or by tracking the effect of the error using classical processing and correcting any subsequent physical qubit measurements (the latter approach is preferred as there is a risk that performing additional correction operations on the physical qubits could cause further errors). In this case, the correction may be in the form of a binary list indicating physical qubits included in the correction.

[0081] As mentioned above, it is generally not necessary to provide the locations of individual physical qubits that are affected by errors. Instead, it suffices to track the effect that the physical qubit errors have upon logical quantum observables (referred to herein as logical observables) of the logical qubits.

[0082] In quantum computing (and quantum mechanics more generally), an observable is a physical property that can be measured, e.g., the state of a qubit. A logical observable is therefore a logical state of a logical qubit. Rather than providing a correction at the physical qubit level, the decoder can instead provide a correction at the logical qubit level by providing a single bit (in the case of qubits) for each logical observable of interest indicating whether the value of that logical observable has been affected (e.g., flipped, in the case of qubits) by errors at the physical qubit level. For example, if the logical observable of interest is the logical Pauli Z observable (which corresponds to observing whether a logical qubit is in a |0) or |1) logical state), the correction for that logical qubit may be a single bit, with a zero indicating that the logical observable is not affected by the physical qubit errors (so measurement of the logical observable will yield a correct value) and a one indicating that the logical observable is affected by the physical qubit errors (in which case the measurement outcome will be incorrect and can be corrected classically, e.g., by changing a |0) measurement result to a |1) measurement result or vice-versa). The cumulative effect of errors upon logical qubit states can therefore be tracked using a single bit per logical observable of interest.

[0083] The decoding system 110 may comprise one or more decoding units (e.g., one or more processing elements or similar) capable of performing decoding tasks, e.g., decoding part of a larger decoding problem. In other words, the syndrome data may be distributed to multiple decoder instances, which may optionally be implemented on separate decoding units. One of the decoding units may act as a central decoding unit / orchestration unit and be responsible for coordinating / orchestrating the decoding process between decoding units, or the decoding system 110 may alternatively comprise an additional dedicated processing unit (e.g., a CPU or controller) to act as a central decoding unit / orchestration unit and oversee the decoding process, e.g., performing tasks such as distributing thesyndrome data to different decoding instances and combining output from separate decoding instances. Correction information may be transmitted from the decoding system 110 to the control system 106, and the control system 106 may use the correction information to apply corrections to logical qubit measurements.

[0084] 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. For example, among other arrangements, the logic layer 102 and / or the decoding system 110 may be integrated into the quantum computing hardware 104, e.g., as discrete components or as part of the control system 106.

[0085] Many conventional QEC schemes utilise a decoding graph (also referred to as a matching graph) when decoding syndrome data. The concept of a decoding graph can be generalised to decoding hypergraphs (also referred to as matching hypergraphs). A hypergraph is a generalisation of a graph in which edges (“hyperedges”) can be connected to more than two nodes. A decoding hypergraph is a hypergraph comprising edges (or more generally, hyperedges) representing error mechanisms, and nodes (also referred to as vertices) representing detectors of the QEC code (e.g., syndrome values, such as stabiliser measurement outcomes or differences between successive stabiliser measurements). A decoding graph is a special case of a decoding hypergraph in which each hyperedge connects only two nodes.

[0086] The methods of the present disclosure apply equally to decoding graphs and decoding hypergraphs. Accordingly, any reference herein to graphs or edges (including, but not limited to, decoding graphs and edges) should be understood to also encompass hypergraphs and hyperedges (including, but not limited to, decoding hypergraphs and hyperedges), respectively.

[0087] Decoding hypergraphs (especially decoding graphs) may be used in error correction codes (such as topological error correction codes including the surface code) to facilitate decoding of the syndrome data by pairing (or grouping) “defects” in the syndrome data (these defects generally provide an indication of end points of chains (or hyperchains) of errors on physical data qubits in the error correction code).

[0088] 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), such as parity measurement results. The decoding hypergraph may have one or more open boundaries, which involve hyperedges extending beyond the hypergraph (e.g., to one or more virtual boundary nodes), e.g., the decodinghypergraph 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, “open boundaries” referred to herein are generally synonymous with the “rough” boundaries in such literature.

[0089] The syndrome data may be 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 data may also include decoding hypergraph location information for each value in the syndrome data - 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). The syndrome data may also comprise other data, such confidence values associated with stabiliser measurements or a bitstring (or similar) describing whether each quantum device is in a leaked or unleaked state.

[0090] In more detail, QEC codes may involve obtaining measurement values for stabilisers, which are quantum operators that act on sets of physical data qubits of the QEC code and provide information about the collective error state of that set of qubits (e.g., the stabiliser measurement value may act as a parity check indicating whether an odd or even number of data qubits in the set of physical data qubits are affected by a certain type of error). Stabiliser values may be obtained by performing entangling operations between physical auxiliary qubits (syndrome qubits) and the set of physical data qubits. The stabiliser values become encoded in the quantum states of the syndrome qubits as a result of the entangling operations, and the stabiliser measurement values can then be obtained by measuring the syndrome qubits. In this way, error information can be inferred without directly measuring states of individual physical data qubits (which would cause logical quantum states encoded in the QEC code to collapse, thereby negating any quantum mechanical effects).

[0091] In other words, the syndrome data may be obtained by measuring syndrome qubits to obtain stabiliser values. The collection of stabiliser values may itself be used as the syndrome data. Alternatively, when performing multiple rounds of error correction, the syndrome data may instead indicate changes in stabiliser values between successive rounds of stabiliser measurements (e.g., classically processing the stabiliser values by taking the exclusive-or (XOR) value of successive measurement values); this is because the decoder is generally interested in changes in the error state.The syndrome data may optionally be provided as or with “soft” information indicative of stabiliser measurement confidence values. In general, there is uncertainty associated with measurement of quantum mechanical systems (such as qubits). This uncertainty (e.g., a probability) can optionally be used to improve decoder accuracy and is commonly referred to as soft information.

[0092] The syndrome data may therefore comprise at least one of (i) stabiliser measurement values obtained from measurement of physical qubits (e.g., readout data such as raw physical qubit measurement data, a list 0 and 1 values representing the |0) and |1) states of the syndrome qubits and / or soft information indicating confidence values / probabilities associated with measurement outcomes), and (ii) a list of stabiliser values that have changed from the previous round of QEC (e.g., the result of performing an XOR operation between successive rounds of syndrome measurement values).

[0093] In the case where the syndrome data is provided to the decoding system 110 in raw form (e.g., as raw measurement data) / soft information, the decoding system 110 may process the syndrome data by performing quantum state discrimination to assign quantum state measurement outcomes to the physical qubit readouts. One skilled in the art will appreciate that quantum state discrimination can be performed in various ways, such as using a threshold value to distinguish between measurement outcomes associated with |0) and |1) physical qubit states.

[0094] 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, e.g., nodes in the decoding hypergraph. Non-trivial syndrome data values (e.g., changes in value between successive syndrome measurements) are referred to as defects, excitations or detection events. A defect generally represents the end of a chain of errors in a decoding hypergraph (the chain of errors may span both space-like and time-like dimensions of the decoding hypergraph). Defects are non-trivial syndrome data values, and they may correspond to a change in value of a syndrome qubit measurement outcome between successive rounds of syndrome measurement.

[0095] The location of these defects in the decoding hypergraph acts as a (generally non-unique, in the sense that different error patterns can result in the same defect locations) signature of the underlying qubit errors (e.g., errors in the data and syndrome qubits). While the examples in the present disclosure will refer primarily to decoding graphs, it should be understood that any reference to a decoding graph also includes decoding hypergraphs unless explicitly stated otherwise. Decoding syndrome data using a decoding hypergraphgenerally involves grouping defects. Numerous graph-based decoding techniques are known, including minimum-weight-perfect-matching, union find and collision clustering. The decoding system 110 must satisfy two important speed criteria in order to enable useful fault-tolerant quantum computation. Firstly, real-time decoding requires that the decoding system 110 decodes the syndrome data at a rate that is at least as fast as the rate at which syndrome data is obtained. If the decoding system 110 cannot decode the syndrome data at the same rate at which it is obtained, this will lead to a backlog that scales exponentially with the length of the computation (see Terhal, B. M. “Quantum error correction for quantum memories”. Rev. Mod. Phys. 87, 307 (2015)). Secondly, the time between the decoding system 110 receiving syndrome data and providing a correction (i.e., the latency) must be low relative to the length of time that it takes to perform quantum operations in the quantum computing hardware 104. If the latency is orders of magnitude greater than the time taken to perform operations in the quantum computing hardware 104 (e.g., orders of magnitude greater than the time it takes to perform quantum gates) then the speed of the decoding system 110 will bottleneck the speed of the quantum computation, thereby limiting the capabilities of the quantum computing system 100 as a whole.

[0096] Parallel window techniques (Skoric, L., Browne, D.E., Barnes, K.M. et al. Parallel window decoding enables scalable fault tolerant quantum computation. Nat Commun 14, 7040 (2023). https: / / doi.org / 10.1038 / s41467-023-42482-1) have been proposed to address the first of these criteria. By splitting the decoding problem into chunks (known as decoding windows) that can be decoded in parallel, the backlog problem can be avoided. However, existing parallel window techniques have limitations. Firstly, these existing techniques require decoding to be performed in at least two stages (or passes), thereby increasing latency (in other words, the problem cannot be fully parallelised into a single stage with all decoding windows being decoded simultaneously). Secondly, existing techniques require decoding information (in particular, information about defects along boundaries between decoding graph regions) to be propagated between different decoding windows (i.e., some decoding windows are dependent upon the decoding results of other decoding windows), which introduces additional runtime data transfer requirements and increases latency (these techniques may require adding knowledge of commit and transfer regions to the decoder or require the decoder to output error mechanisms it thinks were active, thereby adding to the complexity of the design of the decoder). The present disclosure overcomes these problems by providing a parallel decoding method in which all decoding windows can be decoded simultaneously and no information needs to be passed between decoding windows (i.e., all decoding windows may be decoded independently), which in turn simplifies decoder design. In addition, unlike existing sliding window and parallel windowtechniques, the approach of the present disclosure can be used with non-matching type decoding algorithms.

[0097] Fig. 2a shows a decoding graph 200 for a QEC code. The illustrated decoding graph 200 may be associated with a simple QEC code in which quantum error correction is used to detect and correct errors affecting a single logical observable (e.g., a logical X observable or logical Z observable) associated with a single logical qubit (for example, a quantum memory experiment in which only a single logical observable is of interest). One skilled in the art will appreciate that decoding hypergraphs, especially those involving logical computation between multiple logical qubits, will generally be more complex than the illustrated decoding graph 200 and that the techniques described herein are equally applicable to more complex decoding graphs and hypergraphs (such as those associated with lattice surgery operations involving multiple logical qubits). The actual structure of the decoding hypergraph will depend upon factors including the QEC code being implemented, the QEC operation being performed, connectivity of the qubits 108 in the quantum computing hardware 104 etc.; some or all of this information may be transmitted to the decoding system 110 by the logical layer 102 before decoding is performed.

[0098] Edges of the decoding graph 200 correspond to error mechanisms on physical qubits (these error mechanisms may include measurement errors), and vertices (or nodes) of the decoding graph 200 correspond to QEC detectors, which are measurement results that sum to zero (e.g., modulo 2 sum) during perfect (error-free) operation of the quantum computing system. Edges may be weighted based on the likelihood (e.g., error probability) associated with the corresponding error mechanisms.

[0099] A plurality of defects 202 is shown on the decoding graph 200. The defects 202 provide a signature of the underlying error mechanisms that have occurred on the physical qubits, and the location of the defects 202 may be determined by the decoding system 110 from syndrome data received from the control system 106. In other words, the syndrome data provides the location of defects 202 in the decoding graph 200, possibly in encoded form. Each horizontal layer of the illustrated decoding graph 200 may be associated with syndrome data (and therefore defect locations) from a single QEC round (i.e. , a single round of stabiliser measurements / syndrome extraction), with time increasing in the vertically upwards direction. Defect locations for the lower layers may therefore be obtained before defect locations are obtains for the upper layers.

[0100] The function of the decoding system 110 is to find a correction that counteracts the effect of the underlying physical qubit errors. In general, this may be achieved by pairing / grouping defects 202 using a decoding algorithm such as minimum-weight-perfect-matching (MWPM) or clustering. The decoder may then output error and / or correction information.Error information may include decoding hypergraph hyperedges that have been identified when decoding the syndrome data (e.g., when matching the defects 202 on the decoding graph 200) and / or the error mechanisms associated with these hyperedges. Alternatively, error information may identify physical qubits affected by the error mechanisms associated with hyperedges identified when decoding the syndrome data. Correction information may include whether the state of the logical observable (e.g., the logical X or logical Z observable associated with the logical qubit) has been affected by the error state. A logical observable is affected by an error state if the value of that logical observable is changed (e.g., flipped) by the error state (as determined by the decoding system). In other words, a logical observable is affected by an error state if the decoding system determines that a logical error has occurred on the logical observable.

[0101] Fig. 2b shows a possible defect pairing when using a MWPM decoding algorithm. Edges identified by the decoding system 110 during the decoding process (referred to herein as correction edges 204) are highlighted with bold lines. MWPM pairs defects 202 in a way that minimises the overall total weight of the correction edges 204 between paired defects 202. Each defect 202 is either paired to another defect 202 or to an open boundary of the decoding graph 200; the open boundaries of the decoding graph 200 are shown at the left and right sides (the top and bottom are not boundaries in a graph sense). In the illustrated example, it is assumed that the edges have uniform weight (sometimes referred to as being unweighted).

[0102] Decoding a complete decoding hypergraph using a single decoder instance can be prohibitively slow, and it is generally desirable to start decoding before all syndrome data has been obtained (i.e., when only some defect locations are known). Several methods have been proposed in which a decoding graph is split into smaller decoding windows. The first of these is sliding window decoding, which is illustrated in Figs. 3a-d. Instead of decoding the complete decoding graph 200 in a single pass, the decoding graph 200 is split into four contiguous decoding regions w0, wltw2, w3. Each decoding region is a subset of the decoding graph. In sliding window decoding, the decoding regions are decoded in series in time order. However, in order to ensure reliable decoding, decoding regions are decoded with one decoding region as a “commit” region and the subsequent decoding region as a “buffer” window; the commit region and buffer region together form a decoding window. Fig. 3b shows a decoding window involving the first decoding region w0as a commit region and the second decoding region as a buffer region. Decoding is performed on the combination of the first and second decoding regions w0, w . However, because the locations of future defects are not considered by the decoding system 110 at this stage (for example, the syndrome data may not have been obtained), the correction edges 204 in thesecond decoding region w±may be unreliable (that is, there is a high probability that defects 202 in the second decoding region w could be paired to defects in a future decoding region if the decoding graph 200 were instead decoded in a single shot). The decoding system 110 therefore only commits to correction edges 204 in the first decoding region w0, and any correction edges 204 in the second decoding region

[0103]

[0104] are discarded.

[0105] The decoding graph 200 is then updated as shown in Fig. 3c. In particular, the correction edges 204 in the first decoding region w0are committed in the decoding graph 200, and the correction edges 204 in the second decoding region w are discarded. In order to ensure that the committed edges 204 are accounted for when decoding the second decoding region wlta new defect node 208 (referred to herein as an artificial defect node 208 to reflect that this defect is not part of the original syndrome data) is introduced at the boundary between the first decoding region w0and the second decoding region w where the committed correction edges 204 terminate at this boundary.

[0106] The decoding system 110 then proceeds to decode a new decoding window involving the second decoding region w in combination with third decoding region w2, as shown in Fig.

[0107] 3d, with the second decoding region

[0108]

[0109] now being the commit region and the third decoding region w2now being the buffer region. The artificial defect nodes 208 are treated the same way as any other defect nodes 202 when decoding the second decoding region w1. This process continues to ‘slide’ upwards (i.e. , in time) through the decoding graph 200 until all decoding regions have been decoded (the final decoding region will be decoded without a buffer because there is no further syndrome data). A correction can then be determined by combining the effects that the correction edges 204 from all committed decoding regions have upon the logical observable of interest.

[0110] The sliding window approach beneficially allows the decoding problem to be broken into smaller chunks by splitting the decoding graph 200 into decoding windows. In addition, splitting the decoding graph 200 into decoding windows allows the decoding process to begin while syndrome data is still being obtained (i.e., before the quantum computation is complete). However, the sliding window approach is still limited in that the decoding windows must be decoded sequentially, i.e., in time order. This prevents the decoding problem from being parallelised, and means that a backlog of syndrome data can build up if the decoding system 110 cannot decode the decoding windows faster than the syndrome data is collected.

[0111] Figs. 4a-d illustrate the parallel window approach, which addresses the backlog problem. As with the sliding window approach, the decoding graph 200 is split into separate decoding regions. Unlike the sliding window approach, the decoding regions do not need to be processed in strict time order.Decoding of the first decoding region w0in the parallel window approach is the same as in the sliding window approach. That is, the first decoding region w0is decoded using a decoding window with the first decoding region w0as a commit region and the second decoding region w as a buffer region. However, unlike the sliding window approach, decoding of the third decoding region w2can be performed before decoding of the first decoding region w0or second decoding region w has been completed. In other words, the third decoding region w2can be decoded in parallel with the first decoding region w0. For example, the first decoding region w0and the third decoding region w2may each be assigned to different decoder instances (e.g., different decoding units) and decoded in parallel.

[0112] When decoding the third decoding region w2, the second decoding region

[0113]

[0114] and fourth decoding region w3are both used as buffer regions in a decoding window as shown in Fig.

[0115] 4a, while the third decoding region w2is used as a commit region. This is unlike the sliding window technique, in which the third decoding region w2can only be decoded after the second decoding region

[0116]

[0117] has been decoded and is decoded with only the fourth decoding region w3as a buffer region (i.e. , a single buffer region rather than two buffer regions). When both the first decoding region w0and third decoding region w2have been decoded, there are two commit regions in the decoding graph 200. Correction edges 204 within the commit region are committed to the decoding graph 200, and correction edges 204 in the buffer regions are discarded. As with the sliding window technique, artificial defect nodes 208 are introduced at the boundaries between the commit regions and buffer regions to account for committed correction edges 204 that terminate at these boundaries, as shown in Fig. 4b.

[0118] The decoding system 110 can then proceed to decode the second decoding region

[0119]

[0120] and fourth decoding region w3. As the decoding regions adjacent to each of the second decoding region w and fourth decoding region w3have already been decoded, the second decoding region w and fourth decoding regions w3are decoded without any buffer regions as shown in Figs. 4c and 4d respectively (in other words, all correction edges 204 in Figs.

[0121] 4c and 4d resulting from decoding the second decoding regions w and fourth decoding regions w3are committed correction edges 204); this means that the second decoding region w and fourth decoding region w3are used as decoding windows without being combined with other decoding regions for this stage of the decoding process. This differs from the sliding window method (c.f. Figs. 3d and 4d, which show decoding of the third decoding region w2using the sliding window and parallel window approaches respectively), in which buffer regions are used when decoding all decoding regions except the finaldecoding region (because there is no further syndrome data to act as a buffer region for the final decoding window).

[0122] As with the sliding window technique, once all decoding windows have been decoded using the parallel window technique, a correction can be determined by combining the effect of the correction edges 204 from all decoding regions upon the logical observable of interest. While the parallel window technique addresses the backlog problem, both the parallel window and sliding window techniques require information about the artificial defect nodes 208 to be communicated between different decoding windows, which is generally achieved by passing messages between different decoder instances (e.g., between decoding units responsible for decoding different decoding windows). In other words, if a decoding region is adjacent to another decoding region with committed correction edges 204 (i.e. , another decoding region that has already been a commit region in a decoding window), that decoding region can only be decoded once the decoder instance decoding that decoding region has received details of any artificial defect nodes 208 at the boundary of that decoding region. Passing information about the artificial defect nodes 208 between different decoder instances increases overheads (and therefore latency) and also requires that the decoding windows are decoded in at least two rounds: adjacent decoding regions cannot be decoded in parallel, because one of these decoding regions will always be dependent upon the decoding outcome of the other. In addition, creation of the artificial defects requires additional decoder logic to extract the artificial defects and combine them with the buffer region syndrome data and new incoming syndrome data. This is especially complicated when performing lattice surgery QEC operations where there are both spatial and time-like data dependencies, and it is unclear how to design modules to ubiquitously handle the passing of artificial defects without large look-up tables.

[0123] The methods and systems of the present disclosure address these limitations by providing a decoding technique which is fully parallelisable, with each decoding window decoded independently of all others (that is, the decoding outcome of one decoding window does not depend upon the decoding outcome of any other decoding window).

[0124] Fig. 5a shows the decoding graph 200 overlaid with a logical observable I. When performing quantum error correction, each logical qubit will have at least one logical observable of interest, which is a logical operator that can be measured to give a logical outcome. Measurement of logical observables is generally performed by combining measurement outcomes from a subset of the physical qubits used to encode the logical qubit. In the case of surface codes, the most common logical observables are the logical X and logical Z observables.The illustrated logical observable I is associated with a plurality of decoding graph edges, i.e. , the edges intersected by the logical observable I in Fig. 5a. The edges associated with the logical observable I (referred to herein as logical observable edges) are edges associated with error mechanisms that affect the state of the logical observable I. In other words, an edge is a logical observable edge of (i.e. is associated with) a given logical observable if (and only if) occurrence of the error mechanism associated with that edge affects (e.g., flips) the value of the logical observable.

[0125] In general, logical observables are not unique. For example, a logical observable might be modified by combining it with a stabiliser operator to produce an equivalent logical observable that is measured using a different set of physical qubits - in this case the error mechanisms (and therefore edges) associated with a logical observable could be likewise redefined. However, these logical observables are equivalent (that is, all will give the same measurement outcome in the absence of errors), so the logical observable can be chosen arbitrarily. In this case, the logical observable I is chosen to be the logical observable associated with the decoding graph edges on the left-most side of the decoding graph 200. One skilled in the art will appreciate that the choice of logical observable will depend upon the QEC code being implemented and the quantum computation being performed.

[0126] As shown in Fig 5b, the logical observable I can be divided into logical observable subsets l0-l3(which may also be referred to as logical observable partitions or logical observable parts) each associated with a subset of the logical observable edges. As will be described with reference to Figs. 5c-5f, the syndrome data can then be decoded by decoding each of the logical observable subsets l0-l3independently. Once each logical observable subset has been independently decoded, the aggregate correction to the logical observable is determined by combining the partial corrections of each of the logical observable subsets lo'h- Fig. 5c illustrates a decoding window that can be used to decode a first logical observable subset l0. Rather than using separate buffer and commit regions, the first logical observable l0is instead decoded using a decoding window that includes all decoding graph edges within a distance d surrounding the first logical observable subset l0, where d is the code distance of the logical qubit (or logical qubits) associated with the logical observable. As one skilled in the art will appreciate, code distance is a term of the art and describes the minimum weight error that can go undetected by the code.

[0127] One skilled in the art will appreciate that decoding can still be performed if some edges within distance d of the first logical observable subset l0are excluded, but this will effectively reduce the code distance of the logical qubit (in other words, the code distance would become equal to the distance for which all decoding graph edges surrounding the firstlogical observable subset l0are included). The decoding window for the first logical observable l0can be decoded using a decoding algorithm such as MWPM or clustering. Example correction edges 204 are shown in Fig. 5c. The correction to the first logical observable subset l0can be determined by determining the effect that these correction edges 204 have upon the first logical observable subset l0. In the illustrated example there is a single correction edge 204 associated with the first logical observable Zo; this means that the correction edges 204 do affect (e.g., flip) the first logical observable subset l0. Decoding the decoding window associated with the first logical observable subset l0therefore provides a partial correction indicating that the first logical observable subset l0is affected by the error state.

[0128] Independent decoding can be performed for each of the other logical observable subsets l -l3as shown in Figs. 5d-f respectively. Each logical observable subset is preferably decoded using a decoding window that includes at least all decoding graph edges within a distance d surrounding that logical observable subset (as discussed above, decoding is still possible if only decoding graph edges within a smaller distance than d are used, but doing so will effectively reduce the code distance), and the effect upon each logical observable subset is determined. For example, in Fig. 5d, two logical observable edges are identified as correction edges 204 when decoding the second logical observable subset l . However, a single error mechanism has the effect of flipping the logical observable (e.g., changing the outcome from +1 to -1 or vice-versa), so the two correction edges 204 in Fig. 5d will cancel each other (i.e. , the corrections are self-inverting) and have no net effect upon the second logical observable subset l . Decoding the decoding window associated with the second logical observable subset

[0129]

[0130] therefore provides a partial correction indicating that the second logical observable subset is not affected by the error state.

[0131] Continuing with Figs. 5e and 5f, the third logical observable subset l2is unaffected by the correction edges 204 in Fig. 5e, whereas the four logical observable subset l3is affected by a single correction edge 204 as shown in Fig. 5f. Decoding the decoding windows associated with the third logical observable subset l2and fourth logical observable subset l3therefore provides respective partial corrections indicating that the third logical observable subset l2is not affected by the error state and that the fourth logical observable subset l3is affected by the error state.

[0132] In order to determine the net effect of the correction edges 204 upon the logical observable I, the partial corrections for the decoding windows associated with the logical observable subsets l0-l3are combined, e.g., using an XOR operation to determine a parity of the partial corrections. In this case, the partial corrections indicate that the first logical observable subset l0and fourth logical observable subset l3are each affected by the correction edges204, and that the second logical observable subset l±and third logical observable subset l2are unaffected. An even number of subsets is affected, so the effects are once again cancelled, meaning that the correction has no net effect upon value of the logical observable (in other words, the aggregate correction indicates that the logical observable is not affected by the error state, as determined by the decoding system). This means that the decoding system has determined that no adjustments need to be applied to the measured value of the logical observable I for the observed syndrome data.

[0133] Unlike the sliding window and parallel decoding window techniques, no information (e.g., no information about artificial defects) needs to be passed between decoding windows using the approach in Figs. 5a-f: the effect upon the logical observable is determined by aggregating the corrections from the logical observable subsets Zo-Z3without the need to determine artificial defect nodes. Each decoding window is decoded independently of the others. That is, every decoding window is decoded without requiring information about the decoding outcome of an adjacent window (or any other decoding window). This advantageously means that the decoding windows can be decoded in any order (thereby reducing latency compared to the sliding window and parallel window techniques, which require at least two iterations of decoding) and without passing information between decoding windows (which reduces data processing overheads, thereby further improving latency and reducing decoder hardware requirements).

[0134] In addition, existing hardware decoders are not well-suited to passing information about artificial defects between different decoding units when using higher-degree decoding hypergraphs (e.g., with hyperedges connecting more than two nodes) because of hardware connectivity limitations. In contrast, the independent window technique disclosed herein can be implemented on existing hardware decoders with higher-degree decoding hypergraphs because it does not passing of information about artificial defects between different decoding units.

[0135] As explained above, each logical observable subset is preferably decoded using a decoding window that includes at least all decoding hypergraph hyperedges within a distance d. Including all decoding hypergraph hyperedges within a distance d of each logical observable subset ensures that each window includes enough hyperedges to determine the effect on that logical observable subset. Including additional hyperedges (i.e., beyond distance d) will generally have negligible impact upon logical error rates, but it may increase the time required to decode each decoding window. The decoding windows shown in Figs.

[0136] 5c-f could therefore be reduced in size by removing some edges from the decoding windows that are beyond distance d. Fig. 6 shows an example of a decoding window that could beused to decode the second logical observable subset l±instead of the decoding window shown in Fig. 5d.

[0137] The code distance of the QEC code for the illustrated decoding graph 200 is d = 7 (a chain of errors spanning from one side of the decoding graph 200 to the other would be undetectable and would require at least seven decoding graph edges). The hatched regions 600 of Fig. 6 are beyond distance d = 7 from the second logical observable subset lltso edges and nodes within these regions can be excluded from the decoding window. This advantageously improves decoding speed because the size of the decoding window and the number of defect nodes 202 in the decoding window are both reduced (because any defect 202 nodes in the hatched regions 600 do not need to be considered when decoding for the second logical observable subset l ). While these hatched regions 600 are excluded from the decoding window used to decode the second logical observable subset lltthese regions will be included in the decoding windows for the first logical observable subset l0and third logical observable subset Z2.

[0138] One skilled in the art will appreciate that other alternative windowings are also possible. For example, the first two logical observable subsets and last two logical observable subsets could each be combined into a single logical observable subset, which advantageously allows all decoding windows to be the same size when decoding quantum memory operations.

[0139] In order to minimise logical error rates, the decoding windows are preferably decoded consistently. Consistent decoding means that defects in overlapping sections of adjacent decoding windows are decoded such that they affect the same logical observable subset in each of the adjacent decoding windows. In the case of MWPM, this means that a given defect should only be involved in a correction connected to at most a single logical observable subset across all decoding windows (and if a defect is connected to a logical observable subset in one window then it should connect to the same logical observable subset in other windows). In the case of clustering algorithms, this means that a given defect should only be in a cluster that touches at most a single logical observable subset across all decoding windows.

[0140] Inconsistent decoding could lead to two different correction operations being proposed for the same defect or group of defects. If this occurs close to the logical observable, there is a risk that the different correction operations associated with the same defect or group of defects could affect multiple logical observable subsets (and therefore cancel each other) or affect no logical observable subsets (and therefore be missed when aggregating the effect upon the logical observable).One skilled in the art will appreciate that there are numerous ways to ensure consistent decoding. Some decoding techniques, including those that use weighted decoding hypergraphs, are intrinsically consistent. Unweighted decoding techniques may be adapted to introduce bias and break symmetry between time-like and space-like hyperedges of the decoding hypergraph (e.g., by adding different weights to time-like and space-like edges or by introducing total or partial orderings over edges). Alternatively, consistent decoding can be achieved by using an ordering over logical observable subsets to resolve any ambiguities. For example, decoder instances may decode with respect to each logical observable subset to obtain a correction. If ambiguity arises (e.g., if the correction affects two logical observable subsets in a clustering decoding algorithm), the decoder may assume that the error happened on the logical observable subset that is lowest in the ordering and assign the correction to that logical observable subset (e.g., when a cluster touches two logical observable subsets, this cluster may be associated only with the logical observable subset having the lowest ordering). Such an approach may require that the logical observable subsets from adjacent windows are identified in each decoding window so that the decoder can determine when a correction (e.g., cluster) affects two logical observable subsets. As long as all relevant decoding windows use the same ordering over logical observable subsets, this will ensure decoder consistency.

[0141] Fig. 7 shows an example of a process diagram for an error correction procedure according to the present disclosure, e.g., when implementing the independent window decoding technique described above in relation to Figs. 5a-f and Fig. 6. In a first stage 701 of the process, syndrome data is extracted. This stage may be performed as described above, e.g., the control system 106 may perform stabiliser measurement operations on the qubits 108 to obtain stabiliser measurement values. These values may be used as the syndrome data, or they may be pre-processed (e.g., by taking an XOR with stabiliser measurement values from the preceding round of stabiliser measurement) before being transmitted to the decoding system 110. The syndrome extraction may involve multiple rounds of stabiliser measurement, and the syndrome data may be sent in chunks (e.g., syndrome data for one or more complete rounds of stabiliser measurement may be sent together) or it may be continuously streamed (e.g., syndrome data values may be transmitted in a continuous flow as soon as they are obtained). In the case where the syndrome data comprises raw readout data, the decoding system 110 may process the syndrome data upon receipt, e.g., by performing quantum state discrimination to determine syndrome values associated with each syndrome qubit / stabiliser measurement.

[0142] In a second stage 702, the syndrome data is distributed to multiple decoder instances. The decoder instances may be separate hardware decoding units, separate instantiations of software decoders, or a combination of the two (e.g., multiple decoding instances on thesame decoding unit). Distributing the syndrome data to multiple decoder instances may involve identifying defects in the syndrome data and transmitting defect information to the decoder instances associated with decoding windows in which those defects are located, possibly in the form of decoding window data with defect nodes marked (e.g., the syndrome data may be processed by the decoding system 110 before being distributed to the decoder instances), or the syndrome data may be distributed to the decoder instances as a subset of the unprocessed raw syndrome data received from the control system 106. Each decoder instance will receive syndrome data for the decoding window(s) that it is responsible for decoding (a single decoder instance may be responsible for decoding multiple decoding windows). In alternative arrangements, the same decoder instance may be used to decode all decoding windows sequentially (e.g., where the decoding instance is fast enough to decode syndrome data in realtime without the creation of a backlog). While the benefits of the independent window decoding technique disclosed herein are most substantial when using multiple decoder instances, benefits such as reduced latency still occur when using a single decoder instance because there is no need to identify artificial defects at the boundaries between decoding regions (these artificial defects must always be identified when using the sliding window and parallel window approaches, even when using a single decoder instance).

[0143] In a third stage 703, each decoder instance performs independent decoding on the decoding window(s) for which it is responsible. As described above, each decoding window is associated with a logical observable subset, and the decoding windows overlap to ensure that hyperedges or nodes associated with the logical observable subset are sufficiently far from decoding window boundaries. As described above, independent decoding means that the decoding outcome of each decoding window does not depend upon the decoding outcome of any other decoding window. In other words, all decoding windows can be decoded without requiring information about the decoding outcome of any other decoding window (or information derived therefrom). For example, there is no need to share information about artificial defects between decoding windows, unlike in the sliding window and parallel window decoding techniques. This allows adjacent decoding windows (that is, decoding windows associated with adjacent logical observable subsets) to be decoded in parallel in a single iteration (i.e., the decoding can be completely parallelised so that all decoding windows can be decoded in parallel with each other: adjacent decoding windows can be decoded in parallel as soon as syndrome data forthose windows is available), which is not possible with sliding window or parallel window techniques (parallel window requires at least two rounds of decoding and must wait for commit regions to be decoded before buffer regions can be decoded).In a fourth stage 704, the outputs (e.g., partial corrections) from the multiple decoding windows (e.g., from each of the decoder instances) are combined to give a running correction for the logical observable(s) of interest. For example, each decoder instance may output a partial correction for each logical observable subset in the decoding window(s) that it decodes. The value of the partial correction for a given decoding window may be given by the parity of the number of the number of hyperedges / nodes in the logical observable subset associated with that decoding window that are included in the correction identified by the decoder, or by the parity of defects in clusters that touch hyperedges / nodes in the logical observable subset associated with that decoding window. The partial corrections for a given logical observable subset may be combined (e.g., by XORing all outcomes) to give an aggregate correction forthat logical observable (e.g., the parity of the partial corrections). If an existing correction exists for a logical observable (e.g. from earlier rounds of QEC), the value of the existing correction may be XORed with the new partial corrections to give a running value (e.g., running parity value) for the logical state correction. Outputs may be continuously aggregated by calculating an XOR value of the current logical observable correction state and the partial correction from decoding the most recent decoding window. Fig. 8 shows a flowchart of an error correction method according to the present disclosure, e.g., an error correction method using the independent window decoding technique described in relation to Figs. 5a-f, 6 and 7. The method shown in Fig. 8 may be performed by one or more classical processing components (that is, computing components that use classical processors) of a quantum computing system, such as the quantum computing system 100 shown in Fig. 1. For example, the steps may be performed by the decoding system 110 of the quantum computing system 100. Alternatively, the steps may optionally be distributed between different components of the quantum computing system 100. For example, some steps (e.g., step 806) may be performed by the control system 106, and others may be performed by the decoding system 110 and / or other components of the quantum computing system 100 (including components not described herein or illustrated in Fig. 1). One skilled in the art will recognise that it is not necessary that any particular component of the quantum computing system 100 performs the method shown in Fig. 8, and that the technical effects arising by the invention will occur regardless of which component(s) of the quantum computing system 100 the method is performed by.

[0144] In a first step 801, syndrome data is received (e.g., at the decoding system 110) representative of an error state of quantum devices (e.g., physical qubits 108) in the quantum computing system 100. The defects provide a signature of the error state of the physical qubits 108. The defects may be encoded in the syndrome data (that is, the syndrome data may need to be processed by the decoding system 110 to identify the defects, e.g., by XORing syndrome data from successive rounds of syndromemeasurement). The syndrome data may be provided in various formats. For example, the syndrome data may be provided as a bitstring where each bit is associated with a single node of the decoding hypergraph, where a one value may indicate that a node is a defect node and a zero value may indicate that a node is not a defect node (or vice-versa). The syndrome data may include other information, such as soft information providing a likelihood / probability associated with each defect node (e.g., a probability that each node is a defect node). The syndrome data may comprise raw readout data from physical qubit readout (e.g., from readout of syndrome qubits). In the case where the syndrome data comprises raw readout data, the decoding system 110 may process the syndrome data upon receipt, e.g., by performing quantum state discrimination to determine syndrome values associated with each syndrome qubit / stabiliser measurement. In some examples, the decoding system 110 may use probability values to determine which nodes are defect nodes based on a threshold. Alternatively, setting defect states in the decoding hypergraph may comprise setting a probability value associated with each defect node (e.g., probability values for nodes may be set to probability values given in the syndrome data, optionally where any node having a probability above a threshold probability value may be considered a defect node).

[0145] The syndrome data may be received from the control system 106. For example, the syndrome data may be generated from qubit measurement data received at the control system 106, and this qubit measurement data may be obtained from stabiliser measurement operations performed on the qubits 108. The stabiliser measurement operations may be performed on the qubits 108 using control signals generated by the control system 106. In other words, the control system 106 may perform the stabiliser measurement operations on the qubits 108 (in the sense that the control system 106 generates control signals that effect the stabiliser measurement operations on the qubits 108).

[0146] In a second step 802, defect states of nodes in the decoding hypergraph are set (e.g., by the decoding system 110) according to the syndrome data. This may involve determining which nodes are identified as defect nodes in the syndrome data and setting the defect states of those nodes accordingly in the decoding hypergraph, for example by setting a defect flag in the decoding hypergraph for each node identified as a defect node in the syndrome data. This step may be performed on the complete decoding hypergraph, e.g., by a central decoding unit or orchestration unit of the decoding system 110. Alternatively, defect states of nodes in the decoding hypergraph may be set by each decoding instance (e.g., by separate decoding units of the decoding system 110) for the decoding window(s) associated with that decoding instance (in this case step 802 may be performed after step 803 and / or step 804, and a central decoding unit or orchestration unit of the decodingsystem 110 may distribute syndrome data to the decoder instances of the decoding system 110 for the decoder instances to set the defect states).

[0147] In a third step 803, a plurality of elements of the decoding hypergraph my be identified (e.g., by the decoding system 110) that are associated with a logical observable. As described above, a logical observable is a logical operator of the QEC code that can be measured to give a logical outcome. An element of the decoding hypergraph is associated with a logical observable if occurrence of an error mechanism associated with that element (e.g., the error mechanism of the hyperedge itself if the element is a hyperedge, or the error mechanism of a hyperedge connected to the node if the element is a node) affects (e.g., flips) the value of the logical observable.

[0148] When identifying the plurality of elements of the decoding hypergraph that are associated with the logical observable, the decoding system 110 (or other component performing this step) may receive a definition of the logical observable (e.g., as a list of physical qubit measurements that make up the logical observable) and may determine which hypergraph elements (e.g., hyperedges or nodes) are associated with this definition (e.g., hyperedges representing error mechanisms associated with physical qubits making up the logical observable).

[0149] The elements of the decoding hypergraph that are associated with the logical observable (which may also be referred to herein as logical observable elements) may be nodes or hyperedges of the decoding hypergraph. For example, in Fig. 5a all logical observable elements of the logical observable I are edges. However, as each of these logical observable edges connects only to a single node and each logical observable edge connects to a different node, the logical observable I could alternatively and equivalently be described by the nodes to which these logical observable edges are connected. Therefore, while in a strict mathematical sense logical observables may be associated with hyperedges of the decoding hypergraph, one skilled in the art will appreciate that they may also be defined in terms of decoding hypergraph nodes without loss of generality.

[0150] In general, a given QEC code may have multiple logical observables (there may be multiple logical qubits encoded in a QEC code, and each of these may have more than one associated logical observable). Only a subset of the logical observables may be of interest, so it suffices only to track the correction state of the logical observables of interest (referred to herein as reference logical observables). One skilled in the art will recognise that the present disclosure can be readily extended to multiple logical observables by identifying different sets of logical observable elements (these sets may may overlap), each set associated with a different logical observable.In a fourth step 804, a plurality of decoding windows is determined (e.g., by the decoding system 110). A decoding window is a subset of a decoding hypergraph. Each decoding window is associated with a logical observable subset of a plurality of logical observable subsets. Each logical observable subset comprises a subset of the plurality of elements of the decoding hypergraph associated with the logical observable. When there are multiple reference logical observables, each decoding window may be associated with multiple respective logical observable subsets, with each respective logical observable subset in a decoding window comprising a respective subset of logical observable elements of a respective reference logical observable. Alternatively, different reference logical observables may be decoded separately; that is steps 803 onwards may be performed separately for each reference logical observable. Each decoding window contains the logical observable elements of its associated logical observable subset and a surrounding region of the decoding hypergraph. The surrounding region of the decoding hypergraph preferably includes at least all decoding hypergraph elements (hyperedges and nodes) within distance d of the logical observable elements of the associated logical observable subset (where d is the QEC code distance discussed above, and the distance from a given decoding hypergraph element to a given logical observable element is the number of hyperedges in the shortest path between that decoding hypergraph element and that logical observable element). In other words, each decoding window comprises all decoding hypergraph elements within a predetermined distance of the elements in the logical observable subset associated with that decoding window, wherein the predetermined distance is based on a code distance of the quantum error correction code. The predetermined distance is based on the code distance in the sense that it may be equal to the code distance or a function of code distance (e.g., it may be proportional to the code distance or equal to the code distance plus or minus some predetermined value).

[0151] The size of the decoding windows may be varied dependent upon the number of elements in the logical observable subsets. The logical observable subsets may all contain the same number of elements, or they may contain differing numbers of elements. Increasing the number of elements in the logical observable subsets will increase the time required to decode each decoding window (because the decoding windows will be larger), whereas reducing the size of the logical observable subsets will increase the required number of decoding windows (thereby increasing the number of decoder instances required to decode in parallel). One skilled in the art will therefore choose the size of the logical observable subsets according to available computing resources (e.g., based on the number of decoding units available and required decoding latency).

[0152] Determining the plurality of decoding windows may comprise partitioning the logical observable into the logical observable subsets. The logical observable may be partitionedinto non-overlapping subsets (that is, each logical observable element may be included in only one subset). The union of all the logical observable subsets preferably contains all elements associated with the logical observable. Each logical observable subset may be contiguous (that is, neighbouring / next to each other / adjacent in the decoding hypergraph). Using non-overlapping subsets ensures that corrections are not double counted in the aggregate correction. Using contiguous subsets reduces the size of the decoding windows compared to non-contiguous subsets because the number of hyperedges within the predetermined distance of contiguous elements in a logical observable subset is smaller, and also reduces the number of boundaries between different logical observable subsets (and in turn reduces the number of decoding regions where decoding could fail due to inconsistent decoding).

[0153] In step 805, the plurality of decoding windows are independently decoded (e.g., by the decoding system 110) to determine a corresponding plurality of partial corrections. That is, the decoding windows may be decoded by one or more decoder instances to determine respective partial corrections. A decoder instance is an occurrence of a decoder and may be realised using a dedicated hardware decoding unit or may be a software decoder. A decoder instance may be responsible for a single decoding window (e.g., a new decoder instance may be instantiated for each decoding window) or may process multiple decoding windows (e.g., decoding multiple decoding windows sequentially without being reinstantiated between decoding different decoding windows).

[0154] In some arrangements, a single decoder instance may decode all decoding windows sequentially. In other arrangements, each decoding window may be associated with a separate decoder instance (e.g., one decoder instance for each decoding window). In other arrangements, one or more decoder instances may be associated with (responsible for decoding) multiple decoding windows. At least some of the decoder instances may optionally be implemented on different decoding units of the decoding system 110, and / or one or more of the decoder instances may be separate decoding instances implemented on the same decoding unit of the decoding system 110. The partial correction may be a single bit indicating the parity of errors affecting elements of the logical observable subset for the respective decoding window. Each partial correction may optionally comprise information such as a confidence / probability value indicating how confident the decoding system 110 (or other component performing this step) is that the partial correction is correct. In step 806, the partial corrections are combined (e.g., by the decoding system 110 or by the control system 106) to determine an aggregate correction for the error state. In some examples, the partial corrections may be combined using an XOR operation to provide a parity of the partial corrections. Using an XOR operation to combine partial correctionswithout passing additional correction information between windows is simpler (and therefore faster, i.e., lower latency) than existing windowing techniques, which instead require all correction information from every decoding window be combined (e.g., by combining all clusters or all correction edges from all correction edges to determine a complete correction for the entire decoding hypergraph). The partial corrections are preferably combined by the decoding system 110, although they may alternatively be transmitted to a different component of the quantum computing system, such as the control system 106. The aggregate correction may be a single bit indicating whether the logical observable is in a correct state (e.g., measurement of the logical observable would yield the correct logical outcome) or an incorrect state (e.g., measurement of the logical observable would yield an incorrect outcome, which should therefore be corrected, e.g., by flipping the observed value). The aggregate correction may optionally comprise information such as a confidence value / probability indicating how confident the decoding system 110 (or other system performing this step) is that the aggregate correction is correct. While the present disclosure refers to partial corrections and aggregate corrections, these terms may alternatively be referred to as partial errors and aggregate errors respectively - one skilled in the art will appreciate that the output from the decoding system 110 could considered a correction or an error in the sense that both represent the information required to correct the error state of the quantum devices (e.g., qubits).

[0155] The method of Fig. 8 may optionally further comprise obtaining a logical readout value for the logical observable (e.g., by receiving readout data from readout operations performed on a plurality of the quantum devices) and applying the aggregate correction to the logical readout value to determine a corrected logical readout value. For example, the control system 106 may instruct the logical readout on the quantum devices (e.g., qubits 108) to obtain the logical readout value. The aggregate correction may then be applied to the logical readout value by the control system 106 (for example, the decoding system 110 may transmit the aggregate correction to the control system 106), by the decoding system 110 (for example, the control system 106 may transmit the logical readout value to the decoding system 110) or by some other component of the quantum computing system 100, such as a device operating at the algorithmic / application layer of the quantum stack (the control system 106 and decoding system 110 may transmit the logical readout value and the aggregate correction respectively to the other component). In the case where the decoding system 110 applies the corrected state, the decoding system 110 may either receive an explicit uncorrected logical readout value (e.g., from the control system 106), or the logical readout value may be encoded in the syndrome data (for example, a final round of syndrome data may include readout values from data qubit measurements, in which case the decoding system 110 can use these to determine a logical readout value). The decodingsystem 110 may then return the corrected logical readout value (e.g., by sending it to the control system 106 or some other component of the quantum computing system 100). As discussed above, the techniques disclosed herein (i.e., the independent window decoding technique described in relation to Figs. 5a-f and 6-8) provide numerous benefits over existing approaches such as sliding window and parallel window decoding. By associating the logical observable subsets with different decoding windows, each window can be decoded independently, and effects on the logical observable subsets can be combined to give an aggregate correction for the error state without the need to determine artificial defects at decoding window boundaries and propagate data between different decoding windows (every decoding window is decoded without receiving decoding outcome data from any other decoding window, unlike in existing techniques). In addition, due to the lack of artificial defects, the independent window decoding technique can be used with a wide variety of existing decoding algorithms with little or no modification. Furthermore, decoding the decoding windows independently means that decoding can be performed in a single shot because adjacent windows can be completely decoded in parallel, unlike in parallel window where buffer regions (in which decoding is not performed completely) need to be used between commit regions.

[0156] The present disclosure may be used with any quantum error correction code that utilises a decoding hypergraph (e.g., a decoding graph), such as a surface code (e.g., planar surface code) or other topological quantum error correction code. 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 can be used with any suitable decoding method that utilises a decoding hypergraph. Examples of suitable decoding algorithms include minimum-weight perfect matching (MWPM), and clustering algorithms including collision clustering and union find algorithms.

[0157] Data representing graphs, hypergraphs, edges, edge weights, and other objects described herein may be stored in any suitable way. The illustrative objects shown in the figures are not intended to limit data structures that store such objects and / or data relating to such objects to any particular form.

[0158] Pauli X, Y and Z operations may be referred to herein simply as X, Y and Z operations. Any method described herein may be provided as a computer program product and / or on one or more computer readable media, such as on one or more non-transitory computer readable media.

[0159] 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 indicatedotherwise or technically infeasible, method steps disclosed herein may be performed in alternative orders, and any order described herein should be considered as illustrative rather than limiting. The illustrated steps and components could be split into multiple sub-steps / subcomponents.

[0160] Aspects of the above-disclosure can be implemented in any of numerous ways. For example, aspects of the disclosure may be implemented using hardware, software, or a combination thereof. When implemented in software, the software code can be executed on any suitable processor or collection of processors, whether provided in a single computer or distributed among multiple computers. Such processors may be implemented as integrated circuits, with one or more processors in an integrated circuit component, including commercially available integrated circuit components known in the art by names such as CPU chips, GPU chips, microprocessor, microcontroller, or co-processor. Alternatively, a processor may be implemented in custom circuitry, such as an ASIC, or semi-custom circuitry resulting from configuring a programmable logic device. As yet a further alternative, a processor may be a portion of a larger circuit or semiconductor device, whether commercially available, semi-custom or custom. As a specific example, some commercially available microprocessors have multiple cores such that one or a subset of those cores may constitute a processor. Though, a processor may be implemented using circuitry in any suitable format.

[0161] 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.

[0162] Use of ordinal terms such as “first,” “second,” “third,” etc., in the claims to modify a claim element does not by itself connote any priority, precedence, or order of one claim element over another or the temporal order in which acts of a method are performed, but are used merely as labels to distinguish one claim element having a certain name from another element having a same name (but for use of the ordinal term).

[0163] Also, the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. The use of “including,” “comprising,” or “having,” “containing,” “involving,” and variations thereof herein, is meant to encompass the items listed thereafter and equivalents thereof as well as additional items.

Claims

CLAIMS1. A quantum error correction method comprising:receiving syndrome data representative of an error state of quantum devices in a quantum computing system, the syndrome data identifying a plurality of defects, each defect associated with a respective node in a decoding hypergraph;setting defect states of nodes in the decoding hypergraph according to the plurality of defects identified in syndrome data;identifying a plurality of elements of the decoding hypergraph associated with a logical observable of a quantum error correction code;determining a plurality of decoding windows of the decoding hypergraph, wherein each decoding window of the plurality of decoding windows is associated with a logical observable subset of a plurality of logical observable subsets, each of the plurality of logical observable subsets comprising a subset of the plurality of elements of the decoding hypergraph associated with the logical observable;independently decoding the plurality of decoding windows to determine a corresponding plurality of partial corrections; andcombining the partial corrections to determine an aggregate correction for the error state.

2. The method of claim 1, wherein a partial correction for a given decoding window comprises an indication of whether the logical observable subset associated with the given decoding window is affected by the error state.

3. The method of claim 2, wherein the indication of whether the logical observable subset associated with the given decoding window is affected by the error state comprises a probability that the logical observable subset associated with the given decoding window is affected by the error state.

4. The method of any preceding claim, wherein the aggregate correction comprises an indication of whether the logical observable is affected by the error state.

5. The method of claim 4, wherein the indication of whether the logical observable is affected by the error state comprises a probability that the logical observable is affected by the error state.

6. The method of claim 5 when dependent upon claim 3, wherein combining the partial corrections comprises combining probabilities that each given decoding window is affected by the error state to determine the probability that the logical observable is affected by the error state.

7. The method of any preceding claim, wherein combining the partial corrections comprises determining a parity of the partial corrections, and wherein the aggregate correction comprises the parity of the partial corrections.

8. The method of any preceding claim, further comprising maintaining a running aggregate correction state, wherein combining the partial corrections comprises combining the partial corrections with the running aggregate correction state.

9. The method of any preceding claim, wherein at least two adjacent decoding windows are decoded in parallel by separate decoder instances.

10. The method of any preceding claim, wherein each decoding window comprises all decoding hypergraph elements within a predetermined distance of the elements in the logical observable subset associated with that decoding window, wherein the predetermined distance is based on a code distance of the quantum error correction code.

11. The method of any preceding claim, wherein each logical observable subset comprises a contiguous subset of the plurality of elements of the decoding hypergraph associated with the logical observable.

12. The method of any preceding claim, wherein the logical observable subsets are nonoverlapping.

13. The method of any preceding claim, wherein determining the plurality of decoding windows comprises partitioning the logical observable into the logical observable subsets.

14. The method of any preceding claim, wherein independently decoding the plurality of decoding windows comprises decoding the plurality of decoding windows consistently such that defects in overlapping sections of adjacent decoding windows are decoded such that they affect the same logical observable subset in each of the adjacent decoding windows.

15. The method of any preceding claim, further comprising:obtaining a logical readout value for the logical observable; andapplying the aggregate correction to the logical readout value.

16. The method of any preceding claim, wherein independently decoding the plurality of decoding windows comprises independently decoding the plurality of decoding windows using a plurality of decoder instances, and wherein the method further comprises distributing subsets of syndrome data to the plurality of decoder instances.

17. A quantum computing system comprising:a plurality of quantum devices; andone or more classical processing components configured to:receive syndrome data representative of an error state of the quantum devices, the syndrome data identifying a plurality of defects, each defect associated with a respective node in a decoding hypergraph;set defect states of nodes in the decoding hypergraph according to the plurality of defects identified in syndrome data;identify a plurality of elements of the decoding hypergraph associated with a logical observable of a quantum error correction code;determine a plurality of decoding windows of the decoding hypergraph, wherein each decoding window of the plurality of decoding windows is associated with a logical observable subset of a plurality of logical observable subsets, each of the plurality of logical observable subsets comprising a subset of the plurality of elements of the decoding hypergraph associated with the logical observable; independently decode the plurality of decoding windows to determine a corresponding plurality of partial corrections; andcombine the partial corrections to determine an aggregate correction for the error state.

18. The quantum computing system of claim 17, wherein a partial correction for a given decoding window comprises an indication of whether the logical observable subset associated with the given decoding window is affected by the error state.

19. The quantum computing system of claim 17 or claim 18, wherein the indication of whether the logical observable subset associated with the given decoding window is affected by the error state comprises a probability that the logical observable subset associated with the given decoding window is affected by the error state.

20. The quantum computing system of any of claims 17 to 19, wherein the aggregate correction comprises an indication of whether the logical observable is affected by the error state.

21. The quantum computing system of claim 20, wherein the indication of whether the logical observable is affected by the error state comprises a probability that the logical observable is affected by the error state.

22. The quantum computing system of claim 21 when dependent upon claim 19, wherein combining the partial corrections comprises combining probabilities that each given decoding window is affected by the error state to determine the probability that the logical observable is affected by the error state.

23. The quantum computing system of any of claims 17 to 22, wherein combining the partial corrections comprises determining a parity of the partial corrections, and wherein the aggregate correction comprises the parity of the partial corrections.

24. The quantum computing system of any of claims 17 to 23, the one or more classical processing components being further configured to maintain a running aggregate correction state, wherein combining the partial corrections comprises combining the partial corrections with the running aggregate correction state.

25. The quantum computing system of any of claims 17 to 24, wherein at least two adjacent decoding windows are decoded in parallel by separate decoder instances.

26. The quantum computing system of any of claims 17 to 25, wherein each decoding window comprises all decoding hypergraph elements within a predetermined distance of the elements in the logical observable subset associated with that decoding window, wherein the predetermined distance is based on a code distance of the quantum error correction code.

27. The quantum computing system of any of claims 17 to 26, wherein each logical observable subset comprises a contiguous subset of the plurality of elements of the decoding hypergraph associated with the logical observable.

28. The quantum computing system of any of claims 17 to 27, wherein the logical observable subsets are non-overlapping.

29. The quantum computing system of any of claims 17 to 28, wherein determining the plurality of decoding windows comprises partitioning the logical observable into the logical observable subsets.

30. The quantum computing system of any of claims 17 to 29, wherein independently decoding the plurality of decoding windows comprises decoding the plurality of decoding windows consistently such that defects in overlapping sections of adjacent decoding windows are decoded such that they affect the same logical observable subset in each of the adjacent decoding windows.

31. The quantum computing system of any of claims 17 to 30, the one or more classical processing components being further configured to:obtain a logical readout value for the logical observable; andapply the aggregate correction to the logical readout value.

32. The quantum computing system of any of claims 17 to 31, wherein independently decoding the plurality of decoding windows comprises independently decoding the plurality of decoding windows using a plurality of decoder instances, the one or more classicalprocessing components being further configured to distribute subsets of syndrome data to the plurality of decoder instances.

33. A computer program product comprising instructions which, when the program is executed by a quantum computing system, cause the quantum computing system to carry out the method of any of claims 1 to 16.

34. A computer-readable medium comprising instructions which, when executed by a quantum computing system, cause the quantum computing system to carry out the method of any of claims 1 to 16.

Images