Quantum Complexity Theory Ronald de Wolf April 4, 2011 1 Most functions need exponentially many gates As we have seen, quantum computers seem to provide enormous speed-ups for problems like fac- toring, and square-root speed-ups for various search-related problems. Could they be used to speed up almost all problems, at least by some amount? Here we will show that this is not the case: as it turns out, quantum computers are not significantly better than classical computers for most computational problems. Consider the problem of computing a Boolean function f : f0; 1gn ! f0; 1g by means of a quantum circuit. Ideally, most such functions would be computable by efficient quantum circuits (i.e., using at most poly(n) elementary gates). Instead, we will show by means of a simple counting argument that almost all such functions f have circuit complexity nearly 2n. This is a variant of a well-known counting argument for classical Boolean circuits due to Shannon. Let us fix some finite set of elementary gates, for instance the Shor basis fH; Pπ=8; CNOTg or fH; Toffolig. Suppose this set has k gates, of maximal fanout 3. Let us count the number of distinct circuits that have at most C elementary gates. For simplicity we include the initial qubits (the n input bits as well as workspace qubits, which are initially j0i) among those C gates. First we need to choose which type of elementary gate each of the C gates is; this can be done in kC ways. Now every gate has at most 3 ingoing and 3 outgoing wires. For each of its 3 outgoing wires we can choose an ingoing wire for one of the gates in the following level; this can be done in at most C3 ways. Hence the total number of circuits with up to C elementary gates is at most kC C3C = CO(C). We are clearly overcounting here, but that's OK because we want an upper bound on the number of circuits. We'll say that a specific circuit computes a Boolean function f : f0; 1gn ! f0; 1g if for every input x 2 f0; 1gn, a measurement of the first qubit of the final state (obtained by applying the circuit to intial state jx; 0i) gives value f(x) with probability at least 2=3. Each of our CO(C) circuits can compute at most one f (in fact some of those circuits don't compute any function at all). Accordingly, with C gates we can compute at most CO(C) distinct Boolean functions f : f0; 1gn ! f0; 1g. Hence even if we just want to be able to compute 1% of all 22n Boolean functions then we already need 1 n CO(C) ≥ 22 , which implies C ≥ Ω(2n=n): 100 Accordingly, very few computational problems will be efficiently solvable on a quantum computer. Below we will try to classify those using the tools of complexity theory. 1 2 Classical and quantum complexity classes A \complexity class" is a set of decision problems (a.k.a. \languages") that all have similar com- plexity in some sense, for instance the ones that can be solved with polynomial time or polynomial space. Let us first mention some of the main classical complexity classes: • P. The class of problems that can be solved by classical deterministic computers using polynomial time. • BPP. The problems that can be solved by classical randomized computers using polynomial time (and with error probability ≤ 1=3 on every input). • NP. The problems where the `yes'-instances can be verified in polynomial time if some prover gives us a polynomial-length \witness". Some problems in this class are NP-complete, meaning that any other problem in NP can be reduced to it in polynomial time. Hence the NP-complete problems are the hardest problems in NP. An example is the problem of satisfiability: we can verify that a given n-variable Boolean formula is satisfiable if a prover gives us a satisfying assignment, so it is in NP, but one can even show that is NP-complete. Other examples are integer linear programming, travelling salesman, graph-colorability, etc. • PSPACE. The problems that can be solved by classical deterministic computers using polynomial space. We can consider quantum analogues of all such classes, an enterprise that was started by Bernstein and Vazirani [1]: • EQP. The class of problems that can be solved exactly by quantum computers using poly- nomial time. This class depends on the set of elementary gates one allows, and is not so interesting. • BQP. The problems that can be solved by quantum computers using polynomial time (and with error probability ≤ 1=3 on every input). This class is the accepted formalization of “efficiently solvable by quantum computers." • QNP. The problems where the `yes'-instances can be verified efficiently if some prover gives us a polynomial-length \quantum witness." This is again dependent on the elementary gates one allows, and not so interesting. Allowing error probability ≤ 1=3 on every input, we get to a class called QMA (\quantum Merlin-Arthur"). This is a more robust and more interesting quantum version of NP; unfortunately we don't have time to study it in this course. • QPSPACE. The problems that can be solved by quantum computers using polynomial space. This turns out to be the same as classical PSPACE. We should be a bit careful about what we mean by a \polynomial time [or space] quantum algo- rithm." Our model for computation has been quantum circuits, and we need a separate quantum circuits for each new input length. So a quantum algorithm of time p(n) would correspond to a family of quantum circuits fCng, where Cn is the circuit that is used for inputs of length n; it should have at most p(n) elementary gates.1 1 To avoid smuggling loads of hard-to-compute information into this definition (e.g., Cn could contain information about whether the nth Turing machine halts or not), we will require this family to be efficiently describable: there 2 In the next section we will prove that BQP ⊆ PSPACE. We have BPP ⊆ BQP, because a BPP-machine on a fixed input length n can be written as a polynomial-size reversible circuit (i.e., consisting of Toffoli gates) that starts from a state that involves some coin flips. Quantum computers can generate those coin flips using Hadamard transforms, then run the reversible circuit, and measure the final answer bit. It is believed that BQP contains problems that aren't in BPP, for example factoring large integers: this problem (or rather decision-version thereof) is in BQP because of Shor's algorithm, and is generally believed not to be in BPP. Thus we have the following sequence of inclusions: P ⊆ BPP ⊆ BQP ⊆ PSPACE: It is generally believed that P = BPP, while the other inclusions are believed to be strict. Note that a proof that BQP is strictly greater than BPP (for instance, a proof that factoring cannot be solved efficiently by classical computers) would imply that P 6= PSPACE, solving what has been one of the main open problems in computers science since the 1960s. Hence such a proof|if it exists at all|will probably be very hard. What about the relation between BQP and NP? It's generally believed that NP-complete problems are probably not in BQP. The main evidence for this is the lower bound for Grover search: a quantum brute-force search on all 2n possible assignments to an n-variable formula gives a square-root speed-up, but not more. This is of course not a proof, since there might be clever, non-brute-force methods to solve satisfiability. There could also be problems in BQP that are not in NP, so it may well be that BQP and NP are incomparable. Much more can be said about quantum complexity classes; see for instance Watrous's survey [3]. 3 Classically simulating quantum computers in polynomial space When Richard Feynman first came up with quantum computers [2], he motivated them by \the full description of quantum mechanics for a large system with R particles is given by a function q(x1; x2; : : : ; xR; t) which we call the amplitude to find the particles x1; : : : ; xR [RdW: think of xi as one qubit], and therefore, because it has too many variables, it cannot be simulated with a normal computer with a number of elements proportional to R or proportional to N." [. ] \Can a quantum system be probabilistically simulated by a classical (probabilistic, I'd assume) universal computer? In other words, a computer which will give the same probabilities as the quantum system does. If you take the computer to be the classical kind I've described so far, (not the quantum kind described in the last section) and there are no changes in any laws, and there's no hocus-pocus, the answer is certainly, No!" The suggestion to devise a quantum computer to simulate quantum physics is of course a brilliant one, but the main motivation is not quite accurate. As it turns out, it is not necessary to keep track of all (exponentially many) amplitudes in the state to classically simulate a quantum system. Here we will show that it can actually be simulated efficiently in terms of space [1], though not necessarily in terms of time. should be a classical Turing machine which, on input n and j, outputs (in time polynomial in n) the jth elementary gate of Cn, with information about where its incoming and outcoming wires go.