Arithmetik • Grundlegende Tatsachen über den Ring Z • Euklidischer

Grundlegende Tatsachen über den Ring Z
• hZ; +, · i ist ein nullteilerfreier Ring
• Divisionseigenschaft
∀a ∈ Z, b ∈ Z>0 ∃q, r ∈ Z : a = b · q + r, 0 ≤ r < b
Arithmetik
• Bezeichnungen
• Grundlegende Tatsachen über den Ring Z
a
q = b c = (a div b)
b
a
r = a − b c · b = (a mod b)
b
• Euklidischer Algorithmus
• Lösung ganzzahliger Gleichungssysteme
: Quotient
: Rest
• Teilbarkeit
• Binärer euklidischer Algorithmus
b teilt a : b|a ⇔ (a mod |b|) = 0
1
• grösster gemeinsamer Teiler für (a, b) ∈ Z × Z, (a, b) 6= (0, 0)
ist d ∈ Z>0 mit
d|a ∧ d|b ∧ ( ∀c ∈ Z>0 : c|a ∧ c|b ⇒ c|d )
Bezeichnung: d = ggT(a, b)
Tatsache: d = ggT(a, b) = max{c ∈ Z>0 ; c|a ∧ c|b}
Konvention (GA): ggT(0, 0) = 0
• kleinstes gemeinsames Vielfaches für (a, b) ∈ Z × Z, (a, b) 6= (0, 0)
ist m ∈ Z>0 mit
a|m ∧ b|m ∧ ( ∀c ∈ Z>0 : a|c ∧ b|c ⇒ m|c )
Bezeichnung: m = kgV(a, b)
Tatsache: m = kgV(a, b) = min{c ∈ Z>0 ; a|c ∧ b|c}
2
• p ∈ Z>1 ist Primzahl, wenn gilt
∀a ∈ [1..p] : (a|p ⇒ a = 1 ∨ a = p)
• Euklid:
p Primzahl ⇒
∀a, b ∈ Z : p|(a · b) ⇒ p|a ∨ p|b
• Euklid: es gibt unendlich viele Primzahlen
• Fundamentalsatz der Arithmetik (Gauss, GA Theorem 7.21)
Die Zerlegung natürlicher Zahlen in ihre Primteiler (mit Vielfachheiten)
ist eindeutig, d.h.
zu jeder natürlichen Zahl n > 1 gibt es eindeutig bestimmte
Primzahlen p1 < p2 < . . . < pk und Exponenten e1 , e2 , . . . , ek ∈ N>0
mit
n = pe11 · pe22 · · · pekk
• Die Berechnung dieser Darstellung (Faktorisierung) ist mutmasslich ein
algorithmisch sehr aufwendiges Problem.
3
4
• Sind a, b ∈ Z>0 mit
Euklidischer Algorithmus — Grundalgorithmus
β1
β2
βk
αk
α2
1
a = pα
1 · p 2 · · · p k , b = p 1 · p2 · · · pk
mit Primzahlen p1 < p2 < . . . < pk und Exponenten
α1 , α2 , . . . , αk , β1 , β2 , . . . , βk ≥ 0, so gilt
ggT(a, b) =
min{α1 ,β1 } min{α2 ,β2 }
p2
p1
min{αk ,βk }
· · · pk
max{α1 ,β1 } max{α2 ,β2 }
p2
kgV(a, b) = p1
max{αk ,βk }
· · · pk
ggT und kgV ganzer Zahlen lassen sich also prinzipiell mittels Faktorisierung
berechnen — das ist aber keine effiziente Methode!
Von Euklid stammt ein effizientes Verfahren zur ggT-Berechnungs mittels
iterierter Division mit Rest:
rekursive Version:
Euclid-rek (int a,int b)
iterative Version:
Euclid-iter (int a,int b)
if b = 0 then
return(a)
else
return(Euclid-rek(b, a mod b))
end if
• ggT(a, b) · kgV(a, b) = a · b
basierend auf
• Ganze Zahlen a, b heissen teilerfremd (relativ prim), wenn ggT(a, b) = 1.
Theorem (GA, Thm. 7.19)
α := a, β := b
while β 6= 0 do
(α, β) := (β, α mod β)
end while
return(α)
∀a, b ∈ Z : ggT(a, b) = ggT(b, a mod b)
5
6
Schema der Ausführung von Euklids Algorithmus
Beispiel: a = 57, b = 33
a0
:= a
a1
:= b
a0
=
a1 · q0 + a2
(q0 ∈ Z, 0 < a2 < a1 )
57 = 33 · 1 + 24
a1
=
a2 · q1 + a3
(q1 ∈ N+ , 0 < a3 < a2 )
33 = 24 · 1 + 9
a2
=
..
.
a3 · q2 + a4
(q2 ∈ N+ , 0 < a4 < a3 )
24 = 9 · 2 + 6
an−2
=
an−1 · qn−2 + an
an−1
=
an · qn−1
9=6·1+3
(qn−2 ∈ N+ , 0 < an < an−1 )
(qn−1 ≥ 2, an+1 = 0)
6=3·2
Quotientenfolge: hq0 , q1 , . . . , q4 i = h1, 1, 2, 1, 2i
Restefolge: ha0 , a1 , a2 , . . . , a6 i = h57, 33, 24, 9, 6, 3, 0i
hq0 , q1 , q2 , . . . , qn−1 i : Quotientenfolge
ha0 , a1 , a2 , . . . , an , 0i : Restefolge
7
8
• Terminierung
Effizienz wird gesichert durch den Satz von Lamé (1845):
a0 ≥ a1 > a2 > · · · > an > an+1 = 0 für ein n ≥ 1
• Korrektheit
ggT(a, b) = ggT(a0 , a1 )
Wenn die Berechnung von ggT(a, b) für a > b > 0 genau k Aufrufe der
Prozedur Euclid-rek (bzw. k Schleifendurchläufe der while-Schleife in
Euclid-iter) erfordert, dann gilt a ≥ fk und b ≥ fk−1 , wobei fi die
i-te Fibonacci-Zahl ist.
= ggT(a1 , a2 )
Aus den bekannten Aussagen über die Fibonacci-Zahlen ergibt sich:
= ggT(a2 , a3 )
Sind a, b ∈ N mit a ≥ b, dann ist die Zahl der Divisionschritte im
Euklidischen Algorithmus für a, b ≤ 4.8 · log10 (a) + 2.
= · · · = ggT(an , an+1 ) = ggT(an , 0) = an
10
9
Ausgehend von a = a0 ≥ a1 = b ergibt sich
Eine alternative Betrachtung:
Euklids Algorithmus für (a, b) = (a0 , a1 ) erzeugt zu der Folge
ai = ai+1 · qi + ai+2
≤ qn
(0 ≤ i ≤ n)
von Divisionsschritten eine Quotientenfolge hq0 , q1 , . . . , qn i mit
qi ≥ 1 (0 ≤ i < n)
2n+1
und qn ≥ 2
n−1
Y
i=0
=
n−1
an Y ai
a0 · · · an
≤
an+1 i=0 ai+2
a2 · · · an+1 an+1
2
a
≤
ggT(a, b)
(qi + 1) <
a0 a1
an+1 an+1
• Theorem : Für a, b ∈ N benötigt die Berechnung von ggT(a,b) höchstens
b2 · log2 max(a, b)c + 1 Divisionsschritte
Es gilt
ai+2 · (qi + 1) < ai+1 · qi + ai+2 = ai (0 ≤ i < n)
(Linearität in der Problemgrösse)
und somit
qi + 1 < ai /ai+2 (0 ≤ i < n) und qn = an /an+1 .
11
12
Euklidischer Algorithmus — erweiterte Form
Untersuchung im logarithmischen Komplexitätsmodell:
Eine fundamental wichtige Eigenschaft des ggT für ganze Zahlen ist:
`β (a) : Grösse (Länge) von a bei der Darstellungen in Basis β
Jeder Divisionschritt ai = ai+1 · qi + ai+2 erfordert `β (ai+1 ) · `β (qi ) Operationen
in β-Arithmetik.
der ggT(a, b) lässt sich als Linearkombination von a und b mit
ganzzahligen Koeffizienten darstellen ( Bézout-Beziehung)
∀a, b ∈ Z ∃s, t ∈ Z : a · s + b · t = ggT(a, b)
Gesamtaufwand, gemessen in Basis-β-Operationen für Euklids Algorithmus (a, b):
n
X
Tatsächlich ist ggT(a, b) die kleinste positive Zahl ∈ Z, die sich als
Linearkombination von a und b darstellen lässt.
`β (ai+1 ) · `β (qi )
i=0
und dies ist, unter der Annahme a ≥ b, beschränkt durch
!
n−1
n−1
X
Y
`β (a1 ) ·
`β (qi + 1) + `β (qn ) ∼ `β (b) · `β (qn ·
(qi + 1))
i=0
i=0
≤ 2 `β (b) · (`β (a) − `β (ggT(a, b)) + 1)
13
14
Die algebraische Sicht:
• Für a, b ∈ Z ist
Ha,b = { a · u + b · v ; u, v ∈ Z }
eine Untergruppe (sogar ein “Ideal”) von Z,
d.h. x, y ∈ Ha,b ⇒ x − y ∈ Ha,b (und u · x ∈ Ha,b für alle u ∈ Z)
Extended Euclid (int a, int b)
{
/* returns (d, s, t), where d = gcd(a, b) = as + bt */
if (b == 0) return (a, 1, 0);
else
• Divisionseigenschaft von Z ⇒ ist H 6= {0} eine Untergruppe von Z, so gilt
{
H = k · Z = {k · u ; u ∈ Z }
(d0 , s0 , t0 ) = Extended Euclid(b, a mod b);
s = t0 ;
wobei k = min{h ∈ H ; h > 0}
t = s0 − t0 · (a div b);
• Für a, b ∈ Z mit (a, b) 6= (0, 0) gilt Ha,b = k · Z mit k = a · s + b · t und es ist
k = ggT(a, b), denn
– a ∈ Ha,b ⇒ k | a und b ∈ Ha,b ⇒ k | b
return (d0 , s, t);
}
}
– c|a ∧ c | b ⇒ c | (a · s + b · t) = k
• Das liefert noch kein algorithmisches Verfahren zur Berechnung von (s, t)
15
16
Beispiel a = 57, b = 33
α(0) = h1, 0, 57i
α(1) = h0, 1, 33i
Iterative Version des erweiterten Euklidischen Algorithmus:
seien a ≥ b > 0
für i = 0, 1, 2, . . . seien α(i) = hsi , ti , ai i ∈ Z3 und qi ∈ N+ definiert durch
α(0) := h1, 0, ai
α(1) := h0, 1, bi
i := 1
while ai 6= 0 do
qi−1 := bai−1 /ai c
α(i+1) := α(i−1) − qi−1 · α(i)
i := i + 1
end while
(2)
α
(0)
=α
(1)
− q0 · α
= h1, −1, 24i
q0 = b57/33c = 1
q1 = b33/24c = 1
α(3) = α(1) − q1 · α(2) = h−1, 2, 9i
q2 = b24/9c = 2
α(4) = α(2) − q2 · α(3) = h3, −5, 6i
q3 = b9/6c = 1
(5)
α
(3)
=α
(4)
− q3 · α
= h−4, 7, 3i
q4 = b6/3c = 2
α(6) = α(4) − q4 · α(5) = h11, −19, 0i
Bézout-Beziehung
57 · (−4) + 33 · 7 = 3 = ggT(57, 33)
Notabene
57 · 11 − 33 · (−19) = 0, 11 =
17
57
33
, 19 =
ggT(57, 33)
ggT(57, 33)
18
Es ist



0
1
1 0 a

=
···


1 −qi−1
1 −q0
0 1 b
α(i+1)

Die Eigenschaften des erweiterten Euklidischen Algorithmus ergeben sich leicht
aus einer Darstellung in Matrizenschreibweise
α = hα1 , α2 , α3 i := h1, 0, ai
β = hβ1 , β2 , β3 i := h0, 1, bi
while β3 6= 0 do
α(i)


0
1

für 0 ≤ i ≤ n;
daher ist
q := α3 div β3
 

 
α
0 1
α
  := 
 
β
1 −q
β
 
  a
 
α  
0
  b  =  
 
β
0
−1
eine Schleifeninvariante.
Mit α(i) = hsi , ti , ai i ist
end while
hs, t, di := hα1 , α2 , α3 i
a · si + b · ti = ai für 0 ≤ i ≤ n + 1
19
20
Beweis (Induktion über Anzahl der Divisionen im EA)
beachte: ist hq0 , q1 , . . . , qn−1 i die Quotientenfolge für EA(a0 , a1 ), so ist
hq1 , q2 , . . . , qn−1 i die Quotientenfolge für EA(a1 , a2 ), wobei
ggt(a0 , a1 ) = ggt(a1 , a2 ), daher
Daraus ergibt sich die Bézout-Beziehung:
0
a · sn + b · tn = an = ggT(a, b)
@
sn
tn
sn+1
tn+1
1
A=@
sowie
a · sn+1 + b · tn+1 = an+1 = 0
mit
sn+1 = (−1)n+1
0
b
a
und tn+1 = (−1)n
ggt(a, b)
ggt(a, b)
0
1
1
0
A···@
0
1
10
0
1
1
A@
A
1 −q1
1 −q0
0
10
1 0
s0n−1 t0n−1
0
1
s0
A@
A = @ n−1
=@
(−1)n a2
s0n
t0n
1 −q0
ggt(a1 ,a2 )
0
1
t0n−1
s0n−1 − q0 t0n−1
A
= @ (−1)n+1 a
n+1
(−1)n a2
a1
1
− q0 (−1)
ggt(a0 ,a1 )
ggt(a0 ,a1 )
ggt(a0 ,a1 )
0
1
t0n−1
s0n−1 − q0 t0n−1
A
=@
n+1
n
1
−qn
(−1)
a1
ggt(a0 ,a1 )
21
t0n−1
(−1)n+1 a1
ggt(a1 ,a2 )
10
A@
0
1
1
−q0
(−1) a0
ggt(a0 ,a1 )
22
Beispiel a = 57, b = 33:
Euklids Algorithmus (in der erweiterten Form von Bézout) behandelt ein
fundamentales Problem:
Quotientenfolge : hq0 , . . . , q4 i = h1, 1, 2, 1, 2i
Lösen linearer Gleichungen in Z

0

1


0 1
0


1 −2
1

0

1

1
0

−1
1

1
0

−1
1

0

1

1
0

−2
1

1
0

−2
1

1
0

−2
1
23

0
1

−1
1

1
0

−1
1

1
0

−1
1

1
0

−1
1
1


1
=
−1
−1
 
1
−1
=
−1
3
 
1
3
=
−1
−4
 
1
−4
=
−1
11

−1

2

2

−5

−5

7

7

−19
denn es gilt für a, b, c ∈ Z mit (a, b) 6= (0, 0):
∃ u, v ∈ Z : a · u + b · v = c ⇔ ggT(a, b) | c
und wenn diese Bedingung erfüllt ist, ist die Menge der ganzzahligen Lösungen
der Geradengleichung
a·x+b·y =c
gegeben durch
c
k
· (s, t) + · (−b, a) (k ∈ Z)
d
d
wobei s, t Bézout-Koeffizienten für (a, b) und d = ggT(a, b) sind, d.h.,
a·s+b·t=d
(x, y) =
24
1
A
Zum Beweis:
• es gilt
Ha,b = { a · u + b · v ; u, v ∈ Z } = ggT(a, b) · Z
daher ist a · x + b · y = c in Z lösbar ⇔ c ∈ Ha,b (d.h. ggT(a, b) | c)
• falls Lösbarkeit gegeben und d = ggT(a, b)
a·x+b·y =c⇔
a
b
c
·x+ ·y =
d
d
d
wobei nun ggT(a/d, b/d) = 1, d.h. es genügt, den Fall ggT(a, b) = 1 zu betrachten
• mit Bézout-Koeffizienten s, t, d.h. a · s + b · t = 1 gilt
a · (c · s) + b · (c · t) = c
d.h. (x0 , y0 ) = (c · s, c · t) ist spezielle Lösung von a · x + b · y = c
• (x, y) = (x0 + X, y0 + Y ) ist genau dann Lösung von a · x + b · y = c, wenn (X, Y )
Lösung von a · X + b · Y = 0
• die Lösungen von a · X + b · Y = 0 sind genau die (k · b, −k · a) mit k ∈ Z —
hierfür benötigt man ggT(a, b) = 1
25
Beispiel
• 57 · x + 33 · y = −9
Lösungsmenge:
k
−9
· (−4, 7) + · (−33, 57)
3
3
= (12 − 11 · k, −21 + 19 · k) (k ∈ Z)
(x, y) =
• 57 · x + 33 · y = −8
Lösungsmenge: ∅
Wichtige Bemerkung:
man kann diese Idee ausbauen zu einem Verfahren, um die Menge der
ganzzahligen Lösungen von linearen Gleichungssysteme mit ganzzahligen
Koeffizienten zu berechnen.
27
26
(1)
57x + 33y
=
−9
(2)
x+y
=
z
(3)
24x + 33z
=
−9
(4)
x+z
=
u
(5)
24u + 9z
=
−9
(6)
2u + z
=
v
(7)
6u + 9v
=
−9
(8)
u+v
=
w
(9)
6w + 3v
=
−9
(7) − 6 · (8)
(10)
2w + v
=
−3
Division mit min{3, 6} = 3
(11)
v
=
−3 − 2w
(12)
u
=
3w + 3
aus (11) und (8)
(13)
z
=
−9 − 8w
aus (12) und (6)
(14)
x
=
11w + 12
aus (13) und (4)
(15)
y
=
−21 − 19w
aus (14) und (2)
die zu lösende Gleichung
Division mit 33 = min{57, 33}, neue Variable z
(1) − 33 · (2)
Division mit 24 = min{24, 33}, neue Variable u
(3) − 24 · (4)
Division mit 9 = min{24, 9}, neue Variable v
(5) − 9 · (6)
Division mit 6 = min{6, 9}, neue Variable w
aus (10)
28
Die ganzzahlige Lösungsmenge der Gleichung 57x + 33y = −9 ist also
(x, y) = (12, −21) + w · (11, −19) mit w ∈ Z
30
29
Das Verfahren funktioniert auch für Gleichungen mit mehreren Variablen
(1)
8x − 7y − 5z
=
2
zu lösende Gleichung
(2)
x−y−z
=
u
Division mit 5, neue Variable u
(3)
3x − 2y + 5u
=
2
(1) − 5 · (2)
(4)
x − y + 2u
=
v
Division mit 2, neue Variable v
(5)
x + 2v + u
=
2
(3) − 2 · (4)
(6)
x
=
2 − u − 2v
aus (5)
(7)
y
=
2 + u − 3v
aus (6) und (4)
(8)
z
=
−3u + v
aus (7) und (2)
Die ganzzahlige Lösungsmenge der Gleichung 8x − 7y − 5z = 2 ist also
  

 
x
−1 −2  
2
 u
 
  
y  =  1 −3   + 2 u, v ∈ Z
  

 
v
z
−3 1
0
31
Zur Lösung linearer Gleichungen über Z
Gesucht ganzzahlige Lösungsmenge von
(∗) a1 · x1 + a2 · x2 + · · · + an · xn = b
wobei a1 , · · · , an , b ∈ Z, nicht alle ai = 0
– ohne Einschränkung sei a1 > 0 und a1 = min1≤i≤n {|ai | ; ai 6= 0}
– Fall 1: a1 = 1
dann ist die allgemeine Lösung von (*) gegeben durch
(b − a2 · x2 − · · · − an · xn , x2 , . . . , xn ) mit (x2 , . . . , xn ) ∈ Zn−1
– Fall 2a: a1 > 1, alle ai durch a1 teilbar
dann ist (*) lösbar ⇔ a1 | b und Lösung ergibt sich aus
a1
a2
an
b
· x1 +
· x2 + · · ·
· xn =
a1
a1
a1
a1
→ Fall 1.
32
Daher
– Fall 2a: a1 > 1, nicht alle ai durch a1 teilbar
a • x = a1 · (a ÷ a1 ) • x +(a mod a1 ) • x
{z
}
|
Bezeichnungen (÷ = ganzzahlige Division)
y
a = ha1 , a2 , . . . , an i
Betrachte y als neue Variable mit
x = hx1 , x2 , . . . , xn i
(∗∗) y = x1 + b
(a ÷ a1 ) = ha1 ÷ a1 , a2 ÷ a1 , . . . , an ÷ a1 i
| {z }
Mit
=1
(a mod a1 ) = ha1 mod a1 , a2 mod a1 , . . . , an mod a1 i
| {z } |
{z
}
=0
e = ha1 , a2 mod a1 , . . . , an mod a1 i
a
e = hy, x2 , . . . , xn i
x
nicht alle =0
gilt: die Lösungen hx1 , x2 , . . . , xn i von (∗) entsprechen ein-eindeutig den
Lösungen hy, x2 , . . . , xn i von
e•x
e=b
a
Zu lösende Gleichung (• = Skalarprodukt)
a•x=b
(∗)
a2
an
c · x2 + · · · + b c · xn
a1
a1
vermöge (∗∗).
Divisionsbeziehung
Wichtig (für die Terminierung):
a = a1 · (a ÷ a1 ) + (a mod a1 )
min{a1 , a2 mod a1 , . . . , an mod a1 } < a1
33
34
Das Verfahren lässt sich für die Bestimmung der ganzzahligen Lösungen
ganzzahliger Gleichungssysteme verwenden.
4. Elimination von x durch Einführung einer neuen Variablen t2
Beispiel (vgl. Knuth, TAOCP, Abschnitt 4.5.2)
1. zu lösendes System
10w
6w
+
3x +
3y
− 7x
+
8z
=
1
− 5z
=
2
+ x +
y
+
2z
= t1
w
+
3t1
+
2z
=
18t1
+
35
7x +
4t1
+
x +
7t2
+
2z
= t2
3z
=
4
5z
=
2
17z
=
4
t1
+
2t2
+
z
t1
+
t2
+
3t3
= t3
=
4
6. Auflösen nach t2 und Rückwaärtseinsetzen liefert
=
17
−
5t1
− 14t3
x =
20
−
5t1
− 17t3
y
= −55 +
19t1
+
45t3
z
=
t1
+
7t3
w
1
3. Elimination von w aus zweiter Gleichung
6(1 − 3t1 − 2z) − 7x −
+
5. Elimination von z durch Einführung einer neuen Variablen t3
2. Elimination von y mittels der ersten Gleichung und Einführung einer neuen
Variablen t1
3w
2t1
−8
+
36
Der binäre Euklidische Algorithmus
macht sich die Binärdarstellung der Zahlen zu Nutze und realisiert die Berechnung
des ggT mittels Subtraktion und Division durch Zweierpotenzen (= shift).
Er benützt die (offensichtlichen) Beziehungen
ggT(2a, 2b) = 2 · ggT(a, b)
(a, b ∈ N)
(a, b ∈ N, b ungerade)
ggT(2a, b) = ggT(a, b)
ggT(a, b) = ggT(a − b, b)
37
Binary Euclid (int a, int b)
{ /* returns gcd(a, b) provided that a, b ∈ N */
int d = 1;
while ((a mod 2 == 0) && (b mod 2 == 0))
{
a = a/2; b = b/2; d = 2 · d;
}
while (a 6= 0)
{
/* a or b is odd */
while (a mod 2 == 0) a = a/2;
while (b mod 2 == 0) b = b/2;
/* a and b are odd */
if (a < b) swap(a, b)
a = a − b;
}
return (b · d);
}
39
(a, b ∈ N, a ≥ b, beide ungerade)
38
Beispiel: a = 40902, b = 24140
a
40902
b →
a
24140 → 20451
b
12770 ⇒ d = 2
20451 12770 → 20451
6035
14416
6035 →
901
6035
5134
901 →
2567
901
1666
901 →
833
901
68
833 →
17
833
816
17 →
51
17
34
17 →
17
17
0
17 →
⇒ ggT(40902, 24140) = 2 · 17 = 34
40
• Termination und Korrektheit von Binary Euclid ergeben sich aus den drei
verwendeten Gleichungen für den ggT
• Bei jedem Durchlauf der äusseren while-Schleife wird mindestens eines der
beiden Argumente halbiert ⇒ O(log(a + b)) Schleifendurchläufe
• Jeder Schleifendurchlauf erfordert Operationen (Vergleiche, Zuweisungen,
Divisionen durch 2, Subtraktion), die sich insgesamt in O(log(a + b))
Bit-Operationen ausführen lassen
• Binary Euclid berechnet den ggT von natürlichen Zahlen mit
O(log2 (a + b)) Bit-Operationen
(Heun, Grundlegende Algorithmen, Abschnitt 7.1; siehe auch Knuth, The
Art of Computer Programing, vol. 2, Seminumerical Algorihtms, Abschnitt
4.5.2, und Bach/Shallit, Algorithmic Number Theory, vol.1 Efficient
Algorithms, Kapitel 4)
Binary Extended Euclid (int a, int b)
{ /* returns (d, s, t), where d = gcd(a, b) = a · s + b · t */
(d, s, t) = (a, 1, 0);
(d0 , s0 , t0 ) = (b, 0, 1);
while (d0 6= 0)
{
if (d0 < d) swap((d, s, t), (d0 , s0 , t0 ))
0
c = 1 << max(`(d0 ) − `(d) − 1, 0); /*c = 2max(`(d )−`(d)−1,0) */
(d0 , s0 , t0 ) = (d0 , s0 , t0 ) − c(d, s, t);
}
return (d, s, t);
}
41
42
a
• die wesentliche Änderung gegenüber der iterativen Version der Euklidischen
Algorithmus
– an Stelle der exakten Quotienten bd0 /dc wird mit den angenäherten
Quotienten
0
c = 2max(`(d )−`(d)−1,0)
1023
b
15
`(a)−`(b)−1
x=b∗2
480
c=a−x
543
`(c)−`(b)−1
y =b∗2
480
d=c−y
63
`(d)−`(b)−1
z =b∗2
gerechnet (→ shift-Operationen). Dabei gilt
0
1
· bd0 /dc ≤ 2max(`(d )−`(d)−1,0) ≤ bd0 /dc
4
• Konsequenz für die Bit-Komplexität: auch Binary Extended Euclid
verwendet nur O(log2 (a + b)) Bit-Operationen.
e=d−z
u=b∗2
30
f =e−u
3
`(b)−`(f )−1
v =f ∗2
g =b−v
43
1
1
1
1
1
1
1
1
1
`(b) = 4
0
0
0
0
0
0
1
1
1
1
0
1
1
1
1
0
0
0
0
0
1
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
0
0
0
0
0
1
1
1
1
0
`(e) = 6
0
0
0
0
1
0
0
0
0
1
0
0
0
0
0
1
1
1
1
0
`(f ) = 2
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
1
0
0
1
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
1
1
`(c) = 10
`(d) = 6
6
9
`(g)−`(f )−1
1
30
33
`(e)−`(b)−1
`(a) = 10
w =f ∗2
6
h=g−w
3
`(g) = 4
`(h) = 2
44