Is Quantum Parallelism Real?

Marco Lanzagortaa and Jerey Uhlmannb

a George b University

Mason University, Fairfax, VA, USA; of Missouri, Columbia, MO, USA

ABSTRACT

In this paper we raise questions about the reality of computational quantum parallelism. Such questions are important because while quantum theory is rigorously established, the hypothesis that it supports a more powerful model of computation remains speculative. More specically, we suggest the possibility that the seeming computational parallelism oered by quantum superpositions is actually eected by gate-level parallelism in the reversible implementation of the quantum operator. In other words, when the total number of logic operations is analyzed, quantum computing may not be more powerful than classical. This fact has signicant public policy implications with regard to the relative levels of eort that are appropriate for the development of quantumparallel algorithms and associated hardware (i.e., qubit-based) versus quantum-scale classical hardware. Keywords: Quantum Computing, Quantum Algorithms, Complexity Theory, Quantum Circuit Synthesis, Quantum Gates

1. QUANTUM COMPUTING
Moores law continues to hold as the fundamental components of computation - digital logic gates - have grown increasingly smaller in size to support exponentially increasing computational power. Extrapolating forward leads to the conclusion that within a decade or so logic gates will operate at scales at which quantum eects strongly dominate their behavior. Improvements in processing speeds are largely irrelevant to the eld of theoretical computer science because doubling the speed of a processor roughly doubles the speed of any algorithm that is executed on it. The fact that logic gates in the future will operate in the quantum realm is therefore more important to the elds of computer engineering and physics than it is to computer science. However, a new eld of quantum computing has emerged based on a premise that quantum physics oers a new model of computation that is fundamentally more powerful than the classical model and thus has the potential to radically aect the landscape of algorithmic theory. The power of the new quantum computing model derives from a presumption that it is possible to store and simultaneously manipulate an exponentially-large amount of information in a quantum register (i.e., the amount of information is exponential in the size of the register) to perform useful computations. This would be achieved using a register of n qubits (the quantum analog of classical bits) in which information is stored in the form of a quantum superposition of N = 2n states. More specically, a single unitary operation can be used to transform an entire superposition of states in one logical step, which seems to imply that O(2n ) state transformations occur in parallel. The eld of quantum computing is founded on the assumption that the transformation of states in a superposition can be exploited to produce the eect of parallel classical calculations, i.e., that for a xed amount of physical computational resources, quantum phenomena can permit a larger number of eective computations to be performed than is possible in the classical model within the same resource constraints. In this paper we consider the subtleties associated with the complexity results used to assess the relative performance of quantum and classical algorithms. Our objective is to provide a clear and concise explanation of why the status of quantum computing is less clear than commonly accepted. More specically, we discuss the possibility that the seeming computational parallelism oered by quantum superpositions is actually eected by gate-level parallelism in the
Further author information: Lanzagorta: E-mail: mlanzago@gmu.edu, Telephone: 202 767-8427 Uhlmann: E-mail: uhlmannj@missouri.edu, Telephone: 573 884-2129
Quantum Information and Computation VI, edited by Eric J. Donkor, Andrew R. Pirich, Howard E. Brandt, Proc. of SPIE Vol. 6976, 69760W, (2008) 0277-786X/08/$18 doi: 10.1117/12.778019

Proc. of SPIE Vol. 6976 69760W-1 2008 SPIE Digital Library -- Subscriber Archive Copy

reversible implementation of the quantum operator. In other words, when the total number of logic operations is analyzed, quantum computing may not be more powerful than classical. Technical details are included in an extended appendix.

2. HYPOTHETICAL QUANTUM PARALLELISM

Quantum computing hypothesizes that an operator applied to a superposition of states has the eect of being applied to all of the states in parallel. Because a quantum system of n particles denes an exponential 2n number of states, it appears that a small amount of computational hardware can behave like a classical parallel computer with an exponential number of processors. What is critical to note is that the ability to exploit quantum phenomena for computational advantage over classical computing is not an implication of quantum theory. In other words, the power of quantum computing must be demonstrated by example in the form of a quantum algorithm that is able to solve a problem with computational complexity surpassing a provable lower bound for any classical alternative. Given its fundamental importance, it is natural to ask why the reality of quantum parallelism hasnt yet been established. Presumably it should be possible to devise a straightforward example, but that does not seem to be the case. This should be expected if the quantum parallelism assumption is false because that would imply that every such eort must be obstructed in some way by the constraints of the theory, e.g., measurementinduced superposition collapse and/or the no-cloning theorem. For example, quantum parallelism suggests that it is possible to compute the value of a binary function for all N possible values of its input variable in a single computational step. The question, however, is whether the ratio of extracted information and total computations is superior to what is possible within the classical computing framework. Suppose that f is a binary function: f : {0, 1}n {0, 1} and also suppose that U is a reversible quantum operator that performs the following operation: U |x |0 = |x |f (x) Applying U to a uniform quantum superposition performs the following: 1 N
N 1 x=0

(1)

(2)

1 U |x |0 N

N 1

|x |f (x)
x=0

(3)

in a single computational step (i.e., one execution of the operator). The classical complexity to perform the N evaluations of f is clearly (N ), but this does not demonstrate that the quantum approach has superior complexity. This is because a measurement of the quantum register after the evaluation of f has been completed will obtain |xi |f (xi ) (4) with probability 1/N , and information relating to all other function evaluations is destroyed. In other words, only O(n) classical bits of information can be extracted. The entire process could of course be repeated, but to extract all N values would require (N log(N )) iterations . As will be discussed in the following section, even if a quantum algorithm requires fewer iterations than the best classical alternative, it is necessary to examine the relative computational expenditures per iteration because of the complexity costs associated with the reversible implementation of quantum operators.
The quantum Fourier transform (QFT) is a similar example of a quantum algorithm that appears to perform a large operation very eciently, but to extract the complete result of the operation takes time equal to the complexity of the best classical alternative (the FFT). There is no proven optimal bound for the classical analog of the QFT in which the Fourier coecients are sampled.

Proc. of SPIE Vol. 6976 69760W-2

3. ALGORITHM EQUITY ASSUMPTIONS

The vast majority of algorithmic analyses in the literature rely on multiple simplifying assumptions which are not explicitly stated. In most cases such assumptions are inconsequential because a more rigorous and complete analysis will yield essentially the same result. However, it is well known that it is possible to exploit common assumptions to achieve spurious complexity results that are not consistent with those of a more complete analysis. For example, Shamir [1] showed that an assumption that arithmetic operations on integers have O(1) complexity can be exploited to seemingly oer an O(log(N )) algorithm for integer factorization - which of course would be more ecient even than Shors quantum algorithm. Shamir achieves this result by essentially packing a superlinear (in N ) number of bits of information into a single integer while treating operations on that huge integer as still having O(1) complexity. Clearly the true complexity must take into account the scaling of the number of logic gates required to support unit-cost operations for the size integers necessary to perform the computations. If the number of gates grows with N (i.e., the number to be factored) then it becomes clear that the algorithm is beneting from a degree of gate-level parallelism that is not actually available on a conventional computer. Alternatively, if it is explicitly assumed that the required gate-level parallelism actually is available, then competing algorithms may be able to exploit the same assumption to achieve comparable complexity reductions. In other words, equity of assumptions is necessary when comparing the computational complexities of dierent algorithms. Quantum computing assumes that operations can be applied in parallel to all N states in a quantum superposition to solve a given algorithmic problem more eciently than is possible using classical hardware. However, quantum mechanics imposes a signicant restriction: the transformations applied to the quantum register must be unitary. This is necessary because a non-unitary operator is equivalent to performing a measurement and thus will cause a collapse of the superposition. Fortunately, this fact does not limit the generality of quantum computation because in theory an arbitrary Boolean function can be implemented using unitary operators. In 1949 Shannon showed that an arbitrary Boolean function requires a classical circuit of size O(2n /n) = O(N/ log(N )) [2]. However, most Boolean functions found in practice, like those used for arithmetic operations, require only linear-size circuits, O(n) = O(log(N )). Furthermore, it appears that explicit examples of classical Boolean functions requiring superlinear circuits are dicult to constuct, and in fact no example has been found [3, 16, 17]. On the other hand, the implementation of an arbitrary unitary operator requires O(4n ) = O(N 2 ) 2-qubit elementary quantum gates [14]. If we compare the complexities for the worst case scenarios, we observe that the classical circuit requires a factor of O(N log(N )) fewer gates than the quantum circuit . This extra factor of O(N log(N )) gates required for the unitary form changes the relative resource allocation, so an alternative classical algorithm should assume the availability of the same number of logic gates. However, this is is precisely what is needed to achieve the same level of parallelism as is potentially available from N states in a superposition. In light of the above discussion, it is interesting to consider the origins of quantum computing. The eld originated with Richard Feynmans observation that an n-particle quantum system is specied in a state space of size 2n and thus would require an O(4n )-element unitary matrix and O(4n ) calculations to be simulated on a classical computer. To Feynman this suggested the possibility that a quantum system could be used to perform those O(4n ) virtual calculations to solve algorithmic problems, e.g., simulation of quantum systems, that cannot be solved eciently using classical hardware. It now appears, however, that O(4n ) quantum gates are required to perform general unitary transformations of quantum systems, and that result is probably no coincidence. This tends to suggest that when the number of eective computations is divided by the total number of gates, quantum systems do not provide any free extra-dimensional computational power relative to classical computing. This suggests that quantum computation may not be more eective at simulating quantum systems (as Feynman had hoped) unless quantum simulation is interpreted to mean that the evolution of one quantum system (possibly in the form of qubits) provides analogical information about a similar quantum system. If that is the case, however,quantum simulation is no more powerful than, e.g., a hydrodynamic simulation tank that uses real water in a scaled-down system to provide insight about actual ocean systems. It must be emphasized that establishing that quantum computing requires O(4n ) gates in the worst case does not resolve the question of whether or not quantum parallelism oers new computational power. It could be the

The reader is referred to the Appendix for a more detailed discussion of these circuit complexities

Proc. of SPIE Vol. 6976 69760W-3

case that a particular quantum algorithm is able to exploit the special structure of its associated unitary operator so that the implementation of the operator requires only a small number of gates. On the other hand, it may turn out that in every such case the same structure admits a classical algorithm with computational complexity equal to that of the quantum algorithm. Shors quantum factorization algorithm is an example in which the unitary operator can be implemented eciently and leads to an overall complexity which exceeds that of the best openly-published classical alternative [15]. Unfortunately, it does not provably surpass the optimal classical lower bound because the status of factorization is unresolved in the open literature. Thus, at present, there is no quantum algorithm that demonstrates that quantum computing oers greater algorithmic power than classical.

4. DISCUSSION
That quantum parallelism oers a more powerful computational framework than the classical model is an assumption that goes beyond the implications of established quantum theory. Moreover, the validity of the assumption is far from intuitively obvious because it implies, for example, that 800 qubits are sucient to store and manipulate a number of states comparable to the number of bits stored in a grid of Planck-size cells covering the entire universe from the big bang to date at a rate of 1 bit per cell. With an improved understanding of the complexity to implement arbitrary quantum operators it is clear that to perform any calculations with such a grid would require a number of logic gates that would more than ll the universe. This suggests that quantum computational parallelism may be an illusory consequence of a failure to assess the full computational structure of unitary operators. If the foundations of quantum computing are indeed speculative as suggested in this paper, it is natural to consider how so many researchers could be mistaken into thinking that quantum parallelism is established theory. This is of course a sociological question, but we can suggest the following possibilities: 1. When an operator is applied to a superposition of states, the eect is equivalent to the application of the operator to each of the states in parallel, and this is all that is necessary to establish the correctness of quantum algorithms such as Grovers. The mistake is in assuming that the eect of parallelism is the same as real computational parallelism. As has been discussed, it is entirely possible that the apparent computational savings obtained from the application of the operator to states in a superposition are always precisely balanced by the increased number of reversible gates required to implement the operator. 2. It is easy to mistake theoretical and empirical demonstrations of the correctness of quantum algorithms as somehow verifying the computational power of quantum parallelism. The fact is that the correctness of quantum algorithms is guaranteed by quantum theory, but this does not imply that they are more computationally ecient than classical alternatives. 3. It appears that many researchers accept the purported computational power of quantum parallelism as an established implication of quantum theory. In other words, they regard any questioning of the power of quantum parellelism as being equivalent to questioning the validity of quantum theory, which of course is not the case. Providing a quantum algorithm that unambiguously exploits quantum parallelism would of course settle all of the questions raised in this paper, but it must stand up under a rigorous complexity analysis with an equity of assumptions. Until such an algorithm is produced, any claim regarding the reality of quantum parallelism must be regarded as purely speculative. This is a very dierent state of aairs to that recognized by most researchers in the eld, and it raises questions about whether quantum computing has evolved into a pathological science. Specically, if its basic premise is false, the future of the eld will be urries of activity pursuing one deadend after another indenitely. This possibility has serious public policy implications because of the amount of resources (both research and experimental) that have been diverted toward quantum parallelism and away from a more focused quantum-level instantiation of the classical model. It could be argued that research relating to the implementation of quantum parallelism-based architectures has direct relevance to the implementation of quantum circuits for performing classical computations. However, this is not at all clear from either an algorithmic or hardware perspective. For example, computer science and

Proc. of SPIE Vol. 6976 69760W-4

physics departments around the world are now oering courses on quantum algorithms, and it is dicult to see how the time and resource expenditures for such courses are salvaged if quantum parallelism is a ction. The same is true for industry and government-supported research into quantum algorithmics. On the hardware side, the problem of maintaining a large number of entangled states to support quantum parallelism addresses a very dierent set of practical issues than mitigating the eects of unwanted entanglement when implementing classical bit operations on quantum-size components. In summary, the reality of quantum computational parallelism is far from established, and the objective of this paper is simply to highlight this fact. This situation is analogous to that of cold fusion (and other speculative research areas) in that existing theory does not preclude the possibility of a room-temperature fusion apparatus, but that fact doesnt imply that such an apparatus is actually possible and therefore worthy of condent pursuit. On the other hand, a cold fusion apparatus or an incontrovertible example of quantum parallelism could be announced tomorrow with a similar impact as the announcement in 1986 of a high-temperature superconducting material.

APPENDIX
As discussed in the main text, the computational power of quantum computing appears to stem from its ability to perform parallel operations on an exponentially large dataset. One would hope that such inherent parallelism would reduce the complexity count of the number of gates necessary to implement arbitrary computations compared to classical solutions. Unfortunately, this does not appear to be the case. Let us rst consider the classical model. In his celebrated 1949 paper, Claude Shannon revealed that the computation of most Boolean functions require circuits of exponential size [2]. Consider F an arbitrary, n-variable Boolean function: F : {0, 1}n {0, 1} (5) The truth table that describes the behavior of F has 2n rows, and a direct circuit implementation of this function may require signicantly less than 2n gates; however, the Boolean functions used most commonly have small classical circuits of linear size. In fact, it is observed (and conjectured as a general result) that all problems that can be decided in O(2n ) time may be decided by a family of linear-size classical circuits [3,5] . By contrast, a basis of quantum circuts for unitary transformations has uncountably many gates. Di Vincenzo showed in 1994 that the set of all quantum gates operating on 2 bits forms a universal set of gates [6]. Further analysis determined that the number of 2-bit gates necessary to implement an arbitrary quantum operation is O(n3 4n ) [7]. A tighter bound was determined to be O(n4n ) [8], which was subsequently improved to O(4n ) [14]. These improvements do not aect the exponential complexity, and O(4n ) appears to be the optimal bound. Grovers Algorithm Explicit circuit constructions have been found for small numbers of qubits. For example, Bullock and Markov have shown that an arbitrary 2-qubit computation can be achieved with 23 elementary gates (this implementation minimizes the number of multi-qubit interactions, using single qubit rotations and at most 2 CNOT operations) [9]. And within the context of Grovers algorithm, it has been shown that the reversible circuit implementation of an n-qubit quantum oracle comparing a key of length n requires (2n ) quantum gates [4]. Because key comparison is the simplest operation that distinguishes a unique solution, this result implies that Grovers algorithm must use an exponential (in n) number of gates to achieve its claimed time complexity. What is important to note is that a classical algorithm can perform a key comparison in O(n) time simply by comparing each of the n bits. This means that if we were to apply 2n /n classical comparisons in parallel to the 2n states in the dataset, the solution would be found in O(n) time, which is exponentially faster than Grovers O(2n/2 ) complexity. In terms of the number of states N = 2n , if the same number of logic gates is used by Grovers algorithm and by the classical solution, Grovers algorithm has O(N 1/2 ) sequential time complexity and

It turns out that no provably superlinear example has ever even been found [3].

Proc. of SPIE Vol. 6976 69760W-5

the classical solution has O(log(N )) complexity. The critical observation that can be made is that this general algorithmic technique can be applied for any arbitrary oracle, and it can be concluded based on the results discussed above that there can be no case in which Grovers algorithm yields a better complexity . A question that remains is whether Grovers algorithm (or any other quantum algorithm) can achieve a complexity advantage from a time/space complexity tradeo. More specically, changing the available number of gates aects the time complexity for both the quantum and classical algorithms, so it may be possible that there is a number of gates for which the complexity of the quantum algorithm is superior to that of the classical algorithm. This would require an exponential reduction in gates with only a sublinear increase in the time complexity of Grovers algorithm, but the analyses of time/space tradeos for reversible computation by Vitanyi [10] and Franck [11] show that this is not possible. Approximate Circuits The exponentially large circuit complexity needed for the exact representation of an arbitrary unitary operator has motivated the consideration of approximate decompositions of arbitrary unitary operators using a nite set of elementary gates. A unitary operator Ut is dened that approximates a unitary operator U with precision if the following inequality is satised [13]: ||Ut U || (6) where the operator norm is dened as: ||X|| = sup and ||| || = as usual. In this case, invoking the Solovay-Kitaev Theorem, it can be shown that an m-gate quantum circuit made of CNOT gates and 1-qubit gates can be realized with a circuit of size O(m logc (m/)) exclusively using only Hadamard, phase, CNOT, and /8 gates [12]. Also, using a similar nite set of quantum gates, an arbitrary unitary operation in n-qubits can be accomplished with (2n log(1/)/ log(n)) elementary gates [12]. While these approaches are successful in the reduction of the number of gates in the universal set, which is extremely important for the physical realization of quantum computers and architectures, they still imply exponentially large circuits. Beyond the exponential preprocessing and space complexity issues, SK approximations lead to errors which accumulate linearly. Thus, if i is the error for the approximation of operator Ui , then the overall error after a concatenation of k approximate operators is:
k

||X| || ||| || ( | )

(7)

(8)

=
i=1

i kmax

(9)

where max = max{i }. However, the error of the approximation has to be an incredibly small number. Indeed, if an n-qubit register holds a uniform superposition, then the corresponding density matrix is described by terms of order O(1/2n ). In this case, the error in the approximation of the unitary operator has to be max << O(1/2n ). This means that errors will dominate the result of a quantum computation that runs for (2n ) iterations. While this does not apply to all quantum algorithms (e.g., Grovers), it precludes quantum solutions for any hard classical problems. In summary, the founding assumption of quantum computing is that it is possible to apply an O(n) operator in parallel to 2n states in a superposition contained in an n-qubit register to achieve an O(2n ) reduction in
The same analysis holds for the case in which the quantum register stores a superposition of indices which reference keys in an external dataset. In fact, just the O(2n ) parallel gates required by Grovers algorithm to reference the external array are sucient for the classical algorithm to achieve its complexity bound.

Proc. of SPIE Vol. 6976 69760W-6

time complexity. However, the necessary preprocessing can be expected to take between O(2n ) and O(4n ) time depending on the stucture of the operator, and this is sucient to precompute all of the 2n outputs for the 2n possible input states of the n qubits. Once this is done the issue of quantum parallelism is superuous. It is possible to show that there is a small class of unitary operators that have special structures which admit very small circuits (e.g., as in the case of Shors algorithm [15]), but it is also possible that those cases correspond to problems which admit ecient classical solutions as well. At present there are no general statements that can be made in this regard.

REFERENCES
[1] A. Shamir, Factoring Numbers in O(Log(n)) Arithmetic Steps, Information Processing Letters, Volume 8, Number 1, January 1979. [2] C. Shannon, The Synthesis of two-terminal switching circuits, Bell Systems Technical Journal, 28(1):59-98, 1949. [3] V. Kabanets and JY Cai, Circuit Minimization Problem, Proceedings of the thirty-second annual ACM symposium on Theory of computing, ACM, 2000. [4] V. Shende, A. Prasad, I.L. Markov, and J.P. Hayes, Synthesis of Reversible Logic Circuits, IEEE Transactions on CAD, 2003. [5] Mil Mascaras, personal communications with the authors, 2002. [6] D. Di Vincenzo, Two-bit gates are universal for quantum computation, Phys. Rev. A, 51:1015-1022, 1995. [7] A. Barenco, C.H. Bennett, R. Cleve, D.P. DiVincenzo, N. Margolus, P. Shor, T. Sleator, J. Smolin, and H. Weinfurter, Elementary Gates for Quantum Computation, Phys. Rev. A, 52, 3457, 1995. [8] E. Knill, Approximation by Quantum Circuits, LANL Report LAUR-95-2225, 1995. [9] S. Bullock and I Markov, An Arbitrary Two Qubit Computation in 23 Elementary Gates, Phys. Rev. A, 68(2003), no. 1, July 2003. [10] Paul M. B. Vitanyi, Time, space, and energy in reversible computing, Conf. Computing Frontiers, 435-444, 2005. [11] M. P. Franck (Florida State University), personal communication with the authors, 2007. [12] M. A. Nielsen and I L Chuang, Quantum Computation and Quantum Information, Cambridge University Press, 2000. [13] A Yu Kitaev, A H Shen, M N Vyalyi, Classical and Quantum Computation, American Mathematical Society, 1999. [14] J.J. Vartiainen, M. Mottonen, and M. M. Salomaa, Ecient Decomposition of Quantum Gates, Phys. Rev. A, 92, 177902, 2004. [15] St. Beauregard, Circuit for Shors algorithm using 2n+3 qubits, Quantum Information and Computation, 3(2), 175 (2003). [16] Richard J. Lipton,Some Consequences of Our Failure to Prove Non-Linear Lower Bounds on Explicit Functions, Proceedings of the Structure in Complexity Theory Conference,79-87, 1994. [17] Scott Aaronson, Oracles Are Subtle But Not Malicious, Proceedings of IEEE Complexity, 2006.

Proc. of SPIE Vol. 6976 69760W-7