labs/jupyter-notebooks/lab-1-qiskit-101.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d9bef481",
   "metadata": {},
   "source": [
    "# IBM's Qiskit Global Summer School 2023\n",
    "## Lab 1 - Qiskit 101:\n",
    "\n",
    "- This lab shows you how to use IBM's Qiskit to implement some of the key concepts you learned in the first 3 lectures of the IBM's Qiskit Global Summer School 2023."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d4749ad4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# required import of libraries and modules\n",
    "\n",
    "# import array to latex converter from\n",
    "# IBM's Qiskit visualization module\n",
    "from qiskit.visualization import array_to_latex\n",
    "\n",
    "# import state-vector and random state-vector from\n",
    "# IBM's Qiskit quantum information module\n",
    "from qiskit.quantum_info import Statevector, random_statevector\n",
    "\n",
    "# import abstract operator and pauli operator from\n",
    "# IBM's Qiskit quantum information's operators module\n",
    "from qiskit.quantum_info.operators import Operator, Pauli\n",
    "\n",
    "# import quantum circuit from IBM's Qiskit\n",
    "from qiskit import QuantumCircuit\n",
    "\n",
    "# import hadamard gate and CX/CNOT gate from IBM's Qiskit\n",
    "from qiskit.circuit.library import HGate, CXGate\n",
    "\n",
    "# import numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "742da035",
   "metadata": {},
   "source": [
    "## Vectors and Dirac Notation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "808ec86f",
   "metadata": {},
   "source": [
    "In the lectures you learned different ways of representing quantum states, including how to use Bra-Ket (Dirac) notation.\n",
    "\n",
    "Although Bra-Ket notation cannot be represented exactly in code, we can represent their vector and matrix equivalent with Python.\n",
    "\n",
    "For example, we can represent $|0\\rangle$ using a Python list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b93989c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the column-vector for |0>\n",
    "ket0 = [[1],[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34428069",
   "metadata": {},
   "source": [
    "And we can use one of IBM's Qiskit visualisation tools to make our vectors nicer to look at:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ee9b7eb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1  \\\\\n",
       " 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert the column-vector |0> to latex\n",
    "array_to_latex(ket0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a61be47b",
   "metadata": {},
   "source": [
    "We can do the same with $\\langle0|$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "25f9ff7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define the row-vector for <0|\n",
    "bra0 = [1, 0]\n",
    "\n",
    "# convert the row-vector <0| to latex\n",
    "array_to_latex(bra0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cc359db",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 1 - Create the state-vectors $|1\\rangle$ and $\\langle1|$ with Python lists. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "59a7be22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# put your answer answer here for the column-vector |1>\n",
    "ket1 = [ [0], [1] ]\n",
    "\n",
    "# put your answer here for the row-vector <1|\n",
    "bra1 = [0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "dcc474ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 1 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex1 \n",
    "\n",
    "# grade the exercise 1 of the lab 1\n",
    "grade_lab1_ex1([ket1, bra1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21b44ec9",
   "metadata": {},
   "source": [
    "## Qiskit `Statevector` Class\n",
    "\n",
    "In the lectures you learned about using state vectors to represent quantum states. You can represent quantum state vectors in code using IBM's Qiskit [`Statevector` class](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.html).\n",
    "\n",
    "IBM's Qiskit `Statevector` class can take different forms of input (e.g. Python list, Numpy array, another state vector) to construct a state vector.\n",
    "\n",
    "Let's take the `bra0` object we created earlier and convert it to a `Statevector` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3ac7420a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector([1.+0.j, 0.+0.j],\n",
      "            dims=(2,))\n"
     ]
    }
   ],
   "source": [
    "# create a state-vector for the row-vector <0|\n",
    "sv_bra0 = Statevector(bra0)\n",
    "\n",
    "# show the object of the state-vector for the row-vector <0|\n",
    "sv_bra0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d3015ec",
   "metadata": {},
   "source": [
    "The `Statevector` class has its own `draw()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c7d0a57c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ |0\\rangle$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# draw the state-vector for the row-vector <0| in latex\n",
    "sv_bra0.draw(\"latex\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a443d7b",
   "metadata": {},
   "source": [
    "We can create more complex statevectors with multiple qubits like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dc70f9c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{2} |00\\rangle+\\frac{3}{4} |01\\rangle+\\frac{4}{5} |10\\rangle+\\frac{3}{4} |11\\rangle$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a complex state-vector for multiple qubits \n",
    "sv_eq = Statevector( [ 1/2, 3/4, 4/5, 6/8 ] )\n",
    "\n",
    "# draw the complex state-vector created before in latex\n",
    "sv_eq.draw(\"latex\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7e00788",
   "metadata": {},
   "source": [
    "Note that the vector above is not a valid state vector as it is not normalised. \n",
    "We can check this with the `is_valid()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8459bf73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if the complex state-vector created before\n",
    "# is valid for a quantum state (i.e., if it is normalised)\n",
    "sv_eq.is_valid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4b83945",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 2 - Create your own valid statevector object using the `Statevector` class. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "02cfaf2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create your valid statevector here\n",
    "sv_valid = Statevector( [ 1/2, 1/2, 1/2, 1/2 ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ed497a1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 2 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex2 \n",
    "\n",
    "# grade the exercise 2 of the lab 1\n",
    "grade_lab1_ex2(sv_valid)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3faad35b",
   "metadata": {},
   "source": [
    "## IBM's Qiskit `Operator` Class\n",
    "\n",
    "The [`Operator` class](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Operator.html#qiskit.quantum_info.Operator) is used in IBM's Qiskit to represent matrix operators acting on a quantum system. It has several methods to build composite operators using tensor products of smaller operators, and to compose operators.\n",
    "\n",
    "One way we can initialise an IBM's Qiskit `Operator` is by using a Python list, like the one we created earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "180a544f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Operator([1.+0.j, 0.+0.j],\n",
       "         input_dims=(), output_dims=(2,))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create an operator for the row-vector <0|\n",
    "op_bra0 = Operator(bra0)\n",
    "\n",
    "# show the object of the operator for the row-vector <0|\n",
    "op_bra0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc578df9",
   "metadata": {},
   "source": [
    "The Operator class comes with some handy methods for working with operators, for example we can find the tensor product of 2 operators by using the `tensor()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7aed9441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Operator([[1.+0.j, 0.+0.j],\n",
       "          [0.+0.j, 0.+0.j]],\n",
       "         input_dims=(), output_dims=(2, 2))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create an operator for the column-vector |0>\n",
    "op_ket0 = Operator(ket0)\n",
    "\n",
    "# apply the tensor product of the operator\n",
    "# created before to the operator applied to\n",
    "# the row-vector <0|\n",
    "op_bra0.tensor(op_ket0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e244f5a0",
   "metadata": {},
   "source": [
    "We'll use the `Operator` and `Statevector` classes more in the following exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "208cf2b6",
   "metadata": {},
   "source": [
    "## Inner & Outer Product\n",
    "\n",
    "In the lectures you covered the concepts of the inner and outer product. We can explore these concepts in code using Numpy methods `.dot()` (the inner product is a generalised form of the dot product) and `.outer()`.\n",
    "\n",
    "For example, we can find the inner product $\\langle0|0\\rangle$ like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cf3cb816",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# compute the inner product between the row-vector <0|\n",
    "# and the column-vector |0>, as a bra-ket product <0|0>\n",
    "# note: this operator is also used to check if\n",
    "#       two pure quantum states overlap (i.e., are equal)\n",
    "braket = np.dot(op_bra0, op_ket0)\n",
    "\n",
    "# convert the result of the inner product\n",
    "# computed before to latex\n",
    "array_to_latex(braket)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5d604d7",
   "metadata": {},
   "source": [
    "And the outer product $|0\\rangle\\langle0|$ like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "73232e3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0  \\\\\n",
       " 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# compute the outer product between the column-vector |0>\n",
    "# and the column-vector <0|, as a ket-bra product |0><0|\n",
    "ketbra = np.outer(ket0,bra0)\n",
    "\n",
    "# convert the result of the outer product\n",
    "# computed before to latex\n",
    "array_to_latex(ketbra)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdca2a30",
   "metadata": {},
   "source": [
    "Note: The Numpy methods we used above work with IBM's Qiskit Operators as well as regular Python lists."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dc9ed02",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 3 - Use Numpy to find the result of the following inner and outer products:<br>\n",
    "    <p> &#8226; $\\langle1|0\\rangle$, $\\langle0|1\\rangle$, $\\langle1|1\\rangle$, $|1\\rangle\\langle0|$, $|0\\rangle\\langle1|$, and $|1\\rangle\\langle1|$. </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "72e1bb34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# definition of the operators for the row-vectors (bra vectors)\n",
    "# <0| and <1|, and the column-vectors (ket vectors) |0> and |1>\n",
    "op_bra0 = Operator(bra0)\n",
    "op_bra1 = Operator(bra1)\n",
    "op_ket0 = Operator(ket0)\n",
    "op_ket1 = Operator(ket1)\n",
    "\n",
    "\n",
    "# definition of the inner products (bra-ket products)\n",
    "\n",
    "# put your answer for the inner product\n",
    "# (bra-ket product) <1|0> here\n",
    "bra1ket0 = np.dot(op_bra1, op_ket0)\n",
    "\n",
    "# put your answer for the inner product\n",
    "# (bra-ket product) <0|1> here\n",
    "bra0ket1 = np.dot(op_bra0, op_ket1)\n",
    "\n",
    "# put your answer for the inner product\n",
    "# (bra-ket product) <1|1> here\n",
    "bra1ket1 = np.dot(op_bra1, op_ket1)\n",
    "\n",
    "\n",
    "# definition of the outer products (ket-bra products)\n",
    "\n",
    "# put your answer for the outer product\n",
    "# (ket-bra product) |1><0| here\n",
    "ket1bra0 = np.outer(op_ket1, op_bra0)\n",
    "\n",
    "# put your answer for the outer product\n",
    "# (ket-bra product) |0><1| here\n",
    "ket0bra1 = np.outer(op_ket0, op_bra1)\n",
    "\n",
    "# put your answer for the outer product\n",
    "# (ket-bra product) |1><1| here\n",
    "ket1bra1 = np.outer(op_ket1, op_bra1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "37b9cf70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 3 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex3 \n",
    "\n",
    "# grade the exercise 3 of the lab 1\n",
    "grade_lab1_ex3( [ bra1ket0, bra0ket1, bra1ket1, ket1bra0, ket0bra1, ket1bra1 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c03e06d",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> \n",
    "    <p> Ex. 4 - When the inner product of 2 quantum states is equal to 0, those states are orthogonal. Which of the following quantum states are orthogonal? </p>\n",
    "    <p>a) $\\vert 0\\rangle$ and $\\vert 1\\rangle$ </p>\n",
    "    <p>b) $\\vert 0\\rangle$ and $\\vert 0\\rangle$ </p>\n",
    "    <p>c) $\\vert 1\\rangle$ and $\\vert 1\\rangle$ </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6e061263",
   "metadata": {},
   "outputs": [],
   "source": [
    "# two quantum states are orthogonal if\n",
    "# they are completely opposite and\n",
    "# never overlap with each other\n",
    "# (i.e., when their inner product is equal to 0)\n",
    "\n",
    "# <0|1> = <1|0> = 0, the quantum states |0> and |1>\n",
    "# never overlap with each other and are completely opposite,\n",
    "# or in other words, they are orthogonal\n",
    "\n",
    "# add or remove your answer from this list\n",
    "answer = [\"a\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "bf314ab5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 4 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex4 \n",
    "\n",
    "# grade the exercise 4 of the lab 1\n",
    "grade_lab1_ex4(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e695b37a",
   "metadata": {},
   "source": [
    "## Deterministic operations\n",
    "\n",
    "As mentioned in the lectures, there are 4 single bit deterministic operations:  \n",
    "* f1 = constant-0  \n",
    "* f2 = identity  \n",
    "* f3 = bit flip / not  \n",
    "* f4 = constant-1\n",
    "\n",
    "$$\n",
    "\\begin{array}{c|c}\n",
    "  a & f_1(a)\\\\\n",
    "  \\hline\n",
    "  0 & 0\\\\\n",
    "  1 & 0\n",
    "\\end{array}\n",
    "\\qquad\n",
    "\\begin{array}{c|c}\n",
    "  a & f_2(a)\\\\\n",
    "  \\hline\n",
    "  0 & 0\\\\\n",
    "  1 & 1\n",
    "\\end{array}\n",
    "\\qquad\n",
    "\\begin{array}{c|c}\n",
    "  a & f_3(a)\\\\\n",
    "  \\hline\n",
    "  0 & 1\\\\\n",
    "  1 & 0\n",
    "\\end{array}\n",
    "\\qquad\n",
    "\\begin{array}{c|c}\n",
    "  a & f_4(a)\\\\\n",
    "  \\hline\n",
    "  0 & 1\\\\\n",
    "  1 & 1\n",
    "\\end{array}\n",
    "$$\n",
    "\n",
    "We can create Qiskit Operators for these 4 operations, by passing their matrix representations as arguments to the `Operator` class.\n",
    "\n",
    "E.g., for constant-0 we can create the corresponding matrix m1 like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8edc4262",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 1  \\\\\n",
       " 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create an operator for a single qubit system defined as\n",
    "# m_1 = [ [1, 1],\n",
    "#         [0, 0] ], which represents the f1 = constant-0\n",
    "#                   deterministic operation\n",
    "m1 = Operator( [ [1, 1], [0, 0] ] )\n",
    "\n",
    "# convert the operator created before to latex\n",
    "array_to_latex(m1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2792a781",
   "metadata": {},
   "source": [
    "And similarly for m3 (for f3 = bit flip / not):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9cc2ff6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1  \\\\\n",
       " 1 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create an operator for a single qubit system defined as\n",
    "# m_3 = [ [0, 1],\n",
    "#         [1, 0] ], which represents the f3 = bit flip / not\n",
    "#                   deterministic operation\n",
    "m3 = Operator( [ [0, 1], [1,0] ] )\n",
    "\n",
    "# convert the operator created before to latex\n",
    "array_to_latex(m3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "765e8f0e",
   "metadata": {},
   "source": [
    "We can also use builtin Python mutliplication operations (e.g. `@`, `.dot`, or `.matmul`) to check the following equation: $ M|a\\rangle = f|a\\rangle $.\n",
    "\n",
    "For example, $ M1|0\\rangle = f1|0\\rangle $ = 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a283a8bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1  \\\\\n",
       " 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# represent in latex the result of applying\n",
    "# the operator m1 to the column-vector (ket vector) |0>\n",
    "array_to_latex(m1@ket0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f044b3f6",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 5 - Create IBM's Qiskit Operators for m2 and m4.<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Hint: Check out the lectures to find the appropriate matrices). </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "31927dfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an operator for a single qubit system defined as\n",
    "# m_2 = [ [1, 0],\n",
    "#         [0, 1] ], which represents the f2 = identity\n",
    "#                   deterministic operation\n",
    "m2 = Operator( [ [1, 0], [0, 1] ] )\n",
    "\n",
    "# create an operator for a single qubit system defined as\n",
    "# m_4 = [ [0, 0],\n",
    "#         [1, 1] ], which represents the f4 = constant-1\n",
    "#                   deterministic operation\n",
    "m4 = Operator( [ [0, 0], [1, 1] ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "62081ac6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 5 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex5\n",
    "\n",
    "# grade the exercise 5 of the lab 1\n",
    "grade_lab1_ex5( [ m2, m4 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d611468d",
   "metadata": {},
   "source": [
    "## Probabilistic operations\n",
    "\n",
    "A Controlled-NOT (or CNOT) operation is a probabilistic operation you can apply on 2 qubits.\n",
    "\n",
    "Applying a CNOT on a state (X,Y) involves performing a NOT operation on Y when X is 1, otherwise do nothing.\n",
    "X is the control bit, Y is the target bit.\n",
    "\n",
    "We can implement a CNOT gate (and many other quantum gates) using a class from [Qiskit's circuit library](https://qiskit.org/documentation/apidoc/circuit_library.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d6aec987",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " 0 & 0 & 0 & 1  \\\\\n",
       " 0 & 0 & 1 & 0  \\\\\n",
       " 0 & 1 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a CX/CNOT quantum gate as an operator\n",
    "cnot = CXGate()\n",
    "\n",
    "# convert the operator created before to latex\n",
    "array_to_latex(cnot)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49ee11bb",
   "metadata": {},
   "source": [
    "Note: This matrix is different from the one that appeared in the lesson because `CXGate()` takes the right qubit to be the control rather than the left qubit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd0665bc",
   "metadata": {},
   "source": [
    "## Unitary Operations\n",
    "\n",
    "An operator is unitary if: $ UU^{\\dagger} = \\mathbb{1} = U^{\\dagger} U$.\n",
    "\n",
    "We can check if an operator is Unitary using IBM's Qiskit with the `is_unitary()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "83e80fd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if the operator for a single qubit system defined as\n",
    "# m_3 = [ [0, 1],\n",
    "#         [1, 0] ], which represents the f3 = bit flip / not\n",
    "#                   deterministic operation, is unitary\n",
    "m3.is_unitary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef61f742",
   "metadata": {},
   "source": [
    "With small operators like m3 we could probably figure this out easily by ourselves, but with more complex operators it becomes more convenient to use the IBM's Qiskit function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "90fa7840",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a random operator for multiple qubit system\n",
    "random = Operator( np.array( \n",
    "    [ [  0.50778085 - 0.44607116j, -0.1523741  + 0.14128434j, \n",
    "         0.44607116 + 0.50778085j, -0.14128434 - 0.1523741j  ],\n",
    "      [  0.16855994 + 0.12151822j,  0.55868196 + 0.38038841j,\n",
    "        -0.12151822 + 0.16855994j, -0.38038841 + 0.55868196j ],\n",
    "      [  0.50778085 - 0.44607116j, -0.1523741  + 0.14128434j,\n",
    "        -0.44607116 - 0.50778085j,  0.14128434 + 0.1523741j  ],\n",
    "      [  0.16855994 + 0.12151822j,  0.55868196 + 0.38038841j,\n",
    "         0.12151822 - 0.16855994j,  0.38038841-0.55868196j ] ] ) )\n",
    "\n",
    "# check if the random operator for multiple qubit system is random\n",
    "random.is_unitary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6778ed6",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 6 - Create an operator using the `Operator` class that is not unitary. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c43f5bbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create your non-unitary operator here\n",
    "non_unitary_op = Operator( [ [1, 0], [1, 1] ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c159e466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 6 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex6\n",
    "\n",
    "# grade the exercise 6 of the lab 1\n",
    "grade_lab1_ex6(non_unitary_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "220179f8",
   "metadata": {},
   "source": [
    "### Qubit Unitary Operations - Pauli Operations\n",
    "\n",
    "Some of the most common unitary operations in quantum computing are the Pauli operations. IBM's Qiskit `Pauli` classes make it easy to interact with Pauli operators in code:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c5fec2",
   "metadata": {},
   "source": [
    "For example, Pauli X ($\\sigma_x$), the bit flip:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "290462f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1  \\\\\n",
       " 1 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create the Pauli-X (bit flip / not) quantum gate\n",
    "pauli_x = Pauli(\"X\")\n",
    "\n",
    "# convert the quantum gate created before to latex\n",
    "array_to_latex(pauli_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff2d5d30",
   "metadata": {},
   "source": [
    "For Pauli Y ($\\sigma_y$):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "21b32f55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & - i  \\\\\n",
       " i & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create the Pauli-Y quantum gate\n",
    "pauli_y = Pauli(\"Y\")\n",
    "\n",
    "# convert the quantum gate created before to latex\n",
    "array_to_latex(pauli_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9850043",
   "metadata": {},
   "source": [
    "For Pauli Z ($\\sigma_z$), the phase flip:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "9df1dff2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0  \\\\\n",
       " 0 & -1  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create the Pauli-Z (phase flip) quantum gate\n",
    "pauli_z = Pauli(\"Z\")\n",
    "\n",
    "# convert the quantum gate created before to latex\n",
    "array_to_latex(pauli_z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdfa41f0",
   "metadata": {},
   "source": [
    "We can use the `Operator` class with the `Pauli` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "71eb657f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Operator([[0.+0.j, 1.+0.j],\n",
       "          [1.+0.j, 0.+0.j]],\n",
       "         input_dims=(2,), output_dims=(2,))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert the Pauli-X (bit flip / not)\n",
    "# quantum gate to an operator\n",
    "op_x = Operator(pauli_x)\n",
    "\n",
    "# show the Pauli-X (bit flip / not)\n",
    "# quantum gate converted to an operator\n",
    "op_x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22a1dc55",
   "metadata": {},
   "source": [
    "Let's use the `Operator` class and Numpy to find the outcome of $\\sigma_x|0\\rangle$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a3b46f65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0  \\\\\n",
       " 1  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# apply the inner product between the Pauli-X (bit flip / not) operator\n",
    "# the quantum state of the column-vector (ket vector) |0>, resulting to\n",
    "# a new quantum state of the column-vector (ket vector) |1>\n",
    "op_new = np.dot(op_x ,ket0)\n",
    "\n",
    "# convert the resulting new operator to latex\n",
    "array_to_latex(op_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0434735a",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 7 - Apply the Pauli-Z operator on $|1\\rangle$. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "11ea5267",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0  \\\\\n",
       " -1  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# do your operations here\n",
    "\n",
    "# convert the Pauli-Z (phase flip)\n",
    "# quantum gate to an operator\n",
    "op_z = Operator(pauli_z)\n",
    "\n",
    "# apply the inner product between the Pauli-Z (phase flip) operator\n",
    "# the quantum state of the column-vector (ket vector) |1>, resulting to\n",
    "# a new quantum state of the column-vector (ket vector) -|1>\n",
    "result = np.dot(op_z ,ket1)\n",
    "\n",
    "# convert the resulting new operator to latex\n",
    "array_to_latex(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "694825bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 7 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex7\n",
    "\n",
    "# grade the exercise 7 of the lab 1\n",
    "grade_lab1_ex7(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "677ab1ec",
   "metadata": {},
   "source": [
    "### Qubit Unitary Operations - Hadamard\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa9f846",
   "metadata": {},
   "source": [
    "The Hadamard gate is one of the most important unitary operations in quantum computing. We can implement a Hadamard gate (and many other quantum gates) using a class from [IBM's Qiskit circuit library](https://qiskit.org/documentation/apidoc/circuit_library.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "74251a81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}  \\\\\n",
       " \\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create the Hadamard quantum gate\n",
    "hadamard = HGate()\n",
    "\n",
    "# convert the quantum gate created before to latex\n",
    "array_to_latex(hadamard)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08b41da3",
   "metadata": {},
   "source": [
    "You can convert many IBM's Qiskit classes to operators to make use of functions specific to the `Operator` class, such as `is_unitary`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "ebc2f8df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operator([[ 0.70710678+0.j,  0.70710678+0.j],\n",
      "          [ 0.70710678+0.j, -0.70710678+0.j]],\n",
      "         input_dims=(2,), output_dims=(2,))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert the Hadamard quantum gate to an operator\n",
    "op_h = Operator(hadamard)\n",
    "\n",
    "# show the Hadamard quantum gate\n",
    "# converted to an operator\n",
    "print(op_h)\n",
    "\n",
    "# check if the Hadamard quantum gate\n",
    "# converted to an operator is unitary\n",
    "op_h.is_unitary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa5207cc",
   "metadata": {},
   "source": [
    "## Quantum Circuits\n",
    "\n",
    "In the lectures you learned how to create a Quantum Circuit using a CNOT and a Hadamard gate. This circuit creates the Bell State $|\\phi^+\\rangle$. We can implement this using IBM's Qiskit `QuantumCircuit` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c1b3e5a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a quantum circuit for two qubits\n",
    "# and to implement a Bell state\n",
    "bell = QuantumCircuit(2)\n",
    "\n",
    "# apply a Hadamard gate to\n",
    "# the 1st qubit of the quantum circuit\n",
    "bell.h(0)\n",
    "\n",
    "# apply a CX/CNOT gate to\n",
    "# the 1st and 2nd qubits of the quantum circuit\n",
    "bell.cx(0, 1)\n",
    "\n",
    "# draw the quantum circuit implementing the Bell state\n",
    "bell.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b2a93c8",
   "metadata": {},
   "source": [
    "If we want to check what the matrix representation is of this quantum state we can convert the circuit directly to an operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ac8dab7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2} & 0 & 0  \\\\\n",
       " 0 & 0 & \\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}  \\\\\n",
       " 0 & 0 & \\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}  \\\\\n",
       " \\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2} & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# converting the quantum circuit\n",
    "# implementing the Bell state to an operator\n",
    "bell_op = Operator(bell)\n",
    "\n",
    "# convert the quantum operator representing\n",
    "# the quantum circuit created before to latex\n",
    "array_to_latex(bell_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2487769",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 8 - The GHZ state is similar to the Bell State but applied to 3 qubits. Create a quantum circuit outputting the GHZ state. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f7469f9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 371.107x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a quantum circuit for three qubits\n",
    "# and to implement a GHZ state\n",
    "ghz = QuantumCircuit(3)\n",
    "\n",
    "##############################\n",
    "\n",
    "# add gates to your quantum circuit here\n",
    "\n",
    "# apply a Hadamard gate to\n",
    "# the quantum circuit, on the 1st qubit\n",
    "ghz.h(0)\n",
    "\n",
    "# apply a CX/CNOT gate to\n",
    "# the quantum circuit,\n",
    "# with control on 1st qubit\n",
    "# and target on 2nd qubit\n",
    "ghz.cx(0, 1)\n",
    "\n",
    "# apply a CX/CNOT gate to\n",
    "# the quantum circuit,\n",
    "# with control on 2nd qubit\n",
    "# and target on 3rd qubit\n",
    "ghz.cx(1, 2)\n",
    "\n",
    "##############################\n",
    "\n",
    "# draw the quantum circuit implementing the GHZ state\n",
    "ghz.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ffb9113c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 8 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex8\n",
    "\n",
    "# grade the exercise 8 of the lab 1\n",
    "grade_lab1_ex8(ghz)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dec5eb53",
   "metadata": {},
   "source": [
    "## Measuring Quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d05a3cb",
   "metadata": {},
   "source": [
    "As explained in the lectures you can find the probability of measurement outcomes by taking the absolute value squared of the entries of a quantum state vector.\n",
    "\n",
    "For example, when measuring the + state:  \n",
    "\n",
    "$ |+\\rangle = \\frac{1}{\\sqrt2}|0\\rangle + \\frac{1}{\\sqrt2}|1\\rangle $\n",
    "\n",
    "The probability of measuring 0 or 1 is given by the following:\n",
    "\n",
    "$ Pr(0) = |\\frac{1}{\\sqrt2}|^2 = \\frac{1}{2}$  \n",
    "$ Pr(1) = |\\frac{1}{\\sqrt2}|^2 = \\frac{1}{2}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09b17e63",
   "metadata": {},
   "source": [
    "Let's create a $|+\\rangle$ using the `Statevector` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "819fdc56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{\\sqrt{2}}{2} |0\\rangle+\\frac{\\sqrt{2}}{2} |1\\rangle$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create the state-vector for\n",
    "# the quantum superposition state |+>\n",
    "plus_state = Statevector.from_label(\"+\")\n",
    "\n",
    "# convert the state-vector created before to latex\n",
    "plus_state.draw(\"latex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4c7849e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector([0.70710678+0.j, 0.70710678+0.j],\n",
      "            dims=(2,))\n"
     ]
    }
   ],
   "source": [
    "# show the state-vector |+> created before\n",
    "plus_state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9367460",
   "metadata": {},
   "source": [
    "Now we can get the probability of measuring 0 or 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "4b954ae3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': 0.4999999999999999, '1': 0.4999999999999999}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show the probabilities of the possible\n",
    "# classical outcomes/states resulting \n",
    "# from measuring the quantum superposition state |+>\n",
    "plus_state.probabilities_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62b9c13c",
   "metadata": {},
   "source": [
    "The dictionary object above shows you all the possible measurement outcomes and what the probability is of getting them. The actual act of measuring forces the state to collapse into either the 0 or 1 state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "546166ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('1', Statevector([0.+0.j, 1.+0.j],\n",
      "            dims=(2,)))\n",
      "('1', Statevector([0.+0.j, 1.+0.j],\n",
      "            dims=(2,)))\n",
      "('0', Statevector([1.+0.j, 0.+0.j],\n",
      "            dims=(2,)))\n",
      "('0', Statevector([1.+0.j, 0.+0.j],\n",
      "            dims=(2,)))\n",
      "('1', Statevector([0.+0.j, 1.+0.j],\n",
      "            dims=(2,)))\n"
     ]
    }
   ],
   "source": [
    "# run this cell multiple times to show collapsing\n",
    "# into one state or the other (i.e., 0 or 1)\n",
    "\n",
    "# for a number of trials equal to 5\n",
    "for _ in range(5):\n",
    "    \n",
    "    # measure the quantum superposition state |+>\n",
    "    res = plus_state.measure()\n",
    "    \n",
    "    # print the result of the measurement of\n",
    "    # the quantum superposition state |+>\n",
    "    print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbf9efbb",
   "metadata": {},
   "source": [
    "We can implement the same $|+\\rangle$ state with measurement using a quantum circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6af8a51d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 269.064x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a quantum circuit for one qubit and one bit,\n",
    "# to implement a |+> quantum superposition state\n",
    "qc = QuantumCircuit(1, 1)\n",
    "\n",
    "# apply a Hadamard gate to\n",
    "# the quantum circuit, on the 1st qubit\n",
    "qc.h(0)\n",
    "\n",
    "# measure the 1st qubit of the quantum circuit\n",
    "# to the respective 1st bit of the same\n",
    "qc.measure(0, 0)\n",
    "\n",
    "# draw the quantum circuit for one qubit and one bit,\n",
    "# implementing a |+> quantum superposition state\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e3a739",
   "metadata": {},
   "source": [
    "If we ran this circuit using a simulator we would get the same results as we did with the statevector class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3abea6e",
   "metadata": {},
   "source": [
    "In the next example, let's use the `Statevector` class to find the measurement outcomes for a dependent, probabilistic state. We'll find the measurement probilities for the 2-qubit Bell State $|\\phi^+\\rangle$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f0c6e31d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{\\sqrt{2}}{2} |00\\rangle+\\frac{\\sqrt{2}}{2} |11\\rangle$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create the state-vector for the Bell State |phi^+>\n",
    "sv_bell = Statevector( [ np.sqrt(1 / 2), 0, 0, np.sqrt(1 / 2) ] )\n",
    "\n",
    "# draw the state-vector for the Bell State |phi^+>\n",
    "sv_bell.draw(\"latex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "60aca301",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'00': 0.5000000000000001, '11': 0.5000000000000001}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sv_bell.probabilities_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "734489ba",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 9 - Using the Statevector class find the probabilities for the other 3 states in the Bell Basis: $|\\psi^+\\rangle$, $|\\psi^-\\rangle$, $|\\phi^-\\rangle$.<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Hint: Check out lesson 2 to refresh your memory on the equations of the Bell states). </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "119714dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creation of the three quantum states in the Bell basis,\n",
    "# namely, |psi^+⟩, |psi^-⟩, and |phi^-⟩\n",
    "\n",
    "# create a statevector for |psi^+⟩ here\n",
    "sv_psi_plus = Statevector( [ 0, np.sqrt(1 / 2), np.sqrt(1 / 2), 0 ] )\n",
    "\n",
    "# find the measurement probabilities for |psi^+⟩ here\n",
    "prob_psi_plus = sv_psi_plus.probabilities_dict()\n",
    "\n",
    "# create a statevector for |psi^-⟩ here\n",
    "sv_psi_minus = Statevector( [ 0, np.sqrt(1 / 2), -1 * np.sqrt(1 / 2), 0 ] )\n",
    "\n",
    "# find the measurement probabilities for |psi^−⟩ here\n",
    "prob_psi_minus = sv_psi_minus.probabilities_dict()\n",
    "\n",
    "# create a statevector for |phi^-⟩ here\n",
    "sv_phi_minus = Statevector( [ np.sqrt(1 / 2), 0, 0, -1 * np.sqrt(1 / 2) ] )\n",
    "\n",
    "# find the measurement probabilities for |phi^-⟩ here\n",
    "prob_phi_minus = sv_phi_minus.probabilities_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "72585681",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 9 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex9\n",
    "\n",
    "# grade the exercise 9 of the lab 1\n",
    "grade_lab1_ex9([prob_psi_plus, prob_psi_minus, prob_phi_minus])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0faf6184",
   "metadata": {},
   "source": [
    "# Final Challenge - generate a QFT circuit\n",
    "\n",
    "[The Fourier transform](https://en.wikipedia.org/wiki/Fourier_transform) occurs in many different formats throughout classical computing, in areas ranging from signal processing to data compression to complexity theory. The quantum Fourier transform (QFT) is the quantum implementation of the discrete Fourier transform over the amplitudes of a wavefunction. It is part of many quantum algorithms, most notably Shor's factoring algorithm and quantum phase estimation. You'll learn more about this important implementation later on during the Summer School, but for this final challenge of Lab 1 we would like you to use Qiskit to create the following QFT circuit on 2 qubits:\n",
    "\n",
    "![](resources/quantum-fourier-transform.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a06d2b68",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 10 - Create a two-qubit QFT circuit using IBM's Qiskit. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e51049ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 538.128x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a quantum circuit for two qubits,\n",
    "# to implement a quantum fourier transform\n",
    "qft = QuantumCircuit(2)\n",
    "\n",
    "##############################\n",
    "\n",
    "# add gates to your quantum circuit here\n",
    "\n",
    "# apply an Hadamard gate to\n",
    "# the quantum circuit, on the 2nd qubit\n",
    "qft.h(1)\n",
    "\n",
    "# apply a Controlled-Phase (CP) gate to\n",
    "# the quantum circuit acccording to\n",
    "# a theta angle, with control on\n",
    "# the 1st qubit and target on the 2nd qubit\n",
    "qft.cp( np.pi/2, 0, 1 )\n",
    "\n",
    "# apply an Hadamard gate to\n",
    "# the quantum circuit, on the 1st qubit\n",
    "qft.h(0)\n",
    "\n",
    "# apply a SWAP gate to\n",
    "# the quantum circuit,\n",
    "# between the 1st qubit\n",
    "# and the 2nd qubit\n",
    "qft.swap(0, 1)\n",
    "\n",
    "##############################\n",
    "\n",
    "# draw the quantum circuit for two qubits,\n",
    "# implementing a quntum fourier transform\n",
    "qft.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "9ad87edc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# import the grader for the exercise 10 of the lab 1\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab1_ex10\n",
    "\n",
    "# grade the exercise 10 of the lab 1\n",
    "grade_lab1_ex10(qft)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b90a28",
   "metadata": {},
   "source": [
    "To see the matrix that describes the action of this circuit, we can plug the circuit into the `Operator` function like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d83e5f5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "\\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2}  \\\\\n",
       " \\frac{1}{2} & \\frac{i}{2} & - \\frac{1}{2} & - \\frac{i}{2}  \\\\\n",
       " \\frac{1}{2} & - \\frac{1}{2} & \\frac{1}{2} & - \\frac{1}{2}  \\\\\n",
       " \\frac{1}{2} & - \\frac{i}{2} & - \\frac{1}{2} & \\frac{i}{2}  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create an operator U from the quantum circuit of\n",
    "# the quantum fourier transform created before\n",
    "U = Operator(qft)\n",
    "\n",
    "# convert the quantum operator U representing\n",
    "# the quantum circuit created before to latex\n",
    "array_to_latex(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "31e3e448-9ad3-444c-8a80-b2f0a1074d3d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.24.1</td></tr><tr><td><code>qiskit-aer</code></td><td>0.12.1</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.20.2</td></tr><tr><td><code>qiskit</code></td><td>0.43.2</td></tr><tr><td><code>qiskit-nature</code></td><td>0.6.2</td></tr><tr><td><code>qiskit-finance</code></td><td>0.3.4</td></tr><tr><td><code>qiskit-optimization</code></td><td>0.5.0</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.6.1</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.10.8</td></tr><tr><td>Python compiler</td><td>GCC 10.4.0</td></tr><tr><td>Python build</td><td>main, Nov 22 2022 08:26:04</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>31.211322784423828</td></tr><tr><td colspan='2'>Tue Aug 01 11:52:22 2023 UTC</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import the IBM's Qiskit Jupyter Tools\n",
    "import qiskit.tools.jupyter\n",
    "\n",
    "# show the table of the IBM's Qiskit version\n",
    "%qiskit_version_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c1ec931",
   "metadata": {},
   "source": [
    "Congratulations! You finished Lab 1 of the IBM's Qiskit Global Summer School 2023! 🎉 🎉 🎉"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8182d5d9-e5c8-4c09-b1f8-f8529e7248e0",
   "metadata": {},
   "source": [
    "Made with ❤ by Rúben André Barreiro (and adapted from IBM Quantum)."
   ]
  }
 ],
 "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.10.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "0e32ae3cce324e978446eb4e024aee68": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "70px"
      }
     },
     "1bb3652ec1b64368aff96a40829441bc": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "190px"
      }
     },
     "2245267536b842dcaf4e8cc97b04e8d9": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ButtonStyleModel",
      "state": {
       "font_family": null,
       "font_size": null,
       "font_style": null,
       "font_variant": null,
       "font_weight": null,
       "text_color": null,
       "text_decoration": null
      }
     },
     "2390b3ba310d483fa7195b12e0a2a421": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_1bb3652ec1b64368aff96a40829441bc",
       "style": "IPY_MODEL_ea0b2f963397409a9db189eeab40b3f8",
       "value": "<h5>Job ID</h5>"
      }
     },
     "3ad12c0a043c493498d12697747f7297": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_2390b3ba310d483fa7195b12e0a2a421",
        "IPY_MODEL_ee230a78189f4ce08182f1dfb9f9d892",
        "IPY_MODEL_79ff38ea254e469b96e7d404b2f609e4",
        "IPY_MODEL_be503e4d77e740afac329bce7edbb027",
        "IPY_MODEL_5e70e9d9092a4b69903525e7c9f548e6"
       ],
       "layout": "IPY_MODEL_6a3994cf66af45de9b65b10e29ef5d22"
      }
     },
     "3e4df31f160f4011bff9c36261daa329": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "5e70e9d9092a4b69903525e7c9f548e6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_6cbeacc087a94a42bf256427e050ad42",
       "style": "IPY_MODEL_f6ea79fdf34f4a4aa5762cfb5d896bc7",
       "value": "<h5>Message</h5>"
      }
     },
     "68c7d166b32344da90ca38e5bcd6cd9b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "right",
       "padding": "0px 0px 0px 0px",
       "width": "70px"
      }
     },
     "6a3994cf66af45de9b65b10e29ef5d22": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "margin": "0px 0px 0px 37px",
       "width": "600px"
      }
     },
     "6cbeacc087a94a42bf256427e050ad42": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "7427e3c3042f4c61b0d83030caad7ba9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_template_areas": "\n                                       \". . . . right \"\n                                        ",
       "grid_template_columns": "20% 20% 20% 20% 20%",
       "width": "100%"
      }
     },
     "79ff38ea254e469b96e7d404b2f609e4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_a7283709f93246498b793c61deeded70",
       "style": "IPY_MODEL_ce7c36d892d44d3e80e08fb2cc847d6a",
       "value": "<h5>Status</h5>"
      }
     },
     "7cc1129f7e564589af4a795433d846d5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "7deb184e015d49cf8e6d7f4d95d80a49": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "primary",
       "description": "Clear",
       "layout": "IPY_MODEL_68c7d166b32344da90ca38e5bcd6cd9b",
       "style": "IPY_MODEL_2245267536b842dcaf4e8cc97b04e8d9",
       "tooltip": null
      }
     },
     "7fa8bd74292145bf869ea0c0788c093e": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "145px"
      }
     },
     "98625d1aef8244e3a1e6ff0a4148a3ea": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_dfe66c39bbdb4fc5921bab0669cd4d4d",
       "style": "IPY_MODEL_3e4df31f160f4011bff9c36261daa329",
       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
      }
     },
     "a7283709f93246498b793c61deeded70": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "95px"
      }
     },
     "be503e4d77e740afac329bce7edbb027": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_0e32ae3cce324e978446eb4e024aee68",
       "style": "IPY_MODEL_cf931076717649a892e3c2f40d570796",
       "value": "<h5>Queue</h5>"
      }
     },
     "ce7c36d892d44d3e80e08fb2cc847d6a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "cf931076717649a892e3c2f40d570796": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "dfe66c39bbdb4fc5921bab0669cd4d4d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "margin": "0px 0px 10px 0px"
      }
     },
     "ea0b2f963397409a9db189eeab40b3f8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "ee230a78189f4ce08182f1dfb9f9d892": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_7fa8bd74292145bf869ea0c0788c093e",
       "style": "IPY_MODEL_7cc1129f7e564589af4a795433d846d5",
       "value": "<h5>Backend</h5>"
      }
     },
     "f546f0813cec448fae34bcc160ac21b3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "GridBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_7deb184e015d49cf8e6d7f4d95d80a49"
       ],
       "layout": "IPY_MODEL_7427e3c3042f4c61b0d83030caad7ba9"
      }
     },
     "f6ea79fdf34f4a4aa5762cfb5d896bc7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}