{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Postsynaptic trace computation\n",
    "==============================\n",
    "\n",
    "Pre- and postsynaptic traces are used to calculate STDP weight updates, but are computed differently: postsynaptic traces are stored and maintained in the NEST C++ `ArchivingNode` class. Following [nest-simulator#1034](https://github.com/nest/nest-simulator/issues/1034), this notebook (and corresponding unit test in `test_regression_issue-1034.py`) was created to specifically test the postsynaptic trace value, by comparing the NEST-obtained samples to a Python-generated reference timeseries.\n",
    "\n",
    "Construct a network of the form:\n",
    "- pre_spike_gen connects via static_synapse to pre_parrot\n",
    "- pre_parrot connects via stdp_synapse to post_parrot\n",
    "- post_spike_gen connects via static_synapse to post_parrot\n",
    "\n",
    "The spike times of the spike generators are defined in\n",
    "`pre_spike_times` and `post_spike_times`. From the perspective of the\n",
    "STDP synapse, spikes arrive with the following delays (with respect to\n",
    "the values in these lists):\n",
    "\n",
    "- for the presynaptic neuron: one synaptic delay in the static synapse\n",
    "- for the postsynaptic neuron: one synaptic delay in the static synapse\n",
    "- for the synapse itself: one dendritic delay between the post_parrot\n",
    "  node and the synapse itself (see the C++ variable `dendritic_delay`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as plticker\n",
    "import nest\n",
    "import numpy as np\n",
    "import os\n",
    "import scipy as sp\n",
    "import scipy.stats\n",
    "import unittest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NEST simulation\n",
    "---------------\n",
    "\n",
    "Construct and run the NEST network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_post_trace_test_nest_(pre_spike_times, post_spike_times,\n",
    "                              resolution, delay, sim_time, tau_minus,\n",
    "                              show_all_nest_trace_samples=False,\n",
    "                              debug=False):\n",
    "\n",
    "    if debug:\n",
    "        print(\"Pre spike times: [\"\n",
    "              + \", \".join([str(t) for t in pre_spike_times]) + \"]\")\n",
    "        print(\"Post spike times: [\"\n",
    "              + \", \".join([str(t) for t in post_spike_times]) + \"]\")\n",
    "\n",
    "    nest.set_verbosity(\"M_WARNING\")\n",
    "\n",
    "    nest.ResetKernel()\n",
    "    nest.resolution = resolution\n",
    "\n",
    "    wr = nest.Create(\"weight_recorder\")\n",
    "    nest.CopyModel(\"stdp_synapse\", \"stdp_synapse_rec\",\n",
    "                   {\"weight_recorder\": wr, \"weight\": 1.})\n",
    "\n",
    "    # create spike_generators with these times\n",
    "    pre_sg_ps = nest.Create(\"spike_generator\",\n",
    "                            params={\"spike_times\": pre_spike_times,\n",
    "                                    \"precise_times\": True})\n",
    "    post_sg_ps = nest.Create(\"spike_generator\",\n",
    "                             params={\"spike_times\": post_spike_times,\n",
    "                                     \"precise_times\": True})\n",
    "\n",
    "    # create parrot neurons and connect spike_generators\n",
    "    pre_parrot_ps = nest.Create(\"parrot_neuron_ps\")\n",
    "    post_parrot_ps = nest.Create(\"parrot_neuron_ps\",\n",
    "                                 params={\"tau_minus\": tau_minus})\n",
    "\n",
    "    nest.Connect(pre_sg_ps, pre_parrot_ps, syn_spec={\"delay\": delay})\n",
    "    nest.Connect(post_sg_ps, post_parrot_ps,syn_spec={\"delay\": delay})\n",
    "\n",
    "    # create spike recorder --- debugging only\n",
    "    spikes = nest.Create(\"spike_recorder\")\n",
    "    nest.Connect(pre_parrot_ps + post_parrot_ps, spikes)\n",
    "\n",
    "    # connect both parrot neurons with a stdp synapse onto port 1\n",
    "    # so spikes transmitted through the stdp connection are\n",
    "    # not repeated postsynaptically.\n",
    "    nest.Connect(\n",
    "        pre_parrot_ps, post_parrot_ps,\n",
    "        syn_spec={'synapse_model': 'stdp_synapse_rec',\n",
    "                  'receptor_type': 1,\n",
    "                  'delay': delay})\n",
    "\n",
    "    if debug:\n",
    "        print(\"[py] Total simulation time: \" + str(sim_time) + \" ms\")\n",
    "\n",
    "    n_steps = int(np.ceil(sim_time / delay))\n",
    "    trace_nest = []\n",
    "    trace_nest_t = []\n",
    "\n",
    "    t = nest.biological_time\n",
    "    trace_nest_t.append(t)\n",
    "\n",
    "    post_tr = post_parrot_ps.post_trace\n",
    "    trace_nest.append(post_tr)\n",
    "\n",
    "    for step in range(n_steps):\n",
    "        if debug:\n",
    "            print(\"\\n[py] simulating for \" + str(delay) + \" ms\")\n",
    "        nest.Simulate(delay)\n",
    "        t = nest.biological_time\n",
    "        nearby_pre_spike = np.any(\n",
    "            np.abs(t - np.array(pre_spike_times) - delay) < resolution/2.)\n",
    "        if show_all_nest_trace_samples or nearby_pre_spike:\n",
    "            trace_nest_t.append(t)\n",
    "            post_tr = post_parrot_ps.post_trace\n",
    "            trace_nest.append(post_tr)\n",
    "            if debug:\n",
    "                print(\"[py] Received NEST trace: \" +\n",
    "                      str(post_tr) + \" at time t = \" + str(t))\n",
    "\n",
    "    return trace_nest_t, trace_nest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python simulation\n",
    "-----------------\n",
    "\n",
    "Generate the Python reference timeseries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_post_trace_test_python_reference_(pre_spike_times,\n",
    "                                          post_spike_times, resolution,\n",
    "                                          dendritic_delay, sim_time,\n",
    "                                          tau_minus, debug=False):\n",
    "    \"\"\"\n",
    "    compute Python known-good reference of postsynaptic trace\n",
    "    \"\"\"\n",
    "\n",
    "    n_timepoints = 1000 * int(np.ceil(sim_time))\n",
    "    trace_python_ref = np.zeros(n_timepoints)\n",
    "\n",
    "    n_spikes = len(post_spike_times)\n",
    "    for sp_idx in range(n_spikes):\n",
    "        t_sp = post_spike_times[sp_idx] + 2 * dendritic_delay\n",
    "        for i in range(n_timepoints):\n",
    "            t = (i / float(n_timepoints - 1)) * sim_time\n",
    "            if t > t_sp:\n",
    "                trace_python_ref[i] += np.exp(-(t - t_sp) / tau_minus)\n",
    "\n",
    "    n_spikes = len(pre_spike_times)\n",
    "    for sp_idx in range(n_spikes):\n",
    "        t_sp = pre_spike_times[sp_idx] + dendritic_delay\n",
    "        i = int(np.round(t_sp / sim_time\n",
    "                         * float(len(trace_python_ref) - 1)))\n",
    "        if debug:\n",
    "            print(\"* At t_sp = \" + str(t_sp)\n",
    "              + \", post_trace should be \" + str(trace_python_ref[i]))\n",
    "\n",
    "    return trace_python_ref"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the test\n",
    "------------\n",
    "\n",
    "First, define some pre/post spike patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# spike test pattern: generate some random integer spike times\n",
    "t_sp_min = 1.\n",
    "t_sp_max = 50\n",
    "\n",
    "# pre spikes\n",
    "n_spikes = 10\n",
    "pre_spike_times = np.sort(\n",
    "    np.unique(\n",
    "        np.ceil(\n",
    "            sp.stats.uniform.rvs(\n",
    "                t_sp_min, t_sp_max - t_sp_min, n_spikes))))\n",
    "\n",
    "# post spikes\n",
    "n_spikes = 50\n",
    "post_spike_times = np.sort(\n",
    "    np.unique(\n",
    "        np.ceil(\n",
    "            sp.stats.uniform.rvs(\n",
    "                t_sp_min, t_sp_max - t_sp_min, n_spikes))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function that will validate equality between the Python-generated and the NEST-generated timeseries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace_match_atol = 1E-3\n",
    "trace_match_rtol = 1E-3\n",
    "\n",
    "def nest_trace_matches_ref_trace(trace_nest_t, trace_nest,\n",
    "                                 trace_python_ref, pre_spike_times,\n",
    "                                 post_spike_times, resolution,\n",
    "                                 dendritic_delay, trace_match_atol,\n",
    "                                 trace_match_rtol, sim_time,\n",
    "                                 debug=False):\n",
    "    \"\"\"\n",
    "    Trace values are returned from NEST at regular intervals, but only\n",
    "    updated at presynaptic spike times.\n",
    "\n",
    "    To match the NEST samples with the continuous reference trace, step\n",
    "    backwards in time from the sampled value, to find the last time at\n",
    "    which the trace value was updated, namely the time of occurrence of\n",
    "    the last presynaptic spike.\n",
    "    \"\"\"\n",
    "\n",
    "    n_timepoints = len(trace_nest_t)\n",
    "    for i in range(n_timepoints)[1:]:\n",
    "        t = trace_nest_t[i]\n",
    "        if debug:\n",
    "            print(\"* Finding ref for NEST timepoint t = \" + str(t)\n",
    "                  + \", NEST trace = \" + str(trace_nest[i]))\n",
    "\n",
    "        traces_match = False\n",
    "        for i_search, t_search in enumerate(\n",
    "                reversed(np.array(pre_spike_times) + dendritic_delay)):\n",
    "            if t_search <= t:\n",
    "                _trace_at_t_search = trace_python_ref[int(np.round(\n",
    "                    t_search / sim_time\n",
    "                    * float(len(trace_python_ref) - 1)))]\n",
    "                traces_match = np.allclose(\n",
    "                    _trace_at_t_search,\n",
    "                    trace_nest[i],\n",
    "                    atol=trace_match_atol,\n",
    "                    rtol=trace_match_rtol)\n",
    "                post_spike_occurred_at_t_search = np.any(\n",
    "                    (t_search - (np.array(post_spike_times)\n",
    "                                 + 2 * dendritic_delay))**2\n",
    "                    < resolution/2.)\n",
    "\n",
    "                if debug:\n",
    "                    print(\"\\t* Testing \" + str(t_search) + \"...\")\n",
    "                    print(\"\\t   traces_match = \" + str(traces_match))\n",
    "                    print(\"\\t   post_spike_occurred_at_t_search = \"\n",
    "                          + str(post_spike_occurred_at_t_search))\n",
    "\n",
    "                if (not traces_match) and post_spike_occurred_at_t_search:\n",
    "                    traces_match = np.allclose(\n",
    "                        _trace_at_t_search + 1,\n",
    "                        trace_nest[i],\n",
    "                        atol=trace_match_atol,\n",
    "                        rtol=trace_match_rtol)\n",
    "                    if debug:\n",
    "                        print(\"\\t   traces_match = \" + str(traces_match)\n",
    "                              + \" (nest trace = \" + str(trace_nest[i])\n",
    "                              + \", ref trace = \"\n",
    "                              + str(_trace_at_t_search + 1)\n",
    "                              + \")\")\n",
    "                    if traces_match:\n",
    "                        _trace_at_t_search += 1.\n",
    "\n",
    "                if (not traces_match) and post_spike_occurred_at_t_search:\n",
    "                    traces_match = np.allclose(\n",
    "                        _trace_at_t_search - 1,\n",
    "                        trace_nest[i],\n",
    "                        atol=trace_match_atol,\n",
    "                        rtol=trace_match_rtol)\n",
    "                    if debug:\n",
    "                        print(\"\\t   traces_match = \" + str(traces_match)\n",
    "                              + \" (nest trace = \" + str(trace_nest[i])\n",
    "                              + \", ref trace = \"\n",
    "                              + str(_trace_at_t_search - 1)\n",
    "                              + \")\")\n",
    "                    if traces_match:\n",
    "                        _trace_at_t_search -= 1.\n",
    "\n",
    "                break\n",
    "\n",
    "        if (not traces_match) and i_search == len(pre_spike_times) - 1:\n",
    "            if debug:\n",
    "                print(\"\\tthe time before the first pre spike\")\n",
    "            # the time before the first pre spike\n",
    "            traces_match = trace_nest[i] == 0.\n",
    "\n",
    "        if not traces_match:\n",
    "            return False\n",
    "\n",
    "    return True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_run(trace_nest_t, trace_nest, trace_python_ref,\n",
    "             pre_spike_times, post_spike_times, resolution,\n",
    "             dendritic_delay, trace_match_atol, trace_match_rtol,\n",
    "             sim_time, title_snip=\"\", debug=False):\n",
    "\n",
    "    fig, ax = plt.subplots(nrows=3, dpi=120)\n",
    "    ax1, ax2, ax3 = ax\n",
    "\n",
    "    #\n",
    "    #   pre spikes\n",
    "    #\n",
    "\n",
    "    ax1.set_ylim([0., 1.])\n",
    "    ax1.set_ylabel(\"Pre spikes\")\n",
    "    n_spikes = len(pre_spike_times)\n",
    "    for i in range(n_spikes):\n",
    "        ax1.plot(2 * [pre_spike_times[i] + dendritic_delay],\n",
    "                 ax1.get_ylim(),\n",
    "                 linewidth=2, color=\"blue\", alpha=.4)\n",
    "\n",
    "    #\n",
    "    #   post spikes\n",
    "    #\n",
    "\n",
    "    ax2.set_ylim([0., 1.])\n",
    "    ax2.set_ylabel(\"Post spikes\")\n",
    "    n_spikes = len(post_spike_times)\n",
    "    for i in range(n_spikes):\n",
    "        ax2.plot(2 * [post_spike_times[i] + 2 * dendritic_delay],\n",
    "                 [0, 1],\n",
    "                 linewidth=2, color=\"red\", alpha=.4)\n",
    "\n",
    "    #\n",
    "    #   traces\n",
    "    #\n",
    "\n",
    "    ax3.set_ylabel(\"Synaptic trace\")\n",
    "    ax3.set_ylim([0., np.amax(trace_python_ref)])\n",
    "    ax3.plot(np.linspace(0., sim_time, len(trace_python_ref)),\n",
    "             trace_python_ref,\n",
    "             label=\"Expected\", color=\"cyan\", alpha=.6)\n",
    "    ax3.scatter(trace_nest_t, trace_nest,\n",
    "                marker=\".\", alpha=.5, color=\"orange\", label=\"NEST\")\n",
    "    ax3.legend()\n",
    "\n",
    "    #\n",
    "    #   Trace values are returned from NEST at regular intervals, but only\n",
    "    #   updated at presynaptic spike times.\n",
    "    #\n",
    "    #   Step backwards in time from the sampled value, to find the last\n",
    "    #   time at which the trace value was updated, namely the time of\n",
    "    #   occurrence of the last presynaptic spike.\n",
    "    #\n",
    "\n",
    "    pre_spike_times = np.array(pre_spike_times)\n",
    "    n_timepoints = len(trace_nest_t)\n",
    "    for i in range(n_timepoints):\n",
    "        t = trace_nest_t[i]\n",
    "        if debug:\n",
    "            print(\"* Finding ref for NEST timepoint t = \"\n",
    "                  + str(t) + \", trace = \" + str(trace_nest[i]))\n",
    "        for t_search in reversed(pre_spike_times + dendritic_delay):\n",
    "            if t_search <= t:\n",
    "                if debug:\n",
    "                    print(\"\\t* Testing \" + str(t_search) + \"...\")\n",
    "                _idx = int(np.round(t_search / sim_time\n",
    "                           * float(len(trace_python_ref) - 1)))\n",
    "                _trace_at_t_search = trace_python_ref[_idx]\n",
    "                traces_match = np.allclose(_trace_at_t_search,\n",
    "                                           trace_nest[i],\n",
    "                                           atol=trace_match_atol,\n",
    "                                           rtol=trace_match_rtol)\n",
    "                if debug:\n",
    "                    print(\"\\t   traces_match = \" + str(traces_match))\n",
    "                if not traces_match:\n",
    "                    post_spike_occurred_at_t_search = np.any(\n",
    "                        (t_search - (np.array(post_spike_times)\n",
    "                         + 2 * dendritic_delay))**2 < resolution/2.)\n",
    "                    if debug:\n",
    "                        print(\"\\t   post_spike_occurred_at_t_search = \"\n",
    "                              + str(post_spike_occurred_at_t_search))\n",
    "                    if post_spike_occurred_at_t_search:\n",
    "                        traces_match = np.allclose(\n",
    "                            _trace_at_t_search + 1,\n",
    "                            trace_nest[i],\n",
    "                            atol=trace_match_atol,\n",
    "                            rtol=trace_match_rtol)\n",
    "                        if debug:\n",
    "                            print(\"\\t   traces_match = \" + str(traces_match)\n",
    "                                  + \" (nest trace = \" + str(trace_nest[i])\n",
    "                                  + \", ref trace = \"\n",
    "                                  + str(_trace_at_t_search+1) + \")\")\n",
    "                        \n",
    "                        if traces_match:\n",
    "                            _trace_at_t_search += 1.\n",
    "\n",
    "                        if not traces_match:\n",
    "                            traces_match = np.allclose(\n",
    "                                _trace_at_t_search - 1,\n",
    "                                trace_nest[i],\n",
    "                                atol=trace_match_atol,\n",
    "                                rtol=trace_match_rtol)\n",
    "                            \n",
    "                            if debug:\n",
    "                                print(\"\\t   traces_match = \"\n",
    "                                      + str(traces_match)\n",
    "                                      + \" (nest trace = \"\n",
    "                                      + str(trace_nest[i])\n",
    "                                      + \", ref trace = \"\n",
    "                                      + str(_trace_at_t_search-1) + \")\")\n",
    "                            \n",
    "                            if traces_match:\n",
    "                                _trace_at_t_search -= 1.\n",
    "\n",
    "                ax3.scatter(t_search, _trace_at_t_search, 100, marker=\".\",\n",
    "                            color=\"#A7FF00FF\", facecolor=\"none\")\n",
    "                ax3.plot([trace_nest_t[i], t_search],\n",
    "                         [trace_nest[i], _trace_at_t_search],\n",
    "                         linewidth=.5, color=\"#0000007F\")\n",
    "                break\n",
    "\n",
    "    for _ax in ax:\n",
    "        _ax.xaxis.set_major_locator(\n",
    "            plticker.MultipleLocator(base=10*dendritic_delay))\n",
    "        _ax.xaxis.set_minor_locator(\n",
    "            plticker.MultipleLocator(base=dendritic_delay))\n",
    "        _ax.grid(which=\"major\", axis=\"both\")\n",
    "        _ax.grid(which=\"minor\", axis=\"x\", linestyle=\":\", alpha=.4)\n",
    "        _ax.set_xlim(0., sim_time)\n",
    "\n",
    "    ax3.set_xlabel(\"Time [ms]\")\n",
    "    fig.suptitle(title_snip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, run the test and make the plots while we go.\n",
    "\n",
    "The plots should be interpreted as follows. Pre- and postsynaptic spikes are shown in the top two subplots, at the time at which they arrive at the synapse (i.e. from the perspective of the synapse, taking dendritic and axonal delays into account).\n",
    "\n",
    "The bottom subplot shows the reference/known-good timeseries generated (numerically) in Python (**cyan colour**). The values returned from NEST are shown using **orange circles**. They are plotted as points rather than as a continuous line, because we can only retrieve the value at the resolution of the minimum synaptic delay (i.e. fetch trace value; simulate for a timestep `delay`; repeat). Moreover, the postsynaptic trace value is only updated in NEST during the processing of a presynaptic spike, so unless a presynaptic spike was processed in the last delay interval, the value will remain unchanged. To allow comparison between the Python- and NEST-generated values, we thus search for the previous time at which NEST would have updated the trace value, which is the time of arrival of the last presynaptic spike. This value is marked by an **open green circle**. If all is well, all green circles should always overlap an orange circle, and all **black lines** (which simply connect subsequent postsynaptic trace values returned by NEST) should be perfectly horizontal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x480 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "resolution = .1      # [ms]\n",
    "dendritic_delay = 1. # [ms]\n",
    "tau_minus = 2.       # [ms]\n",
    "\n",
    "# settings for plotting debug information\n",
    "show_all_nest_trace_samples = True\n",
    "\n",
    "max_t_sp = max(np.amax(pre_spike_times),\n",
    "               np.amax(post_spike_times))\n",
    "sim_time = max_t_sp + 5 * dendritic_delay\n",
    "trace_nest_t, trace_nest = run_post_trace_test_nest_(\n",
    "    pre_spike_times,\n",
    "    post_spike_times,\n",
    "    resolution, dendritic_delay, sim_time, tau_minus,\n",
    "    show_all_nest_trace_samples)\n",
    "trace_python_ref = run_post_trace_test_python_reference_(\n",
    "    pre_spike_times,\n",
    "    post_spike_times,\n",
    "    resolution, dendritic_delay, sim_time, tau_minus)\n",
    "\n",
    "title_snip = \"Dendritic delay = \" + str(dendritic_delay)\n",
    "plot_run(\n",
    "    trace_nest_t, trace_nest, trace_python_ref,\n",
    "    pre_spike_times,\n",
    "    post_spike_times, resolution,\n",
    "    dendritic_delay, trace_match_atol, trace_match_rtol,\n",
    "    sim_time, title_snip)\n",
    "assert nest_trace_matches_ref_trace(\n",
    "    trace_nest_t,\n",
    "    trace_nest,\n",
    "    trace_python_ref,\n",
    "    pre_spike_times,\n",
    "    post_spike_times,\n",
    "    resolution, dendritic_delay,\n",
    "    trace_match_atol,\n",
    "    trace_match_rtol,\n",
    "    sim_time,\n",
    "    debug=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "License\n",
    "-------\n",
    "\n",
    "This file is part of NEST. Copyright (C) 2004 The NEST Initiative\n",
    "\n",
    "NEST is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.\n",
    "\n",
    "NEST is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details."
   ]
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}