LatticeNotebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "occupied-monkey",
   "metadata": {},
   "source": [
    "# Pricing Derivatives with Binomial Trees"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "going-electronics",
   "metadata": {},
   "source": [
    "This notebook will function to show off the speed advantages of derivatives pricing in kdb/q, as well as  my own binomial tree algorithms. I will cover European options, American options, Barrier options (up and out, up and in, down and out, down and in), as well as Lookback options(floating and fixed). \n",
    "The code for the algorithms may be found in this depository, except for my path dependent options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "small-russian",
   "metadata": {},
   "outputs": [],
   "source": [
    "\\cd C:\\q\\w32\\Lattice\n",
    "\\l LatticePricing.q\n",
    "\\c 100 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "human-italic",
   "metadata": {},
   "source": [
    "#1 European Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "personal-sponsorship",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time upsteps downsteps stockPrice call     put     \r\n",
       "---------------------------------------------------\r\n",
       "1    0       0         100        15.00194 14.6282 \r\n",
       "2    1       0         120        25.61291 6.672286\r\n",
       "2    0       1         85         4.541366 22.73077\r\n",
       "3    2       0         144        42.35433 1.475174\r\n",
       "3    1       1         102        9.128259 11.93629\r\n",
       "3    0       2         72.25      0        33.75312\r\n",
       "4    3       0         172.8      66.78524 0       \r\n",
       "4    2       1         122.4      18.34803 2.965137\r\n",
       "4    1       2         86.7       0        21.0271 \r\n",
       "4    0       3         61.4125    0        46.81751\r\n",
       "5    4       0         207.36     97.36    0       \r\n",
       "5    3       1         146.88     36.88    0       \r\n",
       "5    2       2         104.04     0        5.96    \r\n",
       "5    1       3         73.695     0        36.305  \r\n",
       "5    0       4         52.20062   0        57.79938\r\n"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//Lets get started with our first function binTree\n",
    "d:0.85 //downstep\n",
    "u:1.2 //upstep\n",
    "t:5 //time steps(initial is 1)\n",
    "deltaT:0.5 //timesteps per year\n",
    "r:0.01 //risk  free interest rate\n",
    "y:0.07 //yield\n",
    "s:100 //initial stock price\n",
    "k:110 //strike price\n",
    "binTree[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interracial-salon",
   "metadata": {},
   "source": [
    "binTree creates the entire tree in table form for a European option, returning the values of calls and puts each timestep. binTree is flexible enough to handle Cox-Ross-Rubinstein trees as well as Jarrow-Rudd trees, forcing q = .5 when u =! 1/d \n",
    "\n",
    "binTree is also very fast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "abroad-possibility",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "101\r\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "452\r\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3266\r\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:0.99 \n",
    "u:1%d \n",
    "deltaT:.01\n",
    "t:10\n",
    "\\t binTree[d;u;t;deltaT;r;y;s;k]\n",
    "t:500\n",
    "\\t binTree[d;u;t;deltaT;r;y;s;k]\n",
    "t:1000\n",
    "\\t binTree[d;u;t;deltaT;r;y;s;k]\n",
    "t:2000\n",
    "\\t binTree[d;u;t;deltaT;r;y;s;k]\n",
    "//time in milliseconds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "radio-spanking",
   "metadata": {},
   "source": [
    "binTreeAmerican calculates the value of exercising the option at any time step and replaces the value of the call/put if the exercise value plus interest is higher than holding out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "reverse-photographer",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time upsteps downsteps stockPrice call     put      exCall   exPut   \r\n",
       "---------------------------------------------------------------------\r\n",
       "1    0       0         100        13.3309  16.76962 0        11.50274\r\n",
       "2    1       0         120        23.461   6.966135 11.10711 0       \r\n",
       "2    0       1         85         4.150496 27.76777 0        27.76777\r\n",
       "3    2       0         144        39.99667 1.389267 36.46528 0       \r\n",
       "3    1       1         102        8.596671 13.03927 0        8.580065\r\n",
       "3    0       2         72.25      0        40.48718 0        40.48718\r\n",
       "4    3       0         172.8      65.03692 0        65.03692 0       \r\n",
       "4    2       1         122.4      17.80576 2.877504 12.84168 0       \r\n",
       "4    1       2         86.7       0        24.12994 0        24.12994\r\n",
       "4    0       3         61.4125    0        50.31817 0        50.31817\r\n",
       "5    4       0         207.36     97.36    0        97.36    0       \r\n",
       "5    3       1         146.88     36.88    0        36.88    0       \r\n",
       "5    2       2         104.04     0        5.96     0        5.96    \r\n",
       "5    1       3         73.695     0        36.305   0        36.305  \r\n",
       "5    0       4         52.20062   0        57.79938 0        57.79938\r\n"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:0.85\n",
    "u:1.2 \n",
    "t:5 \n",
    "deltaT:0.5\n",
    "r:0.07\n",
    "y:0.01\n",
    "s:100 \n",
    "k:110 \n",
    "binTreeAmerican[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "weekly-durham",
   "metadata": {},
   "source": [
    "Barrier functions barrierUpOutEur, barrierUpInEur, barrierDownOutEur, and barrierDownInEur calculate European barrier options by taking a dictionary containing downstep, upstep, timesteps(including first), timesteps per year, risk free rate, yield, stock, strike, and barrier\n",
    "these functions take a dictionary instead of 9 parameters due to kdb/q's valence limits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "square-anatomy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time upsteps downsteps stockPrice call      put       \r\n",
       "------------------------------------------------------\r\n",
       "1    0       0         10         0.2109056 0.01015001\r\n",
       "2    1       0         10.62862   0.1057168 0         \r\n",
       "2    0       1         9.40856    0.3171503 0.02035084\r\n",
       "3    2       0         11.29676   0         0         \r\n",
       "3    1       1         10         0.2119628 0         \r\n",
       "3    0       2         8.8521     0.4239255 0.04080355\r\n",
       "4    3       0         12.00689   0         0         \r\n",
       "4    2       1         10.62862   0         0         \r\n",
       "4    1       2         9.408561   0.4249867 0         \r\n",
       "4    0       3         8.328552   0.4249867 0.08181138\r\n",
       "5    4       0         12.76167   0         0         \r\n",
       "5    3       1         11.29676   0         0         \r\n",
       "5    2       2         10         0         0         \r\n",
       "5    1       3         8.852101   0.8521009 0         \r\n",
       "5    0       4         7.835968   0         0.1640323 \r\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//Down and In\n",
    "dict:(`d`u`t`deltaT`r`y`s`k`b)!(0.940856 1.062862 5 0.25 .01 0.06 10 8 9 )\n",
    "//strike is 8,  barrier is 9\n",
    "barrierDownInEur[dict]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "relevant-blues",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time upsteps downsteps stockPrice call         put\r\n",
       "--------------------------------------------------\r\n",
       "1    0       0         10         0.4918511    0  \r\n",
       "2    1       0         10.62862   0.8252806    0  \r\n",
       "2    0       1         9.40856    0.1608839    0  \r\n",
       "3    2       0         11.29676   1.332119     0  \r\n",
       "3    1       1         10         0.3225733    0  \r\n",
       "3    0       2         8.8521     0            0  \r\n",
       "4    3       0         12.00689   2.024147     0  \r\n",
       "4    2       1         10.62862   0.6467606    0  \r\n",
       "4    1       2         9.408561   8.96476e-007 0  \r\n",
       "4    0       3         8.328552   0            0  \r\n",
       "5    4       0         12.76167   2.76167      0  \r\n",
       "5    3       1         11.29676   1.296757     0  \r\n",
       "5    2       2         10         1.79744e-006 0  \r\n",
       "5    1       3         8.852101   0            0  \r\n",
       "5    0       4         7.835968   0            0  \r\n"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//Down and Out\n",
    "dict:(`d`u`t`deltaT`r`y`s`k`b)!(0.940856 1.062862 5 0.25 .01 0.06 10 10 9 )\n",
    "//changed the strike to 10\n",
    "barrierDownOutEur[dict]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "statewide-advertising",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time upsteps downsteps stockPrice call      put\r\n",
       "-----------------------------------------------\r\n",
       "1    0       0         10         0.8012411 0  \r\n",
       "2    1       0         10.62862   1.321544  0  \r\n",
       "2    0       1         9.40856    0.2849495 0  \r\n",
       "3    2       0         11.29676   2.078378  0  \r\n",
       "3    1       1         10         0.5713256 0  \r\n",
       "3    0       2         8.8521     0         0  \r\n",
       "4    3       0         12.00689   3.02165   0  \r\n",
       "4    2       1         10.62862   1.145511  0  \r\n",
       "4    1       2         9.408561   0         0  \r\n",
       "4    0       3         8.328552   0         0  \r\n",
       "5    4       0         12.76167   3.76167   0  \r\n",
       "5    3       1         11.29676   2.296757  0  \r\n",
       "5    2       2         10         0         0  \r\n",
       "5    1       3         8.852101   0         0  \r\n",
       "5    0       4         7.835968   0         0  \r\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//Up and In\n",
    "dict:(`d`u`t`deltaT`r`y`s`k`b)!(0.940856 1.062862 5 0.25 .01 0.06 10 9 11 )\n",
    "//changed the strike to 9, barrier to 11\n",
    "barrierUpInEur[dict]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "diverse-trainer",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time upsteps downsteps stockPrice call      put       \r\n",
       "------------------------------------------------------\r\n",
       "1    0       0         10         0.3093911 0.108635  \r\n",
       "2    1       0         10.62862   0.2481325 0.01834925\r\n",
       "2    0       1         9.40856    0.3721987 0.1994646 \r\n",
       "3    2       0         11.29676   0         0         \r\n",
       "3    1       1         10         0.4975071 0.03679036\r\n",
       "3    0       2         8.8521     0.2487536 0.3631374 \r\n",
       "4    3       0         12.00689   0         0         \r\n",
       "4    2       1         10.62862   0.4987525 0         \r\n",
       "4    1       2         9.408561   0.4987525 0.0737649 \r\n",
       "4    0       3         8.328552   0         0.6543278 \r\n",
       "5    4       0         12.76167   0         0         \r\n",
       "5    3       1         11.29676   0         0         \r\n",
       "5    2       2         10         1.000002  0         \r\n",
       "5    1       3         8.852101   0         0.1478991 \r\n",
       "5    0       4         7.835968   0         1.164032  \r\n"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//Up and out\n",
    "barrierUpOutEur[dict]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "differential-slave",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "184\r\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "856\r\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "186\r\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "958\r\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//These are also fast\n",
    "dict:(`d`u`t`deltaT`r`y`s`k`b)!(0.940856 1.062862 500 0.01 .01 0.06 10 8 9 )\n",
    "//changed timesteps to 500, deltaT to 0.01\n",
    "\n",
    "\\t barrierDownInEur[dict]\n",
    "\\t barrierDownOutEur[dict]\n",
    "\\t barrierUpInEur[dict]\n",
    "\\t barrierUpOutEur[dict]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "provincial-player",
   "metadata": {},
   "source": [
    "Note that the algorithm does not produce alternative values for each path at each node, but works backward to arrive at the correct price. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "artistic-munich",
   "metadata": {},
   "source": [
    "# Path Dependent Options"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "occupied-manchester",
   "metadata": {},
   "source": [
    "The first path dependent options are lookback options, both floating and fixed. Note, the algorithm is only optimized for Cox-Ross-Rubinstein trees and do not work with a tilt, so we must make d=1/u .\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "surrounded-premiere",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.38564\r\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "27.66744\r\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//floating\n",
    "d:0.85\n",
    "u:1%d\n",
    "t:6\n",
    "deltaT:0.5\n",
    "r:0.01\n",
    "y:0.05\n",
    "s:100\n",
    "floatingLBCallCRR[d;u;t;deltaT;r;y;s] //call\n",
    "floatingLBPutCRR[d;u;t;deltaT;r;y;s] //put"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "incorporated-category",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.15555\r\n"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "62.30451\r\n"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//fixed\n",
    "d:0.85\n",
    "u:1%d\n",
    "t:20\n",
    "deltaT:0.5\n",
    "r:0.01\n",
    "y:0.05\n",
    "s:100\n",
    "k:110\n",
    "fixedLBCallCRR[d;u;t;deltaT;r;y;s;k]\n",
    "fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "boolean-communications",
   "metadata": {},
   "source": [
    "KDB does not have a \"BigInteger\" data type, so this implementation is limited by overflow and precision "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "improving-crown",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "41.81428\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "8\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "95.93182\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "5\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1449\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "109.9996\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:0.85\n",
    "u:1%d\n",
    "deltaT:0.25\n",
    "r:0.01\n",
    "y:0.05\n",
    "s:100\n",
    "k:110\n",
    "\n",
    "t:10\n",
    "\\t fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]\n",
    "fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]\n",
    "\n",
    "t:100\n",
    "\\t fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]\n",
    "fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]\n",
    "\n",
    "\\t fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]\n",
    "t:1000\n",
    "\\t fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]\n",
    "fixedLBPutCRR[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "latest-appreciation",
   "metadata": {},
   "source": [
    "A path dependent binary tree with 1000 time steps gives 2^1000, or 1.071509e+301 paths, but this algo will find the lookback value  in 1.194 seconds\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coral-wright",
   "metadata": {},
   "source": [
    "Let us observe the convergence when we set our option duration to 6 months, increasing the number of time steps as we decrease deltaT and u,d accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "abroad-result",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.29649\r\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:50\n",
    "vol:0.3\n",
    "d:exp(neg vol*sqrt(.5%(t-1)))\n",
    "u:1%d\n",
    "deltaT:.5%(t-1)\n",
    "r:0.07\n",
    "y:0.04\n",
    "s:100\n",
    "k:100\n",
    "fixedLBCallCRR[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "distinguished-mexico",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.77524\r\n"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:100\n",
    "vol:0.3\n",
    "d:exp(neg vol*sqrt(.5%(t-1)))\n",
    "u:1%d\n",
    "deltaT:.5%(t-1)\n",
    "r:0.07\n",
    "y:0.04\n",
    "s:100\n",
    "k:100\n",
    "fixedLBCallCRR[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "minus-short",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.43463\r\n"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:500\n",
    "vol:0.3\n",
    "d:exp(neg vol*sqrt(.5%(t-1)))\n",
    "u:1%d\n",
    "deltaT:.5%(t-1)\n",
    "r:0.07\n",
    "y:0.04\n",
    "s:100\n",
    "k:100\n",
    "fixedLBCallCRR[d;u;t;deltaT;r;y;s;k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "regular-portland",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.59483\r\n"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "17.95527\r\n"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:1000\n",
    "vol:0.3\n",
    "d:exp(neg vol*sqrt(.5%(t-1)))\n",
    "u:1%d\n",
    "deltaT:.5%(t-1)\n",
    "r:0.07\n",
    "y:0.04\n",
    "s:100\n",
    "k:100\n",
    "fixedLBCallCRR[d;u;t;deltaT;r;y;s;k]\n",
    "fixedLBCallCRR[d;u;t;deltaT;r;y;s;k] * exp(.5*neg r) //discount the payoff back 6 months"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tight-brazil",
   "metadata": {},
   "source": [
    "We can compare this solution to a Monte Carlo Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "composite-attack",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ev | 18.27656\r\n",
       "err| 0.04964209\r\n",
       "n  | 400000\r\n"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\\cd C:\\q\\w32\\qtips-master\n",
    "\\l stat.q\n",
    "\\l deriv.q\n",
    "\n",
    "n:20000\n",
    "c:1b //call \n",
    "S:100\n",
    "k:100\n",
    "s:.3\n",
    "r:.07\n",
    "\n",
    "t:(til 126)%251\n",
    ".deriv.mcstat raze .deriv.mc[S;s;r;t;.deriv.lb[c;k]] peach 20#n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "parental-porter",
   "metadata": {},
   "source": [
    "We can see that the binomial tree is converging towards the monte carlo solution"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Q (kdb+)",
   "language": "q",
   "name": "qpk"
  },
  "language_info": {
   "file_extension": ".q",
   "mimetype": "text/x-q",
   "name": "q",
   "version": "4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}