{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/EugOT/compneuro/blob/main/notebooks/2023-12-03-DynamicNetworks-3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a> &nbsp; <a href=\"https://kaggle.com/kernels/welcome?src=https://raw.githubusercontent.com/EugOT/compneuro/main/notebooks/2023-11-26-DynamicNetworks-3.ipynb\" target=\"_parent\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" alt=\"Open in Kaggle\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "L9HEfWTjlW1l"
      },
      "source": [
        "# Tutorial 3: Extending the Wilson-Cowan Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "AsqHgQp4lW1l"
      },
      "source": [
        "---\n",
        "# Tutorial Objectives\n",
        "In the previous tutorial, you learned about the **Wilson-Cowan** rate model. Here we will dive into some deeper analyses of this model.\n",
        "\n",
        "Bonus steps:\n",
        "\n",
        "- Find and plot the **fixed points** of the Wilson-Cowan model.\n",
        "- Investigate the stability of the Wilson-Cowan model by linearizing its dynamics and examining the **Jacobian matrix**.\n",
        "- Learn how the Wilson-Cowan model can reach an oscillatory state.\n",
        "\n",
        "Applications of Wilson-Cowan model:\n",
        "- Visualize the behavior of an Inhibition-stabilized network.\n",
        "- Simulate working memory using the Wilson-Cowan model.\n",
        "\n",
        "<br>\n",
        "\n",
        "Reference paper:\n",
        "\n",
        "Wilson, H., and Cowan, J. (1972). Excitatory and inhibitory interactions in localized populations of model neurons. _Biophysical Journal_ **12**. doi: [10.1016/S0006-3495(72)86068-5](https://doi.org/10.1016/S0006-3495(72)86068-5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "N3AthGqrlW1m"
      },
      "source": [
        "---\n",
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "cellView": "both",
        "execution": {},
        "id": "6NaJ9lGClW1m"
      },
      "outputs": [],
      "source": [
        "# Imports\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import scipy.optimize as opt  # root-finding algorithm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "Kv-SQ_MblW1n"
      },
      "outputs": [],
      "source": [
        "# @title Figure Settings\n",
        "import logging\n",
        "logging.getLogger('matplotlib.font_manager').disabled = True\n",
        "\n",
        "import ipywidgets as widgets  # interactive display\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "plt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content/main/nma.mplstyle\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "1Yx68ZCmlW1n"
      },
      "outputs": [],
      "source": [
        "# @title Plotting Functions\n",
        "\n",
        "def plot_FI_inverse(x, a, theta):\n",
        "  f, ax = plt.subplots()\n",
        "  ax.plot(x, F_inv(x, a=a, theta=theta))\n",
        "  ax.set(xlabel=\"$x$\", ylabel=\"$F^{-1}(x)$\")\n",
        "\n",
        "\n",
        "def plot_FI_EI(x, FI_exc, FI_inh):\n",
        "  plt.figure()\n",
        "  plt.plot(x, FI_exc, 'b', label='E population')\n",
        "  plt.plot(x, FI_inh, 'r', label='I population')\n",
        "  plt.legend(loc='lower right')\n",
        "  plt.xlabel('x (a.u.)')\n",
        "  plt.ylabel('F(x)')\n",
        "  plt.show()\n",
        "\n",
        "\n",
        "def my_test_plot(t, rE1, rI1, rE2, rI2):\n",
        "\n",
        "  plt.figure()\n",
        "  ax1 = plt.subplot(211)\n",
        "  ax1.plot(pars['range_t'], rE1, 'b', label='E population')\n",
        "  ax1.plot(pars['range_t'], rI1, 'r', label='I population')\n",
        "  ax1.set_ylabel('Activity')\n",
        "  ax1.legend(loc='best')\n",
        "\n",
        "  ax2 = plt.subplot(212, sharex=ax1, sharey=ax1)\n",
        "  ax2.plot(pars['range_t'], rE2, 'b', label='E population')\n",
        "  ax2.plot(pars['range_t'], rI2, 'r', label='I population')\n",
        "  ax2.set_xlabel('t (ms)')\n",
        "  ax2.set_ylabel('Activity')\n",
        "  ax2.legend(loc='best')\n",
        "\n",
        "  plt.tight_layout()\n",
        "  plt.show()\n",
        "\n",
        "\n",
        "def plot_nullclines(Exc_null_rE, Exc_null_rI, Inh_null_rE, Inh_null_rI):\n",
        "\n",
        "  plt.figure()\n",
        "  plt.plot(Exc_null_rE, Exc_null_rI, 'b', label='E nullcline')\n",
        "  plt.plot(Inh_null_rE, Inh_null_rI, 'r', label='I nullcline')\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "  plt.legend(loc='best')\n",
        "  plt.show()\n",
        "\n",
        "\n",
        "def my_plot_nullcline(pars):\n",
        "  Exc_null_rE = np.linspace(-0.01, 0.96, 100)\n",
        "  Exc_null_rI = get_E_nullcline(Exc_null_rE, **pars)\n",
        "  Inh_null_rI = np.linspace(-.01, 0.8, 100)\n",
        "  Inh_null_rE = get_I_nullcline(Inh_null_rI, **pars)\n",
        "\n",
        "  plt.plot(Exc_null_rE, Exc_null_rI, 'b', label='E nullcline')\n",
        "  plt.plot(Inh_null_rE, Inh_null_rI, 'r', label='I nullcline')\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "  plt.legend(loc='best')\n",
        "\n",
        "\n",
        "def my_plot_vector(pars, my_n_skip=2, myscale=5):\n",
        "  EI_grid = np.linspace(0., 1., 20)\n",
        "  rE, rI = np.meshgrid(EI_grid, EI_grid)\n",
        "  drEdt, drIdt = EIderivs(rE, rI, **pars)\n",
        "\n",
        "  n_skip = my_n_skip\n",
        "\n",
        "  plt.quiver(rE[::n_skip, ::n_skip], rI[::n_skip, ::n_skip],\n",
        "             drEdt[::n_skip, ::n_skip], drIdt[::n_skip, ::n_skip],\n",
        "             angles='xy', scale_units='xy', scale=myscale, facecolor='c')\n",
        "\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "\n",
        "\n",
        "def my_plot_trajectory(pars, mycolor, x_init, mylabel):\n",
        "  pars = pars.copy()\n",
        "  pars['rE_init'], pars['rI_init'] = x_init[0], x_init[1]\n",
        "  rE_tj, rI_tj = simulate_wc(**pars)\n",
        "\n",
        "  plt.plot(rE_tj, rI_tj, color=mycolor, label=mylabel)\n",
        "  plt.plot(x_init[0], x_init[1], 'o', color=mycolor, ms=8)\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "\n",
        "\n",
        "def my_plot_trajectories(pars, dx, n, mylabel):\n",
        "  \"\"\"\n",
        "  Solve for I along the E_grid from dE/dt = 0.\n",
        "\n",
        "  Expects:\n",
        "  pars    : Parameter dictionary\n",
        "  dx      : increment of initial values\n",
        "  n       : n*n trjectories\n",
        "  mylabel : label for legend\n",
        "\n",
        "  Returns:\n",
        "    figure of trajectory\n",
        "  \"\"\"\n",
        "  pars = pars.copy()\n",
        "  for ie in range(n):\n",
        "    for ii in range(n):\n",
        "      pars['rE_init'], pars['rI_init'] = dx * ie, dx * ii\n",
        "      rE_tj, rI_tj = simulate_wc(**pars)\n",
        "      if (ie == n-1) & (ii == n-1):\n",
        "          plt.plot(rE_tj, rI_tj, 'gray', alpha=0.8, label=mylabel)\n",
        "      else:\n",
        "          plt.plot(rE_tj, rI_tj, 'gray', alpha=0.8)\n",
        "\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "\n",
        "\n",
        "def plot_complete_analysis(pars):\n",
        "  plt.figure(figsize=(7.7, 6.))\n",
        "\n",
        "  # plot example trajectories\n",
        "  my_plot_trajectories(pars, 0.2, 6,\n",
        "                       'Sample trajectories \\nfor different init. conditions')\n",
        "  my_plot_trajectory(pars, 'orange', [0.6, 0.8],\n",
        "                     'Sample trajectory for \\nlow activity')\n",
        "  my_plot_trajectory(pars, 'm', [0.6, 0.6],\n",
        "                     'Sample trajectory for \\nhigh activity')\n",
        "\n",
        "  # plot nullclines\n",
        "  my_plot_nullcline(pars)\n",
        "\n",
        "  # plot vector field\n",
        "  EI_grid = np.linspace(0., 1., 20)\n",
        "  rE, rI = np.meshgrid(EI_grid, EI_grid)\n",
        "  drEdt, drIdt = EIderivs(rE, rI, **pars)\n",
        "  n_skip = 2\n",
        "  plt.quiver(rE[::n_skip, ::n_skip], rI[::n_skip, ::n_skip],\n",
        "             drEdt[::n_skip, ::n_skip], drIdt[::n_skip, ::n_skip],\n",
        "             angles='xy', scale_units='xy', scale=5., facecolor='c')\n",
        "\n",
        "  plt.legend(loc=[1.02, 0.57], handlelength=1)\n",
        "  plt.show()\n",
        "\n",
        "\n",
        "def plot_fp(x_fp, position=(0.02, 0.1), rotation=0):\n",
        "  plt.plot(x_fp[0], x_fp[1], 'ko', ms=8)\n",
        "  plt.text(x_fp[0] + position[0], x_fp[1] + position[1],\n",
        "           f'Fixed Point1=\\n({x_fp[0]:.3f}, {x_fp[1]:.3f})',\n",
        "           horizontalalignment='center', verticalalignment='bottom',\n",
        "           rotation=rotation)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "2ZJwiWbrlW1o"
      },
      "outputs": [],
      "source": [
        "# @title Helper functions\n",
        "\n",
        "\n",
        "def default_pars(**kwargs):\n",
        "  pars = {}\n",
        "\n",
        "  # Excitatory parameters\n",
        "  pars['tau_E'] = 1.     # Timescale of the E population [ms]\n",
        "  pars['a_E'] = 1.2      # Gain of the E population\n",
        "  pars['theta_E'] = 2.8  # Threshold of the E population\n",
        "\n",
        "  # Inhibitory parameters\n",
        "  pars['tau_I'] = 2.0    # Timescale of the I population [ms]\n",
        "  pars['a_I'] = 1.0      # Gain of the I population\n",
        "  pars['theta_I'] = 4.0  # Threshold of the I population\n",
        "\n",
        "  # Connection strength\n",
        "  pars['wEE'] = 9.   # E to E\n",
        "  pars['wEI'] = 4.   # I to E\n",
        "  pars['wIE'] = 13.  # E to I\n",
        "  pars['wII'] = 11.  # I to I\n",
        "\n",
        "  # External input\n",
        "  pars['I_ext_E'] = 0.\n",
        "  pars['I_ext_I'] = 0.\n",
        "\n",
        "  # simulation parameters\n",
        "  pars['T'] = 50.        # Total duration of simulation [ms]\n",
        "  pars['dt'] = .1        # Simulation time step [ms]\n",
        "  pars['rE_init'] = 0.2  # Initial value of E\n",
        "  pars['rI_init'] = 0.2  # Initial value of I\n",
        "\n",
        "  # External parameters if any\n",
        "  for k in kwargs:\n",
        "      pars[k] = kwargs[k]\n",
        "\n",
        "  # Vector of discretized time points [ms]\n",
        "  pars['range_t'] = np.arange(0, pars['T'], pars['dt'])\n",
        "\n",
        "  return pars\n",
        "\n",
        "\n",
        "def F(x, a, theta):\n",
        "  \"\"\"\n",
        "  Population activation function, F-I curve\n",
        "\n",
        "  Args:\n",
        "    x     : the population input\n",
        "    a     : the gain of the function\n",
        "    theta : the threshold of the function\n",
        "\n",
        "  Returns:\n",
        "    f     : the population activation response f(x) for input x\n",
        "  \"\"\"\n",
        "\n",
        "  # add the expression of f = F(x)\n",
        "  f = (1 + np.exp(-a * (x - theta)))**-1 - (1 + np.exp(a * theta))**-1\n",
        "\n",
        "  return f\n",
        "\n",
        "\n",
        "def dF(x, a, theta):\n",
        "  \"\"\"\n",
        "  Derivative of the population activation function.\n",
        "\n",
        "  Args:\n",
        "    x     : the population input\n",
        "    a     : the gain of the function\n",
        "    theta : the threshold of the function\n",
        "\n",
        "  Returns:\n",
        "    dFdx  :  Derivative of the population activation function.\n",
        "  \"\"\"\n",
        "\n",
        "  dFdx = a * np.exp(-a * (x - theta)) * (1 + np.exp(-a * (x - theta)))**-2\n",
        "\n",
        "  return dFdx\n",
        "\n",
        "def F_inv(x, a, theta):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    x         : the population input\n",
        "    a         : the gain of the function\n",
        "    theta     : the threshold of the function\n",
        "\n",
        "  Returns:\n",
        "    F_inverse : value of the inverse function\n",
        "  \"\"\"\n",
        "\n",
        "  # Calculate Finverse (ln(x) can be calculated as np.log(x))\n",
        "  F_inverse = -1/a * np.log((x + (1 + np.exp(a * theta))**-1)**-1 - 1) + theta\n",
        "\n",
        "  return F_inverse\n",
        "\n",
        "\n",
        "def get_E_nullcline(rE, a_E, theta_E, wEE, wEI, I_ext_E, **other_pars):\n",
        "  \"\"\"\n",
        "  Solve for rI along the rE from drE/dt = 0.\n",
        "\n",
        "  Args:\n",
        "    rE    : response of excitatory population\n",
        "    a_E, theta_E, wEE, wEI, I_ext_E : Wilson-Cowan excitatory parameters\n",
        "    Other parameters are ignored\n",
        "\n",
        "  Returns:\n",
        "    rI    : values of inhibitory population along the nullcline on the rE\n",
        "  \"\"\"\n",
        "  # calculate rI for E nullclines on rI\n",
        "  rI = 1 / wEI * (wEE * rE - F_inv(rE, a_E, theta_E) + I_ext_E)\n",
        "\n",
        "  return rI\n",
        "\n",
        "\n",
        "def get_I_nullcline(rI, a_I, theta_I, wIE, wII, I_ext_I, **other_pars):\n",
        "  \"\"\"\n",
        "  Solve for E along the rI from dI/dt = 0.\n",
        "\n",
        "  Args:\n",
        "    rI    : response of inhibitory population\n",
        "    a_I, theta_I, wIE, wII, I_ext_I : Wilson-Cowan inhibitory parameters\n",
        "    Other parameters are ignored\n",
        "\n",
        "  Returns:\n",
        "    rE    : values of the excitatory population along the nullcline on the rI\n",
        "  \"\"\"\n",
        "  # calculate rE for I nullclines on rI\n",
        "  rE = 1 / wIE * (wII * rI + F_inv(rI, a_I, theta_I) - I_ext_I)\n",
        "\n",
        "  return rE\n",
        "\n",
        "def EIderivs(rE, rI,\n",
        "             tau_E, a_E, theta_E, wEE, wEI, I_ext_E,\n",
        "             tau_I, a_I, theta_I, wIE, wII, I_ext_I,\n",
        "             **other_pars):\n",
        "  \"\"\"Time derivatives for E/I variables (dE/dt, dI/dt).\"\"\"\n",
        "\n",
        "  # Compute the derivative of rE\n",
        "  drEdt = (-rE + F(wEE * rE - wEI * rI + I_ext_E, a_E, theta_E)) / tau_E\n",
        "\n",
        "  # Compute the derivative of rI\n",
        "  drIdt = (-rI + F(wIE * rE - wII * rI + I_ext_I, a_I, theta_I)) / tau_I\n",
        "\n",
        "  return drEdt, drIdt\n",
        "\n",
        "def simulate_wc(tau_E, a_E, theta_E, tau_I, a_I, theta_I,\n",
        "                wEE, wEI, wIE, wII, I_ext_E, I_ext_I,\n",
        "                rE_init, rI_init, dt, range_t, **other_pars):\n",
        "  \"\"\"\n",
        "  Simulate the Wilson-Cowan equations\n",
        "\n",
        "  Args:\n",
        "    Parameters of the Wilson-Cowan model\n",
        "\n",
        "  Returns:\n",
        "    rE, rI (arrays) : Activity of excitatory and inhibitory populations\n",
        "  \"\"\"\n",
        "  # Initialize activity arrays\n",
        "  Lt = range_t.size\n",
        "  rE = np.append(rE_init, np.zeros(Lt - 1))\n",
        "  rI = np.append(rI_init, np.zeros(Lt - 1))\n",
        "  I_ext_E = I_ext_E * np.ones(Lt)\n",
        "  I_ext_I = I_ext_I * np.ones(Lt)\n",
        "\n",
        "  # Simulate the Wilson-Cowan equations\n",
        "  for k in range(Lt - 1):\n",
        "\n",
        "    # Calculate the derivative of the E population\n",
        "    drE = dt / tau_E * (-rE[k] + F(wEE * rE[k] - wEI * rI[k] + I_ext_E[k],\n",
        "                                   a_E, theta_E))\n",
        "\n",
        "    # Calculate the derivative of the I population\n",
        "    drI = dt / tau_I * (-rI[k] + F(wIE * rE[k] - wII * rI[k] + I_ext_I[k],\n",
        "                                   a_I, theta_I))\n",
        "\n",
        "    # Update using Euler's method\n",
        "    rE[k + 1] = rE[k] + drE\n",
        "    rI[k + 1] = rI[k] + drI\n",
        "\n",
        "  return rE, rI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "MjV0LrYolW1o"
      },
      "source": [
        "The helper functions included:\n",
        "\n",
        "- Parameter dictionary: `default_pars(**kwargs)`. You can use:\n",
        "  - `pars = default_pars()` to get all the parameters, and then you can execute `print(pars)` to check these parameters.\n",
        "  - `pars = default_pars(T=T_sim, dt=time_step)` to set a different simulation time and time step\n",
        "  - After `pars = default_pars()`, use `par['New_para'] = value` to add a new parameter with its value\n",
        "  - Pass to functions that accept individual parameters with `func(**pars)`\n",
        "- F-I curve: `F(x, a, theta)`\n",
        "- Derivative of the F-I curve: `dF(x, a, theta)`\n",
        "- Inverse of F-I curve: `F_inv`\n",
        "- Nullcline calculations: `get_E_nullcline`, `get_I_nullcline`\n",
        "- Derivatives of E/I variables: `EIderivs`\n",
        "- Simulate the Wilson-Cowan model: `simulate_wc`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "LyzEM7SulW1p"
      },
      "source": [
        "---\n",
        "# Section 1: Fixed points, stability analysis, and limit cycles in the Wilson-Cowan model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "p8SSYDRolW1p"
      },
      "source": [
        "As in Tutorial 2, we will be looking at the Wilson-Cowan model, with coupled equations representing the dynamics of the excitatory or inhibitory population:\n",
        "\n",
        "\\begin{align}\n",
        "\\tau_E \\frac{dr_E}{dt} &= -r_E + F_E(w_{EE}r_E -w_{EI}r_I + I^{\\text{ext}}_E;a_E,\\theta_E) \\\\\n",
        "\\tau_I \\frac{dr_I}{dt} &= -r_I + F_I(w_{IE}r_E -w_{II}r_I + I^{\\text{ext}}_I;a_I,\\theta_I) \\qquad (1)\n",
        "\\end{align}\n",
        "\n",
        "$r_E(t)$ represents the average activation (or firing rate) of the excitatory population at time $t$, and $r_I(t)$ the activation (or firing rate) of the inhibitory population. The parameters $\\tau_E$ and $\\tau_I$ control the timescales of the dynamics of each population. Connection strengths are given by: $w_{EE}$ (E $\\rightarrow$ E), $w_{EI}$ (I $\\rightarrow$ E), $w_{IE}$ (E $\\rightarrow$ I), and $w_{II}$ (I $\\rightarrow$ I). The terms $w_{EI}$ and $w_{IE}$ represent connections from inhibitory to excitatory population and vice versa, respectively. The transfer functions (or F-I curves) $F_E(x;a_E,\\theta_E)$ and $F_I(x;a_I,\\theta_I)$ can be different for the excitatory and the inhibitory populations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "fyu9vR_AlW1p"
      },
      "source": [
        "## Section 1.1: Fixed Points of the E/I system\n",
        "\n",
        "The intersection points of the two nullcline curves are the fixed points of the Wilson-Cowan model in Equation $(1)$.\n",
        "\n",
        "In the next exercise, we will find the coordinate of all fixed points for a given set of parameters.\n",
        "\n",
        "We'll make use of two functions, similar to ones we saw in Tutorial 1, which use a root-finding algorithm to find the fixed points of the system with Excitatory and Inhibitory populations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "fJkrJ7jMlW1p",
        "outputId": "577692a3-f17a-47bd-e110-a731af45d212",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 592
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 775,
              "height": 575
            }
          }
        }
      ],
      "source": [
        "# @markdown Execute to visualize nullclines\n",
        "\n",
        "# Set parameters\n",
        "pars = default_pars()\n",
        "Exc_null_rE = np.linspace(-0.01, 0.96, 100)\n",
        "Inh_null_rI = np.linspace(-.01, 0.8, 100)\n",
        "\n",
        "# Compute nullclines\n",
        "Exc_null_rI = get_E_nullcline(Exc_null_rE, **pars)\n",
        "Inh_null_rE = get_I_nullcline(Inh_null_rI, **pars)\n",
        "\n",
        "plot_nullclines(Exc_null_rE, Exc_null_rI, Inh_null_rE, Inh_null_rI)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "pSvMUSpQlW1p",
        "outputId": "d8ca464a-411e-4cac-9817-9a2fb12b8336",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on function my_fp in module __main__:\n",
            "\n",
            "my_fp(pars, rE_init, rI_init)\n",
            "    Use opt.root function to solve Equations (2)-(3) from initial values\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# @markdown *Execute the cell to define `my_fp` and `check_fp`*\n",
        "\n",
        "def my_fp(pars, rE_init, rI_init):\n",
        "  \"\"\"\n",
        "  Use opt.root function to solve Equations (2)-(3) from initial values\n",
        "  \"\"\"\n",
        "\n",
        "  tau_E, a_E, theta_E = pars['tau_E'], pars['a_E'], pars['theta_E']\n",
        "  tau_I, a_I, theta_I = pars['tau_I'], pars['a_I'], pars['theta_I']\n",
        "  wEE, wEI = pars['wEE'], pars['wEI']\n",
        "  wIE, wII = pars['wIE'], pars['wII']\n",
        "  I_ext_E, I_ext_I = pars['I_ext_E'], pars['I_ext_I']\n",
        "\n",
        "  # define the right hand of wilson-cowan equations\n",
        "  def my_WCr(x):\n",
        "\n",
        "    rE, rI = x\n",
        "    drEdt = (-rE + F(wEE * rE - wEI * rI + I_ext_E, a_E, theta_E)) / tau_E\n",
        "    drIdt = (-rI + F(wIE * rE - wII * rI + I_ext_I, a_I, theta_I)) / tau_I\n",
        "    y = np.array([drEdt, drIdt])\n",
        "\n",
        "    return y\n",
        "\n",
        "  x0 = np.array([rE_init, rI_init])\n",
        "  x_fp = opt.root(my_WCr, x0).x\n",
        "\n",
        "  return x_fp\n",
        "\n",
        "\n",
        "def check_fp(pars, x_fp, mytol=1e-6):\n",
        "  \"\"\"\n",
        "  Verify (drE/dt)^2 + (drI/dt)^2< mytol\n",
        "\n",
        "  Args:\n",
        "    pars    : Parameter dictionary\n",
        "    fp      : value of fixed point\n",
        "    mytol   : tolerance, default as 10^{-6}\n",
        "\n",
        "  Returns :\n",
        "    Whether it is a correct fixed point: True/False\n",
        "  \"\"\"\n",
        "\n",
        "  drEdt, drIdt = EIderivs(x_fp[0], x_fp[1], **pars)\n",
        "\n",
        "  return drEdt**2 + drIdt**2 < mytol\n",
        "\n",
        "help(my_fp)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "F1JF95c-lW1p"
      },
      "source": [
        "### Coding Exercise 1.1: Find the fixed points of the Wilson-Cowan model\n",
        "\n",
        "From the above nullclines, we notice that the system features  three fixed points with the parameters we used. To find their coordinates, we need to choose a proper initial value to give to the `opt.root` function inside of the function `my_fp` we just defined, since the algorithm can only find fixed points in the vicinity of the initial value.\n",
        "\n",
        "In this exercise, you will use the function `my_fp` to find each of the fixed points by varying the initial values. Note that you can choose the values near the intersections of the nullclines as the initial values to calculate the fixed points."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "execution": {},
        "id": "cnB3QOV_lW1p",
        "outputId": "736355c4-60d5-4540-acba-bcc43f545389",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 211
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "NotImplementedError",
          "evalue": "student exercise: find fixed points",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-06b854545a9e>\u001b[0m in \u001b[0;36m<cell line: 7>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Check if x_fp's are the correct with the function check_fp(x_fp)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# Hint: vary different initial values to find the correct fixed points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'student exercise: find fixed points'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;31m######################################################################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNotImplementedError\u001b[0m: student exercise: find fixed points"
          ]
        }
      ],
      "source": [
        "pars = default_pars()\n",
        "\n",
        "######################################################################\n",
        "# TODO: Provide initial values to calculate the fixed points\n",
        "# Check if x_fp's are the correct with the function check_fp(x_fp)\n",
        "# Hint: vary different initial values to find the correct fixed points\n",
        "raise NotImplementedError('student exercise: find fixed points')\n",
        "######################################################################\n",
        "\n",
        "my_plot_nullcline(pars)\n",
        "\n",
        "# Find the first fixed point\n",
        "x_fp_1 = my_fp(pars, ..., ...)\n",
        "if check_fp(pars, x_fp_1):\n",
        "  plot_fp(x_fp_1)\n",
        "\n",
        "# Find the second fixed point\n",
        "x_fp_2 = my_fp(pars, ..., ...)\n",
        "if check_fp(pars, x_fp_2):\n",
        "  plot_fp(x_fp_2)\n",
        "\n",
        "# Find the third fixed point\n",
        "x_fp_3 = my_fp(pars, ..., ...)\n",
        "if check_fp(pars, x_fp_3):\n",
        "  plot_fp(x_fp_3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "_WwWrUEplW1p"
      },
      "source": [
        "## Section 1.2: Stability of a fixed point and eigenvalues of the Jacobian Matrix\n",
        "\n",
        "First, let's first rewrite the system $1$ as:\n",
        "\n",
        "\\begin{align}\n",
        "\\frac{dr_E}{dt} &= G_E(r_E,r_I) \\\\\n",
        "\\frac{dr_I}{dt} &= G_I(r_E,r_I)\n",
        "\\end{align}\n",
        "\n",
        "where\n",
        "\n",
        "\\begin{align}\n",
        "G_E(r_E,r_I) &= \\frac{1}{\\tau_E} [-r_E + F_E(w_{EE}r_E -w_{EI}r_I + I^{\\text{ext}}_E;a,\\theta)] \\\\\n",
        "G_I(r_E,r_I) &= \\frac{1}{\\tau_I} [-r_I + F_I(w_{IE}r_E -w_{II}r_I + I^{\\text{ext}}_I;a,\\theta)]\n",
        "\\end{align}\n",
        "\n",
        "By definition, $\\displaystyle\\frac{dr_E}{dt}=0$ and $\\displaystyle\\frac{dr_I}{dt}=0$ at each fixed point. Therefore, if the initial state is exactly at the fixed point, the state of the system will not change as time evolves.\n",
        "\n",
        "However, if the initial state deviates slightly from the fixed point, there are two possibilities\n",
        "the trajectory will be attracted back to the\n",
        "\n",
        "1. The trajectory will be attracted back to the fixed point\n",
        "2. The trajectory will diverge from the fixed point.\n",
        "\n",
        "These two possibilities define the type of fixed point, i.e., stable or unstable. Similar to the 1D system studied in the previous tutorial, the stability of a fixed point $(r_E^*, r_I^*)$ can be determined by linearizing the dynamics of the system (can you figure out how?). The linearization will yield a matrix of first-order derivatives called the Jacobian matrix:\n",
        "\n",
        "\\begin{equation}\n",
        "J=\n",
        "\\left[ {\\begin{array}\n",
        "  \\displaystyle{\\frac{\\partial}{\\partial r_E}}G_E(r_E^*, r_I^*) & \\displaystyle{\\frac{\\partial}{\\partial r_I}}G_E(r_E^*, r_I^*)\\\\[1mm]\n",
        "  \\displaystyle\\frac{\\partial}{\\partial r_E} G_I(r_E^*, r_I^*) & \\displaystyle\\frac{\\partial}{\\partial r_I}G_I(r_E^*, r_I^*) \\\\\n",
        "\\end{array} } \\right] \\quad (7)\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "The eigenvalues of the Jacobian matrix calculated at the fixed point will determine whether it is a stable or unstable fixed point.\n",
        "\n",
        "We can now compute the derivatives needed to build the Jacobian matrix. Using the chain and product rules the derivatives for the excitatory population are given by:\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{align}\n",
        "\\frac{\\partial}{\\partial r_E} G_E(r_E^*, r_I^*) &= \\frac{1}{\\tau_E} [-1 + w_{EE} F_E'(w_{EE}r_E^* -w_{EI}r_I^* +  I^{\\text{ext}}_E;\\alpha_E, \\theta_E)] \\\\[1mm]\n",
        "\\frac{\\partial}{\\partial r_I} G_E(r_E^*, r_I^*) &= \\frac{1}{\\tau_E} [-w_{EI} F_E'(w_{EE}r_E^* -w_{EI}r_I^* +  I^{\\text{ext}}_E;\\alpha_E, \\theta_E)]\n",
        "\\end{align}\n",
        "\n",
        "<br>\n",
        "\n",
        "The same applies to the inhibitory population."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "wB2xCwuElW1p"
      },
      "source": [
        "### Coding Exercise 1.2: Compute the Jacobian Matrix for the Wilson-Cowan model\n",
        "\n",
        "Here, you can use `dF(x,a,theta)` defined in the `Helper functions` to calculate the derivative of the F-I curve."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {},
        "id": "uTbu2njvlW1q"
      },
      "outputs": [],
      "source": [
        "def get_eig_Jacobian(fp,\n",
        "                     tau_E, a_E, theta_E, wEE, wEI, I_ext_E,\n",
        "                     tau_I, a_I, theta_I, wIE, wII, I_ext_I, **other_pars):\n",
        "  \"\"\"Compute eigenvalues of the Wilson-Cowan Jacobian matrix at fixed point.\"\"\"\n",
        "  # Initialization\n",
        "  rE, rI = fp\n",
        "  J = np.zeros((2, 2))\n",
        "\n",
        "  ###########################################################################\n",
        "  # TODO for students: compute J and disable the error\n",
        "  raise NotImplementedError(\"Student exercise: compute the Jacobian matrix\")\n",
        "  ###########################################################################\n",
        "  # Compute the four elements of the Jacobian matrix\n",
        "  J[0, 0] = ...\n",
        "  J[0, 1] = ...\n",
        "  J[1, 0] = ...\n",
        "  J[1, 1] = ...\n",
        "\n",
        "  # Compute and return the eigenvalues\n",
        "  evals = np.linalg.eig(J)[0]\n",
        "  return evals\n",
        "\n",
        "\n",
        "# Compute eigenvalues of Jacobian\n",
        "eig_1 = get_eig_Jacobian(x_fp_1, **pars)\n",
        "eig_2 = get_eig_Jacobian(x_fp_2, **pars)\n",
        "eig_3 = get_eig_Jacobian(x_fp_3, **pars)\n",
        "\n",
        "print(eig_1, 'Stable point')\n",
        "print(eig_2, 'Unstable point')\n",
        "print(eig_3, 'Stable point')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "HMSrEg5flW1q"
      },
      "source": [
        "As is evident, the stable fixed points correspond to the negative eigenvalues, while unstable points correspond to at least one positive eigenvalue."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "eRKQWryWlW1q"
      },
      "source": [
        "The sign of the eigenvalues is determined by the connectivity (interaction) between excitatory and inhibitory populations.\n",
        "\n",
        "Below we investigate the effect of $w_{EE}$ on the nullclines and the eigenvalues of the dynamical system.\n",
        "\n",
        "\\* _Critical change is referred to as **pitchfork bifurcation**_."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "-K8v_UiulW1q"
      },
      "source": [
        "## Section 1.3: Effect of `wEE` on the nullclines and the eigenvalues"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "SMnce8bxlW1q"
      },
      "source": [
        "### Interactive Demo 1.3: Nullclines position in the phase plane changes with parameter values\n",
        "\n",
        "How do the nullclines move for different values of the parameter $w_{EE}$? What does this mean for fixed points and system activity?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "ZRYcUzQflW1q"
      },
      "outputs": [],
      "source": [
        "# @markdown Make sure you execute this cell to enable the widget!\n",
        "\n",
        "@widgets.interact(\n",
        "    wEE=widgets.FloatSlider(6., min=6., max=10., step=0.01)\n",
        ")\n",
        "\n",
        "def plot_nullcline_diffwEE(wEE):\n",
        "  \"\"\"\n",
        "    plot nullclines for different values of wEE\n",
        "  \"\"\"\n",
        "\n",
        "  pars = default_pars(wEE=wEE)\n",
        "\n",
        "  # plot the E, I nullclines\n",
        "  Exc_null_rE = np.linspace(-0.01, .96, 100)\n",
        "  Exc_null_rI = get_E_nullcline(Exc_null_rE, **pars)\n",
        "\n",
        "  Inh_null_rI = np.linspace(-.01, .8, 100)\n",
        "  Inh_null_rE = get_I_nullcline(Inh_null_rI, **pars)\n",
        "\n",
        "  plt.figure(figsize=(12, 5.5))\n",
        "  plt.subplot(121)\n",
        "  plt.plot(Exc_null_rE, Exc_null_rI, 'b', label='E nullcline')\n",
        "  plt.plot(Inh_null_rE, Inh_null_rI, 'r', label='I nullcline')\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "  plt.legend(loc='best')\n",
        "\n",
        "  plt.subplot(222)\n",
        "  pars['rE_init'], pars['rI_init'] = 0.2, 0.2\n",
        "  rE, rI = simulate_wc(**pars)\n",
        "  plt.plot(pars['range_t'], rE, 'b', label='E population', clip_on=False)\n",
        "  plt.plot(pars['range_t'], rI, 'r', label='I population', clip_on=False)\n",
        "  plt.ylabel('Activity')\n",
        "  plt.legend(loc='best')\n",
        "  plt.ylim(-0.05, 1.05)\n",
        "  plt.title('E/I activity\\nfor different initial conditions',\n",
        "            fontweight='bold')\n",
        "\n",
        "  plt.subplot(224)\n",
        "  pars['rE_init'], pars['rI_init'] = 0.4, 0.1\n",
        "  rE, rI = simulate_wc(**pars)\n",
        "  plt.plot(pars['range_t'], rE, 'b', label='E population', clip_on=False)\n",
        "  plt.plot(pars['range_t'], rI, 'r', label='I population', clip_on=False)\n",
        "  plt.xlabel('t (ms)')\n",
        "  plt.ylabel('Activity')\n",
        "  plt.legend(loc='best')\n",
        "  plt.ylim(-0.05, 1.05)\n",
        "\n",
        "  plt.tight_layout()\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "OPCo7xc3lW1q"
      },
      "source": [
        "We can also investigate the effect of different $w_{EI}$, $w_{IE}$, $w_{II}$, $\\tau_{E}$, $\\tau_{I}$, and $I_{E}^{\\text{ext}}$ on the stability of fixed points. In addition, we can also consider the perturbation of the parameters of the gain curve $F(\\cdot)$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "-jCxd9TGlW1q"
      },
      "source": [
        "## Section 1.4: Limit cycle - Oscillations\n",
        "\n",
        "For some values of interaction terms ($w_{EE}, w_{IE}, w_{EI}, w_{II}$), the eigenvalues can become complex. When at least one pair of eigenvalues is complex, oscillations arise.\n",
        "The stability of oscillations is determined by the real part of the eigenvalues (+ve real part oscillations will grow, -ve real part oscillations will die out). The size of the complex part determines the frequency of oscillations.\n",
        "\n",
        "For instance, if we use a different set of parameters, $w_{EE}=6.4$, $w_{EI}=4.8$, $w_{IE}=6.$, $w_{II}=1.2$, and $I_{E}^{\\text{ext}}=0.8$, then we shall observe that the E and I population activity start to oscillate! Please execute the cell below to check the oscillatory behavior."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "6moSucLBlW1q"
      },
      "outputs": [],
      "source": [
        "# @markdown Make sure you execute this cell to see the oscillations!\n",
        "\n",
        "pars = default_pars(T=100.)\n",
        "pars['wEE'], pars['wEI'] = 6.4, 4.8\n",
        "pars['wIE'], pars['wII'] = 6.0, 1.2\n",
        "pars['I_ext_E'] = 0.8\n",
        "pars['rE_init'], pars['rI_init'] = 0.25, 0.25\n",
        "\n",
        "rE, rI = simulate_wc(**pars)\n",
        "plt.figure(figsize=(8, 5.5))\n",
        "plt.plot(pars['range_t'], rE, 'b', label=r'$r_E$')\n",
        "plt.plot(pars['range_t'], rI, 'r', label=r'$r_I$')\n",
        "plt.xlabel('t (ms)')\n",
        "plt.ylabel('Activity')\n",
        "plt.legend(loc='best')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "y9_amYARlW1q"
      },
      "source": [
        "We can also understand the oscillations of the population behavior using the phase plane. By plotting a set of trajectories with different initial states, we can see that these trajectories will move in a circle instead of converging to a fixed point. This circle is called \"limit cycle\" and shows the periodic oscillations of the $E$ and $I$ population behavior under some conditions.\n",
        "\n",
        "Let's plot the phase plane using the previously defined functions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "pqm6yFu7lW1q"
      },
      "outputs": [],
      "source": [
        "# @markdown Execute to visualize phase plane\n",
        "\n",
        "pars = default_pars(T=100.)\n",
        "pars['wEE'], pars['wEI'] = 6.4, 4.8\n",
        "pars['wIE'], pars['wII'] = 6.0, 1.2\n",
        "pars['I_ext_E'] = 0.8\n",
        "\n",
        "\n",
        "plt.figure(figsize=(7, 5.5))\n",
        "my_plot_nullcline(pars)\n",
        "\n",
        "# Find the correct fixed point\n",
        "x_fp_1 = my_fp(pars, 0.8, 0.8)\n",
        "if check_fp(pars, x_fp_1):\n",
        "  plot_fp(x_fp_1, position=(0, 0), rotation=40)\n",
        "\n",
        "my_plot_trajectories(pars, 0.2, 3,\n",
        "                      'Sample trajectories \\nwith different initial values')\n",
        "\n",
        "my_plot_vector(pars)\n",
        "\n",
        "plt.legend(loc=[1.01, 0.7])\n",
        "plt.xlim(-0.05, 1.01)\n",
        "plt.ylim(-0.05, 0.65)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "iR8wER7ylW1q"
      },
      "source": [
        "### Interactive Demo 1.4: Limit cycle and oscillations\n",
        "\n",
        "From the above examples, the change of model parameters changes the shape of the nullclines and, accordingly, the behavior of the $E$ and $I$ populations from steady fixed points to oscillations. However, the shape of the nullclines is unable to fully determine the behavior of the network. The vector field also matters. To demonstrate this, here, we will investigate the effect of time constants on the population behavior. By changing the inhibitory time constant $\\tau_I$, the nullclines do not change, but the network behavior changes substantially from steady state to oscillations with different frequencies.\n",
        "\n",
        "Such a dramatic change in the system behavior is referred to as a **bifurcation**.\n",
        "\n",
        "<br>\n",
        "Please execute the code below to check this out."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "btCcigEnlW1q"
      },
      "outputs": [],
      "source": [
        "# @markdown Make sure you execute this cell to enable the widget!\n",
        "\n",
        "@widgets.interact(\n",
        "    tau_i=widgets.FloatSlider(1.5, min=0.2, max=3., step=.1)\n",
        ")\n",
        "\n",
        "\n",
        "def time_constant_effect(tau_i=0.5):\n",
        "\n",
        "  pars = default_pars(T=100.)\n",
        "  pars['wEE'], pars['wEI'] = 6.4, 4.8\n",
        "  pars['wIE'], pars['wII'] = 6.0, 1.2\n",
        "  pars['I_ext_E'] = 0.8\n",
        "\n",
        "  pars['tau_I'] = tau_i\n",
        "\n",
        "  Exc_null_rE = np.linspace(0.0, .9, 100)\n",
        "  Inh_null_rI = np.linspace(0.0, .6, 100)\n",
        "\n",
        "  Exc_null_rI = get_E_nullcline(Exc_null_rE, **pars)\n",
        "  Inh_null_rE = get_I_nullcline(Inh_null_rI, **pars)\n",
        "\n",
        "  plt.figure(figsize=(12.5, 5.5))\n",
        "\n",
        "  plt.subplot(121)  # nullclines\n",
        "  plt.plot(Exc_null_rE, Exc_null_rI, 'b', label='E nullcline', zorder=2)\n",
        "  plt.plot(Inh_null_rE, Inh_null_rI, 'r', label='I nullcline', zorder=2)\n",
        "  plt.xlabel(r'$r_E$')\n",
        "  plt.ylabel(r'$r_I$')\n",
        "\n",
        "  # fixed point\n",
        "  x_fp_1 = my_fp(pars, 0.5, 0.5)\n",
        "  plt.plot(x_fp_1[0], x_fp_1[1], 'ko', zorder=2)\n",
        "\n",
        "  eig_1 = get_eig_Jacobian(x_fp_1, **pars)\n",
        "\n",
        "  # trajectories\n",
        "  for ie in range(5):\n",
        "    for ii in range(5):\n",
        "      pars['rE_init'], pars['rI_init'] = 0.1 * ie, 0.1 * ii\n",
        "      rE_tj, rI_tj = simulate_wc(**pars)\n",
        "      plt.plot(rE_tj, rI_tj, 'k', alpha=0.3, zorder=1)\n",
        "\n",
        "  # vector field\n",
        "  EI_grid_E = np.linspace(0., 1.0, 20)\n",
        "  EI_grid_I = np.linspace(0., 0.6, 20)\n",
        "  rE, rI = np.meshgrid(EI_grid_E, EI_grid_I)\n",
        "  drEdt, drIdt = EIderivs(rE, rI, **pars)\n",
        "  n_skip = 2\n",
        "  plt.quiver(rE[::n_skip, ::n_skip], rI[::n_skip, ::n_skip],\n",
        "              drEdt[::n_skip, ::n_skip], drIdt[::n_skip, ::n_skip],\n",
        "              angles='xy', scale_units='xy', scale=10, facecolor='c')\n",
        "  plt.title(r'$\\tau_I=$'+'%.1f ms' % tau_i)\n",
        "\n",
        "  plt.subplot(122)  # sample E/I trajectories\n",
        "  pars['rE_init'], pars['rI_init'] = 0.25, 0.25\n",
        "  rE, rI = simulate_wc(**pars)\n",
        "  plt.plot(pars['range_t'], rE, 'b', label=r'$r_E$')\n",
        "  plt.plot(pars['range_t'], rI, 'r', label=r'$r_I$')\n",
        "  plt.xlabel('t (ms)')\n",
        "  plt.ylabel('Activity')\n",
        "  plt.title(r'$\\tau_I=$'+'%.1f ms' % tau_i)\n",
        "  plt.legend(loc='best')\n",
        "  plt.tight_layout()\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "1gBkMbuWlW1q"
      },
      "source": [
        "Both $\\tau_E$ and $\\tau_I$ feature in the Jacobian of the two population network (eq 7). So here is seems that the by increasing $\\tau_I$ the eigenvalues corresponding to the stable fixed point are becoming complex.\n",
        "\n",
        "Intuitively, when $\\tau_I$ is smaller, inhibitory activity changes faster than excitatory activity. As inhibition exceeds above a certain value, high inhibition inhibits excitatory population but that in turns means that inhibitory population gets smaller input (from the exc. connection). So inhibition decreases rapidly. But this means that excitation recovers -- and so on ..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "7Iu4IrHOlW1q"
      },
      "source": [
        "---\n",
        "# Section 2: Inhibition-stabilized network (ISN)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "MeLDrDD_lW1q"
      },
      "source": [
        "## Section 2.1: Inhibition-stabilized network\n",
        "\n",
        "As described above, one can obtain the linear approximation around the fixed point as\n",
        "\n",
        "\\begin{equation}\n",
        "\\frac{d}{dr} \\vec{R} =\n",
        "\\left[ {\\begin{array}\n",
        "\\displaystyle{\\frac{\\partial G_E}{\\partial r_E}} & \\displaystyle{\\frac{\\partial G_E}{\\partial r_I}} \\\\\n",
        "\\displaystyle\\frac{\\partial G_I}{\\partial r_E} & \\displaystyle\\frac{\\partial G_I}{\\partial r_I} \\\\\n",
        "\\end{array} } \\right] \\vec{R},\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "where $\\vec{R} = [r_E, r_I]^{\\rm T}$ is the vector of the E/I activity.\n",
        "\n",
        "Let's direct our attention to the excitatory subpopulation which follows:\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{equation}\n",
        "\\frac{dr_E}{dt} = \\frac{\\partial G_E}{\\partial r_E}\\cdot r_E + \\frac{\\partial G_E}{\\partial r_I} \\cdot r_I\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "Recall that, around fixed point $(r_E^*, r_I^*)$:\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{align}\n",
        "\\frac{\\partial}{\\partial r_E}G_E(r_E^*, r_I^*) &= \\frac{1}{\\tau_E} [-1 + w_{EE} F'_{E}(w_{EE}r_E^* -w_{EI}r_I^* + I^{\\text{ext}}_E; \\alpha_E, \\theta_E)] &\\qquad (8) \\\\\n",
        "\\frac{\\partial}{\\partial r_I}G_E(r_E^*, r_I^*) &= \\frac{1}{\\tau_E} [-w_{EI} F'_{E}(w_{EE}r_E^* -w_{EI}r_I^* + I^{\\text{ext}}_E; \\alpha_E, \\theta_E)] &\\qquad (9)\\\\\n",
        "\\frac{\\partial}{\\partial r_E}G_I(r_E^*, r_I^*) &= \\frac{1}{\\tau_I} [w_{IE} F'_{I}(w_{IE}r_E^* -w_{II}r_I^* + I^{\\text{ext}}_I; \\alpha_I, \\theta_I)] &\\qquad (10) \\\\\n",
        "\\frac{\\partial}{\\partial r_I}G_I(r_E^*, r_I^*) &= \\frac{1}{\\tau_I} [-1-w_{II} F'_{I}(w_{IE}r_E^* -w_{II}r_I^* + I^{\\text{ext}}_I; \\alpha_I, \\theta_I)] &\\qquad (11)\n",
        "\\end{align}\n",
        "\n",
        "<br>\n",
        "\n",
        "From Equation. (8), it is clear that $\\displaystyle{\\frac{\\partial G_E}{\\partial r_I}}$ is negative since the $\\displaystyle{\\frac{dF}{dx}}$ is always positive. It can be understood by that the recurrent inhibition from the inhibitory activity ($I$) can reduce the excitatory ($E$) activity. However, as described above, $\\displaystyle{\\frac{\\partial G_E}{\\partial r_E}}$ has negative terms related to the \"leak\" effect, and positive terms related to the recurrent excitation. Therefore, it leads to two different regimes:\n",
        "\n",
        "- $\\displaystyle{\\frac{\\partial}{\\partial r_E}G_E(r_E^*, r_I^*)}<0$, **noninhibition-stabilized\n",
        "network (non-ISN) regime**\n",
        "\n",
        "- $\\displaystyle{\\frac{\\partial}{\\partial r_E}G_E(r_E^*, r_I^*)}>0$, **inhibition-stabilized\n",
        "network (ISN) regime**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "MSvHFNT-lW1r"
      },
      "source": [
        "### Coding Exercise 2.1: Compute $\\displaystyle{\\frac{\\partial G_E}{\\partial r_E}}$\n",
        "\n",
        "Implement the function to calculate the $\\displaystyle{\\frac{\\partial G_E}{\\partial r_E}}$ for the default parameters, and the parameters of the limit cycle case."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {},
        "id": "S6L_XG1glW1r"
      },
      "outputs": [],
      "source": [
        "def get_dGdE(fp, tau_E, a_E, theta_E, wEE, wEI, I_ext_E, **other_pars):\n",
        "  \"\"\"\n",
        "  Compute dGdE\n",
        "\n",
        "  Args:\n",
        "    fp   : fixed point (E, I), array\n",
        "    Other arguments are parameters of the Wilson-Cowan model\n",
        "\n",
        "  Returns:\n",
        "    J    : the 2x2 Jacobian matrix\n",
        "  \"\"\"\n",
        "  rE, rI = fp\n",
        "\n",
        "  ##########################################################################\n",
        "  # TODO for students: compute dGdrE and disable the error\n",
        "  raise NotImplementedError(\"Student exercise: compute the dG/dE, Eq. (13)\")\n",
        "  ##########################################################################\n",
        "  # Calculate the J[0,0]\n",
        "  dGdrE = ...\n",
        "\n",
        "  return dGdrE\n",
        "\n",
        "\n",
        "# Get fixed points\n",
        "pars = default_pars()\n",
        "x_fp_1 = my_fp(pars, 0.1, 0.1)\n",
        "x_fp_2 = my_fp(pars, 0.3, 0.3)\n",
        "x_fp_3 = my_fp(pars, 0.8, 0.6)\n",
        "\n",
        "# Compute dGdE\n",
        "dGdrE1 = get_dGdE(x_fp_1, **pars)\n",
        "dGdrE2 = get_dGdE(x_fp_2, **pars)\n",
        "dGdrE3 = get_dGdE(x_fp_3, **pars)\n",
        "\n",
        "print(f'For the default case:')\n",
        "print(f'dG/drE(fp1) = {dGdrE1:.3f}')\n",
        "print(f'dG/drE(fp2) = {dGdrE2:.3f}')\n",
        "print(f'dG/drE(fp3) = {dGdrE3:.3f}')\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "pars = default_pars(wEE=6.4, wEI=4.8, wIE=6.0, wII=1.2, I_ext_E=0.8)\n",
        "x_fp_lc = my_fp(pars, 0.8, 0.8)\n",
        "\n",
        "dGdrE_lc = get_dGdE(x_fp_lc, **pars)\n",
        "\n",
        "print('For the limit cycle case:')\n",
        "print(f'dG/drE(fp_lc) = {dGdrE_lc:.3f}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "jvQrvgxTlW1r"
      },
      "source": [
        "**SAMPLE OUTPUT**\n",
        "```\n",
        "For the default case:\n",
        "dG/drE(fp1) = -0.650\n",
        "dG/drE(fp2) = 1.519\n",
        "dG/drE(fp3) = -0.706\n",
        "\n",
        "\n",
        "For the limit cycle case:\n",
        "dG/drE(fp_lc) = 0.837\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "AYY1zOn3lW1r"
      },
      "source": [
        "## Section 2.2: Nullcline analysis of the ISN\n",
        "\n",
        "Recall that the E nullcline follows\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{equation}\n",
        "r_E = F_E(w_{EE}r_E -w_{EI}r_I + I^{\\text{ext}}_E;a_E,\\theta_E).\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "That is, the firing rate $r_E$ can be a function of $r_I$. Let's take the derivative of $r_E$ over $r_I$, and obtain\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{align}\n",
        "&\\frac{dr_E}{dr_I} = F_E' \\cdot (w_{EE}\\frac{dr_E}{dr_I} -w_{EI}) \\iff \\\\\n",
        "&(1-F_E'w_{EE})\\frac{dr_E}{dr_I} = -F_E' w_{EI} \\iff \\\\\n",
        "&\\frac{dr_E}{dr_I} = \\frac{F_E' w_{EI}}{F_E'w_{EE}-1}.\n",
        "\\end{align}\n",
        "\n",
        "<br>\n",
        "\n",
        "That is, in the phase plane `rI-rE`-plane, we can obtain the slope along the E nullcline as\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{equation}\n",
        "\\frac{dr_I}{dr_E} = \\frac{F_E'w_{EE}-1}{F_E' w_{EI}} \\qquad (12)\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "Similarly, we can obtain the slope along the I nullcline as\n",
        "\n",
        "\\begin{equation}\n",
        "\\frac{dr_I}{dr_E} = \\frac{F_I'w_{IE}}{F_I' w_{II}+1} \\qquad (13)\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "Then, we can find that $\\Big{(} \\displaystyle{\\frac{dr_I}{dr_E}} \\Big{)}_{\\rm I-nullcline} >0$ in Equation (13).\n",
        "\n",
        "<br>\n",
        "\n",
        "However, in Equation (12), the sign of $\\Big{(} \\displaystyle{\\frac{dr_I}{dr_E}} \\Big{)}_{\\rm E-nullcline}$ depends on the sign of $(F_E'w_{EE}-1)$. Note that, $(F_E'w_{EE}-1)$ is the same as what we show above (Equation (8)). Therefore, we can have the following results:\n",
        "\n",
        "- $\\Big{(} \\displaystyle{\\frac{dr_I}{dr_E}} \\Big{)}_{\\rm E-nullcline}<0$, **noninhibition-stabilized\n",
        "network (non-ISN) regime**\n",
        "\n",
        "- $\\Big{(} \\displaystyle{\\frac{dr_I}{dr_E}} \\Big{)}_{\\rm E-nullcline}>0$, **inhibition-stabilized\n",
        "network (ISN) regime**\n",
        "\n",
        "<br>\n",
        "\n",
        "In addition, it is important to point out the following two conclusions:\n",
        "\n",
        "**Conclusion 1:** The stability of a fixed point can determine the relationship between the slopes Equations (12) and (13). As discussed above, the fixed point is stable when the Jacobian matrix ($J$ in Equation (7)) has two eigenvalues with a negative real part, which indicates a positive determinant of $J$, i.e., $\\text{det}(J)>0$.\n",
        "\n",
        "From the Jacobian matrix definition and from Equations (8-11), we can obtain:\n",
        "\n",
        "\\begin{equation}\n",
        "J =\n",
        "\\left[ {\\begin{array}\n",
        "\\displaystyle{\\frac{1}{\\tau_E}(w_{EE}F_E'-1)} & \\displaystyle{-\\frac{1}{\\tau_E}w_{EI}F_E'}\\\\[1mm]\n",
        "\\displaystyle {\\frac{1}{\\tau_I}w_{IE}F_I'}& \\displaystyle {\\frac{1}{\\tau_I}(-w_{II}F_I'-1)} \\\\\n",
        "\\end{array} } \\right]\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "Note that, if we let\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{equation}\n",
        "  T=\n",
        "  \\left[\n",
        "  {\n",
        "    \\begin{matrix}\n",
        "      \\displaystyle{\\tau_E} & \\displaystyle{0} \\\\\n",
        "      \\displaystyle 0& \\displaystyle \\tau_I\n",
        "  \\end{matrix}\n",
        "  } \\right],\n",
        "  F=\n",
        "  \\left[\n",
        "  {\n",
        "    \\begin{matrix}\n",
        "      \\displaystyle{F_E'} & \\displaystyle{0} \\\\\n",
        "      \\displaystyle 0& \\displaystyle F_I'\n",
        "    \\end{matrix}\n",
        "  }\n",
        "  \\right]\n",
        "  \\text{, and }\n",
        "  W=\n",
        "  \\left[\n",
        "  {\n",
        "    \\begin{matrix}\n",
        "      \\displaystyle{w_{EE}} & \\displaystyle{-w_{EI}} \\\\\n",
        "      \\displaystyle w_{IE}& \\displaystyle -w_{II}\n",
        "    \\end{matrix}\n",
        "  }\n",
        "  \\right]\n",
        "\\end{equation}\n",
        "\n",
        "then, using matrix notation, $J=T^{-1}(F W - I)$ where $I$ is the identity matrix, i.e., $I = \\begin{bmatrix}\n",
        "1 & 0 \\\\\n",
        "0 & 1\n",
        "\\end{bmatrix}.$\n",
        "\n",
        "<br>\n",
        "\n",
        "Therefore, $\\det{(J)}=\\det{(T^{-1}(F W - I))}=(\\det{(T^{-1})})(\\det{(F W - I)}).$\n",
        "\n",
        "Since $\\det{(T^{-1})}>0$, as time constants are positive by definition, the sign of $\\det{(J)}$ is the same as the sign of $\\det{(F W - I)}$, and so\n",
        "\n",
        "$$\\det{(FW - I)} = (F_E' w_{EI})(F_I'w_{IE}) - (F_I' w_{II} + 1)(F_E'w_{EE} - 1) > 0.$$\n",
        "\n",
        "<br>\n",
        "\n",
        "Then, combining this with Equations (12) and (13), we can obtain\n",
        "\n",
        "\\begin{equation}\n",
        "\\frac{\\Big{(} \\displaystyle{\\frac{dr_I}{dr_E}} \\Big{)}_{\\rm I-nullcline}}{\\Big{(} \\displaystyle{\\frac{dr_I}{dr_E}} \\Big{)}_{\\rm E-nullcline}} > 1.\n",
        "\\end{equation}\n",
        "\n",
        "Therefore, at the stable fixed point, I nullcline has a steeper slope than the E nullcline.\n",
        "\n",
        "<br>\n",
        "\n",
        "**Conclusion 2:** Effect of adding input to the inhibitory population.\n",
        "\n",
        "While adding the input $\\delta I^{\\rm ext}_I$ into the inhibitory population, we can find that the E nullcline (Equation (5)) stays the same, while the I nullcline has a pure left shift: the original I nullcline equation,\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{equation}\n",
        "r_I = F_I(w_{IE}r_E-w_{II}r_I + I^{\\text{ext}}_I ; \\alpha_I, \\theta_I)\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "remains true if we take $I^{\\text{ext}}_I \\rightarrow I^{\\text{ext}}_I +\\delta I^{\\rm ext}_I$ and $r_E\\rightarrow r_E'=r_E-\\frac{\\delta I^{\\rm ext}_I}{w_{IE}}$ to obtain\n",
        "\n",
        "<br>\n",
        "\n",
        "\\begin{equation}\n",
        "r_I = F_I(w_{IE}r_E'-w_{II}r_I + I^{\\text{ext}}_I +\\delta I^{\\rm ext}_I; \\alpha_I, \\theta_I)\n",
        "\\end{equation}\n",
        "\n",
        "<br>\n",
        "\n",
        "Putting these points together, we obtain the phase plane pictures shown below. After adding input to the inhibitory population, it can be seen in the trajectories above and the phase plane below that, in an **ISN**, $r_I$ will increase first but then decay to the new fixed point in which both $r_I$ and $r_E$ are decreased compared to the original fixed point. However, by adding $\\delta I^{\\rm ext}_I$ into a **non-ISN**, $r_I$ will increase while $r_E$ will decrease."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "WAPy3MUUlW1r"
      },
      "source": [
        "### Interactive Demo 2.2: Nullclines of Example **ISN** and **non-ISN**\n",
        "\n",
        "In this interactive widget, we inject excitatory ($I^{\\text{ext}}_I>0$) or inhibitory ($I^{\\text{ext}}_I<0$) drive into the inhibitory population when the system is at its equilibrium (with parameters $w_{EE}=6.4$, $w_{EI}=4.8$, $w_{IE}=6.$, $w_{II}=1.2$, $I_{E}^{\\text{ext}}=0.8$, $\\tau_I = 0.8$, and $I^{\\text{ext}}_I=0$). How does the firing rate of the $I$ population changes with excitatory vs inhibitory drive into the inhibitory population?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "RVSSqn_LlW1r"
      },
      "outputs": [],
      "source": [
        "# @title\n",
        "\n",
        "# @markdown Make sure you execute this cell to enable the widget!\n",
        "\n",
        "pars = default_pars(T=50., dt=0.1)\n",
        "pars['wEE'], pars['wEI'] = 6.4, 4.8\n",
        "pars['wIE'], pars['wII'] = 6.0, 1.2\n",
        "pars['I_ext_E'] = 0.8\n",
        "pars['tau_I'] = 0.8\n",
        "\n",
        "@widgets.interact(\n",
        "    dI=widgets.FloatSlider(0., min=-0.2, max=0.2, step=.05)\n",
        ")\n",
        "\n",
        "\n",
        "def ISN_I_perturb(dI=0.1):\n",
        "  Lt = len(pars['range_t'])\n",
        "  pars['I_ext_I'] = np.zeros(Lt)\n",
        "  pars['I_ext_I'][int(Lt / 2):] = dI\n",
        "\n",
        "  pars['rE_init'], pars['rI_init'] = 0.6, 0.26\n",
        "  rE, rI = simulate_wc(**pars)\n",
        "\n",
        "  plt.figure(figsize=(8, 1.5))\n",
        "\n",
        "  plt.plot(pars['range_t'], pars['I_ext_I'], 'k')\n",
        "  plt.xlabel('t (ms)')\n",
        "  plt.ylabel(r'$I_I^{\\mathrm{ext}}$')\n",
        "  plt.ylim(pars['I_ext_I'].min() - 0.01, pars['I_ext_I'].max() + 0.01)\n",
        "  plt.show()\n",
        "\n",
        "  plt.figure(figsize=(8, 4.5))\n",
        "  plt.plot(pars['range_t'], rE, 'b', label=r'$r_E$')\n",
        "  plt.plot(pars['range_t'], rE[int(Lt / 2) - 1] * np.ones(Lt), 'b--')\n",
        "  plt.plot(pars['range_t'], rI, 'r', label=r'$r_I$')\n",
        "  plt.plot(pars['range_t'], rI[int(Lt / 2) - 1] * np.ones(Lt), 'r--')\n",
        "  plt.ylim(0, 0.8)\n",
        "  plt.xlabel('t (ms)')\n",
        "  plt.ylabel('Activity')\n",
        "  plt.legend(loc='best')\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "4Vug5EMClW1r"
      },
      "source": [
        "---\n",
        "# Section 3: Fixed point and working memory"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "w6UOJk_3lW1s"
      },
      "source": [
        "The input into the neurons measured in the experiment is often very noisy ([links](http://www.scholarpedia.org/article/Stochastic_dynamical_systems)). Here, the noisy synaptic input current is modeled as an Ornstein-Uhlenbeck (OU)process, which has been discussed several times in the previous tutorials.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "yzW1tC5-lW1s"
      },
      "outputs": [],
      "source": [
        "# @markdown Make sure you execute this cell to enable the function my_OU and plot the input current!\n",
        "\n",
        "\n",
        "def my_OU(pars, sig, myseed=False):\n",
        "  \"\"\"\n",
        "  Expects:\n",
        "  pars       : parameter dictionary\n",
        "  sig        : noise amplitute\n",
        "  myseed     : random seed. int or boolean\n",
        "\n",
        "  Returns:\n",
        "  I          : Ornstein-Uhlenbeck input current\n",
        "  \"\"\"\n",
        "\n",
        "  # Retrieve simulation parameters\n",
        "  dt, range_t = pars['dt'], pars['range_t']\n",
        "  Lt = range_t.size\n",
        "  tau_ou = pars['tau_ou']  # [ms]\n",
        "\n",
        "  # set random seed\n",
        "  if myseed:\n",
        "      np.random.seed(seed=myseed)\n",
        "  else:\n",
        "      np.random.seed()\n",
        "\n",
        "  # Initialize\n",
        "  noise = np.random.randn(Lt)\n",
        "  I_ou = np.zeros(Lt)\n",
        "  I_ou[0] = noise[0] * sig\n",
        "\n",
        "  # generate OU\n",
        "  for it in range(Lt-1):\n",
        "      I_ou[it+1] = (I_ou[it]\n",
        "                    + dt / tau_ou * (0. - I_ou[it])\n",
        "                    + np.sqrt(2 * dt / tau_ou) * sig * noise[it + 1])\n",
        "  return I_ou\n",
        "\n",
        "\n",
        "pars = default_pars(T=50)\n",
        "pars['tau_ou'] = 1.  # [ms]\n",
        "sig_ou = 0.1\n",
        "I_ou = my_OU(pars, sig=sig_ou, myseed=2020)\n",
        "plt.figure(figsize=(8, 5.5))\n",
        "plt.plot(pars['range_t'], I_ou, 'b')\n",
        "plt.xlabel('Time (ms)')\n",
        "plt.ylabel(r'$I_{\\mathrm{OU}}$')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "RHckw2WBlW1s"
      },
      "source": [
        "\n",
        "\n",
        "With the default parameters, the system fluctuates around a resting state with the noisy input.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "1g3dPK07lW1s"
      },
      "outputs": [],
      "source": [
        "# @markdown Execute this cell to plot activity with noisy input current\n",
        "pars = default_pars(T=100)\n",
        "pars['tau_ou'] = 1.  # [ms]\n",
        "sig_ou = 0.1\n",
        "pars['I_ext_E'] = my_OU(pars, sig=sig_ou, myseed=20201)\n",
        "pars['I_ext_I'] = my_OU(pars, sig=sig_ou, myseed=20202)\n",
        "\n",
        "pars['rE_init'], pars['rI_init'] = 0.1, 0.1\n",
        "rE, rI = simulate_wc(**pars)\n",
        "\n",
        "plt.figure(figsize=(8, 5.5))\n",
        "ax = plt.subplot(111)\n",
        "ax.plot(pars['range_t'], rE, 'b', label='E population')\n",
        "ax.plot(pars['range_t'], rI, 'r', label='I population')\n",
        "ax.set_xlabel('t (ms)')\n",
        "ax.set_ylabel('Activity')\n",
        "ax.legend(loc='best')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "8ZSNS7cNlW1s"
      },
      "source": [
        "## Interactive Demo 3: Short pulse induced persistent activity\n",
        "Then, let's use a brief 10-ms positive current to the E population when the system is at its equilibrium. When this amplitude (SE below) is sufficiently large, a persistent activity is produced that outlasts the transient input. What is the firing rate of the persistent activity, and what is the critical input strength? Try to understand the phenomena from the above phase-plane analysis."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "bgnZSQ_IlW1s"
      },
      "outputs": [],
      "source": [
        "# @markdown Make sure you execute this cell to enable the widget!\n",
        "def my_inject(pars, t_start, t_lag=10.):\n",
        "  \"\"\"\n",
        "  Expects:\n",
        "  pars       : parameter dictionary\n",
        "  t_start    : pulse starts [ms]\n",
        "  t_lag      : pulse lasts  [ms]\n",
        "\n",
        "  Returns:\n",
        "  I          : extra pulse time\n",
        "  \"\"\"\n",
        "\n",
        "  # Retrieve simulation parameters\n",
        "  dt, range_t = pars['dt'], pars['range_t']\n",
        "  Lt = range_t.size\n",
        "\n",
        "  # Initialize\n",
        "  I = np.zeros(Lt)\n",
        "\n",
        "  # pulse timing\n",
        "  N_start = int(t_start / dt)\n",
        "  N_lag = int(t_lag / dt)\n",
        "  I[N_start:N_start + N_lag] = 1.\n",
        "\n",
        "  return I\n",
        "\n",
        "\n",
        "pars = default_pars(T=100)\n",
        "pars['tau_ou'] = 1.  # [ms]\n",
        "sig_ou = 0.1\n",
        "pars['I_ext_I'] = my_OU(pars, sig=sig_ou, myseed=2021)\n",
        "pars['rE_init'], pars['rI_init'] = 0.1, 0.1\n",
        "\n",
        "\n",
        "# pulse\n",
        "I_pulse = my_inject(pars, t_start=20., t_lag=10.)\n",
        "L_pulse = sum(I_pulse > 0.)\n",
        "\n",
        "@widgets.interact(\n",
        "    SE=widgets.FloatSlider(0., min=0., max=1., step=.05)\n",
        ")\n",
        "\n",
        "\n",
        "def WC_with_pulse(SE=0.):\n",
        "  pars['I_ext_E'] = my_OU(pars, sig=sig_ou, myseed=2022)\n",
        "  pars['I_ext_E'] += SE * I_pulse\n",
        "\n",
        "  rE, rI = simulate_wc(**pars)\n",
        "\n",
        "  plt.figure(figsize=(8, 5.5))\n",
        "  ax = plt.subplot(111)\n",
        "  ax.plot(pars['range_t'], rE, 'b', label='E population')\n",
        "  ax.plot(pars['range_t'], rI, 'r', label='I population')\n",
        "\n",
        "  ax.plot(pars['range_t'][I_pulse > 0.], 1.0*np.ones(L_pulse), 'r', lw=3.)\n",
        "  ax.text(25, 1.05, 'stimulus on', horizontalalignment='center',\n",
        "          verticalalignment='bottom')\n",
        "  ax.set_ylim(-0.03, 1.2)\n",
        "  ax.set_xlabel('t (ms)')\n",
        "  ax.set_ylabel('Activity')\n",
        "  ax.legend(loc='best')\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "t3LXGUBwlW1s"
      },
      "source": [
        "Explore what happens when a second, brief current is applied to the inhibitory population."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernel": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "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.17"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}