Cliquez pour afficher

* Polynôme caractéristique:

* Polynôme minimal : On vérifie bien que ne sont pas annulateurs donc le polynôme minimal c'est le polynôme caractéristique :

* et sont premiers entre eux et est annulateur: d'après le lemme des noyaux :

* La matrice de A dans une base adaptée à cette décomposition : donc A est semblable à A'. (je me suis bien énervé avant de trouver une telle base )

* Par récurrence

 Cliquez pour afficher

Il existe une commande pour trouver le polynôme minimal dans Maple, qui est minpoly. Cette commande est à utiliser avec prudence, et tu as raison de procéder comme tu l'as expliqué.
Pour la base de trigonalisation, il y avait aussi une idée avec Maple, qui peut donner le noyau de A² et de (A-2I)². (par contre, je déconseillerais d'utiliser la commande jordan).

Je pense que même si l'énoncé ne demandait pas l'expression de a_n,b_b,c_b,d_n en fonction de n, il faudrait trouver cette expression.
Dans le cas de cet énoncé, l'énoncé demande l'expression de a_n,b_n,c_n,d_n en fonction de n.

 Cliquez pour afficher

1)
> restart; with(linalg):
> A:=matrix([[1,1,0,2],[-3,1,4,0],[0,1,1,3],[-1,0,1,1]]):
> factor(charpoly(A,X));
                   X²(X-2)²

Après, je vérifie que A n'annule ni X(X-2), ni X²(X-2) ni X(X-2)². Cayley-Hamiltion est content, A annule X²(X-2)². Donc le polynôme minimal est le poly caractéristique, qui vaut

2) Donnons une base de ker((A-2I)²) et ker(A²) : j'utilise la commande kernel( de Maple.

ker(A²) est le plan vectoriel de base

ker((A-2I)²) est le plan vectoriel de base

On vérifie que et que ; et ainsi

3) je n'ai pas encore fait les calculs

4) par récurrence on a leur existence ; pour la valeur il faudra certainement utiliser la 3). Je regarde ça dans la semaine si j'ai le temps.

 Cliquez pour afficher

en posant 1-=a j'obtiens (a²-1)² ce qui donne [(1-X)²-1]² soit(X-2)²X² pour le polynôme caractéristique

 Cliquez pour afficher

Première question:


Voici la syntaxe Maple pour obtenir le polynôme caractéristique et le polynôme minimal de A.

> with(linalg);
> a:=matrix(4,4,[1,1,0,2,-3,1,4,0,0,1,1,3,-1,0,1,1]);
> charpoly(a,x);
> minpoly(a,x);

Le polynôme caractéristique et le polynôme minimal de A sont égaux, valant



Attention: la commande {minpoly} est à utiliser avec prudence; par exemple, si on demande avec cette commande le polynôme minimal de , on obtiendra la réponse , le cas particulier où ayant été oublié.

Si on ne veut pas utiliser la commande {minpoly} (ou si l'examinateur n'autorise pas l'utilisation de cette commande), on sait que le polynôme minimal est est un diviseur du polynôme caractéristique et on fait vérifier par Maple que   et n'annulent pas A. La syntaxe Maple pour calculer et est, par exemple, la suivante:

> multiply(A^2,A-2);
> multiply(A,(A-2)^2);



Voici la syntaxe Maple pour obtenir le noyau de et de
> kernel(A^2);
> kernel((A-2)^2);

Maple retourne une liste de vecteurs formant une base du noyau.On obtient:
est un plan de base
est un plan de base

Il faut être prudent avec la commande {kernel}, lorsqu'il y a des paramètres (un peu comme avec {\rm minpoly})

Pour montrer que les deux sous-espaces vectoriels et sont supplémentaires, on pourrait montrer (avec Maple) que les 4 vecteurs précédemment déterminés forment une base, mais cette méthode est fortement déconseillée lorsque l'on connait le théorème de décomposition des noyaux.

Ici, et sont premiers entre eux. Donc, d'après le théorème de décomposition des noyaux:


Deuxième question

Il y a une commande Maple qui permet d'obtenir directement le résultat.
> jordan(A,P);evalm(P);

Maple renvoie une matrice de Jordan semblable à . Dans le cas présent, Maple renvoie la matrice  

Pour obtenir une matrice de passage, il suffit de demander l'évaluation de . Maple renvoie la matrice:


Cependant, je pense que l'examinateur n'acceptera pas l'utilisation de cette commande, et demandera un raisonnement. On devra donc chercher une base telle que

est donc un élément de qui n'appartient pas à .
De même, est un élément de qui n'appartient pas à .

Réalisation de l'idée en Maple:
> kernel(a);
                           {[1, -1, 1, 0]}
> e2:=vector(4,[1,0,0,1]);e1:=multiply(a,e2);
                          e2 := [1, 0, 0, 1]
                          e1 := [3, -3, 3, 0]
> kernel((a-2));
                            {[1, 1, 1, 0]}
> e4:=vector(4,[-1,0,0,1]);e3:=multiply(a-2,e4);
                         e4 := [-1, 0, 0, 1]
                         e3 := [3, 3, 3, 0]

Troisième question

Ici, je préfère ne pas me servir de Maple.

Pour , on écrit la division euclidienne de par :


est racine double de . Donc  .

En posant , on obtient

En dérivant et en posant , on obtient

Donc:  

Donc: