# A distributed architecture for scalable quantum computation with realistically noisy devices

## Abstract

Tremendous efforts have been paid for realization of fault-tolerant quantum computation so far. However, preexisting fault-tolerant schemes assume that a lot of qubits live together in a single quantum system, which is incompatible with actual situations of experiment. Here we propose a novel architecture for practically scalable quantum computation, where quantum computation is distributed over small-size (four-qubit) local systems, which are connected by quantum channels. We show that the proposed architecture works even with the error probability 0.1% of local operations, which breaks through the consensus by one order of magnitude. Furthermore, the fidelity of quantum channels can be very low 0.7, which substantially relaxes the difficulty of scaling-up the architecture. All key elements and their accuracy required for the present architecture are within reach of current technology. The present architecture allows us to achieve efficient scaling of quantum computer, as has been achieved in today’s classical computer.

###### pacs:

## I Introduction

Scalability and fault-tolerance are essential ingredients in both classical and quantum computation. In 1945, von Neumann proposed the first architecture design of a classical computer [1], and most of today’s classical computers are of von Neumann type. He also explored fault-tolerance in classical computation by developing a systematic way to construct reliable logic circuits from noisy devices [2], which is now attracting renewed interest in the field of nanocomputer [3].

In quantum computation, on the other hand, it is still under extensive investigation what type of physical system is best suited to an experimental realization of quantum computation and what level of accuracy is required for it. For a better understanding of them, a lot of efforts have been made over the past decade both theoretically and experimentally. Quantum fault-tolerance theory ensures scalable quantum computation with noisy quantum devices as long as the error probability of such devices is smaller than a threshold value (see Ref. [4] and references therein). The noise thresholds have been calculated to be about – for several fault-tolerant schemes under various assumptions [5, 6, 7]. In the experiments, it is nowadays possible to control a few to dozen qubits in a wide variety of physical systems such as trapped ions [8] and nitrogen-vacancy (NV) centres in diamond [9] etc. (see Ref. [10] and references therein). There is, however, still a large gap between these top-down (theoretical) and bottom-up (experimental) approaches. For example, the existing fault-tolerant schemes [5, 6, 7] require many qubits live together in a single system and assume that the whole system can be controlled with the same accuracy regardless of its size. In experiment, on the other hand, the number of qubits in a single system is rather limited; if we increase the number of qubits in a single system, the control becomes more and more complex, which makes it hard to achieve the same accuracy. In fact, as mentioned in Ref. [11] there is a consensus that “for practical scalability the probability of error introduced by the application of a quantum gate must be less than 0.0001”. In order to fill the gap and break through the consensus, we have to develop a fundamental design of a scalable and fault-tolerant architecture for quantum computation as von Neumann did in the early years of classical computer technology.

Several architectures for scalable quantum computation have been proposed so far in bottom-up approaches by considering specific physical implementations such as photons [12] and semiconductor nanophotonics [13]. It is, however, still not fully understood what kind of elements and what level of accuracies of them are essentially required to construct a scalable and fault-tolerant architecture. Furthermore, the requirements of the existing quantum architectures are too demanding and complicated to be experimentally feasible. In this paper, we propose a fundamental and simple design of a scalable and fault-tolerant architecture for quantum computation taking a top-down approach, and clarify under what condition scalable quantum computation can be executed fault-tolerantly.

To ensure scalability, we adopt a distributed approach to quantum computation [14], where small quantum systems, say quantum arithmetic logic units (QALUs), are connected via quantum channels. This type of architectures are equipped with built-in modular scalability. That is, the size of the architecture scales up by adding well-established individual units. In the previous one-dimensional (1D) distributed architecture [15, 16], however, entangled states have to be shared between QALUs of arbitrary distance, and therefore the quantum repeater protocol [17] is utilised. As the distance gets larger, this procedure takes more time. Moreover, every QALU in-between must provide a workspace for this procedure, resulting in an overhead which grows with the distance. Besides, if there is a single point of breakdown in the quantum channels possibly due to a manufacturing error, one cannot generate any entanglement between two parts separated by this point.

The present architecture, on the other hand, consists of a two-dimensional (2D) array of QALUs, each of which consists of four qubits, as depicted in Fig. 1. Furthermore, entangled states are shared only between the nearest-neighbour QALUs, which allows highly parallel operations. Surprisingly, this simple architecture is found to be sufficient for fault-tolerant quantum computation and works with very noisy quantum channels of fidelity and reasonably accurate local operations of the error probability , which breaks through the consensus by one order of magnitude [11]. These results are achieved by utilizing twofold error management techniques: entanglement purification [18, 19, 20] and topological quantum computation (TQC) [6]. The former is employed to implement a reliable two-qubit gate by using very noisy quantum channels with the help of quantum gate teleportation [21]. In particular, we apply high-performance entanglement purification, so-called double selection scheme [20], which is essential for achieving the above result. TQC is used to handle the remaining errors and to archive quantum gate operations of arbitrary accuracy, which is required for large-scale quantum computation. Furthermore, the nearest-neighbour quantum communications together with TQC is quite robust against the manufacturing error mentioned above, since we can reconstruct a reliable logical information on the surface code by avoiding such defects [13, 22].

All key ingredients in the present architecture, (i) a four-qubit system, (ii) gate operations in the four-qubit system, and (iii) entangling operations between the separate systems, have already been demonstrated experimentally in various physical systems. Actually, the benchmarks in trapped ion systems are comparable to the requirements of the proposed architecture. These results push the realization of large-scale quantum computation within reach of current technology. We believe that this work providing a fundamental and simple design of a scalable and fault-tolerant architecture for quantum computation fills the gap between the top-down and bottom-up approaches, and gives a good guideline and benchmark in development of devices for quantum computer.

## Ii 2D distributed architecture

The present architecture consists of a 2D array of well-defined small (four-qubit) local quantum systems, QALUs (see Fig. 1), where we can implement the initializations, measurements, and two-qubit gate operations. These local operations are assumed to be imperfect, which is modeled as follows: (i) An ideal two-qubit gate is followed by two-qubit depolarizing noise, where (), and () are the Pauli matrices (). (ii) The measurement of a physical qubit is implemented with an error probability . The QALUs are assumed to work with reasonably high accuracy (). The memory error probability is assumed to be sufficiently smaller than that of the operational errors (as is also the case for most of physical systems) and ignored for clarity (otherwise, since the number of waiting steps is finite in the present 2D architecture, we can take the memory errors into account by replacing the error probability of the two-qubit gates with , where indicates the memory error probability per step). Such QALUs are connected via quantum channels of fidelity . Here the channel fidelity means that we can share a maximally entangled state (MES) of fidelity between the nearest-neighbour QALUs. The remote entangling operations can be used for this purpose [23]. The quantum channels are assumed to be relatively noisy (–), which relaxes the complexity in scaling up the size of the architecture.

## Iii Entanglement pumping and teleportation-based two-qubit gate

The noise introduced by the quantum channel degrades the accuracy of the gate operation between the separate systems. In classical computation, this kind of obstacles can be overcome by using the multiplexing technique [2, 3], where multiple copies of data with majority voting are used to ensure the reliability of logic circuits. In the case of quantum physics, however, we cannot make copies of an unknown quantum state due to the no-cloning theorem [24]. Instead, we can use entanglement purification [18, 19] and quantum teleportation [21] in order to improve the fidelity of the gate operations between two QALUs. In particular, a novel method is devised to realise gate operations of high accuracy, where an intelligent use of the four-qubit local system allows us to obtain MES of high fidelity even with very noisy quantum channels, as shown below.

The noisy copies of the MES (we call it “noisy MES” hereafter), which are shared by using the noisy quantum channels, are purified by using the entanglement pumping scheme [15, 25] as follows [see Fig. 2 (c)]: (i) A noisy MES (we call it the target pair) is purified by reducing its bit-flip () error via level-1 entanglement pumping with double selection [20], where two noisy MESs are used as the ancillae. The phase-flip () error in the target pair increases in this process. (ii) Another noisy MES is purified by using level-1 entanglement pumping with single selection [18, 19], where one noisy MES is used as the ancilla. Here the target pair is untouched. (iii) The target pair is purified by reducing its error via level-2 entanglement pumping with double selection, where the successful output state of (ii) and one noisy MES are used as the ancillae. Here the increase in the error is kept small thanks to the level-1 pumping in step (ii). At each step, we repeat the pumping process from a few to several times. Then, we finally obtain the level-2 double-pumped MES of high fidelity.

The noisy MES , which is shared by the noisy quantum channel, is described as

(1) |

where . The purification processes with single and double selections in the above pumping scheme can be described as maps and , respectively. Here, and are the output and the th input fidelities, respectively, and and are the normalization factors (i.e. ) meaning the success probabilities of the purification processes. Starting from the channel fidelity , the fidelity of the level-2 double-pumped MES is calculated by using the tensors and , which can be written in terms of and (see Appendix A). The contour plots of the output infidelities with respect to the channel fidelity and the error probability of the local operations are shown in Fig. 3 (a), where , and are adopted specifically. Compared to the single pumping [25, 16], the output fidelity is significantly improved in the present scheme with double selection, without increasing the number of spatial resources.

By using the purified MES of high fidelity, we perform the teleportation-based two-qubit gate (TTG) between the data qubits stored in the nearest-neighbour QALUs. Including the memory space for the data qubit, a total of four qubits (i.e. three auxiliary qubits for the entanglement pumping and one data qubit) are required in each QALU. (The four-qubit system seems to be the minimum for our purpose, since we cannot purify both bit- and phase-flip noise by using only two auxiliary qubits.) The probabilities of the errors after the TTG can be calculated in terms of , (), and . Roughly speaking, the gate infidelity is given by , which can be understood from the fact that the TTG is implemented with one purified MES, two local two-qubit gates and measurements [21] (see Appendix B for details).

## Iv Topological fault-tolerant quantum computation

As shown above, we can perform two-qubit gates of high accuracy between the nearest-neighbour two QALUs in the teleportation-based way, but they are still subject to small error. In order to handle this and achieve gate operations of arbitrary accuracy, we perform fault-tolerant TQC [6], where the surface code protects quantum information by virtue of the topological degeneracy [26]. The logical CNOT gate operations in TQC are implemented by braiding anyons (defects) on the surface. Universal fault-tolerant quantum computation can be achieved by using the state injection and the magic state distillation [6, 27]. Actually, these operations for fault-tolerant universal quantum computation can be executed by using only 2D nearest-neighbour two-qubit gates and single-qubit measurements [6], and therefore TQC is best suited for the present distributed architecture.

The noise threshold of TQC is determined from the error correction procedures, which are implemented repeatedly in the bulk region of the surface code [6]. The syndrome measurement for the topological error correction can be executed as shown in Fig. 4 (a) and (b), where the QALUs of gray and blue (red) squares indicate the data and () syndrome QALUs, respectively. After performing the TTGs, the blue qubits are measured in the basis, whose outcome corresponds to the eigenvalue of the stabilizer operator and is used to correct errors [see Fig. 4 (b)]. The errors are transformed to errors by the Hadamard operations, which is incorporated into the TTGs, and corrected in the same way at the next step by using the syndrome qubits (red boxes).

The errors during the error correction can be characterised by the independent and correlated errors on the three-dimensional (i.e. space-like 2D and time-like 1D) lattice [6]. In Ref. [6], the threshold values of the independent and correlated error probabilities and , respectively, have been numerically estimated as , which are attributed to the preparation, gate, measurement errors with equal probability . In our case, these probabilities and are calculated in terms of , and as (see Appendix C for the details)

(2) | |||||

(3) |

Thus if they satisfy and , fault-tolerance of the present architecture is ensured (the true threshold will be slightly higher than the value calculated from the above condition, which can be determined by a full numerical simulation). By using these conditions and the output fidelity obtained in the previous section, we calculate the fault-tolerant region of the channel fidelity and the error probability of local operations, where is taken for simplicity. The threshold curve for these physical parameters is plotted in Fig. 3 (b). Specifically, with , the threshold value of local operations is obtained as ( when is adopted [5, 7]). It is also seen that the present architecture works even with very noisy quantum channels of fidelity provided the error probability of the local operations are reasonably small . This result contrasts with the requirements, and , in the 1D architecture with five-qubit distributed systems [16].

The computational overhead required in the present architecture can be quantified by the total amount of local operations plus quantum communication (i.e. the number of noisy MESs). The overhead is given by , where indicates the number of two-qubit gates in TQC, and is the total amount of local operations plus quantum communication (i.e. the number of initial MESs) per TTG. Specifically, the overhead is a few tens (a few hundreds) when (0.7) and , which mainly depends on the channel fidelity . In order to factorise an -bit composite number, we need Toffoli gates [13], each of which is implemented by using seven gates. Thus a total of gates are required to factorise a -bit composite number. This means that each gate has to work with an error probability of . When , such a gate requires physical two-qubit gates under the physical error probability at 1/3 of the topological threshold, and therefore a total of two-qubit gates are required in TQC. On the other hand, is required to achieve 1/3 of the topological threshold with and (see Appendix D). As a result, the total overhead for the present architecture amounts to be .

Although the above quantum overhead is large, comparable complexity is achieved in today’s classical computer within sec (a few tens of hours), where transistors integrated in a central processing unit (CPU) work at rates of Hz [28] (i.e. ). It contrasts with the fact that the recent factorization of a general 768-bit composite number has taken an overhead equivalent to 1677 years with a CPU of 2.2GHz [29].

## V Physical implementation

All key technologies required in the present architecture have already been demonstrated experimentally in various physical systems, such as trapped ions [8] and NV-centres in diamond [9]. Among them, state-of-the-art technologies in the trapped ion systems have already achieved highly accurate controls. Multiple two-qubit gates, single qubit rotations, and readouts have been achieved with error probabilities [30], [31], and [32, 33], respectively. These benchmarks are comparable to the requirements for the local operations in the QALUs. In order to attain scalability, the ion qubits could be distributed over separate trap zones. There are two main schemes, which can be used as the quantum channels, to entangle separately trapped ion qubits. One is based on the quantum charge-coupled device [34] with the microfabricated ion trap technologies, where entangling operations are implemented by shuttling ion qubits between the storage and interaction regions. The transport of ion qubits has succeeded experimentally with high accuracy, and a two-qubit gate has been demonstrated with high fidelity [35, 36]. Another approach utilises photons as flying qubits in order to entangle two separate ion qubits, where the fidelity has been achieved experimentally [37]. In order to couple ion qubits efficiently with photons, surface-electrode ion traps integrated with microscale optics have also been investigated recently [38, 39]. These fidelities of the above two entangling operations are well above our requirement. (, and leads to the values of and below the thresholds.)

Solid state systems are another promising candidates for a physical implementation of the present architecture. In the NV-centre diamond systems, particularly, there are well-defined local systems as the QALUs [40, 9]. The control of the 12–16 dimensional systems (electric spin-1 and two or three nuclear spin-1/2) [9, 41] and the single-shot readout [42, 43] have already been achieved. The entanglement between the polarization of a single optical photon and a single electronic spin in a NV-centre diamond [44], and two-photon interference from separated NV-centers [45, 46] have also been observed recently. These technology can be used as the quantum channel for the present distributed architecture. Furthermore, universal dynamical decoupling [47] could be employed to suppress noise and achieve reasonably accurate local operations required for the present architecture.

## Vi Discussion and conclusion

We have proposed a distributed architecture for scalable quantum computation. The present architecture works with reasonably accurate small (four-qubit) local systems, which are connected by very noisy quantum channels. All key ingredients employed in the present architecture have already been experimentally demonstrated, and the accuracies required for them are comparable to the recent experimental achievements. Actually this is the first proposal of a practically scalable architecture which works well even with the preexisting level of the experimental devices. We believe that this proposal fills the gap between top-down and bottom-up approaches towards practically scalable quantum computation and gives a good guideline and benchmark in the development of quantum devices.

Finally let us mention that there are a lot of rooms to improve the performance of the present architecture. Instead of the bipartite entangled states, we can also use multipartite entangled states as resource states for teleportation-based multi-qubit gates. Since a part of errors during local operations, which are to be performed in the future computation, are removed beforehand through purification, the physical threshold would be improved. Furthermore, by using improved decoding algorithm, we can fully utilise the potential power of the surface code. It boosts the topological threshold from to – [48]. The topological colour codes [49], whose threshold value [50] is higher than that () of the Kitaev’s surface code [26], can be also implemented on the present architecture. These upgrades will improve the threshold values of the local operations to , which will become comparable to that of the non-distributed fault-tolerant schemes without modular scalability [5, 6, 7].

## Acknowledgements

This work was supported by the Funding Program for World-Leading Innovative R & D on Science and Technology (FIRST), MEXT Grant-in-Aid for Scientific Research on Innovative Areas 20104003 and 21102008, the MEXT Global COE Program and MEXT Grant-in-Aid for Young scientists (A) 23684035.

## Appendix A Entanglement pumping

### a.1 Entanglement pumping with single selection

In the entanglement purification with single selection, one noisy MES is purified by using one noisy MES as the ancilla as shown in Fig. 2 (a). Assuming that all errors are given by probabilistic Pauli errors, the purification map can be described as

(4) |

where indicate the fidelities of the output state. The transition probability tensor is given by

(5) |

where and correspond to the bilateral measurement error and bilateral CNOT gate followed by the two-qubit gate errors [20], respectively, and the summation means the postselection according to the bilateral measurement outcomes as shown in Fig. 5 (a), which are designed to check bit-flip errors. Throughout the level-1 single pumping, the initial noisy MES is used as the ancilla for pumping, and hence we take [16]. Then, the purification can be viewed as a map from , . Starting with the initial noisy MES (i.e. ), the single pumping is repeatedly applied times. As a result, we obtain the level-1 single-pumped MES of the fidelity

(6) |

where indicates the net success probability of the level-1 single pumping.

In the level-2 single pumping [16], the output state of the level-1 single pumping is further purified by using the level-1 single-pumped MES as the ancilla, where the phase-flip errors are checked. The purification map can be described as

(7) |

where , with being the bilateral Hadamard transformation. By repeatedly applying the level-2 single pumping times, we obtain the level-2 single-pumped MES of the fidelity

(8) |

The contour of the infidelity of the level-2 single-pumped MES is plotted with respect to the channel fidelity and error probability of local operations for each in Fig. 6 (a). There is a tradeoff between the channel fidelity and error probability of local operations when the the numbers of repetitions are increased. This behavior can be understood that either bit or phase error is checked repeatedly at each pumping level, which is designed to obtain the output MES of high fidelity even with low channel fidelity as discussed in Ref. [16].

### a.2 Entanglement pumping with double selection

In the level-1 entanglement pumping with double selection, one noisy MES is purified by using two initial noisy MESs as the ancillae as shown in Fig. 5 (b). Similarly to the previous case, the purification map can be described as

(9) |

where the transition probability tensor is given by with . Starting with the initial noisy MES (i.e. ), the level-1 double pumping is repeatedly applied times, and then we obtain the level-1 double-pumped MES of the fidelity

(10) |

where is the net success probability similarly to the previous case with single selection. In the level-2 double pumping, the output state of the level-1 double pumping is further purified by using the level-1 single pumped MES and initial noisy MES as the ancillae. The level-2 double pumping can be described as

(11) |

By applying repeatedly times, we obtain the level-2 double-pumped MES of the fidelity

(12) |

The contour of the infidelity is plotted with respect to the channel fidelity and error probability of the local operations for each in Fig. 6 (b). In Fig. 3 (a), the result with is plotted. In the level-2 double pumping, the acceptable range of the channel fidelity is improved without sacrificing that of the error probability of local operations, when the numbers of repetitions are increased. This is due to the following two factors: (i) Both bit and phase errors are checked at each pumping level. (ii) A large amount of operational errors, which are left on the output state of single selection, can be detected by double selection [20].

## Appendix B Error analysis of TTGs

We employ three types of TTGs in the syndrome measurement (see Fig. 4 (a)).

### b.1 TTG of type I

The TTG of type I [1⃝ in Fig. 4 (a)] is as follows:

(13) |

where the Hadamard operations is required to transform errors to errors. The probabilities of errors on the two output qubits are given by

where we switched the notation from to (), and means .

### b.2 TTG of type II

The TTG of type II [2⃝ and 4⃝ in Fig. 4 (a)] is as follows:

(14) |

The probabilities of errors on the two output qubits are given by

where and indicate the error probabilities of the top and bottom two-qubit gates, respectively, as shown in the above diagram.

### b.3 TTG of type III

The TTG of type III [3⃝ in Fig. 4 (a)] is as follows:

(15) |

The probabilities of errors on the two output qubits are given by

where and indicate the error probabilities of the top (CNOT) and bottom (CZ) two-qubit gates, respectively, as shown in the above diagram.

## Appendix C Threshold analysis

The syndrome measurements for topological error correction are implemented as shown in Fig. 7. The errors during the error correction on the primal lattice [51, 6, 52] can be described as errors located at , , and , which are depicted with green lines in Fig. 7. The errors at and correspond to errors on the measured syndrome and data qubits, respectively. Similarly, the errors during the error correction on the dual lattice are located at , , and , which are depicted with orange lines in Fig. 7. Since the error corrections on the primal and dual lattices are implemented independently, we can ignore the correlations between errors on the primal and dual lattices (i.e. correlated errors between and ). Furthermore, behavior of the errors on the dual lattice is equivalent to that on the primal lattice, since they are symmetric under reflection and rotation. Thus we consider only the errors on the primal lattice, i.e., those errors at , , and .

Let , , and denote the probabilities of the independent errors at , , and , respectively. If errors are located on the data qubits independently with equal probability, and syndrome measurements are perfect, then , . In such a case, the threshold value is given by [26]. With (i.e. independent errors on the syndrome and data qubits with equal probability), the threshold values have been estimated as [53] and [54] by using the minimum-weight perfect matching algorithm and the random-plaquette gauge theory, respectively.

In the present case (and also in Ref. [6, 52]), however, we have to take the correlated errors into account, since the two-qubit gates for the syndrome measurements introduce correlation. By using the commutation relations between errors and two-qubit gates, it is found that the correlated errors are located only at and of the same unit cell and of the neighboring unit cells. Such probabilities are denoted by , , and . The probabilities of independent and correlated errors can be calculated in terms of the error probabilities of the th two-qubit gate (see Fig. 7), where and indicate errors on the syndrome and data qubits respectively, and the Hadamard operation is included in the two-qubit gate for :

(16) | |||||

(17) | |||||

(18) | |||||

(19) | |||||

(20) | |||||

(21) |

where in corresponds to the preparation and measurement errors of the ancilla qubit for the syndrome measurement, and the subscripts , , , and mean , , , and respectively. For example, .

In the original scheme [6], two-qubit gate errors () and single-qubit gate errors () are assumed to occur with equal probability and , respectively. Thus for all when , and and for other when . The preparation and measurement error probabilities are taken as . Then, Eqs. (16)-(21) read , , , . On the other hand, the threshold value for is given by in Ref. [6], which is obtained by using the minimum-weight-perfect-matching algorithm. This leads to threshold conditions of these probabilities (sufficient conditions for fault-tolerance) as

In the present architecture, on the other hand, we use the TTGs of type I (for ), II (for ), and III (for ), where the state preparation for the syndrome measurement and Hadamard operations are incorporated (see TTG I and III). Specifically, for the TTG of type I (i.e. ), the error probabilities () are given by

(23) | |||||

(24) | |||||

(25) | |||||

(26) | |||||

(27) |

where we take . Similarly, for the TTG of type II and III (i.e. ), they are given by

(28) | |||||

(29) | |||||

(30) | |||||

(31) |

By using the these, Eqs. (16)-(21) and threshold conditions (LABEL:eq3) read

(32) | |||||

(33) | |||||

(34) | |||||

(35) |

(Note that in the present case, since preparation of ancilla for the syndrome measurement is taken into account in the TTG of type I.) The threshold curve are plotted in Fig. 3 (b), which is calculated with obtained by using the transition probability tensors. Specifically, in the limit of , the output fidelity of the purification is obtained as in the leading order [20]. With , we obtain the following conditions on :

(36) | |||||

(37) | |||||

(38) | |||||

This leads to the physical threshold with . Since are smaller than the threshold values for them, the true physical threshold would be higher than , which would be determined by using a full numerical simulation.

## Appendix D Resource analysis

The operational overhead under the physical error probability at 1/3 of the topological threshold is plotted as a function of the circuit size in Fig. 11 of Ref. [6]. It reads that if we want to perform gates accurately (i.e. an accuracy of is required for each gate), a logical gate requires ( in Ref. [6]) physical two-qubit gates.

In Fig. 8 (a), 1/3 of the topological thresholds in the present case [i.e., the curves which satisfy , , and ] are plotted for each . It can be seen that achieves 1/3 of the topological threshold even with and . The the total amount of local operations plus quantum communication (i.e. the number of initial MESs) per TTG (i.e. per purified MES) is determined for given repetition numbers by the channel fidelity and error probability of local operations through the success probabilities , , and . In Fig. 8 (b), the contours of the total amount for are plotted against and . Specifically, when and . Accordingly, the total operational overhead can be calculated as .

### References

- J. von Neumann, , Ann. Hist. Comp. 3 263 (1946).
- J. von Neumann, Automata Studies, Annals of Mathematics Studies No. 34 (Princeton University Press, Princeton, NJ, 1956), p. 43.
- J. Han and P. Jonker, Nanotechnology, 14, 224 (2003).
- M. A. Nielsen and I. L. Chuang, (Cambridge University Press, 2000).
- E. Knill, Nature (London) 434, 39 (2005).
- R. Raussendorf, J. Harrington, and K. Goyal, New J. Phys. 9, 199 (2007).
- K. Fujii and K. Yamamoto, Phys. Rev. A 82, 060301(R) (2010).
- T. Monz, et al., Phys. Rev. Lett. 106, 130506 (2011).
- P. Neumann, et al, Science 320, 1326 (2008).
- T. D. Ladd, et al., Nature (London) 464, 45 (2010).
- E. Knill, Nature (London) 463, 441 (2010).
- S. J. Devitt et al., New J. Phys. 11, 083032 (2009).
- R. V. Meter, T. D. Ladd, A. G. Fowler, and Y. Yamamoto, Int. J. Quantum Inf. 8 295 (2010).
- J. I. Cirac, A. K. Ekert, S. F. Huelga, and C. Macchiavello, Phys. Rev. A 59, 4249 (1999).
- W. Dür and H.-J. Briegel, Phys. Rev. Lett. 90, 067901 (2003).
- L. Jian, J. M. Taylor, A. S. Sørensen, and M. D. Lukin, Phys. Rev. A 76, 062323 (2007).
- H.-J. Briegel, W. Dür, J. I. Cirac, and P. Zoller, Phys. Rev. Lett. 81, 5932 (1998).
- C. H. Bennett et al., Phys. Rev. Lett. 76, 722 (1996).
- D. Deutsch et al., Phys. Rev. Lett. 77, 2818 (1996).
- K. Fujii and K. Yamamoto, Phys. Rev. A 80, 042308 (2009).
- D. Gottesman and I. L. Chuang, Nature (London) 402, 390 (1999).
- S. D. Barrett and T. M. Stace, Phys. Rev. Lett. 105, 200502 (2010).
- S. D. Barrett and P. Kok, Phys. Rev. A 71, 060310(R) (2005).
- W. K. Wooters and W. H. Zurek, Nature (London) 299, 802 (1982).
- W. Dür and H.-J. Briegel, Rep. Prog. Phys. 70, 1381 (2007).
- E. Dennis, A. Yu. Kitaev, and J. Preskill, J. Math. Phys. 43, 4452 (2002).
- S. Bravyi and A. Kitaev, Phys. Rev. A 71, 022316 (2005).
- Intel Cooperation. Microprocessor quick reference guide. http://www.intel.com/pressroom/kits/quickreffam.htm (2011).
- T. Kleinjung et al., Advances in Cryptology - Crypto 2010, Lecture Notes in Computer Science Vol. 6223 (Springer-Verlag, Berlin, 2010), pp. 333.
- J. Benhelm et al., Nature Phys. 4, 463 (2008).
- K. R. Brown et al., e-print arXiv:1104.2552.
- A. H. Myerson et al., Phys. Rev. Lett. 100, 200502 (2008).
- A. H. Burrell, et al., Phys. Rev. A 81, 040302(R) (2010).
- D. Kielpinski, C. Monroe, and D. J. Wineland, Nature (London) 417, 709 (2002).
- R. B. Blakestad et al., Phys. Rev. Lett. 102, 153002 (2009).
- J. P. Home, et al., Science 325, 1227 (2009).
- P. Maunz et al., Phys. Rev. Lett. 102, 250502 (2009).
- A. P. VanDevender et al., Phys. Rev. Lett. 105, 023001 (2010).
- E. W. Streed et al., Phys. Rev. Lett. 106, 010502 (2011).
- L. Childress et al., Science 314, 281 (2006).
- N. Mizuochi, et al, Phys. Rev. B 80, 041201(R) (2009).
- L. Jiang et al., Science 326, 269 (2009).
- P. Neumann, et al, Science 329, 542 (2010).
- E. Togan et al, Nature (London) 466, 730 (2010).
- H. Bernien, et al., arXiv:1110.3329.
- A. Sipahigil, et al., arXiv:1112.3975.
- G. de Lange et al, Science 330, 60 (2010).
- D. S. Wang, A. G. Fowler, and L. C. L. Hollenberg, Phys. Rev. A 83, 020302(R) (2011).
- H. Bombin and M. A. Martin-Delgado, Phys. Rev. Lett. 97, 180501 (2006).
- R. S. Andrist et al., New J. Phys. 13, 083006 (2011).
- R. Raussendorf, J. Harrington, and K. Goyal, Ann. of Phys. 321, 2242 (2006).
- R. Raussendorf and J. Harrington, Phys. Rev. Lett. 98, 190504 (2007).
- C. Wang, J. Harrington, and J. Preskill, Ann. Phys. 303, 31 (2003).
- T. Ohno, et al., Nuc. Phys. B 697, 462 (2004).