This notebook illustrates the use of tables in conveying the combination of inferential and computational thinking through studying concepts of probability theory. It the Birthday Surprise as a running example, based on a lecture by Ani Adhikari in http://data8.org/
In [1]:
# HIDDEN
from datascience import *
%matplotlib inline
import matplotlib.pyplot as plots
plots.style.use('fivethirtyeight')
import numpy as np
# datascience version number of last run of this notebook
version.__version__
Out[1]:
Inferential thinking. I sit down next to a random person in class, what is the chance that I have the same birthday as that person?
In [2]:
# what is the chance that we have different birthdays?
364/365
Out[2]:
In [3]:
# what is the chance that we have the same birdthday?
1 - 364/365
Out[3]:
In [4]:
# what is the chance that my birthday is different from both my neighbors?
(364/365) * (363/365)
Out[4]:
In [5]:
# the same as one of them?
1 - (364/365) * (363/365)
Out[5]:
In [6]:
# the same as one of my four neighbors?
1 - (364/365) * (363/365) * (362/365) * (361/365)
Out[6]:
Wow, nearly 3%?
Computational thinking? For a group of N people, what is the probability that at least two of them have the same birthday? An algorithmic question. Given K people with different birthdays, what is the probability that the next random person will have a different birthday than any of them? If we can answer this single step, we have a way to answer the general question? Yes, it is like induction. But it is constructive too. That's an algorithm.
Let's create a little table, kind of like what might think of as a spreadsheet, to collect all of our computational and inferential thoughts about solving this problem.
In [7]:
bday = Table()
In [8]:
# lets start with numbering the days in the year (we'll start with zero). We don't care if they are
# in calendar order, backwars, sideways or the ways that we encounter them in meeting random people
bday["day"] = range(365)
In [9]:
bday
Out[9]:
Cool, we have a column of the days, but its pretty long and we can see them all on the page, but a graph is a great way to summarize things, so let's look at what we have.
In [10]:
bday.plot()
Yep, as easy as pi. The days in a year. But we really need those diminishing fractions of the days left in the year. OK, that's easy, lets build a new column of the days that are left after we've seen some. And let's look at what we've got
In [11]:
bday['left']= 364-bday['day']
bday
Out[11]:
In [12]:
#of course, we could plot these
bday.plot()
In [13]:
# or on top of each other
bday.plot(overlay=True)
After we have k people with different birthdays, we have 365-k possible days left. But what we really want is the fraction of days in the year left. Obviously, divide by the number of days in the year. Let's do that and see where we are.
In [14]:
bday['frac']=bday['left']/365
bday
Out[14]:
OK, that looks like its going from 1 to 0 just as we'd expect. And we can see how things are working together, just as we might in a spread sheet. We can focus on the data that comes out of the computation. In a spreadsheet this would be all spread around in the cells. Here the computation is clearly laid out and we can see how it progresses from one step to the next by building up the table.
We might want to select just 'fraction left' to look at.
In [15]:
bday.select('frac').plot()
Ah, but remember the inferential part. Given k people, what is the probability they all have different birthdays. That's the product of these diminishing fractions.
In [16]:
# each column in our table is really a sequence of values
bday["frac"]
Out[16]:
Phew that's a lot of numbers... tables gives us a little peek, but we can always look into it for more. Sure beats scrolling through 365 rows in excel!
So we need something to take the running product of a bunch of numbers. These things you'll learn to just build. But lots of folks built useful ones already. That's a beautiful thing about computing - you can naturally build on the work of others. Here we'll use the 'cumulative product' tool from the 'numpy' library. Don't worry you'll see that later. The important thing it that it does what we did for 2, 3 or 4 neighbors - but for all of them.
In [17]:
bday["different"] = np.cumprod(bday["frac"])
bday
Out[17]:
In [18]:
# finally the probably that at least two people have the same birthday
bday['some same bday'] = 1-bday['different']
bday
Out[18]:
In [19]:
# so 14% with just ten people. How about the whole story
# Table.select produces a table containing only the selected columns
bday.select('some same bday').plot()
In [20]:
# wow, let's look at the start of that
# Table.take produces a table containing the rows taken from a Table.
bday.take(range(50))
Out[20]:
In [21]:
# Table methods generally produce new tables so they compose naturally.
# Here to convey the essence of the Birthday Surprise
bday.take(range(50)).select('some same bday').plot()
In [22]:
# Since indexing a column by its name gives an array, it can be indexed.
bday['some same bday'][20]
Out[22]:
Now that we understanding this by building it up step by step, could we put it all into one place that we might call a program for answering this question? Sure.
In [23]:
# altogether now like a real program
bd = Table()
bd["day"] = range(365)
bd['left']= 364-bd['day']
bd['frac']=bd['left']/365
bd["different"] = np.cumprod(bd["frac"])
bd['some same bday'] = 1-bd['different']
bd.select('some same bday').take(range(50)).plot()
In [24]:
bd
Out[24]: