Déterminant de matrice et diagonalisation

Bonjour à tous,

N’étant pas connu de ce coté du forum je me présente : je prépare l’agrégation de science physiques à laquelle est intégrée la programmation en python. J’aimerais du coups résoudre deux/trois problèmes que j’ai avec python avec votre aide concernant les mathématiques. Je vous préviens je ne suis pas fortiche-fortiche pour comprendre les documentations en autonomie… donc il se peut que je sois limité par les recherches que j’ai effectuées jusqu’à présent.

Je cherche à résoudre/diagonaliser des matrices (dans le cadre de l’application de la méthode de Huckel @Pierre_24), notamment trouver leur déterminant et leurs valeurs propres; De part ma recherche j’ai trouvé les fonctions suivantes (de la bibliothèque : py numpy) :

np.det(p)
np.eigvals(p)

Une fonction qui permet de connaitre le déterminant d’une matrice mais uniquement une matrice faites de chiffre et enfin une fonction qui permet d’obtenir les valeurs propres de cette dernière. Or mes matrices comportes des $x$, des $1$ et $0$. C’est le premier qui m’embête car les logiciels n’aiment pas ça et ne sont pas fait pour intégrer des inconnues à leurs calculs.

Le site que j’utilisais avant cela était :le suivant. Il permet de calculer le determinant d’une matrice dont voici un exemple :

$\hat{H} = \begin{pmatrix} x & 1 & 0 \\ 1 & x & 1 \\ 0 & 1 & x \end{pmatrix}$

Malheureusement cette problématique est cruciale dans la méthode de calcul que j’essaye d’exploiter car à la fin j’obtiens un polynome que je peux rentrer sois dans wolfram (trouver une suite en python qui fasse ça serait parfait aussi) et qui résout automatiquement le polynome…

C’est comme ça que je faisais sans l’emploi de python. Mais je ne suis pas sûr que ce soit faisable via une fonction toute prête de numpy(?). Est-ce que quelqu’un a déjà été confronté à ça ? Est-il facile de résoudre manuellement la diagonalisation de la matrice sans utiliser de fonction toute faite ?

J’éditerais surement ce post s’il n’est pas assez clair ou bien formulé… Merci pour votre lecture.

Merci Pierre_24 , ça semble être exactement l’outils dont j’ai besoin ! De toute façon tu dois avoir déjà fais ce que je suis en train de mettre au point lol.

Après quelques essaies erreur, c’était pas évident j’en suis là :

Script A

import sympy 
x = sympy.symbols('x') 

M = sympy.Matrix([[x,1,0,0,0,0,0,0,0,1], 
                  [1,x,1,0,0,0,0,0,0,0],
                  [0,1,x,1,0,0,0,0,0,0],
                  [0,0,1,x,1,0,0,0,0,1],
                  [0,0,0,1,x,1,0,0,0,0],
                  [0,0,0,0,1,x,1,0,0,0],
                  [0,0,0,0,0,1,x,1,0,0],
                  [0,0,0,0,0,0,1,x,1,0],
                  [0,0,0,0,0,0,0,1,x,1],
                  [1,0,0,1,0,0,0,0,1,x],]);

print('Polynôme caractéristique : ' + str(sympy.det(M)) + ' = 0')
print(sympy.solveset(sympy.det(M), x))

Bon c’est une sacrée matrice que j’essaye de diagonaliser, c’est pour ça que je préfère la présenter cette matrice de Hückel avec Python !

Alors voici les problèmes que j’ai :

• Les deux lignes suivantes ne fonctionnent pas avec ma matrice :

print('Valeurs propres de la matrice : ' + str(M.eigenvals()) + ' ...')
print('Vecteurs propres de la matrice : ' + str(M.eigenvects()) + '...')

Pourtant quand la nature de M était plus sobre ça avait fonctionné :

Script B

import sympy 
x = sympy.symbols('x') 

M = sympy.Matrix([[x,1,0],[1,x,1],[0,1,x]])

print('Polynôme caractéristique : ' + str(sympy.det(M)) + ' = 0')
print('Valeurs propres de la matrice : ' + str(M.eigenvals()) + ' ...')
print('Vecteurs propres de la matrice : ' + str(M.eigenvects()) + '...')

Cela me retourne effectivement les informations que j’attend :

Trace B

Polynôme caractéristique : x**3 - 2*x = 0
Valeurs propres de la matrice : {x: 1, x - sqrt(2): 1, x + sqrt(2): 1} ...
Vecteurs propres de la matrice : [(x, 1, [Matrix([
[-1],
[ 0],
[ 1]])]), (x - sqrt(2), 1, [Matrix([
[       1],
[-sqrt(2)],
[       1]])]), (x + sqrt(2), 1, [Matrix([
[      1],
[sqrt(2)],
[      1]])])]...

Donc j’imagine que c’est ma matrice qui est trop colossale. Du coups j’me suis tourné vers sympy.solveset() qui semble pouvoir faire le travail de valeurs propres, du moment qu’on a déjà obtenue le polynome caractéristique (ce qu’on obtient à l’aide de sympy.det()). Et pourtant ce que me retourne le script pour la big matrice de $10 \times 10$ c’est pas trop compréhensible :

Trace A

Polynôme caractéristique : 
x**10 - 11*x**8 + 41*x**6 + 2*x**5 - 61*x**4 - 6*x**3 + 31*x**2 + 2*x - 4 = 0
FiniteSet(
CRootOf(x**4 - x**3 - 3*x**2 + x + 1, 0), 
CRootOf(x**4 - x**3 - 3*x**2 + x + 1, 1), 
CRootOf(x**4 - x**3 - 3*x**2 + x + 1, 2), 
CRootOf(x**4 - x**3 - 3*x**2 + x + 1, 3), 
CRootOf(x**6 + x**5 - 7*x**4 - 5*x**3 + 13*x**2 + 6*x - 4, 0), 
CRootOf(x**6 + x**5 - 7*x**4 - 5*x**3 + 13*x**2 + 6*x - 4, 1), 
CRootOf(x**6 + x**5 - 7*x**4 - 5*x**3 + 13*x**2 + 6*x - 4, 2), 
CRootOf(x**6 + x**5 - 7*x**4 - 5*x**3 + 13*x**2 + 6*x - 4, 3), 
CRootOf(x**6 + x**5 - 7*x**4 - 5*x**3 + 13*x**2 + 6*x - 4, 4), 
CRootOf(x**6 + x**5 - 7*x**4 - 5*x**3 + 13*x**2 + 6*x - 4, 5))

J’ai du mal à savoir ce que cette trace signifie… Tu as déjà eu l’occasion @Pierre_24, d’utiliser ces fonctions j’imagine ?

Je pense que Sagemath est plus indiqué. En calcul formel c’est très complet

Donc je passe l’agrégation, et mes scripts ne doivent emprunter que les bibliothèques déjà contenues dans Spyder (Anaconda) d’après ce que j’ai compris. Malheureusement SageMath n’a pas l’air d’en faire partie.

Si ça peut aider
Tridiagonal matrices

C’est très interessant ! ça donne à reflechir sur la formule de Coulson utilisé par la méthode de Hückel. J’ai l’impression de voir un lien entre :

Formule de Coulson

Toeplitz

Selon ta source

Mais si tu regarde attentivement, je ne me limite pas aux matrices tridiagonales. Regarde attentivement ma matrice $10\times 10$ que j’ai mis dans mon SCRIPT A.

Edit :

C’est littéralement la même formule… C’est dingue que l’on appelle ça la formule de Coulson…

donc d’après la source : $b = c = \beta$ ainsi :

Impressionnant…

Indeed.
Tu ne peux pas essayer de trouver une formule pour tes matrices, en développant par rapport aux bonnes lignes/colonnes ?
J’avoue que ça fait longtemps que j’ai pas fait ça à la main, mais tes matrices sont tellement creuses que tu devrais pouvoir trouver quelque chose.

La seule chose que je sais faire à la main à partir d’un determinant de matrice $10 \times 10$ c’est trouver 3 determinants de tailles $9 \times 9$ pour ensuite trouver par chacuns des determinants de matrices $9 \times 9$ respectivement 3 matrices $8 \times 8$ etc.

C’est pour ça que je demande à utiliser un programme

Pour du numérique, je te conseillerais ça : interval Newton
Un peu plus lente (forcément) que la version standard, mais elle te permet de borner toutes les racines avec une précision arbitraire. Si tu as besoin d’un coup de main ou d’un code, n’hésite pas.