Quantum AlgorithmsbyDaniel S. AbramsB.S., Stanford University (1994)Submitted to the Department of Physicsin partial fulfillment of the requirements for the degree ofDoctor of Philosophyat theMASSACHUSETTS INSTITUTE OF TECHNOLOGYJune 1999@ Copyright Daniel S. Abrams. All rights reserved.The author hereby grants toto distribute copiesSignature of Author ............Certified by .............................Certified by .............................Massachusetts Institute of Technology permission toreproduce andof this thesis document in whole or in part.. ......................... .L .. ..........Department of PhysicsI / / 29 April 1999/ '\\1tA LloydAssociate Professor of Mechanical gineering__--hesis Supervisor4. D. JoannopoulosFrancis Wright Davis Professor of PhysicsThesis SupervisorI - .Accepted by..............................., ....... ...... .... .......hom reytakProfessor of Physics and Associate Dep ent HeadMASSACHUSETTS INSTITTLIBRARIESQuantum AlgorithmsbyDaniel S. AbramsSubmitted to the Department of Physicson 29 April 1999, in partial fulfillment of therequirements for the degree ofDoctor of PhilosophyAbstractThis thesis describes several new quantum algorithms. These include a polynomial time al-gorithm that uses a quantum fast Fourier transform to find eigenvalues and eigenvectors of aHamiltonian operator, and that can be applied in cases (commonly found in ab initio physicsand chemistry problems) for which all known classical algorithms require exponential time. Fastalgorithms for simulating many body Fermi systems are also provided in both first and secondquantized descriptions. An efficient quantum algorithm for anti-symmetrization is given as wellas a detailed discussion of a simulation of the Hubbard model.In addition, quantum algorithms that calculate numerical integrals and various character-istics of stochastic processes are described. Two techniques are given, both of which obtain anexponential speed increase in comparison to the fastest known classical deterministic algorithmsand a quadratic speed increase in comparison to classical Monte Carlo (probabilistic) methods.I derive a simpler and slightly faster version of Grover's mean algorithm, show how to applyquantum counting to the problem, develop some variations of these algorithms, and show howboth (apparently distinct) approaches can be understood from the same unified framework.Finally, the relationship between physics and computation is explored in some more depth,and it is shown that computational complexity theory depends very sensitively on physicallaws. In particular, it is shown that nonlinear quantum mechanics allows for the polynomialtime solution of NP-complete and #P oracle problems. Using the Weinberg model as a simpleexample, the explicit construction of the necessary gates is derived from the underlying physics.Nonlinear quantum algorithms are also presented using Polchinski type nonlinearities which donot allow for superluminal communication.Thesis Supervisor: Seth LloydTitle: Associate Professor of Mechanical EngineeringThesis Supervisor: J. D. JoannopoulosTitle: Francis Wright Davis Professor of Physics2Contents1 Introduction1.1 M otivation . . . . . . . . . . . . . . . . . . . . . . . .1.2 An introduction to the theory of computing machines1.3 Classical gate arrays . . . . . . . . . . . . . . . . . . .1.4 Physics of classical computation . . . . . . . . . . . . .2 Quantum Computers2.1 Quantum bits ................2.2 Quantum gate arrays ..........2.3 Universality .................2.4 Introduction to quantum algorithms2.5 Simon and Shor algorithms . . . . .2.6 Accuracy and errors . . . . . . . . .2.7 Potential implementations . . . . . .7. . . . . . . . . . . . . . . 7. . . . . . . . . . . . . . . 10. . . . . . . . . . . . . . . 16. . . . . . . . . . . . . . . 1823. . . . . . . . . . . . . . . . . . . . . . . . . 2 3. . . . . . . . . . . . . . . . . . . . . . . . . 2 5. . . . . . . . . . . . . . . . . . . . . . . . . 2 7. . . . . . . . . . . . . . . . . . . . . . . . . 2 9. . . . . . . . . . . . . . . . . . . . . . . . . 3 3. . . . . . . . . . . . . . . . . . . . . . . . . 3 5. . . . . . . . . . . . . . . . . . . . . . . . . 3 83 Quantum Quantum Simulators3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . .3.2 The fermion problem and the Hubbard model . . . .3.2.1 Description of the system . . . . . . . . . . .3.2.2 Fermions in the second quantized formalism3.2.3 Fermions in the first quantized formalism .3.2.4 Reading the final state . . . . . . . . . . . . .3.3 Finding eigenvalues and eigenvectors . . . . . . . . .41. . . . . . . . . . . . . . . . 41. . . . . . . . . . . . . . . . 44. . . . . . . . . . . . . . . . 44. . . . . . . . . . . . . . . . 45. . . . . . . . . . . . . . . . 47. . . . . . . . . . . . . . . . 52. . . . . . . . . . . . . . . . 5333.3.1 Statement of the problem . . . . . . . . . . . . .3.3.2 Eigenvalues and eigenvectors via quantum FFT .3.3.3 Applying the algorithm . . . . . . . . . . . . . .3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . .4 Integrals and Stochastic Processes4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . .4.2 Statement of the problem and classical algorithms . . .4.3 Review of Grover searching . . . . . . . . . . . . . . . .4.4 Integrals via amplitude amplification . . . . . . . . . . .4.5 Integrals via quantum counting . . . . . . . . . . . . . .4.6 D iscussion . . . . . . . . . . . . . . . . . . . . . . . . . .4.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . .5 Nonlinear Quantum Mechanics and NP-complete5.1 Introduction ......................5.2 First method .........................5.3 An explicit construction using the Weinberg model5.4 Second method .. . . . . . .. . .. . . . . . . . .5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . .Problems5354576162. . . . . . 63. . . . . . 64. . . . . . 66. . . . . . 67. . . . . . 71. . . . . . 72. . . . . . 74767678838688411. 'AcknowledgmentsI thank first and foremost my thesis advisor, Professor Seth Lloyd, who has been both asource of inspiration and a source of ideas, who taught me many important and little knownconcepts (related to quantum computing), who sent me to conferences across the country andaround the globe and who introduced me to the leading members of the community, who wasan understanding and astute co-author, who provided a constant stream of advice and insight,and (perhaps most of all) who was an all-around great guy.I also thank my co-supervisor, Professor John D. Joannopoulos, who not only taught meabout condensed matter physics, the theory of PBGs, and the art of scientific computing, butwho taught me how to be a professional scientist. I thank him also for allowing me the freedomto pursue my intellectual curiosity where it led (quantum computing), for providing me withsupport and office space and a place to call home within the department (and a place to callhome on Thanksgiving), and for many good laughs and much good advice.I thank Professor Robert B. Laughlin (my undergraduate thesis advisor) for teaching mehow to think about physics, for sharing countless hours with me, for continuing to keep aneye on me and an eye out for me (all the way from the other coast), and for the dispensing ofwisdom; in short, for being a mentor and a friend.I thank Professor Douglas D. Osheroff for inspiration when I was an impressionable Stanfordfreshman and throughout my undergraduate years; without his influence, I might not havedevoted myself to the study of physics.Many members of the general quantum computing community have collectively taught mea great deal, through various conversations, some shorter and some longer. These includeLeonard Adleman, Wim Van Dam, Jon Dowling, Chris Fuchs, Daniel Gottesman, RichardJozsa, Andrew Landahl, Norm Margolus, John Preskill, Peter Shor, Mike Sipser. I am surethere are others that I have forgotten, but I am no less appreciative.I thank all the professors and teachers I've had over the years for providing me with thenecessary knowledge and for the inspiration to study. These include D. Spooner, W. Dodge, G.Munley, R. Rhodes, R. Whipple, and W. Bauer. I'm particularly grateful to Professor PaulCohen.I thank Colin Williams, with whom I collaborated on the work discussed in Chapter 4, and5who provided on multiple occasions the opportunity to visit NASA-JPL and the CaliforniaInstitute of Technology.I thank Wati Taylor, who, one day after a colloquium in building 12, introduced me to thefield of quantum computation. I also thank Professor Charlie Marcus for advice in my careerand otherwise.I thank my (non-physicist) friends for putting up with me, entertaining me, supporting me,distracting me, etc. I am especially grateful to count among them Barry, Bob, Daniel, andKelly, Jordan and Laura, Mike and Adelle and Mike, Gary and Maria, Lisa, Viviana, Brian,Judd, Alex and B., Roberto, and Charlie. I also thank those friends of mine who may not behere in Boston but who have been there for me nonetheless.I thank all the members of the group for their friendship and advice, but particularly Nikolaj,Attila, Pierre, Shanhui, Kyeongjae, Rodrigo, Ickjin, Steven, and Tairan.I thank also my friends on the CMT corridor, especially Dicle, Alkan, Sohrab, Claudio,Steve Simon, and Professor Tomas Arias.I thank our department secretary Margaret O'Meara, and Peggy and Pat in the physicsoffice, all of whom were always helpful and friendly.I thank Ray Hagstrom for sharing with me the magic of physics when I was young.I'd like to acknowledge several individuals with whom I have had helpful conversationsdirectly related to the work contained in this thesis. These include I. Singer, C. Froese Fisher,W. R. Johnson, J. Jacobson, S. Simon, T. Arias, S. Johnson, I. Park, and T. Wang.Almost last, but certainly not least, I thank my family, and especially my parents, for somuch that there would be no place to begin and no space to finish.Finally: This thesis would not have been possible without funding from several sources.These include an NDSEG graduate fellowship; grant # N00014-95-1-0975 from the Office ofNaval Research; the ARO and DARPA under grant # DAAH04-96-1-0386 to QUIC, the Quan-tum Information and Computation initiative; a DARPA grant to NMRQC, the Nuclear Mag-netic Resonance Quantum Computing initiative; the NASA/JPL Center for Integrated SpaceMicrosystems; and, the JPL Information and Computing Technologies Research Section.6Chapter 1Introduction1.1 MotivationIt is often difficult to see the hidden assumptions on which the foundations of science arebuilt. The 2 0 th century has witnessed at least two revolutions in physics, and in both of theserevolutions not only were new laws discovered, but prior assumptions were found to be false.Ideas that were previously unquestioned were revealed to be mere approximations.The field of computer science has for the greater part of this century been based upon theideas of classical physics. In fact, the theory of quantum computing has flourished only inthe last few years. In retrospect, this may seem to be hopelessly naive - and, perhaps, tothe physicist who has grown accustomed to dealing mostly with quantum mechanics and onlyoccasionally with classical mechanics - this may appear to be somewhat surprising. The worldis properly described by quantum mechanics; since computers are physical devices that existin the world, surely they too must be properly described by quantum mechanics. The logic isobvious and compelling.However, it is not so clear how a quantum mechanical computer would operate, or even howcomputation is supported by quantum mechanics'. Moreover, it is not at all obvious, a priori,'Indeed, were it not for the fact that the existance of computers in the real world implies that it must7that a quantum mechanical computer should have any advantage over a classical computer. Itis perhaps for some of these reasons that the theory of quantum computing took a long time todevelop. Another explanation may be that theoretical computer science is an abstract discipline,dealing with Turing machines and automata, proofs and lemmas, and mathematical models thatare far removed from the actual physical reality of computing machines. Stated differently, onemight say that the theory of computer science is a subject that has been traditionally muchcloser to mathematics than physics, and the assumption that information is classical was hiddenin the abstractions.Whatever the reason may be, one fact is now clear: the introduction of quantum physicsto computer science changes fundamentally the foundations of the subject. Computers are notclassical devices.Often, in conferences and review articles and other such places, the subject of quantumcomputing is motivated by the argument that transistors are becoming smaller and smaller,that pretty soon quantum effects will start to cause limitations on our ability to design fasterchips, and that one should therefore study the quantum mechanics of computing. While thistype of argument may have been a historical motivation, it is today so far from the point that itpractically misleads. While it is surely important to investigate the quantum mechanics of smallclassical components, the subject of quantum computing is not merely an investigation into thepossibility of smaller and faster computers. It is a new formalism for the theory of computerscience. And just as in the case of mechanics, the classical theory is left as an approximationto be used in those special cases where it may be appropriate.My own interest in quantum computing, like that of many others, came as a result of PeterShor's now famous 1994 discovery of a quantum polynomial-time factoring algorithm[86]. Thisresult publicized the idea that a quantum computer might be fundamentally more powerfulthan a classical computer. It indicated that a quantum computer would be useful - that itbe possible to compute with quantum mechanics on some level, it would not even be obvious, a priori, ifquantum mechanics should allow for the possibility of computing. Proof by existance is vastly different from anunderstanding of computation on a detailed, microscopic level.8might possess capabilities that no classical computer could.2 It also left open two importantquestions:1. How might one build a quantum computer?2. What can one do with a quantum computer other than factor large integers?This thesis attacks the second of these questions. In particular, it asks: What can a physicistdo with a quantum computer? It also explores the relationship between physics and compu-tation in some more depth, and in particular, looks at how computational complexity theorydepends very sensitively on physical laws.The remainder of the thesis is organized as follows: The first two chapters constitute a reviewof computation and the physics of computation. Theoretical computer science and classicalcomputation will be discussed in this first chapter, and quantum computing will be discussed inthe second. While these two chapters provide the necessary background for the remainder of thethesis, the reader who is familiar with these topics may freely pass them over. In the final threechapters, I present new results. Chapter 3 discusses the use of quantum computers for physicssimulations and ab initio calculations. I describe polynomial time quantum algorithms forfinding eigenvalues and eigenvectors of a Hamiltonian operator, for simulating many body Fermisystems in general and the Hubbard model in particular, and for antisymmetrizing the state ofthe computer. Chapter 4 describes how one can obtain a quantum speed-up when calculatingintegrals. I derive a simpler and slightly faster version of Grover's mean algorithm, show how toapply quantum counting to the problem, develop some variations of these algorithms, and showhow both (apparently distinct) approaches can be understood from the same unified framework.Finally, in Chapter 5, I'll show how the power of quantum computers depends very sensitivelyon the underlying physical model - and in particular, that if the physics of the universe wereonly slightly different than we think it is (and it might be!), then quantum computers wouldbe unbelievably powerful.2For the reader who is unfamiliar with public key cryptosystems, it is important to be aware that the securityof RSA [84], one of the world's most common methods for encrypting communications, depends upon the difficultyof factoring large numbers. A real life quantum computer, therefore, would render most secret codes obsolete.(Moreover, there is some indication that quantum computers would render all public key systems obsolete). Thisapplication has been one reason that quantum computing has attracted wide-spread attention.91.2 An introduction to the theory of computing machinesIt is necessary to understand the classical theory of computing machines before one can examinethe quantum theory. Moreover, if one is to argue that quantum computers are truly morepowerful than classical computers, then it will be necessary to be somewhat precise about theclassical theory. This section is thus intended as a physicist's introduction to computer science(or at least, those aspects of computer science which are relevant to the work in this thesis).Since physicists have widely disparate levels of familiarity with computer science, it is writtento be self-contained, with little or no prior knowledge assumed.3The first significant work in theoretical computer science took place in the early part of thiscentury. Gdel, Turing, Church, Post, Kleene and others were interested in the study of whatwas computable, in principle. Now it would seem that in order to address this question, onewould have to specify the precise capabilities of the computer involved. However, it turns outthat if you consider machines with a certain minimum computing capability, then all models ofcomputation are equally powerful (in the sense of computability). This idea was formalized in1936 by Church and Turing and is known as the Church- Turing thesis:Any computing device can be simulated by a Turing machine.This is an important idea, because it means that we need not study every possible type ofcomputing machine - we need only study the model invented by Alan Turing. If something iscomputable (in principle), it is computable on a Turing machine. Note that the Church-Turingthesis is a thesis and not a theorem. In order to prove this conjecture, one would have hadto define precisely a model for computing devices. But the whole point of the thesis is that itapplies to any computing device, and so we don't want to limit ourselves by specifying exactlywhat a computing machine must be. Nevertheless, the hypothesis is fairly self-obvious and in63 years, no one has ever conceived of a counter-example. Moreover, there are many models of3The material in this section and the remainder of this chapter, unless explicitly referenced, is part of thecommon knowledge. The interested reader may find good sources of further information in the following: Sipser[89], Feynman[48], Preskill[83], Shor [87], Benioff[15], Ekert and Jozsa[44], and Garey and Johnson[52].10computation which have been proven to be Turing-equivalent, including those of Church, Post,Von Neumann, and others. So it pays to examine a Turing machine more closely.A Turing machine consists of a head, which can be in one of a finite set of states Q, and atape, which extends infinitely in both directions, and on which the head can read or write a setof symbols or characters from an alphabet A. 4 The head is always pointing to one particularcharacter on the tape, and can move left or right one step at a time, to the previous or nextsymbol on the tape. Finally, there is a rule which tells the computer what to do at each step,based upon the state of the head and the symbol to which it is currently pointing. This rule isa function g of the formg: Q x A ==> Q x A x {L,R} (1.1)That is, it maps a state of the head and symbol on the tape into a new state of the head, anew symbol on the tape, and an instruction to move to the left or to the right. This functiontherefore determines the behavior of the computer. Of course, the computer must begin withthe head in an initial state and with an initial finite input string of symbols on the tape. Bychoosing various sets Q and A, various functions g, and the initial conditions, one can make aTuring machine compute whatever one desires (as long as it is computable in principle).There are two important results pertaining to Turing machines that we shall consider. Thefirst is that there exists what is known as a universal Turing machine. A universal Turingmachine is one which has the capability of simulating the behavior of any other Turing machine(and therefore any other computing machine in general), simply by modifying the initial inputconfiguration of the tape. That is, the function g (and hence the set of states Q and alphabetA ) is to remain fixed. Moreover, what is perhaps more remarkable than the existence of auniversal Turing machine is that it need not be very complicated: roughly 10 or 20 states and10 or 20 symbols will suffice. 54Actually, what I've described here is only one example of a Turing machine. There are many variations ofTuring machines (for example, there can be multiple tapes), but they're all equivalent, so it doesn't matter whichone you choose.5 The exact number depends on how the machine is designed. Actually, two states will suffice if there aremany symbols, and vice versa.11The second result of interest is that there are certain problems which cannot be solved ona Turing machine, and are therefore uncomputable. The most famous example is called thehalting problem[93]. Normally, there is a special state of the head Qf which is the final, orhalting state. Once the head reaches this state, the computer stops. The question is this: givena description of a Turing machine and the initial input on the tape, can you determine if themachine will ever halt? It turns out in general that you cannot. (More precisely, you cannotbuild a computer which can solve the halting problem). The proof is simple and runs as follows:Imagine a Turing machine H that solves the halting problem such that when given as input adescription D of another Turing machine (and its input), H will halt if D does not halt, and Hwill go into an infinite loop if D does halt. Now what happens if you provide H as input to H?The machine can neither halt nor not halt: hence, one must conclude that it is not possible todesign H in the first place. The halting problem is therefore undecidable.One sees therefore that the Turing machine is a very useful concept: by analyzing Turingmachines, one can (attempt to) determine what is in principle computable and what can neverbe computed. However, in real life, one is generally interested in more than whether or notsomething can be computed in theory: one wishes to know how long it will take, how much itwill cost, etc. It may be possible, in theory, to perform an ab initio simulation of each and everyparticle in my brain - but it is hard to imagine that it will ever be possible in practice. Hence,as real life computers became more and more prevalent, the theory of computer science becamemore concerned with how long a computation would take. One thus arrives at a modified formof the Church-Turing thesis:Church- Turing thesis (Strong Form): Any reasonable computing device can be simulatedby a Turing machine in a number of steps which grows as a polynomial function of the resourcesused by the device.Like the Church-Turing thesis in its weaker form, the strong form cannot be proven. (Al-though it has been proven for just about any specific classical model of computation that one canimagine). The statement is deliberately vague, with words such as "reasonable" and "resources"that are open to interpretation. Still, it is clear when a computer is and when a computer isnot reasonable. Unreasonable machines would include those that perform an infinite number12of steps in a finite time (for example, the Zeno's paradox inspired device that performs eachsuccessive operation in half the time of the previous operation), or machines that require infi-nite precision (for example, by storing an arbitrarily precise real number in the frequency of asingle photon). Similarly, it is clear in practice what one should count as a resource. Certainlytime and memory space are resources; precision or power may also be. The important point toremember, especially when one examines non-traditional computing devices (such as quantumcomputers), is that one must be careful to consider all the resources involved.Essentially, the strong form of the Church-Turing thesis says that all computing devicesare polynomially equivalent. This is important because it naturally divides problems intotwo classes: those that can be solved in polynomial time, and those that cannot. (A precisedefinition of polynomial time will be furnished below). If you provide an algorithm that runs inpolynomial time on any one particular computer, then this algorithm can be run in polynomialtime on every computer. Likewise, a problem that requires an exponential number of steps onany particular computer will require exponential steps on every computer.6This division between polynomial and exponential problems is also convenient because itcorresponds intuitively with our notion of efficient and inefficient algorithms. An algorithm thatrequires 0(n) operations is certainly faster than one that requires 0(n3 ), but both scale quitemodestly compared to an algorithm requiring 0(2n) operations. In the later case, one does notneed very large n before the problem becomes impossible in reality, even if it is computable intheory. 7 Polynomial-time algorithms are therefore considered tractable; exponential algorithmsare considered intractable.For both of these reasons, one is frequently concerned with distinguishing polynomial-time6It's worth noting that one experiences these theoretical distinctions in real life. For example, by describingan algorithm as 0(n2), I have already ignored the constant speed difference (between, for example, my Pentium90Mhz and my Pentium 400Mhz). Moreover, it may be that on the Cray C90, which can process a whole vectorof numbers at a single time, this algorithm may not only run faster, it may scale more like 0(n), as opposed to0(n2 ) (at least for n within a certain range - and all real computers with finite memory always have a limitedrange). But no reasonable computer will require exponential time for this problem.7John Preskill calculates that factoring a 400 digit number would take 1010 years (roughly the age of theuniverse) using the best known classical algorithm on state of the art computers, which can factor a 130 digitnumber in about one month (using hundreds of workstations). On the other hand, if we had a quantum computerthat could factor a 130 digit number in one month, it could factor the 400 digit number in a few years - about1010 times faster!13algorithms from those that require exponential time8 . Hence, one must have a precise way ofclassifying algorithms. We say that a problem can be solved with 0(f(n)) operations if, inthe limit of large n, the required number of steps is bounded by c * f(n), where c is a fixedconstant, and n is the length of the input string. Since it is not very useful to describe an0(n) algorithm as 0(2"), we normally try to find the smallest f(n) which the required numberof steps will approach asymptotically. Note, however, that as this definition depends uponthe length of the input, the computational complexity appears to depend upon the manner inwhich the input string is written. We must therefore add an additional constraint, that theinput must be reasonably compact. For example, one can easily factor a number N in roughly0(V77) operations - but because one would normally write down N with only n = log Ndigits, this algorithm is actually exponential in the size of the input. One could specify theinput to the problem so that it required a string of length N instead of length n (for example,by indicating the value with a string of N zeroes followed by a single one), in which case a lineartime algorithm would be straightforward. However, this would not be considered reasonable.The set of all problems whose complexity is asymptotically bounded by a polynomial func-tion is called P. Curiously, while there are many problems known to be in P, there are hardlyany decidable problems which are known not to be in P. This is because it is very difficult toprove that a problem cannot be solved in polynomial time. Thus one is forced to make suchstatements as "there is no known classical algorithm for factoring in polynomial time". Thisis also why it is difficult to prove that a quantum computer is more powerful than a classicalcomputer. Although we know a polynomial time quantum algorithm for factoring, and eventhough the problem is thought not to be in P, there may in fact be a polynomial time classicalalgorithm that no one as yet has been clever enough to discover.A broader class of problems, which contains many well-known problems that are thoughtto be exponential, is called NP. The phrase NP stands for "non-deterministic polynomial" andmeans (strangely enough) that such problems can be solved in polynomial time on a non-deterministic Turing machine. Not surprisingly, a non-deterministic Turing machine is not8 0f course, a problem can be worse than polynomial but better than exponential, e.g., nl*g". However, itseems that most problems are not in this intermediate range - and those that are, are usually (perhaps toocasually) referred to as "exponential" even when they are not.14a "reasonable" model of computation, as discussed above: it is a mathematical model, withconvenient properties. Essentially, it is an ordinary Turing machine which, at each step, canbranch into multiple states at the same time. Pretty soon, there are an exponential numberof Turing machines following an exponential (and rapidly growing) number of paths. It is saidto solve the problem if only one single path finds a solution. Clearly, one would expect thatan ordinary Turing machine (or any "reasonable" computer) would required an exponentialnumber of operations to perform the same computation.One can show that there is an equivalent (but less precise) definition of the class NP whichis the following: The class NP is the set of problems for which it is possible to verify a potentialsolution in polynomial time. For example, the factoring problem is believed to be exponential- but once provided with potential factors, it is quite easy to multiply them and verify if theytruly are factors, in polynomial time. Factoring is therefore in the class NP. In fact, almost allhard (i.e., exponential) problems that occur in practice are in the class NP. (One importantexception is the class #P, to be discussed beow). Amazingly, there are no problems that areknown to be in NP and not in P. We therefore arrive at the great outstanding question oftheoretical computer science:Does P=NP?Of course, almost everyone believes that P 0 NP, but no one knows for sure.In 1971, Stephen Cook showed that a certain problem, the satisfiability problem, or SATproblem, is as hard as any problem in NP[32]. 9 More precisely, he showed that there is a poly-nomial time reduction from any problem in NP to SAT. Hence, if one could find a polynomialtime algorithm for SAT, one could solve any problem in NP in polynomial time. Moreover, ifthere exists just one problem in NP that requires exponential time, then SAT must as well. Forthis reason the SAT problem is called NP-complete. Later, in 1972, Karp showed [60] that many9There are various versions of the SAT problem, but the basic idea is the following: consider a booleanexpression made up of n variables; for example: (b1 or b2) and not ( b1 and b 3 or not b4 ). The question is, arethere a set of values for b1. . .bn such that the expression evaluates to true (i.e., is "satisfied"). It turns outthat, in the worst case, there is no known algorithm that improves upon merely trying all of the (exponentiallymany) possibilities.15other well known problems, such as the traveling salesman probleml1, are also NP-complete. Ahuge amount of work has been done on the theory of NP-completeness since Cook and Karp,and now hundreds of problems are known to be NP-complete[52]. A polynomial time solutionto any one of them would imply that P=NP (and a great deal of fame). Conversely, once aproblem is shown to be NP-complete, it is clear that a polynomial time solution is unlikelyto be found. Interestingly, it turns out that practically every naturally occurring problem inNP (and most naturally occurring problems are in NP) is either in P or is NP-complete. Theclass NPI (for NP intermediate) appears to be quite lonely. In fact, this author is aware ofonly three problems that are thought to be in NPI: integer factoring, graph isomorphism, andcertain versions of the short vector problem. This is unfortunate because problems in NPI aregood candidates for quantum algorithms: they are not as hard as NP-complete problems, butthey still (are thought to) require exponential time on a classical computer.Finally, there is one last class of problems which will be discussed here, known as #P.Problems in the class #P include those that ask for the exact number of solutions to an NPcomplete problem: for example, how many (of the n!) paths that visit each of n cities havelength less than I? It is self-evident that the class #P contains the class NP, and intuitively,it appears to be much larger. (But this is of course an open question). The class #P will beaddressed later in the context of nonlinear quantum algorithms.1.3 Classical gate arraysAlthough the theory of computational complexity is machine independent, it is often useful tohave a particular computational model in mind. This is especially true when considering thephysics of computation. For these purposes, the classical gate array (and later, quantum gatearray) is convenient.1 0The traveling salesman problem is the following: consider a salesman who must visit a set of cities, and wouldlike to do so in the most efficient manner. Given a list of cities (and their locations), find the shortest path whichvisits each of the cities. This is often cast in an alternative manner, as a decision problem, by asking if there isa path of length d or less (that visits all the cities).16Every computational problem can be viewed as a function that maps an input string (whichwe shall represent in binary) to an output string (which may also be represented in binary). Infact, one can consider each bit of the output string separately, so that a computer program canbe viewed quite generally as a function f which maps n bits into a single bit:f : B" ==> B (1.2)where B is the set of possible boolean values {0, 1}. A logic gate is just a simple computation;for example, the NOT gate is the function on a single bit such thatNOT(a) = a=1 (1.3)1; a = ITwo bit gates are just slightly more interesting; for exampleAND (a, b) 0; (a = 0) or (b = 0)(141; (a=1) and (b=1)Once we have a set of logic gates, we can begin to build more complicated computations bydesigning a gate array. In a gate array, we apply a sequence of logic gates, one after another,to the original input bits or to the outputs of the proceeding gates. For any given algorithm,the design of the gate array is fixed; we vary the input bits, the gates are applied in series, andthe result is obtained. Of course, if all of our gates return only a single bit, we will not be ableto build a very interesting (or very long) computation. So we will need some gates that returnmore than one value; for example, COPY (or FANOUT):COPY (a) = a 9 a (1.5)An important and natural question that arises is the following: is there a universal set of gates?In other words, is there a set of gates from which one can build any computation, as long asthe gates are applied correctly? In fact, the set of gates described above is a universal set: with17AND, NOT, and COPY, one can compute any function that is computable.11Since the gate array has been shown to satisfy the weak form of the Church-Turing thesis,one may ask if it satisfies the strong form. In this case, the relevant computational resource isthe number of gates. How does the number of gates scale with the length of the input? Oneneeds to be careful here, because any particular gate array is of a fixed size: if the length of theinput is increased, then a larger gate array will be required. But it may be that the designer ofthe gate array can perform some of the work required to solve the problem. Hence we requirethat the gate array is sufficiently regular - that is, that the gate array can be designed with apolynomial-time algorithm. With this restriction, it is possible to prove that gate arrays andTuring machines can simulate each other with only polynomial overhead. A polynomial timealgorithm requires a polynomial size gate array, and vice versa. Thus, one can prove that gatearrays satisfy the strong form of the Church-Turing thesis.1.4 Physics of classical computationAs has been emphasized throughout this thesis, computers are physical devices and must obeythe laws of physics. One is thus naturally driven to consider if there may be physical limitationsto the power of computing machines. This consideration appears to become more and moresubstantive as computers become smaller and faster. How long can Moore's law1 2 continue?Will quantum mechanics interfere with our ability to compute?If one looks again at the gates described in the previous section, an interesting and impor-tant observation can be made: the usual fundamental logic gates are irreversible. Given theoutput of an AND gate, for instance, it is impossible to determine what inputs were provided.Of course, the gate as described previously takes as input two bits and generates as output only"It is easy to see why these gates are universal. First, recall that a computation is just a function of the formf : Bn ==> B. The set of possible input strings is therefore divided into two classes: those that return true, andthose that return false. Thus, the computation returns false except for on a certain (enumerable) set of possibleinputs. With AND gates and NOT gates it is easy to determine if the input is any particular string. With ORgates, we can then determine if the input is a member of the set which should return true. While this techniqueis by no means efficient, it shows that the gates are universal."Named after Gordon Moore of Intel, it states that computers become twice as fast roughly every 18 months.18P.. 6 ,a single bit, so it obviously cannot be reversible. But even if the gate is modified to output twobits - that is, the output of the AND function and an additional output bit for the purposesof reversibility - it still cannot be made reversible. In the case of AND, there are three inputs- (0,0) , (0,1), and (1,0) - which all generate the same output (0) for the AND operation. Asingle additional output bit is therefore insufficient to make this gate reversible. Indeed, onewill find that this is the case for all of the standard logical operations.The irreversible nature of standard logic gates leads one to an important thermodynamicconsideration. Since the action of each logic gate must contract phase space (or, alternatively,decrease the system's entropy), there must be a corresponding entropy increase taking placeoutside the computer. This therefore leads one to the (incorrect) conclusion that each funda-mental computer operation requires one to do work.In 1961, Rolf Landauer clarified and corrected the previous statement[62]. What requiresenergy is not logical operations, but erasing information. One must do work equal to kB T In 2for each bit of information that is discarded. This is known as Landauer's principle. In theprevious example, a single bit is lost during the AND operation, and so the result is thesame (kBT In 2 heat generated). However, I'll show in a moment that it is possible to performreversible logic, in which case there is no fundamental energy limitation per gate. But itis worth noting that ordinary computers do not employ reversible logic, and that the limit ofkBT In 2 per operation could eventually pose problems. While even the tiniest and most efficientcomputers today are still many orders of magnitude from this limit, it should be obvious thatif the size of transistors continues to shrink at an exponential rate, it will not take long beforethermodynamic considerations will dominate. Eventually, computers will need to be made withreversible logic if they are to be made faster.13The next critical step came in 1973 when Charlie Bennett showed that all computationscan be carried out with reversible logic gates[16] [17] [18] [19]. The number of steps taken bythe reversible computer was a polynomial function of the number of irreversible operationsrequired, and, depending upon the model of computation used (i.e., one-tape Turing machine,13 If the current pace of progress continues, the fundamental limit of irreversible computation will be reachedin roughly 60-80 years.19multi-tape Turing machine, gate array, etc.), the overhead could be only a constant factor. Be-cause reversible classical computation is closely related to quantum computation, we'll examinereversible logic gates in more detail.First, note that the NOT gate is reversible, and that in general, a reversible gate must haveas many outputs as it has inputs. While AND and OR cannot be made into reversible 2-bitgates, the XOR gate can be cast in a reversible form:Input Output(0,0) (0,0)(0, 1) (0, 1) (1.6)(1,0) (1,1)(1,1) (1,0)Feynman calls this XOR gate a "controlled-NOT", because it flips the second bit if andonly if the first bit is 1. The controlled-NOT is a convenient gate, and one employed frequentlyin quantum computations. Unfortunately, it is not universal, i.e., the controlled-NOT is in-sufficient for building an arbitrary classical computation. In fact, one can prove that no set of(classical) two bit reversible gates is universal. Fortunately, one needs only a single 3-bit gatein order to perform universal reversible logic. Two famous examples of 3-bit gates that sufficeare the Fredkin and Toffoli gates [51]. The Fredkin gate has an additional curious property inthat the number of ones and zeros does not change between the input and the output. This wasuseful for Fredkin, who was interested in showing how one could build a universal computerwith a classical "billiard ball" model.The Fredkin gate can be thought of as a controlled exchange: if the first bit is 1, thenexchange the positions of the second and third bits. Otherwise, do nothing. The truth tableappears as follows:20Input Output(0,0,0) (0,0,0)(0,0,1) (0,0,1)(0,1,0) (0,1,0)(0,1,1) (0,1, 1) (1.7)(1,0,0) (1, 0, 0)(1,0,1) (1,1,0)(1,1,0) (1,0,1)(1, 1,1) (1, 1,1)If one is given a supply of fresh ones and zeroes, the Fredkin gate can be made to simulateany of the usual irreversible two bit gates. With this in mind, it is relatively easy to see how onecan replace ordinary irreversible logic gates with reversible gates such as the Fredkin gate. Ineach step of the computation, extra "garbage" bits are introduced. These bits are not requiredfor future steps, but only so that one can retrace the backward path, to satisfy the constraintof reversibility. However, it appears that the number of garbage bits will grow quite quickly(possibly, one for each step of the computation), and this led some early critics to suggest thatreversible computers were in some sense hiding entropy in the garbage bits. Fortunately, thereis a useful trick (due to Bennett) which prevents garbage build-up[19]. For any computablefunction f acting on a bit string T, one can always perform the following transformationreversibly:(T 0)=>(-P, f (V)) (1.8)The transformation is obviously reversible on a macroscopic scale: since the bit string Vis part of the output, one can easily reconstruct the input. The problem is, can one transforman ordinary irreversible algorithm for calculating f(V) into a reversible one such that it doesnot generate any extra garbage bits (as in the equation above). Bennett's trick is the following:follow the course of the original irreversible algorithm, generating garbage bits along the way,21& _ ,to maintain reversibility. Once the answer has been obtained, make a copy of the answer. (Thisis easily accomplished with a sequence of controlled-NOT gates). Then reverse all the stepswhich were used in the original calculation, thereby cleaning up the garbage. One is thus leftwith simply the original input ~.? and the copy of the answer f(-), as desired. This simpletrick is quite useful, and we shall employ it frequently (and variations thereof) in the design ofquantum algorithms.Because of the work of Bennett, Fredkin, and others, we have a detailed understanding ofhow to perform arbitrary computation using the fundamental principles of classical mechanics.It was therefore natural to investigate how computation is possible with quantum systems.Paul Benioff, in a series of important papers, first showed how to design quantum mechanicalmodels of computation[11] [12] [13] [14]. Feynman [47][46] also did important work in this area,as did Margolus [72] [73] [74]. They described how one could build Turing machines, gate arrays,and cellular automata, and showed that, with the proper Hamiltonian, the systems could bemade to time-evolve in such a way that a computation was performed. Feynman [46] wasthe first to speculate that a quantum computer might in principle be more powerful than aclassical computer: in particular, he thought that perhaps a quantum computer could be usedto efficiently simulate other quantum systems (a conjecture later proven by Lloyd [68]). Thusone arrives naturally at the topic of quantum computing, which will be discussed in the followingchapter.22Chapter 2Quantum Computers2.1 Quantum bits1 The fundamental unit of quantum information is the quantum bit, or qubit[85] 2 . Mathemati-cally, a qubit is simply a ray in a two-dimensional Hilbert space: it represents the quantum stateof a two state system, just as a classical bit represents the classical state of a two state system.Physically, a qubit may be stored in many different ways: for example, with a photon polar-ization, two states of an atom, or the spin of a particle. Whatever the actual physical systemmay be, we shall always write the two states as 10) and 1), thus indicating the correspondencebetween classical and quantum bits.The general state of a single qubit is 1b) = e 10) + 0 1); since Ia12 + 11312 = 1, and theabsolute phase is not physically observable, the general state is described by two real numbers.A classical bit, on the other hand, is described by (simply) a classical bit. Even an analog or"fuzzy" bit requires only a single real number for its description. Still, it is not apparent howmuch of the information in the qubit is truly "available", and even with a single quantum bitone can see that the question of how one "gets the information out" is not trivial. Given many'As with the previous chapter, the material covered herein, unless explicitly referenced, is part of the commonknowledge. The interested reader may find good sources of further information in the following: Sipser[89],Feynman[48], Preskill[83], Shor[87], Benioff[15], Ekert and Jozsa[44], and Garey and Johnson[52].2 Like the word "bit", the word "qubit" is used to refer both to an amount of information and to the physicalsystem that registers that information.23copies of the state [0), one can make a series of measurements to determine (or approximate)a and 3. However, with a single preparation, information will be lost during the measurementprocess. One might be tempted to think that by being sufficiently clever one could take a singlepreparation of 1b) and make multiple copies, but this is not possible. There is a theorem due toWooters and Zurek [100] which says that one cannot copy a quantum state (the "no-cloning"theorem).The situation becomes more interesting when one has multiple qubits. While a single two-state system is described by a wavefunction of the form 1b) = a 10) +,3 11), a pair of two-statesystems is described by a ray in the tensor product space:I'') = aoo 0) 9 10) + ao 10) 911) + aio 11) 0 10) + ai 11) 11) (2.1)Whereas two classical bits still require only two classical bits for their description (or two realnumbers if they are analog), the two qubit system is described by 6 real numbers. We see that ingeneral, an n qubit system is described by 2 n+1 - 2 real numbers. For those who are interestedin calculating the properties of quantum systems, this exponential growth is unfortunate; butfor those who are interested in using quantum systems to calculate, this property provides thefirst step toward a more powerful computer.The 2' different basis vectors which are generated by taking tensor products of the states11) and 10) form the canonical basis. There are a few different notations to describe these basisvectors. Using one of the 16 basis states for n = 4 as an example, we may write, depending onthe situation,IID) = 10) 011) 0 11) 9 10) (2.2)= 10)11)11)10) (2.3)= 10110) (2.4)=16) (2.5)where in the last equation the state is labeled according to the integer which represents thequbits viewed as a single binary number (i.e., 61o = 01102). This last notation is the most24dense; an arbitrary state of an n qubit system is merely2"-1|I) = aii) (2.6)i=Owhich is an expression that will occur frequently.As with the single qubit system, there is a question of how one can access the informationhidden in the state, only now the problem is more severe. Measuring the qubits will only reveala single n bit integer i, with any particular result occurring with probability Iajj 2 . There maybe an exponentially large amount of information stored in the state of a quantum system, butit is not at all obvious how it is to be exploited.2.2 Quantum gate arraysHaving thus described how quantum information is stored, the next issue one must address ishow it is to be processed. The most natural way to compute with a set of quantum bits is witha quantum gate array.A quantum gate is a unitary transformation acting on one or more qubits. Essentially, weimagine that the Hamiltonian for all the other qubits (upon which the gate does not act) iszero; the qubits involved in the gate will time-evolve according to their local Hamiltonian. Oneimportant but limited set of gates are those which simply map one member of the canonicalbasis into another; for example:00) == 00) (2.7)101) ==> j1) (2.8)110) ==> 111) (2.9)11) = 1 10) (2.10)which is simply a quantum version of the controlled-NOT gate. If these basis states are or-dered in the natural way (according to the binary number represented), one can write the25transformation as a matrix1 0 0 00 1 0 0 (.1(2.11)0 0 0 1-0 0 1 0which is manifestly unitary. It should be easy to see that all classical reversible logic gatescorrespond to permutations as above; assuming that it is possible to generate any desiredunitary transformation, one therefore concludes that a quantum gate array can perform anycomputation that a classical gate array can. The qubits are initialized in the same manner asthe classical bits; the calculation is performed using the quantum counter-parts of the classicalgates. Throughout the entire calculation, the state of the quantum computer is always one ofthe canonical basis states: it is never in a superposition of multiple basis states or an entangledstate. There is no difficulty in reading the result. Thus a quantum computer can be easilymade to mimic a classical computer, and the quantum computational complexity is no worsethan the classical computational complexity. It follows that classical computation is (in a veryreal sense) just a limiting case of quantum computation.Frequently during a quantum calculation, one desires to perform a classical computation.For example, one may wish to do a transformation such that| -) I V) ==* I-) If (-v)) (2.12)As long as an algorithm exists for computing f(7), this transformation can be performed usingquantum logic gates. Moreover, the quantum algorithm is the same as the reversible classicalalgorithm, which, as discussed in the previous chapter, is essentially the same as the original(presumably irreversible) algorithm.262.3 UniversalityOf course, permutation matrices of the sort described above are only a small subset of allpossible unitary transformations. For example, the single qubit transformation10) => -(Io)+I1)) (2.13)111) = > - 1 ) -| ) (2.14)has no classical analogue. This transformation (and, in particular, its multi-qubit extension)is known as the Walsh-Hadamard transform. It is common for quantum algorithms to makefrequent use of this gate.A natural question to ask is whether or not there exists a set of universal quantum gates,which can be combined together to form any possible unitary transformation. Since there arean infinite number (continuum) of unitary transformations on even a single qubit, this problemis a bit more subtle than the corresponding classical problem. However, since any real physicalsystem will posses only finite accuracy, it should be sufficient to find a set of gates which canbe applied so that they will generate an n bit unitary transformation that is arbitrarily closeto any desired n bit unitary transformation. Fortunately, such gates exist [6] [39][43][69]. Infact, Lloyd has shown that almost any 2-qubit gate is sufficient for generating arbitrary unitarytransformations[69] 3 . This later result is important because it means that one doesn't need toworry much about what type of interaction Hamiltonian exists between pairs of qubits: almostany interaction will do.A general unitary transformation on n qubits is described by 0(2 2n) complex numbers. Itis therefore not too surprising that a general n qubit unitary transformation will require anexponential number of gates. Since a quantum computation is nothing more than a series ofunitary transformations - which when multiplied together are just one very complicated unitarytransformation - this implies that most computations will require an exponentially large number3 1t is interesting to note that only two-qubit gates are required for universal quantum computation, whereasthree-bit gates were required for classical reversable logic27of gates. One of the main goals in designing a quantum algorithm, therefore, is to see if it ispossible to effect a desired n qubit unitary transformation using only a polynomial number ofquantum gates.The class of problems which can be solved by a quantum gate array of polynomial size iscalled BQP 4 . In order for this class to be well-defined, it is important that it should not dependupon the choice of gates; moreover, it should also correspond to polynomial-time complexityfor other models of quantum computation, such as quantum Turing machines. It is clear thatquantum gate arrays must be polynomially equivalent because once one has a set of (constantsized) circuits to effect any desired two qubit unitary transformation, all gate arrays will lookthe same. In 1993, Yao showed that quantum Turing machines and quantum gate arrayswere polynomially equivalent [101]. Moreover, we know that any physically realistic quantumcomputer can simulate any other with only a polynomial overhead, because a quantum computeris nothing more than a physical system, and Lloyd has shown [68) that there exist universalquantum simulators. The class BQP is therefore quite robust: indeed, one could argue that thequantum version of the Church-Turing thesis is a consequence of the laws of physics as theyare known today.The formalism described previously is based upon a system composed of a set of individualqubits. However, one may wish to consider a set of three level systems (a qu-trit), or even nlevel systems. 5 The mathematics are likely to be more complex, but one would hope that thefundamental results should not be effected any more than in the classical case, where usingtrits or analog components are of no impact in terms of computational complexity. In fact, ourquantum formalism is not sensitive to the makeup of the individual subsystems. The statespace of the combined system is the tensor product of the state spaces for each individualcomponent system. This is physically reasonable: one can only store so much information in asingle, local, quantum system, and a reasonable model of computation must combine many suchsubsystems. Moreover, this is how the quantum computer gets its power - by virtue of theexponential growth in the size of the Hilbert space with respect to the number of subsystems4BQP stands for bounded error quantum polynomial time.5The situation is somewhat more complicated if the quantum variables are allowed to be continuous. SeeLloyd and Braunstein [70].28which are combined. As long as it is possible to perform an arbitrary unitary transformationon two subsystems at a time, it is evident that the model will be universal; conversely, onecan represent the state of any subsystem with a collection of one or more qubits, and sincethe qubits can be made to evolve according to an arbitrary unitary transformation, the morecomplex system will have no additional computational power. In some sense, it is the processof decomposing a large quantum computer into component subsytems that allows us to employthe gate array model.All quantum algorithms consist of three steps: First, initialize the computer into the state100...0); second, perform a unitary transformation (which is generated through a sequence ofunitary transformations); third, make a measurement of the computer's state with respect tothe canonical basis. From this description, one can see that is not possible for a quantumcomputer to perform any computations that are classically uncomputable; a Turing machinecan easily simulate a quantum computer, as long as it is allowed exponential overhead 6. Thequantum theory of computation does not therefore have any impact on what can be computed,only on how long a computation will take.2.4 Introduction to quantum algorithmsIn 1985, David Deutsch suggested the idea of quantum parallelism [40][41]: by placing a com-puter in a superposition of input states, it could in some sense perform a large number ofcomputations at the same time. Although his original work was with quantum Turing ma-chines, the essential idea can be easily seen with the gate array models discussed thus far.Consider a quantum computer with 1 = 2n qubits, which we will conceptually divide into twodistinct registers of n qubits each. The initial state of the computer will be the zero state, that6 A priori, one might assume that a classical computer would require exponential memory resources to simulatethe behaviour of a quantum computer. It is thus interesting to note that a classical computer can simulate aquantum computer without requiring exponential memory, as long as it is allowed exponential time [21]. (Seealso [83]).29is 14) = 10) 910) 0 ... 910); we shall also write this state as 1,0) = 10, 0), that is, by labeling thestate with the two integers that represent the two n qubit registers.We operate on each of the first n qubits with a Walsh-Hadamard gate, thus obtaining:) = ( 0) + + 1)) o (10) + 11)) 9 1 (10) + l1)) ) 90) 9 ... 010) (2.15)1 2-1=Ii, 0) (2.16)i=As in equation (2.12), one can perform a transformation IV) 10) == I) If(V)) for any com-putable function f. However, since the input register is in a superposition state, one now obtainsRb) = 1if(i)) (2.17)i=oOne thus calculates the value of f(i) for all 2' possible inputs, without performing any moreelementary gate operations than were required to classically calculate f(i) for a single value.Unfortunately, it is not clear if this accomplishes anything: making a measurement on thesystem will return only one f(i) chosen at random. Thus a quantum algorithm will accomplishnothing unless it exploits interference; one must perform another unitary operator after equation(2.17) such that the various paths interfere with one another. Hopefully, after this additional,inherently non-classical operation, one may be able to make a measurement on the resultingstate and learn some joint property of all the f(i). It took seven years to make further progress;but in 1992 Deutsch and Jozsa showed the first example of a problem in which quantumparallelism could be exploited to obtain a super-classical speedup[42]. Soon after, Bernsteinand Vazirani [21] showed the first exponential separation between a quantum and classicalalgorithm (i.e., a problem for which there is a polynomial time quantum algorithm but nopolynomial time classical algorithm). 7 A year later, in 1994, Dan Simon provided a more7The Deutch-Josza problem, while difficult to solve on an ordinary Turing machine, is easy to solve on aprobalistic Turing machine. A probabilistic Turing machine, loosely defined, is an ordinary Turing machine thathas a built in generator of random bits, and that is not required to solve the problem 100% of the time. Theclass of problems that can be solved in polynomial time on a classical probabilistic Turing machine is knownas BPP, and corresponds most closely with our intutive notion of which problems are tractable in reality. Itis interesting to note that there are a lot of open questions regarding the class BPP and its relation to otherclassical complexity classes; for example, does BPP = PSPACE?30elegant problem with an exponential separation [88], which led directly to Peter Shor's 1994discovery of the factoring algorithm[86].Both Simon's algorithm and the Bernstein and Vazirani algorithm rely upon a black boxfunction, which is called an oracle. 8 The oracle is provided an input value x (either classical orquantum) from which it computes f(x); however, one is not allowed to look inside the oracle(thus "black box") to see how it does the actual computation. One wishes to determine howmany calls to the oracle are required to determine a specific property of the function f(x). Itis possible in this context to prove that a quantum computer is more efficient than a classicalcomputer, as in the previously mentioned papers. Such a result is said to be "relative toan oracle", and such a proof is said to be "relativised". While these relativised results areinteresting, and indicate that a quantum computer probably is more powerful than a classicalcomputer, they are not as compelling as a non-relativised speedup. (Unfortunately, while theShor algorithm does not rely upon an oracle, it is also not proven to be faster than a classicalalgorithm - it is still possible that someone will discover a classical algorithm that is just asfast).One can gain insight into the meaning of the oracle results by considering Grover's algorithm[55] [56]. (Grover's algorithm will be discussed in detail in Chapter 4). In the most basic versionof Grover's algorithm, one is given (inside a black box) a boolean function f(x) over an n bitinput such that the function return zero for all values except for a single value xo; one wishesto determine what the value of xo is. For this reason, it is called a "database search." With noadditional information, it is readily apparent that a classical algorithm can do no better thanto try values of x until it finds the solution; on average it will take time }, where N = 2n2'is the total number of possible values of x. In 1996, Lov Grover showed how this can besolved with a quantum algorithm in time vWN: not an exponential speedup, but still impressiveconsidering the fundamental nature of the problem. The problem is that the classical estimateof E is predicated on the assumption that one cannot look inside the black-box. However, if thecomputer is to execute the code required to calculate f(x), then that code must be available,'A black box function is not precisely the same thing as an oracle, but the two terms are used to meanthe same thing in the quantum computing literature, because the black box is essentially the same as a Turingmachine with an oracle.31so restricting an algorithm from examining the function is an artificial constraint. Once thisconstraint is removed, it is no longer possible to know how many operations are required tofind the solution: it might be that a sufficiently clever algorithm could look at the code whichcalculates f(x) and determine the solution right away, without having to try any values of x.Thus it is only possible (so far) to prove that a quantum algorithm is faster than a classicalalgorithm in a context in which both of the algorithms are in some sense restricted. On theother hand, the power of the quantum computer is readily apparent in the fact that Grover'salgorithm does not need to look at the function; the VW speedup is completely independent ofthe form that f(x) takes. It seems clear that the quantum computer is somehow more powerfulthan the classical machine, even if we are unable as yet to prove it. This viewpoint is mostconvincingly argued by considering that - while it may be in theory possible for an efficientclassical algorithm to analyze the function f(x) and find the solution - it seems extremelyunlikely that such an algorithm would exist for an arbitrary f(x).It is worth noting that Grover's algorithm is known to be optimal [20]. It thus follows thatif quantum computers are to solve NP-complete problems in polynomial time, it will require adeep insight into the structure of NP-complete problems that can be exploited by a quantumcomputer. Such an insight is unlikely to be forthcoming. Indeed, just as the oracle modelallows one to demonstrate super-classical speed-ups, it also allows one to demonstrate quantumlower bounds. In addition to the result just mentioned, it has been proven that the problems ofmean and median estimation admit only a quadratic speed-up [76], that finding the parity of nboolean values admits only a constant speed-up [45], and that, in general, almost all functionsadmit only a factor of two speed increase [8]. While these results demonstrate that one cannotin general make an algorithm faster with "quantum magic", and while they do limit the possibleapplications of quantum computers, they also help to clarify which interesting problems havecomplexities that may be significantly improved.322.5 Simon and Shor algorithmsSimon's algorithm [88] is a prototypical example of a quantum algorithm. Because it is notnecessary for the remainder of the thesis, the reader may skip this section, if desired. It hasbeen included, however, because it is the cleanest and clearest demonstration of the power ofquantum computing. It also forms the basis of Shor's factoring algorithm [86], which will bediscussed briefly at the conclusion of this section.In Simon's problem, one is given a 2 -+ 1 function that maps an n bit string into an n - 1bit string, with the following special property:f(i) = f(j) 4=> i ( j = c (2.18)where the e indicates addition over the group B'-1. (In other words, each bit is added in-dependently, without carry, with 1 G 1 = 0.) (Alternatively, this addition can be seen to bea bitwise XOR of the two n - 1 bit strings). Note that this special type of addition has theinteresting property thati Ejj = i (2.19)for any i and j. The function f is therefore periodic, in the sense that f(i) = f (ie c) = f (i Ece c),etc. One is given an oracle (black box) which computes f for any input i. The problem is todetermine the value of c, with as few operations (or calls to the oracle) as possible.It is easy to see that classically, there is no better algorithm than randomly guessing valuesof i and querying the oracle until the function returns the same result twice (at which point onedetermines c). Since there are 2" values of i, it is also easy to see that this algorithm requiresexponential time. The quantum algorithm, however, will run in polynomial time. First, wegenerate a state as in (2.17). Note that this requires only a single call to the quantum oracle.33Next, we make a measurement of the second register. 9 This will result in a state of the form[ 1) = (1a, f(a)) + la E c, f (a))) (2.20)for a particular value of f(a) chosen at random. This is because there exist two values of iwhich correspond to every possible value of f(i). Since the system is now in a superpositionof two states which differ by c, it would seem to be an easy matter to determine the answer.However, measuring the state would reveal just one value, either a or a e c, and if we wereto repeat the experiment, we would obtain a different (random) value of a. The information isindeed contained within the state of the quantum computer, but it is hidden in a way whichmakes it difficult to extract. It is therefore necessary to do something more clever. The trickis to generate interference between the states by performing an operation such as the originalWalsh-Hadamard transform on the first n qubits. First, we shall rewrite the state of the systemin a slightly different form[) = - (Ia, f(a)) + la D c, f(a))) (2.21)- 1(a) +la E c)) 0 If(a)) (2.22)We factor out the pure state If(a)) of the final n - 1 qubits because it is no longer relevant tothe computation. It will be omitted in what follows (i.e., we will only consider the state of thefirst n qubits). We now perform an operation similar to the Walsh-Hadamard transform thatcauses 10) ==> (10) + 1)) and 11) ==> (10) - 11)).1 12-1 1) i + (- 1 )(aec).i (2.23)n j(-1)a ii) (2.24)i E c-i=OThis step requires perhaps a small amount of explanation. Any state Ia) will be transformed91t is not actually necessary to perform this measurement; however, it makes the algorithm appear simpler.34into an equally weighted superposition over all Ii). However, the phases of the components aredetermined by ja): for every qubit where 1a) is originally 11) and Ii) is also 1), we pick up aphase of (-1). Hence the state 1a) maps into , 2n -O ji) (-1)ai and the state IV) transformsas above. The second step simply reflects the realization that the only terms in the sum whichwill not cancel are those for which c - i = 0.A measurement of the system will yield a state Ii) chosen at random such that c - i = 0. Incontrast to the situation in equation (2.20), a measurement now reveals information about thevalue of c, which is the objective. Indeed, only O(n) trials are necessary to determine n linearlyindependent vectors i such that c - i = 0. From these, one can easily determine c. The quantumalgorithm is therefore exponentially faster than the best classical algorithm.The Shor algorithm works in essentially the same way. It has been known since 1976 thatthe problem of factoring n can be reduced to the problem of finding the order of x mod n, that is,the least integer r such that x' = 1(mod n). If one considers the function f(a) = xa mod n, theorder r is simply the period of this function. The Shor algorithm proceeds exactly as the Simonalgorithm described above, with two differences: First, the function f(a) = xa mod n is differentfrom the function used in Simon's problem. Second, the Walsh-Hadamard transform used inthe last step to find the period of the function over the group B"- 1 is replaced with a quantumFourier transform [33] that finds the conventional period over the ordinary multiplicative group(which is the order r). More detailed discussions of the Shor algorithm can be found in [86], in[87], and in the review by Ekert [44].2.6 Accuracy and errorsUnlike modern digital computing machines, quantum computers are analog devices. Whileon a superficial level it may appear that the qubits themselves are digital, the information isstored in the phases of the states, and these are complex numbers. It is important thereforeto consider what level of precision is required. For example, it is known that a classical analogdevice with exponential precision can solve NP-complete problems in polynomial time; however,35exponential precision is not considered to be reasonable. It is therefore important to determinewhat level of precision is required of a quantum computation.A quantum algorithm is nothing more than a series of unitary operators applied to an initialstate,|@n) = Un...U3 U2U1 0o) (2.25)followed by a measurement of the final state (made with respect to the canonical basis). Letus suppose that at each step of the computation, the unitary operators which we perform arenot exactly the operators which we intend. 0 Alternatively, we can imagine that there is alittle gnome who performs a small unitary transformation in between each gate. Hence, thecalculation which we actually perform isn = Un ...U3 U2U100) (2.26)where U indicates an operator which is close to U; specifically, if IV),) = Ui I400), then kQv) =U, 14o) + E, jE1), where ei is small and all the states are normalized. 1~n) indicates the actualstate vector obtained, which will hopefully be close to IV),), the ideal result. Applying all ofthe U in series, and collecting terms, we find0- [n) = En IEn) + Un(En-1) IEn-1) + UnUn.i(fn- 2 ) En- 2 ) . . . Un...U 2 (E1) 1E1)(2.27)The worst possible situation would occur if all the terms on the right hand side were to addin phase. This would yieldn- In) = (En + Cn-1 + ... + Ei) IE) (2.28)where IE) = IEn) = U~n IEn-1) = ... = Un...U 2(Ej) IE). Let us assume that the maximum error10The particular argument given here is similar to that in Preskill [83] and in Kitaev [61].36occurring with each gate is E; then1nE - V) < nf (2.29)One concludes therefore that the errors grow linearly with respect to the number of gatesapplied. Even without error correction, the required precision of a quantum computer wouldgrow only linearly with the number of gates. (Note that the number of bits of precision thereforegrows only logarithmically). This level of precision is acceptable in a "reasonable" model ofcomputation.Having thus addressed the issue of precision (and unitary gate errors), we now address errorsin general. There are two types of errors which can occur during a quantum computation: bitflips (i.e. 10) -+ 11) and 11) -- 10)) and phase flips ( 10) -+ 10) but 11) -+ - 1)). Smallererrors (e.g., 10) -) v I| 10) - vC7T 11)) are merely superpositions of the error-free state anda small amount of one (or both) of these error states. On the surface, it would seem to beimpossible to correct for such errors during a quantum computation. Classical error correctingcodes are based upon the idea of redundant information and frequent measurement (e.g., storethe bit 1 as three bits 111; as long as only a single bit error is committed, one can correctfor it). But one is unable to make duplicate copies of quantum information (the "no-cloning"theorem), and moreover, one is unable to detect errors by looking at the state of the computerduring the course of the computation, because doing so would necessarily cause a "collapse" ofthe wavefunction. Nevertheless, Peter Shor demonstrated [29] [28] that it is possible to performquantum error correction, and a large literature has developed on this topic (e.g., [91][82]).I will not discuss quantum error correcting codes in detail here; however, it is importantto know of their existence and to understand the fundamental principles upon which they arebased. The key concept on which all quantum codes depend is that errors are assumed tobe uncorrelated and local. Uncorrelated implies that the errors are in some sense random:it is always possible, even with classical error correction, for a little gnome who knows yourscheme to create errors in your calculation by committing just the right errors in the rightplaces. Local implies that the errors act on only one qubit (or a few qubits) at a time. This isphysically reasonable. It is likely that, during the course of a calculation, random atoms may37spontaneously emit photons. It is not likely that all the atoms in your system will spontaneouslyemit photons at the same time. Given these assumptions, and as long as the frequency of errorsis below a certain threshold, it is possible to perform arbitrarily long fault-tolerant quantumcomputations [82].This concludes our discussion of the mathematical formalism used in quantum computation.In addition to providing the necessary background for the rest of the thesis, the author hopesto have made a convincing case that quantum computation is in fact a physically reasonableparadigm that poses a very real challenge to the strong form of the Church-Turing thesis.Indeed, it appears most likely that the strong form of the Church-Turing thesis is wrong.2.7 Potential implementationsAlthough this document focuses on quantum algorithms, it would not be complete withoutat least some discussion of the possible hardware with which a quantum computer might beimplemented. There is at this time a wide variety of suggestions for quantum computing devices;below, I will address a few of the more promising proposals.Trapped Ions. First suggested by Cirac and Zoller[31], this scheme uses ions in a linearPaul trap to store quantum bits. The ground state of an ion is labeled 10) and the 11) stateis a metastable excited state. With a properly timed laser pulse that is tuned to the energydifference, one can effect any desired single qubit unitary transformation. One can measurethe state of a qubit with a laser that drives the 10) state to a short-lived excited state If), andlooking to see if the ion fluoresces. Multiple ions in the trap are physically separated because oftheir coulomb interaction and can be addressed individually. The difficult part of this scheme(like most proposed quantum computer implementations) is with the two qubit gates. In thiscase, the trick is to excite a normal vibrational mode of all the ions in the trap when a particularion absorbs a photon. Another laser pulse can then be used to generate a transformation on aphysically distant qubit in such a way that it depends on the state of the first qubit.Trapped Atoms. This scheme was proposed by Pellizzari et. al. [80]. Instead of using38S. I -Af .trapped ions, it uses neutral atoms trapped within an extremely high Q optical cavity. Thesingle qubit operations are similar to those used in the ion trap; however, the two qubit gatesare -implemented somewhat differently. In this case, the atoms interact with the normal modesof the electromagnetic field inside the cavity. The electromagnetic field is then used as themediator of information between qubits, as opposed to the vibrational modes employed in theion trap.Photons. An obvious place to store quantum information is in the polarization of singlephotons. Unlike trapped ions or atoms, it is relatively easy to keep a photon state from deco-hering. The problem is that it is correspondingly difficult to get photons to interact with eachother. One possible technique is to use small cavity QED, as above, but use atoms to cause thephotons to interact with each other, rather than the other way around. Kimble has pursued thisapproach [92] and has been successful in demonstrating that it is at least possible to generatesubstantial photon-photon couplings in this manner.Nuclear Spins. A lot of recent attention has been generated by proposals [34][53] inwhich quantum computation is performed using NMR. (The essential idea is the same as thatsuggested by Lloyd in 1993, involving arrays of weakly coupled quantum systems [67].) RFpulses are used to control interactions between pairs of nuclear spins; because these spins arewell isolated form their environments, they can have very long coherence times (on the orderof seconds). The current NMR quantum computing implementations differ from the otherschemes because they involve an ensemble of quantum computers which all perform the exactsame computation in parallel; moreover, since it is not possible to initialize the computer ina pure state, various techniques are used to create "pseudo-pure states", in which the slightdeviations from an equal distribution are exploited so that a computation may be performed.At room temperature, the unfortunate result is an exponential loss in signal strength as thenumber of qubits is increased; however, if the system is cooled so that kBT - AE, thenone enters a new regime which does not have this problem. But at such low temperatures,one can no longer perform liquid NMR, and without the tumbling of the molecules, there areadditional difficulties. It thus appears that with current technologies it will be difficult toperform computations with more than 10 or 12 qubits[96][35], although solid NMR may have3911 - Ir -the potential for large scale quantum computing. The current state-of-the-art with liquid NMRis roughly 5 or 6 qubits. However, it is not clear at this time if these experiments are trulyperforming quantum computations or if they are acting in a purely classical regime[26].Semi-conductor devices. If possible, semi-conductor devices would obviously be a highlydesirable platform for quantum computation. Unfortunately, it is hard to maintain coherencein solid state devices: charge dephasing times are typically on the order of nanoseconds. DiVin-cenzo and others have proposed using electron spins as quantum bits because the spin-coherencetimes may be on the order of microseconds, which may be sufficient [66] [27]. Quantum logicoperations are performed by adjusting the exchange coupling between spins in single-electronquantum dots, which is accomplished by varying electric or magnetic fields, or by adjustingthe tunneling barrier. In a different scheme, recently proposed by Kane[59], silicon is combinedwith NMR in an attempt to gain the best of both worlds. Quantum information is stored onthe nuclear spins of impurity ions in doped silicon, and quantum logic operations are performedby using gate voltages to control electrons which have hyperfine interactions with the nuclearspins.In conclusion, it is at this stage quite unclear which (if any) of these proposals will lead to auseful quantum computer. What is clear - unfortunately - is that a useful quantum computerwill not be easy to build, and is unlikely to exist in the near future.40Chapter 3Quantum Quantum Simulators'Summary. This chapter discusses the possibility of using a quantum computer as a quantumsimulator. It describes a new polynomial time algorithm that uses a quantum fast Fouriertransform to find eigenvalues and eigenvectors of a Hamiltonian operator, and that can beapplied in cases (commonly found in ab initio physics and chemistry problems) for which allknown classical algorithms require exponential time. Fast algorithms for simulating manybody Fermi systems are also provided: both first and second quantized descriptions are con-sidered, and the relative computational complexities are determined in each case. In order toaccommodate Fermions using a first quantized Hamiltonian, an efficient quantum algorithmfor anti-symmetrization is given. A simulation of the Hubbard model is discussed in detail, aswell as a problem from quantum chemistry. I find that classically intractable and interestingproblems from atomic physics could be solved with between 50 and 100 quantum bits.3.1 IntroductionSince the discovery by Shor of a quantum algorithm for factoring in polynomial time [86],there has been tremendous activity in quantum computing. Recent results, some of which werediscussed in the previous chapter, include the first experimental demonstrations of working'The work described in this chapter is based upon [11 and [3].41& . 6.1quantum logic gates [75][92], quantum error-correcting codes[29] [28] [91] [82], and many novelproposals for the design of actual quantum computers [31] [67] [90] [7] [77]. Despite these advances,however, the technical hurdles that stand in the way of factoring a large number on a quantumcomputer remain daunting [94] [78] [63]. On the other hand, the problem of simulation - thatis, the problem of modeling the full time evolution of an arbitrary quantum system - is lesstechnologically demanding. While thousands of qubits and billions of quantum logic operationsare needed to solve classically difficult factoring problems[9], it would be possible to use aquantum computer with only a few tens of qubits and perhaps a few thousand operations toperform simulations that would be classically intractable. A quantum computer of this scaleappears to be a more realistic possibility.Because the size of the Hilbert space grows exponentially with the number of particles, afull quantum simulation demands exponential resources on a classical computer2 . A systemof only 100 spin 1/2 particles, for example, requires 210 complex numbers to merely describea general spin state. It is clear that on a classical computer, a simulation of this system isin general intractable. This exponential explosion severely limits our ability to perform true"ab initio" (first principles) calculations; since it is obviously not possible to even describe thestate of anything but the smallest quantum systems, one must resort to various approximationtechniques to calculate the properties of interest. The idea that a quantum computer mightbe more efficient than a classical computer at simulating real quantum systems was first pro-posed by Feynman (long before Shor's algorithm), but he speculated that the problem of Fermistatistics might prevent the design of a universal quantum simulator [46]. This chapter willdeal explicitly with the problem of Fermions, in part by describing a quantum algorithm forantisymmetrization which executes in polynomial time. More recently, Lloyd has shown how aquantum computer is in fact an efficient quantum simulator [68]. In this chapter, I shall pro-vide the first detailed algorithms for a quantum simulation, using the Hubbard model in bothfirst and second quantized formalisms. To emphasize the algorithmic aspect of this work, many2 At least, it is believed to require exponential resources. If a method were found to perform classical simu-lations of quantum mechanics without an exponential overhead, than all quantum algorithms could be reducedto classical algorithms - implying, among other things, a polynomial time classical factoring algorithm. Inthis sense, the problem of performing a quantum simulation is at least as hard as any problem in BQP. (How-ever, because of a mathematical technicality, which there is no space to discuss here, it cannot be called BQPcomplete).42subroutines executed by the quantum computer will be described with pseudo-code instructionsas well as with words.Other recent work in quantum computation has revealed various techniques for simulatingphysics on a quantum computer [68] [1] [23] [102] [99] [64]. However, while other work has describeda variety of algorithms for time evolving a quantum state [68] [1] [23] [102] [991, there has beencomparatively little work done on algorithms which calculate static properties of a physicalsystem [64] [102]. In particular, of all the questions which one might ask about a quantumsystem, there is one most frequently asked and for which one would most greatly desire anefficient algorithm: What are the energy eigenvalues and eigenstates? This chapter will providea quantum algorithm that can find eigenvalues and eigenvectors of a Hamiltonian operator incases that occur frequently in problems of physical interest. Moreover, the algorithm requires anamount of time which scales as a polynomial function of the number of particles and the desiredaccuracy, whereas all classical algorithms (with known complexity3 ) require an exponentialamount of time.Hence, this chapter provides for the first time a complete and detailed quantum algorithmfor simulating and calculating the properties of a system of physical interest, and describesalso the first and only other known, well-defined algorithm, other than the Shor algorithm andcertain artificial problems constructed explicitly for this purpose [21] [88], that is thought to gainan exponential speed increase by exploiting quantum computation. This chapter also attemptsto make a careful estimate of the quantum resources that are required to solve a classicallyintractable problem, and finds that only 50-100 qubits are necessary. This estimate is morethan an order of magnitude smaller than previous estimates of the qubits required to factor"interesting" numbers. 43It is possible that some Quantum Monte Carlo methods may scale polynomially for certain problems, butthe scaling is not known. Moreover, these techniques typically have additional difficulties with Fermi systemsand with excited energy eigenstates.4Because of the obvious difficulties in constructing a quantum computer and maintaining coherence, it isimportant to look for problems which require as few qubits as possible.43J. W3.2 The fermion problem and the Hubbard modelThis section will discuss how one performs a quantum simulation of a many-body Fermi sys-tem, using the Hubbard model as a concrete example. The algorithm used to perform thesimulation could be implemented on a variety of possible hardware schemes: the actual imple-mentation of the quantum computer is not relevant, as long as it supports universal quantumcomputation[6][39][43][69]. (However, different physical implementations may of course be bet-ter or worse suited for different problems).3.2.1 Description of the systemThe problem considered here consists of n particles, each of which can be in any of m singleparticle states, labeled 1. .m. These states might be sites in a lattice, or atomic orbitals, orplane waves, etc. The mapping of the model system onto the qubits of the computer dependson whether we choose a first or second quantized description. In many respects, the secondquantized form appears naturally well-suited for quantum computation of Fermi systems: theoccupation of each state must be either 0 or 1, which maps directly to the state of a qubit.In this case, the memory needed to map the state of the entire n particle system is m qubits(independent of n).5 To treat a first quantized Hamiltonian, one may imagine a quantum word,or qu-word, as a string of qubits of length log 2 m; one qu-word represents any integer in therange 1..m, and, consequently, the state of one particle. The state of the entire physical systembeing simulated can therefore be represented by n qu-words, or n log 2 m bits. If the number ofparticles is much smaller than the number of possible states, a first quantized representation maybe vastly more efficient (n log 2 m qubits vs. m qubits). In either representation, if the simulatedphysical system is in a superposition of many direct product states (as it is in general), thenthe quantum computer will be in a corresponding superposition of states in order to representthe correct physical state of the simulated system.5 For Bose particles, where the occupation number of each state can be any integer in the range 0..n, log nqubits are needed to represent each state, yielding a total of m log n qubits.443.2.2 Fermions in the second quantized formalismThe problem of Fermions is handled more easily in the second quantized form because thestatistics are incorporated into the raising and lowering operators. As usual, the calculationbegins with all qubits in the 10) state. One can prepare the system in any state as long as itcan be reached from the zero state using a relatively small number of quantum logic operations(that is, polynomial in m). Examples of such states include those in which the n particles arelocalized in individual lattices sites, momentum eigenstates, thermal states of non-interactingparticles, and states in which particles obey k-particle correlations or entanglements (for smallk). Thus Fermi statistics do not pose any additional complications for system preparation inthe second quantized formalism. Because the statistics are incorporated into the raising andlowering operators, the additional complications occur during time-evolution.In the Hubbard model, electrons move about a lattice of sites. Each site may be empty oroccupied by a spin up electron, a spin down electron, or two electrons of opposite spin. Twoqubits are therefore required to represent the four possible states of each site. The Hamiltonianfor the system ismH=ZVon nit+ toctc, (3.1)i=1 aIn the first term, which corresponds to potential energy, Vo is the strength of the potential,and ni, is the operator for the number of Fermions of spin o- at site i. In the second term,which corresponds to kinetic energy, the sum < i, j > indicates all neighboring pairs of sites,to is the strength of the "hopping", and ct and cj,are operators for creation and annihilation,respectively, of a Fermion at site i and with spin a. The computer simulates the Hubbardmodel by performing the unitary operation U = e-i H on suitably encoded states. This canbe accomplished most easily by splitting the Hamiltonian into a sum of local terms H andSHj Irepeatedly applying the operators Uj = eH n , to evolve local parts of the system over smalltime slices , in series. (See Ref. [68] for further discussion of this technique; it will also ben Idescribed in more detail below). Thus it suffices to describe algorithms which perform the time-evolution corresponding to each local term in the Hamiltonian. To effect the time evolution45corresponding to the potential energy terms j= 1 Voni4 n i, the following simple algorithm willsuffice: consider each site one at a time; for each site, if it is occupied by two electrons (ofopposite spin), advance the phase of the entire state by -V170. This subroutine requires 0(m)operations. It is often convenient to describe a quantum algorithm in terms analogous to thepseudo codes used to describe classical algorithms; the previous algorithm then appears asfollows:loop i over sitesif site i is occupied by two electrons,set flag qubituse controlled rotation to advance phase of flagged componentsundo if (to restore the flag qubit)To calculate the effect of the hopping terms Ei, tcc, requires a slightly more compli-cated algorithm: first, loop over all pairs of (physically) neighboring sites i and j, and considerhopping between each pair of sites separately. For each pair i, j, count the number of occupiedstates which fall between i and j when the system is written in second quantized form. A flag isset to the parity of this number, which indicates whether or not a change of sign is introducedwhen hopping between the two sites. It is now easy to perform the time evolution Uj becausethe action of the operator takes place in the two qubit space i, j; a simple two qubit unitaryoperation is performed that diagonalizes the Hamiltonian in this space (depending upon theflag), and the phases of the eigenstates are then advanced by the appropriate amount. Inpseudo code, the algorithm appears as follows:loop i over statesloop j over neighbors with i > jcount states occupied between i and jlet flag qubit = parity of this numberdiagonalize bits ij according to parity bitadvance phaseundo diagonalize46undo counting and restore flag qubitAssuming that the number of neighbors is a constant, the loops execute 0(m) times. Ittakes no more than 0(m) operations to count the occupancy of the intervening states, and itfollows that the entire algorithm for simulating the second quantized Hubbard model executesin O(m 2 ) quantum logic operations.3.2.3 Fermions in the first quantized formalismFermi statistics are more difficult to handle in the usual first quantized description, because itis necessary to initialize the quantum computer into an antisymmetrized superposition of statescorresponding directly to the actual physical state of the system. As there are n! states in thesuperposition, one needs a fast quantum algorithm for generating this superposition state inorder for the approach to be tractable.The algorithm described below accepts as input a string of n qu-words (representing thestate of the physical system being modeled) and generates an antisymmetrized superpositionof n! states in 0(n2) time6 . Note that without further restriction, antisymmetrization is anirreversible process and cannot be performed by a reversible quantum computer: there are n!input states which correspond to the same antisymmetrized state (modulo an overall phase).One must therefore add the additional requirement that the input state is ordered. The cor-respondence between an ordered n-tuple of qu-words and an antisymmetrized superposition isone to one. In fact, this observation is in some sense the key to the algorithm.System preparation in the first quantized formalism therefore begins by first initalizing thecomputer into an unsymmetrized state and then antisymmetrizing that state. Placing thesystem in any (unsymmetrized) direct product state is easy: simply place each particle in theappropriate single particle state. These single particle states might include, for example, those'The complexities in this section are often specified only up to a poly-logarithmic factor. For example, theentire algorithm is more accurately described as O(n2 (log M)2 ).47which are localized in position space, momentum space (obtained by using a quantum FFT),and thermal states. The system could also be initialized into states with arbitrary k-particlecorrelations or entanglements by performing quantum logic operations in the appropriate k-particle space, requiring only O(m 2k) operations in the general case, and often far fewer.Antisymmetrization is accomplished in four main steps, summarized below:Step I. Initialization of the input state. Imagine that there is a string of qubits which areall initially set to zero, and define three registers A, B, and C, each consisting of n qu-words(n log m qubits). The qubits in register A are initialized to the ordered string of qu-wordswhich represent the input state of the system . The algorithm is unaffected if this state is asuperposition of several ordered n-tuples.Step II. Generating n! states. We begin by creating the following superposition of statesin register B:1 n n-1 n-2j1 1 n- v 1i2 i) 0 ( 12) +11)) 9|1) (3.2)This is accomplished with O(n(log M) 2 ) steps: by performing appropriate rotations on eachqubit, one at a time, the computer is placed in a superposition of n! unique states. For example,the sum 1(10) + |1) +... + 16) + 17)) is easily generated by rotating three qubits from the state10) into the state (0) + 11)). States of the form 1 ji) for values of j that are not powersof two can be generated in a similar manner, one qubit at a time, by using controlled rotationsthat are conditioned on previous qubits.Step III. Transform into permutations of natural numbers. The goal of this third step is totransform the superposition of states in register B into the superposition 1 E S lo-(..n)),where Sn is the symmetric group of permutations on n objects. This is an equal superposition ofthe states representing all the permutations of the first n natural numbers. The basic idea is asfollows: let B[i] indicate the ith qu-word in register B; map B[i] into a qu-word B'[i] by settingB'[i] equal to the B[i]th natural number less than n which does not occur in B'[1]...B'[i - 1].For example, the state 11111) maps into the state 11234); the state 13321) maps to the state13421). This transformation is accomplished as follows:48loop i over qu-words 2. .nSort B[11. . . B[i-1]{Note: this will generate work bits for reversibility}loop j from 1 to i-1if B[j]<=B[i] then increment B[i]end loop jUndo Sort {this will also cleanup the work bits}end loop iThe algorithm described above requires only 0(n2 ) operations (up to polylogarithmic fac-tors). To prepare for the last phase of the algorithm the n-tuple 1, 2, 3...rn is then assigned toregister C, leaving the computer in the state:IT) j o-(1..n)) 0 11..n) (3.3)Vn\e 0E Sn/Step IV. Sorting and unsorting. The algorithm proceeds with a series of sorting and unsort-ing operations. As in Step III, a string of work qubits is required so that the sorting operationsare reversible. Any sorting algorithm can be used; however, a heap sort is recommended, be-cause it requires 0(n log n) operations in all cases and only n log n scratch qubits.7 The firstsort orders register B with a series of exchanges and scrambles A and C with the same seriesof exchanges. The resulting state iso-(4)) j..n) o-(1..n)) scratch) (3.4)cxESnAt this point, one has already obtained a symmetrized superposition of the input states, but itis entangled with many other qubits. One can antisymmetrize simply by counting the numberof exchanges made during the sorting operation and advancing the phase of that component7 Note that in a quantum algorithm such as the one described here, the complexity of the sorting is theworst-case complexity, because one cannot look at the state of the quantum computer to determine if the sortinghas been completed, and because there are undoubtedly some elements in the superposition which will takethe worst-case time. Thus a QuickSort, which requires 0(n log n) operations on average, would require 0(n2 )operations in the quantum implementation.49of the superposition by 2r (i.e., flip the sign) if this number is odd. (If one wishes to obtain asymmetrized state for a simulation of Bose particles, one can simply leave the state as it is andproceed). The algorithm continues by reversing the sort on register B, but leaving registers Aand C unchanged. The qubits contained in B and C are then redundant: in each componentof the superposition, if B[iI = n, then C[n] = i. This redundancy allows B to be set to zeroreversibly. By then sorting A and C together, eliminating C, and unsorting, one obtains thedesired antisymmetrized state. Note that in the final unsorting operation, the algorithm reliesupon the fact that the ordering of the input state 11F) was stipulated to be the same as theordering of the integers 1..n in register C (so that antisymmetrization would be reversible);if this were not the case, the algorithm would fail. The entire process is completed in O(n 2 )operations.Because the input state is now fully antisymmetrized, time evolution is in principle straight-forward. Using the same technique as before, the Hamiltonian is split into a sum of terms H,and the corresponding time evolution operators U, = e-iXi n are applied to the state in se-ries. (The antisymmetry of the state will not be effected by time step errors that occur duringthis process; although each individual U, does not preserve antisymmetry, their products doexactly.) Each U, can be performed by an appropriate series of quantum logic operations; theactual sequence of gates required can be determined by inverting the Campbell-Baker-Hausdorffformula. Using this procedure, O(m 2 ) steps are required to perform an arbitrary one particleoperator Uj, and O(m 4 ) operations are required to perform an arbitrary two particle operator.It is therefore possible to simulate in polynomial time any system of Fermions using the firstquantized description. For the special case of the Hubbard model, the simplicity of the Hamil-tonian allows one to do better. I describe below how to perform each U, in only 0((log M) 2 )steps. To begin, consider the Hubbard model Hamiltonian in its first quantized form:nH = T + 2 Vk (3.5)i=1 k$Iwhere (iciT~jc-) = toJ4i,jy , and (i T, i I IVji T, i 1) = Vo are the only nonzero matrix elementsof V. As before, the potential energy terms are easier because they are diagonal. For a givenpair of particles, simply determine if they are at the same site and perform a controlled rotation50if they are. In code:loop i,j over pairs of particlesif ij are at same site set flag qubituse controlled rotation to advance phase of flagged componentsundo if (to restore the flag qubit)In order to perform the time evolution corresponding to the kinetic energy terms, we focuson one particle at a time. For each particle, the idea is to decompose the kinetic energy termsinto a sum of block diagonal matrices and then diagonalize the sub-blocks in each matrix inparallel. 8 For simplicity of explanation, consider a 1-d Hubbard model and ignore spin. Thegeneral case is a straightforward extension. In the 1-d spinless case the kinetic energy part ofthe Hamiltonian can be writtenT = h(1, 2) + h(2,3) + h(3, 4) + ... + h(m - 1, m) (3.6)where h(i, j) is the piece of the Hamiltonian that corresponds to hopping between sites i andj: all matrix elements of h(ij) are zero except (ilh(i,j)Ij) = (jih(ij)Ii) = to. One can rewritethe previous expression as follows:T = Ti + T2 (3.7)Ti = h(1, 2) + h(3, 4) + h(5, 6) + ... (3.8)T2 = h(2,3)+h(4,5)+h(6,7)+.... (3.9)The operators T and T 2 are in block diagonal form. To fully diagonalize each matrix (sepa-rately), perform quantum logic operations on each state to transform the state number into twoquantum numbers labeling the block and the location within the block (0 or 1). For example,to diagonalize T 1 , map the state In) into I(n + 1) div 2, n mod 2) (where x div 2 indicates thegreatest integer less than or equal to x/2). Because Ti is block diagonal and only mixes states8Because one often encounters near-diagonal operators in various problems, this technique may likely be usefulin other circumstances besides simulations.51within each block - and because all states within the same block have their first quantum num-ber in common - the action of T, takes place entirely within the space of the second quantumnumber. In this one qubit space it is simply the matrix to ( ). Thus all the blocks can(1 0)be diagonalized in parallel by diagonalizing this trivial 2x2 matrix in the one qubit space ofthe second quantum number. Each state in the superposition is then advanced by the appro-priate phase, and all the previous steps are reversed. The algorithm requires only O((log M) 2)quantum logic operations.3.2.4 Reading the final stateHaving thus described how to prepare a quantum computer in a state that is analogous to theinitial state of a many body Fermi system - and how it can be programmed to simulate thatsystem's time evolution - one must now consider what information can be extracted from aquantum many-body simulation. It is obviously impossible to obtain the entire wavefunction(no classical memory could hold it). Rather, the "answer" is obtained by performing a seriesof measurements on the qubits, one at a time. Each such measurement will yield either a 10)or a 11). It is thus possible to measure any physical property of the wavefunction that canbe expressed in terms of such local variables. To obtain useful information about the physicsof the simulated system, one must initialize the quantum computer, simulate time-evolution,make a measurement, and then repeat this process a sufficient number of times to acquire astatistically significant result.One important example is the electronic charge density distribution. In the second quan-tized representation, one performs measurements at each site to determine the probability ofoccupancy. The number of such measurements required to obtain some desired accuracy Evaries as E- 2 (i.e., the accuracy grows as a polynomial function of the number of trials). In thefirst quantized representation, the same result is obtained by measuring the location of a givenparticle and generating a histogram of locations from repeated trails.It is possible to obtain two-particle correlation functions and even k-particle correlationsusing a similar approach (requiring roughly O(e-2 6 k) trials, where 6 is the density of points52in the histogram and E is the desired accuracy). The momentum distribution function can beobtained by performing a quantum FFT before sampling the wavefunction. From the one andtwo particle densities and the momentum distribution, it is possible to calculate the expectedenergy of the wavefunction.A variety of other techniques might be used to obtain other types of information: for example,one could obtain scattering amplitudes by simulating the motion of an electron through acharged medium and measuring the probability of its emerging with different momenta. Or,one might perform a quantum simulated annealing by time-evolving the system in contact witha simulated heat bath. By then employing the previous techniques one could obtain informationabout the system's ground state.3.3 Finding eigenvalues and eigenvectorsAlthough the techniques described in the previous section allow one to initalize a simulationin a variety of physically interesting states, time evolve that system, and make measurementsto learn the relevant physical information about the final state, it is not clear how one candetermine the properties that are often of most interest: eigenvalues and eigenvectors. Thissection provides an algorithm for finding this information.3.3.1 Statement of the problemThe problem to be solved will be formalized as follows. Consider the time-evolution operatorU = e-h which corresponds to the Hamiltonian H, and an approximate eigenvector V of U(and thus of H) that can be generated in quantum polynomial time; i.e., the machine can beplaced into a state corresponding to V using a polynomial number of quantum logic operations.Call the true eigenvector V and the true eigenvalue A. If the state Va satisfies the property that(Va|V)12 is not exponentially small - that is, the approximate eigenvector contains a componentof the actual eigenvector that is bounded by a polynomial function of the problem size - then53V and A, can be found in time proportional to 1/ (VaIV) 2 and 1/e, where e is the desiredaccuracy.Intuitively, what the algorithm does is to resolve the guess into its non-negligible componentsand determine the corresponding eigenvalues. If the operator U (and thus its eigenvectors) is ofexponentially large dimension - which it typically is - there are no known classical algorithmsthat can find even the eigenvalues in polynomial time. Although the requirement that thereexist an initial state vector Va with the specified properties may appear to be overly restrictive,it is frequently (if not usually) possible to obtain such a guess for "real" problems using existingclassical techniques. For example, in any physical system with discrete energy levels that arenot exponentially close together near the ground state (such as an atom), if it is possible toobtain classically any state vector with expected energy merely less than the first excited state(by a non-exponentially small amount), then this state vector must contain a non-negligiblecomponent of the ground state and - although it may not remotely resemble the ground state- could be used as the approximate state Va to determine the true ground state and groundstate energy in polynomial time. In fact, for a system with discrete energy levels, almost anyphysically reasonable initial state is likely to contain non-negligible components of all nearbyeigenvectors (which this algorithm would therefore find). Finally, if for some problems it is notpossible to obtain classically an approximate state with the desired properties, it may oftenbe the case that the state vector Va may be generated using a quantum algorithm, such asquantum simulated annealing.3.3.2 Eigenvalues and eigenvectors via quantum FFTThe core of the quantum algorithm is a subroutine which applies to any U that can be imple-mented in quantum polynomial time. (It was shown in [68] that the time evolution operatorcorresponding to any local Hamiltonian can be implemented in polynomial time on a quantumcomputer.) (As an example, the Hubbard model, as discussed in the previous section, wouldbe one possible U for which the necessary quantum logic gates are known in detail). A similarsubroutine was previously (though independently) described by Cleve et. al. in [37] to find theeigenvalues of unitary operators. Cleve et. al. show how one can obtain an eigenvalue with54t . 6, 'exponential precision if one is initially given the eigenvector and devices that can perform U,U2,U4, ... ,U2m ; they use this subroutine in a modified version of Shor's algorithm by randomlysampling from the eigenspectrum. Of course, we have no way to generate U2m, nor do we seekrandom eigenvalues or exponential precision (polynomial accuracy will suffice). However, weemploy essentially the same subroutine in an algorithm that takes an estimate of an eigenvec-tor (e.g., the ground state) and uses it to find the eigenstate itself. (In its original form, thisroutine is not useful for finding eigenvectors: in a Hilbert space of exponential dimension thechances of getting the same eigenvector twice are exponentially tiny. The situation is similarto Shor's use of the quantum Fourier transform: the quantum Fourier transform, developedby Coppersmith[33], does not in and of itself supply an exponential speed up over classicalcomputation. It is only when used as a subroutine in a quantum algorithm for factoring thatit allows an exponential speed up over all known classical algorithms).The algorithm will proceed as follows: Consider a quantum computer consisting of m + 1+ wqubits, where a total of m qubits (to be called the index bits) are used for an FFT, a total of1 qubits describe the Hilbert space in which the operator U acts, and w extra working qubitsare required for temporary storage. Let M = 2 m. The accuracy of the result will grow as 1/M- therefore, the required number of qubits will scale as the log of the accuracy. Assume thatthe m index qubits are initially in the state 10) and that the 1 qubits are initially in the stateVa; i.e., the initial state isIT >= 0 > IVa > (3.10)where the w work qubits are assumed to be 10) unless specified otherwise. Perform a 7r/2rotation (Walsh-Hadamard transform) on each of the m index qubits to obtain the stateM-1E > I J)IVa) (3.11)j=0Next, one performs a series of quantum logic operations that transform the computer into55the stateM-11 >= -- Z J)(UYIVa) (3.12)VMj=OThis transformation is accomplished by applying the operation U to the second set of 1qubits (which are initially in the state IVa)) a total of j times. It can be implemented easily byperforming a loop (indexed by i) from 1 to M. Using standard quantum logic operations, seta flag qubit to the value 11) if and only if i 12 is close to 1), then only a fewtrials may be necessary.Moreover, once a measurement is made and an eigenvalue Ak is determined, the remaining 1qubits "collapse" into the state of the corresponding eigenvector. One is likely to be interestedin various properties of the eigenvectors, and these can be determined by making various mea-surements on the state, as described in the previous section. For ab initio quantum calculations,easily obtainable properties include those of greatest interest: charge density distributions, cor-relation functions, momentum distributions, etc. Of course, the state 10k) is still in some sense"trapped" inside the computer. But since it is impossible to store as classical information the21 phases associated with the state, one cannot possibly do better. Nevertheless, the relevantphysical information can be extracted efficiently from the quantum computer.An interesting subtlety occurs if the eigenvalue found above is degenerate or nearly degen-erate (that is, there are several eigenvalues which differ by less than the accuracy 1/M). (Notehowever that nearly degenerate states can be resolved in polynomial time, if desired, as longas they are not exponentially close together.) For degenerate or nearly-degenerate eigenvalues,the measurement projects the system into the corresponding subspace. One can then determineproperties of this subspace - that is, the relevant physical properties of the system - throughadditional measurements as described above. However, one can also use this technique to de-tect the presence of a degeneracy by simulating a small perturbation or by varying the initialconditions.3.3.3 Applying the algorithmLet us now consider more precisely how to use this subroutine to find the eigenvectors andeigenvalues of a "real" Hamiltonian. Generally, one wishes to find energy eigenstates for a57Hamiltonian of the formH = (Ti + Vi) + Vij (3.17)i=1 i>jwhere n is the number of particles, T is the kinetic energy, V is the external potential, andVij is the interaction between the particles. (Other terms can be included, as long as theyact locally). Because the Hamiltonian is Hermitian, one applies the steps described above tothe time evolution operator U(t) = e i"t, which is unitary and has the same eigenvalues andeigenvectors. This time evolution operator is generated using the same technique as in theprevious section (see also [68]); the key idea is to write H = j Hi (where each Hi acts on onlyk qubits at a time) andU(t) =eiHt (e-iH1 m-iH2 .- iH m + [HHj +... (3.18)i>jLet U = e-ii M. Each term Ui can be implemented efficiently, because it acts in a space ofonly k quantum bits, where k is small. For large enough m, the second term on the right (andthe higher order terms) approaches zero. It is therefore possible to generate U(t) by acting onthe state with each U in series, a total of m times. In order to simulate U(t) with an accuracye, one needs to apply O(t 2 /c) quantum logic operations.9For a specific problem, the form of the matrices U depends greatly on the basis set chosento describe the Hilbert space. Moreover, the choice may strongly impact the size of the basisrequired to describe the system accurately. Virtually any basis set may be used: position space,momentum space, wavelets, single electron solutions for an effective potential, etc. As long asthe single particle basis is of a fixed size, then the operators Ui can always be calculated in thechosen basis and implemented using 0(d4 ) operations, where d is the dimension of the single9Since U(t) has the same eigenvalues and vectors for all t, this might lead one to falsely conclude that thenumber of operations necessary to find the eigenstates to a given accuracy could be reduced by choosing a shorterlength of time t for the operator U(t). However, the algorithm requires one to calculate UM, and since U(t)A= U(Mt), one sees that U = U(t) must be calculated with greater precision if UM is to be calculated for afixed precision. In fact, since the eigenvectors are determined with a precision proportional to M, the number ofquantum logic operations required to calculate the energy eigenstates to a precision c is seen to scale as E-58particle basis set [6]. On the other hand, there is a trade-off between memory and speed. Byusing the position or momentum space representation, one needs only O(poly(k)) = O(poly(logd)) operations to perform each Ui; however a large number of qubits are required to describethe eigenstates accurately. By choosing a more elaborate basis set, one can vastly reduce therequired number of qubits, but a much larger number of quantum logic operations 0(d4 ) maybe necessary to implement each Ui. (The trade-off described here is similar to the trade-offbetween first and second quantized representations discussed in the previous section). Thusone finds that, just as with conventional computations, the choice of basis sets in the quantumcomputation will depend upon the specific problem at hand and the specific capabilities of theactual computing machine.Normally, the initial state V will be the result of a classical calculation, for example, aHartree-Fock calculation or configuration interaction calculation. Any ab initio technique whichresults in a known wave function can be used. (Note that this does not include those techniqueswhich utilize density functional theory, as we require a wavefunction, not simply a charge densitydistribution). If the input wave function is not already symmetrized or antisymmetrized, onemay use the algorithms described in the previous section to do so efficiently.Finally, let us consider a state-of-the-art ab initio calculation of atomic energy levels in orderto compare the quantum algorithm described above with known classical techniques. Problemsfrom atomic physics serve as a particularly good benchmark because extremely accurate exper-imental data is widely available. The quantum algorithm corresponds most closely to what isknown as "complete active configuration interaction" or "full configuration interaction" tech-niques, because the many-particle basis set includes all possible products of single particle basisvectors. This approach is most valuable in situations where the correlation energy is large andwhere many "configurations" are of similar energy (this typically occurs when many electronsare in open shells). Unfortunately, it is difficult to state precisely the minimum size problemfor which the quantum calculation surpasses the best classical calculations, because a varietyof sophisticated techniques are used to avoid the exponential explosion in basis states. That is,the most accurate classical calculations do not employ directly the "full configuration interac-tion" method. Based on [58], however, it appears that a calculation of the energy levels of B (559electrons), using roughly 20 angular wavefunctions and 40 radial wavefunctions per particle -for a total of 800 single particle wave functions and therefore 800- 0::10' 5 full many-body basisstates - may provide more accurate results than any classical calculation performed to date. Atthe very least, such a calculation would reveal scientifically interesting (and classically unob-tainable) results with respect to electron correlation energies in B and the relative importanceof various orders of excited configurations.A quantum calculation of the B ground state, using a basis set as described above, can beaccomplished with 60 qubits: 10 per particle (allowing 1024 states in the single-particle basis)to represent the state of the atom (for a total of 50 qubits), 6 or 7 qubits for the FFT, and afew additional "scratch" qubits' 0 . Unfortunately, the two particle operators (generated by thecoulomb attraction between pairs of electrons) take place in a subspace of dimension (210)2;they therefore are represented by matrices with 240 elements. Implementing such an operatorby brute force is likely to remain intractable for the foreseeable future. However, it is possibleto perform the necessary transformation using a quantum algorithm. One possible techniqueis to change basis sets: by representing the interacting particles in position space, instead ofwith the orbital basis set, it is easy to calculate the coulomb terms (because they are diagonalin this basis). Thus one can transform each particle into position space separately (requiringa small number of quantum logic operations), perform the time evolution corresponding to thecoulomb interaction, and then transform back. Unfortunately, a position space representationwill require many more qubits. A fairly conservative estimate is that 30 qubits per particle (10per dimension, for a real space grid of 1024x1024x1024 per particle) will more than suffice.Because these 30 qubits are required only temporarily for the 2 particles whose interaction weare considering at any particular stage in the algorithm, the new efficient algorithm requiresa total of 2 x 30 qubits (for the interacting particles), an additional 3 x 10 qubits (for theremaining particles), and the same 10 qubits for the FFT and work space. It thus appears thatin order to realistically perform an "interesting" calculation using the algorithms described10 The number of qubits required for the FFT is not as large as one might at first suppose, based on the earlierstatement that the accuracy scales linearly with the size of the FFT. This statement is true only for a fixed U. Bychanging U - in particular, by increasing the length of time t in U(t) - one can obtain the eigenvalues to arbitraryprecision using a fixed number of FFT points. However, the number of points in the FFT must be sufficientlylarge so as to seperate the frequencies corresponding to distinct eigenvectors. This is how the estimate of 6 or 7qubits (64 or 128 FFT points) is made.60previously, one will need a quantum computer with approximately 100 qubits. Of course, thepossibility remains that an efficient algorithm for implementing the coulomb interaction couldbe invented that does not require additional working space.3.4 ConclusionIn summary, I have explicitly demonstrated how a universal quantum computer can be used toefficiently simulate systems consisting of many Fermions. Depending on the particular problem,it may be preferable to employ second quantized notation (requiring m qubits) or first quantizednotation (requiring n log m qubits). An 0(n2 ) algorithm for creating an antisymmetrized super-position of states has been described. This chapter also provided detailed algorithms which willsimulate the Hubbard model, requiring 0(n2 ) quantum logic operations in first quantized form,and 0(m2 ) operations in second. The former algorithm employs a scheme for accommodatingnearly diagonal Hamiltonians that might be applied to a wider range of problems.Finally, this chapter demonstrated a new quantum algorithm which can be used to findeigenvectors and eigenvalues of a Hamiltonian operator. The algorithm provides an exponentialspeed increase when compared to the best known classical techniques. Problems from atomicphysics may be the best place to perform the first real calculations, both because accurateexperimental data is available to verify the resulting calculations, and because the parametersinvolved appear to be within the foreseeable range of small quantum computers. I have esti-mated that 50 - 100 qubits would be sufficient to perform "interesting" calculations that areclassically intractable.61Chapter 4Integrals and Stochastic Processes'Summary. This chapter will discuss quantum algorithms that calculate numerical integralsand various characteristics of stochastic processes, and describe how one may apply either quan-tum counting or Grover's mean estimation algorithm to solve these problems. Both of thesetechniques obtain an exponential speed increase in comparison to the fastest known classicaldeterministic algorithms and a quadratic speed increase in comparison to classical Monte Carlo(probabilistic) methods. I derive a simpler and slightly faster version of Grover's mean algo-rithm, show how to apply quantum counting to the problem, develop some variations of thesealgorithms, and show how both (apparently distinct) approaches can be understood from thesame unified framework. Finally, I'll discuss how the exponential speed increase appears to (butdoes not) violate results obtained via the method of polynomials, from which it is known thata bounded-error quantum algorithm for computing a total function can be only polynomiallymore efficient than the fastest deterministic classical algorithm.'This chapter is based upon work [5] which took place while the author was visiting NASA-JPL and whichwill be published separately.624.1 IntroductionAlthough quantum algorithms have been discovered that can solve many problems faster thanthe best known classical algorithms, there is a general sense - due, perhaps, to the enormoustechnical challenges that must be overcome before a useful quantum computer can ever be built- that more applications must be found in order to justify attempts to construct a quantumcomputing device.In this chapter I suggest one possible application of a quantum computer, namely, computingthe values of integrals. This problem can be solved in a fairly straightforward manner via eitherquantum counting[25], or Grover's mean estimation algorithm[57]. Although these generalalgorithms are not new, this application may be the most useful one described to date. (BecauseN operations are required to retrieve N values from a classical database, the mean findingalgorithm affords no speed-up when applied to a pre-existing data set. Indeed, even the originaldatabase search algorithm has only limited utility, because it can only be used to search afunction space. It is not clear to how many real-life problems it could be applied [103]).I also suggest that a quantum computer may be used to determine various characteristics ofstochastic processes. Frequently, such processes are used to generation distribution functions,and one wishes to know the mean, variance, and higher moments. One can apply quantumcounting and mean estimation to obtain super-classical speedups for these problems as well.On a quantum computer, one can find the value of a d-dimensional integral in O(1/E)operations, where e is the desired accuracy. It follows from the results of Nayak and Wu [76]that this is in fact a lower bound. Classically, one requires 0(1/E2 ) operations to achievethe same accuracy using probabilistic methods, and requires 0(1/Ed) - exponentially more- operations to achieve the same accuracy deterministically. (More precisely, it is polynomialin the accuracy and exponential in the number of dimensions.) Since real computers and allclassical devices are in fact deterministic, this exponential speed increase is by no means a redherring. Indeed, there is a popular misconception that real computers can perform probabilisticalgorithms with impunity by employing pseudo-random number generators. Of course, pseudo-random numbers are not truly random at all - and one must in fact be careful about treating63, - .them as such. For example, in 1992 Ferrenberg et al. found bugs in a supposedly good pseudo-random number generator when a numerical simulation of an Ising spin system failed due tohidden correlations in the "random" numbers[49]. The moral here is that one cannot rely upona classical computing device to properly execute a probabilistic algorithm. In some sense, onecould argue that the quantum algorithm for evaluating integrals provides an exponential speedincrease.4.2 Statement of the problem and classical algorithmsWithout loss of generality, one may consider integrals of a real-valued d-dimensional function9(X1, X2, -.-Xd) defined for xi in the range [0,1] and where g(X1, X2, ... Xd) E [0, 1], for all valuesof xi. Thus one seeks to calculateI =JJ... g(Xi, x2, ... )dd 2...dc (4.1)In the discussion that follows, g will be approximated with a real-valued d-dimensionalfunction f(ai, a2, ... ad) defined over integral values ai in the range [1, M] and wherea, a2 ad(42f (a,, a2,...a) = ( )(4.2)Thus, we wish to find the sum1 M M MS = ... E f(a, a2,...a) (4.3)ai=1 a2=1 ad=1Note that the sum S is identical to the average of f over all ai. The accuracy with whichthe sum S approaches the integral I is obviously determined by the density of points M in eachvariable and the shape of the particular function. However 2 , in what follows, our sole concern2Because the computational complexity of the quantum algorithms (and also the classical Monte Carlo algo-rithms, for that matter) depend only logarithmically on M, this approximation is not a limiting factor (as longas the function is not pathological).64I -will be with approximating the sum S.A sum of this form can also be used to determine properties of a stochastic process. Astochastic process may be described by a sequence of values, Wi, W2, ---, WN, where each valuewi is chosen randomly from a distribution which may depend on some (or all) w3 for j < i.For example, a simple random walk would be described by a sequence for which each wi iseither (Wi-1 + 1) or (wi_1 - 1) with equal probability. Often, one is interested in a propertyof such a sequence that can be represented as a function v(wi, w2, ... , WN). (In many cases, thefunction v may depend only upon the final value wN)- One wishes to determine the mean,variance, skewness, and possibly higher moments of the function v over the space of all possiblesequences. This problem is easily transformed into the form (4.1) through a change of variables:write each wi as a function wi(ri, Wi, w2, ... , Wi-1), where ri is a random variable in the range[0,1]. Then one can write v as a function v(ri, r2, ... , rN) of the independent random variablesri , scale the output so that it fits within the desired range, and obtain a function in the form gabove. The mean value of the stochastic process is then simply the integral (4.1). Once again,the integral is represented as a discrete sum. (For some stochastic processes, the problem mayin fact be discrete from the beginning). Thus the problem again reduces to finding the sum Sin (4.3).One can find higher moments of a stochastic process by simply applying the above approachto a calculation of the mean of v 2 , v3 , etc. This method can of course also be applied to calculatemoments of any distribution function (even if it is not the result of a stochastic process) as longas it can be represented in closed form.It should be intuitively obvious that without any knowledge of the function f, one requiresclassically O(Md) operations to evaluate the sum. More precisely, if one views f as an oracle(or "black-box"), then one requires at least Md/2 queries to determine S to within ±-1. (Thisis because it is possible that the remaining Md/2 unqueried function values may be eitherall O's or all l's, one of which will always shift the mean by at least ). It follows that anordinary classical Turing machine requires exponentially many operations (as a function of d)to determine S with accuracy E for any E < .65However, if one is allowed to employ a probabilistic algorithm, then one can randomly samplevalues of the function f for various al, a2, ...ad; as long as the values of a are chosen randomly(and provided that you are not exceedingly unlucky), it is possible to quickly approximateS to any desired precision. Indeed, it is a straightforward consequence of the central limittheorem that one can determine S with accuracy E (with bounded probability) using onlyQ(1/E 2 ) operations. Note that the number of trials does not depend at all upon the size ofthe function's domain - as it did in the deterministic case - but only on the desired accuracy.This is in fact how Monte Carlo integrals are computed, and is essentially the only practicalway to calculate integrals of functions with high dimensionality. (It is also why one need notbe concerned with the approximation of the integral I with the sum S - one can make Messentially as large as one desires, paying only a logarithmic cost in computational complexity).Unfortunately, Monte Carlo integrals on classical devices require the use of a pseudo-randomnumber generator, and as mentioned previously, there is no guarantee that one will obtain"good" random numbers. One obvious way to solve this dilemma would be to use a simplequantum event to produce a string of truly random numbers; but once one introduces quantummechanics into the problem, one can find an even more effective solution.4.3 Review of Grover searchingBoth of the quantum algorithms discussed in this chapter require a generalized version ofGrover searching. The treatment below follows that of Grover [57]; similar ideas have also beendescribed by Brassard et. al. [25] and various others.All quantum algorithms consist of unitary operations applied in series. Any sequence ofunitary operations can be viewed as a single unitary operator. Consider a particular unitaryoperator U which has amplitude Ut, between a starting state Is) and a target state It). If thecomputer is initially in the state Is), then after one application of U the computer will be foundin the state It) with amplitude Ut,, and if the state of the computer is measured in the canonicalbasis, the probability of obtaining the state It) will therefore be IUt8 12. We seek to amplify the66amplitude of the state It). (Increasing the amplitude of this state increases the chances that itwill be found upon measurement and thereby allows for fast searching).Amplitude amplification in it's simplest form requires the inversion operator I which in-verts the phase of the state Ix). We compose the unitary operators I and U to form the unitaryoperator G in the following way:.G = -ISU-'iIU (4.4)It can be easily verified that the operator G leaves invariant the subspace spanned by Is) andU-It). In particular, one finds thatG (als) + fUllt)) = {(1 - 4 IUtsI2)Q + 2Utsl Is) + {-2Ut*sa + 0} U- It) (4.5)which is approximately a rotation by 2 jUts radians. It follows that by applying 0(1/ IUtsI)iterations, one can obtain the state U-' t) with near certainty.The original fast searching algorithm [55][56] applies the above steps with U = W, whereW is the Walsh-Hadamard transform - that is, a 7r/2 rotation of each qubit. If the initialstate Is) = 100...0), then IUtsI = IWtI = 1/vN for all possible target states It). The unitaryoperation It selectively inverts the phase of the actual target state It) for which we are searching.After one application of W, the probability of measuring It) would be only y, the same as onewould obtain classically by guessing. However, it follows immediately from the above that theamplitude It) can be amplified to nearly 1 by applying only 0(v/N) operations.4.4 Integrals via amplitude amplificationTo evaluate the sum S in (4.3), one can use the mean estimation algorithm described by Groverin [57]. I provide a simpler version of this algorithm (that is also faster, because it requiresabout half as many quantum logic operations). The algorithm works by refining a series ofapproximations. One can obtain an intuitive understanding of the approach by employing67an analogy to classical coin-flipping. Consider a coin, which, when tossed, comes up headswith probability p = S. By the central limit theorem, one can determine S with accuracy Eusing 0(1/ E2 ) trials. Let us choose E = 0.1 so that after some (fixed) number of trials N wehave determined (with bounded probability) the first digit of p. 3 As a concrete example, letS = 0.7468332: the first set of trials would then reveal S to be approximately 0.7. Call thisfirst estimate El. Imagine now that we are given a second coin, which, when tossed, comes upheads with probability P2 = S-.7. Just as with the first coin, tossing the coin 0(1/ E2 ) timesdetermines P2 with accuracy E. Choosing the same E and number of trials N as before, we obtain(with bounded probability) the first digit of p2. But this is the second digit of S, and thus thecurrent estimate is now E2 = 0.74. We then undergo a third iteration in which p3 = S-0.74 inorder to determine the third digit of S. Continued iterations of this process, with more andmore refined "coins", allow one to determine S with arbitrary accuracy, each iteration requiringthe same amount of effort to reveal an extra digit. More precisely, one obtains an accuracy E'using only 0(n/ 2 ) coin tosses, or, stated differently, an accuracy 1 with log A coins and afixed number of tosses per coin. Of course, this classical algorithm would not work in practice,because it relies upon being given the requisite series of coins.The quantum algorithm works in a similar way. The final complexity of the algorithm willnot be limited by the number of trials, but by the fact that 0(1/ E) quantum logic operationsare required to "generate" the final coin (that reveals pi to accuracy E). More specifically, onegenerates a series of probabilities Pk and approximations Ek as follows:Eo = 0Pi ~ S El =pj1- a2 (4.6)p2 S - El E2 =E +P2- ap3 = S - E2 E3 = E2 + P3 -aetc. (4.7)3 Actually, this is not precisely true. If the value of p is very close to an integral mulitple of 0.1, then one doesnot have confidence regarding the first digit, even though one has accuracy 0.1. Hence the estimate used in thesecond iteration should actually be the estimate obtained minus one half the error. However, this detail does noteffect the basic principle of the algorithm.68pi ~ S - Ei_48ejEj = Ej-1 + pi - 22 (4.9)I shall now describe a quantum algorithm for estimating Pk to a given accuracy E. Defineh = f - E_1. Recall thatPk = S - EklM-1{f(al, a2,...a) - Ek-l}ala2...,ad=aa(,a2,.ad=.(4.10)(4.11)(4.12)Consider a quantum computer with d log 2 M + 1 qubits. Label the states Ir) jai, a2, ...ad) wherethe first qubit r is a work qubit and the remaining qubits indicate a value in the domain of f.The computer is placed initially in the zero state: I0)|00....0). We begin by applying a Walsh-Hadamard transform to the function qubits in order to obtain an equal superposition of allpossible values for the aj:(4.13)M-1I1 >= Vl 0)1ai, a2, ...ad)al,a2,...ad=ONext, rotate the first qubit by an amount k. The state is then|XF2 >=M-1a1,2,.... a=O1 - f(aa2,--ad)2 10)Jai, a2, ... ad) +k(a, a2,...ad)1)jai, a2,...ad)(4.14)Finally, perform the inverse of the Walsh-Hadamard transform used in the first step. Itis easy to see that the amplitude of the state 11)100...0) will then be Pk (because each state11) ai, a2, ..- ad) contributes amplitude 1dfk(ai, a2, ... ad) to the state 11)100...0)). An estimate69(4.8)for Pk can therefore be obtained by making measurements of the state of the system in repeatedtrials, and counting the frequency of the result 11)100...0). To obtain an accuracy E requires0(1/E2 ) measurements.However, one can use amplitude amplification to increase the accuracy of the estimate. Thesteps described above can be viewed as a single unitary operation U that has amplitude IUtsIbetween the starting state Is) = 0)I00...0) and the target state it) = 11)100...0). It follows thatone can use amplitude amplification to increase the probability of measuring the state 11)100...0).By performing only 0(N) operations, one can increase the amplitude of It) to N *pA. With thesame 0(1/E2 ) trials, one thus determines Pk with accuracy E* = E/N. By fixing e and choosinga large N, one performs only O(1/E*) operations to find Pk with accuracy E*.Of course, there is a limit to the size of N if we want the amplitude of It) to still beapproximately N * Pk. (Alternatively, the size of N is limited by the requirement that N * Pkremains a valid probability amplitude). This is why the algorithm requires several iterations.Initially, Pk may be any value between 0 and 1, and hence N can be at most 1. (That is, onecannot use amplitude amplification at all). As the estimates Ek-1 become more accurate, thenthe value of Pk becomes correspondingly smaller, and one can choose larger and larger N.Each estimate Pk is determined with a fixed number of trials, and since the estimates becomeexponentially more accurate with each Ek, the total number of trials is only a logarithmicfunction of the desired accuracy. Hence, the computational complexity is determined by theamplitude amplification. Within a polylogarithmic factor, the entire cost occurs on the lastiteration (because each iteration takes exponentially more time). The computational complexityof the entire algorithm is therefore the same as the amplitude amplification of the last iteration:0(1/ e*) operations are required, where E* is the desired accuracy.It is interesting to note that, as with the classical Monte Carlo method, the quantumalgorithm depends only upon the desired accuracy: the size of the function's domain (Md) isirrelevant.704.5 Integrals via quantum countingThere is another algorithm which can be used to evaluate the sum S in (4.3), inspired by the ideaof quantum counting [25]. To use this method, one must first convert the real-valued functionf(al, a2, ...ad) into a boolean valued function. This can be accomplished via the addition ofan extra parameter q. The parameter takes on integral values in the range [1,Q] where Q isdetermined by the desired accuracy. Defineb(al, a2, ...ad, q) 1 if q: f(ai, a2, ...ad) * QIn other words, for a given al, a2 , ...ad,the fraction of the Q values for which b(ai, a2, ...ad, q) = 1is the best approximation to f(ai, a2, ...ad). It follows that the average value of b is identicalto the average value of f. However, since b is a boolean-valued function, one can estimate theaverage value of b via approximate counting. That is, S = (b) = ' , where r is the numberof solutions b(ai, a 2, ...ad, q) = 1. To count the number of solutions r, recall that during theamplitude amplification process, the state of the system rotates within the subspace spannedby Is) and U 1 It) at a rate which is proportional to IUtsI. Moreover, recall that by usingthe Walsh-Hadamard transform for U (as in the Grover search algorithm), the magnitude ofUt, is exactly IUtsl = IWI = 1/V'r for any given target state Ii). But if the target stateIt) = I ji), then the amplitude of IUtsI = r/VN. Hence the amplitudes of the states Is)iEb(i)=1and U-1It) will oscillate with a frequency that varies directly with r. It is therefore a simplematter to create a superposition1A-11I' >= |AE j)GIs) (4.16)j=0and determine the value of r by performing a fast Fourier transform on the first register.The accuracy 1/A will depend linearly upon the number of points used in the FFT, as willthe number of quantum logic operations (because it takes 0(1) operations to perform G, onerequires O(A) operations to create the state IT > above). It follows that one can determine thevalue of the integral f to accuracy E with 0(1/ E) operations, as in the previous algorithm.71Also as above, one finds that the number of operations does not depend upon the size of thedomain of f, but only upon the desired accuracy.4.6 DiscussionAt first, it may appear surprising that these two very different quantum algorithms shouldboth require 0(1/ c) operations. However, by exploring some variations of these algorithms,one finds that, while not identical, they are both quite similar.First, note that there is a trivial variation of quantum counting, which is simply to measurethe state of the system in repeated trials, and count the number of times one obtains thetarget state (or more precisely, a state for which b(ai, a2, ...ad, q) = 1.) That is, we determinethe fraction ' = (b) = S through random sampling. This technique is directly analogousto the way, in Grover mean estimation, one finds the probability p, through repeated trials(counting the number of times we measure the target state 11) 100...0)). In both cases, 0(1/ E2)operations would be required to obtain an accuracy E. The difference is that using the Grovermethod, one can subtract the most recent estimate from each term in the sum (to obtain thefunction fk), and then perform amplitude amplification to increase the probability of obtainingthe target state. By amplifying this difference, the precision of the algorithm is limited bythe linear amplitude amplification process rather than by the quadratic sampling process. Inthe case of quantum counting, one can also apply the amplitude amplification process to thetarget state (indeed, this is exactly what the quantum counting algorithm does). However, onecannot subtract the most recent estimate from each term in the sum: specifically, for a givenai, a 2 , ... ad, there can be no less than zero values of q for which b(ai, a2, ... ad, q) = 1. In theGrover method, individual terms in the sum may be negative, even though the sum of all theterms is always positive. The counting method does not allow this possibility. It is thereforeimpossible to use the technique of iterated, refined estimates to increase the precision of theapproximation.The relationship can be viewed from another perspective by considering a variation ofGrover's method. As presented earlier, the technique depends upon measuring the amplitude72of the target state 11)100.. .0). This is accomplished through repeated measurements. However,one can also determine this amplitude with a quantum FFT. Recalling once again that duringthe amplitude amplification process the state of the system rotates within the subspace spannedby is) and U-1It), at a rate which is proportional to IUts j (which in this case is equal to pk),we see that one could also use an FFT to determine IUtsI (and therefore pk). As in the caseof quantum counting, one requires 0(1/ E) operations to obtain the result with accuracy E.Moreover, because the FFT measures the frequency of the rotation, one does not need toperform the iterated estimates (which previously ensured that the initial amplitude IUts I wassufficiently small that it would in fact be amplified throughout the entire process).The situation is in many ways similar to the relationship between Shor's algorithm andKitaev's algorithm[61]. In the Kitaev algorithm, one estimates the phase of an eigenvalue 4 ofa unitary operator U . The number of operations required to estimate # grows polynomially withthe desired precision, but Kitaev obtains exponential precision by considering U2, U U8,etc.This process is analogous to the refined estimates used in the Grover method. In [37], Cleve et.al. describe how to modify Kitaev's algorithm so that it uses an FFT to estimate the phase.The resulting algorithm is then identical to Shor's.One sees, therefore, that the two apparently distinct algorithms are in fact both very closelyrelated. In both cases, one performs a sequence of unitary operations that generate an operatorwith amplitude IUt8 I to make a transition from the 10) state to the target state It), where thevalue of IUts I depends directly on the sum S. In both cases, one may use a quantum FFT toestimate the value of IUtI and approximate S with accuracy E in 0(1/ c) operations. In bothcases, one may estimate the value of jUtI directly through repeated measurements and thenapproximate S with accuracy E in 0(1/ E2) operations. The only difference is that in Grover'smethod, the particular form of the operator U allows one to consider negative values fk - whichin turn allows one to use the process of iterated, refined estimates and thus to obtain linearprecision directly with repeated measurements instead of with the fast Fourier transform.734.7 ConclusionIn conclusion: I have proposed two new applications for quantum computation: evaluating inte-grals and calculating descriptive statistics of stochastic processes. Whereas O(Md) operationsare required on a classical deterministic Turing machine, and 0(1/ E2) operations are requiredwith a classical probabilistic algorithm, one can obtain the same accuracy on a quantum com-puter with only 0(1/ E) quantum operations, using two different algorithms. I have provided asimpler (and slightly more efficient) version of Grover's mean-finding algorithm, demonstratedhow quantum counting can be applied to mean estimation, derived some variations of bothalgorithms, and shown how the two are very closely related.It is interesting to consider these results in light of the work by Beals et. al. [8], whereit is proven (using the method of polynomials) that a bounded-error quantum algorithm forcomputing a total function can be only polynomially more efficient than the fastest deterministicclassical algorithm. A boolean function b(ai, a2, ...ad, q) such as the one described in Section5 can be described as a sequence of Mdq boolean values; the average of b is a function of thoseMdq boolean values, and it is a total function, since it is well-defined for all possible inputfunctions b. In order to phrase mean-estimation as a decision problem, we can ask: "Is theaverage value of b within the range [E- E, E+ E] ?" (for some chosen E and E). Naively, itappears that the results of [8] would imply that this problem cannot be speed up more thanpolynomially on a quantum computer (vs. a classical deterministic computer) - whereas I havepreviously claimed an exponential separation. It appears that there is a contradiction.4The (in fact quite simple) resolution of this problem is that the decision question posed abovedoes not quite correspond to mean-estimation. According to the question given, a function withmean just slightly (infinitesimally) more than E+ E does not have a mean that is approximatelyE, whereas a function that has mean exactly E+ E does. Of course, our quantum algorithmscannot reliably differentiate between these two cases in polynomial time any better than theclassical deterministic algorithms can. The decision question that one can associate with mean-estimation would be a probabilistic one; the answer should be sometimes yes and sometimes no4 Actually, this issue applies equally to the exponential separation between the classical deterministic andprobabilistic algorithms.74with a probability that depends (perhaps as a gaussian function) upon the distance the truemean is from the estimate E. Such a question is not a function (although it can be viewed asthe average value of a weighted ensemble of functions). Thus, the results obtained in [8] do notapply to our problem, and there is no contradiction.In concluding therefore the author would like to make the following point. It is easy forresults such as those in [8] to cause one to be disheartened about the prospects of quantumcomputing. However, sometimes the "real" problems we wish to solve have special propertiesthat can make them easier than the general cases. Calculating approximate integrals is onesuch example - and there are likely others waiting to be discovered.75Chapter 5Nonlinear Quantum Mechanics andNP-complete Problems'Summary. This chapter will demonstrate that nonlinear quantum mechanics allows for thepolynomial time solution of NP-complete and #P problems. If quantum states exhibit smallnonlinearities during time evolution, then by exploiting nonlinear quantum logic gates onecan design quantum algorithms that solve NP-complete and #P oracle problems. Using theWeinberg model as a simple example, the explicit construction of these gates will be derivedfrom the underlying physics. Nonlinear quantum algorithms are also presented using Polchinskitype nonlinearities which do not allow for superluminal communication.5.1 IntroductionIt has been suggested [97][98][50][65] [10] that under some circumstances the superpositionprinciple of quantum mechanics might be violated - that is, that the time evolution of quantumsystems might be (slightly) nonlinear. While there are reasons to believe that a theory ofquantum gravity may involve such nonlinear time evolution, nonlinear quantum mechanicsis at present hypothetical: experiments confirm the linearity of quantum mechanics to a high'The work described in this chapter is based upon [4] and [2].76A~.degree of accuracy[71] [95] [30][24]. (There are, however, some questions about the interpretationof these tests due to the effects of nonlinear quantum mechanics[81]). Nonlinear quantumtheories have also had theoretical difficulties[79] [81][54] - including problems with superluminalcommunication - but there are nonlinear theories that do not appear to have these issues[81].Thevalidity of nonlinear quantum mechanics is an important question that can only be settledby further experiments and the requirements of theoretical self-consistency. However, thischapter is concerned not with the validity of a particular nonlinear theory, but instead with theimplications of nonlinear quantum mechanics on the theory of computation, should quantummechanics in fact turn out to be nonlinear at some level. In particular, I'll show that itis possible to exploit nonlinear time evolution so that the classes of problems NP and #P(including oracle problems) may be solved in polynomial time. An experimental question -that is, the exact linearity of quantum mechanics - could thereby determine the answer towhat may have previously appeared to be a purely mathematical one. This chapter thereforeestablishes a new link between physical law and the theoretical power of computing machines,and demonstrates that the connection is much more subtle than one might suppose. Moreover,because almost all hard computational problems that occur naturally (in computer science,physics, engineering, etc.) are contained within the class of #P oracle problems, this resultcould (someday) be practically important as well.As explained in Chapter 1, the class NP is (loosely defined) the set of problems for which itis possible to verify a potential solution in polynomial time. These include all problems in theclass P (those that can be solved in polynomial time) as well as the NP-complete problems, e.g.,traveling salesman, satisfiability, and sub-graph isomorphism, for which no known polynomialtime algorithms exist. One natural way to approach these problems on a quantum computer isto create a superposition of every possible potential solution, and then try to determine if one ofthose potential solutions is in fact a true solution. In some sense, this technique nicely mimicsthe theoretical behavior of a non-deterministic Turing machine. In order to both simplify andgeneralize the result, it is convenient to replace the actual NP problem with an oracle problem,stated as follows: consider an oracle (or "black box") which calculates a function that mapsn bits into a single bit; i.e., it takes an input between 0 and 2' - 1 and returns either 0 or 1.One needs to determine if there exists an input value x for which f(x) = 1. It is easy to see77that a polynomial time algorithm to solve this problem can be used to solve all problems in theclass NP. (Note, however, that the converse is not necessarily true - the NP complete problemscontain structure, whereas the function defined above is completely arbitrary. Thus this oracleproblem is in fact a harder problem than those in NP, because it clearly requires exponentialtime on a classical Turing machine.) For simplicity we will at first restrict ourselves to the casewhere there is at most one value x for which f(x) = 1.5.2 First methodOne might attempt to solve this oracle problem on an ordinary quantum computer using thefollowing technique. First, create a superposition of all the input states:2"-1S 0)(5.1)Next, use the oracle to calculate f(i) for each 1i) in parallel:2"-1i, f(i)) (5.2)i=oAlthough the final qubit in some sense "knows" the solution to the problem, a measurement ofthis qubit will yield 11) with either zero probability if there is no solution or an exponentiallysmall probability if there is a solution. It is therefore necessary to enhance the amplitude of the11) component of the superposition by an exponentially large factor, in order to distinguish thetwo cases. One idea is to try to increase the number of states with a 11) rather than increasethe amplitude of the particular state 1i) for which f(i) = 1. Imagine comparing the states i)in pairs, according to the last bit of 1i). Looking at just the last bit of Ii) and the final qubit7811 -W.we see one of the following states:(a) 100) +l11)(b) 101) + 110) (5.3)(c) 100) + 110)The last case occurs most frequently. What we'd like to do is map these states into new statesusing the following transformation:(a) 100) +|11) -+01)+l11)(b) 101) + 110) -+ 101) + Il) (5.4)(c) 100) + 10) -+ 00) +110)This transformation is like an AND gate between branches of the wavefunction - it ignoresthe first qubit and places the second qubit in the state 11) if and only if either of the originalcomponents had the state 11) for the second qubit. Performing this transformation on thesuperposition of all 1i) will leave every state unaffected except the state which neighbors thesolution ix). This state will then pick up a 11) in place of the 10) which it originally had. Ifwe then compare states in pairs according to the second bit of i), the number of states with a11) for the final qubit will double again. Repeated application of this process would then leavethe final qubit unentangled with the first n qubits: it would be either in the pure state 10) ifthere are no solutions to the problem, or the pure state 11) if there had existed some state Ix)for which f(x) = 1. A measurement of this qubit thereby reveals the answer to the problem.Of course, this transformation cannot be accomplished using an ordinary quantum com-puter, because it is nonlinear. That this is the case can be easily seen by the fact that in cases(a) and (c) the initial states are non-orthogonal, but the final states are orthogonal. Hence thedesired transformation cannot possibly be linear. One is tempted to try to patch this problemin a variety of ways. One possibility is to imbed this transformation in a larger Hilbert spaceand hope that a projective subspace might reduce to the desired nonlinear transformation.Unfortunately, this approach cannot succeed. The reason is that different elements of the su-796. ;1..perposition need to interfere with each other in later stages of the algorithm. If the "linearized"version of the transformation results in extraneous "garbage" qubits, these will prevent thestates from interfering with each other in future iterations. Equivalently, one might hope thatthe non-unitary evolution associated with the measurement process might suffice to accomplishthe necessary transformation, but this will fail for the same reason. One can also try to hidethe extraneous information in the phases of the states. Although this appears promising atfirst, more careful analysis reveals essentially the same difficulties. 2One sees, therefore, that the potential application of a nonlinear quantum logic gate arisesnaturally from a fairly straightforward approach to the NP oracle problem. From an intuitiveperspective, however, it is not exactly clear why it is that nonlinearity is important, beyondthe fact that the gate which we desire for our algorithm does not happen to be linear. One canget a better feeling for this from a slightly different perspective.Consider the shortest-path version of the traveling salesman problem, and a classical algo-rithm that finds "pretty good" solutions, such as simulated annealing. Implement this algorithmon a quantum computer, and initialize the quantum computer in a state which as before is asuperposition of all possible inputs. After the algorithm has finished, the result will be a quan-tum computer that exists in a superposition of all the various local minima that are found bysearching from every possible initial state. A measurement would then reveal any one of theselocal minima, but most likely not the shortest path. Thus, what one would like to do beforethe measurement is to compare the various states with each other and shift the amplitude intothe states representing shorter paths. Put differently, we would like an algorithm which acts ina space that is restricted to only those quantum states which already have non-zero amplitude.Unfortunately, the linear transformations allowed by ordinary quantum mechanics have no way2 One can also imagine approaching the problem with phases from the very beginning, thereby avoiding theneed for the nonlinear gate. After calculating f(i), multiply the phase of the solution state by -1 and then reversethe computation of f(i). The computer would then be in an equal superposition of all li>, with the state Ix>forwhich f(x)=1 having opposite phase. Pairs of states containing two li>of opposite phase are orthogonal to thosefor which both |i>are of the same phase, so it is possible to reverse the phase of the pair, thereby transfering theminus sign from the solution Ix>to its partner state. Repeating the process which created the phase in the firstplace would then leave two states with negative phase. By iterating through each bit of li>(as in the previousalgorithm), one can continue the process until a substantial fraction of the states have negative phase. Thissituation can be easily detected. Unfortunately, each iteration takes twice as long as the previous one, so thealgorithm described in this footnote requires exponential time.80for a given state (or more precisely, component of a superposition) to "sense" the amplitude ofother states. This is the aspect of nonlinear quantum mechanics which allows for the solutionof NP-complete problems.Returning to the algorithm described above, it is clear that if one could obtain the necessarynonlinear transformation, one could find the answer to an NP-complete problem in polynomial(in fact, linear) time, and using only a single evaluation of the oracle. It may be objected thatthe nonlinear operator described above appears arbitrary and unnatural: indeed, it was selectedexactly so as to be able to solve the stated problem. However, the apparently arbitrary operationcan be built using ordinary unitary operations and much simpler and more 'natural' single qubitnonlinear operators (that is, to the extent that any nonlinear operation in quantum mechanicscan be considered 'natural'). One possible technique for generating the transformation wouldbe to use the following steps: first, act on the two qubits with the unitary operator1 0 0 1-- (5.5)0 1 -1 01 0 0 -1This transforms the states above as follows:1(a)-- [100) + |11)] - 00)2(b) - [101) + 110)] -+ 101) (5.6)1 1(c) - [100) + 110)] -+ [100) + 101) - 110) + 111)]Next, operate on the second qubit with a simple one qubit nonlinear gate n- that maps both81l0)and 11)to the state 10). Thus1(b) 1 [101) + 110)] -+ 100) (5.7)(c) 1 [100) + 110)] -- IA)The third final state is unknown because we have not bothered to specify how the non-lineargate acts on the state 100>+ 101>- 110>+ 11>. This omission thereby allows for flexibilityin choosing the gate -n. Whatever the state IA>may be, we can perform a unitary operationthat will transform the first qubit into the pure state l0)while leaving the state I00>in place.The computer is then in one of the following states(a) 10)10)(b) 10)10) (5.8)(c) 10)(xl0) + yl1))A second non-linear gate -+ is now required that will map the state x 10) + y 1) to the state11) (for the particular values of x and y which result from the above steps but not necessarilyfor arbitrary x and y), while leaving the state |0)unchanged. After this gate is applied, thetransformation resulting from the steps described so far is then:(a) [100) + 111)] - 1 00)(b) - [101) + 110)] - 1 00) (5.9)(c) -- [100) + 110)] -+ 101)The desired two qubit transformation is then easily obtained with a NOT gate on the secondqubit and a 7r/2 rotation on the first qubit.Having thus shown how to generate the needed two qubit gate, the question is now reducedto that of generating the simpler single qubit gates n_ and -n+. If one considers the state of a82qubit as a point on the unit sphere, then all unitary operations correspond to rotations of thesphere; and while such rotations can place two state vectors in any particular position on thesphere, they can never change the angle between two state vectors. A nonlinear transformationcorresponds to a stretching of the sphere, which will in general modify this angle. The desiredgates i_ and n+ are two particular examples of such operations. Excepting perhaps certainpathological cases (e.g., discontinuous transformations), it is evident that virtually any nonlinearoperator, when used repeatedly in combination with ordinary unitary transformations (whichcan be used to place the two state vectors in an arbitrary position on the sphere), can be usedto arbitrarily increase or decrease the angle between two states, as needed to generate the gatesR_ and n+. An explicit method for generating these gates using the Weinberg model will nowbe provided.5.3 An explicit construction using the Weinberg modelIn this section, an explicit construction of the necessary nonlinear gates is provided using theWeinberg model of nonlinear quantum mechanics. Although the Weinberg model is probablynot the most plausible nonlinear theory proposed to date, it serves as a good example becauseof its simplicity and generality, and because it is the most well-known nonlinear theory.In Weinberg's model, the "Hamiltonian" is a real homogeneous non-bilinear function h(O, 4'*)of degree one, that is[98]ak -~ = h (5.10)and state vectors time-evolve according to the equation&zPk .O8h-- = -a (5.11)Following Weinberg [98], one can always perform a canonical homogeneous transformation such83that a two-state system (i.e., a qubit) can be described by a Hamiltonian functionh = nh(a) (5.12)wheren = |0i|2 + |02I2 (5.13)a = 1/21 (5.14)nIt is easy to verify his solution to the time dependent nonlinear Schrodinger equation (5.11),which isOk(t) = cke-k() (5.15)wherewi(a) = h(a) - ah'(a) (5.16)W2(a) = h(a) + (1 - a)h'(a) (5.17)For nonlinear h(a), one sees that the frequencies depend on the magnitude of the initialamplitude in each basis state. Intuitively, one can imagine a transformation on the unit spherewhich, instead of rotating the sphere at a particular rate, twists the sphere in such a way sothat each point rotates at a rate which depends upon its angle 0 from the axis (clearly, thistransformation involves stretching of the surface). One can exploit this stretching of the sphereto build the gate 'n as follows:Step 1. Perform a rotation on the first qubit by an angle # < 450:10) -+ cos(#) 10) - sin(#) 1) (5.18)11) -+ sin(0) 10) + cos(#)I1) (5.19)84Step 2. Time-evolve the system according to the nonlinear Hamiltonian h = nh(a). Thus10) -* cos(#)10) - sin ()11) -- acos(#)0) - 3sin(#)11) (5.20)11) -+ sin(#) 10) + cos(#)11) -+ y cos(#)10) + 6 sin(O)11) (5.21)where a, , y and 6 are phase factors. Because the initial amplitudes of the basis states aredifferent in the two cases, the nonlinear Hamiltonian will cause the components to evolve atdifferent frequencies. As long as these frequencies are incommensurate, there is a time t atwhich a=-y=6=1 and 3=-l (to within an accuracy e). (Further, this time t is a polynomialfunction of the desired accuracy e.) The net result of these two steps is then10) - cos ()10) + sin(#) 1) (5.22)11) -- sin ()10) + cos(#)l1) (5.23)Step 3. Reverse the first step. Thus10) -+ cos(2#) 10) + sin(24)11) (5.24)11) - 1 I1) (5.25)Essentially, we have reduced the angle between the two states by an amount 2#. By suitablerepetition of this procedure (that is, by choosing # appropriately for each iteration), or simplyby choosing # precisely in the first step, the states 10>and I1>can be mapped to within e ofthe state 10>, in an amount of time which is a polynomial function of the desired accuracy.This is the desired behavior for the nonlinear gate i_. The procedure can be modified slightlyto increase the angle between state vectors and produce the desired behavior for the gate -n+.With these two gates, one can solve NP-complete problems using the Weinberg model.Note that this method is robust against small errors: the algorithm does not require expo-nentially precise operations at any stage.Finally, the class #P contains problems in which you must determine not only if there existsa solution, but the exact number of solutions. It is easy to see that the #P problems are much85harder to solve than NP-complete problems. To solve the problems in the class #P, one replacesthe flag qubit with a string of log 2 n qubits and modifies the algorithm slightly - so that it addsthe number of solutions in each iteration rather than performing what is effectively a one bitAND. In this case, a measurement of the final result reveals the exact number of solutions.5.4 Second methodA different algorithm that solves the NP oracle problem can be thought of as an extension ofGrover's data-base search algorithm[55] to a nonlinear regime. Suppose that it is possible toperform a nonlinear operation on a single qubit that has the following property: somewhere onthe unit sphere there exists a line (of not exponentially small extent) along which applicationof the operation causes nearby points to move apart exponentially rapidly. One can exploitthis behavior to solve NP problems in the following manner. Begin with an ordinary quantumcomputer (i.e., one that can perform the usual quantum logic operations) and place it in anequal superposition of all possible inputs. Then use the oracle (only once) to calculate f(i) andobtain the state:2n-1E/; i, f(i)) (5.26)i=ONow perform a 7r/2 rotation on each of the first n qubits. Each state Ii > then mapsinto a superposition over all possible ji >, with amplitude ±. In particular, each stateli>contributes +' of its amplitude to the state 100...0 >, for a total contribution of amplitudefrom each Ii >. At least 12n of these states correspond to a particular value of f(i) = a,and thus the state 100... .0, a > has amplitude at least 1/2. A measurement on the first n qubitswill therefore yield the state 100.. .0 > with probability at least 1/4. The system will then be inthe state2 n +2 00..0) ( { n - S 10) + - -1) (5.27)/22n - 2ns r+ 2 2 2) 21where s is the number of solutions i for which f (i) = 1. The last qubit now contains the86necessary information; for small s, however, a measurement of the last qubit will almost alwaysreturn 10), yielding no information. We wish to distinguish between the cases s=O and s>O. Thisis accomplished by repeatedly applying the nonlinear operation to drive the states representingthese two cases apart at an exponential rate: eventually, at a time determined by a polynomialfunction of the number of qubits n, the number of solutions s, and the rate of spreading, thetwo cases will become macroscopically distinguishable. A measurement on the last qubit willnow reveal the solution. Of course, if the angular extent of the nonlinear region is small, itmay be necessary to repeat the algorithm several times in order to determine the solution withhigh probability. In general, the algorithm will require Q((ir/q)2 ) trials, where q is the angularextent of the nonlinear region. The oracle may need to be called only once for 'q sufficientlylarge.Problems in the class #P ask us to determine the exact number of solutions s. This isapproximately found by counting the number of times that the nonlinear operator was applied.To determine s exactly, one proceeds with finer and finer estimates by rotating the final qubitsuch that the current best estimate is centered in the nonlinear region; in this way, applyingthe nonlinear operator separates states with s near this value so that they are distinguishable.With only a polynomial number of iterations, one determines the value s exactly.Unlike the first method described previously, the above algorithm has one disadvantagein that it requires exponential precision. However, it can be made robust against noise byintroducing a multiple qubit nonlinearity, as follows. Use the previous algorithm but calculatethe value f(i) a total of M times to obtain the state2' s000......0) + 8 I111....1) (5.28)By making M sufficiently large - a constant multiple of n will suffice - the amplitude of the stateswith more ones than zeros (such as 11101...1)) caused by random noise will be exponentiallysmaller then the amplitude caused by the existence of a single solution for which f(i) = 1.Hence, any nonlinear operator that rapidly increases the amplitude of states with more onesthan zeroes with respect to the amplitude of states with more zeroes than ones will suffice todistinguish reliably the cases s=0 and s=1, as required. Moreover, a nonlinearity of this type87satisfies the Polchinski criteria [81] for nonlinear quantum mechanics without superluminalcommunication. (A similar nonlinear operator is described in more detail by Czachor in [36]and was the inspiration for this approach).5.5 ConclusionIn conclusion: it has been demonstrated that nonlinear time evolution can in fact be exploitedto allow a quantum computer to solve NP-complete and #P problems in polynomial time. It hasbeen shown explicitly how to accomplish this exponential speed-up using the Weinberg modelof nonlinear quantum mechanics. A nonlinear quantum algorithm has also been presented usingPolchinski type nonlinearities which are known not to support superluminal communication.The author would like to emphasize that these results are probably best viewed as new andfurther evidence that the universe is exactly linear, rather than as blueprints for the design ofa machine if it were not. (Though it is certainly not obvious, a priori, that quantum mechanicsneed be strictly linear - and the question can be fairly viewed as an experimental one. Moreover,it is the mere existence of a nonlinearity, no matter how small, which changes the structureof the complexity classes.) Thus, the connection between physics and computation is nowmade unavoidable: the underlying laws of physics strongly impact the theoretical complexity ofcomputational problems. And while it does not seem likely that nonlinear time evolution doesexist in reality, the theoretical implications and practical applications that would result from adiscovery to the contrary may warrant further investigation into the matter.88Bibliography[1] D.S. Abrams and S. Lloyd, Phys. Rev. Lett. 79 (1997) 2586-2589[2] D.S. Abrams and S. Lloyd, Phys. Rev. Lett. 81 (1998) 3992-3995[3] D.S. Abrams and S. Lloyd, sub. to Phys. Rev. Lett., quant-ph/9807070[4] D.S. Abrams and S. Lloyd, Proceedings of the 1st NASA International Conference onQuantum Computing and Quantum Communications (1998)[5] D.S. Abrams and C. P. Williams, preprint[6] A. Barenco et. al., Phys. Rev. A 52, 3457 (1995)(7] A. Barenco et. al, Phys. Rev. Lett. 74, 4083 (1995)[8] R. Beals, H. Buhrman, R. Cleve, M. Mosca, R. de Wolf, in Proceedings of the 39th AnnualSymposium on Foundations of Computer Science (1998)[9] D. Beckman et. al, Phys. Rev. A 54, 1034 (1996)[10] 0. Bertolami, Physics Letters A, 154, p. 225-9 (1991)[11] P. Benioff, J. Stat. Phys. 22, 563 (1980)[12] P. Benioff, Phys. Rev. Lett. 48, 1581 (1982)[13] P. Benioff, J. Stat. Phys. 29, 515 (1982)[14] P. Benioff, Ann. N.Y. Acad. Sci. 480, 475 (1986)[15] P. Benioff, Review of Quantum Computation, preprint89[16] C.H. Bennet, IBM J. Res. Dev 17, p. 523-532 (1973)[17] C.H. Bennet, Int. J. Theor. Phys. 21, 905 (1982)[18] C.H. Bennet, SIAM J. Comput. 18, 766-776 (1989)[19] C.H. Bennet, IBM J. Res. Dev. 32, p. 16-23 (1988)[20] C.H. Bennet et. al, SIAM J. Comput. 26: (5) 1510-1523 OCT 1997[21] E. Berstein and U. Vazirani, Proceedings of the 25th Annual ACM Symposium on Theoryof Computing, (ACM, New York, 1993), P. 11[22] M. Biafore, Proceedings of the Workshop on Physics of Computation: PhysComp '94,IEEE Computer Society, Los Alamitos, CA, pp. 63-68[23] B. Boghosian and W. Taylor, Phys. Rev. E. vol 57 (1998), p. 54[24] J.J. Bollinger, D.J. Heinzen, W.M. Itano, S.L. Gilbert, D.J. Wineland, Phys. Rev. Lett.63, 1031 (1989)[25] G. Brassard, P. Hoyer, A. Tapp, quant-ph/9805082[26] S.L. Braunstein, C.M. Caves, R. Jozsa, N. Linden, S. Popescu, and R. Schack, quant-ph/9811018[27] G. Burkard, D. Loss, D. P. DiVincenzo, Phys. Rev. B 59, p. 2070 (1999)[28] A. R. Calderbank and P. W. Shor, Phys. Rev. A, Vol. 54, No. 2, pp. 1098-1106, 1996[29] A. R. Calderbank, E. M Rains, P. W. Shor, and N. J. A. Sloane, Phys. Rev. Lett. 78(1997) 405-408[30] T.E. Chupp and R.J. Hoare, Phys. Rev. Lett. 64, 2261 (1990)[31] J. I. Cirac and P. Zoller, Phys. Rev. Lett. 74, 4091 (1995)[32] S. A. Cook, Proc. 3rd Ann. ACM Symp. on Theory of Computing, Association forComputing Machinery, N.Y., 151-158 (1971)90[33] D. Coppersmith, IBM Research Report RC 19642 (1994)[34] D.G. Cory, A.F. Fahmy, and T. Havel, Proc. Nat. Acad. Sci. USA 94, 1634-1639 (1997)[35] D.G. Cory, private communication[36] M. Czachor, preprint (quant-ph/9802051)[37] R. Cleve, A. Ekert, C. Macchiavello, M. Mosca, Proc. R. Soc. Lond. A 454 (1998), pp.339-354[38] D.P. DiVincenzo, Science 270 255 (1995)[39] D.P. DiVincenzo, Phys. Rev. A., 51, 1015-1021 (1995)[40] D. Deutsch, Proc. R. Soc. London Ser. A 400, 97 (1985)[41] D. Deutsch, Proc. R. Soc. London Ser. A 425, 73 (1989)[42] D. Deutsch and R. Jozsa, Proc. R. Soc. Lond. A 439, 553 (1992)[43] D. Deutsch et. al, Proc. R. Soc. Lond. Ser A 449, 669 (1995)[44] A. Ekert and R. Jozsa, Reviews of Modern Physics 68 733 (1996)[45] E. Farhi, J. Goldstone, S. Gutmann, M. Sipser Phys. Rev. Lett. 81 (1998) 5442-5444[46] R.P. Feynman, Int. J. Theor. Phys. 21, 467 (1982)[47] R.P. Feynman, Optics News 11, p. 11-20; also in Foundations of Physics 16, 507-531(1986)[48] R.P. Feynman, Feynman Lectures on Computation, Perseus Books (Addison-Wesley) 1996[49] A. M. Ferrenberg and D. P. Landau, Phys. Rev. Lett. 69, 23 (1992) pp 33 82-3 38 4[50] D. Fivel, Phys. Rev. A 56, p. 146-56 (1997)[51] E. Fredkin and T. Toffoli, Int. J. Theor Phys. 21, 219 (1982)[52] M. Garey and D. Johnson, Computers and Intractability: A Guide to the Thoery ofNP-Completeness, W.H. Freeman and Company (1979)91F, . Ak -[53] N. A. Gershenfeld and I. Chuang, Science 275, 350-356 (1997)[54] N. Gisin, Phys. Lett. A 113, p. 1 (1990)[55] L.K. Grover, Proceedings of the Twenty-Eighth Annual ACM Symposium on the Theoryof Computing, p. 661, 212-19[56] L.K. Grover, Phys. Rev. Lett. 79, 325-328 (1997)[57] L.K. Grover, quant-ph/9711043[58] W. R. Johnson, private communication[59] B. E. Kane, Nature 393, 133 (1998)[60] R. M. Karp, in Complexity of Computer Computations, ed. by Miller and Thatcher,PLenum Press, N.Y., p. 85-103 (1972)[61] A. Yu. Kitaev, quant-ph/9511026[62] R. Landauer, IBM J. Res. Dev. 5, 183 (1961)[63] Philos. Trans. Roy. Soc. London Ser A 353, 367 (1995)[64] D. Lidar and 0. Biham, Phys. Rev. E vol.56 (1997), p. 36 6 1[65] B.G. Levy, Physics Today, 12 pp. 20 (1989)[66] D. Loss and D.P. Divincenzo, Phys. Rev. A.[67] S. Lloyd, Science 261, 1569 (1993)[68] S. Lloyd, Science 273, 1073 (1996)[69] S. Lloyd, Phys. Rev. Lett. 75, 346 (1995)[70] S. Lloyd, S. L. Braunstein, Phys.Rev.Lett. 82 (1999) 1784-1787[71] P.K. Majumder et. al., Phys. Rev. Lett. 65, 2931 (1990)[72] N. Margolus, Ann. N. Y. Acad. Sci. 480, pp. 487 (1986)92[73] N. Margolus, in Complexity, Entropy, and the Physics of Information, Santa Fe InstituteStudies in the Sciences of Complexity, Vol VIII (W.H. Zurek, ed.) Addison-Wesley, pp.273-287[74] N. Margolus, Physica, 10D, pp. 81-95 (1984).[75] C. Monroe et. al, Phys. Rev. Lett. 75, 4714 (1995)[76] A. Nayak and F. Wu., quant-ph/9804066[77] K. Obermayer, W.G. Teich, G. Mahler, Phys. Rev. B 37, 8096 (1988)[78] G.M. Palma et. al, Proc. R. Soc. London ser. A 452, 567 (1996)[79] A. Peres, Phys. Rev. Lett. 63, 1114 (1989)[80] T. Pellizzari, S.A. Gardiner, J.I. Cirac, P. Zoller, Physical Review Letters, 75, pp. 3788-3791 (1995).[81] J. Polchinski, Phys. Rev. Lett. 66, pg. 397 (1991)[82] J. Preskill, Proc. R. Soc. Lond. A 454, 385-410 (1998)[83] J. Preskill, unpublished notes, available at www.theory.caltech.edu/people/preskill/ph229/[84] R. Rivest, A. Shamir, and L. Adleman (1978) Comm. ACM 21, 120-126[85] B. Schumacher, Phys. Rev. A 51, 2738 (1995)[86] P. Shor, in Proceedings of the 35th Annual Symposium on Foundations of ComputerScience, edited by S. Goldwasser (IEEE Computer Society, Los Alamitos, CA, 1994),p.124[87] P. Shor, SIAM J. Computing 26 (1997) 1484[88] D. Simon, Proceedings of the 35th Annual Symposium on Foundations of ComputerScience, edited by S. Goldwasser (IEEE Computer Society, Los Alamitos, CA, 1994),p.116[89] M. Sipser, Introduction to the Theory of Computation, PWS Publishing Company (1997)93[90] T. Sleator and H. Weinfurter, Phys. Rev. Lett. 74, 4087 (1995)[91] A. Steane, Proc.Roy.Soc.Lond. A452 (1996) 2551[92] Q. A. Turchette et. al, Phys. Rev. Lett. 75, 4710 (1995)[93] A. Turing, Proc. Lond. Math. Soc. Ser. 2 42, 230-265 and 43, 544-546 (1936)[94] W.G. Unruh, Phys. Rev. A 51, 992 (1995)[95] R. L. Walsworth et. al., Phys. Rev. Lett. 64, 2599 (1990)[96] W. Warren, Science 277, 1688-1690 (1997)[97] S. Weinberg, Phys. Rev. Lett. 62, 485 (1989)[98] S. Weinberg, Ann. of Phys. 194, pg. 336 (1989)[99] S. Wiesner, quant-ph/9603028[100] W. K. Wootters and W. H. Zurek, Nature 299 (1982) pp. 802[101] A. Yao, in Proceedings of the 36th Annual Symposium on Foundations of ComputerScience, edited by S. Goldwasser (IEEE computer Society, Los Alamos, CA, 1995), p. 352[102] C. Zalka, Proc. R. Soc. Lond. A 454 (1998) pp. 313-322[103] C. Zalka, quant-ph/990106894

Quantum algorithms

Abstract

Similar works

Full text

Available Versions

DSpace@MIT