qft-adder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing an QFT Adder on a quantum computer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an example of QFT-based Adder. \n",
    "\n",
    "For two quantum states holding an integer $a$ and $b$, the goal is to develop an add algorithm that does\n",
    "\n",
    "$Add\\left|a\\right>\\left|b\\right>=\\left|a\\right>\\left|a+b\\right>$\n",
    "\n",
    "Recall that the quantum Fourier transform is defined as\n",
    "$QFT\\left|a\\right>=\\frac{1}{2^n}\\sum_{j=0}^{2^n-1}{e^{2\\pi ija/2^n}\\left|j\\right>}$\n",
    "\n",
    "Define\n",
    "$\\left|\\phi_k(a)\\right>=\\frac{1}{\\sqrt 2}\\left(\\left|0\\right>+e^{2\\pi ia/2^k}\\left|1\\right>\\right)$\n",
    "\n",
    "QFT could be written as\n",
    "$QFT\\left|a\\right>=\\left|\\phi_1(a)\\right>\\otimes\\left|\\phi_2(a)\\right>\\otimes...\\otimes\\left|\\phi_n(a)\\right>$\n",
    "\n",
    "$a+b$ could be obtained by \n",
    "$\\left|a+b\\right>=QFT^{-1}\\left|\\phi_1(a+b)\\right>\\otimes...\\otimes\\left|\\phi_n(a+b)\\right>$\n",
    "\n",
    "Now the question is, how do we obtain $\\left|\\phi_k(a+b)\\right>$ given $\\left|\\phi_k(b)\\right>$? \n",
    "\n",
    "$\\left|\\phi_k(a+b)\\right>=\\frac{1}{\\sqrt 2}\\left(\\left|0\\right>+e^{2\\pi i(a+b)/2^k}\\left|1\\right>\\right)$\n",
    "\n",
    "Suppose $a = a_1\\cdot 2^{m-1}+a_2\\cdot 2^{m-2}+...+a_{m}\\cdot 2^0$, \n",
    "and $b = b_1\\cdot 2^{n-1}+b_2\\cdot 2^{n-2}+...+b_{n}\\cdot 2^0$\n",
    "\n",
    "Then $\\left|\\phi_k(a+b)\\right>=\\frac{1}{\\sqrt 2}\\left(\\left|0\\right>+e^{2\\pi ia/2^k}e^{2\\pi ib/2^k}\\left|1\\right>\\right)$\n",
    "\n",
    "Let's now compute $\\mathrm{exp}(2\\pi ia/2^k)=\\mathrm{exp}\\left(2\\pi i\\left(a_1\\cdot 2^{m-1-k}+a_2\\cdot 2^{m-2-k}+...+a_m\\cdot 2^{-k}\\right)\\right)=\\mathrm{exp}\\left(2\\pi i\\left(a_{m-k+1}/2+a_{m-k+2}/2^2+...+a_m/2^{k}\\right)\\right)=\\mathrm{exp}\\left(2\\pi i0.a_{m-k+1}a_{m-k+2}...a_m\\right)$\n",
    "\n",
    "This phase could be encoded by series of controlled-phase rotation targeted at the $k$th qubit in $b$ and controlled by the $(m-k+1)$th, $(m-k+2)$th, ..., $m$th qubit in $a$. \n",
    "\n",
    "Overall, the QFT Adder works as the following:\n",
    "\n",
    "1. Initialize two registers to $a$ and $b$. \n",
    "2. Perform QFT on $b$. \n",
    "3. Perform controlled phase rotations on $b$ controlled by $a$. \n",
    "4. Perform inverse QFT on $b$. \n",
    "5. Measure $a$ and $b$. Now $b$ should become $a+b$, and $a$ should stay the same. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "First, make sure that you have the latest version of Qiskit installed. To upgrade your Qiskit package, run the following command:\n",
    "\n",
    "```bash\n",
    "pip install --upgrade qiskit\n",
    "```\n",
    "\n",
    "Get an API key from IonQ. This will be used by the IonQ provider inside Qiskit to submit circuits to the IonQ platform.\n",
    "\n",
    "After securing an API key, install the python package `qiskit_ionq` using `pip`:\n",
    "\n",
    "```bash\n",
    "pip install qiskit_ionq\n",
    "```\n",
    "\n",
    "(IonQ's adapter for Qiskit is currently in private beta -- your feedback is welcomed!)\n",
    "\n",
    "### (Optional) Extra Dependencies\n",
    "\n",
    "Some examples use additional Python dependencies; please make sure to `pip install` them as needed.\n",
    "\n",
    "Dependencies:\n",
    "* `matplotlib`: To run `qiskit.visualization.plot_histogram`.\n",
    "\n",
    "**NOTE**: The provider expects an API key to be supplied via the `token` keyword argument to its constructor. If no token is directly provided, the provider will check for one in the `QISKIT_IONQ_API_TOKEN` environment variable.\n",
    "\n",
    "Now that the Python package has been installed, you can import and instantiate the provider:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import qiskit\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit import Aer, execute\n",
    "from qiskit.circuit.library import QFT\n",
    "\n",
    "from qiskit_ionq import IonQProvider \n",
    "\n",
    "#Call provider and set token value\n",
    "provider = IonQProvider(token='my token')\n",
    "\n",
    "# numpy\n",
    "import numpy as np\n",
    "\n",
    "# plotting\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `provider` instance can now be used to create and submit circuits to IonQ.\n",
    "\n",
    "### Backend Types\n",
    "\n",
    "The IonQ provider supports two backend types:\n",
    "* `ionq_simulator`: IonQ's simulator backend.\n",
    "* `ionq_qpu`: IonQ's QPU backend.\n",
    "\n",
    "To view all current backend types, use the `.backends` property on the provider instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IonQSimulatorBackend('ionq_simulator')>, <IonQQPUBackend('ionq_qpu')>]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provider.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's implement QFT and its inverse\n",
    "\n",
    "Let us create two circuits that implement the quantum Fourier transform and its inverse for a given number of qubits (n). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quantum Fourier transform of |q>, of length n.\n",
    "def qft(circ, q, n):\n",
    "    # Loop through the target qubits.\n",
    "    for i in range(n,0,-1):\n",
    "        # Apply the H gate to the target.\n",
    "        circ.h(q[i-1])\n",
    "\n",
    "        # Loop through the control qubits.\n",
    "        for j in range(i-1,0,-1):\n",
    "            circ.cp(2*np.pi/2**(i-j+1), q[j-1], q[i-1])\n",
    "\n",
    "# Inverse Fourier transform of |q>, of length n.\n",
    "def iqft(circ, q, n):\n",
    "    # Loop through the target qubits.\n",
    "    for i in range(1,n+1):\n",
    "        # Loop through the control qubits.\n",
    "        for j in range(1,i):\n",
    "            # The inverse Fourier transform just uses a negative phase.\n",
    "            circ.cp(-2*np.pi/2**(i-j+1), q[j-1], q[i-1])\n",
    "\n",
    "        # Apply the H gate to the target.\n",
    "        circ.h(q[i-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's implement QFT Adder\n",
    "\n",
    "Let us create the circuit that implement the QFT Adder. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the Add function\n",
    "def Add(circ, a, b, n):\n",
    "    \n",
    "    # add 1 to n to account for overflow\n",
    "    n += 1\n",
    "    \n",
    "    # take the QFT\n",
    "    qft(circ, b, n)\n",
    "    \n",
    "    circ.barrier()\n",
    "    \n",
    "    # Compute the controlled phases \n",
    "    # Iterate over targets \n",
    "    for i in range(n, 0, -1):\n",
    "        # Iterate over controls\n",
    "        for j in range(i, 0, -1):\n",
    "            # If the qubit a[j-1] exists run cp, if not assume the qubit is 0 and never existed\n",
    "            if len(a) - 1 >= j - 1:\n",
    "                circ.cp(2*np.pi/2**(i-j+1), a[j-1], b[i-1])\n",
    "    \n",
    "    circ.barrier()\n",
    "    \n",
    "    # take the inverse QFT\n",
    "    iqft(circ, b, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's now add numbers\n",
    "\n",
    "Finally, we have everything we need to perform $a+b$ on a quantum computer. Let's now add $a=10 (2)$ to $b=001 (1)$, and the ideal result should be $011 (3)$  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1618.14x927.08 with 1 Axes>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Registers and circuit.\n",
    "a = QuantumRegister(2)\n",
    "b = QuantumRegister(3)\n",
    "ca = ClassicalRegister(2)\n",
    "cb = ClassicalRegister(3)\n",
    "qc = QuantumCircuit(a, b, ca, cb)\n",
    "\n",
    "# Numbers to add.\n",
    "qc.x(a[1]) # a = 01110 / a = 10\n",
    "#qc.x(a[2])\n",
    "#qc.x(a[3])\n",
    "qc.x(b[0]) # b = 01011 / b = 001\n",
    "#qc.x(b[1])\n",
    "#qc.x(b[3])\n",
    "\n",
    "qc.barrier()\n",
    "\n",
    "# Add the numbers, so |a>|b> to |a>|a+b>.\n",
    "Add(qc, a, b, 2)\n",
    "\n",
    "qc.barrier()\n",
    "\n",
    "# Measure the results.\n",
    "qc.measure(a, ca)\n",
    "qc.measure(b, cb)\n",
    "\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's look at the ideal outcomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'011 10': 1024}\n"
     ]
    }
   ],
   "source": [
    "# simulate the circuit\n",
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "job_sim   = execute(qc, simulator)\n",
    "result_sim = job_sim.result()\n",
    "\n",
    "print(result_sim.get_counts(qc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! We obtain the correct result!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running jobs on a quantum computer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to submit the jobs on IonQ's QPUs. Since actual quantum computers are noisy, the quality of the output state probabilities decreases with the number of gates favoring fully connected architectures over the ones with limited connectivity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n",
      "Job status is JobStatus.QUEUED\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'bv_job' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-7fbc5cde8d02>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# grab a coffee! This can take up to a few minutes.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;31m# once we break out of that while loop, we know our job is finished\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Job status is\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbv_job\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# these counts are the “true” counts from the actual QPU Run\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'bv_job' is not defined"
     ]
    }
   ],
   "source": [
    "# run the circuit on a real-device\n",
    "qpu = provider.get_backend(\"ionq_qpu\")\n",
    "qpu_job = qpu.run(qc)\n",
    "\n",
    "\n",
    "from qiskit.providers.jobstatus import JobStatus\n",
    "import time\n",
    "# Check if job is done\n",
    "while qpu_job.status() is not JobStatus.DONE:\n",
    "    print(\"Job status is\", qpu_job.status() )\n",
    "    time.sleep(60)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job status is JobStatus.DONE\n",
      "{'000 00': 5, '000 01': 2, '000 10': 7, '000 11': 3, '001 00': 20, '001 01': 1, '001 10': 46, '001 11': 4, '010 00': 1, '010 01': 2, '010 10': 56, '010 11': 17, '011 00': 24, '011 10': 600, '011 11': 5, '100 00': 4, '100 10': 13, '100 11': 10, '101 00': 15, '101 01': 1, '101 10': 61, '110 00': 1, '110 01': 1, '110 10': 10, '110 11': 4, '111 00': 2, '111 10': 104, '111 11': 5}\n"
     ]
    }
   ],
   "source": [
    "# grab a coffee! This can take up to a few minutes.\n",
    "# once we break out of that while loop, we know our job is finished\n",
    "print(\"Job status is\", qpu_job.status() )\n",
    "print(qpu_job.get_counts()) # these counts are the “true” counts from the actual QPU Run\n",
    "\n",
    "result_exp = qpu_job.result()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a bit messy. Let's plot the histogram. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.visualization import plot_histogram\n",
    "\n",
    "plot_histogram(qpu_job.get_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! The expected result is of the largest probability!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}