07_euro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Euro Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "This notebook is part of [Bite Size Bayes](https://allendowney.github.io/BiteSizeBayes/), an introduction to probability and Bayesian statistics using Python.\n",
    "\n",
    "Copyright 2020 Allen B. Downey\n",
    "\n",
    "License: [Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "The following cell downloads `utils.py`, which contains some utility function we'll need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print('Downloaded ' + local)\n",
    "\n",
    "download('https://github.com/AllenDowney/BiteSizeBayes/raw/master/utils.py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "If everything we need is installed, the following cell should run with no error messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review\n",
    "\n",
    "[In the previous notebook](https://colab.research.google.com/github/AllenDowney/BiteSizeBayes/blob/master/06_pmf.ipynb) we extended the cookie problem with more bowls and the dice problem with more dice.\n",
    "\n",
    "And I introduced an alternative to the Bayes table, a probability mass function (PMF), which is a useful way to represent and do computations with distributions.\n",
    "\n",
    "Here's the function I used to create a `Pmf`, given a sequence of quantities, `xs`, and the corresponding probabilities, `ps`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_pmf(xs, ps, **options):\n",
    "    \"\"\"Make a Series that represents a PMF.\n",
    "    \n",
    "    xs: sequence of values\n",
    "    ps: sequence of probabilities\n",
    "    options: keyword arguments passed to Series constructor\n",
    "    \n",
    "    returns: Pandas Series\n",
    "    \"\"\"\n",
    "    pmf = pd.Series(ps, index=xs, **options)\n",
    "    return pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's the function that performs a Bayesian update, given a sequence of likelihoods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bayes_update(pmf, likelihood):\n",
    "    \"\"\"Do a Bayesian update.\n",
    "    \n",
    "    pmf: Series that represents the prior\n",
    "    likelihood: sequence of likelihoods\n",
    "    \n",
    "    returns: float probability of the data\n",
    "    \"\"\"\n",
    "    pmf *= likelihood\n",
    "    prob_data = pmf.sum()\n",
    "    pmf /= prob_data\n",
    "    return prob_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use these functions to solve a new problem similar to the cookie problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Euro problem\n",
    "\n",
    "Here's a problem from David MacKay's book, [*Information Theory, Inference, and Learning Algorithms*](http://www.inference.org.uk/mackay/itila/p0.html), which is the book where I first learned about Bayesian statistics.  MacKay writes:\n",
    "\n",
    "> A statistical statement appeared in The Guardian on\n",
    "Friday January 4, 2002:\n",
    ">\n",
    "> >\"When spun on edge 250 times, a Belgian one-euro coin came\n",
    "up heads 140 times and tails 110. ‘It looks very suspicious\n",
    "to me’, said Barry Blight, a statistics lecturer at the London\n",
    "School of Economics. ‘If the coin were unbiased the chance of\n",
    "getting a result as extreme as that would be less than 7%’.\"\n",
    ">\n",
    "> But [asks MacKay] do these data give evidence that the coin is biased rather than fair?\n",
    "\n",
    "To answer this question, we have to make some modeling choices.\n",
    "\n",
    "First, let's assume that if you spin a coin on edge, there is some probability that it will land heads up.  I'll call that probability $x$.\n",
    "\n",
    "Second, let's assume that $x$ varies from one coin to the next, depending on how the coin is balanced and maybe some other factors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these assumptions we can formulate MacKay's question as an inference problem: given the data --- 140 heads and 110 tails --- what do we think $x$ is for this coin?\n",
    "\n",
    "This formulation is similar to the 101 Bowls problem we saw in the previous notebook; in fact, we will use the same likelihoods.\n",
    "\n",
    "But in the 101 Bowls problem, we are told that we choose a bowl at random, which implies that all bowls have the same prior probability.\n",
    "\n",
    "For the Euro problem, we have to think harder.  What values of $x$ do you think are reasonable?\n",
    "\n",
    "It seems likely that many coins are \"fair\", meaning that the probability of heads is close to 50%.  Do you think there are coins where $x$ is 75%?  How about 90%?\n",
    "\n",
    "To be honest, I don't really know.  To get started, I will assume that all values of $x$, from 0% to 100%, are equally likely.  Then we'll come back and try another prior.\n",
    "\n",
    "Here's a uniform prior from 0 to 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = np.arange(101)\n",
    "prior = 1/101\n",
    "pmf = make_pmf(xs, prior)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the likelihoods for heads and tails:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "likelihood_heads = xs / 100\n",
    "likelihood_tails = 1 - xs / 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here are the updates for 140 heads and 110 tails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(140):\n",
    "    bayes_update(pmf, likelihood_heads)\n",
    "\n",
    "for i in range(110):\n",
    "    bayes_update(pmf, likelihood_tails)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what the results look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf.plot()\n",
    "\n",
    "plt.xlabel('Possible values of x')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('140 heads, 110 tails');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This curve shows the \"posterior distribution\" of $x$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Put a function on it\n",
    "\n",
    "Before we go on, let's put that update in a function, because we are going to need it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bayes_update_euro(pmf, data):\n",
    "    \"\"\"Do a Bayesian update.\n",
    "    \n",
    "    pmf: Series that represents a prior PMF\n",
    "    data: tuple of number of heads, tails\n",
    "    \"\"\"\n",
    "    heads, tails = data\n",
    "    xs = pmf.index\n",
    "    \n",
    "    likelihood_heads = xs / 100\n",
    "    likelihood_tails = 1 - likelihood_heads\n",
    "\n",
    "    for i in range(heads):\n",
    "        bayes_update(pmf, likelihood_heads)\n",
    "\n",
    "    for i in range(tails):\n",
    "        bayes_update(pmf, likelihood_tails)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function takes a PMF that represents the prior, and a tuple that contains the number of heads and tails.\n",
    "\n",
    "Here's the uniform prior again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = np.arange(101)\n",
    "prior = 1/101\n",
    "uniform = make_pmf(xs, prior)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the update."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = 140, 110\n",
    "bayes_update_euro(uniform, data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here are the results again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform.plot()\n",
    "\n",
    "plt.xlabel('Possible values of x')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('140 heads, 110 tails');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A better prior\n",
    "\n",
    "Remember that this result is based on a uniform prior, which assumes that any value of $x$ from 0 to 100 is equally likely.\n",
    "\n",
    "Given what we know about coins, that's probabily not true.  I can believe that if you spin a lop-sided coin on edge, it might be somewhat more likely to land on heads or tails.  \n",
    "\n",
    "But unless the coin is heavily weighted on one side, I would be surprised if $x$ were greater than 60% or less than 40%.\n",
    "\n",
    "Of course, I could be wrong, but in general I would expect to find $x$ closer to 50%, and I would be surprised to find it near 0% or 100%.\n",
    "\n",
    "I can represent that prior believe with a triangle-shaped prior.\n",
    "\n",
    "Here's an array that ramps up from 0 to 49 and ramps down from 50 to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "ramp_up = np.arange(50)\n",
    "ramp_down = np.arange(50, -1, -1)\n",
    "\n",
    "ps = np.append(ramp_up, ramp_down)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll put it in a PMF and normalize it so it adds up to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "triangle = make_pmf(xs, ps)\n",
    "triangle /= triangle.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what the triangle prior looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "triangle.plot(color='C1')\n",
    "\n",
    "plt.xlabel('Possible values of x')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('Triangle prior');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's update it with the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = 140, 110\n",
    "bayes_update_euro(triangle, data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And plot the results, along with the posterior based on a uniform prior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform.plot(label='Uniform')\n",
    "triangle.plot(label='Triangle')\n",
    "\n",
    "plt.xlabel('Possible values of x')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('140 heads, 110 tails')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The posterior distributions are almost identical because, in this case, we have enough data to \"swamp the prior\"; that is, the posteriors depend strongly on the data and only weakly on the priors.\n",
    "\n",
    "This is good news, because it suggests that we can use data to resolve arguments.  Suppose two people disagree about the correct prior.  If neither can persuade the other, they might have to agree to disagree.\n",
    "\n",
    "But if they get new data, and each of them does a Bayesian update, they will usually find their beliefs converging.\n",
    "\n",
    "And with enough data, the remaining difference can be so small that it makes no difference in practice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summarizing the posterior distribution\n",
    "\n",
    "The posterior distribution contains all of the information we have about the value of $x$.  But sometimes we want to summarize this information.\n",
    "\n",
    "We have already seen one way to summarize a posterior distribution, the Maximum Aposteori Probability, or MAP:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform.idxmax()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`idxmax` returns the value of $x$ with the highest probability.\n",
    "\n",
    "In this example, we get the same MAP with the triangle prior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "triangle.idxmax()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to summarize the posterior distribution is the posterior mean.\n",
    "\n",
    "Given a set of values, $x_i$, and the corresponding probabilities, $p_i$, the mean of the distribution is:\n",
    "\n",
    "$\\sum_i x_i p_i$\n",
    "\n",
    "The following function takes a Pmf and computes its mean.  Note that this function only works correctly if the Pmf is normalized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pmf_mean(pmf):\n",
    "    \"\"\"Compute the mean of a PMF.\n",
    "    \n",
    "    pmf: Series representing a PMF\n",
    "    \n",
    "    return: float\n",
    "    \"\"\"\n",
    "    return np.sum(pmf.index * pmf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the posterior mean based on the uniform prior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf_mean(uniform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's the posterior mean with the triangle prior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf_mean(triangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The posterior means are not identical, but they are close enough that the difference probably doesn't matter.\n",
    "\n",
    "In this example, the posterior mean is very close to the MAP.  That's true when the posterior distribution is symmetric, but it is not always true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If someone asks what we think $x$ is, the MAP or the posterior mean might be a good answer.\n",
    "\n",
    "But MacKay asked a different question: do these data give evidence that the coin is biased rather than fair?\n",
    "\n",
    "We have more work to do before we can really answer this question.  But first, I want to rule out an approach that is tempting, but incorrect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Posterior probability\n",
    "\n",
    "If the coin is \"fair\", that means that $x$ is 50%.  So it might be tempting to use the posterior PMF to compute the probability that $x$ is 50%:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform[50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is the posterior probability that $x$ is 50%, but it is not the probability that the coin is fair.\n",
    "\n",
    "The problem is that $x$ is really a continuous quantity, which means it could have any value between 0 and 1.  \n",
    "\n",
    "For purposes of computation, I broke this interval into 101 discrete values, but that was an arbitrary choice.  I could have done the computation with 201 hypotheses, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs2 = np.linspace(0, 100, 201)\n",
    "prior2 = 1/201\n",
    "\n",
    "uniform2 = make_pmf(xs2, prior2)\n",
    "len(uniform2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the update."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "bayes_update_euro(uniform2, data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's what the results look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform2.plot(color='C2')\n",
    "\n",
    "plt.xlabel('201 possible values of x')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('140 heads, 110 tails');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are visually similar, but you might notice that the curve is a little smoother at the peak.\n",
    "\n",
    "The MAPs are the same and the posterior means are almost the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform.idxmax(), uniform2.idxmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf_mean(uniform), pmf_mean(uniform2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the total probability is spread out over twice as many hypotheses, so the proability of any single hypothesis is smaller.\n",
    "\n",
    "If use both posteriors to compute the probability that $x$ is 50%, we get very different results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform[50], uniform2[50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because $x$ is continuous, we divided the interval into discrete values.  But the number of values was an arbitrary choice, so the probability of any single value is not meaningful. \n",
    "\n",
    "However, we can meaningfully compute the probability that $x$ falls in an interval."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Credible intervals\n",
    "\n",
    "We can use a Boolean series to select values from the posterior distribution and add up their probabilities.\n",
    "\n",
    "Here's a function that computes the total probability of all values less than or equal to a given threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prob_le(pmf, threshold):\n",
    "    le = (pmf.index <= threshold)\n",
    "    total = pmf[le].sum()\n",
    "    return total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, here's the probability that $x$ is less than or equal to 60%, based on the uniform prior with 101 values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_le(uniform, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what we get with 201 values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_le(uniform2, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are not identical, but they are close enough that the differences might not matter.\n",
    "\n",
    "So let's say that the probability is 92% that $x$ is less than or equal to 61.\n",
    "\n",
    "I'll also compute the probability that $x$ is less than or equal to 51:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_le(uniform, 50), prob_le(uniform2, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the probability is about 4% that $x$ is less than 50.\n",
    "\n",
    "Putting these results together, we can estimate the probability that $x$ is between 50 and 60; it's about 92% - 4% = 88%.\n",
    "\n",
    "And interval like this is called a \"credible interval\" because it tells us how credible it is that $x$ falls in the interval.\n",
    "\n",
    "In this case the interval from 50 to 60 is an 88% credible interval.  We'll learn more about credible intervals in a future notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this notebook, we used data from a coin-spinning experiment to estimate the probability that a given coin lands on heads.\n",
    "\n",
    "We tried three different priors: uniform distributions with 101 and 201 values, and a triangle distribution.  The results are similar, which indicates that we have enough data to \"swamp the priors\".\n",
    "\n",
    "And we summarized the posterior distributions three ways, computing the value with Maximum Aposteori Probability (MAP), the posterior mean, and a credible interval.\n",
    "\n",
    "Although we have made progress, we have not yet answered the question I started with, \"Do these data give evidence that the coin is biased rather than fair?\"\n",
    "\n",
    "We'll come back to this question in a future notebook, but [in the next notebook](https://colab.research.google.com/github/AllenDowney/BiteSizeBayes/blob/master/08_soccer.ipynb), we'll work on the World Cup problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**Exercise:**  Suppose a baseball player gets 3 hits out of 3 at bats during their first game.  What is the probability that their batting average is actually below the mean?  What is the probability that they go 3-for-3 in the next game?\n",
    "\n",
    "To answer this question, we have to make some modeling choices:\n",
    "\n",
    "* Let's assume that each player has some constant batting average that is their probability of getting a hit during any at bat.\n",
    "\n",
    "* As a prior distribution, let's use a normal distribution with mean 0.260 and standard deviation 0.033.\n",
    "\n",
    "We can use `scipy.stats.norm` to evaluate the normal distribution for a range of batting averages, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import norm\n",
    "\n",
    "mean = 0.26\n",
    "std = 0.033\n",
    "\n",
    "xs = np.linspace(0, 0.5)\n",
    "ps = norm(mean, std).pdf(xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Put these values and probabilities in a Series and normalize it to represent the prior.\n",
    "\n",
    "2. Compute the likelihood of getting 3 hits.\n",
    "\n",
    "3. Compute the total probability of the data, which is the probability that a new player gets 3 hits in their first game.\n",
    "\n",
    "4. Compute the posterior distribution for this player's batting average.\n",
    "\n",
    "5. Plot the prior and posterior distributions.\n",
    "\n",
    "6. Compute the prior and posterior means; how much higher is the posterior mean?\n",
    "\n",
    "7. Compute the posterior probability that the player's batting average is actually below the mean.\n",
    "\n",
    "\n",
    "7. Compute the probability the same player will get 3 hits in their next game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}