Matrice associata ad applicazione lineare

Data l'applicazione lineare \(F: V \to-> W\) e le rispettive basi degli spazi vettoriali \(\beta_V\) e \(\beta_W\). Si indica con:

\(A_F^{\beta_V,\beta_W}\)

Per costruire la matrice associta all'applicazione lineare:

• determinare l'immagine rispetto all'applicazione \(F\) di ogni vettore della base \(\beta_V\): \(F({ v}_1), F({ v}v_1), F(v_2), .., F({ v}v_n)\)
• i vettori ottenuti dalle immagini dei vett della base sono elementi di \(W\) e dunque sono esprimbili come combinazione lineare dei vettori della base \(\beta_W\): \(F({ v}v_n) = \sum_{m=1} a_{nm} { w}w_m\)
• la matrice associata all'app. lineare (rispetto alle basi) si ottiene mettendo in colonna le coordinate dei vettori della combinazione lineare soprindicata: \(A_F^{\beta_V,\beta_W} =\) \(\begin{bmatrix}a_{11} & a_{12} & .. & a_{1n} \\ a_{21} & a_{22} & .. & a_{2n} \\ ... & ... & ... & ... \\ a_{m1} & a_{m2} & .. & a_{mn}\end{bmatrix} \in a K^{m,n}\)

Se si prendono in considerazione le basi canoniche è sufficiente disporre in colonna le immagini risultanti dell'applicazione lineare.

Funzione riassumibile della matrice associata a un'applicazione lineare definita in forma esplicita

def matriceAssociataDaFormaEsplicita(definizione, base_dominio, base_codominio, incognite):
    matrice_associata = sp.zeros(base_codominio.shape[0], base_dominio.shape[0])

    """Calcolo mediante F dei vettori della base del dominio"""
    vettori_dominio = []
    for i in range(base_dominio.shape[0]):
        vettore_dominio = sp.zeros(1, base_codominio.shape[0])
        for j in range(base_codominio.shape[0]):
            f = definizione[j]
            for k,inc in enumerate(incognite):
                f = f.subs(inc, base_dominio[i, k])
            vettore_dominio[0,j] = f
        vettori_dominio.append(vettore_dominio)

    """Combinazione lineare dei vettori ottenuti rispetto alla base del codominio"""
    for i,vettore_dominio in enumerate(vettori_dominio):
        scalari = []
        combinazione_lineare = sp.zeros(1, base_codominio.shape[1])
        for j in range(base_codominio.shape[1]):
            alpha = sp.symbols("a" + str(i) + "_" + str(j))
            scalari.append(alpha)
            combinazione_lineare += (base_codominio.row(j)*alpha)
        combinazione_lineare -= vettore_dominio

        valori_scalari = sp.solve(combinazione_lineare, scalari)
        for j,val in enumerate(valori_scalari.values()):
            matrice_associata[j, i] = val

    return matrice_associata

Esempio

base_dominio = sp.Matrix([[1,0,1],[1,0,0],[1,1,1]])
base_codominio = sp.Matrix([[0,1], [1,1]])

x,y,z = sp.symbols("x y z")
definizione = sp.Matrix([[x + y],[z]])

A = matriceAssociataDaFormaEsplicita(definizione, base_dominio, base_codominio, [x,y,z])
print(A)

Matrix([[0, -1, -1], [1, 1, 2]])

Come da esercizio.

Esempio (rispetto a basi canoniche)

base_dominio = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])
base_codominio = sp.Matrix([[1,0], [0,1]])

x,y,z = sp.symbols("x y z")
definizione = sp.Matrix([[x + y],[z]])

A = matriceAssociataDaFormaEsplicita(definizione, base_dominio, base_codominio, [x,y,z])
print(A)

Matrix([[1, 1, 0], [0, 0, 1]])

Come da esercizio.

Funzione riassumibile della matrice associata a un'applicazione lineare definita da immagini di vettori

def matriceAssociataDaImmaginiVettori(preimmagini, immagini, base_dominio, base_codominio):
    matrice_associata = sp.zeros(base_codominio.shape[0], base_dominio.shape[0])

    """combinazioni preimmagini"""
    combinazioni_preimmagini = []
    for i in range(base_dominio.shape[0]):
        scalari = []
        combinazione_lineare = sp.zeros(1, base_dominio.shape[1])
        for j in range(len(preimmagini)):
            alpha = sp.symbols("a" + str(i) + "_" + str(j))
            scalari.append(alpha)
            combinazione_lineare += (preimmagini[j]*alpha)
        combinazione_lineare -= base_dominio.row(i)

        valori_scalari = sp.solve(combinazione_lineare, scalari)
        combinazioni_preimmagini.append(list(valori_scalari.values()))

    """combinazioni immagini"""
    combinazioni_immagini = []
    for i in range(base_dominio.shape[0]):
        combinazione_lineare = sp.zeros(1, base_codominio.shape[1])
        for j in range(len(immagini)):
            combinazione_lineare += (immagini[j]*combinazioni_preimmagini[i][j])

        combinazioni_immagini.append(combinazione_lineare)

    """combinazioni base arrivo"""
    for i,combinazione_immagine in enumerate(combinazioni_immagini):
        scalari = []
        combinazione_lineare = sp.zeros(1, base_codominio.shape[1])
        for j in range(base_codominio.shape[0]):
            a = sp.symbols("a" + "_" + str(j))
            scalari.append(a)
            combinazione_lineare += (base_codominio.row(j)*a)
        combinazione_lineare -= combinazione_immagine

        valori_scalari = sp.solve(combinazione_lineare, scalari)

        for j,val in enumerate(valori_scalari.values()):
            matrice_associata[j, i] = val

    return matrice_associata

Esempio

base_dominio = sp.Matrix([[1,0],[0,1]])
base_codominio = sp.Matrix([[1,1,1],[1,0,0],[0,-1,1]])

preimmagini = [sp.Matrix([[1,1]]), sp.Matrix([[2,1]])]
immagini = [sp.Matrix([[1,2,0]]), sp.Matrix([[-1,3,1]])]

A = matriceAssociataDaImmaginiVettori(preimmagini, immagini, base_dominio, base_codominio)
print(A)

Matrix([[1, 0], [-3, 3], [0, -1]])

Esempio (rispetto a basi canoniche)

base_dominio = sp.Matrix([[1,0],[0,1]])
base_codominio = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])

preimmagini = [sp.Matrix([[1,1]]), sp.Matrix([[2,1]])]
immagini = [sp.Matrix([[1,2,0]]), sp.Matrix([[-1,3,1]])]

A = matriceAssociataDaImmaginiVettori(preimmagini, immagini, base_dominio, base_codominio)
print(A)

Matrix([[-2, 3], [1, 1], [1, -1]])

Come da esercizio.

Riferimenti

• https://www.youmath.it/lezioni/algebra-lineare/applicazioni-lineari/536-come-trovare-la-matrice-rappresentativa-applicazioni-lineari.html