Quantum decoder

Abstract

The quantum computer system comprises a decoder apparatus and a register of quantum devices. The decoder comprises processing elements, PEs. The method comprises: receiving, at the decoder, syndrome d

Description

This disclosure relates to methods, systems, and apparatus for use in decoding errors in a quantum computer system. Background Quantum computers hold the potential to revolutionize various fields of science and technology. However, today's quantum computers cannot realise these transformational possibilities because their fundamental components, qubits, are highly error-prone. To unlock the transformative possibilities of quantum computing, the error rates for operating on quantum data must be dramatically reduced. This issue may be addressed in part by hardware improvements as physicists and engineers get better at building more stable qubits, but these advancements alone won't be enough to enable algorithms to run with millions or billions of operations reliably. There is a need for quantum error correction methods, however these methods present significant challenges. Fault-tolerant quantum computation will likely involve millions of physical data qubits, generating a huge amount of data which must be processed extremely quickly and in real-time. Both classical and quantum error correction methods seek to identify and address errors in information storage and processing. However, these general approaches operate in fundamentally different ways due to the unique principles of quantum mechanics. For example, while classical information is encoded using classical bits which exist in a well-defined state (either 0 or 1) at any given time, quantum information is encoded using a register of quantum devices such as a register of qubits, which can exist in superpositions of states (both 0 and 1 simultaneously) and exhibit entanglement. In addition, since directly measuring the state of a qubit causes the state to collapse, quantum error correction techniques must measure certain properties of the quantum system to infer the existence of errors, while mitigating the effects of measurements on the quantum state. Some quantum error correction codes involve decoding a "syndrome", which can be considered to be a signature associated with an error state of the physical qubits. A decoder is used to identify an error (or errors) which could have caused the syndrome. A "decoding graph" can be used to facilitate decoding of the syndrome by grouping "defects" in the syndrome. These defects generally provide an indication of end points of chains of errors on physical data qubits in the error correction code. Errors generally create a pair of defects, and an objective of quantum error correction techniques is to identify and match up these defects. After the defects in the syndrome have been grouped, a next step can be determined. For example, a correction for the error state can be determined and applied. Since an objective of this category of quantum error correction approaches is to correct errors by grouping defects, some algorithms seek to decode syndromes by clustering defects. An example of this approach is described in (Delfosse, N. and Nickerson, N.H. (2021) 'Almost-linear time decoding algorithm for topological codes', Quantum, 5, p. 595. doi:10.22331 / q-2021-12-02-595). Every 'odd' cluster, i.e. every grouping of nodes (or 'vertices') that is associated with an odd number of defects, grows until it becomes an "even" cluster, for example a cluster associated with an even number of defects. The number of defects in the cluster is a primary factor which affects the "parity" of a cluster. Each node which is part of an odd cluster grows outward until it encounters another cluster, at which point the clusters merge. If the parity of the new, merged cluster is even, then it stops growing. Otherwise, it continues to grow. This continues until all clusters have an even parity. There may be other criteria which cause a cluster to stop growing, such as if a cluster touches a boundary of the decoding graph. Next steps can then be determined based on the decoded syndrome. For example, correction(s) to the encoded logical state can be determined based on the clustering of defects. This overview has been simplified for brevity and to aid quick understanding, and the limitations of this simplified overview will be understood by the skilled person. Conventional algorithms of this type can be designed to be run on specialised decoding hardware comprising a plurality of processing elements (PEs). Each node in the decoding graph may be associated with a different PE according to a 1:1 mapping to enable parallelisation. Connections are created between neighbouring PEs, i.e. PEs associated with nodes which neighbour each other in the decoding graph, to enable a PE to query and share data with its neighbouring PEs. In this way, data can be propagated through the network of PEs. This approach is effective but does have drawbacks. For example, contention issues may arise when multiple PEs try to access the same data simultaneously (or semi-simultaneously). Memory and resource contention increases response times, and, in some cases, can result in data corruption or other unexpected behaviour. Since data is propagated through the network in waves, a delay in responding to a query can have a significant and unpredictable effect as potentially incorrect or outdated data is rapidly propagated through the network. Further, when a PE receives multiple queries relating to the same data, it must store or 'stall' one or more of the queries in a portion of its memory while each query is serviced in turn. The hardware must therefore be designed to account for this by ensuring each PE has sufficient memory, increasing system complexity and space requirements, but also significantly increasing costs. In addition, because neighbouring processing elements may simultaneously attempt to access each other's data, separate input and output connections are required between a given PE and each of its neighbouring PEs (i.e. two connections between the given PE and each neighbouring PE). Also, in some prior approaches, due to the complexity of associating the PEs with nodes in a hypergraph, it has been necessary to build a three-dimensional array / network of processing elements in order to process the syndrome data. This hardware arrangement is complex, expensive, and gives rise to space and heating inefficiencies. The present application seeks to address these and other disadvantages encountered in the prior art by providing an improved computer-implemented quantum error correction method for decoding a quantum error correction code from a quantum computer, and an improved system suitable for implementing such a method. Summary According to an aspect of the invention, a computer-implemented quantum error correction method is provided, for decoding errors in a quantum computer system. The quantum computer system comprises a decoder apparatus and a register of quantum devices. The decoder apparatus comprises a plurality of processing elements, PEs. The method comprises: receiving, at the decoder apparatus, syndrome data representative of an error state of the quantum devices in the register of quantum devices, the syndrome data comprising a plurality of defects, wherein the syndrome data is representable as a decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices. Each PE of the plurality of PEs is associated with one or more nodes of the decoding hypergraph. The method further comprises performing, by the plurality of PEs, a clustering algorithm, the clustering algorithm comprising a plurality of steps, wherein the clustering algorithm grows and merges clusters of nodes based on the number of defects in each cluster until a final cluster state is reached. The method also comprises determining, by the decoder apparatus, a correction for the error state based on the final cluster state; wherein the PEs are grouped into a plurality of groups of PEs, wherein the groups of PEs perform at least a subset of the steps of the clustering algorithm sequentially such that PEs in a first group perform one or more first steps of the clustering algorithm, and then PEs in a second group perform the one or more first steps of the clustering algorithm. Grouping nodes and performing at least some steps of the algorithm sequentially (and, optionally, successively) as described herein significantly reduces the chance of two PEs attempting to access a dedicated memory of another PE at the same time. In turn, this reduces the likelihood of incorrect information being propagated through the network of PEs. This improves the decoding rate, in turn making fault-tolerant quantum computing more achievable for a larger category of problems. A PE is said to be associated with a node if the PE performs the steps of the clustering algorithm in respect of that node, and / or if the dedicated memory of the PE stores attributes relating to the node. The method may further comprise obtaining, at a quantum processing unit (QPU) of the quantum computer system, the syndrome data by measuring a plurality of syndrome qubits of the QPU. For example, the syndrome data may be obtained by measuring a plurality of syndrome qubits at the QPU (e.g. surface code stabiliser measurements). The decoder may receive the syndrome data as raw (e.g. analogue) measurement data, or the syndrome data may be pre-processed (e.g. processed into digital form by a control system). Optionally, as explained herein, the subset of the steps of the clustering algorithm performed sequentially is a 'first' subset, and a second subset of the steps may be performed in parallel with one another. The steps may be split between the first or the second subset depending on which stage of the clustering algorithm they are associated with, and according to which steps will benefit from being performed sequentially. In particular, steps where processing elements require access to the memory of a neighbouring processing element may be placed in the first subset. Optionally, the PEs in the first group perform the one or more first steps in parallel with each other, and the PEs in the second group perform the one or more first steps in parallel with each other. Optionally, each node on the hypergraph has a plurality of neighbouring nodes. Optionally, for any particular node on the hypergraph, the neighbouring nodes of the particular node are either associated with the same PE as that associated with the particular node; or associated with a different PE in a different group to the PE associated with the particular node. Following the grouping rules described herein, the groups are arranged such that conflicting requests are significantly less likely to occur, or else such that these conflicting requests cannot occur at all. The above two requirements can be met in a number of ways; for example it is possible for one neighbour of a particular node to be associated with the same PE as the particular node (with these PEs being in a particular group), while another neighbouring node of the particular node may be associated with another PE (with this 'other' PE being in a different group to the particular group). Optionally, neighbouring PEs are coupled via a bidirectional link, wherein neighbouring PEs are those PEs associated with nodes which neighbour one another on the hypergraph. Employing the present methods, neighbouring PEs can no longer simultaneously attempt to access each other's data. Therefore, the present methods simplify the accompanying hardware. In particular, a single bidirectional link can connect neighbouring PEs, rather than the two separate input and output links required by prior decoding hardware designed to implement prior approaches. In this way, the number of connections between PEs can be halved. This improved simplicity in hardware design is beneficial for several reasons, in particular because the resulting hardware is simpler to design, manufacture, and is significantly less expensive. Optionally, the neighbouring nodes are connected to the particular node by one hyperedge on the hypergraph. Optionally, there is a distance of at least three hyperedges between a first node associated with a PE in the first group and any other node associated with another PE in the first group. Optionally, there is a distance of at least three hyperedges between any two nodes associated with different PEs in the same group. Applying the above grouping rule not only reduces the chances of conflict occurring, but eliminates the possibility altogether. To aid understanding of the above grouping rule, it should be understood that nodes are grouped such that different PEs in the same group do not have any neighbouring PEs in common. Optionally, each hyperedge connecting any two nodes in the hypergraph either connects two nodes which share an association with the same PE; or is associated with (e.g. is representative of) a bi-directional data link which couples two PEs associated with the any two nodes. Optionally, each PE of the plurality of PEs comprises its own dedicated memory, wherein neighbouring PEs are PEs associated with two nodes which neighbour each other in the hypergraph, and wherein the one or more first steps of the clustering algorithm comprise each PE reading data from and / or writing data to the dedicated memory of at least one of its neighbouring PEs. As described herein, by applying the presently disclosed methods, the dedicated memory requirement at each PE can be reduced, since conflicting queries from nearby and neighbouring nodes are either significantly reduced or else removed altogether, since it removes the need to provide memory at each PE which would, in the absence of the disclosed methods, be essential to provide for a scenario in which a PE is required to stall a request from a neighbouring PE during a conflict. Optionally, the dedicated memory of each PE stores attributes relating to the one or more nodes associated with the PE. Optionally, the attributes comprise one or more of an index of the node, a cluster index, a growth parameter, a defect flag indicating whether the node is associated with a defect, an activity flag indicating whether the node and / or a cluster to which the node belongs is active, a parity flag indicating a parity of the node, and a busyness flag indicating whether the node is busy. Optionally, each PE reading data from and / or writing data to the dedicated memory of at least one of its neighbouring PEs comprises reading an attribute and / or updating an attribute in the dedicated memory of the at least one neighbouring PE. Optionally, the PEs are grouped into the plurality of groups of PEs, and the groups of PEs perform the steps of the clustering algorithm sequentially, such that no two PEs attempt to access a dedicated memory at the same time. Optionally, each PE is associated with a plurality of nodes of the decoding hypergraph. Optionally, each step of the clustering algorithm is associated with a stage of a plurality of stages of the clustering algorithm. Optionally, the stages of the clustering algorithm comprise at least a growth stage, wherein, in the growth stage, one or more PEs update a growth parameter associated with at least one of its associated nodes by one unit up to a maximum growth parameter value, and store the updated growth parameter in its dedicated memory. Optionally, the stages of the clustering algorithm comprise a merge stage; wherein, in the merge stage, one or more PEs query the dedicated memory of a neighbouring PE to determine whether a sum of the growth parameters of the neighbouring nodes meets a growth parameter threshold; and if the growth parameter threshold is met, the one or more PEs additionally determine whether one or more merging criteria are met; and if the one or more merging criteria are met, the one or more PEs merge the clusters by updating a cluster index in their dedicated memories. Optionally, the one or more merging criteria are based on a cluster index value stored in the dedicated memory of the neighbouring PE. Optionally, the one or more PEs that update a growth parameter and / or that query the dedicated memory of a neighbouring PE are those PEs associated with a node which is active, wherein active nodes form part of an active cluster, wherein an active cluster is a cluster with an odd number of defects and which has not merged with one or more boundary nodes of the hypergraph. Optionally, the groups of PEs perform the steps of each stage of the clustering algorithm sequentially and successively such that each group moves through the stages of the clustering algorithm. Optionally, the groups of PEs perform the steps of each stage of the clustering algorithm sequentially such that: in a first stage, the PEs in the first group perform one or more steps associated with the first stage, then PEs in the second group perform the one or more steps associated with the first stage; and in a subsequent second stage: the PEs in the first group perform one or more steps associated with a second stage, then PEs in the second group perform the one or more steps associated with the second stage. Optionally, the groups of PEs perform the steps of each stage of the clustering algorithm until a stopping criterion is reached. Optionally, the final cluster state is reached when the stopping criterion is reached. Optionally, the stopping criterion is reached when each cluster of the decoding hypergraph either comprises an even number of defects; or reaches the boundary of the decoding hypergraph. Optionally, the quantum error correction method is a surface code error correction procedure. Optionally, the PEs are grouped using a graph colouring method. Optionally, the quantum devices are qubits. Optionally, the decoding hypergraph is a decoding graph, and wherein the hyperedges are edges. Optionally, the method further comprises: measuring a logical state encoded in the quantum devices of the quantum computer to obtain a logical state measurement; and applying the correction for the error state to the logical state measurement. Optionally, each of the plurality of PEs is associated with a respective batch of nodes of the decoding hypergraph, each batch containing a plurality of nodes; and wherein each PE of the plurality of PEs performs one or more first steps of the plurality of steps of the clustering algorithm by performing the first steps in respect of each of the nodes in its batch of nodes successively. According to another aspect of the present invention, a quantum computer system is provided, comprising a register of quantum devices; and a decoder apparatus comprising a processor, a plurality of processing elements, PEs, and computer memory. The computer memory stores a decoding hypergraph for a quantum error correction code, the decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices, wherein each PE of the plurality of PEs is associated with one or more nodes of the decoding hypergraph. The computer memory also stores instructions which, when implemented by the decoder apparatus, cause the decoder apparatus to perform any of the methods set out above or disclosed herein. According to another aspect of the present invention, a computer-readable medium is provided, comprising instructions which, when executed by a quantum computer system, cause the quantum computer system to perform any of the methods set out above or disclosed herein. Figures Specific implementations are now described, by way of example only, with reference to the drawings, in which: Figures la-e show an example of a process for decoding a patch of surface code using a clustering decoder; Figure 2 is a flowchart depicting a local clustering decoder algorithm according to the present disclosure; Figure 3a-h show an example of a process for decoding a patch of surface code using a local clustering decoder algorithm; Figure 4a is a decoding graph with multiple decoding rounds; Figure 4b is a decoding graph of Figure 4a from a different perspective; Figure 5 is a graph depicting a method according to the present disclosure; Figure 6 is a graph depicting a grid of processing elements; Figure 7a depicts a graphical representation of a grid of processing elements; Figure 7b depicts the square of the graph of Figure 7a; Figure 7c depicts the graph of Figure 7b with grouped nodes using a method according to the present disclosure; Figure 8 depicts a flowchart of the scheduling of the graph in Figure 7c; Figure 9 depicts the graph of Figure 7a with grouped processing elements; Figure 10 is an example embodiment of a quantum computer system; Figure 11 is an example embodiment of a computer program product. Detailed Description In overview, and without limitation, the application discloses a method for decoding errors in a quantum computer system. Quantum devices, for example qubits, associated with quantum computer systems are inherently noisy and prone to error. Syndrome measurements do not disturb quantum information encoded on the quantum devices, but the resulting data can be used to identify and diagnose errors. Syndrome data can be represented on a decoding hypergraph with nodes and hyperedges. As described above, it is known to use clustering algorithms on the syndrome data, to grow and merge clusters of nodes based on the number of defects in each cluster until a final cluster state is reached. When perform!ng this type of algorithm on specialised decoding hardware comprising a plurality of processing element (PEs), an issue may be encountered where multiple PEs need to access the same data at the same time. In approaches of the present disclosure, processing elements are grouped, and the groups of PEs perform the steps of the clustering algorithm sequentially in a manner which means that no two PEs attempt to access a dedicated memory of another PE at the same time. This is achieved by grouping the PEs such that PEs in a first group perform one or more first steps of the clustering algorithm, and then, afterward, PEs in a second group perform the one or more first steps of the clustering algorithm. In particular implementations, the PEs are associated with one or more nodes, and the PEs are grouped in a way which takes particular account of each nodes' neighbouring nodes in the hypergraph. For example, to further reduce the likelihood of PEs requesting access to the same resource at the same time, the PEs may be associated with nodes, and the PEs may be grouped, such that for any particular node in the hypergraph, its neighbouring nodes are either associated with the same PE as the particular node (in which case the PE can allocate tasks to the particular node and the neighbouring node such that no conflict arises), or are associated with a PE in a different group to the PE associated with the particular node (in which case, because the groups of PEs perform the steps of the algorithm sequentially and successively, conflicting requests for data cannot arise). Methods of the present disclosure speed up the decoding method compared to prior methods, in part by reducing the likelihood of incorrect information being propagated through the network of PEs. The present methods also simplify the hardware required to implement the error correction method by avoiding the need to implement data integrity measures or atomic memories. For example, since the groups are arranged such that conflicting requests do not occur, there is no need for dedicated memory at each PE which is available in the event that a PE is required to stall a request from a neighbouring PE. Also, because neighbouring PEs may no longer simultaneously attempt to access each other's data, the present methods also simplify the hardware required to implement the methods. A single bidirectional link can connect neighbouring PEs, rather than the two separate input and output links required by prior decoding hardware designed to implement prior approaches. In this way, the number of connections between PEs can be halved. Decoding sufficiently quickly to keep up with the sheer volume of syndrome data is one of the key limiting factors for achieving fault tolerant quantum computation. Improving the rate of decoding, as in the disclosed method, is therefore extremely beneficial in terms of increasing the rate at which this large volume of data can be processed, and therefore making fault-tolerant quantum computing more achievable. The improved scheduling and use of bidirectional links improves the simplicity of the hardware designs. The simplicity in hardware designs is beneficial due to the large number of quantum devices needed in these hardware designs and also due to their volatile nature. A quantum computing system (also referred to herein as a quantum computer or quantum computer system) is a computing system that exploits quantum mechanical phenomena (i.e. using quantum devices). The quantum devices may be any quantum devices capable of storing quantum information (i.e. any devices suitable for encoding information using quantum computational states). The quantum devices may be qubits. Alternatively, the quantum devices may be other devices capable of storing quantum information, such as qudits or qutrits. While the description herein will primarily refer to qubits, any reference herein to qubits should be understood to also encompass other types of quantum devices unless explicitly stated otherwise. Building a useful fault-tolerant quantum computer will require quantum error correction hardware that can receive and process enormous amounts of error information (i.e. syndrome data) in real-time almost instantaneously. A delay in decoding can lead to the creation of a backlog that grows exponentially with the size of the computation, which will ultimately lead to failure of the quantum computation. The speed of the decoder acts as a bottleneck to the number of qubits in a quantum error correction code (and therefore also as a bottleneck to reducing logical error rates). Improvements to decoding hardware and algorithms help to prevent this backlog, thereby enabling quantum computers with higher numbers of qubits and lower error rates because faster decoders can handle quantum error correction codes involving more data qubits, and using more data qubits leads to a reduction in logical error rates when performing fault-tolerant quantum computation. Quantum error correction codes generally involve decoding a "syndrome", which can be considered to be a signature associated with an error state of the physical qubits in the code (two different errors can potentially have the same syndrome). A "decoder" is then used to identify an error which could have caused the syndrome (or possibly just a correct operation that can be used to correct the logical qubit states encoded in the code e.g. a single bit representing whether the eventual logical measurement outcomes need to be flipped). Decoding hypergraphs (especially decoding graphs) are used in many error correction codes (such as topological error correction codes including the surface code) to facilitate decoding of the syndrome by grouping "defects" in the syndrome (these defects generally provide an indication of end points of chains of errors on physical data qubits in the error correction code). A decoding hypergraph is a hypergraph (in the mathematical sense) comprising hyperedges representing error mechanisms, and nodes (or vertices) representing differences in successive syndrome measurements (or more generally, a decoding hypergraph comprises nodes representing detectors, which are measurement results that sum to zero (e.g. modulo 2 sum) during perfect (i.e. error-free) operation of the quantum computing system). The decoding hypergraph may have one or more boundaries, which involve hyperedges extending beyond the hypergraph (e.g. to one or more virtual boundary nodes), i.e. the decoding hypergraph may be a sub-hypergraph of a larger hypergraph including the virtual boundary node(s)). Conventionally, some error correction literature has referred to "rough" boundaries and "smooth boundaries". However, the "smooth" boundaries in such literature are not actually boundaries in the above sense, and they will not be referred to as boundaries in the present disclosure. Accordingly, the boundaries referred to herein are synonymous with the "rough" boundaries in such literature. Clustering algorithms decode syndromes by clustering defects into groups. A cluster of decoding graph edges is formed around each defect (defects are located at a subset of nodes of the decoding graph), and these clusters are grown by including additional edges until all defects are included in a cluster containing an even number of defects (or the cluster touches a boundary of the decoding graph), with overlapping clusters being merged after each growth stage. Correction(s) to the encoded logical state can then be determined based on the clustering of defects. A syndrome (also referred to as syndrome data) is a collection of values (e.g. measurement values, generally based on qubit measurements, in particular syndrome qubit measurement) representative of an error state of physical data qubits in the quantum computer. The syndrome may also include decoding hypergraph location information for each syndrome value - e.g. a coordinate or index value. Syndrome data may be obtained by measuring a plurality of syndrome qubits (e.g. surface code stabiliser measurements). The decoder may receive the syndrome data as raw (e.g. analogue) measurement data, or the syndrome data may be pre-processed (e.g. processed into digital form by a control system). A defect (also referred to as an excitation or measurement event) generally represents the end of a chain (or hyperchain) of errors in the decoding hypergraph (the chain of errors may span both space-like and time-like dimensions of the decoding hypergraph). Defects are non-trivial syndrome values, and they may correspond to a change in value of a syndrome qubit measurement outcome between successive rounds of syndrome measurement. A decoding system (also referred to herein as a decoder or quantum error decoding system) is a classical computing system that decodes syndromes and provides one or both of (i) possible error locations (i.e. which data qubits may have experienced an error), and (ii) a correction for the qubit error state. It is possible to determine a correction during decoding without determining error locations, and the correction may be a single bit representing whether a logical error has occurred. The correction can generally be tracked by a classical computer (e.g. by the decoder or a control system) and does not generally need to be applied to the quantum devices. The decoder may be a dedicated hardware device (e.g. implemented using an FPGA or ASIC or similar) or it may be a software component implemented using a CPU. The quantum error correction code may be a surface code (e.g. planar code) error correction procedure. Alternatively, the quantum error correction code may be any other error correction code that utilises a decoding hypergraph (e.g. a decoding graph), such as other topological quantum error correction codes. The decoding hypergraph may be a decoding graph, and the hyperedges may be edges. A hypergraph is a generalisation of a graph in which edges ("hyperedges") can be connected to more than two nodes (graphs are a specific type of hypergraph in which each edge connects to two nodes). The methods of the present invention apply equally to decoding hypergraphs. Accordingly, any reference herein to decoding graphs and edges should be understood to also encompass decoding hypergraphs and hyperedges respectively. The quantum computing system (e.g. a control system of the quantum computing system) may be further configured to measure a logical state encoded in the quantum devices and apply the correction to the measured logical state (the correction may be applied at the control system, at the decoding system or at some other subsystem of the quantum computing device, such as a device operating at the algorithmic / application layer of the quantum stack). The clusters may also be referred to as sets / groups / collections, or any similar term that refers to a grouping of defects. The quantum error correction method may be a surface code (e.g. planar code) error correction procedure. Alternatively, the quantum error correction method may be any other error correction procedure that can be decoded by grouping defects on a decoding graph, such as other topological quantum error correction codes. One skilled in the art will appreciate that the details of how the correction is identified, and how it is based on the clusters of defects, will depend upon the configuration of the error correction method in question. For example, identifying the correction for the error state may comprise: identifying a logical operator for the quantum error correction method involving physical qubits of the quantum computer system that are associated with the boundary of the decoding graph; determining a parity of a total number of clusters that the logical operator intersects that contain an odd total number of defects, wherein an even parity indicates that the logical operator is in a correct logical state and an odd parity indicates that the logical operator is in an incorrect logical state. The parity of a cluster can be described in terms of different bases, for example a parity can be discussed as being even / odd, or 0 / 1. These definitions may be used interchangeably herein. Parity can be discussed in terms of nodes and clusters, and may be used somewhat interchangeably. Initially, the parity of a node, and therefore the parity of its cluster, is dependent on whether the node is a defect or not. For example, a node that is a defect will have an odd parity and a node that is not a defect will have an even parity. Figures la-e depict an example of a process for decoding a patch of surface code using a clustering decoder. The aim of clustering decoders is to cluster defects together into a set of decodable clusters. Several different variants of clustering algorithms exist, and one skilled in the art will appreciate that other clustering decoding algorithms may be used instead of or as well as that shown in Figures la-e. Figures la-e depict decoding graphs 110,120,130,140 and 150. Figures la-e depict stages of the clustering process, where Figure la is the first stage and Figure le is the last stage of this example clustering process. Conventional decoding algorithms primarily focus on error mechanisms that leave qubits in a computational basis state (e.g. some superposition of the |0) and |1) states), such as bit-flip and phase-flip errors. The circles on the decoding graphs 110,120,130,140,150 depict nodes of the decoding graph. The nodes of the decoding graphs 110,120,130,140,150 correspond to syndrome qubits. With no errors, syndrome qubits are in the |0) state, as illustrated by the empty circles in Figures la-e. The hashed circles in Figures la-e correspond to defects, i.e. syndrome qubits in the |1) state. In Figures la-e, the defects are labelled as 112a-f in the decoding graphs. The numbering of the rows (from 0-6) and columns (from 0-7) of the nodes on the decoding graph is included for ease of reference. The edges of the decoding graphs 110,120,130,140,150 correspond to data qubits, with weights determined by the error probability. The decoding graphs have some edges that only connect to a single node; these edges represent boundaries of the decoding graph. The boundaries can conceptually be considered to all connect to one or more virtual nodes / boundary nodes. One skilled in the art will appreciate that the nuances of the decoding graph will depend upon the error correction code being implemented, and that some decoding graphs (e.g. those for toric codes) do not have boundaries. The concept of boundaries can be extended to hyperedges, in which hyperedges at a boundary may connect to a virtual node in addition to one or more nodes of the decoding hypergraph. While the graphs in Figure la-e can be used as basic decoding graphs, it is also possible to use more complex decoding graphs, for example with an extra dimension representing time, in which there is not necessarily a one-to-one correspondence between data qubits and decoding graph edges. One skilled in the art will appreciate that the physical qubits do not necessarily need to be physically arranged as shown in Figures la-e. Figure la shows a first graph 110, depicting an example decoding graph. In this example, there are 6 defects 112a-f in the decoding graph. Decoding algorithms such as clustering algorithms may be used to decode the defects 112a-f. The illustrated clustering algorithm begins by placing each defect 112a-f in its own cluster. The defects 112a-f may be referred to as the first defect 112a, second defect 112b, third defect 112c, fourth defect 112d, fifth defect 112e and sixth defect 112f. This naming convention is used for ease of reference, and not indicative of any order associated with the defects. Figure lb shows a second graph 120, depicting the result of a first stage of growth using the clustering algorithm. In graph 120, each cluster has grown out by a half-edge in each of the four directions of the decoding graph. The growth of each cluster is depicted by bold black lines along the edges of the graph. Each of these clusters has grown due to the presence of an odd number of defects in each cluster, specifically one in each cluster, in this case. In Figure lb, by growing each cluster out by half-edges of the graph, two pairs of clusters have connected; the cluster containing the first defect 112a is in contact with the cluster containing the second defect 112b, and the cluster containing the third defect 112c is in contact with the cluster containing the fourth defect 112d. Any clusters that are touching will merge into a larger cluster, such that there is a cluster containing the first defect 112a and second defect 112b, and another cluster containing the third defect 112c and fourth defect 112d, in this example. In each iterative round of the clustering algorithm, each cluster containing an odd number of defects may extend outwards by a half-edge of the graph, dependent on whether or not the cluster is connected to a boundary. Each cluster containing an even number of defects stops growing. As both of these clusters now contain an even number of defects, they will stop growing. As the clusters containing the fifth defect 112e and sixth defect 112f remain isolated (containing an odd number of defects), they will keep growing. Clusters with an even number of defects can be said to have an even parity, and clusters with an odd number of defects can be said to have an odd parity. Figure lc shows a third graph 130, depicting the result of a second stage of growth using the clustering algorithm. As the clusters containing the fifth defect 112e and sixth defect 112f contained an odd number of defects in graph 120, in the second growth stage both of these clusters grew by half an edge in each of the four connected edges of the decoding graph. After the second stage of growth, the cluster containing the fifth defect 112e still only contains one defect. However, the cluster containing the sixth defect 112f has reached the boundary at point (0, 2) on the decoding graph. A cluster that has reached a boundary will not grow further, and therefore the cluster containing the sixth defect 112f will stop growing. Figure Id shows a fourth graph 140, depicting the result of a third stage of growth using the clustering algorithm. After the third stage of growth, the cluster containing the fifth defect 112e touches the cluster containing the third defect 142c and fourth defect 142d. Therefore a larger cluster is formed containing the third defect 112c, fourth defect 112d and fifth defect 112e. As this cluster has an odd number of defects and is not touching the boundary, this cluster will keep growing. Figure le shows a fifth graph 150, depicting the result of a fourth stage of growth using the clustering algorithm. After the fourth stage of growth, there are two clusters in the decoding graph 150. Both of the clusters in the decoding graph 150 are "neutral" clusters (which may also be referred to as stable clusters): a first neutral cluster 152 and a second neutral cluster 154. Each of the two remaining clusters is "neutral" due to having an even number of defects and / or having met the boundary. The first neutral cluster 152 contains the third defect 112c, fourth defect 112d, fifth defect 112e and sixth defect 112f. This first cluster 152 is formed due to the cluster containing the third defect 112c, fourth defect 112d and fifth defect 112e meeting the cluster containing the sixth defect 112f. The second neutral cluster 154 contains the first defects 112a and the second defect 112b. The second neutral cluster 154 has not grown since the first stage of growth, depicted in Figure lb. The first neutral cluster 152 contains 4 defects and the second neutral cluster 154 contains 2 defects. As the first neutral cluster 152 and the second neutral cluster 154 both contain an even number of defects, both the first neutral cluster 152 and the second neutral cluster 154 stop growing. It can also be noted that the first neutral cluster 152 is also connected to the boundary and this alone could be enough to make the cluster "neutral", regardless of whether the cluster contains an odd or even number of defects. As all the defects are in "neutral" clusters, the clusters can now be decoded by any conventional means. For example, the error can be decoded by defining a logical operator involving edges at a boundary of the decoding graph (e.g. the boundary edges on either the left or the right side of the decoding graph in Figure 4a-e) and counting how many clusters this logical operator intersects that contain an odd total number of defects. If the parity of this count is even, then the defined logical operator is considered to be free from error. However, if the parity is odd then the defined logical operator is considered to be in an error state, and its logical value should be flipped when it is measured. In this way, a single bit can be used to track the error state of the defined logical operator (i.e. it is not necessary to determine physical qubit error locations and physical qubit corrections). Upon using prior art approaches to cluster decoding, data conflicts can occur when processing elements associated with nearby or neighbouring nodes attempt to access the same information. For example, with reference to the example described above, when the cluster containing the first defect 112a met the cluster containing the second defect 112b, the edges of the two clusters may be growing out at the same rate, and therefore each cluster may require to 'know' about the other cluster's presence at the same time. With reference to figures 1-e, and assuming a 1:1 mapping between processing elements (on the decoding apparatus) and nodes (on the hypergraph), it is possible that, as the clusters grow using the prior algorithm, a first processing element associated with a first node may have requested information from a second, neighbouring processing element associated with a second node, at the same time the second processing element made the same or a similar request for information to the first processing element. Because the hardware implementing the prior art method must account for this possibility, separate input and output connections between each neighbouring processing element are required so that a node can both make queries and receive them at the same time. In addition, while the first processing element requests information from the second processing node, it is also possible that a third processing element associated with a third node requested information from the second processing node at the same time. Because the hardware implementing the prior art method must account for this possibility too, each processing element must have sufficient memory requirements to enable a request from a node to be stalled. For example, in this scenario, the second processing element must have sufficient memory to stall the request from the third processing element while the request from the first processing element is dealt with. While reference has been made primarily to requests for information, processing elements associated with neighbouring nodes may also write (not just read) information in each other's memories while performing the decoding algorithm. Therefore, the possibility arises that a first processing element may be stalled in its attempt to update information in a neighbouring second processing element's memory, while a request from a third processing element reads that same information. This scenario stalls the ability of nodes to update their neighbouring nodes with correct information, which in turn enables incorrect information to be passed through the network of nodes, further slowing down the decoding process. In order to achieve conflict-free scheduling, the presently disclosed decoding algorithm may be adapted. For example, the present approaches may make use of a parallelised clustering decoder. An example of a parallelised algorithm that can be used in this conflict-free scheduling method is a local clustering decoder (LCD) algorithm. LCD is a distributed parallelised clustering decoder. Figure 2 depicts, at a high-level, the stages of a new clustering algorithm 200. The flowchart of figure 2 could also be described as a state transition diagram. The new algorithm may be described as a parallelised LCD algorithm. The algorithm 200 comprises several stages, including an initialisation or initialising stage 205, a growing or growth stage 210, a merging stage 215, a picking stage 220, a syncing stage 225 and a stopping or exiting stage 230. The algorithm 200 comprises several steps, where each step is associated with one of the stages depicted in fig. 2. Each processing element is configured to perform the steps of algorithm 200 in respect of its associated node or nodes, such that all of the processing elements perform the LCD algorithm collectively, and together. Examples of code which could be used to implement each stage of the algorithm 200 are provided below, on the final pages of the description. The algorithm comprises several conceptual similarities with the algorithm described above with respect to figures la-e, and reference to the accompanying description of figures la-e may aid understanding of the algorithm 200. Each step of the algorithm 200 may be performed by one or more nodes at any given time. The description of the algorithm 200 may refer to a node in question, or a 'particular' node, where the node in question may be any single node in the decoding graph at a point in time. Also, the description of the algorithm 200 may sometimes refer to a node taking action, such as a node checking information with a neighbouring node. The skilled person will understand that this is shorthand for the processing element(s) associated with the node(s) taking the action. In addition, the present disclosure may refer to a node "growing", or "merging with its neighbour", and the like. Again, the skilled person will understand that this is shorthand for the associated processing elements performing actions such as updating a growth parameter associated with a particular node, or updating a cluster index associated with a particular node, and the like. As will be explained, according to the present disclosure, PEs are grouped. In particular, the PEs are grouped into a plurality of groups of PEs. These groups of PEs perform the steps of each stage of the clustering algorithm sequentially and successively, such that each group moves through the stages of the clustering algorithm. Groups of PEs may perform the steps of each stage of the clustering algorithm sequentially; for example, in a first stage of the clustering algorithm, the PEs in a first group of PEs may perform one or more steps associated with the first stage, then PEs in the second group perform the one or more steps associated with the first stage, then PEs in the third group perform the one or more steps associated with the first stage, and so on until each group of PEs has performed the one or more steps. In a subsequent second stage, the PEs in the first group may perform one of more steps associated with the second stage, then PEs in the second group may perform the one or more steps associated with the second stage, and so on. In this way, conflicts between neighbouring nodes can be avoided. The PEs are grouped such that conflict is avoided between neighbouring nodes (i.e. nodes connected to each other by one hyperedge on the hypergraph). For the effects of the grouping to be maximised, the groups should be formed such that no node has a neighbouring node which is associated with a different PE, where those PEs are in the same group. In other words, for any particular node on the hypergraph, the neighbouring nodes of the particular node must be either: i) associated with the same PE as that associated with the particular node (in which case the PE can schedule tasks for the neighbouring nodes to avoid conflict, for example by assigning each node in its 'batch' of nodes the steps of the algorithm successively as will be explained); or ii) associated with a different PE to the PE associated with the particular node, where these PEs are in different groups (in which case, since the groups of PEs perform tasks successively rather than at the same time, the neighbouring nodes will never send conflicting requests to one another). Further to point i), these neighbouring nodes form part (or all) of the "batch" of nodes associated with that PE, as will be explained. In some implementations of the present disclosure, each of the plurality of PEs is associated with a respective batch of nodes of the decoding hypergraph, where each batch contains multiple nodes. In this implementation, each PE performs one or more first steps of the clustering algorithm by performing them in respect of each of the nodes in its batch of nodes successively. In other words, each PE with a batch of nodes performs tasks in respect of each of its associated nodes in sequence. In this way, conflict between nodes in the same batch is avoided. Further to point ii), according to the present disclosure, neighbouring PEs (i.e. PEs associated with nodes which neighbour one another on the hypergraph) can be coupled via a bidirectional link. Figure 2 depicts an algorithm 200 for clustering nodes in a decoding hypergraph or graph. The growth of clusters on a decoding graph is often described in terms of tree growth, where a cluster may be referred to as a "tree". Continuing this analogy, each cluster has a "root" node, whereby all nodes in a cluster are descended from the root node. As a cluster grows, the root node may become the "parent" to other nodes in the cluster, as more nodes are added to the edge of the cluster. The edge of the cluster may also be known to the skilled person as the "boundary" of the cluster. Similarly, a new node added to a cluster may be described as a "child" node to a parent node. Therefore a large cluster will exhibit a series of child-parent relationships along the branches of the cluster tree, all the way back to the root node. If a child node has an odd parity, it may be described herein as an odd child. At the beginning of the algorithm 200, each node is the root of its own cluster tree, as there is one node per cluster. As a cluster grows, the root of the cluster may change, for example upon merging with one or more other clusters. Clusters may be associated with an activity status. The activity status of a cluster is either active or inactive. An active cluster is a cluster that comprises an odd number of defects and is not touching a boundary of the decoding graph. A node is active if its cluster is active. Therefore, an active cluster and an active node may be used somewhat interchangeably. A cluster is inactive if there are an odd number of defect nodes in the cluster or the cluster meets the boundary of the decoding graph. When a cluster is inactive, all the nodes within that cluster will be inactive, such that all the nodes in the cluster will stop growing. Therefore an inactive cluster and an inactive node may also be used somewhat interchangeably. A node that is a defect will initially be active and a node that is not a defect will initially be inactive. Therefore, the activity of a node, and hence a cluster, may be related to the node's parity. Processing elements and / or nodes may be deemed busy or not busy. Multiple processing elements may be connected to a controller, in which the controller controls the processing of each processing element it is connected to. For example, the controller instructs processing elements to be in certain stages of the method 200. A processing element becoming busy is used to flag to the controller that something has changed. In the situation where each processing element is associated with a plurality of nodes, a processing element is busy when at least one of its nodes is busy. For example, a node is busy if its data changes during the merging or syncing stages, as described below. If a node is busy, the controller must re-run the current stage to allow the other processing elements to process the change that has occurred to the node. In implementations of the present disclosure, one node may be assigned to each processing element, e.g. in a 1:1 mapping. Alternatively, multiple nodes may be assigned to each processing element. As set out above, the multiple nodes assigned to a processing element may be referred to as a "batch" of nodes. Equivalently, similar words such as "group" may be used to refer to the multiple nodes assigned to a processing element. When multiple nodes are associated with each processing element, the stages of the method 200 may be performed with an extra outer loop, such that each stage of the method 200 is performed for each node in the batch. This is best appreciated by inspection of the code listings provided toward the end of this description. At step 205, the LCD algorithm is in the "initialising" stage. The initialising stage may include setting up initial parameters associated with the decoding hypergraph used in the algorithm 200. Each PE comprises its own dedicated memory, and this memory is used to store attributes relating to the one or more nodes associated with the PE. For PEs which have a batch of nodes, the dedicated memory is used to store information associated with each node in the batch. The attributes associated with each node may comprise one or more of an index of the node, a cluster index, a growth parameter, a defect flag indicating whether the node is associated with a defect; an activity flag indicating whether the node and / or a cluster to which the node belongs is active; a parity flag indicating a parity of the node, and a busyness flag indicating whether the node is busy, and the like. Stage 205 comprises initialising these attributes to starting values. For example, step 205 may comprise assigning each node a node index. At step 205, each node in the decoding graph is assigned to its own cluster, so that each node is initialised with its own cluster index. Therefore at step 205, the node index and cluster index may be the same. The parent of each node may be initialised to be the node itself. In other words, each node is initialised to be the root of its own singleton cluster. In an example, non-limiting implementation, attributes for each node, and their initialised values, may be as follows: nindex The index of the node. Must be in [2, N), where N is the number of nodes in the decoding graph. The indices 0 and 1 are reserved for the boundary nodes on the left and right-hand side of the patch cindex The index of the node's cluster. Must be in [0, N), where N is the number of nodes in the decoding graph. Initially, node. cindex = node, nindex parent The parent of the node in the tree of its cluster. Must be in [0, N), where N is the number of nodes in the decoding graph. Initially, node . parent = node Growth parameter The degree to which the node has grown. Must be in [0, 2], where 0 represents un-grown, 1 half-grown and 2 fully-grown. Initially, node. growth = 0 defect True if the node is defective. Must be in [0,1], since this is a Boolean flag. Initially, node . def ect = syndrome [node . nindex] active True if the node is active. Must be in [0,1], since this is a Boolean flag. Initially, node. active = node, def ect parity True if the node is odd. Must be in [0,1], since this is a Boolean flag. Initially, node. parity = node, def ect busy True if the node is busy. Must be in [0,1], since this is a Boolean flag. Initially, node.busy = 0 As will be appreciated from the following description, algorithm 200 involves neighbouring PEs reading data from and / or writing data to the dedicated memory of their neighbouring PEs, and this comprises reading an attribute and / or updating an attribute in the dedicated memory of the neighbouring PE. At stage 210, the algorithm 200 is in the "growing" stage. In the growing stage, active nodes (i.e. those nodes in an active cluster) which haven't already reached a maximum growth parameter value have their growth parameter increased. Therefore, at stage 210, the size of one or more clusters in the decoding graph grows. In the growth stage, a PE may update a growth parameter associated with at least one of its associated nodes by one unit, and store the updated growth parameter in its dedicated memory. This may only happen if the node is active. Active nodes form part of an active cluster, i.e. a cluster with an odd number of defects and which has not merged with one or more boundary nodes of the hypergraph. A "growth parameter" is used to define the degree of growth of each node in a cluster. In practice, the growth parameter may be considered to be quantity such as a radius around a node. The growth parameter value may take values which correspond to "ungrown", "half-grown", and "fully-grown", at any point in the growth cycle of a cluster. In this example, "ungrown" is a minimum value and "fully-grown" is a maximum value of the growth parameter value. The increase of the growth parameter value from ungrown to half-grown may be referred to as one unit, and similarly the increase from half-grown to fully-grown. In an example, the growth parameter can be increased from 0 (minimum value), to 1 (half-grown), to 2 (a maximum value). Once at the maximum value, the nodes cannot be "grown" any further. A half-grown growth parameter of a node may span half an edge along each of its incident edges of the decoding graph. A fully-grown growth parameter of a node may span a full edge along each of its incident edges of a hypergraph. Therefore if two neighbouring nodes are half-grown, they are connected by one fully grown edge on the decoding graph. If instead two nodes are separated by a distance of two edges on the decoding graph, they may be connected at the stage of both of those nodes having fully-grown edges. At stage 210, any active nodesthat have an ungrown or half-grown growth parameters associated with them in the decoding graph will increase their growth parameter by a unit. Any active nodes with a fully-grown growth parameter will remain with a fully-grown growth parameter, and the edge will not continue to grow. At stage 215, the algorithm 200 is in the "merging" stage. In the merge stage, one or more PEs query the dedicated memory of a neighbouring PE to determine whether a sum of the growth parameters of neighbouring nodes meets a growth parameter threshold. Two inactive clusters, and therefore two inactive nodes, cannot be merged in the merge stage. However, the merge stage may be performed on inactive nodes in order to accurately propagate information. Only one cluster needs to be active for a merge to occur. In other words, an active cluster can merge with another active cluster, or with an inactive cluster. A growth parameter threshold is met when a fully-grown edge is formed between two neighbouring nodes. The growth parameter threshold may be met when the sum of the growth parameter values of two neighbouring nodes is equal to or greater than 2 units. For example, two neighbouring nodes would meet this criteria if they both had a half-grown edge, and were therefore connected. In the merge stage, different clusters are merged when the growth parameter threshold is met between neighbouring nodes in different clusters. When it has been determined, that two clusters should be merged, it then needs to be determined which cluster index to assign to the new cluster. Therefore, if the growth parameter threshold is met, the one or more PEs additionally determine whether one or more merging criteria are met. A purpose of the merging criteria is to determine which cluster index value to use for the new cluster. The one or more merging criteria are based on a cluster index value stored in the dedicated memory of the neighbouring PE. One or more of the merging criteria may be based on the cluster index of the neighbouring node being less than the cluster index of the node in question. If the one or more merging criteria are met for a particular cluster, the one or more PEs merge the clusters by updating a cluster index in their dedicated memories for those nodes associated with the particular cluster. If the one or more merging criteria are not met, the cluster indices are not updated for those nodes. The cluster index of multiple nodes may be updated within the dedicated memory of the same PE within the merging stage. In summary, a node will (typically) adopt the cluster index of a neighbour connected to it by a fully-grown edge if the neighbour has a cluster index less than the cluster index of the node. At the beginning of stage 215, the status of the node in question may be set to not busy. At stage 215, clusters that met during stage 210 may merge into a single, larger cluster. Typically, two clusters will meet by one fully-grown edge and they will become one single, resultant cluster during the merge. Alternatively, three or more clusters may meet at the same time by a fully-grown edge between each cluster. Alternatively, two clusters could meet by two or more fully-grown edges at one time, and so on. As the clusters merge, the status of the node is set to busy. During the merging stage 215, the cluster index, parent or parity of a node can change. When two or more clusters merge, the cluster index of one or more of the clusters may change, such that the resultant cluster has one cluster index. In this example of the algorithm 200, the cluster index of the resultant cluster is taken to be the cluster index of the merging cluster that has the lowest cluster index. However, in alternative implementations, the resultant cluster may take on another cluster index, such as the largest cluster index of the merging clusters, for example. When the node in question is connected to a neighbour by a fully-grown edge, the cluster index of the node in question is updated to be the cluster index of the neighbour if the cluster index of the neighbour is lower than that of the node in question. The parent node of the node in question may then change as the clusters merge. The node in question may become a child node to the neighbouring node. In other words, the neighbouring node may become the parent node to the node in question as the clusters merge. Once the resultant cluster is formed, a root of the resultant cluster may be allocated. The root of the resultant cluster will be decided based on the parenthood relationships in the merging clusters. For example, the root node of the resultant cluster may be the root of the merging cluster with the lowest cluster index. The root of the new larger cluster may be another node, such as the root node of the merging cluster with the largest cluster index. The parity of the resultant cluster may be decided after the merge. Each child node in the cluster relays its parity onto its parent, if the child node in question is odd. This relaying of the parity may in practice be an addition modulo two. For example, for a child node with an odd parity (i.e. a parity of 1) and its parent node with an even parity (i.e. parity of 0), the child node may relay its odd parity such that the child node has a parity of 0 and the parent node has a parity of 1. This operation will not be performed for the node which is the root of the cluster, as the root node may be defined as its own parent node. As data is being changed in this process, the node in question is set to busy when relaying the parity information to its parent. This relaying of parity information is repeated for each node within the cluster until the parity of each child node in the cluster is even. This process may be repeated multiple times for each node. For example, if at least one child node in the resultant cluster starts with an odd parity and therefore relays this parity information, this process will need to happen at least twice for each node. This is because the odd parity child node will be in the busy state. Each node in the cluster will then need to be checked again until all of the child nodes are not busy, in order to continue to the next stage. The parity of the root node will therefore represent the parity of the cluster. At the end of the merging state, the parity of each cluster will be equal to the parity of the root node, i.e. the node with the lowest index in the cluster. At stage 220, the algorithm 200 is in the "picking" stage. In the picking stage, one or more PEs update the activity of the root node associated with one or more clusters formed by one or more of their associated nodes in their dedicated memories. The parity of the root node of a cluster determines the activity of the cluster. If the root of the resultant cluster has an odd parity, the one or more PEs put the root node associated with this resultant cluster into an active state. Therefore this resultant cluster is said to be active. If the root of the resultant cluster has an even parity, the one or more PEs put the root node associated with this resultant cluster into an inactive state. Therefore this resultant cluster is said to be inactive. At the end of the picking stage, the nodes in a cluster that are not the root node are set to be inactive. Therefore, at the end of the picking stage, only the root node of a cluster will be active. At step 225, the algorithm 200 is in the "syncing" stage. In stage 225, one or more PEs update the activity flag and / or busyness flag associated with one or more nodes in their dedicated memory. The one or more PEs propagate the activity status of the root node of one or more clusters to other nodes of the one or more clusters. If the node in question is connected by a fully-grown edge to a neighbour that is active, the node in question becomes busy. By determining that these nodes are connected by a fully-grown edge, we are considering nodes that are in the same cluster. The node in question will then become active if it is busy or if it was already active before this step. The picking stage ensures that all nodes in an odd parity cluster must be active. As represented by the arrow looping from the end of the syncing stage back to the start, the syncing stage is repeated until none of the nodes are busy. The explanations of stages 205-225 have generally been given in terms of one resultant cluster. However, the algorithm 200 is scalable to multiple clusters on the decoding graph. For example, there may be multiple clusters growing simultaneously or at different times during the stages of the algorithm 200. If one or more clusters in the decoding graph are still active at the end of stage 225, the algorithm 200 goes back to the growing stage at step 210. At stage 230, the algorithm 200 is in the "exiting" stage. The exiting stage will begin once a stopping criterion is reached. The groups of PEs perform the steps of each stage of the clustering algorithm until the stopping criterion is reached. This stopping criterion defines the final cluster state. The stopping criterion is reached when each cluster of the decoding hypergraph has even parity, i.e. either comprises an even number of defects, or has reached the boundary of the decoding hypergraph. In other words, if there are no active clusters remaining in the decoding graph in the syncing stage, the algorithm 200 will continue to the exiting stage 230, in which the algorithm stops. This could include clusters that have an odd parity but have met the boundary, and therefore will not continue growing. At step 230, the decoding graph will contain one or more neutral clusters in which the errors can be decoded. Correction(s) to the encoded logical state can then be determined based on the final cluster state, i.e. based on the clustering of defects. Figures 3a-h show decoding graphs 310, 320, 330, 340, 350, 360, 370 and 380. Figures 3a-h depict a simplified example of a process for decoding a patch of surface code using the algorithm 200 depicted in figure 2. Figure 3a depicts a first stage, and Figure 3h depicts a last stage of decoding a patch of surface code. Each stage of the decoding process shown in Figures 3a-h may show the result of a stage of the algorithm 200, shown in Figure 2, as detailed below. However, stages of the decoding process may also not correspond to a stage of the algorithm 200 or may show the result of multiple stages of the algorithm 200. The circles and squares on the decoding graphs both represent nodes. The circles represent inactive nodes and the squares represent active nodes. Empty nodes represent nodes with an even parity and filled-in nodes represent nodes with an odd parity. The nodes of the decoding graphs depicted in Figures 3a-h may correspond to syndrome qubits in a quantum computing system. Each node is labelled with its cluster index above it and its node index below it. The cluster index of a node depicts the number of the cluster that the node belongs to. In Figure 3a the nodes are labelled with cluster indices 0 to 12, meaning each node belongs to a cluster numbered 0 to 12. The cluster index of a node may change through the clustering algorithm, as will be seen by inspection of Figures 3a-h. The node index of a node depicts a number associated with the node, in order to easily refer to different nodes in a decoding graph. Each node in the decoding graphs of Figures 3a-g will have a different node index to every other node in the decoding graph. The exception to this is the boundary nodes which may have the same node index as at least one other node in the decoding graph. The node index of a node stays constant through the clustering algorithm, and therefore through Figures 3a-h. In Figures 3a-h, possible connections between nodes are represented using dotted lines. While the graphs in Figure 3a-h can be used as basic decoding graphs, it is also possible to use more complex decoding graphs, for example with an extra dimension representing time, in which there is not necessarily a one-to-one correspondence between qubits and decoding graph edges. One skilled in the art will appreciate that the physical qubits do not necessarily need to be physically arranged as shown in Figures 3a-h. In Figures 3a-h, the block lines between nodes show the extent of the growth parameter of a node on the decoding graph at a particular time, i.e. ungrown, half-grown or fully-grown. The arrows on fully-grown edges display parenthood relationships between nodes, i.e. an arrow pointing from node 1 to node 2 signifies that node 2 is a parent of node 1 and similarly that node 1 is the child of node 2. Figures 3a-h contain boundary nodes 312a-c, 314a-c. The boundary nodes 312a-c, 314a-c show the nodes on the boundary of the decoding graph. The boundary nodes 312a-c are the boundary nodes on the left boundary of the decoding graph and the boundary nodes 314a-c are the boundary nodes on the right boundary of the decoding graph. The boundary nodes 312a-c each have a node index of 0 and the boundary bodes 314a-c each have a node index of 1. One skilled in the art will appreciate that the nuances of the decoding graph will depend upon the error correction code being implemented, and that some decoding graphs (e.g. those for toric codes) do not have boundaries. The graphs 310, 320, 330, 340, 350, 360, 370 and 380 may each represent information derived from the hypergraph at one of the stages of the algorithm 200 described above in relation to fig. 2. Figures 3a-h schematically depict the general process of the method 200 for this example decoding graph, however not every step of the process is shown in Figures 3a-h for simplicity and brevity. In the example decoding graph given in Figures 3a-h, all of the 12 nodes are assigned to one single processing element for simplicity. In other words, the 12 nodes are part of one PE's batch of nodes. Figure 3a shows a first graph 310. The graph 310 depicts an example decoding graph. In this example decoding graph, there are 3 defects present. The defects are at node / cluster indices 6,10 and 11. The defects are demonstrated by filled-in square nodes. The square shape of the node means that the node is active and the fact that the node is filled-in means that the node has an odd parity. All of the nodes in the graph 310 have ungrown edges. The graph 310 is included here to demonstrate the decoding problem, and therefore does not correspond directly to the result of a stage of the algorithm 200. Figure 3b shows a second graph 320. The graph 320 depicts the result of a first growing stage, correlating with stage 210 of method 200. In this first growing stage, the PE updates the growth parameter associated with the nodes at node indices 6,10 and 11, i.e. the defects. The PE updates the growth parameter of these nodes by one unit and stores the updated value of the growth parameter in its dedicated memory. In the graph 320, this updated growth parameter for defects at node indices 6,10 and 11 is shown by each of these nodes growing out by half an edge. This half-edge growth is along each of the four edges incident to each of these nodes on the decoding graph. Therefore the extent of clusters 6,10 and 11 have grown in this step. As the current stage is not syncing, the controller puts the PE into the next stage, i.e. the merging stage at stage 215 in method 200. Due to the lack of fully-grown edges, no cluster indices change. Also since there are no nodes with odd children, no parities change. Similarly, the PE moves through the subsequent picking and syncing stages (stage 220 and 225, respectively) without changing the activity of the nodes. After the syncing stage, the PE has not reached the stopping criterion as multiple clusters have an odd parity. The PE remains active and so the controller puts the PE back into the growing stage (stage 210). Figure 3c shows a third graph 330. The graph 330 depicts the result of a second growing stage, once again correlating with stage 210 of method 200. In this second growing stage, each defect / cluster (at node indices 6, 10 and 11) has grown out its growth parameter by a half-edge along all possible edges surrounding it on the decoding graph. In other words, the PE associated with each of the nodes at node indices 6,10 and 11 increases a growth parameter associated with these nodes by one unit in its memory. Therefore the extent of clusters 6,10 and 11 have grown in this step. The three clusters in the graph containing defects are now connected to each other by at least one fully-grown edge. At the same time, the cluster with cluster index 11 has met the boundary at node 0. The PE associated with the nodes of the decoding graph will then update the cluster index of the nodes associated with the clusters 6,10 and 11. Figure 3d shows a fourth graph 340. The graph 340 depicts the result of a merging stage, correlating with step 215 of method 200. In this merging stage attributes for multiple nodes are updated in the memory of the PE. This merging stage starts a flood, where many cluster indices and parent nodes change as the union of ten clusters take shape. As explained in step 215, the parent-child relationship between nodes will change based on the cluster index of neighbouring nodes. For example, the defect node at node index 10 is now connected by a fully-grown edge to the neighbours with node indices 8, 9,12 and 13. As neighbouring node 8 has the lowest cluster index, defect node 10 will have an updated cluster index in the memory of the PE to that of cluster 8, and node 8 will become its parent. During this change, the node will be put into the busy state. As explained with regards to stage 215, the defects at node indices 6,10 and 11 relay their odd parity to their parents. During this change, the node will also be put into a busy state, if it was not already in a busy state. At the end of this merge, by cycling through all the nodes in the cluster, the nodes with node index 4 and 8 have an odd parity. Some of the edges between nodes in Figure 3d do not show parent-child relations due to the order in which the nodes have been processed in this example. As multiple changes of parent and parity have occurred during this merge, at least one node is still in the busy state, and therefore the merge will continue further. Figure 3e,f and g show graphs 350, 360, and 370, respectively. These graphs depict further merge steps, once again correlating with stage 215 of method 200. The merge continues due to at least one node still being in the busy state, as child-parent relationships and node parities continue to be updated in the memory of the PE whilst cycling through the nodes in the resultant cluster. Equivalently, the merging stage re-runs until all children in the resultant cluster have an even parity. Graph 370 depicts the final merge step, in which the child-parent relationships and node parities of the cluster reach their final merged state. In the final merged state, each node in the resultant cluster has the cluster index 0 stored in the memory of the PE. The root of the cluster tree is the node with node index 0, which has an odd parity. This can be seen by all the child-parent relationships in the cluster pointing back to cluster 0. In this example, the resultant cluster has an overall odd parity, however it ceases to continue growing as the resultant cluster has met the boundary. Figure 3h shows an eighth graph 380. The graph 380 depicts picking and syncing stages after the final merge stage, correlating to step 220 and step 225 of method 200 respectively. In the picking stage, the PE updates the activity of the root node associated with the resultant cluster. In the syncing stage, the PE updates the activity status of the child nodes based on the activity of the root node of the resultant cluster. The PE updates the busyness flag of multiple nodes associated with the resultant cluster in its dedicated memory . If one or more nodes are still busy at the end of the syncing stage, this stage may be repeated one or more times, as described above. These final picking and syncing stages deactivate the defect nodes 6,10 and 11. The LCD algorithm proceeds into the exiting stage, corresponding with step 230 of method 200. The logical correction equals the parity of the topmost boundary node on the left i.e. a parity of 1. This is equivalent to the sum modulo 2 of the number of defects in cluster 0. Figures 4a and b both depict a decoding graph 410 with multiple decoding rounds. The decoding graph 410 shown in Figure 4b is rotated by an angle relative to the decoding graph 410 shown in Figure 4a. The decoding graph 410 depict a distance 5 rotated planar surface code with 6 decoding rounds in time. Figures 4a and b show a 2D representation of the decoding graph 410 in 3D. The decoding graph 410 is made up of 6 layers, where each layer is associated with a decoding round. A decoding algorithm may be performed on each layer of the decoding graph, and then repeated again in each decoding round. As would be understood by the skilled person, the purpose of having multiple decoding rounds is to allow the decoder to correct measurement errors. The decoding graph 410 shows circular nodes connected in a 3D structure. The nodes in a lighter colour are boundary-adjacent nodes 412, 414. In Figures 4a and 4b, boundary-adjacent nodes are nodes of the decoding graph which are at the boundary. The boundary-adjacent nodes 412, 414 are either on the front 414 and back 412 boundaries of the decoding graph 410. The nodes in a darker colour are bulk nodes 416. In Figures 4a and 4b, bulk nodes are nodes that are not at a boundary of the decoding graph 410. The distinction between the boundary nodes 412,414 nodes and the bulk nodes 416 is helpful in understanding where the layers lie in Figures 4a and 4b. Figure 4b is included here in order to see the layers of the decoding graph more clearly, due to some nodes of the decoding graph being covered up by other nodes in Figure 4a. The decoding graph 410 is also representative of a 3D array of processing elements that could be used to decode a distance 5 rotated planar surface code with six decoding rounds, assuming each node is assigned to a different processing element in a 1:1 relationship, as in the prior art. This decoding hardware is complex and extremely expensive to build. There are a large number of connections between processing elements, requiring a separate input and output connection between a given processing element and each of its neighbours due to the possibility of processing elements possibly needing to access each other's data at the same time. Figure 5 depicts a method 500 according to the present disclosure. The method advantageously utilises grouped PEs to perform a clustering algorithm, for example the clustering algorithm described above with respect to figure 2. The method 500 is a computer-implemented quantum error correction method for decoding errors in a quantum computer system, for example a quantum computing system 1000 as depicted in figure 10, which comprises a decoder apparatus and a register of quantum devices such as qubits. The decoder apparatus comprises a plurality of processing elements, PEs, which are grouped in such a way that conflicting queries between neighbouring PEs cannot occur. Each PE of the plurality of PEs is associated with one or more nodes of a decoding hypergraph, i.e. either in a 1:1 assignment or an assignment in which each PE is associated with a batch of nodes. There may also be a separate controller coupled to each processing element, which acts to move each processing element through the various stages of the clustering algorithm. At step 502, syndrome data is received at the decoder apparatus. The syndrome data is representative of an error state of the quantum devices in the register of quantum devices. The syndrome data comprises a plurality of defects and, as described above, is representable as a decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices. At step 504, the plurality of PEs perform a clustering algorithm. The PEs perform the clustering algorithm in the manner described above with respect to figure 2 and the graphs depicted in figures 3a-h. The clustering algorithm comprises a plurality of steps, and has the overall aim of growing and merging clusters of nodes based on the number of defects in each cluster until a final cluster state is reached. In a particularly advantageous implementation, the PEs are grouped into a plurality of groups. The groups of PEs perform the steps of the clustering algorithm sequentially, for example one after another, such that PEs in a first group perform one or more first steps of the clustering algorithm, and then PEs in a second group perform the one or more first steps of the clustering algorithm. In most implementations there will preferably be three or more groups of PEs, and in this scenario each group of PEs performs the steps associated with a stage of the clustering algorithm sequentially, for example one group at a time and in a predetermined order, before moving on to the next stage of the algorithm. This is completely contrary to existing techniques which involve performing clustering algorithms using a plurality of PEs, in which the PEs all perform steps at the same time, potentially leading to conflicting queries between neighbouring processing elements. An example grouping of PEs is described below with respect to figure 7c. In an example, the PEs in a particular group may perform the steps of the appropriate stage of the algorithm in parallel with one another, such that all PEs in a particular group are active at the same time. For example, the PEs a first group may perform one or more first steps of the algorithm in parallel with each other, and the PEs in a second group perform the one or more first steps in parallel with each other, and so on until each group has performed the steps of the relevant stage of the algorithm. In other words, advantageously, the PEs are grouped, and the groups of PEs perform the steps of the clustering algorithm sequentially, such that no two PEs can attempt to access the same dedicated memory at the same time. In an example, the groups of PEs perform the steps of each stage of the clustering algorithm sequentially and successively, such that each group moves through the stages of the clustering algorithm. Therefore, in a first stage of the algorithm (for example, the merge stage), the PEs in a first group perform the steps associated with the first stage, then PEs in a second group perform the steps associated with the first stage, and so on until each group of PEs has performed the steps associated with the first stage of the algorithm. When the algorithm moves to a second, subsequent stage (e.g. a syncing stage), the PEs in the first group perform the steps associated with the second stage, then the PEs in the second group perform the steps associated with the second stage, and so on until every group has performed the merging stage. In this way, the groups may move through the stages of the algorithm sequentially and successively in a manner which does not give rise to conflicting requests between neighbouring PEs. The groups of PEs may not be executed sequentially at every stage of the clustering algorithm. The sequential execution of PEs as described above is most impactful, and therefore may only be required, at stages of the algorithm in which one or more PEs attempt to access data from one or more other PEs, in particular during the merging and / or syncing stages. It is during these stages that data conflict may arise. Therefore, the growth stage and / or the picking stage may not require conflict-free scheduling to be implemented. In other words, the groups of PEs may perform a subset (a first subset) of the steps of the clustering algorithm sequentially and successively. The steps of the algorithm in the first subset are those steps associated with stages during which PEs are required to query and access the member of neighbouring PEs. The groups of PEs may then perform the remainder of the steps (a second subset of the steps) of the clustering algorithm in parallel. The steps of the algorithm in the second subset are those steps associated with stages during which PEs are not required to query and access the member of neighbouring PEs (for example the initialising, growing, picking and exiting stages). This difference is highlighted in the following example. In this example, the PEs in different groups (e.g. a first group, second group, and so on) perform the steps associated with the growth stage in parallel with each other, such that PEs in different groups are executed at the same time. When the algorithm moves to a merging stage, the PEs in a first group perform the steps associated with the merging stage, then the PEs in a second group perform the steps associated with the merging stage, and so on until every group has performed the merging stage. In other words, the different groups of PEs may perform the merging stage sequentially. When the algorithm moves to the picking stage, the different groups of PEs may perform the steps associated with the picking stage in parallel with each other, similar to during the growing stage. When the algorithm moves to a syncing stage, the different groups of PEs may perform the steps associated with the syncing stage sequentially to each other, similar to during the merging stage. In this way, the groups move through the stages of the algorithm in a manner which does not give rise to conflicting requests between neighbouring PEs, by the groups performing some stages of the algorithm sequentially to each other and others in parallel with each other. Only executing groups of PEs sequentially at the stages of the algorithm where this scheduling will be most impactful enables a further speed improvement in the algorithm. In another particularly advantageous implementation, each of the plurality of PEs may be associated with a respective batch of nodes of the decoding hypergraph. Each batch contains a plurality of nodes, such that each PE is associated with more than one node in the hypergraph. This is completely in contrast with prior known approaches, in which a 1:1 assignment between PE and node has been thought to lead to optimal results. In this implementation, each PE of the plurality of PEs performs one or more steps of the plurality of steps of the clustering algorithm by performing the steps in respect of each of the nodes in its batch of nodes successively. In an example, a particular PE is associated with three nodes, numbered 1,2, and 3. At a particular stage of the clustering algorithm, the PE instructs the first node to perform the steps associated with the first stage. Once the first node has completed its steps, the PE then instructs the second node to perform the steps associated with the first stage. Once the second node has completed the steps, the PE then instructs the third 29 node to perform the steps associated with the first stage. In this way, the PE controls its batch of nodes so that none of the nodes make conflicting requests. Each PE may move its batch of nodes through the various stages of the algorithm, so that the batch performs steps associated with a first stage (such as growing), and the batch then performs steps associated with a second stage (such as merging). In an example, each PE may perform one or more steps of the clustering algorithm in respect of each of the nodes in its batch of nodes successively, such that, during a first stage of the clustering algorithm, each PE performs the steps associated with a first stage of the algorithm in respect of each of the nodes in its batch successively (e.g., so that the steps are performed for each node one after one another). Then, during a second stage of the clustering algorithm, each PE may perform the steps associated with the second stage of the algorithm in respect of each of the nodes in its batch successively (again, e.g., so that the steps are performed for each node one after one another). As described above, the first and second stages of the algorithm described here may be the merging and syncing stages, while the steps in other stages of the algorithm may be performed in parallel to maximise algorithmic speed and efficiency. To provide a further example of what is meant by performing steps for the batches of nodes successively (to ensure the concept is well-understood) in another example the plurality of PEs comprises a first PE associated with a first batch of nodes. The first batch of nodes comprises at least a first and a second node. This is a simple example, and the skilled person will understand that many more nodes can be comprised within a batch of nodes. In this example, during the growing stage, the first PE performs the steps of the growth stage in respect of the first node, and then performs the steps of the growth stage in respect of the second node. As described above with respect to figure 2, these steps may comprise, for example, updating a growth parameter associated with the first node by one unit and storing the updated growth parameter in the dedicated memory of the first PE. After performing these steps in respect of the first node, the first PE subsequently turns to the second node, and takes no action since the second node is not active. Then, during a merging stage of the clustering algorithm, the first PE performs the relevant (different) steps of the clustering algorithm in respect of the first node, and then subsequently performs the steps in respect of the second node. As set out above in connection with figure 2, this may involve the first PE querying the dedicated memory of a neighbouring PE (i.e. a PE associated with a node which neighbours the first node) to determine whether a sum of the growth parameters of the first PE and a neighbouring node meets a growth parameter threshold. After performing these steps, the first PE turns to the second PE in its batch and performs the same steps in respect of the second node and its neighbouring node(s). At step 506, the decoder apparatus determines a correction. The correction corrects for the error state of the quantum devices, and is based on a final cluster state. The final cluster state is reached when the clustering algorithm stops or exists, as described above. Once the final clustering state has been reached, a correction can be determined in a known way. For example, the method may comprise measuring a logical state encoded in the quantum devices of the quantum computer to obtain a logical state measurement, and applying the correction for the error state to the logical state measurement. With respect to step 504, two high-level implementations of the present disclosure have been described; the first in which PEs are grouped together in a manner which mitigates or removes the issue of conflicting queries, and the second in which each PE is assigned multiple nodes to form a batch of nodes, and these nodes are assigned tasks successively such that conflicting queries are avoided. It should be understood that these implementations can be applied separately, or together. For example, consider an implementation in which the PEs are formed into groups, and in which each PE is associated with a batch of nodes. In this implementation, the PEs move through the stages of the algorithm by each group performing the relevant stages of the algorithm one after another. When a particular group is active, each PE in the group is moving through its batch of nodes successively. For example, each PE in a first group of PEs may successively perform first steps of the clustering algorithm in respect of each of the nodes in its batch of nodes, and then each PE in a second group of PEs may successively perform the same first steps of the clustering algorithm in respect of each of the nodes in its batch of nodes. As with examples described above, the PEs in the same group may be instructed in parallel, such that the PEs in the first group perform the one or more first steps in parallel with each other, and the PEs in the second group perform the one or more first steps in parallel with each other, etc. Figure 6 depicts an example grid 600 of processing elements which is suitable for performing the method(s) of the present disclosure; in particular the method 500 described with respect to figure 5. Herein, a grid of processing elements may also be referred to as an array of elements. The depicted 2D grid 600 is significantly easier to implement in hardware than the corresponding 3D processing grids 400 and 410 required by the prior art. By implementing a method in which a PE is associated with more than one node, the grid 600 requires fewer components than the corresponding 3D processing grids 400 and 410. The grid 600 can also be made into a 2D grid more easily, which is significantly simpler to implement. For example the grid of Figure 6 relates to the decoding graph of Figure 4a and 4b, but with two nodes per processing element. Each PE in the processing grid is depicted by a square, and each PE is given a number from 0 to 35, in this example. The bidirectional arrows between PEs depict bidirectional links in hardware between PEs. Each depicted PE in the grid 600 comprises its own dedicated memory suitable for storing attributes relating to the one or more nodes associated with the PE. PEs can read and write data to / from the memory of neighbouring PEs, where neighbouring PEs are those PEs associated with nodes which are neighbouring in the hypergraph. A PE is said to be associated with a node if the PE performs the steps of the algorithm in respect of that node, and / or if the dedicated memory of the PE stores the attributes relating to the node. If PEi is associated with a node and PEj is associated with a neighbouring node to that node, a bidirectional link is added between PEi and PEj. For example, a bidirectional link is required between PEO and PEI, since node 0 associated with PEO is a neighbour of node 2 associated with PEI. This enables PEO to read / write data in the memory of PEI or PEI to read / write data in the memory of PEO, but not both at the same time. According to methods of the present disclosure, it is ensured that no two PEs can attempt to access each other's data at the same time. This means that only a single bidirectional link can be used to couple neighbouring PEs, instead of two unidirectional links as require din the prior art. Therefore, the number of links in the processing grid can be reduced by 50%, which results in significant cost and complexity savings. In the prior art, two PEs could attempt to write to the same memory at the same time. For example, if the parent nodes of two nodes associated with PEi and PEj are associated with PEk, running the merging stage on both PEs in parallel could result in simultaneous write requests on the memory of PEk. As described above, the present methods resolve contention issues and ensure that no two PEs can attempt to access data in a neighbouring PE of the other. Figures 7a-c depict graphs according to a method of the present disclosure. Figures 7a-c depict example graphs that implement conflict-free scheduling. The graphs used in Figures 7a-c are 6 by 6 square graphs but this is simply an example to aid understanding. Figure 7a depicts the same graph as in Figure 6, but with circles in place of the labelled squares. Figure 7a depicts a graph 710 which could be processed by the grid of processing elements of Figure 6. Each processing element in grid 600 is associated with a circular node on the graph 710. Each bidirectional link in grid 600 corresponds to an edge of the graph 710. The edges are depicted by solid lines between nodes. The edges in Figure 7a show the connections between nodes and their neighbours on the graph. Figure 7b depicts a graph, which is a 'square' of the graph of Figure 7a. The skilled person will be familiar with graph powers. As the skilled person will be familiar with, the square of a graph in this context is obtained by adding new edges between vertices in the graph that are a distance two apart. Specifically, the graph 720 shows extra links between a node and its neighbours' neighbours. In other words, the extra edges connect a node with nodes that are two edges away on the graph. These extra edges are depicted using dashed lines on the graph 720. In Figure 7b additional edges have only been added between one node and two of its neighbours' neighbours for simplicity. However these additional edges could be added for each node on the graph. The square of the graph may be used when performing a graph colouring algorithm (as will be explained) to avoid potential scheduling issues that may arise due to the nature of the merging stage, step 215 of method 200, and / or syncing stage, step 225 of method 200. For example, as the parent-child relationships change during the merging stage, two nodes could have the same parent during a merging stage. Therefore, there could also be a conflict between nodes which are two edges apart on the graph 720 and therefore extra edges are added between nodes that are two edges away from each other. In some executions of the decoder, this conflict may not exist and therefore it may not be necessary to protect against conflicts between a node and its neighbours' neighbours. Figure 7c depicts a graph 730. The graph 730 is based on the graph 720 of Figure 7b. The graph 730 depicted in figure 7c is shaded to depict an effective grouping of processing elements for graph 720. Each node is shaded, and numbered 1 though 8, according to the group of the associated processing element. Specifically, the graph 730 shows the graph of Figure 7b but with each PE (and therefore node) assigned to a group, in order to implement the conflict-free scheduling techniques described above with respect to figure 5. There are several ways in which the nodes in the graph 720 of Figure 7b could be grouped such that conflict-free scheduling occurs. The grouping of the nodes also depends on whether conflicts between nodesand other nodes two edges away need to prevented, which depends on the specific clustering algorithm being implemented. The grouping of nodes in the graph may be assigned using a graph colouring technique. It should therefore be appreciated that the assignment of nodes to colours (groups) may be manual or could be assigned using a graph colouring algorithm. The skilled person will be familiar with graph colouring algorithms, such as the greedy colouring algorithm. Other methods also exist, such as simply selecting suitably spaced rows / columns of the graph. In Figure 7c, the graph colouring is depicted by labelling each group ("colour") with a number. Each node is labelled with its group number, from 0 to 8. As will be appreciated from inspection of the figure, the nodes (and their associated PEs) are assigned into groups according to specific grouping rules. In this example, there is a relationship between processing element and node such that each PE is associated with two nodes. To ensure optimal grouping in this scenario, the nodes are assigned into groups such that for any particular node on the graph, no neighbouring nodes are in the same group. In other words, the neighbouring nodes of any particular node are associated with a different PE to the PE associated with the particular node, and these PEs are in different groups. Such a grouping reduces, i.e. mitigates, conflicting queries between neighbouring nodes, e.g. those nodes joined by a single hyperedge. To further reduce, or even eliminate conflicts, then the grouping rules can be extended as seen in figure 7c. In figure 7c, the nodes (and therefore PEs) are grouped such that, for any particular node, its neighbours' neighbouring nodes are also all associated with different groups. According to these grouping rules, there is a distance of at least three hyperedges between any two nodes in the same group. In other words, at least three hyperedges separates a first node associated with a PE in a first group (e.g. group 0) and any other node associated with another PE in the first group. The same rules apply for nodes in the second group, the third group, and so on. Figure 8 depicts a flowchart of the scheduling of the groups depicted in the graph 730 in Figure 7c. The numbers in Figure 8 correspond to the order in which the nodes in Figure 7c and / or processing elements in Figure 6 may be processed in a schedule. For example the node associated with the number '1' will be processed first, then the node associated with the number '2', and so on, until the node associated with the number '8' is processed. The arrows depict the order in which the groups of nodes / processing elements are processed. As set out above, the terms nodes and processing elements may be used interchangeably for this example. As with figures 7a-7c, the depicted example in figure 8 depicts a one-to-one mapping between nodes and processing elements. The groups of nodes are processed sequentially, from lowest to highest group number, with group 0 being processed first and group 8 being processed last. In Figure 8, it is apparent that groups 0 to 8 each contain 4 processing elements. All of the processing elements in group 0 may be processed in parallel, then the processing elements in group 1 may be processed in parallel etc. In this way, as each node is processed at a different time to its neighbours (and at a different time to its neighbours' neighbours), conflict-free scheduling is achieved. In implementing clustering algorithm 200, for example as part of method 500, it will be appreciated from figure 8 that the groups of PEs perform the steps of the clustering algorithm sequentially such that all PEs in group 0 perform one or more first steps of the clustering algorithm at the same time, and then all the PEs in group 1 perform the one or more first steps of the clustering algorithm at the same time, and so on until each PE has performed the first steps of the algorithm, and the algorithm can move on to the next stage (assuming the requirements are met to do so). Figure 9 depicts the graph of Figure 7a, but in an arrangement in which each PE is associated with a batch of nodes. In particular, a first PE (not shown) is associated with a first batch of nodes 902, a second PE is associated with a second batch of nodes 904, a third PE is associated with a third batch of nodes 906, a fourth PE is associated with a fourth batch of nodes 908, a fifth PE is associated with fifth batch of nodes 910, and a sixth PE is associated with a sixth batch of nodes 912. The shading of each batch depicts a group of the associated PE. The first and fourth PE are in a first group of PEs, the second and fifth PE are in a second group of PEs, and the third and sixth PE are in a third group of PEs. The groupings of PES (and nodes) complies with the following grouping rule. For any particular node on the hypergraph, the neighbouring nodes of the particular node are either: i) associated with the same PE as that associated with the particular node (these nodes are in the same batch); or ii) associated with a different PE to the PE associated with the particular node, where these PEs are in different groups. Applying the above rule mitigates and reduces potential conflicts, but to eliminate conflicts altogether an additional rule may be applied, that: ill) there is a distance of at least three hyperedges between any two nodes in the same group. In other words, as can be seen from figure 9, a distance of at least three hyperedges exists between any particular node associated with a PE in a particular group and any other node associated with another PE in the same particular group. Equivalently, rule iii) can be summarised as: different PEs in the same group do not have any neighbouring PEs in common. As explained elsewhere herein, the PEs can be considered to be grouped in the same manner as the nodes, so that PEs and their associated nodes can be thought of as being in the same group. In this implementation, each hyperedge connecting any two nodes in the hypergraph either connects two nodes which share an association with the same PE (i.e. are in the same batch), or corresponds to a bi-directional data link which couples two PEs associated with the any two nodes. A schematic of an exemplary quantum computing system 1000 suitable for performing the method of the present disclosure is shown in Figure 10. The quantum computing system 1000 comprises a plurality of physical qubits 1006 (unless specified otherwise, reference herein to qubits should be understood to refer to physical qubits rather than logical qubits). The qubits 1006 include data qubits used to encode logical qubit states, and syndrome qubits (or auxiliary qubits) used to perform syndrome measurements for quantum error correction. While the exemplary quantum computing system 1000 uses qubits 1006, one skilled in the art will appreciate that the invention described herein is also applicable to quantum computing systems that use other quantum devices, such as qutrits and qudits. Accordingly, it should be understood that any reference herein to qubits is applicable to any type of quantum devices that can be used to encode quantum information. The qubits 1006 are controlled by a control system 1004 having one or more classical processors. The control system 1004 transmits control signals (e.g. RF pulses) to the qubits 1006 for performing operations on the qubits 1006 (including measurement operations) and receives measurement information from the qubits 1006. 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 1004 in some implementations (e.g. the qubits 1006 may be provided with one or more analogue to digital converters). The control system 1004 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. The quantum computing system 1000 also comprises a decoding system 1002 (also referred to herein as a decoder). The decoding system 1002, which is generally a classical computing system, receives an error 35 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 1004. The decoding system 1002 may be connected to the control system 1004 and receive the error syndrome via the control system 1004 as illustrated in Figure 10 (potentially via one or more additional intermediary systems), or in alternative examples the decoding system 1002 may be connected directly to the qubits 1006 and receive the error syndrome from the qubits 1006 (e.g. as raw analogue signals or digital measurement values). The decoding system 1002 uses a decoding process / algorithm to decode the error syndrome to determine a correction for an error state of the qubits 1006 associated with the error syndrome (i.e. an error state that causes the measured error syndrome). The decoding system 1002 comprises a plurality of PEs in the manner described extensively above. At compiletime, nodes may be assigned to processing elements of the hardware; for example so that each PE has a batch of nodes and / or such that each PE is grouped according to the grouping rules described herein. One skilled in the art will appreciate that the quantum computing system 1000 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 1002 may be connected directly to the qubits 1006 as previously described). Figure 11 depicts a computer-readable medium according to the present disclosure. The various methods described above may be implemented by a computer program. The computer program may include computer code (e.g. instructions) 1110 arranged to instruct a computer to perform the functions of one or more of the various methods described above. The steps of the methods described above may be performed in any suitable order. The computer program and / or the code 1110 for performing such methods may be provided to an apparatus, such as a computer, on one or more computer readable media or, more generally, a computer program product), depicted in Figure 11. The computer readable media may be transitory or non-transitory. The one or more computer readable media 1100 could be, for example, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, or a propagation medium for data transmission, for example for downloading the code over the Internet. Alternatively, the one or more computer readable media could take the form of one or more physical computer readable media such as semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disc, and an optical disk, such as a CD-ROM, CD-R / W or DVD. It will be understood that the above description of specific embodiments is by way of example only and is not intended to limit the scope of the present disclosure. Many modifications of the described embodiments are envisaged and intended to be within the scope of the present disclosure. An example clustering algorithm according to the present disclosure The following pseudo-code listings provide examples of the types of steps and operations which may be run by the controller or a processing element configured to implement a clustering algorithm of the type disclosed herein, for example of the type depicted in fig. 2 and described above. def advance (): if any(pe.busy for pe in return if stage == SYNCING: pes) : if any(pe. active for stage = GROWING else : stage = EXITING else: stage += 1 pe in pes): Listing 1. Run by the controller after every stage def growing (): for node in batch: if node.active and node.growth <2: node.growth += 1 Listing 2. Run by each PE during the GROWING stage def merging (): for node in batch: node.busy = 0 for neighbor in node . neighbors : if node.growth + neighbor . growth >= 2: if node.cindex >neighbor .cindex: node.cindex = neighbor .cindex node.parent = neighbor node.busy = 1 if node.parent • = node and node.parity: node. parent. parity A= 1 node.parity = 0 node.busy = 1 Listing 3. Run by each PE during the MERGING stage def picking () : for node in batch: node.active = node.parent == node and node.parity Listing 4. Run by each PE during the PICKING stage def syncing (): for node in batch: any neighbor active = 0 for neighbor in node . neighbors : if node.growth + neighbor . growth >= 2: any neighbor active |= neighbor. active node.busy = not node.active and any neighbor active node.active |= node.busy Listing 5. Run by each PE during the SYNCING stage

Claims

1. A computer-implemented quantum error correction method for decoding errors in a quantum computer system, the quantum computer system comprising a decoder apparatus and a register of quantum devices, the decoder apparatus comprising a plurality of processing elements, PEs; the method comprising:receiving, at the decoder apparatus, syndrome data representative of an error state of the quantum devices in the register of quantum devices, the syndrome data comprising a plurality of defects, wherein the syndrome data is representable as a decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices, and wherein each PE of the plurality of PEs is associated with one or more nodes of the decoding hypergraph;performing, by the plurality of PEs, a clustering algorithm, the clustering algorithm comprising a plurality of steps, wherein the clustering algorithm grows and merges clusters of nodes based on the number of defects in each cluster until a final cluster state is reached; anddetermining, by the decoder apparatus, a correction for the error state based on the final cluster state;wherein the PEs are grouped into a plurality of groups of PEs, wherein the groups of PEs perform at least a subset of the steps of the clustering algorithm sequentially such that PEs in a first group perform one or more first steps of the clustering algorithm, and then PEs in a second group perform the one or more first steps of the clustering algorithm.

2. The method of claim 1, wherein the PEs in the first group perform the one or more first steps in parallel with each other, and the PEs in the second group perform the one or more first steps in parallel with each other.

3. The method of any preceding claim, wherein each node on the hypergraph has a plurality of neighbouring nodes.

4. The method of claim 3, wherein, for any particular node on the hypergraph, the neighbouring nodes of the particular node are either:associated with the same PE as that associated with the particular node; orassociated with a different PE in a different group to the PE associated with the particular node.

5. The method of claim 3 or claim 4, wherein neighbouring PEs are coupled via a bidirectional link, wherein neighbouring PEs are those PEs associated with nodes which neighbour one another on the hypergraph.

6. The method of any of claims 3 to 5, wherein the neighbouring nodes are connected to the particular node by one hyperedge on the hypergraph.

7. The method of any preceding claim, wherein there is a distance of at least three hyperedges between a first node associated with a PE in the first group and any other node associated with another PE in the first group.

8. The method of any preceding claim, wherein there is a distance of at least three hyperedges between any two nodes associated with different PEs in the same group.

9. The method of any preceding claim, wherein each hyperedge connecting any two nodes in the hypergraph either:connects two nodes which share an association with the same PE; oris associated with a bi-directional data link which couples two PEs associated with the any two nodes.

10. The method of any preceding claim, wherein each PE of the plurality of PEs comprises its own dedicated memory, wherein neighbouring PEs are PEs associated with two nodes which neighbour each other in the hypergraph, and wherein the one or more first steps of the clustering algorithm comprise each PE reading data from and / or writing data to the dedicated memory of at least one of its neighbouring PEs.IL The method of claim 10, wherein the dedicated memory of each PE stores attributes relating to the one or more nodes associated with the PE.

12. The method of claim 11, wherein the attributes comprise one or more of an index of the node, a cluster index, a growth parameter, a defect flag indicating whether the node is associated with a defect, an activity flag indicating whether the node and / or a cluster to which the node belongs is active, a parity flag indicating a parity of the node, and a busyness flag indicating whether the node is busy.

13. The method of claim 11 or claim 12, wherein each PE reading data from and / or writing data to the dedicated memory of at least one of its neighbouring PEs comprises reading an attribute and / or updating an attribute in the dedicated memory of the at least one neighbouring PE.

14. The method of any of claims 10 to 13, wherein the PEs are grouped into the plurality of groups of PEs, and the groups of PEs perform the steps of the clustering algorithm sequentially, such that no two PEs attempt to access a dedicated memory at the same time.

15. The method of any preceding claim, wherein each PE is associated with a plurality of nodes of the decoding hypergraph.

16. The method of any preceding claim, wherein each step of the clustering algorithm is associated with a stage of a plurality of stages of the clustering algorithm.3917. The method of claim 16, wherein the stages of the clustering algorithm comprise at least a growth stage, wherein, in the growth stage, one or more PEs update a growth parameter associated with at least one of its associated nodes by one unit up to a maximum growth parameter value, and store the updated growth parameter in its dedicated memory.

18. The method of claim 16 or claim 17, wherein the stages of the clustering algorithm comprise a merge stage; wherein, in the merge stage, one or more PEs query the dedicated memory of a neighbouring PE to determine whether a sum of the growth parameters of the neighbouring nodes meets a growth parameter threshold; andif the growth parameter threshold is met, the one or more PEs additionally determine whether one or more merging criteria are met; andif the one or more merging criteria are met, the one or more PEs merge the clusters by updating a cluster index in their dedicated memories.

19. The method of claim 18, wherein the one or more merging criteria are based on a cluster index value stored in the dedicated memory of the neighbouring PE.

20. The method of any of claims 17 to 19, wherein the one or more PEs that update a growth parameter and / or that query the dedicated memory of a neighbouring PE are those PEs associated with a node which is active, wherein active nodes form part of an active cluster, wherein an active cluster is a cluster with an odd number of defects and which has not merged with one or more boundary nodes of the hypergraph.

21. The method of any of claims 16 to 20, wherein the groups of PEs perform the steps of each stage of the clustering algorithm sequentially and successively such that each group moves through the stages of the clustering algorithm.

22. The method of any of claims 16 to 21, wherein the groups of PEs perform the steps of each stage of the clustering algorithm sequentially such that:in a first stage, the PEs in the first group perform one or more steps associated with the first stage, then PEs in the second group perform the one or more steps associated with the first stage; andin a subsequent second stage: the PEs in the first group perform one or more steps associated with a second stage, then PEs in the second group perform the one or more steps associated with the second stage.

23. The method of any of claims 16 to 21, wherein the groups of PEs perform the steps of each stage of the clustering algorithm until a stopping criterion is reached.

24. The method of claim 23, wherein the final cluster state is reached when the stopping criterion is reached.

25. The method of claim 23 or claim 24, wherein the stopping criterion is reached when each cluster of the decoding hypergraph either:comprises an even number of defects; orreaches the boundary of the decoding hypergraph.

26. The method of any preceding claim, wherein the quantum error correction method is a surface code error correction procedure.

27. The method of any preceding claim, wherein the PEs are grouped using a graph colouring method.

28. The method of any preceding claim, wherein the quantum devices are qubits.

29. The method of any preceding claim, wherein the decoding hypergraph is a decoding graph, and wherein the hyperedges are edges.

30. The method of any preceding claim, further comprising:measuring a logical state encoded in the quantum devices of the quantum computer to obtain a logical state measurement; andapplying the correction for the error state to the logical state measurement.

31. The method of any preceding claim, wherein each of the plurality of PEs is associated with a respective batch of nodes of the decoding hypergraph, each batch containing a plurality of nodes; andwherein each PE of the plurality of PEs performs one or more first steps of the plurality of steps of the clustering algorithm by performing the first steps in respect of each of the nodes in its batch of nodes successively.

32. A quantum computer system comprising:a register of quantum devices; anda decoder apparatus comprising a processor, a plurality of processing elements, PEs, and computer memory storing:a decoding hypergraph for a quantum error correction code, the decoding hypergraph comprising a plurality of nodes connected by hyperedges representing error mechanisms associated with the plurality of quantum devices, wherein each PE of the plurality of PEs is associated with one or more nodes of the decoding hypergraph; and5 instructions which, when implemented by the decoder apparatus, cause the decoderapparatus to perform the method of any preceding claim.

33. A computer-readable medium comprising instructions which, when executed by a quantum computer system, cause the quantum computer system to perform the method of any of claims 1 to 31.10

Images