# Distributed Quantum Computation Based-on Small Quantum Registers

###### Abstract

We describe and analyze an efficient register-based hybrid quantum computation scheme. Our scheme is based on probabilistic, heralded optical connection among local five-qubit quantum registers. We assume high fidelity local unitary operations within each register, but the error probability for initialization, measurement, and entanglement generation can be very high (). We demonstrate that with a reasonable time overhead our scheme can achieve deterministic non-local coupling gates between arbitrary two registers with very high fidelity, limited only by the imperfections from the local unitary operation. We estimate the clock cycle and the effective error probability for implementation of quantum registers with ion-traps or nitrogen-vacancy (NV) centers. Our new scheme capitalizes on a new efficient two-level pumping scheme that in principle can create Bell pairs with arbitrarily high fidelity. We introduce a Markov chain model to study the stochastic process of entanglement pumping and map it to a deterministic process. Finally we discuss requirements for achieving fault-tolerant operation with our register-based hybrid scheme, and also present an alternative approach to fault-tolerant preparation of GHZ states.

###### pacs:

03.67.Lx, 03.65.Ud, 42.50.-p, 03.67.Pp## I Introduction

The key challenge in experimental quantum information science is to identify isolated quantum mechanical systems with good coherence properties that can be manipulated and coupled together in a scalable fashion. Recently, considerable advances have been made towards interfacing of individual qubits in the optical and microwave regimes. These include advances in cavity QED Mabuchi and Doherty (2002); Wallraff et al. (2004) as well as in probabilistic techniques for entangling remote qubits Simon and Irvine (2003); Duan et al. (2004); Lim et al. (2006). At the same time, substantial progress has been made towards the physical implementation of few-qubit quantum registers using systems of coupled trapped ions Barrett et al. (2004); Riebe et al. (2004); Reichle et al. (2006), neutral atoms Mandel et al. (2003), or solid-state qubits based on either electronic and nuclear spins in semiconductors Jelezko et al. (2004); Childress et al. (2006); Dutt et al. (2007) or superconducting islands Yamamoto et al. (2003); McDermott et al. (2005).

While the precise manipulation of large, multi-qubit systems still remains an outstanding challenge, various approaches for connecting such few qubit sub-systems into large scale circuits have been investigated Dür and Briegel (2003); Lim et al. (2006); Oi et al. (2006); Van Meter et al. (2006, 2007). These studies suggest that hybrid schemes, which benefits from short range interactions for local coupling and (optical) long range interactions for non-local coupling, might be an effective way toward large scale quantum computation: small local few-qubit quantum systems may be controlled with very high precession using optimal control techniques Leibfried et al. (2003); Vandersypen and Chuang (2004), and in practice it may be more feasible to operate several such small sub-systems compared to the daunting task of high-precession control of a single large quantum system with thousands of qubits. Optical techniques for quantum communication can then be used to connect any two sub-systems. For example, we may directly transfer a quantum state from one sub-system to another via an optical channel Cirac et al. (1997) (see Fig. 1a), which immediately provides an efficient way to scale-up the total number of the physical qubits we can manipulate coherently. In particular the use of optical means for connecting different subsystems has the advantage that it allows for fast non-local operations over large distances. This is advantageous for quantum error correction since the existence of such non-local coupling operations alleviates the threshold requirement for fault-tolerant quantum computation Svore et al. (2005).

In practice, however, it is very difficult to have a perfect optical connection. In particular, there is excitation loss associated with the optical channel, due to scattering or absorption. For a lossy channel, it is therefore more desirable to use it to generate entanglement between different sub-systems (see Fig. 1b), rather than for direct state transfer. The entanglement generation is then heralded by the click patterns from the photon detectors. Such detection-based scheme is intrinsically robust against excitation loss in the channel, since it only reduces the success probability but does not affect the entanglement fidelity. This entanglement can then be used as a resource to teleport quantum state from one sub-system to another Bouwmeester et al. (2000). More generally, entanglement provides a physical resource to implement non-local unitary coupling gates (such as CNOT gate) Gottesman and Chuang (1999); Sørensen and Mølmer (1998); Zhou et al. (2000); Eisert et al. (2000). If there is only one physical qubit for each sub-system, so-called cluster states Briegel and Raussendorf (2001) can be created based on probabilistic, heralded entanglement generation (see Ref. Lim et al. (2006) and references therein). Such cluster states can be used for universal quantum computation Raussendorf and Briegel (2001). If there are two physical qubits available for each sub-system, cluster states can be created deterministically Benjamin et al. (2006); meanwhile one can also use these two-qubit sub-systems to implement any quantum circuit directly Duan et al. (2004).

Furthermore, realistic optical channel connecting sub-systems has other imperfections beside excitation loss, such as the distortion of the polarization or shape of the wave-packet. These imperfections will reduce the fidelity of the heralded entanglement generated between the sub-systems. To overcome these imperfections in the channel, entanglement purification schemes have been proposed, which may create some high-fidelity Bell pairs from many low-fidelity ones Bennett et al. (1996); Deutsch et al. (1996). In particular, the entanglement pumping scheme originally presented in the context of quantum communication over long distances Briegel et al. (1998); Dür et al. (1999); Childress et al. (2005) provides a very efficient purification scheme in terms of local physical resources, and Dür and Briegel Dür and Briegel (2003) first proposed to use such entanglement pumping scheme for quantum computation. In principle, the infidelity of the purified Bell pair shared by the sub-systems can be very low, and is only limited by the error probability from local operations. In Ref. Dür and Briegel (2003) it was found that three auxiliary qubits (requiring a total of five qubits including the storage and communication qubits) for each sub-system provide enough physical resources to obtain high fidelity entangled pairs via entanglement pumping.

In order to implement the idea of distributed quantum computation using realistic optical channel and imperfect operations, it is necessary to consider the following questions: What are the minimal local physical resources needed for robust entanglement generation? What is the time overhead associated with entanglement generation? Can we extend the robustness to other imperfections, such as errors from initialization and measurement?

Motivated by these considerations, we study the practical implementation of robust quantum registers for scalable applications. In Ref. Jiang et al. (2007a) we have proposed an entanglement purification scheme that only requires two auxiliary qubits for robust entanglement generation. We have found that the time overhead associated with entanglement generation ranges from a factor of to a few , depending on the initial and targeting infidelities. We have also suggested to use one more auxiliary qubit to suppress errors from initialization and measurement. Thus, our hybrid scheme also requires only 5 (or fewer) qubits with local deterministic coupling, while providing additional improvements over the protocol of Ref. Dür and Briegel (2003): reduced measurement errors, higher fidelity, and more efficient entanglement purification. In this paper, we will provide a detailed discussion on the register-based, hybrid quantum computation scheme presented in Ref. Jiang et al. (2007a).

The paper is organized as follows. In Sec. II, we will introduce the concept of quantum register and discuss two experimental implementations. In Sec. III, we will review the idea of universal quantum computation based on two-qubit quantum registers. In Sec. IV, we will specify the error models for imperfections and provide the basic ideas underlying our robust operations. In Sec. V, we will describe the robust measurement/initialization scheme. In Sec. VI, we will present our bit-phase two-level entanglement pumping scheme. In Sec. VII, we will introduce the Markov chain model to quantitatively analyze the time overhead and residual infidelity associated with the stochastic process of entanglement pumping, and discuss further improvement upon our two-level entanglement pumping scheme. In Sec. VIII, we will map our stochastic, hybrid, and distributed quantum computation scheme to a deterministic computation model that is characterized by two quantities (the clock cycle and effective error probability), and estimate the practical values for these quantities. We will also consider the constraint set by the finite memory lifetime and determine the achievable performance of hybrid distributed quantum computation. Finally, in Sec. IX, we will discuss using our hybrid scheme for fault-tolerant quantum computation with quantum error correcting codes, and provide a resource-efficient approach for fault-tolerant preparation of the GHZ states.

## Ii Quantum Register and Experimental Implementations

We define a quantum register as a few-qubit device (see Fig. 2a) that contains one communication qubit (), with a photonic interface; one storage qubit (), with very good coherence times; and several auxiliary qubits (), used for purification and error correction. A critical requirement for a quantum register is high-fidelity unitary operations between the qubits within a register.

The quantum registers considered here can be implemented in several physical systems, but in this paper we shall focus on two specific systems where these considerations are particularly relevant. First, ion traps have been used to demonstrate all essential elements of quantum registers. (1) The ion qubits may play the role of communication qubits: they can be initialized and measured efficiently using optical pumping and cycling transitions respectively, and they can also be prepared in highly entangled states with the polarization of single photons Blinov et al. (2004); Rosenfeld et al. (2007). Very recently, entanglement generation between ion qubits from two remote traps has been demonstrated Maunz et al. (2007); Moehring et al. (2007). This experiment directly demonstrates the non-local connection required for our hybrid approach. Since the photon collection and detection efficiency is not perfect, the entanglement generation is a probabilistic process. However, the entanglement generation is also a heralded process, because different click patterns from the detectors can be used to identify each successful entanglement generation. As we will discuss Sec. III, such probabilistic, heralded entanglement generation process is already sufficient to implement deterministic non-local coupling gates. (2) The ion qubits can be good storage qubits as well. Coherence time of approximately seconds has been demonstrated in ion traps Langer et al. (2005); Haffner et al. (2005a), which is times longer than the typical gate operation time which is at the order of . Since fault-tolerant quantum computation only requires the coherence time to be approximately times longer than the gate time, the very long coherence of the ions provides new opportunities, such as performing non-local coupling gates with some extra time overhead. (3) Coherent manipulation of few ions in the same trap has been demonstrated Leibfried et al. (2005); Haffner et al. (2005b), allowing gates to be implemented among the qubits in the register. (4) High fidelity operations between the ion qubits within the ion trap has also been demonstrated Leibfried et al. (2003).

A second promising candidate for implementing quantum registers is the nitrogen vacancy (NV) centers in diamond. Each NV center can be regarded as an ion trap confined by the diamond crystal, which can be treated as a single register. The qubits for each NV register consists of one electronic spin associated with the defect and several nuclear spins associated with the proximal C-13 nuclei. The electronic spin is optically active, so that it can be measured and initialized optically. With optical cavities or diamond-based photonic crystal micro-cavities Tomljenovic-Hanic et al. (2006) one could enhance photon collection efficiency towards unity. Furthermore, the electron spin can be coherently manipulated by microwave pulses Jelezko et al. (2004). The electronic spin is thus suitable as the communication qubit. The nuclear spins are coupled to the electronic spin via hyperfine interactions. One can either use these hyperfine interaction to directly rotate the nuclear spins Hodges et al. (2007); Khaneja (2007), or apply radio-frequency pulses to address individual nuclear spins spectroscopically Cappellaro et al. (in preparation). These nuclear spins have very long coherence times approaching seconds Dutt et al. (2007), and can be good storage and auxiliary qubits. Furthermore, the optical manipulation of the electronic spin can be well decoupled from the nuclear spins Jiang et al. (2007b). It can be inferred from the recent experiment Dutt et al. (2007) that the fidelity of local operations between electronic and nuclear spins is higher than . While the fidelity is still low for the procedures considered here, we believe that it can be significantly improved (to higher than ) by optimal control techniques Vandersypen and Chuang (2004); Cappellaro et al. (in preparation), such as composite pulses Levitt (1986) and numerically optimized GRAPE pulses Khaneja et al. (2005).

## Iii Universal Quantum Computation with Two-Qubit Registers: Fundamentals

We now consider universal quantum computation via the simplest possible two-qubit registers Duan et al. (2004); Benjamin et al. (2006). Each register has one qubit for communication and the other qubit for storage. We can use probabilistic approaches from quantum communication (Childress et al. (2005) and references therein) to generate entanglement between communication qubits from two arbitrary non-local registers. The probabilistic entanglement generation creates a Bell pair conditioned on certain measurement outcomes, which are distinct from outcomes of unsuccessful entanglement generation. If the entanglement generation fails, it can be re-attempted until success, with an exponentially decreasing probability of continued failure.

When the communication qubits ( and ) are prepared in the Bell state, we can immediately perform the non-local CNOT gate on the storage qubits ( and ) using gate-teleportation between registers and . The gate-teleportation circuit in Fig. 3 implements (before the conditional Pauli operations) the following map

(1) |

where , is the controlled-NOT (CNOT) gate with the th qubit as control and the th qubit as target, and is the measurement result for qubit from the circuit in Fig. 3.

By consuming one Bell pair, one can implement any non-local controlled-U gate between two storage qubits Eisert et al. (2000), as shown in Fig. 4. Since operations on a single qubit can be performed within a register, the CNOT operation between different quantum registers is in principle sufficient for universal quantum computation Duan et al. (2004). Similar approaches are also known for deterministic generation of graph states Benjamin et al. (2006) —an essential resource for one-way quantum computation Raussendorf and Briegel (2001).

We emphasize that deterministic entanglement generation is not required, which opens up a wide range of possibilities of entanglement generation. It is experimentally challenging to achieve deterministic quantum state transfer directly Cirac et al. (1997), but we are able to achieve the same task by probabilistic entanglement scheme and two-qubit quantum registers Duan et al. (2004).

## Iv Errors and Imperfections

In practice, the qubit measurement, initialization, and entanglement generation can be noisy with error probabilities as high as , due to practical limitations such as imperfect cycling transitions, finite collection efficiency, and poor interferometric stability. As a result, there will be a large error probability in non-local gate circuits. In contrast, local unitary operations may fail infrequently () when quantum control techniques for small quantum system are utilized Vandersypen and Chuang (2004); Leibfried et al. (2003). We now show that the most important sources of imperfections, such as imperfect initialization and measurement errors for individual qubits in each quantum register, and entanglement generation errors between registers, can be corrected with a modest increase in register size. We determine that with just three additional auxiliary qubits and high-fidelity local unitary operations, all these errors can be efficiently suppressed by repeated quantum non-demolition (QND) measurement Braginsky et al. (1980) and entanglement purification Briegel et al. (1998); Dür et al. (1999). This provides an extension of Ref. Dür and Briegel (2003) that mostly focused on suppressing errors from entanglement generation.

We will use the following error model for the entire paper: (1) The imperfect local two-qubit operation is

(2) |

where is the partial trace over
the qubits and , and is the identity operator for
qubits and . This error model describes that with a probability
the gates perform the correct operation and with a probability
the gates produce a complete random output for the two involved qubits
^{20}^{20}20The error model introduced in
Eq. (2) can be regarded as the worst case error, since it
in principle includes all possible errors that can happen to the
system.. (2) The imperfect initialization of state will prepare a mixed state

(3) |

which has error probability , i.e., it prepares the wrong state with a probability . (3) The imperfect measurement of state will correspond to the projection operator

(4) |

This operator describes that a qubit prepared in state or will give rise to the opposite measurement output with the measurement error probability . (4) Finally, the entanglement fidelity for a non-ideal preparation of state is defined as

(5) |

and the infidelity is just . The fidelity does, however, not completely characterize the produced entangled state. Depending on the exact method used to generate the entangled state, one can in some situations argue that the error will predominantly be, e.g., only a phase error Duan and Kimble (2003); Simon and Irvine (2003); Barrett and Kok (2005), whereas in other situations it will be a combination of phase and bit flip errors (see Childress et al. (2005) and references therein). Below we shall therefore both consider the situation where we only have a dephasing error as well the situation, where we have a more complicated depolarizing error (exact definition given later). As we shall see, the knowledge that the error is of a particular type (e.g. only dephasing error) provides a significant advantage for purification.

We will also assume a separation of error probabilities: any internal, unitary operation within the register fails with extremely low probability, , while all operations connecting the communication qubit to the outside world (initialization, measurement, and entanglement generation) fail with error probabilities that can be several orders of magnitude higher.

(6) |

In terms of these quantities the error probability in the non-local CNOT gate in Fig. 3 is

(7) |

because we use one entangled state, two local operations, and two measurements. In the next two sections, we will show how to use robust operations to dramatically improve the fidelity for these non-local coupling gates.

Robust measurement can be implemented by repeated QND measurement, i.e., a majority vote among the measurement outcomes (Fig. 5), following a sequence of CNOT operations between the auxiliary/storage qubit and the communication qubit. This also allows robust initialization by measurement. High-fidelity, robust entanglement generation is achieved via entanglement pumping Briegel et al. (1998); Dür et al. (1999); Dür and Briegel (2003) (Figs. 6 and 7), in which lower fidelity entanglement between the communication qubits is used to purify entanglement between the auxiliary qubits, which can then be used for non-local CNOT operations. To make the most efficient use of physical qubits, we introduce a new entanglement pumping scheme. In our bit-phase two-level entanglement pumping scheme, we first use unpurified Bell pairs to repeatedly pump (purify) against bit-errors (Fig. 7a), and then use the bit-purified Bell pairs to repeatedly pump against phase-errors (Fig. 7b).

Entanglement pumping, like entanglement generation, is probabilistic; however, failures are detected. In computation, where each logical gate should be completed within the allocated time (clock cycle), failed entanglement pumping can lead to gate failure. To demonstrate the feasibility of our approach for quantum computation, we will analyze the time required for robust initialization, measurement and entanglement generation, and show that the failure probability for these procedures can be made sufficiently small with reasonable time overhead.

## V Robust Measurement & Initialization

In this section, we will analyze the robust measurement scheme based on repeated QND measurement, discuss the recent experimental demonstration of robust measurement in the ion-trap system, and present two approaches to robust initialization.

The measurement circuit shown in Fig. 5 yields the correct result based on a majority vote from consecutive readouts (bit-verification). Since the evolution of the system (CNOT gate) commutes with the measured observable ( operator) of the auxiliary/storage qubit, it is a quantum non-demolition (QND) measurement Braginsky et al. (1980), which can be repeated many times. The error probability for such a majority vote measurement scheme is:

(8) |

where the last term conservatively estimates the probability for bit-flip error of the auxiliary/storage qubit during the repeated QND measurement. For simplicity, we will use Eq. (8) for our conservative estimate of error probability for repeated QND measurement. Suppose , we can achieve by choosing for , or even by choosing for . For convenience of discussion, we shall add to the set of imperfection parameters: . The time for robust measurement is

(9) |

where , , and are times for initialization, local unitary gate, and measurement, respectively.

Measurements with very high fidelity ( as low as ) have recently been demonstrated in the ion-trap system Hume et al. (2007), using similar ideas as above. There are several possibilities to further improve the performance of the repeated QND measurement. (1) We may use maximum likelihood estimate (MLE) to replace the majority vote for repeated measurements with multi-value outcomes (e.g., fluorescent intensity) Hume et al. (2007). (2) We may keep updating the error probability using MLE after each measurement. Once the estimated error probability is below some fixed error rate, we stop the repetition of the QND measurement to avoid errors from redundant operations Hume et al. (2007). (3) We may use the implementation of CNOT gate that has small/vanishing bit-flip errors to the control qubit, which will reduce/eliminate the last term in Eq. (8).

The robust measurement scheme also allows to achieve robust initialization by measurement, i.e., by measuring the state of a qubit with the robust measurement scheme, we initialize the qubit into the result of the measurement outcome with an effective initialization error

(10) |

Besides the above measurement-based scheme, we may achieve robust
initialization using verification-based scheme ^{50}^{50}50The
verification-based scheme requires verifications for a good
initialization and suppresses the initialization error to , a smaller
error probability than that of the measurement-based scheme. However, the
verification-based scheme may fail at some intermediate step and require
reiteration of the verification from scratch, which is very similar to the
one-level entanglement pumping, described by the Markov chain model in Sec.
VII.. For clarity, we shall assume the measurement-based
initialization [Eq. (10)] for the rest of the paper.

## Vi Robust Non-Local Two-Qubit Gate

With high-fidelity local unitary gate and repeated QND measurement, the error probability for non-local coupling gates (e.g., Fig. 3 and 4) is

(11) |

which is dominated by the infidelity of the Bell pair , since we assume . In this section, we will show how to create high-fidelity Bell pairs between two registers with a reasonable time overhead. We will first briefly review entanglement pumping Briegel et al. (1998); Dür et al. (1999); Childress et al. (2005). Then we will quantitatively analyze the fidelity of the purified Bell pairs for our efficient two-level pumping scheme, and introduce the Markov chain model to calculate the failure probability for entanglement pumping within a given number of attempts. Next we will quantify the performance of the high-fidelity Bell pair generation in terms of the total error probability (or average infidelity) and the time overhead, and discuss the trade-off between these two criteria. Finally, we will mention a non-post-selective pumping scheme which may further reduce the time overhead.

### vi.1 Entanglement pumping

We now consider entanglement pumping Briegel et al. (1998); Dür et al. (1999); Childress et al. (2005) with high-fidelity local unitary gate and robust measurement. During the entanglement pumping process, we first store one unpurified Bell pair [Fig. 6 (a,b)], and then generate another unpurified Bell pair to purify the previously stored pair [Fig. 6 (c,d)]. If the purification is successful, we will obtain a purified Bell pair with higher fidelity, which can be further purified by repeating the process in Fig. 6 (c,d) with new unpurified Bell pairs; otherwise we discard the stored Bell pair, and start the entire pumping process from the beginning. Sometimes, we may want to introduce a second level of entanglement pumping; that is to use previously purified pairs to purify a stored Bell pair [Fig. 6 (e-h)].

### vi.2 Fidelity of entanglement pumping

We now analyze the performance of entanglement pumping for different errors of the unpurified Bell pairs. If the unpurified Bell pair is dominated by one type of error (e.g., dephasing error with density matrix in the Bell basis , defined as , ), we can skip the first level pumping. The unpurified pair then immediately becomes a level-1 pair and is purified with the circuit in Fig. 7b. In Fig. 8a we plot the fidelity curve (purified fidelity v.s. number of successful pumping steps) for the one-level pumping process (i.e. ), where a very high fidelity pair can be created after successful pumping steps. Note that we consider the full density matrix for all numerical calculation of entanglement fidelities Dür (1998), with the error models given in Eqs. (2,3,4).

If the unpurified Bell pair contains errors from both bit-flip and dephasing processes (e.g., depolarizing error with density matrix in the Bell basis), two-level entanglement pumping is needed. We introduce the following bit-phase two-level pumping scheme —the first level has steps of bit-error pumping using raw Bell pairs (Fig. 7a) to produce a bit-error-purified entangled pair, and the second level uses these bit-error-purified pairs for steps of phase-error pumping (Fig. 7b). In Fig. 8b we plot the fidelity curves for the first level (thin blue curve) and the second level (thick red curve) of entanglement pumping. One-level pumping is insufficient to achieve high fidelity, but two-level pumping can achieve very high fidelity. With the parameters specified for Fig. 8b, the maximum fidelity is achieved via the optimal choice of control parameters for successful pumping steps of the first and second levels, respectively.

For successful purification, the infidelity of the purified pair, , depends on both the control parameters and the imperfection parameters . For depolarizing error, we find

(12) | |||

to leading order in and , for . The dependence on the initial infidelity is exponentially suppressed at a cost of a linear increase of error from local operations and robust measurement . Measurement-related errors are suppressed by the prefactor , since measurement error does not cause infidelity unless combined with other errors. In the limit of ideal operations (), the infidelity can be arbitrarily close to zero, which is rigorously proved in Appendix A. On the other hand, if we use the standard entanglement pumping scheme Briegel et al. (1998); Dür et al. (1999) (that alternates purification of bit and phase errors within each pumping level), the reduced infidelity from two-level pumping is always larger than . Therefore, for very small and , the new pumping scheme is crucial to minimize the number of qubits per register.

In Fig. 9, we show the contours of the infidelity as a function of and , where the contours are labeled by values of . The parameters for the contour plots are (left) and (right); (up) and (down). For optimal choice of , the minimal infidelity is limited by and .

For dephasing error, one level pumping is sufficient (i.e. no bit-error purification, ). The infidelity is approximately

(13) |

by expanding to the leading order in and .

## Vii Markov Chain Model

The overall success probability can be defined as the joint probability that all successive steps succeed. We use the model of finite-state Markov chain Meyn and Tweedie (1993) to directly calculate the failure probability of -two-level entanglement pumping using raw Bell pairs, denoted as .

### vii.1 Markov chain model for entanglement pumping

We first use the Markov chain model to study the -step one-level entanglement pumping. As shown in Fig. 10, we use ”” to denote the initial state with no Bell pairs, ”” for the state with one stored unpurified pair, for the state with one purified pair surviving steps of pumping, and ”” for the final state with the purified pair surviving steps of pumping. Altogether there are states. The (success) transition probability from state to state is , while the (failure) transition probability from state to state is , for . Here [corresponding to deterministic state transfer as shown in Fig. 6 (a,b)] and can be calculated with the density matrix of the purified Bell pair surviving steps of pumping Dür et al. (1999). The final state is self-trapped, and goes back to itself with unit probability, representing that once we have reached the desired final fidelity we no longer make any purification attempts and the system remains in this state with unit probability. Each transition attempt consumes one unpurified Bell pair. We would like to know the probability of reaching the final state ”” after attempts. More generally, we might also want to know the probability distribution over all states.

We use a (column) vector with elements to characterize the probability distribution among all states. From the -th attempt to the -th attempt, the probability vector evolves from to according to the rule

(14) |

with the transition matrix

(15) |

Since the initial probability vector is , we can calculate the probability vector after attempts

(16) |

The probability vector describes the entire probability distribution over all states of the Markov chain. The last element of is the success probability of reaching the final state ”” after attempts; the failure probability after attempts is thus

(17) |

For two-level entanglement pumping, the state transition diagram is shown in Fig. 11. and are the number of pumping steps used to purify bit-errors and phase-errors, respectively. As detailed in Appendix B, we may use a (column) vector with elements to characterize the probability distribution among all states. From the -th attempt to the -th attempt, the probability vector evolves from to according to the same rule as above [Eq. (14)], but with the transition matrix given in Eq. (81).

Similar to one-level pumping, we can calculate the probability vector after attempts using Eq. (16). The probability vector describes the entire probability distribution over all states of the Markov chain. The last element of is the success probability of reaching the final state ”” after attempts; the failure probability after attempts is then

(18) |

In Fig. 12, we plot the failure probability v.s. , for control parameters and . For sufficiently large, the failure probability decreases exponentially to zero. For any given parameters, we can efficiently suppress the failure probability with some reasonably large .

### vii.2 Total error probability & average infidelity

We now introduce the total error probability (TEP) approximated by the sum of the failure probability and the infidelity of the purified Bell pair

(19) |

This is a very conservative estimate, since sometimes we do create some partially purified Bell pair though not the targeted purified Bell pair. And here we just say that the state has fidelity zero in these cases.

To consider the possibility of using a partially purified Bell pair for output, we may introduce another useful quantity —the average infidelity (AIF) —for the output Bell pair from the robust entanglement generation, where we take into account these partially purified pairs. The average infidelity of the output pair is the weighted average of the infidelity of the Markov chain

(20) | |||

Here the first term sums over all states of the Markov chain (except for the initial one), each of which has at least one partially purified pair with infidelity and probability ; the last term comes from the situation that none of the partially purified Bell pairs remain after the last attempt of the entanglement purification and we just use a classically correlated pair with infidelity . Generally, the average infidelity is smaller than the total error probability.

We may also optimize the choice of the control parameters

(21) |

and

(22) |

In Fig. 13, we plot both the optimized total error probability and the optimized average infidelity as a function of . Both quantities asymptotically approaches the same minimum value

(23) |

Here the minimum value is simply the minimal infidelity of the entanglement purification

(24) |

which is achieved by the control parameters , for the imperfection parameters .

We remark that a faster and less resource intensive approach may be used if the unpurified Bell pair is dominated by dephasing error. Then, one-level pumping is sufficient (i.e. no bit-error purification, ). The optimized total error probability and average infidelity (thin blue curves) for this situation are plotted as a function of in Fig. 13.

### vii.3 Total time for robust entanglement generation

The total time for robust entanglement generation is proportional to the average number of raw Bell pairs generated

(25) |

where is the average generation time of the unpurified Bell pair. Note that the entanglement generation itself is a stochastic process. In principle, we may also include the stochastic nature of the entanglement generation by introducing a sub-level of Markov chain to characterize the stochastic entanglement generation. Since each entanglement generation either succeeds or fails, the sub-level Markov chain only involves two states, which can be easily incorporated into the Markov chain models discussed above. After incorporating the sub-level into the Markov chain, each transition corresponds to one attempt of entanglement generation, instead of one attempt of entanglement purification that consumes one unpurified Bell pair previously.

Nevertheless, the number of Bell pairs generated in a given period of time (i.e. ) has a distribution. Since the relative deviation of this distribution () is fairly small for large (), this only has a minor influence. Thus we replace by .

### vii.4 Trade-off between gate quality and time overhead

We now consider the balance between the ”quality” of the robustly generated entangled pairs and the time overhead associated with the robust generation process. We may use either the optimized total error probability or the optimized average infidelity to characterize the quality. Since both quantities approaches the same asymptotic minimum according to Eq. (23), there is only little improvement in the quality of the robust entanglement generation once or is comparable to (say ). Thus, we find the value for by imposing the relations

(26) |

or

(27) |

First, we consider the total error probability . The relation in Eq. (26) can be simplified, if we assume fixed control parameters for the left hand side (rather than minimizing over all possible choices of ). Combined with Eq. (19), the failure probability should be comparable to the minimal infidelity

(28) |

Since both the variable and the parameters depend on , the above relation implicitly determines as a function a function of .

In Fig. 14, we plot the contours of [Eq. (26)] and [Eq. (28)] with respect to the imperfection parameters and , while assuming . Actually the choice of and () has negligible effect on the contours, since they only modify marginally. For initial fidelity , the contours of are very close to vertical lines; that is is mostly limited by with an overhead factor (about ) very insensitive to . The contours of indicate that the entanglement pumping needs about tens or hundreds of raw Bell pairs to ensure a very high success probability.

Similarly, we may also numerically obtain the value from Eq. (27). The contour plot of with respect to the imperfection parameters and is also shown in Fig. 14 (c,f). We compare s obtained from two estimates (total error probability [Eq. (26)] and average infidelity [Eq. (27)]). As we expected, the obtained from total error probability is approximately time larger than the obtained from average infidelity, since the former is a more conservative estimate and requires more unpurified Bell pairs. Nevertheless, the difference is small and can be easily accounted by a prefactor of order unity. For clarity, in the rest of the paper we will use the estimated by using total error probability, and sometimes quote the values estimated by using average infidelity.

### vii.5 Entanglement pumping with non-post-selective (NPS) scheme

We now consider another entanglement pumping protocol, proposed by Campbell Campbell (2007). The entanglement pumping scheme we have considered so far is post-selective (PS); that is we discard the Bell pair if one step of entanglement pumping is not successful. However, the Bell pair may still be highly entangled even if the entanglement pumping failed at some intermediate step. The non-post-selective (NPS) entanglement pumping scheme Campbell (2007) keeps track of the evolution of the density matrix of the Bell pair after each step of pumping. The NPS scheme avoids the inefficient restart (i.e., discarding intermediately purified Bell pairs), and it may reduce the time overhead, especially when the unpurified Bell pairs have relatively low fidelity (). In Ref. Campbell (2007), the NPS pumping is discussed in the context of generating a graph state.

We now describe how to use the NPS pumping scheme to generate purified Bell pairs. To simplify the discussion, we first assume that the errors from local measurements and operations are negligible. This assumption enables us to establish a connection between the Markov chain model and the NPS pumping scheme.

Suppose the unpurified Bell pairs have only phase errors, then one level of entanglement pumping is sufficient. For this error model, one can show that a failed attempt produces an EPR pair with a density matrix identical to the one in the previous step Campbell (2007). One may introduce an accumulated score associated with entanglement pumping. The score increases by one unit for each attempt of successful pumping, and decrease by one unit for an attempt of unsuccessful pumping. The score for no Bell pair is , and for one unpurified Bell pair it is . The score exactly corresponds to the state label of the Markov chain (see Fig. 15). After each attempt of pumping, the score changes by . If the score drops to (i.e. no Bell pair left), it gets back to in the next attempt (i.e., creating a new unpurified Bell pair). The pumping procedure continues, until the score reaches (i.e., the final state ”” in the Markov chain). The key different from the previous Markov chain for post-selective pumping scheme (see Fig. 10) is that here the score decrease by for unsuccessful pumping rather than restart from . This modification increases the success probability of the robust entanglement generation.

When the unpurified Bell pairs have both bit-flip and phase errors (e.g., depolarizing error), we may use the bit-phase two-level pumping scheme (see Sec. VI.2), which purifies the bit error at the first level and then the phase error at the second level. Since the phase error is not purified at the first level, it accumulates after each attempt of pumping. Therefore, it is better to use PS entanglement pumping scheme at the first level to have minimal accumulation of phase errors. At the second level, the NPS scheme works more efficiently than the PS scheme. The Markov chain circuit for such mixed PS-NPS pumping schemes is shown in Fig. 16.

In practice, the error probability for the local operations is always finite. Then our simple Markov chain model only provides an approximate description for the real process. The approximation comes from the fact that the score is now insufficient to specify the density matrix for intermediate Bell pairs, in the presence of local operational errors. In order to obtain the density matrix for the intermediate state, we need to have the entire list of all previous pumping outcomes. Nevertheless, when the local operational errors are small compared to the infidelity of the intermediate Bell pairs, the Markov chain model still provides an (optimistic) estimate for the total error probability and the average fidelity.

## Viii Mapping to Deterministic Model

In this section, we will map our stochastic, hybrid, and distributed quantum computation scheme to a deterministic computation model, which is characterized by two parameters — the clock cycle and the effective error probability. We will show that even when the underlying operations such as the entanglement generation are non-deterministic, our approach still maintains reasonable fast clock cycle time and sufficiently low effective error probability. We will associate our discussion with achievable experimental parameters, consider the constraint set by the finite memory lifetime, and determine the achievable performance of hybrid distributed quantum computation.

### viii.1 Time and error in the theoretical model

All the previous discussions can be summarized in terms of the clock cycle time

(29) |

and the effective error probability

(30) |

for a general coupling gate between two registers.

We now provide an estimate of the clock cycle time based on realistic parameters. The time for optical initialization/measurement is

(31) |

with a photon collection/detection efficiency , vacuum radiative lifetime , and the cooperativity (Purcell) factor for cavity-enhanced radiative decay Michler et al. (2000); Purcell (1946). Eq. (31) is obtained from the estimate for the measurement error probability with . We assume that the entanglement is generated based on detection of two photons Duan and Kimble (2003); Simon and Irvine (2003), which takes time

(32) |

Generally entanglement fidelity is higher for the two-photon schemes than one-photon schemes Childress et al. (2005). In addition, some two-photon schemes have intrinsic purification against bit-flip errors Barrett and Kok (2005). The time for robust measurement is given in Eq. (9), and the total time for robust entanglement generation is given in Eq. (25).

Combining Eqs. (29), (31), (32), (9) and (25), we obtain the clock cycle time (in units of the local operation time) as a function of other parameters

(33) |

Meanwhile, we may obtain the relation by minimizing with Eq. (8), and find the relation using Eqs. (24 and 26). Therefore, we have

(34) |

The dimensionless parameter is the ratio between the times of emitting a single photon and performing a local unitary operation. For systems such as ion-traps and NV centers, this ratio is usually much less than unity ().

Similarly, we can obtain the effective error probability in terms of imperfection parameters

(35) |

In Fig. 18, we plot the clock cycle time and effective error probability , for two-level pumping against depolarizing error. Assuming , we consider the two choices of parameters (left) and (right). For each case, we plot the contours of the normalized clock cycle time as a function of and , and the effective error probability as a function of . The clock cycle time can be reduced by having a fast radiative decay rate , which can be facilitated by having a large cooperativity factor . The reduction of the clock cycle time stops once this ratio is below certain value, approximately (left) and (right), where local gate operation becomes the dominant time consuming step. Similarly, we plot the clock cycle time and effective error probability , for one-level pumping against dephasing error in Fig. 19.

In the limit of negligible radiative decay time, we obtain the lower bound for the normalized clock cycle time

(36) |

where for there is a time overhead associated with local operation and robust measurement; while there is no such overhead for .

### viii.2 Estimated numbers for experimental setups

Suppose the parameters are
Garcia-Ripoll et al. (2003); Steinmetz et al. (2006); Keller et al. (2004) and for our quantum registers (based on ion-traps or NV
centers). For depolarizing errors, two-level pumping can achieve . For some entanglement generation schemes
Duan and Kimble (2003); Simon and Irvine (2003); Barrett and Kok (2005) in principle only dephasing error exists,
because they have intrinsic purification against bit-flip errors. If all
bit-flip errors are suppressed, then one-level pumping is sufficient and
^{100}^{100}100For depolarizing or dephasing errors,
the estimated is approximately times less by using the average
infidelity..
In Table 1, we have listed
for parameters or , and , ,
, or . As expected, we find that gets longer, if the
fidelity is lower and/or the error probability ( or ) is
higher; significantly reduces if the error for the unpurified Bell
pairs changes from depolarizing error to dephasing error.

Depolarizing | Dephasing | |||||||
---|---|---|---|---|---|---|---|---|

(s) | (s) | (s) | (s) | |||||

65 | 19 | 20 | 8 | |||||

200 | 49 | 42 | 17 | |||||

387 | 65 | 80 | 22 | |||||

997 | 162 | 140 | 39 |

We remark that should be much shorter than the memory time of the storage qubit, . Because the memory error probability for each clock cycle is approximately , which should be small (say ) in order to achieve fault-tolerant quantum computation. This is indeed the case for both trapped ions (where s has been demonstrated Langer et al. (2005); Haffner et al. (2005a)), as well as for proximal nuclear spins of NV centers (where approaching a second can be inferred Dutt et al. (2007)). So far, we have justified the feasibility of the hybrid distributed quantum computation scheme. In the next subsection, we will provide a criterion for hybrid distributed quantum computation.

### viii.3 Constraints from finite memory life time

Above we have mostly ignored the effect of finite memory time, and with the various sequences of purification of imperfections the final fidelity of the operations have then been limited only be the local operation. All of these purifications, however, increase the time of the operations and eventually the system may become limited by the finite life time of the memory. In this subsection we shall evaluate this constraint set by the finite memory lifetime.

To simplify the discussion we assume that we have a very short radiative lifetime or that we are able to achieve a very large Purcell factor so that becomes negligible. All the time scales are then proportional to the local gate time . With a finite memory time, i.e., some fixed , there is a limit to have many operations we can do before we are limited by the memory error. To get an estimate for this limit we assume that the ideal number of operations is roughly given by the point, where the memory error probability is the same as the effective error probability for the non-local coupling gate:

(37) |

Then according to Eq. (36), we have

(38) |

where the variables are all determined by the imperfection parameters . We further reduce the imperfection parameters by assuming , and get the contour plot of in terms of the imperfection parameter and in Fig. 20. In the plot, we consider both the situation of depolarizing or dephasing error during entanglement generation.

For given , we may use Fig. 20 to find the valid region in the parameter space of and , and then identify the achievable effective error probability . For example, with ion-trap systems it may be possible to achieve Garcia-Ripoll et al. (2003); Langer et al. (2005); Haffner et al. (2005a), and the region left of the shaded contour line () can then be accessed, which enables us to obtain a wide range effective error probability depending on the practical values of and . For NV centers, it should be feasible to achieve by having s and s Dutt et al. (2007); the region on the left side of the shaded contour line () still covers a large portion of the parameter space. For a given experiment situation with a finite memory time as well as other imperfections, we can thus use Fig. 20 to determine the achievable performance of hybrid distributed quantum computation.

## Ix Approaches to Fault Tolerance

The entanglement based approach discussed in this paper provides a method to make gates between any quantum registers and this can be used to implement arbitrary quantum circuits, once the errors in the gates are sufficiently small. The errors can be further suppressed by using quantum error correction. For example, as shown in Table 1, can achieve , well below the threshold for fault tolerant computation based on approaches such as the code Knill (2005) or 2D toric codes Raussendorf and Harrington (2007); can achieve , which allows efficient codes such as the BCH [[127,43,13]] code to be used without concatenation.

Following Ref. Steane (2003) we estimate registers per logical qubit to be necessary for a calculation involving logical qubits and logical operations, assuming the memory failure rate and effective error probability are (e.g., achieved by s, s). (This estimate is based on Fig. 10b of Ref. Steane (2003).) Assuming that error correction is applied after each logical operation, and that logical operation and following recovery take approximately clock cycles depending on the type of operation and the coding scheme (see section II.A of Ref. Steane (2003)), the total running time of this computation would then be approximately s.

We remark that one important property of distributed quantum computation is that the measurement time is relatively fast compared with the non-local coupling gate, because the measurement does not rely on the time-consuming processes of entanglement generation and purification while the non-local coupling gate does. This property is different from the conventional model of quantum computation, where the measurement is usually a slow process that induces extra overhead in both time and physical resources Steane (2003). Thus, instead of reconciling slow measurements DiVincenzo and Aliferis (2007), it might also be interesting to study possible improvement using fast measurements for fault-tolerant quantum computation.

The above estimates have been performed assuming that our hybrid register based approach is mapped directly to the standard circuit model. In some situations this may, however, not be the most advantageous way to proceed, since the register architecture may allow for more efficient performance of certain tasks. As a particular example, we now briefly discuss an alternative new approach to fault-tolerant preparation of GHZ states (e.g., ), which are a critical component both for syndrome extraction and construction of universal gates in quantum error correcting codes Nielsen and Chuang (2000); Knill (2005). This new approach relies upon the observation that the EPR pairs from entanglement generation can be used for deterministic partial Bell measurement (PBM), which is achieved by applying local coupling gates and projective measurements as shown in Fig. 21c. After the PBM, the two storage qubits are projected to the subspace spanned by the Bell states if the measurement outcomes are the same, or they are projected to the subspace spanned by the Bell states if the measurement outcomes are different. For the latter case, we may further flip one of the storage qubits, so that they are projected to the subspace spanned by . By using PBMs, we can perform fault-tolerant preparation of GHZ state efficiently (up to single qubit rotations) as detailed below.

Fault-tolerant state preparation requires that the probability to have errors in more than one qubit in the prepared state is , with the error probability for each input qubit or quantum gate being ; that is multiple errors only occur at the second or higher orders. The regular circuit to prepare a four-qubit GHZ state fault-tolerantly Knill (2005) is shown in Fig. 21a. If this circuit should be implemented with quantum registers, the CNOT gates in Fig. 21a should be created by using the circuit detailed in Fig. 3, and eight quantum registers would be required.

By using PBMs, however, only four quantum registers are needed in order to generate GHZ states fault-tolerantly as shown in Fig. 21b. The fault-tolerance comes from the last (redundant) PBM between the second and fourth register (Fig. 21b), which detects bit-errors from earlier PBMs. The advantage of the PBMs is that it propagates neither bit- nor phase-errors. The circuit of Fig. 21c indicates that the only way to propagate error from one input to another (say, to ) is via some initial error in the entangled pair between