Top Banner
ABSTRACT Several limitations have become evident in classical computer. One of these limitations is factorizing a large number into its prime factors and quantum computers have the potential to solve this problem. This factorization is important in the area of applied cryptography. Quantum computers have memory that is exponentially larger than its apparent physical size and it can manipulate an exponential set of inputs simultaneously using a relatively few simple concepts from quantum mechanics. The subject of quantum computing brings together ideas from classical information theory, computer science, and quantum physics. Quantum Algorithms such as Shor’s Algorithm, Deutsch-Jozsa’s Algorithm, and Grover’s Algorithm, are discussed in this seminar work. The concept of Quantum Bits (Qubits) is discussed as well. These algorithms factorizes large numbers and provides smarter answers for search engine results in a very short time relative to the time it takes for classical computers to do same. The work done thus far suggests that it will only be a matter of time before we have devices to test Shor's and other quantum algorithms. Therefore, quantum
53

quantum computing

Oct 31, 2014

Download

Documents

Guy Dauda

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

ABSTRACT

Several limitations have become evident in classical computer. One of these limitations is

factorizing a large number into its prime factors and quantum computers have the potential to

solve this problem. This factorization is important in the area of applied cryptography.

Quantum computers have memory that is exponentially larger than its apparent physical size

and it can manipulate an exponential set of inputs simultaneously using a relatively few

simple concepts from quantum mechanics. The subject of quantum computing brings together

ideas from classical information theory, computer science, and quantum physics.

Quantum Algorithms such as Shor’s Algorithm, Deutsch-Jozsa’s Algorithm, and Grover’s

Algorithm, are discussed in this seminar work. The concept of Quantum Bits (Qubits) is

discussed as well. These algorithms factorizes large numbers and provides smarter answers

for search engine results in a very short time relative to the time it takes for classical

computers to do same. The work done thus far suggests that it will only be a matter of time

before we have devices to test Shor's and other quantum algorithms. Therefore, quantum

computers will emerge as the most superior computational device known to man.

Page 2: quantum computing

1.0. INTRODUCTION

The science of physics seeks to inquire or find precise answers to the questions that

nature and the universe presents so as to facilitate the interaction and manipulation of

certain properties and phenomena of nature. The invention of computer made

mathematical computations as well as other analogue processes to be performed easier,

faster and more efficiently. Since the invention of computer we have seen technological

advancements in science and society. The invention of the Internet brought about the

network of information which has helped to accelerate development and advancement

in fields in a plethora of ways. The internet has also facilitated many web based

operations some of which include internet banking as well as other internet transactions

which requires some formidable security. Without any doubt, the invention of computer

has been highly useful to the world. Computers are so ubiquitous and are used in almost

every discipline, however, it has fallen short in some areas that are pivotal to

development. That is where the concept of quantum computers was born, because these

quantum computers can make up for the limitations of the classical computers and they

can execute these operations with greater speed and accuracy (Hodges 2005).

1.1 How Quantum Computer Works

Firstly a quantum computer is a computational device that makes direct use of the

phenomenon of quantum mechanics such as entanglement and superposition to perform

operations on data. Classical computers require data to be encoded into binary digits (bits).

Quantum computation uses quantum properties to represent data and perform operations on

these data (Neil et al., 2009).

A quantum computer stores information as 0, 1, or a quantum superposition of the two

states. Such a "quantum bit," called a qubit, allows for far greater flexibility than the

binary system. Specifically, a quantum computer would be able to perform calculations

Page 3: quantum computing

on a far greater order of magnitude of data than traditional computers (a concept which

has serious implications in the area of cryptography & encryption. The development of

a successful and practical quantum computer would no doubt destabilize world's

financial system by making obsolete, its computer security encryptions, which are

based on factoring large numbers that for now cannot be cracked by traditional

computers within the life span of the universe. A quantum computer, on the other hand,

could factor the numbers in a reasonable period of time. To understand how this fact

speeds things up, consider this example. If the qubit is in a superposition of the 1 state

and the 0 state, and it performed a calculation with another qubit in the same

superposition, then one calculation actually obtains 4 results: a 1/1 result, a 1/0 result, a

0/1 result, and a 0/0 result. This is a result of the mathematics applied to a quantum

system when in a state of de-coherence, which lasts while it is in a superposition of

states until it collapses down into one state. The ability of a quantum computer to

perform multiple computations simultaneously is called quantum parallelism. The exact

physical mechanism at work within the quantum computer is somewhat theoretically

complex and intuitively disturbing. Generally, its execution is based on interpretations

and phenomena of quantum physics.

2.0 HISTORY OF QUANTUM COMPUTING

The idea of a computational device based on quantum computing was explored by a group of

computer scientists and physicists in the 1970’s and early 1980’s. And these individuals were

Richard Feynman from CALTECH (California Institute of Technology), David Deutsch from

University of Oxford, and Paul A. Benioff from Argonne National Laboratory and Charles H.

Bennett from IBM Research Centre. The idea emerged when these scientists were pondering

the fundamental limits of computation of the existing classical computers. They noticed

Page 4: quantum computing

according to Moore’s Law (which states that the number of micro components that can be

placed in an integrated circuit (microchip) will continue to double), that the continual

shrinking size of the circuitry packed onto the silicon chip would eventually reach a point

where the individual elements would be no larger than an atom. A conundrum arose at this

stage, since the classical computers in use all obey classical physics (classical theories of

physics) and classical physics fails in the atomic domain .The physical laws that govern the

properties and behaviour of the circuit in the atomic scale are quantum mechanical based.

This then raised a question whether a computer could be built based on the laws of quantum

mechanics. In 1982 Richard Feynman produced an abstract model that showed how a

quantum system can be used to perform calculations at a conference in MIT (Massachusetts

Institute of Technology) as an attempt to answer these questions. He also showed how useful

that system would be to physicists that may wish to simulate their ideas that may be quantum

physics based. In other words, the computer would act as a tool of experimentation of

quantum physics principles.

In 1985, David Deutsch published a crucial theoretical paper showing that any physical

process in principle could be modeled perfectly by a quantum computer. Thus, a quantum

computer will have capabilities and potentials that will be far above the conventional

classical computer. While David Deutsch succeeded in motivated people to look into the

development of quantum computing, challenges arose in the mathematical aspect of the field.

These challenges halted when Peter Shor generated a factoring algorithm. He set out methods

for using quantum computing to factor large integers. He showed how primitive

mathematical tools and an ensemble of mathematical operations can be built and designed

specifically for a quantum computer could be organized to enable such a machine to factorize

large numbers extremely rapidly and much faster than is possible on conventional computer.

With this breakthrough, quantum computing transformed from a mere academic curiosity, to

Page 5: quantum computing

a world interest. Hence other algorithms sprung up and people have been working on the field

from that time till date.

3.0. ELEMENTS OF QUANTUM COMPUTING

A quantum computer can be thought of as a classical computer with a quantum circuit

attached to it with some kind of interface between conventional and quantum logic.

Since there are only a few things a quantum computer does better than a classical

computer it makes sense to do the bulk of the processing on the classical machine.

3.1. Bits and Qubits

Quantum computers perform operations on qubits which are analogous to conventional

bits but they have an additional property in that they can be in a superposition. Bits

describe operations of gates, registers and circuits. Similarly qubits describe operations

of quantum gates, registers and circuits.

A quantum register with 3 qubits can store 8 numbers in superposition simultaneously,

and a 250 qubit register holds more numbers (superposed) than there are atoms in the

universe.

Figure 1: Representation of data-qubits

Page 6: quantum computing

3.1.1. Single Qubit

Classical computers use two discrete states to represent a unit of information; this state

is called a binary digit (or bit for short). A bit has the following two values:

0 and 1

There is no intermediate state between them, i.e. the value of the bit cannot be in a

superposition. Quantum bits, or qubits, can on the other hand be in a state “between” 0

and 1, but only during the computational phase of a quantum operation. When

measured, a qubit can become either:

The | > symbolic notation is part of the Dirac notation.

3.1.2. Multiple Qubits

The potential amount of information available during the computational phase grows

exponentially with the size of the system, i.e. the number of qubits. This is because if

we have n qubits the number of basis states is 2n. E.g. if we have two qubits, forming a

quantum register then there are four (=22) computational basis states: forming

Here |01> means that qubit 1 is in state |0> and qubit 2 is in state |1>, etc.

Page 7: quantum computing

Figure 2: Qubits constructed using diamond crystals

4.0. CONCEPTS OF QUANTUM COMPUTING

The following are concepts of quantum computing:

4.1. Superposition

Superposition means that a system can be in two or more of its states simultaneously.

For example a single particle can be travelling along two different paths at once. This

implies that the particle has wave-like properties, which can mean that the waves from

the different paths can interfere with each other. Interference can cause the particle to

act in ways that are impossible to explain without these wave-like properties.

The ability for the particle to be in a superposition is where we get the parallel nature of

quantum computing: If each of the states corresponds to a different value then, if we

have a superposition of such states and act on the system, we effectively act on all the

states simultaneously.

Figure 3: Caesium experiment to demonstrate quantum superposition

Page 8: quantum computing

4.2. Entanglement

In 1935 Einstein (along with colleagues Podolski and Rosen) demonstrated a paradox

(named EPR after them) in an attempt to refute the undefined nature of quantum

systems. The results of their experiment seemed to show that quantum systems were

defined, having local state BEFORE measurement (Bell, J.S. 1964). Although the

original hypothesis was later proven wrong (i.e. it was proven that quantum systems do

not have local state before measurement). The effect they demonstrated was still

important, and later became known as ENTANGLEMENT. Entanglement is the ability

for pairs of particles to interact over any distance instantaneously. Particles do not

exactly communicate, but there is a statistical correlation between results of

measurements on each particle that is hard to understand using classical physics. To

become entangled, two particles are allowed to interact; they then separate and, on

measuring say, the velocity of one of them (regardless of the distance between them),

we can be sure of the value of velocity of the other one (before it is measured). The

reason we say that they communicate instantaneously is because they store no local

state and only have well defined state once they are measured. Because of this

limitation particles cannot be used to transmit classical messages faster than the speed

of light as we only know the states upon measurement. Entanglement has applications

in a wide variety of quantum algorithms and machinery.

Figure 4: Eight-photon quantum entanglement

Page 9: quantum computing

4.3. Uncertainty

The quantum world is irreducibly small so it’s impossible to measure a quantum system

without having an effect on that system as the measurement device is also quantum

mechanical. As a result there is no way of accurately predicting all of the properties of a

particle. There is a trade off - the properties occur in complementary pairs (like position

and momentum, or vertical spin and horizontal spin) and if we know one property with

a high degree of certainty then we must know almost nothing about the other property.

That unknown property’s behaviour is essentially random. An example of this is a

particle’s position and velocity: if we know exactly where it is then we know nothing

about how fast it is going. This indeterminacy is exploited in quantum cryptography.

Page 10: quantum computing

5.0 CLASSICAL ALGORITHMS

A lot of algorithms have been developed for the factorization of numbers into their respective

prime factors using a classical computer. Examples of these classical algorithms include:

1. Trial Division Algorithm.

2. Fermat Factorization Algorithm.

3. Pollard Rho Factorization Algorithm

4. Brent’s Factorization Algorithm.

5.1 Trial Division Algorithm

Trial division is the simplest algorithm for factoring an integer. Assume that s and t are

nontrivial factors of N such that st = N and s ≤ t. To perform the trial division algorithm, one

simply checks whether s | N for s = 2,.,√N. When such a divisor s is found, then t = N / s is

also a factor, and a factorization has been found for N. The upper bound of s √N is provided

by the following theorem:

Theorem: if N has nontrivial factors s, t with st = N and s ≤ t, then s ≤ √N.

Proof: Assume s > √N. Then t ≥ s > √N, and st > N, which contradicts the assumption that

That st = N. Then s ≤ √N

5.1.1 Pseudo Code for Trial Division

function trialDivision(N)

for s from 2 to floor(sqrt(N))

if s divides N then

return s, N/s

end if

end for

end function

Page 11: quantum computing

If this algorithm is given composite N, then it returns a pair of nontrivial factors s, t with s ≤

t. The statement s | N is equivalent to s ≡ 0 (mod N), and so it can be implemented via

modular arithmetic in most languages.

5.2 Fermat’s Factorization Algorithm

This algorithm was discovered by mathematician Pierre de Fermat in the 1600s. Fermat

factorization rewrites a composite number N as the difference of squares:

N = x2 - y2

The difference of two squares, leads immediately to the factorization of N:

N = (x+y)(x-y)

Assume that s and t are nontrivial odd factors of N such that st = N and s ≤ t. We can find x

and y such that s = (x - y) and t = (x + y). Solving this equation, we find that x= (s + t) / 2 and

y = (t - s) / 2. Here x and y are integers, since the difference between any two odd numbers is

even, and an even number is divisible by two. Since s > 1 and t ≥ s. we find that x ≥ 1 and y ≥

0. For particular x, y satisfying s = (x - y) and t = (x + y), we thus know that x = √N + y2, and

hence x ≥ N. Also, x ≤ (s + t) / 2 ≤ 2t / 2 ≤ N .For an algorithm, we choose x =√N, and xi+1 =

xi+1. For each i, we check whether yi = √xi-N is an integer and whether (xi+yi)(xi-yi) are

nontrivial factors of N. If both of these conditions hold, we return the nontrivial factors.

Otherwise, we continue to the next i, and exit once xi = N.

5.2.1 Pseudo code for Fermat Factorization.

function fermatFactor(N)

for x from ceil(sqrt(N)) to N

ySquared := x * x - N

if isSquare(ySquared) then

Page 12: quantum computing

y := sqrt(ySquared)

s := (x - y)

t := (x + y)

if s <> 1 and s <> N then

return s, t

end if

end if

end for

end function.

Here the isSquare(z) function is true if z is a square number and false otherwise. It is

straightforward to construct an isSquare function by taking a square root, rounding the

answer to an integer, squaring the result, and checking if the original number is reproduced.

5.3 Pollard’s Rho Factorization Algorithm

Pollard's rho method is a probabilistic method for factoring a composite number N by

iterating a polynomial modulo N. The method was published by J.M. Pollard in 1975.

Suppose we construct the sequence:

This sequence will eventually become periodic. It can be shown that the length of the cycle is

less than or equal to N by a proof by contradiction: assume that the length L of the cycle is

greater than N, however we have only N distinct xn values in our cycle of length L>N, so there

must exist two xn values are congruent, and these can be identified as the .starting points. of a

cycle with length less than or equal to N. Probabilistic arguments show that the expected time

Page 13: quantum computing

for this sequence (mod N) to fall into a cycle and expected length of the cycle are both

proportional to √N, for almost all N [8]. Other 7 initial values and iterative functions often

have similar behaviour under iteration, but the function f(n) = xn2+1 has been found to work

well in practice for factorization.

Pseudo code: Pollard rho Factorization

function pollardRho(N)# Initial values x(i) and x(2*i) for i = 0.xi := 2x2i := 2do# Find x(i+1) and x(2*(i+1))xiPrime := xi ^ 2 + 1x2iPrime := (x2i ^ 2 + 1) ^ 2 + 1# Increment i: change our running values for x(i), x(2*i).xi := xiPrime % Nx2i := x2iPrime % Ns := gcd(xi - x2i, N)if s <> 1 and s <> N thenreturn s, N/s

end if end do end function

5.4 Brent’s Factorization Algorithm

Brent's factorization method is an improvement to Pollard's rho algorithm, published by R.

Brent in 1980 (Weinstein, 2002). In Pollard's rho algorithm, one tries to find a nontrivial

factor s of N by finding indices i, j with i < j such that xi ≡ xj (mod s).

X0≡ 2 (mod N) Xn+1 ≡ xn

2 + 2 (mod N).

Pollard suggested that xn be compared to x2n for n = 1, 2, 3... Brent's improvement to Pollard's

method is to compare xn to xm, where m is the largest integral power of 2 less than n.

Pseudocode: Brent's Factorization Method

function brentFactor(N)

# Initial values x(i) and x(m) for i = 0.

Page 14: quantum computing

xi := 2

xm := 2

for i from 1 to infinity

# Find x(i) from x(i-1).

xi := (xi ^ 2 + 1) % N

s := gcd(xi - xm, N)

if s <> 1 and s <> N then

return s, N/s

end if

if integralPowerOf2(i) then

xm := xi

end if

end do

end function

Here the function integralPowerOf2(z) is true if z is an integral power of 2 and false

otherwise. An inefficient implementation for this function can be made by checking

successive powers of 2 until a power of 2 equals or exceeds z:

function integralPowerOf2(z)

pow2 := 1

while pow2 <= z do

if pow2 = z then

return true

end if

pow2 := pow2 * 2

end while

Page 15: quantum computing

return false

end function

In terms of more efficient operations, integralPowerOf2 (z) is true if and only if (z&(z-1)) is

zero, where & is the bitwise AND operation (Ohannessian, 2003).

All this algorithms that are listed above are good algorithms but they are intractable in that

they are not efficient and practically applicable. This is because when applied in the

factorization of a very large number of say 100 digits, it could take more than 65 years to

work through to a solution. This is where quantum algorithms come in to play.

6.0 QUANTUM ALGORITHMS

Since quantum computing is based on a concept that is different from that governing classical

computing. Hence the algorithms that are constructed are fundamentally different which

inevitably affects the structure as well as the function, implementation and execution.

The first quantum algorithms were designed to exploit the adequacy of quantum computation

to computational problems which involve oracles. Oracles are devices which are used to

answer questions with a simple yes or no.

6.1 The Deutsch Oracle

This oracle (Deutsch, 1989) answers the following question. Suppose we have a

function ƒ: {0, 1} → {0, 1}, which can be either constant or balanced. In this case, the

function is constant if ƒ(0) = ƒ(1) and it is balanced if ƒ(0) ≠ ƒ(1). One can prepare the

input qubits of the Deutsch oracle as the superposition ( 0 + 1 )/√2 (using the

Hadamard gate on 0 ) and the superposition ( 0 − 1 )/√2 (using the Hadamard

Page 16: quantum computing

superposition) ( 0 − 1 )/√2 (using the Hadamard gate on 1 ). The final output of

the algorithm is the state

± ƒ(0) ⊕ƒ(1) ([ 0 − 1 ]/√2).

6.2 The Simon Oracle

Suppose we have a Boolean function ƒ: {0, 1} n → {0, 1} n. The function is supposed to

be 2-to-1, i.e., for every value of ƒ there are always two x1 and x2 such that ƒ(x1) =

ƒ(x2). The function is also supposed to be periodic, meaning that there is a binary vector

a such that ƒ (x⊕a) = ƒ(x), where ⊕ designates addition modulo 2, i.e., 1 ⊕ 1 = 0. The

Simon oracle returns the period a in a number of measurements linear in n, which is

exponentially faster than any classical algorithm.

6.3 Shor’s Algorithm

Shor’s algorithm named after the mathematician, Peter Shor, is a quantum algorithm built for

the factorization of integers. Informally it solves the problem; given an integer N, find its

prime factors. It is a lot easier to compute the product of two prime numbers or prime factors

than to take a composite number and break it down into its prime factors. For example, let N

be a composite number having factors N1 and N2. If N1 = 879651 and N2 = 685741, then N =

603212756391. If you look closely you will deduce that it is relatively easy to compute the

products of those large numbers than to take the result and find the factors that make it up.

On a quantum computer, to find an integer N, Shor’s algorithm runs in polynomial time (the

time taken is a polynomial in log N which is the size of the input). Specifically it takes time

O ((log N) 3), demonstrating that the integer factorization problem can be effectively solved

on a quantum computer at a rate that is exponentially faster than the most efficient classical

factoring algorithm (Lipton, 1995). The general number sieve method, which works in sub-

Page 17: quantum computing

exponential time. The efficiency of Shor’s algorithm is due to the efficiency of the quantum

Fourier transform and modular exponentiation by squaring.

Figure 5: flowchart representation of Shors algorithm

If a quantum computer with a sufficient number of qubits were to be constructed, Shor’s

algorithm could be used to break public-key cryptography schemes such as the commonly

known and widely used RSA-129 e.t.c scheme.

6.3.1 Steps of Shor’s Algorithm

Since the Algorithm consists of three key steps, this explanation will be presented in 3

stages.

Stage 1

In order to keep the example relatively easy to follow we will consider the problem of

finding the prime factors of the number 15. The first stage of the algorithm is to place a

memory register into a coherent superposition of all its possible states. The letter 'Q'

will be used denote a qubit that is in the coherent state.

Stage 2

The second stage of the algorithm performs a calculation using a register. The details of

this calculation are as follows:

The number N is the number we wish to factorize, N = 15

A random number X is chosen, where 1 < X < N-1

Page 18: quantum computing

X is raised to the power contained in the register (register A)

and then divided by N

The remainder from this operation is placed in a second 4 bit register

(register B).

After this operation has been performed, register B contains the superposition of

each universe’s result.

Stage 3:

The final stage is perhaps the most difficult to follow. The frequency of

repetition, f, can be found using a quantum computer. This is done by

performing a complex operation on register B and then looking at its contents

which causes the results from every universe to interfere with each other. The

resulting value for f is then used in the following equation to calculate a

(possible) factor:

Figure 6: the possible factor equation

Page 19: quantum computing

6.4 Adiabatic Algorithm

According to the adiabatic theorem and given certain specific conditions, a quantum system

remains in its lowest energy state, known as the ground state, along an adiabatic

transformation in which the system is deformed slowly and smoothly from an initial

Hamiltonian to a final Hamiltonian. The most important condition in this theorem is the

energy gap between the ground state and the next excited state. Being inversely proportional

to the evolution time T, this gap controls the latter. If this gap exists during the entire

evolution, the theorem dictates that in the adiabatic limit (when T→∞) the system will remain

in its ground state (Farhi, 2001). In practice, of course, T is always finite, but the longer it is,

the less likely it is that the system will deviate from its ground state during the process of the

time evolution.

Figure 7: flowchart of adiabatic algorithm

Page 20: quantum computing

Figure 8: classical simulation of quantum adiabatic algorithm

The figure above shows the process of simulating a quantum adiabatic algorithm

classically using multiple programming languages structurally for each section of

execution of the simulation.

6.5 Grover’s Algorithm

Grover’s algorithm is a quantum algorithm for searching an unsorted database with N entries

with O (N1/2) time and using O (log N) storage space. It was discovered by Lov Grover in

1996. In models of classical computation, searching an unsorted database cannot be done in

less than linear time. (So merely searching through every time is optimal). Grover’s

algorithm illustrates that in the quantum model searching can be done faster than this; in fact

Page 21: quantum computing

its time complexity O (N1/2) is asymptotically the fastest possible for searching unsorted

database in quantum model. It provides a quadratic speed up, unlike other quantum

algorithms which provide exponential speed up over their classical counterparts. However

quadratic is considerable when N is large. Like many other quantum algorithms, Grover’s

algorithm is probabilistic that is it gives the required result in high probability. Iteration

reduces the probability of failure. An example of a deterministic quantum algorithm is the

Deutsch-Jozsa algorithm. It always gives the correct result to the problem. The probability of

getting the right answer using the Deutsch-Jozsa algorithm is 1 (100%).

Figure 9: Quantum Gate Operation In The Presence Of Grover’s Algorithm

6.5.1 Uses of Grover's algorithm

Although the purpose of Grover's algorithm is usually described as "searching a database", it

may be more accurate to describe it as "inverting a function". Roughly speaking, if we have a

function y=f(x) that can be evaluated on a quantum computer, Grover's algorithm allows us to

calculate x when given y. Inverting a function is related to the searching of a database

because we could come up with a function that produces a particular value of y if x matches a

desired entry in a database, and another value of y for other values of x. Grover's algorithm

Page 22: quantum computing

can also be used for estimating the mean and median of a set of numbers, and for solving

the collision problem Grover (1996). In addition, it can be used to solve NP-

complete problems by performing exhaustive searches over the set of possible solutions. This

would result in a considerable speedup over classical solutions, even though it does not

provide the "holy grail" of a polynomial-time solution. Below, we present the basic form of

Grover's algorithm, which searches for a single matching entry. The algorithm can be further

optimized if there is more than one matching entry and the number of matches is known

beforehand.

6.5.2 Setup Steps of Grover’s Algorithm

Consider an unsorted database with N entries. The algorithm requires an N-dimensional state

space H, which can be supplied by log2N qubits. Let us number the database entries by 0,

1, ... (N-1). Choose an observable, Ω, acting on H, with N distinct eigen-values whose values

are all known. Each of the eigen-states of Ω encodes one of the entries in the database, in a

manner that we will describe. Denote the eigen states (using bra-ket notation) as

And the corresponding eigen-values by

We are provided with a unitary operator, Uω, which acts as a subroutine that compares

database entries according to some search criterion. The algorithm does not specify how this

subroutine works, but it must be a quantum subroutine that works with super-positions of

states. Furthermore, it must act specially on one of the eigen-states, |ω>, which corresponds

to the database entry matching the search criterion. To be precise, we require Uω to have the

following effects:

Page 23: quantum computing

Our goal is to identify this eigen-state |ω>, or equivalently the eigen-value ω, that Uω acts

specially upon (Grover, 2001)

6.5.3 Steps Of Grover’s Algorithm

The steps of Grover's algorithm are as follows:

1. Initialize the system to the state

2. Perform the following "Grover iteration" r(N) times. The function r(N) is described

below.

1. Apply the operator Uω

2. Apply the operator .

3. Perform the measurement Ω. The measurement result will be λω with probability

approaching 1 for N>>1. From λω, ω may be obtained.

6.5.4 Explanation of the Algorithm

Our initial state is given as

Consider the plane spanned by |s> and |ω>. Let |ω×> be a ket in this plane perpendicular to |

ω>. Since |ω> is one of the basis vectors, the overlap is

Page 24: quantum computing

In geometric terms, there is an angle (π/2 - θ) between |ω> and |s>, where θ is given by:

The operator Uω is a reflection at the hyper plane orthogonal to |ω>; for vectors in the plane

spanned by |s> and |ω>, it acts as a reflection at the line through |ω×>. The operator Us is a

reflection at the line through |s>. Therefore, the state vector remains in the plane spanned by |

s> and |ω> after each application of Us and after each application of Uω, and it is

straightforward to check that the operator UsUω of each Grover iteration step rotates the state

vector by an angle of 2θ toward |ω>.

We need to stop when the state vector passes close to |ω>; after this, subsequent iterations

rotate the state vector away from |ω>, reducing the probability of obtaining the correct

answer. The number of times to iterate is given by r. In order to align the state vector exactly

with |ω>, we need:

However, r must be an integer, so generally we can only set r to be the integer closest to (π/θ

- 2)/4. The angle between |ω> and the final state vector is O(θ), so the probability of

obtaining the wrong answer is O(1 - cos2θ) = O(sin2θ).

For N>>1, θ ≈ N-1/2, so

Page 25: quantum computing

Furthermore, the probability of obtaining the wrong answer becomes O(1/N), which goes to zero for large N.

6.5.5 Extensions of Grover’s Algorithm

If, instead of 1 matching entry, there are k matching entries, the same algorithm works but the

number of iterations must be π(N/k)1/2/4 instead of πN1/2/4. There are several ways to handle

the case if k is unknown. For example, one could run Grover's algorithm several times, with

iterations. For any k, one of iterations will find a matching entry with a sufficiently high

probability. The total number of iterations is at most which is still O(N1/2).

It is known that Grover's algorithm is optimal. That is, any algorithm that accesses the

database only by using the operator Uω must apply Uω at least as many times as Grover's

algorithm (Bernstein et al., 1997).

6.6 Topological-Quantum-Field-Theory (TQFT) Algorithms

Another exotic model for quantum computing which is attracting a lot of attention lately,

especially from Microsoft inc. (Freedman 1998), is the Topological Quantum Field Theory

model. In contrast to the straightforward and standard circuit model, this model resides in the

most abstract reaches of theoretical physics. The exotic physical systems TQFT describes are

topological states of matter. That the formalism of TQFT can be applied to computational

problems was shown by Witten (1989) and the idea was later developed by others. Also here

Page 26: quantum computing

the model was proved to be efficiently simulated on a standard quantum computer

(Freedman, Kitaev and Wang (2000) and Aharonov et al. 2005), but its merit lies in its high

tolerance to errors resulting from any possible realization of a large scale quantum computer

(see below). Topology is especially helpful here because many global topological properties

are, by definition, invariant under deformation, and given that most errors are local,

information encoded in topological properties is robust against them.

7.0 OPERATIONS OF A QUANTUM COMPUTER

As we saw earlier, a quantum computer is a computer design which uses the principles

of quantum physics to increase the computational power beyond what is attainable by a

traditional computer. Quantum computers have been built on the small scale and work

continues to upgrade them to more practical models. A quantum computer looks like

this, taking n input qubits, the register V, and producing n output qubits, the register W:

Figure 10: Input register prepared as a superposition of states

The computer then calculates in parallel the function applied to all 2n integers

simultaneously. From QMP (Quantum Measurement Postulate), when we measure W,

it will choose a Boolean for each bit of the output register according to the resulting

Page 27: quantum computing

entangled wave function of the output qubits. F is designed so that it maximizes the

probability that the output we measure is the answer we want. Measuring the output

collapses the wave function: get Boolean values for all the qubits in W. The result is

one of the possible outputs. Imagine that F is (integer) square root W =√V. For the

optimum solution, let V be prepared as the superposition of all integers from 0 to 2nso

that when we run the computer W can be measured. F calculates the square roots of all

the integers in parallel, while in QMP we can only find out about one. For real

problems, F should be arranged so that the probability amplitudes of the output state

strongly favour the desired output from F.

Quantum computers are like huge multidimensional arrays of slits that generate

interference patterns in the wave functions. If the array is designed correctly, the pattern

gives the solution of the problem. A quantum computer is probabilistic hence we may

need to run it multiple times before we get the answer we want.

7.1 Quantum Gates

In quantum computing and specifically the quantum circuit model of computation, a

quantum gate (or quantum logic gate) is a basic quantum circuit operating on a small

number of qubits. They are the building blocks of quantum circuits, like classical logic

gates are for conventional digital circuits. Unlike many classical logic gates, quantum

logic gates are reversible. However, classical computing can be performed using only

reversible gates. Quantum logic gates are represented by unitary matrices. The most

common quantum gates operate on spaces of one or two qubits, just like the common

classical logic gates operate on one or two bits. This means that as matrices, quantum

gates can be described by 2 × 2 or 4 × 4 unitary matrices.

Page 28: quantum computing

7.1.1 Commonly Used Gates

The quantum gates identified till date include the following:

1. Hadamard Gate

2. Pauli-X Gate

3. Pauli-Y Gate

4. Pauli-Z Gate

5. Swap Gate

6. Controlled-NOT Gate

7.1.1.1 Hadamard Gate

The Hadamard gate acts on a single qubit. It maps the basis state to

and to .

It is represented by the Hadamard matrix:

Since the rows of the matrix are orthogonal, H is indeed a unitary matrix (Barenco, et

al. 1995).

Page 29: quantum computing

Figure 11: Representation of Hadamard Gate

7.1.1.2 Pauli-X Gate

The Pauli-X gate acts on a single qubit. It is the quantum equivalent of a NOT gate. It

equates to a rotation of the Bloch Sphere around the X-axis by π radians. It maps to

and to . It is represented by the Pauli X matrix:

This gives us the following:

7.1.1.3 Pauli-Y Gate

HState |0>

State |0> + |1>

HState |1>

Page 30: quantum computing

The Pauli-Y gate acts on a single qubit. It equates to a rotation around the Y-axis of the

Bloch Sphere by π radians. It maps to and to . It is represented by the

Pauli Y matrix:

.

This gives us the following:

7.1.1.4 Pauli-Z Gate

The Pauli-Z gate acts on a single qubit. It equates to a rotation around the Z-axis of the

Bloch Sphere by π radians. It leaves the basis state unchanged and maps to .

It is represented by the Pauli Z matrix:

This gives us the following:

Page 31: quantum computing

7.1.1.5 Swap Gate

The swap gate swaps two qubits. It is represented by the matrix:

7.1.1.6 Controlled-NOT Gate

Controlled-NOT gate (C-NOT, for short) is a two-qubit gate, where the value of the first

qubit (called control) determines what will happen to the second qubit (called target) qubit.

[13]. Controlled-NOT gates act on 2 or more qubits, where one or more qubits act as a

control for some operation. For example, the controlled-NOT (or CNOT) gate acts on 2

qubits, and performs the NOT operation on the second qubits only when the first qubit is ,

and otherwise leaves it unchanged. It is represented by the matrix.

This gives the following:

Page 32: quantum computing

Figure 11: Representation of CNOT gate

8.0 APPLICATIONS, USES AND THE DISADVANTAGES OF QUANTUM

COMPUTING

8.1. Applications of quantum computing

1. Quantum Communication

Quantum communication systems allow a sender and receiver to agree on a code

without ever meeting in person. The uncertainty principle, an inescapable property of

the quantum world, ensures that if an eavesdropper tries to monitor the signal in transit

it will be disturbed in such a way that the sender and receiver are alerted.

2. Quantum Cryptography

The expected capabilities of quantum computation promise great improvements in the

world of cryptography. Ironically the same technology also promises current

cryptography techniques a world of problems. They will create the ability to break the

A - Target

B - Control

A’

B’

Page 33: quantum computing

RSA coding system and this will render almost all current channels of communication

insecure.

3. Artificial Intelligence

The theories of quantum computation suggest that every physical object, even the

universe, is in some sense a quantum computer. As Turing's work says that all

computers are functionally equivalent, computers should be able to model every

physical process. Ultimately this suggests that computers will be capable of simulating

conscious rational thought. And a quantum computer will be the key to achieving true

artificial intelligence.

8.2 Uses of Quantum Computing

Quantum Computing is ideal for tasks such as

Cryptography

Modeling

Indexing very large databases

8.3 Disadvantages of Quantum Computing

Quantum computing is not well suited for tasks such as word processing and email. For

a broad class of problems, quantum computation cannot provide any speed-up. 

Page 34: quantum computing

9.0 CONCLUSION

Experimental and theoretical research in quantum computation is accelerating world-

wide. New technologies for realizing quantum computers are being proposed, and new

types of quantum computation with various advantages over classical computation are

continually being discovered and analyzed and I believe some of them will bear

technological fruit. And these fruits will be evident in a lot of fields.

Page 35: quantum computing

REFERENCES

Barenco, A. (1995): Elementary gates for quantum computation. Phys. Rev., 52: 3457–3467.

Bassi, A. (2005): Towards quantum superpositions of a mirror: stochastic collapse analysis.

http://www.itpro.co.uk/news/121086/trappedatoms-could-advance-quantum

computing.html.

Bell, J.S. (1964): On the Einstein Podolsky Rosen paradox, Physics, 1: 195–200.

Bennett, C. (1997): Strengths and weaknesses of quantum computing. SIAM Journal on

Computing, 26(5): 1510–1523.

Biham E., Bryant S., Graham B. (2004): Quantum computing without entanglement,

Theoretical Computer Science, 320: 15–33.

Das, A. and Chakrabarti B. K (2008): Quantum annealing and analog quantum computation.

Rev.Mod. Phys. 80:1061-1081.

David P. DiVincenzo (1995): Quantum Computation". Science 270 (5234): 255–261.

David P. DiVincenzo (2000): The Physical Implementation of Quantum Computation.

Experimental Proposals for Quantum Computation. arXiv:quant-ph/0002077.

Farhi, E. (2001): A quantum adiabatic evolution algorithm applied to random instances of an

NP-complete problem. Science, 292(5516): 472–475.

Feynman, R. (1982): Simulating physics with computers. International Journal of

Theoretical Physics, 21: 467–488.

Grover L.K. (2001): From Schrodinger's equation to quantum search algorithm. American

Journal of Physics, 69(7): 769-777.

Grover L.K. (1996): A fast quantum mechanical algorithm for database search. Proceedings,

28th Annual ACM Symposium on the Theory of Computing, p. 212.

Grover, L. (1996): A fast quantum mechanical algorithm for database search. Proc. 28th

ACM Symp. Theory of Computing, 212–219.

Page 36: quantum computing

Lipton, R. (1995): Using DNA to solve NP-complete problems. Science, 268: 542–545.

Neil Gershenfeld and Isaac L.Chuang (2009): Quantum Computing with Molecule. Scientific

American (http://phm.cba.mit.edu/papers/98.06.sciam/0698gershenfeld.html).

Preskill, J. (1998): Quantum computing: Pro and Con. Proc. Roy. Soc. Lond., 454: 469–486.

Rabin, M. (1976): Probabilistic algorithms: in J. Traub (ed.) Algorithms and Complexity: New

Directions and Recent Results, New York: Academic Press.

Rene Millman (2007): Trapped atoms could advance quantum computing. Nature, 473:194–

198.

Saffman, M. (2006): Dirac Notation and rules of Quantum Mechanics, Atomic and Quantum

Physics. http://hexagon.physics.wisc.edu/teaching/2007f_ph448/diracnotation.pdf.

Retrieved 2007-07-26

Simon, D.R. (1994): On the power of quantum computation. Proceedings of the 35th Annual

IEEE Symposium on Foundations of Computer Science, pp. 116–123

Vergis, A. (1997): The complexity of analog computation. Mathematics and Computers in

Simulation. SIAM Journal on Computing, 26(5): 1474–1483.28: 91–113