quantum-deutsch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26296214-2240-4bff-b710-b69d32fc4aac",
   "metadata": {},
   "source": [
    "# What is Quantum Computing\n",
    "\n",
    "***\n",
    "\n",
    "It is a type of computing that utilises properties of quantum states such as superposition, entanglement and interference to perform it's calculations.\n",
    "Quantum computers process information in a fundementally different way to classical computing. Classical computers require transistors, which can be used to either represent '1' or '0' but quantum computers use qubits, which can represent 0 and 1 at the same time.\n",
    "- Quantum computers increase exponentially in power by the amount of qubits linked together.\n",
    "- Unlike classical computers which only increase in direction proprotion to the number of transistors <br>\n",
    "\n",
    "A quantum circuit is a computational routine consisting of coherent quantum operations <br>\n",
    "<img src=\"circuit.png\" width=\"600\"> <br>\n",
    "\n",
    "#### *Initialization and reset*\n",
    "- First we need to start our quantum computer with well definied quantum states. We accomplish this with the initialization and reset operations\n",
    "- The resets can be performed by single-qubit gates and real-time classical computation.\n",
    "    - they monitor whether we have achieved the desired state\n",
    "- The initialization of q0 into a desired state  |ψ⟩ can then follow by applying single-qubit gates\n",
    "\n",
    "#### *Quantum gates*\n",
    "- We apply a sequence of quantum gates that manipulate the three qubits\n",
    "\n",
    "#### *Measurements*\n",
    "- We measure two of the three qubits\n",
    "- A classical computer interprets these qubits as either 1 or 0 and then stores them\n",
    "\n",
    "#### *Classically condition quantum gates*\n",
    "- We apply single-qubit Z and X quantum gates on the third qubit\n",
    "- These gates are conditioned on the results of the measurements stored in the two classical bits\n",
    "\n",
    "### What do we need it for\n",
    "- Quantum computers can solve complex problems which be used by business or to discover new technologies\n",
    "- It would be able to simulate on a molecular level which would help pharmaceutical companies with making new drugs\n",
    "- Current applications of quantum computing at the moment are searching for the Higgs event and origins of the universe\n",
    "- Quantum computers are drastically fast compared to classical compueters\n",
    "    - to search for a list containing 1 trillion items would require a classical computer a week, a quantum computer only one second\n",
    "<br> <br>\n",
    "\n",
    "\n",
    "## What is classical computing\n",
    "\n",
    "***\n",
    "\n",
    "- They require transistors which can either be on or off\n",
    "- This information is stored in bits which are represented by either '1' or '0' <br>\n",
    "\n",
    "Classical computers can outperform quantum computers in practical applications. Although quantum computers are believed to be able to solve certain complex problems such as interger factorization which would underline encryption or manipulate the blockchain and underline certain cryptocurrencies.\n",
    "Here is a comparison of the two. <br>\n",
    "\n",
    "| Quantum Computing | Classical Computing |\n",
    "|------|------|\n",
    "| Based on the phenomenon of quantum mechanics where it is possible to be in more than one state at a time | Based on the classical phenomenon of electrical circuit being in a single state at a time |\n",
    "| Used by large scale \n",
    "| Information storage is based on a Quantum Bit or qubit | Information storage is based on a bit |\n",
    "| A bit can be 1 or 0 at the same time | A bit can only be 1 or 0 |\n",
    "| Circuit behaviour is governed by quantum physics | Circuit behaviour is governed by classical physics |\n",
    "| SQUID or quantum transistors are the basic building blocks of classic computers | CMOS transistors are the basic building blocks of classical computers |\n",
    "| Data processing is done in the Quantum Processing Unit (QPU) | Data processing is done in the Central Processing Unit (CPU) |\n",
    "| Operations are defined by Linear Algebra over Hilbert space | Operations are defined by Boolean Algebra |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4db91628-f709-4739-b375-02cb5144e7f0",
   "metadata": {
    "tags": []
   },
   "source": [
    "# The Deutsch-Jozsa Algorithm\n",
    "\n",
    "[Official Website](https://qiskit.org/textbook/ch-algorithms/deutsch-jozsa.html)\n",
    "\n",
    "***\n",
    "\n",
    "The Deutsch-Jozsa Algorithm, was the first example of a quantum algorithm performing better than the best classical algorithm. <br>\n",
    "It showed that there can be advantages to using quantum computing as a computational tool for a specific problem. <br>\n",
    "\n",
    "We will now implement the Deutsch-Jozsa algorithm for the example of a three-bit function. With both constant and balanced oracles\n",
    "#### Code Below\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a6d1724e-8f4d-4b54-9721-fde902f5be9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import numpy as np\n",
    "# Qiskit \n",
    "import qiskit\n",
    "# Aer simulator\n",
    "import qiskit.providers.aer as aer\n",
    "# Visualisation\n",
    "from qiskit.visualization import plot_histogram\n",
    "import matplotlib.pyplot as plt\n",
    "# Changing pyplot style\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b6d95015-89fb-41eb-acae-7d89ead1f604",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting the length of the input register for our oracle\n",
    "n = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fbd5639b-8d39-4359-b008-2e853b31c3ca",
   "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: \n",
       "     \n",
       "q_1: \n",
       "     \n",
       "q_2: \n",
       "     \n",
       "q_3: \n",
       "     </pre>"
      ],
      "text/plain": [
       "     \n",
       "q_0: \n",
       "     \n",
       "q_1: \n",
       "     \n",
       "q_2: \n",
       "     \n",
       "q_3: \n",
       "     "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Constant Oracle\n",
    "constant_oracle = qiskit.QuantumCircuit(n + 1)\n",
    "\n",
    "output = np.random.randint(2)\n",
    "if output == 1:\n",
    "    constant_oracle.x(n)\n",
    "\n",
    "constant_oracle.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1a2bb094-5222-4663-a2b6-cb36dc66cc65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐\n",
       "q_0: ┤ X ├\n",
       "     └───┘\n",
       "q_1: ─────\n",
       "     ┌───┐\n",
       "q_2: ┤ X ├\n",
       "     └───┘\n",
       "q_3: ─────\n",
       "          </pre>"
      ],
      "text/plain": [
       "     ┌───┐\n",
       "q_0: ┤ X ├\n",
       "     └───┘\n",
       "q_1: ─────\n",
       "     ┌───┐\n",
       "q_2: ┤ X ├\n",
       "     └───┘\n",
       "q_3: ─────\n",
       "          "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Balanced Oracle\n",
    "balanced_oracle = qiskit.QuantumCircuit(n + 1)\n",
    "# For every qubit we place an X-gate if the corresponding digit is 1\n",
    "balanced_string = '101'\n",
    "\n",
    "# Placing X-gates\n",
    "for qubit in range(len(balanced_string)):\n",
    "    if balanced_string[qubit] == '1':\n",
    "        balanced_oracle.x(qubit)\n",
    "balanced_oracle.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "30cc4e05-13cb-4b8f-b58a-b3aad222a654",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐ ░                 ░ \n",
       "q_0: ┤ X ├─░───■─────────────░─\n",
       "     └───┘ ░   │             ░ \n",
       "q_1: ──────░───┼────■────────░─\n",
       "     ┌───┐ ░   │    │        ░ \n",
       "q_2: ┤ X ├─░───┼────┼────■───░─\n",
       "     └───┘ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ \n",
       "q_3: ──────░─┤ X ├┤ X ├┤ X ├─░─\n",
       "           ░ └───┘└───┘└───┘ ░ </pre>"
      ],
      "text/plain": [
       "     ┌───┐ ░                 ░ \n",
       "q_0: ┤ X ├─░───■─────────────░─\n",
       "     └───┘ ░   │             ░ \n",
       "q_1: ──────░───┼────■────────░─\n",
       "     ┌───┐ ░   │    │        ░ \n",
       "q_2: ┤ X ├─░───┼────┼────■───░─\n",
       "     └───┘ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ \n",
       "q_3: ──────░─┤ X ├┤ X ├┤ X ├─░─\n",
       "           ░ └───┘└───┘└───┘ ░ "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Next we do Controlled-NOT gates, using each input qubit as a control, and the output qubit as a target\n",
    "\n",
    "# Using barrier as divider\n",
    "balanced_oracle.barrier()\n",
    "# Controlled-NOT gates\n",
    "for qubit in range(n):\n",
    "    balanced_oracle.cx(qubit, n)\n",
    "\n",
    "balanced_oracle.barrier()\n",
    "balanced_oracle.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0cfdf840-a88a-4f2a-b7b7-271fae140b89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐ ░                 ░ ┌───┐\n",
       "q_0: ┤ X ├─░───■─────────────░─┤ X ├\n",
       "     └───┘ ░   │             ░ └───┘\n",
       "q_1: ──────░───┼────■────────░──────\n",
       "     ┌───┐ ░   │    │        ░ ┌───┐\n",
       "q_2: ┤ X ├─░───┼────┼────■───░─┤ X ├\n",
       "     └───┘ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘\n",
       "q_3: ──────░─┤ X ├┤ X ├┤ X ├─░──────\n",
       "           ░ └───┘└───┘└───┘ ░      </pre>"
      ],
      "text/plain": [
       "     ┌───┐ ░                 ░ ┌───┐\n",
       "q_0: ┤ X ├─░───■─────────────░─┤ X ├\n",
       "     └───┘ ░   │             ░ └───┘\n",
       "q_1: ──────░───┼────■────────░──────\n",
       "     ┌───┐ ░   │    │        ░ ┌───┐\n",
       "q_2: ┤ X ├─░───┼────┼────■───░─┤ X ├\n",
       "     └───┘ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘\n",
       "q_3: ──────░─┤ X ├┤ X ├┤ X ├─░──────\n",
       "           ░ └───┘└───┘└───┘ ░      "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To finish up the balanced oracle we place X-gates after the barrier\n",
    "for qubit in range(len(balanced_string)):\n",
    "    if balanced_string[qubit] == '1':\n",
    "        balanced_oracle.x(qubit)\n",
    "balanced_oracle.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c133f974-c7c1-43ab-ac34-430cb18d994e",
   "metadata": {},
   "source": [
    "We have just created a balanced oracle. <br>\n",
    "Now to see if Deutsch-Jozsa algorithm can solve it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c1bdfb1f-e65b-4d4f-87c7-6bc8c2a600ac",
   "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: ┤ H ├─────\n",
       "     ├───┤     \n",
       "q_1: ┤ H ├─────\n",
       "     ├───┤     \n",
       "q_2: ┤ H ├─────\n",
       "     ├───┤┌───┐\n",
       "q_3: ┤ X ├┤ H ├\n",
       "     └───┘└───┘\n",
       "c: 3/══════════\n",
       "               </pre>"
      ],
      "text/plain": [
       "     ┌───┐     \n",
       "q_0: ┤ H ├─────\n",
       "     ├───┤     \n",
       "q_1: ┤ H ├─────\n",
       "     ├───┤     \n",
       "q_2: ┤ H ├─────\n",
       "     ├───┤┌───┐\n",
       "q_3: ┤ X ├┤ H ├\n",
       "     └───┘└───┘\n",
       "c: 3/══════════\n",
       "               "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The first step in the algorithm is to initialise the input qubits in the |+⟩ and the output qubit in the state |−⟩\n",
    "jozsa_circuit = qiskit.QuantumCircuit(n + 1, n)\n",
    "\n",
    "# Applying H-gates\n",
    "for qubit in range(n):\n",
    "    jozsa_circuit.h(qubit)\n",
    "\n",
    "# Putting qubit in state |->\n",
    "jozsa_circuit.x(n)\n",
    "jozsa_circuit.h(n)\n",
    "jozsa_circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "45e27c81-4b29-463d-86d7-81d3bea0970d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Pascal\\AppData\\Local\\Temp/ipykernel_35448/3927475880.py:2: DeprecationWarning: The QuantumCircuit.__iadd__() method is being deprecated. Use the compose() (potentially with the inplace=True argument) and tensor() methods which are more flexible w.r.t circuit register compatibility.\n",
      "  jozsa_circuit += balanced_oracle\n",
      "C:\\Users\\Pascal\\anaconda3\\lib\\site-packages\\qiskit\\circuit\\quantumcircuit.py:942: DeprecationWarning: The QuantumCircuit.extend() method is being deprecated. Use the compose() (potentially with the inplace=True argument) and tensor() methods which are more flexible w.r.t circuit register compatibility.\n",
      "  return self.extend(rhs)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐┌───┐ ░                 ░ ┌───┐\n",
       "q_0: ┤ H ├┤ X ├─░───■─────────────░─┤ X ├\n",
       "     ├───┤└───┘ ░   │             ░ └───┘\n",
       "q_1: ┤ H ├──────░───┼────■────────░──────\n",
       "     ├───┤┌───┐ ░   │    │        ░ ┌───┐\n",
       "q_2: ┤ H ├┤ X ├─░───┼────┼────■───░─┤ X ├\n",
       "     ├───┤├───┤ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘\n",
       "q_3: ┤ X ├┤ H ├─░─┤ X ├┤ X ├┤ X ├─░──────\n",
       "     └───┘└───┘ ░ └───┘└───┘└───┘ ░      \n",
       "c: 3/════════════════════════════════════\n",
       "                                         </pre>"
      ],
      "text/plain": [
       "     ┌───┐┌───┐ ░                 ░ ┌───┐\n",
       "q_0: ┤ H ├┤ X ├─░───■─────────────░─┤ X ├\n",
       "     ├───┤└───┘ ░   │             ░ └───┘\n",
       "q_1: ┤ H ├──────░───┼────■────────░──────\n",
       "     ├───┤┌───┐ ░   │    │        ░ ┌───┐\n",
       "q_2: ┤ H ├┤ X ├─░───┼────┼────■───░─┤ X ├\n",
       "     ├───┤├───┤ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘\n",
       "q_3: ┤ X ├┤ H ├─░─┤ X ├┤ X ├┤ X ├─░──────\n",
       "     └───┘└───┘ ░ └───┘└───┘└───┘ ░      \n",
       "c: 3/════════════════════════════════════\n",
       "                                         "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now apply the balanced_oracle to the circuit\n",
    "jozsa_circuit += balanced_oracle\n",
    "jozsa_circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1da36e46-c873-453d-bb29-54abcfb49219",
   "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: ┤ H ├┤ X ├─░───■─────────────░─┤ X ├┤ H ├─░─┤M├──────\n",
       "     ├───┤└───┘ ░   │             ░ ├───┤└───┘ ░ └╥┘┌─┐   \n",
       "q_1: ┤ H ├──────░───┼────■────────░─┤ H ├──────░──╫─┤M├───\n",
       "     ├───┤┌───┐ ░   │    │        ░ ├───┤┌───┐ ░  ║ └╥┘┌─┐\n",
       "q_2: ┤ H ├┤ X ├─░───┼────┼────■───░─┤ X ├┤ H ├─░──╫──╫─┤M├\n",
       "     ├───┤├───┤ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘└───┘ ░  ║  ║ └╥┘\n",
       "q_3: ┤ X ├┤ H ├─░─┤ X ├┤ X ├┤ X ├─░────────────░──╫──╫──╫─\n",
       "     └───┘└───┘ ░ └───┘└───┘└───┘ ░            ░  ║  ║  ║ \n",
       "c: 3/═════════════════════════════════════════════╩══╩══╩═\n",
       "                                                  0  1  2 </pre>"
      ],
      "text/plain": [
       "     ┌───┐┌───┐ ░                 ░ ┌───┐┌───┐ ░ ┌─┐      \n",
       "q_0: ┤ H ├┤ X ├─░───■─────────────░─┤ X ├┤ H ├─░─┤M├──────\n",
       "     ├───┤└───┘ ░   │             ░ ├───┤└───┘ ░ └╥┘┌─┐   \n",
       "q_1: ┤ H ├──────░───┼────■────────░─┤ H ├──────░──╫─┤M├───\n",
       "     ├───┤┌───┐ ░   │    │        ░ ├───┤┌───┐ ░  ║ └╥┘┌─┐\n",
       "q_2: ┤ H ├┤ X ├─░───┼────┼────■───░─┤ X ├┤ H ├─░──╫──╫─┤M├\n",
       "     ├───┤├───┤ ░ ┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘└───┘ ░  ║  ║ └╥┘\n",
       "q_3: ┤ X ├┤ H ├─░─┤ X ├┤ X ├┤ X ├─░────────────░──╫──╫──╫─\n",
       "     └───┘└───┘ ░ └───┘└───┘└───┘ ░            ░  ║  ║  ║ \n",
       "c: 3/═════════════════════════════════════════════╩══╩══╩═\n",
       "                                                  0  1  2 "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now perform H-dates on the n-input qubits and measure our input register\n",
    "\n",
    "# Applying H-gates\n",
    "for qubit in range(n):\n",
    "    jozsa_circuit.h(qubit)\n",
    "jozsa_circuit.barrier()\n",
    "\n",
    "# Measure\n",
    "for i in range(n):\n",
    "    jozsa_circuit.measure(i, i)\n",
    "    \n",
    "jozsa_circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cae276de-f017-4d44-bf6f-66c5db125e3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Pascal\\anaconda3\\lib\\site-packages\\qiskit\\utils\\deprecation.py:62: DeprecationWarning: Using a qobj for run() is deprecated as of qiskit-aer 0.9.0 and will be removed no sooner than 3 months from that release date. Transpiled circuits should now be passed directly using `backend.run(circuits, **run_options).\n",
      "  return func(*args, **kwargs)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lets see the outputs\n",
    "aer_simulator = aer.QasmSimulator()\n",
    "qobj = qiskit.assemble(jozsa_circuit, aer_simulator)\n",
    "results = aer_simulator.run(qobj).result()\n",
    "answer = results.get_counts()\n",
    "\n",
    "plot_histogram(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "185fc340-e779-43bc-8269-712ec93fbc6c",
   "metadata": {},
   "source": [
    "As we can see from the results there is a 0% chance of measuring 000. Deutsch-Jozsa's algorithm correctly predicts the function is balanced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa729c3c-0a77-4e8f-9a67-8b86d231c272",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8b7f22c-e2b5-4327-b59f-c8465ef05d62",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbb2d081-5646-41ce-a6a7-8526ad9f9837",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07c75a72-d067-40e6-b4b3-aa4e5a2b4bb2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}