Matrice di cambiamento di base

\(M_{\beta \to \beta'}\). In caso la base di destinazione \(\beta'\) sia la base canonica (es. in \(\mathbb{R}^3\) è \((1,0,0)(0,1,0)(0,0,1)\)) si scrivono in colonna i vettori della base di partenza \(\beta\).

Altrimenti si pongono i vettori della base \(\beta\) come combinazione lineare dei vettori della base \(\beta'\), si risolvono poi le combinazioni in un sistema lineare (come avviene per trovare le coordinate rispetto a base, vedi sezione "Coordinate rispetto a una base"). Avremo un sistema lineare per ogni vettore di \(\beta\). Si pongono in colonna le soluzioni dei sistemi lineari (in quanto queste soluzioni sono le coordinate del vettore rispetto alla base \(\beta'\)) e si ottiene la matrice di cambiamento di base \(M_{\beta \to \beta'}\).

Esempio con base canonica

In \(\mathbb{R}^2\) trovare la matrice di cambiamento da \(\beta = \{(1,2),(3,4)\}\) a \(\beta'=\{(1,0),(0,1)\}\) la base canonica di \(\mathbb{R}^2\). Il risultato dovrebbe essere \(M_{\beta \to \beta'} = \begin{bmatrix}1&3\\2&4\end{bmatrix}\).

E' stato sufficiente mettere in colonna i vettori di \(\beta\).

Esempio con base diversa da quella canonica

In \(\mathbb{R}^3\) trovare la \(M_{\beta \to \beta'}\) da:

\(\beta = \{(0,2,0), (1,1,0), (0,1,1)\}\)

\(\beta' = \{(1,0,2), (2,3,0), (0,4,4)\}\)

Soluzione finale: \(\begin{bmatrix}-\frac{3}{2}&\frac{1}{2}&0\\1&2&0\\2&0&4\end{bmatrix}\)

import sympy as sp
import numpy as np
a1,a2,a3,b1,b2,b3,c1,c2,c3 = sp.symbols('a1 a2 a3 b1 b2 b3 c1 c2 c3')
linearComb1,linearComb2,linearComb3 = sp.symbols('linearComb1 linearComb2 linearComb3')
# le due basi
beta = sp.Matrix([[0,2,0],[1,1,0],[0,1,1]])
beta1 = sp.Matrix([[1,0,2],[2,3,0],[0,4,4]])

# combinazioni lineari per le rispettive basi
linearComb1 = a1*beta.row(0) + b1*beta.row(1) + c1*beta.row(2)
linearComb2 = a2*beta.row(0) + b2*beta.row(1) + c2*beta.row(2)
linearComb3 = a3*beta.row(0) + b3*beta.row(1) + c3*beta.row(2)

# primo sistema
primo_sistema = [
    linearComb1[0] - beta1[0, 0],
    linearComb1[1] - beta1[0, 1],
    linearComb1[2] - beta1[0, 2],
]

sol = sp.solve(primo_sistema)

print(sol)

{a1: -3/2, b1: 1, c1: 2}

La prima colonna della matrice di cambiamento è \(\begin{bmatrix}-\frac{3}{2}&1&2\end{bmatrix}\).

Si fa la stessa cosa per gli altri componenti di \(\beta'\):

secondo_sistema = [
    linearComb2[0] - beta1[1, 0],
    linearComb2[1] - beta1[1, 1],
    linearComb2[2] - beta1[1, 2],
]

terzo_sistema = [
    linearComb3[0] - beta1[2, 0],
    linearComb3[1] - beta1[2, 1],
    linearComb3[2] - beta1[2, 2],
]

print(sp.solve(secondo_sistema))
print(sp.solve(terzo_sistema))

{a2: 1/2, b2: 2, c2: 0} {a3: 0, b3: 0, c3: 4}

Quindi le altre due colonne sono:\(\begin{bmatrix}\frac{1}{2}&2&0\end{bmatrix}\) e \(\begin{bmatrix}0&0&4\end{bmatrix}\)

Formando la matrice di soluzione iniziale, esattamente come nell'esercizio YouMath.

Funzione riassumibile

Funzione riassumibile per il cambiamento di base

def matriceCambiamentoBase(beta, beta1):

    def incognita(j,i):
        return "_"+str(i)+"_"+str(j)

    size = sp.shape(beta)[0]

    incognite = {}

    """Definizione incognite"""
    for i in range(size):
        incognite["linearComb"+str(i)] = sp.symbols("linearComb"+str(i))

        for j in range(size):
            incognite[incognita(i,j)] = sp.symbols(incognita(i,j))

    """Combinazioni lineari delle coordinate di beta' su beta"""
    for i in range(size):
        combinazione_lineare = incognite[incognita(i,0)] * beta.row(0)

        for j in range(size-1):
            k = j+1
            combinazione_lineare += incognite[incognita(i,k)] * beta.row(k)

        incognite["linearComb"+str(i)] = combinazione_lineare

    matrice_cambiamento = sp.zeros(size, size)

    """sistemi"""
    for i in reversed(range(size)):
        sistema = []

        for j in range(size):
            sistema.append(incognite["linearComb"+str(i)][j] - beta1[i, j])

        sol = sp.solve(sistema)

        # Aggiunta della soluzione in colonna nella matrice di cambiamento
        for s in range(size):
            matrice_cambiamento[s,i] = sol[incognite[incognita(i,s)]]

    print(matrice_cambiamento)

    return matrice_cambiamento

Esempio della funzione riassumibile in spazio polinomiale

In YouMath è richiesto di trovare la matrice di cambiamento di base da \(\beta=\{2,-3+x,7-5x+x^2\}\) a \(\beta'=\{1,x,x^2\}\) (base canonica). Il risultato deve essere: \(\begin{bmatrix} 2&-3&7\\0&1&5\\0&0&1\end{bmatrix}\)

Proviamo la funzione da me creata. Guardare come converto il polinomio (incluso quello canonico) in un espressione sp.Matrix()

beta = sp.Matrix([[2,0,0],[-3, 1, 0],[7,-5*1,1**2]])
beta1 = sp.Matrix([[1,0,0],[0,1,0],[0,0,1]])
matrice = matriceCambiamentoBase(beta, beta1)

Matrix([[2, -3, 7], [0, 1, -5], [0, 0, 1]])

Esattamente come nella soluzione.

Riferimenti

• https://www.youmath.it/lezioni/algebra-lineare/matrici-e-vettori/710-matrice-di-passaggio.html