Strategies for the preparation of large cluster states using non-deterministic gates

The cluster state model for quantum computation has paved the way for schemes that allow scalable quantum computing, even when using non-deterministic quantum gates. Here the initial step is to prepare a large entangled state using non-deterministic gates. A key question in this context is the relative efficiencies of different ‘strategies’, i.e. in what order should the non-deterministic gates be applied, in order to maximize the size of the resulting cluster states? In this paper we consider this issue in the context of ‘large’ cluster states. Specifically, we assume an unlimited resource of qubits and ask what the steady state rate at which ‘large’ clusters are prepared from this resource is, given an entangling gate with particular characteristics. We measure this rate in terms of the number of entangling gate operations that are applied. Our approach works for a variety of different entangling gate types, with arbitrary failure probability. Our results indicate that strategies whereby one preferentially bonds together clusters of identical length are considerably more efficient than those in which one does not. Additionally, compared to earlier analytic results, our numerical study offers substantially improved resource scaling.


Introduction
The development of cluster state (or one-way) quantum computation [1] has presented us with a completely alternate perspective to the standard circuit model for quantum computing (QC). This model has the benefit that it transfers all entangling quantum gates to an offline state preparation stage. This has attracted much interest in the QC community because in some instances it has highly favourable properties. One of the key benefits offered by this model is its applicability to architectures where entangling gates are non-deterministic, such as linear optics QC [2,3].
Here the cluster state model can allow significant physical resource savings when compared to the circuit model, most notably in optical implementations [4]- [9]. The central idea here is that a large cluster state, a highly entangled state of many qubits, can be 'grown' using a 'divide-andconquer' approach, whereby smaller clusters are iteratively bonded together, a process which can lead to very efficient physical resource scaling characteristics. While several approaches for efficiently growing cluster states using non-deterministic gates have been prescribed, a key open question is 'what are the minimal physical resource requirements for preparing a certain cluster using entangling gates with a given success probability?' and 'what strategy (or algorithm) must be employed to achieve optimal resource scaling?'.
A number of other authors have considered the problem of efficiently constructing cluster states using non-deterministic two-qubit entangling operations (EOs). The authors of [4,5] present procedures for generating multi-qubit entangled states (cluster states in the case of [4] and 'linked states' in [5]) using non-deterministic linear optical gates, and calculate the efficiency of this process for particular values of the success probability of the elementary EOs, p gate , with p gate > 1/2. Subsequently, in [9], a simplified linear optical scheme for generating cluster states was described, and it was also shown how to scalably construct clusters in the case where p gate = 1/2. In [10] a comparable scheme is described within the standard circuit model.
In [6], and subsequently [8], these ideas were extended to the case of arbitrary values of p gate . In particular, it was shown that, even for arbitrarily small values of p gate , linear clusters can 3 DEUTSCHE PHYSIKALISCHE GESELLSCHAFT be grown with a cost that grows linearly with the size of the required cluster, albeit with a linear coefficient that becomes rather large for very small values of p gate .
One shortcoming of the calculations presented in [6,8] is that, in order to obtain analytic approximations for this overhead cost, certain assumptions are made that necessarily reduce the efficiency of the protocol. In particular, it is assumed that short clusters (below some critical length that depends on p gate ) are constructed without recycling-upon gate failure, the remaining subclusters are discarded and construction starts from scratch. In this paper, we avoid such profligate measures by directly computing the cost of a more frugal scheme via numerical simulations.
In general, the questions of optimal strategies and physical resource requirements are difficult problems. Previous work by Kieling et al [11,12] considered this issue. Here the authors specifically focused on the linear optics implementation of [9], where gate success probability is assumed to be p gate = 1/2. They assumed a resource of N Bell pairs, and asked, for a given strategy of bonding them, what the expected length of the longest chain, Q(N), will be. They then considered the behaviour of Q(N) against N for various strategies and asked what the upper bound on this scaling relationship was. There are two strategies that were given special attention in their analysis that we will repeat here. The first is Greed, whereby we always preferentially bond the largest existing cluster states together. Intuitively one might expect such a strategy to perform extremely well-we rapidly build up clusters of higher length. The second is Modesty, where we do exactly the opposite and always preferentially bond the smallest available clusters together. Surprisingly, the authors showed that Greed is in fact not only a sub-optimal strategy, but Modesty is substantially better and close to optimal. More recently, other strategies for growing cluster states based on percolation theory have been examined [13].
In this paper, we consider the question of cluster state preparation strategies from a slightly different perspective. Specifically, if we are ever to implement large-scale cluster state QC we will effectively be operating in a regime where we must have an effectively infinite resource of qubits. In such a situation we are interested in the rate at which we can prepare 'large' clusters from this resource, i.e. how many elementary EOs must we perform per large cluster we prepare? Thus, in our analysis we assume an infinite resource of qubits and calculate the rate at which large clusters are prepared from this resource, given a particular entangling gate. Our approach is to employ a numerical Monte Carlo simulation of the preparation procedure. This technique works for a variety of different entangling gate types with arbitrary gate success probability.
Related questions to that examined in this work have been addressed in other papers appearing in this special issue. Campbell et al [14] have considered appropriate strategies in the presence of physical imperfections in the experimental apparatus, while Kieling et al [15] consider the related question of the maximum size of cluster state that can be prepared with given initial resources.
In this paper, we focus on the preparation of linear clusters, which are basic primitive in the construction of larger clusters. There are many strategies for preparing arbitrary large cluster states. For example, in the scheme of Nielsen [4], a resource of star-shaped 'micro-cluster' is used to prepare large cluster states using non-deterministic gates. These star-shaped clusters can in turn be prepared from linear clusters using local operations and single-qubit measurements. Similarly, in the scheme of Duan and Raussendorf [8] a resource of linear clusters are used to prepare '+'-shaped clusters, which facilitate the construction of lattice clusters using nondeterministic gates. The scheme of Kieling et al [11,12] describes a 'weaving' technique, where a lattice cluster is prepared directly from a number of linear clusters. A different approach to preparing lattice clusters from linear clusters is described in [6,7,9,16]. In these cases the additional cost of preparing 2D clusters from 1D chains is well understood. Therefore, it is appropriate to focus our attention on the preparation of linear clusters as a primitive for use in such higher-level protocols.
This paper is structured as follows. In section 2, we present background material on cluster states, strategies and gate types. In section 3, we describe our analysis techniques, and in section 4, we discuss our simulation results. We conclude in section 5.

Cluster states
The standard circuit model for quantum computation is very analogous to our usual understanding of classical circuits-we begin with an input state, apply a series of gates to manipulate the state, and then measure the output to determine the 'answer'. The cluster state model is completely different and has no analogy in classical circuit theory. Here we prepare a highly entangled state, known as a cluster (or graph) state, and then perform some sequence of single-qubit measurements. The choice of measurements-both the measurement basis and the order in which they are performed-then implements the algorithm.
It has been shown that lattice clusters are universal for quantum computations up to a given size. Thus lattice clusters act as a resource for universal quantum computation. For this reason theoretical studies often focus on lattice clusters.
A cluster state can be expressed as a graph, hence the alternate term 'graph state'. In this representation vertices represent single qubits that are initially prepared in the |+ = (|0 + |1 )/ √ 2 state. Graph edges represent controlled-phase (CZ) gates performed between the neighbouring vertices. This bonding procedure is shown in figure 1.
An additional property of cluster states that we will make use of in this paper is qubit removal. When a qubit is measured in the Z eigenbasis (where Z is the usual Pauli phase-flip operator) this removes the qubit and any edges connecting to it, while leaving the remainder of the cluster unchanged. This property is useful to recover from certain types of gate failure. For example, consider a linear cluster to which we attempt to bond another cluster at the end. If the bonding fails with no well-defined failure outcome (i.e. the qubit is effectively depolarized) then Table 1. Summary of different bonding strategies. For the Modesty and Paired Modesty strategies single qubits are excluded from the decision-making process, unless no larger clusters are available. This is necessary since we assume an infinite resource of single qubits. This is distinct from the Modesty strategy employed in [11,12]. The Pairedvariations of strategies always only bond two clusters of identical size. Thus, bins containing only a single chain will not undergo bonding.

Strategy
Choice of clusters to bond

Two largest available clusters Modesty
Two smallest available clusters Random Randomly choose two clusters Paired Greed Largest available identical clusters Paired Modesty Smallest available identical clusters Paired Random Random identical clusters performing Z measurements on the qubits adjacent to the affected ones recovers the remainder of the cluster by isolating the malignant qubits from the rest of the graph. This is shown in figure 1.
We have only recapped the basic properties of cluster states requisite for our analysis techniques. Excellent reviews of the cluster state model can be found in [1,17,18].

Strategies
Beginning with a resource of qubits, we begin bonding clusters together to construct progressively larger cluster states. At any point in time, we will have a 'pool' of clusters of varying lengths, to which we may apply bonding operations. A 'strategy' is an algorithm that inspects the current pool of available clusters and decides which two clusters to attempt to bond together. Previously we reviewed two strategies-Greed and Modesty. In our simulations we will consider several additional strategies, which we summarize in table 1 (note that the Modesty strategy applied in this work differs from that in [11,12], as will be discussed in section 4).
Typically there will be much room for parallelizability in bonding strategies, limited only by the number of gates available, the number of clusters in the pool, and potentially other practical constraints. While this parallelization will not reduce the overall number of bonding operations that must be performed, it will, in general, reduce the average amount of time qubits spend in quantum memory. Clearly this will generally be highly favourable from a decoherence perspective.
In all our simulations we do not employ any parallelization. That is, exactly one gate operation is applied per time step. There are two reasons for this. Firstly, it eliminates a parameter and makes the results much easier to digest. Secondly, the resource efficiency of a strategy without parallelization will represent an upper bound on the achievable resource efficiency with parallelization, and therefore is an extremely useful parameter to know. This is because any strategy involving parallelization can be simulated without parallelization, but the converse is not true in general. Therefore, parallelizability represents an added constraint on the class of strategies that can effectively be implemented. Table 2. Resource usage of different cluster state bonding operations, acting on the initial cluster states {l 1 , l 2 }. 'CZ' is a generic non-destructive controlled-sign gate. No qubits are lost upon success. However, the failure mode of the gate is undefined. Thus, recovering the clusters upon failure requires measuring the neighbouring qubits in the Z eigenbasis [8]. The 'KLM CZ' gate [2] CZ performs Z measurements on both qubits upon failure. This has the effect of removing the qubits from the cluster and no further recovery measurements are necessary. The 'type-I fusion' [9] and 'EO' [6] gates implement a partially destructive fusion. Upon success one of the two qubits is consumed, and upon failure both qubits are effectively measured in the Z eigenbasis. The 'type-II fusion' gate differs only in that upon success both qubits are consumed.

Gate type
Success Failure It is important to note that any model of quantum computation in the presence of noise must have some degree of parallelization, in order to be fault tolerant in the presence of noise [19]. Thus, ultimately the extent to which strategies can be parallelized will be an important consideration for future work in this area.

Gate types
In addition to various strategies for bonding clusters together there are a variety of gates that may be employed to perform the necessary bonding operations to prepare cluster states. Specifically, there are two features that differentiate bonding gates. The first is their success probability, p gate . In our simulations we treat this as a parameter. The second is their resource usage. That is, how qubits are wasted upon success and failure respectively. Formally, a bonding operation will act on a set of two linear clusters of lengths l 1 and l 2 , which, upon success or failure will be mapped to a set of new linear clusters. In table 2, we summarize the most well-known gate types and their resource usage. The action of these gates is shown graphically in figure 2.
In our simulations, we will primarily focus on three gates in particular: two variations of the CZ gate-the archetypical bonding gate; and, the so-called EO gate introduced in [6], also referred to as the Double Heralding gate in the literature. These gates are particularly relevant to current architectures for performing quantum computation using non-deterministic gates.
The regular CZ gate, upon success, acts in the usual way, implementing a non-destructive CZ operation. Upon failure its action is undefined. Thus to recover the remaining cluster one must measure the qubits neighbouring the ones acted upon by the CZ gate in the Z-basis. This disconnects those qubits from the cluster resulting in two clusters, each two qubits smaller in size [20].
The Knill-Laflamme-Milburn (KLM) CZ gate differs in that upon failure it performs Z-measurements on the affected qubits. Thus, these qubits are automatically removed from the clusters and no additional measurements are needed to recover. Therefore, the KLM CZ gate is more resource savvy and, upon failure, results in two clusters each with only one qubit removed.
The EO gate is employed in a hybrid scheme, involving both photons and 'matter qubit' systems. These may be trapped ions or atomic systems, impurities in semiconductors or insulators (e.g the nitrogen-vacancy in diamond system) or quantum dots. In this approach, the matter systems contain additional optical transitions, such that photons can be emitted whose state is conditional on the logical qubit state. In [6] the photons are encoded in separate time windows, although other encodings such as frequency have subsequently been proposed [20].

DEUTSCHE PHYSIKALISCHE GESELLSCHAFT
Two matter qubit systems can be entangled by first inducing them to emit photons, passing these photons through a simple passive linear optical device (typically a beam-splitter), and detecting the output modes with destructive photo-detectors. In [6] two such rounds are implemented, one for each time window. Success of the scheme is 'heralded' by a particular sequence of detector clicks, and results in a highly entangled state of the two qubits.
In fact, it can be shown that the scheme amounts to a partial parity measurement. That is, in the case of success, a projection operator + = |01 01| + |10 10| (up to local unitary corrections) is applied to the state of the two qubits. In the case of failure, each of the two qubits may be affected by a Pauli Z (phase flip) error. Success occurs with probability p gate = η 2 /2, where η is the combined photon collection and detection efficiency for each of the modes output from the beam-splitter.
This partial parity measurement can be used to generate linear cluster states as follows. Pairs of unentangled qubits are first prepared in the product state |+ |+ . Applying the EO, followed by single-qubit local unitary corrections [6] leads to a two-qubit cluster state in the case of success. In the case of failure, the matter qubits are in an unknown state and should be re-initialized. Given an l 1 -qubit linear cluster state, a single qubit can be added to one end of the chain by preparing the qubit in the state |+ and applying the EO between this qubit and the qubit at the end of the chain. On success, this results (up to local unitary corrections) in a chain of length l 1 + 1. On failure, the qubit at the end of the linear cluster may have undergone a Z-error, and so this qubit should be removed from the cluster by measuring it in the Z-basis. The result is a chain of length l 1 − 1 and two unentangled qubits which may be re-prepared. Finally, in this paper we will often consider the case when two chains of arbitrary lengths, l 1 and l 2 , are fused at their endpoints. In this case, on success, the result (up to local unitary corrections) is a chain with a 'backbone' of length l 1 + l 2 − 1 with a further dangling node (or 'cherry') which is an extra qubit connected to the backbone at the point where the two chains were connected [16]. For the purposes of this work, we assume for simplicity of our calculations that this cherry is removed via a Z-measurement. However, in general the cherry may be utilized to increase the efficiency of growing linear clusters or higher dimensional graph states [16]. Thus the estimates of the cost presented in this paper may be reduced even further.
On failure, again the end qubits of each chain must be measured in the Z-basis, and the result is two chains of length l 1 − 1 and l 2 − 1, and two unentangled qubits. These results are summarized in table 2. Note that, apart from the initial step of making two-qubit clusters, the resource usage rules for the EO and the type-I fusion [9] are identical.

Analysis
We now turn our attention to our analysis technique. Our analysis proceeds as follows. We begin with a pool of linear clusters of various lengths. We describe the state of the pool by a population vector n, whose elements correspond to the number of clusters in the pool of the respective length. Beginning with an initial population vector n 0 , we repeatedly apply a bonding strategy, which inspects the population vector and decides which two chains to attempt to bond together using the given gate operation. Let f s represent one iteration of the strategy. Then the evolution of the pool of clusters takes the form, n t+1 = f s ( n t ). (1)

DEUTSCHE PHYSIKALISCHE GESELLSCHAFT
As discussed previously, we always assume strategies apply exactly one gate operation per time unit. Thus, t gives the total number of gate operations that are applied. In our simulations we assume the population vector is initialized such that all elements are initially zero, except the first element (i.e. l = 1, the single-qubit bin), which is set to infinity. Thereafter we assume that the l = 1 bin always contains an infinite population. This sets a boundary condition for the problem.As we begin applying a given strategy to the initial population vector, higher length bins begin to populate, and eventually longer chains will begin 'spilling over' off the end of the vector. We regard any of these spillover chains as being 'complete'. Note that the definition of 'complete' depends on how many bins are used in the simulation, which we label L. Once qubits in these completed chains are removed from the vector, they play no further role in the simulation and are removed from the problem. This effectively sets a second boundary condition. One can picture the cluster growing process as a continuous (albeit stochastic) flow of qubits from the l = 1 bin until they 'spill over' and are removed from the problem. We tally the total number of qubits contained in all the cluster chains that spill out of the population vector, which we label N Q .
After a sufficient number of applications of the bonding strategy the system reaches a quasi-steady state, whereby the average population of each bin in the population vector remains constant, averaged over a sufficiently large time period 4 . In our simulations we are interested in the quasi-steady state dynamics of this evolution. In particular we are interested in the rate at which large clusters are prepared per gate operation. Thus we define, r is to be interpreted as the rate at which qubits are added to the long chains. Note that 1/r corresponds to the average number of attempted entangling gate operation per qubit added to the completed chains. At first our treatment of large clusters may appear somewhat dubious, in that we are treating all large clusters, irrespective or their individual lengths, as being equal and simply putting them in one basket. The key observation here is that the resource overhead in bonding together multiple large clusters is negligible compared to the size of the cluster. Specifically, with a gate success probability of p gate one expects to perform 1/p gate bonding operations on average until two clusters are successfully joined. If the lengths of the individual chains are much larger than this, l 1,2 1/p gate , this overhead is negligible and bonding can essentially be treated as 'free'. Thus, in the large cluster regime, it is justified to assume that a pool of large clusters is equivalent to a single large cluster of size equal to the cumulative size of the pool. Furthermore, for L 1/p gate , r becomes independent of L. Thus, for simulation purposes we can simply choose some value of L, sufficiently large that changes in L leave r unchanged.
It is important to note that this technique is only suited to the analysis of linear cluster state preparation. The reason for this is that the population vector, n, contains a single entry for each possible graph configuration. When restricted to linear graphs the dimensionality of n is just the maximum number of qubits. However, in the 2D case the dimensionality of n grows exponentially with the number of qubits, ruling out even moderately large simulations.
In our analysis we ignore the effects of decoherence. Clearly while chains are sitting in bins they must be kept in some form of quantum memory, which will inevitably have a decohering effect. We do not consider these effects for two reasons. Firstly, we desire our result to represent bounds on physical resource requirements for given strategies and gate types. Secondly, decoherence will be strongly related to parallelization, an issue we avoid in this paper.

Results
We simulate the effect of bonding strategies and gate parameters using a Monte Carlo approach. We use a population vector with L = 50 bins, and simulate over 50 000 time steps. At each time step we tally N Q , the number of spillover qubits. Finally, at the end of the simulation we calculate r, the rate at which large clusters were prepared. We consider all six strategies listed in table 1. There is one caveat associated with the Modesty and Paired Modesty strategies. Specifically, we exclude the single-qubit bin from the calculation, unless no other bins are populated. The reason for this variation, relative to the Modesty strategy discussed in [11,12], is that we are assuming an infinite resource of single qubits. Thus, without this modification Modesty strategies would forever be stuck bonding single qubits together.
It is important to note that in the context of an infinite resource of single qubits, the modified Modesty and Greed strategies behave somewhat differently to those discussed in [11,12]. Specifically they both reduce to 'sequential' type algorithms, where small clusters are progressively added on to a main long cluster. Consider the Greed strategy. Here we begin by finding the largest available cluster, then the next largest cluster, and bond them together. The dynamics of this process are that there will always be a single main cluster to which we bond single qubits. There is no possibility for clusters of intermediate length to arise. The Modesty protocol behaves slightly differently. Here we find the shortest cluster and then search again for the next shortest cluster. If no other cluster is found we resort to bonding two single qubits together to prepare a Bell pair. Then in the next round the Bell pair will be bonded on to the main cluster. Notice that the Modesty protocol effectively reduces to a protocol where we prepare Bell pairs offline and then bond them on to the main cluster. For this reason we expect the modified Modesty approach to offer better resource scaling than Greed, since it implements a divide-and-conquer type strategy. One could envisage generalizing this strategy to employ larger level offline state preparation. For example, one might preferentially prepare three qubit clusters, which are then bonded to the main cluster.
In figure 3 we plot r against p gate for all strategies. There are several interesting features. In agreement with [11,12] the Modesty strategy performs better than Greed for all p gate . The Random strategy performs worse again. Particularly interesting are the three Paired strategies, which all exhibit identical performance within the accuracy of our simulation. Perhaps surprisingly the Paired strategies perform significantly better than the un-Paired ones. In particular, for small values of p gate , r drops to zero (within the accuracy our simulations) for all the un-Paired strategies, which is not the case for the Paired strategies.
We have compared the performance of a variety of strategies for a given gate, the CZ gate. Next we consider the performance of different gates for a fixed strategy. In figure 4 we plot the performance of the Paired Greed strategy for three different gate types: CZ, KLM CZ and EO.
Consider the general behaviour of these plots. In the limit p gate = 1 the rate of large cluster preparation is r = 1. This is expected. It tells us that once the system attains its quasi-steady state, large clusters are spilling off the end of the population vector at an average rate of one qubit per gate operation, which clearly must necessarily be the case. For p gate < 1 we observe a lower r. This is because now the gate has some failure probability which results in larger clusters being converted into smaller cluster with nonzero probability. In other words, the dynamics of the population vector are no longer described by a one-way coupling from lower bins to higher bins, but now includes reverse couplings which slow down the overall flux of qubits towards higher length. The most striking feature of these plots is that all three Paired strategies exhibit identical performance, which is significantly better than any of the other un-Paired strategies. Although we considered only a limited set of strategies, empirically this suggests that one should always preferentially bond clusters of equal length, and beyond this the performance is strategy independent.
It is worth briefly speculating why the paired strategy seems to be a good one. Consider a different strategy in which a very long chain is bonded with very short chains, such that, on failure, the same bonding operation is attempted with the same pair of chains (which are now both one or two qubits shorter). Attempting such a bonding operation is clearly not beneficial if the length of the short chain is of order 1/p gate or less, since it is likely that the short chain will be completely destroyed before a successful bonding operation is made, and in these situations the long chain will also suffer some damage. The paired strategy specifically rules out such situations, since short chains are only ever bonded with other short chains.

Comparison with analytic results
We finish by comparing the scaling relationships obtained through our numerical methods with two recent analytical studies of resource scaling. In the first instance we compare against the analytic results of Duan and Raussendorf [8] for preparing linear clusters using non-deterministic CZ gates. In the second instance we compare against the analytic expressions obtained by Barrett and Kok for preparing linear clusters using the EO gate. See appendixA for a discussion on the derivation of the analytic expressions. Note that in both plots the best numerical scaling relationships are significantly more efficient than the analytic ones, owing to the lack of recycling in the analytic derivations leading to inefficient resource usage. In the case of the EO gate we have included a third strategy, labelled EO Greed Paired, which is identical to the usual Greed Paired strategy except that if a Bell pair is available we always preferentially bond it with a single qubit to attempt to form a GHZ state. The reason for this exception is that with this type of gate bonding two Bell pairs together also forms a GHZ state upon success. Thus, doing so wastes the operation required to form one of the Bell states. At higher levels this discrepancy no longer occurs, so the usual pairing approach is favourable.

Conclusion
We have considered the question of preparing large cluster states using non-deterministic and potentially destructive bonding operations, and the effect that bonding strategies have on the resource requirements of this process. Empirically, our results indicate that Paired strategies, i.e. ones where we only bond clusters of equal length, perform much better than un-Paired ones, especially in the regime of small p gate . Additionally, all three Paired strategies considered exhibited identical performance. This suggests that the performance of large cluster state preparation is strategy independent provided one only bond chains of equal size. This is in stark contrast to un-Paired strategies, where performance is highly strategy dependent. In this case it is observed that the Modesty strategy is superior to a Greed approach, consistent with the observations made in [11,12].
We also compared the Paired strategies with earlier analytic estimates for the cost of preparing linear clusters. We found substantial improvement in efficiency over these earlier estimates. We attribute this to the use of full recycling in our numerical analysis, whereas previous analytic results did not make full use of cluster recycling. This suggests that numerical techniques play an important role in the evaluation of resource scaling efficiency.
The analysis techniques we described are very general and hold for arbitrary gate success probabilities and a variety of different entangling gate types, including destructive ones. Therefore, our approach is suited to calculating physical resource requirements in a diverse array of different situations. However, our technique does have the disadvantage that it is only well suited to directly analysing the preparation of linear clusters.
Importantly, in our analysis we have not proven which strategies are optimal, we have simply made empirical observations that some classes of strategies are better than others, and that some are equivalent. Thus there is much room for further analysis in this direction. The MATLAB source code used for our simulations is available at http://www.physics.uq.edu.au/people/rohde/.

Appendix. Analytic estimates of the cost of growing cluster states with non-deterministic operations
An analytic estimate of the cost of growing cluster states using non-deterministic operations was given in [6]. For the purposes of obtaining simple expressions for the cost of making linear clusters, the method used was intrinsically less efficient than the one used in our numerical simulations in this work. Here, we elaborate on the calculation presented in [6], for the purposes of a comparison with our numerical results.
The method used was to build short cluster chains (above some critical length, as described below) using an inefficient technique, and then join these chains together to form a long chain. Assume that we already have a linear chain of length N, and would like to add a short chain of length m to one end of this chain, using the EO with success probability p gate . Using the rules given in table 2, the expected length of the chain after this operation is Therefore the critical length depends directly on the gate success probability. To make these short chains of length m, we use a 'divide-and-conquer' technique. For ease of calculation, we assume that if any of the gates fail, any cluster chain fragments are simply discarded, and the process starts from scratch. For instance, to make a chain of length m = 3 qubits, we attempt to bond 2-chains with single qubits. The total number of attempted gate operations to make a single 3-chain is then