Dimensione e base di nucleo e immagine

Dimensione e base del nucleo

Si trova la matrice associata $A_F$ rispetto a $\beta_V$ e $\beta_W$ due basi scelte (vedi sezione "Matrice associata a una applicazione lineare")
si pone in colonna un vettore ${\textbf v}$ corrispondente alle coordinate della base ($x_1, x_2, .., x_n$) di $\beta_V$ (${\textbf v}_\beta$)
per la definizione di nucleo si considera $F({\textbf v}) = 0_W$ a cui si associa l'equazione matriciale $A_F \cdot {\textbf v}_\beta = 0_W$
di quest'ultima equazione si svolge il prodotto riga-colonna ottenendo il sistema lineare omogeneo
si cercano dimensione e base dell'insieme delle soluzioni del sistema (vedi sezione "Base dello spazio delle soluzioni di un sistema lineare omogeneo")
le soluzioni trovate ${s_1, s_2, .., s_k}$ costiuiscono i vettori coordinata rispetto alla base $\beta_V$
- se il dominio $V = \mathbb{R}^n$ e $\beta_V$ è base canonica allora le coordinate trovate coincidono con la base del nucleo (le coordinate di un vettore rispetto alla base canonica sono le componenti del vettore stesso)
- se il dominio $V \ne \mathbb{R}^n$ oppure $\beta_V$ non è base canonica si effettua in ordine la moltiplicazione di ciascun vettore trovato per i vettori di $\beta_V$ (preso $s_i$ un vettore delle soluzioni si effettua $s_{i1}{\textbf v}_1 + s_{i2}{\textbf v}_2 + .. + s_{in}{\textbf v}_n$
- i vettori risultanti costituiscono la base del nucleo

Dimensione e base dell'immagine

Si trova la matrice associata $A_F$ rispetto a $\beta_V$ e $\beta_W$ due basi scelte (come sopra) (vedi sezione "Matrice associata a una applicazione lineare")
Estrarre una base $\beta_C$ dalle colonne di $A_F$ (vedi sezione "Estrazione base da sistema generatori")
- se il codominio $W = \mathbb{R}^m$ e $\beta_W$ è base canonica allora $\beta_C$ è la base dell'immagine
- se il dominio $W != \mathbb{R}^m$ oppure $\beta_W$ non è base canonica si effettua in ordine la moltiplicazione di ciascun vettore di $\beta_C$ per i vettori di $\beta_W$ (preso $c_i$ un vettore delle soluzioni si effettua $c_{i1}{\textbf w}_1 + c_{i2}{\textbf w}_2 + .. + c_{im}{\textbf w}_m$
- i vettori risultanti costituiscono la base di $Im(F)$

Teorema delle dimensioni

Dato l'omomorfismo $F: V \to W$ $$dim(V) = dim(Ker(F)) + dim(Im(F))$$Che si può rigirare per ottenere, per esempio, la dimensione dell'immagine conoscendo quella del nucleo e del dominio. Nel caso di endomorfismo$dim(Im(F)) = dim(V)$.

Funzione riassumibile - Dimensione e base nucleo

def baseNucleo(b_v: sp.Matrix, b_w: sp.Matrix, definizione: sp.Expr = None, preimmagini: List = None, immagini: List = None, forma_bilineare : List[tuple] = None, incognite: List[sp.Symbol]=[], parametri_liberi: List[sp.Symbol]=None) -> sp.Matrix:

    """matrice associata rispetto alle basi"""
    matrice_associata = None
    if definizione is not None and forma_bilineare is not None:
        matrice_associata = matriceAssociataDiFormaBilineare(forma_bilineare, definizione, b_v)
    elif definizione is not None and forma_bilineare is None:
        matrice_associata = matriceAssociataDaFormaEsplicita(definizione, b_v, b_w, incognite)
    elif preimmagini is not None and immagini is not None:
        matrice_associata = matriceAssociataDaImmaginiVettori(preimmagini, immagini, b_v, b_w)
    else:
        raise Exception("Parametri errati per la funzione matriceCambiamentoBaseApplicazioneLineare")

    """vettore coordinate"""
    vettore_coordinate = sp.zeros(len(incognite), 1)
    for i in range(len(incognite)):
        vettore_coordinate[i, 0] = incognite[i]

    Ax = matrice_associata*vettore_coordinate

    """sistema lineare omogeneo"""
    sistema_lineare_omogeneo = []
    for row in range(Ax.shape[0]):
        sistema_lineare_omogeneo.append(list(Ax.row(row))[0])

    base_soluzioni = baseDaSpazioSoluzioniSistema(sistema_lineare_omogeneo, incognite, parametri_liberi)

    """moltiplicazione base soluzioni su vettori base"""
    base_nucleo = sp.zeros(0)
    for row in range(base_soluzioni.shape[0]):
        vettore_base_nucleo = sp.zeros(1, b_v.shape[1])

        for col in range(base_soluzioni.shape[1]):
            vettore_base_nucleo += base_soluzioni.row(row).col(col) * b_v.row(col)

        base_nucleo = base_nucleo.row_insert(row, vettore_base_nucleo)

    return base_nucleo

Esempio con applicazione lineare definita esplicitamente

x,y,z = sp.symbols("x y z")
definizione = [x+y+z,x+3*y,3*x+5*y+2*z]
b_v = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])
b_w = b_v

base_nucleo = baseNucleo(b_v, b_w, definizione=definizione, incognite=[x,y,z], parametri_liberi=[y])
print(sp.latex(base_nucleo))

$\left[\begin{matrix}-3 & 1 & 2\end{matrix}\right]$

Come da esercizio.

Esempio con applicazione lineare definita da immagini di vettori

x,y,z = sp.symbols("x y z")

b_v = sp.Matrix([[0,1,1],[2,0,0],[1,1,0]])
b_w = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])

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

base_nucleo = baseNucleo(b_v, b_w, preimmagini=preimmagini, immagini=immagini, incognite=[x,y,z], parametri_liberi=[y])
print(sp.latex(base_nucleo))

$\left[\begin{matrix}-4 & -4 & 2\end{matrix}\right]$

Come da esercizio.

Funzione riassumibile - Dimensione e base immagine

def baseImmagine(b_v: sp.Matrix, b_w: sp.Matrix, definizione: sp.Expr=None, preimmagini: List=None, immagini: List=None, incognite: List[sp.Symbol]=[]) -> sp.Matrix:

    """matrice associata rispetto alle basi"""
    matrice_associata = None
    if definizione is not None:
        matrice_associata = matriceAssociataDaFormaEsplicita(definizione, b_v, b_w, incognite)
    elif preimmagini is not None and immagini is not None:
        matrice_associata = matriceAssociataDaImmaginiVettori(preimmagini, immagini, b_v, b_w)
    else:
        raise Exception("Parametri errati per la funzione matriceCambiamentoBaseApplicazioneLineare")

    C = matrice_associata.T

    base_C = estrapolaLinearmenteIndipendenti(C)

    """moltiplicazione base C su vettori base"""
    base_immagine = sp.zeros(0)
    for row in range(base_C.shape[0]):
        vettore_base_nucleo = sp.zeros(1, b_w.shape[1])

        for col in range(base_C.shape[1]):
            vettore_base_nucleo += base_C.row(row).col(col) * b_w.row(col)

        base_immagine = base_immagine.row_insert(row, vettore_base_nucleo)

    return base_immagine

Esempio con applicazione lineare definita esplicitamente

x,y,z = sp.symbols("x y z")

b_v = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])
b_w = sp.Matrix([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]])

definizione = [y+z, 3*x+y, x+y+z, 2*z]

base_immagine = baseImmagine(b_v, b_w, definizione=definizione, incognite=[x,y,z])
print(sp.latex(base_immagine))

$\left[\begin{matrix}0 & 3 & 1 & 0\\1 & 1 & 1 & 0\\1 & 0 & 1 & 2\end{matrix}\right]$

Come da esercizio.

Esempio con applicazione lineare definita da immagini di vettori

x,y,z = sp.symbols("x y z")

b_v = sp.Matrix([[0,1,1],[2,0,0],[1,1,0]])
b_w = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])

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

base_immagine = baseImmagine(b_v, b_w, preimmagini=preimmagini, immagini=immagini, incognite=[x,y,z])
print(sp.latex(base_immagine))

Matrix([[5, 2, 3], [2, 2, 0]]) $\left[\begin{matrix}5 & 2 & 3\\2 & 2 & 0\end{matrix}\right]$

Riferimenti

https://www.youmath.it/lezioni/algebra-lineare/applicazioni-lineari/771-calcolare-dimensione-e-base-di-nucleo-e-immagine.html