Proving the Monty Hall Problem Experimentally.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Testing the Monty Hall Problem</h1>\n",
    "\n",
    "The <a href=\"https://en.wikipedia.org/wiki/Monty_Hall_problem\">Monty Hall Problem</a> is a classic thought experiment and probability puzzle. It was first published in 1975 by statistician Steve Selvin in the scientific journal <i>American Statician</i>, and rose to popularity in 1990 when published in <i>Parade</i> magazine.\n",
    "\n",
    "The Wikipedia article does a fantastic job explaining the rules, assumptions, and has many helpful ways of thinking about this unintuitive puzzle. I reccomend it for further reading for mathematical proofs and other explorations that are out of the scope of this exercise. Let's take a look at the basic rules and assumtions. The <i>Parade</i> version of the problem is as follows:\n",
    "\n",
    "  <i>Suppose you're on a game show, and you're given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what's behind the doors, opens another door, say No. 3, which has a goat. He then says to you, \"Do you want to pick door No. 2?\" Is it to your advantage to switch your choice?</i>\n",
    "  \n",
    "When posed this problem, most people will respond that it doesn't matter if you switch or not, since there are two closed doors your chances 50/50. However, switching actually DOUBLES your chance of winning from 1/3 to 2/3, as correctly answered by <i>Parade</i> columnist Marylin vos Savant. This answer is so unintuitive that <i>Parade</i> received approximately 10,000 letters telling them that their answer was wrong. As I mentioned, the Wikipedia article has many tools and methods to help you understand why it is to your advantage to switch. However, I'm here to prove it experimentally through simulating the game 1,000 each switching choices, and not switching.\n",
    "\n",
    "To start, we'll need to import the random module to help us generate our doors at random, and to help our virtual contestant and host make decisions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's define a Door class. Each door will have a name (Door 1, Door 2, and Door 3), something behind it, and be initialized as \"closed\", represented as a boolean value. Here I've added a method to \"open\" the door, setting \"is_closed\" to \"False\" and adding what is in the \"behind\" attribute to the name to simulate the contestant's experience. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Door:\n",
    "    def __init__(self, name, behind):\n",
    "        self.behind = behind\n",
    "        self.name = name\n",
    "        self.is_closed = True\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def open_door(self):\n",
    "        if self.is_closed:\n",
    "            self.name = self.name + ': ' + self.behind\n",
    "            self.is_closed = False       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's define a function to generate doors based on a list of possible outcomes and assign each outcome randomly to a door. We copy the list to preserve the original (we'll use it again later in our code), so that we can remove each outcome as we assign it to a door, making sure it is only used once. Once complete, this function returns a list of Door objects the same length as our list of possible outcomes. For our purposes here, it will always be 3 items long."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_random_doors(possible_outcomes):\n",
    "    outcomes = possible_outcomes[:]\n",
    "    list_of_doors = []\n",
    "    for i in range(len(outcomes)):\n",
    "        rand_index = random.randint(0, (len(outcomes)-1))\n",
    "        list_of_doors.append(Door('Door '+str(i+1), outcomes[rand_index]))\n",
    "        outcomes.pop(rand_index)\n",
    "    return list_of_doors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll define our list of possible outcomes, or what's behind each door we want to generate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "possible_outcomes = ['car', 'goat', 'goat']    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great. Now let's test our function with our established list of outcomes and print the result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Door 1, Door 2, Door 3]\n"
     ]
    }
   ],
   "source": [
    "test_doors = generate_random_doors(possible_outcomes)\n",
    "print(test_doors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make sure our open_door method is working correctly, let's iterate through our list and open each door, printing the result again at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Door 1: goat, Door 2: car, Door 3: goat]\n"
     ]
    }
   ],
   "source": [
    "for door in test_doors:\n",
    "    door.open_door()\n",
    "print(test_doors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything seems to be working so far. We have a way to randomly assign our outcomes to closed doors, and opening them allows us to easily see what's behind them. Now, let's create a Contestant class, with attributes that hold their \"choice\", a method to make that choice randomly from a list of closed doors, and a boolean value for whether they will switch their choice when given the option. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Contestant:\n",
    "    def __init__(self, always_switches):\n",
    "        self.choice = None\n",
    "        self.always_switches = always_switches\n",
    "        \n",
    "    def make_choice(self, choices):\n",
    "        self.choice = choices[random.randint(0, (len(choices)-1))]\n",
    "    \n",
    "    def switch_choice(self, choices):\n",
    "        for choice in choices:\n",
    "            if choice != self.choice and choice.is_closed:\n",
    "                self.choice = choice \n",
    "                break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's make two instances of our Contestant class: one that always switches when given the choice, and one that never switches. We'll use these instances throughout the rest of our program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "always_switches = Contestant(True)\n",
    "never_switches = Contestant(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our test doors are already open, so let's generate another set of test doors that are closed to make sure our \"make_choice\" and \"switch_choice\" methods work as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Door 1, Door 2, Door 3]\n"
     ]
    }
   ],
   "source": [
    "test_doors2 = generate_random_doors(possible_outcomes)\n",
    "print(test_doors2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have one of our contestants make a choice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Door 3\n"
     ]
    }
   ],
   "source": [
    "always_switches.make_choice(test_doors2)\n",
    "print(always_switches.choice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we have our list of doors, and our contestant has made their choice. We need to simulate the hosts actions in the next step. One of the keys to understanding this puzzle is that the host knows where the car is, and will not open the door with the car behind it. The host will also not open the door that our contestant has picked, and will only open one door. Let's write a quick function to simulate those actions by generating a random index from our list of doors and checking to see if the door at that index meets both of our conditions. If it doesn't, we recursively call the function until the random index <i>does</i> meets both our conditions, and open the door."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Door 1: goat, Door 2, Door 3]\n"
     ]
    }
   ],
   "source": [
    "def open_a_door(list_of_doors, contestant):\n",
    "    rand_index = random.randint(0, (len(list_of_doors)-1))\n",
    "    if list_of_doors[rand_index] != contestant.choice and list_of_doors[rand_index].behind != 'car':\n",
    "            list_of_doors[rand_index].open_door()\n",
    "    else:\n",
    "        open_a_door(list_of_doors, contestant)\n",
    "open_a_door(test_doors2, always_switches)\n",
    "print(test_doors2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking good! Our contestant made their selection, and our virtual host has opened one of the doors that they didn't choose to reveal a goat. Now, let's make sure our switch_choice method works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Door 2\n"
     ]
    }
   ],
   "source": [
    "always_switches.switch_choice(test_doors2)\n",
    "print(always_switches.choice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excellent! At this point we've simulated the entire gameplay, and whether the contestant wins or loses is determined by what's behind their door at this stage. Let's put all this functionality into one function that will return a boolean \"True\" if the contestant has chosen the door with the car behind it, and \"False\" otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_game(contestant, possible_outcomes):\n",
    "    new_doors = generate_random_doors(possible_outcomes)\n",
    "    contestant.make_choice(new_doors)\n",
    "    open_a_door(new_doors, contestant)\n",
    "    if contestant.always_switches == True:\n",
    "        contestant.switch_choice(new_doors)\n",
    "    if contestant.choice.behind == 'car':\n",
    "        return True\n",
    "    else:\n",
    "        return False "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can simply use our play_game function to simulate the entire game, and have either True or False as a result if the contestant has won or lost. You can run the cell below a few times and watch the output change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_game(always_switches, possible_outcomes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's write a function that uses our play_game function, plays it some N number of times based on the input, logs the result to a list and returns that list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_game_n_times(n, contestant, possible_outcomes):\n",
    "    result_list = []\n",
    "    while len(result_list) < n:\n",
    "        result_list.append(play_game(contestant, possible_outcomes))\n",
    "    return result_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make sure this function is working correctly by printing out the result of playing the game 10 times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "ten_results = play_game_n_times(10, always_switches, possible_outcomes)\n",
    "for result in ten_results:\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fantastic! Now, let's simulate playing the game 1,000 times for both of our options: always switching and never switching, using both the Contestants we instantiated earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_thousand_switches = play_game_n_times(1000, always_switches, possible_outcomes)\n",
    "one_thousand_stays = play_game_n_times(1000, never_switches, possible_outcomes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each of these variables contains a list of 1,000 results of playing the game. Let's count them up and print out the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of switch wins: 674\n",
      "Number of switch losses: 326\n",
      "Number of stay wins: 334\n",
      "Number of stay losses: 666\n"
     ]
    }
   ],
   "source": [
    "switch_wins = 0\n",
    "switch_losses = 0\n",
    "\n",
    "stay_wins = 0\n",
    "stay_losses = 0\n",
    "\n",
    "for result in one_thousand_switches:\n",
    "    if result:\n",
    "        switch_wins += 1\n",
    "    else:\n",
    "        switch_losses += 1\n",
    "        \n",
    "for result in one_thousand_stays:\n",
    "    if result:\n",
    "        stay_wins += 1\n",
    "    else:\n",
    "        stay_losses += 1\n",
    "        \n",
    "print(\"Number of switch wins: {}\".format(switch_wins))\n",
    "print(\"Number of switch losses: {}\".format(switch_losses))\n",
    "\n",
    "print(\"Number of stay wins: {}\".format(stay_wins))\n",
    "print(\"Number of stay losses: {}\".format(stay_losses))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point I think it's safe to say we've established a pretty clear pattern. Switching is clearly the winning strategy, winning about 2/3 the time, (666/1000) and not switching the contestant only wins about 1/3 of the time (333/1000)."
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}