weekend_exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-ap-southeast-1.amazonaws.com/he-public-data/wordmark_black65ee464.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Weekend Exercise (Ungraded)\n",
    "\n",
    "During all the questions so far you've been asked to use simulators with no (or negligible) noise to do the computational tasks necessary. However, Quantum Computers today are far from ideal and noiseless. As coined by John Preskill we are in the [Noisy Intermediate Scale Quantum (NISQ)](https://arxiv.org/abs/1801.00862) era where our quantum computers are of the intermediate scale (50-100 qubits) and are very noisy, for example, a qubit initialized in the $|0\\rangle$ state might not give $0$ on measurement in the computational basis all the time.\n",
    "\n",
    "To understand the statement above lets do an experiment on a noiseless simulator and on an actual quantum computer and compare the results. \n",
    "\n",
    "### Simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from qiskit import QuantumCircuit, execute, Aer\n",
    "from qiskit.tools.jupyter import *\n",
    "from qiskit.visualization import *\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 233.576x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(1, 1)\n",
    "qc.x(0)\n",
    "qc.measure(0,0)\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we build our circuit lets use the `qasm_simulator` from Aer to get the measurement counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = Aer.get_backend(\"qasm_simulator\")\n",
    "job = execute(qc,backend=backend, shots =1000)\n",
    "counts = job.result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you'd expect we received all 1000 counts to be corresponding to `1`. Now lets do the same experiment on a real device. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Real device\n",
    "\n",
    "To run your experiments on a real device you'll first need to create(login into) an [IBM Quantum Experience](https://www.ibm.com/quantum-computing/technology/experience/) account and follow the instructions given [here](https://qiskit.org/documentation/install.html#install-access-ibm-q-devices-label) to be able to access IBM quantum services form Qiskit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "configrc.store_credentials:WARNING:2020-09-07 21:31:10,372: Credentials already present. Set overwrite=True to overwrite.\n"
     ]
    }
   ],
   "source": [
    "# only run this cell once, running it the second time might raise an error/warning as enable_account() already has your token stored\n",
    "from qiskit import IBMQ\n",
    "\n",
    "# to enabble your account you'll need to enter your token from IBM Quantum Experience in 'YOUR_IBM_TOKEN' in a string format \n",
    "IBMQ.save_account('ed4617679492e9c0f933116b0b62d0d110aa210faf481974a8720903b8c8c69febcb7158f1d044fedcac64bd11a94153e907aff42068a427f59e238464577816')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "IBMQAccountError",
     "evalue": "'An IBM Quantum Experience account is already in use for the session.'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIBMQAccountError\u001b[0m                          Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-c0c779be1e16>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mIBMQ\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0menable_account\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'ed4617679492e9c0f933116b0b62d0d110aa210faf481974a8720903b8c8c69febcb7158f1d044fedcac64bd11a94153e907aff42068a427f59e238464577816'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\qiskit\\providers\\ibmq\\ibmqfactory.py\u001b[0m in \u001b[0;36menable_account\u001b[1;34m(self, token, url, hub, group, project, **kwargs)\u001b[0m\n\u001b[0;32m     93\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_credentials\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     94\u001b[0m             raise IBMQAccountError(\n\u001b[1;32m---> 95\u001b[1;33m                 'An IBM Quantum Experience account is already in use for the session.')\n\u001b[0m\u001b[0;32m     96\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     97\u001b[0m         \u001b[1;31m# Check the version used by these credentials.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIBMQAccountError\u001b[0m: 'An IBM Quantum Experience account is already in use for the session.'"
     ]
    }
   ],
   "source": [
    "IBMQ.enable_account('ed4617679492e9c0f933116b0b62d0d110aa210faf481974a8720903b8c8c69febcb7158f1d044fedcac64bd11a94153e907aff42068a427f59e238464577816')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ibmqfactory.load_account:WARNING:2020-09-06 21:28:11,995: Credentials are already in use. The existing account in the session will be replaced.\n"
     ]
    }
   ],
   "source": [
    "# loading your account\n",
    "IBMQ.load_account() \n",
    "\n",
    "# Getting a backend for running the circuit on. In this case 'ibm_armonk'. For more devices you have access to you \n",
    "# can look into your IBM Q Experience account's dashboard.\n",
    "provider = IBMQ.get_provider(hub='ibm-q')\n",
    "backend = provider.get_backend(\"ibmq_armonk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = execute(qc,backend=backend,shots =1000)\n",
    "counts = job.result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above histogram we see that not all the counts resulted in a `1`. This is an example of the noise that gates induce. It's important to note that different gates induce different levels of noise into the system. For example, 2-qubit gates induce a lot more noise into the system than single qubit gates, hence while creating circuits to be run on real devices we should be wary of the number of 2-qubit gates being used and try to reduce them as much as possible. This idea will be the essence of the exercise today. [Chapter 5 of the Qiskit Textbook](https://qiskit.org/textbook/ch-quantum-hardware/index-circuits.html) delves deeper into noise and some methods to tackle it if you're interested in learning more. \n",
    "\n",
    "While in today's exercise we won't be working with noisy simulators or real devices, lets take a step forward in understanding how to build circuits that give better results in the presence of noise. To do that lets dive into the exercise: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Construct a 3 digit binary adder circuit with minimum cost.\n",
    "\n",
    "You have learnt how to construct a binary half adder in [Chapter 1.2](https://qiskit.org/textbook/ch-states/atoms-computation.html) of the Qiskit Textbook. Using that knowledge we want you to create a 3 digit binary adder circuit which can do computations such as $101 + 110 = 1011$ where each input is a 3 digit binary number and the output is a four digit binary number. Your task is to find such a circuit with the least cost possible. The exercise is intentionally defined without many constraints to give you the freedom to test different data encoding schemes, basis gate sets, etc. \n",
    "\n",
    "Let us now define our cost function: \n",
    "\n",
    "**Cost of the circuit = Number of Single qubit gates + 10 $\\times$ Number of CX gates** \n",
    "\n",
    "### The cost function\n",
    "\n",
    "Any given quantum circuit can be decomposed into single-qubit and `CX` gates as they are a set of [universal quantum gates](https://en.wikipedia.org/wiki/Quantum_logic_gate#Universal_quantum_gates). With the current Noisy Intermediate-Scale Quantum (NISQ) devices noise introduced is higher when implementing a `CX` gate. Therefore, we  weigh `CX` gates 10 times more than a single-qubit gate while evaluating the cost of our circuit. To evaluate the cost of your circuit you can use the `cost_function()` method given below. \n",
    "\n",
    "The `cost_function()` takes as **input**: \n",
    "\n",
    "* `circuit`: (`QuantumCircuit`) -- The quantum circuit for which you'd like to find the cost.\n",
    "\n",
    "And gives as **output**:\n",
    "\n",
    "\n",
    "* `circuit_cost`: (`a`) -- Cost of the circuit\n",
    "\n",
    "\n",
    "* `gates`: (`Dict`) -- Dictionary with the number of gates used in the circuit\n",
    "\n",
    "\n",
    "* `unrolled_circuit`: (`QuantumCircuit`) -- The resultant circuit after change of basis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.transpiler import PassManager\n",
    "from qiskit.transpiler.passes import Unroller\n",
    "\n",
    "\n",
    "def cost_function(circuit):\n",
    "    if not isinstance(circuit, (QuantumCircuit)):\n",
    "        print(\"the inserted circuit must be a QuantumCircuit object, not {}\".format(type(circuit)))\n",
    "    else:\n",
    "        basis_gate_set = ['u3', 'cx'] # basis that we are unrolling the circuit into\n",
    "\n",
    "        # changing our basis using an Unroller\n",
    "        pass_ = Unroller(basis_gate_set)\n",
    "        pm = PassManager(pass_)\n",
    "        unrolled_circuit = pm.run(circuit)\n",
    "\n",
    "        # calculating the cost function using the equation given above\n",
    "        gates = unrolled_circuit.count_ops()\n",
    "        circuit_cost = gates['u3'] + 10*gates['cx']\n",
    "        \n",
    "    return circuit_cost, gates, unrolled_circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Internally, the `cost_function()` method uses an `Unroller` pass to convert our circuit to the {'u3', 'cx'} basis gate set and then applies the cost function equation as defined above. Here are a few resources to understand how the transpiler works: \n",
    "\n",
    "* Qiskit Terra Documentation - [Transpiler](https://qiskit.org/documentation/apidoc/transpiler.html)\n",
    "* Advanced Circuit Tutorial - [Tranpiler Passes and Pass Manager](https://qiskit.org/documentation/tutorials/circuits_advanced/4_transpiler_passes_and_passmanager.html)\n",
    "\n",
    "\n",
    "Let's understand how to use the `cost_function()` method by applying it on a half adder circuit as given in [Chapter 1.2](https://qiskit.org/textbook/ch-states/atoms-computation.html) of the Qiskit Textbook. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐ ░                 ░       \n",
       "q_0: ┤ X ├─░───■─────────■───░───────\n",
       "     ├───┤ ░   │         │   ░       \n",
       "q_1: ┤ X ├─░───┼────■────■───░───────\n",
       "     └───┘ ░ ┌─┴─┐┌─┴─┐  │   ░ ┌─┐   \n",
       "q_2: ──────░─┤ X ├┤ X ├──┼───░─┤M├───\n",
       "           ░ └───┘└───┘┌─┴─┐ ░ └╥┘┌─┐\n",
       "q_3: ──────░───────────┤ X ├─░──╫─┤M├\n",
       "           ░           └───┘ ░  ║ └╥┘\n",
       "c_0: ═══════════════════════════╩══╬═\n",
       "                                   ║ \n",
       "c_1: ══════════════════════════════╩═\n",
       "                                     </pre>"
      ],
      "text/plain": [
       "     ┌───┐ ░                 ░       \n",
       "q_0: ┤ X ├─░───■─────────■───░───────\n",
       "     ├───┤ ░   │         │   ░       \n",
       "q_1: ┤ X ├─░───┼────■────■───░───────\n",
       "     └───┘ ░ ┌─┴─┐┌─┴─┐  │   ░ ┌─┐   \n",
       "q_2: ──────░─┤ X ├┤ X ├──┼───░─┤M├───\n",
       "           ░ └───┘└───┘┌─┴─┐ ░ └╥┘┌─┐\n",
       "q_3: ──────░───────────┤ X ├─░──╫─┤M├\n",
       "           ░           └───┘ ░  ║ └╥┘\n",
       "c_0: ═══════════════════════════╩══╬═\n",
       "                                   ║ \n",
       "c_1: ══════════════════════════════╩═\n",
       "                                     "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Constructing the Half Adder circuit\n",
    "\n",
    "qc_ha = QuantumCircuit(4,2)\n",
    "# encode inputs in qubits 0 and 1\n",
    "qc_ha.x(0) # For a=0, remove the this line. For a=1, leave it.\n",
    "qc_ha.x(1) # For b=0, remove the this line. For b=1, leave it.\n",
    "qc_ha.barrier()\n",
    "# use cnots to write the XOR of the inputs on qubit 2\n",
    "qc_ha.cx(0,2)\n",
    "qc_ha.cx(1,2)\n",
    "# use ccx to write the AND of the inputs on qubit 3\n",
    "qc_ha.ccx(0,1,3)\n",
    "qc_ha.barrier()\n",
    "# extract outputs\n",
    "qc_ha.measure(2,0) # extract XOR value\n",
    "qc_ha.measure(3,1) # extract AND value\n",
    "\n",
    "qc_ha.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost of the circuit : 91\n",
      "Gates counts after unrolling : OrderedDict([('u3', 11), ('cx', 8), ('barrier', 2), ('measure', 2)])\n",
      "Circuit after unrolling :\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌─────────────┐ ░                                                  »\n",
       "q_0: ┤ U3(pi,0,pi) ├─░─────────■─────────────────────────────────────■──»\n",
       "     ├─────────────┤ ░         │                                     │  »\n",
       "q_1: ┤ U3(pi,0,pi) ├─░─────────┼──────────■────■─────────────────────┼──»\n",
       "     └─────────────┘ ░       ┌─┴─┐      ┌─┴─┐  │                     │  »\n",
       "q_2: ────────────────░───────┤ X ├──────┤ X ├──┼─────────────────────┼──»\n",
       "                     ░ ┌─────┴───┴─────┐└───┘┌─┴─┐┌───────────────┐┌─┴─┐»\n",
       "q_3: ────────────────░─┤ U3(pi/2,0,pi) ├─────┤ X ├┤ U3(0,0,-pi/4) ├┤ X ├»\n",
       "                     ░ └───────────────┘     └───┘└───────────────┘└───┘»\n",
       "c_0: ═══════════════════════════════════════════════════════════════════»\n",
       "                                                                        »\n",
       "c_1: ═══════════════════════════════════════════════════════════════════»\n",
       "                                                                        »\n",
       "«                                                                »\n",
       "«q_0: ────────────────────────────────────────■─────────■────────»\n",
       "«                           ┌──────────────┐  │       ┌─┴─┐      »\n",
       "«q_1: ──────────────────■───┤ U3(0,0,pi/4) ├──┼───────┤ X ├──────»\n",
       "«                       │   └──────────────┘  │       └───┘      »\n",
       "«q_2: ──────────────────┼─────────────────────┼──────────────────»\n",
       "«     ┌──────────────┐┌─┴─┐┌───────────────┐┌─┴─┐┌──────────────┐»\n",
       "«q_3: ┤ U3(0,0,pi/4) ├┤ X ├┤ U3(0,0,-pi/4) ├┤ X ├┤ U3(0,0,pi/4) ├»\n",
       "«     └──────────────┘└───┘└───────────────┘└───┘└──────────────┘»\n",
       "«c_0: ═══════════════════════════════════════════════════════════»\n",
       "«                                                                »\n",
       "«c_1: ═══════════════════════════════════════════════════════════»\n",
       "«                                                                »\n",
       "«      ┌──────────────┐      ░       \n",
       "«q_0: ─┤ U3(0,0,pi/4) ├──■───░───────\n",
       "«     ┌┴──────────────┤┌─┴─┐ ░       \n",
       "«q_1: ┤ U3(0,0,-pi/4) ├┤ X ├─░───────\n",
       "«     └───────────────┘└───┘ ░ ┌─┐   \n",
       "«q_2: ───────────────────────░─┤M├───\n",
       "«     ┌───────────────┐      ░ └╥┘┌─┐\n",
       "«q_3: ┤ U3(pi/2,0,pi) ├──────░──╫─┤M├\n",
       "«     └───────────────┘      ░  ║ └╥┘\n",
       "«c_0: ══════════════════════════╩══╬═\n",
       "«                                  ║ \n",
       "«c_1: ═════════════════════════════╩═\n",
       "«                                    </pre>"
      ],
      "text/plain": [
       "     ┌─────────────┐ ░                                                  »\n",
       "q_0: ┤ U3(pi,0,pi) ├─░─────────■─────────────────────────────────────■──»\n",
       "     ├─────────────┤ ░         │                                     │  »\n",
       "q_1: ┤ U3(pi,0,pi) ├─░─────────┼──────────■────■─────────────────────┼──»\n",
       "     └─────────────┘ ░       ┌─┴─┐      ┌─┴─┐  │                     │  »\n",
       "q_2: ────────────────░───────┤ X ├──────┤ X ├──┼─────────────────────┼──»\n",
       "                     ░ ┌─────┴───┴─────┐└───┘┌─┴─┐┌───────────────┐┌─┴─┐»\n",
       "q_3: ────────────────░─┤ U3(pi/2,0,pi) ├─────┤ X ├┤ U3(0,0,-pi/4) ├┤ X ├»\n",
       "                     ░ └───────────────┘     └───┘└───────────────┘└───┘»\n",
       "c_0: ═══════════════════════════════════════════════════════════════════»\n",
       "                                                                        »\n",
       "c_1: ═══════════════════════════════════════════════════════════════════»\n",
       "                                                                        »\n",
       "«                                                                »\n",
       "«q_0: ────────────────────────────────────────■─────────■────────»\n",
       "«                           ┌──────────────┐  │       ┌─┴─┐      »\n",
       "«q_1: ──────────────────■───┤ U3(0,0,pi/4) ├──┼───────┤ X ├──────»\n",
       "«                       │   └──────────────┘  │       └───┘      »\n",
       "«q_2: ──────────────────┼─────────────────────┼──────────────────»\n",
       "«     ┌──────────────┐┌─┴─┐┌───────────────┐┌─┴─┐┌──────────────┐»\n",
       "«q_3: ┤ U3(0,0,pi/4) ├┤ X ├┤ U3(0,0,-pi/4) ├┤ X ├┤ U3(0,0,pi/4) ├»\n",
       "«     └──────────────┘└───┘└───────────────┘└───┘└──────────────┘»\n",
       "«c_0: ═══════════════════════════════════════════════════════════»\n",
       "«                                                                »\n",
       "«c_1: ═══════════════════════════════════════════════════════════»\n",
       "«                                                                »\n",
       "«      ┌──────────────┐      ░       \n",
       "«q_0: ─┤ U3(0,0,pi/4) ├──■───░───────\n",
       "«     ┌┴──────────────┤┌─┴─┐ ░       \n",
       "«q_1: ┤ U3(0,0,-pi/4) ├┤ X ├─░───────\n",
       "«     └───────────────┘└───┘ ░ ┌─┐   \n",
       "«q_2: ───────────────────────░─┤M├───\n",
       "«     ┌───────────────┐      ░ └╥┘┌─┐\n",
       "«q_3: ┤ U3(pi/2,0,pi) ├──────░──╫─┤M├\n",
       "«     └───────────────┘      ░  ║ └╥┘\n",
       "«c_0: ══════════════════════════╩══╬═\n",
       "«                                  ║ \n",
       "«c_1: ═════════════════════════════╩═\n",
       "«                                    "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit_cost, gates, unrolled_circuit = cost_function(qc_ha)\n",
    "\n",
    "print('Cost of the circuit : {}'.format(circuit_cost))\n",
    "print('Gates counts after unrolling : {}'.format(gates))\n",
    "print('Circuit after unrolling :')\n",
    "unrolled_circuit.draw()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}