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 Shors Algorithm, Deutsch-Jozsas Algorithm, and Grovers 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 1970s and early 1980s. 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 Moores 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
n

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

quantum register then there are four (=2 ) 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 its 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 propertys behaviour is essentially random. An example of this is a particles 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. Brents 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

Fermats 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

Pollards 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 := 2 x2i := 2 do # Find x(i+1) and x(2*(i+1)) xiPrime := xi ^ 2 + 1 x2iPrime := (x2i ^ 2 + 1) ^ 2 + 1 # Increment i: change our running values for x(i), x(2*i). xi := xiPrime % N x2i := x2iPrime % N s := gcd(xi - x2i, N) if s <> 1 and s <> N then return s, N/s end if end do end function Brents Factorization Algorithm

5.4

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 xn2 + 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 (xa) = (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

Shors Algorithm

Shors 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, Shors 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 Shors 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, Shors 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 Shors 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 and then divided by N

(register A)

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

Grovers Algorithm

Grovers 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). Grovers 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, Grovers 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 Grovers 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 Grovers 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 Grovers 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 Grovers 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

2 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
n

optimum solution, let V be prepared as the superposition of all integers from 0 to 2 so 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 and to . It is represented by the Pauli X matrix: to

This gives us the following:

7.1.1.3 Pauli-Y Gate 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 the Pauli Y matrix: to and to . It is represented by

. 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 . It is represented by the Pauli Z matrix: unchanged and maps to

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 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 worldwide. 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: 34573467. 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: 195200. Bennett, C. (1997): Strengths and weaknesses of quantum computing. SIAM Journal on Computing, 26(5): 15101523. Biham E., Bryant S., Graham B. (2004): Quantum computing without entanglement, Theoretical Computer Science, 320: 1533. 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): 255261. 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): 472475. Feynman, R. (1982): Simulating physics with computers. International Journal of Theoretical Physics, 21: 467488. 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, 212219.

Lipton, R. (1995): Using DNA to solve NP-complete problems. Science, 268: 542545. 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: 469486. 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. 116123 Vergis, A. (1997): The complexity of analog computation. Mathematics and Computers in Simulation. SIAM Journal on Computing, 26(5): 14741483.28: 91113