Programme : matrices trigonalisables

Le calcul du crochet de Lie ne pose pas de probl`eme particulier.

PROCEDURE CrochetDeLie (n: integer; A, B: matC; VAR ALieB: matC);

ALieB=AB−BA

END; { de "CrochetDeLie" }

Avec les exemples de la question 1, on trouve

A1A2 =

ce qui explique les r´esultats.

Pour calculer la dimension de l’espace vectoriel (E) engendr´e par un ensemble finiE= {A1, . . . , Ak} de matrices de Kn et pour d´eterminer une base de (E), on transforme chaque matrice Ai en un vecteur vi de dimension n², puis on calcule le rang de la matrice rectangulaire V de taillek×n² form´ee par les vi. On extrait simultan´ement deV une famille maximale de lignes lin´eairement ind´ependantes, qui fournit donc une base deE. La premi`ere op´eration est r´ealis´ee par la proc´edure suivante :

PROCEDURE Linearise (n: integer; A: matC; VAR vA: vecC);

Transforme une matrice carr´ee d’ordrenen un vecteur `an² composantes.

VAR

i, j: integer;

BEGIN

FOR i := 0 TO n - 1 DO FOR j := 1 TO n DO

vA[i * n + j] := A[i + 1, j];

END; { de "Linearise" }

Pour le calcul du rang et d’un syst`eme maximal de lignes ind´ependantes, le principe est assez simple. On examine les lignes de la matrice dans leur ordre naturel. Si la lignek est nulle, on lui substitue la derni`ere ligne courante et on diminue le nombre de lignes d’une unit´e. Sinon on utilise la m´ethode du pivot : on s´electionne le premier ´el´ement ak,q non nul de la lignek. On permute ´eventuellement les colonnesketqsiq > k, puis on pivote.

On fait donc subir `a la matrice un certain nombre de permutations des lignes et des colonnes et des op´erations de pivot sur les lignes. Comme on veut ´egalement obtenir un ensemble maximal de lignes ind´ependantes, on m´emorise les permutations des lignes. En revanche, il est inutile de m´emoriser les permutations des colonnes et les op´erations de pivot, puisque deux matrices d´eduites l’une de l’autre par permutation des colonnes ou par op´eration de pivot sur les lignes ont les mˆemes ensembles de lignes ind´ependantes.

PROCEDURE BaseDesLignes (m, n: integer; B: matC; VAR rang: integer;

VAR LignesIndependantes: vecE);

Calcule le rang d’une matrice B d’ordre(m, n) et en extrait un ensemble maximal de lignes ind´ependantes.

VAR

inversible: boolean;

A: matC; Obtenue par permutation des lignes deB.

Lignes: vecE; D´ecrit la permutation des lignes d´efinissantA.

v: vecC;

i, j, k, pivot, q: integer;

FUNCTION ChercherPivot (k: integer): integer;

Cherche un pivot non nul entreketn; si le r´esultat estn+ 1, il n’y a pas de pivot non nul.

VAR

i: integer;

BEGIN i := k;

WHILE (i <= n) AND EstCNul(a[k, i]) DO { "and" s´equentiel } i := i + 1;

ChercherPivot := i END; { de "ChercherPivot" }

PROCEDURE EchangerFinColonnes (i, j: integer);

VAR

m: integer;

BEGIN

FOR m := i TO n DO

EchangerC(a[m, i], a[m, j]);

END; { de "EchangerColonnes" }

La proc´edure qui permet l’´echange de deux lignes est presque identique `a la pr´ec´edente, mais on prend la pr´ecaution de m´emoriser la permutation.

PROCEDURE EchangerLignes (i, j: integer);

VAR

m: integer;

BEGIN

FOR m := i TO n DO

EchangerC(a[i, m], a[j, m]);

EchangerE(Lignes[i], Lignes[j]);

END; { de "EchangerLignes" } PROCEDURE PivoterGauss (k: integer);

VAR

i, j: integer;

g, z: complexe;

BEGIN

FOR j := k + 1 TO n DO BEGIN

ComplexeSurComplexe(a[k, j], a[k, k], g);

FOR i := k + 1 TO n DO BEGIN

ComplexeParComplexe(g, a[i, k], z);

ComplexeMoinsComplexe(a[i, j], z, a[i, j]);

END END

END; { de "PivoterGauss" } BEGIN { de "BaseDesLignes" }

A := B;

rang := 0;

FOR i := 1 TO m DO

Lignes[i] := i; Au d´epart, les lignes sont dans l’ordre.

inversible := true;

k := 1;

WHILE (k <= m) DO BEGIN q := ChercherPivot(k);

inversible := q <> n + 1;

IF inversible THEN BEGIN IF q > k THEN

EchangerFinColonnes(k, q);

PivoterGauss(k);

rang := rang + 1;

LignesIndependantes[rang] := Lignes[k];

k := k + 1 END

ELSE BEGIN

EchangerLignes(k, m);

m := m - 1 END

END; { sur k }

END; { de "BaseDesLignes" }

Enfin, la proc´edure ci-dessous donne la dimension de l’espace vectoriel engendr´e par un ensemble fini de matrices.

FUNCTION dim (CardE, n: integer; E: EnsembleDeMatrices;

VAR BaseE: EnsembleDeMatrices): integer;

Calcule la dimension de l’espace vectoriel engendr´e par un ensembleE deCardE ma-trices et extrait deE une base de cet espace vectoriel.

VAR

i, r: integer;

L: vecE;

ELinearise: matC;

BEGIN

FOR i := 1 TO CardE DO

Linearise(n, E[i], ELinearise[i]);

BaseDesLignes(CardE, n * n, ELinearise, r, L);

FOR i := 1 TO r DO BaseE[i] := E[L[i]];

dim := r;

END; {de "dim"}

Pour calculer la dimension de l’alg`ebre de Lie engendr´ee par un ensemble fini de matrices E, on calcule, pour chaque entierk, une baseBk de l’espace vectoriel Ek d´efini dans l’´enonc´e. Pour obtenirB0, il suffit d’extraire une base deE. Pour passer deBk `aBk+1, on calcule l’ensemble de tous les crochets de Lie des matrices deBk, puis on extrait une base de cet ensemble. Lorsque les dimensions deBk et deBk+1 sont ´egales, le calcul est termin´e.

PROCEDURE LesCrochetsDeLie (VAR CardB: integer; n: integer;

VAR B: EnsembleDeMatrices);

VAR

i, j, k: integer;

BEGIN

k := CardB;

FOR i := 1 TO CardB DO

FOR j := i + 1 TO CardB DO BEGIN

k := k + 1; On ajoute tous les crochets de Lie.

CrochetDeLie(n, B[i], B[j], B[k]) END;

CardB := k

END; { de "LesCrochetsDeLie" }

PROCEDURE AlgebreDeLie (CardE, n: integer; E: EnsembleDeMatrices);

Calcule la dimension de l’alg`ebre de Lie engendr´ee par un ensembleEdeCardEmatrices d’ordren.

VAR

i, CardB, dimE: integer;

B: EnsembleDeMatrices;

BEGIN

CardB := dim(CardE, n, E, B);

REPEAT

dimE := CardB;

LesCrochetsDeLie(CardB, n, B);

CardB := dim(CardB, n, B, B);

UNTIL dimE = CardB;

Si le rang n’a pas augment´e, on a l’alg`ebre de Lie engendr´ee parE.

writeln(’Dimension de l’’alg`ebre de Lie comme espace vectoriel = ’, CardB : 1);

writeln(’Base de l’’alg`ebre de Lie comme espace vectoriel : ’);

FOR i := 1 TO CardB DO

EcrireMatriceC(n, B[i], ’’);

END; { de "AlgebreDeLie" }

Pour terminer, voici quelques exemples d’ex´ecution : Voici A1 :

- i 0 - 2.0

0 1.0 0

i 0 2.0 + i

rang(A 1) = 3 Voici A2 :

2.0 - i 0 - 2.0 i

- i 1.0 - 1.0 - i

- 1.0 0 i

rang(A 2) = 3 Voici A3 :

1.0 1.0 - i - 1.0 - i

0 1.0 - i - 1.0

0 - 1.0 1.0 + i

rang(A 3) = 3 Voici A1A2 :

1.0 - 2.0 i 0 - 2.0 - 2.0 i

- i 1.0 - 1.0 - i

- 1.0 + i 0 1.0 + 2.0 i

rang (A1A2) = 3 Voici [A1,A2] :

0 0 0

0 0 0

0 0 0

rang ([A1,A2]) = 0 Voici [A1,A3] :

- 1.0 + i 0 2.0 i

i 0 1.0 + i

1.0 0 1.0 - i

rang(A 1A 3) = 1

Dimension de l’espace engendr´e par E = 3

Dimension de l’alg`ebre de Lie comme espace vectoriel = 4 Base de l’alg`ebre de Lie comme espace vectoriel :

- i 0 - 2.0

0 1.0 0

i 0 2.0 + i

2.0 - i 0 - 2.0 i

- i 1.0 - 1.0 - i

- 1.0 0 i

1.0 1.0 - i - 1.0 - i

0 1.0 - i - 1.0

0 - 1.0 1.0 + i

- 1.0 + i 0 2.0 i

i 0 1.0 + i

1.0 0 1.0 - i

Notes bibliographiques

Les pseudo-inverses sont fr´equemment d´efinies pour les matrices complexes, la trans-pos´ee ´etant remplac´ee par l’adjointe. Parmi les monographies consacr´ees aux pseudo-inverses, citons :

R. M. Pringle, A. A. Rayner,Generalized Inverse Matrices, London, Griffin, 1971.

Une pr´esentation br`eve est donn´ee par :

J. Stoer,Numerische Mathematik 1, Berlin, Springer-Verlag, 1989.

Chapitre 3

D´ ecompositions

Uned´ecompositiond’une matrice carr´eeAest un couple (B, C) de deux matrices carr´ees B et C telles queA=BC. Lorsque ces matrices ont une forme particuli`ere, certaines op´erations, comme la r´esolution de syst`emes lin´eaires, s’en trouvent simplifi´ees. Dans ce chapitre, nous consid´erons trois d´ecompositions : la d´ecompositionLU, la d´ecomposition de Choleski et la d´ecompositionQR. On utilisera aussi ces d´ecompositions pour le calcul des valeurs propres.

3.1 D´ ecomposition LU

Uned´ecompositionLUd’une matrice carr´eeAd’ordrenest un couple (L, U) de matrices carr´ees d’ordre n, avec L unitriangulaire inf´erieure, c’est-`a-dire ayant des 1 sur la diagonale, etU triangulaire sup´erieure, telles que

A=LU

L’int´erˆet de disposer d’une telle d´ecomposition est clair. La r´esolution d’un syst`eme d’´equations lin´eaires

Ax=b

se ram`ene alors `a la r´esolution des deux syst`emes triangulaires Ly=b U x=y

ce qui est particuli`erement simple. De la mˆeme mani`ere, si A est inversible, l’inverse A⁻¹=U⁻¹L⁻¹ s’obtient en inversant deux matrices triangulaires, ce qui est facile. En fait, une matrice quelconque n’admet pas n´ecessairement une d´ecompositionLU.

Proposition 3.1.1. Une matrice inversible A admet une d´ecomposition LU si et seulement si tous ses mineurs principaux sont inversibles; de plus, la d´ecomposition LU est alors unique.

Preuve. Supposons que A ait deux d´ecompositions A = LU = L⁰U⁰. Comme A est inversible, L et L⁰ le sont. Alors L⁻¹L⁰ = U U⁰⁻¹. La matrice L⁻¹L⁰ est triangulaire inf´erieure et U U⁰⁻¹ est triangulaire sup´erieure. L’´egalit´e implique qu’elles sont toutes deux diagonales et la premi`ere, donc aussi la deuxi`eme, est en fait la matrice unit´e, montrant queL=L⁰ etU =U⁰. Ceci prouve l’unicit´e, qui d’ailleurs d´ecoule aussi de la preuve d’existence qui suit.

L’existence se montre par r´ecurrence sur l’ordre n de A, le cas n = 1 ´etant ´evident.

Consid´erons alors la d´ecomposition par blocs A=

A⁰ b b⁰ a

o`uA<sup>0</sup> est d’ordren−1. Par r´ecurrence,A<sup>0</sup>poss`ede une d´ecompositionLU, soit (L⁰, U⁰).

Cherchons alors deux matrices d’ordren L=

avecLU =A. On obtient les ´equations

L⁰u=b vU⁰=b⁰ vu+r=a

Les deux premi`eres permettent de d´etermineruetvde fa¸con unique parce queL<sup>0</sup> etU<sup>0</sup> sont inversibles et la troisi`eme donnerde fa¸con unique. D’o`u l’existence.

R´eciproquement, si A =LU, alors U est inversible et en particulier le produit de ses

´el´ements diagonaux est non nul. Soit 1 ≤k ≤ n et soit A⁰ le mineur principal deA d’ordrek. Consid´erons la d´ecomposition par blocs

L=

Il n’est pas difficile de v´erifier que, siAposs`ede deux d´ecompositions (L, U) et (L⁰, U⁰), alors on a toujoursU =U⁰. En revanche, l’´egalit´e entre L et L⁰ ne peut ˆetre assur´ee;

consid´erer par exemple le casU = 0.

Toute matrice inversible A peut ˆetre, par une permutation de ses lignes, transform´ee en une matrice dont les mineurs principaux sont inversibles. Toute matrice inversible poss`ede donc, `a une permutation de ses lignes pr`es, une d´ecompositionLU. La m´ethode appel´ee m´ethode de Crout ou m´ethode de Gauss modernis´ee est un algorithme pour obtenir cette d´ecomposition. Elle consiste en fait en une organisation judicieuse des calculs faits lors de la m´ethode de Gauss.

Dans la m´ethode de Gauss, une op´eration de pivotage peut ˆetre interpr´et´ee comme la multiplication `a gauche par une matrice de Frobenius Gk qui, dans ce cas, est unitri-angulaire inf´erieure. S’il n’y a pas d’´echange de lignes, une matrice A d’ordre n est transform´ee en

Gn−1· · ·G2G1A=U

la matrice U est triangulaire sup´erieure et G = Gn−1· · ·G2G1 est unitriangulaire inf´erieure. On a donc

A=LU

avecL=G⁻¹. En d’autres termes, la m´ethode de Gauss contient de fa¸con cach´ee une m´ethode de d´ecompositionLU.

S’il y a ´echange de lignes dans la m´ethode de Gauss, on a en fait Gn−1Pn−1· · ·G2P2G1P1A=U o`u lesPk sont des matrices de permutations. Or

Gn−1Pn−1· · ·G2P2G1P1=P Hn−1· · ·H2H1

avecP =Pn−1· · ·P2P1 et

Hk = (Pk· · ·P1)⁻¹GkPk· · ·P1 1≤k < n

de sorte que la matrice H = P Hn−1· · ·H2H1P⁻¹ est unitriangulaire inf´erieure et HP A=U; avecL=H⁻¹, on a

A=LU

Pour la r´ealisation, nous partons de l’´equation A = LU, avec A = (ai,j), L = (`i,j), U = (ui,j). On suppose`i,j = 0 pourj > iet `i,i = 1 et de mˆemeui,j = 0 pouri > j.

On a alors, en identifiant

ai,k=

min(i,k)

X

j=1

`i,juj,k

d’o`u l’on tire

`i,k= (ai,k−

k−1

X

j=1

`i,juj,k)/uk,k i > k ui,k =ai,k−

i−1

X

j=1

`i,juj,k i≤k

Il y a plusieurs strat´egies pour r´esoudre ces ´equations : on peut proc´eder ligne par ligne, colonne par colonne, en diagonale, etc. On peut ´egalement remarquer que chaque coefficient ai,k n’est utilis´e qu’une fois; on peut donc stocker, `a la place de ai,k, le coefficient `i,k, si i > k, et ui,k quand i ≤ k (les ´el´ements diagonaux de L n’ont pas besoin d’ˆetre conserv´es).

Pour pouvoir ´eliminer un pivotuk,k nul, on constate que les formules donnantuk,k et les`i,ksont, `a la division pr`es, formellement les mˆemes. Ceci montre que tout `i,k pour i > kpeut jouer le rˆole deuk,k. On adopte donc la d´emarche suivante : on calcule, pour

chaque colonnek, d’abord des ´el´ements`⁰_i,k et ui,k par les formules ui,k=ai,k−

i−1

X

j=1

`i,juj,k i≤k

`⁰_i,k = ai,k−

kX−1 j=1

`i,juj,k i > k

puis l’on cherche un pivot non nul et on fait la division des`⁰_i,k par le pivot. Voici une r´ealisation :

PROCEDURE DecompositionLU (n: integer; VAR a: mat; VAR p: vecE;

VAR inversible: boolean);

Calcule, dansa, la d´ecomposition LU dea, `a une permutation des lignes pr`es. Cette permutation est dans le vecteurp. Sia n’est pas inversible, le bool´een est mis `a faux, mais une partie deapeut ˆetre d´etruite.

VAR

k, q: integer;

FUNCTION PivotMax (k: integer): integer;

Cherche le pivot maximal entreketn.

VAR

i, p: integer;

BEGIN p := k;

FOR i := k + 1 TO n DO

IF abs(a[i, k]) > abs(a[p, k]) THEN p := i;

PivotMax := p END; { de "PivotMax" }

PROCEDURE EchangerLignes (i, j: integer);

VAR

m: integer;

BEGIN

FOR m := 1 TO n DO echanger(a[i, m], a[j, m]);

END; { de "EchangerLignes" } PROCEDURE Decomposer (k: integer);

VAR

i, j: integer;

somme: real;

BEGIN

FOR i := 1 TO n DO BEGIN somme := a[i, k];

FOR j := 1 TO min(i, k) - 1 DO

somme := somme - a[i, j] * a[j, k];

a[i, k] := somme END

END; { de "Decomposer" } PROCEDURE Diviser (k: integer);

VAR

i: integer;

BEGIN

FOR i := k + 1 TO n DO

a[i, k] := a[i, k] / a[k, k]

END; { de "Diviser" } BEGIN { de "DecompositionLU" }

FOR k := 1 TO n DO p[k] := k;

k := 1;

inversible := true;

WHILE (k <= n) AND inversible DO BEGIN Decomposer(k);

q := PivotMax(k);

inversible := NOT EstNul(a[q, k]);

IF inversible THEN BEGIN IF q > k THEN BEGIN

EchangerLignes(k, q);

echangerE(p[q], p[k]) END;

Diviser(k) END;

k := k + 1

END; { du while sur k } END; { de "DecompositionLU" } Voici un exemple de d´ecomposition :

Voici la matrice lue

4.000 2.000 1.000 0.000 2.000 5.000 3.000 5.000 1.000 1.000 1.000 1.000 2.000 1.000 4.000 1.000 Matrice L

1.000 0.000 0.000 0.000 0.500 1.000 0.000 0.000 0.500 0.000 1.000 0.000 0.250 0.125 0.125 1.000 Matrice U

4.000 2.000 1.000 0.000 0.000 4.000 2.500 5.000 0.000 0.000 3.500 1.000 0.000 0.000 0.000 0.250 Vecteur de permutation des lignes

1 2 4 3

Matrice LU

4.000 2.000 1.000 0.000 2.000 5.000 3.000 5.000 2.000 1.000 4.000 1.000 1.000 1.000 1.000 1.000

Les lignes 3 et 4 sont en effet permut´ees. Comme il est d´ej`a dit plus haut, la d´ecompo-sitionLUfacilite la r´esolution d’un syst`eme lin´eaire. Voici une r´ealisation :

PROCEDURE SystemeParCrout (n: integer; a: mat; b: vec; VAR x: vec;

VAR inversible: boolean);

R´esolution du syst`eme d’´equations lin´eaireAx=bpar la m´ethode de Crout. Si Aest inversible,xcontient la solution, sinon le bool´een est faux.

VAR

p: vecE;

PROCEDURE Permuter (b: vec; p: vecE; VAR bp: vec);

VAR

k: integer;

BEGIN

FOR k := 1 TO n DO bp[k] := b[p[k]];

END; { de "Permuter" } BEGIN

DecompositionLU(n, a, p, inversible);

IF inversible THEN BEGIN Permuter(b, p, b);

SystemeUniTriangulaireInferieur(n, a, b, x);

SystemeTriangulaireSuperieur(n, a, x, x);

END

END; { de "SystemeParCrout" }

La proc´edureSystemeTriangulaireSuperieura d´ej`a ´et´e pr´esent´ee au chapitre 1; la proc´edureSystemeUniTriangulaireInferieurci-dessous tient en plus compte du fait que les ´el´ements diagonaux valent 1 pour ne pas faire de division :

PROCEDURE SystemeUniTriangulaireInferieur (n: integer; a: mat; b: vec;

VAR x: vec);

R´esolution d’un syst`eme unitriangulaire inf´erieur.

VAR

k, j: integer;

s: real;

BEGIN

FOR k := 1 TO n DO BEGIN s := b[k];

FOR j := 1 TO k - 1 DO s := s - a[k, j] * x[j];

x[k] := s Pas de division : le coefficient diagonal est1.

END;

END; { de "SystemeUniTriangulaireInferieur" }

Dans le document Probl`emes r´esolus ALG`EBRE, COMBINATOIRE, ARITHM´ETIQUE (Page 57-69)