Euclidean algorithm

From Wikipedia, the free encyclopedia

Not to be confused with Euclidean geometry.

In number theory, the Euclidean algorithm (also called Euclid's algorithm) is an algorithm to determine the greatest common divisor (GCD) of two elements of any Euclidean domain (for example, the integers). Its major significance is that it does not require factoring the two integers, and it is also significant in that it is one of the oldest algorithms known, dating back to the ancient Greeks.

1 History of the Euclidean algorithm
2 Description of the algorithm
3 An example
4 Proof
5 Running time
6 Relation with continued fractions
7 Generalization to Euclidean domains
8 See also
9 References
10 External links

[edit] History of the Euclidean algorithm

The Euclidean algorithm is one of the oldest algorithms known, since it appeared in Euclid's Elements around 300 BC. Euclid originally formulated the problem geometrically, as the problem of finding a common "measure" for two line lengths, and his algorithm proceeded by repeated subtraction of the shorter from the longer segment. However, the algorithm was probably not discovered by Euclid and it may have been known up to 200 years earlier. It was almost certainly known by Eudoxus of Cnidus (about 375 BC), and Aristotle (about 330 BC) hinted at it in his Topics, 158b, 29-35.

[edit] Description of the algorithm

Given two natural numbers a and b: check if b is zero; if yes, a is the gcd. If not, repeat the process using (respectively) b, and the remainder after dividing a by b (written a mod b below).

These algorithms can be used in any context where division with remainder is possible. This includes rings of polynomials over a field as well as the ring of Gaussian integers, and in general all Euclidean domains. Applying the algorithm to the more general case other than natural number will be discussed in more detail later in the article.

[edit] Using recursion

Using recursion, the algorithm can be expressed naturally:

 function gcd(a, b)
     if b = 0 return a
     else return gcd(b, a mod b)

[edit] Using iteration

This is more efficient with compilers that don't optimize tail recursion:

 function gcd(a, b)
     while b ≠ 0
         t := b
         b := a mod b
         a := t
     return a

[edit] The extended Euclidean algorithm

Main article: extended Euclidean algorithm

By keeping track of the quotients occurring during the algorithm, one can also determine integers p and q with ap + bq = gcd(a, b). This is known as the extended Euclidean algorithm.

[edit] Original algorithm

The original algorithm as described by Euclid treated the problem geometrically, using repeated subtraction rather than mod (remainder). This is significantly less efficient:

 function gcd(a, b)
     while b ≠ 0
         if a > b
             a := a - b
         else
             b := b - a
     return a

[edit] An example

As an example, consider computing the gcd of 1071 and 1029, which is 21. Recall that “mod” means “the remainder after dividing.”

With the recursive algorithm:

		a	b	Explanations
	gcd(	1071,	1029)	The initial arguments
=	gcd(	1029,	42)	The second argument is 1071 mod 1029
=	gcd(	42,	21)	The second argument is 1029 mod 42
=	gcd(	21,	0)	The second argument is 42 mod 21
=		21		Since `b=0`, we `return a`

With the iterative algorithm:

a	b	Explanation
1071	1029	Step 1: The initial inputs
1029	42	Step 2: The remainder of 1071 divided by 1029 is 42, which is put on the right, and the divisor 1029 is put on the left.
42	21	Step 3: We repeat the loop, dividing 1029 by 42, and get 21 as remainder.
21	0	Step 4: Repeat the loop again, since 42 is divisible by 21, we get 0 as remainder, and the algorithm terminates. The number on the left, that is 21, is the gcd as required.

Observe that a ≥ b in each call. If initially, b > a, there is no problem; the first iteration effectively swaps the two values.

[edit] Proof

Suppose a and b are the natural numbers whose gcd has to be determined. And suppose the remainder of the division of a by b is r. Therefore a = qb + r where q is the quotient of the division.

Any common divisor of a and b is also a divisor of r. To see why this is true, consider that r can be written as r = a − qb. Now, if there is a common divisor d of a and b such that a = sd and b = td, then r = (s−qt)d. Since all these numbers, including s−qt, are whole numbers, it can be seen that r is divisible by d.

The above analysis is true for any divisor d; thus, the greatest common divisor of a and b is also the greatest common divisor of b and r. Therefore it is enough if we continue searching for the greatest common divisor with the numbers b and r. Since r is smaller in absolute value than b, we will reach r = 0 after finitely many steps.

[edit] Running time

Plot of the running time for gcd(x,y). Red indicates a fast computation, while successively bluer points indicate slower computations

When analyzing the running time of Euclid's algorithm, it turns out that the inputs requiring the most divisions are two successive Fibonacci numbers (because their ratios are the convergents in the slowest continued fraction expansion to converge, that of the golden ratio), and the worst case requires O(n) divisions, where n is the number of digits in the input. However, the divisions themselves are not constant time operations; the actual time complexity of the algorithm is $O (n 2)$ . The reason is that division of two n-bit numbers takes time $O (n (m + 1))$ , where m is the length of the quotient. Consider the computation of gcd(a,b) where a and b have at most n bits, let $a_0,\dots,a_k$ be the sequence of numbers produced by the algorithm, and let $n_0,\dots,n_k$ be their lengths. Then $k = O (n)$ , and the running time is bounded by

$O\Big(\sum_{i<k}n_i(n_i-n_{i+1}+2)\Big)\le O\Big(n\sum_{i<k}(n_i-n_{i+1}+2)\Big)\le O(n(n_0+2k))\le O(n^2).$

This is considerably better than Euclid's original algorithm, in which the modulus operation is effectively performed using repeated subtraction in $O (2 n)$ steps. Consequently, that version of the algorithm requires $O (2 n n)$ time for n-digit numbers, or $O (m log m)$ time for the number m.

Euclid's algorithm is widely used in practice, especially for small numbers, due to its simplicity. An alternative algorithm, the binary GCD algorithm, exploits the binary representation used by computers to avoid divisions and thereby increase efficiency, although it too is O(n²); it merely shrinks the constant hidden by the big-O notation on many real machines.

There are more complex algorithms that can reduce the running time to $O (n (log n) 2 (loglog n))$ . See Computational complexity of mathematical operations for more details.

[edit] Relation with continued fractions

The quotients that appear when the Euclidean algorithm is applied to the inputs a and b are precisely the numbers occurring in the continued fraction representation of a/b. Take for instance the example of a = 1071 and b = 1029 used above. Here is the calculation with highlighted quotients:

1071 = 1029 × 1 + 42

1029 = 42 × 24 + 21

42 = 21 × 2 + 0

Consequently,

$\frac{1071}{1029} = \mathbf{1} + \frac{1}{\mathbf{24} + \frac{1}{\mathbf{2}}}$ .

This method applies to arbitrary real inputs a and nonzero b; if a/b is irrational, then the Euclidean algorithm does not terminate, but the computed sequence of quotients still represents the (now infinite) continued fraction representation of a/b.

The quotients 1,24,2 count certain squares nested within a rectangle R having length 1071 and width 1029, in the following manner:

(1) there is 1 1029×1029 square in R whose removal leaves a 42×1029 rectangle, R₁;

(2) there are 24 42×42 squares in R₁ whose removal leaves a 21×42 rectangle, R₂;

(3) there are 2 21×21 squares in R₂ whose removal leaves nothing.

The "visual Euclidean algorithm" of nested squares applies to an arbitrary rectangle R. If the (length)/(width) of R is an irrational number, then the visual Euclidean algorithm extends to a visual continued fraction.

[edit] Generalization to Euclidean domains

The Euclidean algorithm can be applied to some rings, not just the integers. The most general context in which the algorithm terminates with the greatest common divisor is in a Euclidean domain. For instance, the Gaussian integers and polynomial rings over a field are both Euclidean domains.

As an example, consider the ring of polynomials with rational coefficients. In this ring, division with remainder is carried out using long division, also known as synthetic division. The resulting polynomials are then made monic by factoring out the leading coefficient.

We calculate the greatest common divisor of

x 4 - 4 x 3 + 4 x 2 - 3 x + 14 = (x 2 - 5 x + 7)(x 2 + x + 2)

and

x 4 + 8 x 3 + 12 x 2 + 17 x + 6 = (x 2 + 7 x + 3)(x 2 + x + 2).

Following the algorithm gives these values:

a	b
$x 4 + 8 x 3 + 12 x 2 + 17 x + 6$	$x 4 - 4 x 3 + 4 x 2 - 3 x + 14$
$x 4 - 4 x 3 + 4 x 2 - 3 x + 14$	$x^3+\frac{2}{3}x^2+\frac{5}{3}x-\frac{2}{3}$
$x^3+\frac{2}{3}x^2+\frac{5}{3}x-\frac{2}{3}$	$x 2 + x + 2$
$x 2 + x + 2$	$0$

This agrees with the explicit factorization. For general Euclidean domains, the proof of correctness is by induction on some size function. For the integers, this size function is just the identity. For rings of polynomials over a field, it is the degree of the polynomial (note that each step in the above table reduces the degree by one).

[edit] See also

[edit] References

Donald Knuth. The Art of Computer Programming, Volume 2: Seminumerical Algorithms, Third Edition. Addison-Wesley, 1997. ISBN 0-201-89684-2. Sections 4.5.2–4.5.3, pp.333–379.
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to Algorithms, Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Section 31.2: Greatest common divisor, pp.856–862.
Clark Kimberling. "A Visual Euclidean Algorithm," Mathematics Teacher 76 (1983) 108-109.

[edit] External links

Euclid's Algorithm at cut-the-knot
Binary Euclid's Algorithm (Java) at cut-the-knot
Euclid's Game (Java) at cut-the-knot
Eric W. Weisstein, Euclidean Algorithm at MathWorld.
Euclid's algorithm at PlanetMath.

Retrieved from "http://en.wikipedia.org../../../e/u/c/Euclidean_algorithm.html"

Categories: Number theoretic algorithms | Articles with example pseudocode