COMPUTER ENGINEERING STUDIES

A seminar report on :
“Quantum Structural Complexity”

Prepared by : Durga Datta Kandel

Roll No. : U07CO264

Class : B.TECH. IV (Computer Engineering) 7th Semester

Year : 2010-2011

Guided by : Dr. Devesh Jinwala

DEPARTMENT OF COMPUTER ENGINEERING

SARDAR VALLABHBHAI NATIONAL INSTITUTE OF TECHNOLOGY,
SURAT - 395 007 (GUJARAT, INDIA)
 Certificate

This is to certify that the seminar report entitled

“Quantum Structural Complexity”
____________ is prepared and presented by,
Durga Datta Kandel ,
bearing Roll NO : U07CO264 , Final Year of Computer
Engineering and his/her work is satisfactory.

SIGNATURE :

GUIDE JURY HEAD OF DEPT.

 Index
Title
Certificate
Abstract
List of Figures
Notation Used
Acknowledgement

1. Quantum Computation: Historical Development ……………………………………1

2. Elements of Quantum Computing……………………………………………………3
2.1 Qubit…………………………………………………………………….3
2.2 Quantum Gate …………………………………………………………..5
2.2.1 The CNOT gate…………………………………………………6
2.3 Quantum Circuits……………………………………………………….6
2.4 Quantum Algorithm…………………………………………………….7
3. Complexity Theory…………………………………………………………………...9
3.1 Complexity Models……………………………………………………..9
3.2 Computational Complexity……………………………………………..10

4. Quantum Complexity Theory………………………………………………………...11

4.1 Definition of the subject and Importance & Importance……………….11
4.2 Basic Complexity Class: Definition…………………………………….12
4.3 Polynomial Time Quantum Computation………………………………15
4.3. 1 Polynomial Circuit Families and BQP…………………………...15
4.4 Quantum Proof………………………………………………………….17
4.4.1 Definition of QMA……………………………………………..17
5. Conclusion……………………………………………………………………………19
Acknowledgement……………………………………………………………………20
Reference......................................................................................................................
21
List of Figures

Fig. 2.1 The Bloch Sphere …………………………………………………………………..4

Fig. 2.2: The CNOT Gate……………………………………………………………………5

Fig. 2.3: The Hadamard Gate………………………………………………………………..8
Fig 3.1: An example of a quantum circuit…………………………………………………10
Fig. 4.1: Relation among Complexity Class………………………………………………...14
Fig. 4.2: Suspected relation among P, NP , BQP and QMA…………………………….......18

Notations :
Pr[A] probability of event A
[ .] reference index

ψ Quantum Stare Vector

i √(-1)
Σ alphabet {0,1}
Σ∗ All the language over Σ
A⊆B A is subset of B
A∩B Set A intersection Set B
A∪B Set A union Set B
|x| modulus ( Length)
X∈ A X belongs to A
 Abstract

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
Shor’s 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 inter-
disciplinary 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 can—in principle now, but probably
eventually in practice—be 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.
 1
Quantum Computation: Historical Development

A 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

1
characterization of the complexity class BPP (defined later), which is widely viewed as the class
of efficiently solvable problems.
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 super-
polynomial 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
Vaziarni’s problem appears contrived, Simon’s problem looks quite natural. Simon’s 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]. It’s 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.

2
 2
Elements of Quantum Computing

2.1 The Qubit

The 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 +

eiφsin(θ) 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,

3
the amount of “hidden” information it stores is conserved under the dynamic evolution (namely,
Schrödinger'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.

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.

4
2.2 Quantum Gates
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 U†U=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.

5
 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
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 Circuits

Quantum 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.

6
2.4 Quantum Algorithms

Algorithm 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
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.

7
Fig. 2.3 : The Hadamard Gat

3
Complexity Theory
8
 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 Complexity

9
 In 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
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 .

4
Quantum Complexity Theory

10
4.1 Definition & Importance
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 computers—for 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 Moore’s 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
11
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
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
one’s 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 Classes

Several 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]

12
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
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).

13
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.

14
4.3 Polynomial time quantum computaton
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 & BQP

Let 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 ∈
N} is referred to, it should be interpreted that this is a shorthand for {Q1n : n ∈ N}.
Notice that every polynomial-time generated family {Qx : 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,

15
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
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

16
 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 Merlin–Arthur, 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 setting—for 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.)

17
 Fig. 4.2: Suspected relation among P, NP , BQP and QMA
(http://www.nature.com/nphys/journal/v5/n10/fig_tab/nphys1370_F1.html)

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 such that Pr[Q
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 |).

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

18
 Conclusions

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 bounded-
error 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.

19
 Acknowledgement
I 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
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. It’s 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.

20
 References
[1] Michael Nielsen, Isaac Chuang, “Quantum Computation and Quantum Information" ,
Cambridge University Press (2000).
[2] Peter Shor, “Algorithms for Quantum Computation: Discrete Logarithms
and Factoring," Proceedings of the 35th Annual Symposium on Foundations
of Computer Science (1994), 124-134.
[3] L. Grover, “A fast quantum mechanical algorithm for database search" Pro-
ceedings of the 28th Annual ACM Symposium on the Theory of Computing
(STOC 1996), (1996) 212-219.
[4] J. Watrous, ‘Quantum computational complexity",Proceedings of the
thirty-third annual ACM symposium on Theory of computing (STOC), 60-67,(2001).
[5] C.Bennet et al“Quantum Information and Computation” Nature, Vol. 404, 16 March
(200) 247-255
[6] Bernstein, E. and Vazirani, U., “Quantum complexity theory”, Proceedings of the 25th
Annual ACM Symposium on Theory of Computing, 1993, pp. 11 – 20.
[7] [Simon, D., “On the power of quantum computation”, Proceedings of the 35th Annual
IEEE Symposium on Foundations of Computer Science, 1994, pp. 116 – 123.
[8] R. Feynman (1982), Simulating physics with computers, Internat. J. Theoret. Phys., 21,
pp. 467–488.
[9] 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. 563–591.
[10] D. Deutsch (1985), “Quantum theory, the Church–Turing principle and the universal
quantum computer”, Proc. Roy. Soc. London Ser. A, 400, pp. 96–117.
[11] 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. 60–62.
[12] A. Berthiaume and G. Brassard (1992a), “The quantum challenge to structural
Complexity” Society Press, Los Alamitos, CA, pp. 132–137.

21
[13] C. Bennett, E. Bernstein,G. Brassard, and U. Vazirani. “Strengths andweaknesses of
quantum computing”. SIAM Journal on Computing, 26(5):1510–1523, 1997.
[14] 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. 116–123.
[15] S. Lloyd (1993), A potentially realizable quantum computer, Science, 261, pp. 1569–
1571.
[16] R. Landauer (1995), “Is quantum mechanics useful?” Philos. Trans. Roy. Soc. London
Ser. A.
[17] O. Goldreich. “On promise problems” (a survey in memory of Shimon Even [1935–
2004]). Electronic Colloquium on Computational Complexity, Report TR05-018, 2005.
[18] Barenco, A. et al. (1995), ‘Elementary gates for quantum computation’, Phys. Rev., A
52: 3457–3467.
[19] DiVicenzo, D. (1995), ‘Two-bit gates are universal for quantum computation’, Phys.
Rev., A 51: 1015–1022.
[20] Deutsch, D. and Jozsa, R. (1992), ‘Rapid solution of problems by quantum computer’,
Proc. Roy. Soc. Lond, A 439: 553–558.
[21] A. C.-C. Yao, “Quantum circuit complexity”, Proc. 34th Ann. IEEE
Symp. on Foundations of Computer Science (FOCS ’93), pp. 352–361, 1993.
[22] E. Knill. Quantum randomness and nondeterminism. Technical Report LAUR-96- 2186,
Los Alamos National Laboratory, 1996. Available as arXiv.org e-Print quant-
ph/9610012.
[23] A. Kitaev. “Quantum NP”. Talk at AQIP’99: SecondWorkshop on Algorithms in
Quantum Information Processing, DePaul University, January 1999.
[24] A. Kitaev, A. Shen, and M. Vyalyi. Classical and Quantum Computation, volume 47 of
Graduate Studies in Mathematics, American Mathematical Society, 2002.
[25] Quantum Computing (Stanford Encyclopedia of Philosophy)
[26] R. Landauer (1995), Is quantum mechanically coherent computation useful? in
Proceedings of the Drexel-4 Symposium on Quantum Nonintegrability—Quantum
Classical Correspondence, D. H. Feng and B-L. Hu, eds., International Press,

22
23