challenge-2023.03-mar/challenge-2023.03-mar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4e802544",
   "metadata": {},
   "source": [
    "# Challenge: working with NISQ Devices\n",
    "\n",
    "\n",
    "[<img src=\"https://qbraid-static.s3.amazonaws.com/logos/Launch_on_qBraid_white.png\" width=\"150\">](https://account.qbraid.com?gitHubUrl=https://github.com/qosf/monthly-challenges.git)\n",
    "\n",
    "\n",
    "Quantum computers have important potential applications in multiple areas as are chemistry, machine learning, optimization, etc. But there exists a problem that is not mentioned at the moment you start working with a quantum processing unit (QPU): a large amount of noise and a limited number of qubits. \n",
    "\n",
    "Multiple companies work around quantum computers and algorithms but, on this challenge, we are focusing on the final step when your algorithm has been implemented on a real QPU and you need to mitigate errors. This will be possible using Mitiq, a multiplatform package focused on error mitigation. If you want to know more about this package you can check the following link https://mitiq.readthedocs.io/en/stable/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45dcf314",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Note \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "To run on real QPU and simulators use  [qbraid](https://account.qbraid.com/) and send them a dm on their [discord server]( https://discord.gg/KtEwsR2TZE) to get credits!\n",
    "\n",
    "\n",
    "## The problem\n",
    "\n",
    "Imagine you are working for a quantum computing company, and your role is to find the possibility to implement a quantum algorithm on QPUs. The first step is coding the following pseudocode in your favourite framework.   \n",
    "\n",
    "<div style=\"background-color:#FFFF00; padding:10px 0;font-family:monospace;\">\n",
    "<font color = \"blue\"><b>def draper_adder(n:int, n1:int, n2:int):</b></font><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#0037ffff\">     “”” <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; n : integer value that is the number of qubits.<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; n1: integer value that is the first value for the adder.<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; n2: integer value that is the secod value for the adder.<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; Return the quantum circuit<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;     “””</font>  <br>    \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"blue\"><b>input </b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $X_{basis_1} = X(n_1) $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $X_{basis_2} = X(n_2) $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $H_{init} = X_{basis_1}^{n} + X_{basis_2}^{n} $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $H_{init} = I^{n} + QFT^{n} $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $|X\\rangle|Y\\rangle = |00...0\\rangle_{n}|00...0\\rangle_{n}$ <br> \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $|\\psi_1 \\rangle = H_{init}|X\\rangle|Y\\rangle$ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"blue\"><b>procedure </b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>for </b></font>$i \\in  \\{1,2,...,n\\}$ <font color = \"#ff0000ff\"><b></b>do</font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>for </b></font>$j \\in  \\{0,1,...,n\\}$ <font color = \"#ff0000ff\"><b></b>do</font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $|\\psi_2\\rangle=CP(\\frac{\\pi}{2^{i}},j)|\\psi_1\\rangle$<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>end for</b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>end for</b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $H_{out} = I^{n} + QFT^{\\dagger n} $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $|\\psi_3 \\rangle = H_{out}|\\psi_2 \\rangle$ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#00b400ff\"><b>return  </b></font>Circuit producing $\\langle Y|\\psi_3 \\rangle$ <br>\n",
    "    \n",
    "    \n",
    "        \n",
    "</div>\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02f39e22",
   "metadata": {},
   "source": [
    "The general quantum algorithm scheme you can find in Figure 1. For example, if you want to do 5+ 2 you need 6 qubits in total, 3 for the state |101> that is 5, and |010> that is 2 in the basis encoding. The result is 7 and, therefore, final state when you measure the quantum circuit must be |111> (wihtout noise). \n",
    "\n",
    "\n",
    "![Draper adder](images/draper_adder.png)\n",
    "<center>Figure 1. General quantum circuit to Draper adder </center>\n",
    "\n",
    "\n",
    "### Resources\n",
    "\n",
    "For some guidelines regarding the quantum algorithm, you can check the following sources, including the original paper explaining this idea, as well as some tutorials from different frameworks.\n",
    "\n",
    "[1]Draper, Thomas. (2000). Addition on a Quantum Computer [[0008033]](https://arxiv.org/abs/quant-ph/0008033).\n",
    "\n",
    "[2] [Qiskit Code](https://qiskit.org/documentation/stubs/qiskit.circuit.library.DraperQFTAdder.html).\n",
    "\n",
    "[3] [Qiskit Application](https://github.com/qiskit-community/ibm-quantum-challenge-fall-2021/blob/main/solutions-by-authors/challenge-4/challenge-4.ipynb)\n",
    "\n",
    "[4] [Pennylane Tutorial](https://pennylane.ai/qml/demos/tutorial_qft_arithmetics.html)\n",
    "\n",
    "[5] [Q# Tutorial](https://learn.microsoft.com/en-us/azure/quantum/user-guide/libraries/standard/algorithms)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "676259bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# code of your proposal for draper adder\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def draper_adder(n:int, n1:int, n2:int):\n",
    "    \"\"\"\n",
    "     n : integer value that is the number of qubits.\n",
    "     n1: integer value that is the first value for the adder.\n",
    "     n2: integer value that is the second value for the adder.\n",
    "     Return the quantum circuit\n",
    "    \"\"\"\n",
    "    #quantum circuit\n",
    "    \n",
    "    ## implementation of the draper adder consider n qubits for the basis encoding\n",
    "\n",
    "    return quantum_circuit # your quantum circuit\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df5c4dd8",
   "metadata": {},
   "source": [
    "## Ideal simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e41e88a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#consider the following example\n",
    "qc = draper_adder(3, 5, 2)\n",
    "\n",
    "# execute this in a simulator must be the output 7 or 111 with 100% of probability\n",
    "######################\n",
    "# your code here#\n",
    "#################\n",
    "result = \n",
    "###################\n",
    "\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5360dca",
   "metadata": {},
   "source": [
    "## Noisy Simulation\n",
    "\n",
    "Add depolarizing noise with a probability of 0.02 in the simulation that you are working on. Try to execute your code and see if the output is the same or if instead the probability distribution in the output bitstring is different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "018697bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#consider the following example\n",
    "qc = draper_adder(3, 5, 2)\n",
    "\n",
    "from mitiq.interface.mitiq_qiskit.qiskit_utils import initialized_depolarizing_noise\n",
    "noise_model = initialized_depolarizing_noise(noise_level=0.02)\n",
    "\n",
    "# execute this in a noise simulator must be the output 7 or 111, but with a noise could be other states in the output.\n",
    "######################\n",
    "# your code here#\n",
    "#################\n",
    "\n",
    "\n",
    "\n",
    "result = \n",
    "##############\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e19df6dc",
   "metadata": {},
   "source": [
    "## Using Mitiq\n",
    "At this point, you need to use Zero noise Extrapolation (ZNE) and obtain a result which is closer to the ideal result. For that, you need to scale up the noise level by applying _unitary folding_  to your quantum circuit such that you can estimate the error-mitigated result via different extrapolation methods: linear, polynomial, exponential, and Richardson. You can find a guide for applying ZNE with Mitiq [here](https://mitiq.readthedocs.io/en/stable/guide/zne.html) and you can find additional examples [here](https://mitiq.readthedocs.io/en/stable/examples/examples.html) ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b17d2867",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mitiq import zne\n",
    "from mitiq.zne.scaling import fold_global, fold_gates_from_left, fold_gates_from_right, fold_gates_from_left\n",
    "\n",
    "qc = draper_adder(3, 5, 2)\n",
    "\n",
    "\n",
    "result = # the result of your simulation\n",
    "\n",
    "\n",
    "\n",
    "print(\"Unmitigated result:\", result)\n",
    "\n",
    "## To create the executor method check the mitiq examples depending on the framework that is implementing this challenge.\n",
    "\n",
    "###################\n",
    "\n",
    "\n",
    "default_result = zne.execute_with_zne(qc, executor)\n",
    "\n",
    "print(\"Default ZNE result:\", default_result)\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "\n",
    "\n",
    "scale_factors = # choose your scale factors in a list\n",
    "\n",
    "\n",
    "#################\n",
    "## Linear Factory\n",
    "linear_factory = zne.inference.LinearFactory(scale_factors=scale_factors)\n",
    "linear_result = zne.execute_with_zne(qc, executor, factory=linear_factory, scale_noise=) #indicate the scaling method\n",
    "print(\"Linear ZNE result:\", lineal_result)\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "## Exp Factory\n",
    "exp_factory = zne.inference.ExpFactory(scale_factors=scale_factors, asymptote= ) # select your asymptote\n",
    "exp_result = zne.execute_with_zne(decomposed, executor, factory=exp_factory, scale_noise=) #indicate the scaling method\n",
    "\n",
    "print(\"Exponential ZNE result:\", exp_result)\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "## Richardson Factory\n",
    "richardson_factory = zne.inference.RichardsonFactory(scale_factors=scale_factors)\n",
    "richardson_result = zne.execute_with_zne(decomposed, executor, factory=richardson_factory, scale_noise=) #indicate the scaling method\n",
    "\n",
    "print(\"Richardson ZNE result:\", richardson_result)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "## Poly Factory\n",
    "poly_factory = zne.inference.PolyFactory(scale_factors=scale_factors, order=) # choose the order\n",
    "poly_result = zne.execute_with_zne(decomposed, executor, factory=poly_factory, scale_noise=) #indicate the scaling method\n",
    "\n",
    "print(\"Polynomial ZNE result:\", poly_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fee8daa7",
   "metadata": {},
   "source": [
    "As you can see, error mitigation slightly increases the probability of the correct result \"111\". However, since the noise is very large, even the error-mitigated expectation values are quite far from the ideal result which is 1.\n",
    "\n",
    "This fact shows that, error mitigation can be very effective to mitigate weak levels of noise but it can have bad performances if the noise is too large. In particular, if the noise is so strong to destroy any signal of the ideal result, error mitigation may not work.\n",
    "\n",
    "In the next section we try to simplify the draper_added algorithm itself, in order to obtain better results."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93a408a8",
   "metadata": {},
   "source": [
    "## Version 2 of Draper Adder circuit\n",
    "\n",
    "\n",
    "Using the same process but we can reduce the depth and the number of gates using the following  changes:\n",
    "\n",
    "<div style=\"background-color:#FFFF00; padding:10px 0;font-family:monospace;\">\n",
    "<font color = \"blue\"><b>def draper_adder(n:int, n1:int, n2:int):</b></font><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#0037ffff\">     “”” <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; n : integer value that is the number of qubits.<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; n1: integer value that is the first value for the adder.<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; n2: integer value that is the secod value for the adder.<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; Return the quantum circuit<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;     “””</font>  <br>    \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"blue\"><b>input </b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $X_{basis_1} = X(n_1) $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $X_{basis_2} = X(n_2) $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $H_{init} = X_{basis_1}^{n} + X_{basis_2}^{n} $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $H_{init} = I^{n} + QFT^{n} $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $|X\\rangle|Y\\rangle = |00...0\\rangle_{n}|00...0\\rangle_{n}$ <br> \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $|\\psi_1 \\rangle = H_{init}|X\\rangle|Y\\rangle$ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"blue\"><b>procedure </b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>for </b></font>$j \\in  \\{1,2,...,n\\}$ <font color = \"#ff0000ff\"><b></b>do</font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; k = 0 <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>for </b></font>$j \\in  \\{n-1-j,...,0\\}$ <font color = \"#ff0000ff\"><b></b>do</font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $|\\psi_2\\rangle=CP(\\frac{n_2 *\\pi}{2^{i}},j,k)|\\psi_1\\rangle$<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>end for</b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#ff0000ff\"><b>end for</b></font><br>   \n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $H_{out} = I^{n} + QFT^{\\dagger n} $ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; $|\\psi_3 \\rangle = H_{out}|\\psi_2 \\rangle$ <br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp; <font color = \"#00b400ff\"><b>return </b></font>$\\langle Y|\\psi_3 \\rangle$ <br>\n",
    "    \n",
    "</div>\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "740c79d9",
   "metadata": {},
   "source": [
    "You can find the quantum circuit of this new version in Figure 2. \n",
    "\n",
    "![Draper adder](images/draper_adder_v2.png)\n",
    "<center>Figure 1. General quantum circuit to Draper adder version 2. </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d25323f8",
   "metadata": {},
   "source": [
    "Now you can apply the previous process to generate the circuit for simulation, run it without and with depolarizing noise, and mitigate the results.\n",
    "\n",
    "\n",
    "### Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58668748",
   "metadata": {},
   "outputs": [],
   "source": [
    "# code of your proposal for draper adder\n",
    "\n",
    "def draper_adder_v2(n:int, n1:int, n2:int):\n",
    "    \"\"\"\n",
    "     n : integer value that is the number of qubits.\n",
    "     n1: integer value that is the first value for the adder.\n",
    "     n2: integer value that is the second value for the adder.\n",
    "     Return the quantum circuit\n",
    "    \"\"\"\n",
    "        \n",
    "    #quantum circuit\n",
    "\n",
    "    return quantim_circuit\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c831557",
   "metadata": {},
   "outputs": [],
   "source": [
    "#consider the following example\n",
    "qc = draper_adder_v2(3, 5, 2)\n",
    "\n",
    "# execute this in a simulator must be the output 7 or 111 with 100% of probability\n",
    "######################\n",
    "# your code here#\n",
    "#################\n",
    "\n",
    "result =\n",
    "\n",
    "##############\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fa7fb49",
   "metadata": {},
   "source": [
    "### Noisy simulation\n",
    "\n",
    "Using the same parameter for the noise model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c15c6ce9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#consider the following example\n",
    "qc = draper_adder_v2(3, 5, 2)\n",
    "\n",
    "# execute this in a noise simulator must be the output 7 or 111, but with a noise could be other states i nthe output.\n",
    "######################\n",
    "# your code here#\n",
    "#################\n",
    "\n",
    "\n",
    "\n",
    "##############\n",
    "\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0decae7",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Depth of quantum circuit\",qc.decompose().decompose().depth()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c0f1e4",
   "metadata": {},
   "source": [
    "## Using Mitiq\n",
    "\n",
    "Use the same proccess and the same four functions: linear, polynomial, exponential and Richardson to find the best fit for the mitigation error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e59b867",
   "metadata": {},
   "outputs": [],
   "source": [
    "qc = draper_adder_v2(3, 5, 2)\n",
    "\n",
    "\n",
    "result = # the result of your simulation\n",
    "\n",
    "\n",
    "\n",
    "print(\"Unmitigated result:\", result)\n",
    "\n",
    "## To create the executor method check the mitiq examples depending on the framework that is implementing this challenge.\n",
    "\n",
    "###################\n",
    "\n",
    "\n",
    "default_result = \n",
    "\n",
    "print(\"Default ZNE result:\", default_result)\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "\n",
    "\n",
    "scale_factors = # choose your scale factors in a list\n",
    "\n",
    "\n",
    "#################\n",
    "## Linear Factory\n",
    "linear_factory =  #fill in this line as in the previous version, you may need to make some modifications\n",
    "linear_result = #fill in this line as in the previous version, you may need to make some modifications\n",
    "print(\"Linear ZNE result:\", lineal_result)\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "## Exp Factory\n",
    "exp_factory = #fill in this line as in the previous version, you may need to make some modifications\n",
    "exp_result = #fill in this line as in the previous version, you may need to make some modifications\n",
    "\n",
    "print(\"Exponential ZNE result:\", exp_result)\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "## Richardson Factory\n",
    "richardson_factory = #fill in this line as in the previous version, you may need to make some modifications\n",
    "richardson_result = #fill in this line as in the previous version, you may need to make some modifications\n",
    "\n",
    "print(\"Richardson ZNE result:\", richardson_result)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#################\n",
    "## Poly Factory\n",
    "poly_factory = #fill in this line as in the previous version, you may need to make some modifications\n",
    "poly_result = #fill in this line as in the previous version, you may need to make some modifications\n",
    "\n",
    "print(\"Polynomial ZNE result:\", poly_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acfbf545",
   "metadata": {},
   "source": [
    "## Bonus\n",
    "\n",
    "If you completed the notebook and to arrived at this point, congratulations! You did a great job on learning how to obtain better results on your quantum circuit executed on a QPU. Remember that you need an account on qBraid and send us a DM to share the credits and to use a real QPU. You can consider and try to contribute to an important part of the quantum community working in the field of quantum noise and error mitigation 😊"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be6dcaab",
   "metadata": {},
   "source": [
    "# Acknowledgments\n",
    "\n",
    "🎉🎉🎉 Special thanks to Unitary Fund for helping us create this challenge and being able to exploit their mitiq package and see that in the NISQ era, it was one part creating the algorithm and another mitigating the error, and each has its complications and should be highlighted. If you want to know more about the Unitary Fund you will see their [discord channel](http://discord.unitary.fund/) 🎉🎉🎉 "
   ]
  }
 ],
 "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}