money_management.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\"   \\n- various methods we can use to size trades and the\\nrisk/reward characteristics that each choice implies  \\n\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd \n",
    "import numpy as np \n",
    "\n",
    "\"\"\"\"   \n",
    "- various methods we can use to size trades and the\n",
    "risk/reward characteristics that each choice implies  \n",
    "\n",
    "- The simplest method is to size according to ‘‘feel.’’ The trade size is\n",
    "adjusted on an ad hoc basis depending on how good the trader thinks the\n",
    "individual bet is. This is a terrible idea.\n",
    "\n",
    "-The next step is to trade the same amount every time. For example, we\n",
    "might choose to always trade 100 options or 1,000 vega. This is known\n",
    "as a fixed trade size systemAny system that can find value will be profitable\n",
    "(over the long run) with such a sizing scheme. In back testing this is often\n",
    "the sizing scheme used,\n",
    "\n",
    "- we could choose to trade a constant percentage of our bankroll at\n",
    "each opportunity. This is known as a fixed fraction sizing system.\n",
    "\n",
    "The Kelly Criterion\n",
    "\n",
    "f = (pw - ql)/wl\n",
    "\n",
    "Expected bankroll for 10 bets as a function of bet size \n",
    "w = w0(1+pLn(1+Fw)+ qLn(1-Fl))**N \n",
    "\n",
    "\n",
    "To estimate our trading size we\n",
    "need only the expected return of the trade and its variance, no matter how\n",
    "complicated the actual trade is. Actually, the return here should generally\n",
    "be interpreted as the return over the risk-free rate. Many derivations neglect\n",
    "to mention this (those aimed at gamblers probably neglect it as it is difficult\n",
    "to earn interest while sit\n",
    "r = E[r]\n",
    "simga = variance of returns \n",
    "f = r/sigma**2 \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Growth Rate of someon trading at fraction,f, of the kelly is given by:\n",
    "Growth_ratio = (f-(f**2 / 2)) * (r**2 / simga**2)\n",
    "which is maximized for f = 1: Trading at the full kelly ration when the growth rate is:\n",
    "growth_rate_max = sigma**2/(2*sigma**2)\n",
    "\n",
    "Probability of reaching bank roll,A, before we we reach bank roll,B, is given by: \n",
    "P(A,B) = 1-A**(1-(2/f)) / (B**(1-(2/f)) - A**(1-(2/f))) \n",
    "Example:\n",
    "P(.5,2) = 2/3 , which means 1/3 of the time you bankroll will half before doubling\n",
    "\n",
    "\n",
    "Reducing Fraction of kelly reduced bankrolll goal. The expected time,E[T], is given by:\n",
    "\n",
    "E[T] = 1/Grow_ratio * Log(B**(P(A,B) / A**(P(A,B)-1) )\n",
    "Before we reach our goal,(B.W0), or are stopped out at (A.W0)\n",
    "\n",
    "\n",
    "Probability of Doubling before\n",
    "Halving as a Function of\n",
    "the Kelly Fraction That\n",
    "We Are Trading\n",
    "Fraction of Kelly   Prob (A,B):\n",
    "________________________________\n",
    "    1           |        0.667\n",
    "    0.8         |        0.739\n",
    "    0.6         |        0.834\n",
    "    0.4         |        0.941\n",
    "    0.2         |        0.998\n",
    "\n",
    "Example:\n",
    "considers an investor who has a choice between a stock with an annual return of\n",
    "15 percent and a volatility of 30 percent and an interest bearing account\n",
    "that pays 7 percent.\n",
    "pw = 0.15\n",
    "ql = 0.07 \n",
    "wl = 0.3**2\n",
    "remember kc is given by:\n",
    "k = (pl -ql)/wl\n",
    "k = (0.15 - 0.07)/(.3**2)\n",
    "k = 89 % of bank roll \n",
    "\n",
    "Expected time for kelly to outperform another strategy with a trading factor f', by E percent is given by:\n",
    "(1/(sigma**2(f-f')**2))Ln(1+E)\n",
    "Before we have a 95 percent probability of beating\n",
    "the all cash portfolio by 10 percent, we have to wait 157 years. Even\n",
    "worse, to have a 95 percent probability of beating the all-stock portfolio\n",
    "by 10 percent, we have to wait 10,286 years. Even the expected times\n",
    "to outperform these benchmarks is 2.8 years and 184 years.1 Patience is\n",
    "indeed necessary.\n",
    "\n",
    "\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kelly(expected_return,risk_free_rate,annualized_volatility):\n",
    "    numerator = expected_return - risk_free_rate\n",
    "    k = numerator/annualized_volatility**2\n",
    "    return k\n",
    "\n",
    "def expected_bankroll_based_on_size(initial_bank_roll,number_of_bets,probability_of_win,probability_of_loss,kelly_ratio):\n",
    "    win = 1 + (probability_of_win)*np.log(1+kelly_ratio)\n",
    "    loss = probability_of_loss * np.log(1-kelly_ratio)\n",
    "    expected_final_bank_roll = initial_bank_roll(win+loss)**number_of_bets\n",
    "    return expected_final_bank_roll\n",
    "\n",
    "def growth_ratio(fraction_of_kelly,annualized_volatility,expected_return):\n",
    "    first_term = fraction_of_kelly - (fraction_of_kelly**2 / 2)\n",
    "    second_term = expected_return**2 / annualized_volatility**2\n",
    "    gr = first_term*second_term\n",
    "    return gr \n",
    "\n",
    "\n",
    "def probability_of_reaching_A_before_B(fraction_of_kelly,A,B)\n",
    "    numerator = 1 - A**(1-(2/fraction_of_kelly))\n",
    "    denominator = B**(1-(2/fraction_of_kelly)) - A**(1-(2/fraction_of_kelly))\n",
    "    p = numerator/denominator\n",
    "    return p \n",
    "\n",
    "def expected_time_to_beat_other_strategies(annualized_volatility,fraction_of_kelly,outperform_percentage):\n",
    "    first_term = (2/(annualized_volatility**2 *(1-fraction_of_kelly)**2))\n",
    "    second_term = np.log(1+outperform_percentage)\n",
    "    time_to_outperform = first_term*second_term\n",
    "    return time_to_outperform\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.11 ('master')",
   "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.11"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "1916c2951b7d8dd2fcd4da114e9e1cb618c233012d48d93c3e66f00335cabeb4"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}