Results_colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Results_colab.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMRljpXNKHR1Gm3R2npKMTF",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/brentianpalmer/FinMarketsFinal/blob/main/Results_colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bNua0W8rgUqm",
        "outputId": "839449fb-ca25-4b80-c96c-8cc8edd63b19"
      },
      "source": [
        "#@title\n",
        "import math\n",
        "import numpy as np\n",
        "from scipy.stats import norm\n",
        "import matplotlib.pyplot as plt\n",
        "import pprint\n",
        "from statsmodels.iolib.table import SimpleTable\n",
        "import pandas as pd\n",
        "import collections\n",
        "\n",
        "inputs = {\n",
        "          'delta': 0.25, \n",
        "          'T': 3, \n",
        "          'q': 0, \n",
        "          'k_stock_lognormal': 1, \n",
        "          'k_libor_lognormal': 1,\n",
        "          'Nsim': 100000, \n",
        "          'L0': 0.0034, \n",
        "          'sigma_l': 0.08, \n",
        "          'sigma_p': 0.05, \n",
        "          'rho_sl': 0.65, \n",
        "          'xp': [1.0/12, 2.0/12, 3.0/12, 0.5, 1, 2, 3, 5, 7, 10, 20, 30],\n",
        "          'yp': [0.02,\t0.01,\t0.02,\t0.04,\t0.05,\t0.16,\n",
        "                 0.32,\t0.80,\t1.27,\t1.63,\t2.20,\t2.32], \n",
        "          }\n",
        "\n",
        "def lognormalPricer(inputs=inputs):\n",
        "    outputs = {}\n",
        "    T = inputs.get('T')\n",
        "    delta = inputs.get('delta')\n",
        "    k_stock_lognormal = inputs.get('k_stock_lognormal')\n",
        "    S0 = 271.27211906501435\n",
        "    # Japan 3 year government bond yield (from market data (3yr yield)\n",
        "    r_f = -0.00138\n",
        "    # -------- Correlations --------- #\n",
        "    # Correlation stock and exchange rate #\n",
        "    rho_sx = -0.3049678  # correl (NI225 in USD, USD/JPY (DOM exchange rate))\n",
        "    \n",
        "    # Correl (NI225 in USD, bond maturing in 3 years) *** THIS IS MADE UP ***\n",
        "    rho_sl = inputs.get('rho_sl')\n",
        "    rho_sp = -rho_sl\n",
        "    # -------- Volatilities --------- #\n",
        "    sigma_s = 0.199468950979314  # Volatility of NI225 in USD\n",
        "    sigma_x = 0.0519824811701589  # Volatility of USD/JPY (DOM exchange rate).\n",
        "\n",
        "    quanto_adj = r_f - inputs.get('q') - rho_sx * sigma_s * sigma_x\n",
        "    girsanov_chg_measure_QT = sigma_s * inputs.get('sigma_p') * rho_sp\n",
        "\n",
        "    Nsim = inputs.get('Nsim')\n",
        "    # Process for Generating Correlated Random Samples from Normal distribution from Hull Chapter 21\n",
        "    # np.random.seed(456)\n",
        "    # random sample from standard normal dist\n",
        "    rand1 = np.random.normal(0, 1, Nsim)\n",
        "    # another random sample from different standard normal dist\n",
        "    rand2 = np.random.normal(0, 1, Nsim)\n",
        "    eps = rand1  # eps for stock lognormal simulation\n",
        "    # eps for libor lognormal simulation\n",
        "    eps_tilda = (rho_sl*rand1)+rand2*np.sqrt(1-rho_sl**2)\n",
        "    outputs['eps'] = eps\n",
        "    outputs['eps_tilda'] = eps_tilda\n",
        "\n",
        "    # As a result, we now can simulate ST with a one-step monte carlo as follows:\n",
        "    ST = S0 * np.exp((quanto_adj + girsanov_chg_measure_QT-0.5 *\n",
        "                      sigma_s*sigma_s)*T + sigma_s*np.sqrt(T)*eps) # The MC scheme with vectorized NumPy code handling all paths at once.\n",
        "    ST_avg = np.average(ST)\n",
        "\n",
        "    # Equity Ratio at time T:\n",
        "    ST_over_S0 = ST/S0\n",
        "    ST_over_S0_avg = np.average(ST_over_S0)\n",
        "\n",
        "    # Equity Ratio vs. strike price k\n",
        "    ST_over_S0_k = ST_over_S0-k_stock_lognormal\n",
        "    ST_over_S0_avg_k = ST_over_S0_avg-k_stock_lognormal\n",
        "\n",
        "    outputs['ST'] = ST\n",
        "    outputs['ST_avg'] = ST_avg\n",
        "    outputs['ST_over_S0'] = ST_over_S0\n",
        "    outputs['ST_over_S0_avg'] = ST_over_S0_avg\n",
        "    outputs['ST_over_S0_k'] = ST_over_S0_k\n",
        "    outputs['ST_over_S0_avg_k'] = ST_over_S0_avg_k\n",
        "\n",
        "    xp = inputs.get('xp')\n",
        "    yp = inputs.get('yp')\n",
        "    L0 = inputs.get('L0')\n",
        "\n",
        "    x_hat = np.arange(0, 30.25, 0.25)\n",
        "    y_interp = np.interp(x_hat, xp, yp)\n",
        "    \n",
        "    # Y(0,T) is the yield-to-maturity on a zero coupon bond maturing at time T, \n",
        "    # which we use to calculate p(0,T).\n",
        "    y_0T = np.interp(T, xp, yp)\n",
        "\n",
        "    # Y(0,T-delta) is the yield-to-maturity on a zero coupon bond maturing \n",
        "    # at time T-delta. This is used to calculated p(0,T-delta).\n",
        "    y_0Td = np.interp(T-delta, xp, yp)\n",
        "    \n",
        "    # p(0,T) is the value at time 0 of receiving a dollar at time T\n",
        "    # This is also called the discount factor\n",
        "    p_0T = np.exp(-y_0T/100*T)\n",
        "\n",
        "    # p(0,T-delta)is the value at time 0 of receiving a dollar at time T-delta\n",
        "    p_0Td = np.exp(-y_0Td/100*(T-delta)) \n",
        "\n",
        "    # sigma_l is the vol of libor\n",
        "    sigma_l = inputs.get('sigma_l')\n",
        "\n",
        "    # We then simulate L(T-delta,T-delta,T) via a Monte Carlo simulation \n",
        "    # starting at L0\n",
        "    L_TdTdT = L0 * np.exp(sigma_l * np.sqrt(T - delta) *\n",
        "                         eps_tilda - 0.5*sigma_l*sigma_l*(T-delta))\n",
        "    \n",
        "    # Average L(T-delta,T-delta,T) # Numerator of payoff\n",
        "    L_TdTdT_avg = np.average(L_TdTdT) \n",
        "\n",
        "\n",
        "    # We then derive from market data for L(0,T-delta,T) \n",
        "    # L(0,T-delta,T) is L_0TdT #Denominator of payoff\n",
        "    L_0TdT = -(p_0T - p_0Td)/(delta*p_0T)\n",
        "\n",
        "    # Average of L(0,T-delta,T) is L_0TdT #Denominator of payoff L(0,T-delta,T)\n",
        "    L_0TdT_avg = np.average(L_0TdT)\n",
        "\n",
        "    # Libor ratio of payoff L(T-delta,T-delta,T) over L(0,T-delta,T)\n",
        "    L_TdTdT_over_L_0TdT = L_TdTdT/L_0TdT\n",
        "    L_TdTdT_over_L_0TdT_avg = np.average(L_TdTdT_over_L_0TdT)\n",
        "\n",
        "    # Get libor strike K from inputs\n",
        "    k_libor_lognormal = inputs.get('k_libor_lognormal')\n",
        "    \n",
        "    # Calculate payoff for equity and libor ratios relative to strikes, k, and multiply\n",
        "    pi = np.maximum(0, np.multiply(\n",
        "        (ST_over_S0 - k_stock_lognormal), (k_libor_lognormal-L_TdTdT_over_L_0TdT)))\n",
        "    pi_avg = np.average(pi)\n",
        "\n",
        "    # Discount pi back to today using p(0,T)\n",
        "    price = p_0T * pi_avg\n",
        "\n",
        "    outputs['x_hat'] = x_hat\n",
        "    outputs['y_interp'] = y_interp\n",
        "    outputs['y_0T'] = y_0T\n",
        "    outputs['y_0Td'] = y_0Td\n",
        "    outputs['p_0T'] = p_0T\n",
        "    outputs['p_0Td'] = p_0Td\n",
        "    outputs['L_0TdT'] = L_0TdT\n",
        "    outputs['L_0TdT_avg'] = L_0TdT_avg\n",
        "    outputs['L_TdTdT'] = L_TdTdT\n",
        "    outputs['L_TdTdT_avg'] = L_TdTdT_avg\n",
        "    outputs['L_TdTdT_over_L_0TdT'] = L_TdTdT_over_L_0TdT\n",
        "    outputs['L_TdTdT_over_L_0TdT_avg'] = L_TdTdT_over_L_0TdT_avg\n",
        "    outputs['pi'] = pi\n",
        "    outputs['pi_avg'] = pi_avg\n",
        "    outputs['price'] = price\n",
        "\n",
        "    return outputs\n",
        "\n",
        "outputs = lognormalPricer(inputs)\n",
        "\n",
        "print(\"Complete\")\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Complete\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "IiWiX2m26IiY"
      },
      "source": [
        "#@title\n",
        "def stock_graph():\n",
        "    S0 = inputs.get('S0')\n",
        "    ST = outputs.get('ST')\n",
        "    ST_avg = outputs.get('ST_avg')\n",
        "    x = []\n",
        "    y = []\n",
        "    for i in ST:\n",
        "        y.append(i)\n",
        "        y.append(S0)\n",
        "        x.append(1)\n",
        "        x.append(0)\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.title(\"One-Step Monte Carlo Simulation for Stock\")\n",
        "    plt.plot(x, y, label='paths')\n",
        "    plt.axhline(ST_avg, color='r', label='mean value of ST')\n",
        "    plt.legend(loc='upper left')\n",
        "    plt.xticks()\n",
        "    plt.xticks(np.arange(0, 1.1, step=1))\n",
        "    plt.xticks([0, 1], ['0', 'T'])\n",
        "    print(\"ST mean: \", ST.mean())\n",
        "    plt.show()\n",
        "\n",
        "def ST_outcomes():\n",
        "    ST = outputs.get('ST')\n",
        "    ST_avg = outputs.get('ST_avg')\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.hist(ST, bins=35, label='ST')\n",
        "    plt.axvline(ST_avg, color='r', label='ST_avg')\n",
        "    plt.title(\"ST Outcomes\")\n",
        "    plt.legend(loc=0)\n",
        "    print(\"ST_avg: \", ST_avg)\n",
        "    plt.legend(loc=0)\n",
        "    plt.show()\n",
        "\n",
        "def ST_over_SO_outcomes():\n",
        "    ST_over_S0_avg = outputs.get('ST_over_S0_avg')\n",
        "    ST_over_S0 = outputs.get('ST_over_S0')\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.hist(ST_over_S0, bins=35, label='Stock Payoff (ST/SO)')\n",
        "    plt.title(\"Stock Payoff (ST/S0)\")\n",
        "    plt.axvline(ST_over_S0_avg, color='r', label='Stock_payoff_avg')\n",
        "    plt.legend(loc=0)\n",
        "    print(\"ST_over_S0_avg (ST/S0): \", ST_over_S0_avg)\n",
        "    plt.legend(loc=0)\n",
        "    # print(\"Stock Portion of Payoff ((ST/S0)- k, where k=1): \", ST_over_S0_avg-1)\n",
        "    plt.show()\n",
        "\n",
        "def yield_curve_display():\n",
        "    xp = inputs.get('xp')\n",
        "    yp = inputs.get('yp')\n",
        "    x_hat = outputs.get('x_hat')\n",
        "    y_interp = outputs.get('y_interp')\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.plot(xp, yp, 'o', label='US Treasury Yield Curve Constant Maturity Rates')\n",
        "    plt.title(\"Interpolated US Treasury Yield Curve Rates on May 10, 2021\")\n",
        "    plt.plot(x_hat, y_interp, 'o', alpha=0.5, label='Interpolated Treasury Yield Curve')\n",
        "    plt.legend(loc=0)\n",
        "    plt.xlabel(\"Maturity\")\n",
        "    plt.ylabel(\"Yield\")\n",
        "    plt.show()\n",
        "\n",
        "def TS_info():\n",
        "    y_0T = outputs.get('y_0T')\n",
        "    print (\"y_0T:\", y_0T)\n",
        "    y_0Td = outputs.get('y_0Td') \n",
        "    print (\"y_0Td:\", y_0Td)\n",
        "    p_0T = outputs.get('p_0T') \n",
        "    print(\"p_0T: \",p_0T)    \n",
        "    L0 = inputs.get('L0')\n",
        "    print(\"L0: \",L0)\n",
        "\n",
        "def L_TdTdT_Outcomes():\n",
        "    L_TdTdT = outputs.get('L_TdTdT')\n",
        "    L_TdTdT_avg = outputs.get('L_TdTdT_avg')\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.hist(L_TdTdT, label='L_TdTdT')\n",
        "    plt.axvline(L_TdTdT_avg, color='r', label='L_TdTdT_avg')\n",
        "    plt.title(\"L_TdTdT_Outcomes\")\n",
        "    print(\"L_TdTdT_avg: \", L_TdTdT_avg)\n",
        "    plt.legend(loc=0)\n",
        "    plt.show()\n",
        "\n",
        "def L_TdTdT_over_L_0TdT_Outcomes():\n",
        "    L_TdTdT_over_L_0TdT = outputs.get('L_TdTdT_over_L_0TdT')\n",
        "    L_TdTdT_over_L_0TdT_avg = outputs.get('L_TdTdT_over_L_0TdT_avg')\n",
        "    print(\"L_TdTdT_over_L_0TdT_avg: \", L_TdTdT_over_L_0TdT_avg)\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.hist(L_TdTdT_over_L_0TdT, label='L')\n",
        "    plt.axvline(L_TdTdT_over_L_0TdT_avg, color='r', label='L_TdTdT_over_L_0TdT_avg')\n",
        "    plt.title(\"L_TdTdT_over_L_0TdT_Outcomes\")\n",
        "    plt.legend(loc=0)\n",
        "    plt.show()\n",
        "\n",
        "def pi_outcomes():\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    pi = outputs.get('pi')\n",
        "    pi_avg = outputs.get('pi_avg')\n",
        "    plt.hist(pi)\n",
        "    plt.title(\"Method 2: payoff at T\")\n",
        "    print(\"Average payoff is: \", pi_avg)\n",
        "    plt.show()\n",
        "\n",
        "def display_price():\n",
        "    price = outputs.get('price')\n",
        "    print(price)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ePnuu7km1eJx",
        "cellView": "form",
        "outputId": "a074b44f-8ee6-423c-9bd5-5a51752931dc"
      },
      "source": [
        "#@title\n",
        "print(\"Inputs:\")\n",
        "\n",
        "for k,v in inputs.items():\n",
        "  print(k,v)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Inputs:\n",
            "delta 0.25\n",
            "T 3\n",
            "q 0\n",
            "k_stock_lognormal 1\n",
            "k_libor_lognormal 1\n",
            "Nsim 100000\n",
            "L0 0.0034\n",
            "sigma_l 0.08\n",
            "sigma_p 0.05\n",
            "rho_sl 0.65\n",
            "xp [0.08333333333333333, 0.16666666666666666, 0.25, 0.5, 1, 2, 3, 5, 7, 10, 20, 30]\n",
            "yp [0.02, 0.01, 0.02, 0.04, 0.05, 0.16, 0.32, 0.8, 1.27, 1.63, 2.2, 2.32]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QuCZbA2yvMNm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "cellView": "form",
        "outputId": "7216a037-1085-45c3-fefd-6b2f6a84c13f"
      },
      "source": [
        "#@title\n",
        "display_outputs = {key: outputs[key] for key in outputs.keys()\n",
        "                               & { 'ST_avg', \n",
        "'ST_over_S0_avg', \n",
        "'ST_over_S0_avg_k',\n",
        "'y_0T', 'y_0Td', 'p_0T', 'p_0Td' ,'L_0TdT_avg', 'L_TdTdT_avg', 'L_TdTdT_over_L_0TdT_avg', 'pi_avg', 'price'}}\n",
        "\n",
        "display_outputs_ordered = collections.OrderedDict()\n",
        "\n",
        "display_outputs_ordered['ST_over_S0_avg'] = display_outputs['ST_over_S0_avg']\n",
        "display_outputs_ordered['ST_over_S0_avg_k'] = display_outputs['ST_over_S0_avg_k']\n",
        "display_outputs_ordered['y_0T'] = display_outputs['y_0Td']\n",
        "display_outputs_ordered['p_0T'] = display_outputs['p_0T']\n",
        "display_outputs_ordered['p_0Td'] = display_outputs['p_0Td']\n",
        "display_outputs_ordered['L_0TdT_avg'] = display_outputs['L_0TdT_avg']\n",
        "display_outputs_ordered['L_TdTdT_avg'] = display_outputs['L_TdTdT_avg']\n",
        "display_outputs_ordered['L_TdTdT_over_L_0TdT_avg'] = display_outputs['L_TdTdT_over_L_0TdT_avg']\n",
        "display_outputs_ordered['pi_avg'] = display_outputs['pi_avg']\n",
        "display_outputs_ordered['price'] = display_outputs['price']\n",
        "\n",
        "print(\"Simulation Results:\")\n",
        "for k, v in display_outputs_ordered.items():\n",
        "    print (k, v)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Simulation Results:\n",
            "ST_over_S0_avg 0.9860195136559762\n",
            "ST_over_S0_avg_k -0.013980486344023824\n",
            "y_0T 0.28\n",
            "p_0T 0.990445932897216\n",
            "p_0Td 0.9923295690574124\n",
            "L_0TdT_avg 0.007607224574839476\n",
            "L_TdTdT_avg 0.003399659844192899\n",
            "L_TdTdT_over_L_0TdT_avg 0.4468988407989306\n",
            "pi_avg 0.06391136659616857\n",
            "price 0.06330075311107815\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "igCAc7MuvvpV",
        "cellView": "form"
      },
      "source": [
        "#@title\n",
        "df_results = pd.DataFrame.from_dict([display_outputs_ordered])\n",
        "df_results\n",
        "df_results.to_excel(\"df_results.xlsx\", sheet_name='Sheet_name_1')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 796
        },
        "id": "UfJZH6vIhxL0",
        "outputId": "3274d65a-8142-4c13-9917-0b290338e4ad"
      },
      "source": [
        "#@title\n",
        "\n",
        "# stock_graph()\n",
        "\n",
        "ST_outcomes()\n",
        "ST_over_SO_outcomes()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ST_avg:  267.47960290891166\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "ST_over_S0_avg (ST/S0):  0.9860195136559762\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 473
        },
        "id": "FkW2HI8IrnuS",
        "outputId": "279cb47f-1cd5-4e47-cc7f-37112bcc8fbc"
      },
      "source": [
        "yield_curve_display()\n",
        "TS_info()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "y_0T: 0.32\n",
            "y_0Td: 0.28\n",
            "p_0T:  0.990445932897216\n",
            "L0:  0.0034\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "PQ5c3BO8rpOe",
        "outputId": "12e6aa39-b185-4b67-bab4-380421e45c5c"
      },
      "source": [
        "L_TdTdT_Outcomes()\n",
        "L_TdTdT_over_L_0TdT_Outcomes()\n",
        "pi_outcomes()\n",
        "display_price()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "L_TdTdT_avg:  0.003399659844192899\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "L_TdTdT_over_L_0TdT_avg:  0.4468988407989306\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Average payoff is:  0.06391136659616857\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "0.06330075311107815\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}