Top Banner
COMPUTER ENGINEERING STUDIES A seminar report on : “Quantum Structural Complexity” Prepared by : Durga Datta Kandel Roll No. : U07CO264 Class : B.TECH. IV (Computer Engineering) 7 th Semester Year : 2010-2011 Guided by : Dr. Devesh Jinwala

seminar report

Aug 18, 2014




A seminar report on :Quantum Structural Complexity

Prepared by : Roll No. Class Year : : :

Durga Datta Kandel U07CO264 B.TECH. IV (Computer Engineering) 7th Semester 2010-2011 Dr. Devesh Jinwala

Guided by :




CertificateThis is to certify that the seminar report entitled Quantum Structural Complexity ____________is presented by, U07CO264 , Final prepared and NO : Computer Durga Datta Kandel , bearing Roll Year of Engineering and his/her work is satisfactory.





IndexTitle Certificate Abstract List of Figures Notation Used Acknowledgement 1. Quantum Computation: Historical Development 1 2. Elements of Quantum Computing3 2.1 2.2 2.3 2.4 3.1 3.2 Qubit.3 Quantum Gate ..5 2.2.1 The CNOT gate6 Quantum Circuits.6 Quantum Algorithm.7 Complexity Models..9 Computational Complexity..10

3. Complexity Theory...9

4. Quantum Complexity Theory...11 4.1 4.2 4.3 4.4 Definition of the subject and Importance & Importance.11 Basic Complexity Class: Definition.12 Polynomial Time Quantum Computation15 4.3. 1 Polynomial Circuit Families and BQP...15 Quantum Proof.17 4.4.1 Definition of QMA..17

5. Conclusion19 Acknowledgement20 Reference...................................................................................................................... 21

List of Figures Fig. 2.1 The Bloch Sphere ..4 Fig. 2.2: The CNOT Gate5 Fig. 2.3: The Hadamard Gate..8 Fig 3.1: An example of a quantum circuit10 Fig. 4.1: Relation among Complexity Class...14 Fig. 4.2: Suspected relation among P, NP , BQP and QMA.......18

Notations : Pr[A] [ .] i AB AB AB |x| X A probability of event A reference index Quantum Stare Vector (-1) alphabet {0,1} All the language over A is subset of B Set A intersection Set B Set A union Set B modulus ( Length) X belongs to A


Quantum Computing generalizes and extend the notion of conventional computation by directly using the quantum mechanical phenomena such as entanglement and superposition to perform operation (quantum rule) on data encoded in physical system [1]. With the discovery of Shors Factorization Algorithm [2] and Grover's Search Algorithm [3], significant interest has been drawn in the field of Quantum Computing. Though practical quantum computing is still in its infancy, both practical and theoretical continues. It has become an attractive interdisciplinary research area in Physics, Mathematics and Computer Science with profound implication to all of these. Quantum effects like interference and entanglement play no direct role in conventional information processing, but they canin principle now, but probably eventually in practicebe harnessed to break codes, create unbreakable codes, and speed up otherwise intractable computations [5]. Following the sequences of results [2, 6, 7] suggesting that quantum computers are more powerful than classical probabilistic computers, a great deal of attention has focused on quantum computing. Several outstanding problems in Theoretical Computer Science can be tackled in a new approach. Several Important results have been found in Quantum Computational Complexity which can potentially shake the foundations of Theoretical Computer Science. Here, I give a brief introduction to quantum computing and track through the developments in Quantum Computational Complexity along with its implication to Computer Science.

1Quantum Computation: Historical DevelopmentA nice historical perspective of evolution of computational model as a physical system is given at [2]. The first person to look at the interaction between computation and quantum mechanics appears to have been Benioff [9]. Although he did not ask whether quantum mechanics conferred extra power to computation, he showed that reversible unitary evolution was sufficient to realize the computational power of a Turing machine, thus showing that quantum mechanics is at least as powerful computationally as a classical computer. This work was fundamental in making later investigation of quantum computers possible. Feynman [8] seems to have been the first to suggest that quantum mechanics might be more powerful computationally than a Turing machine. He gave arguments as to why quantum mechanics might be intrinsically expensive computationally to simulate on a classical computer. He also raised the possibility of using a computer based on quantum mechanical principles to avoid this problem, thus implicitly asking the converse question: by using quantum mechanics in a computer can you compute more efficiently than on a classical computer? Deutsch [10] was the first to ask this question explicitly. In order to study this question, he defined both quantum Turing machines and quantum circuits and investigated some of their properties. The question of whether using quantum mechanics in a computer allows one to obtain more computational power was addressed by Deutsch and Jozsa [11] and Berthiaume and Brassard [12]. These papers showed that there are problems which quantum computers can quickly solve exactly, but that classical computers can only solve quickly with high probability and the aid of a random number generator. However, these papers did not show how to solve any problem in quantum polynomial time that was not already known to be solvable in polynomial time with the aid of a random number generator, allowing a small probability of error; this isthe characterization of the complexity class BPP (defined later), which is widely viewed as the class of efficiently solvable problems. 1

Further work on this problem was stimulated by Bernstein and Variani [13]. One of the results contained in their paper was an oracle problem (that is, a problem involving a black box subroutine that the computer is allowed to perform, but for which no code is accessible) which can be done in polynomial time on a quantum Turing machine but which requires superpolynomial time on a classical computer. This result was improved by Simon [14], who gave a much simpler construction of an oracle problem which takes polynomial time on a quantum computer but requires exponential time on a classical computer. Indeed, while Bernstein and Vaziarnis problem appears contrived, Simons problem looks quite natural. Simons algorithm inspired the work presented in this paper. Two number theory problems which have been studied extensively but for which no polynomial-time algorithms have yet been discovered are finding discrete logarithms and factoring integers [2]. Its been sown that these problems can be solved in polynomial time on a quantum computer with a small probability of error.[2].Currently, nobody knows how to build a quantum computer, although it seems as though it might be possible within the laws of quantum mechanics. Some suggestions have been made as to possible designs for such computers [15], but there will be substantial difficulty in building any of these [16, 17]. The most difficult obstacles appear to involve the decoherence of quantum superposition through the interaction of the computer with the environment, and the implementation of quantum state transformations with enough precision to give accurate results after many computation steps. Both of these obstacles become more difficult as the size of the computer grows, so it may turn out to be possible to build small quantum computers, while scaling up to machines large enough to do interesting computations may present fundamental difficulties. Even if no useful quantum computer is ever built, this research does illuminate the problem of simulating quantum mechanics on a classical computer. Any method of doing this for an arbitrary Hamiltonian would necessarily be able to simulate a quantum computer. Thus, any general method for simulating quantum mechanics with at most a polynomial slowdown would lead to a polynomial-time algorithm for factoring.


Elements of Quantum Computing2.1 The QubitThe qubit is the quantum analogue of the bit, the classical fundamental unit of information. It is a mathematical object with specific properties that can be realized physically in many different ways as an actual physical system. Just as the classical bit has a state (either 0 or 1), a qubit also has a state. Yet contrary to the classical bit, 0 and 1 are but two possible states of the qubit, and any linear combination (superposition) thereof is also physically possible. In general, thus, the physical state of a qubit is the superposition = 0 + 1 (where and are complex numbers). The state of a qubit can be described as a vector in a two-dimensional Hilbert space, a complex vector space . The special states 0 and 1 are known as the computational basis states, and form an orthonormal basis for this vector space. According to quantum theory, when we try to measure the qubit in this basis in order to determine its state, we get either 0 with probability or 1 with probability . Since + = 1 (i.e., the qubit is a unit vector in the aforementioned two-dimensional Hilbert state), we may (ignoring the overall phase factor) effectively write its state as = cos() 0 + eisin() 1 , where the numbers and define a point on the unit three-dimensional sphere, as shown here. This sphere is often called the Bloch sphere, and it provides a useful means to visualize the state of a single qubit.

Theoretically, a single qubit can store an infinite amount of information, yet when measured it yields only the classical result (0 or 1) with certain probabilities that are specified by the quantum state. In other words, the measurement changes the state of the qubit, collapsing it from the superposition to one of its terms. The crucial point is that unless the qubit is measured, the amount of hidden information it stores is conserved under the dynamic evolution (namely, Schrdinger's equation). This feature of quantum mechanics allows one to manipulate the


information stored in unmeasured qubits with quantum gates, and is one of the sources for the putative power of quantum computers. 0

1 Fig. 2.1 The Bloch Sphere (Stanford Encyclopedia, Quantum Computing[25])

To see why, let us suppose we have two qubits at our disposal. If these were classical bits, then they could be in four possible states (00, 01, 10, 11). Correspondingly, a pair of qubits has four computational basis states ( 00 , 01 , 10 , 11 ). But while a single classical two-bit register can store these numbers only one at a time, a pair of qubits can also exist in a superposition of these four basis states, each of which with its own complex coefficient (whose mod square, being interpreted as probability, is normalized). As long as the quantum system evolves unitarily and is unmeasured, all four possible states are simultaneously stored in a single two-qubit quantum register. More generally, the amount of information that can be stored in a system of n unmeasured qubits grows exponentially in n. The difficult task, however, is to retrieve this information efficiently.


2.2 Quantum


Classical computational gates are Boolean logic gates that perform manipulations of the information stored in the bits. In quantum computing these gates are represented by matrices, and can be visualized as rotations of the quantum state on the Bloch sphere. This visualization represents the fact that quantum gates are unitary operators, i.e., they preserve the norm of the quantum state (if U is a matrix describing a single qubit gate, then UU=I, where U is the adjoint of U, obtained by transposing and then complex-conjugating U). As in the case of classical computing, where there exists a universal gate (the combinations of which can be used to compute any computable function), namely, the NAND gate which results from performing an AND gate and then a NOT gate, in quantum computing it was shown [18] that any multiple qubit logic gate may be composed from a quantum CNOT gate (which operates on a multiple qubit by flipping or preserving the target bit given the state of the control bit, an operation analogous to the classical XOR, i.e., the exclusive OR gate) and single qubit gates. One feature of quantum gates that distinguishes them from classical gates is that they are reversible: the inverse of a unitary matrix is also a unitary matrix, and thus a quantum gate can always be inverted by another quantum gate.

Fig. 2.2: The CNOT Gate.

Unitary gates manipulate the information stored in the quantum register, and in this sense ordinary (unitary) quantum evolution can be regarded as computation ([2] showed how a small set of single-qubit gates and a two-qubit gate is universal, in the sense that a circuit combined from this set can approximate to arbitrary accuracy any unitary transformation of n qubits). In 5

order to read the result of this computation, however, the quantum register must be measured. The measurement gate is a non-unitary gate that collapses the quantum superposition in the register onto one of its terms with the corresponding probability. Usually this measurement is done in the computational basis, but since quantum mechanics allows one to express an arbitrary state as a linear combination of basis states, provided that the states are orthonormal (a condition that ensures normalization) one can in principle measure the register in any arbitrary orthonormal basis. This, however, doesn't mean that measurements in different bases are efficiently equivalent. Indeed, one of the difficulties in constructing efficient quantum algorithms stems exactly from the fact that measurement collapses the state, and some measurements are much more complicated than others.

2.3 Quantum CircuitsQuantum circuits are similar to classical computer circuits in that they consist of wires and logical gates. The wires are used to carry the information, while the gates manipulate it (note that the wires do not correspond to physical wires; they may correspond to a physical particle, a photon, moving from one location to another in space, or even to time-evolution). Conventionally, the input of the quantum circuit is assumed to be a computational basis state, usually the state consisting of all 0 . The output state of the circuit is then measured in the computational basis, or in any other arbitrary orthonormal basis. The first quantum algorithms [2,3,20] were constructed in this paradigm. Additional paradigms for quantum computing exist today that differ from the quantum circuit model in many interesting ways. So far, however, they all have been demonstrated to be computationally equivalent to the circuit model (see below), in the sense that any computational problem that can be solved by the circuit model can be solved by these new models with only a polynomial overhead in computational resources.

2.4 Quantum AlgorithmsAlgorithm design is a highly complicated task, and in quantum computing it becomes even more complicated due to the attempts to harness quantum mechanical features to reduce the 6

complexity of computational problems and to speed-up computation. Before attacking this problem, we should first convince ourselves that quantum computers can be harnessed to perform standard, classical, computation without any speed-up. In some sense this is obvious, given the belief in the universal character of quantum mechanics, and the observation that any quantum computation that is diagonal in the computational basis, i.e., involves no interference between the qubits, is effectively classical. Yet the demonstration that quantum circuits can be used to simulate classical circuits is not straightforward (recall that the former are reversible while the latter use gates which are inherently irreversible). Indeed, quantum circuits cannot be used directly to simulate classical computation, but the latter can still be simulated on a quantum computer using an intermediate gate, namely the Toffoli gate. This gate has three input bits and three output bits, two of which are control bits, unaffected by the action of the gate. The third bit is a target bit that is flipped if both control bits are set to 1, and otherwise is left alone. This gate is reversible (its inverse is itself), and can be used to simulate all the elements of the classical irreversible circuit with a reversible one. Consequently, using the quantum version of the Toffoli gate one can simulate, although rather tediously, irreversible classical logic gates with quantum reversible ones. Quantum computers are thus capable of performing any computation which a classical deterministic computer can do. What about non-deterministic computation? Not surprisingly, a quantum computer can simulate also this type of computation by using another famous quantum gate, namely the Hadamard gate, which receives as an input the state 0 and produces the state ( 0 + 1 )/2. Measuring this output state yields 0 or 1 with 50/50 probability, which can be used to simulate a fair coin toss.


Fig. 2.3 : The Hadamard Gat

3Complexity Theory8

Complexity theory is concerned with the inherent cost required to solve information processing problems, where the cost is measured in terms of various well-defined resources. In this context, a problem can usually be thought of as a function whose input is a problem instance and whose corresponding output is the solution to it. Sometimes the solution is not unique, in which case the problem can be thought of as a relation, rather than a function. Resources are usually measured in terms of: some designated elementary operations, memory usage, or communication. We consider three specific complexity scenarios, which illustrate different advantages of working with quantum information

3.1 Complexity Models Computational complexity Query complexity Communication complexity

Despite the differences between these models, there are some intimate relationships among them. The usefulness of many currently-known quantum algorithms is ultimately best expressed in the computational complexity model; however, virtually all of these algorithms evolved from algorithms in the query complexity model. The query complexity model is a natural setting for discovering interesting quantum algorithms, which frequently have interesting counterparts in the computational complexity model. Quantum algorithms in the query complexity model can also be transformed into protocols in the communication complexity model that use quantum information (and sometimes these are more efficient than any classical protocol can be). Also, this latter relationship, taken in its contra-positive form, can be used to prove that some problems are inherently difficult in the query complexity model

3.2 Computational ComplexityIn the computational complexity scenario, an input is encoded as a binary string (say) and supplied to an algorithm, which must compute an output string corresponding to the input. For 9

example, in the case of the factoring problem, for input 100011 (representing 35 in binary), the valid outputs might be 000101 or 000111 (representing the factors of 35). The algorithm must produce the required output by a series of local operations. By this, we do not necessarily mean local in space, but, rather, that each operation involves a small portion of the data. In other words, a local operation is a transformation that is confined to a small number of bits or qubits (such as two or three). The above property is satisfied by Turing machines and circuits, and also by quantum Turing machines [6,10] and quantum circuits [21] . It is more convenient to use quantum circuit model of computation for our purpose here.

Fig 3.1: An example of a quantum circuit. (J. Watrous, Quantum Computational Complexity[4]) In the input qubits are labelled X1, . . . , X4, the output qubits are labeled Y1, . . . , Y3, and the gates are labeled by (hypothetical) quantum operations 1 , . . . , 6 .

4Quantum Complexity Theory4.1 Definition & Importance10

The inherent difficulty, or hardness, of computational problems is a fundamental concept in computational complexity theory. Hardness is typically formalized in terms of the resources required by different models of computation to solve a given problem, such as the number of steps of a deterministic Turing machine. A variety of models and resources are often considered, including deterministic, nondeterministic and probabilistic models; time and space constraints; and inter- actions among models of differing abilities. Many interesting relationships among these different models and resource constraints are known. One common feature of the most commonly studied computational models and resource constraint is that they are physically motivated. This is quite natural, given that computers are physical devices, and to a significant extent it is their study that motivates and directs research on computational complexity. The predominant example is the class of polynomial-time computable functions, which ultimately derives its relevance from physical considerations; for it is a mathematical abstraction of the class of functions that can be efficiently computed without error by physical computing devices. In light of its close connection to the physical world, it seems only natural that modern physical theories should be considered in the context of computational complexity. In particular, quantum mechanics is a clear candidate for a physical theory to have the potential for implications, if not to computational complexity then at least to computation more generally. Given the steady decrease in the size of computing components, it is inevitable that quantum mechanics will become increasingly relevant to the construction of computersfor quantum mechanics provides a remarkably accurate description of extremely small physical systems (on the scale of atoms) where classical physical theories have failed completely. Indeed, an extrapolation of Moores Law predicts sub- atomic computing components within the next two decades [83, 78]; a possibility inconsistent with quantum mechanics as it is currently understood. That quantum mechanics should have implications to computational complexity theory, how- ever, is much less clear. It is only through the remarkable discoveries and ideas of several researchers, including Richard Feynman [8], David Deutsch [10], Ethan Bernstein and Umesh Vazirani [13], and Peter Shor [2], that this potential has become evident. In particular, Shor s polynomial-time quantum factoring and discrete-logarithm algorithms [2] give strong support to the conjecture that quantum and classical computers yield differing notions of computational hardness. Other quantum complexity-theoretic concepts, such as the efficient verification of 11

quantum proofs, suggest a wider extent to which quantum mechanics influences computational complexity. It may be said that the principal aim of quantum computational complexity theory is to understand the implications of quantum physics to computational complexity theory. To this end, it considers the hardness of computational problems with respect to models of quantum computation, classifications of problems based on these models, and their relationships to classical models and complexity classes The notion of promise problems [17] is central to quantum computational complexity. These are decision problems for which the input is assumed to be drawn from some subset of all possible input strings. More formally, a promise problem is a pair A = ( Ayes, Ano), where Ayes, Ano are sets of strings satisfying Ayes Ano = . The strings contained in the sets Ayes and Ano are called the yes-instances and no-instances of the problem, and have answers yes and no, respectively. Languages may be viewed as promise problems that obey the additional constraint Ayes Ano = . Although complexity theory has traditionally focused on languages rather than promise problems, little is lost and much is gained in shifting ones focus to promise problems. Karp reductions (also called polynomial-time many-to-one reductions) and the notion of completeness are defined for promise problems in the same way as for languages.

4.2 Definition of Basic Complexity ClassesSeveral classical complexity classes are referred to in this article, and compared with quantum complexity classes when relations are known. The following classical complexity classes, which should hereafter be understood to be classes of promise problems and not just languages, are among those discussed[4] P: A promise problem A = ( Ayes, Ano) is in P if and only if there exists a polynomial-

time deterministic Turing machine M that accepts every string x Ayes and rejects every string x Ano. NP: A promise problem A = ( Ayes, Ano ) is in NP if and only if there exists a

polynomial-bounded function p and a polynomial-time deterministic Turing ma- chine M with 12

the following properties. For every string x Ayes, it holds that M accepts (x, y) for some string y p(|x |) , and for every string x Ano, it holds that M rejects (x, y) for all strings y p(| x |). BPP: A promise problem A = ( Ayes, Ano ) is in BPP if and only if there exists a

polynomial-time probabilistic Turing machine M that accepts every string x Ayes with probability at least 2/3, and accepts every string x Ano with probability at most 1/3. PP: A promise problem A = ( Ayes, Ano ) is in PP if and only if there exists a polynomial-

time probabilistic Turing machine M that accepts every string x Ayes with prob- ability strictly greater than 1/2, and accepts every string x Ano with probability at most 1/2 MA: A promise problem A = ( Ayes, Ano) is in MA if and only if there exists a

polynomial-bounded function p and a probabilistic polynomial-time Turing machine M with the following properties. For every string x Ayes, it holds that Pr[ M accepts (x, y)] 2/3 for some string y p(| x |) ; and for every string x Ano, it holds that Pr[ M accepts (x, y)] 1/3 for all strings y p(|x |). AM: A promise problem A = ( Ayes, Ano) is in AM if and only if there exist polynomial-

bounded functions p and q and a polynomial-time deterministic Turing machine M with the following properties. For every string x Ayes, and at least 2/3 of all strings y p(| x |) , there exists a string z q(|x |) such that M accepts (x, y, z); and for every string x Ano, and at least 2/3 of all strings y p(| x |) , there are no strings z q(|x |) such that M accepts (x, y, z). PSPACE: A promise problem A = ( Ayes, Ano ) is in PSPACE if and only if there exists a

deterministic Turing machine M running in polynomial space that accepts every string x Ayes and rejects every string x Ano.


Fig. 4.1 Relation among Complexity Class (J.Watrous, Quantum Computational Complexity [4]) The above diagram illustrates known inclusions among most of the classical complexity classes discussed in this paper. Lines indicate containments going upward; for example, AM is contained in PSPACE. EXP: A promise problem A = ( Ayes, Ano ) is in EXP if and only if there exists a deterministic Turing machine M running in exponential time (meaning time bounded by 2p , for some polynomial-bounded function p), that accepts every string x Ayes and rejects every string x Ano. NEXP: A promise problem A = ( Ayes, Ano ) is in NEXP if and only if there exists an exponential-time non-deterministic Turing machine N for A.

4.3 Polynomial time quantum computaton14

This section focuses on polynomial-time quantum computations. These are the computations that are viewed, in an abstract and idealized sense, to be efficiently implementable by the means of a quantum computer. In particular, the complexity class BQP (short for bounded-error quantum polynomial time) is defined. This is the most fundamentally important of all quantum complexity classes, as it represents the collection of decision problems that can be efficiently solved by quantum computers.

4.3.1 Polynomial-time generated circuit families & BQPLet S be any set of strings. Then a collection {Qx : x S} of quantum circuits is said to be polynomial-time generated if there exists a polynomial-time deterministic Turing machine that, on every input x S, outputs an encoding of Qx . This definition is slightly more general than what is needed to define BQP, but is convenient for other purposes. For instance, it allows one to easily consider the situation in which the input, or some part of the input, for some problem is hard-coded into a collection of circuits; or where a computation for some input may be divided among several circuits. In the most typical case that a polynomial-time generated family of the form {Qn N} is referred to, it should be interpreted that this is a shorthand for {Q1n Notice that every polynomial-time generated family {Qx : n : n N}.

: x S} has the property that

each circuit Qx has size polynomial in | x |. Intuitively speaking, the number of quantum and classical computation steps required to implement such a computation is polynomial; and so operations induced by the circuits in such a family are viewed as representing polynomial-time quantum computations. The complexity class BQP, which contains those promise problems abstractly viewed to be efficiently solvable using a quantum computer, may now be defined. More precisely, BQP is the class of promise problems that can be solved by polynomial-time quantum computations that may have some small probability to make an error. For decision problems, the notion of a polynomial-time quantum computation is equated with the computation of a polynomial-time generated quantum circuit family Q = {Qn : n N}, where each circuit Qn takes n input qubits, and produces one output qubit. The computation on a given input string is obtained by first applying the circuit Q| x | to the state |x)(x|, and then measuring the output 15

qubit with respect to the standard basis. The measurement results 0 and 1 are interpreted as yes and no (or accept and reject), respectively. The events that Q accepts x and Q rejects x are understood to have associated probabilities determined in this way. BQP Let A = ( Ayes, Ano ) be a promise problem and let a, b : N [0, 1] be functions. Then, A BQP(a, b) if and only if there exists a polynomial-time generated family of quantum circuits Q = {Qn : n N}, where each circuit Qn takes n input qubits and

produces one output qubit, that satisfies the following properties:

1. if x Ayes then Pr[Q accepts x] a(| x |), and 2. if x Ano then Pr[Q accepts x] b(| x |).

The class BQP is defined as BQP = BQP(2/3, 1/3). Similar to BPP, there is nothing special about the particular choice of error probability 1/3, other than that it is a constant strictly smaller than 1/2. This is made clear in the next section. There are several problems known to be in BQP but not known (and generally not believed) to be in BPP. Decision-problem variants of the integer factoring and discrete logarithm problems, shown to be in BQP by Shor [94], are at present the most important and well-known examples.

4.4 Quantum proofs


There are many quantum complexity classes of interest beyond BQP. This section concerns one such class, which is a quantum computational analogue of NP. The class is known as QMA, short for quantum MerlinArthur, and is based on the notion of a quantum proof: a quantum state that plays the role of a certificate or witness to a quantum computer that functions as a verification procedure. Tnterest in both the class QMA and the general notion of quantum proofs is primarily based on the fundamental importance of efficient verification in computational complexity. The notion of a quantum proof was first proposed by Knill [22] and consider more formally by Kitaev (presented at a talk in l999 [23] and later published in [24]).

4.4.1 QMA The definition of QMA is inspired by the standard definition of NP included in Section TT.l of this article. This definition is of course equivalent to the other well-known definition of NP based on nondeterministic Turing machines, but is much better-suited to consideration in the quantum settingfor non-determinism is arguably a non-physical notion that does not naturally extend to quantum computing. In the definition of NP from Section 4.2, the machine M functions as a verification procedure that treats each possible string y p(|x |) as a potential proof that x Ayes. The conditions on M are known as the completeness and soundness conditions, which derive their names from logic: completeness refers to the condition that true statements have proofs, while soundness refers to the condition that false statements do not. To define QMA, the set of possible proofs is extended to include quantum states, which of course presumes that the verification procedure is quantum. As quantum computations are inherently probabilistic, a bounded probability of error is allowed in the completeness and soundness conditions. (This is why the class is called QMA rather than QNP, as it is really MA and not NP that is the classical analogue of QMA.)


Fig. 4.2: Suspected relation among P, NP , BQP and QMA ( QMA :Let A = ( Ayes, Ano ) be a promise problem, let p be a polynomial-bounded function, and let a, b : N [0, 1] be functions. Then A QMA p (a, b) if and only if there exists a polynomial-time generated family of circuits Q = {Qn : n N}, where each circuit Qn takes n + p(n) input qubits and produces one output qubit, with the following properties Completeness. For all x Ayes, there exists a p(| x |)-qubit quantum state p accepts (x, p)] a(| x |). Soundness. For all x Ano and all p(| x |)-qubit quantum states p it holds that Pr[Q accepts (x, p)] b(| x |). such that Pr[Q

Also it is defined that QMA =U p QMA p (2/3, 1/3), where the union is over all polynomialbounded functions p


Quantum complexity theory is a part of computational complexity theory in theoretical computer science. It studies complexity classes defined using quantum computers and quantum information which are computational models based on quantum mechanics. It studies the hardness of problems in relation to these complexity classes, and the relationship between quantum complexity classes and classical (i.e., non-quantum) complexity classes. A complexity class is a collection of problems which can be solved by some computational model under resource constraints. For instance, the complexity class P is defined to be the set of problems solvable by a Turing machine in polynomial time. Similarly, one may define a quantum complexity class using a quantum model of computation, such as a standard quantum computer or a quantum Turing machine. Thus, the complexity class BQP is defined to be the set of problems solvable by a quantum computer in polynomial time with bounded error. Two important quantum complexity classes are BQP and QMA which are the boundederror quantum analogues of P and NP. One of the main aims of quantum complexity theory is to find out where these classes lie with respect to classical complexity classes such as P, NP, PP, PSPACE and other complexity classes.

AcknowledgementI am very much thankful to my guide Prof. Devesh Jinwala. While allowing me to work flexibly he has inculcated in me standard research practices: respecting and acknowledging 19

others work and communicating our own ideas in a very clear way. We had fruitful discussion about complexity theory. In every work and endeavor of mine in Quantum Computing, Prof. Prasanta Panigarihi, IISER-K, Department of Theoretical Physics, will be reflected in some ways. Summer and Winter School on Quantum Information Theory which I attended under is guidance helped me quite a lot in understanding the intricate ideas of Quantum Information Theory which are otherwise quite challenging for a person like me a non-major in Physics/Mathematics. Its my honour to remember him here.

I would also like to thank Prof. Shengyu Zhang, Computer Science Department, Chinese University of Hong Kong, constant interaction with whom is inspiring me to devote my life in the fundamental research of Quantum Algorithms and Complexity Theory. He guided me to select this particular topic among other interesting areas in Quantum Computation. I have extensively used this Book Quantum Computation and Quantum Information by Nielson and Chuang for this seminar as well as my other work in Quantum Computation. Survey paper Quantum Computational Complexity by J.Watrous, IQC, Canada also proved extremely useful. I am indebted to authos of various books, research and sruvery paper and othere useful resources I have consulted for my seminar. I have duly cited all resourceas I have used with gratitude and thanks.

References[1] [2] Michael Nielsen, Isaac Chuang, Quantum Computation and Quantum Information" , Cambridge University Press (2000). Peter Shor, Algorithms for Quantum Computation: Discrete Logarithms and Factoring," Proceedings of the 35th Annual Symposium on Foundations 20

of Computer Science (1994), 124-134. [3] L. Grover, A fast quantum mechanical algorithm for database search" Proceedings of the 28th Annual ACM Symposium on the Theory of Computing (STOC 1996), (1996) 212-219. [4] [5] [6] [7] [8] [9] J. Watrous, Quantum computational complexity",Proceedings of the thirty-third annual ACM symposium on Theory of computing (STOC), 60-67,(2001). C.Bennet et alQuantum Information and Computation Nature, Vol. 404, 16 March (200) 247-255 Bernstein, E. and Vazirani, U., Quantum complexity theory, Proceedings of the 25th Annual ACM Symposium on Theory of Computing, 1993, pp. 11 20. [Simon, D., On the power of quantum computation, Proceedings of the 35th Annual IEEE Symposium on Foundations of Computer Science, 1994, pp. 116 123. R. Feynman (1982), Simulating physics with computers, Internat. J. Theoret. Phys., 21, pp. 467488. P. Benioff (1980), The computer as a physical system: A microscopic quantum mechanical Hamiltonian model of computers as represented by Turing machines, J. Statist. Phys., 22, pp. 563591. [10] [11] D. Deutsch (1985), Quantum theory, the ChurchTuring principle and the universal quantum computer, Proc. Roy. Soc. London Ser. A, 400, pp. 96117. A. Berthiaume, D. Deutsch, and R. Jozsa (1994), The stabilisation of quantum computations, in Proceedings of the Workshop on Physics of Computation: PhysComp 94, IEEE Computer Society Press, Los Alamitos, CA, pp. 6062. [12] [13] [14] A. Berthiaume and G. Brassard (1992a), The quantum challenge to structural Complexity Society Press, Los Alamitos, CA, pp. 132137. C. Bennett, E. Bernstein,G. Brassard, and U. Vazirani. Strengths andweaknesses of quantum computing. SIAM Journal on Computing, 26(5):15101523, 1997. D. Simon (1994), On the power of quantum computation, in Proceedings of the 35th Annual Symposium on Foundations of Computer Science, IEEE Computer Society Press, Los Alamitos, CA, pp. 116123. [15] S. Lloyd (1993), A potentially realizable quantum computer, Science, 261, pp. 1569 1571.


[16] [17] [18] [19] [20] [21] [22]

R. Landauer (1995), Is quantum mechanics useful? Philos. Trans. Roy. Soc. London Ser. A. O. Goldreich. On promise problems (a survey in memory of Shimon Even [1935 2004]). Electronic Colloquium on Computational Complexity, Report TR05-018, 2005. Barenco, A. et al. (1995), Elementary gates for quantum computation, Phys. Rev., A 52: 34573467. DiVicenzo, D. (1995), Two-bit gates are universal for quantum computation, Phys. Rev., A 51: 10151022. Deutsch, D. and Jozsa, R. (1992), Rapid solution of problems by quantum computer, Proc. Roy. Soc. Lond, A 439: 553558. A. C.-C. Yao, Quantum circuit complexity, Proc. 34th Ann. IEEE Symp. on Foundations of Computer Science (FOCS 93), pp. 352361, 1993. E. Knill. Quantum randomness and nondeterminism. Technical Report LAUR-96- 2186, Los Alamos National Laboratory, 1996. Available as e-Print quantph/9610012.

[23] [24] [25] [26]

A. Kitaev. Quantum NP. Talk at AQIP99: SecondWorkshop on Algorithms in Quantum Information Processing, DePaul University, January 1999. A. Kitaev, A. Shen, and M. Vyalyi. Classical and Quantum Computation, volume 47 of Graduate Studies in Mathematics, American Mathematical Society, 2002. Quantum Computing (Stanford Encyclopedia of Philosophy) R. Landauer (1995), Is quantum mechanically coherent computation useful? in Proceedings of the Drexel-4 Symposium on Quantum NonintegrabilityQuantum Classical Correspondence, D. H. Feng and B-L. Hu, eds., International Press,


Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Related Documents