Shriphani Palakodety » Mathematics

Summer and Fall 2010 + SURF 2010

Shriphani — Thu, 26 Aug 2010 05:03:07 +0000

So, 4 days into this semester I think I have decided my schedule. I am assuming I have a relatively light semester owing to some stupidity I engaged in (screw ups with the coursework). Anyway, here’s my coursework for this semester:

CS 352 – Compilers (supposed to be hard)
CS 314 – Numerical Methods (this course looked very interesting).
MA 375 – Discrete Math (to consolidate my probability concepts and to study graphs deeply)
COM 217 – Had to take it sometime.
CS 490 – Bioinformatics independent study.

So, I chickened out of ECE 270 since Compilers + Digital Systems would be suicide and since CS 497 is planned for semester #6, I am in a tight spot since one more CS course can cause my GPA in all courses to tank so I am stuck here with this stupid setup. Also, I took the Phy test out and I am not sure if that went very well so I will have to wait.

Anyway, enough about the current semester. Summer was the most eventful time of my 2 years here @ Purdue. First, I worked for Dr. David S. Ebert in his Visualization laboratory (PURPL) on an emergency response system (the project screenshots shown there are still old. They probably won’t be updated in a while). It was extremely interesting since I got to work with OpenGL (I am not sure I will ever get a chance to work with it again) and got to learn about computer graphics. Here is a list of things we got done in the summer:

A 3D picking algorithm (nothing too fancy. This took a while since I had to read OpenGL documentation about their coordinate systems).
A controllable camera (one you can turn, zoom in/out with using keystrokes)
A couple of camera angles (The high angle mode and the first person mode). Getting them to follow characters smoothly was a crazy issue.
Then we implemented a path based attribute visualization technique which became the topic for my poster.

I stood with a poster @ the SURF symposium and I won “Top Poster” and my grad mentor, S. Kim, earned “Graduate Student Mentor of the Summer” so I would rate my SURF 2010 experience as one of the top 10 experiences of my life (the other 9 are yet to arrive).

Now, I might just go and join SIG-APP or something like that to spend spare time. Now, here are some goals I set for myself this semester:

Prepare for the GRE (it sucks but it has to be done).
Learn how to speak Japanese reasonably well.
Consolidate my probability knowledge (I would really like to learn it well this time round).
Finish reading a book on NP Complete problems.

Well, I just hope I don’t screw up anything this year since this is my last chance to build a great resume for grad school (and achieve some lofty goals which are too childish for even this blog) before applications season begins.

Bipartite Matching And Max Flow – Tweaks And Other Observations

Shriphani — Sat, 17 Jul 2010 00:45:16 +0000

When I was in Dr. Frederickson’s CS 381 class (if you go to Purdue CS and are wondering if you should sit in his CS 381, I would say YES), I learned how to solve a simple class of Matching problems, biparitite matching.

So, you have 2 sets of vertices and no 2 members of the same set are connected. Now, given a bipartite graph, we are supposed to find a maximum matching for it.

The simplest way to solve this problem would be to use integer valued flow. Here’s our sample graph:

Well, the obvious solution is to direct the edges from the set on the left (marked L in the pic below) to the set on the right (marked R in the pic below) and to make a source vertex and a sink vertex. Next, to apply integer valued flow algorithms on this network, set the capacity of each edge to 1.

PS, I haven’t noted the capacities in the graph above because that would introduce too much clutter. But the capacities are indeed 1. When you run any method on this network that computes maximum integer valued flow (Choose between Ford-Fulkerson and Edmonds-Karp), you are going to have a flow of 0 or 1 on the edges in the graph. The edges that have flow = 1 on them are the ones that are included in the matching and those that are not in the matching have a flow value = 0. Here is one of the possible matchings:

The edges that are untouched have a flow value = 1 (also equal to the capacity of the edge) and those that look like they’ve been shot (i.e have holes in them, have a flow of 0 and hence are not in the matching).

Well, everyone knows this stuff. Else you wouldn’t have approached this line is < 10 seconds. Anyway, in one very productive office hour session with Dr. Frederickson, he pointed out the importance of using an approach to solve a problem. In this case, why do we set a capacity of 1 and compute max integer-valued flow? Well, considering I have a really low IQ, I had to look at this problem as if it were a communication network. Setting a capacity of 1 on each edge and then computing max flow would give us edges with a flow value of 1 or 0. That means we either use the edge to communicate or we don’t (this is why we set a capacity of 1).

So, extending this thinking to problems that bipartite matching can solve, let us consider the simple problem:

B is a set of boys who need to be paired up with girls in set G. Any boy can be paired with any girl.

So, the solution would involve what we just did.

Now, we can modify the problem so:

B is a set of boys who need to be paired up with girls in set G for a performance at their community center. Each boy can appear at most thrice and each girl can appear at most 4 times and a pair can appear at most twice.

Extending my “communication network” idea, this problem can also be solved by computing a max flow on this network. But we need to set the capacities on each edge correctly.

We have an edge from a source S to every boy. Now, a boy can appear at most thrice. This essentially means, the boy can be picked once, twice, three times (or if he really sucks, he might not be picked at all). So, the capacity you set on this edge is 3.
Now, we have an edge from every girl to a sink T. Remember a girl can be picked at most 4 times. So, the capacity of the edge from every girl to the sink is 4.
Now, each pair can appear twice so every edge from set B to set G gets a capacity of 2.

That’s it. Computing max flow on this should give us a decent matching!

Hebb’s Rule

Shriphani — Mon, 09 Feb 2009 00:58:30 +0000

This post is slightly psychology influenced. Well, in the Psychology class I have been taking this semester (Introduction To Cognitive Learning), I was taught about Neural Networks and a certain Hebb’s Rule which allows a network to remember a previous configuration and use this configuration to interpret new information. We use the following model to represent a cell:

1. A cell (neuron) has only two activation states: On or Off.

On: Cell has high firing rate. (High number of action potentials fired in unit time).
Off: Cell has low firing rate.

2. Cell weights are reciprocal. Weights symbolize the size of the synapse between two cells. Greater size = greater strength.

3. If cells fire simultaneously, they develop positive weights. The active cells (activation = on) inhibit the inactive cells (develop negative weights.

4. The network organizes itself based on sensory input. And new sensory info is interpreted by previously developed weights.

5. The network updates itself one at a time.

6. The activation of a cell can be determined by the following formula:

1 if ∑w_ija_j > 0
0 otherwise

The weights lend a sort of memory to the network since weights influence the interpretation of subsequent sensory input.

Based on these rules, I wrote something that simulated a network that implemented the Hebb’s rule.

First, we need to describe a neuron. Our neurons represent an uppercase letter of the english alphabet. We also need a way to represent the weights with each of the other neurons.

So a basic class to describe a neuron:

class Neuron:
def __init__(self, a, weight_dict):
”‘A Represents The Cell’s Content”‘

self.content = a #what letter of the alphabet a cell represents
self.weights = weight_dict #only contains contents of each neuron.
self.state = 0 #activation state initially on.

def __str__(self):
return "Activation: "+str(self.state)+"\nWeights: "+str(self.weights)

Now, the network has a collection of neurons (26 in our case which signify each letter of the alphabet). Hence, the init method for the neuron class:

def __init__(self):
self.neurons = []
self.flush = {} #weight calculator while updating activities
self.possibilities = []

for char in string.uppercase:
self.flush[char] = 0

for letter in string.uppercase:
weights = copy.copy(self.flush)
weights.pop(letter)
a = Neuron(letter, weights)
self.neurons.append(a)

Now that we have a network that is populated, we need a method that receives input and figures out the changes in the weights between cells (or the strength of the connection between cells). This method is then fed by another method that figures out the overall change in the weights and computer which cells are active:

def recvInput(self):
a = raw_input("Sensory Interface: ") #Get a word

while a != "QUIT":
b = list(a)
for i in xrange(len(b)):
for neuron in self.neurons:
char = b[i]
if neuron.content == char:
neuron.state = 1
reqd_list = b[0:i]+b[i+1:]
for char in string.uppercase:
if char in reqd_list:
neuron.weights[char]+=1
else:
if neuron.weights.has_key(char):
neuron.weights[char]-=1
else:
continue

self.checkInfo()
self.possibleInfo()
print "The possible interpretations of this input might be anagrams of the subsets of: \n"
print self.possibilities
a = raw_input("Sensory Interface: ")

def checkInfo(self):
output = []
possibilities = {}
for neuron in self.neurons:
if neuron.state == 1:
for info in neuron.weights.keys():
self.flush[info] += neuron.weights[info]
print self.flush

for neuron in self.neurons:
if self.flush[neuron.content] > 0:
neuron.state = 1
else:
neuron.state = 0

for char in self.flush.keys():
self.flush[char] = 0

def possibleInfo(self):
self.possibilities = []
for neuron in self.neurons:
if neuron.state == 1:
self.possibilities.append(neuron.content)

Then we run this network with:

words = Network()

words.recvInput()

Before I run this, let me mention that this thing only accepts uppercase letters and breaks if a letter is repeated in a word. This is because neurons rarely have their own axon connected to their own dendrite (neurons are not connected to themselves).

So, a sample run:

tark-b-183:scripts shriphani\> python hebb.py
Sensory Interface: HELP
{'A': -4, 'C': -4, 'B': -4, 'E': 3, 'D': -4, 'G': -4, 'F': -4, 'I': -4, 'H': 3, 'K': -4, 'J': -4, 'M': -4, 'L': 3, 'O': -4, 'N': -4, 'Q': -4, 'P': 3, 'S': -4, 'R': -4, 'U': -4, 'T': -4, 'W': -4, 'V': -4, 'Y': -4, 'X': -4, 'Z': -4}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'H', 'L', 'P']
Sensory Interface: LOSER
{'A': -9, 'C': -9, 'B': -9, 'E': 7, 'D': -9, 'G': -9, 'F': -9, 'I': -9, 'H': -2, 'K': -9, 'J': -9, 'M': -9, 'L': 7, 'O': 0, 'N': -9, 'Q': -9, 'P': -2, 'S': 0, 'R': 0, 'U': -9, 'T': -9, 'W': -9, 'V': -9, 'Y': -9, 'X': -9, 'Z': -9}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'L']
Sensory Interface: HOMELY
{'A': -12, 'C': -12, 'B': -12, 'E': 9, 'D': -12, 'G': -12, 'F': -12, 'I': -12, 'H': 4, 'K': -12, 'J': -12, 'M': -1, 'L': 9, 'O': 4, 'N': -12, 'Q': -12, 'P': -6, 'S': -6, 'R': -6, 'U': -12, 'T': -12, 'W': -12, 'V': -12, 'Y': -1, 'X': -12, 'Z': -12}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'H', 'L', 'O']
Sensory Interface: LOSER
{'A': -17, 'C': -17, 'B': -17, 'E': 13, 'D': -17, 'G': -17, 'F': -17, 'I': -17, 'H': -5, 'K': -17, 'J': -17, 'M': -9, 'L': 13, 'O': 8, 'N': -17, 'Q': -17, 'P': -11, 'S': 1, 'R': 1, 'U': -17, 'T': -17, 'W': -17, 'V': -17, 'Y': -9, 'X': -17, 'Z': -17}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'L', 'O', 'R', 'S']

So we observe that in the first case, four neurons were activated. The word “LOSER” led to H and P being deactivated because the synapse weakened. The next input “HOMELY” causes H and O to activate because O began developing positive weights with other cells and when LOSER was submitted as input and developed a strong enough connection when it was seen in another sensory input. When LOSER is flashed again, it leads to H being forgotten and causes R and S to activate.

Now, a particular case which (I think) indicates the use of this “learning” technique is when we are playing scrabble. Assume that I have words such as NEAR in my memory and when I see N and E on a board, I should be able to complete these words. Watch:

Sensory Interface: NEAR
{'A': 3, 'C': -4, 'B': -4, 'E': 3, 'D': -4, 'G': -4, 'F': -4, 'I': -4, 'H': -4, 'K': -4, 'J': -4, 'M': -4, 'L': -4, 'O': -4, 'N': 3, 'Q': -4, 'P': -4, 'S': -4, 'R': 3, 'U': -4, 'T': -4, 'W': -4, 'V': -4, 'Y': -4, 'X': -4, 'Z': -4}
The possible interpretations of this input might be anagrams of the subsets of: 

['A', 'E', 'N', 'R']
Sensory Interface: NE
{'A': 1, 'C': -6, 'B': -6, 'E': 4, 'D': -6, 'G': -6, 'F': -6, 'I': -6, 'H': -6, 'K': -6, 'J': -6, 'M': -6, 'L': -6, 'O': -6, 'N': 4, 'Q': -6, 'P': -6, 'S': -6, 'R': 1, 'U': -6, 'T': -6, 'W': -6, 'V': -6, 'Y': -6, 'X': -6, 'Z': -6}
The possible interpretations of this input might be anagrams of the subsets of: 

['A', 'E', 'N', 'R']
Sensory Interface:

Well, this semester, I have already been taught some insanely great stuff. I have a bunch of exams coming up. Great scores will be the perfect way to make an awesome semester even better.

The script can be downloaded here.
The material here was used from Professor Greg Francis’ notes on Neural Learning.

Post’s Machine Emulator

Shriphani — Sat, 17 Jan 2009 19:42:35 +0000

I was bored as usual and since Combat Arms has begun to slip in my list of pastimes, I decided to write a Post’s Machine Emulator as described in the booklet by V. A. Uspensky titled “Post’s Machine” ( Amazon Link

This machine has a tape (infinitely long) and the reel has cells which can be marked or unmarked. I decided to represent a marked cell with a “1″ and an unmarked cell as “0″.

The head of this machine can move both ways and can mark and at the same time remove the mark from the other side.

The machine can be instructed using the syntax:

number, action, jump

The position of the head is indicated by a structure \”[]\” around the cell. Example:

Initial Stage
.....[0], 0, 0, 0, 0, .....

I used the “…..” to indicate that the remnant cells are all unmarked.

So here are the Head and Tape classes:

class Cell:
”‘Class describing the cell of a tape’”

def __init__(self, mark=0):
”‘Each cell is unmarked by default’”
self.mark = mark

def setMark(self):
self.mark = 1

def remMark(self):
self.mark = 0

class Tape:
”‘Class describing the infinite reel in the machine’”

def __init__(self):
”‘Each tape has an infinite number of cells both ways’”
self.reel = []
for i in xrange(5): #we display only the required elements at a time
cell = Cell()
self.reel.append(cell)

def __str__(self):
printstr = "….."
for cell in self.reel:
printstr += str(cell.mark)+","
printstr += "….."
return printstr

class Head:
”‘Class describing the head’”

def __init__(self, tape, position=0):
self.position = position
self.tape = tape

def moveLeft(self):
if self.position != 0:
self.position -= 1

else:
extension = []
extension.append(Cell())
self.tape = extension + tape.reel

def etchMark(self):
self.tape.reel[self.position].setMark()

def remMark(self):
self.tape.reel[self.position].remMark()

def moveRight(self):
if self.position == len(self.tape.reel) – 1:
self.tape.reel.append(Cell())
self.position += 1

def getPosition(self):
return self.position

Then comes the Machine class which takes a tape as an argument. So that you can insert your own tape or use the default tape:

class Machine:
”‘Class describing the Post Machine’”

def __init__(self, tape):
self.tape = tape
self.head = Head(tape)
self.commands = {}

def parseInstruction(self, number, action, jump):
”‘Instruction is of form "[number, action, jump]"’”
self.commands[number] = [action, jump]

def beginExecution(self):
instruction = 0
action = self.commands[instruction][0]

while action != "exit":
if action == "<":
self.head.moveLeft()
elif action == ">":
self.head.moveRight()
elif action == "mark":
self.head.etchMark()
elif action == "unmark":
self.head.remMark()

print self
instruction = self.commands[instruction][1]
action = self.commands[instruction][0]

return

def __str__(self):
”‘This returns tape with the head displayed’”
a = str(self.tape)
posn = self.head.getPosition()
temp = "….."
for i in xrange(len(self.tape.reel)):
if i == posn:
temp += "["+str(self.tape.reel[i].mark)+"], "
else:
temp += str(self.tape.reel[i].mark) + ", "
temp += "….."
return temp

Next comes a function that reads an input file for instructions:

def run(input_file):
infile = open(input_file, ‘r’)
b = infile.readlines()
for instruction in b:
try:
splits = instruction.split(",")
number = int(splits[0].strip())
action = splits[1].strip()
if action == "exit":
a.parseInstruction(number, action, 0)
else:
jump = int(splits[2].strip())
a.parseInstruction(number, action, jump)
except KeyError:
return
infile.close()
a.beginExecution()

A bunch of instructions which need to be written to some file:

0, >, 2
1, <, 0
2, >, 3
3, >, 4
4, >, 5
5, mark, 6
6, >, 7
7, exit

The output:

pal-178-222:~ shriphani$ python post.py
Initial Stage
.....[0], 0, 0, 0, 0, .....
File: input_file
.....0, [0], 0, 0, 0, .....
.....0, 0, [0], 0, 0, .....
.....0, 0, 0, [0], 0, .....
.....0, 0, 0, 0, [0], .....
.....0, 0, 0, 0, [1], .....
.....0, 0, 0, 0, 1, [0], .....
pal-178-222:~ shriphani$ python post.py

The full script can be obtained at http://shriphani.com/scripts/post.py

Well, later.

RPN Calculator – Keeping Boredom Away

Shriphani — Wed, 14 Jan 2009 20:09:35 +0000

Alright, those who know me well are bound to ask, 19 credit hours and you are bored? Answer: Yes. It is still the first week and we don’t seem to have gotten beyond the “introduce your loser self to the other non-interested members of the class” and since I have only 1 programming intensive course this semester, I should have lots of time to kill.

Well, my first script this semester is an RPN calculator. Totally useless for the vast majority of people out there but they know what to expect from someone who likes theoretical computer science.

So, I first began with a stack – in this case an array. I then keep populating it with numbers and every time the state of the stack changes, it prints out the current state.

If an operation is entered (only +, -, * and /), it performs the operation, replaces the appropriate positions in the stack and then prints out the current state.

Here is the code, Its been a while since I wrote any OOP stuff in Python and the “self” especially feels weird after an entire semester of Java…

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#RPN Calculator

class Machine:
def __init__(self, stack=[]):
self.stack = []

def modifyStack(self, element):
”‘add to stack if input is float else run operation or complain’”

if self.isOperator(element):
self.operate(element)
self.printStack()
elif self.isFloat(element):
self.stack.append(element)
self.printStack()

else:
print "Only numbers and operators"

def isFloat(self, char):
”‘Checks whether the last item entered in the stack is a float or not’”
try:
float(char)
except ValueError:
return False
return True

def isOperator(self, char):
”‘Checks whether the last item entered in the stack is an operator or not’”
if char == ‘+’ or char == ‘-’ or char == ‘*’ or char == ‘/’:
return True
else:
return False

def operate(self, operator):
”‘Perform the stated operation on the last two elements in the stack’”

operand1 = float(self.stack[-1])
operand2 = float(self.stack[-2])

self.stack.pop(-1)
self.stack.pop(-1)

if operator==‘+’:
self.stack.append(operand1+operand2)

elif operator==‘-’:
self.stack.append(operand2-operand1)

elif operator==‘*’:
self.stack.append(operand1*operand2)

elif operator==‘/’:
self.stack.append(float(operand2)/float(operand1))

else:
print "God only knows what operation you have typed in"
self.stack += [operand2, operand1]
self.printStack()

def printStack(self):
print self.stack

def kickOff():
calc = Machine()
while True:
a = raw_input(‘Input: ‘)
if a != ”:
calc.modifyStack(a)
else:
calc.printStack()
raise SystemExit

print"Press Enter to Quit\n"
kickOff()

The calculator in action:

pal-179-083:~ shriphani$ python rpn.py
Press Enter to Quit

Input: 1
['1']
Input: 2
['1', '2']
Input: 3
['1', '2', '3']
Input: 4
['1', '2', '3', '4']
Input: 5
['1', '2', '3', '4', '5']
Input: +
['1', '2', '3', 9.0]
Input: h
Only numbers and operators
Input: -
['1', '2', -6.0]
Input:
['1', '2', -6.0]

In other news, I am really pissed with Picasa since I can’t see how many people have viewed my pics (http://picasaweb.google.com/shriphanip in case you are interested), I have begun filling my playlists with songs played at apple keynotes and in apple ads. Friends say this is an obsession with everything with the Apple stamp on it. I basically don’t care.

There has always been this one question bugging me since last semester. In Java:

class Test
{
public static void main(String[] args)
{
int a = 012345;
System.out.println(a);
}
}

When I run this:

pal-179-083:~ shriphani$ java Test
5349
pal-179-083:~ shriphani$

What is happening here?

Anyway, looking forward to this semester. Hope my GPA stays at 4.0

Curious Fractions

Shriphani — Fri, 14 Nov 2008 16:52:11 +0000

While suffering from conjuctivitis, fever, a sore throat and what seems to be a case of swollen tonsils determined to make nutrition a pain for the next week or two, I decided to solve a problem on Project Euler. The question I picked was Problem 33: Find all fractions with the given unorthodox cancelling method (just click the fscking link for heaven’s sake!).

I thought this problem can be solved by beginning with a base fraction and adding a numbers in the tens place to both the numerator and the denominator, then adding a number in the units place to the numerator and the denominator, adding to the units place in the numerator and the tens in the denominator and the other way round.

The code needed (in Python2.6 – just love the Fractions module there):

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Blog: http://shriphani.com/blog
#Mail: shriphani@shriphani.com

frac_list = []

from fractions import Fraction

prod = 1

def findLeft(num, den):
”‘Given a denominator, numerator pair, return the double digit possibilities by appending chars to the left’”
global prod
for i in xrange(1, 10):
if i == num or i == den:
continue
else:
if Fraction(10*i+num, 10*i+den)==Fraction(num, den):
frac_list.append(Fraction(num, den))
print num,den

def findRight(num, den):
global prod
for i in xrange(1, 10):
if i == num or i == den:
continue
else:
if Fraction(10*num+i, 10*den+i)==Fraction(num, den):
print num, den
frac_list.append(Fraction(num, den))

def findAlt(num, den):
global prod
for i in xrange(1, 10):
if i == num or i == den:
continue

elif Fraction(10*num+i, 10*i+den)==Fraction(num, den):
frac_list.append(Fraction(num, den))

elif Fraction(10*i+num, 10*den+i)==Fraction(num, den):
frac_list.append(Fraction(num, den))

for i in xrange(1, 10):
for j in xrange(1, 10):
if i==j:
continue
else:
findLeft(i, j)
findRight(i, j)
findAlt(i, j)

prod = 1
for i in xrange(len(frac_list)):
if frac_list[i] < 1/1:
prod *= frac_list[i]

print prod

BTW, it is funny how total nutjobs with no clue about probes, payloads, science or physics take up the job of reporting the Chandrayaan’s progress.

Peace…..

Awesome Developments

Shriphani — Thu, 30 Oct 2008 10:26:23 +0000

So, I’ve had the best week of my life and let me tell you folks, nothing’s better than sitting in front of one of the most awesome boxes in the world – the macbook pro. Yes, the alpha and the omega is here, I am now the proud owner of a macbook pro (not the new ones, this is the older version). So, here are the specs:

2.5 GHz

2 GB RAM (Vista was a PITA on 2 Gigs, OS X is such a beauty)

512 MB NVidia 8600M GeForce

Intel Core2Duo (obviously)

And so, here are a few select screenshots:

And of course:

And then comes:

By the way, that is how beautiful Komodo looks.

Then of course:

That is what iPhoto looks like.

BTW, between a tough courseload which does not require me to use Python, I managed to squeeze some time for myself so I could automate a few modular arithmetic algorithms.

The first one I shall be dealing with is modular exponentiation.

If we have a^k mod n, then we can express it as
(a mod n)^k mod n.

This allows us to express this in the form of code as:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: spalakod@purdue.edu
#Blog: http://shriphani.com/blog

def modular(base, exponent, divisor):
false_exponent = 0
result = 1

while false_exponent < exponent:
result = ((base%divisor)*result)%divisor
print result
false_exponent+=1

return result

Then of course comes finding the modular inverse using euclid’s algorithm:

def extended(a, b):
if a % b == 0:
return (0, 1)

else:
(x, y) = extended(b, a%b)
return (y, x-y*(a/b))

That should return a tuple whose first element is the GCD. Well, I am going to have fun with the Macbook.

Awesome Problem

Shriphani — Thu, 25 Sep 2008 00:48:39 +0000

I had the opportunity to work on an interesting problem:

Find a decent approximation for the Zeta function (large values), given by:

So, to make any sort of headway, I decided that I would have to look at the graph. Hence, I whipped up a script in Python:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#Blog: http://shriphani.com/blog

#Generate the plot of the Zeta function.

from pylab import * #imports the matplotlib graphing library

def zetaValue(n):
”‘Returns the value of the Zeta Function n’”
val = 0
for i in range(1, n+1):
zeta_term = float(1)/float(i**2)
val += zeta_term
return val

def makePlotRange():
”‘Generates an array of form [domain_list, values_list] for 1<1000′”
num_list = [] #This contains the domains
range_list = [] #Contains value returned by Zeta function for every element in domain
for i in xrange(1,1000):
num_list.append(i)
range_list.append(zetaValue(i))
return num_list, range_list

plot_range = makePlotRange() #gets the arrays

plot(plot_range[0], plot_range[1], ‘bs’)
savefig(‘zetaplot.png’)
show()

This looks a like:

plot of the zeta function

Observe this plot. We can see that there is a horizontal asymptote at x = 1.65 .

Hence,

This leads me to conclude one bloody thing:

And,

Now, it shouldn’t come a surprise to all math or CS majors that g(x) is a function whose denominator has a higher degree than the numerator. So for the sake of simplicity, I shall assume that;

Another reason prompting my eagerness to pick that particular function is because of the following observation:

1/x is a rectangular hyperbola which looks like:
Rectangular Hyperbola
If you use -1/x , the graph is rotated about the X axis and it looks like:
Inverted Rectangular Hyperbola
So, if you look at the positive X axis, we have already managed to replicate behavior of the Zeta function. All we need to do is move it up and ensure that the limit stays.
To move this graph up, just add 1.65 to f(x) and it will work:
Inverted Rectangular Hyperbola Moved Up by 1.65
So, the limits match, the behavior matches and all we need to do is test:

I fired up Python again and wrote this code to perform the final test:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#Blog: http://shriphani.com/blog

from pylab import * #imports the matplotlib graphing library

def zetaValue(n):
”‘Returns the value of the Zeta Function n’”
val = 0
for i in range(1, n+1):
zeta_term = float(1)/float(i**2)
val += zeta_term
return val

def makePlotRange():
”‘Generates an array of form [domain_list, values_list] for 1<1000′”
num_list = [] #This contains the domains
range_list = [] #Contains value returned by Zeta function for every element in domain
for i in xrange(1,1001):
num_list.append(i)
range_list.append(zetaValue(i))
return num_list, range_list

plot_range = makePlotRange() #gets the arrays

def hypoFunction():
num_list = []
range_list = []
for i in xrange(1, 1001):
num_list.append(i)
range_list.append(float(-1)/float(i) + 1.65)
return num_list, range_list

other_range = hypoFunction()

plot(plot_range[0], plot_range[1], ‘bs’, other_range[0], other_range[1], ‘ro’)

savefig(‘zetaplot.png’)

show()

And this looks like:

A Plot of Proposed Approximation and The Zeta Function

Hey, this thing seems to replicate the behavior of the Zeta function way below x=100. Assignment done !!!!

I had another question which is coming up in the next post. I am in love with Discrete math.

Anyway, I attended this job fair thingy and got free stuff from Google, MS and others (MS was giving us ping-pong balls…). Google’s pens are serving me well. Anyway, I am sure I won’t be accepted as an intern anywhere thanks to the fact that every company thinks that freshmen are losers and don’t deserve to be emloyed right in their first year.

Anyway, keep waiting for the second approximation I did.

Pythagoras and lambdas…..

Shriphani — Sat, 23 Aug 2008 22:13:45 +0000

Here is the first bit of code I’ve ever written at college (on my own computer though, I’ve concentration problems in the lab). I was solving problem 39 of the project euler problem set (and I am ashamed of my work). So the question is:

If p is the perimeter of a right angle triangle with integral length sides, {a,b,c}, there are exactly three solutions for p = 120.

{20,48,52}, {24,45,51}, {30,40,50}

For which value of p 1000, is the number of solutions maximised?

So, I decided that I could look for Pythagorean triplets using the following snippet:

def checkCond(a, b, c): #c is the bloody hypotenuse and a
if c ** 2 == a ** 2 + b ** 2 and a + b + c < 1000:
return True
else:
return False

for c in xrange(1000):
for b in xrange(c):
for a in xrange(b+1):
if checkCond(a, b, c):
if peri_count.has_key(a+b+c):
peri_count[a+b+c] += 1
else:
peri_count[a+b+c] = 1
else:
continue

That gives us a dictionary whose (key, value) pairs are (perimeter, count). We need the max count and then pick the corresponding perimeter. I hence wrote a small function (which was very inefficient) to make the value the keys and the keys the values. I think it is the second time I used “lambda”:

def flip(dict_name):
”‘Flip the dictionary’s (key, value) pairs to (value, key)”‘
return dict(map(lambda item: (item[1], item[0]), dict_name.items()))

and finally, to complete the script:

peri_count = flip(peri_count)

max_no = max(peri_count.keys())
print peri_count[max_no]

So, here are the rather shameful execution stats:

$ time python euler39.py
840

real    3m15.140s
user    0m0.046s
sys     0m0.015s

I suggest you throw a glance at the awesome header that http://desk.stinkpot.org:8080/blog/ has.

Happy Coding.

Factoradic

Shriphani — Wed, 13 Aug 2008 19:02:28 +0000

I was trying to solve the lexicographic permutation problem yesterday and out of plain curiosity, I decided to carry out some research on Wikipedia. I found this thing called factoradic which is a factorial-based number system. I conveniently used this thing to approach the solution and decided to work out how factoradic actually worked.

I decided to assign this thing called a rank to the permutation. So assuming that we have 9 digits [1, 2, 3, 4, 5, 6, 7, 8, 9] and that we need to find the 2092nd lexicographic permutation, we begin as follows.

Assume that the first digit is 1 (the smallest of the digits we have). There are 8 remaining digits. So, the maximum number starting with one should occupy the 40320th position ( 8! = 40320 ). Since 2092 < 40320, we know that the first digit is 1.

Now, we place the next smallest digit beside 1. We have 7 digits left and the maximum number whose 1st two digits are 1 and 2 occupies the position 5040. 2092 < 5040 and hence, we can confirm that the first two digits are 1 and 2 indeed. We now append 3 at the end of our current permutation. We have 6 other digits and hence the maximum number of numbers we can get with 123 in front is 720. Now, 2092 > 720 and this means that the number placed 2092 is greater than “123xxxxxx” where the “x” represent the digits we have not come across yet.

We now replace 3 by 4 (the permutation becomes “124xxxxxx”). The maximum number of numbers is 720 + 720 = 1440 which is still lesser than 2092 and we can safely replace 4 by 5 and the maximum position we get is 1440 + 720 = 2160 which is greater than 2092. So the permutation now looks like “125xxxxxx”.

Placing the minimum number from the remaining numbers after 5 in our permutation (the number is 3), we get something like “1253xxxxx”. The maximum rank is 1440 + 5! = 1440 + 120 = 1570. This falls short of 2092. So we replace 3 by 4, the maximum position is 1440 + 120 + 120 = 1690. Still short, put 6 there, the maximum position is 1810. Put 7 there, the rank becomes 1930. Put 8 there and the rank becomes 2050. Still short, replace 8 by 9 and 2170 is what we get. So our permutation now looks like “1259xxxxx”.

It should be straightforward from here on. Proceed in this fashion and you should end up at 125963784.

If you look at the above procedure and note down the number of replacements, you get the factoradic! It is as simple as that.

So, I whipped up a small script to get the factoradic:

First a straightforward factorial function:

def factorial(n):
if n==0 or n==1:
return 1
else:
return n * factorial(n-1)

Then, a function that greedily chooses the digit of the factoradic:

def genFact(decimal_num, position):
for i in xrange(position, -1, -1):
fact = factorial(position) * i
if fact < decimal_num:
return i, decimal_num – fact
else:
continue

Finally a function that generates the entire factoradic:

def getFactoradic(decimal_num, length):
factoradic = []
num = decimal_num
for i in xrange(length-1, -1, -1):
bag = genFact(num, i)
factoradic.append(bag[0])
num = bag[1]
return factoradic

Testing this on 2092 with an initial number containing 9 elements, we get:
[0,0,2,5,2,0,1,1,0]

Which leads us to the answer from my calculations.

I decided to solve the project euler problem (number 24) on lexicographic permutations using this algorithm and the factoradic I obtained was [2, 6, 6, 2, 5, 1, 2, 1, 1, 0] which leads us to 2783915460 which turned out to be the right answer.

You can obtain the factoradic generating script at http://shriphani.com/scripts/factoradic.py .