Euclid’s Algorithm

Sudeshna Chakraborty, Mark Heller, Alex Phipps.

Faculty Advisor: Dr. Ivan Soprunov, Department of Mathematics, Cleveland State University
Introduction Proof continued Worst Case
The Euclidean algorithm, also known as Euclid’s algorithm, is an Earlier we determined that the distance between the numbers
algorithm for finding the greatest common divisor (GCD) between 1 GCD(a, b) b  ≥  a  >  0 was an important factor in determining the runtime, so this leads
two numbers. The GCD is the largest number that divides two to the question what is the worst possible distance? Consecutive
numbers without a remainder. The GCD of two numbers can be 2 b = q1 × a + r 1 a > r1 ≥  0 Fibonacci numbers give the worst possible run time. Fibonacci
found by making a list of factors for the two numbers, and finding
the largest factor that is in both sets. This works well for small
3 a = q2 × r1 + r 2 r1 > r2 ≥  0 numbers are recursive in nature adding the two previous
numbers to get the next number. This leads to each q value (the
numbers, but it can become quite tedious and time consuming 4 r1 = q3 × r2 + r 3 r2 > r3 ≥  0 same q value shown in figure 2) being 1 and the remainder when
for larger numbers. To address this problem, Euclid’s algorithm they are divided being the previous Fibonacci number. The
can be used, which allows for the GCD of large numbers to be … example below demonstrates this on two small Fibonacci
found much faster. Euclid’s algorithm uses the principle that the numbers 8 and 5:
GCD of a set of two numbers does not change if you replace the n rn - 1 = qn + 1 × rn + 0 1: 8 = 1 × 5 + 3;
larger of the two with the remainder when you divide the larger of 2: 5 = 1 × 3 + 2;
the two by the smaller. 3: 3 = 1 × 2 + 1;
Figure 2: Illustration of proof, the number in the red circle will be
4: 2 = 1 × 1 + 1;
Procedure the GCD.
5: 1 = 1 × 1 + 0;
The algorithm takes two numbers and finds the GCD between
them. It does this in a recursive fashion by replacing the larger of
Runtime 1 is the GCD of 8 and 5.
Even though the numbers are small it took 5 steps to find the
the 2 numbers with the remainder of dividing those two numbers. Runtime is an important characteristic of any algorithm. The GCD using the algorithm. The algorithm goes through all the
This continues until the remainder is found to be 0. This process Euclidean algorithm has an upper bound on the number of steps Fibonacci numbers until it reaches 0.
is visually demonstrated in figure 1 below. it will take to find the GCD. This bound is found by the equation:
k ≤ log2(a) + log2(b) Experiment
b = (b / a) * a + (b % a) where k is the number of steps. This inequality can be easily Using java we generated 200 random number pairs between 0
proven, if we assume a and b are positive integers and (a < b), and 2,147,483,647 (the maximum integer value in Java) and
148 = 5 * 26 + 18 we can replace b with r as proven earlier so the inequality
changes to (a > r). Since a is smaller then b and r is smaller
found the GCD between them. We tracked the number of steps
it took to find the GCD and plotted them in a histogram. The data
26 = 1 * 18 + 8 then a, we can conclude that:
(2 × r < a + r ≤ b)
make a bell curve around an average of 18 steps, shown below.
The program used the built in java method Random which can
We then come to the conclusion that: generate random int numbers between a given upper bound and
18 = 2 * 8 + 2 (a × r) < (.5 × a × b) 0. Even for randomly generated arbitrarily large numbers the
With every step of Euclid’s algorithm the product of the current a algorithm can finish reasonably quickly.
8 = 4 * 2 + 0 and b goes down by a factor of 2. So: 50
Figure 1 demonstrates Euclid’s algorithm. The first row shows the a × b ≥ 2k 40
equation used to find the GCD. Cleaning this up we get back to where we started: 30
k ≤ log2(a) + log2(b)
Proof This gives a fairly decent estimate on the upper bound of steps
20
10
Before we can prove Euclid’s algorithm, we must prove that that it could take to perform the algorithm, but with the inequality
0
GCD(a, b) = GCD(a, r). Where a and b are integers, and q and r it will only be a rough estimate.
10 11 13 14 15 17 18 20 21 22 24 25 26 28
are integers such that b = q × a + r.
We know that: Best case Figure 3:Histogram of the frequency (y-axis) and the number of
steps to complete the algorithm (a-axis) on randomly generated
GCD(a, b) | a and GCD(a, b) | b The best case scenario for this algorithm would be the fastest it
From the Division Theorem we know: could possibly find the GCD. The fastest possible would be in pairs in Java.
GCD(a, b) | (1 × b – q × a) and r = (b – q × a)
We can then replace the right side with r:
one or two steps. This can happen in two different scenarios.
The first being either a or b is 0. If a or b is zero the algorithm
Conclusion
GCD(a, b) | r will end and return the other value to you as the GCD. The other The Euclidean algorithm is a very fast way of finding the GCD of
From here we can start on the other side of that coin: scenario is it being two steps with non zero values for a and b. two numbers no matter how large those numbers are. With good
GCD(r, a) | r and GCD(r, a) | a There are several easy scenarios for this such as relatively small estimates for the maximum number of steps and known worst
Using the Division Theorem again: numbers, but what about very large numbers? The Euclidean case scenarios, the algorithm is efficient and predictable.
GCD(r, a) | (1 × r + q × a) and b = q × a + r algorithm can end in one step even if the numbers themselves
We can then replace the right side with a: are arbitrarily large. For example we could choose the pair References
GCD(r, a) | b below: Lovász, L., Pelikán, J., & Vesztergombi, K. (2003). Discrete
This shows that a and b, and b and r have the same set of GCD(2,000,000 , 2,000,001) mathematics elementary and beyond (pp. 99-104). New York:
common divisors. Since the set of divisors is the same it follows Running through the algorithm: Springer.
that the GCD’s are the same. 1: 2,000,001 = 1 × 2,000,000 + 1;
GCD(a, b) = GCD(r, a) 2: 2,000,000 = 2,000,000 × 1 + 0; Acknowledgments
This proof is the basis for Euclid’s algorithm. We can continually 1 is the GCD of 2,000,000 and 2,000,001. Special thanks to Dr. Soprunov for his guidance and support
replace the larger of the pair with the remainder of the division of This example shows that the size of the numbers is not as throughout this project, and a special thanks to the COF and
the two. This is demonstrated again in figure 2. important as the distance between them. NSF programs for the funding.