lab2_ex1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](resources/qgss-header.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 2: Grover's Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you will implement Grover's algorithm in `Qiskit` and investigate its behavior following the material presented in lecture 2.\n",
    "\n",
    "You might find this chapter of the Qiskit Textbook useful:\n",
    "- https://qiskit.org/textbook/ch-algorithms/grover.html\n",
    "\n",
    "Remember, to run a cell in Jupyter notebooks, you press `Shift` + `Return/Enter` on your keyboard."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installing necessary packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we begin, you will need to install some prerequisites into your environment. Run the cell below to complete these installations. At the end, the cell outputs will be cleared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -U -r grading_tools/requirements.txt\n",
    "\n",
    "from IPython.display import clear_output\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Review of Grover's Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](resources/grover_blockdiagram.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might recall from lecture 2 that Grover's algorithm has three main components. \n",
    "1. First, we begin by creating a superposition of all $2^n$ computational basis states by applying a Hadamard ($H$) gate on each qubit starting off in the state $\\vert0\\rangle^{\\otimes n}$. Here, the exponent $\\otimes n$ means that we have a tensor product of the states of $n$ qubits. \n",
    "2. Second, we apply an Oracle operator to mark the appropriate elements among the $2^n$ elements. The oracle operator applies a coefficient of $-1$ to each of the marked elements.\n",
    "3. Third, we apply a Diffusion operator, or diffuser, which inverts the amplitude of all elements about the average amplitude.\n",
    "\n",
    "Putting these components together, and applying the Oracle and Diffusion operators $O(\\sqrt{N = 2^n})$ times, Grover's algorithm allows us to successfully determine the elements that were marked by the Oracle operator with high probability. This is shown in the block diagram above, where the quantum circuit for Grover's algorithm is depicted with a measurement in the end to read out the qubits.\n",
    "\n",
    "# Graded Exercise 1: Implementing Grover's Algorithm\n",
    "\n",
    "As you saw in the lecture, it is not hard to implement Grover's algorithm using `Qiskit`. The goal of this lab is to implement Grover's algorithm by creating a quantum circuit that has the marked elements `000001` and `101010`. You will see that the algorithm outputs one of these two marked elements with probability greater than $99\\%$. \n",
    "\n",
    "Let us build each block step by step.\n",
    "\n",
    "### 1.) Phase Oracle\n",
    "We start with the phase oracle. You might find it helpful to have a look at the corresponding chapter in the Qiskit textbook: https://qiskit.org/textbook/ch-algorithms/grover.html. However, note that the implementation in the textbook is done on 2 and 3 qubits only, while here we need to apply it to 6 qubits.\n",
    "\n",
    "**Recall that the action of the phase oracle is to add a phase of $-1$ to all states representing the marked elements, while leaving all other states unchanged.** An easy way to implement the phase oracle is to create an identity matrix on all $n$ qubits (remember that the corresponding dimension of this matrix is $2^n$) and then change those diagonal elements to $-1$ that correspond to the marked elements. Then, you need to convert that unitary into an operator.\n",
    "\n",
    "We have created a function below called `phase_oracle` which takes in two arguments. The first argument, $n$, gives the number of qubits in the quantum circuit. The second argument, `indices_to_mark`, is a list of the indices whose elements will be marked by the phase oracle with a phase of $-1$. Using these inputs, create a $2^n\\times2^n$ identity matrix, and apply a phase of $-1$ to the diagonal elements at locations given in `indices_to_mark`. For example, if $0$ is in `indices_to_mark`, that means you need to set the top-left-most diagonal element of the identity matrix to -1.\n",
    "\n",
    "Once you complete these steps, apply the unitary operator to the quantum circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.quantum_info import Operator\n",
    "from qiskit import QuantumCircuit\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def phase_oracle(n, indices_to_mark, name = 'Oracle'):\n",
    "    \n",
    "    # create a quantum circuit on n qubits\n",
    "    qc = QuantumCircuit(n, name=name)\n",
    "\n",
    "    ### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "    oracle_matrix = np.identity(2**n)\n",
    "    \n",
    "    for marked_index in indices_to_mark:\n",
    "        oracle_matrix[marked_index, marked_index] = -1\n",
    "        \n",
    "    ### WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "\n",
    "    # convert your matrix (called oracle_matrix) into an operator, and add it to the quantum circuit\n",
    "    qc.unitary(Operator(oracle_matrix), range(n))\n",
    "    \n",
    "    return qc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.) Diffusion Operator $V$\n",
    "\n",
    "Next, we define the diffuser, which we called $V$ in the lecture. Its effect is to reflect all amplitudes about the average amplitude. To do so, we simply call the `phase_oracle` with only the zero state ($\\vert0\\rangle^{\\otimes n}$) as the marked element and sandwich it between Hadamard gates applied to all qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diffuser(n):\n",
    "    \n",
    "    # create a quantum circuit on n qubits\n",
    "    qc = QuantumCircuit(n, name='Diffuser')\n",
    "    \n",
    "    ### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "    qc.h(range(n))\n",
    "    qc.append(phase_oracle(n,[0]), range(n))\n",
    "    qc.h(range(n))\n",
    "    ### WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "    \n",
    "    return qc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.) Putting it all together\n",
    "\n",
    "Finally, we combine the functions to construct Grover's algorithm. We need to determine the optimal number of rounds $r$ as described in the lecture.\n",
    "\n",
    "This was given by \n",
    "\n",
    "$$r = \\left\\lfloor\\frac{\\pi}{4}\\sqrt{\\frac{N}{k}}\\right\\rfloor$$\n",
    "\n",
    "where $k$ is the number of marked elements, and $\\lfloor~\\rfloor$ means rounding down to the nearest integer. In the specific example that we consider here, where we have six qubits ($N = 2^6$) and two marked elements ($k = 2$), implying that $r = 4$. You can check this yourself by plugging in the numbers.\n",
    "\n",
    "In the lecture, we have also seen a lower bound on the success probability when using $n$ qubits. In this exercise, the success probability should be higher than $99\\%$.\n",
    "\n",
    "Let's construct a quantum program that finds the marked elements `000001` and `101010` using Grover's algorithm. To do this, we will need to do the following: \n",
    "1. We start with a Hadamard gate on all qubits.\n",
    "2. Next, we apply $r$ rounds of Grover's algorithm, where each round consists of the application of the phase oracle with the marked elements and the diffuser. The indices for the two marked elements `000001` and `101010` are $1$ and $42$. \n",
    "3. Finally, we need to measure all qubits.\n",
    "\n",
    "The next lines of code put everything together. **You do not need to modify anything below, but you will need to run the cell to submit your solution.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 qubits, basis states [1, 42] marked, 4 rounds\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: ┤ H ├┤0        ├┤0          ├┤0        ├┤0          ├┤0        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_1: ┤ H ├┤1        ├┤1          ├┤1        ├┤1          ├┤1        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_2: ┤ H ├┤2        ├┤2          ├┤2        ├┤2          ├┤2        ├»\n",
       "     ├───┤│  Oracle ││  Diffuser ││  Oracle ││  Diffuser ││  Oracle │»\n",
       "q_3: ┤ H ├┤3        ├┤3          ├┤3        ├┤3          ├┤3        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_4: ┤ H ├┤4        ├┤4          ├┤4        ├┤4          ├┤4        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_5: ┤ H ├┤5        ├┤5          ├┤5        ├┤5          ├┤5        ├»\n",
       "     └───┘└─────────┘└───────────┘└─────────┘└───────────┘└─────────┘»\n",
       "c_0: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_1: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_2: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_3: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_4: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_5: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "«     ┌───────────┐┌─────────┐┌───────────┐┌─┐               \n",
       "«q_0: ┤0          ├┤0        ├┤0          ├┤M├───────────────\n",
       "«     │           ││         ││           │└╥┘┌─┐            \n",
       "«q_1: ┤1          ├┤1        ├┤1          ├─╫─┤M├────────────\n",
       "«     │           ││         ││           │ ║ └╥┘┌─┐         \n",
       "«q_2: ┤2          ├┤2        ├┤2          ├─╫──╫─┤M├─────────\n",
       "«     │  Diffuser ││  Oracle ││  Diffuser │ ║  ║ └╥┘┌─┐      \n",
       "«q_3: ┤3          ├┤3        ├┤3          ├─╫──╫──╫─┤M├──────\n",
       "«     │           ││         ││           │ ║  ║  ║ └╥┘┌─┐   \n",
       "«q_4: ┤4          ├┤4        ├┤4          ├─╫──╫──╫──╫─┤M├───\n",
       "«     │           ││         ││           │ ║  ║  ║  ║ └╥┘┌─┐\n",
       "«q_5: ┤5          ├┤5        ├┤5          ├─╫──╫──╫──╫──╫─┤M├\n",
       "«     └───────────┘└─────────┘└───────────┘ ║  ║  ║  ║  ║ └╥┘\n",
       "«c_0: ══════════════════════════════════════╩══╬══╬══╬══╬══╬═\n",
       "«                                              ║  ║  ║  ║  ║ \n",
       "«c_1: ═════════════════════════════════════════╩══╬══╬══╬══╬═\n",
       "«                                                 ║  ║  ║  ║ \n",
       "«c_2: ════════════════════════════════════════════╩══╬══╬══╬═\n",
       "«                                                    ║  ║  ║ \n",
       "«c_3: ═══════════════════════════════════════════════╩══╬══╬═\n",
       "«                                                       ║  ║ \n",
       "«c_4: ══════════════════════════════════════════════════╩══╬═\n",
       "«                                                          ║ \n",
       "«c_5: ═════════════════════════════════════════════════════╩═\n",
       "«                                                            </pre>"
      ],
      "text/plain": [
       "     ┌───┐┌─────────┐┌───────────┐┌─────────┐┌───────────┐┌─────────┐»\n",
       "q_0: ┤ H ├┤0        ├┤0          ├┤0        ├┤0          ├┤0        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_1: ┤ H ├┤1        ├┤1          ├┤1        ├┤1          ├┤1        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_2: ┤ H ├┤2        ├┤2          ├┤2        ├┤2          ├┤2        ├»\n",
       "     ├───┤│  Oracle ││  Diffuser ││  Oracle ││  Diffuser ││  Oracle │»\n",
       "q_3: ┤ H ├┤3        ├┤3          ├┤3        ├┤3          ├┤3        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_4: ┤ H ├┤4        ├┤4          ├┤4        ├┤4          ├┤4        ├»\n",
       "     ├───┤│         ││           ││         ││           ││         │»\n",
       "q_5: ┤ H ├┤5        ├┤5          ├┤5        ├┤5          ├┤5        ├»\n",
       "     └───┘└─────────┘└───────────┘└─────────┘└───────────┘└─────────┘»\n",
       "c_0: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_1: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_2: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_3: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_4: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "c_5: ════════════════════════════════════════════════════════════════»\n",
       "                                                                     »\n",
       "«     ┌───────────┐┌─────────┐┌───────────┐┌─┐               \n",
       "«q_0: ┤0          ├┤0        ├┤0          ├┤M├───────────────\n",
       "«     │           ││         ││           │└╥┘┌─┐            \n",
       "«q_1: ┤1          ├┤1        ├┤1          ├─╫─┤M├────────────\n",
       "«     │           ││         ││           │ ║ └╥┘┌─┐         \n",
       "«q_2: ┤2          ├┤2        ├┤2          ├─╫──╫─┤M├─────────\n",
       "«     │  Diffuser ││  Oracle ││  Diffuser │ ║  ║ └╥┘┌─┐      \n",
       "«q_3: ┤3          ├┤3        ├┤3          ├─╫──╫──╫─┤M├──────\n",
       "«     │           ││         ││           │ ║  ║  ║ └╥┘┌─┐   \n",
       "«q_4: ┤4          ├┤4        ├┤4          ├─╫──╫──╫──╫─┤M├───\n",
       "«     │           ││         ││           │ ║  ║  ║  ║ └╥┘┌─┐\n",
       "«q_5: ┤5          ├┤5        ├┤5          ├─╫──╫──╫──╫──╫─┤M├\n",
       "«     └───────────┘└─────────┘└───────────┘ ║  ║  ║  ║  ║ └╥┘\n",
       "«c_0: ══════════════════════════════════════╩══╬══╬══╬══╬══╬═\n",
       "«                                              ║  ║  ║  ║  ║ \n",
       "«c_1: ═════════════════════════════════════════╩══╬══╬══╬══╬═\n",
       "«                                                 ║  ║  ║  ║ \n",
       "«c_2: ════════════════════════════════════════════╩══╬══╬══╬═\n",
       "«                                                    ║  ║  ║ \n",
       "«c_3: ═══════════════════════════════════════════════╩══╬══╬═\n",
       "«                                                       ║  ║ \n",
       "«c_4: ══════════════════════════════════════════════════╩══╬═\n",
       "«                                                          ║ \n",
       "«c_5: ═════════════════════════════════════════════════════╩═\n",
       "«                                                            "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Grover(n, indices_of_marked_elements):\n",
    "    \n",
    "    # Create a quantum circuit on n qubits\n",
    "    qc = QuantumCircuit(n, n)\n",
    "    \n",
    "    # Determine r\n",
    "    r = int(np.floor(np.pi/4*np.sqrt(2**n/len(indices_of_marked_elements))))\n",
    "    print(f'{n} qubits, basis states {indices_of_marked_elements} marked, {r} rounds')\n",
    "    \n",
    "    # step 1: apply Hadamard gates on all qubits\n",
    "    qc.h(range(n))\n",
    "    \n",
    "    # step 2: apply r rounds of the phase oracle and the diffuser\n",
    "    for _ in range(r):\n",
    "        qc.append(phase_oracle(n, indices_of_marked_elements), range(n))\n",
    "        qc.append(diffuser(n), range(n))\n",
    "        \n",
    "    # step 3: measure all qubits\n",
    "    qc.measure(range(n), range(n))\n",
    "  \n",
    "    return qc\n",
    "\n",
    "mycircuit = Grover(6, [1, 42])\n",
    "mycircuit.draw(output='text')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it! Before you submit your solution for grading, you might find it useful to run your quantum circuit and see the measurement outcomes, as well as visualize the statevector at the end.\n",
    "\n",
    "In order to run your quantum circuit and get the measurement outcomes, you simply need to run `Qiskit`'s `execute` function as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import Aer, execute\n",
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "counts = execute(mycircuit, backend=simulator, shots=1000).result().get_counts(mycircuit)\n",
    "from qiskit.visualization import plot_histogram\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, grade your solution by running the cell below after filling in your name and email address. **Always provide the same name and email as the one you used during registration to ensure consistency.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lab2/ex1 - 🎉  Correct\n",
      "🎊  Hurray! You have a new correct answer! Let's submit it.\n",
      "Submitting the answers for lab2...\n",
      "📝  Our records, so far, are:\n",
      "Correct answers: lab1:ex1, lab2:ex1\n"
     ]
    }
   ],
   "source": [
    "name = 'First Last'\n",
    "email = 'first.last@domain.com'\n",
    "\n",
    "### Do not change the lines below\n",
    "from qiskit import transpile\n",
    "mycircuit_t = transpile(mycircuit, basis_gates=['u1', 'u2', 'u3', 'cx'], optimization_level=0)\n",
    "from grading_tools import grade\n",
    "grade(answer=mycircuit_t, name=name, email=email, labid='lab2', exerciseid='ex1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional reading\n",
    "\n",
    "- In the exercise above, we implemented the phase oracle and diffuser as matrices without decomposing them into single- and two-qubit gates. To run on real hardware, one will also need to consider how to build these oracles using gates. You can find examples of how the oracles can be built in the Grover's algorithm section of the Qiskit Textbook here: https://qiskit.org/textbook/ch-algorithms/grover.html"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}