Options_américaines_et_volatilité_forward.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tsLkew68oNNO"
      },
      "source": [
        "# Options américaines : l'impact de la volatilité forward\n",
        "\n",
        "\n",
        "> **Emmanuel Evilafo**\n",
        "\n",
        "Dans le cadre du modèle de Black & Scholes, on regarde dans ce notebook comment la structure par terme de la volatilité de l'actif sous jacent, et donc en particulier sa volatilité forward, peut influencer le prix des options américaines.\n",
        "\n",
        "Les options sont évaluées par différences finies.\n",
        "\n",
        "On se donne deux dates $T_1<T_2$, et des volatilités implicites $\\sigma_\\text{imp}(T_1)$ et $\\sigma_\\text{imp}(T_2)$ pour ces deux maturités ; on souhaite étudier le prix des options européennes et américaines de maturité $T_2$ dans le modèle de Black & Scholes généralisé suivant :\n",
        "$$\n",
        "\\frac{dS_t}{S_t} = (r - d)\\, dt + \\sigma(t)\\,dW_t\n",
        "$$\n",
        "On suppose la fonction de volatilité instantanée $\\sigma$ constante par morceaux : $\\sigma(t) = \\sigma_1$ sur $[0, T_1[$ et $\\sigma(t) = \\sigma_2$ sur $[T_1,, T_2[$, et on calibre $\\sigma_1$ et $\\sigma_2$ sur les deux volatilités implicites $\\sigma_\\text{imp}(T_1)$ et $\\sigma_\\text{imp}(T_2)$. Compte tenu de la relation $\\sigma_\\text{imp}(T)^2\\;T = \\int_0^{T}\\sigma(t)^2dt$ entre la volatilité implicite et volatilité instantanée, on obtient :\n",
        "$$\n",
        "\\sigma_1 = \\sigma_\\text{imp}(T_1) \\qquad\\text{et}\\qquad \\sigma_2 = \\sqrt{\\frac{\\sigma_\\text{imp}(T_2)^2\\,T_2-\\sigma_1^2\\, T_1}{T_2-T_1}}\n",
        "$$\n",
        "\n",
        "Dans ce qui suit on va comparer les prix d'options obtenus dans le cas d'un BS standard ($\\sigma_\\text{imp}(T_1)=\\sigma_\\text{imp}(T_2)$ conduisant à une volatilité instantanée $\\sigma(t)$ constante), et dans le cas où les deux volatilités implicites diffèrent, induisant dans le modèle une term structure non constante de volatilité."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a-UsBwndesNk"
      },
      "source": [
        "## Imports et formules de BS (Black Scholes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "lFUVBbreoIZ1"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import math\n",
        "import time\n",
        "from scipy.linalg import solve_banded\n",
        "from scipy.interpolate import interp1d\n",
        "from scipy.stats import norm\n",
        "\n",
        "# Fonction call BS\n",
        "def bs_call(T, K, F0, sigma) :\n",
        "    sigma_sqrt_T = sigma * np.sqrt(T)\n",
        "    d1 = (np.log(F0/K) + 0.5 * sigma**2 * T) / sigma_sqrt_T\n",
        "    d2 = d1 - sigma_sqrt_T\n",
        "    return F0 * norm.cdf(d1) - K * norm.cdf(d2)\n",
        "\n",
        "# Fonction call BS\n",
        "def bs_put(T, K, F0, sigma) :\n",
        "    return bs_call(T, K, F0, sigma) - (F0 - K)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J6z_24AKYaD9"
      },
      "source": [
        "## Implémentation des différences finies (Crank-Nicholson)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "36UwOza78ckw"
      },
      "outputs": [],
      "source": [
        "class bs_pde :\n",
        "\n",
        "\tdef __init__(self, S0, r, d, sigma, T, nt, ns, nstdev):\n",
        "\n",
        "\t\tself.t = np.linspace(0., T, nt, endpoint=True)\n",
        "\t\tself.S0 = S0\n",
        "\t\tself.r = r\n",
        "\t\tself.d = d\n",
        "\t\tself.sigma = sigma\n",
        "\n",
        "\t\t# s discrétisation\n",
        "\t\tavg_vol = (sigma(0) + sigma(T)) / 2.\n",
        "\t\tu_max = math.exp(nstdev * avg_vol * math.sqrt(T))\n",
        "\t\ts_max = S0 * u_max\n",
        "\t\ts_min = S0 / u_max\n",
        "\t\tself.s = np.linspace(s_min, s_max, ns, endpoint=True)\n",
        "\n",
        "\n",
        "\t# calcul et affichage du prix du PDE\n",
        "\tdef compute_price (self, payoff, name = 'Prix du PDE', closed_form_price = -1, display = True, return_price_grid = False) :\n",
        "\t\tt_start = time.time()\n",
        "\n",
        "\t\t# Crank Nicholson\n",
        "\t\ttheta = 0.5\n",
        "\n",
        "      \t# dimensions d'espace et de temps\n",
        "\t\tnt = len(self.t)\n",
        "\t\tns = len(self.s)\n",
        "\t\tds = (self.s[-1] - self.s[0]) / (ns - 1.)\n",
        "\t\tdt = (self.t[-1] - self.t[0]) / (nt - 1.)\n",
        "\n",
        "\t\t# valeur de l'option\n",
        "\t\tv = np.zeros((nt, ns))\n",
        "\n",
        "\t\t# payoff à la date finale\n",
        "\t\tv[-1,:] = payoff(self.t[-1], v[-1,:])\n",
        "\n",
        "\t\t# boucle darrière à partir de t = t_max - dt to t = 0\n",
        "\t\tfor i in range(nt-2, -1, -1): # => i = nt-2 ... 0\n",
        "\n",
        "\t\t\t# précalculs\n",
        "\t\t\tvol = self.sigma(self.t[i])\n",
        "\t\t\tvar =  (vol*self.s)**2 * dt\n",
        "\t\t\tmu_dt = (self.r - self.d) * self.s * dt\n",
        "\t\t\tr_dt = self.r * dt\n",
        "\n",
        "\t\t\talpha_u = (var + mu_dt * ds) / (2.*ds**2)\n",
        "\t\t\talpha_d = (var - mu_dt * ds) / (2.*ds**2)\n",
        "\t\t\talpha_c = - var / ds**2\n",
        "\n",
        "\t\t\t# limites\n",
        "\t\t\talpha_u[0]  = mu_dt[0] / ds\n",
        "\t\t\talpha_c[0]  = -alpha_u[0]\n",
        "\t\t\talpha_d[0]  = 0.\n",
        "\t\t\talpha_u[-1] = 0.\n",
        "\t\t\talpha_c[-1] = mu_dt[-1] / ds\n",
        "\t\t\talpha_d[-1] = -alpha_c[-1]\n",
        "\n",
        "\t\t\t# coeficiens de transition\n",
        "\t\t\tp_ur = (1.-theta)*alpha_u\n",
        "\t\t\tp_dr = (1.-theta)*alpha_d\n",
        "\t\t\tp_cr = (1.-theta)*alpha_c + 1. - (1.-theta)*r_dt\n",
        "\t\t\tp_ul = -theta*alpha_u\n",
        "\t\t\tp_dl = -theta*alpha_d\n",
        "\t\t\tp_cl = -theta*alpha_c + 1. + theta*r_dt\n",
        "\n",
        "\t\t\t# calcul du right\n",
        "\t\t\tright = np.empty(ns)\n",
        "\t\t\tright[0] = p_cr[0]*v[i+1, 0] + p_ur[0]*v[i+1, 1]\n",
        "\t\t\tright[1:ns-1] = p_dr[1:ns-1]*v[i+1,0:ns-2] + p_cr[1:ns-1]*v[i+1,1:ns-1] + p_ur[1:ns-1]*v[i+1,2:ns]\n",
        "\t\t\tright[-1] = p_cr[-1]*v[i+1,-1] + p_dr[-1]*v[i+1,-2]\n",
        "\n",
        "\t\t\t# matrice tridiagonale inversée par étape\n",
        "\t\t\tupper_band = np.insert(p_ul, 0, 0.)[:-1] # transform p_ul pour appeler solve_banded (0 doit être en première position)\n",
        "\t\t\tlower_band = np.append(p_dl[1:ns], 0)  # transformer p_ul pour appeler solve_banded (0 doit être en dernière position)\n",
        "\t\t\ttridiag = np.array([upper_band, p_cl, lower_band])\n",
        "\t\t\tv[i,:] = solve_banded((1, 1), tridiag, right)\n",
        "\n",
        "\t\t\t# applique le payoff à v\n",
        "\t\t\tv[i,:] = payoff(self.t[i], v[i,:])\n",
        "\n",
        "\t\t# interpoler le prix dans le tableau des valeurs d'option\n",
        "\t\tprice_interp = interp1d(self.s, v[0,:], kind='linear')\n",
        "\t\tprice = price_interp(self.S0)\n",
        "\n",
        "\t\tif (display):\n",
        "\t\t\tprint(\"--------------------------------------------------------------\")\n",
        "\t\t\tif (closed_form_price == -1) :\n",
        "\t\t\t\tprint(\"{} = {:.5f}\".format(name, price) )\n",
        "\t\t\telse :\n",
        "\t\t\t\tprint(\"{} = {:.5f} (closed-form price = {:.5f})\".format(name, price, closed_form_price) )\n",
        "\t\t\tif (closed_form_price != -1):\n",
        "\t\t\t\tprint(\"Rel. error : {:.4f}%\".format(100.*(price-closed_form_price)/closed_form_price))\n",
        "\t\t\tprint(\"PDE computation time : {:.3f} seconds\".format(time.time()-t_start))\n",
        "\n",
        "\t\tif (return_price_grid):\n",
        "\t \t\treturn v\n",
        "\t\telse:\n",
        "\t\t\treturn price\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v1a_0wX4ZdLe"
      },
      "source": [
        "## Pricing des options\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sD1GFEtm8nS2",
        "outputId": "8ea408a9-2167-4bcd-aa37-d11b90e732a4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "Black & Scholes standard, volatilité constante = 20.00% \n",
            "===================================================================================================================\n",
            "--------------------------------------------------------------\n",
            "Call européen - PDE = 10.45277 (closed-form price = 10.45058)\n",
            "Rel. error : 0.0210%\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.033 seconds\n",
            "--------------------------------------------------------------\n",
            "Call américain - PDE = 10.45277\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.028 seconds\n",
            "--------------------------------------------------------------\n",
            "Put européen - PDE = 5.57572 (closed-form price = 5.57353)\n",
            "Rel. error : 0.0393%\n",
            "PDE computation time : 0.025 seconds\n",
            "--------------------------------------------------------------\n",
            "Put américain - PDE = 6.08911\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.024 seconds\n",
            "\n",
            "\n",
            "Volatilité croissante : vol implicite T1 = 15.00%, vol implicite T2 = 20.00%, vol forward T1 -> T2 = 23.98%\n",
            "===================================================================================================================\n",
            "--------------------------------------------------------------\n",
            "Call européen - PDE = 10.44969 (closed-form price = 10.45058)\n",
            "Rel. error : -0.0085%\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.027 seconds\n",
            "--------------------------------------------------------------\n",
            "Call américain - PDE = 10.44969\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.026 seconds\n",
            "--------------------------------------------------------------\n",
            "Put européen - PDE = 5.57263 (closed-form price = 5.57353)\n",
            "Rel. error : -0.0160%\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.026 seconds\n",
            "--------------------------------------------------------------\n",
            "Put américain - PDE = 5.87473\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.042 seconds\n",
            "\n",
            "\n",
            "Volatilité décroissante : vol implicite T1 = 25.00%, vol implicite T2 = 20.00%, vol forward T1 -> T2 = 13.23%\n",
            "===================================================================================================================\n",
            "--------------------------------------------------------------\n",
            "Call européen - PDE = 10.45205 (closed-form price = 10.45058)\n",
            "Rel. error : 0.0140%\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.026 seconds\n",
            "--------------------------------------------------------------\n",
            "Call américain - PDE = 10.45205\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.025 seconds\n",
            "--------------------------------------------------------------\n",
            "Put européen - PDE = 5.57499 (closed-form price = 5.57353)\n",
            "Rel. error : 0.0262%\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.024 seconds\n",
            "--------------------------------------------------------------\n",
            "Put américain - PDE = 6.47044\n",
            "Temps de calcul de PDE (Equation differentielle stochastique) : 0.030 seconds\n",
            "\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Parametres de PDE (Equation differentielle stochastique) \n",
        "T2 = 1 # date finale du schéma = date d'échéance des options\n",
        "T1 = T2/2\n",
        "nt = 201\n",
        "ns = 301\n",
        "nstdev = 6\n",
        "\n",
        "# Params du sous-jacent et des options\n",
        "S0 = 100\n",
        "K = 100\n",
        "r = 0.05\n",
        "q = 0.0\n",
        "implied_vol = 0.20 # vol implicite de référence pour la maturité T2\n",
        "\n",
        "# initialisation sigma1 et sigma2\n",
        "sigma1 = sigma2 = 0\n",
        "\n",
        "# Calibration de sigma1 et sigma2 sur les vols implicites\n",
        "def calibrate_sigma():\n",
        "    global sigma1, sigma2\n",
        "    sigma1 = implied_vol_T1\n",
        "    sigma2 = math.sqrt( (implied_vol_T2**2 * T2 - sigma1**2 * T1) / (T2 - T1) )\n",
        "\n",
        "# Fonction de vol instantanée\n",
        "def sigma(t):\n",
        "    global sigma1, sigma2\n",
        "    if (t < T1) :\n",
        "        return sigma1\n",
        "    else :\n",
        "        return sigma2\n",
        "\n",
        "# Définition des payoffs des options européennes et américaines\n",
        "def european_call_payoff(t,v):\n",
        "\tif (math.isclose(t,T2)):\n",
        "\t\tv = np.maximum(pde.s - K, 0)\n",
        "\treturn v\n",
        "\n",
        "def european_put_payoff(t,v):\n",
        "\tif (math.isclose(t,T2)):\n",
        "\t\tv = np.maximum(K - pde.s, 0)\n",
        "\treturn v\n",
        "\n",
        "def american_call_payoff(t,v):\n",
        "\treturn np.maximum(pde.s - K, v)\n",
        "\n",
        "def american_put_payoff(t,v):\n",
        "\treturn np.maximum(K - pde.s, v)\n",
        "\n",
        "# Prix du call et du put européen de maturité T2\n",
        "DF = math.exp(-r*T2)\n",
        "fwd = S0 * math.exp((r-q)*T2)\n",
        "call_eur =  DF * bs_call(T2, K, fwd, implied_vol)\n",
        "put_eur  =  DF * bs_put(T2, K, fwd, implied_vol)\n",
        "\n",
        "# Prix des options dans le modèle BS classique\n",
        "# la vol implicite de maturité T1 est la même que la la vol implicite de maturité T2, la vol instantanée est constante au cours du temps\n",
        "implied_vol_T2 = implied_vol_T1 = implied_vol\n",
        "calibrate_sigma()\n",
        "pde = bs_pde (S0, r, q, sigma, T2, nt, ns, nstdev)\n",
        "print(\"\\n\")\n",
        "print(\"Black & Scholes standard, volatilité constante = {:.2f}% \".format(implied_vol_T2*100) )\n",
        "print(\"===================================================================================================================\")\n",
        "pde_call_eur_flat_vol = pde.compute_price(european_call_payoff, \"Call européen - PDE\", call_eur)\n",
        "pde_call_us_flat_vol  = pde.compute_price(american_call_payoff, \"Call américain - PDE\")\n",
        "pde_put_eur_flat_vol  = pde.compute_price(european_put_payoff, \"Put européen - PDE\", put_eur)\n",
        "pde_put_us_flat_vol   = pde.compute_price(american_put_payoff, \"Put américain - PDE\")\n",
        "print(\"\\n\")\n",
        "\n",
        "# Prix des options dans le modèle BS généralisé avec une vol implicite croissante et donc une volatilité forward sigma2 plus élevée (sigma1 < implied_vol_T2 < sigma2)\n",
        "implied_vol_T2 = implied_vol\n",
        "implied_vol_T1 = implied_vol - 0.05\n",
        "calibrate_sigma()\n",
        "pde = bs_pde (S0, r, q, sigma, T2, nt, ns, nstdev)\n",
        "print(\"Volatilité croissante : vol implicite T1 = {:.2f}%, vol implicite T2 = {:.2f}%, vol forward T1 -> T2 = {:.2f}%\".format(implied_vol_T1*100, implied_vol_T2*100, sigma2*100) )\n",
        "print(\"===================================================================================================================\")\n",
        "p = pde.compute_price(european_call_payoff, \"Call européen - PDE\", call_eur)\n",
        "p = pde.compute_price(american_call_payoff, \"Call américain - PDE\")\n",
        "p = pde.compute_price(european_put_payoff, \"Put européen - PDE\", put_eur)\n",
        "p = pde.compute_price(american_put_payoff, \"Put américain - PDE\")\n",
        "print(\"\\n\")\n",
        "\n",
        "# Prix des options dans le modèle BS généralisé avec sigma1 > implied vol > sigma2 (vol forward faible)\n",
        "implied_vol_T2 = implied_vol\n",
        "implied_vol_T1 = implied_vol + 0.05\n",
        "calibrate_sigma()\n",
        "pde = bs_pde (S0, r, q, sigma, T2, nt, ns, nstdev)\n",
        "print(\"Volatilité décroissante : vol implicite T1 = {:.2f}%, vol implicite T2 = {:.2f}%, vol forward T1 -> T2 = {:.2f}%\".format(implied_vol_T1*100, implied_vol_T2*100, sigma2*100) )\n",
        "print(\"===================================================================================================================\")\n",
        "p = pde.compute_price(european_call_payoff, \"Call européen - PDE\", call_eur)\n",
        "p = pde.compute_price(american_call_payoff, \"Call américain - PDE\")\n",
        "p = pde.compute_price(european_put_payoff, \"Put européen - PDE\", put_eur)\n",
        "p = pde.compute_price(american_put_payoff, \"Put américain - PDE\")\n",
        "\n",
        "print(\"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TEAAbrcar6E_"
      },
      "source": [
        "## Interprétation des résultats\n",
        "\n",
        "Le modèle étant calibré sur la volatilité implicite de maturité $T_2$, le prix des call et put européens de maturité $T_2$ reste totalement inchangé quelle que soit la Structure des termes de volatilité (autrement dit quelle que soit la vol implicite de maturité $T_1$).\n",
        "\n",
        "De même, nous sommes ici dans le cas d'un taux d'intérêt positif et d'absence de dividendes sur l'actif, cas où le prix du call américain coïncide parfaitement avec celui du call européen, et ce quel que soit le modèle utilisé. En conséquence, pour les 3 Structure des termes de volalité, le prix du call américain est égal à celui de l'européen et demeure inchangé.\n",
        "\n",
        "En revanche, le prix du put américain est dans cette situation strictement supérieur à celui du put européen (car son exercice anticipé est parfois plus intéressant que sa conservation) et **le prix du put américain est sensible à la Structure des termes de volatilité** :\n",
        "\n",
        "* Prix du put américain pour une volatilité constante : **6.09**\n",
        "* Prix du put américain pour une volatilité croissante : **5.87**\n",
        "* Prix du put américain pour une volatilité décroissante : **6.47**\n",
        "\n",
        "Autrement dit, **plus la volatilité forward est faible, plus le put américain est cher.**\n",
        "\n",
        "Comment expliquer qualitativement ce phénomène ?\n",
        "\n",
        "Le surplus de valeur du put américain par rapport au put européen s'explique par l'existence de trajectoires de l'actif où l'exercice anticipé du put européen est plus intéressant que la conservation de l'optionnalité pour une date ultérieure. Plus formellement, il s'agit des situations où à une date $t>0$, la valeur $K-S_t$ de l'exercice anticipé du put américain est supérieure à son prix $P_t$ à cette date.\n",
        "\n",
        "Or la valeur $P_t$ en $t$ du put américain dépend de la volatilité forward de l'actif entre $t$ et la maturité $T_2$ de l'option : plus la volatilité en question est faible, plus le prix $P_t$ est faible, et donc plus exercice immédiat de valeur $K-S_t$ a de chance d'être préférable. Ce nombre accru d'exercices anticipés renchérit alors la valeur du put américain.\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "v7Cx3dDoKrM5"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}