Maximizing_Expected_Growth.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNaAkf6UznxNQwNAIpAN4mD",
      "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/ConnerEvans/ConnerEvans.github.io/blob/main/Maximizing_Expected_Growth.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This notebook is a companion to the article here: https://connerevans.github.io/maximizing_expected_growth.html\n",
        "\n",
        "It shows how to calculate the optimal betting proportions and the resulting growth ratios shown in the article."
      ],
      "metadata": {
        "id": "joQefll6vKih"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PVZCDLjIt3H_"
      },
      "outputs": [],
      "source": [
        "# Import Libraries\n",
        "from scipy import optimize as opt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Input data from the table for MVP\n",
        "\n",
        "R_A = 7\n",
        "s_A = .233\n",
        "f_A = 1-s_A\n",
        "\n",
        "R_B = 1.7\n",
        "s_B = .454\n",
        "f_B = 1-s_B\n",
        "\n",
        "R_C = 5.5\n",
        "s_C = .110\n",
        "f_C = 1-s_C\n",
        "\n",
        "R_D = 8\n",
        "s_D = .050\n",
        "f_D = 1-s_D\n",
        "\n",
        "R_E = 4.5\n",
        "s_E = .043\n",
        "f_E = 1-s_E"
      ],
      "metadata": {
        "id": "k1PnWhNAubQe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "initial_guess = [.0001] # initial guesses should be near 0\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_A*p)**(s_A) * (1-p)**(f_A) # the algorithm can only minimize, so I multiplied it by -1\n",
        "\n",
        "result = opt.minimize(formula, initial_guess) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player A: ', np.round(result.x[0],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x[0]),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x[0])-1)*100,2),'percent')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XSODQDkPuiLy",
        "outputId": "498dfb53-65ae-4dcc-aaba-154c36aa1586"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion for Player A:  0.1234\n",
            "Resulting Growth Ratio:  1.045\n",
            "Equivalent Growth Rate:  4.5 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "initial_guess = [.0001]\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_A*p)**(s_A) * (1-p)**(f_A) # the algorithm can only minimize, so I multiplied it by -1\n",
        "\n",
        "result = opt.minimize(formula, initial_guess) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player A: ', np.round(result.x[0],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x[0]),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x[0])-1)*100,2),'percent')\n",
        "print()\n",
        "\n",
        "\n",
        "# Do the same thing for the other 4 players\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_B*p)**(s_B) * (1-p)**(f_B) # the algorithm can only minimize, so I multiplied it by -1\n",
        "\n",
        "result = opt.minimize(formula, initial_guess) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player B: ', np.round(result.x[0],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x[0]),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x[0])-1)*100,2),'percent')\n",
        "print()\n",
        "\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_C*p)**(s_C) * (1-p)**(f_C) # the algorithm can only minimize, so I multiplied it by -1\n",
        "\n",
        "result = opt.minimize(formula, initial_guess) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player C: ', np.round(result.x[0],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x[0]),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x[0])-1)*100,2),'percent')\n",
        "print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t8HPX2RxwLlT",
        "outputId": "906ac336-4930-4dbc-d00d-e4f708f9b2c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion for Player A:  0.1234\n",
            "Resulting Growth Ratio:  1.045\n",
            "Equivalent Growth Rate:  4.5 percent\n",
            "\n",
            "Optimal betting proportion for Player B:  0.1328\n",
            "Resulting Growth Ratio:  1.0147\n",
            "Equivalent Growth Rate:  1.47 percent\n",
            "\n",
            "Optimal betting proportion for Player C:  -292.2633\n",
            "Resulting Growth Ratio:  nan\n",
            "Equivalent Growth Rate:  nan percent\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in power\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in power\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in power\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in double_scalars\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Players A and B\n",
        "\n",
        "initial_guess = [.33,.33]\n",
        "\n",
        "b = (0,1)\n",
        "bounds = (b,b)\n",
        "\n",
        "def constraint(p):\n",
        "    return 1 - (p[0]+p[1])\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_A*p[0]-p[1])**(s_A) * (1-p[0]+R_B*p[1])**(s_B) * (1-p[0]-p[1])**(1-s_A-s_B)\n",
        "\n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint}) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player A: ', np.round(result.x[0],4))\n",
        "print('Optimal betting proportion for Player B: ', np.round(result.x[1],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x)-1)*100,2),'percent')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ALvGlQaBxnoE",
        "outputId": "1b96291b-e44d-4950-91f5-a18c7ff06fa5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion for Player A:  0.1555\n",
            "Optimal betting proportion for Player B:  0.2244\n",
            "Resulting Growth Ratio:  1.092\n",
            "Equivalent Growth Rate:  9.2 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Players A, B, and C\n",
        "\n",
        "initial_guess = [.25,.25,.25]\n",
        "\n",
        "b = (0,1)\n",
        "bounds = (b,b,b)\n",
        "\n",
        "def constraint(p):\n",
        "    return 1 - (p[0]+p[1]+p[2])\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_A*p[0]-p[1]-p[2])**(s_A) * (1-p[0]+R_B*p[1]-p[2])**(s_B) * (1-p[0]-p[1]+R_C*p[2])**(s_C) * (1-p[0]-p[1]-p[2])**(1-s_A-s_B-s_C)\n",
        "\n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint}) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player A: ', np.round(result.x[0],4))\n",
        "print('Optimal betting proportion for Player B: ', np.round(result.x[1],4))\n",
        "print('Optimal betting proportion for Player C: ', np.round(result.x[2],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x)-1)*100,2),'percent')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "52zTSFo7L8NT",
        "outputId": "7938a45f-09bb-4813-cc3a-58d2f347cf24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion for Player A:  0.1607\n",
            "Optimal betting proportion for Player B:  0.2396\n",
            "Optimal betting proportion for Player C:  0.021\n",
            "Resulting Growth Ratio:  1.0937\n",
            "Equivalent Growth Rate:  9.37 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Players A, B, C, and D\n",
        "\n",
        "initial_guess = [.2,.2,.2,.2]\n",
        "\n",
        "b = (0,1)\n",
        "bounds = (b,b,b,b)\n",
        "\n",
        "def constraint(p):\n",
        "    return 1 - (p[0]+p[1]+p[2]+p[3])\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_A*p[0]-p[1]-p[2]-p[3])**(s_A) * (1-p[0]+R_B*p[1]-p[2]-p[3])**(s_B) * (1-p[0]-p[1]+R_C*p[2]-p[3])**(s_C) * (1-p[0]-p[1]-p[2]+R_D*p[3])**(s_D) * (1-p[0]-p[1]-p[2]-p[3])**(1-s_A-s_B-s_C-s_D)\n",
        "\n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint}) # use scipy's algorithm to solve\n",
        "print('Optimal betting proportion for Player A: ', np.round(result.x[0],4))\n",
        "print('Optimal betting proportion for Player B: ', np.round(result.x[1],4))\n",
        "print('Optimal betting proportion for Player C: ', np.round(result.x[2],4))\n",
        "print('Optimal betting proportion for Player D: ', np.round(result.x[3],4))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x)-1)*100,2),'percent')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eYYSeuSfMVap",
        "outputId": "d8318896-1bb1-4747-b8f8-a9ad855f4e5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion for Player A:  0.1606\n",
            "Optimal betting proportion for Player B:  0.2401\n",
            "Optimal betting proportion for Player C:  0.021\n",
            "Optimal betting proportion for Player D:  0.0\n",
            "Resulting Growth Ratio:  1.0937\n",
            "Equivalent Growth Rate:  9.37 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2 Concurrent Games\n",
        "\n",
        "R_1 = 1/1.2\n",
        "s_1 = .57\n",
        "\n",
        "R_2 = 1.2\n",
        "s_2 = .47\n",
        "\n",
        "initial_guess = [.001]\n",
        "\n",
        "b = (0,1)\n",
        "bounds = (b,)\n",
        "\n",
        "def constraint(p):\n",
        "    return 1 - p\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_1*p)**(s_1) * (1-p)**(1-s_1)\n",
        "\n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint})       \n",
        "print('Optimal betting proportion on Game 1: ', np.round(result.x[0],3))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x[0]),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x[0])-1)*100,2),'percent')\n",
        "print()\n",
        "\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_2*p)**(s_2) * (1-p)**(1-s_2)\n",
        " \n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint})       \n",
        "print('Optimal betting proportion on Game 2: ', np.round(result.x[0],3))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x[0]),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x[0])-1)*100,2),'percent')\n",
        "print()\n",
        "\n",
        "\n",
        "initial_guess = [.2,.2]\n",
        "\n",
        "b = (0,1)\n",
        "bounds = (b,b)\n",
        "\n",
        "def constraint(p):\n",
        "    return 1 - (p[0]+p[1])\n",
        "\n",
        "def formula(p): # create the relevant function\n",
        "    return -1*(1+R_1*p[0]+R_2*p[1])**(s_1*s_2) * (1+R_1*p[0]-p[1])**(s_1*(1-s_2)) * (1+R_2*p[1]-p[0])**(s_2*(1-s_1)) * (1-p[0]-p[1])**((1-s_1)*(1-s_2))\n",
        "\n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint})\n",
        "print('Optimal betting proportion on Game 1: ', np.round(result.x[0],3))\n",
        "print('Optimal betting proportion on Game 2: ', np.round(result.x[1],3))\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x)-1)*100,2),'percent')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iwZXOgI9MZix",
        "outputId": "ddf3341d-7aa7-48eb-ec46-b30f47d284cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion on Game 1:  0.054\n",
            "Resulting Growth Ratio:  1.0012\n",
            "Equivalent Growth Rate:  0.12 percent\n",
            "\n",
            "Optimal betting proportion on Game 2:  0.028\n",
            "Resulting Growth Ratio:  1.0005\n",
            "Equivalent Growth Rate:  0.05 percent\n",
            "\n",
            "Optimal betting proportion on Game 1:  0.054\n",
            "Optimal betting proportion on Game 2:  0.028\n",
            "Resulting Growth Ratio:  1.0017\n",
            "Equivalent Growth Rate:  0.17 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Betting on a full slate of Sunday NFL Games\n",
        "\n",
        "R = np.array([  1, 1/1.2, 1.2, 1/2, 1/1.5,  2])\n",
        "s = np.array([.54,   .57, .47, .67,  .595, .3])\n",
        "\n",
        "n = R.shape[0] # number of games\n",
        "initial_guess = np.ones((n))/(n+1)\n",
        "b = (0,1)\n",
        "bounds = (b,b,b,b,b,b)#((0,1)*n) # this repeats the tuple '(0,1)' n times\n",
        "\n",
        "def constraint(p):\n",
        "    return 1 - np.sum(p)\n",
        "\n",
        "def formula(p):\n",
        "    z = -1\n",
        "    for i in np.arange(2**n,dtype=np.uint8):\n",
        "        flag = np.unpackbits(i)[-n:]\n",
        "        payout = 1\n",
        "        prob = 1\n",
        "        for j in np.arange(n):\n",
        "            if flag[j]:\n",
        "                payout += R[j]*p[j]\n",
        "                prob *= s[j]\n",
        "            else:\n",
        "                payout += -1*p[j]\n",
        "                prob *= (1-s[j])\n",
        "                \n",
        "        z *= payout**prob          \n",
        "    return z\n",
        "\n",
        "result = opt.minimize(formula, initial_guess, bounds = bounds, constraints = {'type': 'ineq', 'fun': constraint})\n",
        "for i in np.arange(n): \n",
        "  print('Optimal betting proportion on Game ',i,': ', np.round(result.x[i],3))\n",
        "print()\n",
        "print('Resulting Growth Ratio: ', np.round(-formula(result.x),4))\n",
        "print('Equivalent Growth Rate: ', np.round((-formula(result.x)-1)*100,2),'percent')\n",
        "print('Growth Rate over 18 weekends: ', np.round(((-formula(result.x))**18-1)*100,2),'percent')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r5cMTzKgTa8U",
        "outputId": "ba49d143-b8e2-4bc1-c46f-895c4ae32f12"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal betting proportion on Game  0 :  0.08\n",
            "Optimal betting proportion on Game  1 :  0.054\n",
            "Optimal betting proportion on Game  2 :  0.028\n",
            "Optimal betting proportion on Game  3 :  0.011\n",
            "Optimal betting proportion on Game  4 :  0.0\n",
            "Optimal betting proportion on Game  5 :  0.0\n",
            "\n",
            "Resulting Growth Ratio:  1.0049\n",
            "Equivalent Growth Rate:  0.49 percent\n",
            "Growth Rate over 18 weekends:  9.25 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Approximate Stock Market Growth Rate per Week: ', np.round(((1.1)**(1/52)-1)*100,2),'percent')"
      ],
      "metadata": {
        "id": "_BgqvefflD2A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6eba6eb7-af46-49dd-f620-0d65ed72d08b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Approximate Stock Market Growth Rate per Week:  0.18 percent\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "hSCsmwxXfESL"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}