Mitschrift der Vorlesung

Numerische lineare Algebra I

an der TU Berlin

WS 2013/2014

Dozent: Christian Schröder

Übersetzung und Tex: Benedikt Bodendorf

Quellen

(1) Skript, Numerische Lineare Algebra I, C. Mehl, 2005(2) L. Trefethen, D. Bau, Numerical linear algebra, SIAM Philadelphia,

1997(3) C. Mehl, S. Börm, Numerical Methods for Eigenvalue Problems, De

Gruyter, to appear, 2012

Weiterführende Literatur:

(1) G. Golub, C. Van Loan, Matrix Computations, 3rd Ed, Boltimore,1996

(2) N.J. Higham, Accuracy and stability of numerical algorithms, Phil-adelphia, 2002

i

Inhaltsverzeichnis

Quellen i

Kapitel 0. Einleitung 1

Kapitel 1. Matrix Theorie 51. Grundlagen 52. Matrix Zerlegungen 63. Winkel und Abstände zwischen Unterräumen 10

Kapitel 2. Der Jacobi-Algorithmus 131. Der 2 x 2 Fall 132. Der Jacobi-Algorithmus 143. Eigenpaar-Fehlergrenzen 184. Quadratische Konvergenz 20

Kapitel 3. Groÿe Eigenwert-Probleme 251. Die Potenzmethode 252. Unterraum-Iteration 273. Projektionsmethoden 294. Krylov Unterräume und die Arnoldi-Methode 305. Die symmetrische Lanczos-Methode 366. Die nicht-symmetrische Lanczos-Methode 377. Shift-Invert-Krylov-Methoden 398. Jacobi-Davidson-Methode 40

Kapitel 4. Groÿe lineare Gleichungssysteme 431. Iterative Verbesserung 442. Projektionsmethoden 453. GMRES Methode 464. Konjugierte Gradienten Methode (CG) 50

i

KAPITEL 0

Einleitung

Numerische lineare Algebra ist das Studium der Algorithmen von Pro-

blemen der linearen Algebra mit Augenmerk auf Geschwindigkeit/Kosten,

Genauigkeit/Stabilität und Konvergenz.

Geschwindigkeit/Kosten.

• Wie lange braucht der Algorithmus um ein Problem der Gröÿe n

zu lösen?

• Wie viele elementare Operationen (FLOPS/�oating point operati-

ons) sind nötig?

• Z.B. das Lösen eines linearen Gleichungssystems (LGS) Ax = b,

A ∈ Cn×n mit

� Gauÿsche Elimination: 23n

3 +O(n2)

� Householder QR: 43n

3 +O(n2)

• Wie viel Speicher wird benötigt?

Genauigkeit/Stabilität.

• Abstrakt gesprochen ist ein Problem eine Abbildung x = f(a, b, ...),

z. B. LGS: x = f(A, b) = A−1b.

• Ein Algorithmus ist eine Abbildung f(a, b, ...), welche f approxi-

miert, z. B. gauÿsches Eliminationsverfahren mit Rundung.

Definition 0.1. Ein Algorithmus f heiÿt vorwärtsstabil für ein Problem

f mit den Eingabewerten a, b, ..., wenn‖f(a,b,...)−f(a,b,...)‖

‖f(a,b,...)‖ klein ist.1

Er ist vorwärtsstabil für f , wenn er für alle Eingabewerte a, b, ... vor-

wärtsstabil ist.

Definition 0.2. Ein Algorithmus f heiÿt rückwärtsstabil für ein Pro-

blem f mit den Eingabewerten a, b, ..., wenn ∆a,∆b, ... existieren, sd. f(a, b, ...) =

f(a+ ∆a, b+ ∆b, ...) und max{‖∆a‖‖a‖ ,

‖∆b‖‖b‖ , ...

}klein ist.

Er ist rückwärtsstabil für f , wenn er für alle Eingabewerte a, b, ... rück-

wärtsstabil ist.

Ein rückwärtsstabiler Algorithmus löst das Problem für leicht abweichen-

de Eingabewerte genau.

1Für gewöhnlich c ·Emach, wobei c eine Konstante und Emach die Maschinengenauigkeit ist.

1

Beispiel 0.1.

• Für LGS existiert kein vorwärtsstabiler Algorithmus.

• Das gauÿsche Eliminationsverfahren ist nur für wenige A, b rück-

wärtsstabil, für die meisten A, b ist es instabil.

• Das gauÿsche Eliminationsverfahren mit Pivotisierung ist rückwärts-

stabil für fast alle A, b, aber für ein paar A, b instabil.

• Die Householder QR-Transformation ist rückwärtsstabil.

Konvergenz. Nur für iterative Algorithmen, welche eine Folge {xi}i=1,2,...

generieren.

• Konvergiert {xi}? Wenn ja, konvergiert sie zu f(a, b, ...)?

• Wie schnell konvergiert sie?

• Wann bricht man ab?

Hauptprobleme. Die Hauptprobleme der numerischen linearen Algebra

sind:

• Lineare Gleichungssysteme (LGS):

Gegeben: Eine nicht singuläre Matirx A ∈ Cn×n und ein

Vektor b ∈ Cn.Gesucht: x ∈ Cn, sd. Ax = b.

Spezialfälle: A hermititsch, A positiv de�nit, ...

• Eigenwertprobleme (EWP):

Gegeben: A ∈ Cn×n.Gesucht: x ∈ Cn, λ ∈ C, sd. Ax = λx.

Spezialfälle: A hermititsch, ...

• Kleinste Quadrate Probleme (KQP):

Gegeben: A ∈ Cm×n, m > n, b ∈ Cm.Gesucht: x ∈ Cn, sd. ‖Ax− b‖2 = min.

Spezialfälle: A hat nicht vollen Rang

Wir werden uns auf LGS und EWP beschränken. Im Folgenden ist A

eine n× n Matrix mit komplexen Einträgen.

Zwei häu�ge Situationen.

• A ist dichtbesetzt (d. h. fast alle Einträge von A sind ungleich 0).

=⇒ n ist klein2

• A ist dünnbesetzt (d. h. nur wenige Einträge von A sind ungleich

0).

=⇒ nur die Einträge ungleich 0 müssen zwischengespeichert wer-

den, n ist groÿ3

2Heutzutage ungefähr 10000, ��ts on computer�.31000000 oder mehr.

2

LGS EWPdichtbesetzt Gauÿsche Elimination QR-Algorithmus

Householder QR Jacobi-Algorithmusdünnbesetzt GMRES Arnoldi Methode

Konjugierte Gradienten Lanczos MethodeJacobi-Davidson

Bemerkung 0.1. In der Praxis sollte der QR-Algorithmus angewandt

werden. QR-Factorisierung: A = QR. QR-Algo.: Ak = QkRk, Ak+1 = RkQk,

wobei auf der Diagonalen von R die Eigenwerte von A sind.

3

KAPITEL 1

Matrix Theorie

1. Grundlagen

Definition 1.1. Für eine Matrix A heiÿt λ ∈ C Eigenwert, wenn Ax =

λx eine nicht triviale Lösung x ∈ Cn \ {0} hat.Diese Lösungen x heiÿen Eigenvektoren von A zum Eigenwert λ. Man

nennt (λ, x) Eigenpaar.

Folgende Menge wird als Spektrum von A bezeichnet:

Λ(A) := {λ ∈ C|λ ist ein Eigenwert von A}

Fakt: Wenn A hermitisch ist, dann Λ(A) ⊂ R.

Definition 1.2. Für eine Matrix A ∈ Cm×n nennt man das Skalar

‖A‖p := supx∈C\{0}

‖Ax‖p‖x‖p

die Matrix-p-Norm von A, wobei p ∈ N ∪ {∞}.1 Für m = n und A nicht

singulär nennt man das Skalar

κp(A) := ‖A‖p ·∥∥A−1

∥∥p

die Konditionszahl von A. (Für singuläre A : κp(A) =∞.)

Definition 1.3. Man nennt eine Matrix U ∈ Cn×k mit k ≤ n

• isometrisch, wenn UHU = Ik.

• unitär, wenn sie isometrisch und n = k ist.

Satz 1.1. Für eine Matrix U ∈ Cn×k mit k ≤ n sind folgende Aussagen

äquivalent:

(a) U ist isometrisch.

(b) Die Spalten von U sind paarweise orthonormal.

(c) < Ux,Uy >=< x, y > ∀x, y ∈ Ck.2

(d) ‖Ux‖2 = ‖x‖2 ∀x ∈ Ck.3

Wenn auÿerdem n = k, dann sind (a)-(d) äquivalent zu:

1Jede Norm, die so geschrieben werden kann, heiÿt Operator-Norm2< x, y >= xHy ist das gewöhnliche innere (Skalar-)Produkt.3Diese Eigenschaft ist namensgebend für isometrische Matrizen.

5

(e) UUH = In.

(f) U−1 = UH .

(g) Die Zeilen von U sind paarweise orthonormal.

(h) ‖U‖2 = 1 =∥∥U−1

∥∥2

= κ2(U).

Definition 1.4. Eine Teilmenge U ⊂ Cn heiÿt (linearer) Unterraum,

wenn αx+ y ∈ U für alle x, y ∈ U , α ∈ C.

Satz 1.2. Sei U ⊂ Cn ein Unterraum mit Basis (x1, ..., xn) und X =

[x1, ..., xn] ∈ Cn×m. Dann gelten folgende Aussagen:

(a) rank(X) = m.

(b) U = range(X) := {Xy|y ∈ Cm}.(c) Sei Y ∈ Cn×m mit rank(Y ) = m. Dann gilt:

range(X) = range(Y ) ⇐⇒ X = Y · B für ein invertierbares B ∈Cm×m.

(d) Der Gram-Schmidt Algorithmus angewandt auf (x1, ..., xm) liefert

eine orthonormale Basis (q1, ..., qm) von U mit

range([q1, ..., qm]) = range([x1, ..., xm])∀ i = 1, ...,m. D. h. es exis-

tiert eine obere Dreiecksmatrix R ∈ Cm×m, sd. X = QR mit Q =

[q1, ..., qm].

Definition 1.5. Sei A ∈ Cn×n, U ⊂ Cn. Man nennt U A-invariant,

wenn x ∈ U ⇒ Ax ∈ U ∀x ∈ Cn. Wenn U 6= {0},Cn, wird U nicht trivial

genannt.

Satz 1.3. Sei A ∈ Cn×n, X ∈ Cn×k, rank(X) = k, U = range(X). Dann

sind folgende Aussagen äquivalent:

(a) U ist A-invariant.

(b) Es gibt eine Matrix B ∈ Ck×k, sd. AX = XB.

In diesem Fall gilt zusätzlich für λ ∈ C, v ∈ Ck

Bv = λv =⇒ A (Xv) = λ (Xv) .

Damit ist jeder Eigenwert von B ein Eigenwert von A. �AX = XB� äh-

nelt �Ax = λx�, daher nennt man B Eigenwertpack und X Eigenvektorpack.

2. Matrix Zerlegungen

� QR-Zerlegung

� LR-Zerlegung

� Cholesky-Zerlegung

� Singulärwertzerlegung

� Schurform, Schur-Normalform oder Schur-Zerlegung

6

� Polarzerlegung4

Satz 1.4 (Schur, 1909). Sei A ∈ Cn×n. Dann existiert eine unitäre

Matrix U ∈ Cn×n, sd. T := UHAU eine obere Dreiecksmatrix ist.

Beweis. Induktion über n. Der Fall n = 1 ist trivial (U = 1, T = A).

n− 1 −→ n:

Sei (λ, v) ein Eigenpaar von A und q1 = v‖v‖2

. Erweitere q1 zu einer ortho-

normalen Basis von Cn. Dann ist Q := [q1, ..., qn] unitär und es gilt

AQ = Q

λ A12

0... A22

0

für gewisse A12 ∈ C1×n−1, A22 ∈ Cn−1×n−1.

Durch die Induktionsannahme existiert eine unitäre Matrix U22 ∈ Cn−1×n−1,

sd. UH22A22U22 =: T22 eine obere Dreiecksmatrix ist. Mit

U := Q

1 0 . . . 0

0... U22

0

erhält man:

T := UHAU =

1 0 . . . 0

0... UH22

0

λ A12

0... A22

0

1 0 . . . 0

0... U22

0

=

λ A12

0... T22

0

T ist eine obere Dreiecksmatrix. �

Bemerkung 1.1.

• Der Beweis ist konstruktiv, allerdings sollte die verwendete Methode

in der Praxis nicht benutzt werden. Sie ist von Komplexität O(n4),

wohingegen der QR-Algorithmus von Komplexität O(n3) ist.

• U kann so gewählt werden, dass die Eigenwerte von A in jeder

beliebigen Reihenfolge auf der Diagonalen von T stehen.

4A = UH, wobei U unitär und H hermitisch, positiv semide�nit.

7

Definition 1.6. Eine Matrix T ∈ Rn×n heiÿt quasi-obere Dreiecksma-

trix, wenn T eine obere Block-Dreiecksmatrix mit Blöcken der Gröÿe 1 × 1

oder 2× 2, wobei die 2× 2 Blöcke keine reellen Eigenwerte besitzen.

Satz 1.5 (Murungham, Wintner, 1931 (aka reelle Schurform)). Sei A ∈Rn×n. Dann existiert eine orthogonale Matrix Q ∈ Rn×n, sd. QTAQ =: T

eine quasi-obere Dreiecksmatrix ist.

Beweis. Analog zum komplexen Fall.

Skizze:

Wenn A einen reellen Eigenwert (und damit auch einen reellen Eigenvektor)

hat, verfahre wie im komplexen Fall. Andernfalls:

Sei λ = λ1 + iλ2 ein komplexer Eigenwert von A und v = v1 + iv2 der ent-

sprechende Eigenvektor, wobei v1, v2 ∈ Rn, λ1, λ2 ∈ R. Verfahre wie folgt:

A(v1 + iv2) = (v1 + iv2)(λ1 + iλ2) liefert

A [v1, v2] = [v1, v2]

[λ1 λ2

−λ2 λ1

],

d. h. range([v1, v2]) ist A-invariant. Sei (q1, q2) eine orthonormale Basis von

[v1, v2] und [q1, ..., qn] orthogonal, dann ist

Q>AQ =

[A11 A12

0 A22

]mit A11 ähnlich zu

[λ1 λ2

−λ2 λ1

].

Verfahre nun wie im komplexen Fall. �

Definition 1.7. Eine Matrix A ∈ Cn×n heiÿt normal, wenn

AAH = AHA.

Beispiele dafür sind hermitische, schief-hermitische, unitäre oder diago-

nale Matrizen.

Satz 1.6. Sei A ∈ Cn×n normal und U ∈ Cn×n unitär, sd.

UHAU =

[A11 A12

0 A22

]für ein gewisses A11 ∈ Ck×k.

Dann ist A12 = 0.

Korollar 1.1. Sei A normal. Dann existiert eine unitäre Matrix U , sd.

UHAU diagonal ist.

Beweis. Skizze:

Schurform: UHAU = T diagonal. Benutze vorherige Ergebnisse für jedes

k = 1, 2, ..., n− 1⇒ T ist diagonal. �

8

Satz 1.7 (Singulärwertzerlegung (kurz SVD)5). Sei A ∈ Cm×n von Rang

r. Dann existieren unitäre Matrizen U ∈ Cm×m und V ∈ Cn×n, sd.

UHAV = Σ =

[Σ1 0

0 0

]∈ Cm×n für gewisse Σ1 =

σ1 0

. . .

0 σr

∈ Rr×r,

wobei σ1 ≥ σ2 ≥ ... ≥ σr > 0.6

Definition 1.8. Seien A,U = [u1, ..., um] , V = [v1, ..., vn] , σ1, ...σr wie

oben gegeben. Setze σr+1 = ... = σmin{m,n} = 0.

(a) σ1, ...σmin{m,n} heiÿen Singuläwerte von A.

(b) u1, ..., um heiÿen Links-Singulärvektoren von A.

(c) v1, ..., vn heiÿen Rechts-Singulärvektoren von A.

(d) (σi, ui, vi) heiÿt Singulärtripel von A für i = 1, ...,min{m,n}.

Man beachte, dass die Singulärtripel durch AHui = σivi und Avi = σiui

charakterisiert werden. Diese Gleichungen ähneln der Eigenpaargleichung.

Bemerkung 1.2.

(a) A = UΣV H .

(b) • AHA = V ΣHUHUΣV H = V

[Σ2

1 0

0 0

]V H

• AAH = UΣHV HV ΣUH = U

[Σ2

1 0

0 0

]UH

Damit sind σ21, ..., σ

2r die Eigenwerte von AA

H und AHA, wel-

che ungleich Null sind.

• (v1, ..., vn) sind Eigenvektoren von AHA.

• (u1, ..., um) sind Eigenvektoren von AAH .

• ‖A‖2 = σ1

• Wenn m = n und A invertierbar, dann gilt∥∥A−1

∥∥2

= σ−1n ⇒

κ(A) = σ1σn.

(c) AV = UΣ ⇒ Kern(A) = span{vr+1, ..., vn} und range(A) =

span{u1, ...ur}

5Im Englischen: singular value decomposition.6Dieses Verfahren ist in der Praxis äuÿerst erfolgreich. Es wurde sogar im ersten StarTrek Film als Algorithmus für Spoks Computer benutzt, auf diesem wurden dann dieZwischenschritte angezeigt, die eine Matrix auf Diagonalform bringen.

9

(d) Neben der vollen SVD oben gibt es auch eine economy SVD7, z. B.

für m > n:

A = U ΣV H , wobei U = [u1, ..., ur] , Σ =

[Σ1 0

0 0

]∈ Rn×n;

und eine dünne SWZ :

A = UΣ1VH mit U = [u1, ..., ur] , V = [v1, ..., vr] .

(e) Die SVD kann auch als Summe geschrieben werden:

A = UΣ1V (dünne SVD)

= U

σ1

0. . .

0

+ ...+

0

. . .

0

σr

V H

=r∑i=1

σiuivHi .

Man kann zeigen, dass für 0 ≤ k ≤ min{m,n}

Ak :=k∑i=1

σiuivHi

die beste Rang-k-Approximation von A im Bezug auf die 2-Norm

ist, d. h.

infB∈Cm×n, Rang(B)=k

‖A−B‖2 = ‖A−Ak‖2 = σk+1.

(f) Anwendungen gibt es viele: numerische Rangbestimmung, beste

Rang-k-Approximation, Datenkompression (U , V , Σ benötigen we-

niger Speicher als A, wenn r << m,n), Bildkompression (in der

Praxis eher nicht), Berechnung des Kerns, Berechnung der Kondi-

tionszahl, Bestimmung von Winkeln zwischen Unterräumen

3. Winkel und Abstände zwischen Unterräumen

Seien U ,V ⊂ Cn Unterräume der Dimension k. Wie nah sind U und V zu-

einander? (Z. B. wie gut ist eine gefundene Approximation eines invarianten

Unterraums?)

Bestimme die Winkel zwischen den Vektoren in U , V iterativ, startend beidem Kleinsten, d. h. �nde normierte Vektoren x ∈ U , y ∈ V, sd. | < x, y > |

7In Matlab ruft man mit [U, S, V ] = svd(A) die volle SVD auf und mit ... = svd(A, 0) dieeconomy SVD.

10

maximal ist. Man beachte, dass x, y so gewählt werden kann, dass < x, y >

real und nicht-negativ ist:

(a) Wähle x1 ∈ U und y1 ∈ V mit ‖x1‖2 = 1 = ‖y1‖2, sd.

〈x1, y1〉 = maxx∈U ,y∈V

‖x1‖2=1=‖y1‖2

{Re 〈x, y〉}

Dann ist 〈x1, y1〉 ≤ 1, real und nicht-negativ. Man nennt θ1 :=

arccos 〈x1, y1〉 den ersten kanonischen Winkel und x1, y1 die ersten

kanonischen Vektoren.

(b) Hat man x1, ..., xj−1 ∈ U und y1, ..., yj−1 ∈ V (mit x1, ..., xj−1

und y1, ..., yj−1 orthonormal) bestimmt, fährt man fort, indem man

xj ∈ U und yj ∈ V so wählt, dass xj⊥x1, ..., xj−1, yj⊥y1, ..., yj−1,

‖xj‖2 = 1 = ‖yj‖2 und 〈xj , yj〉 = max{Re 〈x, y〉} mit x ∈ U , y ∈V, x⊥x1, ..., xj−1, y⊥y1, ..., yj−1, ‖x‖2 = 1 = ‖y‖2.

Dann ist 〈xj , yj〉 real, nicht-negativ und 0 ≤ 〈xj , yj〉 ≤ cosθj−1

und man nennt θj := arccos 〈xj , yj〉 den j-ten kanonischen Winkel

und xj , yj die j-ten kanonischen Vektoren. Dies liefert k kanonische

Winkel 0 ≤ θ1 ≤ ... ≤ θk ≤ π2 und orthonormale Basen x1, ..., xk

von U und y1, ..., yk von V.

Lemma 1.1. Für i, j = 1, ...k und i 6= j gilt dann 〈xi, yj〉 = 0.

Beweis. Übung. Skizze:

Angenommen i < j und 〈xi, yj〉 = ε > 0, dann liefert yi :=√

1− δ2yi + δyi

für ein gewisses 0 < δ < ε ≤ 1

∠ (xi, yi) < ∠ (xi, yi) .

Das ist aber ein Widerspruch zur Optimalität von xi, yi ⇒ ε = 0. �

Dies impliziert (mit X = [x1, ..., xk] , Y = [y1, ..., yk] ∈ Cn×k), dass

XHY = [〈xi, yi〉]ki,j=1 =

cos(θ1) 0

. . .

0 cos(θk)

= I ·

cos(θ1) 0

. . .

0 cos(θk)

· Imit cos(θ1) ≥ ... ≥ cos(θk) ≥ 0. Es handelt sich somit um eine SVD von von

XHY , denn die Einheitsmatrix ist auch unitär. Damit ergibt sich folgende

Methode zur Bestimmung kanonischer Winkel und Vektoren:

11

(a) Bestimme orthonormale Basen von U und V, d. h. isometrische Ma-

trizen P,Q ∈ Cn×k sodass U = range(P ) und V = range(Q).

(b) Ermittle eine SVD von PHQ : PHQ = U · Σ · V H .

Dann gilt: Σ = UHPHQV = XHY mit X := PU = [x1, ..., xk] und

Y := QV = [y1, ..., yk].8

(c) Dann sind θi = arccos(σi), i = 1, ...k die kanonischen Winkel und

xi und yi die kanonischen Vektoren.

Definition 1.9. Seien U ,V ⊆ Cn Unterräume der Dimension k.

(a) Für x ∈ U nennt man d(x,V) := miny∈V‖x− y‖ den Abstand von x zu

V.(b) Man nennt d(U ,V) := max

x∈U ,‖x‖=1d(x,V) den Abstand von U zu V.

Satz 1.8. Dann gilt d(U ,V) = sin(θk), wobei θk der k-te kanonische

Winkel zwischen U ,V.

8Man beachte, dass auch (x1, ..., xk) und (y1, ..., yk) orthonormale Basen von U und Vsind.

12

KAPITEL 2

Der Jacobi-Algorithmus

Sei A ∈ Cn×n hermitisch. Da A normal ist, existiert eine unitäre Matrix

U ∈ Cn×n, sodass UHAU =: D diagonal ist. Wie werden U,D bestimmt?

1. Der 2 x 2 Fall

Gegeben:

A = AH =

[a b

b d

]∈ C2×2, a, d ∈ R, b ∈ C

Gesucht:

c ∈ R, c > 0, s ∈ C, sd. U :=

[c s

−s c

]ist unitär ⇒ c2 + |s|2 = 1

und UHAU ist diagonal.

Sei B := UHAU = ... =

[∗ ∗

(a− d)sc− bs2 + bc2 ∗

].

Wenn b = 0, dann setze c = 1, s = 0. Andernfalls führe t := sc ein. Dann ist

B diagonal, wenn

bs2 − (a− d)cs− bc2 = 0

⇔ (bt2 − (a− d)t− b)c2 = 0

Damit

t1,2 =a− d

2b±

√(a− d

2b

)2

+b

b=a− d

2b± |b|

b

√∣∣∣∣a− d2b

∣∣∣∣2 + 1

= Ψ± 1

sign(b)

√|Ψ|2 + 1 mit Ψ :=

a− d2b

, sign(b) :=

b|b| für b 6= 0

1 für b = 0

Mit diesen t kann man s und c rekonstruieren:

1 = c2 + |s|2 = c2 + |tc|2 = c2(1 + |t|2)

⇒ c =1√

1 + |t|2, s = t · c

Welches t sollte benutzt werden?

13

Man will wenig Änderungen an A vornehmen ⇒ U sollte nah an der Ein-

heitsmatrix sein ⇒ c sollte groÿ und s klein sein ⇒ |t| sollte klein sein ⇒(unter Verwendung von sign(b) = ± sign(Ψ)) t = Ψ− sign(Ψ)

√|Ψ|2 + 1

Diese Formel ist allerdings instabil. Betrachtet man das andere t,

t = Ψ− sign(Ψ)

√|Ψ|2 + 1 = sign(Ψ)

(|Ψ|+

√|Ψ|2 + 1

),

so ist die Formel stabil. Man hat tt = bb1:

tt = − bb

= −Ψ

Ψ= −sign(Ψ)

sign(Ψ)= −sign(Ψ)2 ⇒ t =

−sign(Ψ)

|Ψ|+√|Ψ|2 + 1

.

Algorithmus 2.1 (Jacobi-Rotation).

Eingabe: a, d ∈ R, b ∈ C

Ausgabe: c ∈ R, c > 0, s ∈ C, sd. U =

[c s

−s c

]unitär und UHAU diagonal

ist.

if b = 0 then

t = 0

else

Psi = (a - d) / (2 * b)

t = sign(Psi) / (|Psi| + sqrt(|Psi|^2 + 1))

end

c = 1 / sqrt(|t|^2 + 1)

s = t * c

Kosten: 16 Flops.

2. Der Jacobi-Algorithmus

Für n > 4 existiert kein direkter Algorithmus. Eigenwerte sind die Null-

stellen des charakteristischen Polynoms und können nach dem Satz von Abel

nicht direkt bestimmt werden. Daher benutzt man iterative Algorithmen,

d. h. man konstruiert eine Sequenz

A0 = A,Am+1 = UHm+1AmUm+1 m ∈ N0

mit Um unitär für alle m, sd. Am (ho�entlich) gegen eine diagonale Matrix

konvergiert. Die Anhäufung der Transformationen, d. h.

U0 = I, Um+1 = UmUm+1,

1Diese sind die Nullstellen von t2 − a−db

t− bb.

14

liefert eine approximative Diagonalisierung von A:

UHmAUm = Am ≈ diagonal.

Der Jacobi-Algorithmus ist ein Spezialfall. Man wählt in einem Schritt

der Iteration 1 ≤ p < q ≤ n und bestimmt die Jacobi-Rotation U , sd.

B := UH ·

[app apq

aqp aqq

]· U ist diagonal,

d. h. apq sollte durch unitäre Operationen der Zeilen und Spalten p, q auf

Null gebracht werden. Danach bestimmt man B = UHAU mit

U =

Ip−1

c . . . s... Iq−p−1

...

−s . . . c

In−q

∈ Cn×n,

wobei c, s in Zeile p, −s, c in Zeile q, c,−s in Spalte p und s, c in Spalte q

liegen. Dann gilt bpq = 0, denn

[bpp bpq

bqp bqq

]= B.

Algorithmus 2.2 (Jacobi-Schritt).

Eingabe: A = AH ∈ Cn×n, 1 ≤ p < q ≤ nAktion: A wird wie oben mit B überschrieben

Ausgabe: c, s

[c,s] <---- jacobi_rotation(a_pp, a_qq, a_pq)

for i = 1,...,n

h <---- a_ip, a_ip <---- h*c - a_iq*s, a_iq <---- h*s_quer + a_iq*c

end

for j = 1,...,n

h <---- a_pj, a_pj <---- c*h - s_quer*a_qj, a_qj <---- s*h + c*a_qj

end

Kosten: 16 + 12n Flops

Funktioniet das oder werden nur Zahlen herumgeschoben?

Definition 2.1. Für A ∈ Cn×n nennt man

o� (A) :=

√√√√√ n∑p,q=1p 6=q

|apq|2

die o�-Norm von A.

15

Bemerkung 2.1. o� (A) ist keine Matrix-Norm von A, sondern die

Frobenius-Norm der Nichtdiagonalen von A. Damit ist eine Matrix A diago-

nal genau dann, wenn o� (A) = 0.

Satz 2.1. Sei A = AH ∈ Cn×n und 1 ≤ p < q ≤ n. Sei B das Ergebnis

eines Jacobi-Schritts. Dann gilt

o�(B)2 = o�(A)2 − 2 |apq|2 .

Beweis. Sei A =

[app apq

aqp aqq

], B = UHAU , U =

[c s

−s c

]. Dann gilt

‖A‖F = ‖B‖F und ‖A‖F = ‖B‖F und

‖A‖2F = o� (A)2 +∑|aii|2i=1...n = o� (A)2 +

n∑i=1i 6=p,q

|aii|2 + ‖A‖2F − 2 |apq|2

‖B‖2F = o� (B)2 +∑|bii|2i=1...n = o� (B)2 +

n∑i=1i 6=p,q

|bii|2 + ‖B‖2F − 2 |bpq|2 .

Mit ‖A‖2F = ‖B‖2F folgt die Aussage, denn aii = bii für i 6= p, q, bpq = 0 und

‖A‖F = ‖B‖F . �

Bestimmt man p, q sd. apq 6= 0, wird die o� -Norm reduziert. Um lineare

Konvergenz zu erhalten tri�t man die kanonische Wahl: p, q sd. |apq|maximal

ist.

Korollar 2.1. Sei A = AH ∈ Cn×n. Sei 1 ≤ p < q ≤ n sd.

|apq| ≥ |aij | ∀ i, j ∈ {1, ..., n}, i 6= j.

Sei B das Ergebnis eines Jacobi-Schritts. Dann gilt

o�(B)2 ≤(

1− 2

n(n− 1)

)o�(A)2

=

(1− 1

N

)o�(A)2 mit N =

n(n− 1)

2.

Beweis. Übung. �

Algorithmus 2.3 (Jacobi, klassisch).

Eingabe: A = AH ∈ Cn×n, eine Toleranz εAktion: A wird mit UHAU mit o�(UHAU) ≤ ε überschrieben.Ausgabe: U ∈ Cn×n unitär

(U = 0)

bestimme off(A)^2 und p < q sd. |a_pq| maximal ist

while off(A)^2 > epsilon^2

[A,c,s] <---- jacobi_step(A,p,q)

16

(update U)

bestimme off(A)^2 und p < q sd. |a_pq| maximal ist

end

Kosten pro Iteration: 16 + 12n (+6n) Flops für die Aktualisierung von A

(und U).2

Der Vorteil des klassischen Jacobi-Algorithmus ist die globale Konver-

genz, allerdings ist er durch die überproportionalen Kosten durch die Be-

stimmung von o� (A), p, q teuer. Man kann die Kosten senken, indem man

p, q anders wählt, z. B. zyklisch, dann wird o� (A) nicht in jeder Iteration

benötigt.

Algorithmus 2.4 (Jacobi, zyklisch3).

Eingabe: A = AH ∈ Cn×n, eine Toleranz ε, mmax maximale Anzahl von

Iterationen

Aktion: A wird überschrieben durch UHAU mit entweder o�(UHAU) ≤ ε

und flag = 0 oder flag = 1 (keine Konvergenz).

Ausgabe: (optional) U ∈ Cn×n, flag

(U = 0), K = 0

while off(A)^2 > epsilon^2 and k < m_max

for p = 1,...,(n-1)

for q = (p+1),...,n

[A,c,s] <---- jacobi_step(A,p,q)

(Update U)

k = k + 1

end

end

end

Kosten pro Sweep4: n(n−1)2 · (16 + 12n(+6n)) + n(n−1)

2 · 2 ≈ 6n3 + 3n2(+3n3)

Bei diesem Algorithmus steckt der meiste Aufwand in der Aktualisierung

von A (und U), d. h. kein Mehraufwand für p, q. Er besitzt keine globale

Konvergenz, jedoch funktioniert er in der Praxis fast immer und besitzt

lokale quadratische Konvergenz.5

Wie nah sind die Diagonalelemente an den Eigenwerten, wenn wir bei

o� (A) = ε > 0 stoppen?

2Das sind ungefähr n(n−1)2

4 ≈ 2n2 Flops für die Bestimmung von o� (A), p, q.3Zeilenzyklisch.4Die verschachtelte for-Schleife wird als Sweep bezeichnet.5Es existiert eine Variante, bei der Rotationen für Submatrizen statt Matrix-Elementendurchgeführt werden. Diese hat globale Konvergenz.

17

3. Eigenpaar-Fehlergrenzen

Satz 2.2 (Gerschgorin). Sei A ∈ Cn×n. Seien die Scheiben

Di ={z ∈ C| |z − aii| ≤

∑j 6=i |aij |

}und D = D1 ∪ ... ∪Dn. Dann ist jeder

Eigenwert von A in D enthalten.

Tatsächlich gilt sogar für jede Zusammenhangskomponente von D, dass

sie genau so viele Eigenwerte von A enthält wie die Anzahl ihrer Scheiben.

Beweis. Übung. �

Lemma 2.1. Sei λmax der maximale und λmin der minimale Eigenvektor

von A. Dann gilt

λmin = minx∈Cn

x 6=0

xHAx

‖x‖22, λmax = max

x∈Cn

x 6=0

xHAx

‖x‖22.

Satz 2.3. Seien A = AH , B = BH ∈ Cn×n und ‖.‖c eine beliebige

Matrixnorm, welche mit der Vektor-2-Norm kompatibel ist, d. h. ‖Ax‖2 ≤‖A‖c ‖x‖2 (z. B. Matrix-2-Norm, Frobenius-Norm). Dann existiert für jeden

Eigenwert µ von B ein Eigenwert λ von A, sd. |λ− µ| ≤ ‖A−B‖c.

Beweis. Sei µ ∈ Λ(B) und y ein dazugehöriger Eigenvektor mit ‖y‖2 =

1. Dann ist (B − µI)y = 0. Wähle λ ∈ Λ(A), welches am nächsten an µ

ist. Damit ist λ− µ der betraglich kleinste Eigenwert von A− µI. Da A,Bhermitisch sind, sind λ, µ reell. Daher ist (λ−µ)2 der kleinste Eigenwert von

(A− µI)2. Dann gilt

(λ− µ)2 = minx∈Cn

x 6=0

xH(A− µI)2x

‖x‖22≤ yH(A−B +B − µI)2y

= yH(A−B)2y + yH(A−B)(B − µI)y + yH(B − µI)(A−B)y

+ yH(B − µI)2y

= yH(A−B)2y = ‖(A−B)y‖22≤ ‖A−B‖2c ‖y‖

22 = ‖A−B‖2c

�

Als nächstes wird eine Grenze für den Fehler bei der Eigenvektorbestim-

mung gesucht.

Beispiel 2.1. Betrachte folgende Matrizen:

Aε :=

[1 + 2ε 0

0 1

], Bε :=

[1 ε

ε 1

]= UH

[1 + ε 0

0 1− ε

]U mit U =

1√2

[1 1

1 −1

](unitär). Dann gilt, obwohl ‖Aε −Bε‖2 = (1 +

√2)ε beliebig

18

klein wird, dass der Winkel zwischen jedem beliebigen Eigenvektor von Aεund jedem beliebigen Eigenvektor von Bε 45◦ = π

4 beträgt.

Grund: A0 = B0 = I ⇒ Jeder Vektor v 6= 0 ist ein Eigenvektor.

Es gilt, dass Eigenvektoren von Aε Approximationen von gewissen Eigen-

vektoren von A0 sind. Das gleiche gilt für Bε. Um diesen Fall zu vermeiden,

wird folgende De�nition eingeführt:

Definition 2.2. Für A = AH ∈ Cn×n und λ ∈ Λ(A) nennt man

γA(λ) = min {|µ− λ| : µ ∈ Λ(A) \ {λ}}

den Spektralabstand (engl. gap) von A und λ.

Satz 2.4. Sei A = AH , B = BH ∈ Cn×n und ‖.‖c eine beliebige Ma-

trixnorm, welche mit der Vektor-2-Norm kompatibel ist. Dann existiert für

jedes Eigenpaar (λ, y) von B ein Eigenwert λ von A mit zugehörigem Eigen-

vektor x, sd.

‖x− y‖ ≤ 2‖A−B‖cγA(λ)

‖y‖ .

Beweis. Sei µ ∈ Λ(B) und y ∈ Cn \ {0} ein zugehöriger EIgenvektor.

Durch Satz 2.3 hat man einen Eigenwert λ von A mit |λ− µ| ≤ ‖A−B‖c.Sei A = UDUH eine Diagonalisierung von A, y := UHy und x ∈ Cn sei

de�niert durch

xi :=

yi, falls dii = λ

0, sonst∀ i = 1, ..., n.

Für x := Ux gilt:

Ax = UDUHx = UDx = λUx = λx.

Somit ist x ein Eigenvektor von A zum Eigenwert λ. Damit

‖(A− λI) (x− y)‖ = ‖(A− λI) y‖

= ‖(A−B +B − µI + µI − λI) y‖

= ‖(B − µI) y + (A−B) y + (µ− λ) y‖

≤ ‖(A−B) y‖+ |µ− λ| ‖y‖

≤ 2 ‖A−B‖c ‖y‖

19

Als nächstes wird A− λI aus der Ungleichung eliminiert:

‖(A− Iλ) (x− y)‖2 =∥∥U (D − Iλ)UH (x− y)

∥∥2

= ‖(D − Iλ) (x− y)‖2

=n∑i=1

|dii − λ|2 |xi − yi|2

≥ γA(λ)2n∑i=1

|xi − yi|2

= γA(λ)2 ‖x− y‖2

= γA(λ)2 ‖x− y‖2

Fügt man nun die Ungleichungen zusammen, so folgt die Behauptung. �

Korollar 2.2. Sei A = AH ∈ Cn×n. Dann existiert für jedes i ∈{1, ..., n} ein Eigenwert λ von A, sodass

|λ− aii| ≤ ρi ≤ o�(A)

und ein zugehöriger Eigenvektor x ∈ Cn, sodass

‖x− ei‖ ≤ 2ρi

γA(λ)≤ o�(A)

γA(λ)mit ρi :=

2n∑j=1j 6=i

|aij |2

12

.

Beweis. Folgt direkt aus den beiden vorherigen Sätzen mitB =

a11 0

. . .

0 ann

und ‖.‖c = ‖.‖F . Dann ist ‖A−B‖c = o�(A) und (aii, ei) ist ein Eigenpaar

von B. �

Man kann γA(λ) durch folgende einfach zu berechnende Gröÿe ersetzen:

γi := min

|λ− µ| : λ ∈ [aii − ρi, aii + ρi] , µ ∈⋃j 6=i

[aij − ρj , aji + ρj ]

≤ γA(λ).

4. Quadratische Konvergenz

Damit der Jacobi-Algorithmus konvergiert, dürfen die einzelnen Trans-

formationen A nicht zu stark verändern. Daher muss |s| aus der Jacobi-

Rotation klein sein. In dem Schritt zur Elimination von apq (1 ≤ p < q ≤ n)

gilt

|s| ≤ |t| |c| ≤ |t| ≤ 1

|ψ|+√|ψ|2 + 1

≤ 1

2 |ψ|=

|apq||app − aqq|

.(4.1)

20

Dies ist allerdings nur nützlich, wenn |app − aqq| nicht klein ist. Da {aii}gegen die Eigenwerte konvergiert, müssen diese verschieden sein. Von jetzt

an wird daher angenommen, dass die Eigenwerte verschieden sind und setzen

∆ := min {|λ− µ| : λ, µ ∈ Λ(A), λ 6= µ} .

Lemma 2.2. Sei 2o�(A) < ∆, das heiÿt δ := ∆− 2o�(A) > 0. Dann gilt

|app − aqq| ≥ δ ∀ p, q ∈ {1, ..., n} , p 6= q.

Beweis. Da ∆ > 2o�(A) schneiden sich die Intervalle

[λi − o�(A), λi + o�(A)] nicht. Durch die verschiedenen Eigenwerte enthält

jedes Intervall mindestens ein Diagonalelement aii. Daraus folgt, dass jedes

Intervall genau ein Diagonalelement aii enthält. Die Behauptung folgt nun,

da jedes Intervall mindestens den Abstand δ zu seinen Nachbarintervallen

hat. �

Als nächstes wird iteriert:

Die Startmatrix wird mit A(0) bezeichnet. Betrachtet man den r-ten Schritt

so ist dies der Übergang von A(r−1) zu A(r). Wählt man 1 ≤ pr < qr ≤ n

und eliminiert a(r−1)pr,qr durch Jacobi-Rotation mit sr und cr, so kann man |sr|

durch das folgende Lemma abschätzen:

Lemma 2.3 (Jacobi-Winkel). Sei δ := ∆ − 2o�(A(0)

)> 0 und N ∈ N.

Dann gilt

N∑r=1

|sr|2 ≤o�(A(0)

)22δ2

.

Beweis. Es gilt

0 ≤ o�(A(N)

)2≤ o�

(A(N−1)

)2− 2|a(N−1)

pN ,qN|2

Induktion= o�

(A(0)

)2− 2

N∑r=1

|apr,qr |2

Damit gilt

N∑r=1

|sr|2(4.1)

≤N∑r=1

|a(r−1)pr,qr |2

|a(r−1)pr,pr − a

(r−1)qr,qr |2

≤ 1

δ2

N∑r=1

|a(r−1)pr,qr |

2 ≤o�(A(0)

)22δ2

�

Es folgt eine Analyse des Elements a(r)ij für �xe i, j und r. Wenn i = pr

und j = qr, verringert sich |a(r)ij | in der r-ten Iteration (zu Null). Es gibt 4

21

Fälle, in denen es zunehmen könnte:

a) i = pr, j 6= qr ⇒ |a(r)ij | = |cra(r−1)

ij − sra(r−1)qr,j

| ≤ |a(r−1)ij |+ |sr||a(r−1)

qr,j|

b) i = qr, j 6= pr ⇒ |a(r)ij | = |sra(r−1)

pr,j− cra(r−1)

ij | ≤ |a(r−1)ij |+ |sr||a(r−1)

pr,j|

c) i 6= qr, j = pr ⇒ |a(r)ij | = |cra(r−1)

ij − sra(r−1)i,qr

| ≤ |a(r−1)ij |+ |sr||a(r−1)

i,qr|

d) i 6= pr, j = qr ⇒ |a(r)ij | = |sra(r−1)

i,pr− cra(r−1)

ij | ≤ |a(r−1)ij |+ |sr||a(r−1)

i,pr|

Man beachte, dass i = qr, j = pr nicht möglich ist, da i < j und p < q. Sind

i, j /∈ {pr, qr} ändert sich a(r−1)ij nicht. Fügt man alles zusammen, erhält

man:

|a(r)ij | ≤ |a

(r−1)ij |+ |sr||e(r)

ij | wobei e(r)ij wie folgt de�niert ist

e(r)ij :=

a

(r−1)qr,j

, falls i = pr, j 6= qr

a(r−1)pr,j

, falls i = qr, j 6= pr

a(r−1)i,qr

, falls i 6= qr, j = pr

a(r−1)i,pr

, falls i 6= pr, j = qr

Nun kann man die quadratische Konvergenz des Jacobi-Algorithmus be-

weisen:

Satz 2.5. Sei A(0) = A(0)H ∈ Cn×n sodass δ := ∆ − 2o�(A(0)

)> 0.

Sei auÿerdem A(N) das Ergebnis nach N Iterationen des Jacobi-Algorithmus,

sodass für jedes 1 ≤ p < q ≤ n ein r ∈ {1, ..., N} existiert, sodass p = pr, q =

qr, d. h. jedes Nichtdiagonalelement wird wenigstens einmal eliminiert. Dann

gilt

o�(A(N)

)≤√

N

2δ2· o�

(A(0)

)2.

Beweis. Sei 1 ≤ p < q ≤ n. Per Annahme existiert ein rpq mit p = prpq

und q = qrpq . Da somit a(rpq)pq = 0 gilt

|a(N)pq |2 ≤

0 +N∑

r=rpq+1

|sr||e(r)pq |

2

≤

(N∑r=1

|sr||e(r)pq |

)2

Cauchy-

≤Schwarz

(N∑r=1

|sr|2)(

N∑r=1

|e(r)pq |2

).

22

Letzteres ist unabhängig von rpq, damit gilt es für alle p < q. Sei E die

Matrix mit den Elementen eij . Die Summe über alle p < q (p 6= q) liefert

o�(A(0)

)2≤

(N∑r=1

|sr|2)

︸ ︷︷ ︸≤o�(A(0))

2

2δ

N∑r=1

o�(E(r)

)2

︸ ︷︷ ︸≤o�(A(r−1))

2≤o�(A(0))2

≤ N

2δo�(A(0)

)4.

Wurzelziehen liefert die Behauptung. �

Bemerkung 2.2.

• Es ist keine bestimmte Reihenfolge beim Eliminieren der Elemen-

te erforderlich. Jede funktioniert, solange jedes Element wenigs-

tens einmal eliminiert wurde. D. h. die Zyklus-Strategie funktio-

niert. Man hat dann N = n(n−1)2 und das ist das kleinstmögliche

N .

• Die Grenze ist sehr konservativ. Insbesondere die Ungleichung o�(E(r)

)≤

o�(A(0)

)ist sehr pessimistisch. Mit einem verfeinerten Beweis lässt

sich die Konstante√

N2δ2 auf

√1

2δ2 verbessern. Diese ist dann un-

abhängig von N .

• Eine ähnliche Grenze lässt sich für den klassischen Jacobi-Algorithmus

�nden.

• Die Annahme von verschiedenen Eigenwerten kann umgangen wer-

den, indem man die Diagonalelemente zusammenfasst, die gegen

den gleichen Eigenwert konvergieren. Dies erreicht man durch Sor-

tierung der Diagonalelemente mit einer symmetrischen Permutation

(A→ PAP T ) nach je N Iterationen.

• In endlicher Genauigkeit macht es keinen Sinn endlos zu iterie-

ren. Die erreichbare Genauigkeit für Algorithmen, die mit unitären

Transformationen arbeiten, ist |λ−aii||λmax| = O(εmach).

• Der Jacobi-Algorithmus ist besser. Er erreicht |λj−aii||λj | = O(εmach).

• Es existieren Varianten des Jacobi-Algorithmus für die SVD und

die Schurform.

23

KAPITEL 3

Groÿe Eigenwert-Probleme

Gegeben: A ∈ Cn×n mit n sehr groÿ1.

Das bedeutet man kann die Matrix nicht mehr auf dem herkömmlichen Weg

speichern, Matrixtransformationen sind nicht möglich und daher auch die

Jacobi-Algorithmen.

Gesucht: Einige Eigenpaare (xi, λi) mit Axi = λixi oder eine partielle

Schurform: V ∈ Cn×m, V HV = Im, S ∈ Cm×m obere Dreiecksmatrix mit

AV = V S.

Die einzige Interaktion mit A sind Matrix-Vektor-Produkte.

Beispiel 3.1.

• dünnbesetzte Matrix (Anzahl der Nichtnull-Einträge << n2)

↪→ man speichert nur die Nichtnull-Einträge und deren Positionen

• Diagonalmatrix −→ man speichert die Diagonalelemente als Vektor

• Matrix mit niedrigem Rang −→ man speichert die dünne SVD von

A

• Toeplitz-Matrix A =

a1 a2 · · · an

b1. . . . . .

......

. . . . . . a2

bn−1 · · · b1 a1

−→ man speichert nur

die erste Zeile und erste Spalte

• Summen der oben genannten Matrizen

1. Die Potenzmethode

Idee: Wähle q ∈ Cn \ {0}. Bestimme Aq,A2q, ...Akq iterativ.

Annahme: A ist diagonalisierbar. Seien λ1, ..., λn mit |λ1| ≥ |λ2| ≥ ... ≥ |λn|die Eigenwerte von A und v1, ..., vn eine zugehörige Basis aus Eigenvektoren.

=⇒ Es existieren c1, ..., cn mit q = c1v1 + ...+ cnvn.

1Dies ist von der vorhandenen Technologie abhängig. 1950 war bspw. 100 sehr groÿ, heut-zutage liegt es zwischen 105 und 106.

25

Annahme: c1 6= 0 (das Gegenteil ist unwahrscheinlich), dann

Aq = c1λ1v1 + ...+ cnλnvn

Akq = c1λk1v1 + ...+ cnλ

knvn

Für |λ1| > 1 wächst |λk1|, daher skaliert man mit 1λk1.

Annahme: |λ1| > |λ2|

=⇒∥∥∥∥ 1

λk1Akq − c1v1

∥∥∥∥ =

∥∥∥∥∥c1v1 +

(λ2

λ1

)kc2v2 + ...+

(λnλ1

)kcnvn − c1v1

∥∥∥∥∥≤ (|c2|‖v2‖+ ...+ |cn|‖vn‖)

∣∣∣∣λ2

λ1

∣∣∣∣k k→∞−→ 0

In der Praxis ist λ1 unbekannt, daher skaliert man, sodass das Element mit

maximalem Betrag 1 ist.

Algorithmus 3.1.

Eingabe: A ∈ Cn×n, q ∈ Cn, q 6= 0

for k = 1,2,... until convergence

q_k = (1/alpha_k) * A * q_(k-1)

end

Dabei ist αk das Element von Aqk−1 mit maximalem Betrag.

Damit ist folgender Satz bewiesen:

Satz 3.1. Sei A ∈ Cn×n mit den Eigenwerten λ1, ..., λn, sd. |λ1| > |λ2| ≥|λ3| ≥ ... ≥ |λn|. Angenommen q0 ∈ Cn liegt nicht im invarianten Unterraum

von λ2, ..., λn (�c1 6= 0�). Dann existiert ein Eigenvektor v1 zum Eigenwert

λ1, sd. für jedes ρ >∣∣∣λ2λ1

∣∣∣ eine Konstante c exstiert, sd.‖qk − v1‖ ≤ c · ρk.

Auÿerdem konvergiert αk gegen λ1.

Bemerkung 3.1.

• Funktioniert auch für nicht diagonalisierbare A. Dann ist die Be-

dingung ρ >∣∣∣λ2λ1

∣∣∣ notwendig.• Die Bedingung c1 6= 0 ist in der Praxis nicht wichtig, da durch

Rundungsfehler eine Komponente in v1-Richtung entsteht.

• In den meisten Anwendungen ist∣∣∣λ2λ1

∣∣∣ ≈ 1, dadurch erhält man nur

eine langsame Konvergenz.

• Einfachste Methode, welche in den 1950ern benutzt wurde.

• Fand Anwendung in der ersten Version von Googles Sortieralgorith-

mus.

26

2. Unterraum-Iteration

Idee: Potenzmethode für mehrere Vektoren zugleich.

Sei W0 := [w1, ..., wm] ∈ Cn×m, bestimme Wk := AkW0 = [Akw0, ..., Akwm].

Satz 3.2. Sei A ∈ Cn×n mit den Eigenwerten λ1, ..., λn, sodass

|λ1| ≥ |λ2| ≥ ... ≥ |λm| > |λm+1| ≥ ... ≥ |λn|.

Seien U ,V die zu λ1, ..., λm und λm+1, ..., λn zugehörigen invarianten Unter-

räume von A.

Sei W ∈ Cn×m mit rank(W ) = m und range(W ) ∩ V = {0} (�c1 6= 0�).

Dann gilt für jedes ρ >∣∣∣λm+1

λm

∣∣∣, es existiert ein c > 0, sd.

d(range(AkW ),U

)≤ c · ρk ∀ k ≥ 1.

Beweis. (nur der Spezialfall, wenn A diagonalisierbar ist)

Basiswechsel:

A = S−1AS =

[A1 0

0 A2

], A1 =

λ1

. . .

λm

, A2 =

λm+1

. . .

λn

A1 und A2 sind invertierbar, da für i, j ∈ {1, ...,m} und i, j ∈ {m+ 1, ..., n}mit i > j gilt |λi| ≥ |λj | > 0.

U = S−1U = range

([Im

0

]),

V = S−1V = range

([0

In−m

])

W0 := W := S−1W :=

[Z1

Z2

]mit Z1 ∈ Cm×m, Z2 ∈ C(n−m)×m

Wk := AkW0 = S−1Wk

Es gilt

range(W ) ∩ V = {0} ⇐⇒ range(W ) ∩ V = {0}

⇐⇒ Z1 ist invertierbar (Übung)

Damit und mit X0 := Z2Z−11 gilt W =

[I

X0

]Z1 also

range(W ) = range(AkW0

)= range

(Ak

[I

X0

])27

Betrachtet man nun

Ak

[I

X0

]=

[Ak1

Ak2

][I

X0

]=

[Ak1Ak2X0

]=

Im

Ak2X0A−k1︸ ︷︷ ︸

=:Xk

Ak1

=⇒ range(Wk

)= range

([I

Xk

])Es bleibt zu zeigen, dass d(range(Wk),U) −→ 0. Dies folgt aus

d(range(Wk),U) ≤ κ(S)d(range(Wk, U) (Übung)

und (mit θ(k)max := der maximale kanonische Winkel zwischen range(Wk) und

U)

d(range(Wk), U) = sin(θ(k)

max

)≤ tan

(θ(k)

max

)= ‖Xk‖2 (Übung)

≤∥∥∥Ak2∥∥∥

2· ‖X0‖2 ·

∥∥∥A−k1

∥∥∥2

= |λm+1|k ‖X0‖2 |λm|−k =

∣∣∣∣λm+1

λm

∣∣∣∣k ‖X0‖2

Die Bedingung ρ >∣∣∣λm+1

λm

∣∣∣ ist nur im nichtdiagonalisierbaren Fall notwendig.

�

Sei 1 ≤ j ≤ m und W0 = [w1, ..., wm]. Die ersten j Spalten von Wk =

Ak[w1, ..., wm] sind Ak[w1, ..., wj ]. Daher konvergiert range([Akw1, ..., Akwj ])

zu dem zu λ1, ..., λj zugehörigen invarianten Unterraum von A. Deshalb wird

diese Methode auch �simultaneous subspace iteration� genannt.

In der Theorie impliziert rank(W0) = m, dass rank(Wk) = m, sofern A

invertierbar ist. In der Praxis konvergiert jedoch jede Spalte von Wk gegen

den dominanten Eigenvektor. Wk ist also nahe einer Rang-1-Matrix.

Lösung: dünne QR-Zerlegung Wk = QkRk.

Bestimme Qk ohne Wk:

QkRk = Wk = AWk−1 = AQk−1Rk−1

range(Wk) = range(Qk) = range(AQk−1)

Dieser Ansatz liefert folgenden Algorithmus zur Bestimmung der Qk ohne

Wk zu benutzen:

Algorithmus 3.2 (Unterraum Iteration).

Eingabe: A ∈ Cm×n, Q0 ∈ Cm×n, QH0 Q0 = In

for k = 1,2,... bis zur Konvergenz

bestimme Z_k = A * Q_(k-1)

duenne QR-Zerlegung Z_k = Q_k * R_k

28

end

Bemerkung 3.2.

• Wurde in den 1970ern benutzt.

• Bei Konvergenz, d. h. Qk −→ Q∗, Rk −→ R∗, erhält man AQ∗ =

Q∗R∗, d. h. eine partielle Schurform.

3. Projektionsmethoden

Gegeben: Ein m-dimensionaler Unterraum V ⊂ Cn (der Suchraum). Wie

�ndet man gute Approximationen der Eigenvektoren von A in V (der hof-

fentlich gute Approximationen enthält)?

Petrov-Galerkin-Ansatz : Man wählt einen zweiten m-dimensionalen Un-

terraum W (den Testraum) und benutzt Paare (µ, x) ∈ C × V, sd. derenResiduum r = Ax − µx orthogonal zu W ist. Im Folgenden wird nur der

Spezialfall W = V betrachtet, dieser heiÿt Ritz-Galerkin-Ansatz :

Definition 3.1. Ein Paar (µ, x) ∈ C × V heiÿt Ritzpaar (von A im

Bezug zu V), wenn Ax−µx⊥V. In diesem Fall ist µ ein Ritzwert und x ein

Ritzvektor (von A im Bezug zu V).

Wie kann man die Ritzpaare bestimmen?

Lemma 3.1. Sei A ∈ Cn×n und V ⊂ Cn einm-dimensionaler Unterraum.

Seien die Spalten von V ∈ Cn×n eine orthonormale Basis von V. Sei (µ, x) =

(µ, V y) ∈ C× V. Dann

(µ, x) ist ein Ritzpaar von A im Bezug zu V

⇐⇒ (µ, y) ist ein Eigenpaar von V HAV.

Beweis.

Ax− µx⊥V ⇔ V H(Ax− µx) = 0

⇔ V H(AV y − µV y) = 0

⇔ V HAV y = µV HV y = µy

�

Man beachte, dass Ritzpaare allgemein nicht die Norm des Residuums

minimieren. Es gibt allerdings folgende schwächere Optimalitätseigenschaft:

Definition 3.2. Für x ∈ C, x 6= 0 nennt man xHAxxHx

den Rayleigh-

Quotienten von A und x.

Lemma 3.2. Sei A ∈ Cn×n, x ∈ Cn, x 6= 0. Dann

minθ∈C‖Ax− θx‖2 =

∥∥∥∥Ax− xHAx

xHxx

∥∥∥∥2

.

29

Wenn zusätzlich x ein Ritzvektor von A im Bezug zu einem Suchraum V mit

zugehörigem Ritzwert µ ∈ C ist, so ist µ = xHAxxHx

.

Beweis. Übung. �

Was ist ein guter Suchraum? Idee: Die Potenziterierten x,Ax,A2x, ...

konvergieren zum dominanten Eigenvektor, vielleicht ist der von ihnen auf-

gespannte Raum gut.

4. Krylov Unterräume und die Arnoldi-Methode

Definition 3.3. Sei A ∈ Cn×n, X ∈ Cn×k und m ∈ N.

a) Man nennt Km(A,X) := [X,AX, ..., Am−1X] Block-Krylov-Matrix

(von A und X).

b) Man nenntKm(A,X) := range(Km(A,X)) Block-Krylov-Unterraum

(von A und X der Gröÿe m).

c) Wenn k = 1, nennt manKm(A,X) eineKrylov-Matrix undKm(A,X)

einen Krylov-Unterraum (ohne �Block�).

Man beachte, dass für x ∈ Cn o�ensichtlich

Km(A, x) = {p(A)x|p ∈ C≤m−1[x]} .

Dabei ist C≤m−1[x] der Raum der Polynome von Grad höchstens m− 1.

Satz 3.3. Sei A ∈ Cn×n, x ∈ Cn,m ∈ N, q ∈ C[x], d := max(0, deg(q)).

Dann gilt

Km(q(A), [x,Ax,A2x, ..., Ak−1x]

)= K(m−1)d+k(A, x).

Insbesondere gilt: Km(A− σI, x) = Km(A, x).

30

Beweis. Für q ≡ 0 gilt die Aussage o�ensichtlich. Daher betrachte q 6≡0. Für d = 0 ist die Aussage erfüllt. Betrachte also d > 0 =⇒ d = deg(q).

� ⊂ � : Sei y ∈ Km(q(A), [x,Ax, ..., Ak−1x]

)Sei K := [x,Ax, ..., Ak−1x]

=⇒ ∃ z0, ..., zm−1 ∈ Ck, sd.

y = Kz0 + q(A)Kz1 + ...+ qm−1(A)Kzm−1

=⇒ ∃ r0, ..., rm−1 ∈ Ck−1[x] mit Kzi = ri(A)x.

=⇒ y = r0(A)x+ q(A)r1(A)x+ ...+ qm−1(A)rm−1(A)x = p(A)x,

wobei p(A) :=m−1∑i=0

qi(A)ri(A).

deg(p) ≤ maxi=0,...,m−1

d · i+ deg(ri) ≤ d(m− 1) + k − 1

=⇒ y ∈ Kd(m−1)+k(A, x)

� ⊃ � : Übung.

�

Für genügend groÿe m folgt:

• Km(A, x) enthält die Iterierten der Unterraum-Iteration angewandt

auf die Matrix q(A).

• Km(A, x) enthält eine gute Approximation eines Eigenvektors von

A mit zugehörigem Eigenwert λ ∈ Λ(A). Wenn es ein Polynom q

(mit niederigem Grad) gibt, sd. |q(λ∗)| einer der gröÿten Werte in

der Menge S := {|q(λ)| : λ ∈ Λ(A)} und in S eine Lücke zwischen

den gröÿten und den restlichen Werten ist.

Betrachte den Krylov-UnterraumKm(A, x) = span(x,Ax,A2x, ..., Am−1x)

und suche in ihm nach einer Approximation der Eigenvektoren.

Lemma 3.3. Sei A ∈ Cn×n, x ∈ Cn, x 6= 0. Dann

a) dimKm(A, x) = min(m, d) ≤ n,b) Km(A, x) = Kd(A, x) ∀m ≥ d,c) Kd(A, x) ist A-invariant.

Dabei ist d der Grad des minimal Polynoms pA,x(λ), d. h. das eindeutige

normierte2 Polynom mit niedrigstem Grad, sd.

pA,x(A)x = 0.

Beweis. Übung. �

2Normiert bedeutet in diesem Zusammenhang, dass der Koe�zient des Gliedes mit derhöchsten Potenz 1 ist.

31

Ziel: Ritz-Galerkin-Projektion mit Km(A, x) als Suchraum

↪→ Man braucht eine orthonormale Basis von Km(A, x), auch aus

numerischen Gründen:

Die Spalten von Km(A, x) werden immer paralleler für wach-

sende m.

=⇒ Benutze eine dünne QR-Zerlegung Km = QmRm

Da Km+1 = [Km, Amx] kann man Qm+1 so wählen, dass

Qm+1 = [Qm, qm+1] = [q1, ..., qm+1].

Auf ähnliche Weise kann man auch Rm+1 wählen:

Rm+1 =

[Rm ∗0 ∗

]Wie kann man Qm bestimmen ohne vorher Km zu berechnen?

Qm+1Rm+1 = Km+1 = [x,AKm] = [x,AQmRm]

Multipliziert man nun beide Seiten mit

[0 · · · 0

Im

]·R−1

m erhält man:

AQm = Qm+1Hm = QmHm + qm+1hm+1,meTm,(4.1)

wobei Hm ∈ Cm+1×m,Hm := Rm+1 ·

[0 · · · 0

Im

]·R−1

m =

[Hm

0 hm+1,m

]Hm ist dann eine obere Dreiecksmatrix mit einer unteren Nebendiagonale

und wird als obere Hessenberg-Matrix bezeichnet. Sie hat die gleiche Ver-

schachtelungseigenschaft wie Rm:

Hm+1 =

∗

Hm...

∗0 . . . 0 ∗

Definition 3.4. Die Gleichung 4.1 heiÿt Arnoldirelation (von Grad m).

Die letze Spalte der Arnoldirelation ist

Aqm = q1h1,m + q2h2,m + ...+ qmhm,m + qm+1hm+1,m.

Multiplikation mit qHi von links liefert

hi,m = qHi Aqm, i = 1, ...,m, hm+1,m sd. ‖qm+1‖ = 1

und führt zu folgendem Algorithmus:

32

Algorithmus 3.3 (Arnoldi,1951).

Eingabe: A ∈ Cn×n, x ∈ Cn, x 6= 0

Ausgabe: Qm,Hm sd. 4.1 erfüllt ist

q_1 = x / norm(x), Q_1 = q_1

for m 1,2,...

w = A * q_m

h = Q^H_m * w

w_tilde = w - Q_m * h

h_tilde = Q^H_m * w_tilde

w_tildetilde = w_tilde - Q_m * h_tilde

alpha = norm(w_tildetilde)

q_(m+1) = w_tildetilde / alpha

Q_(m+1) = [Q_m, q_(m+1)]

[ H_underbar_(m-1) | h + h_tilde ]

H_underbar_m = [ 0 ... 0 | alpha ]

end

Bemerkung 3.3.

• Diem-te Iteration kostet eine Matrix-Vektor-Multiplikation und ca.

8mn Flops.

• Die Reorthogonalisierung (h, ˜w) ist in der exakten Arithmetik nicht

notwendig, in der nicht exakten Arithmetik hingegen unabdingbar,

da sonst q1, ..qm ihre Orthogonalität verlieren.

• Die Methode bricht in der d-ten Iteration ab, wenn α = hd+1,d =

0. In diesem Fall liefert die Arnoldirelation AQd = QdHd. Damit

ist range(Qd) A-invariant. Diese Situation nennt man einen Lucky

Breakdown.

• Wenn mehr als d Eigenpaare gesucht werden, kann die Metho-

de mit einem beliebigen Vektor qd+1 fortgeführt werden, sofern

qd+1⊥ q1, ..., qd und ‖qd+1‖ = 1. Ein solcher Vektor existiert im-

mer für d < n.

• Hat man m = n, so gilt hn+1,n = 0, da q1, ..., qn eine Basis von Cn

bilden.

=⇒ Qn ist unitär und QHn AQn = Hn ist in oberer Hessenberg-

form. Arnoldi hat diese Methode für diesen Zweck entwickelt,

die Verbindung zu Krylov-Unterräumen wurde erst später ent-

deckt.

• Für Ritz-Galerkin-Projektionen braucht man zudem noch QHmAQm.

Es gilt QHm(AQm) = QHm(QmHm + qm+1hm+1,meTm) = Hm.

33

� Sei (µ, y) ein Eigenpaar von Hm, dann ist (µ, x) mit x = Qmy

ein Ritzpaar von A. Für das Residuum gilt:

r = Ax− µx = (AQm)y − µQmy= (QmHm + qm+1hm+1,me

Tm)y − µQmy

= Qm(Hmy − µy) + qm+1hm+1,meTmy

Also ist ‖r‖ = |hm+1,m| · |eTmy|.Also muss r (oder sogar x) nicht bestimmt werden um das

Residuum zu �nden.

• Die Arnoldi-Methode ist die Methode der Wahl und ist in FORT-

RAN 77 als ARPACK implementiert und in Matlab über den Befehl

eigs für dünnbesetzte Matrizen.

Die Arnoldirelation liefert nach m Schritten des Arnoldi-Algorithmus:

AQm = QmHm + qm+1hm+1,meTm

Man will nun p Eigenpaare bestimmen. Wie soll man fortfahren, wenn m+1

die Anzahl der Vektoren ist, welche man im Speicher speichern kann, Qmaber noch immer nicht p Ritzpaare mit genügend kleinen Residuen enthält?

Idee: Wähle einen neuen Startvektor q(neu)1 (z. B. eine Kombination der bes-

ten bisher bekannten Ritzvektoren) und starte die Arnoldi-Methode erneut.

Dies nennt man einen expliziten Neustart.

- pro: Funktioniert (unter schwachen Bedingungen).

- contra: Benötigt m Matrix-Vektor-Multiplikationen um eine neue Arnoldi-

relation der Gröÿe m zu bestimmen.

Kann man das verbessern? −→ impliziter Neustart (IRAM)

• Entwickelt von Sorensen/Lehough 1992.

• q(neu)1 = q(A)q1, q(A) ist ein Polynom um die ungewollten Kompo-

nenten von q1 �abzuschwächen�.

• Standard Wahl: Die Wurzeln von q sind die ungewollten m − p

Eigenwerte von Hm (Ritzwerte von A).

• Die alte Arnoldirelation 4.1 kann für q(neu)1 in eine Relation der Grö-

ÿenordnungm− deg(q) ohne jegliche Matrix-Vektor-Multiplikationen

umgeformt werden. Diese kann zu m erweitert werden indem man

deg(q) Iterationen der Arnoldi-Methode durchführt.

• Die Transformation benutzt Iterationen des QR-Algorithmus.

• Implementationen �nden sich in ARPACK (Fortran) und eigs (Mat-

lab).

Später wurde auch eine zweite Neustart-Methode eingeführt:

• Sie heiÿt Krylov-Schur-Algorithmus und wurde von Stewart (2002)

entwickelt.

34

• Sie ist äquivalent zur IRAM mit Standardwahl q(A), allerdings wird

q(A) nicht benutzt.

• Die Idee ist die Arnoldirelation 4.1 auf die Gröÿenordnung p zu

reduzieren und den von p Ritzvektoren aufgespannten Unterraum

zu behalten.

Sei U1 ∈ Cm×m unitär, sd.

UH1 HmU1 = S =

[S11 S12

0 S22

](4.2)

eine Schurform ist und S11 ∈ Cp×p.−→ Ritzwerte von A sind Eigenwerte von S = Λ(S11) ∪ Λ(S22).

Annahme: S ist derart, dass Λ(S11) die �gesuchten� Ritzpaare enthält. (Sor-

tierung → Übung)

Sei bT := [0, ..., 0, hm+1,m], bTU1 =: [bT1 , bT2 ], b1 ∈ Cp.

Sei Qm := QmU1 =: [Qp, Q], Qp ∈ Cn×p. Qp spannt den Unterraum, der von

den gesuchten Ritzvektoren aufgespannt wird, auf. Dann liefert die Multipli-

kation der Arnoldirelation 4.1 von rechts mit U1:

AQmU1 = QmU1UH1 HmU1 + qm+1[0, ..., 0, hm+1,m]U1

A[Qp, Q] = [Qp, Q]

[S11 S12

0 S22

]+ qm+1[bT1 , b

T2 ]

Multiplikation von rechts mit

[Ip

0

]liefert:

AQp = QpS11 + qm+1bT1(4.3)

• Die Gleichung 4.3 heiÿt Krylov-Schur-Relation der Gröÿenordnung

p. Es ist keine Arnoldirelation, da b1 keine führenden Nullen hat.

• Allerdings kann 4.3 in eine Arnoldirelation der Gröÿenordnung p

überführt werden:

Man sucht eine unitäre Matrix U2, sd. bT1 U2 = [0, ...0, ∗] und UH2 S11U2

eine Hessenbergmatrix ist. Dies erreicht man durch eine Reihe von

Householdertransformationen oder durch die Arnoldi-Methode an-

gewandt auf S11 mit Startvektor b1.

↪→ AQpU2 = (QpU2)UH2 S11U2+qm+1bT1 U2, wobei bT1 U2 = [0, ..., 0, ∗]

Algorithmus 3.4.

Eingabe: Arnoldirelation der Gröÿenordnung m

Ausgabe: Arnoldirelation der Gröÿenordnung p

1. Bestimme Schurform von H_m, sd. die gesuchten Eigenwerte oben sind

(d.h. bestimme U_1, S_11)

35

2. b_1' = U_1(m,1:p) * h_(m+1,m) ( " ' " Matlab Schreibweise)

3. Bestimme U_2, Hdach_p = U_2' * S_11 * U_2, hdach_(p+1,p)

( U_1 * [I_p] * U_2 )

4. Qdach_p = Q_m * ( [ 0 ] ), qdach_(m+1) = q_(m+1)

Algorithmus 3.5 (IRAM).

Eingabe: A ∈ Cn×n, q1 ∈ Cn, ‖q1‖2 = 1, p < m < n, tol> 0

Ausgabe: p approximierte Eigenpaare von A mit ‖Axi − λixi‖2 ≤ tol (falls

der Algorithmus stoppt)

1. Generiere eine Arnoldirelation der Groesse m mit der Arnoldi-Methode.

2. Bestimme die m Ritzpaare, suche p aus.

3. if alle gesuchten p Ritzpaare sind konvergiert (residual < tol)

4. STOP

5. else

6. verringere die Groesse der Arnoldirelation zu p mit Algo. 3.4.

7. vergroessere die Arnoldierelation wieder auf Groesse m

durch die Arnoldi-Methode, goto 2

8. end

• Gewöhnlich wählt man m als max{20, 2p}.• Eine praktische Implementation würde eine maximale Anzahl von

Zyklen benutzen.

5. Die symmetrische Lanczos-Methode

Spezialfall der Arnoldi-Methode für hermitische A = AH ∈ Cn×n.=⇒ Nach m Schritten: Hm = QHmAQm

=⇒ Hm ist hermitisch

=⇒ Tm := Hm ist tridiagonal

Tm =

α1 b1 0

β1 α2 β2

β2 α3. . .

. . . . . . βm−1

0 βm−1 αm

Tm ist sogar reell, weil die Diagonalelemente von hermitischen Matrizen

reell sind und βi als die Norm von ˜w aus dem Arnoldi-Algorithmus gewählt

wird.

Vergleicht man die Spalten von AQm und QmTm + qm+1βmeTm liefert:

Aq1 = α1q1 + β1q2

Aqi = βi−1qi−1 + αiqi + βi+1qi+1 i = 2, ...,m

36

Dies nennt man eine 3-term-recurrence. Da q1, ..., qm orthogonal sind, gilt

weiterhin αi = qHi Aqi.

Algorithmus 3.6 (Lanczos, 1950).

Eingabe: A = AH ∈ Cn×n, q ∈ Cn, ‖q‖ = 1, mmax ∈ NAusgabe: Qm+1 = [q1, ..., qm+1] isometrisch, α1, ..., αmmax, β1, ..., βmmax, sd.

AQm = QmTm + qm+1βmeTm

(β0 = 0, q0 = [0, ..., 0]′)

for m = 1,...,m_max

w = A * q_m

alpha_m = q_m' * w

wtilde = w - beta_(m-1) * q_(m-1) - alpha_m * q_m

beta_m = norm(wtilde)

if b_m = 0

STOP

else

q_(m+1) = wtilde / beta_m

end

end

• Lanczos-Algorithmus liefert dieselben qm wie die Arnoldi-Methode

(in exakter Arithmetik).

• Es werden immer nur drei Vektoren gleichzeitig im Speicher abge-

legt.

↪→ mmax kann wesentlich gröÿer sein als im nicht-hermitischen

Fall.

• In endlicher Genauigkeit verlieren q1, ..., qm ihre Orthogonalität.

Orthogonalisierung würde helfen, jedoch be�nden sich q1, ..., qm−1

nicht im Speicher.

• Ergebnis: Tm hat mehrere Eigenwerte mit dazugehörigen einfachen

Eigenwerten von A, diese werden Geisteigenwerte genannt.

Man hat also bisher

Lanczos: für hermitische A, speichert 3 Vektoren

Arnoldi: für allgemeine A, speichert alle Basisvektoren

6. Die nicht-symmetrische Lanczos-Methode

Existiert für groÿe nicht-hermitische A ∈ Cn×n eine kurze recurrence?

Idee: Verwerfe die Orthonormalität der Basis und suche ein X ∈ Cn×n

sd.

X−1AX = T tridiagonal, d. h.(6.1)

37

AX = X

α1 γ1

β1 α2. . .

. . . . . . γn−1

βn−1 αn

Betrachtet man X = [x1, ..., xn], so erhält man aus der k-ten Spalte (mit

der Konvention, dass γ0 = 0 ist, x0 ist dann egal)

Axk = γk−1xk−1 + αkxk + βkxk+1 ∀ k = 1, ..., n− 1.

Auÿerdem hat man Y HX = I mit Y = X−H = [y1, ..., yn], d. h. yHi xj = δij .

Definition 3.5. Man nennt obige (x1, ..., xn), (y1, ..., yn) bi-orthonormal.

Aus 6.1 erhält man leicht TH = XHAHX−H = Y −1AHY , d. h. AHY =

Y TH . Die k-te Spalte ist (mit der Konvention, dass β0 = 0 ist, y0 ist dann

egal)

AHyk = βk−1yk−1 + αkyk + γkyk+1 ∀ k = 1, ..., n− 1.

Aus 6.1 erhält man auch Y HAX = T =⇒ yHk Axk = αk und

βkxk+1 = Axk − γk−1xk−1 − αkxk =: rk

γkyk+1 = AHyk − βk−1yk−1 − αkyk =: sk

Aus der Biorthonormalität hat man

1 = yHk−1xk+1 =1

βkγksHk rk.

Das Produkt βkγk ist also fest. Wähle βk = ‖rk‖, andere Varianten sind

γk = ‖sk‖ oder βk = γk. Fügt man das alles zusammen, erhält man folgenden

Algorithmus:

Algorithmus 3.7 (nicht-symmetrischer Lanczos).

Eingabe: A ∈ Cn×n, x1, y1 ∈ Cn mit xH1 y1 = 1

for k = 1,2,...

alpha_k = y_k' * A * x_k

r_k = A * x_k - gamma_(k-1) * x_(k-1) - alpha_k * x_k (mit gamma_0 = 0)

s_k = A' * y_k - conjugiert(beta_(k-1)) * y_(k-1)

- conjugiert(alpha_k) * y_k (mit beta_0 = 0)

if s_k = 0 then breakdown

beta_k = norm(r_k)

gamma_k = (s_k' * r_k) / beta_k

x_(k+1) = r_k / beta_k

y_(k+1) = s_k / gamma_k

end

38

Bemerkung 3.4.

• Jede Iteration kostet hauptsächlich eine Multiplikation mit A und

eine mit AH .

• Nach k Schritten ohne Breakdown hat man

AXk = XkTk + βkxk+1eTk und

AHYk = YkTHk + γkyk+1e

Tk ,

wobei Xk = [x1, ..., xk], Yk = [y1, ..., yk] und Tk die führende

k × k-Untermatrix von T ist.

• span{x1, ..., xk} = Kk(A, x1)

• span{y1, ..., yk} = Kk(A, yk)• Für A = AH und x1 = y1 erhält man die symmetrische Lanczos-

Methode.

• Im Falle eines Breakdowns, d. h. sHk rk = 0

a) rk = 0 =⇒ span{x1, ..., xk} ist A-invariant. (Lucky Break-

down)

b) sk = 0 =⇒ span{y1, ..., yk} istAH -invariant. (Lucky Break-

down)

c) rk 6= 0 6= sk =⇒ Serious Breakdown, keine Invarianz-Information

(Neustart mit anderen x1, y1 oder versuche eine andere Metho-

de)

• sHk rk ≈ 0 =⇒ numerische Probleme, Methode wird instabil.

• Man hat Tk = Y Hk AXk und (einige) Eigenwerte von Tm sind (oft)

gute Approximationen der Eigenwerte von A. Sei (µ, z) ein Eigen-

paar von Tm, v = Xmz, r = Av − µv. DannY Hm (Av − µv) = Y H

m AXmz − µYmXmz = Tmz − µz = 0.

=⇒ Die nicht-symmetrische Lanczos-Methode ist eine Petrov-Galerkin-

Projektions Methode mit Suchraum Km(A, x1) und Testraum

Km(AH , y1).

7. Shift-Invert-Krylov-Methoden

Die Krylov-Methoden (Arnoldi, Lanczos) konvergieren für gewöhnlich im

äuÿeren Teil des Spektrums. Wie kann man Eigenpaare im Inneren bestim-

men, z. B. nah an einem Zielwert σ ∈ C?Fakt:

• (λ, x) ist ein Eigenpaar von A

⇔(

1λ−σ , x

)ist ein Eigenpaar von (A− σI)−1

• λ ist nah bei σ ⇔∣∣∣ 1λ−σ

∣∣∣ ist groÿ39

Idee: Wende eine Krylov-Methode auf (A− σI)−1 an.

Bemerkung 3.5.

• Diese Methode nennt man Shift-Invert-Arnoldi(-Lanczos)-Methode.

• (A−σI)−1 wird nicht explizit bestimmt! (Sie ist nicht dünnbesetzt.)

• Anstelle der Matrix-Vektor-Produkte w = Aq, muss man nun groÿe

lineare Gleichungssysteme (A− σI)w = q lösen.

• Diese linearen Systeme müssen mit hoher Genauigkeit gelöst wer-

den, andernfalls ist die Arnoldirelation verletzt.

• Während des Algorithmus müssen viele lineare Gleichungssysteme

mit derselben Matrix (A−σI) gelöst werden. Dazu verwendet man

gewöhnlich eine LU-Zerlegung (welche ho�entlich dünnbesetzt ist).

Ist die LU-Zerlegung einmal bestimmt, wird in jeder Iteration eine

Vorwärts-Rückwärts-Substitution durchgeführt.

8. Jacobi-Davidson-Methode

Ziel: Finde eine Methode die rapide gegen ein Eigenpaar (λ, x) mit λ am

nächsten beim Zielwert σ konvergiert.

Sei (µ, v) eine Approximation von (λ, x).

Idee: Nutze die Newton-Methode.

Ziel:

• Bestimme Korrekturen c∗ von v und δ∗ von µ.

• Dabei soll gelten: c∗⊥ v.3

⇒ (c∗, δ∗) sind Lösungen des nichtlinearen Gleichungssystems:

f(c, δ) =

[A(v + c)− (µ+ δ)(v + c)

vHc

]=

[0

0

]Man approximiert c∗, δ∗ durch einen Schritt der Newton-Methode star-

tend im Punkt (0, 0), d. h.

f ′(0, 0)

[c

δ

]= −f(0, 0)

⇔

[A− µI v

vH 0

][c

δ

]= −

[r

0

]mit r = Av − µv. (∗)

Nutzt man c um einen Suchraum in einer Ritz-Galerkin-Methode zu

erweitern, erhält man folgende Methode:

Algorithmus 3.8 (Jacobi-Davidson, 1996 von Slijpen/Vander Vorst).

Eingabe: A ∈ Cn×n, q1 ∈ Cn mit ‖q1‖ = 1, σ ∈ C

3Damit die Lösung einzigartig ist.

40

for k = 1,2,...

w_k = A * q_k

update Q_k = [q_1,...,q_k]

update W_k = [w_1,...,w_k]

update M_k = Q_k' * W_k

bestimme die Eigenpaare von M_k (= die Ritzpaare von A)

waehle von diesen (mu,z) mit mu am naechsten bei sigma

v = Q_k * z

r = W_k * z - mu * v

if norm(r) < tol STOP

loese (*) fuer c

bestimme q_(k+1) durch Orthonormalisierung von c zu Q_k

end

Bemerkung 3.6.

• Hauptkosten pro Iteration:

� Matrix-Vektor-Multiplikation

� eine Lösung von (∗)• (∗) wird häu�g umformuliert zu

(A− µI)c+ δv = −r und c⊥ v⇔ P (A− µI)Pc = −r und c⊥ v. (∗∗)

Dabei ist P = I − vvH

vHvder Orthogonalprojektor auf den span(v).

• Wenn (∗) oder (∗∗) exakt gelöst wird, ist die Konvergenzgeschwin-digkeit für gewöhnlich quadratisch (Newton), allerdings durch den

Projektionspart robuster als die Newton-Methode.

• Anders als in der Shift-Invert-Arnoldi-Methode ist es in Ordnung

eine Lösung von (∗) oder (∗∗) nur zu approximieren. Dies relati-

viert die Tatsache, dass sich das lineare Gleichungssystem in jedem

Schritt ändert, die Konvergenzgeschwindigkeit ist dann linear.

• Häu�g genutzte Approximationen sind:

� P (A− µI)P ≈ I (Übung)

� P (A−µI)P ≈ D−µI (D = diag(A)) �Davidson-Methode� in

der Quantenchemie

� Nutze iterative Methoden (Kapitel 4).

• JD approximiert ein Eigenpaar zur gleichen Zeit, wohingegen SI-

Arnoldi gegen mehrere zu gleich konvergiert.

• Neustarts sind einfacher als in Arnoldi-Methoden.

41

KAPITEL 4

Groÿe lineare Gleichungssysteme

Gegeben: A ∈ Cn×n, b ∈ Cn, n groÿ, A dünnbesetzt, invertierbar

Gesucht: x∗ ∈ Cn sodass Ax∗ = b oder eine Approximation von x∗

→ Beachte, dass x∗ = A−1b, aber A−1 ist nicht dünnbesetzt. Daher ist

A−1 zu bestimmen keine Option.

a) Dünnbesetzte direkte Methoden Ziel ist es Permutationen P (und

Q) zu �nden, sodass die LU-Zerlegung von PAP T (oder PAQ) dünnbesetzt

ist.

Beispiel 4.1. Betrachtet man folgende (4× 4)-Matrix mit Nichtnullein-

trägen ∗

A=

∗ ∗ ∗ ∗∗ ∗∗ ∗∗ ∗

,dann sind L und U dichtbesetzte Dreiecksmatrizen. Allerdings ergibt sich

mit folgender Permutation:

P =

1

1

1

1

⇒ PAP T =

∗ ∗∗ ∗∗ ∗

∗ ∗ ∗ ∗

⇒ L =

1

1

1

∗ ∗ ∗ 1

, U =

∗ ∗∗ ∗∗ ∗∗

Bemerkung 4.1.

• Normalerweise haben U und L− I mehr Nichtnullen als A.

• Eine Permutation P (undQ) zu �nden, sodass die Anzahl der Nicht-

nullen in U und L − I minimiert wird, ist NP-schwer (d. h. der

Rechenaufwand von O(2n) ist zu hoch). Daher müssen Heuristiken

benutzt werden.

43

• Je mehr Pivotisierung man betreibt um das Verfahren numerisch

stabil zu machen, desto mehr Nichtnullen erhält man.

• Wenn diese Methoden funktionieren, sind sie sehr robust und lösen

das Problem für viele Vektoren b ohne Probleme.

• Implementiert in:

UMF PACK (Matlab Backslash)

PARDISO, MUMPS, wobei das Letztere kontinuierlich in Frank-

reich weiterentwickelt wird.

b) Iterative Methoden Sei eine Approximation xk von x∗ gegeben, gesucht

ist eine Verbesserung der Approximation. In diesem Kapitel wird ausschlieÿ-

lich dieses Problem behandelt.

Es gibt (mindestens) zwei Arten die Güte von xk zu bewerten:

• Der Fehler ek := x∗ − xk (Tatsächlich von Interesse, aber nicht

bestimmbar ohne x∗ bereits zu kennen.)

• Das Residuum rk := b−Axk (Bestimmbar!)

Man beachte

rk = b−A(−ek + x∗) = b−Ax∗ +Aek = Aek

⇒ ‖rk‖ ≤ ‖A‖‖ek‖

ek = A−1rk ⇒ ‖ek‖ ≤ ‖A−1‖‖rk‖

1. Iterative Verbesserung

Annahme: M ∈ Cn×n, sodass• M−1 ≈ A−1,

• das lineare Gleichungssystem Mx = b ist leicht zu lösen,

solch eine Matrix M wird Vorkonditionierer von A genannt.

Ziel: Bestimme für eine gegebene Approximation xk eine Korrektur ck ∈ Cn,sodass xk + ck ≈ x∗.Idee: Wähle ck = M−1rk ≈ A−1rk = ek = x∗ − xk.

Die Iteration

xk+1 = xk +M−1(b−Axk)(1.1)

bei gegebenem Startvektor x0 wird iterative Verbesserung oder Splitting-

Methode genannt. Man beachte, dass nur Multiplikationen mit A und Lö-

sungen mit M benötigt werden. Dieses Verfahren funktioniert für gute Vor-

konditionierer.

Satz 4.1. Seien A,M ∈ Cn×n invertierbar. Dann sind folgende Aussagen

äquivalent:

44

a) Die Iteration (1.1) konvergiert gegen x∗ = A−1b für alle x0, b ∈ Cn.b) ρ∗ := ρ(I −M−1A) < 1.

Dabei ist ρ(X) der Spektralradius1 der Matrix X. In diesem Fall ist die Kon-

vergenz Geschwindigkeit linear mit Geschwindigkeitsrate ρ∗.

Beweis. Übung. �

Spezialfälle (Hier ist A = L+D + U , wobei L die strikte untere Drei-

ecksmatrix von A, D die Diagonalmatrix von A und U die strikte obere

Dreiecksmatrix von A ist. Daher auch der Name Splitting-Methode.)

• M = D, gut für diagonaldominante A, heiÿt Jacobi-Verfahren oder

Gesamtschrittverfahren.

• M = D + L, gut wenn ‖U‖ klein ist, heiÿt Gauÿ-Seidel-Verfahren

oder Einzelschrittverfahren.

• M = LU , wobei A ≈ LU eine Approximation der LU-Zerlegung

von A ist.

Die folgenden Methoden

• funktionieren für mehr Vorkonditionierer und

• konvergieren schneller

oder benutzen die Symmetrie von A.

2. Projektionsmethoden

Gegeben: A, b, x0 wie oben und Q ∈ Cn×k mit vollem Rang.

Gesucht: Eine gute Approximation von x∗ = A−1b der Form

x = x0 +Qz ∈ x0 + range(Q)︸ ︷︷ ︸Ansatzraum, Suchraum

Oder anders formuliert: Welches Element des Suchraums ist eine gute Kor-

rektur für x0?

Sei r0 = b−Ax0; r = b−Ax.

Petrov-Galerkin-Ansatz. Sei W ∈ Cn×n mit vollem Rang gegeben,

wähle ein r, sd.

r⊥ range(W )︸ ︷︷ ︸Testraum

⇐⇒WHr = 0

Bestimmung:

0 = WHr = WH (b−A(x0 +Qz)) = WHr0 −WHAQz ⇒ z = (WHAQ)−1WHr0

1Zur Erinnerung: Der Spektralradius ist der betraglich gröÿte Eigenwert einer Matrix.

45

Es gibt zwei Spezialfälle:

a) Ritz-Galerkin-Ansatz / ORTHORES Ansatz

W = Q⇒ z = (QHAQ)−1QHr0

b) MINRES Ansatz

W = AQ⇒ z = (WHW )−1WHr0

⇒WHWz = WHr0

Das ist die Normalgleichung des kleinste Quadrate Problems

‖x0 −Wz‖2 = minz∈Ck

r0 −Wz

= b−Ax0 −AQz = b−Ax = r

3. GMRES Methode

Was ist ein guter Suchraum?

Idee: Nutze den Raum, der durch die Korrektion der iterativen Verbesserung

aufgespannt wird.

Anstelle von xk+1 = xk + ck = x0 + c0 + c1 + ...+ ck,

benutze xk+1 ∈ x0 + span(c0, c1, ..., ck).

In diesem Abschnitt wird angenommen, dass M = I oder äquivalent,

dass anstelle von Ax = b folgendes lineare Gleichungssystem gelöst werden

soll

M−1A︸ ︷︷ ︸A

x = M−1b︸ ︷︷ ︸b

oder M−1A︸ ︷︷ ︸A

x = b x = M−1x

GMRES ist eine Projektionsmethode mit MINRES Ansatz und dem

Suchraum range(Qk) = span(c0, ...ck).

Lemma 4.1. Sei A ∈ Cn×n invertierbar und b, x0 ∈ Cn. Setze r0 =

b− Ax0 und seien {ck} die Korrektionen der iterativen Verbesserungen mit

M = I. Dann ck ∈ Kk+1(A, r0).

Beweis. Induktion über k.

k = 0: c0 = M−1r0 = r0 ∈ K1(A, r0) = span(r0).

46

k → k + 1:

ck+1 = M−1rk+1 = rk+1 = b−Axk+1

= b−A(x0 + c0 + ...+ ck) = r0 −A(r0 + r1 + ...+ rk)

IV⇒ r0 + ...+ rk ∈ Kk+1(A, r0)

⇒ A(r0 + ...+ rk) ∈ Kk+2(A, r0)

⇒ ck+1 ∈ Kk+2(A, r0)

�

Damit kann man die Arnoldi-Methode benutzen um eine (orthonormale)

Basis q1, ..., qk des Suchraums zu bestimmen. Man kann das GMRES also

wie folgt aufstellen:

xk = x0 +Qkzk

range(Qk) = Kk(A, r0)

zk sodass ‖rk‖2 = ‖b−Axk‖2 = min

Nach k Schritten der Arnoldi-Methode liefert die Arnoldirelation:

AQk = Qk+1Hk q1 =r0

‖r0‖2In der Projektionsmethode muss man ein kleinste Quadrate Problem in

n Dimensionen lösen. Diese können auf k Dimensionen reduziert werden:

minzk

= ‖b−A(x0 +Qkzk)‖2 = |r0 −AQkzk|2

= ‖Qk+1(‖r0‖2

1

0...

0

−Hkzk)‖2 = ‖‖r0‖2

1

0...

0

−Hkzk‖2

⇒ zk und rk können nur mit Hilfe von kleinen (Gröÿe k) Objekten be-

stimmt werden. Die Lösung ist zk = R−1k UHk [1, 0, ..., 0]T ‖r0‖, wobei

Hk = UkRk eine dünne QR-Zerlegung ist. Das kostet O(k2) Flops2.

Algorithmus 4.1 (GMRES, Saad und Schultz, 1986).

Eingabe: A ∈ Cn×n, b, x0 ∈ Cn, tol, mAusgabe: x

r_0 = b - A * x_0

if norm(r_0) < tol

x = x_0

STOP

2Nur für Hessenbergmatrizen, im Allgemeinen für (k + 1)× k Matrizen: O(k3).

47

end

q_1 = r_0 / norm(r_0)

Q_1 = q_1

Hunderbar_0 = [] (1x0 Matrix)

for k = 1,2,...,m

Erweitere die Arnoldirelation zur Groessenordnung k

(d.h. aktualisiere Q_k, Hunderbar_(k-1) zu Q_(k+1), Hunderbar_k)

Loese norm(norm(r_0) * e_1 - Hunderbar_k * z_k) = min fuer z_k

if norm(norm(r_0) * e_1 - Hunderbar_k * z_k) < tol

break

end

end

x = x_0 + Q_k * z_k

Bemerkung 4.2.

• Kosten für die k-te Iteration:

� Eine Matrix-Vektor-Mutliplikation

� O(kn) Flops für Orthogonalisierung

� O(k2) Flops für kleinste Quadrate

• Wenn die Arnoldi-Methode in der k-ten Iteration abbricht (d. h.

hk+1,k = 0) gilt

‖rk‖ = ‖‖r0‖e1 −Hkzk‖2 = 0

↪→ Man hat die exakte Lösung von Ax = b gefunden. (Lucky

Breakdown)

• Wenn ‖rm‖ > tol, startet man den Algorithmus normalerweise er-

neut mit x(neu)0 = xm.

↪→ Diese Methode nennt man GMRES(m)3.

• GMRES konvergiert nach höchstens n Iterationen (für die Praxis

nicht relevant).

Konvergenzanalyse. Da xk ∈ x0 + Kk(A, r0), existiert ein Polynom

qk ∈ C≤k−1[λ], sodass xk = x0 + qk(A)r0. Für das Residuum gilt

rk = b−Ax0︸ ︷︷ ︸=r0

−Aqk(A)r0 = pk(A)r0,

wobei pk := 1 − λqk(λ) ∈ C∗≤k[λ] und C∗≤k[λ] := {p ∈ C≤k[λ]|p(0) = 1}.GMRES minimiert die Norm von rk.

⇒ ‖rk‖ = minp∈C∗

≤k[λ]‖p(A)r0‖ ≤ min

p∈C∗≤k[λ]‖p(A)‖‖r0‖

3Explizite und implizite Neustart Techniken existieren (Morgan, 2002), werden aber nichthäu�g genutzt.

48

Man teilt das Produkt, damit man unabhängig von b und x0 ist. Nimmt

man nun an, dass A diagonalisierbar und A = SDS−1, dann erfüllt das k-te

Residuum:

‖rk‖‖r0‖

≤ minp∈C∗

≤k[λ]‖p(SDS−1)︸ ︷︷ ︸

=Sp(D)S−1

‖ ≤ minp∈C∗

≤k[λ]‖S‖‖p(D)‖‖S−1‖

= κ(S) minp∈C∗

≤k[λ]maxλ∈Λ(A)

|p(λ)|

Bemerkung 4.3.

• Damit ist die GMRES Konvergenzanalyse auf ein polynomielles Ap-

proximations Problem reduziert worden.4

• Für den Fall, dass alle Eigenwerte bekannt sind, existieren Formeln,

diese sind jedoch unschön.

• Wenn alle Eigenwerte reell und positiv sind (sehr spezieller Fall),

können skalierte Chebychev-Polynome benutzt werden.

• Faustregel: Wenn alle Eigenwerte an einem oder ein paar wenigen

Punkten σi angehäuft sind und κ(S) nicht zu groÿ ist, konvergiert

GMRES gut, weil(

1− λσ1

)k1(

1− λσ2

)k2

... klein ist in der Nähe

von σ1, σ2, ...

• κ(S) darf nicht vergessen werden:

A =

0 c0

1 0 c1

1. . .

.... . . 0 cn−2

1 cn−1

, c0 6= 0, b =

1

0...

0

⇒ x∗ =

c1

...

cn−1

1

−1c0

Für x0 = 0⇒ r0 = b, q1 = b, q2 = e2, qL = eL,5Hk =

0 . . . 0

1. . .. . . 0

1

⇒ zk = 0⇒ xk = x0 = 0, rk = r0

=⇒ Kein Progress bis zur n-ten Iteration. Dies ist unabhängig von

den Eigenwerten, da das charakteristische Polynom von A die Form

zn−n−1∑i=0

cizi hat. Daher kann jede Menge von Eigenwerten konstru-

iert werden, indem man {ci} entsprechend wählt.

4D. h. �nde ein Polynom das auf einer Menge von Punkten (Λ(A)) klein und 1 an derStelle 0 ist.5ei bezeichne den i-ten Einheitsvektor.

49

• Gewöhnliches Verhalten von ‖rk‖‖r0‖ :

1

k

Anfangsphase

superlinear

4. Konjugierte Gradienten Methode (CG)

Algorithmus 4.2 (CG, Hestenes, Stiefel, 1952).

Eingabe: A ∈ Cn×n, hermitisch, positiv de�nit, b, x0 ∈ Cn

Ausgabe: xk, eine Approximation von A−1b

1. r_0 = b - A * x_0

2. p_1 = r_0

3. for k = 1,2,...

4. alpha_k = norm(r_(k-1))^2 / ( p_k^H * A * p_k )

5. x_k = x_(k-1) + alpha_k * p_k

6. r_k = r_(k-1) - alpha_k * A * p_k

7. beta_k = norm(r_k)^2 / norm(r_(k-1))^2

8. p_(k+1) = r_k + beta_k * p_k

9. end

Bemerkung 4.4.

• Kosten pro Iteration:

� eine A-Multiplikation

� ein paar Vektor-Operationen

• Speicherverbrauch: 4 Vektoren (xk, rk, pk, Apk)

• Sieht sehr einfach aus.

• Bedeutungen:

� xk: Aktuelle Iterierte (Approximation der Lösung x∗).

� rk: Residuum von xk.

� pk: Suchrichtung, xk ist in xk−1 + span{pk}.� αk: Schrittweite. Welches Vielfache von pk ist notwendig um

eine bessere Iterierte xk zu erhalten?

50

� βk: Relative Reduktion des Residuums.

• Die folgende Analyse ist unter der Annahme von exakter Arith-

metik, allerdings funktioniert CG bemerkenswert gut in endlicher

Genauigkeit.

Satz 4.2. Sei A = AH ∈ Cn×n positiv de�nit und b, x0 ∈ Cn. Ange-nommen die CG Methode ist nach k Iterationen noch nicht konvergiert (d. h.

rk−1 6= 0).

a) Dann gibt es keine Division durch Null.

b) Dann gilt:

span(x1 − x0, ..., xk − x0) = span(p1, ..., pk) = span(r0, ..., rk−1) =

Kk(A, r0)

c) Die Residuen sind orthogonal, d. h. rHj ri = 0∀ i, k = 0, ..., k, i 6= j.

d) Die Suchrichtungen sind A-konjugiert6: pHk+1Api = 0∀ i = 1, ..., k.

Aus b) und c) erhält man xk ∈ x0 +Kk(A, r0) und rk⊥Kk(A, r0). Damit

ist CG eine Projektionsmethode mit Suchraum Kk(A, r0) und ORTHORES

Ansatz. Es folgt auch, dass xk in folgendem Sinne optimal ist:

CG minimiert den Fehler ek = x∗ − xk in der A-Norm, ‖.‖A : z 7→√zHAz.

Satz 4.3. Sei A = AH ∈ Cn×n positiv de�nit und b, x0 ∈ Cn. Angenom-men die CG Methode konvergiert nicht in den ersten k Iterationen. Dann

a) ist xk der eindeutige Minimierer von ‖x∗−xk‖A über x0+Kk(A, r0),

b) konvergiert das Verfahren monoton, d. h. ‖ek‖A ≤ ‖ek−1‖A,c) wird ek = 0 für ein k ≤ n erreicht.

Wie zuvor bereits erwähnt ist die garantierte Konvergenz nach spätestens

n Schritten in der Praxis nicht von Nutzen (n kann sehr groÿ sein) und ist

im Fall der endlichen Genauigkeit nicht gegeben. CG minimiert ‖ek‖A und

kann als ein Minimierungsalgorithmus, angewandt auf folgende Funktion,

interpretiert werden:

ϕ(x) :=1

2xHAx− Re(xHb).

Diese steht im engen Zusammenhang mit ‖ek‖A:

‖ek‖2A = (x∗ − xk)HA(x∗ − xk) = xHk Axk − xHk Ax∗ − x∗HAxk + x∗HAx∗

= xHk Axk − 2Re(xHk Ax∗) + x∗HAx∗ = 2ϕ(xk) + const.

Eine einfache (und sehr langsame) Optimierungsmethode ist die Wahl

des steilsten Abstiegs (den negativen Gradienten) als Suchrichtung. In diesem

6Alte Bezeichnung für orthogonal.

51

Fall ist pk+1 = rk, denn

∂ϕ

∂Re(x)= Re(Ax− b) = Re(−r) und ∂ϕ

∂Im(x)= Im(Ax− b) = Im(−r).

Da diese Suchrichtungen aber nicht A-konjugiert sind, sind die Iterierten nur

in der Menge xk+1 + span(pk) optimal und nicht in x0 + span(p1, ..., pk). An-

dererseits ist eine steile Abstiegsrichtung in der Optimierung wünschenswert

und man kann beweisen, dass CG Suchrichtungen pk+1 folgende Gleichung

erfüllen:

‖pk+1 − rk‖ = minp⊥Ap1,...,Apk

‖p− rk‖2.

Also sind die Suchrichtungen des CG die leicht modi�zierten Gradienten

von ϕ, damit diese A-konjugiert sind. Daher auch der Name Konjugierte

Gradienten Methode.

Konvergenzanalyse. Man weiÿ, dass rk ∈ Kk(A, r0). Wie im GMRES

existiert ein pk ∈ C∗≤k[λ], sodass rk = pk(A)r0. Da ri = Aei und pk(A)A =

Apk(A), gilt auÿerdem

ek = pk(A)e0 ⇒ ‖ek‖A = minp∈C∗

≤k[λ]‖p(A)e0‖A.

Schreibt man nun e0 als e0 =n∑i=1

αivi, wobei vi die Eigenvektoren von A

sind, liefert dies

‖e0‖2A =n∑i=1

|αi|2λi und ‖p(A)e0‖2A =n∑i=1

|αip(λi)|2λi ≤ ‖e0‖2A maxλ∈Λ(A)

|p(λ)|2

für jedes Polynom p. Da CG den normierten Fehler ‖ek‖A minimiert gilt

‖ek‖A‖e0‖A

= minp∈C∗

≤k[λ]

‖p(A)e0‖A‖e0‖A

≤ minp∈C∗

≤k

maxλ∈Λ(A)

|p(λ)|.(4.1)

Somit konvergiert CG gut, wenn A ein �gutes� Spektrum Λ hat, in dem

Sinne, dass es ein normiertes Polynom (p(0) = 1) zulässt, welches klein auf

dem Spektrum ist. Für den extremen Fall, dass A nur ein paar verschiedene

Eigenwerte hat oder dass alle Eigenwerte sich um einen Wert zentrieren (d. h.

die Konditionszahl κ(A) ist klein):

Satz 4.4. Sei CG angewandt auf ein lineares Gleichungssystem Ax = b

mit A = AH ∈ Cn×n positiv de�nit.

a) Wenn A nur m verschiedene Eigenwerte hat, konvergiert CG in

höchstens m Schritten.

b) Sei κ die 2-Norm Konditionszahl von A. Dann

‖ek‖A‖e0‖A ≤ 2

[(√κ+1√κ−1

)k+(√

κ+1√κ−1

)−k]−1

52

≤ 2(√

κ−1√κ+1

)k≤ 2

(1− 2√

κ

)k.

Beweis. a) Nutze p(λ) =m∏i=1

(1− λ

λi

)in 4.1.

b) Chebychev-Polynome �

Bemerkung 4.5.

• Der letzte Satz deutet auf lineare Konvergenz hin.

• Da(

1− 1√κ

)k≈ 1 − k√

κ(wenn 1√

κ<< 1) kann man eine Konver-

genz in O(√κ) Iterationen erwarten.

Idee: Anstelle von Ax = b löse CHACx = CHb, x = Cx, wo-

bei CHAC eine bessere Konditionszahl als A haben sollte. Daher

kommt auch die Bezeichnung Vorkonditionierer.

53