Method for decoding errors in a quantum computer system

Abstract

A computer-implemented quantum error correction method uses a decoder apparatus for decoding errors in a register of quantum devices. The decoder apparatus comprises processing elements (PEs) in a pro

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. Examples of this approach are described in: N. Delfosse and G. Zemor. 'Linear-time maximum likelihood decoding of surface codes over the quantum erasure channel', Phys. Rev. Res. 2, 033042 (2020); and N. Delfosse and N. H. Nickerson, 'Almost- linear time decoding algorithm for topological codes', Quantum 5, 595 (2021). These approaches describe a "Union-find" decoder. 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. Decoding is typically a sparse problem since, at subthreshold, the Hamming weight of the syndrome is much less than the number of nodes in the decoding graph 'N'. For typical prior art clustering decoders, this results in, on average, k clusters of size s <log(d), where d is the code distance. As such, the number of nodes in a decoding graph that are in a cluster (u = k*s) is only a small fraction ( <1.5%) of the total number of nodes (N) in the decoding graph. This means that only a small fraction of the total nodes in the decoding graph will be used to correct the syndrome. Conventional decoding algorithms of the type described above can be designed to run on specialised decoding hardware comprising a plurality of processing elements (PEs). In the vast majority of prior approaches, each node in the decoding graph is associated with a different PE according to a 1:1 mapping to enable parallelisation. Physical 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. However, this type of 'finegrained' architecture, in which there is a 1:1 mapping between PE and node, is, highly power inefficient. These approaches drive N PEs per operation with less than 1.5% of these PEs doing useful work. Very recently, the applicant developed an approach in which each PE may be associated with multiple nodes in the hypergraph. This may be described as a 'l:many' mapping between PE and node, and may also be referred to herein as a 'coarse-grained' architecture. In this approach, each PE may perform steps of a clustering algorithm in respect of each of the nodes in its 'batch' of nodes successively, e.g. in turn. This approach and associated scheduling techniques help address contention issues which may otherwise arise, for example when multiple PEs try to access the same data simultaneously. While this new approach is advantageous for several reasons, similar problems to those described above are still encountered and the approach can be sub-optimal when it comes to power efficiency. The approach can also lead to slowdowns, since each PE processes its batch of nodes successively. If the number of nodes per PE is 'r', each stage requires r timesteps, even if fewer than r nodes are in the cluster sets. The present disclosure 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, disclosed herein is a computer-implemented quantum error correction method 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 comprising 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. The method further comprises performing, by the plurality of PEs, a clustering algorithm, the clustering algorithm comprising a plurality of steps, and 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 further comprises determining, by the decoder apparatus, a correction for the error state based on the final cluster state; 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. Each PE of the plurality of PEs performs one or more first steps of the plurality of steps of the clustering algorithm. Performing the one or more first steps by each PE comprises determining which nodes of the PE's associated batch of nodes are in a cluster, and performing, in respect of each of the nodes determined to be in a cluster, the one or more first steps of the clustering algorithm. As will be explained in the specification, for at least some of the steps of the algorithm, each PE first determines which nodes are in a cluster before performing the steps of the algorithm in respect of those nodes. This approach leads to a faster algorithm, since nodes which are not in a cluster, and hence which need not be considered at certain stages of the algorithm, may be skipped. This approach also leads to a more power-efficient algorithm, since each PE performs fewer steps, and fewer PEs are driven. Optionally, each PE of the plurality of PEs comprises its own dedicated memory. Optionally, for each PE of the plurality of PEs, the dedicated memory stores cluster-node data which indicates which nodes of the PE's batch of nodes are in a cluster; and wherein each PE determines which nodes of its associated batch of nodes are in a cluster by consulting its cluster-node data. Optionally, performing the one or more first steps further comprises updating the cluster-node data as the clustering algorithm progresses. This type of data, 'cluster-node' data, may be referred to herein as frontier data. Tracking whether each node is in a cluster or not in this manner is a completely new approach, and helps to enable the benefits of improved processing speed and algorithmic efficiency. 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 a growth stage, and in the growth stage, one or more PEs update a growth parameter associated with at least one of the nodes in their respective batches by one unit up to a maximum growth parameter value, and store the updated growth parameter values in their dedicated memories. Optionally, the stages of the clustering algorithm comprise a merge stage; wherein, during the merge stage, each PE: determines, for each node determined to be in a cluster, whether the nodes which neighbour the node should join the cluster based at least in part on one or more merging criteria; and updates the clusternode data for those nodes which meet the one or more merging criteria and which did not previously form part of a cluster. Optionally, the stages of the clustering algorithm comprise a merge stage and, in the merge stage, each PE of the plurality of PEs determines which nodes of its associated batch of nodes are in a cluster, and for each node determined to be in a cluster: queries a dedicated memory of a PE associated with a neighbouring node to determine a sum of the growth parameters of the node and a neighbouring node, wherein the neighbouring node neighbours the node in the hypergraph; determines whether one or more merging criteria are met, the one or more merging criteria comprising whether the sum meets a growth parameter threshold; and if the one or more merging criteria are met and the neighbouring node is not already in its own cluster, adds the neighbouring node to the node's cluster. Optionally, if the neighbouring node is already in its own cluster and the one or more merging criteria are met, the PE merges the nodes' cluster and the neighbouring node's cluster. Optionally, the one or more first steps of the clustering algorithm are performed successively for each node determined to be in a cluster. Optionally, the plurality of PEs comprises a first PE, the first PE being associated with a first batch of nodes comprising at least a first and a second node, and wherein during a first stage of the clustering algorithm, the first PE: determines that the first node is in a cluster and that the second node is not; and performs the one or more first steps of the clustering algorithm in respect of the first node, and does not perform the one or more first steps in respect of the second node. Optionally, the clustering algorithm is iterative such that the first stage of the clustering algorithm is performed multiple times as the clustering algorithm progresses; wherein, if the second node is added to a cluster as the clustering algorithm progresses: during subsequent performances of the first stage of the clustering algorithm, the first PE performs the one or more first steps of the clustering algorithm in respect of the first node and in respect of the second node. Optionally, 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 the one or more first steps of the clustering algorithm in respect of each of their respective batches of nodes, and then PEs in a second group perform the one or more first steps of the clustering algorithm in respect of each of their respective batches of nodes. Optionally, each PE in the first group successively performs the one or more first steps of the plurality of steps of the clustering algorithm in respect of each of the nodes in its batch of nodes determined to be in a cluster, and each PE in the second group successively performs the one or more first steps of the plurality of steps of the clustering algorithm in respect of each of the nodes in its batch of nodes determined to be in a cluster. 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. According to an aspect of the invention, a quantum computer system is disclosed herein which comprises a register of quantum devices; and a 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; and instructions which, when implemented by the decoder apparatus, cause the decoder apparatus to perform any of the methods and methodologies set out above or described herein. According to an aspect of the invention, a computer-readable medium is disclosed herein comprising instructions which, when executed by a quantum computer system, cause the quantum computer system to perform any of the methods and methodologies set out above or described 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 flowchart depicting a method according to the present disclosure; Figure 6 is a flowchart depicting a method according to the present disclosure; Figures 7a-c are graphs showing data derived from decoding runs; Figures 8a-d show a plurality of processing elements each comprising a new data structure according to the present invention; Figure 9a depicts a graphical representation of a grid of processing elements, figure 9b depicts the square of the graph of Figure 9a; and figure 9c depicts the graph of Figure 9b with grouped nodes; Figure 10 is depicts a flowchart of the scheduling of groups of processing elements; Figure 11 is a graph depicting an arrangement in which each PE is associated with a batch of nodes; Figure 12 is an example embodiment of a quantum computer system; Figure 13 is an example embodiment of a computer readable medium or computer program product. Detailed Description In overview, and without limitation, the disclosure relates to a quantum error correction method for decoding errors in a quantum computer system. The quantum computer system comprises a decoder apparatus and a register of quantum devices, e.g. qubits. The decoder apparatus comprises a plurality of processing elements, PEs. These PEs are utilised to perform a clustering algorithm in relation to syndrome data, where the clustering algorithm aims to grow and merge clusters of nodes based (at least in part) on a number of defects in each cluster until a final cluster state is reached. This enables a correction for the error state to be determined. As the clustering algorithm progresses through its various stages, at least some of the steps of the clustering algorithm are only performed in respect of nodes which are in clusters. Unlike in prior approaches, in which every PE is driven at every stage of the algorithm, in the present approach only those PEs are driven which can usefully advance the clustering process. In some implementations, each PE comprises its own dedicated memory which can be used to store a new form of data: cluster-node data. For a particular PE, the cluster-node data indicates which nodes of its batch of nodes 6 are in a cluster. Herein, this data may be referred to as 'frontier' data, with the nodes in a batch of nodes which are in a cluster sometimes being referred to as 'frontier' nodes. This data can be consulted and updated as the algorithm progresses so that in one or more stages of the clustering algorithm, the PEs execute the stage kernel only on the nodes in their 'frontiers' (i.e. that are in a cluster). This approach leads to a faster algorithm, since nodes which are not in a frontier may be skipped. This approach also leads to a more power efficient algorithm, since fewer PEs are driven. Several other concepts are disclosed herein which are synergistic with the concept of a 'frontier'. For example. Conflicting updates to each PE's frontier data can be avoided by running a conflict-free schedule. Herein, each of the plurality of PEs is associated with more than one node, and in particular with a respective batch of nodes of the decoding hypergraph. For a particular PE with a batch of nodes, running a 'conflict-free' schedule may involve performing the steps of the clustering algorithm successively for each node in its batch which is determined to be in a cluster. For example, each PE can perform one or more steps of the clustering algorithm by allocating tasks to a first node of its batch determined to be in a cluster, then tasks to a second node in its batch determined to be in a cluster, not allocating tasks to a third node in its batch since the third node is not in a cluster, and so on until the tasks have been performed by each node in the batch which is in a cluster. This ensures that the nodes within a batch will not be instructed to access each other's memory, and in particularto update the clusternode data, at the same time by their PE. To further reduce the chance of a conflicting update being made to a particular PE's memory, the PEs may further be grouped into a plurality of groups of PEs, where these groups perform the steps of the clustering algorithm sequentially, i.e. such that PEs in a first group perform one or more first steps of the clustering algorithm in respect of each of their respective batches of nodes, and then PEs in a second group perform the same one or more first steps of the clustering algorithm in respect of each of their respective batches of nodes. These concepts will be explained in greater detail herein. Several terms and concepts will be discussed in the present disclosure, and though the skilled person will be familiar with this terminology and these concepts, the following section serves to provide additional context to the reader. 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 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 15 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, 16 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.defect busy True if the node is busy. Must be in [0,1], since this is a Boolean flag. Initially, node . busy = 0 In addition, the 'frontier' data structure is initialised. Each node associated with a defect is marked as being in a cluster. Every other node is marked as not being in a cluster. In some implementations, "pre grown" edges may be identified or introduced between certain nodes. In such implementations, during the initialisation stage, non-defect nodes incident to a pre-grown edge are also added to the frontier. This would support decoding of erasure errors, for example. The skilled person will be familiar with pre-grown edges. A pre-grown edge might refer to an edge that is introduced between certain nodes before the full matching clustering process occurs. This pre-growth can help guide the clustering algorithm, especially when certain types of errors or noise patterns are more likely, or when the decoder has some prior knowledge about where errors are more probable 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 nodes that 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. One of the purposes of the merging criteria is to determine which cluster index value to use for the new cluster. The one or more merging criteria may be 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. According to the methods disclosed herein, the merge step may be performed in respect of those nodes determined to be in a cluster. The merging stage may therefore first comprise an initial step in which it is determined which nodes are in a cluster, and therefore which nodes should run the remaining steps of the merging stage. Once a particular node has been determined to be in a cluster, its PE determines whether the nodes which neighbour the particular node should join the cluster based at least in part on one or more merging criteria. The merging criteria may comprise whether the edge joining the particular node to the neighbouring node is fully grown, i.e. meets a growth threshold, for example. For those neighbouring nodes which meet the criteria, the PE updates the cluster node (or 'frontier') data. Forthose nodes not previously forming part of a cluster, their cluster-node data is changed to indicate that they are now part of a cluster. These nodes have been added to the 'frontier' and perform the merging steps in future iterations of the clustering algorithm. Further to the above paragraph, more detail is provided in the accompanying pseudo-code at the end of the description. From the code it can be appreciated that, in the merging stage, each PE determines which nodes of its associated batch of nodes are in a cluster ("for node in frontier"). For each node determined to be in a cluster, the relevant PE queries a dedicated memory of a PE associated with a neighbouring node to determine a sum of the growth parameters of the node and the neighbouring node. The PE determines whether one or more merging criteria are met, including whether the sum of the growth parameters meets a growth parameter threshold, i.e. if the relevant edge is fully grown. If the one or more merging criteria are met and the neighbouring node is not already in its own cluster, it is added to the node's cluster and its cluster index and cluster-node data is updated accordingly. If the neighbouring node is already in its own cluster and the one or more merging criteria are met, the PE merges the nodes' cluster and the neighbouring node's cluster and updates the cluster indices accordingly. 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 often 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 24 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 boundaryadjacent nodes 412, 414. In Figures 4a and 4b, boundaryadjacent 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 utilises multiple 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 1200 as depicted in figure 12, 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 may 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 an 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. 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 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 firstand 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. Performing the clustering algorithm at step 504 is also performed according to method 600 shown in figure 6. As will be explained later, this may mean that at least some stages of the algorithm are performed only in respect of each of the nodes determined to be in a cluster, e.g. in respect of those nodes which are a defect node or which are incident to a fully grown edge. 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. Figure 6 depicts a method 600 according to the present disclosure. The method 600 depicts the manner in which part or all of a clustering algorithm may be performed, such as the clustering algorithm 200 depicted in figure 2. According to method 600, at least some of the steps of the clustering algorithm are only performed in respect of nodes which are in a cluster. To enable this functionality, each PE is given a new data structure, which herein may be called the frontier. The data structure is stored in dedicated memory for each PE and stores cluster-node data (or 'fronter data') which indicates which nodes in a PE's batch of nodes are in a cluster. The cluster-node data may be binary for each node, with a '1' indicating the node is in a cluster, and a '0' indicating the node is not in a cluster. A node in batch Bi is in frontier Fi if it is in a cluster. A node is in a cluster if it is a defect node or incident to a fully-grown edge. The cluster-node data can be updated as the algorithm progresses. For example, if a node is added to a cluster, the associated PE updates the cluster-node data stored in its dedicated memory. The method 600 focuses on a particular part of the clustering algorithm. Block 610 and block 640 depict earlier and later stages of the algorithm. These stages can be any stage of the clustering algorithm. To provide an illustrative example, blocks 620 and 630 will be described with respect to the 'merge' or 'merging' stage described with respect figure 2. In this example, block 610 represents the 'growth' or 'growing' stage, and block 640 represents the 'picking' stage. In this example, as described above, at block 610 the PEs seek to update, e.g. increase, a growth parameter associated with each of the nodes in their batches by one unit up to a maximum growth parameter value. The current growth parameter value for each node in the batch is stored in the PE's dedicated memory. Since the growth parameter values of one or more nodes are increased during the growth stage, it's likely that some of these nodes now meet the requirements to be placed into a cluster. This is assessed in the merge stage. Blocks 620 and 630 represent the next stage in the clustering algorithm. The stage is associated with one or more steps to be performed by each of the PEs. Continuing the above illustrative example, this stage may be the merge stage. At block 620, it is determined at each PE which nodes are in a cluster. As part of this process, each PE consults its cluster-node data, which indicates which nodes of its batch of nodes are in a cluster. At block 630, the PE performs one or more first steps of the clustering algorithm in respect of each of the nodes determined to be in a cluster. In contrast with prior approaches, the PE does not necessarily perform those steps in respect of every one of its associated nodes. Part of the steps performed by the PE at this stage may relate to updating the cluster-node data. For example, if during the merge stage new nodes have been added to a cluster, the associated cluster-node data is updated to indicate the nodes' new cluster status. At block 640, the algorithm moves to the next stage in the clustering algorithm. As indicated by the arrow, and as described above e.g. in relation to figure 2, the clustering algorithm may be iterative such that the stage of the clustering algorithm represented by blocks 620 and 630 is performed multiple times as the clustering algorithm progresses. In this way, the number of nodes performing the "one or more steps" represented by blocks 620 and 630 may increase as the algorithm progresses and more and more nodes are added to clusters. To provide an example of this, consider an example in which each PE has two nodes associated with it, i.e. there are two nodes per batch. The cluster-node data can be stored in a 2 bit register at each PE. For example, a '1' in the register may indicate that a node is in a cluster, and a '0' may indicate that a node is not in a cluster. Consider just one PE of the many PEs. This 'first' PE is associated with a first batch of nodes comprising a first and a second node. When the algorithm is initialised, neither node is associated with a defect and neither node is in a cluster. As the algorithm moves through blocks 620 and 630, the PE does not perform the associated steps of the algorithm in respect of any of the nodes in its batch. At a subsequent stage, the first node meets the criteria for joining a cluster. The cluster-node data is updated accordingly. During the next run-through of blocks 620 and 630, the first PE determines at block 620 that the first node is in a cluster and that the second node is not, and at block 630 performs the one or more first steps of the clustering algorithm in respect of the first node, and does not perform the one or more first steps in respect of the second node. As the algorithm progresses, at a subsequent stage, the second node meets the criteria for joining a cluster. The cluster-node data is updated accordingly. During the next run-through of blocks 620 and 630, the first PE determines at block 620 that both nodes are in a cluster by consulting the cluster-node data, and performs the one or more first steps of the clustering algorithm at block 630 in respect of the first node and in respect of the second node. As described above, the stage represented by blocks 620 and 630 may be the merge stage. Example pseudocode for a merge stage inline with method 600 is provided at the end of the specification. As can be appreciated from the pseudo-code, during the merge stage, one or more clusters of nodes may grow in size to encompass new cluster nodes, i.e. nodes which did not previously form part of a cluster. When this happens, the clusternode (frontier) data is updated for the new cluster nodes to indicate they are now in a cluster. Again as can be appreciated form the pseudo-code, the one or more first steps of the clustering algorithm at block 630 can be steps which relate specifically to the merge stage. For example, after each PE of the plurality of PEs has determined at block 620 which nodes of its associated batch of nodes are in a cluster, the PEs then perform merge stage steps for each node determined to be in a cluster. With respect to a particular node which is in a cluster, these steps may comprise querying a dedicated memory of a 'neighbouring PE', i.e. a PE associated with a node which neighbours the particular node on the hypergraph. The query seeks to retrieve a growth parameter value associated with the neighbouring node, in order to determine a sum of the growth parameters of the particular node and a neighbouring node. The one or more steps at block 630 may further comprise determining whether one or more merging criteria are met, the one or more merging criteria comprising whether the determined sum meets a growth parameter threshold. To use alternative terminology, this is equivalent to determining whether a node is incident to a fully-grown edge. If the one or more merging criteria are met, the neighbouring node merges with the cluster associated with the particular node. If the neighbouring node is not already in its own cluster, this comprises adding the neighbouring node to the particular node's cluster. The 'neighbouring PE', i.e. the PE associated with the neighbouring node, will update the cluster-node data for the neighbouring node in due course to indicate that it now belongs to a cluster. If the neighbouring node is already in a cluster, then the PE merges the two clusters. The result is that the particular nodes' cluster and the neighbouring node's cluster are merged into a single cluster. Figures 7a-c depict graphs depicting the performance of prior art approaches, from which the advantages of the present approaches, in particular the methods discussed above with respect to figures 5 and 6, can be appreciated. To generate the data underlying the figures it is necessary to make some assumptions, including regarding the noise model, and therefore the figures should be seen as merely illustrative of the prior approaches. Figure 7a looks at the average number of clusters seen at the end of a decoding run with increasing code distance (d). As the code distance increases, the number of clusters (k) typically seen at the end of a decoding run also increases, according to the relationship depicted in the figure. Figure 7b looks at the typical cluster size (s) at the end of a typical decoding run. For typical clustering decoders, there are, on average, k clusters of size s <log(d). Figure 7c looks at the % of nodes used (u). This can be calculated by multiplying the data from figures 7a and7b and dividing by the total number of nodes on the graph. As can be appreciated, the number of nodes in a decoding graph that are in a cluster (u = k*s) is only a small fraction ( <1.5%) of the total number of nodes (N) in the decoding graph. This means that only a small fraction of the total nodes in the decoding graph are used to correct the syndrome. As can be appreciated from figure 7c, the percentage of nodes which are in a cluster 30 at the end of a decoding run is low, and this percentage would be lower in previous stages of the algorithm (i.e. before the stopping criteria are met). In prior approaches, every processing element is driven at every operation. For example, considering the 'merge' stage of the clustering algorithm, every PE is driven regardless of whether any of its associated nodes are actually in a cluster or meet the requirements for being in a cluster. This is highly power inefficient. In contrast, for at least some steps of the clustering algorithm, the present methodologies involve determining which nodes of a PE's associated batch of nodes are in a cluster, and performing the steps of the algorithm in respect of those nodes. This significantly increases power efficiency, and also makes the algorithm faster since time is not wasted performing steps in respect of nodes which cannot advance the progress of the algorithm. Figures 8a-d depict example grids 800a-d of processing elements which are suitable for performing the method(s) of the present disclosure, and in particular the method 500 incorporating the method 600 described with respect to figures 5 and 6. Herein, a grid of processing elements may also be referred to as an array of elements. 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. As described herein, each PE may be associated with more than one node, so that each PE has a 'batch' of nodes. The grid 800 requires fewer components than the corresponding 3D processing grids 400 and 410. Due to the provision of 'batches' of nodes, the grids 800 can also be made into a 2D grid more easily, which is significantly simpler to implement. For example the grids of Figures 8a-d may relate to the decoding graph of Figure 4a and 4b, but with two nodes per processing element. Each depicted PE in the grid 800 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 may be provided between PEi and PEj. For example, a bidirectional link is provided 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. Each PE has a register stored in its dedicated memory which stores the cluster-node data for each of its associated nodes. This register is shown schematically in figures 8a-d. The depicted cluster-node data is numbered for each node; for example, PEO holds cluster-node data for nodes 0 and 1. The registers use a simple binary indication to indicate whether each node is in a cluster or not, with dark grey indicating the node is not in a cluster, and lighter grey indicating the node is in a cluster. Alternatively, the cluster-node data may not stored in the dedicated memory of each PE, and instead some or all of the cluster data may be stored in one or more dedicated memories external to the PEs. Storing the cluster-node data for multiple PEs in one more dedicated memories may require the addition of physical links in hardware between the one or more dedicated memories and the PEs in order to communicate the clusternode data. Figure 8a depicts a plurality of PEs PE0->PE35 which may form part of a decoder apparatus in a quantum computer system. Figure 8a depicts a grid 800a at the start of the clustering algorithm. Before receipt and / or processing of the syndrome data, each register shows that no nodes are in a cluster. Figure 8b depicts a grid 800b, after receipt of the syndrome and subsequent initialisation based on the syndrome. A node in PEl's batch of nodes is associated with a defect and is therefore in a cluster. PEI updates the cluster-node data for node 2 to indicate that this node is in a cluster and this is depicted in figure 8b. Figure 8c depicts a grid 800c after the clustering algorithm has progressed somewhat. It can be appreciated that several more nodes have been merged, i.e. incorporated or added, into the cluster. PEs 0, 2, 6 and 7 have nodes associated with clusters and the cluster-node (frontier) data has been updated to reflect this. Figure 8d depicts a grid 800d in which the clustering algorithm has progressed still further, and in which still more PEs have updated their cluster-node data as the cluster grows. Figures 8a-d show how few PEs may be associated with a cluster at any one time stage in the clustering algorithm. It will be appreciated that, as the cluster(s) grow, power can be saved by only driving those PEs which are associated with nodes in a cluster, i.e. nodes which are themselves defect nodes or incident to a fully-grown edge. These nodes are the nodes which are relevant for the potential expansion of the cluster. It will be appreciated from the figures, for example, that as the grid progresses from 800a-d, it would be a waste of computer resources and power to drive PE28 at every stage of the clustering algorithm, since this PE cannot contribute to the growth of any clusters. The present disclosure is primarily concerned with the 'frontier' data and its use to improve power efficiency during the application of a clustering algorithm. However, several other concepts and approaches can be used in conjunction with frontier data to provide additional, synergistic benefits. An example includes a 'conflict-free scheduling' technique. These approaches are described below with respect to figures 5 and 9 to 11. As described above in relation to figure 5, the steps of the clustering algorithm may be performed successively for each node in a PEs' batch which is determined to be in a cluster. This reduces the likelihood of conflict and contention issues. In some implementations of the present disclosure, it is ensured that no two PEs can attempt to access each other's data at the same time by grouping the PEs in a particular way and having these groups 32 perform steps sequentially. This has several benefits. Because the chance of an outgoing request being made at the same time as an incoming request is removed, only a single bidirectional link can be used to couple neighbouring PEs, instead of two unidirectional links as required in 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 addition, scenarios in which two PEs attempt to write to the same memory at the same time can be avoided. For example, with reference to the gris depicted in figure 8, 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 will be described below, the present methods involve 'grouping' the PEs to resolve contention issues and ensure that no two PEs can attempt to access data in a neighbouring PE of the other. In an optional but advantageous implementation of the method 500 described above with respect to figure 5, 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 other, prior 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. 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. With respect to step 504 of figure 5, as has now been described, the PEs may be grouped together in a manner which mitigates or removes the issue of conflicting queries. The PEs are also 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 applied together provide a synergistic benefit of improved algorithmic speed without conflict issues. 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. As the PEs move through the stages of the algorithm, some of the steps of the algorithm are only performed for nodes which are in a cluster. Figures 9a-c depict graphs according to a method of the present disclosure. Figures 9a-c depict example graphs that implement conflict-free scheduling. The graphs used in Figures 9a-c are 6 by 6 square graphs but this is simply an example to aid understanding. Figure 9a depicts similar graph / array as in Figures 8a-d, but with circles in place of the labelled squares. Figure 9a depicts a graph 910 which could be processed by the grid of processing elements of Figures 8a-d. Each processing element in grids 800 are associated with a circular node on the graph 1110. Each bidirectional link in the grids 800 corresponds to an edge of the graph 910. 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 9b depicts a graph, which is a 'square' of the graph of Figure 9a. 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 920 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 920. In Figure 9b 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 920 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 9c depicts a graph 930. The graph 930 is based on the graph 920 of Figure 9b. The graph 930 depicted in figure 9c is shaded to depict an effective grouping of processing elements for graph 920. Each node is shaded, and numbered 1 though 8, according to the group of the associated processing element. Specifically, the graph 930 shows the graph of Figure 9b but with each PE (and therefore node) assigned to a group, in order to implement the conflict-free scheduling techniques. There are several ways in which the nodes in the graph 920 of Figure 9b could be grouped such that conflict-free scheduling occurs. The grouping of the nodes also depends on whether conflicts between nodes and 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 9c, 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 9c. In figure 9c, 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 10 depicts a flowchart 1000 of the scheduling of the groups depicted in the graph 930 in Figure 9c. The numbers in Figure 9 correspond to the order in which the nodes in Figure 9c and / or processing elements in Figure 8 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 9a-9c, the depicted example in figure 10 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 9, 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 9 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 11 depicts a graph 1100. The graph 1100 is the graph of Figure 9a, 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 1102, a second PE is associated with a second batch of nodes 1104, a third PE is associated with a third batch of nodes 1106, a fourth PE is associated with a fourth batch of nodes 1108, a fifth PE is associated with fifth batch of nodes 1110, and a sixth PE is associated with a sixth batch of nodes 1112. 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: iii) 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 11, 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. As will be appreciated, in some implementations, the PEs carry out steps according to their groups, sequentially. When a PE in a group carries out steps of the algorithm it does so in respect of each of its batch of nodes successively. For at least some of the stages of the algorithm, the PE first determines whether a node is in a cluster, before carrying out the steps only for those nodes which are determined to be in a cluster. A schematic of an exemplary quantum computing system 1200 suitable for performing the method of the present disclosure is shown in Figure 12. The quantum computing system 1200 comprises a plurality of physical qubits 1206 (unless specified otherwise, reference herein to qubits should be understood to refer to physical qubits rather than logical qubits). The qubits 1206 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 1200 uses qubits 1206, 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 1206 are controlled by a control system 1204 having one or more classical processors. The control system 1204 transmits control signals (e.g. RF pulses) to the qubits 1206 for performing operations on the qubits 1206 (including measurement operations) and receives measurement information from the qubits 1206. 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 1204 in some implementations (e.g. the qubits 1206 may be provided with one or more analogue to digital converters). The control system 1204 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 1200 also comprises a decoding system 1202 (also referred to herein as a decoder). The decoding system 1202, which is generally a classical computing system, receives an error syndrome (also referred to as syndrome data) obtained from measurements of syndrome qubits. The error syndrome may comprise raw analogue measurement data, or it may alternatively be pre-processed (e.g. into digital format) by the control system 1204. The decoding system 1202 may be connected to the control system 1204 and receive the error syndrome via the control system 1204 as illustrated in Figure 12 (potentially via one or more additional intermediary systems), or in alternative examples the decoding system 1202 may be connected directly to the qubits 1206 and receive the error syndrome from the qubits 1206 (e.g. as raw analogue signals or digital measurement values). The decoding system 1202 uses a decoding process / algorithm to decode the error syndrome to determine a correction for an error state of the qubits 1206 associated with the error syndrome (i.e. an error state that causes the measured error syndrome). The decoding system 1202 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 1200 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 1202 may be connected directly to the qubits 1206 as previously described). Figure 13 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) 1310 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 1310 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 13. The computer readable media may be transitory or non-transitory. The one or more computer readable media 1300 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. Pseudo-code examples for implementing a clustering algorithm 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. 5 Consider the MERGING stage as an example. As can be appreciated from listing 3 below, the merging stage steps are performed only in respect of those nodes which are in a "frontier" data structure, i.e. only in respect of those nodes which are in a cluster. Listing 3 also indicates the manner in which new nodes which meet the criteria are added to the frontier. One or more other stages of the method 600 may also be performed in respect of those nodes which are in a 10 cluster. For example, other stages of the method 600 may comprise an outer loop over the nodes in the frontier data structure. Considering the GROWING stage as another example, as can be seen from listing 2, in the growth stage, only those PEs which are in the frontier may be considered when determining whether the growth parameter value (node.growth) should be increased by one unit up to a maximum growth parameter value (here, the maximum growth parameter is 2). 15 The pseudo-code listings provide examples of how the frontier data structure can be used to improve speed and power efficiency in any of the GROWING, MERGING, PICKING, and / or SYNCYING stages. 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 frontier: if node.active and node.growth < node.growth += 1 Listing 2. Run by each PE during the GROWING stage def merging () : for node in frontier: node.busy = 0 for neighbor in node . neighbors : if node.radius + neighbor. radius >= 2: $ The edge is fully-grown, so add get_frentier(neighbor). add(neighbor) 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 frontier. Listing 3. Run by each PE during the MERGING stage def pick i ng (): for node in frontier: node.active = node.parent == node and node.parity Listing 4. Run by each PE during the PICKING stage def sync! ng () : for node in frontier: 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;performing, by the plurality of PEs, a clustering algorithm, the clustering algorithm comprising a plurality of steps, and 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 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, wherein performing the one or more first steps by each PE comprises:determining which nodes of the PE's associated batch of nodes are in a cluster; and performing, in respect of each of the nodes determined to be in a cluster, the one or more first steps of the clustering algorithm.

2. The method of claim 1, wherein each PE of the plurality of PEs comprises its own dedicated memory.

3. The method of claim 2, wherein, for each PE of the plurality of PEs, the dedicated memory stores cluster-node data which indicates which nodes of the PE's batch of nodes are in a cluster; andwherein each PE determines which nodes of its associated batch of nodes are in a cluster by consulting its cluster-node data.

4. The method of claim 3, wherein performing the one or more first steps further comprises updating the cluster-node data as the clustering algorithm progresses.

5. The method of any of claims 2 to 4, wherein each step of the clustering algorithm is associated with a stage of a plurality of stages of the clustering algorithm.

6. The method of claim 5, wherein the stages of the clustering algorithm comprise a growth stage;wherein, in the growth stage, one or more PEs update a growth parameter associated with at least one of the nodes in their respective batches by one unit up to a maximum growth parameter value, and store the updated growth parameter values in their dedicated memories.

7. The method of claim 5 or claim 6, wherein the stages of the clustering algorithm comprise a merge stage; wherein, during the merge stage, each PE:determines, for each node determined to be in a cluster, whether the nodes which neighbour the node should join the cluster based at least in part on one or more merging criteria; andupdates the cluster-node data for those nodes which meet the one or more merging criteria and which did not previously form part of a cluster.

8. The method of any of claim 6, or claim 7 when dependent on claim 6, wherein the stages of the clustering algorithm comprise a merge stage and, in the merge stage, each PE of the plurality of PEs determines which nodes of its associated batch of nodes are in a cluster, and for each node determined to be in a cluster:queries a dedicated memory of a PE associated with a neighbouring node to determine a sum of the growth parameters of the node and a neighbouring node, wherein the neighbouring node neighbours the node in the hypergraph;determines whether one or more merging criteria are met, the one or more merging criteria comprising whether the sum meets a growth parameter threshold; andif the one or more merging criteria are met and the neighbouring node is not already in its own cluster, adds the neighbouring node to the node's cluster.

9. The method of claim 8, wherein if the neighbouring node is already in its own cluster and the one or more merging criteria are met, the PE merges the nodes' cluster and the neighbouring node's cluster.

10. The method of any preceding claim, wherein the one or more first steps of the clustering algorithm are performed successively for each node determined to be in a cluster.

11. The method of any preceding claim, wherein the plurality of PEs comprises a first PE, the first PE being associated with a first batch of nodes comprising at least a first and a second node, and wherein during a first stage of the clustering algorithm, the first PE: determines that the first node is in a cluster and that the second node is not; and performs the one or more first steps of the clustering algorithm in respect of the first node, and does not perform the one or more first steps in respect of the second node.

12. The method of claim 11, wherein the clustering algorithm is iterative such that the first stage of the clustering algorithm is performed multiple times as the clustering algorithm progresses; wherein, if the second node is added to a cluster as the clustering algorithm progresses:during subsequent performances of the first stage of the clustering algorithm, the first PE performs the one or more first steps of the clustering algorithm in respect of the first node and in respect of the second node.

13. The method of any preceding claim, 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 the one or more first steps of the clustering algorithm in respect of each of their respective batches of nodes, and then PEs in a second group perform the one or more first steps of the clustering algorithm in respect of each of their respective batches of nodes.

14. The method of claim 13, wherein each PE in the first group successively performs the one or more first steps of the plurality of steps of the clustering algorithm in respect of each of the nodes in its batch of nodes determined to be in a cluster, and each PE in the second group successively performs the one or more first steps of the plurality of steps of the clustering algorithm in respect of each of the nodes in its batch of nodes determined to be in a cluster.

15. The method of any of claims 13 or 14, 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.

16. 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; andinstructions which, when implemented by the decoder apparatus, cause the decoder apparatus to perform the method of any preceding claim.

17. 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 15.

Images