microproject-infinite-money-in-roulette-martingale.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "<h1 style=\"text-align: center\">\n",
    "<div style=\"color: #DD3403; font-size: 60%\">Data Science DISCOVERY MicroProject</div>\n",
    "<span style=\"\">MicroProject: Infinite Money in Roulette (Martingale Betting System)</span>\n",
    "<div style=\"font-size: 60%;\"><a href=\"https://discovery.cs.illinois.edu/microproject/infinite-money-in-roulette-martingale/\">https://discovery.cs.illinois.edu/microproject/infinite-money-in-roulette-martingale/</a></div>\n",
    "</h1>\n",
    "\n",
    "<hr style=\"color: #DD3403;\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## The Martingale Betting System\n",
    "\n",
    "The \"Martingale Betting System\" is a specific strategy where, when applied to the game of Roulette, involves the following actions:\n",
    "\n",
    "- You will initially start by betting a small amount (ex: $1) on red,\n",
    "- If you win (the wheel lands on red), you will win your bet, and then bet $1 again on red,\n",
    "- Each time red lose, you double your bet.  (Initially, it'll be a $2 bet, then $4, then $8, and so on.)\n",
    "- Each will will always recover all previous losses.  (A $4 bet that wins happens after a $1 and $2 loss, resulting in a +$1 win.)\n",
    "\n",
    "It is commonly claimed that this strategy will result in an **infinite increasing amount of money** so long as you play the game long enough!  In this MicroProject, we will explore this claim and use simulation to play Roulette using the Martingale Betting System.  Let's nerd out! :)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "<hr style=\"color: #DD3403;\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Part 1: Creating a Function to Play Roulette\n",
    "\n",
    "To begin to test any betting system, we first need the logic to play the game.  In this MicroProject, we are focusing on Roulette.  In the game of Roulette, a large wheel with 38 slots is spun and a ball is placed into the spinning wheel.  As the spinning wheel slows down, the ball will land in one of the 38 slots.  Each of the slots are labeled with a number **and** a color.\n",
    "- The numbers `0`, `00`, and then `1` through `36`\n",
    "- The colors are:\n",
    "    - The red numbers are: `32`, `19`, `21`, `25`, `34`, `27`, `36`, `30`, `23`, `5`, `16`, `1`, `14`, `9`, `18`, `7`, `12`, and `3` (18 total red numbers).\n",
    "    - The black numbers are: `15`, `4`, `2`, `17`, `6`, `13`, `11`, `8`, `10`, `24`, `33`, `20`, `31`, `22`, `29`, `28`, `35`, and `26`  (18 total black numbers).\n",
    "    - The green numbers are: `0` and `00` (2 total green numbers).\n",
    "\n",
    "\n",
    "### Return Value\n",
    "\n",
    "Write a function called `playRoulette` that returns a dictionary that contains two keys:\n",
    "- `number`, the number, and\n",
    "- `color`, the corresponding color\n",
    "\n",
    "For example:\n",
    "\n",
    "```py\n",
    "return { \"number\": number, \"color\": color }\n",
    "```\n",
    "\n",
    "Make sure `number` is a number, except for the case `00`, which should be the string \"00\".\n",
    "\n",
    "\n",
    "### Helpful Code\n",
    "\n",
    "To help you, it may be useful to use this logic to test if a number of in a list of red or black numbers:\n",
    "\n",
    "---\n",
    "```py\n",
    "red_numbers = [32, 19, 21, 25, 34, 27, 36, 30, 23, 5, 16, 1, 14, 9, 18, 7, 12, 3]\n",
    "if number in red_numbers:\n",
    "  color = \"red\"\n",
    "\n",
    "black_numbers = [15, 4, 2, 17, 6, 13, 11, 8, 10, 24, 33, 20, 31, 22, 29, 28, 35, 26]\n",
    "if number in black_numbers:\n",
    "  color = \"black\"\n",
    "```\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Observe your Function Results\n",
    "\n",
    "The following code will use show the results of your function 10 times.  Make sure it looks good!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "  print(playRoulette())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "### TEST CASE for Part 1: Creating a Function to Play Roulette\n",
    "tada = \"\\N{PARTY POPPER}\"\n",
    "\n",
    "assert( \"playRoulette\" in vars() )\n",
    "\n",
    "color_map = {}\n",
    "for i in [32, 19, 21, 25, 34, 27, 36, 30, 23, 5, 16, 1, 14, 9, 18, 7, 12, 3]:\n",
    "  color_map[i] = \"red\"\n",
    "for i in [15, 4, 2, 17, 6, 13, 11, 8, 10, 24, 33, 20, 31, 22, 29, 28, 35, 26]:\n",
    "  color_map[i] = \"black\"\n",
    "for i in [0, \"00\"]:\n",
    "  color_map[i] = \"green\"\n",
    "\n",
    "occurrence = {}\n",
    "n = 100000\n",
    "for i in range(n):\n",
    "  d = playRoulette()\n",
    "  assert(\"number\" in d), \"Your return value did not have a dictionary entry for the key `number`\"\n",
    "  assert(\"color\" in d), \"Your return value did not have a dictionary entry for the key `color`\"\n",
    "  assert(d[\"number\"] in color_map), f\"You returned the `number` ${d['number']}, which isn't a valid result of Roulette\"\n",
    "\n",
    "  if (d[\"number\"] not in occurrence):\n",
    "    occurrence[d[\"number\"]] = 0\n",
    "  occurrence[d[\"number\"]] += 1\n",
    "\n",
    "max = 0\n",
    "min = n\n",
    "ev = n / len(occurrence)\n",
    "for num in color_map:\n",
    "  assert(num in occurrence), f\"Your function never returned the `number` ${num}\"\n",
    "  count = occurrence[num]\n",
    "\n",
    "  assert((count / ev) >= 0.5), f\"Your function returned the `number` ${num} far too few times\"\n",
    "  assert((count / ev) <= 1.5), f\"Your function returned the `number` ${num} far too many times\"\n",
    "\n",
    "tada = \"\\N{PARTY POPPER}\"\n",
    "print(f\"{tada} All tests passed! {tada}\") "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "<hr style=\"color: #DD3403;\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Part 2: Simulation of Betting with $10,000\n",
    "\n",
    "To test the Martingale Betting System, let's start playing with $10,000 (that's a lot of money)!\n",
    "\n",
    "To do this, write a simulation that tracks your total amount of money as you play many games of roulette.  To do this, you'll want to initially set two variables outside of your simulation:\n",
    "- `money = 10000` ($10,000), your starting money\n",
    "- `bet = 1`, your starting bet size\n",
    "\n",
    "In your simulation, you'll want to play a game of roulette using your `playRoulette` once for each run of your simulation!\n",
    "- If you get **red**, you have won your `bet`!  You'll want to add your bet to your money and reset your bet back to $1.\n",
    "    - Ex: `money = money + bet` and `bet = 1`\n",
    "- If you get anything else, you have lost your `bet`. You'll want to subtract your bet from your money and then double it.\n",
    "    - Ex: `money = money - bet` and `bet = bet * 2`\n",
    "\n",
    "In your simulation, make sure to record all five of these real-world variables:\n",
    "1. `money`, you current amount of money (before adding/subtracting any result from this round)\n",
    "2. `bet`, your current bet size\n",
    "3. `number`, the number the Roulette wheel landed on\n",
    "4. `color`, the color the Roulette wheel landed on\n",
    "4. `win`, the total amount of winning for this spin of the roulette wheel\n",
    "\n",
    "Write your simulation below that simulates playing 1,000,000 games or Roulette and storing the reuslts in a DataFrame called `df`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "### TEST CASE for Part 2: Simulation of Betting with $10,000\n",
    "tada = \"\\N{PARTY POPPER}\"\n",
    "\n",
    "assert( \"df\" in vars() ), \"Your simulation must be stored in df\"\n",
    "assert( df.money.values[0] == 10000 ), \"Your starting money must be $10,000\"\n",
    "assert( df.bet.values[0] == 1 ), \"Your starting bet must be $1\"\n",
    "assert( len(df) == 1000000 ), \"Your simulation must be of exactly 1,000,000 games\"\n",
    "\n",
    "uniqueBets = list(df.bet.unique())\n",
    "maxBet = df.bet.unique().max()\n",
    "curBet = 1\n",
    "for i in range(len(uniqueBets)):\n",
    "    val = 2 ** i\n",
    "    if val in uniqueBets:\n",
    "        uniqueBets.remove(2 ** i)\n",
    "\n",
    "assert( len(uniqueBets) == 0 ), f\"Your `bets` contains values that are not valid bets: {uniqueBets}\"\n",
    "\n",
    "redCount = len(df[df.color == \"red\"])\n",
    "assert(abs(df.money.max() - redCount - 10000) < 10), \"You should only make $1 every time `red` occurs, even in a streak.\"\n",
    "\n",
    "tada = \"\\N{PARTY POPPER}\"\n",
    "print(f\"{tada} All tests passed! {tada}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "<hr style=\"color: #DD3403;\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Part 3: Analysis of Infinite Money"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "The following code creates a line plot using `df.plot.line` and uses `money` as the `y`-axis value to create a plot of our current money:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.line(y=\"money\", xlabel=\"Plays of Roulette\", ylabel=\"Current Money\", title=\"Infinite Money in Roulette?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Negative Money?\n",
    "\n",
    "A casino requires you to have money to place a bet -- so if you money ever went below $0, you couldn't make the bet.  In your 100,000 games, create a DataFrame of all games with a negative balance -- store that as `df_negativeBalance`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_negativeBalance = ...\n",
    "df_negativeBalance"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Required Bankroll"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "What is the largest amount of debt you had?  This is represents the **additional \"bankroll\"** (on top of the original $10,000) you would be requried to have to be able to make the bet.  Store this answer as a postive number of the `additional_bankroll_needed`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "additional_bankroll_needed = ...\n",
    "additional_bankroll_needed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "### TEST CASE for Part 3: Analysis of Infinite Money\n",
    "tada = \"\\N{PARTY POPPER}\"\n",
    "\n",
    "assert( \"df_negativeBalance\" in vars() )\n",
    "assert( len(df_negativeBalance) == len(df) - len(df[df.money >= 0]) ), \"Your df_negativeBalance does not contain all of the negative balances\"\n",
    "\n",
    "assert( \"additional_bankroll_needed\" in vars() )\n",
    "assert( additional_bankroll_needed >= 0 ), \"additional_bankroll_needed must be positive\"\n",
    "assert( additional_bankroll_needed == -df.money.min() ), \"additional_bankroll_needed is incorrect\"\n",
    "\n",
    "def money(value):\n",
    "    value = round(value, 2)\n",
    "    return \"${:,}\".format(value)\n",
    "\n",
    "tada = \"\\N{PARTY POPPER}\"\n",
    "print(f\"{tada} All tests passed! {tada}\") \n",
    "print()\n",
    "print(f\"With your initial $10,000, you would have needed an ADDITIONAL {money(additional_bankroll_needed)} to be able to use this strategy.\")\n",
    "print(\"...that's a lot of money! (!!)\")\n",
    "print(\"...in addition, every additional game you play has a chance to double the need of the bankroll.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "<hr style=\"color: #DD3403;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Analysis\n",
    "\n",
    "The Martingale Betting System seems like infinite money -- the graph continues to go up increasing the amount of money you have -- but doing so requires a larger and larger bankroll.\n",
    "\n",
    "As the games grow from 1,000,000 to 10,000,000 and beyond -- and if we assume a casino would let you bet larger and larger amounts (no casino does that, all have what's called a \"maximum bet\") -- **the bankroll you need grows the more games you play but the expected value does not**.\n",
    "\n",
    "You can try that yourself, seeing how the more you play the more bankroll you will need -- and it grows at a faster rate than any amount of money would win.\n",
    "\n",
    "**Final Conclusion**: The Martingale Betting System feels like infinite money (and even looks like it on a graph), but the Martingale Betting System ONLY allows you to make \"infinite money\" if you already have \"infinite money\" in your bank. :("
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "<hr style=\"color: #DD3403;\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "execution_count": 0,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Submission\n",
    "\n",
    "You're almost done!  All you need to do is to commit your lab to GitHub and run the GitHub Actions Grader:\n",
    "\n",
    "1.  ⚠️ **Make certain to save your work.** ⚠️ To do this, go to **File => Save All**\n",
    "\n",
    "2.  After you have saved, exit this notebook and return to https://discovery.cs.illinois.edu/microproject/infinite-money-in-roulette-martingale/ and complete the section **\"Commit and Grade Your Notebook\"**.\n",
    "\n",
    "3. If you see a 100% grade result on your GitHub Action, you've completed this MicroProject! 🎉"
   ]
  }
 ],
 "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.11.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}