Quantum error decoding

Abstract

A computer-implemented error decoding method performed by a decoding system of a quantum computing system is disclosed. The method involves assigning vertices of a decoding graph respective coordinates in a coordinate space such that distances between the respective coordinates in the coordinate space represent distances between the respective vertices in the decoding graph. A correction for an error state of qubits in the quantum computing system is then determined by decoding an error syndrome using distances determined using a distance function associated with the coordinate space.

Description

[0001] QUANTUM ERROR DECODING

[0002] Field of the invention

[0003] The invention relates to quantum computing error decoding methods.

[0004] Background

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

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

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

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

[0009] Summary of the invention

[0010] According to a first aspect of the invention, there is provided a computer-implemented error decoding method performed by a decoding system of a quantum computing system, the method comprising: obtaining (e.g. receiving or constructing) a decoding graph comprising a plurality of vertices connected by edges representing error mechanisms associated with qubits in the quantum computing system, each edge having an associated distance; assigning respective vertices of the decoding graph respective coordinates in a coordinate space such that distances between the respective coordinates in the coordinate space represent distances between the respective vertices in the decoding graph, wherein the coordinate space has an associated distance function for determining the distances between the respective coordinates; receiving syndrome data representative of an error state of the qubits in the quantum computing system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective vertex in the decoding graph; and, determining a correction for the error state by decoding the syndrome data using distances between the defects determined using the distance function.

[0011] Existing approaches to determining distances in quantum error decoding generally either use a pathfinding algorithm (such as Dijkstra’s) algorithm in real-time when decoding the syndrome, or precompute all possible distances before decoding the syndrome and storing these precomputed distances in memory. The first of these approaches is relatively slow and can lead to bottlenecks when performing quantum computations. The second of these approaches requires a large amount of memory, often more than is available to the hardware decoding the syndrome data (which may be an FPGA or ASIC).

[0012] The method of the first aspect provides faster decoding compared to real-time pathfinding algorithms because all distances can be computed using a distance function, which is much simpler than a pathfinding algorithm. In addition, the only memory required is a list of coordinates (e.g. in a lookup table) and details of the distance function. Accordingly, the method of the first aspect provides a fast, low-memory decoding method that can be implemented on low-power hardware decoders (e.g. FPGAs and ASICs) that are fast, highly-flexible and have a low memory footprint (it is desirable to use low-power decoding hardware because quantum computing systems often have strict power requirements in order to maintain low / cryogenic temperatures). In addition, the method of the first aspect is extremely flexible because changes to the decoding graph can be effected simply by updating the coordinates (e.g. updating the lookup table).

[0013] The decoding system, which may also be referred to as a decoder, is preferably a classical computing system (i.e. a computing system comprising at least one classical processor for performing the method of the first aspect). The decoding system may comprise multiple components (or subsystems), and different method steps may be performed on different components. For example, at least the steps of receiving syndrome data and determining the correction are preferably performed on specialised decoding hardware (i.e. implemented using an FPGA or ASIC, which may have limited computing capabilities), whereas the steps of obtaining the decoding graph and assigning coordinates to the decoding graph vertices may be performed on other classical computing components (e.g. with less-restricted processing and / or memory capacities compared to the specialised decoding hardware).

[0014] The respective coordinates assigned to the respective vertices of the decoding graph may optionally be stored in a lookup table, and decoding the syndrome using distances between the defects determined using the distance function may comprise using the lookup table to determine the respective coordinates assigned to the respective vertices of the decoding graph associated with defects in the syndrome data; and determining the distances between the defects by using the determined coordinates as inputs of the distance function.

[0015] The method may further comprise obtaining an updated decoding graph; assigning respective vertices of the updated decoding graph respective updated coordinates in an updated coordinate space such that distances between the respective updated coordinates in the updated coordinate space represent distances between respective vertices in the updated decoding graph, wherein the updated coordinate space has an associated updated distance function for determining distances between the respective updated coordinates; storing the respective updated coordinates in an updated lookup table; receiving updated syndrome data representative of an updated error state of the qubits, the updated syndrome data comprising a plurality of updated defects, each updated defect associated with a respective vertex in the updated decoding graph; using the updated lookup table to determine the respective updated coordinates assigned to respective vertices of the updated decoding graph associated with the updated defects; determining a correction for the updated error state by decoding the updated syndrome data using distances between the updated defects determined by using the determined updated coordinates as inputs of the updated distance function.

[0016] Certain quantum computation operations, such as lattice surgery, require the use of an updated decoding graph. Changes to the decoding graph can be easily implemented simply by updating the lookup table to use updated coordinates for decoding graph vertices.

[0017] The updated coordinates may optionally have different dimensions to the original coordinates (e.g. higher or lower dimensionality).

[0018] According to a second aspect of the invention, there is provided a computer-implemented error decoding method performed by a decoding system of a quantum computing system, the method comprising: receiving syndrome data representative of an error state of qubits in the quantum computing system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective vertex in the decoding graph; determining respective coordinates assigned to respective vertices associated with the plurality of defects, wherein distances between the respective coordinates in a coordinate space represent distances between the respective vertices in the decoding graph; and, decoding the syndrome data to determine a correction for the error state by using a distance function to determine distances between the respective coordinates in the coordinate space.

[0019] The method of the second aspect provides the same advantages as the method of the first aspect. As with the first aspect, the decoding system is preferably a classical computing system and may comprise multiple components (or subsystems), and different method steps may be performed on different components. The decoding system of the second aspect may comprise an ASIC or FPGA configured to perform the method of the second aspect. Advantageously, all of the steps of the method of the second aspect can be performed quickly on low-power hardware (e.g. FPGAs and ASICs) with a low memory footprint.

[0020] The respective coordinates assigned to the respective vertices may be stored in a lookup table, and determining the respective coordinates assigned to the respective vertices associated with the plurality of defects may comprise using the lookup table to determine a respective coordinate assigned to the respective vertex associated with each defect of the plurality of defects.

[0021] The method may further comprise receiving an updated lookup table and an updated distance function; receiving updated syndrome data representative of an updated error state of the qubits, the update syndrome data comprising a plurality of updated defects, each updated defect of the plurality of updated defects associated with a respective vertex of an updated decoding graph; using the updated lookup table to determine a respective updated coordinate assigned to each respective vertex associated with each updated defect, wherein distances between the respective updated coordinates in an updated coordinate space represent distances between respective vertices in the updated decoding graph; and decoding the updated syndrome data to determine a correction for the updated error state by using the updated distance function to determine distances between the respective updated coordinates in the updated coordinate space.

[0022] Certain quantum computation operations, such as lattice surgery, require the use of an updated decoding graph. Changes to the decoding graph can be easily implemented simply by updating the lookup table to use updated coordinates for decoding graph vertices.

[0023] The updated coordinates may optionally have different dimensions to the original coordinates (e.g. higher or lower dimensionality).

[0024] The following features apply to both the first and second aspects of the invention. Any feature described herein in relation to the first aspect of the invention may also be combined with the second aspect of the invention and vice-versa.

[0025] A decoding graph is a graph (in the mathematical sense) comprising edges representing error mechanisms, and vertices (or nodes) representing differences in successive syndrome measurements (or more generally, a decoding graph comprises vertices representing detectors, which are measurement results that sum to zero (e.g. modulo 2 sum) during perfect (i.e. error-free) operation of the quantum computing system). The decoding graph may have one or more boundaries, which involve edges that only connect to a single vertex in the decoding graph (the other end of these boundary edges may either be unconnected, or they may connect to one or more virtual boundary vertices, i.e. the decoding graph may be a subgraph of a larger graph including the virtual boundary vertex (or vertices)).

[0026] The distances associated with each edge may also be referred to as weights. The distance between any two vertices in the decoding graph is given by the sum of the distances (or weights) associated with the edges along the shortest (i.e. minimum distance / weight) path between the vertices.

[0027] A defect (also referred to as an excitation or a measurement event) generally represents the end of a chain of errors in the decoding graph. Defects are non-trivial syndrome values, and they may correspond to a change in value of a syndrome qubit measurement outcome between successive rounds of syndrome measurement. Each defect in the error syndrome is associated with a vertex in the decoding graph.

[0028] Decoding is the process of analysing the error syndrome data to infer a correction. The decoding process may optionally involve determining potential error(s) that caused the observed error syndrome. The correction may identify a plurality of qubits for which measurement outcomes need to be adjusted, or it may be a single bit indicating whether an encoded logical qubit is in an errored state (in which case any subsequent measurement of that logical state should be adjusted accordingly).

[0029] The distances between the respective coordinates in the coordinate space may represent (i.e. be equal to, proportional to (i.e. some multiple of), some (preferably linear) function of etc.) distances between the respective vertices in the decoding graph within a predetermined accuracy. The accuracy may be defined in terms of a relative error or any other suitable quantifier.

[0030] For example, the distance between any two respective coordinates may be equal to or proportional to the distance between the respective vertices in the decoding graph within a predetermined percentage such as 5%, 10%, 20% etc. One skilled in the art will select a desired accuracy depending upon factors such as underlying qubit error rates, desired logical error rates etc. In addition, one skilled in the art will recognise that adjusting all decoding graph distances by the same scale factor will generally not affect the outcome of the decoding method, hence distances in the coordinate space (referred to herein as embedded distances) need not be the same as distances in the decoding graph provided relative distances between different pairs of vertices are maintained (within a predetermined accuracy / relative error). For example, all embedded distances could be twice (or some other multiple) as long as corresponding decoding graph distances without affecting the decoding outcome. The lookup table used in methods of the present disclosure may store a relationship between vertices (e.g. identifiers / indices assigned to each vertex) in the decoding graph and coordinates in the coordinate space.

[0031] The coordinate space may be any coordinate space having a well-defined distance function for determining the distance between coordinates in the coordinate space. Examples of suitable coordinate spaces include metric spaces and Euclidean spaces.

[0032] The coordinate space may have more than three dimensions. Using a coordinate space with more than three dimensions allows edges representing complicated error mechanisms (e.g. those that span multiple physical qubits and multiple timesteps) to be accounted for.

[0033] The distance function is a function (which may be a linear function, polynomial function etc.) that takes two coordinates as inputs and returns the distance between those two coordinates in the coordinate space. The distance function may be a metric or a norm, such as the norm norm.

[0034] The method may further comprise, at the decoding system, receiving distance function implementation information. The distance function implementation information comprises information that enables the decoding system to implement (i.e. use) the distance function to determine distances between pairs of coordinates. The distance function implementation information may comprise a distance function equation for implementing the distance function, or it may comprise information identifying the distance function (e.g. norm or norm) so that the decoding system can access an appropriate distance function equation already stored in memory (e.g. where one or more distance functions are already known by / stored in memory on the decoding system).

[0035] Decoding the syndrome may comprise using a matching decoding method, for example a minimum-weight-perfect-matching method or a clustering matching method such as union find. Matching decoding method are quantum error correction decoding methods that pair (i.e. match) defects in the syndrome data based on distances between defects in the decoding graph.

[0036] The distances between the respective coordinates in the coordinate space may be approximately equal to (i.e. within a predefined accuracy / relative error of) the distances between the respective vertices in the decoding graph up to a global scale factor. That is, the distances between the respective coordinates in the coordinate space may be equal to the distances between the respective vertices in the decoding graph (or equal to the distances between the respective vertices in the decoding graph multiplied by a global scale factor, i.e. a scale factor that is the same for all distances) within a predefined accuracy / relative error (e.g. some maximum deviation). The global scale factor may be equal to one (i.e. equivalent to there being no scale factor). Multiplying all decoding graph distances by a global scale factor generally has no impact upon the outcome of the decoding process.

[0037] Alternatively, the distances between the respective coordinates in the coordinate space may be equal to (i.e. exactly equal to) the distances between the respective vertices in the decoding graph up to a global scale factor (which may likewise be equal to one).

[0038] According to a third aspect of the invention, there is provided a decoding system (of a quantum computing system) configured to perform the method of the first or second aspects. The decoding system may comprise one or more classical processors arranged to perform the method of the first or second aspects.

[0039] According to a fourth aspect of the invention, there is provided a computer-readable storage medium comprising instructions which, when executed by a decoding system of a quantum computing system, cause the decoding system to carry out the method of the first or second aspects. The computer-readable storage medium may optionally be a non-transitory computer-readable storage medium.

[0040] The third and fourth aspects of the invention provide the same advantages as the first and second aspects of the invention. Any feature described in relation to first or second aspects of the invention may be combined with the third and / or fourth aspects of the invention.

[0041] Brief description of the drawings

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

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

[0044] Fig. 2 illustrates a qubit layout suitable for planar code error correction;

[0045] Fig. 3a illustrates a planar code;

[0046] Figs. 3b(i), 3b(ii), 3c(i) and 3c(ii) illustrate planar code stabilisers;

[0047] Figs. 4a and 4b illustrate quantum circuits for performing planar code stabiliser measurements;

[0048] Figs. 5a, 5b and 5d illustrate possible qubit errors on the planar code;

[0049] Fig. 5c and 5e illustrates combined errors and corrections on the planar code;

[0050] Fig. 6 illustrates another planar code;

[0051] Fig. 7 illustrates an example decoding graph for the planar code of Fig. 6;

[0052] Fig. 8 is a flowchart of a decoding method;

[0053] Fig. 9a shows a unit cell edge structure for a decoding graph; and Fig. 9b shows a pseudo-coordinate system for rotated planar code.

[0054] Detailed description

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

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

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

[0058] The output of a decoder is a probabilistic prediction. Given the syndrome observed, the decoder outputs a best guess for the error that caused it, or alternatively a likely correction that will correct the error. A given family of error correction codes may have a variety of decoding algorithms to choose from; selecting the decoder is a balance between accuracy, speed, and compute budget for decoding. A more accurate decoder will be more effective at producing a best guess for errors and corrections, and this will result in improved logical accuracy of the quantum computation. The decoder is therefore a key element in the performance of the QEC protocol (and therefore the quantum computation as a whole).

[0059] A schematic of an exemplary quantum computing system 100 for performing the method of the present disclosure is shown in Fig. 1. The quantum computing system 100 comprises a plurality of physical qubits 106 (unless specified otherwise, reference herein to qubits should be understood to refer to physical qubits rather than logical qubits). The qubits 106 may include data qubits used to encode logical qubit states, and auxiliary qubits (or syndrome qubits) used to perform syndrome measurements for QEC.

[0060] The qubits 106 are controlled by a classical control system 104. The control system 104 transmits control signals to the qubits 106 for performing operations on the qubits 106 (including measurement operations) and receives measurement information from the qubits 106. The measurement information will generally be analogue data signals, although the analogue signals may alternatively be converted to digital signals before being transmitted to the control system 104 in some implementations (e.g. the qubits 106 may be provided with one or more analogue to digital converters).

[0061] The control system 104 may receive high-level instructions from an algorithmic system or similar (not shown) and convert these high-level instructions (such as logic gates) into low- level qubit instructions (e.g. microwave pulses etc.), which may be in analogue format.

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

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

[0064] Fig. 2 shows a qubit layout 200 that is suitable for performing planar code QEC. The qubit layout 200 shown in Fig. 2 has physical data qubits 202 that are used to encode logical quantum states and physical syndrome qubits 204 (also referred to as auxiliary qubits) that are used to facilitate measurement of error syndromes associated with errors on the data qubits 202.

[0065] Connections 206 allow for interaction (e.g. two-qubit gates) between adjacent data qubits 202 and syndrome qubits 204. Examples of two-qubit gates include controlled-X gates (also referred to as CNOT gates) and controlled-Z gates (also referred to as CPHASE gates). Unless indicated otherwise, reference herein to X, Y and Z operators should be understood to refer to Pauli X, Y and Z operators. The stabiliser measurement values obtained during a QEC procedure provide a syndrome that is representative of errors on the data qubits 202. The syndrome is then provided to the decoding system 102, which analyses the syndrome and determines and tracks errors and / or corrections. Often, it suffices to track the errors and / or corrections classically: it is not generally necessary to apply any corrections to the data qubits 202 or syndrome qubits 204 (although certain types of errors, such as leakage errors, may necessitate active correction in some scenarios).

[0066] While the qubits 202, 204 in Figs. 2a and 2b are illustrated in a regular array, it should be understood that alternative arrangements (such as irregular arrangements) could be used to achieve equivalent qubit connectivity. For example, the qubits 202, 204 could be physically separated and connected by transmission lines or similar. In addition, one skilled in the art will appreciate that planar code error correction can be performed with different qubit layouts (e.g. with different connectivity) and that alternative error correction schemes may also be used: the present disclosure is applicable to any error correction scheme in which a decoder requires knowledge of the distance between vertices on a decoding graph. Fig. 3. illustrates a planar code 300 on an array of physical data qubits 202 and syndrome qubits 204 (connections 206 between qubits have been omitted for clarity). While it is often preferable that the physical qubits are arranged in a regular array, this is not essential to perform quantum computation using the planar code, and the qubits could alternatively have a different physical arrangement while still achieving the desired connectivity (e.g. degree- four connectivity or greater). The illustrated planar code 300 encodes a single logical qubit and has a “code distance” of five (i.e. a logical qubit error requires errors on at least five data qubits 202, and the code is capable of reliably detecting and correcting any error involving up to [code distance / 2j = [5 / 2J = 2 qubits) and is in a configuration commonly referred to as the “rotated” planar code, which requires fewer physical qubits for a given code distance compared to “unrotated” planar codes. It should be understood that the code distance is a global property of the QEC code and is a separate concept to decoding graph edge distances (which are distance / weight values associated with each edge of a decoding graph) and distances between vertices of the decoding graph (which are determined by summing the distances associated with the edges between vertices). Any reference to distance herein should be understood to refer to decoding graph edge distances and distances between vertices or coordinates unless explicit reference is made to code distance.

[0067] The planar code 300 is formed of Z-type stabilisers 302 (hatched squares and triangles) and X-type stabilisers 304 (blank squares and triangles). Z-type stabilisers 302 involve joint Pauli-Z measurements (e.g. Z 0 Z Z 0 Z measurements) of the data qubits 202 at the vertices of the Z-type stabilisers 302 (four data qubits 202 for the square stabilisers as shown in Fig. 3b(i), and only two data qubits 202 for the triangular stabilisers as shown in Fig. 3b(ii) because the third vertex is occupied by a syndrome qubit 204). Similarly, the X- type stabilisers 304 involve joint Pauli-X measurements of the data qubits 202 at the vertices of the X-type stabilisers 304 as shown in Figs. 3c(i) and 3c(ii).

[0068] Each stabiliser 302, 304 is associated with a single syndrome qubit 204 (either in the centre of the respective square, or at a vertex of the respective triangle). Comparing the planar code 300 to the qubit layout 200 in Fig. 2, it can be seen that the syndrome qubit 204 of each stabiliser is connected to the data qubits 202 associated with that stabiliser. All of the stabilisers 302, 304 commute with each other.

[0069] The syndrome qubits 204 are used to measure the value of the stabilisers 302, 304. Figs. 4a and 4b show circuits for measuring the X-type stabilisers 304 and Z-type stabilisers 302 respectively. In both Figs. 4a and 4b, the topmost qubit represents the respective syndrome qubit 204 associated with the respective stabiliser 302, 304, and the other qubits represent the data qubits 202 associated with that respective stabiliser 302, 304.

[0070] The stabilisers 302, 304 detect the ends of chains of errors on the data qubits 202. The Z- type stabilisers 302 detect the ends of chains of errors involving X and / or Y data qubit errors, and the X-type stabilisers 304 detect the ends of chains of errors involving Y and / or Z data qubit errors. For simplicity, the following section of this disclosure will focus on the detection and correction of X errors by Z-type stabilisers 302. However, one skilled in the art will appreciate that the detection and correction of Z (and Y) data qubit errors can be achieved using equivalent procedures with X-type stabilisers 304.

[0071] Fig. 5a shows a planar code 300 with two X errors on the data qubits 202 (indicated by data qubits 202 labelled with an X). The upper X error anticommutes with the Z-type stabiliser 302 associated with the syndrome qubit 204 labelled 1. The lower X error anticommutes with the Z-type stabiliser 302 labelled 3. The X errors shown in Fig. 5a therefore act to flip the measurement outcome of these Z-type stabilisers 302 (i.e. the measurement outcomes when measuring the syndrome qubits 204 labelled 1 and 3 are flipped from whatever they would have been in the absence of errors on the data qubits 202, e.g. if the measurement value in a previous round of syndrome measurements without errors was 0, the new measurement value (assuming no measurement errors) would be 1 and vice-versa).

[0072] The two X errors in Fig. 5a collectively commute with the Z-type stabiliser 302 associated with syndrome qubit 204 labelled 2, so the outcome of measuring this syndrome qubit 204 is unchanged by the presence of the X errors.

[0073] Changes in the measurement value of a syndrome qubit 204 between successive rounds of syndrome measurement are referred to as defects or detection events. In the example shown in Fig. 5a, defects would be associated with syndrome qubits 204 labelled 1 and 3. These defects collectively form the error syndrome. It should be noted that the syndrome does not provide the actual location of the errors: it simply provides the location of the ends of ‘chains’ of errors on the planar code 300. The decoder must process the syndrome to identify a correction that leaves the encoded logical qubit in the correct logical state with high probability.

[0074] Error syndromes are not unique: it is possible for different error patterns to cause the same error syndrome. Consequently, the decoder cannot always identify the exact location of errors. For example, the X errors shown in Fig. 5b act on different data qubits 202 to those in Fig. 5a but would result in the same error syndrome (defects associated with syndrome qubits 204 labelled 1 and 3).

[0075] It is not necessary for the decoder to exactly identify the error with complete certainty: there are generally multiple possible corrections that leave the encoded logical qubit in the correct logical state. For example, the errors in Fig. 5a could be corrected by applying an X operator to each of the data qubits 202 that originally experienced X errors, thereby effectively reversing the errors. If the same correction is applied for the errors in Fig. 5b, the combined error and correction operations would leave the planar code 300 in the state shown in Fig. 5c, with X operators effectively occurring on four data qubits 202. While this does not exactly reverse the original error, it is equivalent to performing an X-type stabiliser operator 304 on the planer code 300. Stabiliser operators 302, 304 do not affect the logical state encoded in the planar code 300, so this correction would leave the encoded logical qubit in the correct logical state.

[0076] It is not always possible to successfully correct errors. Fig. 5d shows three X errors that would cause the same error syndrome as the errors shown in Figs. 5a and 5b. Applying the same correction described above (i.e. X operators as shown in Fig. 5a) would result in a chain of X operators that spans the planar code 300 as shown in Fig. 5e. This chain of X operators changes the logical state of the logical qubit encoded in the planar code 300 and would therefore be an unsuccessful correction (i.e. a correction that results in a logical error).

[0077] It is important to note that the decoder cannot distinguish between the error patterns shown in Figs. 5a, 5b and 5d: all of these error patterns cause the same error syndrome. The job of the decoder is to identify a correction that will successfully correct errors on data qubits 202 with high confidence; there is often a trade-off between decoding speed and decoding accuracy (i.e. probability of successful correction).

[0078] Many QEC decoding methods utilise a decoding graph. Edges of the decoding graph represent error mechanisms, and vertices of the decoding graph are associated with syndrome measurement outcomes (e.g. changes in syndrome measurement values). Each graph edge will generally have an associated distance (or weight), which will generally be a positive integer or floating point number. The distance between any two vertices in the decoding graph is defined as the sum of edge weights / distances along a shortest path between the two vertices (i.e. along the path that gives the lowest value for the distance). The weights associated with each edge will generally represent the probability of the error mechanism associated with the edge occurring (e.g. log probabilities).

[0079] It will be understood that while graphs (e.g. decoding graphs) are sometimes visualised in two (or more dimensions), graphs do not have dimensions or a coordinate system. In other words, while decoding graph edges may have distances (weights) and can be visualised in two or more dimensions, the distances between vertices in the visualisations are not indicative of the distances between vertices in the decoding graph as calculated using edge distances. Graphs are data structures that store a list of vertices and edges between the vertices (optionally also storing additional local / vertex / edge attributes).

[0080] A syndrome (also referred to as syndrome data) is a collection of values (e.g. measurement values, generally based on qubit measurements - in particular syndrome qubit 204 measurement) representative of an error state of physical data qubits 202 in the quantum computer. The syndrome may also include decoding graph information for each syndrome value - e.g. a vertex index value. The syndrome includes one or more defects which correspond to changes in the value of a syndrome qubit 204 measurement outcome between successive rounds of syndrome measurement. Each defect in the error syndrome is associated with a vertex in the decoding graph.

[0081] Decoding a syndrome using a decoding graph generally involves pairing (or matching) defects. Many decoding methods (especially those that use matching, such as minimum- weight-perfect-matching (MWPM) decoding algorithms and clustering algorithms) involve determining a distance between defects as the shortest path along weighted edges of the decoding graph (the weights of the edges represent distances, and the distance between any two vertices in the decoding graph along a given path of edges is the sum of the weights (i.e. distances) associated with those edges). One way to compute the distances is to run Dijkstra’s algorithm (or similar) between every two points of interest (e.g. defects) in the graph at every decode cycle. This is computationally intensive and can introduce a bottleneck for fast decoder implementations.

[0082] Another option is to precompute distances using Dijkstra’s algorithm (or similar) and store them in memory in a look-up table. This requires n2 / 2 entries, where n is the number of vertices in the graph. For reference, a code having code distance 20 with 20 rounds of syndrome measurement would require around 64MB of data to store all distances for each decoding graph (a separate decoding graph is required for X-type and Z-type stabiliser syndromes), while a code with code distance 30 would require -700MB. Additionally, dynamically changing the code while performing lattice surgery operations required to perform quantum computation would require storing several such look-up tables, or dynamically changing these large data structures during the quantum computation. Memory requirements therefore quickly become a bottleneck for hardware decoders implemented on FPGAs and ASICs, which generally have limited memory.

[0083] Each of these options therefore has a major drawback: either a slow runtime speed (potentially causing a bottleneck) or excessively high memory requirements (i.e. beyond the capabilities of hardware decoders).

[0084] These drawbacks can be overcome by embedding vertices of the decoding graph into a coordinate space (i.e. assigning each vertex of the decoding graph coordinates in a coordinate space) such that distances between respective embedded vertices in the coordinate space represent (e.g. are equal to or proportional to, or are approximately equal to or proportional to (i.e. within some arbitrary / predefined accuracy / relative error)) distances between the respective vertices in the decoding graph (where the distance between vertices in the decoding graph is defined as the sum of edge weights along the shortest (lowest- weight) path between the respective vertices in the decoding graph).

[0085] The coordinate space is some d-dimensional space (where d may optionally be greater than three dimensions) that has an associated distance function (such as a metric) for determining distances between coordinates of the embedded vertices. Examples of such distance functions include the norm (also referred to as the taxicab or Manhattan norm) and the norm (sometimes referred to as the Euclidean norm). Computing distances using such functions is 0 d). As d (the dimension of the coordinate space) is generally not a function of the code distance, this means that the complexity of computing distances on the decoding graph using the embedding approach does not scale unfavourably with code distance.

[0086] The embedding can be performed ahead of the quantum computation and only needs to be performed once (unless the connectivity of the decoding graph changes). Compared to using Dijkstra’s algorithm in real-time, distances can be computed with much lower processing overhead (i.e. much faster) using the distance function of the embedding. Compared to using precomputed distances, the embedding requires far less memory because all that is required is a lookup table storing the relationship between the decoding graph vertices and embedded coordinates and details of which distance function to use. Storing such a lookup table will require O(n) memory to store the coordinates (where n is the number of decoding graph vertices). This means that a surface code having code distance 20 would require -100 kB memory to store the embedding, and a surface code having code distance 30 would require -500 kB. Additionally, the method of the present invention allows the code to be changed dynamically (and very quickly) simply by updating the lookup table, and it can be used to decode error syndromes when performing quantum computation with lattice surgery.

[0087] In addition to being performed prior to the quantum computation, the embedding can also be performed by a more powerful computing device if necessary (i.e. with less onerous power and / or heat limitations), with the actual syndrome analysis being performed by specific decoding hardware with more limited capabilities (e.g. by an FPGA or ASIC device with limited processing and / or memory capabilities).

[0088] Embedding decoding graph vertices into coordinate spaces therefore reduces runtime memory and processing requirements compared to existing decoding methods, which in turn means that it can be used with a greater number of physical qubits, thereby facilitating fault-tolerant quantum computations with lower error rates and / or increased numbers of logical qubits. The methods disclosed herein enable low-power hardware decoders (e.g. FPGA or ASIC decoders) that are fast, highly flexible and have a low memory footprint.

[0089] Embedding graphs into coordinate spaces such as Euclidean and spaces has been widely studied in other fields such as the field of discrete geometry (see e.g. Matousek, J. (2002). Embedding Finite Metric Spaces into Normed Spaces. In: Matousek, J. (eds) Lectures on Discrete Geometry. Graduate Texts in Mathematics, vol 212. Springer, New York, NY. https: / / doi.org / 10.1007 / 978-1-4613-0039-7_15). However, these ideas have not previously been used in the context of QEC.

[0090] Methods for embedding graphs into coordinate spaces are known in the art. For example, Akshay Agrawal, Alnur Ali and Stephen Boyd (2021), "Minimum-Distortion Embedding", Foundations and Trends in Machine Learning: Vol. 14: No. 3, pp 211-378. http: / / dx.doi.org / 10.1561 / 2200000090 describes methods for that embedding with minimal distortion. In addition, Bourgain’s Theorem states that every n-element metric space can be embedded into some Euclidean space with distortion at most O(logn), which guarantees that a Euclidean space (i.e. a space having a Euclidean norm) exists for any embedding with at most O(logn) distortion (the distortion is the maximal amount by which the distances are “stretched” due to an approximate embedding, i.e. differences between the distances in the decoding graph and differences in the coordinate space - provided the distortion is sufficiently low, accurate error decoding can still be performed). Depending on the structure of the decoding graph, the distortion can be significantly lower than O(logn) (see e.g. Rao, S. Small distortion and volume preserving embeddings for planar and Euclidean metrics, in Proceedings of the fifteenth annual symposium on Computational geometry 300-306 (Association for Computing Machinery, 1999). doi:10.1145 / 304893.304983). Any suitable method (such as those discussed above, or even trial and error) can be used to determine an embedding. Determining an embedding will generally be a trade-off between accuracy (defined herein as \Dgraph- Dembed\ / Dgraphfor a given pair of vertices, where Dgraphis the distance between the two vertices in the decoding graph and Dembedis the distance between the embeddings of the same two vertices in the coordinate space, although it should be understood that different formulae may be used by one skilled in the art to provide alternative measures of accuracy / relative error that can be used in combination with the present disclosure) and the number of dimensions in the coordinate space. Increasing accuracy (e.g. reducing relative error) of the embedding can increase accuracy of the decoder (up to a point), while increasing the number of dimensions will lead to a slight increase in the processing power required by the decoder at runtime. A person skilled in the art will chose a suitable accuracy (i.e. require the accuracy / relative error to be within a certain range for all pairs of vertices) depending upon factors including available computing resources, physical qubit error rates, and target logical error rates.

[0091] A decoding method according to the present disclosure is shown in Fig. 8. The method may be performed by a decoding system (or decoder) such as that shown in Fig. 1 . The method steps may be performed by a single classical computing device, although it is envisaged that at least steps 803 and 804 would preferably be performed by specific (classical) decoding hardware with more limited capabilities (e.g. an ASIC or FPGA), whereas steps 801 and 802 may be performed by more powerful general-purpose (classical) computing hardware.

[0092] In a first step 801 , the decoding system obtains a decoding graph. The decoding graph may be programmed by a user, or it may be received from another device or retrieved from a file stored in memory. One skilled in the art of QEC will appreciate that there are various ways a decoding graph can be constructed (e.g. based on empirical and / or analytically calculated error rates) and that the structure of the decoding graph (i.e. connectivity and edge weights) will depend upon the QEC code and decoding method in question.

[0093] In step 802, vertices of the decoding graph are embedded into a coordinate space by the decoding system by assigning coordinates to each decoding graph vertex. As discussed above, this may be performed using any suitable method. The embedding is performed such that distances between respective embedded vertices in the coordinate space represent (e.g. are equal to, approximately equal to, proportional to, or approximately proportional to, wherein “approximately” means within some arbitrary pre-defined accuracy / relative error, such as 10% for example) distances between the respective vertices in the decoding graph. The result of this step is a list of coordinates that represent positions of the decoding graph vertices in the coordinate space (one for each vertex in the decoding graph) and an associated distance function to be used when determining distances between embedded vertices in the coordinate space (e.g. a metric).

[0094] The coordinates assigned to each vertex may be written into a lookup table in memory on the decoder for quick access during decoding. The distance function may also be stored in memory on the decoder.

[0095] In step 803, the decoding system receives syndrome data representative of an error state of the qubits in the quantum computer. The syndrome data may be received from a control system of the quantum computer (a classical computing device configured to control qubits of the quantum computer), which may in turn obtain the syndrome data through measurement of syndrome qubits in the quantum computer. The syndrome data comprises one or more defects, each being associated with a decoding graph vertex.

[0096] In step 804, the decoding system determines a correction for the error state of the qubits. This will generally be achieved by pairing defects in the syndrome, which will often require knowledge of the distance between pairs of defects in the syndrome. The decoding system determines these distances using the coordinates determined in step 802. For example, for a pair of vertices associated with defects in the syndrome, the decoding system will use the lookup table to determine the embedded coordinates associated with (assigned to) these vertices and will use the distance function to determine a distance between them. One skilled in the art will appreciate that various decoding algorithms can be used to determine a correction, including MWPM and clustering algorithms. Determining the correction may also involve determining a potential error that caused the syndrome, or it may simply involve determining a correction to the logical state encoded in the physical qubits (which could be a single bit representing whether a logical error has occurred). There will generally not be any need to apply a physical correction to the data qubits: corrections can instead be tracked classically by the control system and / or decoding system or some other component of the quantum computing system.

[0097] Steps 801 and 802 generally only need to be performed once unless the decoding graph changes. Decoding graph changes may occur in response to hardware recalibration (e.g. updated error models that affect decoding graph edge weights). Steps 803 and 804 may be repeated many times with different error syndromes.

[0098] Example

[0099] An example application of the decoding method of Fig. 8 will now be discussed in relation to Fig. 6 and Fig. 7.

[0100] Fig. 6 shows a planar code 600 similar to that in Fig. 3a but with fewer qubits and a lower code distance (the planar code 600 in Fig. 6 has code distance three and therefore provides less protection against logical errors compared to the planar code 300 in Fig. 3a). The planar code 600 has nine data qubits 202 and eight syndrome qubits 204.

[0101] Fig. 7 shows an example of a decoding graph 700 for the X-type stabilisers 304 associated with the planar code 600 in Fig. 6. The decoding graph 700 is formed from vertices (or nodes) 702 connected by edges 701 .

[0102] Each edge 701 of the decoding graph 700 has an associated edge weight (distance), which could be e.g. the log-likelihood of the probability of an error mechanism that flips the vertices 702 and the endpoints of the edge 701 in question.

[0103] Each vertex 702 of the decoding graph 700 is associated with a syndrome qubit 204 measurement (e.g. a change in value when measuring the syndrome qubit 204), so the decoding graph 700 has been overlaid onto planar code patches to assist conceptual understanding. In particular, vertices 702 labelled 0 to 3 are associated with syndrome qubit measurement outcomes during a first round (timestep) of syndrome measurement, and the vertices 702 labelled 4 to 7 are associated with syndrome qubit measurement outcomes during a second round (timestep) of measurements. While the decoding graph 700 is illustrated projected onto the planar codes, it should be understood that the decoding graph 700 itself is a graph structure with no well-defined coordinate system: the position of the vertices 702 in Fig. 7 is not related to the weight (distances) of the edges 701. Accordingly, the decoding graph 700 itself does not have a dimension: it is simply an abstract data structure storing a list of vertices 702 and edges 701 , with each vertex 702 and edge 701 optionally having associated attributes (such as edge weights, measurement outcome values / changes etc.).

[0104] The decoding graph 700 may have the following edge weights (given in the form (first vertex, second vertex): edge weight)’.

[0105] (0: 1): 5.3640 (0: 4): 4. 1279 (1: 2): 4.3642 (1: 4): 4.7433 (1: 5): 4.0477 (2: 4): 5.9216 (4: 5): 4.2605 (2: 3): 5.3640 (2: 5): 5.2284 (2: 6): 4.0477 (3: 5): 5.9216 (5: 6): 3.8097 (3: 6): 4.7433 (3: 7): 4. 1279 (6: 7): 4.2605 Using the methods in Akshay Agrawal, Alnur Ali and Stephen Boyd (discussed above) to embed the vertices 702 of the decoding graph 700 into a four-dimensional coordinate space yields the following coordinates for each vertex 702 when using the norm:

[0106] 0: (2.1166, 2.2408, 3.2068, -7.0071)

[0107] 1: ( 0.9746, 3.0412, 0.0292, -2.5556)

[0108] 2: (-1.4867, 1.9529, 0.5797, 1.1966)

[0109] 3: (-3.3379, -1.7211, -2.7540, 3.1912)

[0110] 4: ( 1.0612, -0.3539, 2.5776, -3.7992)

[0111] 5: ( 1.2358, -0.8711, -0.6481, -0.6982)

[0112] 6: ( 0.4809, -1.0702, -0.5186, 3.2965)

[0113] 7: (-1.0443, -3.2187, -2.4727, 6.3757)

[0114] These coordinates can be stored in a lookup table (or similar data structure) on the decoding hardware. During the decoding process, the decoder can determine the distance between first and second decoding graph vertices 702 (i.e. two vertices 702 that are in the error syndrome) by querying the lookup table to obtain the coordinates associated with these vertices 702 and using the distance function to determine the distance between these coordinates.

[0115] For example, the distance between vertices 702 labelled 0 and 4 in the decoding graph 700 can be determined by calculating the distance between (2.1166, 2.2408, 3.2068, - 7.0071) and (1.0612, -0.3539, 2.5776, -3.7992), which is equal to:

[0116] 7(2.1166 - — 3.3379)2+ (2.2408 - 1.7211)2+ (3.2068 - -2.7540)2+ (-7.0071 - 3.1912)2which gives a distance value of 13.60.

[0117] For comparison, using Dijkstra’s algorithm (or similar) to find the distance between vertices 702 labelled 0 and 3 results a path from vertex 702 labelled 0 to vertex 702 labelled 4 to vertex 702 labelled 5 to vertex 702 labelled 3 with a total weight (distance) of 14.31. As such, the distance between vertex embeddings in the coordinate space is not exactly equal to the distance between the same two vertices 702 in the decoding graph 700. However, the coordinate space distances are representative of the decoding graph 700 distances in that they approximate the decoding graph 700 distances. Further examples are given in the table below: It can therefore be seen that the embeddings for each of these pairs of vertices 702 has a relative error value less than 0.1 (i.e. the embedding distances approximate the decoding graph distances to within 10% of the decoding graph distances).

[0118] While not shown on the illustrated decoding graph 700, some decoding graphs feature additional “boundary” vertices (or virtual nodes / vertices) as discussed earlier. These boundary vertices can also be included in the embedding, or they can be handled separately, e.g. by using a dedicated “distance to boundary” lookup table or similar logic.

[0119] Examples of assign coordinates to decoding graph vertices will now be discussed in the context of the rotated planar code. One skilled in the art will appreciate that similar methods can be used with different decoding graphs (e.g. using methods discussed above).

[0120] Fig. 9a shows the same planar code 300 as in Fig. 3; the data qubits 202 have been omitted for clarity. Fig. 9a also illustrates a ‘unit cell’ of edges that can be used to generate a decoding graph for the planar code 300 (i.e. the unit cell is replicated throughout the bulk of the decoding graph, with suitable adjustments being made at the boundary, e.g. by omitting edges that do not connect to other vertices). The illustrated unit cell is defined for a syndrome qubit 900 in a timestep t; this syndrome qubit 900 is associated with an X-type stabiliser 304. The outcome of measuring this syndrome qubit 900 in timestep t is associated with a unique vertex in the decoding graph. In the illustrated example, the unit cell associated with this vertex contributes six edges to the decoding graph (i.e. the bulk of the decoding graph is formed using the repeated unit cell edge structure, and each bulk vertex adds six edges to the decoding graph - it should be understood that the bulk vertices have more than six adjacent edges due to other edges contributed by the unit cells of nearby vertices).

[0121] The edges associated with the unit cell of the vertex are edges 901-906 (while the edges 901-906 are illustrated as arrows to aid the reader, they generally do not have any directionality in the decoding graph). Edges 901 and 902 connect to vertices associated with measurements of neighbouring X-type stabilisers 304 in the same timestep, t. Edge 903 connects to a vertex associated with measurement of the same X-type stabiliser 304 in the next timestep, t+1. Edges 904-906 connect to vertices associated with measurements of neighbouring X-type stabilisers in the next timestep, t+1. It should be understood that different decoding graph structures can be used depending upon the error model and the method used to perform stabiliser measurements (i.e. decoding graphs may have additional / fewer edges and / or edges that provide different connectivity). Edges 904-906 are often referred to as “hook edges”.

[0122] Each edge 901-906 has an associated weight (or distance) wx-w6; for this example it is assumed that the weights have translational symmetry (i.e. different unit cells in the decoding graph use the same edge weights). Each decoding graph vertex in the illustrated example can be labelled with a pseudo-coordinate (i.e. a coordinate that represents the space-time position of the stabiliser measurement but does not represent distances / weights between the associated decoding vertices) based upon the timestep and the position of the associated syndrome qubit 204 in the planar code 300. An example of such a pseudocoordinate system is shown in Fig. 9b with x, y, and t directions (i.e. each decoding graph vertex associated with the planar code 900 in Fig. 9a can be labelled with a pseudocoordinate (x, y, f) using the pseudo-coordinate system of Fig. 9b). As the pseudocoordinates do not take account of the edge weights, distances between these coordinates do not represent distances between the respective vertices in the decoding graph. However, the pseudo-coordinates can be used to determine coordinates for which the associated distances do represent distances between the respective vertices in the decoding graph.

[0123] As discussed above, each edge 901-906 has a respective weight w1-w6. To determine coordinates for the decoding graph nodes, it is useful to define “modified” weights w'4-w'2

[0124] These modified weights can then be used to define a 7-dimensional embedding (i.e. to assign coordinates to each decoding graph vertex in a 7-dimensional coordinate space) with coordinates:

[0125] X x,y, t) = (x1, x2, x3, x4, x5, x6, x7)

[0126] = (w4x, w2y, w2t, w4(x + y), w5' (x + t), w^y + t), w7(x + y + t)) with a distance function that uses the Manhattan norm: where X(x,y, t) represents the coordinate assigned to the decoding graph vertex labelled with pseudo-coordinate (x, y, f), is the distance function that gives the distance between coordinates X and X2.

[0127] It will be understood that embedding decoding graph nodes does not always require the use of pseudo-coordinates and / or modified weights: these are simply useful constructs to assist in this particular example for the rotated planar code on a decoding graph with hook edges 904-906. For example, in the case where there are no hook edges 904-906, a simpler embedding can be obtained in a 4-dimensional coordinate space using coordinates = (w1X, w2y, w3t) using the Manhattan distance (D(X'I, X'2) = HX^ - X'2||i = wl|Ax| + w2 |Ay| + w3|At|) as the distance function.

[0128] The above examples have been given in the context of the rotated planar code. One skilled in the art will appreciate that the methods disclosed herein can be applied to any decoding method that involves finding the distance between vertices in a decoding graph (e.g. matching codes). Additional examples of such codes include the unrotated planar code, the toric code, colour codes etc.

[0129] It should be understood that any method of the present disclosure could include additional steps, and any device could include additional components. In addition, unless indicated otherwise or technically infeasible, the method steps disclosed herein may be performed in alternative orders, and any order described herein should be considered as exemplary rather than limiting.

[0130] Furthermore, while the decoding methods described herein are envisaged to be performed by a classical processing device, 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, the decoding methods described herein can also be performed by a classical processing device, such as a quantum processing unit (QPU) comprising a plurality of qubits.

Claims

CLAIMS1. A computer-implemented error decoding method performed by a decoding system of a quantum computing system, the method comprising: obtaining a decoding graph comprising a plurality of vertices connected by edges representing error mechanisms associated with qubits in the quantum computing system, each edge having an associated distance; assigning respective vertices of the decoding graph respective coordinates in a coordinate space such that distances between the respective coordinates in the coordinate space represent distances between the respective vertices in the decoding graph, wherein the coordinate space has an associated distance function for determining the distances between the respective coordinates; receiving syndrome data representative of an error state of the qubits in the quantum computing system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective vertex in the decoding graph; and, determining a correction for the error state by decoding the syndrome data using distances between the defects determined using the distance function.

2. The method of claim 1 , wherein the respective coordinates assigned to the respective vertices of the decoding graph are stored in a lookup table, and wherein decoding the syndrome data using distances between the defects determined using the distance function comprises: using the lookup table to determine the respective coordinates assigned to the respective vertices of the decoding graph associated with defects in the syndrome data; and determining the distances between the defects by using the determined coordinates as inputs of the distance function.

3. The method of claim 2, further comprising: obtaining an updated decoding graph; assigning respective vertices of the updated decoding graph respective updated coordinates in an updated coordinate space such that distances between the respective updated coordinates in the updated coordinate space represent distances between respective vertices in the updated decoding graph, wherein the updated coordinate space has an associated updated distance function for determining distances between the respective updated coordinates; storing the respective updated coordinates in an updated lookup table; receiving updated syndrome data representative of an updated error state of the qubits, the updated syndrome data comprising a plurality of updated defects, each updated defect associated with a respective vertex in the updated decoding graph;using the updated lookup table to determine the respective updated coordinates assigned to respective vertices of the updated decoding graph associated with the updated defects; determining a correction for the updated error state by decoding the updated syndrome data using distances between the updated defects determined by using the determined updated coordinates as inputs of the updated distance function.

4. A computer-implemented error decoding method performed by a decoding system of a quantum computing system, the method comprising: receiving syndrome data representative of an error state of qubits in the quantum computing system, the syndrome data comprising a plurality of defects, each defect of the plurality of defects associated with a respective vertex in a decoding graph; determining respective coordinates assigned to respective vertices associated with the plurality of defects, wherein distances between the respective coordinates in a coordinate space represent distances between the respective vertices in the decoding graph; and, decoding the syndrome data to determine a correction for the error state by using a distance function to determine distances between the respective coordinates in the coordinate space.

5. The method of claim 4, wherein the respective coordinates assigned to the respective vertices are stored in a lookup table, and wherein determining the respective coordinates assigned to the respective vertices associated with the plurality of defects comprises using the lookup table to determine a respective coordinate assigned to the respective vertex associated with each defect of the plurality of defects.

6. The method of claim 5, further comprising: receiving an updated lookup table and an updated distance function; receiving updated syndrome data representative of an updated error state of the qubits, the update syndrome data comprising a plurality of updated defects, each updated defect of the plurality of updated defects associated with a respective vertex of an updated decoding graph; using the updated lookup table to determine a respective updated coordinate assigned to each respective vertex associated with each updated defect, wherein distances between the respective updated coordinates in an updated coordinate space represent distances between respective vertices in the updated decoding graph; and decoding the updated syndrome data to determine a correction for the updated error state by using the updated distance function to determine distances between the respective updated coordinates in the updated coordinate space.

7. The method of any of claims 4 to 6, wherein the decoding system comprises an ASIC or FPGA configured to perform the method.

8. The method of any preceding claim, wherein the coordinate space is a metric space.

9. The method of any preceding claim, wherein the coordinate space has more than three dimensions.

10. The method of any preceding claim, wherein the distance function is a metric or norm.

11. The method of any preceding claim, further comprising receiving distance function implementation information at the decoding system.

12. The method of any preceding claim, wherein decoding the syndrome comprises using a matching decoding method.

13. The method of any preceding claim, wherein the distances between the respective coordinates in the coordinate space are approximately equal to the distances between the respective vertices in the decoding graph up to a global scale factor.

14. A decoding system configured to perform the method of any preceding claim.

15. A computer-readable storage medium comprising instructions which, when executed by a decoding system, cause the decoding system to carry out the method of any of claims 1 to 13.

Images