Shor's algorithm
From Academic Kids

Shor's algorithm is a quantum algorithm for factoring a number N in O((log N)^{3}) time and O(log N) space, named after Peter Shor.
The algorithm is significant because it implies that public key cryptography might be easily broken, given a sufficiently large quantum computer. RSA, for example, uses a public key N which is the product of two large prime numbers. One way to crack RSA encryption is by factoring N, but with classical algorithms, factoring becomes increasingly timeconsuming as N grows large; more specifically, no classical algorithm is known that can factor in time O((log N)^{k}) for any k. By contrast, Shor's algorithm can crack RSA in polynomial time. It has also been extended to attack many other public key cryptosystems.
Like all quantum computer algorithms, Shor's algorithm is probabilistic: it gives the correct answer with high probability, and the probability of failure can be decreased by repeating the algorithm.
Shor's algorithm was demonstrated in 2001 by a group at IBM, which factored 15 into 3 and 5, using a quantum computer with 7 qubits.
Contents 
Procedure
The problem we are trying to solve is that, given an integer N, we try to find another integer p between 1 and N that divides N.
Shor's algorithm consists of two parts:
 A reduction of the factoring problem to the problem of orderfinding, which can be done on a classical computer.
 A quantum algorithm to solve the orderfinding problem.
Classical part
 Pick a pseudorandom number a < N
 Compute gcd(a, N). This may be done using the Euclidean algorithm.
 If gcd(a, N) ≠ 1, then it is a nontrivial factor of N, so we are done.
 Otherwise, use the periodfinding subroutine (below) to find r, the period of the following function:
 <math>f(x) = a^x\ \mbox{mod}\ N<math>,
 If r is odd, go back to step 1.
 If a ^{r/2} ≡ 1 (mod N), go back to step 1.
 The factors of N are gcd(a^{r/2} ± 1, N). We are done.
Quantum part: Periodfinding subroutine:
 Start with a pair of input and output qubit registers with log_{2}N qubits each, and initialize them to
 <math>N^{1/2} \sum_x \leftx\right\rangle \left0\right\rangle<math>
 Construct f(x) as a quantum function and apply it to the above state, to obtain
 <math>N^{1/2} \sum_x \leftx\right\rangle \leftf(x)\right\rangle<math>
 Apply the quantum Fourier transform on the input register. The
quantum Fourier transform on N points is defined by:
 <math>U_{QFT} \leftx\right\rangle
 <math> N^{1} \sum_x \sum_y e^{2\pi i x y/N} \lefty\right\rangle \leftf(x)\right\rangle<math>
 Perform a measurement.
We obtain some outcome y in the input register and <math>f(x_0)<math> in the output register.
Since f is periodic, the probability to measure some y is given by
 <math> N^{1} \left \sum_{x:\, f(x)=f(x_0)} e^{2\pi i x y/N} \right^2
 Turn y/N into an irreducible fraction, and extract the denominator r′, which is a candidate for r.
 Check if f(x) = f(x + r′). If so, we are done.
 Otherwise, obtain more candidates for r by using values near y, or multiples of r′. If any candidate works, we are done.
 Otherwise, go back to step 1 of the subroutine.
Explanation of the algorithm
The algorithm is composed of two parts. The first part of the algorithm turns the factoring problem into the problem of finding the period of a function, and may be implemented classically. The second part finds the period using the quantum Fourier transform, and is responsible for the quantum speedup.
I. Obtaining factors from period
The integers less than N and coprime with N form a finite group under multiplication modulo N, which is typically denoted (Z/NZ)^{×}. By the end of step 3, we have an integer a in this group. Since the group is finite, a must have a finite order r, the smallest positive integer such that
 <math>a^r \equiv 1\ \mbox{mod}\ N.\,<math>
Therefore, N  (a ^{r} − 1). Suppose we are able to obtain r, and it is even. Then
 <math>a^r  1 = (a^{r/2}  1) (a^{r/2} + 1) \equiv 0\ \mbox{mod}\ N<math>
 <math>\Rightarrow N\  (a^{r/2}  1) (a^{r/2} + 1).\,<math>
r is the smallest positive integer such that a ^{r} ≡ 1, so N cannot divide (a ^{r / 2} − 1). If N also does not divide (a ^{r / 2} + 1), then N must have a nontrivial common factor with each of (a ^{r / 2} − 1) and (a ^{r / 2} + 1).
Proof: For simplicity, denote (a ^{r / 2} − 1) and (a ^{r / 2} + 1) by u and v respectively. N  uv, so kN = uv for some integer k. Suppose gcd(u, N) = 1; then mu + nN = 1 for some integers m and n (this is a property of the greatest common divisor.) Multiplying both sides by v, we find that mkN + nvN = v, so N  v. By contradiction, gcd(u, N) ≠ 1. By a similar argument, gcd(v, N) ≠ 1.
This supplies us with a factorization of N. If N is the product of two primes, this is the only possible factorization.
II. Finding the period
Shor's periodfinding algorithm relies heavily on the ability of a quantum computer to be in many states simultaneously. Physicists call this behaviour a "superposition" of states. To compute the period of a function f, we evaluate the function at all points simultaneously.
Quantum physics does not allow us to access all this information directly, though. A measurement will yield only one of all possible values, destroying all others. Therefore we have to carefully transform the superposition to another state that will return the correct answer with high probablity. This is achieved by the quantum Fourier transform.
Shor thus had to solve three "implementation" problems. All of them had to be implemented "fast", which means that they can be implemented with a number of quantum gates that is polynomial in <math>\log N<math>.
 Create a superposition of states. This can be done by applying Hadamard gates to all qubits in the input register. Another approach would be to use the quantum Fourier transform (see below).
 Implement the function f as a quantum transform. To achieve this, Shor used repeated squaring for his modular exponentiation transformation.
 Perform a quantum Fourier transform. By using controlled NOT gates and single qubit rotation gates Shor designed a circuit for the quantum Fourier transform that uses just <math>O((\log N)^2)<math> gates.
 <math>e^{2 \pi i b yr/N} = 1<math>
References
Preprint of the original paper by Peter Shor:
 PolynomialTime Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer, Peter W. Shor (http://www.arxiv.org/abs/quantph/9508027)
A general textbook on quantum computing:
 Quantum Computation and Quantum Information, Michael A. Nielsen, Isaac L. Chuang, Cambridge University Press, 2000