# Accuracy threshold for concatenated error detection in one dimension

###### Abstract

Estimates of the quantum accuracy threshold often tacitly assume that it is possible to interact arbitrary pairs of qubits in a quantum computer with a failure rate that is independent of the distance between them. None of the many physical systems that are candidates for quantum computing possess this property. Here we study the performance of a concatenated error-detection code in a system that permits only nearest-neighbor interactions in one dimension. We make use of a new message-passing scheme that maximizes the number of errors that can be reliably corrected by the code. Our numerical results indicate that arbitrarily accurate universal quantum computation is possible if the probability of failure of each elementary physical operation is below approximately . This threshold is three orders of magnitude lower than the highest known.

###### pacs:

03.67.Lx, 03.67.Pp## I Introduction

For a quantum computer to reliably outperform a classical computer, it must be robust against the effects of decoherence and imprecise quantum control. There are many ideas on how to achieve such fault tolerance, including topological quantum computing Kitaev1 (); Nayak1 (); Raussendorf2 (), surface codes Kitaev1 (); Bravyi1 (); Dennis1 (), color codes Bombin1 (), self-correcting codes Bacon1 (), and concatenated codes Shor2 (); Steane1 (). The threshold theorem indicates that, under certain conditions, scalable quantum computing is possible in principle Aharonov1 (); Aliferis1 (). The theorem asserts that if the probability of failure of each elementary physical operation in a quantum computer is below some threshold then arbitrarily accurate quantum computation can be performed efficiently given sufficient time and qubits. The actual value of the threshold for a given error-correction code depends on a number of parameters that describe the quantum computer and the noise that affects it Gottesman1 ().

In most estimates of the accuracy threshold, the assumption is made that it is possible to interact arbitrary pairs of qubits in a quantum computer with a failure rate that is independent of the distance between them. This property is desirable, since it allows higher failure rates to be tolerated, but it is unrealistic in the limit of many qubits. In all of the physical systems that are candidates for quantum computing the range of controllable interactions is constrained such that at least some pairs of qubits will need to be transported before they can undergo logic gates such as cnot and cphase. Moreover, we expect that in many systems, especially trapped-ion, superconducting, and solid-state systems, hardware limitations will require that the qubit array is two- or one-dimensional Kielpinski1 (); Taylor1 (); Hollenberg1 (); Fowler1 ().

The combination of local interactions and low coordination number is not a problem in principle as it is known that the threshold theorem still applies Aharonov1 (); Gottesman4 (). The value of the threshold has been quantified for systems that permit only nearest-neighbor interactions in two dimensions Raussendorf1 (); Svore1 (); Roychowdhury1 () and in various quasi one-dimensional settings Szkopek1 (); Stephens1 (), and the threshold is also known for superconducting Fowler1 () and ion-trap Metodi1 () architectures with similar properties. However, there are a large number of systems under development that permit only nearest-neighbor interactions in one dimension Kane1 (); Loss1 (); Vrijen1 (); Tian1 (); Hollenberg2 (); Feng1 (); Pachos2 (); Vandersypen1 (); Solinas1 (); Jefferson1 (); Petrosyan1 (); Vyurkov1 (); Kamenetskii1 (), for which the threshold is unknown. The threshold in one dimension is expected to be significantly lower than in all other cases.

Here we find the accuracy threshold for a system that permits only nearest-neighbor interactions in one dimension. Where required, qubits are transported via nearest-neighbor swap gates. To minimize this overhead we use a small error-detection code. To correct errors we make use of a new message-passing method that uses classical information gathered during error detection to maximize the number of errors that can be reliably corrected Evans2 (). Our numerical results indicate that arbitrarily accurate quantum computation is possible if the probability of failure of each elementary physical operation is below approximately .

## Ii [[4,1,2]] subsystem code

The code that we have chosen to use is the [[4,1,2]] subsystem code, a stabilizer CSS quantum code that encodes one logical qubit into four physical qubits Bacon1 (); Bacon2 (). Its stabilizer, , is

(1) |

where and represent the Pauli operators and applied to the qubit respectively. Identity operators and tensor products between operators are omitted. Although there are two degrees of freedom in which to store encoded information, we choose to ignore one of these encoded qubits. Then, elements in the non-Abelian group, , generated by the operators

(2) |

act trivially on the sole protected qubit. The encoded and operators for this qubit are

(3) |

Because the elements in are products of elements in , and since all elements in commute with all elements in and the encoded operators, to determine the eigenvalues of the elements of it is sufficient to measure the eigenvalues of the elements in . This may change the state of the system but it will not affect the state of the protected qubit. This property allows us to use only two ancilla qubits to simultaneously perform operator measurements of the operators in Aliferis3 (). We decode the syndrome by taking the parity of the two measurement outcomes in each basis. This is used to infer the presence or absence of errors in each basis—if the parity is even there is no error, if the parity is odd there is an error. For the [[4,1,2]] subsystem code, cnot is a valid transversal gate and is a valid transversal gate up to a permutation of qubits.

## Iii Using concatenated error detection to correct errors

In our scheme the [[4,1,2]] subsystem code is concatenated such that physical qubits form encoded qubits which in turn form higher-level encoded qubits and so on. However, while concatenating the code times results in a final code that has distance , if each level of error detection operates independently of every other level, then the code cannot reliably correct even a single error—a single physical failure may cause an encoded error at any level. To do more than simply detect errors classical messages must be passed from each level to the level above. These messages serve to indicate the location of potential errors, thereby removing the ambiguity in the cause of any odd parity syndrome that is observed, which allows errors that are detected to be located and corrected.

The message-passing method applied in this paper is similar to those of Refs. Knill1 (); Evans1 (); Aliferis5 () but, unlike those, it will only fail if the number of concurrent errors is greater than or equal to half of the distance of the final concatenated code—in the case of the [[4,1,2]] subsystem code, the leading-order exponent of the probability of failure scales with the number of levels of concatenation as (physical), and so on. This is also a property of the noisy-channel method of Ref. Poulin1 (). Although we will only describe the message-passing method in the case where it is applied to the [[4,1,2]] subsystem code, it can be applied to codes with greater distance. A detailed description of the method is contained in Ref. Evans2 ().

Messages in the method consist solely of classical information which indicates our confidence that each location in the circuit has not failed given what is known about it. We call these messages flags. The probability that any given flag represents an actual error is described by the weight, , carried by the flag such that , where is the probability of failure of an elementary physical location in the quantum computer. Since we assume that errors at each location are independent of all other locations, the probability of a set of flags representing actual errors is , where the sum is over the entire set. Flags are raised at every elementary physical and encoded location. All flags at the physical level are given weight equal to one by definition and at all other levels weights are determined during error detection at the level below. Flags in the and bases are separate.

As flags are raised they are classically propagated through the error-detection circuit to determine the effect that an error at the location at which the flag originated would have on the data and ancilla qubits at the point of syndrome extraction. Note that cnot copies errors from the control qubit to the target qubit and errors in the opposite direction, and that we define the point of syndrome extraction to be immediately after the ancilla qubits are measured. Since there are significantly fewer effects than there are locations at which flags are raised, flags are binned by effect. Each bin is assigned a single weight which is only updated if a flag is raised with a weight lower than its existing value.

Figure 1 illustrates the binning system where, for simplicity, non-local circuits are used and only errors are considered. Note that the -error syndrome is obtained using the second half of the circuit in Fig. 1, so we are interested in the effect of errors at the second set of measurements. errors do not affect the -error syndrome, but since they can occur during the circuit to obtain the -error syndrome this part of the circuit must be considered. Because of the degeneracy of the code, we need only consider two pairs of data qubits rather that four individual data qubits. For example, since acts trivially on the encoded qubit, both and give the same syndrome and can be corrected by the operator .

Since the failure of a single cnot or swap gate can introduce a pair of correlated errors, these gates require special treatment. The weights of the two flags that are raised immediately following each two-qubit gate are used to update the bin which corresponds to the two-qubit correlated error. Note that both of the bins corresponding to single errors following the two-qubit gate are also updated. The weight of the correlated error is taken to be the maximum of the two single-qubit weights, as opposed to the sum, which would describe the probability of the pair of errors occurring without correlation.

Once the syndrome is measured its most likely cause is identified by finding the bin that has the lowest weight while still being consistent with, or matching, the syndrome. In the case of the [[4,1,2]] subsystem code, in each error-correction cycle we consider only three bins, , , and . The most likely cause of an odd syndrome is a single error occurring in the bin with the lowest weight, as each of these bins corresponds to a change in the parity of the ancilla. The most likely cause of an even syndrome is always no error at all. If the match implies an error on a data qubit then the appropriate correction is applied.

Although we correct for the most likely error it is possible that the true error is the complement of the correction—that is, the true error and the correction that we apply combine to form an encoded operator. To determine the weight of the flag that is raised in the error-correction circuit at the level above, what we will call the encoded weight, we calculate the difference between the weight of the match on which we act and the weight of its complement. For example, if we have an odd syndrome and the is the match, then is the complement match and the encoded weight is the difference between the weights of the these two matches, .

There is the possibility that a correction will result in a state that is outside the code space so that it is neither correct nor affected by an encoded operator. Just as the complement match is used to determine the probability of an encoded error, the conditional probability of single errors on the pairs of data qubits can be updated by considering other matches. At the end of each error-correction cycle the weights of and are updated to the minimum of the weight of any previous locations that have not yet had an opportunity to affect the ancilla, given by and , and a weight obtained during the preceding circuit, calculated in an analogous way to the encoded weight based on the syndrome that is observed.

Table I shows a list of all possible flag matches along with the various flag-weight updates that would result from each of them being acted on, where we have retained the notation of Fig. 1. By the careful consideration of every possible cause of every syndrome in this way we always have accurate weights for every qubit at every level. We can always, therefore, apply corrections based on the most likely set of errors.

synd. | match | corr. | |||
---|---|---|---|---|---|

+1 | None | none | |||

n/a | |||||

n/a | |||||

n/a | |||||

-1 | |||||

none | |||||

n/a |

## Iv Accuracy threshold in one dimension

To estimate the threshold for universal quantum computation in one dimension we construct circuits for error detection and for the encoded operations cnot, swap, Hadamard, state preparation, and measurement. These operations, which we will refer to as CSS operations, are sufficient to concatenate error detection and to perform state distillation following the ideas presented in Refs. Bravyi3 (); Aliferis4 (). State distillation involves preparing the ancillary state to enable the logical phase gate, , and preparing the ancillary state to enable the logical Toffoli gate. These gates together with the CSS operations complete a universal set for quantum computation. Accurate states can be distilled from many noisy states provided the noisy states can be made with a failure rate lower than some distillation threshold, which is typically above one percent. We determine the threshold for CSS operations by numerically simulating the circuit for an error-corrected logical cnot under a stochastic error model. The cnot is chosen because it has the highest failure rate of the CSS operations. As the threshold we find is well below the distillation threshold it is the threshold for universal computation under our scheme.

Figure 2 shows a circuit for syndrome extraction for the [[4,1,2]] subsystem code where only nearest-neighbor interactions on a linear array are permitted. Note that the encoded Hadamard can be achieved by transversal application of the Hadamard gate in addition to removing a single swap gate from this circuit to permute the qubits. This syndrome-extraction circuit has the same depth as the non-local circuit in Fig. 1 and the two circuits differ only by a rearrangement of qubits and the addition of two swap gates. This difference is significant, however, since each of the additional swap gates involves two data qubits. New pairs of correlated errors are introduced with probability , where is the probability of failure of an elementary physical location. Without the swap gates these particular pairs of errors occur with probability . Since these errors include the encoded operators, this means that an undetected encoded error occurs with probability .

Figure 3 shows the encoded cnot circuit. A pair of correlated errors caused by the failure of one of the swap gates prior to the transversal cnot results in a pair of errors on the encoded control qubit and a pair of errors on the encoded target qubit. This is because the transversal cnot copies errors. This means that a pair of correlated, undetected encoded errors occurs with probability . The encoded swap gate, in which the transversal cnot is replaced by a transversal swap, does not possess this property. Two gates must fail during the encoded swap for both encoded qubits to fail undetected.

Here we make an important observation: to leading order, the relative probabilities of undetected failure of first-level encoded locations in the one-dimensional case mimic the relative probabilities of failure of physical locations in the non-local case. Specifically, all single-qubit locations fail with probability , a pair of correlated errors after a cnot occurs with probability , and a pair of correlated errors after a swap occurs with probability . A pair of correlated errors can occur after a swap gate because of a single fault, but they will always be detected. A corollary of this is that after the first level of concatenation our linear scheme will mimic a non-local scheme. In the non-local case we expect to succeed whenever the number of concurrent errors is less than half of the distance of the final concatenated code. This implies that in the one-dimensional case the first-order exponent of the probability of failure should scale with the number of levels of concatenation as (physical), and so on.

Note that Figs. 2 and 3 show circuits constructed from physical gates. To generate circuits for error correction and encoded operations at higher encoded levels we replace all physical gates with encoded gates. Like in other concatenated schemes, after every encoded operation we perform error correction on the encoded qubits involved in that operation Aliferis1 (). All circuits are designed so that ancilla qubits are always available to perform error correction using the circuit in Fig. 2.

To attempt to verify that our scheme performs as expected and to determine the threshold, we simulate a logical cnot under a stochastic error model. The simulated circuit consists of a cnot extended rectangle Aliferis1 (), the failure rate of which is meant to approximate the failure rate of a cnot in some algorithm or at a higher level of concatenation. Because the circuit only contains gates from the Clifford group, we need only simulate the propagation of errors that occur during the circuit Steane3 () rather than store the complete state of the quantum computer. We have written our own simulator for this purpose. We simply assume the state begins in an arbitrary valid codeword state and is stochastically perturbed by errors during the circuit. The circuit is defined to succeed if measurement of the data qubits at the end of the circuit in either the or basis would give the correct outcome. Equivalently, a circuit is defined to have succeeded if an errorless error-correction cycle applied to its output state would produce the correct state.

We generate data in two different ways. Where is the number of levels of error correction, for , instead of applying an error at each location with some probability, we simulate the full concatenated circuit with exactly errors placed randomly. For all single-qubit locations (state preparation, memory, measurement) the error is a randomly selected Pauli error and for all two-qubit locations (cnot, swap) the error is a randomly selected two-qubit Pauli error. This is repeated many times to generate the probability that the circuit fails given errors, . These conditional probabilities can be combined to give the failure rate of the circuit as a function of ,

(4) |

where is the number of locations in the entire circuit, 172, 11992, and 864496 for respectively. The series is truncated after , 10, and 21 for respectively. These numbers are chosen so that the approximation is valid in the region of the threshold.

For , too much time is required to generate statistically significant results in this way. Instead, after each elementary physical location in the circuit we apply an error with probability , where errors at all locations are independent. We study the failure rate of the circuit as we vary between and , again, simulating the full concatenated circuit. The time required to generate statistically significant results for is prohibitive using our methods. In our simulator we use the SIMD-oriented Mersenne Twister pseudorandom number generator Saito1 (). The message-passing method is simulated along side the error-correction circuit so that it operates in the same way as it would in a real quantum computer.

Our results are summarized in Fig. 4. The gradients of the lines in Fig. 4, which are related to the minimum number of errors that cause the code to fail, are as expected. Since the first two levels of error correction are unable to reliably correct errors, the failure rate for any less than three levels of error correction is always greater than . Note that the lines for are truncated at . This is because for the approximation that for breaks down as failure due to more than 21 errors becomes common.

Our results suggest that the threshold is approximately equal to . For elementary physical failure rates below this threshold, we expect that arbitrarily accurate CSS operations can be performed efficiently given sufficient time and qubits. This threshold is well below the threshold for distillation of ancilla states that enable universal computation Bravyi3 (); Aliferis4 (). A failure rate much lower than would, however, be required to achieve a sufficiently low encoded failure rate using a practical amount of resources. For example, we estimate that to achieve an encoded failure rate of using physical qubits per encoded qubit, a physical failure rate of approximately is necessary. Furthermore, if there is a non-zero probability of defective qubits in the linear array then the threshold will cease to exist. In contrast, a constant density of defective qubits in a two-dimensional array can be tolerated and will merely lower the threshold.

## V Conclusions and further work

That the accuracy threshold for universal quantum computation in a system that permits only nearest-neighbor interactions in one dimension may be or higher is somewhat surprising. In two dimensions the highest proven threshold for concatenated error correction is Roychowdhury1 (). There is strong evidence that the threshold in two dimensions can be as high as Raussendorf1 () but this relies on techniques that are not expected to be useful in only one dimension. In quasi one-dimensional settings the highest proven threshold is Stephens1 (). Since the threshold presented in this paper is based on numerical simulations, it would be useful to obtain a rigorous bound on its value. Due to the unconventional error-correction method that we use, it is unclear if this can be done using the established level-reduction procedure of Ref. Aliferis1 ().

By adding swap gates where necessary, any quantum algorithm can be implemented on a linear nearest-neighbor array with an overhead that is, at most, polynomial in the number of qubits. This has been done explicitly for Shor’s algorithm Shor1 () in Ref. Fowler2 (). Our result strengthens the notion that one-dimensional architectures are viable candidates for quantum computing, although how to achieve defect tolerance remains an open question. It will be interesting to see if a higher threshold can be achieved by adapting the postselection scheme of Ref. Knill1 () to a system that permits only nearest-neighbor interactions in one dimension. In this scheme ancilla states are protected by an error-detection code and postselected. We expect that the new methods of message passing presented in Ref. Evans2 () will help in improving the efficiency of such a scheme, as the weights outputted from error correction may be useful in moderating the amount of postselection. These ideas are the subjects of further work.

## Acknowledgements

We thank Charles Hill and Magdalena Carrasco for their helpful suggestions. We acknowledge financial support from the Australian Research Council (ARC), the US National Security Agency (NSA), and the Army Research Office (ARO) under contract number W911NF-04-1-0290.

## References

- [1] A. Kitaev. Ann. Phys. 303, 2 (2003).
- [2] C. Nayak, S. H. Simon, A. Stern, M. Freedman, and S. Das Sarma. arXiv:0707.1889 (2007).
- [3] R. Raussendorf, J. Harrington, and K. Goyal. New J. Phys. 9, 199 (2007).
- [4] S. Bravyi and A. Kitaev. arXiv:quant-ph/9811052 (1998).
- [5] E. Dennis, A. Kitaev, A. Landahl, and J. Preskill. J. Math. Phys. 43, 4452 (2002).
- [6] H. Bombin and M. A. Martin-Delgado. Phys. Rev. Lett. 97, 180501 (2006).
- [7] D. Bacon. Phys. Rev. A 73, 012340 (2006).
- [8] P. W. Shor. Proc. Ann. Symp. Found. Comput. Sci. 37, 56 (1996).
- [9] A. M. Steane. Phys. Rev. Lett. 78, 2252 (1997).
- [10] D. Aharonov and M. Ben-Or. Proc. Ann. ACM Symp. Th. Comp. 29, 176 (1997).
- [11] P. Aliferis, D. Gottesman, and J. Preskill. Quant. Inf. Comp. 6, 97 (2006).
- [12] D. Gottesman. arXiv:quant-ph/0701112 (2007).
- [13] D. Kielpinski, C. Monroe, and D. Wineland. Nature 417, 709 (2002).
- [14] J. M. Taylor, H. -A. Engel, W. Dür, A. Yacoby, C. M. Marcus, P. Zoller, and M. D. Lukin. Nature Phys. 1, 177 (2005).
- [15] L. C. L. Hollenberg, A. D. Greentree, A. G. Fowler, and C. Wellard. Phys. Rev. B 74, 045311 (2006).
- [16] A. G. Fowler, W. Thompson, Z. Yan, A. M. Stephens, B. Plourde, and F. Wilhelm. Phys. Rev. B. 76, 174507 (2007).
- [17] D. Gottesman. J. Mod. Opt. 47, 333 (2000).
- [18] K. Svore, D. DiVincenzo, and B. Terhal. Quant. Inf. Comp. 7, 297 (2007).
- [19] R. Raussendorf and J. Harrington. Phys. Rev. Lett. 98, 190504 (2007).
- [20] F. M. Spedalieri and V. P. Roychowdhury. arXiv:0805.4213v1 (2008).
- [21] T. Szkopek, P. O. Boykin, H. Fan, V. Roychowdhury, E. Yablonovitch, G. Simms, M. Gyure, and B. Fong. IEEE Trans. Nano. 5, 42 (2006).
- [22] A. M. Stephens, A. G. Fowler, and L. C. L. Hollenberg. Quant. Inf. Comp. 8, 330 (2008).
- [23] T. S. Metodi, D. D. Thaker, A. W. Cross, F. T. Chong, and I. L. Chuang. arXiv:quant-ph/0509051 (2005).
- [24] B. E. Kane. Nature 393, 133 (1998).
- [25] D. Loss and D. P. DiVincenzo. Phys. Rev. A 57, 120 (1998).
- [26] R. Vrijen, E. Yablonovitch, K. Wang, H. W. Jiang, A. Balandin, V. Roychowdhury, T. Mor, and D. DiVincenzo. Phys. Rev. A 62, 012306 (2000).
- [27] L. Tian and P. Zoller. Phys. Rev. A 68, 042321 (2003).
- [28] L. C. L. Hollenberg, A. S. Dzurak, C. Wellard, A. R. Hamilton, D. J. Reilly, G. J. Milburn, and R. G. Clark. Phys. Rev. B 69, 113301 (2004).
- [29] M. Feng, I. DÕAmico, P. Zanardi, and F. Rossi. Europhys. Lett. 66, 14 (2004).
- [30] J. K. Pachos and P. L. Knight. Phys. Rev. Lett. 91, 107902 (2003).
- [31] L. M. K. Vandersypen, R. Hanson, L. H. Willems van Beveren, J. M. Elzerman, J. S. Greidanus, S. De Franceschi, and L. P. Kouwenhoven. Kluwer Academic / Plenum Publishers, New York (2003).
- [32] P. Solinas, P. Zanardi, N. Zanghi, and F. Rossi. Phys. Rev. B 67, 121307 (2003).
- [33] J. H. Jefferson, M. Fearn, D. L. J. Tipton, and T P. Spiller. Phys. Rev. A 66, 042328 (2002).
- [34] D. Petrosyan and G. Kurizki. Phys. Rev. Lett. 89, 207902 (2002).
- [35] V. Vyurkov and L. Y. Gorelik. Quant. Computers and Computing 1, 77 (2000).
- [36] E. O. Kamenetskii and O. Voskoboynikov. Trends in Quantum Computing Research, 221 (2006).
- [37] Z. W. E. Evans and A. M. Stephens. arXiv:0902.4506 (2009).
- [38] D. Bacon and A. Casaccino. Proc. Ann. Alerton Conf. 44, arXiv:quant-ph/0610088 (2006).
- [39] P. Aliferis and A. W. Cross. Phys. Rev. Lett. 98, 220502 (2007).
- [40] E. Knill. Nature 434, 39 (2005).
- [41] Z. W. E. Evans and A. M. Stephens. Phys. Rev. A 78, 062317 (2008).
- [42] P. Aliferis and J. Preskill. Phys. Rev. A 79, 012332 (2009).
- [43] D. Poulin. Phys. Rev. A 74, 052333 (2006).
- [44] S. Bravyi and A. Kitaev. Phys. Rev. A 71, 022316 (2005).
- [45] P. Aliferis. Ph.D. thesis, California Institute of Technology, Pasadena, CA. arXiv:quant-ph/0703230 (2007).
- [46] A. M. Steane. Phys. Rev. A 68, 042322 (2003).
- [47] M. Saito and M. Matsumoto. Monte Carlo and Quasi-Monte Carlo Methods 2, 607 (2006).
- [48] P. Shor. Soc. Ind. App. Math. 26, 1484 (1997).
- [49] A. G. Fowler, S. J. Devitt, and L. C. L. Hollenberg. Quant. Inf. Comp. 4, 237 (2004).