08_arbitrage.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arbitrage and bond markets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bootstrapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [97.5, 0, 0.5, 100]\n",
    "B = [95, 0, 1.0, 100]\n",
    "C = [955, 0.025, 1.5, 1000]\n",
    "D = [1000, 0.0575, 2.0, 1000]\n",
    "\n",
    "bonds = np.row_stack((A, B, C, D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>bond</th>\n",
       "      <th>price</th>\n",
       "      <th>coupon_rate</th>\n",
       "      <th>maturity</th>\n",
       "      <th>face</th>\n",
       "      <th>period</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A</td>\n",
       "      <td>97.5</td>\n",
       "      <td>0.0000</td>\n",
       "      <td>0.5</td>\n",
       "      <td>100.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>B</td>\n",
       "      <td>95.0</td>\n",
       "      <td>0.0000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>C</td>\n",
       "      <td>955.0</td>\n",
       "      <td>0.0250</td>\n",
       "      <td>1.5</td>\n",
       "      <td>1000.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>D</td>\n",
       "      <td>1000.0</td>\n",
       "      <td>0.0575</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1000.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  bond   price  coupon_rate  maturity    face  period\n",
       "1    A    97.5       0.0000       0.5   100.0     1.0\n",
       "2    B    95.0       0.0000       1.0   100.0     2.0\n",
       "3    C   955.0       0.0250       1.5  1000.0     3.0\n",
       "4    D  1000.0       0.0575       2.0  1000.0     4.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(bonds, \n",
    "        columns = ['price', 'coupon_rate', 'maturity','face'], \n",
    "        index=['A','B','C','D'])\n",
    "df['period'] = df.maturity*2\n",
    "df=df.reset_index()\n",
    "df.index = df.index+1\n",
    "df.columns = ['bond', 'price', 'coupon_rate', 'maturity','face', 'period']\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to generalize bootstrapping and pricing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.02564102564102555,\n",
       " 0.025978352085153977,\n",
       " 0.028390767355670476,\n",
       " 0.02882263912764249]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def bootstrap(d, nop):\n",
    "    ''' \n",
    "    d: a dataset with prices, face value, coupon_rate, period of maturity\n",
    "    nop: compounding period (ie., 1 = annual, 2=semiannual)\n",
    "    '''\n",
    "    spot_rates = []\n",
    "    for t in d.index:\n",
    "        p      = d.loc[t,'price']\n",
    "        face   = d.loc[t,'face']\n",
    "        cr     = d.loc[t,'coupon_rate']\n",
    "        period = int(d.loc[t,'period'])\n",
    "        coupon = face*cr/nop\n",
    "        cf_maturity = face + coupon\n",
    "\n",
    "        pv_coupons = 0.0\n",
    "        for i in range(period-1):\n",
    "            pv_coupons = pv_coupons + coupon / (1+spot_rates[i])**(i+1)\n",
    "        x = p - pv_coupons\n",
    "        z = (cf_maturity / x )**(1/period) - 1\n",
    "        spot_rates.append(z)\n",
    "    return spot_rates\n",
    "spot_curve = bootstrap(df,2)\n",
    "spot_curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1076.8171999459971"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def spot_pricer(cfs, spot):\n",
    "    ''' \n",
    "    cfs:  list of cash flows at each period\n",
    "    spot: list of spot rates at each period\n",
    "    cfs should be the same length as spot\n",
    "    '''\n",
    "    cfs = np.array(cfs)\n",
    "    discount_factors = np.array([1/(1+spot[i])**(i+1) for i in range(len(spot))])\n",
    "    return cfs @ discount_factors\n",
    "spot_pricer([0,100,0,1100], spot_curve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The bond cash flows for bond A are:  [100.   0.   0.   0.]\n",
      "The fair price for A is: $97.50\n"
     ]
    }
   ],
   "source": [
    "# Check that the prices are consistent with the spot curve\n",
    "\n",
    "# pick a bond\n",
    "BOND_ID = 'A'\n",
    "bond_dict = {'A': 1, 'B':2, 'C':3, 'D':4}\n",
    "def cf_generator(bond_id):\n",
    "    i = bond_dict[bond_id]\n",
    "    nop = 2\n",
    "    face   = df.loc[i,'face']\n",
    "    cr     = df.loc[i,'coupon_rate']\n",
    "    period = int(df.loc[i,'period'])\n",
    "    coupon = face*cr/nop\n",
    "    cf_maturity = face + coupon\n",
    "    cfs =  np.zeros(len(spot_curve))\n",
    "    for i in range(period-1):\n",
    "        cfs[i] = coupon\n",
    "    cfs[period-1] = cf_maturity\n",
    "    print('The bond cash flows for bond ' + bond_id + ' are: ', cfs)\n",
    "    return cfs\n",
    "cfs = cf_generator(BOND_ID)\n",
    "\n",
    "p = spot_pricer(cfs.tolist(),spot_curve)\n",
    "print('The fair price for ' + BOND_ID + f' is: ${p:,.2f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arbitrage and replicating portfolio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Example #1 (2-period bond)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.87500000000003"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spot_pricer([15,115,0,0], spot_curve)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example #2 (4-period bond)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,  100,    0, 1100])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Target bond cash-flows\n",
    "cfs = np.array([0,100,0,1100])\n",
    "cfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "A\n",
      "The bond cash flows for bond A are:  [100.   0.   0.   0.]\n",
      "1\n",
      "B\n",
      "The bond cash flows for bond B are:  [  0. 100.   0.   0.]\n",
      "2\n",
      "C\n",
      "The bond cash flows for bond C are:  [  12.5   12.5 1012.5    0. ]\n",
      "3\n",
      "D\n",
      "The bond cash flows for bond D are:  [  28.75   28.75   28.75 1028.75]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 100.  ,    0.  ,    0.  ,    0.  ],\n",
       "       [   0.  ,  100.  ,    0.  ,    0.  ],\n",
       "       [  12.5 ,   12.5 , 1012.5 ,    0.  ],\n",
       "       [  28.75,   28.75,   28.75, 1028.75]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix of cash flows for bonds A-D\n",
    "CF = np.zeros((len(df), len(df)))\n",
    "for j, id in enumerate(['A','B','C','D']):\n",
    "    print(j)\n",
    "    print(id)\n",
    "    CF[j] = cf_generator(id)\n",
    "CF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.3036167 ,  0.6963833 , -0.03036167,  1.06925881])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solve the system of equations\n",
    "portfolio = cfs @ np.linalg.inv(CF)\n",
    "portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,  100,    0, 1100])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check that replicating portfolio delivers same cash flows\n",
    "repl_cfs = portfolio @ CF \n",
    "repl_cfs.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1076.8171999459971"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Price of replicating portfolio\n",
    "repl_price = portfolio @ df.price\n",
    "repl_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.817199945997118"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "profit = repl_price-1050\n",
    "profit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 ('venv': venv)",
   "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.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "cc788b38d8cb434c82f45ef9d481d0310e17b79321e4c8cbfbfe90f656a3f023"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}