## Greatest Common Divisors; Euclidean Algorithm.

### January 5, 2013

Recently, I’ve been learning to program in a new language and have been doing Project Euler problems for practice — of course, as the name suggests, most of these problems deal explicitly with problems which must be solved (efficiently) with mathematical techniques. Two of the most common algorithms I’ve used are: Prime Testing, GCD Finder. I’ll post about the former later, but the latter is an interesting problem in its own right:

**Initial Problem**. Given two natural (positive whole) numbers called , can we find some other natural number that divides both of them?

This problem is a first step. It’s nice to be able to write numbers as a multiple of some other number; for example, if we have 16 and 18, we may write them as and , thus giving us some insight as to the relationship between these two numbers. In that case it may be easy to see, but perhaps if you’re given the numbers 46629 and 47100, you may not realize right away that these numbers are and respectively. This kind of factorization will reveal "hidden" relationships between numbers.

So, given two numbers, how do we find if something divides both of them — in other words, how do we find the *common divisors *of two numbers? If we think back to when we first began working with numbers (in elementary school, perhaps) the first thing to do would be to note that 1 divides *every number*. But that doesn’t help us all that much, as it turns out, so we go to the next number: if both numbers are even, then they have 2 as a common factor. Then we "factor" both numbers by writing them as and then attempt to keep dividing things out of the *something*. We then move onto 3, skip 4 (since this would just be divisible by 2 twice), go onto 5, then 7, then…and continue for the primes. This gives a *prime *factorization, but we have to note that if, say, 2 and 5 divide some number, then so does 10. These latter divisors are the *composite *factors.

This seems excessive, but it is sometimes the only way one can do it.

**Anecdote!: **On my algebra qualifying exam, there was a question regarding a group of order 289 which required us to see if 289 was prime or not; if not, we were to factor it. We were not allowed calculators, so what could we do? Try everything. Note that we only need to try up to the square root of the number (which we could estimate in other ways), but it’s still a number of cases. If you check, none of the following numbers divide into 289: 2, 3, 5, 7, 11, 13. At this point, I was about to give up and call it a prime, but, for whatever reason, I decided to try 17. Of course, as the clever reader will have pointed out, . It is not prime. There was, luckily, only one student who thought it was prime, but it points out how the algorithm above is not entirely trivial if one does not have access to a computer or calculator.

Once we have a common divisor, or a set of common divisors, a natural thing to want to do is to find the *biggest* (we already have the smallest, 1) since in this way we can write our numbers with the largest common factor multiplied by some other number. It will, in effect, make things prettier.

**Real Problem.** Find the *greatest* divisor which is common to two natural numbers, .

If you were just learning about this kind of thing, you may spout out the following solution: find *all *of the common divisors, then pick the greatest. While this is not especially efficient, it *is* a solution. Unfortunately, even for small numbers, this gets out of hand quickly. For example, 60 and 420 have the following common divisors: 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60. This takes a while to compute by hand.

Even if we were to find prime factors, this would be and , which gives us that they share a number of prime factors. A bit of thinking gives us that we take all of the prime factors they "share" and multiply them together to get the greatest common divisor. This is another potential solution which is much faster than simply listing out all of the common divisors. Unfortunately, this falls prey to the same kind of trap that other prime-related problems do: it is, at times, especially difficult to factor large composite numbers. For example, the "reasonably small" number 49740376105597 has a prime factorization of ; this is not at all efficient to factor if one does not have a computer or a specialized calculator with a factoring algorithm on it. As a mean joke, you may ask your friend to factor something like 1689259081189, which is actually the product of the 100,000th and 100,001st prime — that is, they would need to test 99,999 primes before getting to the one which divides the number. If they divided by one prime per second (which is quite fast!) this would take them 1 day, 3 hours, and 46 minutes. Not especially effective, but it *will *eventually get the job done.

**Real Problem, With Efficiency: **Find the greatest divisor which is common to two natural numbers, , but do so in an efficient manner (we’ve all got deadlines!).

We need to sit down and think about this now. We need an entirely new idea. We note, at least, that for the two numbers that one of them must be larger than the other (or else the problem is trivial). One thing to try would be to see if the smaller one goes into the larger one (for example, above we had 60 going into 420, which gave us the easy solution that 60 must be the greatest common divisor). If not, maybe we can see how much is left over. That is, if is the larger number,

where here is the number of times goes into without exceeding it, and is the "remainder"; if it’s equal to 0, then evenly divides into , and otherwise it is less than (or else we could divide an additional into ).

Using this, if , we may write ; this means that, in particular, divides and , so it is a factor of and of . But it may not actually be a factor of ; so let’s see how many times it goes into . Using the same process…

and by rearranging, we have that is divisible by . So, is divisible by , but we aren’t sure if is divisible by …if it were, we would be able to say that was a common divisor of and (why?). That’s *something* at least.

The cool thing about our algorithm here is that, because we have that either and we’re done with the algorithm, or and we may form a new equation ; this equation has, on the left-hand side, the number which is less than the previous equation’s left-hand side, which was . Continuing this process, we will have on the left-hand side, each of which is less than the one which came before it. Because for any of the remainders, *eventually* it will become 0 (why?) and this algorithm will terminate. That is, we will have found *some * which is a common divisor for both ; specifically, it will be the such that (or, it may simply be if divides ).

This algorithm, called the *Euclidean Algorithm,* actually does more "automatically": it not only finds a common divisor, but actually finds the *greatest common divisor *of , which, from now on, we will denote . The "proof" of this is simply noting that (we noted this above without making reference to the gcd, but the reader should attempt to go through all the same steps using the idea of the gcd).

So. If you have two natural numbers, , you divide them, find the remainder, write the equation, then continue as above until you get a 0 remainder. Then you pick the remainder directly before you got 0 as your gcd (or, you pick the smaller number if one number divides the other). Pretty simple algorithm, but is it efficient?

Without going into formal "efficiency" definitions, "yes", it is quite efficient. To prove it, let’s take an "average" example using the "large" numbers 1337944608 and 4216212. We note that (by pen and paper, or by using a standard calculator) that

1337944608 = 317(4216212) + 1405404.

Next, we note that

4216212 = 3(1405404) + 0

which instantly gives us the solution . That’s pretty awesome. Note that this was an especially quick trial, but even the "worst" ones are relatively quick.

**Unexpected Corollary!: **For natural numbers, if then there exists integers such that .

This is more useful than you might think at first glance, and we’ll get into why in a later post, but what’s nice about this corollary is that it comes "for free" from the Euclidean algorithm. Note that, since divides , it suffices to prove this corollary for where have . The proof uses induction on the number of steps of the Euclidean algorithm for those numbers, but for those of you who are more experienced and know modular arithmetic, you may enjoy the following simple proof:

*"Clever" Proof of the Corollary: * Let (for equality, the proof is easy). We will only care about remainders in this proof, so we will look at some numbers modulo . Consider

Note there are exactly remainders here and that the remainder never occurs (since are relatively prime). Suppose that for each of the ; that is, the remainder 1 does not ever show up in this list. By the pigeon-hole principle (as there are remainders but only possible values for the remainders) we must have that for some . That is, we have

which implies

but this is impossible, since it implies that either or is some integer multiple of , but and we have assumes are relatively prime. Hence, the remainder must occur. That is, for some and

But what does this mean? It means that there is some integer such that . To make this prettier, let and we find that there exists integers such that , as required. .

Pretty slick, no?

## Pointwise Convergent Sequence of Polynomials.

### August 7, 2012

An interesting question came up during my studying today which made me think about some of the different ways we can think about polynomials. The solution to this problem was not immediately obvious to me, and, in fact, it wasn’t until I looked up a completely unrelated problem (in a numerical methods book!) that some solution became clear.

**Question: **Suppose that is a sequence of polynomials with each of degree and suppose pointwise. Show that is also a polynomial of degree no more than .

Some interesting points come up here. First is that we only have pointwise convergence — it wasn’t even immediately obvious to me how to prove the resulting limit was *continuous*, let alone a polynomial of some degree. Second, we know very little about the polynomials except for what degree they are. This should be an indication that we need to characterize them with respect to something degree-related.

Indeed, polynomials can be represented in a few nice ways. Among these are:

- In the form where it is usually stated that .
- In terms of their coefficients. That is, if we have a list of polynomials of degree 3 to store on a computer, we could create an array where the first column is the constant, the second is the linear term, and so forth. This is sort of like decimal expansion.
- Where they send each point. That is, if we know what is equal to for each , we could recover it.
- If a polynomial is of degree then, somewhat surprisingly, we can improve upon the previous statement: if we know the value of for distinct points, then we can find , and is the unique such polynomial of that degree which has those values. (Note that if we were to have points and a polynomial of degree , then
*many*polynomials of this degree could fit the points. Consider, for example, and . Then we have one points and we want to fit line through it. Clearly this can be done in infinitely many ways.)

This last one is going to be useful for us. So much so that it might be a good idea to prove it.

**Lemma. **Let be distinct points in , and let be distinct points in . Then there is a *unique *polynomial of degree at most such that for each considered here.

*Proof. *This is an exercise in linear algebra. We need to solve the system of linear equations

where spans , for the constants . Notice that this is simply plugging into a general polynomial of degree . Notice that the matrix that this forms will be a Vandermonde matrix. Since each is distinct, the determinant of this matrix is nonzero, which implies that there is a unique solution. This gives us our coefficients, and note that this is a polynomial not necessarily of degree exactly , since some coefficients may be 0, but it is at most .

[Note: For those of you who forgot your linear algebra, the end of this goes like this: if we let our coefficients be denoted by the column matrix and our Vandermonde matrix is denoted by , then we want to solve where is the column vector with entries . If has non-zero determinant, then it is invertible, and so we have that gives us our coefficients.]

Neato. But now we need to specialize this somewhat for our proof.

**Corollary. **Let the notation and assumptions be as in the last lemma. For , let be the unique polynomial of degree at most with (where if and ). Then every polynomial of degree at most is of the form for each .

This might be a bit more cryptic, so let’s do an example. Let’s let so that we have two points. Let’s say and . Then we have is the unique polynomial of degree at most 1 such that and . Of course, this function will be . Now and ; this gives us that . The theorem now states that any polynomial of degree at most can be written in the form

.

For example, let . Then the lemma says , as we’d expect. The power of this lemma will become clear when we use this in the solution. The proof of this corollary is just a specialization of the previous lemma, so we exclude it.

**Solution.** Recall, just for notation, that our sequence pointwise. Let’s let be our distinct points, as usual. In addition, let’s let be defined as in the corollary above. Represent each as follows:

for each . Here comes the magic: let and note that at every point, so, in particular, on each and on . We obtain

for each . But this is the sum of polynomials of degrees at most , which gives us that is itself a polynomial of degree at most .

I’ll admit, I did a bit of digging around after finding the lemma above; in particular, this corollary representation of polynomials seems to be a nice way to represent a polynomial if we do not know the coefficients but do know the values at a certain number of points and have that its degree is bounded below that number of points.

**Exercise: **Try to write out this representation for and . If you’re a programmer, why not make a program that allows you to input some points and some values and spits out the polynomial from the corollary above?

## Summing 1 + 11 + 111 + … and My Problem Solving Technique.

### September 17, 2011

This post was inspired by a question on the comment second of my last post about the prime-ness of 111…111. The question is: what’s the sum of 1 + 11 + 111 + … + 111…111? This seemed kind of silly to me (especially if the sum has less than 10 terms) but I quickly realized that I couldn’t figure out a "closed form" without appealing to weird "carry" tricks. So I tried to figure something else out.

Because my final solution to this question was somewhat unsatisfying, I’ve made this a special kind of post! This post will have two main purposes: to try to answer this question and to show what kinds of things I do when I don’t know the answer to a problem. So let’s begin.

**First, **I scribbled out lots of examples to see if there were patterns in the numbers. Indeed, there are, but there was no nice way to describe them in general without creating a whole lot of variables and expanding the number of terms out into a base-ten sum. This was frustrating. Especially because I knew there might be an easy answer looming out there that I wasn’t clever enough to see.

**Second,** I noted that 11 and 111 and 1111 are kind of weird numbers; written in base 10 they look pretty, but they don’t have much else in common. As we saw in the last post, a few are prime but many are not, and many have very strange prime factorizations — these factorizations do group together, but that seemed to be too far away from this problem to use. So, maybe another base would make them better formed? I plugged away in wolfram alpha. The first two bases I tried were base 2 and base 11. Neither one worked nicely. When I tried base 5, I found that the numbers followed an interesting pattern:

were mapped to

Note that the last few digital always stay the same here. Because the decimal form of these numbers is 1 + 10 + 100 + 10000 + … this is not all that surprising. We’re essentially adding the base-5 versions of these together. Note that means the number 400 in base 5; in decimal this is the number 100. So . We drop the in our base 10 numbers and note the following:

and while this seems to have a bit of a pattern, it grows too fast to be of use for adding. On the other hand, I found that base 5 can be fairly neat when you input numbers that have "nice forms" in base 10. Try it out!

**Third, **I was a bit upset, so I went back to thinking that I could write the number of terms as and some some mods to figure out the digits. The first digit will be easy: it’s just . But then what’s the carry? After a bit, I worked out that it will just be . This did not seem to be going anywhere, since this number might be somewhat large too; we would need to add this number times, and then there’s another carry that will look significantly more complex than the one I just wrote. After trying this for five carries, I started to lose track of what I was doing; the formula was getting much more difficult than just doing "normal" addition. This clearly wasn’t going to go anywhere. At this point, a flash of insight hit me. Of course. This is just like adding 1 + 10 + 100 + 1000 + …, but only a *little bit off*. But how much off?

**Fourth,** I thought that, okay, 1 + 11 + 111 + 1111 +… is the same sum as 1 + 10 + 100 + 1000 + … with a difference of exactly 1 + 11 + 111 + … with one less term. If there are terms in the original, then it is equal to with terms plus with terms. Note, then, that if we define the term to be the sum of terms that look like , then we have . At this point, I began kicking myself, because this tells me nothing new about the problem; in fact, it is essentially a restatement of the problem! But because of this, I thought about what happens when we do addition in 10’s. I realized that it is exactly the same sort of thing we are doing when we add 11’s, but each successive digit will raise by 1. So for example, while

1 + 10 + 100 + 1000 + 10000 = 11111

we have

1 + 11 + 111 + 1111 + 11111 = 12345

Each digit, starting at the left, is one plus the one before it. Of course, this suggests a pattern. But then what happens when you get far enough along?

which does not look as pretty. But look; if we add in the following way, this becomes easy! (I’ve attempted to use a chart to display place values.)

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | |||

1 | 0 | ||||||||||

1 | 1 | ||||||||||

1 | 2 | ||||||||||

+ |

1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 | 0 | 1 | 1 | 2 |

Which is exactly what we got above! Note here that I’ve made a "10" that sits inside the tenth decimal place (and so is implicitly a carry of 1 in the ninth place) and a "11" that sits in the tenth place (and so is a carry of 1 in the tenth place and 1 in the eleventh place) and so on. I’ve found that this method of computing is slightly faster than computing the original sum by hand and much less space consuming. Unfortunately, the clever (and even not-so-clever) reader will notice that this is still the sum of terms. Though I find it faster because you are only adding at most three things in each column (carries included). I tried to speed-test myself by adding together 20 terms this way and by doing 1 + 11 + 111 + … etc. straight out. My times are as follows:

Original Way (Adding 1 + 11 + 111…): 1 minute.

New Way (Described above): 40 seconds.

I also was much less confident doing this the original way (try it; you’ll have to keep track of the carry and the number of ones you need to add up and that gets confusing). The most time consuming part about the "new way" was writing out the problem; I did not count this in the "original way" because it’s just as easy to visualize the problem as it is to write it out — it would take significantly longer. If I were to only time the "calculation" part, the new way took me about 15 seconds. Pretty good for a human.

**But, **this solution was the best I could do. I do not have a closed form. If anyone has a different or more interesting solution, let me know. I didn’t want to resort to asking google, but maybe there’s a cute trick that makes this into a nice closed form. I’m not sure.

**Edit: **Of course, there is an easier solution which was provided to me by Josh "The Widowmaker" Silverman over at his blog. The key was to represent this as a geometric series (something that I seem to have completely missed out on). It turns out that the closed form expression is

for the sum of the first numbers of this form. To see the derivation, go to his blog and read it over.

## Linking and Unlinking a Double Torus.

### March 12, 2011

I cannot find a suitable picture of a linked double torus, which makes me think it’s called something else. Luckily, because it’s on the cover of Armstrong’s book (and I don’t think Springer would mind some free advertising) we can reproduce it here:

Now, how can we take this "linked" double torus and make it an "unlinked" double torus without cutting anything up? This one kept me up last night, but the solution turns out to be quite easy once you see it.

**If you don’t want the full solution, a hint might be: start thinking of the double torus as two handles on a sphere. What can you do with these handles?**

The picture solution after the jump.

## Divisibility Rules.

### January 31, 2011

Sometimes when I’m at a restaurant with friends and the check comes, we need to evenly split the bill. If you’re a math major, then you’re already assumed to be able to calculate this in your head; nonetheless, no one wants to hear that they owe $3.53333333333… because very few people have fractions of pennies lying around. It suffices, sometimes, to round up or down a penny or two to make things come out nice. But this means you should have a good understanding of when numbers divide into other numbers.

Here’s an example (which motivated me to post this): every month, the bill for the internet is around $65. I have two other roommates (and a freeloading daschund) so we split it up into three even parts. Now, I know that 3 does not divide into $65, so I just "round up" to $66 and then use the excess as credit, since that’s easy to divide by 3. But what happens if you lived with 10 other people and you needed to divide up a $2033 bill. Does this work? What about $2035? Did you have to use a calculator?