Karazuba-Algorithmus
# Karazuba-Algorithmus

Der Karazuba-Algorithmus ist ein Algorithmus zur Multiplikation zweier großer ganzer Zahlen. Er wurde 1960 von dem 23-jährigen Anatoli Alexejewitsch Karazuba (engl. Karatsuba, russisch Анатолий Алексеевич Карацуба) entwickelt und 1962 veröffentlicht.

Bezeichnet $n$ die Bit-Anzahl der beiden Zahlen und $O$ ein Landau-Symbol, so ist der Algorithmus mit einer Laufzeitkomplexität von $O(n^{\log _{2}3}),\ \log _{2}3=1{,}5849\ldots ,$ deutlich schneller als die Schulmethode. Diese (und auch deren implizite Übertragung auf das Binärsystem in Form der russischen Bauernmultiplikation) besitzt eine Laufzeitkomplexität von $O(n^{2})$. Die Methode von Karazuba wurde zum Vorbild für das Teile-und-herrsche-Prinzip in der Informatik. Für hinreichend große Zahlen ist der Karazuba-Algorithmus langsamer als seine Verallgemeinerungen, wie der Toom-Cook-Algorithmus (1965) und der Schönhage-Strassen-Algorithmus (1971), dessen Laufzeitkomplexität $O{\bign(\log n)\log(\log n){\big )}$ beträgt und der aus Sicht der Komplexitätstheorie als schnellster Algorithmus zur Multiplikation großer ganzer Zahlen galt, bis 2007 Martin Fürer eine Weiterentwicklung mit einer (bisher nur theoretisch) geringeren Laufzeitkomplexität vorstellte.

## Idee des Algorithmus

Multiplizieren verursacht in der Schulmethode einen Aufwand, der mit dem Quadrat der Stellenanzahl wächst, während Additionen und Verschiebeoperationen, bei denen mit einer Potenz der Basis des verwendeten Stellenwertsystems multipliziert wird, nur linearen Aufwand benötigen. Die Idee ist, nach dem Teile-und-herrsche-Prinzip die beiden zu multiplizierenden Zahlen in zwei Teile aufzuspalten, und die Multiplikationen soweit möglich durch Additionen und Verschiebeoperationen zu ersetzen. Das Ausmultiplizieren der aufgeteilten Zahlen ergibt drei Teilterme, die durch vier Multiplikationen gebildet werden. Diese können durch Verschiebe- und Additionsoperationen zum Gesamtergebnis zusammengesetzt werden. Einer dieser Terme ist dabei eine Summe zweier Produkte. Dieser Term lässt sich als Differenz mit einem neuen Produkt und der Summe der anderen beiden Teilterme schreiben. Insgesamt spart man so also eine Teilmultiplikation ein. Führt man dieses Verfahren rekursiv durch, so erhält man eine wesentlich günstigere Laufzeit als nach der Schulmethode.

## Der Algorithmus im Detail

Der hier angegebene Algorithmus gilt für natürliche Zahlen, er lässt sich aber leicht auch auf ganze Zahlen verallgemeinern, indem ihre Vorzeichen gesondert berücksichtigt werden. Die Faktoren $X$ und $Y$ seien im Stellenwertsystem zur Basis $b$ als Tupel dargestellt. Der Wert von $b$ ist unerheblich: Etwa in einem Computer mit einem Multiplizierer für 32 Bit breite Zahlen würde $b=2^{31}$ gewählt werden. Die Beispiele weiter unten verwenden Dezimalzahlen. Um die Rekursion bis $n=1$ durchführen zu können, seien die Längen beider Zifferntupel eine Zweierpotenz $2^{m}$ mit $m>1$, und es sei $n:\,=2^{m-1}$. Das ist immer erreichbar durch geeignet vorangestellte Nullen; an der unten durchgeführten Laufzeitabschätzung ändert sich dadurch nichts Wesentliches.

Die Zifferntupel seien also

    $X=(x_{2n-1}\ldots x_{0})_{b}\$ und $\ Y=(y_{2n-1}\ldots y_{0})_{b}.$

Jedes Zifferntupel wird nun in zwei Tupel der Länge $n$ aufgespalten. Das liefert die vier Zahlen

    $X_{h}=(x_{2n-1}\ldots x_{n})_{b}\$ und $\ X_{l}=(x_{n-1}\ldots x_{0})_{b}\$ sowie
    $Y_{h}=(y_{2n-1}\ldots y_{n})_{b}\$ und $\ Y_{l}=(y_{n-1}\ldots y_{0})_{b}.$

Damit ist

    $X=X_{h}b^{n}+X_{l}\$ und $\ Y=Y_{h}b^{n}+Y_{l}.$

Ausmultipliziert ergibt sich

    $X\,Y=(X_{h}b^{n}+X_{l})(Y_{h}b^{n}+Y_{l})=X_{h}Y_{h}b^{2n}+(X_{h}Y_{l}+X_{l}Y_{h})\,b^{n}+X_{l}Y_{l}.$

Den Term $X_{h}Y_{l}+X_{l}Y_{h}$ kann man nun in eine andere, hier schneller berechenbare Form bringen:

    $X_{h}Y_{l}+X_{l}Y_{h}=(X_{h}Y_{h}+X_{h}Y_{l}+X_{l}Y_{h}+X_{l}Y_{l})-(X_{h}Y_{h}+X_{l}Y_{l})=(X_{h}+X_{l})(Y_{h}+Y_{l})-(X_{h}Y_{h}+X_{l}Y_{l}).$

Damit ergibt sich für das Produkt die Darstellung

    $X\,Y=X_{h}Y_{h}b^{2n}+{\big(X_{h}+X_{l})(Y_{h}+Y_{l})-(X_{h}Y_{h}+X_{l}Y_{l}){\big )}\,b^{n}+X_{l}Y_{l},$

in der nur noch die drei „kurzen“ Produkte

    $P_{1}=X_{h}Y_{h},\ P_{2}=X_{l}Y_{l},\ P_{3}=(X_{h}+X_{l})(Y_{h}+Y_{l})$

erscheinen. Rekursiv berechnet und mit einfachen Verschiebe- und Additionsoperationen verknüpft ergeben sie

    $X\,Y=P_{1}b^{2n}+{\bigP_{3}-(P_{1}+P_{2}){\big )}\,b^{n}+P_{2}.$

Von den vier möglichen Produkten (von X mit Y) $X_h$ $Y_h,$ $X_h$ $Y_l,$ $X_l$ $Y_h,$ $X_l$ $Y_l$ wird das erste $P_1$ und das letzte $P_2$ direkt im Ergebnis verwendet. Der Term aus der Summe der beiden mittleren Produkten kann als Summe von allen Produkten minus des ersten und letzten Produkt gebildet werden. Die Summe aus allen vier Produkten kann über das neu eingeführte Produkt $P_3$ mit nur einer Multiplikation erzeugt werden.

## Laufzeitanalyse

Eine Multiplikation zweier $2n$-stelliger Zahlen wird zurückgeführt auf drei Multiplikationen von je zwei $n$-stelligen Zahlen und vier Additionen bzw. Subtraktionen $n$-stelliger Zahlen eventuell mit Überträgen sowie mit zwei Verschiebungen. Die benötigte Zeit für die Operationen, die keine Multiplikationen sind, ist kleiner als $cn$ mit einer von $n$ unabhängigen Konstanten $c$. Bezeichnet $T(s)$ die Gesamtzahl der Operationen bei der Multiplikation zweier $s$-stelliger Zahlen, so gilt

    $T(2n)\leq 3T(n)+cn,\ T(1)=1.$

Der hier anwendbare erste Fall des Master-Theorems mit $a=3,\ b=2$ und $f(n)\leq cn$ liefert $O(n^{\log _{2}3})$ als Laufzeitkomplexität von $T(n).$ Die direkte Herleitung mit vollständiger Induktion ermöglicht einen genaueren Einblick:

    $T(2^{m})\leq 3^{m}T(1)+{\frac {c}{2}}2^{m}\sum \limits _{k=0}^{m-1}\left({\frac {3}{2}}\right)^{k}=3^{m}+c(3^{m}-2^{m})<(c+1)\,3^{m}.$

Ersetzen von $2^{m}$ durch $n$ ergibt dann

    $T(n)<(c+1)\,(2^{\log _{2}3})^{m}=(c+1)\,(2^{m})^{\log _{2}3}=(c+1)\,n^{\log _{2}3}.$

## Beispiel zur Produktumformung

Die zu multiplizierenden Zahlen seien

    $X=84\,232\,332\,233\$ und $\ Y=1\,532\,664\,392$.

Da es hier nur um die Veranschaulichung der Produktumformung geht, wird mit vorangestellten Nullen auf die nächste gerade und gleiche Länge und nicht auf eine Zweipotenzlänge aufgefüllt. Damit ergeben sich die Zifferntupel

    $X={\color {Blue}084\,232}\,{\color {OliveGreen}332\,233}$ und $Y={\color {Red}001\,532}\,{\color {Brown}664\,392}$

der Länge $2n=12$, die in vier Tupel der Länge $n=6$ zerlegt werden:

    $X_{h}={\color {Blue}084\,232}$ und $X_{l}={\color {OliveGreen}332\,233}$ sowie
    $Y_{h}={\color {Red}001\,532}$ und $Y_{l}={\color {Brown}664\,392}.$

Es gilt

    $X=X_{h}\cdot 10^{6}+X_{l}={\color {Blue}084\,232}\cdot 10^{6}+{\color {OliveGreen}332\,233}$ und
    $Y=Y_{h}\cdot 10^{6}+Y_{l}={\color {Red}001\,532}\cdot 10^{6}+{\color {Brown}664\,392}.$

Die benötigten Produkte sind

    $P_{1}=X_{h}\cdot Y_{h}={\color {Blue}084\,232}\cdot {\color {Red}001\,532}=000\,129\,043\,424$,
    $P_{2}=X_{l}\cdot Y_{l}={\color {OliveGreen}332\,233}\cdot {\color {Brown}664\,392}=220\,732\,947\,336$ und
    $P_{3}=$$\!(X_{h}+X_{l})\cdot (Y_{h}+Y_{l})=({\color {Blue}084\,232}+{\color {OliveGreen}332\,233})\cdot ({\color {Red}001\,532}+{\color {Brown}664\,392})=416\,465\ \cdot \ 665\,924=277\,334\,038\,660.$

Der Algorithmus würde die Produkte $P_{1}$, $P_{2}$ und $P_{3}$ rekursiv bestimmen. Es bleibt das Ergebnis gemäß obiger Formel zusammenzusetzen:

    ${\begin{array}{rll}X\cdot Y&=&P_{1}\cdot 10^{12}+{\bigP_{3}-(P_{1}+P_{2}){\big )}\cdot 10^{6}+P_{2}\\&=&000\,129\,043\,424\cdot 10^{12}\\&&+{\big277\,334\,038\,660-(000\,129\,043\,424+220\,732\,947\,336){\big )}\cdot 10^{6}\\&&+220\,732\,947\,336.\end{array}}$

Während die Schulmethode 110 Ziffernmultiplikationen und 90 Additionen (ohne Überträge) benötigt, sind es hier 92 Multiplikationen und 83 Additionen.

## Verallgemeinerung

Statt in zwei Teile, können die zu multiplizierenden Zahlen auch in mehr Teile zerlegt werden. Durch geschickte Linearkombination von Teilergebnissen genügen dann bei Zerlegung in $d+1$ Teile $2d+1$ Multiplikationen auf den kleineren Zahlen. Rekursiv angewandt führt dieses Verfahren dann zum Toom-Cook-Algorithmus.

