After trying to define the problem and find an answer mathematically, I remembered that I suck at statistical reasoning about as much as the average American. So I decided to model the problem with a short Python script and find the answer that way.

The problem: There are n people (say, at a party) drawn randomly from a population in which the chances of having a birthday on any day is equal to having a birthday on any other (which is not true of real populations (probably)). What is the probability of there being at least two people with the same birthday in the sample?

To put this thing together, I figure we need three things:

1. The ability to generate random numbers (provided by Python’s random module);
2. An object representing each person;
3. A party object full of those people.

Then we can add things like the ability to choose how many people we want at the party and how many parties to have, as well as some output for making plots!

First, the Person object. All each person needs is a birthday:

import random
random.seed()

class Person:
    def __init__( self ):
        self.birthday = random.randint( 1, 365 )

After that we need a Party object, which must be able to contain a bunch of people and check to see whether any of them have the same birthday:

class Party:
    def __init__( self, partiers ):
        self.members   = [ Person()        for p      in range(partiers) ]
        self.birthdays = [ member.birthday for member in self.members    ]
        self.check_matching_birthdays()

    def check_matching_birthdays( self ):
        birthday_frequencies = { b:0 for b in self.birthdays }
        for b in self.birthdays: birthday_frequencies[b] += 1
        for b in self.birthdays:
            if birthday_frequencies[b] < 2:
                del birthday_frequencies[b]
        self.matching_dates = len(birthday_frequencies)

Finally, we need the main() function allowing the user to choose the number of parties and attendees:

def main():
    while True:
        parties  = int(input("Number of parties:  "))
        partiers = int(input("Number of partiers: "))
        parties_with_matching_birthdays = 0

        for party in range( parties ):
            party = Party( partiers )
            if party.matching_dates:
                parties_with_matching_birthdays += 1

        print( 'Fraction of parties having at least one match:' )
        print( '   ', parties_with_matching_birthdays / parties )

main()

Putting it all together we get a simple program that allows you to answer the question given, and for any number of people. As you increase the number of parties, the variability gets smaller and smaller (and, being an inefficient program, the time taken gets longer and longer). The output I get from a few values is:

Figure 1: Frequency of finding individuals with the same birthday in groups of various sizes.

At 25 people there is already a better-than-even chance of finding two people with the same birthday, and by 50 it’s almost guaranteed! That does seem a little unbelievable, so I’ll refer you to the Wikipedia page on the topic for the math (yes, there really is a page for this).

Just to see if this little simulation would recreate what Wikipedia shows, we can modify the main() function and change it to the following:

def main():
    max_partiers      = 60
    number_of_parties = 10000
    iterations        = 3

    with open( 'birthdays.r', 'w' ) as rfile:
        # First add the variable containing each number of people.
        rfile.write( 'people = c( 1' )
        for partier in range( 2, max_partiers+1 ):
            rfile.write( ', ' + str(partier) )
        rfile.write( ')\n' )

        # Then the variables for the matches in each iteration.
        for iteration in range(iterations):
            rfile.write( 'matches' + str( iteration ) + ' = c( 0' )
            for partiers in range( 2, max_partiers+1 ):
                print( 'iteration =', iteration, 'partiers =', partiers )
                matches = 0
                for party in range( number_of_parties ):
                    party = Party( partiers )
                    if party.matching_dates:
                        matches += 1
                rfile.write( ', ' + str( matches / number_of_parties ) )
            rfile.write( ')\n' )

main()

Plotting the results in R gives:

Figure 2: Output of simulation. Plotted in R using the Cairo package.

And overlaying it onto the Wikipedia plot:

Figure 3: Overlay (using Inkscape) of simulated values (blue) on Wikipedia's calculated values (red).

]]> http://adamcoster.com/2011/07/13/python-shared-birthdays/feed/ 2 sacred atom party birthday simulation simulated_birthday overlay http://adamcoster.com/2011/04/30/mindforge-tutorial-cleartype-tuner/ http://adamcoster.com/2011/04/30/mindforge-tutorial-cleartype-tuner/#comments Sat, 30 Apr 2011 12:00:17 +0000 adamcoster http://adamcoster.com/?p=1164 ]]> As part of the continuing closet-cleaning series: WindowsXP text is ugly and induces eye-pain and headaches. Here’s what you can do about it:

If your first thought, when reading the title of this post, was “What in the hell is a disk image?”, you probably aren’t alone. But before you decide that you don’t care enough to read on, let me quickly tell you what the big deal is so that your decision to stop reading will be an informed one!

A disk image is a virtual copy of a real disk (so a virtual CD).

That’s it. This is cool because you can make backup copies of your CDs/DVDs (though some have protections that may make this difficult), video games, operating systems, etc etc.

On top of that, you can use virtual CD-drives to play your virtual disks! This has a few advantages: [1] your computer communicates faster with your virtual disks than your real ones, and [2] you won’t have to worry about carrying CDs around ever. Of course, CDs are going the way of the Dodo, so this post may already be useless.

In any event, my middle brother and I once started a custom-PC company called Mindforge Technologies. I made a screencast tutorial for the company that shows how to use disk images, which is the Youtube video above. Enjoy!

However, current biological research is done more and more by computer, and a lot of this stuff does not translate well to a hard-bound notebook. For instance, I’m regularly taking thousands of microscopy images (in a single day) for my projects, and printing all of these off would be tremendously stupid. The value of spreadsheets, scripts, plots, and all kinds of computer-generated data is in the fact they they are digital, so why try to convert them to an outdated medium?

So, I’ve been working on an electronic notebook system that would be court-defensible, highly organized, and easy enough to use that the time requirements wouldn’t be much higher than that for a hardcopy notebook. Currently, this system consists of a handful of Python scripts for organizing and creating a LaTeX notebook, though my plan is to make the thing more cohesive and, eventually, usable (and maybe even useful) for slightly-computer-savvy biologists.

Once I clean it up a bit more, I’ll start posting code and ideas, but in the meantime here’s my problem:

I have been having a hell of a time coming up with a decent name for the project. Since it will eventually be public, I need something catchy. I’ve come up with some pretty lame stuff, too embarrassing to mention, such that until a flash of inspiration a few hours ago the best I had was “Slabnote”…

That light-bulb radiation was this: LabTeX.

Awesome, right? It’s pronounced “Lab tech”, so it’s hugely punny. HUGELY.

I was quite excited and so, of course, did a quick Google search which, to my immense displeasure, showed that a company with that very same name already exists. And it’s a Laboratory equipment company. Which means that my use of LabTeX could be considered trademark infringement. They are based in the UK though, so maybe I’m in the clear?

Anyway, if you are one of the 10 people reading this, please weigh in! I’m looking for both legal advice and punny names. For inspiration (for names, not law), here is a list of relevant keywords:

biology, science, lab, notebook, electronic, LaTeX, TeX, life, cell, molecule, gene, organizer, system