Contents
1 Preface
1.
1
On Tutorial
1.
2
Computing v. Computation
2
Computing with Cells and Atoms
2.1 DNA Computing
2.2 Membrane Computing
2.3 Quantum Computing
3
Elements of Computer Scienc
e Related to Quantum Computing
3
.1
Turing Machines
3
.2
The Chu
rch

Turing Thesis
3
.3
Complexity
Classes
4
Introduction to
Quantum
Computing
4
.1
Introduction
4
.
2
Quantum Mechanics
4
.
3
Quantum Bits
4
.
4
Multiple Qubits
4
.5
Measurement
4
.6 Quantum Gates
4
.
7
Quantum Computer
4.8 Turing is Forever
4
.
9
Quantum
Parallelism
4
.
10 Classical Computers vs. Quantum Computers
4
.
11 Bits vs.
Q
ubits
4
.1
2
Initialization, Execution and Termination
4
.1
3
Power of Quantum Computer
4.14
Quantum Computing in Computational Complexity
4
.1
5
Problems in Building Quantum Computers
4
.1
6
Quantum Decoherence
4
.1
7
Quantum Comput
er
Candidates
5
Some Applications of Quantum Computing in Bioinformatics
5
.1
Sequence Alignment
5
.2
Quantum Evolutionary/Genetic Algorithm & MSA
5
.3
Quantum Representation
5
.4
Main Algorithms
5
.5 Objective Func
tions
5
.6
Optimization
5
.7
Experimental Results
5
.8 Conclusions
5
.9 Open Problems
6
Further Reading
s

General reference

Introduction to Quantum Computation

Thermal ensembles

Using quantum computers to simulate quantum systems

Quantum cryptogra
phy

Universal quantum computer and the Church

Turing thesis

Shor's factoring algorithm

Quantum database search

Quantum sorting

Quantum computer simulators

Quantum Programming Languages

Quantum error correction

Quantum error avoidance

S
olving NP

complete and #P

complete problems
7
Bibliography
8
Appendix
A
. Mathematics Used in this Paper
B
. Code for the
S
imulation of QEAlign
B
.1 header.h
B
.2 main.C
B
.3 initpopulation.C
B
.4 evaluation.C
C
. Sample output
C
.1 Sample output for
1aboA_ref1
.msf with similarity 25 from BAliBASE
C
.2 Sample output for
1dox_ref1
.msf with similarity 25 from BAliBASE
C
.3 Sample output for
1r69_ref2
.msf from BAliBASE
C
.4 Sample output for
2trx_ref2
.msf from BAliBASE
C
.5 Sample output for
1idy_ref3
.msf from BAliBASE
C
.6 Sample output for
1pamA_ref3
.msf from BAliBASE
D
.
Selected Presenters’ Papers Related to Quantum and DNA Computing
1 Preface
1.
1
On Tutorial
The t
utorial
“
Applications of Quantum Computing in Bioinformatics
”
covers:

Computing with
Cells and Atoms

Elements of
Computer Science Related to Quantum Computing

Quantum Computing

Some Applications of Quantum Computing in Bioinformatics

Conclusion and Open Questions

Further Reading
s

Bibliography
The tutorial time is li
mited and
some material
will be
just mentioned,
skipped and left for
homework.
1.2
Computing v. Computation
C
omputing is any goal

oriented activity requiring, benefiting from, or creating computers.
Thus, computing includes designing and building hardware and softwar
e systems for a wide
range of purposes; processing, structuring, and managing various kinds of information; doing
scientific studies using computers; making computer systems behave intellig
ently;
finding
and gathering information relevant to any particular
purpose, and so on.
C
omputing is the systematic study of algorithmic processes that describe and transform
information: their theory, analysis, design, efficiency, implementation, and application.
Computation is a process following a well defined model
that is un
derstood and can be
expressed by
an algorithm, protocol, network topology, etc.
Hongwei Huo
Vojislav Stojkovic
2 Computing with Cells and Atoms
2.1 DNA Computing
2.
1.1
DNA
DNA, deoxyribonucleic acid, is a molecu
le found in every living cell, which directs the
formation, growth, and reproduction of cells. DNA consists of nucleotides. Nucleotides
contain compounds called phosphate, deoxyribose, and base. Within all nucleotides,
phosphate and deoxyribose are the sam
e, however, the bases vary. The four distinct bases are:
adenine (A), guanine (G), thymine (T), and cytosine (C). The exact amount of each
nucleotide and the order in which they are arranged are unique for every kind of living
organism. DNA represents info
rmation as a pattern of molecules on a DNA strand. A DNA
strand is a string of the alphabet {A, C, G, T}. The length of a DNA strand is equal to the
length of the string that represents the DNA strand.
2.1.2
. DNA Computer
A DNA computer is a chemical i
nstrument consisting of a system of connected test tubes and
other auxiliary units. DNA computers use the chemical properties of DNA molecules by
examining the patterns of combination or growth of the molecules or strings. DNA computers
can do this through
the manufacture of enzymes, which are biological catalysts that could be
considered the ‘software’ used to execute the desired DNA computation. DNA computers
represent information in terms of DNA. In DNA computers, deoxyribonucleic acids serve as
the memo
ry units that can take on four possible positions (A, C, G, or T). DNA computers do
not have the vonNeumann architecture. DNA computers are massively parallel and are
considered promising for complex problems that require multiple simultaneous computations
.
DNA computers perform computations by synthesizing particular sequences of DNA and
allowing them to react in test tubes. The task of the DNA computer is to check each possible
solution and remove those that are incorrect, using restrictive enzymes. When
the
chemical
reactions are complete, the DNA
strands can then be analyzed to find the solution.
A super DNA computer is a programmable DNA computer.
2.1.3
. DNA Computing
DNA computing is a form of computing which uses DNA and
biochemistry
and
molecular
biology
technologies
instead of the traditional silicon

based
computer
technologies
.
In 1961 Feynman predicts in 1994 Adleman
realized computations at a molecular level
computing with DNA. DNA computing b
egan in 1994 when Adleman showed that DNA
computing was possible by solving the Traveling Salesman Problem
on a DNA computer.
Adelman
used DNA polymerase and Watson

Crick complementary strands to do DNA
computation. Since then, it has been a surge of resea
rch in the DNA computation field. DNA
computation has emerged in an exciting new research field at the intersection of computer
science, biology, mathematics, and engineering. DNA computation has been demonstrated to
have the capability to solve problems c
onsidered to be computationally difficult for von
Neumann machines. After the Hamiltonian Path problem was solved, several researchers
proposed solutions to a spectrum of NP

comp
lete problems (such as Lipton
) dealing with
satisfiability, cryptography, as w
ell as other search oriented problems.
We have assumed that DNA computations are error

free, i.e., they work perfectly without any
errors. However, in reality DNA computations can be faulty because some DNA operations
can introduce errors.
DNA operatio
ns are constrained by biological feasibility.
DNA operations may be:
(i) realized by the present biotechnology or
(ii) implemented by simulation on the conventional vonNeumann computers.
2.1.4
. DNA Computation Model
As computer components become s
maller and/or more compact, scientists and engineers
dream of a chemical, multi

processor computer, whose processors are individual molecules
involved in chemical processes.
Following this thinking, we propose DNA computation model that involves the foll
owing
three operations levels:
(i) Basic DNA operations (DNA molecular interactions);
(ii) Test tube operations (proposed in 1996 b
y Gibbons, Amos, and Hodgson
) such as: remove,
union, copy, select, and etc.
(iii) High level operations
A selection
of Easel/C

like programming language statements such as:
(i) begin

end or {

} (for grouping)
(ii) if

then

else (for selection)
(iii) for (for loop)
The basic DNA operations level is the chemical interactions between DNA

s. It may be seen
as machine p
rogramming and may be interpreted as executions of machine code. The basic
DNA operations can be implemented at DNA computers or simulated at vonNeumann
machines.
The test tube operations level is an interface level that serves as an interface between
vo
n

Neumann machine and DNA machine. It may be seen as the hardware of a DNA
computer. The test tube operations can be implemented at DNA computers or simulated at
vonNeumann machines.
The high level operations

the programming language level can be imple
mented using
vonNeumann machines with standard processors, operating systems, and programming
languages processors.
In the last twelve years DNA computation has emerged as an exciting, fascinating, and
important new research field at the intersection of
computer science, mathematics, biology,
chemistry, bioinformatics, and engineering.
The main reasons for the interest in DNA

computations are:
(i) size and variety of available DNA molecular "tool boxes"
(ii) massive parallelism inherent in laborator
y and chemical operations on DNA molecule
(iii) feasible and efficient models
(iv) physical realizations of the models
(v) performing computations in vivo.
Unfortunately it is still not clear whether DNA computing can compete (or will be able to
comp
ete in the near future) with existing electronic

digital computing. We propose that in
the near future it will be possible to join vonNeumann and DNA computer in a
functional super biocomputer. We are confident that in 10

20 years our desktop computers
will be evolved into biocomputers. These machines will be able to perform calculations in
seconds that take today’s PCs hours, and solve in hours problems that take today’s PCs years.
A computational substrate
–
a substance that is acted upon by the im
plementation of DNA
computational model is DNA. DNAs are represented by strings. DNA computational model
operates upon sets of strings. A DNA computation starts and ends with a single set of strings.
A DNA algorithm is composed of a sequence of operation
s upon one or more sets of strings.
At the end of the DNA algorithm’s execution, a solution to the given problem is encoded as a
string in the final set.
Characterization of DNA computations using traditional measures of complexity, such as
time and spa
ce is misleading due to the nature of the laboratory implementation of DNA
computation. One way to quantify the time complexity of a DNA

based algorithm is to count
the required numbers of “biological steps” to solve the problem. The biological steps inclu
de
the creation of an initial library of strands, separation of subsets of strands, sorting strands by
length, chopping and joining strands, and etc.
2.1.5
. Basic DNA Operations
An assignment is a finite sequence of unit assignments. A unit assignment
is coded by a DNA
strand. All unit assignments of an assignment have the same length.
The most important basic DNA operations are:
(i) Append (Concatenate, Rejoined)

appends two DNA strands with ‘sticky ends’
(ii) Melt (Anneal, Renaturation)

br
eaks two DNA strands with complementary sequences
(iii) Cut

cuts a DNA strand with restriction enzymes.
2.1.6. Test Tube Operations
A test tube contains an assignment.
The most important test tube operations are:
(i) Union (Merge, Create)

pours the context of more tubes into one tube.
(ii) Copy (Duplicate, Amplify)

makes copies of a tube.
(iii) Separate

separates an assignment into a finite sequence of assignments sorted by the
length of unit assignments.
(iv) Detect

confirms pre
sence or absence of a unit assignment in a tube.
(v) Select

selects on the uniformly random way from an assignment a unit assignment.
(vi) Append (Concatenate, Rejoined)

appends an unit assignment to each unit assignment
of an assignment.
(vii) M
elt (Anneal, Renaturation)

melts each unit assignment of an assignment with a unit
assignment.
(viii) Extract

extracts the context of one tube into two tubes using a pattern unit
assignment.
(ix) Remove

removes unit assignments that contain occu
rrence(s) of other unit
assignments.
(x) Cut

cuts each unit assignment of an assignment for the given length.
(xi) Discard
–
empty the tube.
2.1.7. DNA Representations
A DNA representation of a string c1 ... cm is a sequence c[1] ... c[m], where:

c[i], where i = 1, ..., m, is the character at the position i.
Characters c[i] are uniquely encoded by DNA strands.
If an unsigned integer number is not used for numerical calculations, then the unsigned
integer number may be represented as a string of
digits of some base.
A DNA representation of an unsigned integer number d1...dm is a sequence d[1]...d[m],
where:

d[i], where i = 1, ..., m, is the digit at the position i, and

0 <= d[i] <= base

1.
The base may be any integer number >= then 1.
Digits
d[i] are uniquely encoded by DNA strands.
If an unsigned integer number is used for numerical calculations, then the given DNA
representation of an unsigned integer number is not suitable because it does not care on
carries what complicates implementati
ons of arithmetic operations with unsigned integer
binary numbers.
2.1.8
. DNA

Based Algorithm for Creating a Set of Unsigned Integer Binary Numbers
DNA

Based Algorithm for creating a set of unsigned integer binary numbers may be specified
on the foll
owing way:
procedure CreateInputSet(m, T)
// m is the input data;
// m is a
unsigned
integer number;
// T is the input data and the output data;
// T is the tube;
// T as the input data
// is the set of one of more empty strings.
// The tube T contai
ns a finite sequence of unit assignments
// (DNA strands) that represents empty strings.
// T as the output data
// is the set of
unsigned
integer binary numbers of the length m;
// T has maximum 2
m
elements;
// The tube T contains a finite sequence of u
nit assignments
// (DNA strands) that represents
// the set of
unsigned
integer binary numbers of the length m;
{
base = 2;
T = {ε}; // ε is the empty string
for (i = 1; i <= m; i++)
{
Copy(T, { T[base

1] });
Parallèle for(j = 0; j <= base

1; j++)
{
k = rand(base

1);
Append(T[j], k, T[j]);
}
Union({ T[base

1] }, T);
Discard( { T[base

1] }
);
}
}
2.1.9. DNA

Based Algorithm for Determining the Smallest Element of a Set of Unsigned
Integer Binary Numbers
DNA

Based Algorithm for determining the smallest element of a set of unsigned integer binary
numbers of the given length may be specifi
ed on the following way:
function Smallest(m, T)
// The function Smallest returns
// the smallest element of the set T;
// It is the unit assignment (DNA strand).
// m is the input data;
// m is a
unsigned
integer number;
// T i
s the input
data;
//
T is the tube;
// T as the input data
// is the set of
unsigned
integer binary numbers of the length m;
// T has maximum 2
m
elements;
// The tube T contains a finite sequence of unit assignments
// (DNA strands) that represents
// the set of
unsigned
i
nteger binary numbers of the length m;
{
for i = m to 1 do
{
// Parallel
// {
// T

> T[0];
// T

> T[1];
// }
Copy(T, { T[1] });
// It is a very important to empty the tube T.
Discard(T);
Parallel
{
Remove(T[1], {i 0});
Remo
ve(T[0], {i 1});
}
if(Detect(T[0]))
then
Union(T[0], T);
else
Union(T[1], T);
}
return Select(T);
}
Explanations
i means the unsigned integer number j from the range 1 .. m.
i j means the unsigned integer number j from the range
1 .. m at the position i.
Remove(T[j], {i j}) removes from the tube T[j] all DNA strands which contain at least one
occurrence of the DNA substrands i j.
Remove(T[j], {i j}) saves in the tube T[j] only DNA strands which contain at
the position i
the value ¬ j.
Parallel{A; B} means that operation A and B may be executed in parallel.
Complexity
Complexity of the DNA

Based Algorithm for determining the smallest element of a set of m
unsigned integer binary numbers is O(m).
Program
The DNA

Based program for determining the
smallest
element
of a
set of unsigned integer
binary
numbers
of the length m
may be specified on the following way:
program S
{
m=4;
CreateInputSet(m, T);
smallest =
Smallest(m, T);
}.
Program Execution
The progra
m S may be executed:
(i) step by step in a DNA

lab or on a DNA

computer
(ii) automatically on a super DNA

computer or on an electronic

digital computer
(iii) for small (less then 10) number of elements.
Test Example
The purpose of the test exampl
e is to "visualize" execution of the DNA

Based program S for
determining the smallest element of a set of unsigned integer binary numbers of the length m.
m=4;
CreateInputSet(4, T);
base = 2;
T = {ε}; // ε is the empty string
T
ε
i = 1;
Copy(T, {T[1]});
T[0]
T[1]
ε
=
ε
=
=
††
偡牡汬敬
=
††
{
=
††=
欠㴠牡湤⠱⤻潲硡浰汥‽‰
=
††=
䅰灥湤⡻⁔嬰崬⁽Ⱐ呛そ⤻
=
††=
欠㴠牡湤⠱⤻潲硡浰汥‽‱k
=
††=
䅰灥湤⡔嬱崬Ⱐ呛ㅝ⤻
=
††
}
=
=
T[0
]
T[1]
0ε
=
1ε
=
=
†
啮楯渨笠呛ㅝ⁽Ⱐ吩r
=
=
T
0ε 1ε
=
=
†
䑩獣慲搨笠呛ㅝ⁽⤻
=
=
T[0]
T[1]
i = 2;
Copy(T, {T[1]});
T[0]
T[1]
0ε 1ε
=
0ε 1ε
=
=
††
偡牡汬敬
=
††
{
=
††=
欠㴠牡湤⠱⤻‽‰k
=
††=
䅰灥湤⡻⁔嬰崬⁽Ⱐ呛そ⤻
=
††=
欠㴠牡湤⠱⤻潲硡浰汥‽‰k
=
Append(T[1], k, T[1]);
}
T[0]
T[1]
00ε 01ε
=
00ε 01ε
=
=
†
啮楯渨笠呛ㅝ⁽Ⱐ吩r
=
=
T
00ε 01ε 00ε 01ε
=
=
†
䑩獣慲搨笠呛ㅝ⁽⤻
=
=
T[0]
T[1]
And etc.
k = rand(1); for example k = 1;
k = rand(1); for example k = 0;
k = rand(1); for example k =
0;
k = rand(1); for example k = 1;
And finally
T
0100ε 0101ε 0100ε 0101ε 0000ε 0001ε 0000ε 0001ε
=
1100ε 1101ε 1100ε 1101ε 1000ε 1001ε 1000ε 1001ε
=
=
smallest =
Smallest(4, T);
i = 4;
Copy(T, { T[1] });
T[0]
T[1]
0100ε 0101ε 0100ε 0101ε
=
〰0
0ε 0001ε 0000ε 0001ε
=
1100ε 1101ε 1100ε 1101ε
=
1000ε 1001ε 1000ε 1001ε
=
0100ε 0101ε 0100ε 0101ε
=
0000ε 0001ε 0000ε 0001ε
=
1100ε 1101ε 1100ε 1101ε
=
1000ε 1001ε 1000ε 1001ε
=
†
=
†
䑩獣慲搨吩D
=
=
T
Parallel{Remove(T[1], {4 0}); Remove(T[0], {4 1});}
T[0]
T[1]
0100ε 0101ε 0100ε 0101ε
=
0000ε 0001ε 0000ε 0001ε
=
1100ε 1101ε 1100ε 1101ε
=
1000ε 1001ε 1000ε 1001ε
=
†
=
†
楦⡄整散琨呛そ⤩
=
瑨敮⁕湩潮⡔嬰崬⁔⤻
=
敬獥⁕湩潮⡔嬱崬⁔⤻e
=
=
T
0100ε 0101ε 0100ε 0101ε 0000ε 0001ε 0000ε 0001ε
=
=
椠㴠㌻
=
†
䍯灹⡔Ⱐ笠呛ㅝ⁽⤻
=
=
T[0]
T[1]
0100ε 0101ε 0100ε 0101ε
=
0000ε 0001ε 0000ε 0001ε
=
0100ε 0101ε 0100ε 0101ε
=
0000ε 0001ε 0000ε 0001ε
=
=
偡牡汬敬筒敭潶攨呛ㅝⰠ笳‰紩㬠剥浯癥⡔嬰崬⁻㌠ㅽ⤻m
=
=
T[0]
T[1]
0000ε 0001ε 0000ε 0001ε
=
0100ε 0101ε 0100ε 0101ε
=
†
=
†
楦⡄整散琨呛そ⤩
=
瑨敮⁕湩
潮⡔嬰崬⁔⤻
=
敬獥⁕湩潮⡔嬱崬⁔⤻e
=
=
T
0000ε 0001ε 0000ε 0001ε
=
=
椠㴠㈻
=
†
䍯灹⡔Ⱐ笠呛ㅝ⁽⤻
=
=
T[0]
T[1]
0000ε 0001ε 0000ε 0001ε
=
0000ε 0001ε 0000ε 0001ε
=
偡牡汬敬筒敭潶攨呛ㅝⰠ笲‰紩㬠剥浯癥⡔嬰崬⁻㈠ㅽ⤻m
=
=
T[0]
T[1]
0000ε 0001ε 0000ε 0001ε
=
0000ε 0001ε 00
00ε 0001ε
=
=
†
楦⡄整散琨呛そ⤩
=
瑨敮⁕湩潮⡔嬰崬⁔⤻
=
敬獥⁕湩潮⡔嬱崬⁔⤻e
=
=
T
0000ε 0001ε 0000ε 0001ε
=
=
椠㴠ㄻ
=
Copy(T, { T[1] });
T[0]
T[1]
0000ε 0001ε 0000ε 0001ε
=
0000ε 0001ε 0000ε 0001ε
=
=
偡牡汬敬⁻剥浯癥⡔嬱崬⁻ㄠぽ⤻⁒敭潶攨呛そⰠ笱‱紩㭽
=
=
T[0]
T[1
]
0000ε 0000ε
=
0001ε 0001ε
=
†
=
†
楦⡄整散琨呛そ⤩⁴桥渠啮楯渨呛そⰠ吩i
=
敬獥⁕湩潮⡔嬱崬⁔⤻e
=
=
T
0000ε 0000ε
=
return Select(T);
smallest =
0000ε;
2.2 Membrane Computing
Membrane computing
is a branch of natural computing inspired
by the structure and
functions
of the living cell
s
.
It connects
:

distributed parallel
computing models and

membrane
systems.
The field of membrane computing was initiated in 1998
by
Gheorghe Paun
.
2.3 Quantum Computing
Quantum computing is
a
multidisciplinary resear
ch area
bringing together ideas from
:

information theory,

computer science,

mathematics
,
and

quantum physics.
3
Elements of Computer Science Related to Quantum Computation
3
.1
Turing Machines
A Turing machine (TM) is a basic abstract sym
bol

manipulating machine which can simulate
any
computer
that could possibly be constructed.
A Turing machine that is able to simulate any other Turing machine is called a
Universal
Turing machine
(UTM, or simply a universal machine).
Studying
abstract
properties
of TM and UTM yields many insights into
computer science
and
complexity theory
.
Turing and others proposed mathematical
computing models allow
the study of alg
orithms
independently
of any particular computer hardw
are. This abstraction is
invalu
able
.
3.1.1. Informal Description
A Turing machine consists of:

A tape

A head

A table

A state register
A t
ape is divided into cells, one
next to the other.
Each cell contains a symbol f
rom some
finite alphabet.
The alphabet contains a special bl
an
k symbol
(here written as 'B') and
one or
more other symbols.
The tape is assumed to be arbitrarily extendable to the left and to the right. Cells that have not
been written to before are assumed to be filled with the blank sym
bol.
In some models:

the tape has a left end marked wit
h a special symbol

the tape extends or is indefinitely extensible to the right
A head can read and write symbols on the tape and move the tape left a
nd right one (and only
one) cell at a time. In some models the head moves and the tape is stationary.
A table (transition function) of
instructions
(usually 5

tuples but sometimes 4

tuples) for:

the state the machine is current
ly in and

the symbol it is reading on the tape
tells the machine what to do.
In some models, if there is no entry in the table for the current combination of symbol and
s
tate then th
e machine will halt. O
ther models require all entries to be filled.
In case of the 5

tuple models:
(i) either erase or write a symbol, and then
(ii) move the head ('L' for one step left or 'R' for one step right), and then
(iii) assume the same or a ne
w state as prescribed.
In the case of 4

tuple models:
(ia) erase or to write a symbol or
(ib) move the head left or right, and then
(ii) assume the same or a new state as prescribed, but not both actions (ia) and (ib) in the
same instruction.
A stat
e register stores the state of
the Turing table.
The number of different states i
s always
finite and
there is one special start state with which the state register is initialized.
3.1.2
. Formal Description
A (one

tape) Turing machine is
a 7

tuple
where

Q is a finite set of states

Γ is a finite set of the tape alphabet/symbols

is the blank symbol

Σ, a subset of Γ not including b
,
is the set of input symbols

i
s
the transition function,
where L is left
shift and
R is right shift.

is the initial state

is the set of final or accepting states
3.1.3. Example
–
Copy String
3
.2
The Church

Turing Thesis
A more mathematically

oriented definition with a similar "uni
versal" nature was introduced
by Alonzo Church
. Church’s
work on lambda calculus
intertwined
with Turing's
work
in a
formal theory of computation
resulted
as the Church

Turing thesis.
The
Church

Turing
thesis sta
tes that Turing machines:

capture the in
formal notion of effective metho
d in logic and mathematics

provide a precise definition of an algorithm or 'mechanical procedure'.
Turing proposed the following hypothesis:
Every ‘function which would naturally be regarded as computable’ can be computed
by the
universal Turing machine.
I
t should be noted that there is ambiguity as to what, precisely, a function which would
naturally be regarded as computable means. Due to this ambiguity, this statement is not
subject to rigorous proof.
There are
stro
ng
evidence
s for this hypothesis:

M
any diverse models of computa
tion
compute the same set o
f functions as a Turing
machine

No counterexamples of
the
hypo
thesis.
The Church

Turing thesis gives the insight into the “power” of computing machines. If a
comp
uting machine can solve all problems a Turing machine can solve, then the computing
machine is powerful as a Turing machine.
3
.3
Complexity Classes
It is interesting
and important
to determine
does a problem computable or
not computable
.
B
ut
,
this distin
ction is not fine enough to determine does a problem solvable by a physical
computer in a reasonable amount of time. If
a computation will take hundred
s of years to get
result, it may be considered as not computable from the perspective of a pragmatist
An
algorithm can be characterized by the number of operations and amount of memo
ry it
requires to compute a result
for the given
input of size N. These characterizations of the
algorithm determine what is called the algorithms complexity.
Specifically, the c
omplexity of
an algorithm is determined by looking/analyzing how the number of operations and memory
usage influence to getting a result for the size of the input of the algorithm.
P
roblems
are grouped
into the following complexity
classes:

P: Polynomi
al time

NP: Nondeterministic polynomial time

NP

complete
P: Polynomial time, the running time of the given algorithm is in the worst
case some
polynomial function of the size of the input. For example if an
algorithm with an
input size of
10 bits
need
s
10
^
4
+7
*
10
^
2
+
5
operations to get result, it
is a polynomial time algorithm.
NP: Nondeterministic polynomial time, a candidate for an answer can be veri
fi
ed as a correct
answer or not in
the
polynomial time.
NP

complete: A set of problems such that if an
y member is in P, the set
P
is equal to
the set
NP.
[
Cormen, Leiserson, Rivest
, and Cliff 2001
]
Problems which can be
solved in polynomial time or less are generally
deemed to be
“
tractable”.
Problems which require more than polynomial time are usually c
onsidered to be “intracta
ble”.
For example
an algorithm which would take 2^n operations for an input size of n would be
considered intractable.
It sho
uld be noted at this point that in Shor's Algorithm, we will be given n,
a number to be
factored. In n's
most compact representation, it will take
log n
bits to be encoded. When
discussing the running time of algorithms, we must
always speak in reference to the encoded
input size. For Shor's algorithm (or
any algorithm w
hose input is an integer), the
input
size"
grows logarithmically
with the value of n to be factored.
W
hether or not P and NP describe the same set of problems
is one of the most important open
quest
ions in computer science. If
a
polynomial time algorithm for any NP

complete problem
be disco
vered, then
we would know that P and NP are the same set.
Many NP

complete
problems have known algorithms which can compute their solutions in exponential time. It is
unknown whether any polynomial time algorithms exist.
When discussing the complexity of
a problem it is important to distinguish
between there
being no known algorithm to compute it in polynomial time,
and there being no algorithm to
compute it in polynomial time. There are
many problems whose best known algorithm
requires an exponential numb
er
of steps to compute a solution. These problems are generally
considered to
be intractable. Determining the prime factors of a large number is one such
problem, and its assumed intractability is the bases for most cryptography.
The interest
in quantum c
omputing is twofold:

Does
a quantum computer can solve problems which are uncomputab
le on a classical
computer?

Does
a quantum computer can make problems thought of as intractable, tractable?
4
Introduction to
Quantum Computing
4
.1
Introduction
Ric
hard Feynman
[Feynman 1982] observed that certain quantum mechanical effects cannot
be simulated efficiently on a computer. This observation led to speculation that perhaps
computation in general could be done more efficiently if it made use of these quant
um effects.
But building quantum computers, computation machines that use such quantum effects,
proved tricky,
and
no one was sure how to use the quantum effects to speed up computation,
the field developed slowly. It wasn
’
t until 1994, when Peter Shor[Sho
r 1994; 1997] surprised
the world by describing a polynomial time quantum algorithm for factoring integers, that the
field of quantum computing came into its own. This discovery promoted a flurry of activity
among experimentalists trying to build quantum c
omputers and theoreticians trying to find
other quantum algorithms. Additional interest in the subject has been created by the invention
of quantum key distribution and, more recently, popular press accounts of experimental
successes in quantum teleportati
on and the demonstration of a 3

bit quantum computer.
During the past forty years astounding advances have been made in the manufacture
of
computers. The number of atoms needed to represent a bit in memory
has been decreasing
exponentially since 1950. Lik
ewise the number of transistors
per chip, clock speed, and
energy dissipated per logical operation have all
followed their own improving exponential
trends. This rate of improvement
cannot be sustained much longer, at the current rate in the
year 2020 one
bit
of information will requite only one atom to represent it. The problem is
that
at that size the behavior of a computer's components will be dominated by the
principles
of quantum physics
[
Williams, Clearwater
1998
]
.
Classically, the time it takes to d
o certain computations can be decreased by using
parallel
processors. To achieve an exponential decrease in time requires an exponential
increase in the number of processors, and hence an exponential increase in the amount of
physical space needed. However
, in quantum systems the
amount
of parallelism increases
exponentially with the size of the system. Thus, an exponential increase in parallelism
requires only a linear increase in the amount of physical space needed. This effect is called
quantum paralleli
sm [Deutsch and Jozsa 1992].
There is a big catch at that. While a quantum
system
can perform massive parallel
computation
, access to the results of the computation is equivalent to making a measurement,
which disturbs the quantum state. This problem makes
the situation, on the face of it, seem
even worse than the classical situation; we can only read the result of one parallel thread, and
because measurement is probabilistic, we cannot even choose which one we get. But in the
past few years, various people
have found clever ways of
finessing
the measurement problem
to exploit the power of quantum parallelism. This sort of manipulation has no classical analog
and requires nontraditional programming techniques. One technique manipulates the quantum
state so t
hat a common property of all of the output values such as the symmetry or period of
a function can be read off. This technique is used in Shor
’
s factorization algorithm.
A
nother
technique transforms the quantum state to increase the likelihood that output
of interest will
be read. Grover
’
s search algorithm [Grover 1997] makes use of such an amplification
technique and searches an unstructured list of n items in O(
n
) steps on a quantum computer.
Classical computers can do no better than O(
n
), so unstructure
d search on a quantum
computer is provably more efficient than search on a classical computer. However, the
speed

up is only polynomial, not exponential, and it has been shown that Grover
’
s algorithm
is optimal for quantum computers.
A quantum
system
can u
ndergo two types of operations: measurement and quantum state
transformation. Most quantum algorithms involve a sequence of quantum state
transformations followed by a measurement. For classical computer there are sets of gates
that are universal in the se
nse that any classical computation can be performed using a
sequence of these gates. Similarly, there are sets of primitive quantum state transformation,
called quantum gates, which are universal for quantum computation. Given enough quantum
bits, it is po
ssible to construct a universal quantum Turing machine.
4
.
2
Quantum Mechanics
Quantum mechanical phenomena are difficult to understand, since most of our everyday
experiences are not applicable. This paper cannot provide a deep understanding of quantum
me
chanics
[see
Feynman et al. 1965, Liboff 1997, and Greenstein and Zajonc 1997
for
expositions of quantum mechanics
]
. Instead, we will give some feeling as to the nature of
quantum mechanics and some of the mathematical formalisms needed to work with quantu
m
mechanics to the extent needed for quantum computing.
Quantum mechanics
is
a mathematics framework or set of rules for the construction of
physical theories. For example, there is a physical theory known as quantum electrodynamics
which describes with f
antastic
accuracy
the interaction of atoms and light. Quantum
electrodynamics is built up within the framework of quantum mech
anics, but it contains
specific rules not determined by quantum mechanics. The
relationship
of quantum mechanics
to specific physi
cal theories like quantum electrodynamics
is rather like the relationship of a
computer
’
s operating system to specific applications software
–
the operating
system
sets
certain basic parameters and modes of operation, but leaves open how specific tasks are
accomplished by the applications.
4
.
3
Quantum Bits
A quantum bit, or qubit, is a unit v
ector in a two

dimensional complex vector space for
which a particular basis, denoted by {0
, 1
}, has been fixed. The orthonormal basis 0
and
1
may correspond t
o the ↑
and →
polarizations of a photon respectively, or to the
polarizations 
↗
and
↖
. Or

0
and

1
could correspond to the spin

up and spin

down states
of an elec
tron. When talking about qubits
and quantum computations in general, a fixed basis
w
ith respect to
which all statements are made has been chosen in advance. In particular,
unless otherwise specified, all measurements will be made with respect to the standard basis
for quantum computation,
{
0
,
1
}
.
For the purposes of quantum computati
on,
the basis states

0
and

1
are taken
to
represent the classical bit values 0 and 1
respectively. Unlike classical bits however,
qubits
can be in a superposition of

0
and

1
such as
a

0
+
b
1
, where
a
and
b
are
complex numbers
such that

a

2
+ 
b

2
=
1.
Just as in the photon polarization case, if
such a superposition is
measured with respect
to the basis
{
0
,
1
}
, the probability
that the measured value is

0
is

a

2
and
the probability that the measured value is

1
is

b

2
.
Even though a quantu
m can be put in infinitely many superposition states, it is only
possible to extract a single classical bit’s worth of information from a single quantum bit. The
reason that no more information can be gained from a qubit
than in a classical bit is that
inf
ormation can only be obtained by measurement. When a qubit is measured, the
measurement changes the state to one of the basis states in the way seen in the photon
polarization experiment. As every measurement can result in only one of two states, one of
th
e basis vectors associated to the given measuring device, so, just as in the classical case,
there are only two possible results. As measurement changes the state, one cannot measure
the state of a
qubit in two different bases. Furthermore, as we shall see
in Section 4.
6
,
quantum states cannot be cloned, so it is not possible to measure a qubit in two ways, even
indirectly by, say, copying the qubit and measuring the copy in a different basis from the
original.
4
.
4
Multiple
Qub
its
Imagine a macroscopic phys
ical object breaking apart and multiple pieces flying off in
different directions. The state of this system can be described completely by describing the
state of each of its component pieces separately. A surprising and unintuitive aspect of the
state spa
ce of an
n

particle quantum system is that the state of the system cannot always be
described in terms of the state of its component pieces. It is when examining systems of more
than one qubit that one first gets a glimpse of where the computational power
of quantum
computers could come from.
T
he state of a qubit can be represented by a vector in the two

dimensional complex
vector space spanned by

0
and

1
. In classical physics, the possible states of a system of
n
particles, whose individual states can
be described by a vector in a two

dimensional vector
space, form a vector space of 2
n
dimensions. However, in a quantum system the resulting
state space is much larger; a system of
n
qubits has a state space of 2
n
dimensions. It is this
exponential growth
of the state space with the number of particles that suggests a possible
exponential speed

up of computation on quantum computers over classical computers.
Individual state spaces of
n
particles combine classically through the Cartesian product.
Quantum st
ates, however, combine through the tensor product.
Details on properties of tensor
products and their expression in terms of vectors and matrices are given in Appendix. Let us
look briefly at distinctions between the Cartesian product and the tensor produc
t that will be
crucial to understanding quantum computation.
Let
V
and
W
be
2
two

dimensional complex vector spaces with bases {
v
1
,
v
2
} and
{
w
1
,
w
2
},
respectively. The Cartesian product of these two spaces can take as its basis the union of
the bases of i
ts component spaces
{
v
1
,
v
2
,
w
1
,
w
2
}
. Note that the order of the basis was chosen
arbitrarily. In particular, the dimension of the state space of multiple classical particles grows
linearly with the number of particles, since dim(
X
Y
)
=
dim(
X
)
+
dim(
Y
)
. The tensor
product of
V
and
W
has basis
{
v
w
1
,
v
1
w
2
,
v
2
w
1
,
v
2
w
2
}.
Note that the order of the basis,
again, is arbitrary. So the state space for two qubits, each with basis
{
0
,

1
}
, has basis
{
0

0
,

0

1
,

1

0
,

1

1
}
, which can be writte
n more compactly as
{
00
,

01
,

10
,

11
}
. More generally, we write

x
to mean

b
n
b
n

1
…
b
0
where
b
i
are the binary digits of the
number
x
.
A basis for a 3

qubit system is
{
000
,

001
,

010
,

011
,

100
,

101
,

110
,

111
}
and in general an
n

qu
bit system has 2
n
basis vectors. We can now see the exponential
growth
of the state space with the number of quantum particles. The tensor product
X
Y
has
dimension
dim
(
X
)
dim
(
Y
).
The state 00
+ 11
is an example of a quantum state that cannot be de
scribed in terms
of the state each of its components (qubits) separately. In other words
, we cannot find a
1
, a
2
,
b
1
, b
2
such that (a
1
0
+ b
1
1
)
(a
2
0
+ b
2
1
)
, since (a
1
0
+ b
1
1
)
(a
2
0
+ b
2
1
) = a
1
a
2
00
+
a
1
b
2
01
+
b
1
a
2
10
+ b
1
b
2
11
and a
1
b
2
=
0 implies that either a
1
a
2
= 0 or b
1
b
2
= 0. States that
cannot be de
composed in this way are called entangled states. These states represent
situations that have no classical counterpart and for which we have no intuition. These are
also
the states that p
rovide the exponential growth of quantum state spaces with the number
of particles
.
Thus, the real power of quantum computation derives from the exponential state spaces
of multiple quantum bits: just as a single qubit can be in a
superposition
of 0 and 1,
a register
of
n
qubits can be in a superposition of all 2
n
possible values.
However, it would require vast
resources to simulate even a small quantum system on traditional computers.
The evolution
of quantum systems is exponentially faster than their clas
sical simulations. The reason for the
potential power of quantum computers is the possibility of exploiting the quantum state
evolution as a computational mechanism.
4
.
5
Measurement
The measurement postulate of quantum mechanics states that any device meas
uring a
two

dimensional system has an associated orthonormal basis with respect to which the
quantum measurement takes place. Measurement of a state transforms the state into one of
the measuring device
’
s associated basis vectors. The probability that the
state is measured as
basis vector
a
is the square of the norm of the amplitude of the component of the original
state in the direction of the basis vector
a
. For example, given a device
for measuring the
polarization of photons with associated basis
{

↑
,
→
}
, the state

=
a
↑
+
b
→
is
measured as
↑
with probability

a

2
and as
→
with probability

b

2
(see Figure 1). Note that
different measuring devices will have different associated bases, and measurements using
these devices will have differe
nt outcomes. As measurements are always made with respect
to an orthonormal basis, throughout the rest of this paper all bases will be assumed to be
orthonormal.
Fig. 1 Measurement is a projection onto the basis.
The result of a measurement is pro
babilistic and the process of measurement changes the
state to that measured.
Let us look at an example of measurement in a two

qubit system. Any
two

qubit state can be expressed as
a
00
+
b
01
+ c10
+
d

11
, where
a
,
b
,
c
,
and
d
are
complex numbers su
ch that

a

2
+

b

2
+

c

2
+

d

2
=
1. Suppose we wish to measure the first
qubit with respect to the standard basis
{0
,
1
}
. For convenience we will rewrite the state as
follows:
a
00
+
b
01
+ c10
+
d
11
=
0
(
a
0
+ b
1
)
+
1
(
c
0
+ d1
)
=
u
0
(
a
/u
0
+ b
/u
1
)
+
v
1
(
c
/v
0
+ d
/v
1
)
For u =
and v =
, the vectors
a/u
0
+ b/u1
and
c/v
0
+ d/v1
are
of unit length. Once the state
has been rewritten as above, as a tensor product of the bit b
eing
measured and a second vector of unit length, the probabilistic result of a measurement is easy
to read off. Measurement of the first bit will with probability
u
2
= 
a

2
+ 
b

2
return
0
,
projecting the state to
0
(
a
/
u
0
+
b
/
u
1
), or with probabil
ity
v
2
= c
2
+ d
2
yield
1
,
projecting the state to
1
(
c
/
v
0
+
d/
v
1
)
. As
0
(
a
/
u
0
+
b
/
u
1
)
and
1
(
c
/
v
0
+
d/
v
1
)
are both unit vectors, no scaling is necessary. Measuring the second bit works similarly.
Measurement gives another way of th
inking about entangled particles. Particles are not
↑
→

b
a
entangled if the measurement of one has no effect on the other. For instance, the state
1
/
2
(
00
+
01
)
is entangled, since the probability that the first bit is measured to be
0
is
1
/
2 if the second
bit has not been measured. However, if the second bit had been measured,
the probability that the first bit is measured as
0
is either 1 or 0, depending on whether the
second bit was measured as
0
or
1
respectively. Thus the probable result of measur
ing the
first bit is changed by a measurement of the second bit. On
the other hand, the state
1
/
2
(
00
+
01
)
is not entangled: since
1
/
2
(
00
+
01
)
=
0
1
/
2
(
0
+ 1
)
, any measurement of the
first bit will yield
0
regardless of whether the secon
d bit was measured. Similarly, the
second bit has a fifty

fifty chance of being measured as
0
regardless of whether the first bit
was measured or not. Note that entanglement, in the sense that measurement of one particle
has an effect
on measurements of
another particle, is equivalent to our previous definition of
entangled states as states that cannot be written as a tensor product of individual states.
4
.
6
Quantum
G
ates
So far we have looked at static quantum systems, which change only when measured. Th
e
dynamics of a quantum system, when not being measured, are governed by Schr
ö
dinger’s
equation; the dynamics must take states to states in a way that preserves orthogonality. For a
complex vector space, linear transformations that preserve orthogonality a
re unitary
transformations, defined as follows. Any linear transformation on a complex vector space can
be described by a matrix. Let
M
*
denote
the conjugate transpose of the matrix
M
. A matrix
M
is unitary (describes a unitary transformation) if
MM* = I
.
Any unitary transformation of a
quantum state space is a legitimate quantum transformation, and vice versa. One can think of
unitary transformations as being rotations of a complex vector space
.
One important consequence of the fact that quantum transforma
tions are unitary is that
they are reversible. Thus quantum gates must be reversible. Bennett, Fredkin, and Toffoli had
already looked at reversible versions of standard computing models showing that all classical
computations can be done reversibly. See F
eynman’s
Lectures on Computation
[Feynman
1996] for an account of reversible computation and its relation to the energy of computation
and information.
The following are
two
examples of single

qubit quantum state transformations. Because
of linearity, the
transformations are fully specified by their effect on the basis vectors. The
associated matrix, with
{
0
,
1
}
as the preferred ordered basis, is also shown.
I:
0
〉
0
〉

1
〉

1
〉
X:
0
〉

1
〉

1
〉
0
〉
Y:
0
〉

1
〉

1
〉
0
〉
Z:
0
〉
0
〉

1
〉

1
〉
The names of these transformations are conventional.
I
is the identity transformation,
X
is
negation,
Z
is a phase shift operation, and
Y
=
ZX
is a com
bination of both. It can be readily
verified that these gates are unitary.
The controlled

NOT gate,
C
not
, operates on two qubits as follows: it changes the second
bit if the first bit is 1 and leaves this bit unchanged otherwise. The vectors

00
,

01
,

10
, and

11
form an orthonormal basis for the state space of a two

qubit system, a four

dimensional
complex vector space. In order to represent transformations of this space in matrix notation
we need to choose an isomorphism
between this space and the s
pace of complex 4

tuples.
There is no reason, other than convention, to pick one isomorphism over another. The one we
use here associates

00
,

01
,

10
, and

11
to the standard 4

tuple basis (1, 0, 0, 0)
T
, (0, 1, 0,
0)
T
, (0, 0, 1, 0)
T
, and (0, 0, 0,
1)
T
, in that order. The
C
not
transformation has representations
C
not
0
0
〉
0
0
〉

0
1
〉

0
1
〉

1
0
〉

1
1
〉

1
1
〉

1
0
〉
The transformation
C
not
is unitary since
C
*
not
=
C
not
and
C
not
C
not
=
I
. The
C
not
gate cannot be
decomposed into a tensor product of two single

bit transformations.
Another importan
t single

bit transformation is the Hadamard transformation, defined by
H
: 
0
(
1/
2
)
(

0
+
1
)

1
(
1/
2
)
(

0
1
)
The transformation
H
has a number of important applications. When applied to

0
,
H
creates a superposition state
(
1/
2
)
(

0
+
1
)
. Applied to
n
bits individually,
H
generates a
superposition of all 2
n
possible states, which can be viewed as the binary representation of the
numbers from 0 to 2
n
1.
(
H
H
…
H
)00
…
0
=
((

0
+
1
)
(

0
+
1
)
…
(

0
+
1
))
=
The transformation that applies
H
to
n
bits is called the
Hadamard
, or
sometimes the
Walsh
–
Hadamard, transformation
W
. It can be defined as a recursive decomposition of the
form
W
1
= H, W
n+1
= H
W
n
The unitary property implies that qu
antum states cannot be copied or cloned. The no
cloning proof given here, originally due to
Wootters and Zurek [1982], is a simple application
of the linearity of unitary transformations.
Assume that U is a unitary transformation that clone, in that U(
a0
)
= aa
for all
quantum states a
. Let a
and b
be two orthogonal quantum states. Say U(a0
) = aa
and
U(b0
) = bb
. Consider c
= (1/
2)(
a
+ b
)
. By linearity,
U(c
0
) = (1/
2)(U(a0
) + U(b0
))
= (1/
2)(aa
+ bb
)
But if U is a cloning tr
ansformation then
U(c0
) = cc
= (1/2)(aa
+ 
a
b
+

b
a
+ bb
)
which is not equal to (1
/
2)(
aa
+ bb
). Thus there is no unitary operation that can reliably
clone unknown quantum states. It is clear that cloning is not possible by using measurement,
since measurement
is both prob
a
bi
listic and destructive of states not in the measuring
device’s associated
subspaces.
It is important to understand what sort of cloning is and isn’t allowed. It is possible to
clone a known quantum state. What the no cloni
ng principle tells us is that it is impossible to
reliably clone an unknown quantum state. Also, it is possible to obtain
n
particles in an
entangled state
a

00
…
0
+
b

11
…
1
from an unknown state
a

0
+
b
1
. Each of these particles
will behave in exactly
the same way when measured with respect to the standard basis for
quantum computation
{
00
…
0
,

00
…
01
,
…
,
11
…
1
},
but not when measured with respect
to other bases. It is not possible to create the
n

particle state (
a

0
+
b
1
)
…
(
a

0
+
b
1
)
from an unk
nown state
a

0
+
b
1
.
4
.
7
Quantum Compute
r
This section discusses how quantum mechanics can be used to perform computations and
how these computations are qualitatively different from those performed by a conv
entional
computer.
Recall from Section 4.6 th
at all quantum state transformations have to be
reversible. While the classical NOT gate is reversible, AND, OR, and NAND gates are not.
Thus it is not obvious that quantum transformations can carry out all classical computations.
Fi
rst
ly
we
describe compl
ete sets of reversible gates that can perform any classical
computation on a quantum computer.
S
econd
ly
we
discuss
quantum parallelism.
For two arbitrary unitary transformation
U
1
and
U
2
, the
“
conditional
”
transformation
0
0
U
1
+ 1
1
U
2
is also un
itary. The controlled

NOT gate can be defined by
C
NOT
=
0
0
I + 1
1
X
The three

bit controlled

controlled

NOT gate or Toffoli gate is also an instance of this
conditional definition:
T
=
0
0
I
I + 1
1
C
NOT
The Toffoli gate
T can be used
to construct complete set of
Boolean
connectives, as can
seen from the fact that it can be used be construct the AND and NOT operators in the
following way:
T1, 1, x
= 1, 1,
x
Tx, y, 0
= x, y, x
y
The T gate is sufficient to construct arbitrary c
ombinatorial circuits.
The Fredkin gate is a
“
controlled swap
”
and can be defined as
F
=
0
0
I
I + 1
1
S
where S is the swap operation.
S =

00
00

+ 
0
1
1
0

+1
0
0
1

+11
11

The reader can verify
that F, like T, is complete for combi
natorial circuits.
Knowing that an arbitrary classical function
f
with
m
input and
k
output bits can be
implemented on quantum computer, we assume the existence of a
quantum gate array U
f
that
implements
f
.
U
f
is a
m
+
k

bit transformation of the form
U
f
:

x
,
y

x
,
y
f
(
x
)
, where
denotes the bitwise exclusive

OR. Quantum gate arrays
U
f
, defined in this way, are unitary
for any function
f
. To compute
f
(
x
) we apply
U
f
to

x
tensored with
k
zeros

x
,
0
. Since
f
(
x
)
f
(
x
)
=
0 we have
U
f
U
f
=
I
.
Graphically the
transformation U
f
: 
x
,
y

x
,
y
f
(
x
)
is
depicted as
(See Figure 2)
x
x
U
f
y y
f ( x )
 0 >
 1 >
Fig. 2
Transformation
U
f
:

x
,
y

x
,
y
f
(
x
)
While the
T
and
F
gates are complete for combinatorial circuits, they cannot achieve
arbitrary quantum state transformations. I
n order to realize arbitrary unitary transformations,
single

bit rotations need to be included. Barenco et al
[
199
5]
show that
C
not
together with all
1

bit quantum gates is a universal gate set. It suffices to i
nclude the following 1

bit
transformations
for all 0
2
together with the
C
not
to obtain a universal set of gates.
As we shall see,
such nonclassical
transformation
s
are crucial for exploiting the power of quantum computers.
4
.
8
Turing is
F
orever
Quantum computers may
be faster than classical
(
von

Neumann
)
computers, but quantum
com
puters cannot solve any problem
that classical computers, if they have enough time and
memory, cannot solve.
A Turing machine can simulate a quantum computer, so a quantum computer could not
solve an undecidable problem like the halting problem.
The existence of quantum computers does not disprove the Church

Turing thesis.
4
.
9
Quantum Parallelism
What happens if U
f
is applied to input that is in a superposition? The answer is easy but
powerf
ul: since
U
f
is a linear transformation, it is applied to all basis vectors in the
superposition simultaneously and will generate a superposition of the results. In this way, it is
possible to compute
f
(
x
) for
n
values of
x
in a single application of
U
f
. T
his effect is called
quantum parallelism.
Quantum parallelism is a fundamental feature of many quantum algorithms. Heuristically,
and at the risk of over

simplifying, quantum parallelism allows quantum
computers
to
evaluate a function f(x) for many differe
nt values of x simultaneously. In this section we
explain how a quantum parallelism works, and some of its limitations.
The power of quantum algorithms comes from taking advantage of quantum parallelism
and entanglement. So
,
most quantum algorithms begin b
y computing a function on a
superposition of all values as follows.
Consider the
circuit
shown in Figure
3
, which applies U
f
to an input not in the
computational basis. Ins
tead,
the data register is prepared in the superposition (
0
+
1
)/
2,
which can b
e created with a Hadamard gate acting on 
0
. Then we apply U
f
, resulting in the
state:
(
0
, f(0)
+
1, f(1)
)/
2
This is a remarkable state! The different terms contain information about both f(0) and f(1); it
is almost as if we have evaluated f(x) for t
wo values of x simultaneously, it is a feature
known as quantum parallelism. Unlike class
ical
parallelism
, where multiple circuits each
built to compute f(x) are execute
simultaneously
, her
e
a single f(x) circuit is employed to
evaluate the function for mu
ltiple values of x simultaneously, by exploiting the ability of a
quantum computer to be in superpositions of different of different states.
Fig. 2 Quantum circuit for evaluating f(0) and f(1) simultaneously. U
f
is the quantum circuit which takes
inputs like 
x
,
y

x
,
y
f
(
x
)
This procedure can easily be generalized to functions on an arbitrary number of bits, by
using the
Hadamard transformation
described in
Section 3.6
. This operation is just n
Hadamard
gates acting in parallel on a qubits.
For
example
, shown in Figure
4
is the case n =
2 with qubits initially prepared as 
0
, which gives
((
0
+
1
)/
2)((
0
+
1
)/
2) = (
0
0
+
01
+ 1
0
+
11
)/2
as output.
Start with an
n

qubit state

00
…
0
. A
pply the Hadamard transformation to get
a
superposition
(

0
0
…
0
+
00
…
1
+
…
+
11
…
1
)
=
which should be viewed as the superposition of all integers 0
x <
2
n
. Add a
k

bit register
0
then by linearity
=
=
where
f
(
x
)
is the function of interest. Note that since
n
q
ubits enable working simultaneously
with 2
n
states, quantum parallelism circumvents the time/space tradeoff of classical
parallelism through its ability to provide an ex
ponential amount of computational space in a
linear amount of physical space.
Consider the trivial example of a controlled

controlled

NOT (Toffoli) gate
T
,
that
computes the conjunction of two values
.
Now take as input a superposition of all possible bit c
ombinations of
x
and
y
together
x x
U
f
y y
f(x)
(
0
+
1
)/
2
0>

>
with the necessary 0:
H0
H0
0
= (1/
2)(0
+ 1
)
(1/
2)(0
+ 1
)
0
= (1/2)(000
+ 010
+ 100
+ 110
)
Apply
T
to the superposition of inputs to get a superposition of the results, namely
T(H0
H0
0
) =
(
1/2)(000
+ 010
+ 100
+ 111
)
The resulting superposition can be viewed as a truth table for the conjunction, or more
generally as the graph of a function. In the output the values of
x
,
y
, and
x
y
are entangled
in such a way that measuring the res
ult will give one line of the truth table
, or more generally
one point of graph of the function. Note that the bits can be
measured in any order: measuring
the result will project the state to a superposition of the set of all input values for which
f
prod
uces this result, and measuring the input will project the result to the corresponding
function value.
Measuring at this point gives no advantage over classical parallelism because only one
result is obtained, and worse still one cannot even choose which r
esult one gets. The heart of
any quantum algorithm is the way in which it manipulates quantum parallelism so that
desired results will be measured with high probability. This sort of manipulation has no
classical analog and requires nontraditional programm
ing techniques. We list a couple of the
techniques currently known.
Amplify output values of interest. The general idea is to transform the state in such a way
that values of interest have larger amplitude and therefore have a higher probability of
being
measured.
Find common properties of all the values of
f
(
x
). This idea is exploited in Shor’s algorithm,
which uses a quantum Fourier transformation to obtain the period of
f
.
4.1
0
Classical
C
omputers vs. Quantum
C
omputers
Unsolved problems in physics
:
I
s it possible to construct a practical computer that performs
calculations
on
qubits
(quantum bits)?
A classical computer has a memory made up of
bits
, where each bit holds either a one or
a zero. A quantum computer maintains a sequence of
qubits
. A single
qubit can hold a one, a
zero, or, crucially, a
superposition
of these, allowing for an infinite number of states. A
quantum computer operates by manipulating those qubits with (possibly a suite of)
quantum
logic gates
.
An example of an implementation of q
ubits for a quantum computer would be the use of
particles with two
spin
states: "up" and "down" (typically written
0
and
1
). But in fact any
system possessing an
observable
quantity
A
which is
conserved
under time evolution and
such that
A
has at leas
t two discrete and sufficiently spaced consecutive
eigenvalues
, is a
suitable candidate for implementing a qubit. That's because any such system can be mapped
onto an effective
spin

1/2
.
4
.
11
Bits vs.
Q
ubits
Consider first a classical computer that operate
s on a 3 bit
register
. At any given time, the bits
in the register are in a definite state, such as 101. In a quantum computer, however, the qubits
can be in a superposition of all the classically allowed states. In fact, the register is described
by a
wav
efunction
:

= a000
+ b001
+ c010
+ d011
+ e100
+ f100
+ g110
+ h111
Qubits are made up of controlled particles and the means of
control (e.g. devices that trap particles and switch
them from
one state to another),
where the coefficients a, b, c,... are
complex numbers
whose amplitudes squared are the
probabilities to measure the qubits in each state

for example,

c

2
is the probab
ility to measure the register in the state 010.
It is important that these numbers are complex, due to the
fact that the
phases
of the numbers can constructively and
destructively interfere with one another; this is an important
feature for quantum algorit
hms.
Recording the state of a
quantum register
requires an exponential number of complex
numbers (the 3

qubit register above requires 2
3
= 8 complex numbers). The number of
classical bits required even to estimate the complex numbers of some quantum state
grows
exponentially with the number of qubits. For a 300

qubit quantum register, somewhere on the
order of 1090 classical registers are required, more than there are atoms in the
observable
universe
.
4
.
1
2
Initialization,
E
xecution and
T
ermination
In our e
xample, the contents of the qubit registers can be thought of as an 8

dimensional
complex
vector
. An algorithm for a quantum computer must initialize this vector in some
specified form (dependent on the design of the quantum computer). In each step of the
algorithm, that vector is modified by multiplying it by a
unitary matrix
. The matrix is
determined by the physics of the device. The unitary character of the matrix ensures the
matrix is invertible (so each step is reversible).
Upon termination of the algo
rithm, the 8

dimensional complex vector stored in the
register must be somehow read off from the qubit register by a
quantum measurement
.
However, by the laws of quantum mechanics, that measurement will yield a
random
3 bit
string (and it will destroy the
stored state as well). This random string can be used in
computing the value of a function because (by design) the
probability distribution
of the
measured output bitstring is skewed in favor of the correct value of the function. By repeated
runs of the qu
antum computer and measurement of the output, the correct value can be
determined, to a high probability, by majority polling of the outputs. In brief, quantum
computations are probabilistic; see
quantum circuit
for a more precise formulation.
4
.
1
3
Power o
f
Q
uantum
C
omputers
Integer factorization
is believed to be computationally infeasible with an ordinary computer
for large integers that are the product of only a few
prime numbers
(e.g., products of two
300

digit primes). By comparison, a quantum computer
could solve this problem more
efficiently than a classical computer using
Shor's algorithm
to find its factors. This ability
would allow a quantum computer to "break" many of the cryptographic systems in use today,
in the sense that there would be a polyn
omial time (in the number of bits of the integer)
algorithm for solving the problem. In particular, most of the popular public key ciphers are
based on the difficulty of factoring integers, including forms of
RSA
and
ElGamal
. These are
used to protect secu
re Web pages, encrypted email, and many other types of data. Breaking
these would have significant ramifications for electronic privacy and security. The only way
to increase the security of an algorithm like
RSA
would be to increase the key size and hope
that an adversary does not have the resources to build and use a powerful enough quantum
computer. It seems plausible that it will always be possible to build classical computers that
have more bits than the number of qubits in the largest quantum computer
.
There are some
digital signature
schemes such as
Lamport signatures
that are believed to
be secure against quantum computers. Perhaps not as surprisingly, quantum computers could
also be useful for running simulations of quantum mechanics. This idea goes
back to
Richard
Feynman
(1982) who observed that there is no known algorithm for simulating quantum
systems on a classical computer and suggested studying the use of quantum computers for
this purpose. The speedup achieved by quantum computers could be ju
st as large as for
factoring. This could be a great boon to physics, chemistry, materials science, nanotechnology,
biology and medicine, all of which are limited today by the slow speed of quantum
mechanical simulations. For example, some modern simulation
s that are taking IBM's
Blue
Gene
supercomputer years, would take a quantum computer only a matter of seconds.
This dramatic advantage of quantum computers has only been discovered for these three
problems
so far
:
factoring, discrete logarithm, and quantum
physics simulations. However,
there is no proof that the advantage is real: an equally fast classical algorithm may still be
discovered. There is one other problem where quantum computers have a smaller, though
significant (quadratic) advantage. It is qua
ntum database search, and can be solved by
Grover's algorithm
. In this case the advantage is provable. This establishes beyond doubt that
(ideal) quantum computers are superior to classical computers for at least one problem.
Σχόλια 0
Συνδεθείτε για να κοινοποιήσετε σχόλιο