Shor's Factorization Algorithm

Shor's Algorithm is a quantum algorithm for integer factorization. It was discovered by Peter Shor in 1994 and is one of the most well-known quantum algorithms.

How it works

The algorithm is based on the fact that if we can factorize a large number into its prime factors, then we can easily solve many difficult problems in cryptography.

The algorithm works in two main steps:

1. Quantum Fourier Transform
2. Period finding

Quantum Fourier Transform

The first step involves applying a Quantum Fourier Transform (QFT) to a quantum register. The QFT is a quantum analog of the classical Fourier transform and is used to convert a quantum state into its Fourier representation.

Period Finding

The second step involves using the QFT to find the period of a function. The function in this case is the modular exponential function which is defined as:

$$f(x) = a^x \mod N$$

where a is a random integer and N is the number to be factorized. The period of this function can be used to find the factors of N using classical algorithms.

The period-finding step consists of the following steps:

1. Prepare two quantum registers. One containing the input x and the other containing the output of the modular exponential function.
2. Apply the QFT to the input register.
3. Apply the modular exponential function to the output register.
4. Measure the output register to obtain a random integer, r.
5. Use classical algorithms to find the period of the function.

Code Example

Here's a Python implementation of Shor's algorithm:

from math import gcd
from random import randint
from numpy.fft import fft
from cmath import exp, pi

def shor(N):
    # Step 1: Choose a random number a < N
    a = randint(2, N-1)
    
    # Step 2: Calculate the GCD of a and N
    d = gcd(a, N)
    if d > 1:
        return d
    
    # Step 3: Transform the quantum state using QFT
    # Note: The QFT and its inverse can be implemented
    # using numpy.fft. However, they assume that the
    # input is an array of complex numbers so we need
    # to convert the input to this format.
    x = [0] * N
    for i in range(N):
        x[i] = 1 if pow(a, i, N) < (N/2) else -1
    y = fft(x)
    
    # Step 4: Measure the output register
    r = y.argmax()
    
    # Step 5: Calculate the period of the function
    if r % 2 != 0:
        r *= 2
    guess = pow(a, int(r/2), N)
    if guess == N-1:
        return None
    p = gcd(guess+1, N)
    if p == 1 or p == N:
        return None
    return p

Conclusion

Shor's algorithm is an important algorithm in quantum computing because it demonstrates the power of quantum computers to solve problems that are intractable on classical computers. Its use in factoring large numbers makes it useful in breaking many cryptographic systems.