FIN5615_Project_3_Neil_Yejjey_tuk12930.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<h2>FIN5615 Project #3\n",
    "    <p class=\"text-primary\">Random Walk Simulaton (Part II)</p>\n",
    "</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-success\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:black\"><b>Project Introduction</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    In this project we will try to address some of the shortcomings of modeling stock price as a simple random walk. We will compare the simulated option prices from our random walk model against that of the Black-Scholes options pricing formula.\n",
    "    </div>\n",
    "</div>\n",
    "<div class = \"panel panel-info\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:black\"><b>Instructions</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    Please code you solutions directly in this Notebook under each task in the cells provided below. Include all code used to produce your results, and support your answers with textual explanations if neccessary. You may feel free to add additional Code and/or Markdown cells as needed. Code must be written using <b>Python 3</b>.\n",
    "    <br><br>Please order the cells in your Notebook in the order in which they are intended to run! It is expected that your Notebook is able to run in sequence from start to finish without any errors (before submitting check by: <code>Kernel > Restart & Run All</code>).\n",
    "    <br><br>Once ready, please submit your assignment as an <b>.ipynb file</b> (<code>File > Download as > Notebook</code>). You must name your files in the following format: <b><code>FIN5615_Project_1_Richard_Lee_tuc12345.ipynb</code></b>.\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "<div class = \"alert alert-block alert-warning\">\n",
    "    <b>Note</b>: Import all libraries that you plan on using in the code block below.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 1</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    Recall the random walk simulation we built to model Ford's stock price from the previous project:\n",
    "    <br><br>\n",
    "    $$X_{t+1} = \\left\\{\n",
    "        \\begin{array}{ll}\n",
    "            X_t \\times u = X_te^{\\sigma\\sqrt{h}} & \\quad p = \\frac{e^{rh} - d}{u - d} \\\\\n",
    "            X_t \\times d = X_te^{-\\sigma\\sqrt{h}} & \\quad 1 - p\n",
    "        \\end{array}\n",
    "    \\right.$$ \n",
    "    <br><br>Where we assumed that the annual volatility of F's returns is 10% and a risk-free rate of 1%, and simulated the price of F under this new dynamic over the next year (250 trading days) for 1000 trials.\n",
    "    <br><br>Rerun that simulation using the code below:\n",
    "    <br><code>\n",
    "random.seed(5615)\n",
    "\n",
    "starting_value = 5.\n",
    "sigma = .1\n",
    "risk_free = .01\n",
    "\n",
    "steps = 250\n",
    "trials = 1000\n",
    "\n",
    "u = np.exp(sigma \\* np.sqrt(1. / steps))\n",
    "d = 1. / u\n",
    "p = (np.exp(risk_free / steps) - d) / (u - d)\n",
    "\n",
    "sims = []\n",
    "for trial in range(trials):\n",
    "    random_path = [starting_value]\n",
    "    for step in range(steps):\n",
    "        if random.random() < p:\n",
    "            price_change = u\n",
    "        else:\n",
    "            price_change = d\n",
    "\n",
    "        random_path.append(random_path[-1] \\* price_change)\n",
    "    sims.append(random_path)\n",
    "</code>\n",
    "    <br><br>The simulation is stored in the variable <code>sims</code>. Check that <code>sims</code> is a list of length 1000 (i.e. 1000 trials), with each element being a list of length 251 (i.e. price at time 0 plus 250 future time steps).\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(5615)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "starting_value = 5.\n",
    "sigma = .1\n",
    "risk_free = .01\n",
    "\n",
    "steps = 250\n",
    "trials = 1000\n",
    "\n",
    "u = np.exp(sigma * np.sqrt(1. / steps))\n",
    "d = 1. / u\n",
    "p = (np.exp(risk_free / steps) - d) / (u - d)\n",
    "\n",
    "sims = []\n",
    "for trial in range(trials):\n",
    "    random_path = [starting_value]\n",
    "    for step in range(steps):\n",
    "        if random.random() < p:\n",
    "            price_change = u\n",
    "        else:\n",
    "            price_change = d\n",
    "        random_path.append(random_path[-1] * price_change)\n",
    "    sims.append(random_path)\n",
    "len(sims)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 2</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    The model we have now is the <b>Cox-Ross-Rubinstein Binomial Tree</b>, and is a much better approximation of stock price movements compared to a simple random walk. We can even price options contracts using this model.\n",
    "    <br><br>Continue to assume that F is worth \\$5 today, with an annual volatility of 10%, and risk-free rate at 1%. \n",
    "    <ul>\n",
    "        <li>Using the simulation results from the previous task, for each of the 1000 trials, calculate the terminal payoff of a call option with strike of \\$5.50 that expires 1 year from today. Your result should be a list of 1000 payoffs (one for each trial of the simulation).</li>\n",
    "        <li>Calculate the simulated average payoff of this call option. It should be approximately \\$0.05.</li>\n",
    "        <li>What is the present value of the simulated average payoff of this call option? This is the Binomial Tree's simulated option price.</li>\n",
    "        <li>Compare this value against the price under the Black-Scholes options pricing formula (you do not have to do this in python). How close are the two prices?</li>\n",
    "    </ul>\n",
    "    <br>Recall the payoff of a call option is $max(S_T - K, 0)$.\n",
    "    <p style=\"text-align:right;\">[20pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(5615)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.050584429128212864"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(5615)\n",
    "\n",
    "starting_value = 5.\n",
    "sigma = .1\n",
    "risk_free = .01\n",
    "k = 5.5\n",
    "t = 1\n",
    "\n",
    "steps = 250\n",
    "trials = 1000\n",
    "\n",
    "\n",
    "u = np.exp(sigma * np.sqrt(1. / steps))\n",
    "d = 1. / u\n",
    "p = (np.exp(risk_free / steps) - d) / (u - d)\n",
    "c_payoff = []\n",
    "\n",
    "sims = []\n",
    "for trial in range(trials):\n",
    "    random_path = [starting_value]\n",
    "    for step in range(steps):\n",
    "        if random.random() < p:\n",
    "            price_change = u\n",
    "        else:\n",
    "            price_change = d\n",
    "\n",
    "\n",
    "        random_path.append(random_path[-1] * price_change)\n",
    "    sims.append(random_path)\n",
    "    c_payoff.append(max(random_path[-1] - k, 0))\n",
    "average = np.mean(c_payoff)\n",
    "average\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.050081105648683726"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PV = average*np.exp(-risk_free * t)\n",
    "PV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "\n",
    "The value of the black-schoels and this value are almost identical, with the black schoels being marginally higher\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 3</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    We can further improve our simulated option price to match the Black-Scholes options price, by (1) using more steps in our binomial tree, i.e. smaller step sizes, and (2) increasing the number of trials.\n",
    "    <br><br>Reprice the call option on F using 1000 steps and 5000 trials (this will take more computation time). How does the simulated price compare to the Black-Scholes options price? (It should be close.)\n",
    "    <br><br>Set the random seed to 5615 at the beginning of your code.\n",
    "    <br><br>Make sure you've changed the values for <code>steps</code> and <code>trials</code>, then rerun the simulation from Task 1. Your simulation should now be a list of lists of lengths 1000 by 5001.\n",
    "    <p style=\"text-align:right;\">[30pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(5615)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(5615)\n",
    "starting_value = 5.\n",
    "sigma = .1\n",
    "risk_free = .01\n",
    "k = 5.5\n",
    "t = 1\n",
    "\n",
    "steps = 1000\n",
    "trials = 5000\n",
    "\n",
    "\n",
    "u = np.exp(sigma * np.sqrt(1. / steps))\n",
    "d = 1. / u\n",
    "p = (np.exp(risk_free / steps) - d) / (u - d)\n",
    "c_payoff = []\n",
    "\n",
    "sims = []\n",
    "for trial in range(trials):\n",
    "    random_path = [starting_value]\n",
    "    for step in range(steps):\n",
    "        if random.random() < p:\n",
    "            price_change = u\n",
    "        else:\n",
    "            price_change = d\n",
    "\n",
    "\n",
    "        random_path.append(random_path[-1] * price_change)\n",
    "    sims.append(random_path)\n",
    "    c_payoff.append(max(random_path[-1] - k, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.059152444165736916"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Average = np.mean(c_payoff)\n",
    "Average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.058563867512144784"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pv = Average*np.exp(-risk_free * t)\n",
    "pv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "###similar to the last problem, the black scohoels and this problem are nearly identical in value. This time around the black schoels model is sligtly smaller"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<div class = \"panel panel-primary\">\n",
    "    <div class = \"panel-heading\"> \n",
    "    <span style=\"color:white\"><b>Task 4</b>\n",
    "    </div>\n",
    "    <div class = \"panel-body\"> \n",
    "    Tesla (TSLA) stock price is currently \\$1400, with an annual volatility of 70%. Assume a risk-free rate of 1%. Assume a 6-month put option with a strike of \\$1200.\n",
    "    <ul>\n",
    "        <li>Calculate the price of this put option by simulating a CRR binomial tree with 5000 trials and using 1000 steps. Compare the simulated option price against the Black-Scholes options price which has a theoretical value of \\$163.23 (it should be close).</li>\n",
    "        <li>Plot the average simulated TSLA stock price over the 5000 trials. How does TSLA's simulated average path compare against F?</li>\n",
    "        <li>If simulations from the CRR Binomial Tree can give option prices similar to the Black-Scholes model, then why do we still use the latter? Under what situations might we prefer simulations over the Black-Scholes model?</li>\n",
    "    </ul>\n",
    "    <br>Recall the payoff of a put option is $max(K - S_T, 0)$.\n",
    "    <br><br>Set the random seed to 5615 at the beginning of your code.\n",
    "    <p style=\"text-align:right;\">[30pts]</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(5615)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "starting_value = 1400.\n",
    "sigma = .7\n",
    "risk_free = .01\n",
    "k = 1200\n",
    "t = .5\n",
    "\n",
    "steps = 1000\n",
    "trials = 5000\n",
    "\n",
    "\n",
    "u = np.exp(sigma * np.sqrt(.5 / steps))\n",
    "d = 1. / u\n",
    "p = (np.exp(risk_free / steps) - d) / (u - d)\n",
    "p_payoff = []\n",
    "\n",
    "sims = []\n",
    "for trial in range(trials):\n",
    "    random_path = [starting_value]\n",
    "    for step in range(steps):\n",
    "        if random.random() < p:\n",
    "            price_change = u\n",
    "        else:\n",
    "            price_change = d\n",
    "\n",
    "\n",
    "        random_path.append(random_path[-1] * price_change)\n",
    "    sims.append(random_path)\n",
    "    p_payoff.append(max(k - random_path[-1], 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "165.73579251423828"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AVerage = np.mean(p_payoff)\n",
    "AVerage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "164.90918180055624"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PV = AVerage*np.exp(-risk_free * t)\n",
    "PV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tesla's simulated average is far more volatile than F, meaning that F's average is more linear than tesla due to it being a less volitile option. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "averageP = np.mean(sims, axis = 0)\n",
    "plt.plot(averageP)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We would use the black-shoels model due to the fact that it is unrivaled in its ability to quickly process and provide accurate data on a bunch of options simueltanously.  However, we would prefer simulations over the black-shoels method when working with exotic options\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}