02_probability.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to the Dark Art of Coding:\n",
    "## Introduction to Data Science Fundamentals\n",
    "Basic Probability\n",
    "\n",
    "\n",
    "<img src='images/logos.3.600.wide.png' height='250' width='300' style=\"float:right\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main objectives\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will be able to:\n",
    "\n",
    "* Understand how to calculate probabilities of dependent and independent events\n",
    "* Explore probabilities using Venn diagrams\n",
    "* Explore probabilities using Probability Trees\n",
    "* Understand the principles behind the Law of Total Probability AND Bayes' Theorem\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculating the probability of an event\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of definitions of probability... let's use one found in **Statistics in a Nutshell** (Sarah Boslaugh):\n",
    "\n",
    "*\"... probability tells us how often something is likely to occur when an experiment is repeated...\"*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definitions\n",
    "\n",
    "To get started, let's put together some additional definitions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trials (or experiments or observations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **trial** is an event whose outcome is unknown\n",
    "\n",
    "Trials can be very simple OR extremely complex:\n",
    "\n",
    "* simple as flipping a coin or rolling a dice\n",
    "* complex as determining whether someone with a low birth weight is gonna graduate college 22 years later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sample space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **sample space**, often signified by an `S` is a set of **all possible outcomes** of a trial.\n",
    "\n",
    "Thus, if our trial is a single roll of a six-sided die, then the sample space will be:\n",
    "\n",
    "`S = {1, 2, 3, 4, 5, 6}`\n",
    "\n",
    "AND if our trial is choosing a coin from a bag, then the sample space might be:\n",
    "\n",
    "`S = {quarter, dime, nickel, penny}`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An **Event** specifies the outcome of a trial. Events can be the outcome of a single trial OR a set of outcomes.\n",
    "\n",
    "Events are often designated with an `E`.\n",
    "\n",
    "For example, if we roll a die and want to specify our event to be that we get a one (1), then our event might be defined:\n",
    "\n",
    "`E = {1}`\n",
    "\n",
    "Similarly, if we want to specify our event to be that we get an even number, then our event might be defined:\n",
    "\n",
    "`E = {2, 4, 6}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating a probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To calculate a simple probability of an event, labeled `P(E)`, we divide the number of ways of getting the event, `n(E)` by the number of elements in the sample space, `n(S)`.\n",
    "\n",
    "$\\Large P(E) = \\frac{n(E)}{n(S)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, if we calculate the probability of rolling a `1` on a six sided die...\n",
    "\n",
    "```\n",
    "E = {1}\n",
    "S = {1, 2, 3, 4, 5, 6}\n",
    "\n",
    "\n",
    "n(E) = 1      # number of ways to get the event\n",
    "n(S) = 6      # number of elements in the sample space\n",
    "\n",
    "P(E) = 1 / 6\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using python to calculate some probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a simple function that allows us to calculate a simple probability of getting a `1` when we roll a six-sided die.\n",
    "\n",
    "NOTE: in the gaming community, die are often referred to with the prefix `d` and the number of sides:\n",
    "* d6 for a six-sided die\n",
    "* d8 for an eight-sided die\n",
    "* etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_on_a_d6():\n",
    "    '''Return the probability of rolling a 1 on a d6'''\n",
    "    \n",
    "    return 1 / 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_on_a_d6()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can imagine, this is pretty limited. So let's put together a function that is a bit more capable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def probability(sample_size, event):\n",
    "    '''Return the probability of an event given the event and the sample size.\n",
    "    NOTE: the event can only be composed of a single element.'''\n",
    "    \n",
    "    count = 1\n",
    "    return count / sample_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Presuming that our event is to roll a `4` on a six-sided die..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "probability(sample_size=6, event=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The astute observer would notice that... `event` didn't really do anything in our function, since we were focused on the probability of only one event occurring.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What about multiple elements in an event?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we wanted to calculate the probability of rolling a `1, 2, or 3`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you recall, our probability formula alluded to the fact that we can calculate the probability of an event w/ multiple elements. To calculate this probability labeled `P(E)`, we use the same formula and divide the number of ways of getting the event, `n(E)` by the number of elements in the sample space, `n(S)`.\n",
    "\n",
    "$\\Large P(E) = \\frac{n(E)}{n(S)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, if we calculate the probability of rolling a `1, 2, or 3` on a six-sided die, since there are 3 elements in our event.\n",
    "\n",
    "```\n",
    "n(E) = 3      # number of ways to get the event\n",
    "n(S) = 6      # number of elements in the sample space\n",
    "\n",
    "P(E) = 3 / 6 = 0.5\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our previous function presumed we were only looking at a single element out of a sample space and thus used a hard coded value of `1` as our `count` for the number of elements in the event. That function doesn't help us if we have multiple elements in our event. Let's look at the probability of rolling a `1, 2, or 3`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "event = [1, 2, 3]\n",
    "\n",
    "def probability(sample_size, event=event):\n",
    "    '''Return the probability of an event given the event and the sample size.\n",
    "    The event may be composed of either a single element OR multiple elements (i.e. \n",
    "    a tuple OR list).\n",
    "    '''\n",
    "        \n",
    "    if isinstance(event, (list, tuple)):\n",
    "        count = len(event)\n",
    "    else:\n",
    "        count = 1\n",
    "    return count / sample_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For simplicity, let's alias our function as `P`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = probability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We want to make sure this works in the base case of a single element in a event\n",
    "# i.e. rolling a two on a six-sided die\n",
    "\n",
    "P(6, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# probability of rolling a four, five OR a six on a six-sided die\n",
    "\n",
    "P(6, [4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# probability of rolling an odd number on a six-sided die\n",
    "\n",
    "P(6, [1, 3, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Venn diagrams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Venn diagrams are often used to represent elements in a sample space using simple pictures:\n",
    "    \n",
    "This might be a representation of rolling the odd numbers on a d10:\n",
    "\n",
    "**NOTE**: \n",
    "\n",
    "* When dealing with Venn diagrams, typically the rectangle represents all possible values.\n",
    "* Values in the circles/ellipses are values that you are interested in.\n",
    "* For convenience, I explictly stated that the rectangle holds all the other values, but eventually, I will stop doing so (as that is generally a given).\n",
    "    \n",
    "<img src='images/venn_odd.jpg' height='600' width='600'>    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experience Points\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete the following exercises:\n",
    "\n",
    "It may be useful to create a Venn Diagram to help you characterize the Sample Space and the Event."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A**. Use Python to calculate the probability of rolling a 20 on a d20. To help you, we suggest some inputs representing the element(s) in the event and elements in the sample space.\n",
    "\n",
    "$E = 1$\n",
    "\n",
    "$S = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}$\n",
    "\n",
    "$\\large P(E) = \\frac{n(E)}{n(S)}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**B**. Use Python to calculate the probability of rolling an even number on a d10. To help you, we suggest some inputs representing the element(s) in the event and elements in the sample space.\n",
    "\n",
    "$E = \\{2, 4, 6, 8, 10\\}$\n",
    "\n",
    "$S = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10\\}$\n",
    "\n",
    "$\\large P(E) = \\frac{n(E)}{n(S)}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**C**. Use Python to calculate the probability of picking an Ace from a standard 52-card deck. To help you, we suggest some inputs representing the element(s) in the event and elements in the sample space.\n",
    "\n",
    "As a shortcut, we will represent the cards using this nomenclature:\n",
    "\n",
    "Ace = A, King = K, Queen = Q, Jack = J, numbered cards are represented by number\n",
    "\n",
    "Club = C, Spade = S, Diamond = D, Heart = H\n",
    "\n",
    "Some example cards would be:\n",
    "\n",
    "* Ace of Spades: AS\n",
    "* King of Hearts: KH\n",
    "* Queen of Clubs: QC\n",
    "* Ten of Diamonds: 10D\n",
    "* Nine of Spades: 9S\n",
    "\n",
    "Thus... our Event and Sample Space would look like this:\n",
    "\n",
    "$E = \\{AC, AS, AD, AH\\}$\n",
    "\n",
    "$S = \\{2C, 3C, 4C, 5C, 6C, 7C, 8C, 9C, 10C, JC, QC, KC, AC, \\\\\n",
    "   \\phantom{=} 2S, 3S, 4S, 5S, 6S, 7S, 8S, 9S, 10S, JS, QS, KS, AS, \\\\\n",
    "\\phantom{=} 2D, 3D, 4D, 5D, 6D, 7D, 8D, 9D, 10D, JD, QD, KD, AD, \\\\\n",
    "\\phantom{=} 2H, 3H, 4H, 5H, 6H, 7H, 8H, 9H, 10H, JH, QH, KH, AH\\}$\n",
    "\n",
    "$\\large P(E) = \\frac{n(E)}{n(S)}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**D**. Use Python to calculate the probability of a day in May 2018 falling a weekend. Practice figuring out what the Event looks like and the Sample Space looks like. Use your answers to calculate the probability.\n",
    "\n",
    "$E = ?$\n",
    "\n",
    "$S = ?$\n",
    "\n",
    "$\\large P(E) = \\frac{n(E)}{n(S)}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**E**. Use Python to calculate the probability of rolling an even number on a d10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**F**. Use Python to calculate the probability of drawing a face card (Jack, Queen, King) from a deck of cards that includes not only the standard 52 cards, but two jokers, as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you (and your partner, if you're working in pairs) are done, then you can put your green sticky up! This is how we know you're done.\n",
    "\n",
    "<img src='images/green_sticky.300px.png' width='200' style='float:left'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exclusive events and intersections\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As noted above, sometimes events are exclusive and adding their probabilities works as expected.\n",
    "\n",
    "In other cases, events are not exclusive (i.e. they have some degree of overlap or intersection) and thus simply adding the probabilities together doesn't work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exclusive events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a simple example of a pair of exclusive events:\n",
    "\n",
    "On a d10, what is the probability of rolling an even number OR and odd number?\n",
    "\n",
    "$P(even) = 0.5$\n",
    "\n",
    "$P(odd) = 0.5$\n",
    "\n",
    "$P(even \\ OR \\ odd) = 1.0 \\ (i.e. \\ this \\ outcome \\ is \\ guaranteed)$\n",
    "\n",
    "**NOTE**: you can't get higher than a **1.0** when calculating probabilities. Probabilities range from **zero** (it will not happen) to **one** (it will happen, guaranteed).\n",
    "\n",
    "<img src='images/venn_exclusive.jpg' height='600' width='600'> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intersecting events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the probability you roll a number higher than 5 OR roll an even number on a d10. Let's start by creating our Event sets...\n",
    "    \n",
    "$E(greater\\_than\\_five) = \\{6, 7, 8, 9, 10\\}$\n",
    "\n",
    "$E(even) = \\{2, 4, 6, 8, 10\\}$\n",
    "\n",
    "$S = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10\\}$\n",
    "\n",
    "<img src='images/venn_intersection.jpg' height='600' width='600'> \n",
    "\n",
    "\n",
    "\n",
    "$P(greater\\_than\\_five) = \\frac{5}{10} = 0.5$\n",
    "\n",
    "$P(even) = \\frac{5}{10} = 0.5$\n",
    "\n",
    "Which implies that ...\n",
    "\n",
    "$P(greater\\_than\\_five \\ OR \\ even) = 1.0$\n",
    "\n",
    "...which is clearly not correct. The **correct answer is**: \n",
    "\n",
    "$P(greater\\_than\\_five \\ OR \\ even) = \\frac{7}{10} = 0.7$\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wait, what went wrong?\n",
    "\n",
    "Why does this fail? Because the formula we used previously for calculating exclusive events did not take into account overlap OR intersection:\n",
    "\n",
    "$E(greater\\_than\\_five \\ OR \\ even) = \\{2, 4, 6, 7, 8, 9, 10\\}$\n",
    "\n",
    "The generic formula for this is:\n",
    "\n",
    "\n",
    "$\\large P(A \\ \\cup \\ B) = \\frac{n(A) \\ + \\ n(B) \\ - \\ n(A \\cap B)}{n(S)}$    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the formula above, the intersection between two events is symbolized by this shape:\n",
    "\n",
    "$\\Large \\cap$\n",
    "\n",
    "And thus the intersection (or overlapping portion in a Venn diagram) is represented by:\n",
    "\n",
    "$\\large n(A \\cap B)$\n",
    "\n",
    "Similarly, the union between two events is symbolized by this shape:\n",
    "\n",
    "$\\Large \\cup$\n",
    "\n",
    "And thus the union in the formula is represented by:\n",
    "\n",
    "$\\large n(A \\cup B)$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this in mind, our previous calculation looks more like this:\n",
    "    \n",
    "$\\large P(A \\ \\cup \\ B) = \\frac{n(A) \\ + \\ n(B) \\ - \\ n(A \\cap B)}{n(S)}$   \n",
    "\n",
    "$\\large P(A \\ \\cup \\ B) = \\frac{5 \\ + \\ 5 \\ - \\ 3}{10} = \\frac{7}{10}$\n",
    "\n",
    "$\\large P(A \\ \\cup \\ B) = 0.7$\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting this into practice\n",
    "\n",
    "Let's explore this a bit using our Python function:\n",
    "\n",
    "What is the probability of rolling greater than a 5 on a d10 OR rolling an even number?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = P(10, [6, 7, 8, 9, 10]) + P(10, [2, 4, 6, 8, 10]) - P(10, [6, 8, 10])\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the probability of drawing a red card from a standard deck OR drawing a King?\n",
    "\n",
    "As you can imagine, this becomes problematic as our sample size grows..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "answer = P(52, ['AD', '2D', '3D', '4D', ...]) + P(52, ['KS', 'KC', 'KD', 'KH']) - P(52, ['KD', 'KH'])\n",
    "print(answer)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get around this, we can alter our probability function... to simply allow us to input the size of our event space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def probability(sample_size, event=None, event_size=None):\n",
    "    '''Return the probability of an event given the event and the sample size.\n",
    "    \n",
    "    event: the event argument may be composed of either\n",
    "    * multiple elements (i.e. a tuple OR list) (which are then counted) OR\n",
    "    * a single element which is equated internally to a count of one\n",
    "    \n",
    "    event_size: As an alternative to providing an event, you can simply provide your own count using\n",
    "    the event_size argument:\n",
    "    * an integer representing the number of elements in an event.\n",
    "    \n",
    "    Only one of these two (event OR event_size) should be provided.\n",
    "    \n",
    "    '''\n",
    "        \n",
    "    if isinstance(event, (list, tuple)):\n",
    "        count = len(event)\n",
    "    elif isinstance(event_size, int):\n",
    "        count = event_size\n",
    "    else:\n",
    "        count = 1\n",
    "    return count / sample_size\n",
    "\n",
    "# Again, let's provide an alias for our probability function...\n",
    "\n",
    "P = probability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# red card\n",
    "# OR\n",
    "# king\n",
    "\n",
    "answer = P(52, event_size=26) + P(52, event_size=4) - P(52, event_size=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a sanity check... let's take a quick look at the each of the components of the formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('P(red)', P(52, event_size=26))\n",
    "print('P(king)', P(52, event_size=4))\n",
    "print('P(red kings)', P(52, event_size=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So, what is the answer?\n",
    "\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's try it again...\n",
    "\n",
    "What is the probability of drawing a red card from a standard deck OR drawing a face card (King, Queen, Jack)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = P(52, event_size=26) + P(52, event_size=12) - P(52, event_size=6)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If the problem is simple enough to do the arithmetic in your head, then that is fine, too:\n",
    "\n",
    "# 26 + 12 - 6 = 32\n",
    "\n",
    "P(52, event_size=32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine the 46 players in your board game group have favorite games in the following categories:\n",
    "    \n",
    "* pandemic ONLY (12 players)\n",
    "* pandemic AND carcassonne (6)\n",
    "* carcassonne ONLY (16)\n",
    "* carcassonne AND clank! (4)\n",
    "* clank! ONLY (8)\n",
    "\n",
    "<img src='images/venn_games.jpg' height='600' width='600'> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the probability of finding a **pandemic** player or a **carcassonne** player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = P(46, event_size=18) + P(46, event_size=26) - P(52, event_size=6)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the probability of finding a **carcassonne** player or a **clank!** player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = P(46, event_size=34)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experience Points\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete the following exercises:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A**. Use Python to calculate the probability of drawing a Black card OR an Ace, King, Queen, Jack, or 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**B**. Use Python to calculate the probability of drawing a Diamond card OR an odd numeric card (3, 5, 7, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**C**. Use Python to calculate the probability of drawing a Diamond or Spade card OR a numeric card (2 - 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you (and your partner, if you're working in pairs) are done, then you can put your green sticky up! This is how we know you're done.\n",
    "\n",
    "<img src='images/green_sticky.300px.png' width='200' style='float:left'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditionals\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another level of understanding probability is to be able to evaluate the probability of an event given some other condition.\n",
    "\n",
    "* What is the probability that a given card is a King if you know that it is black?\n",
    "* What is the probability that you roll a 10 if you know that the number rolled was even?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Probability Trees\n",
    "While Venn Diagrams were useful to help us solve the previous questions, an alternate visualization (a probability tree) is often useful to answer questions like this.\n",
    "\n",
    "In this case, we create a probability tree that has two-levels of branches.\n",
    "\n",
    "* The first level (on the left) shows the probability that a given card is Red or Black\n",
    "* The second level (on the right) then shows the probabilities that a card is a King or Not a King for each branch on the first level\n",
    "\n",
    "**NOTE**: here, each set of level branches happens to be binary (with only two branches (i.e. red/black)) but levels could have more options.\n",
    "\n",
    "For example, the squares on a roulette table might be red, black, and green.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_black_king.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To solve for the total probability across any single branch, we multiple the probability of the first level of an extended branch by the probability of the second level of that branch. For example, if we want to determine the probability of a card being a King and Black:\n",
    "\n",
    "$\\Large \\frac{26}{52} \\times \\frac{2}{26} = 0.03846$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can test this using our probability formula:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P(52, event_size=26) * P(26, event_size=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other branches play out similarly:\n",
    "\n",
    "\n",
    "Black and Not a King: $\\Large \\frac{26}{52} \\times \\frac{24}{26} = 0.46153$\n",
    "\n",
    "Red and King: $\\Large \\frac{26}{52} \\times \\frac{2}{26} = 0.03846$\n",
    "\n",
    "Red and Not a King: $\\Large \\frac{26}{52} \\times \\frac{24}{26} = 0.46153$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sum of the probabilities for any set of branches is always 1.0 (accounting for rounding errors).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(sum([0.03846, 0.46153, 0.03846, 0.46153]), 3) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generically speaking "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the diagram above, we see that our probabilities are defined as binary conditionals. This is so common, that there is a special syntax for it.\n",
    "\n",
    "$B$ stands for all elements in B\n",
    "\n",
    "$B^\\prime$ stands for all elements NOT in B\n",
    "\n",
    "\n",
    "and \n",
    "\n",
    "$P(B)$ stands for the probability of event B\n",
    "\n",
    "$P(B^\\prime)$  stands for the probability of NOT getting event B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this in mind, we can genericize the above probability tree, where the syntax:\n",
    "\n",
    "$P(A|B)$ stands for probability of A, given B.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_B_A.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This leads to the formula:\n",
    "    \n",
    "$\\Large P(A|B) = \\frac{P(A \\cap B)}{P(B)}$\n",
    "\n",
    "which can be algebraically rearranged to read:\n",
    "\n",
    "$\\Large P(A \\cap B) = P(A|B) \\times P(B)$\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rules for probability trees:\n",
    "\n",
    "Those formula, along with **four rules** will help us calculate probabilities using probability trees:\n",
    "\n",
    "1. Define each level of the tree\n",
    "1. Fill in any facts that you have\n",
    "1. Complete branch groups based on the fact that a set of branches will always sum to 1\n",
    "1. Apply the formula $ P(A|B) = \\frac{P(A \\cap B)}{P(B)}$ to determine remaining probabilities\n",
    "    \n",
    " \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's work through an example:\n",
    "\n",
    "What are the probabilities associated with each of the branches given that some of the folks in your company:\n",
    "\n",
    "* eat burgers OR don't eat burgers\n",
    "* eat dessert OR don't eat dessert\n",
    "\n",
    "We are given three initial facts to get us started:\n",
    "\n",
    "* $P(burger) = \\frac{2}{3}$ \n",
    "* $P(dessert \\ | \\ burger^\\prime) = \\frac{1}{4}$\n",
    "* $P(burger \\cap dessert) = \\frac{8}{15}$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_burger_dessert_1.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we start to apply the values we know and take advantage of the fact that each pair of branches must sum to 1.0, we get the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_burger_dessert_2.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From there, we know that the `burger - dessert` branch has a total probability of 8/15. \n",
    "\n",
    "$\\large P(dessert \\cap burger) = P(dessert \\ | \\ burger) \\times P(burger)$\n",
    "\n",
    "$\\large \\frac{8}{15} = P(dessert \\ | \\ burger) \\times \\frac{2}{3}$\n",
    "\n",
    "$\\large \\frac{8}{15} \\times \\frac{3}{2} = P(dessert \\ | \\ burger)$\n",
    "\n",
    "\n",
    "$\\large \\frac{4}{5} = P(dessert \\ | \\ burger)$\n",
    "\n",
    "We can the plug in this value and then calculate the value of the opposite branch based on the fact that they sum to 1.0.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_burger_dessert_3.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From there, we can multiply each probability for each branch of the tree:\n",
    "\n",
    "GIVEN: $\\frac{2}{3} \\times \\frac{4}{5} = \\frac{8}{15} = 0.53333$\n",
    "\n",
    "$\\frac{2}{3} \\times \\frac{1}{5} = \\frac{2}{15} = 0.13333$\n",
    "\n",
    "$\\frac{1}{3} \\times \\frac{1}{4} = \\frac{1}{12} = 0.08333$\n",
    "\n",
    "$\\frac{1}{3} \\times \\frac{3}{4} = \\frac{3}{12} = 0.25$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_burger_dessert_4.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And we can see that all the branches sum to one.\n",
    "branch1 = P(3, event_size=2) * P(5, event_size=4) \n",
    "branch2 = P(3, event_size=2) * P(5, event_size=1) \n",
    "branch3 = P(3, event_size=1) * P(4, event_size=1) \n",
    "branch4 = P(3, event_size=1) * P(4, event_size=3) \n",
    "\n",
    "round(sum([branch1, branch2, branch3, branch4]), 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experience Points\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete the following exercises:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A**. Fill out the empty probabilities on this probability tree and then use Python to ensure that the probability for all the branches sums to 1.0. \n",
    "\n",
    "You are given data related to the probability that a staff member is right OR left-handed and whether a staff member is a programmer OR not.\n",
    "\n",
    "In addition, you are provided the following empty probability tree and these initial values:\n",
    "\n",
    "* $P(left) = \\frac{1}{10}$ \n",
    "* $P(programmer^\\prime \\ | \\ left) = \\frac{7}{9}$\n",
    "* $P(right \\cap programmer^\\prime) = \\frac{54}{70}$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_blank_1.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**B**. Create a probability tree given the following information... about a study on chimpanzees and gorillas and their respective right/left-handedness. Then solve for the remaining probability values.\n",
    "\n",
    "* $P(chimp) = \\frac{13}{19}$ \n",
    "* $P(chimp \\cap left) = \\frac{26}{171}$\n",
    "* $P(left \\ | \\ gorilla) = \\frac{1}{11}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you (and your partner, if you're working in pairs) are done, then you can put your green sticky up! This is how we know you're done.\n",
    "\n",
    "<img src='images/green_sticky.300px.png' width='200' style='float:left'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Law of total probability and Bayes Theorem\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we looked at the above probability trees, we were fairly easily able to determine the probability of one item given a condition, i.e.:\n",
    "\n",
    "* What is the probability that someone eats a dessert given the fact that they ate a burger:\n",
    "\n",
    "$P(dessert \\ | \\ burger)$\n",
    "\n",
    "The big question becomes can we reverse that question to answer:\n",
    "\n",
    "* What is the probability that someone ate a burger, given that they ate a dessert?\n",
    "\n",
    "$P(burger \\ | \\ dessert)$\n",
    "\n",
    "This becomes trickier, because if we are given the probability that someone ate dessert, we have to back our solution out of the fact that there are two categories of dessert eaters, but only one is related to the burger eater."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_burger_dessert_1.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Law of Total Probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a principle called the **Law of Total Probability** that can help us get an answer to this question.\n",
    "\n",
    "Let's presume we want to solve the problem:\n",
    "\n",
    "$\\large P(burger \\ | \\ dessert)$\n",
    "\n",
    "We know from our previous explorations that to calculate the probability of a burger given a dessert is: \n",
    "\n",
    "$\\large P(burger \\ | \\ dessert) = \\frac{P(burger \\ \\cap \\ dessert)}{P(dessert)}$ \n",
    "\n",
    "We know that the intersection of burger and dessert can be found using this formula:\n",
    "\n",
    "$\\large P(burger \\ \\cap \\ dessert) = P(dessert \\ | \\ burger) \\times P(burger)$ \n",
    "\n",
    "which simply allows us to calculate the probability for a specific branch (it calculates the intersection of non-independent events)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then substitute this into our formula:\n",
    "\n",
    "$\\large P(burger \\ | \\ dessert) = \\frac{P(dessert \\ | \\ burger) \\ \\times \\ P(burger)}{P(dessert)}$ \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can solve readily for each of the elements on the right, except the $P(dessert)$\n",
    "\n",
    "The total probability of getting a dessert is based on both branches that end in dessert:\n",
    "\n",
    "$\\large P(dessert) =  P(burger \\ \\cap \\ dessert) + P(burger^\\prime \\ \\cap \\ dessert)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we substitute for each of the intersections... we get the following formula known as the **Law of Total Probability**\n",
    "\n",
    "$\\large P(dessert) =  P(dessert \\ | \\ burger) \\times P(burger) + P(dessert \\ | \\ burger^\\prime) \\times P(burger^\\prime)$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bayes' Theorem (Bayes' Formula)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To take us the rest of the way to our answer, we use the formula referred to as Bayes' Theorem.\n",
    "\n",
    "Substituting again, we get the following formula known as **Bayes' Theorem**:\n",
    "\n",
    "$\\large P(burger \\ | \\ dessert) = \\frac{P(dessert \\ | \\ burger) \\ \\times \\ P(burger)}{P(dessert \\ | \\ burger) \\ \\times \\ P(burger) \\ + \\ P(dessert \\ | \\ burger^\\prime) \\ \\times \\ P(burger^\\prime)}$ \n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's put Bayes' Theorem to the test:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A common use for Bayes' Theorem is the detection of spam messages in email OR comments OR social media.\n",
    "\n",
    "As a spam classifier looks at a message, it evaluates for the presence of certain key words (Viagra, get rich, etc). \n",
    "\n",
    "Each message will be classified as Spam OR Not Spam.\n",
    "\n",
    "NOTE: for each message that gets categorized as Spam, it may have certain keywords, it may not. Similarly, some messages that are categorized as Not Spam may also have Keywords OR Not.\n",
    "\n",
    "For example, a message from your friend about a book \"Get Rich Slowly\" wouldn't be considered spam.\n",
    "\n",
    "Our **question** in this case will be:\n",
    "\n",
    "* Given that a spam Keyword is found in a message, what is the probability that it is classified as Not Spam?\n",
    "\n",
    "$\\large P(Not \\ Spam \\ | \\ Keyword)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_spam_1.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the probabilities:\n",
    "    \n",
    "* $P(spam^\\prime) = \\frac{7}{10}$ \n",
    "* $P(keyword \\ | \\ spam^\\prime) = \\frac{1}{10}$    \n",
    "* $P(spam \\cap keyword^\\prime) = \\frac{3}{100}$\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can build up this probability tree in the same way we have done other trees:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_spam_2.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Continuing our calculations, we can finish all the individual levels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_spam_3.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ultimately, we calculate all the branches:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/probtree_spam_4.jpg' width='600' >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\large P(Spam^\\prime | \\ Keyword) = \\frac{P(Keyword \\ | \\ Spam^\\prime) \\ \\times \\ P(Spam^\\prime)}{P(Keyword \\ | \\ Spam^\\prime) \\ \\times \\ P(Spam^\\prime) \\ + \\ P(Keyword \\ | \\  Spam) \\ \\times \\ P(Spam)}$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = ((P(10, event_size=1) * P(10, event_size=7))/\n",
    "          (P(10, event_size=1) * P(10, event_size=7) + P(10, event_size=9) * P(10, event_size=3)))\n",
    "    \n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experience Points\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete the following exercises:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A**. Bayes: Game A vs Game B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Presume that we are a board game designer and we create two slightly different versions of a game. Our testers are given free agency to choose the version they want to try (Game A or Game B). Based on their game play experience, the testers rank the game in two categories: **Buy** vs **Don't Buy**.\n",
    "\n",
    "We get a chance to chat with one of our testers and ask how they rated the game. They enthusiastically claimed the game was a **Buy**. Given a rating of Buy, what is the probability that the tester chose to play version B?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* $P(GameB) = \\frac{13}{19}$ \n",
    "* $P(GameB \\cap Not Buy) = \\frac{26}{171}$\n",
    "* $P(Buy \\ | \\ GameA) = \\frac{10}{11}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on these probabilities, let's calculate: \n",
    "\n",
    "$\\large P(Game B \\ | \\ Buy) = \n",
    "  \\frac{P(Buy \\ | \\ Game B) \\ \\times \\ P(Game B)}\n",
    "       {P(Buy \\ | \\ Game B) \\ \\times \\ P(Game B) \\ + \\ P(Buy \\ | \\ Game B^\\prime) \\ \\times \\ P(Game B^\\prime)}$\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you (and your partner, if you're working in pairs) are done, then you can put your green sticky up! This is how we know you're done.\n",
    "\n",
    "<img src='images/green_sticky.300px.png' width='200' style='float:left'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Independent events versus dependent events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In probability, some events are considered independent and other events are considered dependent. How do we tell the difference?\n",
    "\n",
    "||Definition|Examples|\n",
    "|--- |:--- |:--- |\n",
    "|Independent|Events do not affect each other|Two sequential flips of the same coin|\n",
    "|||Drawing two cards out of a deck, replacing the card between draws|\n",
    "|||Different rolls of a die|\n",
    "|Dependent|One event impacts the probability of the second event|Pulling multiple shoes from a closet until find a pair|\n",
    "|||Plucking one marble from a jar and then taking a second (w/o replacement)|\n",
    "|||Drawing straws to see who washes the dishes|\n",
    "||||\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experience Points\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complete the following exercises:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Events|Dependent|Independent|\n",
    "|:---|:---|:---|\n",
    "|Draw a Heart from a deck followed by a Heart (w/ replacement)|||\n",
    "|Roll an Even on one die and Odd on another die|||\n",
    "|Roll an Even on one die and Even on another die|||\n",
    "|Pull earrings out of box until you get a matched pair (w/ replacement)|||\n",
    "|Eat a Jelly Belly Jelly Bean from a jar followed by a second Jelly Bean|||\n",
    "|Pull socks out of drawer until you get a matched pair (w/o replacement)|||\n",
    "|Draw a Heart from a deck followed by a King (w/o replacement)|||\n",
    "|Draw a Red card from a deck followed by a Black card (w/ replacement)|||\n",
    "||||\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you (and your partner, if you're working in pairs) are done, then you can put your green sticky up! This is how we know you're done.\n",
    "\n",
    "<img src='images/green_sticky.300px.png' width='200' style='float:left'>"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}