content/ex3/ex3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 3 - Quantum error correction\n",
    "\n",
    "## Historical background\n",
    "\n",
    "Shor's algorithm gave quantum computers a worthwhile use case—but the inherent noisiness of quantum mechanics meant that building hardware capable of running such an algorithm would be a huge struggle. In 1995, Shor released another landmark paper: a scheme that shared quantum information over multiple qubits in order to reduce errors.[1]\n",
    "\n",
    "A great deal of progress has been made over the decades since. New forms of error correcting codes have been discovered, and a large theoretical framework has been built around them. The surface codes proposed by Kitaev in 1997 have emerged as the leading candidate, and many variations on the original design have emerged since then. But there is still a lot of progress to make in tailoring codes to the specific details of quantum hardware.[2]\n",
    "\n",
    "In this exercise we'll consider a case in which artificial 'errors' are inserted into a circuit. Your task is to design the circuit such that these additional gates can be identified.\n",
    "\n",
    "You'll then need to think about how to implement your circuit on a real device. This means you'll need to tailor your solution to the layout of the qubits. Your solution will be scored on how few entangling gates (the noisiest type of gate) that you use.\n",
    "\n",
    "### References\n",
    "1. Shor, Peter W. \"Scheme for reducing decoherence in quantum computer memory.\" Physical review A 52.4 (1995): R2493.\n",
    "1. Dennis, Eric, et al. \"Topological quantum memory.\" Journal of Mathematical Physics 43.9 (2002): 4452-4505."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The problem of errors\n",
    "\n",
    "Errors occur when some spurious operation acts on our qubits. Their effects cause things to go wrong in our circuits. The strange results you may have seen when running on real devices is all due to these errors.\n",
    "\n",
    "There are many spurious operations that can occur, but it turns out that we can pretend that there are only two types of error: bit flips and phase flips.\n",
    "\n",
    "Bit flips have the same effect as the `x` gate. They flip the $|0\\rangle$ state of a single qubit to $|1\\rangle$ and vice-versa. Phase flips have the same effect as the `z` gate, introducing a phase of $-1$ into superpositions. Put simply, they flip the $|+\\rangle$ state of a single qubit to $|-\\rangle$ and vice-versa.\n",
    "\n",
    "The reason we can think of any error in terms of just these two is because any error can be represented by some matrix, and any matrix can be written in terms of the matrices $X$ and $Z$. Specifically, for any single qubit matrix $M$,\n",
    "\n",
    "$$\n",
    "M = \\alpha I + \\beta X + \\gamma XZ + \\delta Z,\n",
    "$$\n",
    "\n",
    "for some suitably chosen values $\\alpha$, $\\beta$, $\\gamma$ and $\\delta$.\n",
    "\n",
    "So whenever we apply this matrix to some single qubit state $|\\psi\\rangle$ we get\n",
    "\n",
    "$$\n",
    "M |\\psi\\rangle = \\alpha |\\psi\\rangle + \\beta X |\\psi\\rangle + \\gamma XZ |\\psi\\rangle + \\delta Z |\\psi\\rangle.\n",
    "$$\n",
    "\n",
    "The resulting superposition is composed of the original state, the state we'd have if the error was just a bit flip, the state for just a phase flip and the state for both. If we had some way to measure whether a bit or phase flip happened, the state would then collapse to just one possibility. And our complex error would become just a simple bit or phase flip.\n",
    "\n",
    "So how do we detect whether we have a bit flip or a phase flip (or both). And what do we do about it once we know? Answering these questions is what quantum error correction is all about.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An overly simple example\n",
    "\n",
    "One of the first quantum circuits that most people ever write is to create a pair of entangled qubits. In this journey into quantum error correction, we'll start the same way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, Aer\n",
    "\n",
    "# Make an entangled pair\n",
    "qc_init = QuantumCircuit(2)\n",
    "qc_init.h(0)\n",
    "qc_init.cx(0,1)\n",
    "\n",
    "# Draw the circuit\n",
    "display(qc_init.draw('mpl'))\n",
    "\n",
    "# Get an output\n",
    "qc = qc_init.copy()\n",
    "qc.measure_all()\n",
    "job = Aer.get_backend('qasm_simulator').run(qc)\n",
    "job.result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see the expected result when we run the circuit: the results `00` and `11` occurring with equal probability.\n",
    "\n",
    "But what happens when we have the same circuit, but with a bit flip 'error' inserted manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make bit flip error\n",
    "qc_insert = QuantumCircuit(2)\n",
    "qc_insert.x(0)\n",
    "\n",
    "# Add it to our original circuit\n",
    "qc = qc_init.copy()\n",
    "qc = qc.compose(qc_insert)\n",
    "\n",
    "# Draw the circuit\n",
    "display(qc.draw('mpl'))\n",
    "\n",
    "# Get an output\n",
    "qc.measure_all()\n",
    "job = Aer.get_backend('qasm_simulator').run(qc)\n",
    "job.result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the results are different: `01` and `10`. The two bit values have gone from always agreeing to always disagreeing. In this way, we detect the effect of the error.\n",
    "\n",
    "Another way we can detect it is to undo the entanglement with a few more gates. If there are no errors, we return to the initial $|00\\rangle$ state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Undo entanglement\n",
    "qc_syn = QuantumCircuit(2)\n",
    "qc_syn.cx(0,1)\n",
    "qc_syn.h(0)\n",
    "\n",
    "# Add this after the error\n",
    "qc = qc_init.copy()\n",
    "qc = qc.compose(qc_syn)\n",
    "\n",
    "# Draw the circuit\n",
    "display(qc.draw('mpl'))\n",
    "\n",
    "# Get an output\n",
    "qc.measure_all()\n",
    "job = Aer.get_backend('qasm_simulator').run(qc)\n",
    "job.result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what happens if there are errors one of the qubits? Try inserting different errors to find out.\n",
    "\n",
    "Here's a circuit with all the components we've introduced so far: the initialization `qc_init`, the inserted error in `qc_insert` and the final `qc_syn` which ensures that the final measurement gives a nice definite answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define an error\n",
    "qc_insert = QuantumCircuit(2)\n",
    "qc_insert.x(0)\n",
    "\n",
    "# Undo entanglement\n",
    "qc_syn = QuantumCircuit(2)\n",
    "qc_syn.cx(0,1)\n",
    "qc_syn.h(0)\n",
    "\n",
    "# Add this after the error\n",
    "qc = qc_init.copy()\n",
    "qc = qc.compose(qc_insert)\n",
    "qc = qc.compose(qc_syn)\n",
    "\n",
    "# Draw the circuit\n",
    "display(qc.draw('mpl'))\n",
    "\n",
    "# Get an output\n",
    "qc.measure_all()\n",
    "job = Aer.get_backend('qasm_simulator').run(qc)\n",
    "job.result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll find that the output tells us exactly what is going on with the errors. Both the bit and phase flips can be detected. The bit value on the left is `1` only if there is a bit flip (and so if we have inserted an `x(0)` or `x(1)`). The bit on the right similarly tells us there is a phase flip (an inserted `z(0)` or `z(1)`).\n",
    "\n",
    "This ability to detect and distinguish bit and phase flips is very useful. But it is not quite useful enough. We can only tell *what type* of errors are happening, but not *where*. Without more detail, it is not possible to figure out how to remove the effects of these operations from our computations. For quantum error correction we therefore need something bigger and better.\n",
    "\n",
    "It's your task to do just that! Here's a list of what you need to submit. Everything here is then explained by the example that follows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "<b>Goal</b>\n",
    "\n",
    "Create circuits which can detect `x` and `z` errors on two qubits.\n",
    "You can come up with a solution of your own. Or just tweak the almost valid solution given below.\n",
    "\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>What to submit</b> \n",
    "\n",
    "* You need to supply two circuits:\n",
    "    * `qc_init`: Prepares the qubits (of which there are at least two) in a desired initial state;\n",
    "    * `qc_syn`: Measures a subset of the qubits.\n",
    "\n",
    "* The artificial errors to be inserted are `x` and `z` gates on two particular qubits. You need to pick the two qubits to be used for this (supplied as the list `error_qubits`).\n",
    "\n",
    "* There are 16 possible sets of errors to be inserted (including the trivial case of no errors). The measurement result of `qc_syn` should output a unique bit string for each. The grader will return the error message *'Please make sure the circuit is created to the initial layout.'* if this is not satisfied.\n",
    "\n",
    "* The grader will compile the complete circuit for the backend `ibmq_tokyo` (a retired device). To show that your solution is tailor made for the device, this transpilation should not change the number of `cx` gates. If it does, you will get the error message *'Please make sure the circuit is created to the initial layout.'*\n",
    "    \n",
    "* To guide the transpilation, you'll need to tell the transpiler which qubits on the device should be used as which qubits in your circuit. This is done with an `initial_layout` list.\n",
    "    \n",
    "* You may start with the example given below, which can become a valid answer with a few tweaks.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A better example: the surface code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile\n",
    "\n",
    "import qiskit.tools.jupyter\n",
    "from qiskit.test.mock import FakeTokyo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we'll use 5 qubits that we'll call code qubits. To keep track of them, we'll define a special quantum register."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = QuantumRegister(5,'code')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll also have an additional four qubits we'll call syndrome qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "syn = QuantumRegister(4,'syn')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly we define a register for the four output bits, used when measuring the syndrome qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out = ClassicalRegister(4,'output')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We consider the qubits to be laid out as follows, with the code qubits forming the corners of four triangles, and the syndrome qubits living inside each triangle.\n",
    "\n",
    "```\n",
    "c0----------c1\n",
    "| \\   s0   / |\n",
    "|   \\    /   |\n",
    "| s1  c2  s2 |\n",
    "|   /    \\   |\n",
    "| /   s3   \\ |\n",
    "c3----------c4\n",
    "```\n",
    "\n",
    "For each triangle we associate a stabilizer operation on its three qubits. For the qubits on the sides, the stabilizers are ZZZ. For the top and bottom ones, they are XXX.\n",
    "\n",
    "The syndrome measurement circuit corresponds to a measurement of these observables. This is done in a similar way to surface code stabilizers (in fact, this code is a small version of a surface code).\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    " \n",
    "<b>Warning</b> \n",
    "\n",
    "You should remove the barriers before submitting the code as it might interfere with transpilation. It is given here for visualization only. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc_syn = QuantumCircuit(code,syn,out)\n",
    "\n",
    "\n",
    "# Left ZZZ\n",
    "qc_syn.cx(code[0],syn[1])\n",
    "qc_syn.cx(code[2],syn[1])\n",
    "qc_syn.cx(code[3],syn[1])\n",
    "qc_syn.barrier()\n",
    "\n",
    "# Right ZZZ\n",
    "qc_syn.cx(code[1],syn[2])\n",
    "qc_syn.cx(code[2],syn[2])\n",
    "qc_syn.cx(code[4],syn[2])\n",
    "qc_syn.barrier()\n",
    "\n",
    "# Top XXX\n",
    "qc_syn.h(syn[0])\n",
    "qc_syn.cx(syn[0],code[0])\n",
    "qc_syn.cx(syn[0],code[1])\n",
    "qc_syn.cx(syn[0],code[2])\n",
    "qc_syn.h(syn[0])\n",
    "qc_syn.barrier()\n",
    "\n",
    "# Bottom XXX\n",
    "qc_syn.h(syn[3])\n",
    "qc_syn.cx(syn[3],code[2])\n",
    "qc_syn.cx(syn[3],code[3])\n",
    "qc_syn.cx(syn[3],code[4])\n",
    "qc_syn.h(syn[3])\n",
    "qc_syn.barrier()\n",
    "\n",
    "\n",
    "# Measure the auxilliary qubits\n",
    "qc_syn.measure(syn,out)\n",
    "qc_syn.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initialization circuit prepares an eigenstate of these observables, such that the output of the syndrome measurement will be `0000` with certainty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc_init = QuantumCircuit(code,syn,out)\n",
    "\n",
    "qc_init.h(syn[0])\n",
    "qc_init.cx(syn[0],code[0])\n",
    "qc_init.cx(syn[0],code[1])\n",
    "qc_init.cx(syn[0],code[2])\n",
    "qc_init.cx(code[2],syn[0])\n",
    "\n",
    "qc_init.h(syn[3])\n",
    "qc_init.cx(syn[3],code[2])\n",
    "qc_init.cx(syn[3],code[3])\n",
    "qc_init.cx(syn[3],code[4])\n",
    "qc_init.cx(code[4],syn[3])\n",
    "\n",
    "qc_init.barrier()\n",
    "qc_init.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check that is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc = qc_init.compose(qc_syn)\n",
    "display(qc.draw('mpl'))\n",
    "\n",
    "job = Aer.get_backend('qasm_simulator').run(qc)\n",
    "job.result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's make a circuit with which we can insert `x` and `z` gates on our two code qubits. For this we'll need to choose which of the 5 code qubits we have will correspond to the two required for the validity condition.\n",
    "\n",
    "For this code we need to choose opposite corners."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "error_qubits = [0,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here 0 and 4 refer to the positions of the qubits in the following list, and hence are qubits `code[0]` and `code[4]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc.qubits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check that the code does as we require, we can use the following function to create circuits for inserting artificial errors. Here the errors we want to add are listed in `errors` as a simple text string, such as `x0` for an `x` on `error_qubits[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert(errors,error_qubits,code,syn,out):\n",
    "\n",
    "    qc_insert = QuantumCircuit(code,syn,out)\n",
    "\n",
    "    if 'x0' in errors:\n",
    "        qc_insert.x(error_qubits[0])\n",
    "    if 'x1' in errors:\n",
    "        qc_insert.x(error_qubits[1])\n",
    "    if 'z0' in errors:\n",
    "        qc_insert.z(error_qubits[0])\n",
    "    if 'z1' in errors:\n",
    "        qc_insert.z(error_qubits[1])\n",
    "        \n",
    "    return qc_insert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rather than all 16 possibilities, let's just look at the four cases where a single error is inserted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for error in ['x0','x1','z0','z1']:\n",
    "    \n",
    "    qc = qc_init.compose(insert([error],error_qubits,code,syn,out)).compose(qc_syn)\n",
    "    job = Aer.get_backend('qasm_simulator').run(qc)\n",
    "    \n",
    "    print('\\nFor error '+error+':')\n",
    "    counts = job.result().get_counts()\n",
    "    for output in counts:\n",
    "        print('Output was',output,'for',counts[output],'shots.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see that each bit in the output is `1` when a particular error occurs: the leftmost detects `z` on `error_qubits[1]`, then the next detects `x` on `error_qubits[1]`, and so on.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    " \n",
    "<b>Attention</b> \n",
    "\n",
    "The correct ordering of the output is important for this exercise. Please follow the order as given below:\n",
    "1. The leftmost output represents `z` on `code[1]`.\n",
    "2. The second output from left represents `x` on `code[1]`.\n",
    "3. The third output from left represents `x` on `code[0]`.\n",
    "4. The rightmost output represents `z` on `code[0]`.\n",
    "    \n",
    "</div>\n",
    "\n",
    "When more errors affect the circuit, it becomes hard to unambiguously tell which errors occurred. However, by continuously repeating the syndrome readout to get more results and analysing the data through the process of decoding, it is still possible to determine enough about the errors to correct their effects.\n",
    "\n",
    "These kinds of considerations are beyond what we will look at in this challenge. Instead we'll focus on something simpler, but just as important: the fewer errors you have, and the simpler they are, the better your error correction will be. To ensure this, your error correction procedure should be tailor-made to the device you are using.\n",
    "\n",
    "In this challenge we'll be considering the device `ibmq_tokyo`. Though the real version of this was retired some time ago, it still lives on as one of the mock backends."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Please use the backend given here\n",
    "backend = FakeTokyo()\n",
    "backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a simple idea of how our original circuit is laid out, let's see how many two-qubit gates it contains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc = qc_init.compose(qc_syn)\n",
    "qc = transpile(qc, basis_gates=['u','cx'])\n",
    "qc.num_nonlocal_gates()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we were to transpile it to the `ibmq_tokyo` backend, remapping would need to occur at the cost of adding for two-qubit gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc1 = transpile(qc,backend,basis_gates=['u','cx'], optimization_level=3)\n",
    "qc1.num_nonlocal_gates()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can control this to an extent by looking at which qubits on the device would be best to use as the qubits in the code. If we look at what qubits in the code need to be connected by two-qubit gates in `qc_syn`, we find the following required connectivity graph.\n",
    "\n",
    "```\n",
    "c0....s0....c1\n",
    ":      :     :        \n",
    ":      :     :\n",
    "s1....c2....s2\n",
    ":      :     :\n",
    ":      :     :\n",
    "c3....s3....c4\n",
    "```\n",
    "\n",
    "No set of qubits on `ibmq_tokyo` can provide this, but certain sets like 0,1,2,5,6,7,10,11,12 come close. So we can set an `initial_layout` to tell the transpiler to use these.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_layout = [0,2,6,10,12,1,5,7,11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These tell the transpiler which qubits on the device to use for the qubits in the circuit (for the order they are listed in `qc.qubits`). So the first five entries in this list tell the circuit which qubits to use as the code qubits and the next four entries in this list are similarly for the syndrome qubits. So we use qubit 0 on the device as `code[0]`, qubit 2 as `code[1]` and so on.\n",
    "\n",
    "Now let's use this for the transpilation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc2 = transpile(qc,backend,initial_layout=initial_layout, basis_gates=['u','cx'], optimization_level=3)\n",
    "qc2.num_nonlocal_gates()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though transpilation is a random process, you should typically find that this uses less two-qubit gates than when no initial layout is provided (you might need to re-run both transpilation code multiple times to see it as transpilation is a random process).\n",
    "\n",
    "Nevertheless, a properly designed error correction scheme should not need any remapping at all. It should be written for the exact device used, and the number of two-qubit gates should remain constant with certainty. This is a condition for a solution to be valid. So you'll not just need to provide an `initial_layout`, but also design your circuits specifically for that layout.\n",
    "\n",
    "But that part we leave up to you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check your answer using following code\n",
    "from qc_grader import grade_ex3\n",
    "grade_ex3(qc_init,qc_syn,error_qubits,initial_layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submit your answer. You can re-submit at any time.\n",
    "from qc_grader import submit_ex3\n",
    "submit_ex3(qc_init,qc_syn,error_qubits,initial_layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional information\n",
    "\n",
    "**Created by:** James Wootton, Rahul Pratap Singh\n",
    "\n",
    "**Version:** 1.0.0"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}