The Euclidean Algorithm and Lamé's Theorem

The Euclidean algorithm and Lame’s´ theorem 1 The Euclidean algorithm Suppose a and b are a pair of integers. We will assume, furthermore, that a and b are both positive and that a ≥ b. Lemma 1.1. If a and b are both non-zero positive integers with a > b, then we may write a = qb+r, and the following equality holds gcd(a; b) = gcd(b; r): Proof. First, let d = gcd(a; b). Since dja and djb, it follows that dja−qb = r. Thus, gcd(a; b)jgcd(b; r). Now, if c is any common divisor of b and r, then c necessarily also divides qb + r. In other words, cja as well. Thus, cjb an cja, which means that cjd. In particular gcd(b; r)jgcd(a; b) and thus gcd(a; b) = gcd(b; r). Using this fact, we may now use the division algorithm to produce the gcd of two integers. Construction 1.2 (Euclidean algorithm). Indeed, take a and b positive integers with a > b. To make the recursive nature of the discussion clear we write it as follows. Set a = r0 and b = r1. Set i = 0. 1. Using the division algorithm, write ri = qi+1ri+1 + ri+2: where 0 ≤ ri+2 < ri+1. 2. If ri+2 = 0, then gcd(r0; r1) = r1 and we output r2 and stop, else go to the next step. 3. If ri+2 6= 0, then 0 < ri+2 < ri+1. In the case, increment i and go back to Step 1. Theorem 1.3. The Euclidean algorithm terminates. Proof. At each iteration of the Euclidean algorithm, we produce an integer ri. Since 0 ≤ ri+1 < ri by construction, the sequence ri is a strictly decreasing sequence of positive numbers and thus must eventually be 0. 2 Analyzing the running time of the Euclidean algorithm The naive argument about termination of the Euclidean algorithm implies that it terminates in at most b steps, since there are at most b integers between 0 and b − 1. However, doing a few examples should make it clear that typically the algorithm terminates in significantly fewer than b steps. To further analyze we make more observations about the integers qi and ri above. 1 2 2 Analyzing the running time of the Euclidean algorithm Lemma 2.1. The sequence q1; : : : ; qn of quotients produced in the division algorithm have the property that qi ≥ 1 and qn ≥ 2. Proof. We will prove qn ≥ 2. At the last step of the division algorithm, we have rn−1 = qnrn. The division algorithm tells us that rn < rn−1. Thus, qn ≥ 2. Now, we go backwards in the division algorithm. Indeed, rn ≥ 1. Then, rn−1 ≥ 2rn ≥ 2. At the next step, rn−2 = qn−1rn−1 + rn−2. Since qn−1 ≥ 1, it follows that rn−2 = qn−1rn−1 + rn ≥ rn−1 + rn ≥ 1 + 2 = 3: At the next stage, again we see that rn−3 = qn−2rn−2 + rn−1 ≥ rn−2 + rn−1 = 3 + 2 = 5: At each stage, we see that ri = qi−1ri−1 + ri−2 ≥ ri−1 + ri−2: Let fi be the i-th Fibonacci number, where f0 = 1, f1 = 1 Now, rn ≥ 1 = f1. Likewise rn−1 ≥ 2 = f2, and rn−2 ≥ 3 = f3. The inequality above shows that ri ≥ ri−1 + ri−2: Proposition 2.2. For any integer i ≥ 0, ri ≥ fn+1−i. Proof. We proceed by induction. In the case i = n, f1 = 1 and r0 ≥ f1 = 1. Now assume inductively that ri ≥ fn+1−i for each i > k. Consider rn−k = qn−k−1rn−k−1+rn−k−2 ≥ rn−k−1+rn−k−2 ≥ fn+1−(n−k−1)+fn+1−(n−k−2) = fn−k+fn−k−1 = fn−k+1: Thus, by induction, we conclude that ri ≥ fn+1−i. Iterating this observation, we conclude that, if the Euclidean algorithm terminates after n steps, then r1 in the division algorithm must be at least fn, i.e., b must be at least as large as fn. Thus, the question we are interested in is, how large is fn? For example, how many digits does it have? To k answer this question we want to consider log10b = log10fn (since log1010 = k, this number grows roughly as the number of digits). To answer the question about the size ofp log10fn, we can appeal to our formula for the n-th −1± 5 Fibonacci number. Recall that if '± = 2 , then 1 n+1 n+1 n+1 fn = p (−1) (' − ' ): 5 − + p 1± 5 If we set α± := 2 , then the above formula may also be written as 1 n+1 n+1 fn = p (α − α ): 5 + − 3 2 Analyzing the running time of the Euclidean algorithm n+1 Notice that α+ > 1, while α− is negative, but smallerp than 1. In particular, α− is always smaller than 1 in absolute value. Since 5 > 4, we know that 5 > 2, and thus that p1 < 1 . Now, f is 5 2 n always an integer. The formula above thus shows that fn is the largest integer smaller than 'n+1 1 p+ + : 5 2 'n+1 Therefore, its rate of growth is bounded by p+ . In particular, we see that 5 n+1 α+ p log10fn ∼ log10( p ) = (n + 1)log10α+ − log10( 5): 5 The leading term here n log10 α+ (as the other term is constant). So, it suffices to estimate log10α+, which we now do. Since we’re interested in computing log10α+, it suffices to find the first power of α+ which is bigger than 10 (take logarithms of both sides!). Note that α is a root of x2 − x − 1, i.e., α2 = α + 1. Therefore, α3 = α2 + α = 2α 1. + + + + + + +p Likewise, α4 = 2α2 + α = 3α + 2, and α5 = 3α2 + 2α = 5α 3. Now, α = 1+ 5 . +p + + + + + + + + 2 3 21 Since 2 < 5, we see that α+ > 2 , so 5α+ + 3 > 2 > 10. It follows immediately that 5 1 log10α+ = 5 log10 α+ = log10(5α + 3) > log1010 = 1. In other words, log10α+ > 5 . Putting everything together we have deduced the following fact. Theorem 2.3 (Lame)´ . The number of steps n in the Euclidean algorithm grows at the same rate as n ∼ 5log10b: In other words, the number of steps in the Euclidean algorithm grows at about 5 times the rate of the number digits of b. Proof. Putting the various steps of the analysis above together, we see that: 1 asoklog b ∼ log f ∼ n log α ∼ n: 10 10 n 10 + 5 Remark 2.4. In fact, our analysis gives us something much better. We see how to produce versions of the Eucliden algorithm that runs slowly using Fibonacci sequences. In fact, it turns out that one can use Fibonacci numbers to produce numbers for which the Euclidean algorithm takes about 5 times the number of digits in b number of steps. Nevertheless, for a given pair a and b, the algorithm can run much faster (for an extreme example, take a = b!). What we’ve really done is describe the number of steps in a worst case scenario. Moreover, more precise estimates for log10α+ would yield more precise information about the number of steps required..

Load more