Hypothesis: My headaches are caused by withdrawal from caffeine, a substance that I am addicted to.
Alternative Hypothesis: My headaches are due to some biological cause, and caffeine treats this undefined problem.

Experimental Approach: Attempt to slowly wean myself off of caffeine. If I can do this successfully and remain headache-free for an extended period of time, I will take this as evidence for a caffeine addiction. If I cannot, I will take this as evidence for a biological problem.

Today’s post explains exactly how I plan to do this, in academically painful detail (below the fold).

Figure 1: (A) My current dose is 2 packets per day. Shown are 24 packets, enough for 12 days. I later added 5 packets to the total. (B) Packets claim to weigh 20g, and my scale agrees. Packaging is included in this weight. (C) An empty, seal-able, flexible-plastic container weighs 2g. (D) The first filled container has a mass of 182g, giving 180g powder. (E) The second filled container has a mass of 202g, giving 200g powder. (F) The third and final container weighs 200g, for 198g powder.

I’ve been drinking this instant Vietnamese coffee for a long time now, because it gives me a pretty precise daily caffeine dose and has kept me more headache-free than has normal coffee. I attribute this to high variability in brewed coffee, since the amount of grounds used, water temperature, and brew time vary day-to-day and likely have large effects on final caffeine concentration. So the plan is to use this instant coffee, starting on Day 1 with the amount that I am currently using, followed by 1 gram/day reductions. This will be slow process, allowing me to adjust to the reduced caffeine intake. If during this process I hit quantities that fail to prevent headaches, I will stay on that dose until the headaches stop. If I hit a dose that causes daily headaches for at least 5 days, I will conclude that this is a biological problem.

My current dose is 2 packets per day (Fig. 1A), which should be 40g including the packaging. To more precisely determine the daily amount, I emptied 29 packets (14.5 daily doses) into 3 sandwhich bags and weighed each (Fig. 1). The results are summarized in Table 1, and were remarkably close to the expected value (39.9g actual versus 40g expected).

 
Tomorrow marks Day 0 of The Weaning, which I will begin by measuring out 40g into a tared coffee mug using the scale shown in Fig. 1. I will decrease my daily intake linearly, 1g/day, for the days following as described above, and will follow up this post with the results or with problems that I run into.

// Public Domain 2012 by A.Coster

// some constants for readability, using booleans to save memory
boolean ON  = 1 ;
boolean OFF = 0 ;

// Arduino pin setup - there are 3 pins used for LEDs,
// 1 for push-button. The pin at index success_led is
// the one the user should try to hit.
byte led_pins[3]       = {8,9,10} ;
byte button_pin        =    2 ;
byte success_led       =    1 ;  // refers to pin 9

// time_change is the number of milliseconds to add upon
// failure or subtract upon success.
// colorswitch_delay is the amount of time that the LED stays
// on. This value has time_change added to/subtracted from it.
// So that the user knows which LED was lit up when they hit
// the button, push_pause defines the number of milliseconds
// that the LED will stay on after the button is pressed.
unsigned int time_change       =   50 ;
unsigned int colorswitch_delay =  500 ;
unsigned int push_pause        = 2000 ;

void setup(){

    for (int i=0 ; i        pinMode( led_pins[i], OUTPUT ) ;
    }
    pinMode( button_pin, INPUT ) ;
}

void loop(){
    // need to keep track of button presses
    // so set the button state to 0 and overwrite
    // later upon button press
    boolean button_state = OFF ;

    // sequentially turn on each LED
    for ( int i=0 ; i        digitalWrite( led_pins[i], HIGH ) ;

        // Check for a button press every 5 milliseconds
        for ( int t=0 ; t            button_state = digitalRead( button_pin ) ;

            // if the button has been pressed, stop
            // switching LEDs so the user knows, and
            // then check if it was the success_led
            if ( button_state == ON ){
                delay( push_pause ) ;

                // set the button state back to off
                button_state = OFF ;
                if ( i == success_led )
                    // if the user hit the right LED,
                    // make it more challenging by
                    // reducing the delay between LED
                    // switches.
                    colorswitch_delay -= time_change ;
                else
                    // if the user was wrong, make it
                    // easier by increasing the delay.
                    colorswitch_delay += time_change ;
                    break ;
                }
            delay( 5 ) ;
        }
        // and turn it off before looping through
        // to turn the next LED on.
        digitalWrite( led_pins[i], LOW ) ;
    }
}

Fig.1: Kit contents.

Since I intend to do a lot of fiddling with Arduinos, and because I need the soldering practice, I bought the breadboard voltage regulator kit (by Solarbotics) from Makershed. The kit is simple – it just requires the soldering of a handful of parts to the provided board. The instructions are super-clear, so even though I barely know what the parts are and only recently discovered that LEDs have to be connected in a certain direction, the task was easy. I did find, however, that I still totally suck at soldering, even after the purchase of a nicer iron. With time perhaps.

In the end, though it took me probably 5 minutes to solder each joint, I plugged the thing in and it works! This regulator is supposed to hold the voltage at 5V, which is perfect for the Arduino since that is what it outputs. Pretty handy little thing, and if you are a bit more knowledgeable you could make your own from scratch for way cheaper.

Fig.2: Assembled kit, plugged in with glowing LED.

I’m writing this post on my new Asus Transformer Prime (with keyboard) and it just feels clumsy as hell. Probably that feeling comes mostly from the Android operating system, which makes text editing a difficult process. And the slowness of switching applications to find links or open other documents also makes this a pain. Perhaps I will get used to it and even begin to like this system over time, but for now I cannot recommend that anyone who wants to do any serious mobile writing (or coding) get one of these things. It seems you’re much better off with a small laptop.

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