lab9_ex1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](resources/qgss-header.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 9: Hardware-efficient trial states for variational quantum eigensolvers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, we want to find the ground state energy of the following two-qubit Hamiltonian representing molecular $H_2$ at its equilibrium distance. Note that we have already mapped the fermionic operators onto qubits here.\n",
    "\n",
    "```\n",
    "h2_hamiltonian = (-1.0523732)  II + \n",
    "                 (0.39793742)  IZ + \n",
    "                 (-0.3979374)  ZI + \n",
    "                 (-0.0112801)  ZZ + \n",
    "                 (0.18093119)  XX\n",
    "```\n",
    "                \n",
    "Note that these co-efficients are functions of the interatomic distance between the atoms. A term like `IZ` is shorthand notation for a tensor product of two-qubit operators -- the identity operator ($I$) on one qubit and pauli-Z operator ($Z$) on the other qubit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installing necessary packages\n",
    "\n",
    "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": [
    "# Hardware efficient trial states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to prepare a guess for the ground state of this Hamiltonian. For this exercise, we will construct a hardware efficient trial state of depth `d=2`, with CNOT (`CX`) gates for the entanglers. We will interleave each entangling layer with a set of $R_yR_z$ gates on each qubit (total 4 layers). For the first guess, we will use rotation angles of $\\pi/2$ on all the $R_y$ and $R_z$ gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import pi\n",
    "from qiskit import QuantumCircuit, Aer, execute\n",
    "from qiskit.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_hets_circuit(depth, angle1, angle2):\n",
    "\n",
    "    hets_circ = QuantumCircuit(depth)\n",
    "    hets_circ.ry(angle1, 0)\n",
    "    hets_circ.rz(angle1, 0)\n",
    "    hets_circ.ry(angle1, 1)\n",
    "    hets_circ.rz(angle1, 1)\n",
    "\n",
    "    for ii in range(depth):\n",
    "        hets_circ.cx(0,1)\n",
    "        hets_circ.ry(angle2,0)\n",
    "        hets_circ.rz(angle2,0)\n",
    "        hets_circ.ry(angle2,1)\n",
    "        hets_circ.rz(angle2,1)\n",
    "    \n",
    "    return hets_circ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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: ┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├»\n",
       "     ├──────────┤├──────────┤┌─┴─┐├──────────┤├──────────┤┌─┴─┐├──────────┤»\n",
       "q_1: ┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├»\n",
       "     └──────────┘└──────────┘└───┘└──────────┘└──────────┘└───┘└──────────┘»\n",
       "«     ┌──────────┐\n",
       "«q_0: ┤ RZ(pi/2) ├\n",
       "«     ├──────────┤\n",
       "«q_1: ┤ RZ(pi/2) ├\n",
       "«     └──────────┘</pre>"
      ],
      "text/plain": [
       "     ┌──────────┐┌──────────┐     ┌──────────┐┌──────────┐     ┌──────────┐»\n",
       "q_0: ┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├»\n",
       "     ├──────────┤├──────────┤┌─┴─┐├──────────┤├──────────┤┌─┴─┐├──────────┤»\n",
       "q_1: ┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├»\n",
       "     └──────────┘└──────────┘└───┘└──────────┘└──────────┘└───┘└──────────┘»\n",
       "«     ┌──────────┐\n",
       "«q_0: ┤ RZ(pi/2) ├\n",
       "«     ├──────────┤\n",
       "«q_1: ┤ RZ(pi/2) ├\n",
       "«     └──────────┘"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)\n",
    "hets_circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measuring expectation values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we measure expectation values. **We will begin by measuring the ZZ expectation value, or $\\langle ZZ \\rangle$**. We will first create a copy of the `hets_circ` quantum circuit that we created above, and add measurements to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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: ┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├»\n",
       "        ├──────────┤├──────────┤┌─┴─┐├──────────┤├──────────┤┌─┴─┐├──────────┤»\n",
       "   q_1: ┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├»\n",
       "        └──────────┘└──────────┘└───┘└──────────┘└──────────┘└───┘└──────────┘»\n",
       "meas_0: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "meas_1: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "«        ┌──────────┐ ░ ┌─┐   \n",
       "«   q_0: ┤ RZ(pi/2) ├─░─┤M├───\n",
       "«        ├──────────┤ ░ └╥┘┌─┐\n",
       "«   q_1: ┤ RZ(pi/2) ├─░──╫─┤M├\n",
       "«        └──────────┘ ░  ║ └╥┘\n",
       "«meas_0: ════════════════╩══╬═\n",
       "«                           ║ \n",
       "«meas_1: ═══════════════════╩═\n",
       "«                             </pre>"
      ],
      "text/plain": [
       "        ┌──────────┐┌──────────┐     ┌──────────┐┌──────────┐     ┌──────────┐»\n",
       "   q_0: ┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├»\n",
       "        ├──────────┤├──────────┤┌─┴─┐├──────────┤├──────────┤┌─┴─┐├──────────┤»\n",
       "   q_1: ┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├»\n",
       "        └──────────┘└──────────┘└───┘└──────────┘└──────────┘└───┘└──────────┘»\n",
       "meas_0: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "meas_1: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "«        ┌──────────┐ ░ ┌─┐   \n",
       "«   q_0: ┤ RZ(pi/2) ├─░─┤M├───\n",
       "«        ├──────────┤ ░ └╥┘┌─┐\n",
       "«   q_1: ┤ RZ(pi/2) ├─░──╫─┤M├\n",
       "«        └──────────┘ ░  ║ └╥┘\n",
       "«meas_0: ════════════════╩══╬═\n",
       "«                           ║ \n",
       "«meas_1: ═══════════════════╩═\n",
       "«                             "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def measure_zz_circuit(given_circuit):\n",
    "    zz_meas = given_circuit.copy()\n",
    "    zz_meas.measure_all()\n",
    "    return zz_meas\n",
    "\n",
    "zz_meas = measure_zz_circuit(hets_circuit)\n",
    "zz_meas.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's execute this quantum circuit and see the measurement outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulator = Aer.get_backend('qasm_simulator')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = execute(zz_meas, backend = simulator, shots=10000).result()\n",
    "counts = result.get_counts(zz_meas)\n",
    "\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can analyze the counts and calculate the $\\langle ZZ \\rangle$ as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def measure_zz(given_circuit, num_shots = 10000):\n",
    "\n",
    "    zz_meas = measure_zz_circuit(given_circuit)\n",
    "    \n",
    "    result = execute(zz_meas, backend = simulator, shots = num_shots).result()\n",
    "    counts = result.get_counts(zz_meas)\n",
    "\n",
    "    if '00' not in counts:\n",
    "        counts['00'] = 0\n",
    "    if '01' not in counts:\n",
    "        counts['01'] = 0\n",
    "    if '10' not in counts:\n",
    "        counts['10'] = 0\n",
    "    if '11' not in counts:\n",
    "        counts['11'] = 0 \n",
    "\n",
    "    total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']\n",
    "    zz = counts['00'] + counts['11'] - counts['01'] - counts['10']\n",
    "    zz = zz / total_counts\n",
    "    \n",
    "    return zz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<ZZ> = 0.0052\n"
     ]
    }
   ],
   "source": [
    "zz = measure_zz(hets_circuit)\n",
    "print(\"<ZZ> =\", str(zz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What about $\\langle ZI \\rangle$ and  $\\langle IZ \\rangle$? Do these need new circuits?**\n",
    "\n",
    "The answer is no, and they can be computed from the results above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def measure_zi(given_circuit, num_shots = 10000):\n",
    "    \n",
    "    zz_meas = measure_zz_circuit(given_circuit)\n",
    "    \n",
    "    result = execute(zz_meas, backend = simulator, shots = num_shots).result()\n",
    "    counts = result.get_counts(zz_meas)\n",
    "\n",
    "    if '00' not in counts:\n",
    "        counts['00'] = 0\n",
    "    if '01' not in counts:\n",
    "        counts['01'] = 0\n",
    "    if '10' not in counts:\n",
    "        counts['10'] = 0\n",
    "    if '11' not in counts:\n",
    "        counts['11'] = 0 \n",
    "\n",
    "    total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']\n",
    "    \n",
    "    zi = counts['00'] - counts['11'] + counts['01'] - counts['10']\n",
    "    zi = zi / total_counts\n",
    "    \n",
    "    return zi\n",
    "\n",
    "def measure_iz(given_circuit, num_shots = 10000):\n",
    "    \n",
    "    zz_meas = measure_zz_circuit(given_circuit)\n",
    "    \n",
    "    result = execute(zz_meas, backend = simulator, shots = num_shots).result()\n",
    "    counts = result.get_counts(zz_meas)\n",
    "\n",
    "    if '00' not in counts:\n",
    "        counts['00'] = 0\n",
    "    if '01' not in counts:\n",
    "        counts['01'] = 0\n",
    "    if '10' not in counts:\n",
    "        counts['10'] = 0\n",
    "    if '11' not in counts:\n",
    "        counts['11'] = 0 \n",
    "\n",
    "    total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']\n",
    "    \n",
    "    iz = counts['00'] - counts['11'] - counts['01'] + counts['10']\n",
    "    iz = iz / total_counts\n",
    "    \n",
    "    return iz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<ZI> = 0.0064\n",
      "<IZ> = 0.0048\n"
     ]
    }
   ],
   "source": [
    "zi = measure_zi(hets_circuit)\n",
    "print(\"<ZI> =\", str(zi))\n",
    "\n",
    "iz = measure_iz(hets_circuit)\n",
    "print(\"<IZ> =\", str(iz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Next, we measure $\\langle XX \\rangle$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def measure_xx_circuit(given_circuit):\n",
    "    xx_meas = given_circuit.copy()\n",
    "    \n",
    "    ### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "    xx_meas.h([0,1])\n",
    "    \n",
    "    xx_meas.measure_all()\n",
    "\n",
    "    \n",
    "    ### WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "\n",
    "    return xx_meas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "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: ┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├»\n",
       "        ├──────────┤├──────────┤┌─┴─┐├──────────┤├──────────┤┌─┴─┐├──────────┤»\n",
       "   q_1: ┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├»\n",
       "        └──────────┘└──────────┘└───┘└──────────┘└──────────┘└───┘└──────────┘»\n",
       "meas_0: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "meas_1: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "«        ┌──────────┐┌───┐ ░ ┌─┐   \n",
       "«   q_0: ┤ RZ(pi/2) ├┤ H ├─░─┤M├───\n",
       "«        ├──────────┤├───┤ ░ └╥┘┌─┐\n",
       "«   q_1: ┤ RZ(pi/2) ├┤ H ├─░──╫─┤M├\n",
       "«        └──────────┘└───┘ ░  ║ └╥┘\n",
       "«meas_0: ═════════════════════╩══╬═\n",
       "«                                ║ \n",
       "«meas_1: ════════════════════════╩═\n",
       "«                                  </pre>"
      ],
      "text/plain": [
       "        ┌──────────┐┌──────────┐     ┌──────────┐┌──────────┐     ┌──────────┐»\n",
       "   q_0: ┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├┤ RZ(pi/2) ├──■──┤ RY(pi/2) ├»\n",
       "        ├──────────┤├──────────┤┌─┴─┐├──────────┤├──────────┤┌─┴─┐├──────────┤»\n",
       "   q_1: ┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├┤ RZ(pi/2) ├┤ X ├┤ RY(pi/2) ├»\n",
       "        └──────────┘└──────────┘└───┘└──────────┘└──────────┘└───┘└──────────┘»\n",
       "meas_0: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "meas_1: ══════════════════════════════════════════════════════════════════════»\n",
       "                                                                              »\n",
       "«        ┌──────────┐┌───┐ ░ ┌─┐   \n",
       "«   q_0: ┤ RZ(pi/2) ├┤ H ├─░─┤M├───\n",
       "«        ├──────────┤├───┤ ░ └╥┘┌─┐\n",
       "«   q_1: ┤ RZ(pi/2) ├┤ H ├─░──╫─┤M├\n",
       "«        └──────────┘└───┘ ░  ║ └╥┘\n",
       "«meas_0: ═════════════════════╩══╬═\n",
       "«                                ║ \n",
       "«meas_1: ════════════════════════╩═\n",
       "«                                  "
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xx_meas = measure_xx_circuit(hets_circuit)\n",
    "xx_meas.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<XX> = -1.0\n"
     ]
    }
   ],
   "source": [
    "def measure_xx(given_circuit, num_shots = 10000):\n",
    "    \n",
    "    xx_meas = measure_xx_circuit(given_circuit)\n",
    "    \n",
    "    result = execute(xx_meas, backend = simulator, shots = num_shots).result()\n",
    "    counts = result.get_counts(xx_meas)\n",
    "\n",
    "    if '00' not in counts:\n",
    "        counts['00'] = 0\n",
    "    if '01' not in counts:\n",
    "        counts['01'] = 0\n",
    "    if '10' not in counts:\n",
    "        counts['10'] = 0\n",
    "    if '11' not in counts:\n",
    "        counts['11'] = 0\n",
    "\n",
    "    total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']\n",
    "    xx = counts['00'] + counts['11'] - counts['01'] - counts['10']\n",
    "    xx = xx / total_counts\n",
    "    \n",
    "    return xx\n",
    "\n",
    "xx = measure_xx(hets_circuit)\n",
    "print(\"<XX> =\", str(xx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we evaluate the energy of the trial state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_energy(given_circuit, num_shots = 10000):\n",
    "    \n",
    "    zz = measure_zz(given_circuit, num_shots = num_shots)\n",
    "    iz = measure_iz(given_circuit, num_shots = num_shots)\n",
    "    zi = measure_zi(given_circuit, num_shots = num_shots)\n",
    "    xx = measure_xx(given_circuit, num_shots = num_shots)\n",
    "    \n",
    "    energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx\n",
    "    \n",
    "    return energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The energy of the trial state is -1.2281792068799997\n"
     ]
    }
   ],
   "source": [
    "energy = get_energy(hets_circuit)\n",
    "print(\"The energy of the trial state is\", str(energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computing gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objective of the next set of exercises is to compute the next set of angles to use for the trial state preparation. Create two quantum circuits using `prepare_hets_circuit(depth=2, angle2 = pi/2)` for measuring expectation values with values for `angle1 = pi/2 + 0.1*pi/2` and `angle1 = pi/2 - 0.1*pi/2`, and measure the energy of both trial states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.1607520695598 -1.277765480269\n"
     ]
    }
   ],
   "source": [
    "hets_circuit_plus = None\n",
    "hets_circuit_minus = None\n",
    "\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "hets_circuit_plus = prepare_hets_circuit(depth=2, angle1= pi/2 + 0.1*pi/2, angle2 = pi/2)\n",
    "hets_circuit_minus = prepare_hets_circuit(depth=2, angle1= pi/2 - 0.1*pi/2, angle2 = pi/2)\n",
    "\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "\n",
    "energy_plus = get_energy(hets_circuit_plus, num_shots=100000)\n",
    "energy_minus = get_energy(hets_circuit_minus, num_shots=100000)\n",
    "\n",
    "print(energy_plus, energy_minus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, one of these is certainly lower energy than the other, and is also lower energy than the case when `angle1 = pi/2`. This is a suitable next point for our iteration of a variational eigensolver."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Submitting your solutions for grading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, 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": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading...\n",
      "lab9/ex1 - 🎉 Correct\n",
      "🎊 Hurray! You have a new correct answer! Let's submit it.\n",
      "Submitting the answers for lab9...\n",
      "📝 Our records, so far, are:\n",
      "Correct answers: lab1:ex1, lab2:ex1, lab3:ex1, lab4:ex1, lab5:ex1, lab6:ex1a, lab6:ex1b, lab9:ex1, lab9:ex2, lab9:ex3\n",
      "Grading...\n",
      "lab9/ex2 - 🎉 Correct\n",
      "Grading...\n",
      "lab9/ex3 - 🎉 Correct\n"
     ]
    }
   ],
   "source": [
    "name = 'First Last'\n",
    "email = 'first.last@domain.com'\n",
    "\n",
    "### Do not change the lines below\n",
    "from grading_tools import grade\n",
    "\n",
    "grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')\n",
    "grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')\n",
    "grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Help us improve our educational tools by submitting your code**<br>\n",
    "If you would like to help us learn how to improve our educational materials and offerings, you can opt in to send us a copy of your Jupyter notebook. By executing the cell below, you consent to sending us the code in your Jupyter notebook. All of the personal information will be anonymized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.save_checkpoint();"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sending ex1.ipynb ...\n",
      "Sent. Thanks!\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import display, Javascript;display(Javascript('IPython.notebook.save_checkpoint();'));\n",
    "from grading_tools import send_code;send_code('ex1.ipynb')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this is not graded, explore whether the decision above would be easy if your execution ran different numbers of shots. In particular, measure `energy_plus` and `energy_minus` again with `100`, `1000` and `10000` shots to explore how easy or difficult this decision gets with each one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0\n",
    "energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0\n",
    "\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "\n",
    "print(energy_plus_100, energy_minus_100, \"difference = \", energy_minus_100 - energy_plus_100)\n",
    "print(energy_plus_1000, energy_minus_1000, \"difference = \", energy_minus_1000 - energy_plus_1000)\n",
    "print(energy_plus_10000, energy_minus_10000, \"difference = \", energy_minus_10000 - energy_plus_10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this is not graded, diagonalize the Hamiltonian by writing down the matrices for the Pauli operators `I`, `X` and `Z`, and find the exact ground state energy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - END"
   ]
  }
 ],
 "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": 2
}