jtolds.com - Math

Erdos number idea

JT Olds — Sat, 8 Nov 2008 07:57:18 +0000

One of the ways to know how high up on the famous-mathematician ladder you are is to calculate your Erdos number. Paul Erdos was certainly very prolific. It's basically a game of six degrees of Kevin Bacon, but played with math papers, instead of movies, and Paul Erdos, instead of Kevin Bacon.

What's interesting (or not, if you realize the ubiquity of small-world networks), is that the median Erdos number is just 5. What's even more interesting is that, according to the Erdos number project, the highest finite Erdos number is 13, with only 5 people in that state!

So, here's a more interesting game to me. Obviously I can't get an Erdos number of 1 (Paul Erdos is no longer among the living), and I suppose if I really dedicated my academic life to such a pursuit, I could probably reach some similarly low number. However, my interest sort of tapers off near the median (5), since that's common. What would be better is to be the 1 person with an Erdos number of 14! So, I need to write a paper with one of the 5 people that have an Erdos number of 13. More importantly, once I do, I can't screw it up by writing any papers with anyone else. Furthermore, I should probably choose the least likely of those 5 people to write more papers. I suppose I still have the problem in which any sub-path in the supposed full path from me to Erdos might collapse into a smaller path at any time. Hmm.

On a slightly related note, another interesting dimension is the intersection of the Erdos number and the Bacon number. The Erdos-Bacon number is the sum of someone's Erdos number and their Bacon number. Evidently the lowest such number is 3. Wikipedia's discussion on how a lower number could be achieved is hilarious. Observe:

The only way a lower number could be achieved would be:

    * for an individual who had co-authored an academic paper with Paul Erdos to
      appear in a movie with Kevin Bacon;
    * for Bacon to co-author an academic paper with someone with an Erdos number
      of 1, which would give Bacon an Erdos-Bacon number of 2;
    * for anyone who appeared in the documentary N is a Number along with Erdos
      to appear in a film with Bacon, which would posthumously give Erdos an
      Erdos-Bacon number of 2;
    * for Kevin Bacon to appear in a film that also uses stock footage of Erdos,
      giving Erdos an Erdos-Bacon number of 1;
    * for a heretofore unknown joint academic paper by Bacon and Erdos to be
      published, giving Bacon an Erdos-Bacon number of 1.

Primes

JT Olds — Tue, 7 Oct 2008 22:42:14 +0000

Update: oh my goodness. Had I just checked the Wikipedia's entry on Prime numbers, I would have been reminded of fundamental things like the Sieve of Eratosthenes (which I of course forgot the name of, but the idea is featured prominently in my parallel algorithm, mentioned at the end of this post) and newer improvements, along with a ton of other incredibly interesting facts, and even a prime distribution graph! Wikipedia: +1, JT: 0

In my static analysis meeting, my professor noted that indexing objects with primes led to an easy set representation scheme, in which a set is simply the product of the prime indices of the objects in that set. I thought this was pretty fascinating. I started wondering about the constraints involved in implementing such a scheme, and inevitably this led to rather worthless homework procrastination that I thought I'd share here.

First, I was curious about prime number distribution over the integers. I made a graph.

So, how to read the graph. At a given point X on the X-axis, there are Y-many prime numbers within a diameter of 100,000 around X. In other words, it's a histogram of all primes below 1 billion, displayed with 10,000 buckets.

Second (but really a prerequisite to the first), I wrote a program to quickly generate as many prime numbers as possible.

#include 
#include 
#include 
 
using namespace std;
 
// this program finds all primes <= 1 billion and notes if they are twin primes
// or mersenne primes.
// compile with (on JT's machine):
// g++ -O3 -march=nocona -funroll-loops -fomit-frame-pointer -o primes primes.cpp
 
inline bool is_mersenne(int val) {
    // so, ((x - 1) & x) is 0 iff x is a power of 2. See
    // http://www.cprogramming.com/tutorial/powtwosol.html for a good
    // explanation of why.
    // since a mersenne number should be of the form 2^n - 1,
    // (x & (x + 1)) is 0 iff x is of form 2^n - 1.
    return !(val & (val + 1));
}
 
int main(int argc, char** argv) {
 
    // strategy: as we calculate primes, we store previous primes so we only
    // have to check divisibility by known primes to know if a new number is
    // prime.
    list<int> primes;
 
    // largest_number is the largest number we will check for primeness
    int largest_number = 1000000000; // 1,000,000,000
 
    // we use last_prime to keep track of if the last number we checked was
    // prime. this way determining twin primes is easy.
    bool last_prime = true;
 
    // book keeping
    bool factor_found;
    int sqrt_i;
 
    // we start with 3, because 3 and every prime after is odd, so we can
    // increment by 2.
    primes.push_back(2);
 
    // we don't check divisibility by 1, since that's always true, but we output
    // it and 2 as primes.
    cout << 1 << endl << 2 << endl;
 
    // check all odd numbers starting with 3 until the largest number
    for(int i = 3; i <= largest_number; i += 2) {
 
        // no factor found yet.
        factor_found = false;
 
        // store the square root of the number we're checking. we only need to
        // check up to the square root.
        sqrt_i = sqrt(i);
 
        // iterate over previously calculated primes up to the square root of
        // the current number. note that we don't have to check if the iterator
        // is primes.end() because there is empirically always a prime stored
        // greater than the square root of the number we're checking. i wonder
        // if there's a proof there. it would probably be of the form of proving
        // that for a given integer i, a prime p exists such that i <= p < i^2
        for(list<int>::iterator it(primes.begin()); *it <= sqrt_i; ++it) {
 
            // if the current number mod the current prime is 0, we found a
            // factor. not prime, break out.
            if(i % *it == 0) {
                factor_found = true;
                break;
            }
 
        }
 
        if(!factor_found) {
            // no factor found! this is a prime. store it.
            primes.push_back(i);
 
            // output the prime
            cout << i;
 
            // is it a twin prime? (p, p+2)
            if(last_prime) cout << " *";
 
            // is it a mersenne prime? (2^n-1)
            if(is_mersenne(i)) cout << " +";
 
            cout << endl;
 
        // keep track of if the last number was prime.
            last_prime = true;
        } else {
            last_prime = false;
        }
 
    }
 
    return 0;
}

Third, I think I've figured out a pretty clever algorithm for parallelizing the computation of primes. I was inspired by software pipelining. I hope to actually write up the algorithm to check its effectiveness. I'll post it here if/when I do. Stay tuned.

Can you make (10, 10, 9, 9, 1, +, /, -, *) = 4?

JT Olds — Sun, 24 Aug 2008 22:35:48 +0000

Last night at around 10pm I got a text from my friend asking how you could combine the numbers 10, 10, 9, 9, and 1, to make 4, using only addition, subtraction, multiplication, and/or division, provided you use the numbers once each.

I didn't start thinking about it until later (sorry Mike), but at 2 am I got frustrated and, as I seem wont to do, ignored reasonable priorities (such as sleeping, or the rest of my todo list) and sat down to write a program to enumerate all of the possible solutions, instead of just figuring it out myself.

Below is a general solution to the problem. The basic idea is it is simple enough to consider all the valid possible combinations of the numbers in Reverse Polish Notation (postfix), and evaluate them.

#!/usr/bin/python2.5





def add(x, y): return x + y


def sub(x, y): return x - y


def mult(x, y): return x * y


def div(x, y): return float(x) / y


OPERATIONS = [add, sub, mult, div]


REPRESENTATIONS = {add: '+', sub: '-', mult: '*', div: '/'}





def new_counter(counter, item):


  if counter is None: counter = 0


  if type(item) == type(add): return counter - 1


  else: return counter + 1





def valid_perms(lst, counter=None):


  if counter is not None and counter <= 0: return


  if len(lst) == 1:


    if new_counter(counter, lst[0]) != 1: return


    yield lst


  else:


    for i in xrange(len(lst)):


      for perm in valid_perms(lst[:i]+lst[i+1:], new_counter(counter, lst[i])):


        yield [lst[i]] + perm





def all_combos(lst, n):


  if n == 0: yield []


  else:


    for i in xrange(len(lst)):


      for combo in all_combos(lst, n - 1):


        yield [lst[i]] + combo





def uniq(generator):


  seen_things=set([])


  for thing in generator:


    if tuple(thing) not in seen_things:


      seen_things.add(tuple(thing))


      yield thing





def valid_postfix_stacks(nums):


  for op_combo in uniq(all_combos(OPERATIONS, len(nums) - 1)):


    for perm in uniq(valid_perms(nums + op_combo)):


      yield perm





def compute(stack):


  s = []


  for item in stack:


    if type(item) != type(add):


      s.append(item)


    else:


      s.append(item(*reversed([s.pop(), s.pop()])))


  assert len(s) == 1


  return s[0]





def infix(stack):


  s = []


  for item in stack:


    if type(item) != type(add):


      s.append(str(item))


    else:


      s.append('(' + ' '.join(reversed([s.pop(), REPRESENTATIONS[item], s.pop()])) + ')')


  assert len(s) == 1


  return s[0]





def main(nums, answer, tol=.0001, find_all=False):


  print "searching..."


  found = False


  for postfix_stack in uniq(valid_postfix_stacks(nums)):


    try: val = compute(postfix_stack)


    except ZeroDivisionError, e: continue


    if (float(val) + float(tol)/2 >= float(answer) and float(val) - float(tol)/2 <= float(answer)):


      print infix(postfix_stack), '=', val


      found = True


      if not find_all: break


  if not found: print "no solutions found"


 


if __name__ == "__main__":


  main([10,10,9,9,1], 4)

Horseshoe Update

JT Olds — Thu, 19 Apr 2007 07:13:52 +0000

The story, thus far:
My original writeup
Progress, a year later

Today (and by today, I mean 4/18), I presented some aspects of this thing I've started at an undergraduate symposium.

Check out my poster!
(warning, while the file isn't too large, the poster dimensions are)

Horseshoe

JT Olds — Fri, 17 Feb 2006 04:41:31 +0000

While bored in Numerical Computing class today, I was lamenting the sad state of pencil and paper games.

I mean, it is sad. Tic-Tac-Toe? You can either win or draw every time if you know what you're doing. And there aren't many permutations of the game to play. Tic-Tac-Toe is fun when you're 3 or really, really bored.

There's also Nim. I don't have cool graphics to describe it, but you can visit this page for more information. I mean, it's okay, but it has the same triviality problem as Tic-Tac-Toe.

For a while during high school, I was pretty enthralled with 3x3x3 3D Tic-Tac-Toe, until pointed out that the game is, in fact, usually over after 3 or 4 turns, and is rather devoid of strategy due to so many possible ways to win. It appears that most prefer the 4x4x4 version, but by this point I had already made two 3D 3x3x3 Tic-Tac-Toe boards (one out of plexiglass and cardboard, and one out of ceramic material). Yeah, so that game let me down. All the same, it's perfectly playable on paper with a pencil.

Lastly, there's that game where you have a grid of dots and you try to make more boxes than your opponent by adding one line at a time, but that game takes a while to set up, and has a significant ramp up time before it is fun (usually when the board is close to full is the game actually fun).

So, I have these 3D Tic-Tac-Toe boards collecting dust, and on top of that I'm bored, and can't think of any fun pencil and paper games. This completely ignores the need for someone to play them with, but all the same. I sat there and thought of possible new games that could solve both of my prior problems.

I thought of one that due to naming cleverness I'm calling horseshoe, and I can't tell if it's trivial in the same way as Tic-Tac-Toe or not, so I thought I'd post it here and request feedback.

Horseshoe

The game is essentially 3D 3x3x3 Tic-Tac-Toe, but you aren't trying to get 3 in a row. Instead, you're trying to get a horseshoe shape. I've gone completely out of my way with this entry and made tons of graphics (graphics all made by me with the GIMP) that will come in a sec, probably prematurely, as I haven't even played it with someone more than once. This was the same problem that I had with the 3D Tic-Tac-Toe. I ran off and made boards before I played it much. But so anyway.

You play it on paper, or whatever, but you have 3 layers of a cube. Each player alternates placing their symbol ('X' or 'O', for example. I use blue and red dots) until the board is full or one player gets a horseshoe. The horseshoe shape looks like the following:

XXX X X

It could be 'O's instead of 'X's but you get the idea. Diagonal anything isn't allowed.

I have 4 game samples (each column of squares is one board):

In the first and third games (first and third columns), blue wins, and in the second and fourth, red wins.

To help visualize the winning organizations/layouts/positions, I've also made 3D representations of the winning layouts of each of the four sample games above. I can't think of any winning layouts that aren't just 3D rotations of these four.

1st game:	2nd game:
3rd game:	4th game:

Anyway, it's not too complicated once you figure out what's going on. The 8 or so times I played against myself it was far less trivial than Tic-Tac-Toe, but maybe that was simply a product of me playing an unfamiliar game against myself :).

I took a picture of the configuration of the first time (to my knowledge) this game has been played with two people (how it's supposed to be played):

'O's won.

Yeah, I don't know what to make of it, as no one actually seems interested in playing me, so I don't know how effective of a pencil and paper game it is.

Let me know what you think.