Euclidean algorithm

Because the sequence of non-negative integers k, and each nth step with r0, we need to find integers 1071=q0⋅462+r0.

This is the quotient r0=147 and so the sequence is now q1 and q1=3 since {1071, 462, 147, r1=21}. The next step is to continue the sequence to find r2<r1 such that:

147=7⋅21+0. This determines 0 can be found. The penultimate remainder a and gcd(a, a)=a as the sequence of remainders will be a≡0⋅b+a, suggesting the next remainder should be r0<r−1 but now we have rk<rk−1 only for k≥0 is strictly decreasing, therefore excluding rN=0 follows from the condition rN−1 being equal to gcd⁡(x,0)=x, for all 0 are exactly all the divisors of gcd⁡(x,y)=gcd⁡(y,x−zy)

In fact, the sets of common divisors of the pairs d is a common divisor of X,Y such that x−zy=dX−zdY=d(X−zY), where x−zy.

Conversely, if y, then there are integers x−zy=dZ and Z+zY is an integer. Therefore, y.

Now, the Euclidean algorithm starts with the pair (rk−1,rk−2−qkrk−1)=(rk−1,rk). Property 2 shows that the (a,b) and the last pair a = 1071 and 462×147 rectangle. This rectangle is tiled with 21×21 squares, leaving no uncovered area. The smallest square size, 462.

For illustration, the Euclidean algorithm can be used to find the greatest common divisor of 462 are subtracted from q0 = 2), leaving a remainder of 147 are subtracted from q1 = 3), leaving a remainder of 21 are subtracted from q2 = 7), leaving no remainder:

1071 and 1071 = q0 462 + r00</sub> = 2"}},"i":0}}]}'/>q0 = 2 and 0</sub> = 147"}},"i":0}}]}'/>r0 = 147 11</sub> 147 + ''r''₁"}},"i":0}}]}'/>462 = q1 147 + r11</sub> = 3"}},"i":0}}]}'/>q1 = 3 and 1</sub> = 21"}},"i":0}}]}'/>r1 = 21 22</sub> 21 + ''r''₂"}},"i":0}}]}'/>147 = q2 21 + r22</sub> = 7"}},"i":0}}]}'/>q2 = 7 and 2</sub> = 0"}},"i":0}}]}'/>r2 = 0; algorithm ends

Visualization

edit

The Euclidean algorithm can be visualized in terms of the tiling analogy given above for the greatest common divisor. Assume that we wish to cover an b×b square tiles; however, this leaves an 0</sub>×''b''"}},"i":0}}]}'/>r0×b residual rectangle untiled, where 0</sub> < ''b''"}},"i":0}}]}'/>r0 < b. We then attempt to tile the residual rectangle with 0</sub>×''r''₀"}},"i":0}}]}'/>r0×r0 square tiles. This leaves a second residual rectangle 1</sub>×''r''₀"}},"i":0}}]}'/>r1×r0, which we attempt to tile using 1</sub>×''r''₁"}},"i":0}}]}'/>r1×r1 square tiles, and so on. The sequence ends when there is no residual rectangle, i.e., when the square tiles cover the previous residual rectangle exactly. The length of the sides of the smallest square tile is the GCD of the dimensions of the original rectangle. For example, the smallest square tile in the adjacent figure is 1071 and

At every step rk from two numbers ''k''−1</sub>"}},"i":0}}]}'/>rk−1 and ''k''−2</sub>"}},"i":0}}]}'/>rk−2

''k''−2</sub> = ''q''_''k'' ''r''_''k''−1 + ''r''_''k''"}},"i":0}}]}'/>rk−2 = qk rk−1 + rk,

where the ''k''</sub>"}},"i":0}}]}'/>rk is non-negative and is strictly less than the absolute value of ''k''−1</sub>"}},"i":0}}]}'/>rk−1. The theorem which underlies the definition of the Euclidean division ensures that such a quotient and remainder always exist and are unique.

In Euclid's original version of the algorithm, the quotient and remainder are found by repeated subtraction; that is, ''k''−1</sub>"}},"i":0}}]}'/>rk−1 is subtracted from ''k''−2</sub>"}},"i":0}}]}'/>rk−2 repeatedly until the remainder ''k''</sub>"}},"i":0}}]}'/>rk is smaller than ''k''−1</sub>"}},"i":0}}]}'/>rk−1. After that ''k''</sub>"}},"i":0}}]}'/>rk and ''k''−1</sub>"}},"i":0}}]}'/>rk−1 are exchanged and the process is iterated. Euclidean division reduces all the steps between two exchanges into a single step, which is thus more efficient. Moreover, the quotients are not needed, thus one may replace Euclidean division by the modulo operation, which gives only the remainder. Thus the iteration of the Euclidean algorithm becomes simply

''k''</sub> = ''r''_''k''−2 mod ''r''_''k''−1"}},"i":0}}]}'/>rk = rk−2 mod rk−1.

Implementations

edit

Implementations of the algorithm may be expressed in pseudocode. For example, the division-based version may be programmed as

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

At the beginning of the rk−1, whereas the variable b := a mod b is equivalent to the above recursion formula ''k''</sub> ≡ ''r''_''k''−2 mod ''r''_''k''−1"}},"i":0}}]}'/>rk ≡ rk−2 mod rk−1. The temporary variable rk is being calculated. At the end of the loop iteration, the variable a holds its predecessor, ''k''−1</sub>"}},"i":0}}]}'/>rk−1.

(If negative inputs are allowed, or if the mod function may return negative values, the last line must be replaced with '''return abs'''(a)</code>"}},"i":0}}]}'>return abs(a).)

In the subtraction-based version, which was Euclid's original version, the remainder calculation (b := a '''mod''' b</code>"}},"i":0}}]}'>b := a mod b) is replaced by repeated subtraction. Contrary to the division-based version, which works with arbitrary integers as input, the subtraction-based version supposes that the input consists of positive integers and stops when b alternate holding the previous remainders ''k''−1</sub>"}},"i":0}}]}'/>rk−1 and ''k''−2</sub>"}},"i":0}}]}'/>rk−2. Assume that a equals ''k''−2</sub>"}},"i":0}}]}'/>rk−2, since ''k''−2</sub> > ''r''_''k''−1"}},"i":0}}]}'/>rk−2 > rk−1. During the loop iteration, a is smaller than rk. Then a, giving the next remainder ''k''+1</sub>"}},"i":0}}]}'/>rk+1, and so on.

The recursive version is based on the equality of the GCDs of successive remainders and the stopping condition ''N''−1</sub>, 0) = ''r''_''N''−1"}},"i":0}}]}'/>gcd(rN−1, 0) = rN−1.

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

(As above, if negative inputs are allowed, or if the mod function may return negative values, the instruction '''return''' a</code>"}},"i":0}}]}'>return a must be replaced by '''return max'''(a, −a)</code>"}},"i":0}}]}'>return max(a, −a).)

For illustration, the gcd(147, 462 mod 147) = gcd(147, 21), which in turn is calculated from the |rk−1| > rk > 0. However, an alternative negative remainder ''k''</sub>"}},"i":0}}]}'/>ek can be computed:

''k''−2</sub> = (''q''_''k'' + 1) ''r''_''k''−1 + ''e''_''k''"}},"i":0}}]}'/>rk−2 = (qk + 1) rk−1 + ek

if ''k''−1</sub>&nbsp;>&nbsp;0"}},"i":0}}]}'/>rk−1 > 0 or

''k''−2</sub> = (''q''_''k'' – 1) ''r''_''k''−1 + ''e''_''k''"}},"i":0}}]}'/>rk−2 = (qk – 1) rk−1 + ek

if ''k''−1</sub>&nbsp;<&nbsp;0"}},"i":0}}]}'/>rk−1 < 0.

If ''k''</sub>"}},"i":0}}]}'/>rk is replaced by ''k''</sub>"}},"i":0}}]}'/>ek. when ''k''</sub>}} < {{abs|''r''_''k''}}"}},"i":0}}]}'/>|ek| < |rk|, then one gets a variant of Euclidean algorithm such that

''k''</sub>}} ≤ {{abs|''r''_''k''−1}} / 2"}},"i":0}}]}'/>|rk| ≤ |rk−1| / 2

at each step.

Leopold Kronecker has shown that this version requires the fewest steps of any version of Euclid's algorithm. More generally, it has been proven that, for every input numbers a and b, the number of steps is minimal if and only if ''k''</sub>"}},"i":0}}]}'/>qk is chosen in order that g that measures a and m multiples of the smaller pile from the larger. Thus, if the two piles consist of x is larger than x − my stones, as long as the latter is a nonnegative integer. The winner is the first player to reduce one pile to zero stones.

Mathematical applications

edit

Bézout's identityedit