A brief overview of quantum computing
or,
Can we compute faster in a multiverse?

Tom Carter

http://cogs.csustan.edu/~ tom/quantum

May 14, 1999

• Hilbert spaces and quantum mechanics.
• Tensor products and entangled quantum states.
• Quantum bits (qubits), the physics of computation, elements of quantum computing.
• Tractability of computation (e.g., factoring and boolean satisfiability).
• Models for quantum computing.
• Suggestions for practical implementations of quantum computers.
• Problems and prospects.

"There was a time when the newspapers said that only 12 men understood the theory of relativity. I do not believe there ever was such a time. There might have been a time when only 1 man did, because he was the only guy who caught on, before he wrote his paper. But after people read the paper a lot of people understood the theory of relativity in some way or other, certainly more than 12. On the other hand, I think I can safely say that nobody understands quantum mechanics"

-Richard Feynman

• A Hilbert space H is a complete normed vector space over \mathbbC :

  1. H is a vector space over \mathbbC
  2. There is an inner product
     á·|·ñ : H x H® \mathbbC
     

     which is conjugate linear:
     áv|wñ = [`(áw|vñ)]
     áv|awñ = aáv|wñ for a Î \mathbbC
     áv+w|zñ = áv|zñ + áw|zñ
     áv|vñ ³ 0 and áv|vñ = 0 iff v = 0

  3. From the inner product, as usual, we define the norm of a vector:
     ||v ||² = áv|vñ
  4. H is complete with respect to the norm.

• We will typically use the bra/ket notation:
  |vñ is a vector in H, and
  áv| is the covector which is the conjugate transpose of v.
• This notation also allows us to represent the outer product of a vector and covector as |vñ áw|, which, for example, acts on a vector |zñ as |vñ áw|zñ. For example, if {v₁,v₂} is an orthonormal basis for a two-dimensional Hilbert space, |v₁ñáv₂| is the transformation that maps |v₂ñ to |v₁ñ and |v₁ñ to (0, 0)^T since

  |v1ñáv2||v2ñ = |v1ñáv2|v2ñ = |v1ñ |v1ñáv2||v1ñ = |v1ñáv2|v1ñ = 0 |v1ñ = æ ç è 0 0 ö ÷ ø .

  Equivalently, |v₁ñáv₂| can be written in matrix form where |v₁ñ = (1, 0)^T, áv₁| = (1, 0), |v₂ñ = (0, 1)^T, and áv₂| = (0, 1). Then

  |v1ñáv2| = æ ç è 1 0 ö ÷ ø (0, 1) = æ ç è 0 1 0 0 ö ÷ ø .

• A unitary operator U : H® H is a linear mapping whose conjugate transpose is its inverse: U^f = U^-1
• Unitary operators are norm preserving:
  ||Uv ||² = áv| U^f U |vñ = áv|vñ = ||v ||²
• We will think of a quantum state as a (normalized) vector |vñ Î H. For math folks, we are in effect working in Complex projective space, normalizing to 1 so that the probabilities make sense.
• The dynamical evolution of a quantum system is expressed as a unitary operator acting on the quantum state.

• Eigenvalues of a unitary matrix are of the form e ^iw where w is a real-valued angle. A unitary operator is in effect a rotation.
• Just for reference, a typical expression of Schrödinger's equation looks like

  é ê ë - (h/2p)2 2me \bigtriangledown2+V(x,y,z) ù ú û Y = i(h/2p) ¶ ¶t Y

  with general solution

  Y(x,y,z,t) = ¥ å n = 0  cnYn(x,y,z)exp æ ç è -iEnt (h/2p) ö ÷ ø

  where Y_n(x,y,z) is an eigenfunction solution of the time independent Schrödinger equation with E_n the corresponding eigenvalue. The inner product, giving a time dependent probability, looks like

  P(t) = ó õ Y   Ydv.

• Another way to think of this is that we have to find the Hamiltonian H which generates evolution according to:

  i(h/2p) ¶ ¶t |Y(t)ñ = H |Y(t)ñ.

  In our context, we will have to solve for H given a desired U:

  |Yfñ = exp æ ç è - i (h/2p) ó õ Hdt ö ÷ ø |Y0ñ = U|Y0ñ

  A solution for H always exists, as long as the linear operator U is unitary.

• A measurement consists of applying an operator O to a quantum state v. To correspond to a classical observable, O must be Hermitian, O^f = O, so that all its eigenvalues are real. If one of its eigenvalues l is associated with a single eigenvector u_l, then we observe the value l with probability |áv|u_l ñ |² (i.e., the square of the length of the projection along u_l).

• In general, if there is more than one eigenvector u_l associated with the eigenvalue l, we let P_l be the projection operator onto the subspace spanned by the eigenvectors, and the probability of observing l when the system is in state v is ||P_l v||² .

• Most projection operators do not commute with each other, and are not invertible. Therefore, we can expect that the order in which we do measurements will matter, and that doing a measurement will irreversibly change the state of the quantum system.

• We can form tensor products of a wide variety of objects. For example:

  1. The tensor product of an n dimensional vector u and an m dimensional vector v is an nm dimensional vector u Äv.
  2. If A and B are operators on n and m dimensional vectors, respectively, then A ÄB is an operator on nm dimensional vectors.
  3. if H₁ and H₂ are Hilbert spaces, then H₁ ÄH₂ is also a Hilbert space. If H₁ and H₂ are finite dimensional with bases {u₁, u₂, ¼u_n} and {v₁, v₂, ¼v_m} respectively, then H₁ ÄH₂ has dimension nm with basis {u_i Äv_j | 1 £ i £ n, 1 £ j £ m}.

• Tensor products obey a number of nice rules. For matrices A, B, C, D, U, vectors u, v, w, and scalars a, b, c, d the following hold:

  (A ÄB) (C ÄD) = ACÄBD (A ÄB) (u Äv) = AuÄBv (u+v)Äw = uÄw + vÄw uÄ(v+w) = uÄv + uÄw auÄbv = ab(uÄv)

  Thus for matrices,

  æ ç è A B C D ö ÷ ø ÄU = æ ç è A ÄU B ÄU C ÄU D ÄU ö ÷ ø ,

  which specializes for scalars to

  æ ç è a b c d ö ÷ ø ÄU = æ ç è a U b U c U d U ö ÷ ø .

• The conjugate transpose distributes over tensor products:

  (AÄB)f = AfÄBf.

• The tensor product of several matrices is unitary if and only if each one of the matrices is unitary up to a constant. Let U = A₁Ä... ÄA_n. Then U is unitary if A_i^f A_i = k_i I and Õ_ik_i = 1.

  Uf U = (A1fÄ... ÄAnf )(A1Ä... ÄAn) = A1f A1Ä... ÄAnf An = k1IÄ... ÄknI = I

• Note that áu Äv|w Äzñ = áu|wñ áv|zñ. This implies that á0 Äu|0 Äuñ = 0, and therefore 0 Äu must be the zero vector of the tensor product Hilbert space.

  This in turn implies (reminds us?) that the tensor product space is actually the equivalence classes in a quotient space.

  In particular, if A and B are vector spaces, F is the free abelian group on A×B, and K is the subgroup of F generated by all elements of the following forms (where
  a, a₁, a₂ Î A, b, b₁, b₂ Î B, a a scalar):

  1. (a₁ + a₂,b) - (a₁,b) - (a₂,b)
  2. (a,b₁ + b₂) - (a,b₁) - (a,b₂)
  3. (aa,b) - (a,ab)

  then AÄB is the quotient space F/K.

• A quantum bit, or qubit, is a unit vector in a two dimensional complex vector space for which a particular orthonormal basis, denoted by {|0ñ, |1ñ}, has been fixed. It is important to notice that the basis vector |0ñ is NOT the zero vector of the vector space.
• For example, the basis |0ñ and |1ñ may correspond to the |­ ñ and |® ñ polarizations of a photon respectively, or to the polarizations |\nearrow ñ and |\nwarrow ñ. Or |0ñ and |1ñ could correspond to the spin-up and spin-down states (|­ ñ and |¯ ñ) of an electron.

• For the purposes of quantum computing, the basis states |0ñ and |1ñ are taken to encode the classical bit values 0 and 1 respectively. Unlike classical bits however, qubits can be in a superposition of |0ñ and |1ñ such as a|0ñ + b|1ñ where a and b are complex numbers such that |a|² + |b|² = 1. If such a superposition is measured with respect to the basis {|0ñ,|1ñ}, the probability that the measured value is |0ñ is |a|² and the probability that the measured value is |1ñ is |b|².

• Key properties of quantum bits:

  1. A qubit can be in a superposition state of 0 and 1.
  2. Measurement of a qubit in a superposition state will yield probabilistic results.
  3. Measurement of a qubit changes the state to the one measured.
  4. There is no transformation which exactly copies all qubits. This is known as the `no cloning' principle. Interestingly, it is nonetheless possible to `teleport' a quantum state, but in the process, the original quantum state is destroyed ...

"The Universe is full of magical things patiently waiting for our wits to grow sharper."

-Eden Phillpotts

Äny sufficiently advanced technology is indistinguishable from magic."

-Arthur C. Clarke

• If we have available more than one (physical) qubit, we may be able to entangle them. The tensor product of the Hilbert spaces for the individual qubits is the appropriate model for these entangled systems.

• For example, if we have two qubits with bases {|0ñ₁,|1ñ₁} and { |0ñ₂,|1ñ₂} respectively, the tensor product space has the basis

  {|0ñ1Ä|0ñ2,|0ñ1Ä|1ñ2,|1ñ1Ä|0ñ2,|1ñ1Ä|1ñ2}.

  We can (conveniently) denote this basis as

  {|00ñ,|01ñ,|10ñ,|11ñ}.

• More generally, if we have n qubits to which we can apply common measurements, we will be working in the 2ⁿ-dimensional Hilbert space with basis

  {|00¼00ñ,|00¼01ñ,¼,|11¼10ñ,|11¼11ñ}

• A typical quantum state for an n-qubit system is

  2n-1 å i = 0  ai|iñ

  where a_i Î \mathbbC, å|a_i|² = 1, and {|iñ} is the basis, with (in our notation) i written as an n-bit binary number.

• A classical (macroscopic) physical object broken into pieces can be described and measured as separate components. An n-particle quantum system cannot always be described in terms of the states of its component pieces. For instance, the state
  |00ñ+|11ñ cannot be decomposed into separate states of each of the two qubits in the form

  (a1|0ñ + b1|1ñ)Ä(a2|0ñ + b2|1ñ).

  This is because

  (a1|0ñ + b1|1ñ)Ä(a2|0ñ + b2|1ñ) =

  a1a2|00ñ + a1b2|01ñ + b1a2|10ñ + b1b2|11ñ

  and a₁b₂ = 0 implies that either a₁a₂ = 0 or b₁b₂ = 0. States which cannot be decomposed in this way are called entangled states. These are states that don't have classical counterparts, and for which our intuition is likely to fail.

• Particles are entangled if a measurement of one affects a measurement of the other. For example, the state [1/( Ö2)](|00ñ+|11ñ) is entangled since the probability of measuring the first bit as |0ñ is 1/2 if the second bit has not been measured. However, if the second bit has been measured, the probability that the first bit is measured as |0ñ is either 1 or 0, depending on whether the second bit was measured as |0ñ or |1ñ, respectively. On the other hand, the state [1/( Ö2)](|00ñ+|01ñ) is not entangled. Since [1/( Ö2)](|00ñ+|01ñ) = |0ñÄ[1/( Ö2)](|0ñ+|1ñ), any measurement of the first bit will yield |0ñ regardless of measurements of the second bit. Similarly, the second bit has a fifty-fifty chance of being measured as |0ñ regardless of measurements of the first bit. Note that entanglement in terms of particle measurement dependence is equivalent to the definition of entangled states as states that cannot be written as a tensor product of individual states.

``Anyone who is not shocked by quantum theory has not understood it.'' -Neils Bohr

``One is led to a new notion of unbroken wholeness which denies the classical analyzability of the world into separately and independently existing parts. The inseparable quantum interconnectedness of the whole universe is the fundamental reality.'' -David Bohm

``I don't like it, and I'm sorry I ever had anything to do with it.'' -Erwin Schrodinger

• This exponential growth in number of states, together with the ability to subject the entire space to transformations (either unitary dynamical evolution of the system, or a measurement projection into an eigenvector subspace), provides the foundation for quantum computing.
• An interesting (apparent) dilemma is the energetic costs/irreversability of classical computing. Since unitary transformations are invertible, quantum computations (except measurements) will all be reversible. Most classical boolean operations such as b₁\land b₂, b₁Úb₂, and b₁\land\negthickspace\negthickspace\negmedspace\negthinspace ~ b₂ are irreversible, and therefore cannot directly be used as basic operations for quantum computers.

• The logical nand-gate (b₁\land\negthickspace\negthickspace\negmedspace\negthinspace\negthinspace ~ b₂) is sufficient to generate all the traditional boolean functions (e.g., ~ \negmedspace b º b \land\negthickspace\negthickspace\negmedspace\negthinspace ~ b). We are likely to end up looking for simple quantum gates that are similarly generic for quantum operations.

• In general, if we had enough time, we could simulate any quantum computation with a classical computer. The real potential value of quantum computers lies in speeding up computations. The critical questions are:
  1. How much can we speed up particular computations?
  2. Can we develop a practical implementation of a particular quantum computation?
  3. Can we build a physical implementation of a quantum computer?
  4. Does the implementation allow us to carry out useful computations before decoherence interactions with the environment disturb the system too much?
  5. Given the ``no cloning'' principle, can we develop quantum error detection/correction systems? In particular, we can't just take measurements for error control since measurements have irreversible effects on quantum systems.

• These are some examples of useful single-qubit quantum state transformations. Because of linearity, the transformations are fully specified by their effect on the basis vectors. The associated matrix is also shown.

  I : |0ñ ® |0ñ |1ñ ® |1ñ æ ç è 1 0 0 1 ö ÷ ø sx: |0ñ ® |1ñ |1ñ ® |0ñ æ ç è 0 1 1 0 ö ÷ ø sy: |0ñ ® |1ñ |1ñ ® -|0ñ æ ç è 0 -1 1 0 ö ÷ ø sz: |0ñ ® |0ñ |1ñ ® -|1ñ æ ç è 1 0 0 -1 ö ÷ ø

  I is the identity transformation, s_x is negation, s_z is a phase shift operation, and s_y = s_zs_x is a combination of both. All these gates are unitary. For example

  sysyf = æ ç è 0 -1 1 0 ö ÷ ø æ ç è 0 1 -1 0 ö ÷ ø = I.

• Another important single-bit transformation is the Hadamard transformation defined by

  H: |0ñ ® 1 Ö2 (|0ñ + |1ñ) |1ñ ® 1 Ö2 (|0ñ - |1ñ).

  Applied to n bits each in the |0ñ state, the transformation generates a superposition of all 2ⁿ possible states.

  (HÄH Ä... ÄH)|00... 0ñ = 1   __ Ö2n   ((|0ñ+|1ñ)Ä...Ä(|0ñ+|1ñ)) = 1   __ Ö2n   2n-1 å x = 0  |xñ.

  The transformation acting on n bits is called the Walsh or Walsh-Hadamard transformation W.

• An important example of a two qubit gate is the controlled- not gate, C_not, which complements the second bit if the first bit is 1 and leaves the bit unchanged otherwise.

  Cnot: |00ñ ® |00ñ |01ñ ® |01ñ |10ñ ® |11ñ |11ñ ® |10ñ æ ç ç ç ç è 1 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 ö ÷ ÷ ÷ ÷ ø

  The transformation C_not is unitary since C_not^f = C_not and C_notC_not = I. The C_not gate cannot be decomposed into a tensor product of two single-bit transformations.

• The bra/ket notation is useful in defining other unitary operations. Given two arbitrary unitary transformations U₁ and U₂, the ``conditional'' transformation |0ñá0| ÄU₁ + |1ñá1|ÄU₂ is also unitary. For example, the controlled- not gate can defined by

  Cnot = |0ñá0| ÄI + |1ñá1|ÄX.

• The three-bit controlled-controlled- not gate or Toffoli gate is also an instance of this conditional definition:

  T = |0ñá0|ÄI ÄI + |1ñá1| ÄCnot.

  T: |000ñ ® |000ñ |001ñ ® |001ñ |010ñ ® |010ñ |011ñ ® |011ñ |100ñ ® |100ñ |101ñ ® |101ñ |110ñ ® |111ñ |111ñ ® |110ñ

  T can be used to construct a complete set of the classical boolean connectives and thus general combinatory circuits since it can be used to construct the not and and operators in the following way:

  T|1, 1, xñ = |1, 1, ~ xñ T|x, y, 0ñ = |x, y, x Ùyñ

• We can generally categorize computational algorithms according to how the resources needed for execution of the algorithm increase as we increase the size of the input. Typical resources are time and (storage) space. In different contexts, we may be interested in worst-case or average-case performance of the algorithm. For theoretical purposes, we will typically be interested in large input sets ...
• The hope of quantum computing is that problems that are difficult or impossible for classical computers to solve can be handled by quantum computers.
• A standard mechanism for comparing the growth of functions with domain \mathbbN is ``big-Oh.'' One way of defining this notion is to associate each function with a set of functions. We can then compare algorithms by looking at their ``big-Oh'' categories.
• Given a function f, we define O(f) by:

  g Î O(f) Û

  there exist c > 0 and N ³ 0 such that
  |g(n) | £ c|f(n) | for all n ³ N.
  
• We further define q(f) by:
  g Î q(f) iff g Î O(f) and f Î O(g).
  
• In general we will consider the run-time of algorithms in terms of the growth of the number of elementary computer operations as a function of the number of bits in the (encoded) input. Some important categories - an algorithm's run-time f is:
  1. Logarithmic if f Î q(log(n)).
  2. Linear if f Î q(n).
  3. Quadratic if f Î q(n²).
  4. Polynomial if f Î q(P(n)) for some polynomial P(n).
  5. Exponential if f Î q(bⁿ) for some constant b > 1.
  6. Factorial if f Î q(n!).

• Typically we say that a problem is tractable if (we know) there exists an algorithm whose run-time is (at worst) polynomial that solves the problem. Otherwise, we call the problem intractable.

• There are many problems which have the interesting property that if someone (an oracle?) provides you with a solution to the problem, you can tell in polynomial time whether what they provided you actually is a solution. Problems with this property are called Non-deterministically Polynomial, or NP, problems. One way to think about this property is to imagine that we have arbitrarily many machines available. We let each machine work on one possible solution, and whichever machine finds the (a) solution lets us know.
• There are some even more interesting NP problems which are universal for the class of NP problems. These are called NP-complete problems. A problem S is NP-complete if S is NP and, there exists a polynomial time algorithm that allows us to translate any NP problem into an instance of S. If we could find a polynomial time algorithm to solve a single NP-complete problem, we would then have a polynomial time solution for all NP problems.
• Some examples:
  1. Factoring a number is NP. First, we recognize that if M is the number we want to factor, then the input size m is approximately log(M) (that is, the input size is the number of digits in the number). The elementary school algorithm (try dividing by each number less than ÖM) has run-time approximately 10^m/₂, which is exponential in the number of digits. On the other hand, if someone hands you two numbers they claim are factors of M, you can check by multiplying, which takes on the order of m² operations.

     It is worth noting that there is a polynomial time algorithm to determine whether or not a number is prime, but for composite numbers, this algorithm does not provide a factorization. Factoring is a particularly important example because various encryption algorithms such as RSA (used in the PGP software) depend for their security on the difficulty of factoring numbers with several hundred digits.

  2. Satisfiability of a boolean expression is NP-complete. Suppose we have n boolean variables {b₁,b₂,¼,b_n} (each with the possible values 0 and 1). We can form a general boolean expression from these variables and their negations:

     f(b1,b2,¼,bn) = Ù k  ( Ú i,j £ n  (bi, ~ bj)).

     A solution to such a problem is an assignment of values 0 or 1 to each of the b_i such that f(b₁,b₂,¼,b_n) = 1. There are 2ⁿ possible assignments of values. We can check an individual possible solution in polynomial time, but there are exponentially many possibilities to check. If we could develop a feasible quantum computation for this problem, we would in some sense resolve the traditional P\overset? = NP problem ...
  3. The discrete Fourier transform of a sequence \overset\rightharpoonupa = áa_jñ_{j = 0}^q-1 is the sequence \overset\rightharpoonupA = áA_kñ_{k = 0}^q-1 where

     Ak = 1 Öq q-1 å j = 0  aje[(2pijk)/ q]

     One way to think about this is that \overset\rightharpoonupA = F\overset\rightharpoonupa where the linear transformation F is given by:

     [F]j,k = 1 Öq e[(2pijk)/ q]

     Note that the inverse of F is F^f - that is,

     [F-1]k,j = 1 Öq e-[(2pijk)/ q].

     Suggestively, this says that the discrete Fourier transform is a unitary operation.

     The action of this transformation on a vector of dimension q looks as though it would take the q² operations of matrix multiplication, but there is enough structure that the classical fast Fourier transform algorithm can be done in qlog(q) operations.

     The corresponding quantum Fourier transform U_QFT with base 2ⁿ is defined by

     UQFT: |xñ ® 1   __ Ö2n   2n-1 å c = 0  e[(2picx)/( 2n)]|cñ.

     We will see that this can be accomplished in approximately n² operations rather than n2ⁿ. This is an exponential speed-up of the process.

• The quantum algorithm which has probably done the most for popularizing quantum computation is Shor's factoring algorithm. As noted above, a fast algorithm for factoring numbers with several hundred digits would invalidate some of the most widely used encryption systems. Shor's algorithm provides theoretical evidence for such an algorithm, waiting only for a practical physical realization.
• The general approach used by Shor is based on a classical probabilistic method for factoring. The classical algorithm is exponential in the number of digits - Shor's is (quantum) polynomial.
• Outline of Shor's algorithm for factoring a number M:

  1. Choose an integer y < M arbitrarily. If y is not relatively prime to M, we've found a factor of M. Otherwise apply the rest of the algorithm.

  2. Let n be such that M² £ 2ⁿ < 2M². We begin with n qubits, each in state |0ñ. We now apply the Walsh transformation W to superpose all states:

     2n-1 å a = 0  |0ñ\oversetW\longmapsto 1   __ Ö2n   2n-1 å a = 0  |añ.

  3. Apply a transformation which implements raising to powers mod M:

     1   __ Ö2n   2n-1 å a = 0  |añ ® 1   __ Ö2n   2n-1 å a = 0  |a, f(a)ñ

     where f(a) = y^a mod M.

  4. Measure to find a state whose amplitude has the same period as f.

  5. Apply a quantum Fourier transform to invert the frequency.

  6. Extract the period, which we expect to be the order of y mod M.

  7. Find a factor of M.

     When our estimate for the period, q, is even, we use the Euclidean algorithm to efficiently check whether either y^q/2+1 or y^q/2-1 has a non-trivial common factor with M.

  8. Repeat the algorithm, if necessary.

• To factor a number M, we choose a number y < M with gcd(y,M) = 1. We then find r, the order of y in the multiplicative group mod M. If r is even, then (y^r/2+1)(y^r/2-1) = (y^r-1) º 0 mod M. Then gcd(y^r-1,M) is a non-trivial factor of M except when r is odd or y^r/2 º -1 mod M. This procedure produces a non-trivial factor of M with probability at least 1 - 1/2^k-1, where k is the number of distinct odd prime factors of M. If we don't get a factor, we can choose a new y and repeat the process. By repeating the process, we can make our likelihood of success as close to one as we like. Note that if M is even, finding a factor is easy; if M is a power of a prime, there are other fast classical methods of factoring which we can use on M before we start this process.

• We want to find the period of the function f(a) = y^a mod M. We do that by measuring to find a state whose amplitude has the same period as f.

  We measure the qubits of the state obtained from encoding f(a). A random value u is obtained. We don't actually use the value u; only the effect the measurement has on our set of superpositions is of interest. This measurement projects the state space onto the subspace compatible with the measured value, so the state after measurement is

  C å a  g(a)|a,uñ,

  for some scale factor C where

  g(a) = ì í î 1 if f(a) = u 0 otherwise

  Note that the a's that actually appear in the sum, those with g(a) ¹ 0, differ from each other by multiples of the period, and thus g(a) is the function we are looking for. If we could just measure two successive a's in the sum, we would have the period. Unfortunately the quantum world permits only one measurement.

• Shor's method uses a quantum version of the Fourier transform to find the period of the function y^a mod M. We apply the quantum Fourier transform to the state obtained by the measurement.

  å a  g(a)|añ\oversetQFT\longmapsto å c  G(c)|cñ

  Standard Fourier analysis tells us that when the period r of g(a) is a power of two, the result of the quantum Fourier transform is

  C¢ å j  rj|j 2n r ñ

  where |r_j| = 1. When the period r does not divide 2ⁿ, the transform approximates the exact case so most of the amplitude is attached to integers close to multiples of [(2ⁿ)/ r].

• In order for Shor's factoring algorithm to be a polynomial algorithm, the quantum Fourier transform must be efficiently computable. Shor developed a quantum Fourier transform construction with base 2ⁿ using only [(n(n+1))/ 2] gates. The construction makes use of two types of gates. One is a gate to perform the Hadamard transformation H. We will denote by H_j the Hadamard transformation applied to the jth bit. The other type of gate performs transformations of the form

  Sj,k = æ ç ç ç ç è 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 eiqk-j ö ÷ ÷ ÷ ÷ ø

  where q_k-j = p/2^k-j, which acts on the kth element, depending on the value of the jth element. Think of this as acting on the basis {|00ñ,|01ñ,|10ñ,|11ñ} ...

  The quantum Fourier transform is given by

  H0S0,1... S0,n-1H1...

  Hn-3Sn-3,n-2Sn-3,n-1Hn-2Sn-2,n-1Hn-1.

  This actually produces the reverse of the Fourier transform, so it typically will be followed by a bit reversal transformation.
• There is a second piece of Shor's algorithm which must be accomplished in polynomial time. We need to extract (using the QFT) the period of the function a ® (y^a) mod M. We must transform as:

  1   __ Ö2n   2n-1 å a = 0  |añ ® 1   __ Ö2n   2n-1 å a = 0  |a,ya(mod M)ñ

  We want to develop a transformation which computes the function f_y,M(a) = y^a mod M. First, we write y^a as y^a = y^20a₀·y^{21 a₁} ·¼y^{2m-1 a_m-1}, where m is the number of digits in the binary expansion of M. Then, modular exponentiation can be computed by initializing the result register to |1ñ, and successively effecting m multiplications by y²ⁱ mod M, depending on the value of the qubit |a_iñ. If a_i = 1, we want the operation

  |y20a0+¼2i-1ai-1,0ñ ®

  |y20a0+¼2i-1ai-1,y20a0+¼ 2i-1ai-1·y2iñ

  to be performed; otherwise, when a_i = 0 we just require

  |y20a0+¼2i-1ai-1,0ñ ®

  |y20a0+¼2i-1ai-1,y20a0+¼ 2i-1ai-1ñ.

  Note that in both cases the result can be written as |y^{20a₀+¼2i-1a_i-1},y^{20a₀+¼2ia_i}ñ.

• To extract the period, we measure the state in the standard basis for quantum computation, and call the result v. In the case where the period happens to be a power of 2 so that the quantum Fourier transform gives exactly multiples of the scaled frequency, the period is easy to extract. In this case, v = j[(2ⁿ)/ r] for some j. Most of the time j and r will be relatively prime, in which case reducing the fraction [v/( 2ⁿ)] to its lowest terms will yield a fraction whose denominator q is the period r. The fact that in general the quantum Fourier transform only gives approximately multiples of the scaled frequency complicates the extraction of the period from the measurement. When the period is not a power of 2, a good guess for the period can be obtained using the continued fraction expansion of [v/( 2ⁿ)].
• Various things could have gone wrong so that this process does not yield a factor of M:

  1. The value v was not close enough to a multiple of [(2ⁿ)/ r].
  2. The period r and the multiplier j could have had a common factor so that the denominator q was actually a factor of the period, rather than the period itself.
  3. We find M as M's factor.
  4. The period of f(a) = y^a mod M is odd.

  A few repetitions of this algorithm yields a factor of M with high probability.

• Various approaches have been developed which provide hope that the NP-complete boolean satisfiability problem can be solved in polynomial time. It is not clear that any of the published techniques will be effective. Some of the methods seem to require either exponential space/hardware (e.g., bulk spin resonance via NMR) or exponential measurement precision. This is a very active area of current research.

  One algorithm which has been well analyzed is Grover's search algorithm. It gives quadratic speedup of solving satisfiability, but in its general form can do no better than that, and hence does not give the exponential speedup needed to get P = NP.

• Following is an outline of Grover's general search algorithm. If P(x) is a boolean function for 0 £ x < N, classical search algorithms take on the order of ^N/₂ operations to find an item x₀ for which P(x₀) = 1. Grover's algorithm takes on the order of ÖN operations. Grover's algorithm has been shown to be optimal for the general search problem. This is not an exponential speedup, but it is an improvement over the classical algorithms. However, problems such as satisfiability have additional structure which can make them easier to solve.

• Grover's algorithm consists of the following steps:

  1. Let n be such that 2ⁿ ³ N, and prepare a register containing a superposition of all x_i Î [0... 2ⁿ-1].
  2. Apply a unitary transformation that computes P(x_i) on this register:

     UP: 1   __ Ö2n   n-1 å x = 0  |x, 0ñ ® 1   __ Ö2n   n-1 å x = 0  |x, P(x)ñ.

     For any x₀ such that P(x₀) is true, |x₀, 1ñ will be part of the resulting superposition, but since its amplitude is [1/( Ö[(2ⁿ)])], the probability that a measurement produces x₀ is only 2^-n.
  3. Change amplitude a_j to -a_j for all x_j such that P(x_j) = 1.
  4. Apply inversion about the average to increase amplitude of x_j with P(x_j) = 1 and decrease other amplitudes.
  5. Repeat steps 2 through 4 [(p)/ 4]Ö[(2ⁿ)] times.
  6. Measure the last qubit of the quantum state, representing P(x). Because of the amplitude change, there is a high probability that the result will be 1. If this is the case, the measurement has projected the state onto the subspace [1/( Ö[(2^k)])]å_{i = 1}^k|x_i, 1ñ where k is the number of solutions. Further measurement of the remaining bits will provide one of these solutions.

• An interesting feature of this algorithm is that repeating steps 2 through 4 [(p)/ 4]Ö[(2ⁿ)] times is optimal. In particular, if the process is repeated more times, the probability of a successful measurement decreases back toward zero ...
• An alternative approach builds the unitary transformation for the boolean expression, applies the transformation to molecules in solution, then uses bulk spin resonance analysis via NMR to measure the expected values of the spins, and thus solves the satisfiability problem. However, realistic implementations seem to require an exponentially large NMR sample.
• The general estimate is that if n is the number of qubits, and M is the number of molecules in the sample, then n2ⁿ < M. For a typical sample, M » 10²³ » 2⁷⁶ and so n < 70. For an upper limit, a reasonable estimate of the number of elementary particles in the accessible universe is » 10⁸⁰ » 2²⁶⁵ which corresponds with » 256 qubits ...

• Implementations of quantum computers will be a difficult experimental challenge. Quantum computer equipment must satisfy a variety of constraints: (1) the qubits must interact very weakly with their environment to minimize decoherence and preserve their superpositions, (2) the qubits must interact very strongly with one another for the logic gates and information transfer to be effective, and (3) the initialization and readout of states must be efficient. Not many known physical systems can satisfy these requirements, although there are some possibilities.
• A collection of charged ions held in an electromagnetic trap is one possibility. Each atom stores a qubit of information in a pair of internal electron levels. Each atom's levels are protected from environmental influences. Scaling to larger numbers of qubits should be able to be done by adding more atoms to the collection. When appropriate laser radiation is applied to the atoms, only one of the two internal states fluoresces. This allows detection of the state of each qubit. The atoms are coupled by virtue of their mutual Coulomb repulsion. Experimental development of trapped ion quantum computation is at the level of single-ion and two-ion qubit systems. Extensions to larger numbers of trapped ions has been difficult, but there do not seem to be impossible theoretical limits to scaling.
• Another system which could be developed into a quantum computer is a single molecule, in which nuclear spins of individual atoms represent qubits. This is the basis of the NMR technique mentioned above. The spins can be manipulated, initialized, and measured. For example, the carbon and hydrogen nuclei in a chloroform molecule can be used to represent two qubits. Applying a radio-frequency pulse to the hydrogen nucleus addresses that qubit and causes it to rotate from a |0ñ state to a superposition [1/( Ö2)](|0ñ + |1ñ) state. Interactions through chemical bonds allow multiple-qubit logic to be performed. However, it is difficult to find molecules with more than 10 spins in them and with a large coupling constant between every pair of spins ...

• Decoherence in general arises from interactions with the environment, which typically has the effect of measuring the system and thus collapsing a quantum computation. In addition, we have to be careful about leaving temporary qubits floating around. We can expect them to be entangled with the rest of the system, and thus an observation of the ``dust'' left behind by intermediate computations could effect a measurement of the system, invalidating later stages. Thus, one emphasis in research on quantum computation has been on how to efficiently avoid leaving any garbage floating about.
• As noted above, error detection/correction is difficult in the quantum environment since we cannot reliably clone an arbitrary qubit. Further, any intermediate measurement of the system for error control is likely to invalidate our computation. There are, however, approaches using polarization encoding schemes for error control.

• The history of quantum mechanical algorithms is very brief. There are two main approaches that have resulted in descriptions of efficient quantum computational algorithms: the first is estimates of periodicity that resulted in the factorization algorithm, and the second is amplitude amplification that has led to Grover's quantum search and related algorithms.
• Over the past 70 or 80 years, physicists have observed various quantum mechanical phenomena that lead to puzzling and even apparently paradoxical results. Most of these still remain to be investigated from a quantum computing perspective.
• One interesting question is how slight difference in the laws of quantum mechanics might affect these issues. Some interesting work by Abrams et al. shows that if there was even the slightest amount of nonlinearity in quantum mechanics, it would be possible to modify the amplitude amplification scheme of Grover's quantum search algorithm to obtain an efficient algorithm solving the NP-complete satisfiability problem. However, most people believe that such nonlinearity probably does not exist because it would also lead to faster-than-light communication, noncausality, and other violations of fundamental physical principles ...

``Nature uses only the longest threads to weave her patterns, so that each small piece of her fabric reveals the organization of the entire tapestry.'' - Richard Feynman

References