Question

Manish was on his way to an interview. On the way, he encountered his long lost cousin, Vijay, whom he hadn’t met in more than a decade. They started catching up on lost time. Manish learned that Vijay had 3 sons. When he asked about their ages, Vijay replied, “You’re going for an interview, right? Consider this a trial question. Figure out their ages from this: The product of the ages of my three sons is 36.” To this, Manish grumbled that he needed more information. Vijay, then, pointed to a sign board across the street that displayed the address of the area and said that the sum of the ages of his three children was equal to the last two digits of the pin code (zip code) of that area. Manish demanded still more information. Finally, Vijay said, “My eldest son wore a black shirt today. This is all I can tell you.”

What were the ages of the three children?

Solution

Say the ages are a, b and c. We know from clue 1 that a.b.c = 36, where “.” represents multiplication. First step in identifying such factors is to factorize 36 into its smallest factors – 1.2.2.3.3. The next step is to figure out how to group these 5 numbers into 3 groups. Note that we can have more 1s in the factorization. For example, what if 2 kids are 1 year old and 1 “kid” is 36 years old? So, to allow that to happen, we need another 1 in the factors. So the factors are 1.1.2.2.3.3. By trial and error, we recognize that the way to make 3 groups from 6 objects is by making groups of:

1 + 1 + 4 (call it Grouping Style 1, or GS1)

1 + 2 + 3 (call it Grouping Style 2, or GS2)

and 2 + 2 + 2 (call it Grouping Style 3, or GS3)

GS1 requires selecting 1 out of 6 for the first component, 1 out of remaining 5 for the second component and the remaining 4 automatically go into the third component. There are 6 ways to choose the first component, 5 ways to choose the second component and 1 way to chose the third component. This gives us a total of 6.5=30 combinations for GS1. Many of these will turn out to be identical. After some work, we can whittle down the GS1 groupings to the following:

1,1,36

1,2,18

1,3,12

2,2,9

2,3,6

3,3,4

GS2 requires selecting 1 out of 6 for the first component, 2 out of 5 for the second component and the remaining 3 automatically go into the third component. There are 6 ways to choose the first component, 5C2 = 10 ways to choose the second component, and 1 way to choose the third component. This gives us a total of 6.10=60 combinations for GS2. In reality it is easier to work it out by trial and error. After some work, and after recognizing and ignoring the combinations that we have already seen under GS1, we can whittle down the GS2 groupings to the following:

1,4,9

1,6,6

Similar analysis for GS3 gives us no new combinations.

Before we can use clue 2, we need to add up the ages in these combinations. Doing so, we get the following:

1+1+36=38

1+2+18=21

1+3+12=16

2+2+9=13

2+3+6=11

3+3+4=10

1+4+9=14

1+6+6=13

Notice that all the combinations give us unique totals, except for two combinations which both give us 13. The fact that the second clue did not suffice to answer the question indicates that the total of the ages must have been 13. The children could be aged (2,2 and 9) or (1,6 and 6). Any other value for the total age and the answer would have been clear after clue 2.

Clue 3 tells us of the existence of an eldest child. The color of the shirt is immaterial. In the (1,6 and 6) combination, there is no eldest child. There are 2 elder children, who are twins. In the (2,2 and 9) combination, there is an eldest child. Hence, that is the answer. The children are aged 2 years, 2 years and 9 years.

Intersecting Ramanujan’s trail

With the specific problem out of the way, let us think about a generalization to the problem. India’s best known mathematician, Srinivasa Ramanujan, hiked (given his genius, he probably breezed) along a mathematical thought process, probably in 1913, leading to his work on Integer Partitions. In attempting to solve this problem, I seem to have unknowingly stepped onto this trail briefly. Let me explain. Remember that we had to figure out how many ways could 6 objects be grouped into 3 groups. I listed these out as groupings with (1,1,4), (1,2,3) and (2,2,2) objects. There are 3 grouping styles possible, no more, no less. But as the number of total objects grows larger, or the number of groups to create changes, the number of such grouping styles are harder to figure out. At least they seem to follow no simple pattern. For example, to group 6 objects into 2 groups, there are also 3 ways – {5,1}, {4,2} and {3,3}. To group 7 objects into 2 groups, there are only 3 groupings – {6,1} and {5,2} and {4,3}. To group 7 objects into 3 groups, however, there are 4 groupings – {1,1,5}, {1,2,4}, {1,3,3}, and {2,2,3}.

The question is, is there a more general formula to figure this (the number of distinct ways to group N objects into G groups) out? And another question is – what is Integer Partitioning and how is that related to this problem?

So before going into the theory, let us try to do look at this problem from different angles, and we may see an opening to solving it. Let us use the following example – find the number of ways of grouping 7 objects into 2 groups. We discovered (through some mental enumerations, I admit) that there are three grouping styles – {6,1}, {5,2}, {4,3} – possible here. But now, let me draw your attention to a simple fact – notice that the sum of the numbers each of the groupings is equal to 7. Hardly a surprise, you say. There were 7 objects to begin with. And regardless of how we group them, the total object count is 7. Big deal! But it is often rewarding to look at problems from a different perspective. We now know that “grouping 7 objects into 2 groups” is essentially the same as “finding 2 positive integers that add up to 7″. How many ways are there to add up 2 positive integers to get a total of 7? 6+1=7 and 5+2=7 and 4+3=7. No more ways to do it. So, the number of ways to group N things into G groups is equal to the number of ways to add G positive integers to make N. Allow me create a short hand notation to identify this count. I will use P(N,G). P for partition, but really you can use any symbol. I think it only makes sense when N>=G. Otherwise P(N,G)=0.

P(N,G) = number of ways to add G positive integers to make N = numbers of ways to divide N objects into G groups

There are a couple of simple properties of P(N,G) which are easy to observe. There is only 1 way to divide N objects into N groups, and that is to assign 1 object per group. Similarly there is 1 way to divide N objects into 1 group, and that is to place all objects into 1 group. Symbolically,

P(N,N) = 1

P(N, 1) = 1

OK, I think we have beaten that one into submission (if not to death).

Note that we have only defined it. We we after a general formula for P(N,G). And we do not have that yet.

Now, let us visualize this slightly differently, meditate upon it a bit, and see if we can uncover some other properties about P(N,G). The following figure shows the objects, and groupings, visually. This style of representation, called, Ferrers Diagrams, uses one dot for one object. And it arranges the dots in each group along a column. There are 3 groupings shown – these are our friends {6,1}, {5,2} and {4, 3}. If we stare at this for some time we realize that the reason there are 2 columns is because we wanted 2 groups. This means there is at least 1 row, the first row, which has 2 dots in each of the groupings. Now, imagine that we remove those two dots from each of the groupings. What are we left with?

The figure below shows the case where the 2 dots in the first row are removed. We are left with 5 dots. But more importantly notice the groupings that are left. {5}, {4,1} and {3,2}. These are some of the ways you can group 5 objects. This time, we do not necessarily group 5 objects into 2 groups – since we have a grouping, {5}, with only 1 group. It may be interesting to see how many ways there are in all to group 5 objects – not necessarily into 1 or 2 groups, but rather into any number of groups.

The following figure shows all the ways to group 5 objects.

1 group – {5}

2 groups – {4,1}, {3,2}

3 groups – {3,1,1}, {2,2,1}

4 groups – {2,1,1,1}

5 groups – {1,1,1,1,1}

Note that the number of ways to group 5 into 1 and 2 groups in this figure exactly matches the 3 groups in the previous figure. That is P(7,2) = P(5,1)+P(5,2)! That is a breakthrough. So maybe there is a way to break down any P(N,G) into smaller and smaller pieces and add up the totals of the smaller pieces. For example, P(N,G) = P(N-G,1)+P(N-G,2)+ … + P(N-G,G). Let’s try this for P(7,2).

P(7,2) = P(5,1) + P(5,2) = 1 + P(3,1) + P(3,2) = 1 + 1 + P(1,1) = 1 + 1 + 1 = 3

Not quite a closed form, but an recursive solution.

Integer Partitioning and a Generating Function for it

By the way, this is a good place to (finally) get into Integer Partitioning. In the figure above we listed out all the ways to group 5 objects. That is the Integer Partitioning of 5. I use P(5) to represent it.

P(5) = P(5,1) + P(5,2) + P(5,3) + P(5,4) + P(5,5)

Though it is possible to use the recursive technique I described above to solve for P(5) term by term, there is a very interesting alternative way to figure it out. It is based on a near mind-bending technique, based on Generating Functions. It is powerful technique, used in many different places. I have not yet been able to pin down if the abstraction involved in using Generating Functions is pure genius or if it simply falls out of the mechanics of mathematics if only you start from the correct perspective. Let me attempt to convey how Generating Functions work in this specific situation.

We want to find out all the possible ways to group N objects. But instead of starting with this specific problem we turn the problem on its head and solve a much more general problem. Let us use a bunch of 1s, a bunch of 2s, a bunch of 3s etc. and see what we can add them up to. We do this exhaustively. That is, we we do not let any combination fall through the cracks. Then, we can count up all the different ways a bunch of addends give us the total N. For example, if N is 5, and we do this exhaustive (but structured) adding of all integers (repetitions allowed) and see how many combinations add to 5. We can be sure that none of the addends will be 6 or greater. Similarly, the number of addends will also be no greater than 5, because each addend is at least 1, and with 5 1s we already are at 5. So, the number of combinations we need to look at only needs to cover the addends 1 through 5, and no more than 5 of those addends.

This exhaustive search seems hard to do. But generating functions provide a structured method to approach this. Let us do it one step at a time. We will look at the potential contributions to the total, of each candidate addend one at a time.  Let us look at the addend 1. What totals can 1 contribute to? 1s can add up to 1 in 1 way, {1}. 1s can add up to 2 in 1 way, {1,1}. 1s can add up to 3 in 1 way {1,1,1} and so on. That is, 1 alone can add up to any N, AND, in only 1 way for each given N. In fact if there is no 1 in the addends, then 1 can contribute 0 to the total. In generating function terms this would be represented as follows:

What? Where did that come from? That is typically, always the reaction in my own mind when I see that. Essentially, the order of , which is k, indicates the total that the addends (remember we are only talking about the addends being 1) add up to. The coefficient of , which is 1, indicates the number of ways the addends can be added up to get to k. There is only 1 way to do this using only 1s. And there may be no 1s in the addends, and that is the term .

But what if 2s are allowed? There can be 1 two, or 2 twos, or 3 twos, etc. Thus the generating function based on contributions only from twos is as follows:

This basically means twos can add up to 0 or 2 or 4 or 6 or 8 etc.

Now, we know that we can have both 1s and 2s in the set of addends. In fact, we can have 1s, and 2s, and 3s, and 4s etc. Let us restrict the addends to 1s and 2s for the time being. There can be 1 one and 1 two, or 1 one and 2 twos or 2 ones and 1 two etc. How do we mathematically express these combinations? This is where the true import of the elegance of generating functions becomes clear. By allowing the contributions of the addends to be in the power of x position, products of and correctly give us the sum in the power’s position, .  Further, if there are multiple ways to add up to a given addend, they show up in the coefficient position. That is, as an example, say we want to figure out the Integer Partitions of any number N, using only the addends 1 and 2, we can multiply the individual addends’ generating polynomials.

This product of infinite polynomials will give us every possible way to add up 1s and 2s to get us to a specific total N. Say N=5, then we know we need not worry about and above in either polynomial.

And after some math, we end up with the necessary coefficient for , and that is the number of ways to get to 5 using only 1s and 2s.

Now, just extending this to allow contributions from the addends 3, 4, 5 etc., we get the full generating function for Integer Partitioning.

P(N) = coefficient of in

Whew! So we have that out of the way. What amazes me no end is how generating functions are able to hijack this polynomial product form to solve (or, more accurately, bring structure to) seemingly impossible scenarios that need counting. Notice that we still do not have a closed form for the Partition of Integers, P(N). Computers can be employed for the multiplication of terms and accumulation of coefficients.

A Closed Form Approximation

In 1918, Srinivasa Ramanujan and his advisor, G. Hardy, came up with a closed form , albeit a closed form for an approximation to P(N). With the current understanding of Integer Partitioning, this seems like an amazing accomplishment. This closed form was:

This produces pretty good approximations. For example, P(100) = 190,569,292, and this closed form approximates it to around 199 million.

References

1. Joseph Laurendi, Partitions of Integers, 2005, http://www.artofproblemsolving.com/Resources/Papers/LaurendiPartitions.pdf

2. Wikipedia, http://en.wikipedia.org/wiki/Partition_%28number_theory%29

One way to avoid (or, at least drastically reduce) this problem is to either send or store multiple copies of the information. Say you send the message “BILL JOHN” 3 times. One of the times the error converts this to “KILL JOHN”, but two of the times the message transmits successfully. Then you know that most likely the intended message was “BILL JOHN”. Similarly, your bank probably stores your account information of multiple storage locations to avoid this and other problems (such as, catastrophic data loss due to a fire).  However, redundancy is not very efficient, and may be overkill. Further, it may not be always possible to apply (say the communication takes a long time and repeat communication is not possible).

Another solution is to add a small amount of extra information to the message being communicated or stored to validate the correctness of the data. This is, in effect, redundancy, but is often a more space-efficient form of it. Its purpose is primarily to detect errors in the message data, not to handle catastrophic destruction of data (which is the primary purpose of full redundancy). The most common way to detect errors in transmitted data is by the use of parity bits. The data is first divided into blocks of bits, say 7 or 15-bit blocks. Next, for each block of bits a parity bit is added, thus making the block size 8 or 16 bits. For example, if the original data is “10110101000101010″, and the block size is 7 +1 parity bit, then the data is first extended to make it a multiple of 7. So, say the message is changed to “000010110101000101010″. Then, it is broken into 7-bit blocks – “0000101″, “1010100″, “0101010″. And finally, for each 7-bit block one more bit is added. Say, it is added to the right end. The parity bit is dependent on the data bits. The parity bit is set to a 1 or a 0 depending on the number of 1s in the message. If there are an odd number of 1s in the message, the parity bit is set to 1 to make the total parity of the 8-bit block even. I am assuming even parity in this example; the parity may also be set up to be odd. Going back to the example, if there are already an even number of 1s in the 7-bit data block the parity bit is set to 0. The recipient knows what the block size is, where the parity bit appears, and what kind of parity (Even or Odd Parity) is being used. This is part of a pre-established communication agreement. For example, “0000101″ has 2 1s, that is, an even number of 1s. The parity bit is set to 0 and appended to these 7 bits to make the transmission block, “00001010“. Upon transmission, say there is a bit flip and the message becomes “00101010″. The receiver can then figure out that the parity, which is supposed to be even is now odd, and therefore indicates an error. The receiver can then request a retransmission. Notice that the parity bit itself may be transmitted in error, and that triggers an error as well (even though in reality the data bits were all transmitted fine). The size of the block is set to be small enough so that the probability of a bit flip is very very low. More importantly, the probability of two flips is infinitesimally small. Notice that if there are two flips, however, a single bit parity scheme as described above will not work. There is then a need for a more involved parity scheme. If the channel or storage medium has a propensity for unidirectional flips (that is, say it can only flip a 1 to a 0, bit never a 0 to a 1), then a counter may be maintained along with the data to count the number of 1s in the data block. If the number of 1s changes, then the receiver can detect an error. It is a little tricky once you realize that the number of 1s counted must include the number of 1s in the counter itself! The counter bits need to be transmitted as well, and are subject to bit flips as well.

In some situations, there may not be a second copy to rerequest the data upon detecting the error. Or in case of a communication channel, it may take too long to request a replay. And regardless of the application, it seems mathematically challenging to come up with a way to send a message such that not only is the error detected, it is also corrected by the receiver. This was the challenge that Richard Hamming took up an solved in an ingenious way. Here I would like to think through the same problem and come with a solution, which will then help us think through some of Hamming’s thoughts in the 1930s and 40s.  We will stick to the single bit error scenario. We can always reduce the block size sufficiently that only a single bit error can occur with any meaningful probability.

The first insight that led to the discovery of the Hamming code seems to be that some extra meta data (just like parity) needs to be transmitted in addition to the main data. In the presence of this extra data the receiver must be able to identify a bit flip in any bit in the transferred message (including a bit flip in the meta bits).  How do we uniquely identify a bit that flipped? We need to identify the position of the bit that flipped. In a message with d bits of data and p bits of meta data, the total number of transmitted bits is d+p. To identify a unique position where the flip may have occurred, we need log2(d+p) bits. The genius of Hamming was in recognizing that the bits being transmitted should be grouped into several groups such that each bit was a member of a unique set of groups. Further, the binary representation of the bit positions was the simplest way to identify the groups.

Say the message were 10 bits long. That is, d+p=10. The 10 positions can be represented as:

0001 – message bit 1
0010 – message bit 2
0011 – message bit 3
0100 – message bit 4
0101 – message bit 5
0110 – message bit 6
0111 – message bit 7
1000 – message bit 8
1001 – message bit 9
1010 – message bit 10

Notice that we start from 0001, and not 0000. This is because we need to make sure all numbers have 1 (or 0). This means to represent 8 positions (d+p=8), we actually need 4 bits. So the number of groups = log2(d+p+1). Further, notice that the binary representation of every message-bit-position has 1s in unique power-of-2 positions. This is obvious. After all, that is how we represent the positions uniquely. But the insight Hamming was able to draw was that each of the representations (left column above) with a 1 in a certain power-of-2 position could be clubbed together into a group. That is, in the example above, message bits with a 1 in the 2^0 position could be grouped into Club 0. Message bits with a 1 in the 2^1 position could be grouped into Club 1. Notice that some of the numbers which were members of Club 1 were also members Club 0 (for example message bit 3). Similarly, Club 2 and Club 3 could be formed. Further, exactly 4 clubs were needed to identify every bit (including the meta bits uniquely).

0 | 0 | 0 | 1 | – message bit 1  – Club 0
0 | 0 | 1 |0 | – message bit 2 – Club 1
0 | 0 | 1 | 1 | – message bit 3 – Club 0,1
0 | 1 | 0 | 0 | – message bit 4 – Club 2
0 | 1 | 0 | 1 | – message bit 5 – Club 0, 2
0 | 1 | 1 | 0 | – message bit 6 – Club 1, 2
0 | 1 | 1 | 1 | – message bit 7 – Club 0, 1, 2
1 | 0 | 0 | 0 | – message bit 8 – Club 3
1 | 0 | 0 | 1 | – message bit 9 – Club 0, 3
1 | 0 | 1 | 0 | – message bit 10 – Club 1, 3

Notice that no two bit-position-representations can belong to the same set of Clubs. After all, every bit position is represented uniquely in binary, and a 1 in the binary representation corresponds to a “key” to a certain club. No two binary representations are the same and so no two bit-positions can belong to the same club combination.

The groups/clubs thus formed are:

Club 0 – message bits 1, 3, 5, 7, 9
Club 1 – message bits 2, 3, 6, 7, 10
Club 2 – message bits 4, 5, 6, 7
Club 3 – message bits 8, 9, 10

Now, Hamming must have realized that he has created clubs with careful membership such that a unique member could be located if we knew which clubs he belonged to. So, a flipping bit can be located if that flip can identify all the clubs the bit belongs to. The clubs must start with some common property, and the flip must change that property for each club that it belongs to. This would help identify the clubs in which the flipped bit has membership, and by that unique combination, we can identify the flipped bit.

That unique property that Hamming gave each club was parity. Since no two clubs has the same membership, each club needed at least 1 unique parity bit. Since we want to keep the number of parity bits as small as possible to keep the message overhead as small as possible, the smallest solution would need as many parity bits as clubs. And we know that for transmitting d+n bits, we need log2(d+p+1) bits to represent the positions and, therefore, log2(d+p+1) clubs. This leads to the following observation:

The minimum overhead bits/parity bits = log2(d+p+1). But we assumed that the number of parity bits = p.

p >= log2(d+p+1)

Now we know how many groups, which bits make up the groups and the minimum number of parity bits. In the above example with d+p=10, p=4. Thus for 6 data bits we need to transmit 4 parity bits. But we must recognize that the parity bits cannot be simply lumped together into any casually selected positions. This is because without careful selection we may not have at least 1 parity bit per group. For example if the first 4 bit positions of a 10 bit message are used for parity, there would be no parity bits in Club 3. If we instead used the last 4 bits in a 10-bit message for parity, each club would have at least one parity bit, but all 3 of Club 3’s members would be parity bits. This creates a dependency on filling out the parity bits on the sender side. First parity bit 7 would have to be established based on Club 2 which has 3 data bits and only 1 parity bit. Then the remaining parity bits in Club 0 and Club 1 would have to be established, followed finally by the parity for Club 3. Hamming realized that it would be much easier to ensure that one parity bit belonged to 1 club, no more no less. All the members of a club are data bits except the one parity. This helps speed up setting the parity bit – there is no dependency and fixed order in which the parity bits need to be established. The bit positions in the message which belong t0 only 1 club are positions with a single 1 and all else 0s. These are also the power-of-two bit positions. Bit position 1, 2, 4 and 8. By making these bits parity bits, there is another advantage. At the receiving end, once parity is established for the various clubs, if it turns out that club 2 and club 1 are not maintaining parity, then to identify the bit position which flipped all that is needed is to calculate 2^2 + 2^1 = 6. Bit at position 6 is the only bit which is a member of Club 2 and 1 and no other club.

References:
I found this video of a class, held in University of New South Wales, Australia, and taught by Professor Richard Buckland, to be very useful in helping me understand how Hamming Codes work. The Hamming Code material starts at minute 8:00. http://www.youtube.com/watch?v=kE7V7UI4jpk

http://www.justiceharvard.org/

It contains some fascinating discussions on morals, philosophy, rights and justice. Professor Sandel has a very interesting teaching style, where he almost helps the students discover right vs. wrong, rather than just teaching it to them. Also, he has an extraordinary delivery style – careful and sincere. It is clear that he is actively participating in the discussion himself; he tailors the material such that it conveys all the crucial points while at the same time allowing the journey to these crucial points to be shaped by the students in the classroom. The class itself is comprised of over a thousand students, hanging on to every word from the teacher, and is a sight to behold.

A must watch. More accurately, a must think.

The mathematical constant shows up in strange places. Moreover, its significance is not as easy to grasp as that of the other famous constant, , because there is no easy physical object in whose context to imagine it. For example, is the ratio of the circumference to the diameter of a circle. Yes, it is irrational, but if you can get over that mystery (or ignore it for the time being), it is straightforward to imagine what is. Every circle does seem to have a certain circleness, which makes them all look the same. It is intuitively not hard to agree with the hunch that every circle has an unchanging ratio between the circumference and the diameter; and it makes sense to keep that ratio handy and give it a name.

The constant is considerably more elusive. It appears, at first, to be a number you would not go hunting after. You just happen to stumble upon in during one of your mathematical excursions; it seems interesting enough that you then pick it up and put in in your pocket for some potential use later. After stumbling upon the same thing along other mathematical excursions, in hindsight, it does seem to be something rather useful. Something you should have gone looking for.

Jacob Bernoulli, sometime in the late 1600s, stumbled upon this constant when he was trying to calculate the maximum compound interest that can be earned on an investment by compounding continuously.

If you invest 1 dollar in an account that earns 100% annual interest, then after 1 year the value of your investment will be 2 dollars assuming the compounding (interest calculation) happens once during the year. Assuming you do not touch the money and let it grow, by the end of 2 years, the money would have doubled again and you’ll have 4 dollars in all. Now, imagine the bank decided to compound every 6 months instead of once a year. The annual interest rate remains the same, 100%. 50% is applied at the end of 6 months and another 50% is applied at the end of the year. The 1 dollar grows to 1.50 after the first 6 months. For the second half of the year 1.50 dollars grow in value. At the end of the first year, the total value in your account is 1.50 + (1.50*50%), that is, 2.25 dollars. Not bad! Just by compounding every 6 months you made 2.25 instead of 2. Now you start thinking (as, perhaps, did Jacob Bernoulli). What if the bank compounded every 3 months? What if the bank compounded every month? Every week? Every day? Every second? Every picosecond? A similar question is what Jacob Bernoulli asked himself in the late 1600s. It turns out that this calculation results in an infinite series, which when added up closes in on 2.718281…This means if your bank was really generous and compounded continuously, your 1 dollar would become 2.718281 dollars at the end of the year. Quite a swing there – between 2 and 2.71, wouldn’t you say? And this given that the interest rate is unchanged between the two scenarios. (Aside: In general, pay some attention to how often your investments are being compounded, not just to the the annual rate of return.)

That number, 2.718281…, shows up in such seemingly disparate scenarios that it may be hard to see the connection between those scenarios. I recall that the way this constant was introduced to me in school was entirely different from the discussion above. I was taught that , where is a constant, is the only function whose derivative is equal to itself. That is, the slope of the curve is the value of the curve. Wow, I thought. That is quite a curve. I now feel that though that was correct, it may not have been the best way to introduce ; it does not say why is the only function that satisfies this property. Further, it is not explained why a function that does satisfy this property should even be of the basic form , where a is a constant.

I decided therefore to think through two things. First, I wanted to understand why the only function whose slope at a given is the same as its value. I wanted to approach this problem by using the knowledge of this special property, and then trying to come up with the function which would fit this requirement. Second, I wanted to tie together the two seemingly different arenas where e shows up – continuous compounding and as the base of the curve whose slope is equal to its value. There are other areas where shows up also. For example, if the probability of winning a wager is 1 in , and a man places bets, then the probability that he wins at least one bet is . This question is related closely to the hat check problem (also known as Derangements). also shows up in Euler’s Identity. I will need to do more digging before I attempt to understand, intuitively, why shows up in those scenarios so I may not tackle these in much depth in this article.

Why is the only function whose slope at a given is the same as its value?

Before I looked at this particular issue and attempted to uncover the function which gave me this special property, I decided to start small. I decided to look at some other canonical functions that might have been interesting. For example, “What is a function whose value, , is equal to ?”, “What is a function whose value is equal to ?”, “What is a function whose value is equal to ?”. The first question is easy. It defines . The curve for this is a straight line at a angle through the origin. The second one is easy as well. It defines . A parabola passing through the origin, (1,1) and (-1,1). The third question is the easiest of all, but the one that gets us closest to the question we are going after. It defines ! That is silly. Any function will fit. Notice, however, that in the third question the value of the function is dependent on the value of the function and not directly on . This starts to highlight the significance of the question we are trying to answer. We want to discover a function, . There is something quirky going on here. The right hand side is the derivative of the left hand side. So which comes first? It seems like you cannot really know the slope at , until you define . But then, you need the slope of to define because its value is the slope of . It is a bit confusing. The trick is to realize that this function is continuous. So the value of the slope of will be pretty close to the value of the slope of , the slope of the curve just prior to x. (This recursion also vaguely points to an upcoming infinite series.)

Now, let us try to find the function which satisfies the interesting property, . In words, this means the rate of growth of this function at a given point is equal to the value of the function at that point. More on that in a bit. Let us use the fact that the function is continuous and therefore, , the slope of the function at is given by the following.

Since we know that the function we are trying to uncover has the special property that , we can substitute instead of in the previous equation, to get the following.

This can be rewritten as

which in turn can be rewritten as

I will substitute with (this is unfortunately one of those things which you do after you have worked out the steps and realize that doing something like this may make things a little cleaner to understand).

So we get,

Swapping the right and left sides, we get the following.

The above equation represents in terms of . Using steps similar to the ones shown above if we express in terms of we get the following.

Extending this process times we get the following.

If is large enough that then the above equation becomes very interesting.

Notice that is still not a power to any base. So is still not an exponential curve, at least it does not look so. It does seem like it may expand into a sum of polynomials with the largest polynomial being of degree . A polynomial, however large in degree, grows slower than an exponential curve (as long as the degree is finite). However, note that is not a finite integer. It is an infinitely large number because is infinitesimally small. So there is still hope that this sum of polynomials may catch up to an exponential curve. Now, we apply a trick which changes the nature of this curve. A sum of polynomials becomes an exponential curve, and the goes up to a “position of power”. We simply reapply the equation to the and the term in the above equation to get the following.

Now, say we represent by a new variable, . Then the above equation can be written as follows.

which in turn can be written as

And now we start seeing the exponential form emerge. The is the power to which must be raised to evaluate .

This term, , when expanded out (remember that is infinitely large) hones in on a constant, 2.718281. And that is why, a special name is given to this term (). The right hand side thus becomes .

This takes the general form , where , the value of the function at . In other words we have proved that a function that satisfies the property that the curve’s value at any point is equal to the slope of the curve at that point follows the general form of an exponential curve.

How is continuous compounding related to the base of the exponential curve whose slope is equal to its value?

Now that we understand the general structure of the exponential curve and its special property, slope equals value, let us revisit the issue of continuous compounding. How is that related to this curve? It is intuitive once we realize that the rate at which money grows at any point in time is directly proportional to the amount of money in the account at that point in time. This is the same as saying the slope of the curve at a given point is directly proportional to the value of the function at that point. The interest rate plays the role of tempering the proportionality. For example, if the interest rate is 100%, the value of the continuously compounding account after units of time ( years) is . Here is the amount in the account at the beginning (value of the function at ). If the interest rate is 8%, then the value at time years is . Once we see that the two phrases, “slope of a curve is proportional to its value” and “rate of growth of something is proportional to the amount of that something”, are saying the same thing, it is clearer that these two ways of defining or discovering are equivalent.

Other places shows up

Another place shows up is called Derangements, as in the opposite of arrangement. A popular example used to explain this issue is the hat check problem. Say there are people who check in at a party, and the butler takes their hats as they enter the party. There are boxes to hold the hats, one per guest. The boxes have names on them to identify which guest’s hat should go into it. The butler, however, does not know the names of the guests. He puts the hats into those boxes randomly. When the number of hats (and boxes) is large, the probability that no hat is in the right box is . I have been able to work this out mathematically, but I still have not been able to understand this intuitively. Maybe the reason shows up here has nothing to do with the properties of . Maybe it just so happens that the same summation, which adds up to e, , shows up here.

Solution to Hat Check Problem: An Outline

The probability that all hat are in wrong boxes = 1 – probability that at least one hat is in the right box

= 1 – (prob. that the hat is in the right box OR prob that the hat is the right box OR … OR probability that the hat is in the right box)

Note that for the hat to be in the right box the first i-1 hats have to avoid that box. Therefore,

Probability that the hat is in the right box = (probability that the hat has not taken up the right box of the hat).(probability that the hat has not taken up the right box of the hat)…(probability that the hat has not taken up the right box of the hat).(the hat does take up the right box)

Using this, the probability that all hat are in wrong boxes

where,

Putting this back in the equation for the probability we are looking for, we get,

now, replacing by ,

The second term goes to as increases. So we are left with,

I do not know why shows up here. But, well, it does. Yet another place where shows up with unabated vigor is when representing complex numbers, and, of course, in that famous Euler’s equation that brings together 5 of the most interesting quantities in mathematics, . I will go into exploring that another time.

References and Acknowledgments

My discussions with my friend Mani, and my investigations on the internet led to this write up. I found the Wikipedia site very useful to tie together the seemingly unconnected ways in which the constant shows up in real life. The BetterExplained.com website has a very good illustrated tutorial for those who want to understand the concept of in simple terms.

Wikipedia.com – http://en.wikipedia.org/wiki/E_(mathematical_constant)

BetterExplained.com – http://betterexplained.com/articles/an-intuitive-guide-to-exponential-functions-e/

Reference for the population figure: http://www.google.com/publicdata?ds=wb-wdi&met=sp_pop_totl&tdim=true&dl=en&hl=en&q=world+population

The question I posed to myself after thinking through the puzzle was, “How can we divide a square into 7 equal parts with only a straight edge and a compass available?” Note that the question implies that we do not have a ruler or a scale. We have a straight edge, but without any markings on it to indicate inches or centimeters. Even if it did have the markings, such markings can only measure accurately up to a certain level. For example, say you have a scale with markings at the granularity of a millimeter. Say the square had a side equal to some irrational number, say or , or, even a simple integer which is not a multiple of 7, such as, 8 millimeters. There is no way to measure or or millimeters using such a scale.

There are at least 2 approaches to dividing this square into 7 parts. The first is a simpler approach and the second is slightly more involved. Let me talk about the second one first. The first one will then become easy to see. The main intuition behind the first idea is that a triangle’s area depends only on its base and height. If we can mark out 7 equidistant points along the square’s border, thus creating 7 equal bases, we can join the bases to the center of the square to create 7 regions with equal areas. The heights of these shapes will be equal, and the bases are equal by construction.

As shown in the figure to the far left, the corners of the square are joined, and the intersection gives us the center of the square. Then, assuming we already have the 7 equidistant points of the square’s edge marked out,  joining the center to the 7 points creates 7 regions with equal area, as shown in the figure to the immediate left. It may not be obvious why these regions are equal in area. If you divide up the quadrilateral regions (regions with 4 edges) into 2 triangles, you should start seeing that the area of the quadrilateral piece is the same as the area of a triangular piece since they both have the same height (, where is the length of the square’s side) and same base ().

The question then is, how do we make those 7 markings on the square? Let us first imagine that we peel off the edge and lay it out along a straight line. If there were some simple way to then divide the peeled out, straight line edge into 7 equal parts, we can visualize rolling the laid out edge back on to the square. Of course, the actual process would involve measuring the widths of each piece using the compass and then laying them back on the square’s border. At the corners these segments may have to be further broken down into two pieces. How to do that it is relatively intuitive with a compass and I will not go into explaining that. The next two figures illustrate the process of peeling off the edges of the square and laying them onto a straight line, and the process of rolling the laid out edge back on to the square once the 7 equidistant markings have been made.

The question now remains, how do we divide the laid out border into 7 equal pieces. More generally, this question can be posed as, how can we divide any line segment into n equal segments.

The figure to the left illustrates the steps. The steps are labeled (a) through (e). In Step (a), we draw a line using the straight edge at some angle to the line segment to be divided. This edge is shown in a light color and its length does not really matter. Then in Step (b) make 7 equidistant markings on the newly drawn line segment using the compass. The length between the markings does not matter. Just pick something that seems to fit in the space. Then, in Step (c), the 7th such marking and the end of the original line segment are joined. In Step (d), using the compass, identify a point corresponding to the 7th marking, on the other side of the base line segment. Connect the ends of the base line segment to that point and complete the paralellogram shown in the figure in Step (d). Using the compass mark out the other 6 markings on the line on the other side of the base line segment. This is shown in Step (e). Join the corresponding intermediate markings using the straight edge. Voila! The line segment we wanted to divide into 7 pieces just got divided into 7 equal pieces.

Now, by retracing the steps laid out in the figures above, you can divide the square into 7 equal regions. This question is also posed as, “How can you divide a square cake into n equal sized pieces?”. Now that we know how to divide a line into n equal parts using a straight edge and a compass, we may realize that there is a simpler way to divide up the square cake. Instead of dividing up the whole border into 7 equal-length line segments, why not just divide up one side into 7 equal length segments. Then we can cut the square into 7 long rectangles, in a fashion similar to the one proposed in the original puzzle (see the pdf slides posted at the beginning of this article).

This also brings up another interesting question, although quite off-topic, it may seem. We have been using the phrase straight edge throughout this article. But what is straight? How was the first straight edge made? My guess is that a taut string might have been used to define straightness. But then what is space itself is curved? Does that mean a taut string is also actually curved in accordance with the space it is in? What does it even mean to say that space is curved? Curved with respect to what? What is the underlying measure of straightness, against which the space appears curved? There are probably questions for another disussion. I do not know the answer. I will have to think and read a bunch before it may be clear. It may, of course, never be clear. There is no reason everything should make sense. Nature is not obligated to be understandable by humans, much less one particular human that I call me.

Here is a cool tool for playing with and visualizing simple logic gates:

http://joshblog.net/projects/logic-gate-simulator/Logicly.html

Build your own circuit:

(a) Drag over a few gates in the middle.
(b) Drag few switches to the left side as inputs
(c) Drag one or more light bulbs to right as output(s)
(d) Connect items together with wires by clicking on needed endpoints.

Operate it:
(e) Click on switches to toggle inputs between one (blue) and zero (white).
(f) Watch the wires change state — one (blue) and zero (white) and light bulbs go on (blue) or off (off).

Here is my approach and my solution to the problem. This solution has not been verified by Mau or anyone else, and there is a chance that I am missing some aspect of rigor required to make the proof watertight and, thus, self-verifying.

Approach

The space of all nxm matrices can be divided into a disjoint set of matrices that completely span the space. This disjoint set comprises
- matrices which have no row with all n numbers
- matrices which have exactly one row that contains all n numbers
- matrices which have exactly two rows that contain all the n numbers
… so on till
- matrices which have exactly n-1 rows that contain all the n numbers
- matrices which have each of the n rows containing all the n numbers

Now we can solve the problem for each subset that makes up the disjoint set that spans the space of mxn matrices, and add up the individual results. Interestingly, working backwards makes more sense to me. So let’s look at the subset of matrices which have all the n numbers in each of the n nows. There is no candidate matrix here that fails our criterion. All matrices will satisfy the criterion. Let’s call the set of matrices that satisfy the criterion, the set S and those that fail the criterion the set F. Therefore no matrix in this subset adds to F.

Next, let’s look at the subset of matrices which have all the n numbers in exactly n-1 rows. The remaining row, whatever be the number or numbers it carries, will cause the matrix to satisfy the criterion. Therefore no matrix in this subset adds to F.

Next, let’s look at the subset of matrices which have all the n numbers in exactly n-2 rows. The remaining 2 rows, will cause the overall matrix to fail, if they have no more than 1 number in them. That is they remaining two rows must be full of only one number. If a second number exists in either of the two rows, the matrix satisfies our criterion.

And so on.

So, the number of matrices in F is a sum of the following product over all values of i:
(how many ways can we select n-i rows)(how many ways can all n unique numbers show up in each of those selected rows)(how many ways can the remaining i rows contain, at most, i-1 unique numbers)

Solution

Basically, out of all possible matrices with n rows and m cols such that each element is an integer between 1 and n (both included), I try to figure out the number of matrices which do NOT satisfy the condition we are after, i.e., for these matrices you CANNOT select n elements, one on each row, such that the n elements are the n unique numbers, 1 through n. Call this set of matrices, which fail the condition, F (for fail). We are trying to find how many elements are in the set F.

The final answer for the number of matrices the satisfy the criteion, therefore, will be n^(n.m) – |F|, where |F| represents the cardinality of F, that is, the number of elements in set F.

To get to |F|, my line of thinking was:

F =
matrices for which there are, at most, n-1 unique numbers in the n rows
+ matrices for which there are, at most, n-2 unique numbers in n-1 rows and all n numbers in the remaining 1 row
+ matrices for which there are n-3 unique numbers in n-2 rows and all n numbers in the remaining 2 rows + … etc.

By ensuring that all the n numbers show up in the remaining x rows we are making sure that the matrix that satisfies a given term in the above summation does not satisfy the the previous term, and thus avoids being double counted.

Substituting terms,

As a summation, this can be written as

Here is how to understand each term in the summation above:
is the number ways can you choose n-i rows
  is the number ways can you choose the n-i-1 numbers that will go into the selected n-i rows
is the number of ways can those (n-i).m elements in those n-i rows be filled with the chosen (n-i-1) numbers
is the number of ways we can guarantee that the remaining i rows each contain all the n elements.

Anant’s Party Puzzle

Anil and Kavita attend a party with 3 other couples,including Srini and Shyamala (a couple). During the party everyone shakes hands with a certain number of other people that doesn’t include oneself and one’s spouse. At the end of the party Anil asks each person (apart from himself) how many people they shook hands with. He finds that each person answered truthfully and each one gave a different number. Anil did shake hands with Srini. From this information find out
1: Did Kavita shake hands with Srini?
2: Did Kavita shake hands with Shyamala?
Adapted from a puzzle found here (the last but one puzzle June 1998): http://www.research.ibm.com/ponder/

Solution:

Anil asks 7 people and gets 7 different handshake counts. The maximum count can be 6, since a person does not shake his own hand or his spouse’s. The 7 non-negative numbers (there cannot be negative counts) with a maximum of 6 are 0, 1, 2, 3, 4, 5, 6. Whoever has a count of 6 shakes hands with all the other people (other than his or her spouse, of course). Therefore, only that spouse can be the one with the 0 count. If Kavita were the person with the count of 6, no one but Anil could have had the count of 0. But Anil did hear someone else say 0. If Kavita were the person with a count of 0, no one else could have claimed 6. However, someone did. So Kavita does not have a count of 0 either. There is some couple with counts of 0 and 6. If that couple is removed from contention, everyone reduces in count by 1, the 1 coming from their handshake with the person with count 6. Anil and Kavita shook hands with one person in that couple (the one with the count 6). The remaining counts become 0, 1, 2, 3, 4. Whoever has the count of 4, partners the spouse with count of 0, using logic similar to above. Also, this couple cannot be Anil and Kavita. If Kavita had a count of 4, no one could have claimed a count of 0. If Kavita had a count of 0, no one could have claimed a 4. Therefore, the 4-0 pair is not Anil-Kavita. Again, Anil and Kavita shook hands with one person in that couple (the one with the count 4). Removing the 4-0 pair (originally the 5-1 pair) from contention, we have the counts of 0, 1, 2.

Using similar logic as above, the 2-0 pair is not Anil-Kavita. Removing them (original pair 4-2), leaves Kavita alone with the count of 0. Bumping it back to the original count gives us 3. Kavita and Anil shook hands with one person in each couple, and, Anil and Kavita shook hands with the exact same people. So, to answer the specific questions – Yes, Kavita shook hands with Srini, and, No, Kavita did not shake hands with Shyamala.

Raghu’s Peanuts Puzzle

Later, when we visited my cousin and his family in New Jersey, he asked me and Anant a high protein mathematical puzzle laden with peanuts. I will recreate the puzzle from memory here.
There are 5 friends and a pet monkey. They also have a bag of peanuts. The are travelling through a tropical jungle in southern India when they decide to stop for the night in a clearing. They pitch the tent and go to sleep. One of the 5 friend wakes up in the middle of the night, a little hungry. He remembers the peanuts. He steps out quietly, careful not to wake anyone up, with the peanuts bag, divides up the peanuts into 5 even parts. He finds one extra peanut remains after the division. He feeds the remaining peanut to the monkey, eats his share and goes back to sleep. The other 4 friends wake up one after the other also and do the exact same thing as the first guy. Then, morning comes. Everyone wakes up refreshed and, unsurprisingly, a little hungry. They divide up the peanuts in the clearly smaller looking bag. And again just like each of them had found in the night, they find one peanut remaining. They feed that to the monkey, taking the monkey’s total intake to 6 peanuts, and eat the remaining peanuts. How many peanuts were in the bag when they pitched the tent?

Solution:

Raghu had asked me this puzzle about 4 years ago, when I had visited them in Alpharetta (near Atlanta), Georgia. I am not sure if my then recent exposure to discrete mathematics at Purdue University helped, or, as might be more likely, my mathematical intuition worked better then. I was actually able to solve the puzzle without resorting to a spreadsheet or a computer! This time around I found it harder to imagine up a way to solve it without a computer. I did find the answer with a spreadsheet program, but that was hardly consequential. More than getting the answer, this exercise was, for me, a journey in figuring out how to solve it without a computer. And in doing so I learnt something about what such problems are called and a generic way to solve them. This problem appears in several places in the web with coconuts in place of peanuts. The solution also appears in several places. I will try to recreate my approach.

Say, the initial number of peanuts is N.
When the first guy wakes up he sees N peanuts. When he is done eating there are (4/5)(N-1) peanuts.
When the second guy wakes up he sees (4/5)(N-1) peanuts, which is
(4/5)N – (4/5).
Similarly, when the third guy wakes up he sees, (4/5)[(4/5)N - (4/5) - 1] peanuts, which is
(4/5)²N – (4/5)² – (4/5)
Extending the pattern, when the fourth guy wakes up he sees,
(4/5)³N – (4/5)³ – (4/5)² – (4/5) peanuts
Extending the pattern, when the fifth guy wakes up he sees,
(4/5)⁴N – (4/5)⁴ – (4/5)³ – (4/5)² – (4/5) peanuts
When they all wake up the next morning, they all see,
(4/5)⁵N – (4/5)⁵ – (4/5)⁴ – (4/5)³ – (4/5)² – (4/5) peanuts
This, is again divided evenly amongst the 5, after a peanut is given to the monkey. That implies that the above count of peanuts is precisely 5k + 1, where k is some integer.
The final equation looks like,
(4/5)⁵N – (4/5)⁵ – (4/5)⁴ – (4/5)³ – (4/5)² – (4/5) = 5k + 1

This reduces to,
(1024/3125)N-(1024/3125)-(256/625)-(64/125)-(16/25)-(4/5) = 5k+1
=> (1024/3125)N-(1024/3125)-(256/625)-(64/125)-(16/25)-(4/5)-1 = 5k
=> (1024/3125)(1/5)N-(1024/3125)(1/5)-(256/625)(1/5)-(64/125)(1/5)-(16/25)(1/5)-(4/5)(1/5)-1(1/5) = k
=> (1024/15625)N-(1024/15625)-(1280/15625)-(1600/15625)-(2000/15625)-(2500/15625)-(3125/15625) = k
=> (1024/15625)N-(11529/15625) = k
=> 1024N-11529 = 15625k
=> 1024N-15625k = 11529

Finally, we got the equation we were after. But wait a second, there are two variables(N and k) and only one equation! That is the equation of a line. You choose any value of N and you can always find a k. How are we to solve that for a single solution or a set of solutions?
Aha! Integers. N and k can take only integral values. So, even though this is the equation for a line, we are trying to find out if this line passes through the lattice points. Such equations have a special name – Diophantine equations. The one at hand, specifically, is a Diophantine equation of the first order, in two variables. These equations have been studied and solved in texts written between 800 BC and 500 BC in India. Aryabhatta and Brahmagupta (around 400AD to 650AD) gave general solutions to such equations and extended the study to higher order Diophantine equations and ones with more variables.
A generic Diophantine equation looks like ax + by = c, where x and y are the variables that must take integer values. a,b,c are integer constants. A equation of this type may have no solutions or infinitely many solutions. An example of an equation with no solutions is
2x + 2y = 5 (No Solution!)
The above equations has no solution because whatever the values of integral x and y, the left hand side is even and right hand side is odd.
A way to think of it is, you can draw a line on a graph paper such that it neatly avoids all the lattice points. I am not sure about this, but intuition tells me that if a line does cross through one lattice point, it will cross through infinitely many. That is, in other words, there are are either no solutions or infinitely many for a given Diophanine equation of the above form.

Now, coming back to the equation at hand, it is easy to see why a spreadsheet is a tempting approach. You vary N from 1 through a big number. You write k in terms of N, and visually inspect if K ever takes an integer value. Though this approach is what I tried at first, it is both ugly, unsatisfactory and unbounded. There might be no way to figure out if there exists no solution!
The solution that follows is based on the approach shown at this BBC webpage about Diophantine equations.

1024N-15625k = 11529
Now pay careful attention. The right hand side (11529) is odd. The first term on the left hand side (1024N) will always be even, whatever the value of N. The second term on the left hand side (15625k) will be even if k is even, and odd if k is odd. If k is even, the whole left hand side will be even. But since the right hand side is odd, this can’t be. Therefore k must be odd. We can, therefore write k is 2a+1. And the equation becomes,
1024N-15625(2a+1) = 11529
1024N-2(15625)a – 15625 = 11529
1024N-2(15625)a = 27154
Now notice that all the terms have a common factor of 2, which when cancelled out, leaves
512N-15625a = 13577, where k=2a+1
Continuing the above logic, and successively substitution 2b+1 for a, 2c+1 for b etc, when a or b should be odd and 2b for a, 2c for b etc. when a or b should be even, we get the following equations.
256N-15625b = 14601, where a=2b+1
128N-15625c = 15113, where b=2c+1
64N-15625d = 15369, where c=2d+1
32N-15625e = 15497, where d=2e+1
16N-15625f = 15561, where e=2f+1
8N-15625g = 15593, where f=2g+1
4N-15625h = 15609, where g=2h+1
2N-15625i = 15617, where h=2i+1
N-15625j = 15621, where i=2j+1
The final equation gives us,
N = 15621+15625j

The smallest positive solution therefore is N = 15621, when j = 0. This is one valid solution. Substituting N in the original Diophantine equation gives us k = 1023. So the 5 friends could have started with 15621 peanuts and had 1023 peanuts the next morning. Of course, they could have also started with 15625 + 15621 = 31246 peanuts (j=1 case) or even more.
I vaguely remember that this is how I had solved it in Alpharetta, GA, four years ago, without knowing anything about Diophantine equations and Brahmagupta or relying on spreadsheets.

My father’s Walkers Puzzle

Then, a few days back, my father, who loves his daily hour-long walks sent us this walking related puzzle. Later, when I wanted to confirm my answer, he informed me that he made the problem up but had not been able to solve it yet! The fact that he was able to think this up is by itself impressive considering the solution is not straightforward, yet, involves elegant abstraction. Since he thought this up when walking with his good friend who I call Subbanna Uncle, I will recreate the puzzle with my father, Kishore, and Subbanna Uncle participating in the activity.
ABCD is a rectangular park with a walking trail on all four sides. The rectangle is of dimensions a units by b units.
Two walking enthusiasts, Subbanna and Kishore, start walking around the park’s trail with same speed, S units per hour.
Subbanna starts at A and goes around the park covering all 4 sides each time repetedly, AD->DC->CB->BA->AD->DC… and so on.
Kishore starts at the same time as Subbanna but starts at B and walks around the park covering 3 sides repeatedly, BC->CD->DA then he turns back to trace AD->DC->CB, turns back again and so on.
1: How many times do Subbanna and Kishore cross each other while walking for a time period of t hours?
2: How many times do Subbanna and Kishore walk side by side in the same direction?
3: What is the time period before the two walking routines repeat an earlier pattern?

Solution:

The park is a rectangle with sides measuring a units and b units as shown.

The pattern that Subbanna follows is shown with a yellow/orange line and the pattern that Kishore follows is shown with a green line.

The beauty of this problem is that it is easier to solve the puzzle by opening up the paths. Both the paths taken by the two walkers are repetitive. What we need is a repetitive representation that would show intersections of the paths accurately, while clearly laying out the paths in time, so that a repetition does not overlap a previous representation. I chose to keep time on the x-axis and label the corners A,B,C,D on the y axis. The speed being constant keeps the path traced by the walkers straight lines on this graph, and also helps assign a scale for the x-axis.

Subbanna’s pattern repeats every (2b+2a)/S hours, while Kishore’s repeats every 2(2b+a)/S hours, as is clear from the graph. While Kishore is going in the BC->CD->DA direction (downward) he intersects Subbanna’s path once or twice. He cannot avoid intersecting because the distance between two parallel orange lines is less than the length of Kishore’s downward path. If Subbanna’s orange line intersects Kishore’s upward path (AD->DC->CB), that has to be the time they walk together.

After time t, the projection of time on to an axis parallel to Kishore’s downward path, is t*S distance units. This is shown as T is the figure, however, to avoid confusion let us continue to use S*t for that distance. In this time, every orange line (Subbanna’s one loop) causes an intersection with Kishore, except if they overlap. Put mathematically,
the total number of intersections = total number of orange lines – number of times orange line and upward green line coincide
total number of orange lines = (t*S – (2b+a)/2)/(b+a) + 1
“number of times orange line and upward green line coincide” is a little more involved. The first time they coincide, (2b+a)/2+n*(b+a)=m*(2b+a), where m and n are integers. This implies,
n*(b+a)=(m-1/2)*(2b+a)
Multiplying by 2 on either side,
2n*(b+a)=(2m-1)*(2b+a)
If (b+a) and (2b+a) are integers,this will happen if 2b+a is even. If 2b+a is odd, this will never happen and Kishore and Subbanna’s paths never coincide. If (a+b) and (2b+a) are not integers, then I am not sure what the condition is for the paths to not coincide. I assume they will always coincide.
From them on they coincide when k*(b+a)=l*(2b+a), which is every LCM(b+a, 2b+a) units.
Therefore, “number of times orange line and upward green line coincide” = (0 or 1)+(S*t)/(LCM(b+a,2b+a))
Here are the final answers:
1: How many times do Subbanna and Kishore cross each other while walking for a time period of t hours?
(t*S – (2b+a)/2)/(b+a) + 1 – (0 or 1) + (S*t)/(LCM(b+a,2b+a))
2: How many times do Subbanna and Kishore walk side by side in the same direction?
(0 or 1)+(S*t)/(LCM(b+a,2b+a))
3: What is the time period before the two walking routines repeat an earlier pattern?
The time period is when the original situation repeats. That is Kishore is at B and Subbanna is at A.
LCM(2*(2b+a)/S, (2b+2a)/S)
Note: I have used LCM for Least Common Multiple, and I do not restrict it to integers alone.

My friend Srikanth, aka Coffee, sent this question to the egroups after hearing the one Anant had asked me.

A reporter meets two famous mathematicians P1 and P2 in a train and tells them that he is going to whisper the sum of two 2-digit numbers into P1’s ear and their product into P2’s, and then he wants them to guess what those two 2-digit numbers were. After he has whispered the sum and the product to P1 and P2 respectively, the conversation goes as follows:
P1: I don’t know.
P2: I don’t know either.
P1: Now I know.
P2: Now I know too.

What are the two numbers?

Solution

I ended up writing a program for this one too, although if there are paper-pencil or in-the-head kinds of solutions, I’d be happy to hear about those.

Lets take the statements one by one, and see how they reveal more and more detail. Notice that here P1 is the person with the SUM and P2 is the persone with the PRODUCT (other way round compared to the one Anant asked me). Also notice that since the range includes only 2-digit numbers, denoting the two numbers as X and Y, both X and Y lie between 10 and 99.

P1 says: I don’t know.
Deduction: Not very surprising. Unless the sums were 20 , 21, 198 or 197, there are multiple ways to add two numbers to get a SUM in the range 20 to 198.

P2 says: I don’t know either.
Deduction: X and Y are not primes, because if they were, then the product could have given away the factors. In fact, to make it more general, the product P = X*Y is such that there is more than one way to factorize it into valid factors (each factor lying between 10 and 99).

P1 says: Now I know.
Deduction: P1 has a sum S = X+Y such that of all the ways to add up two legal numbers (between 10 and 99) to get S, there is exactly one pair (which P1 could therefore identify), for which the product has more than one valid factorization. If it were any other way of adding up two numbers to add to S, then P2 would have immediately identified the unique factorization.

P2 says: Now I know too.
Deduction: P2 has a product PP = X*Y such that of all the valid (numbers between 10 and 99) ways to factorize it, there is only one pair that adds up to a sum that P1 could have identified. That is, only one factorization of P is such that if the factors were added, that sum could have been reached by only one pair of valid numbers, for the product of which multiple valid factorizations exist.

C Program to solve the same problem (specific to this range, but could be generalized and optimized to save time and space)

    #include <stdlib.h>
    #include <stdio.h>

    main(int argc, char** argv)
    {
      unsigned int i,j,k;

      unsigned int histProducts[10000];
      unsigned int X[10000];
      unsigned int Y[10000];
      unsigned int Z[10000];

      for(i=1;i<10000;i++){
        histProducts[i]=0;
        X[i]=0;
        Y[i]=0;
        Z[i]=0;
      }
      for(i=10;i<100;i++){
        for(j=10;j<100;j++){
          if(i<=j){
            k=i*j;
            histProducts[k]++;
            if(histProducts[k]==1) X[k]=i;
            else if (histProducts[k]==2) Y[k]=i;
            else if (histProducts[k]==3) Z[k]=i;
            //else printf("%d has more than 3 ways of factorizing", k);
          }
        }
      }

      unsigned int histNonUniqueProdsOfComponents[200];
      unsigned int A[200];
      unsigned int B[200];
      for(i=1;i<200;i++){
        histNonUniqueProdsOfComponents[i]=0;
        A[i]=0;
        B[i]=0;
      }
      for(i=20;i<197;i++){
        for(j=10;j<=(i>>1);j++){
          if(j>=10 && j<=99 && (i-j)>=10 && (i-j)<=99){
            if(histProducts[j*(i-j)]>1){
              histNonUniqueProdsOfComponents[i]++;
              A[i]=j;
              B[i]=i-j;
            }
          }
        }
      }

      unsigned int foundValidProds;
      for(i=1;i<200;i++){
        if(histNonUniqueProdsOfComponents[i]==1){
          foundValidProds=0;
          k=A[i]*B[i];
          printf("%d,%d SUM=%d PRODUCT=%d\n",A[i],B[i],A[i]+B[i],k);
          printf("For this PRODUCT %d, the following factorizations exist",k);
          if(histProducts[k]==2){
            printf(" %d*%d,",X[k], k/X[k]);
            printf(" %d*%d\n",Y[k], k/Y[k]);
            if(histNonUniqueProdsOfComponents[X[k]+k/X[k]]==1) foundValidProds++;
            if(histNonUniqueProdsOfComponents[Y[k]+k/Y[k]]==1) foundValidProds++;
            if(foundValidProds==1)
              printf("Of these factorizations only 1 could have been identified by the SUM guy--VALID\n\n");
            else if (foundValidProds>1)
              printf("Of these factorizations >1 could have been identified by the SUM guy\n\n");
            else
              printf("Something is wrong with this factorizations\n\n");
          }
          else if(histProducts[k]==3){
            printf(" %d*%d,",X[k], k/X[k]);
            printf(" %d*%d,",Y[k], k/Y[k]);
            printf(" %d*%d\n",Z[k], k/Z[k]);
            if(histNonUniqueProdsOfComponents[X[k]+k/X[k]]==1) foundValidProds++;
            if(histNonUniqueProdsOfComponents[Y[k]+k/Y[k]]==1) foundValidProds++;
            if(histNonUniqueProdsOfComponents[Z[k]+k/Z[k]]==1) foundValidProds++;
            if(foundValidProds==1)
              printf("Of these factorizations only one could have been identified by the SUM guy--VALID\n\n");
            else if (foundValidProds>1)
              printf("And of these factorizations >1 could have been identified by the SUM guy\n\n");
            else
             printf("Something is wrong with this factorizations\n\n");
          }
          else if(histProducts[k]>3){
            printf(" %d*%d,",X[k], k/X[k]);
            printf(" %d*%d,",Y[k], k/Y[k]);
            printf(" %d*%d,",Z[k], k/Z[k]);
            printf(" OTHERS EXIST TOO\n\n");
          }
        }
      }

    }