Der Chinesische Restsatz und seine Anwendung in ... - SwissEduc

Der Chinesische Restsatz und seine
Anwendung in Computer-Algebra-Systemen
Stefan Heller Markus Hohenwarter Michael Huber
Rudolf Schürer
12. Dezember 2001
1 Der Chinesische Restsatz 1
Der Chinesische Restsatz beschreibt die Lösung eines Systems von Kongruenzen
der Form
x ≡
.
.
a1 (mod m1)
x ≡ an (mod mn).
Anwendungen ergeben sich dabei einerseits für das Rechnen mit großen Zahlen
(Modular-Arithmetik in Abschnitt 1.3), für das Rechnen mit Polynomen
(siehe Abschnitt 3), wie auch in anderen Gebieten.
1.1 Satz und Beweis
Satz 1 (Chinesische Restsatz) Seien m1,...,mn ∈
gcd(mi,mj) =1 für i = j.
, paarweise relativ prim, d. h.
Sei m = m1m2 ···mn und seien a1,...,an ∈ ¡ . Dann gibt es genau ein x ∈ ¡ mit
0 ≤ x

eine Lösung von (1), da für j =1,...,n
n
x ≡
mod m (mod mj)
≡
i=1
aiNiMi
n
aiNiMi (mod mj)
i=1
≡ aj NjMj
≡1
+
n
i=1
i=j
≡ aj (mod mj).
aiNi Mi
≡0
(mod mj)
Das stimmt, da für i = jMi ein Vielfaches von mj ist und daher Mi ≡ 0
(mod mj). NjMj ≡ 1(modmj), daNj ja gerade als Inverses zu Mj modulo
mj definiert war. Aufgrund der mod-Operation in (2) ist x auch im Bereich
0 ≤ x

Eine andere möglich Wahl, die zwar den Zahlenbereich verkleinert, andererseits
aber einige arithmetische Operationen vereinfacht, ist mi =2 ei −1. Dabei
ist e1 die Wortlänge, und für alle weiteren ei wird die jeweils nächstmögliche
kleinere Zahl gewählt, unter der Voraussetzung, daß der resultierende Modul
relativ prim zu allen vorhergehenden ist. Auf einer 32-bit Maschine und
für 4 Residuen ergibt das m1 =2 32 −1,m2 =2 31 −1,m3 =2 29 −1,m4 =2 27 −1
und damit m ≈ 2 119 .
Arithmetik
Viele wichtige Arithmetische Operationen lassen sich in Modular-Arithmetik
einfach dadurch ausführen, daß die entsprechende Operation auf die Residuen
ai modulo mi angewandt wird. Dazu zählen unter anderem:
• Addition und Subtraktion
• Multiplikation
• ggT und kgV
Dabei ist bemerkenswert, daß auch bei der Multiplikation die Rechenzeit nur
mit O(n) ansteigt, ein Resultat, das bei Zifferndarstellung nur mit aufwendigen
Algorithmen erzielt werden kann. Aber selbst bei Addition und Subtraktion
hat Modular-Arithmetik Vorteile: Da im Gegensatz zur ziffernweisen Addition/Subtraktion
kein Übertrag berücksichtigt werden muß, lassen sich die n
Operationen auf den Residuen unabhängig, und dadurch zum Beispiel auch
effizient parallel durchführen.
Leider gibt es auch ein Reihe von Operationen, die in Modular-Arithmetik
nicht möglich sind. Dazu zählen unter anderem:
• Division
• Größenvergleich zweier Zahlen
• Überprüfen, ob bei Addition/Subtraktion/Multiplikation ein Überlauf
aufgetreten ist
Für diese Operationen ist in der Regel ein Transformation in Zifferndarstellung
samt anschließender Rücktransformation nötig. Nur in Einzelfällen (z. B.
Größenvergleich) existieren effizientere Algorithmen.
Transformation Ziffern → Modular
Natürlich kann der Rest ai = x mod mi durch Division von x bestimmt werden.
Man muß dabei aber berücksichtigen, daß x in der Regel nicht in ein
Maschinen-Wort paßt, und daher eine entsprechende Divisions-Routine verwendet
werden muß.
Daher ist es oft einfacher ai durch Auswertung des folgenden Polynoms zu
berechnen (xmxm−1 ...x0 seien dabei die Ziffern von x zur Basis b)
ai =(...(xmb + xm−1)b + ...)b + x0,
wobei alle Operationen modulo mi ausgeführt werden können (Horner’s method).
3

Transformation Modular → Ziffern
Die Rücktransformation kann basierend auf dem konstruktiven Existenzbeweis
des Chinesischen Restsatzes erfolgen. Dazu werden die Zahlen Ci =
NiMi für i =1,...,n einmalig vorberechnet, und bei der eigentlichen Transformation
die Linearkombination
n
x =
mod m
i=1
aiCi
gebildet. Auch hier ist man wieder mit dem Problem konfrontiert, daß die Zahlen
Ci sowie alle Zwischenergebnisse groß sind. Es existieren bessere Algorithmen,
die die Transformation großteils basierend auf Berechnungen modulo mi
durchführen können.
2 Befehle in Mathematica und Derive 4
Im Folgenden werden zunächst die Syntax und danach die Implementierungen
der in Mathematica (Version 4) und Derive (Version 5) zur Verfügung stehenden
Befehle zur Lösung des Chinesischen Restsatz Problems (CRP) vorgestellt.
2.1 Syntax
Zur Erklärung der Syntax wollen wir folgendes einfache System von Kongruenzen
als Beispiel des CRP in Mathematica und Derive lösen.
Mathematica
r ≡ 0 (mod 4)
r ≡ 1 (mod 9)
r ≡ 2 (mod 121)
In Mathematica gibt es den Befehl ChineseRemainder, der jedoch erst nach
Laden des folgenden Pakets zur Verfügung steht:
< < NumberTheory‘NumberTheoryFunctions‘
Mittels ?ChineseRemainder informieren wir uns über die Syntax:
ChineseRemainder[list1, list 2] gives the minimal
nonnegative integer solution of Mod[r, list 2] == list 1.
The solution is unique modulo the LCM of list 2.
Die Argumente der Funktion sind also eine Liste von Resten (list 1) und eine
Liste von Moduln (list 2). Unser Beispiel lässt sich damit wie folgt lösen:
ChineseRemainder[{0, 1, 2}, {4, 9, 121}]
Als Ergebnis erhalten wir 244.
4 Von Markus Hohenwarter
4

Derive
In Derive heißt der entsprechende Befehl CRT (Chinese Remainder Theorem).
Er ist im Paket NUMBER.MTH (Number Theory Functions) definiert, welches
automatisch bei Verwendung eines ihrer Befehle geladen wird.
Die Syntax entspricht jener von Mathematica. Auch hier werden der Funktion
die Listen der Reste und Moduln übergeben:
CRT([0,1,2], [4,9,121])
Derive liefert ebenfalls die Lösung 244.
2.2 Implementierung
Sowohl Mathematica als auch Derive erlauben es uns, einen Blick auf die Implementierung
der Befehle ChineseRemainder bzw. CRT zu werfen, da die
entsprechenden Quelltexte den Distributionen beiliegen.
Mathematica
Im Folgenden ist die Implementierung von ChineseRemainder im Paket
NumberTheory‘NumberTheoryFunctions‘ abgedruckt.
Mathematica verwendet zwei verschiedene Algorithmen. Wenn alle Moduln
paarweise relativ prim und nicht zu groß sind (< 3000000), wird der
Algorithmus von Lagrange (vergleiche [4, Kapitel 3.1, Seite 54f]) verwendet
(CRTStandard).
Ansonsten kommt der rekursive Algorithmus von Newton (vergleiche [4,
Kapitel 3.1, Seite 55f]) zum Einsatz (CRTlist). Hierbei wird das Problem auf
ein System von zwei Kongruenzen zurückgeführt (CRTPair). Solange mehr
als 16 Kongruenzen vorliegen, geschieht dies in Mathematica tatsächlich rekursiv,
danach iterativ (CRTlist).
(* Chinese Remainder code is by Stan Wagon, Macalester College,
and Daniel Lichtblau, Wolfram Research, Inc.
It is based in part on earlier code by Mike McGeachie and
Craig Ortner (students at Macalester College).
January 1998. *)
ChineseRemainder[a_List, m_List] :=
If[ Max[m] < 3000000 && LCM @@ m == Times @@ m,
CRTStandard[a, m],
Catch[First[CRTlist[a, m, 1, Length[a]]]]
] /; Length[a] == Length[m]
CRTStandard[a_, m_] :=
Module[{mm = Times @@ m, m1},
m1 = mm/m;
Mod[a.(m1*PowerMod[m1, -1, m]), mm]
]
CRTpair[{a1_, a2_}, {m1_, m2_}] :=
Block[{mm, d = GCD[m1, m2]},
If[Mod[a1 - a2, d] == 0,
5

Derive
]
]
mm = m1/d;
{ Mod[a1+(a2-a1)*mm*PowerMod[mm, -1, m2/d], mm*m2],
mm*m2 },
Throw[{}]
CRTlist[a_, m_, first_, last_] /; last - first

¢
¢
Da
p(a) =b.
[x] ein euklidischer Bereich ist, garantiert der Euklidische Algorithmus
die Existenz von eindeutigen Polynomen q, r ∈ [x], sodaß
p(x) =q(x)(x − ai)+r
und r vom Grad 0, also ein Konstante unabhänging von x ist. Für x = a erhalten
wir dann
p(a) =q(a)(a − a)+r,
woraus sich r = p(a) =b ergibt. Es muß also für jede Lösung p(a) =b die
Kongruenz
p(a) ≡ b (mod x − a)
gelten.
Umgekehrt folgt aus
sofort
p(x) ≡ b (mod x − a)
p(x) =q(x)(x − a)+b
und damit
p(a) =q(a)(a − a)+b,
woraus sich die Lösung p(a) =b ergibt.
Insgesamt erhalten wir also
p(a) =b ⇐⇒ p(x) ≡ b (mod x − a).
Daher ist obige Problemstellung äquivalent mit einem System von Kongruenzen,
welches mit dem Chinesischen Restsatz lösbar ist.
Bemerkung: Der Chinesische Restsatz liefert ein Polynom mit minimalem
Grad.
3.2 Realisierung in Mathematica
Der Befehl ChineseRemainder funktioniert nicht mit Polynomen. Den mathematisch
geübten Benutzer hindert dies allerdings nicht an seinem Tun. Mit
einigen wenigen Änderungen wird die Funktion ChineseRemainder auf unsere
Anforderungen hin adaptiert. Dabei genügt es, sich auf relativ prime Moduln
zu beschränken.
Zur Erinnerung hier noch einmal die entscheidende Passage aus der aus
Abschnitt 2.2 bekannten Implementierung für relativ prime Moduln:
CRTStandard[a_List, m_List] :=
Module[{mm = Times @@ m, m1},
m1 = mm / m;
Mod[a . (m1 * PowerMod[m1, -1, m]), mm]
]
7

Der Algorithmus bleibt im Prinzip der Gleiche. In der 4. Zeile wird der Befehl
Mod verwendet, der wieder nicht mit Polynomen arbeitet. Mathematica bietet
dafür die Funktion PolynomialRemainder[p, q, x],diewieMod arbeitet,
nur mit Polynomen im Parameter x.
Das Inverse zu m1 modulo m berechnet sich mit dem erweiterten euklidischen
Algorithmus: Sei m1,m teilerfremd, dann gibt es r und s so daß 1=
rm1 + sm. Damit haben wir rm1 =1(modm), worausfolgt,daßr invers zu
m1 modulo m ist.
In Mathematica wird dafür die Funktion PolynomialExtendedGCD[p1,
p2] im Paket Algebra’PolynomialExtendedGCD’ verwendet. Als Ergebnis
wird die Liste {gcd, {r, s}} geliefert.
Da PolynomialExtendedGCD nicht mit Listen arbeitet, wird die Funktion
MapThread verwendet. MapThread[f, {{a1,a2,...}, {b1,b2,...},...}]
liefert {f[a1,b1,...], f[a2,b2,...],...}.
Mit diesen Überlegungen wird aus CRTStandard{aList, mList] die erweiterte
Funktion PolynomialCRT[aList, mList, x] :
PolynomialCRT[a_List, m_List, x_] :=
Module
[
{mm = Times @@ m, m1},
m1 = mm / m;
PolynomialRemainder[
a . (m1 * MapThread[PolynomialExtendedGCD, {m1, m}]
[[All, 2]][[All, 1]]),
mm, x]
]
3.3 Beispiel Anwendung
Gegeben sind die Punkte (1, 1), (2, −4), (3, 0), (4, −1). Gesucht sei ein Polynom,
das diese Punkte als Lösungen besitzt.
Also benötigen wir die Lösung von diesem System von Kongruenzen:
p(x) ≡ 1 (mod x − 1)
p(x) ≡ −4 (mod x − 2)
p(x) ≡ 0 (mod x − 3)
p(x) ≡ −1 (mod x − 4)
Abbildung 1 enthält die nötigen Mathematica Befehle zum Berechnen des
Interpolationspolynoms. Abbildung 2 zeigt die resultierende Mathematica Grafik.
8

Algebra‘PolynomialExtendedGCD‘
PolynomialCRT[a_List, m_List, x_] :=
Module
[
{mm = Times @@ m, m1},
m1 = mm / m;
PolynomialRemainder[
a . (m1 * MapThread[PolynomialExtendedGCD, {m1, m}]
[[All, 2]][[All, 1]]),
mm, x]
]
PolynomialCRT[{1, -4, 0, -1}, {x - 1, x - 2, x - 3, x - 4}, x]
-1\6 (-4 + x)(-3 + x)(-2 + x) - 2 (-4 + x)(-3 + x)(-1 + x)
- 1\6 (-3 + x)(-2 + x)(-1 + x)
Simplify[%]
29 - 265 x \ 6 + 37 x^2 \ 2 - 7 x^3 \ 3
poly = Plot[%, {x, 0, 5}, DisplayFunction -> Identity];
punkte = ListPlot[{1, -4, 0, -1}, PlotStyle -> PointSize[.03],
DisplayFunction -> Identity];
Show[{poly, punkte}, DisplayFunction -> $DisplayFunction]
Abbildung 1: Interpolation mittels des Chinesischen Restsatzes
5
-5
-10
1 2 3 4 5
Abbildung 2: Das berechnete Interpolationspolynom
9