quantum computing
description
Transcript of 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.
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
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
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
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
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.
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
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
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.
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
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
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
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.
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
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
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-
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
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
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
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
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
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:
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
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
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
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
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.
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).
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>
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:
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:
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’
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.
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.
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.
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