{'fraction_non_alphanumeric': 0.03686926605504587, 'fraction_numerical': 0.011410550458715597, 'mean_word_length': 4.758791480931154, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Deterministic generation of arbitrary all-photonic graph states from quantum emitters

We present protocols to generate arbitrary photonic graph states from quantum emitters that are in principle deterministic. We focus primarily on two-dimensional cluster states of arbitrary size due to their importance for measurement-based quantum computing. Our protocols for these and many other types of two-dimensional graph states require a linear array of emitters in which each emitter can be controllably pumped, rotated about certain axes, and entangled with its nearest neighbors. We show that an error on one emitter produces a localized region of errors in the resulting graph state, where the size of the region is determined by the coordination number of the graph. We describe how these protocols can be implemented for different types of emitters, including trapped ions, quantum dots, and nitrogen-vacancy centers in diamond.

FIG. 1. Two-dimensional cluster state. Each vertex represents a qubit, and each edge represents entanglement between the qubits it connects. This state can serve as a resource for universal measurement-based quantum computation.

I. INTRODUCTION
Quantum information science holds the promise of providing novel capabilities and computational speedups for a host of problems related to computer science [1], secure communication [2][3][4][5][6], the simulation of physical systems [7,8], and distributed computation [9][10][11][12]. One quantum computing paradigm is measurement-based computing [13][14][15] with a highly entangled cluster state (Fig. 1). The appeal of this approach is that once a two-dimensional cluster state is created, only local measurements of each qubit are required to perform arbitrary quantum computation. If the qubits are photons, this corresponds only to waveplate operations and polarized photon counters.
Cluster states have been experimentally demonstrated using trapped ions [16,17], squeezed states of light [18][19][20], superconducting qubits [21], and photons [22][23][24][25]. In the case of photons, this was done both by a combination of frequency down-coversion and fusion gates [26], and by pumping entangled photons from quantum dot emitters [24] using a pulsed generation protocol for the creation of one-dimensional cluster states [27]. This approach coherently drives a quantum dot into an excited state manifold, after which it then relaxes back to a ground state or metastable manifold via spontaneous emission, creating photons entangled with the emitter. This is a deterministic approach in the sense that no probabilistic fusion gates are needed.
A generalization of the deterministic pulsed generation protocol produces 2 × m "ladder" photonic cluster states [28]. In this scheme, two quantum dot spins are acted on by a twoqubit controlled phase gate, creating entanglement. When both dots are then pumped to produce a pair of photons, these photons are entangled with each other. If this process is repeated multiple times with a periodicity that allows for free, single-qubit precession by an angle of π/2 between each entangling operation and pumping process, then the resulting state is a 2 × m cluster state, where m is the number of cycles. Schemes to create ladder-type cluster states using trapped ions have also been proposed [29]. However, for universal quantum computation, a larger two-dimensional grid (n by m, with n, m 2) is needed; moreover, fault-tolerant universal computation requires a three-dimensional grid [30]. One proposal to create a larger two-dimensional grid using feedback and atom-photon interactions in a cavity has been put forward [31].
In this paper, we propose a deterministic method to produce an arbitrary graph state that does not require qubit-photon interactions. Instead, the entanglement is created between emitters and then transferred onto photons through optical pumping. This is similar to the idea presented in Ref. [28], although here, in addition to being able to create graph states of arbitrary size, our scheme also allows for the entangling operations between emitters to occur after the photon pumping, which can make the protocol more compatible with experimental constraints. Our protocol allows for arbitrary sized n by m clusters, given a linear array of n emitters, where each emitter can be entangled with its nearest neighbors. For three-dimensional clusters, which permit fault-tolerant universal computation, our protocol requires a two-dimensional grid of nearest-neighbor connected emitters. This paper is organized as follows. First, a brief overview of the graph state formalism is provided. Second, our new framework to produce arbitrary graph states using emitters, assuming entangling gates are available between emitters, is presented. Then, we discuss concrete realizations of parallelized two-and three-dimensional cluster state generation protocols, which require a number of emitters that is proportional to the width of the cluster, entangling gates only between nearestneighbors, and a time proportional only to the length of the cluster. We close with an assessment of realizations in ion traps, quantum dots, and nitrogen-vacancy color centers.
Energy level structure in a quantum dot emitter. The Jz = +1/2, +3/2 states shown at left are degenerate with the opposite angular momentum states at right. Selection rules prohibit crossexcitation or decay. Both ground states can be driven coherently up to their respective excited states by linearly polarized light (orange lines), leading to spontaneous emission from the dot (blue arrows), producing a single photon with polarization entangled with the spin degree of freedom of the quantum dot.

II. GRAPH STATES FROM QUANTUM EMITTERS: GENERAL CONSIDERATIONS
A graph state [32] is a simultaneous eigenstate of the stabilizer operators with eigenvalues equal to 1. Here, G is a graph in which each vertex represents a qubit, and edges represent entanglement between the connected qubits. There is one stabilizer for each vertex, a, of the graph, and it involves the application of Pauli operations to each of its neighboring vertices, b. Every graph G can thus be used to define a particular multi-qubit state. The graph provides a compact and pictorial way to represent certain highly entangled states of many qubits. Graph states can also be defined in a constructive way by first preparing each qubit in the state |+ = (|0 + |1 )/ √ 2 and then applying a two-qubit controlled-Z gate between each pair of qubits connected by an edge: The CZ 's commute with each other, so the order in which they are performed is immaterial. While this description suggests a natural way to create a graph state, such an approach will not work with photons because there is no efficient, deterministic method to directly entangle pre-existing photons. We will focus on producing such a state using physically reasonable operations, in a way that avoids the necessity to implement entangling operations directly between photons or between photons and emitters. We assume that the level structure and selection rules of the emitter are such that each of its (a) Illustration of the 1D Lindner-Rudolph cluster state generation procedure. (a) A single emitter is initialized into the state |0 , and then H acts to produce |ψ1 . A proper Hadamard H would have θ1 = θ2 = ϕ = 0, but we will see here that this is not necessary. (b) The photon pumping action creates |ψ2 , and then H is applied to produce |ψ 2 . Local phase operations on p1 can remove the phases to create |ψ 2 , which is a graph state, up to a basis change (on the emitter only). (Here, H |0 = + and H |1 = − and |± = (|0 ± |1 )/ √ 2.) (c) Subsequent pumping and action of H produces |ψ 3 . Local phase operations on qubits 1 and 2 correct the phases of H in |ψ 3 , which is again a graph state, (again, up to a local basis change on the emitter only). two ground states optically couples to its own excited state, and that the two transitions have opposite polarization selection rules (i.e., the emitter possesses an "II" level system). In this case, if the emitter is initially in a superposition state, then optical excitation with linearly polarized light followed by spontaneous emission will produce a photon that is entangled with the emitter: where the first ket corresponds to the emitter, and the second to the newly emitted photon. Thus, when the emitter is prepared in a generic superposition before the pumping process, it will be entangled with the emitted photon. Maximal entanglement will occur for an equal superposition, |α| = |β|. Such a state can be initialized by first preparing the emitter in one of the basis states and then applying a Hadamard-like gate on it, The Lindner-Rudolph protocol for generating 1D cluster states [27] amounts to alternating between applications of H and optical pumping, as is illustrated in Fig. 3. Each cycle entangles a new photon to the graph. The protocol works for any H of the form shown in Eq. (4), although in the remainder of this paper, we will focus on the case where H = H is a proper Hadamard gate, corresponding to θ 1 = θ 2 = ϕ = 0. The fact that repeating the pump-Hadamard cycle produces a 1D photonic cluster state can be seen from the following. Start by assuming that the emitter is already entangled with n photons in a 1D cluster state |ψ n+1 with the emitter at one end. Using the Schmidt decomposition, we can write the state as |ψ n+1 = |0 e |ψ n +|1 e ψ n , where here we assume that ψ n ψ n = 0. Now consider pumping the emitter and then applying H on it: Pumping the emitter e yields the first transformation, with the emitted photon labelled by p. The second transformation is the action of H on the emitter. The final expression can be expanded as |0 e |ψ n |0 p + ψ n |1 p + |1 e |ψ n |0 p − ψ n |1 p . (6) This is the Schmidt decomposition of a state in which the emitter is now entangled with n + 1 photons. More precisely, the multi-photon state multiplying |0 e in this decomposition is essentially just the original cluster state |ψ n+1 we started with, but where the emitter has been replaced by the newly emitted photon p. Moreover, Eq. (6) is the state we would get if we started with (|ψ n |0 p + ψ n |1 p ) |+ e and then applied a CZ gate between photon p and the emitter. This implies that it is the 1D cluster state |ψ n+2 for n + 1 photons and the emitter, with the emitter attached at one end. Thus repeating the pump-Hadamard cycle n times produces a 1D cluster state involving n photons. Now suppose that we replace the state |ψ n (and ψ n ) in Eqs. (5) and (6) with a general graph state |Ψ (and Ψ ) that may involve multiple photons and other emitters with which the emitter is entangled. The pumping and Hadamard operations still act in the same way, leading to the conclusion that these two processes together essentially insert a new photon into the graph in the place of the emitter, while the emitter gets pushed out from the graph and is only connected to the new photon. This is one way to understand why entangled emitters produce entangled photons, as originally shown in A local complementation, corresponding to X (Z) rotations by π/2 (−π/2) on the green (blue) highlighted qubit(s). All possible edges among the neighbors of the green qubit are "toggled" in the sense that the existing ones are removed, and non-existing ones are created. Such toggled edges are presented as dashed black lines. Physically, it may be more convenient to track all local complementations, and only apply the final, overall unitary at the end of the graph state creation process. However, for expository purposes, we will apply them in sequence with other operations such as pumping and measurements as they are needed. [28]. The fact that this mechanism holds for a general graph features prominently in the protocols we present here.
It is important to note that the edges of the graph do not uniquely determine the entanglement structure of the corresponding state. In particular, edges can appear or disappear under the application of purely local unitary operations. The exact class of graph states that are related to each other by local unitary (LU) operations is not fully understood [32,33]. The rich [34][35][36][37], but smaller [35,38] set of local Clifford (LC) operations can be understood in graph-theoretic terms as "local complementations" [32,39] of the graph (see Fig. 4). These operations are also very useful for the protocols we introduce below; they describe an equivalence class of graphs that can be accessed from one another by local unitary operations. In the present context of all-photonic graph states, this corresponds to waveplate operations. In the following section, we describe an experimentally meaningful coarsening of these equivalence classes: we additionally allow CZ entangling gates on preferred vertices (i.e., the quantum emitters).

III. GENERAL SCHEME FOR EMITTING GRAPH STATES
The emitter-based graph state generation scheme described in the previous section involves first creating entanglement between emitters and then pumping the emitters to create entangled photons. However, instead of creating the entanglement and then pumping, which requires all entanglement edges to have been created before performing the pumping action, the entanglement edges can be produced after emission of the photons, as is illustrated in detail in Fig. 5. This may lead to simplifications in the experimental implementation of such schemes. For instance, if the pumping process admits some mechanism for heralding the successful emission of a photon, then one could choose whether or not to implement subsequent entangling gates based on this information. Because all local unitary operations on the photons commute with all operations on the emitters (except for the pumping), the operations on the emitters described in Fig. 5 can be collected into a single entangling operation: where U (1) and U (2) are X and Z rotations (by π/2 and −π/2), and the subscripts 1 and 2 indicate which emitter the operator is being applied to. We emphasize that g adds precisely one edge between a pair of photons that have already been emitted, irrespective of other qubits' entanglement with the two photons. There remains some freedom in the choice of U (1) and U (2) (and some choices may be preferred for a given type of emitter), but regardless of this choice, g is locally equivalent to a maximally entangling gate. We will take U (2) U (1) = H for concreteness here. Other combinations of gates might allow for better parallelization, e.g., the scheme of Fig. 8 might avoid the final CZ , because it could in principle be performed in parallel. Finally, notice that which explains that our choice of which emitter to perform the first local complementation on (in Fig. 5) is immaterial. We now have in place all the basic ingredients we need to describe our general protocol for creating arbitrary graph states. The full protocol is illustrated in Fig. 7, and is, in summary, 1. The emitters are initialized to |+ = (|0 + |1 )/ √ 2.
2. Emitters are pumped and H is applied for each photon in the desired "active" layer.
3. Entanglement edges are created using optimized g, until at least one photon has every desired entanglement edge (and possibly one extra, attached to the emitter).
4. The emitter attached to that photon is pumped, and H is applied.
5. If the newly emitted photon is not part of the target state (i.e., if the entanglement edge to the emitter was ultimately unneeded), it is measured in the Z basis, disconnecting the emitter from the graph state. If another photon is desired in the active layer, the emitter is pumped and H applied once again.
6. Steps 3-5 are repeated until all photons and edges are created. For step 3 to be performed, the emitters must have sufficient connectivity to produce the appropriate entanglement edges. That connectivity, and the number of emitters required, depends on the graph state and the order that the photons are produced. This can be understood in terms of the number of the "active photons" which are directly linked to an emitter via a graph edge and waiting to be connected to additional photons (e.g., the photons outlined in red in Fig. 7). The maximal number of photons in this layer determines the number of required emitters, and the connectivity between photons in that layer corresponds to the connectivity required between emitters. In particular, each photon is kept directly entangled with an emitter (in the graph state sense through an entanglement edge) until all entanglement edges associated with that photon have been constructed. Among the photons still attached to the emitters (the active layer), entanglement is produced between emitters and transferred to the existing photons via g and appropriate local operations on the emitted photons.
To illustrate why photons need to remain attached to emitters until all their connections are created, and to understand better why a single CZ gate is not in general sufficient to create an entanglement edge between two photons, consider the graph state shown in Fig. 6(a). Could a single CZ , creating a single entanglement edge between emitters, be sufficient to produce an entanglement edge between photons, i.e, can we get from (a) to (b) in Fig. 6 by only local waveplate operations? The answer is no. For graphs of 8 or fewer qubits, the equivalence class of graphs related by local unitary operations is the same as those related by local Clifford unitaries, or equivalently local complementations [32,33,40]. There are efficient methods to check if two graphs are related by local complementation [41], allowing us to check that the three graphs of Fig. 6 are inequivalent. However, if CZ gates are allowed on the emitters, the equivalence classes generically coarsen. We have shown, in the construction of g, a sequence of such gates that relate (a) and (b), so they are in the same coarsened equivalence class. An exhaustive numerical search shows that (c) is not included in that class, highlighting why it is necessary to keep photons attached to emitters until all their connecting edges are generated.
At this point, it is worth making a few comments about the efficiency and resource requirements of our protocol. First of all, the protocol requires the gate g to be performed for each edge in the graph. However, the number of edges in a graph is not invariant under local unitary operations. A carefully chosen local unitarily-equivalent graph state may be significantly faster to produce. Whether or not there exists an equivalent graph with significantly fewer edges likely depends strongly on the particular graph in question, and therefore so do the performance and resource requirements of the protocol. Finding optimal graphs that are local unitary-equivalent to a graph of interest remains an active area of research [42]. Furthermore, allowing for the measurement of a photon during the generation of the graph state may also significantly reduce the emitter requirements.
We now show how this protocol can be used to create a 2D cluster state of arbitrary size n × m. The step-by-step procedure is illustrated in Fig. 8. The protocol assumes that we have n emitters (where n is the smaller dimension of the graph) arranged in a linear array, and that we have the capability to perform entangling g gates between nearest neighbors. The protocol essentially amounts to alternating between applying multiple g gates between adjacent emitters in parallel and performing pump-Hadamard operations. One subtlety is that we must apply the g gates in two layers each time to avoid having a single emitter undergo entangling operations with two of its neighbors simultaneously. The fact that we can perform all the g gates in each layer at the same time allows for a significant savings in the overall time required to implement the protocol. This scheme naturally generalizes to d-dimensional cluster states; a w d−1 × m cluster state would require w d−1 emitters with connectivity between near- est neighbors, and time proportional to m×2(d−1)+constant (the factor of 2(d − 1) comes from the need to produce each edge in the active layer).
We close out this section with a discussion of errors and their propagation during the generation of the graph state. Even the highest quality systems will inevitably develop at least some error during their operation-whether it be from photon loss, decoherence of the emitters, or non-ideal emitter gates. As in other graph state generation protocols [27,28,43], the "pumping" step of the graph state generation tends to reduce the severity of the error on the emitter, at the expense of producing corrupted photons. The other stages, such as the U (2) U (1) operation of the 1D cluster case or g of the present protocol, simply transform the type of error. For example, if we commute a Pauli error past g from right to left, we obtain a residual error operator that can be interpreted as the error that remains on the emitter after g is applied. Eq. (8) allows us to only consider errors on the first qubit. To wit: which is obvious, because X commutes with itself. The remaining Pauli errors, on the other hand, have more complicated commutation properties: and FIG. 10. Raman driving from two ground S states, split by a Zeeman field (blue lines) detuned from a |P state. Emitted photons (red lines) would, in free space, be circularly or π-polarized, but in a cavity are projected to horizontal and vertical polarizations. Coherent manipulations (green lines) return the system from the metastable D 5/2 -manifold to the S 1/2 Zeeman-split ground states.
Therefore, pre-existing Y or Z errors induce an X error on emitters that are entangled via g. The X errors, however, will not propagate any further, localizing the region of damage in the emitter layer, at that step.
During the pumping process, as in the 1D cluster state case, errors are passed into the photonic states: Z errors induce an X error on the new photon; X errors induce a Z photon error on the second most recently emitted photon; and finally, Y errors induce an X error on the emitted photon and a Z error on the second most recently emitted photon [43]. As additional local operations are performed on the photons (i.e., to implement the local complementations), these will transform further (see Fig. 9).
Any error existing just before the entangling g gate is applied will propagate no further than the nearest-neighbor emitters. After the subsequent pumping step, the quantum state of the emitter is put in a form where all errors are in the photons-while maintaining the unaffected emitters entanglement with the photonic graph state. Thus, if an emitter is entangled with n other emitters, at most n + 2 corrupted photons will be produced. The error localizes, though errors on neighboring sites are not uncorrelated: fault tolerant algorithms will need to be adjusted to handle the pattern of errors created.

IV. EXPERIMENTAL REALIZATIONS
Trapped ions exhibit remarkably useful properties for the purposes of quantum information applications, including stability on the order of minutes [44], single-photon-matter quantum interfaces [45][46][47][48][49], high-fidelity universal gates [50,51], and entanglement in quantum registers, involving as many as 20 trapped ions [52,53]. Critically, the required integration of these techniques is already underway [54]. Widely recognized as a promising platform for quantum computation [55], trapped ions possess all the essential capabilities necessary to implement our graph state generation protocols.
The energy levels of a single trapped ion, e.g., 40 Ca + , in a cavity, are shown schematically in Fig. 10. A magnetic field orthogonal to the cavity axis induces a Zeeman splitting in each of the S, P , and D manifolds, enabling sophisticated state-specific Raman scattering (see [46,47]). In particular, states from the metastable D 5/2 manifold are Raman-resonantly excited from the Zeeman-split ground states S 1/2 ; m = ±1/2 by a monochromatic laser pulse (compare with the dichromatic pulse of [47]). The states D and D are carefully selected to maximize the overall Raman scattering strength [46]. The system is initialized (by cooling) to the S 1/2 ; m = −1/2 states, and then excited via dichromatic pumping detuned from the P 3/2 ; m = −3/2 states, as in [47]. This architecture has been realized in [46], and allows for fast (∼ 1 µs) single-qubit operations and photon generation (∼ 20 µs), with relatively long coherence times (∼ 250 µs) limited primarily by slow instabilities of the magnetic field strength. Pumping multiple ions in the same cavity requires each ion be precisely positioned at the antinodes of the standing wave-and this condition can be stabilized by the presence of multiple ions [56]. The other ions in the trap in the hyperfine manifold will be unresponsive to the scattered (pumped) photon.
Fast (∼ 10 µs), high-fidelity ( 99%) two-qubit gates have already been realized in cavities [51], suggesting that the g gates required for our protocol could be implemented with high precision. In fact, well-controlled entangling operations driven by laser fields have very recently been demonstrated with up to 20 ions [53]. Because our approach only requires entangling a pair of neighboring ions at a time, we anticipate that the main experimental challenge in implementing our protocol, at least for cluster states of size 20, lies in integrating the various operations together.
This architecture also holds promise for scaling up to the much larger cluster state dimensions required for actual quantum computations. The parallelized protocol depicted in Fig. 8, for example, can be compatible with setups involving many trapped ions distributed across several different traps. To apply the entangling gate g on emitters in different traps, a pair of optically active ancilla ions, one in each trap, are employed. The ancillae are first entangled by a heralded, but not necessarily deterministic, approach, such as [57], where a successful joint measurement of photons in a Bell state entangles the emitting ancillae. Notice that in the event of failure, this entangling operation can be retried without affecting the rest of the graph state by simply restarting the entangling step. Intra-trap gates between the ancilla ion and the desired emitter, along with subsequent ancilla measurement, are sufficient to create the maximally entangling g. Moreover, not every attempt at generating entanglement needs to be successful: after just two attempts, the probability of generating an entanglement bond is at least 3/4, which is greater than the percolation threshold for two-dimensional (and three-dimensional) square lattices [58,59]. Given a percolating subset of the cluster state, it is possible to efficiently perform generic quantum computation [60,61]. Alternatively, there is interest in shuttling ions between traps within separate cavities, which could then be directly entangled by intra-trap techniques [62][63][64][65][66]. Provided that inter-trap operations between unrelated pairs can be performed in parallel, the scaling of such a device would take time proportional to the width n of the cluster state, rather than the total number of emitted photons. For the fault-tolerant three-dimensional case, this significantly improves the theoretical performance. The higher-dimensional case requires a two, rather than one, dimensional array of ion traps, which has been demonstrated [67].
Another promising candidate architecture for our scheme is self-assembled quantum dots, with fast, optically controlled interactions [68][69][70][71], comparatively long lifetimes [72], and fast photonic pumping [27,[73][74][75][76]. The Lindner-Rudolph protocol [27] has in fact been used to experimentally demonstrate the creation of a linear five-photon cluster state from a quantum dot emitter [24]. The energy level diagram for a negatively charged quantum dot is shown in Fig. 2. Here, |↑ and |↓ are the spin states of the confined electron. Each of these ground states is coupled via circularly polarized light to a J z = ±3/2 trion, denoted by |⇑ and |⇓ , respectively. (A trion is a bound state of an exciton and an electron.) Linearly polarized light drives both transitions such that if the electron spin is prepared in a superposition, then coherent excitation followed by spontaneous emission (with time scale T 1 ∼ ns) produces a photon whose polarization is entangled with the electron spin: Because our scheme requires only nearest-neighbor entangling gates, an array of stacked quantum dots [77,78] could potentially be used to generate a 2D cluster state. Creating larger arrays and achieving high photon collection efficiency are likely among the most challenging aspects of this approach.
A third candidate architecture that we will discuss is negatively charged nitrogen-vacancy (NV) color centers in diamond or silicon carbide. The relevant energy levels of an NV center in diamond are shown in Fig. 11 [79]. Optical pumping initializes the NV into the state |0 , and microwave driving subsequently brings the system into the metastable |J z | = 1 qubit subspace, spanned by |1 , |1 . Light-matter entanglement can be achieved very much analogously to Eq. (12): linearly-polarized coherent light drives an excitation that then decays, emitting a polarized photon (T 1 ∼ 10 ns). While this decay time is slower than that of the quantum dot, the coherence time of these centers is also longer-up to a millisecond at room temperature in isotopically purified samples [80] that has been extended to nearly a second using dynamical decoupling [81], with continuing effort to further improve this via, e.g., quantum error correction [82]. Directly entangling these nitrogen vacancy centers is challenging, but (non-deterministic) heralded entanglement generation has been demonstrated [83]. A failure to entangle the NV centers would require a full restart of the graph state generation, making such an approach unsuitable. However, by using an ancillary quantum state, such as a nearby nuclear spin (e.g., 14 C), repeated attempts to produce heralded entanglement can be made without having to start the whole graph state generation process over. Then, even with a weak ( 50 kHz) hyperfine coupling between the nuclear spin and the NV-center, microwave manipulations can be used to implement fast (∼ 30 µs) entangling gates between them [43]. For this architecture, we propose a variant of our protocol where the nuclear spins play the role of the "active" layer in Fig. 7-a single nuclear spin per emitter is required. This al-lows non-deterministic operations to be performed on the NV center without disturbing the existing graph state.
Both the pumping and g operation are slightly different in this version of the protocol. We first describe the pumping operation. Because the nuclear spins are not optically active, the spin-photon interface must be realized via the NV-center. The most straightforward approach is to perform a full SWAP gate (equivalent to two entangling gates), pump the NV center, and then perform another full SWAP (to return the quantum state to the stable nuclear spin). Two full SWAP operations may take a prohibitively long amount of time. An alternative approach may be faster: (1) entangle the NV-center with the nuclear spin; (2) pump the NV-center (interspersed with H operations) twice; (3) measure the second photon to disentangle the emitter; and finally (4) perform two local complementations (one on the nuclear spin, and one on the first emitted photon), producing the desired connectivity, where the new photon has taken the place of the nuclear spin in the graph (see Fig. 12). Again, as with g, all the local operations commute with each other, so all operations on the nuclear spins and NV-center can be compiled into a single pulse. Although both procedures are more complex than simple microwave driving, the limited exposure of the long-lived nuclear spin to the noisier NV-center may improve overall fidelity. Notice the trade off between performing two entangling operations (i.e., a swap) vs two pumping operations.
Next, we describe realizations of the g operation. Similar to the ion trap case, we first obtain heralded entanglement of the NV centers by entanglement swapping while they are disentangled from the nuclear spin. Next, entangle the NV centers with their respective nuclear spins deterministically with a microwave pulse [43]. We are guided by the results of Fig. 6: using only local unitaries, the entanglement cannot be transferred from the NV centers to the nuclear spin. Instead, we complete the protocol by pumping each NV-center twice, measuring the first two photons in the Y basis, and the second two photons in the Z; the Z measurements isolate the nuclear and photonic quantum state from the NV center, and the Y measurements collapse the entanglement edges directly to the ancilla. Compare this scheme to Fig. 5 where, instead of using a second entangling operation, two Y measurements are made. As in the ion trap architecture, because the entanglement is heralded, a single failed attempt to entangle the NV-centers can be retried without restarting the whole graph state generation procedure.. Similarly, the g does not have to succeed, because incomplete cluster states (with probability of missing entanglement edges below a percolation threshold) are still sufficient for universal quantum computing.
NV-centers suffer from low out-coupling efficiencies, though this is conventionally combatted by coupling the center to a cavity [84], which has the added benefit of reducing emission out of the zero-phonon line by the Purcell effect.

V. OUTLOOK
We presented an approach to generate large-scale cluster states suitable for measurement based quantum computing. The approach requires a one-or two-dimensional array of emitters to produce a two-or three-dimensional cluster state. The time it takes to produce these states scales with the linear dimension of the state, provided the emitters can be controlled individually. Quantum errors in the emitters localize in the sense that they only affect a limited number of emitted photons, allowing for the possibility of fault-tolerant quantum computation. Additionally, the protocol can be generalized to arbitrary graph states, with the required number of emitters scaling with the generalized "width" of the graph state, and the time with the "length," again as long as the emitters can be manipulated independently. Because the protocol only requires nearest-neighbor entanglement, ion traps, quantum dots, and nitrogen-vacancy color centers are all promising platforms for carrying out the protocol.