FIN5615_Project_5_NeilYejjey_tuk12930 (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<h2>FIN5615 Project #5\n",
    "    <p class=\"text-primary\">Black Scholes Options Pricing (Part II)</p>\n",
    "</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-success\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:black\"><b>Project Introduction</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    The goal of this project is to build an options pricing calculator using the Black-Scholes pricing model. Our calculator will be able to price both put and call options as well as the following set of Greeks: delta, gamma, theta, vega, and rho. \n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "<div class = \"panel panel-info\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:black\"><b>Instructions</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    Please code you solutions directly in this Notebook under each task in the cells provided below. Include all code used to produce your results, and support your answers with textual explanations if neccessary. You may feel free to add additional Code and/or Markdown cells as needed. Code must be written using <b>Python 3</b>.\n",
    "    <br><br>Please order the cells in your Notebook in the order in which they are intended to run! It is expected that your Notebook is able to run in sequence from start to finish without any errors (before submitting check by: <code>Kernel > Restart & Run All</code>).\n",
    "    <br><br>Once ready, please submit your assignment as an <b>.ipynb file</b> (<code>File > Download as > Notebook</code>). You must name your files in the following format: <b><code>FIN5615_Project_1_Richard_Lee_tuc12345.ipynb</code></b>.\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "<div class = \"alert alert-block alert-warning\">\n",
    "    <b>Note</b>: Import all libraries that you plan on using in the code block below.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 1</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\">\n",
    "    Recall from the previous project, we coded the function <code>black_scholes_formula(stock_price, strike, term, rf, volatility, option, dividend = 0.)</code>, which returned the price of either a call or put option depending on the value of the input parameter <code>option</code>.\n",
    "    <br><br>Write another function called <code>black_scholes_greeks</code> that takes in the same input parameters as <code>black_scholes_formula</code>, and calculates the option's greeks (delta, gamma, vega, theta, and rho) according to the below table :\n",
    "    ![Task_6_Table.JPG](attachment:Task_6_Table.JPG)\n",
    "    <br><br>Note that $N^{\\prime}(x)$ is simply the probability density function of the normal distribution.\n",
    "    <br><br>The output should be returned in the form of dictionary with the following keys: <code>delta</code>, <code>gamma</code>, <code>vega</code>, <code>theta</code>, <code>rho</code>, each storing the corresponding greek value for the option. Run <code>black_scholes_greeks</code> on a call option where:\n",
    "    <ul>\n",
    "        <li><code>stock_price</code> = \\$30</li>\n",
    "        <li><code>strike</code> = \\$35</li>\n",
    "        <li><code>term</code> = 6 months</li>\n",
    "        <li><code>rf</code> = 1%</li>\n",
    "        <li><code>volatility</code> = 0.2</li>\n",
    "        <li><code>dividend</code> = 2.5%</li>\n",
    "    </ul>\n",
    "    Your function should return a dictionary output like this:\n",
    "    ![Task_6_Output.JPG](attachment:Task_6_Output.JPG)\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def black_scholes_formula(stock_price, strike, term, rf, volatility, option, dividend = 0):\n",
    "    \n",
    "    d1 = (1 / (volatility * np.sqrt(term))) * (np.log(stock_price / strike) + (rf - dividend + .5 * \n",
    "                                                                               (volatility ** 2)) * term)\n",
    "    d2 = d1 - volatility * np.sqrt(term)\n",
    "    \n",
    "    if option == 'call':\n",
    "        price = stock_price * np.exp(-dividend * term) * norm.cdf(d1, 0, 1) - \\\n",
    "                                        strike * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "    elif option == 'put':\n",
    "        price = strike * np.exp(-rf * term) * norm.cdf(-d2, 0, 1) - \\\n",
    "                                        stock_price * np.exp(-dividend * term) * norm.cdf(-d1, 0, 1)\n",
    "    return price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def black_scholes_greeks(stock_price, strike, term, rf, volatility, option, dividend = 0):\n",
    "    d1 = (1 / (volatility * np.sqrt(term))) * (np.log(stock_price / strike) + (rf - dividend + .5 * \n",
    "                                                                               (volatility ** 2)) * term)\n",
    "    d2 = d1 - volatility * np.sqrt(term)\n",
    "    \n",
    "    greeks = dict()\n",
    "    \n",
    "    if option == 'call':\n",
    "        greeks['delta'] = np.exp(-dividend * term) * norm.cdf(d1, 0, 1)\n",
    "        greeks['gamma'] = norm.pdf(d1, 0, 1) * np.exp(-dividend * term) / (stock_price * volatility * np.sqrt(term))\n",
    "        greeks['rho'] = strike * term * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "        greeks['theta'] = -stock_price * norm.pdf(d1, 0, 1) * volatility * np.exp(-dividend * term) / \\\n",
    "                            (2 * np.sqrt(term)) + dividend * stock_price * norm.cdf(d1, 0, 1) * \\\n",
    "                            np.exp(-dividend * term) - rf * strike * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "        greeks['vega'] = stock_price * norm.pdf(d1, 0, 1) * np.sqrt(term) * np.exp(-dividend * term)\n",
    "    \n",
    "    elif option == 'put':\n",
    "        greeks['delta'] = np.exp(-dividend * term) * (-norm.cdf(-d1, 0, 1))\n",
    "        greeks['gamma'] = norm.pdf(d1, 0, 1) * np.exp(-dividend * term) / (stock_price * volatility * np.sqrt(term))\n",
    "        greeks['rho'] = -strike * term * np.exp(-rf * term) * norm.cdf(-d2, 0, 1)\n",
    "        greeks['theta'] = -stock_price * norm.pdf(d1, 0, 1) * volatility * np.exp(-dividend * term) / \\\n",
    "                            (2 * np.sqrt(term)) - dividend * stock_price * norm.cdf(-d1, 0, 1) * \\\n",
    "                            np.exp(-dividend * term) + rf * strike * np.exp(-rf * term) * norm.cdf(-d2, 0, 1)\n",
    "        greeks['vega'] = stock_price * norm.pdf(d1, 0, 1) * np.sqrt(term) * np.exp(-dividend * term)\n",
    "        \n",
    "    return greeks\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeks_results = black_scholes_greeks(stock_price = 30, strike = 35, term = .5, rf = .01, volatility = .2, \n",
    "                                                                            option = 'call', dividend = .025)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'delta': 0.14002412854910162,\n",
       " 'gamma': 0.05225745967362611,\n",
       " 'rho': 1.957553740472613,\n",
       " 'theta': -0.8747672525228961,\n",
       " 'vega': 4.703171370626351}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeks_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 2</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    Modify the function <code>black_scholes_formula</code> to take in a <b>boolean</b> input parameter called <code>greeks</code> that can be either <code>True</code> or <code>False</code>, a default value of <code>False</code>.\n",
    "    <br><br>If <code>greeks</code> is <code>True</code>, then in addition to producing the price of a call / put option, <code>black_scholes_formula</code> will also calculate the greeks of the option by calling the function <code>black_scholes_greeks</code> (<b><u>do not</u></b> code the formulas for the greeks again), and return the delta, gamma, vega, theta, and rho as a dictionary, in addition to the price of the option.\n",
    "    <br><br>If <code>greeks</code> is <code>False</code>, then simply return the price of the option just like before. Run <code>black_scholes_formula</code> to price of a call option where:\n",
    "    <ul>\n",
    "        <li><code>stock_price</code> = \\$30</li>\n",
    "        <li><code>strike</code> = \\$35</li>\n",
    "        <li><code>term</code> = 6 months</li>\n",
    "        <li><code>rf</code> = 1%</li>\n",
    "        <li><code>volatility</code> = 0.2</li>\n",
    "        <li><code>dividend</code> = 2.5%</li>\n",
    "        <li><code>greeks</code> = True</li>\n",
    "    </ul>\n",
    "    Your function should return an output like this:\n",
    "    ![Task_2_Output.JPG](attachment:Task_2_Output.JPG)\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def black_scholes_formula(stock_price, strike, term, rf, volatility, option, dividend = 0, greeks = False):\n",
    "    \n",
    "    d1 = (1 / (volatility * np.sqrt(term))) * (np.log(stock_price / strike) + (rf - dividend + .5 * \n",
    "                                                                               (volatility ** 2)) * term)\n",
    "    d2 = d1 - volatility * np.sqrt(term)\n",
    "    \n",
    "    if option == 'call' and greeks == True:\n",
    "        price = stock_price * np.exp(-dividend * term) * norm.cdf(d1, 0, 1) - \\\n",
    "                                        strike * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "        return price, greeks_results\n",
    "    elif option == 'call' and greeks == False:\n",
    "        price = stock_price * np.exp(-dividend * term) * norm.cdf(d1, 0, 1) - \\\n",
    "                                        strike * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "    elif option == 'put' and greeks == True:\n",
    "        price = strike * np.exp(-rf * term) * norm.cdf(-d2, 0, 1) - \\\n",
    "                                        stock_price * np.exp(-dividend * term) * norm.cdf(-d1, 0, 1)\n",
    "        return price, greeks_results\n",
    "    elif option == 'put' and greeks == False:\n",
    "        price = strike * np.exp(-rf * term) * norm.cdf(-d2, 0, 1) - \\\n",
    "                                        stock_price * np.exp(-dividend * term) * norm.cdf(-d1, 0, 1)\n",
    "    return price\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "price_greeks = black_scholes_formula(stock_price = 30, strike = 35, term = .5, rf = .01, volatility = .2, \n",
    "                                                             option = 'call', dividend = .025, greeks = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.2856163755278227,\n",
       " {'delta': 0.14002412854910162,\n",
       "  'gamma': 0.05225745967362611,\n",
       "  'rho': 1.957553740472613,\n",
       "  'theta': -0.8747672525228961,\n",
       "  'vega': 4.703171370626351})"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price_greeks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 3</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    One of the assumptions to the Black-Scholes pricing model is that the risk-free interest rate is constant. However in practice, interest rates should follow a term structure, such as the spot curve.\n",
    "    <br><br>Assume that the spot curve follows the below formula:\n",
    "    <br><br>\n",
    "    $$r(t) = \\beta_0 + \\beta_1\\left(\\frac{1 - e^{-\\alpha t}}{\\alpha t}\\right) + \\beta_2\\left(\\frac{1 - e^{-\\alpha t}}{\\alpha t} - e^{-\\alpha t}\\right)$$\n",
    "    <br>Note that resulting $r(t)$ is expressed as a percentage. Set the parameters equal to the following values:\n",
    "    <ul>\n",
    "        <li>$\\alpha = .7143$</li>\n",
    "        <li>$\\beta_0 = 2.99$</li>\n",
    "        <li>$\\beta_1 = -2.70$</li>\n",
    "        <li>$\\beta_2 = -2.12$</li>\n",
    "    </ul>\n",
    "    <br>Next:\n",
    "    <ul>\n",
    "        <li>Write a function that takes in <code>term</code> as an input parameter, then calculates and returns the spot rate according to the formula above.</li>\n",
    "        <li>Plot the spot curve for terms ranging from 1 quarter to 30 years in quarterly increments on a line plot. Provide axis labels and a title for the plot. Your final plot should look something like this:\n",
    "        ![Task_7_Plot.JPG](attachment:Task_7_Plot.JPG)</li>\n",
    "        <li>Comment on the shape and reasonableness of this calculated spot curve. </li>\n",
    "    </ul>\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spot_curve_formula(alpha, beta0, beta1, beta2, term):\n",
    "    \n",
    "    spot_curve = beta0 + beta1 * ((1 - np.exp(-alpha * term)) / (alpha * term)) + beta2 * \\\n",
    "                                    ((1 - np.exp(-alpha * term)) / (alpha * term) - (np.exp(-alpha * term)))\n",
    "    return spot_curve\n",
    "\n",
    "T = np.arange(.25, 30.25, .25)\n",
    "spot_rate = spot_curve_formula(alpha = .7143, beta0 = 2.99, beta1 = -2.70, beta2 = -2.12, term = T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(T, spot_rate)\n",
    "plt.title('Model Spot Curve')\n",
    "plt.xlabel('T')\n",
    "plt.ylabel('Spot Rate (%)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 4</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    Modify the function <code>black_scholes_formula</code> to use the spot rate outputted from the function in the previous task as the appropriate risk-free rate in our Black-Scholes formula based on the term of the options contract.\n",
    "    <br><br>Note that this means <code>rf</code> will no longer be an input to the <code>black_scholes_formula</code> function. Run <code>black_scholes_formula</code> to price the following options:\n",
    "    <ul>\n",
    "        <li>A call option where the stock price is \\$30, strike is \\$35, term is 9 months, volatility is 20%, that also pays a 2.5% annual dividend, with <code>greeks</code> set to <code>True</code>. Check that your function prices this option at approximately \\$0.4822.</li>\n",
    "        <li>A put option where the stock price is \\$35, strike is \\$30, term is 2 years, volatility is 20%, that also pays a 2.5% annual dividend, with <code>greeks</code> set to <code>True</code>. Check that your function prices this option at approximately \\$1.9289.</li>\n",
    "    </ul>\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def black_scholes_formula(stock_price, strike, term, volatility, option, dividend = 0, greeks = False):\n",
    "    \n",
    "    rf = spot_curve_formula(alpha = .7143, beta0 = 2.99, beta1 = -2.70, beta2 = -2.12, term = term) / 100\n",
    "    \n",
    "    d1 = (1 / (volatility * np.sqrt(term))) * (np.log(stock_price / strike) + (rf - dividend + .5 * \n",
    "                                                                               (volatility ** 2)) * term)\n",
    "    d2 = d1 - volatility * np.sqrt(term)\n",
    "\n",
    "    if option == 'call' and greeks == True:\n",
    "        price = stock_price * np.exp(-dividend * term) * norm.cdf(d1, 0, 1) - \\\n",
    "                                        strike * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "        return price, greeks_results\n",
    "    elif option == 'call' and greeks == False:\n",
    "        price = stock_price * np.exp(-dividend * term) * norm.cdf(d1, 0, 1) - \\\n",
    "                                        strike * np.exp(-rf * term) * norm.cdf(d2, 0, 1)\n",
    "    elif option == 'put' and greeks == True:\n",
    "        price = strike * np.exp(-rf * term) * norm.cdf(-d2, 0, 1) - \\\n",
    "                                        stock_price * np.exp(-dividend * term) * norm.cdf(-d1, 0, 1)\n",
    "        return price, greeks_results\n",
    "    elif option == 'put' and greeks == False:\n",
    "        price = strike * np.exp(-rf * term) * norm.cdf(-d2, 0, 1) - \\\n",
    "                                        stock_price * np.exp(-dividend * term) * norm.cdf(-d1, 0, 1)\n",
    "    return price\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "call = black_scholes_formula(stock_price = 30, strike = 35, term = .75, volatility = .2, \n",
    "                                                             option = 'call', dividend = .025, greeks = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.48218332751282755,\n",
       " {'delta': 0.14002412854910162,\n",
       "  'gamma': 0.05225745967362611,\n",
       "  'rho': 1.957553740472613,\n",
       "  'theta': -0.8747672525228961,\n",
       "  'vega': 4.703171370626351})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "put = black_scholes_formula(stock_price = 35, strike = 30, term = 2, volatility = .2, \n",
    "                                                             option = 'put', dividend = .025, greeks = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.928873211758626,\n",
       " {'delta': 0.14002412854910162,\n",
       "  'gamma': 0.05225745967362611,\n",
       "  'rho': 1.957553740472613,\n",
       "  'theta': -0.8747672525228961,\n",
       "  'vega': 4.703171370626351})"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "put"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 5</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    On June 30th, 2020, the AAPL's stock price was valued at \\$364.14 and paying a dividend yield of 0.9%. On that same day, a call option on AAPL with a strike of \\$380, expiring in 6-months was trading at \\$26.\n",
    "    <br><br>Estimate the implied volatility on this call option using the bisection method with a tolerance of $0.001 on the error of the calculated Black-Scholes call option price. Set <code>option</code> to <code>call</code> and <code>greeks</code> to <code>False</code> when calling the function <code>black_scholes_formula</code>.\n",
    "    <br><br>Your final estimated implied volatility should be approximately 0.3228.\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "call = black_scholes_formula(stock_price = 364.14, strike = 380, term= .5, volatility = .15, option = 'call', dividend = .009, greeks = False)\n",
    "\n",
    "left_volatility = .1\n",
    "right_volatility = .50\n",
    "tol = 26 - call\n",
    "while abs(tol) > 0.001:\n",
    "    volatility = (left_volatility + right_volatility) / 2\n",
    "    call = black_scholes_formula(stock_price = 364.14, strike = 380, term = .5, volatility = volatility, \n",
    "                                 option = 'call', dividend = .009, greeks = False)\n",
    "    tol = 26 - call\n",
    "    \n",
    "    if tol > 0:\n",
    "        left_volatility = volatility\n",
    "    else:\n",
    "        right_volatility = volatility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.32280273437499996"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volatility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}