monty-hall.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a Jupyter Notebook, running [Python](https://www.python.org) code in each cell.\n",
    "\n",
    "We've preloaded all the cells with content, so you should be good to go to just run them!\n",
    "\n",
    "**Use Shift-ENTER (or the \"run\" button, above) to run each cell; feel free to edit, etc, before and after running!**\n",
    "\n",
    "Practice by running the next cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello world\")\n",
    "print(\"4*4 is\", 4*4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Monty Hall problem\n",
    "\n",
    "You, lucky contestant, are on a game show!  You stand a chance to win a car (with a trade-in value of $50k)!\n",
    "\n",
    "The host, one Monty Hall, describes the game to you as follows:\n",
    "\n",
    "   1. Here before you, you see three doors -- A, B, and C!  Behind one of them is the car.\n",
    "\n",
    "   2. I will start by having you pick one door, but I **do not open it**.\n",
    "\n",
    "   3. Then, I will reveal what is behind one of the two doors you did not choose (needless to say, it will not be the car!)\n",
    "\n",
    "   4. At that point, you may either keep your first choice, OR you may switch your choice to another door.\n",
    "\n",
    "If you can identify which door has the car behind it, you get to keep the car (or the money).\n",
    "\n",
    "The question for you is this: as a winning strategy, should you (a) always stay with your original door choice, (b) always switch, or (c) it doesn't matter?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monty Hall Monte Carlo\n",
    "\n",
    "You, being an accomplished computational scientist, decide that rather than thinking hard about this, you're just going to simulate it using the Monte Carlo method ([http://en.wikipedia.org/wiki/Monte_Carlo_method](http://en.wikipedia.org/wiki/Monte_Carlo_method)). This lets you explore the more complex emergent properties of this system by only worrying about the simple rules defining the system. ([http://en.wikipedia.org/wiki/Agent-based_model](http://en.wikipedia.org/wiki/Agent-based_model))\n",
    "\n",
    "Let's start by setting up the problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# import the pseudo-random number generator module in Python\n",
    "import random\n",
    "\n",
    "# now, build a function to create 3 doors, with one car behind them - chosen at random.\n",
    "# this function will return a dictionary with keys A, B, and C, containing associated values 'empty' or 'car'.\n",
    "def create_doors():\n",
    "    doors = {}\n",
    "    doors['A'] = 'empty'\n",
    "    doors['B'] = 'empty'\n",
    "    doors['C'] = 'empty'\n",
    "    \n",
    "    # randomly choose *one* of the three doors\n",
    "    keylist = list(doors.keys())\n",
    "    car_is_behind = random.choice(keylist)\n",
    "    doors[car_is_behind] = 'car'\n",
    "    \n",
    "    return doors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the output of this function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print('hello, world')\n",
    "print(create_doors())\n",
    "print(create_doors())\n",
    "print(create_doors())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, here are two functions, one which simulates choice (a) -- staying with your original door -- and one which simulates choice (b) -- switch.  If the function returns true, you've won! If the function returns false, you've lost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def always_switch():\n",
    "    # set up the problem\n",
    "    doors_d = create_doors()\n",
    "    \n",
    "    # pick a door\n",
    "    doors = ['A', 'B', 'C']\n",
    "    my_choice = random.choice(doors)\n",
    "    \n",
    "    # remove it from Monty's consideration -- he will never choose this one\n",
    "    doors.remove(my_choice)\n",
    "    assert len(doors) == 2, \"you should only have two doors left...\"\n",
    "    \n",
    "    # now Monty Hall picks a door:\n",
    "    while 1:\n",
    "        monty_choice = random.choice(doors)\n",
    "        if doors_d[monty_choice] != 'car': # he'll never reveal the car!\n",
    "            break\n",
    "    \n",
    "    doors.remove(monty_choice)\n",
    "    \n",
    "    # now, because you always switch, you're left with monty's non-choice:\n",
    "    assert len(doors) == 1, \"you should only have one door left...\"\n",
    "    \n",
    "    my_choice = doors[0]\n",
    "    \n",
    "    if doors_d[my_choice] == 'car':\n",
    "        return True                    # you win!\n",
    "    return False                       # you lose :(\n",
    "\n",
    "print(always_switch())\n",
    "print(always_switch())\n",
    "print(always_switch())\n",
    "print(always_switch())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def never_switch():\n",
    "    # set up the problem\n",
    "    doors_d = create_doors()\n",
    "    \n",
    "    # pick a door\n",
    "    doors = ['A', 'B', 'C']\n",
    "    my_choice = random.choice(doors)\n",
    "    doors.remove(my_choice)\n",
    "    assert len(doors) == 2, \"you should only have two doors left...\"\n",
    "    \n",
    "    # now Monty Hall picks a door:\n",
    "    while 1:\n",
    "        monty_choice = random.choice(doors)\n",
    "        if doors_d[monty_choice] != 'car': # he'll never reveal the car!\n",
    "            break\n",
    "    \n",
    "    doors.remove(monty_choice)\n",
    "    \n",
    "    # now, because you never switch, you're left with your original choice:\n",
    "    assert len(doors) == 1, \"you should only have one door left...\"\n",
    "    \n",
    "    # you stick with your original choice:\n",
    "    if doors_d[my_choice] == 'car':\n",
    "        return True                    # you win!\n",
    "    return False                       # you lose :("
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# ok, let's try this out!\n",
    "print(always_switch())\n",
    "print(always_switch())\n",
    "print(always_switch())\n",
    "\n",
    "print(never_switch())\n",
    "print(never_switch())\n",
    "print(never_switch())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some notes!\n",
    "\n",
    "OK, a couple of notes here.\n",
    "\n",
    "First, this *is* a true implementation of the Monty Hall scenario, right?  Even though you're randomly choosing doors, it's no different from what you'd normally be doing, right -- guessing?\n",
    "\n",
    "Second, every time you run this, you will get a different set of answers -- because we're using a random number generator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The First Question: is it better to always switch? Or should you never switch? Or is it the same?\n",
    "\n",
    "To answer this question, let's run 'always_switch()' a bunch of times, and calculate how often we win."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "won_count = 0\n",
    "N = 10000\n",
    "for i in range(N):\n",
    "    if always_switch():\n",
    "        won_count += 1\n",
    "        \n",
    "print('With always_switch(), I won', won_count, 'of', N, 'tries')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do the same with never switching:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "won_count = 0\n",
    "N = 1000\n",
    "for i in range(N):\n",
    "    if never_switch():\n",
    "        won_count += 1\n",
    "        \n",
    "print('With never_switch(), I won', won_count, 'of', N, 'tries')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, so according to our simulation, we should always switch.  ...can we get this answer some other way?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another question: what happens if you increase the number of doors, and Monty opens n-1 doors?\n",
    "\n",
    "Since all our doors are virtual, we can change their number quite easily.  (Well, it involves a little more programming...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# write a function to create M doors, not just 3.\n",
    "def create_multi_doors(M):\n",
    "    doors = {}\n",
    "    for i in range(M):\n",
    "        doors[i] = 'empty'\n",
    "        \n",
    "    # randomly choose *one* of the three doors\n",
    "    keylist = list(doors.keys())\n",
    "    car_is_behind = random.choice(keylist)\n",
    "    doors[car_is_behind] = 'car'\n",
    "    \n",
    "    return doors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll also need to update our always_switch/never_switch functions to use create_multi_doors():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def always_switch2(M):\n",
    "    # set up the problem\n",
    "    doors_d = create_multi_doors(M)\n",
    "    \n",
    "    # pick a door\n",
    "    doors = list(doors_d.keys())\n",
    "    my_choice = random.choice(doors)\n",
    "    \n",
    "    doors.remove(my_choice)\n",
    "    \n",
    "    while len(doors) > 1:\n",
    "        door = random.choice(doors)\n",
    "        if doors_d[door] != 'car':\n",
    "            doors.remove(door)\n",
    "    \n",
    "    assert len(doors) == 1, doors\n",
    "    \n",
    "    # now pick the one that's left:\n",
    "    my_choice = doors[0]\n",
    "    \n",
    "    if doors_d[my_choice] == 'car':\n",
    "        return True                    # you win!\n",
    "    return False                       # you lose :(\n",
    "\n",
    "def never_switch2(M):\n",
    "    # set up the problem\n",
    "    doors_d = create_multi_doors(M)\n",
    "    \n",
    "    # pick a door\n",
    "    doors = list(doors_d.keys())\n",
    "    my_choice = random.choice(doors)\n",
    "    \n",
    "    doors.remove(my_choice)\n",
    "    \n",
    "    while len(doors) > 1:\n",
    "        door = random.choice(doors)\n",
    "        if doors_d[door] != 'car':\n",
    "            doors.remove(door)\n",
    "    \n",
    "    assert len(doors) == 1, doors\n",
    "    \n",
    "    # ...but we're sticking with our original choice.    \n",
    "    if doors_d[my_choice] == 'car':\n",
    "        return True                    # you win!\n",
    "    return False                       # you lose :("
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print(always_switch2(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print(always_switch2(100))\n",
    "print(always_switch2(100))\n",
    "print(always_switch2(100))\n",
    "\n",
    "print(never_switch2(100))\n",
    "print(never_switch2(100))\n",
    "print(never_switch2(100))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, the functions don't obviously break... what happens if we run them a bunch?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "won_count = 0\n",
    "N = 1000 # num trials\n",
    "M = 100 # doors\n",
    "\n",
    "for i in range(N):\n",
    "    if always_switch2(M):\n",
    "        won_count += 1\n",
    "        \n",
    "print('With always_switch2() and', M, 'doors, I won', won_count, 'of', N, 'tries')\n",
    "\n",
    "won_count = 0\n",
    "\n",
    "for i in range(N):\n",
    "    if never_switch2(M):\n",
    "        won_count += 1\n",
    "        \n",
    "print('With never_switch2() and', M, 'doors, I won', won_count, 'of', N, 'tries')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yikes! That's a pretty clear answer...\n",
    "\n",
    "##  A few questions to explore --\n",
    "\n",
    "How do we know always_switch2() and never_switch2() work properly?\n",
    "\n",
    "What's the actual mathematical formula underlying the results?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# calculate the avg & standard deviation\n",
    "def calc_stddev(series):\n",
    "    avg = sum(series) / float(len(series))\n",
    "    devs = [ i - avg for i in series ]\n",
    "    devs = [ i**2 for i in devs ]\n",
    "    stddev = math.sqrt(sum(devs) / float(len(series)))\n",
    "    return avg, stddev\n",
    "\n",
    "\n",
    "# run the given function with parameter M (# doors), N times; return average\n",
    "def try_N_times(fn, M, N):\n",
    "    won = 0\n",
    "    for i in range(N):\n",
    "        if fn(M):\n",
    "            won += 1\n",
    "    return won / float(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explore the simulation\n",
    "\n",
    "What does `N` represent and what happens as you change `N` in different ways?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does `n_trials` represent and what happens as you change `n_trials` in different ways?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does `M` represent and what happens as you change `M` in different ways?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's do some plotting!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats\n",
    "\n",
    "# Parameters we've made easy to change\n",
    "#################\n",
    "\n",
    "n_trials = 1000  # How many times to gather statics from groups of N samples\n",
    "M = 3           # How many doors to use (originally 3)\n",
    "N = 100         # How many samples from which to gather statistics (like mean of N coin flips)\n",
    "\n",
    "#################\n",
    "\n",
    "# Try M doors N times; then run n_trials times, and track.\n",
    "always_list = [ try_N_times(always_switch2, M, N) for _ in range(n_trials) ]\n",
    "never_list = [ try_N_times(never_switch2, M, N) for _ in range(n_trials) ]\n",
    "\n",
    "# get the actual and fitted distribution for the 'always switch' decision\n",
    "n1, bins1, patches1 = plt.hist(always_list, facecolor='green', alpha=0.5, range=(0, 1), bins=50, density=True)\n",
    "always_avg, always_stddev = calc_stddev(always_list)\n",
    "y1 = scipy.stats.norm.pdf(bins1, always_avg, always_stddev)\n",
    "plt.plot(bins1, y1, 'g--')\n",
    "\n",
    "# get the actual and fitted distribution for the 'never switch' decision\n",
    "n2, bins2, patches2 = plt.hist(never_list, facecolor='red', alpha=0.5, range=(0, 1), bins=50, density=True)\n",
    "never_avg, never_stddev = calc_stddev(never_list)\n",
    "y2 = scipy.stats.norm.pdf(bins2, never_avg, never_stddev) # fit\n",
    "plt.plot(bins2, y2, 'r--')\n",
    "\n",
    "# label the plot\n",
    "plt.xlabel('probability of winning')\n",
    "plt.ylabel('distribution of p for multiple trials')\n",
    "plt.title('Monty Hall problem (%d doors)' % M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(bins1, y1, 'g', label='always switch')\n",
    "plt.plot(bins2, y2, 'r', label='never switch')\n",
    "plt.axis(ymax=12)\n",
    "plt.legend()\n",
    "plt.xlabel('probability of winning')\n",
    "plt.ylabel('distribution of p for multiple trials')\n",
    "plt.title('Monty Hall problem (%d doors)' % M)\n",
    "print('average win rate, always switching:', always_avg)\n",
    "print('average win rate, never switch:', never_avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}