Statistical_Simulation_in_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Statistical Simulation in Python\n",
    "\n",
    "Simulations are a class of computational algorithms that use the relatively simple idea of random sampling to solve increasingly complex problems. Although they have been around for ages, they have gained in popularity recently due to the rise in computational power and have seen applications in multiple domains including Artificial Intelligence, Physics, Computational Biology and Finance just to name a few. Students will use simulations to generate and analyze data over different probability distributions using the important NumPy package. This course will give students hands-on experience with simulations using simple, real-world applications.\n",
    "\n",
    "## Basics of randomness & simulation\n",
    "### Introduction to random variables\n",
    "\n",
    "Simulations are a powerful and practical tool for solving a wide variety of data science problems.\n",
    "* Basics of randomness & simulation .\n",
    "* Simulation & probability.\n",
    "* Bootstrapping and resampling methots.\n",
    "* Advances application of simulation.\n",
    "\n",
    "A random variable is a quantity that can take an multiple values based on random choice.\n",
    "\n",
    "**Continues random variable** When the value can take an infinitely many values, it is called a continious random  variable. such as height or weight. <br>\n",
    "**Discrete random variable** If the varibale only can take a finite set of values like the roll of six-sided die can have only one of six possible outcomes. It is called discrete random variable. \n",
    "\n",
    "### Probability distributions\n",
    "\n",
    "A probability distribution is a mappping from set of possible outcomes of random variable to the probability of observing that outcomes.\n",
    "\n",
    "Probability distributions tells you how likely you are to obserbe a given outcomes or set of outcomes. Probability distributions are eithrt random or discerete depending on the type of random variable they represent.\n",
    "\n",
    "*For continues variables*, the distributions is represented by a probability density function (PDF) an probability is defined over an interval like *normal distribution.*\n",
    "\n",
    "*For discerete variables*, the distributions is represented by a probability mass function (PMF) and probability can be defined a single point or interval like *bioimal or poisson distrubitions*. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normal Distribution \n",
    "\n",
    "**numpy.random.normal(loc=0.0, scale=1.0, size=None)** <br>\n",
    "**loc :** Mean (“centre”) of the distribution. <br>\n",
    "**scale :** Standard deviation (spread or “width”) of the distribution.<br>\n",
    "**size :** int or tuple of ints, optional\n",
    "\n",
    "Draws a random samples from a normal (Gaussian) distribution.\n",
    "\n",
    "The probability density function of the normal distribution, first derived by De Moivre and 200 years later by both Gauss and Laplace independently is often called the bell curve because of its characteristic shape. The probability density for the Gaussian distribution is\n",
    "\n",
    "\\begin{equation}\n",
    "p(x) = \\frac{1}{\\sqrt{2 \\pi \\sigma^2}} e^{\\frac{-(x-\\mu^2)}{2 \\sigma^2}}\n",
    "\\end{equation}\n",
    "\n",
    "where $\\mu$ is the mean and $\\sigma$ the standard deviation. The square of the standard deviation, $\\sigma^2$, is called the variance. The function has its peak at the mean, and its “spread” increases with the standard deviation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.318573791902771e-05 True\n",
      "0.0014223049493314321 True\n"
     ]
    }
   ],
   "source": [
    "# Draw samples from the distribution:\n",
    "mu, sigma = 0, 0.1 # mean and standard deviation\n",
    "s = np.random.normal(mu, sigma, 1000)\n",
    "# Verify the mean and the variance:\n",
    "print(abs(mu - np.mean(s)),abs(mu - np.mean(s)) < 0.01)\n",
    "print(abs(sigma - np.std(s, ddof=1)),abs(sigma - np.std(s, ddof=1)) < 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Display the histogram of the samples, along with the probability density function:\n",
    "count, bins, ignored =plt.hist(s, 30, density=True)\n",
    "plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) * np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n",
    "         linewidth=2, color='r')\n",
    "plt.title('Normal Distribution')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binomial Distribution\n",
    "**numpy.random.binomial(n, p, size=None)** <br>\n",
    "**n :** Parameter of the distribution, >= 0. Floats are also accepted, but they will be truncated to integers.<br>\n",
    "**p :** Parameter of the distribution, >= 0 and <=1.<br>\n",
    "**size :** int or tuple of ints, optional<br>\n",
    "Draw samples from a binomial distribution.\n",
    "Samples are drawn from a binomial distribution with specified parameters, n trials and p probability of success where n an integer >= 0 and p is in the interval [0,1]. \n",
    "\n",
    "The binomial distribution gives the discrete probability distribution $P_p(n|N)$ of obtaining exactly *n* successes out of *N* Bernoulli trials (where the result of each Bernoulli trial is true with probability *p* and false with probability *q=1-p*). The binomial distribution is therefore given by\n",
    "\n",
    "\\begin{equation}\n",
    "P_p(n|N) = \\binom{N}{n} p^n q^{N-n}\\\\\n",
    "= \\frac{N!}{n!(N-n)!} p^n (1-p)^{N-n}\n",
    "\\end{equation}\n",
    "\n",
    "where $\\binom{N}{n}$ is binomial coefficient whic is the number of ways of picking n unordered outcomes from N possibilities,also known as a combination \n",
    "\n",
    "**Bernoulli trials** An experiment in which *s* trials are made of an event, with probability *p* of success in any given trial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`A real world example. A company drills 9 wild-cat oil exploration wells, each with an estimated probability of success of 0.1. All nine wells fail. What is the probability of that happening?\n",
    "\n",
    "Let’s do 20,000 trials of the model, and count the number that generate zero positive results.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3812\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'0.384 or 38%'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial = np.random.binomial(9, 0.1, 20000)\n",
    "print(sum(binomial ==0)/20000)\n",
    "\"\"\"0.384 or 38%\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Poisson  Distribution\n",
    "\n",
    "**numpy.random.poisson(lam=1.0, size=None)***<br>\n",
    "**lam :** Expectation of interval, should be >= 0. A sequence of expectation intervals must be broadcastable over the requested size.\n",
    "**size :** int or tuple of ints, optional\n",
    "Draw samples from a Poisson distribution which is the limit of the binomial distribution for large N.\n",
    "\n",
    "Given a Poisson process, the probability of obtaining exactly n successes in N trials is given by the limit of a binomial distribution.\n",
    "\n",
    "For the poisson distribution:\n",
    "\\begin{equation}\n",
    "f(k;\\lambda) = \\frac{\\lambda^k e^{-\\lambda}}{k!}\n",
    "\\end{equation}\n",
    "\n",
    "For events with an expected separation $\\lambda$ the Poisson distribution f(k; $\\lambda$) describes the probability of k events occurring within the observed interval $\\lambda$.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "poisson = np.random.poisson(5, 10000)\n",
    "plt.hist(s, 14, density=True)\n",
    "plt.title('Poisson Distribution')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will learn how to draw samples from a probability distribution.In particular, we will draw samples from a very important discrete probability distribution, the Poisson distribution, which is typically used for modeling the average rate at which events occur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Lambda - sample mean| with 3 samples is 0.33333333333333304 \n",
      "|Lambda - sample mean| with 1000 samples is 0.07699999999999996. \n"
     ]
    }
   ],
   "source": [
    "#Initialize seed and parameters\n",
    "np.random.seed(123)\n",
    "lam, size_1, size_2 = 5,3,1000\n",
    "#Using np.random.poisson() draw samples from a Poisson distribution using lam (lambda) and size_1 \n",
    "sample_1 = np.random.poisson(lam, size_1)\n",
    "sample_2 = np.random.poisson(lam, size_2)\n",
    "\n",
    "#calculate the absolute difference between their mean and lambda using np.mean() and abs()\n",
    "answer_1 = abs(lam - sample_1.mean())\n",
    "answer_2 = abs(lam - sample_2.mean())\n",
    "print(\"|Lambda - sample mean| with {} samples is {} \\n|Lambda - sample mean| with {} samples is {}. \"\n",
    "      .format(size_1, answer_1, size_2, answer_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plt.hist(sample_1, density=True, alpha=0.7)\n",
    "_ = plt.hist(sample_2, density=True, alpha=0.7)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will learn another useful function - np.random.shuffle(). This function allows you to randomly shuffle a sequence in place. At the end of this exercise, you will know how to shuffle a deck of cards or any sequence of items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "deck_of_card =[('Heart', 0),('Heart', 1),('Heart', 2),('Heart', 3),('Heart', 4),('Heart', 5),('Heart', 6),\n",
    " ('Heart', 7),('Heart', 8),('Heart', 9),('Heart', 10),('Heart', 11),('Heart', 12),('Club', 0),('Club', 1), \n",
    " ('Club', 2),('Club', 3),('Club', 4),('Club', 5),('Club', 6),('Club', 7), ('Club', 8),('Club', 9),('Club', 10),\n",
    " ('Club', 11), ('Club', 12),('Spade', 0),('Spade', 1),('Spade', 2),('Spade', 3), ('Spade', 4), ('Spade', 5),\n",
    " ('Spade', 6),('Spade', 7),('Spade', 8),('Spade', 9),('Spade', 10),('Spade', 11),('Spade', 12),('Diamond', 0),\n",
    " ('Diamond', 1), ('Diamond', 2),('Diamond', 3),('Diamond', 4),('Diamond', 5), ('Diamond', 6), ('Diamond', 7),\n",
    " ('Diamond', 8), ('Diamond', 9), ('Diamond', 10),('Diamond', 11),('Diamond', 12)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Spade', 11), ('Heart', 10), ('Diamond', 1)]\n"
     ]
    }
   ],
   "source": [
    "np.random.shuffle(deck_of_card)\n",
    "print(deck_of_card[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation Basic\n",
    "\n",
    "Simulations is a frame work that allows us to model real=worl systems and processes. Simulations is typically chracterized by repeated randon sampling which means that we use the power of random variable to generate multiple outcomes . Simulations gives us approximate solutions. \n",
    "\n",
    "Simulatons steps.<br>\n",
    "    *1- Define the set of outcomes associated with a random variable.<br>\n",
    "    2- Assign a probability to each of these outcomes- the probability sitribitions.<br>\n",
    "    3- Define the relationship betweeen multiple random variables..<br>\n",
    "    4- Draw samples from the probability distributions..<br>\n",
    "    5- Anlyze the sample outcomes..<br>*\n",
    "\n",
    "For pactice, we will run a siple dice game. The dice game involves throwing two dice and winning if they show the same number. For the step 1&2 we first define the outcomes of the die and assing the probability to each outcomes.Since we have a fair dice, we can use the identical distrubitons so, it becomes uniform distributions. in step 3, we denine the relationship between the dice. if they shoe the same number we win, otherwise we lost. Step 1,2&3 gies us the statistical model underliying the simulation. -describing the model. We generate multiple outcomes though repeated random sampling.And then analyze the outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outcome of the throw: 1\n"
     ]
    }
   ],
   "source": [
    "# Define die outcomes and probabilities\n",
    "#Construct a six-sided die as a list of each of the possible outcomes and assign it to the variable die\n",
    "#Define the probability of each of the six sides having an equal chance of showing up \n",
    "die, probabilities, throws = [1,2,3,4,5,6], [1/6, 1/6, 1/6, 1/6, 1/6, 1/6], 1\n",
    "\n",
    "# Use np.random.choice to throw the die once and record the outcome\n",
    "outcome = np.random.choice(die, size=throws, p=probabilities)\n",
    "print(\"Outcome of the throw: {}\".format(outcome[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Throwing two fair dice**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dice show 4 and 3. You lose!\n"
     ]
    }
   ],
   "source": [
    "# Initialize model parameters & simulate dice throw\n",
    "die_t, probabilities_t, num_of_dice = [1,2,3,4,5,6], [ 1/6, 1/6, 1/6, 1/6, 1/6, 1/6], 2\n",
    "outcomes = np.random.choice(die, size=2, p=probabilities_t)\n",
    "if outcomes[0] == outcomes[1]:\n",
    "    answer = 'win'\n",
    "else:\n",
    "    answer = 'lose'\n",
    "print(\"The dice show {} and {}. You {}!\".format(outcomes[0], outcomes[1], answer))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Simulating the dice game**\n",
    "We now know how to implement the first three steps of a simulation. Now let's consider the next step - repeated random sampling.\n",
    "\n",
    "Simulating an outcome once doesn't tell us much about how often we can expect to see that outcome. In the case of the dice game from the previous exercise, it's great that we won once. But suppose we want to see how many times we can expect to win if we played this game multiple times, we need to repeat the random sampling process many times. Repeating the process of random sampling is helpful to understand and visualize inherent uncertainty and deciding next steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In 100 games, you win 21 times\n"
     ]
    }
   ],
   "source": [
    "## Initialize model parameters & simulate dice throw\n",
    "die_s, probabilities_s , num_of_dice_s = [1,2,3,4,5,6], [ 1/6, 1/6, 1/6, 1/6, 1/6, 1/6], 2\n",
    "#sims variable how many times we want to simulate and wins varibale to count how many times we win.\n",
    "sims, wins = 100, 0\n",
    "\n",
    "#write a loop for simulations\n",
    "for i in range(sims):\n",
    "    outcomes_s = np.random.choice(die, size=2, p=probabilities)\n",
    "    ## Increment `wins` by 1 if the dice show same number\n",
    "    if outcomes_s[0] == outcomes_s[1]:\n",
    "        wins = wins +1\n",
    "print(\"In {} games, you win {} times\".format(sims, wins))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using simulation for decision-making\n",
    "\n",
    "We will run a complete simulation, take a decision based on our observed outcomes, and learn to modify inputs to the simulation model.\n",
    "\n",
    "We will use simulations to figure out whether or not we want to buy a lottery ticket. Suppose you have the opportunity to buy a lottery ticket which gives you a shot at a grand prize of $1 Million. Since there are 1000 tickets in total, your probability of winning is 1 in 1000. Each ticket costs $10. Let's use our understanding of basic simulations to first simulate one drawing of the lottery."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outcome of one drawing of the lottery is [-10]\n"
     ]
    }
   ],
   "source": [
    "# Pre-defined constant variables\n",
    "lottery_ticket_cost, num_tickets, grand_prize = 10, 1000, 1000000\n",
    "\n",
    "# Probability of winning: Remember that 1 out of the total number of lottery tickets sold will win.\n",
    "chance_of_winning = 1/1000\n",
    "\n",
    "# Simulate a single drawing of the lottery\n",
    "gains = [-lottery_ticket_cost, grand_prize-lottery_ticket_cost]\n",
    "probability = [1 - chance_of_winning, chance_of_winning]\n",
    "outcome = np.random.choice(a=gains, size=1, p=probability, replace=True)\n",
    "\n",
    "print(\"Outcome of one drawing of the lottery is {}\".format(outcome))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We complete the simulation process by repeating the process multiple times.Repeating the process gives us multiple outcomes. We can think of this as multiple universes where the same lottery drawing occurred. We can then determine the average winnings across all these universes. If the average winnings are greater than what we pay for the ticket then it makes sense to buy it, otherwise, we might not want to buy the ticket.This is typically how simulations are used for evaluating business investments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average payoff from 2000 simulations = 490.005\n"
     ]
    }
   ],
   "source": [
    "# Initialize size and simulate outcome\n",
    "lottery_ticket_cost, num_tickets, grand_prize = 10, 1000, 1000000\n",
    "chance_of_winning = 1/num_tickets\n",
    "size = 2000\n",
    "#Set payoffs equal to a list containing how much you could lose and how much you could win\n",
    "payoffs = [-lottery_ticket_cost, grand_prize]\n",
    "#Set probs equal to a list of probabilities of losing and winning.\n",
    "probs = [1 - chance_of_winning, chance_of_winning]\n",
    "\n",
    "outcomes = np.random.choice(a=payoffs, size=size, p=probs, replace=True)\n",
    "\n",
    "# Mean of outcomes.\n",
    "answer = np.mean(outcomes)\n",
    "print(\"Average payoff from {} simulations = {}\".format(size, answer))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we might want to know how expensive the ticket needs to be for it to not make sense to buy it. To understand this, we need to modify the ticket cost to see when the expected payoff is negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The highest price at which it makes sense to buy the ticket is 12\n"
     ]
    }
   ],
   "source": [
    "lottery_ticket_cost, num_tickets, grand_prize = 10, 1000, 1000000\n",
    "chance_of_winning = 1/num_tickets\n",
    "\n",
    "# Initialize simulations and cost of ticket\n",
    "sims, lottery_ticket_cost = 3000, 0\n",
    "\n",
    "# Use a while loop to increment `lottery_ticket_cost` till average value of outcomes falls below zero\n",
    "while 1:\n",
    "    outcomes = np.random.choice([-lottery_ticket_cost, grand_prize-lottery_ticket_cost],\n",
    "                 size=sims, p=[1-chance_of_winning, chance_of_winning], replace=True)\n",
    "    if outcomes.mean() < 0:\n",
    "        break\n",
    "    else:\n",
    "        lottery_ticket_cost += 1\n",
    "answer = lottery_ticket_cost - 1\n",
    "\n",
    "print(\"The highest price at which it makes sense to buy the ticket is {}\".format(answer))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probability and Data genaration Process \n",
    "\n",
    "Sample Space is a set of full possible outcomes.\n",
    "\n",
    "**Probablity** is a numbers that help us the understanad the likelihood of accurance of an event within that sample space. There is general agreement that a probability is a real value between 0 and 1.\n",
    "\n",
    "The “things” we assign probabilities to are called *events*. If E represents an event, then P(E) represents the probability that E will occur. A situation where E might or might not happen is called a *trial*.\n",
    "\n",
    "If two events are mutually exclusive, that means that only one of them can happen, so the conditional probabilities are 0:<br>\n",
    "$P(A|B) = P(B|A) = 0$\n",
    "\n",
    "In this case it is easy to compute the probability of either event:<br>\n",
    "$P(A or B) = P(A) + P(B)$ Warning: not always true.\n",
    "\n",
    "But remember that this only applies if the events are mutually exclusive. Ingeneral the probability of A or B or both is:<br>\n",
    "$P(A or B) = P(A) + P(B) - P(A and B)$ <br>\n",
    "The reason we have to subtract off 4P(A and B)4 is that otherwise it gets counted twice.\n",
    "\n",
    "**Example** <br>\n",
    "*We will use the generalized probability formula P(A∪B)=P(A)+P(B)−P(A∩B) to calculate the probability of two events. Consider a deck of cards (13 cards x 4 suites = 52 cards in total). One card is drawn at random. What is the probability of getting a queen or a spade? Here event A is the card being a queen and event B is the card being a spade. Think carefully about whether the two events have anything in common.*\n",
    "\n",
    "Solution: P(A∪B)=P(A)+P(B)−P(A∩B) \n",
    "\n",
    "$P(A) = 4/52 $ probability of being queen->Because we have 4 queen in all cards coming from each suites<br>\n",
    "$P(B) = 13/52 $probability of being spade -> we have 13 spade cards in total 52.<br>\n",
    "$P(A∩B) 1/52$ probabiliy of being queen and spade<br>\n",
    "\n",
    "$ P(A∪B)=P(A)+P(B)−P(A∩B) $ <br>\n",
    "$P(A∪B) = \\frac{4}{52} + \\frac{13}{52} - \\frac{1}{52} $<br>\n",
    "$P(A∪B) = \\frac{16}{52}$<br>\n",
    "\n",
    "Estimating the probablity sample space for events which has all possible outcomes.\n",
    "* Construct the sample space for events which has all possible outcomes.\n",
    "* Determine how to simulate one random outcomes .\n",
    "* Determine rule for success.\n",
    "* Sample repeatedly and count success.\n",
    "* Calcalate the frequency of success as on estimate of probability."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Two of a kind:**\n",
    " Now let's use simulation to estimate probabilities. Suppose you've been invited to a game of poker at your friend's home. In this variation of the game, you are dealt five cards and the player with the better hand wins. You will use a simulation to estimate the probabilities of getting certain hands. Let's work on estimating the probability of getting at least two of a kind. Two of a kind is when you get two cards of different suites but having the same numeric value (e.g., 2 of hearts, 2 of spades, and 3 other cards)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "deck_of_cards = [('Heart', 1),('Heart', 2),('Heart', 3),('Heart', 4),('Heart', 5),('Heart', 6),('Heart', 7),\n",
    "                 ('Heart', 8),('Heart', 8),('Heart', 10),('Heart', 11),('Heart', 12),('Heart', 13),('Diamond',1),\n",
    "                ('Diamond', 2),('Diamond', 3),('Diamond', 4),('Diamond', 5),('Diamond', 6),('Diamond', 7),\n",
    "                 ('Diamond', 8),('Diamond', 9),('Diamond', 10),('Diamond', 11),('Diamond', 13),('Spade', 1),\n",
    "                ('Spade', 2),('Spade', 3),('Spade', 4),('Spade', 5),('Spade', 6),('Spade', 7),('Spade', 8),\n",
    "                 ('Spade', 9),('Spade', 10),('Spade', 11),('Spade', 12),('Spade', 13),('Heart', 1),('Heart', 2),\n",
    "                ('Heart', 3),('Heart', 4),('Heart', 5),('Heart', 6),('Heart', 7),('Heart', 8),('Heart', 10),\n",
    "                ('Heart', 11),('Heart', 12),('Heart', 13)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of seeing at least two of a kind = 0.51 \n"
     ]
    }
   ],
   "source": [
    "# Shuffle deck & count card occurrences in the hand\n",
    "n_sims, two_kind = 10000, 0\n",
    "for i in range(n_sims):\n",
    "    np.random.shuffle(deck_of_cards)\n",
    "    hand, cards_in_hand = deck_of_cards[0:5], {}\n",
    "    #print('hand', hand)\n",
    "    for card in hand:\n",
    "        # Use .get() method on cards_in_hand\n",
    "        cards_in_hand[card[1]] = cards_in_hand.get(card[1], 0) + 1\n",
    "        #print('cards in hand',cards_in_hand)\n",
    "    # Condition for getting at least 2 of a kind\n",
    "    highest_card = max(cards_in_hand.values())\n",
    "    #print('highest card',highest_card)\n",
    "    if highest_card>=2: \n",
    "        two_kind += 1\n",
    "\n",
    "print(\"Probability of seeing at least two of a kind = {} \".format(two_kind/n_sims))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "#Print the hand, card of hand nad highest number to see how select the two  same kind\n",
    "hand [('Diamond', 1), ('Heart', 8), ('Heart', 1), ('Heart', 4), ('Spade', 11)]\n",
    "cards in hand {1: 1}\n",
    "cards in hand {1: 1, 8: 1}\n",
    "cards in hand {1: 2, 8: 1}\n",
    "cards in hand {1: 2, 8: 1, 4: 1}\n",
    "cards in hand {1: 2, 8: 1, 4: 1, 11: 1}\n",
    "highest card 2\n",
    "#it counts 1 two times\n",
    "hand [('Diamond', 10), ('Heart', 3), ('Heart', 8), ('Heart', 7), ('Spade', 10)]\n",
    "cards in hand {10: 1}\n",
    "cards in hand {10: 1, 3: 1}\n",
    "cards in hand {10: 1, 3: 1, 8: 1}\n",
    "cards in hand {10: 1, 3: 1, 8: 1, 7: 1}\n",
    "cards in hand {10: 2, 3: 1, 8: 1, 7: 1}\n",
    "highest card 2\n",
    "#it counts 10 two times\n",
    "hand [('Diamond', 9), ('Heart', 7), ('Heart', 11), ('Spade', 8), ('Spade', 5)]\n",
    "cards in hand {9: 1}\n",
    "cards in hand {9: 1, 7: 1}\n",
    "cards in hand {9: 1, 7: 1, 11: 1}\n",
    "cards in hand {9: 1, 7: 1, 11: 1, 8: 1}\n",
    "cards in hand {9: 1, 7: 1, 11: 1, 8: 1, 5: 1}\n",
    "highest card 1\n",
    "#we don't have any same number\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Game of thirteen**\n",
    "\n",
    "A famous French mathematician Pierre Raymond De Montmart, who was known for his work in combinatorics, proposed a simple game called as Game of Thirteen. You have a deck of 13 cards, each numbered from 1 through 13. Shuffle this deck and draw cards one by one. A coincidence is when the number on the card matches the order in which the card is drawn. For instance, if the 5th card you draw happens to be a 5, it's a coincidence. You win the game if you get through all the cards without any coincidences. Let's calculate the probability of winning at this game using simulation.\n",
    "\n",
    "*any() returns:\n",
    "\n",
    "True if at least one element of an iterable is true<br>\n",
    "False if all elements are false or if an iterable is empty*\n",
    "\n",
    "```python\n",
    "#one of the output of draw\n",
    "[ 2 11 12 10  9  7  6 13  4  3  1  5  8]\n",
    "#check the draw == list(np.arange(1, 14)) output \n",
    "[False False False False False False False False False False False False False]\n",
    "# so the coincidense here is False because in the array we don;t have any True value\n",
    "#check another draw here\n",
    "[ 8  4  2 13  6 11  5  9  3  1 10 12  7]\n",
    "[False False False False False False False False False False False  True False]\n",
    "#coincidende here is True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of winning = 0.3759\n"
     ]
    }
   ],
   "source": [
    "# Pre-set constant variables\n",
    "deck, sims, coincidences = np.arange(1, 14), 10000, 0\n",
    "\n",
    "for _ in range(sims):\n",
    "    # Draw all the cards without replacement to simulate one game\n",
    "    draw = np.random.choice(deck, size=13, replace=False) \n",
    "    # Check if there are any coincidences\n",
    "    coincidence = (draw == list(np.arange(1, 14))).any()\n",
    "    if coincidence == True:\n",
    "        coincidences += 1\n",
    "\n",
    "# Calculate probability of winning\n",
    "prob_of_winning = 1-coincidences/sims\n",
    "print(\"Probability of winning = {}\".format(prob_of_winning))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional Probability \n",
    "\n",
    "The conditional probability of an A, given event B is defined as the probability of A occurs given that B has already occured,It's calculated as the probability of A intersection B ($A∩B$) divided by the probability of B\n",
    "\n",
    "$$P(A|B) = \\frac{P(A∩B)}{P(B)}$$ , $$P(B|A) = \\frac{P(B∩A)}{P(A)}$$, $$P(A∩B)=P(B∩A)$$\n",
    "\n",
    "if we assume that neither P(A) or P(B) is zero, than we can easlily derive Bayes rules.\n",
    "Bayes Rule = $P(A|B) = \\frac{P(B|A) P(A)}{P(B)} $\n",
    "\n",
    "**Independed Events:** is are events where probability of one accuring is independent of the probability of the other.\n",
    "\n",
    "$$P(A|B) = \\frac{P(A∩B)}{P(B)} = \\frac{P(A) P(B)}{P(B)} = P(A)$$\n",
    "\n",
    "**Let's work on example:**\n",
    "\n",
    "Consider a neighberhood with 150 houses. You are given the data regarding whether or not each house has solar panels installed and whether or not have a clean vehicle hybird or electric car.\n",
    "\n",
    "*We want to find out the probability of having solor panels conditional on the owners having hybird or electric car.*\n",
    "\n",
    "| ---|Solor Panels|No Solor Panels||\n",
    "|---|---|---|---|\n",
    "|Hybird/Ev|$\\frac{30}{150}$| $\\frac{50}{150}$ | $\\frac{80}{150}$|\n",
    "|No Hybird/Ev|$\\frac{10}{150}$| $\\frac{60}{150}$ | $\\frac{70}{150}$|\n",
    "|---|$\\frac{40}{150}$| $\\frac{110}{150}$ | $\\frac{150}{150}$|\n",
    "\n",
    "\n",
    "We first need to calculate the marginal probabilities. The marginal probability of solor panles is sum of probability of solor with and without a clean vehicle,\n",
    "\n",
    "$$P(Solor) = P(Solar ∩ Hybrid, Ev) + P(Solar ∩ No Hybird, Ev) = \\frac{30}{150} + \\frac{10}{150}= \\frac{40}{150}$$\n",
    "$$P(No Solor) = P(No Solar ∩ Hybrid, Ev) + P(No Solar ∩ No Hybird, Ev) = \\frac{50}{150} + \\frac{60}{150}= \\frac{110}{150}$$\n",
    "$$P(Hybird) = P(Hybird ∩ Solar, Ev) + P(Hybird ∩ No Solar, Ev) = \\frac{30}{150} + \\frac{60}{150}= \\frac{80}{150}$$\n",
    "$$P(No Hybird) = P(No Hybird ∩ Solar, Ev) + P(No Hybird ∩ No Solar, Ev) = \\frac{10}{150} + \\frac{60}{150}= \\frac{70}{150}$$\n",
    "\n",
    "Finaly, we want to the probability of solar panels conditional an owners having a clean vehicle.\n",
    "\n",
    "$$ P(Solar|Hybird, Ev) = \\frac{P(Solar ∩ Hybird, Ev)}{P(Hybird)} = \\frac{\\frac{30}{150}}{\\frac{80}{150}} = \\frac{30}{80} = 0.375 $$\n",
    "\n",
    "Let's find out the probability of solar panels conditional an owners having a non-clean vehicle.\n",
    "$$ P(Solar|No Hybird, Ev) = \\frac{P(Solar ∩ No Hybird, Ev)}{P(No Hybird)} = \\frac{\\frac{10}{150}}{\\frac{70}{150}} = \\frac{10}{70} = 0.143 $$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The conditional urn\n",
    "The conditional probability is defined as the probability of an event given another event. To illustrate this concept, let's turn to an urn problem.\n",
    "\n",
    "We have an urn that contains `7 white` and `6 black` balls. Four balls are drawn at random. *We'd like to know the probability that the `first and third balls are white`, while `the second and the fourth balls are black`*.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probabiliy of succes 0.0718\n"
     ]
    }
   ],
   "source": [
    "#Initialize the counter success to 0 and sims to 5000\n",
    "success, sims =0, 5000\n",
    "\n",
    "# Define a list, urn, with 7 white balls ('w') and 6 black balls ('b').\n",
    "urn = ['w','w','w','w','w','w','w','b','b','b','b','b','b']\n",
    "\n",
    "#for loop to create the simulation\n",
    "for _ in range(sims):\n",
    "    ##Draw 4 balls without replacement \n",
    "    draw = np.random.choice(urn, replace=False, size=4)\n",
    "    #check to see if the first and third are white and second and fourth are black \n",
    "    if (draw[0] == 'w' and draw[1] == 'b' and draw[2] == 'w' and draw[3] == 'b'):\n",
    "    #Increment success if the above criterion is met.\n",
    "        success +=1\n",
    "print('Probabiliy of succes {}'. format(success/sims))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Birthday problem\n",
    "\n",
    "How many people do you need in a room to ensure at least a `50% chance` that two of them share the same birthday?\n",
    "\n",
    "*With 366 people in a 365-day year, we are 100% sure that at least two have the same birthday, but we only need to be 50% sure. Simulation gives us an elegant way of solving this problem.*\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With 23 people, there's a 50% chance that two share a birthday.\n"
     ]
    }
   ],
   "source": [
    "# Draw a sample of birthdays & check if each birthday is unique\n",
    "days = np.arange(1,366)\n",
    "people = 2\n",
    "\n",
    "def birthday_sim(people):\n",
    "    sims, unique_birthdays = 2000, 0 \n",
    "    for _ in range(sims):\n",
    "        draw = np.random.choice(days, size=people, replace=True)\n",
    "        \n",
    "        if len(draw) == len(set(draw)): \n",
    "            unique_birthdays += 1\n",
    "    out = 1 - unique_birthdays / sims\n",
    "    return out\n",
    "# Break out of the loop if probability greater than 0.5\n",
    "while (people > 0):\n",
    "    prop_bds = birthday_sim(people)\n",
    "    if prop_bds > 0.5: \n",
    "        break\n",
    "    people += 1\n",
    "\n",
    "print(\"With {} people, there's a 50% chance that two share a birthday.\".format(people))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}