Quantum-project-spring-22.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ce6bfdbf",
   "metadata": {},
   "source": [
    "** Using Shor's algorithm, a number N can be factored  in polynomial time. In this example, we will factor 15 using a quantum algorithm. Qiskit will be used to implement the code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f15c40f0",
   "metadata": {},
   "source": [
    "importing necessary libraries from Qiskit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8d17ea29",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from qiskit import QuantumCircuit, Aer, execute\n",
    "from math import gcd\n",
    "import pandas as pd\n",
    "from qiskit.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5ac7764",
   "metadata": {},
   "source": [
    "## Initializing the Qubits\n",
    "\n",
    "We will start by initializing a set of $n$ qubits with $2^n$ number of computational basis states in superposition. To create a superposition, a hadamard gate is then applied on n qubits so that they go from the |0> to |0>$^(n\\bigotimes)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1aed21b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_qubits(given_circuit, n, m): \n",
    "\n",
    "    given_circuit.h(range(n))\n",
    "    given_circuit.x(n+m-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9169c06a",
   "metadata": {},
   "source": [
    "## Modular Exponentiation\n",
    "\n",
    "We will use the fact that any prime number can be rewritten as $N=pq$ where $p$ and $q$ are primes to reframe the problem so that we can solve the equation $f(x)=a^x\\mod{n}$ for it's period, $r$. The smallest variable to solve $1=a^r\\mod{n}$ and $f(x)=f(y), |x-y|=k \\cdot r$ will also be $r$ when $k$ is an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2caa0950",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "def c_amod15(a, x):\n",
    "    if a not in [2,7,8,11,13]:\n",
    "        raise ValueError(\"'a' must be 2,7,8,11,13\")\n",
    "    U = QuantumCircuit(4)        \n",
    "    for iteration in range(x):\n",
    "        if a in [2,13]:\n",
    "            U.swap(0,1)\n",
    "            U.swap(1,2)\n",
    "            U.swap(2,3)\n",
    "        if a in [7,8]:\n",
    "            U.swap(2,3)\n",
    "            U.swap(1,2)\n",
    "            U.swap(0,1)\n",
    "        if a == 11:\n",
    "            U.swap(1,3)\n",
    "            U.swap(0,2)\n",
    "        if a in [7,11,13]:\n",
    "            for q in range(4):\n",
    "                U.x(q)\n",
    "    U = U.to_gate()\n",
    "    U.name = \"%i^%i mod 15\" % (a, x)\n",
    "    c_U = U.control()\n",
    "    return c_U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "396e29df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def modular_exponentiation(circuit, n, m, a):\n",
    "    \n",
    "\n",
    "    for x in range(n):\n",
    "        exponent = 2**x\n",
    "        circuit.append(c_amod15(a, exponent), \n",
    "                     [x] + list(range(n, n+m)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "142d33f3",
   "metadata": {},
   "source": [
    "## Applying the Inverse Quantum Fourier Transform\n",
    "\n",
    "Here we will create a function which takes a circuit and a set of measurement qubits onto which the Inverse Quantum Fourier will be applied as well as .inverse() so as to yield the inverse QFT function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cc1cceda",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.circuit.library import QFT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "652f9ac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def inverse_qft(circuit, measurement_qubits):\n",
    "    \n",
    "\n",
    "    circuit.append(QFT( len(measurement_qubits), do_swaps=False).inverse(), measurement_qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1265308d",
   "metadata": {},
   "source": [
    "## Implementing the Circuit\n",
    "\n",
    "Here we create a visual representation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "21dd7681",
   "metadata": {},
   "outputs": [],
   "source": [
    "def shors_algorithm(n, m, a):\n",
    "    \n",
    "   \n",
    "    qc = QuantumCircuit(n+m, n)\n",
    "    \n",
    "  \n",
    "    initialize_qubits(qc, n, m)\n",
    "    qc.barrier()\n",
    "\n",
    "   \n",
    "    modular_exponentiation(qc, n, m, a)\n",
    "    qc.barrier()\n",
    "\n",
    " \n",
    "    inverse_qft(qc, range(n))\n",
    "\n",
    "    \n",
    "    qc.measure(range(n), range(n))\n",
    "    \n",
    "    return qc\n",
    "    \n",
    "n = 4; m = 4; a = 7\n",
    "final_circuit = shors_algorithm(n, m, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8152d9e4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1290.6x565.88 with 1 Axes>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_circuit.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c216b2",
   "metadata": {},
   "source": [
    "## Running on a Quantum Simulator\n",
    "\n",
    "Here we can check the values during the circuit execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c8ae02ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "counts = execute(final_circuit, backend=simulator, shots=1000).result().get_counts(final_circuit)\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "40987a14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n",
      " {int(measured_value[::-1], 2)}\n"
     ]
    }
   ],
   "source": [
    "for measured_value in counts:\n",
    "    print(\" {int(measured_value[::-1], 2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79710084",
   "metadata": {},
   "source": [
    "## Classical Computer Simulation\n",
    "\n",
    "Here we compare a classical version with the quantum one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "914c9ee9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measured value not even\n",
      "Measured value not even\n",
      "(1, 3)\n",
      "Measured value not even\n",
      "Measured value not even\n",
      "Measured value not even\n",
      "(5, 3)\n",
      "(1, 15)\n",
      "(1, 3)\n",
      "(1, 15)\n",
      "(5, 3)\n",
      "(1, 3)\n",
      "Measured value not even\n"
     ]
    }
   ],
   "source": [
    "for i in counts:\n",
    "    measured_value = int(i[::-1], 2)\n",
    "  \n",
    "    \n",
    "    if measured_value % 2 != 0:\n",
    "        print(\"Measured value not even\")\n",
    "        continue #measured value should be even as we are doing a^(r/2) mod N and r/2 should be int\n",
    "    x = int((a ** (float(measured_value)/2)) % 15)\n",
    "    if (x + 1) % 15 == 0:\n",
    "        continue\n",
    "    factors = gcd(x + 1, 15), gcd(x - 1, 15) #we saw earlier that a^(r/2)+1 or a^(r/2)-1 should be a factor of 15\n",
    "    print(factors)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}