Matrice diagonalizzabile

\(A\) (matrice quadrata) è diagonalizzabile se e solo se esiste una matrice invertibile \(P\) tale che \(D = P^{-1}AP\) (dove \(D\) è una matrice diagonale risultante), ossia \(PD = AP\) (matrice invertibile matrice diagonale = matrice in oggetto matrice invertibile). \(P\) è la matrice diagonalizzante di \(A\). \(A\) è diagonalizzabile se

• la somma delle molteplicità algebriche dei suoi autovalori è pari all'ordine della matrice
• la molteplicità geometrica di ogni autovalore coincide con la relativa molteplicità algebrica.

Se \(A\) è diagonalizzabile si può trovare \(D\) (matrice diagonale a cui è simile) e \(P\) (matrice diagonalizzante):

• \(D\): matrice diagonale i cui elmenti della diagonale sono gli autovalori di \(A\). Gli autovalori con \(m_a(\lambda)\) > 1 vanno ripetuti tante volte quanto è la loro molt. algebrica
• \(P\): ha come colonne i vettori che formano le basi degli autospazi relativi a ciascun autovalore (autovettori).

Funzione riassumibile

def matriceDiagonale(A):
    ordine_matrice = A.shape[0]

    Avals = autovaloriMolteplicita(A)

    somma_molt_algebriche = sum(Avals["molteplicitaAlgebriche"])

    """1) la somma delle molt algebriche deve essere pari all'ordine della matrice"""
    diagonalizzabile = [somma_molt_algebriche is ordine_matrice]

    """2) le molteplicita algebriche devono corrispondere alle rispettive geometriche"""
    for i, moltA in enumerate(Avals["molteplicitaAlgebriche"]):
        diagonalizzabile.append(moltA is Avals["molteplicitaGeometriche"][i])

    if all(diagonalizzabile):
        """Diagonalizzabile: ricerca matrice diagonalizzante P e diagonale D"""

        """Matrice diagonale"""
        valori_diagonali = []
        for i, autovalore in enumerate(Avals["autovalori"]):
            risp_molt_algebrica = Avals["molteplicitaAlgebriche"][i]
            for j in range(risp_molt_algebrica):
                valori_diagonali.append(autovalore)

        D = sp.eye(len(valori_diagonali))
        for i in range(len(valori_diagonali)):
            D[i, i] = valori_diagonali[i]

        """Matrice diagonalizzante"""
        P = sp.zeros(0)
        i = 0
        for base in Avals["basiAutospazi"]:
            for v in range(base.shape[0]):
                P = P.col_insert(i, base.row(v).T)
                i+=1

        D_check = (P**-1)*A*P
        print(D_check)

        return {
            "diagonalizzabile": True,
            "matriceDiagonale": D,
            "matriceDiagonaleCheck": D_check,
            "matriceDiagonalizzante": P
        }

    return {
        "diagonalizzabile": False
    }

Esempio

    A = sp.Matrix([[1,2,1], [0,2,0], [1,-2,1]])
    result = matriceDiagonale(A)
    pprint.pprint(result)

{'diagnoaliabile': True, 'matriceDiagonale': Matrix([ [2, 0, 0], [0, 2, 0], [0, 0, 0]]), 'matriceDiagonaleCheck': Matrix([ [2, 0, 0], [0, 2, 0], [0, 0, 0]]), 'matriceDiagonalizzante': Matrix([ [ 1, 0, 1], [1/2, -1/2, 0], [ 0, 1, -1]])}

Il risultato differisce dall'esercizio a causa di una scelta diversa dei parmetri liberi nella costruzione delle basi degli autospazi, tuttavia matriceDiagonaleCheck conferma il corretto risultato.

Riferimenti

• https://www.youmath.it/lezioni/algebra-lineare/matrici-e-vettori/1581-matrice-diagonalizzabile.html