Didattica & Progetti

Operazioni con Matrici

← Torna ad Algebra Lineare

Operazioni Matriciali: Teoria, Esempi e Implementazione
1. Somma e Sottrazione di Matrici
Definizione Date due matrici $A$ e $B$ della stessa dimensione $m \times n$, la loro somma (o differenza) è una matrice $C$ della stessa dimensione i cui elementi sono: $$C = A + B \quad \Rightarrow \quad c_{ij} = a_{ij} + b_{ij}$$ $$C = A - B \quad \Rightarrow \quad c_{ij} = a_{ij} - b_{ij}$$
Nota: La somma è definita solo per matrici con le stesse dimensioni.
Esempio Numerico
$$A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}, \quad B = \begin{bmatrix} 7 & 8 & 9 \\ 10 & 11 & 12 \end{bmatrix}$$
$$A + B = \begin{bmatrix} 1+7 & 2+8 & 3+9 \\ 4+10 & 5+11 & 6+12 \end{bmatrix} = \begin{bmatrix} 8 & 10 & 12 \\ 14 & 16 & 18 \end{bmatrix}$$
$$A - B = \begin{bmatrix} 1-7 & 2-8 & 3-9 \\ 4-10 & 5-11 & 6-12 \end{bmatrix} = \begin{bmatrix} -6 & -6 & -6 \\ -6 & -6 & -6 \end{bmatrix}$$
Codice Python 
import numpy as np

# Definizione delle matrici
A = np.array([[1, 2, 3],
              [4, 5, 6]])

B = np.array([[7, 8, 9],
              [10, 11, 12]])

# Somma di matrici
C_somma = A + B
print("A + B =")
print(C_somma)

# Sottrazione di matrici
C_diff = A - B
print("\nA - B =")
print(C_diff)

# Output:
# A + B =
# [[ 8 10 12]
#  [14 16 18]]
#
# A - B =
# [[-6 -6 -6]
#  [-6 -6 -6]]
2. Moltiplicazione per uno Scalare
Definizione Dato uno scalare $k \in \mathbb{R}$ e una matrice $A$ di dimensione $m \times n$, il prodotto $kA$ è una matrice della stessa dimensione i cui elementi sono: $$C = kA \quad \Rightarrow \quad c_{ij} = k \cdot a_{ij}$$
Ogni elemento della matrice viene moltiplicato per lo scalare $k$.
Esempio Numerico
$$A = \begin{bmatrix} 2 & -1 \\ 0 & 3 \\ 4 & -2 \end{bmatrix}, \quad k = 3$$
$$3A = \begin{bmatrix} 3 \cdot 2 & 3 \cdot (-1) \\ 3 \cdot 0 & 3 \cdot 3 \\ 3 \cdot 4 & 3 \cdot (-2) \end{bmatrix} = \begin{bmatrix} 6 & -3 \\ 0 & 9 \\ 12 & -6 \end{bmatrix}$$
Codice Python 
import numpy as np

# Definizione della matrice
A = np.array([[2, -1],
              [0, 3],
              [4, -2]])

# Scalare
k = 3

# Moltiplicazione per scalare
C = k * A
print(f"{k} * A =")
print(C)

# Output:
# 3 * A =
# [[ 6 -3]
#  [ 0  9]
#  [12 -6]]
3. Moltiplicazione tra Matrici (Prodotto Righe per Colonne)
Definizione Date due matrici $A$ di dimensione $m \times p$ e $B$ di dimensione $p \times n$, il loro prodotto $C = AB$ è una matrice di dimensione $m \times n$ dove: $$c_{ij} = \sum_{k=1}^{p} a_{ik} \cdot b_{kj}$$
L'elemento $c_{ij}$ è il prodotto scalare tra la riga $i$ di $A$ e la colonna $j$ di $B$.

Condizione necessaria: Il numero di colonne di $A$ deve essere uguale al numero di righe di $B$.

Nota importante: Il prodotto matriciale non è commutativo: in generale $AB \neq BA$.
Esempio Numerico
$$A = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix}_{2 \times 2}, \quad B = \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}_{2 \times 2}$$
Calcolo elemento per elemento:
$c_{11} = 1 \cdot 5 + 2 \cdot 7 = 5 + 14 = 19$
$c_{12} = 1 \cdot 6 + 2 \cdot 8 = 6 + 16 = 22$
$c_{21} = 3 \cdot 5 + 4 \cdot 7 = 15 + 28 = 43$
$c_{22} = 3 \cdot 6 + 4 \cdot 8 = 18 + 32 = 50$

$$AB = \begin{bmatrix} 19 & 22 \\ 43 & 50 \end{bmatrix}$$
Verifica non commutatività:
$BA = \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix} \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} = \begin{bmatrix} 23 & 34 \\ 31 & 46 \end{bmatrix} \neq AB$
Codice Python 
import numpy as np

# Definizione delle matrici
A = np.array([[1, 2],
              [3, 4]])

B = np.array([[5, 6],
              [7, 8]])

# Prodotto matriciale usando @
C = A @ B
print("A @ B =")
print(C)

# Alternativa: usando np.dot()
C_dot = np.dot(A, B)
print("\nnp.dot(A, B) =")
print(C_dot)

# Verifica non commutatività
BA = B @ A
print("\nB @ A =")
print(BA)
print("\nAB == BA?", np.array_equal(C, BA))

# Output:
# A @ B =
# [[19 22]
#  [43 50]]
#
# np.dot(A, B) =
# [[19 22]
#  [43 50]]
#
# B @ A =
# [[23 34]
#  [31 46]]
#
# AB == BA? False
Esempio con Dimensioni Diverse
$$A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}_{2 \times 3}, \quad B = \begin{bmatrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{bmatrix}_{3 \times 2}$$
$c_{11} = 1 \cdot 1 + 2 \cdot 3 + 3 \cdot 5 = 1 + 6 + 15 = 22$
$c_{12} = 1 \cdot 2 + 2 \cdot 4 + 3 \cdot 6 = 2 + 8 + 18 = 28$
$c_{21} = 4 \cdot 1 + 5 \cdot 3 + 6 \cdot 5 = 4 + 15 + 30 = 49$
$c_{22} = 4 \cdot 2 + 5 \cdot 4 + 6 \cdot 6 = 8 + 20 + 36 = 64$

$$AB = \begin{bmatrix} 22 & 28 \\ 49 & 64 \end{bmatrix}_{2 \times 2}$$ 
import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6]])  # 2x3

B = np.array([[1, 2],
              [3, 4],
              [5, 6]])     # 3x2

C = A @ B  # Risultato: 2x2
print("A (2x3) @ B (3x2) =")
print(C)
print(f"Dimensione risultato: {C.shape}")

# Output:
# A (2x3) @ B (3x2) =
# [[22 28]
#  [49 64]]
# Dimensione risultato: (2, 2)
4. Trasposizione di Matrici
Definizione La trasposta di una matrice $A$ di dimensione $m \times n$, indicata con $A^T$, è la matrice di dimensione $n \times m$ ottenuta scambiando righe e colonne: $$(A^T)_{ij} = a_{ji}$$
La riga $i$ di $A$ diventa la colonna $i$ di $A^T$.

Proprietà:
  • $(A^T)^T = A$
  • $(A + B)^T = A^T + B^T$
  • $(kA)^T = kA^T$
  • $(AB)^T = B^T A^T$ (inversione dell'ordine!)
Esempio Numerico
$$A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}_{2 \times 3}$$
$$A^T = \begin{bmatrix} 1 & 4 \\ 2 & 5 \\ 3 & 6 \end{bmatrix}_{3 \times 2}$$

La prima riga di $A$ (1, 2, 3) diventa la prima colonna di $A^T$.
La seconda riga di $A$ (4, 5, 6) diventa la seconda colonna di $A^T$.
Codice Python 
import numpy as np

# Definizione della matrice
A = np.array([[1, 2, 3],
              [4, 5, 6]])

# Trasposizione
A_T = A.T
print("A =")
print(A)
print(f"Dimensione A: {A.shape}")

print("\nA^T =")
print(A_T)
print(f"Dimensione A^T: {A_T.shape}")

# Verifica proprietà: (A^T)^T = A
A_T_T = A_T.T
print("\n(A^T)^T =")
print(A_T_T)
print("(A^T)^T == A?", np.array_equal(A_T_T, A))

# Output:
# A =
# [[1 2 3]
#  [4 5 6]]
# Dimensione A: (2, 3)
#
# A^T =
# [[1 4]
#  [2 5]
#  [3 6]]
# Dimensione A^T: (3, 2)
#
# (A^T)^T =
# [[1 2 3]
#  [4 5 6]]
# (A^T)^T == A? True
5. Matrice Inversa
Definizione Data una matrice quadrata $A$ di ordine $n$, se esiste una matrice $A^{-1}$ tale che: $$A \cdot A^{-1} = A^{-1} \cdot A = I_n$$ allora $A^{-1}$ si chiama matrice inversa di $A$.

Condizione di invertibilità: Una matrice quadrata $A$ è invertibile se e solo se $\det(A) \neq 0$.

Proprietà:
  • $(A^{-1})^{-1} = A$
  • $(AB)^{-1} = B^{-1}A^{-1}$ (inversione dell'ordine)
  • $(A^T)^{-1} = (A^{-1})^T$
  • $\det(A^{-1}) = \frac{1}{\det(A)}$
Formula per Matrici $2 \times 2$ Per una matrice $2 \times 2$: $$A = \begin{bmatrix} a & b \\ c & d \end{bmatrix}$$
Se $\det(A) = ad - bc \neq 0$, allora: $$A^{-1} = \frac{1}{ad - bc} \begin{bmatrix} d & -b \\ -c & a \end{bmatrix}$$

Esempio: $$A = \begin{bmatrix} 4 & 7 \\ 2 & 6 \end{bmatrix}$$
$\det(A) = 4 \cdot 6 - 7 \cdot 2 = 24 - 14 = 10 \neq 0$ → $A$ è invertibile

$$A^{-1} = \frac{1}{10} \begin{bmatrix} 6 & -7 \\ -2 & 4 \end{bmatrix} = \begin{bmatrix} 0.6 & -0.7 \\ -0.2 & 0.4 \end{bmatrix}$$
Verifica: $$A \cdot A^{-1} = \begin{bmatrix} 4 & 7 \\ 2 & 6 \end{bmatrix} \begin{bmatrix} 0.6 & -0.7 \\ -0.2 & 0.4 \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} = I_2$$
Codice Python 
import numpy as np

# Definizione della matrice
A = np.array([[4, 7],
              [2, 6]])

# Calcolo del determinante
det_A = np.linalg.det(A)
print(f"det(A) = {det_A}")

# Verifica che la matrice sia invertibile
if det_A != 0:
    # Calcolo dell'inversa
    A_inv = np.linalg.inv(A)
    print("\nA^(-1) =")
    print(A_inv)

    # Verifica: A * A^(-1) = I
    I = A @ A_inv
    print("\nA @ A^(-1) =")
    print(I)

    # Verifica con np.allclose (per gestire errori numerici)
    I_attesa = np.eye(2)
    print("\nÈ l'identità?", np.allclose(I, I_attesa))
else:
    print("La matrice non è invertibile (determinante nullo)")

# Output:
# det(A) = 10.000000000000002
#
# A^(-1) =
# [[ 0.6 -0.7]
#  [-0.2  0.4]]
#
# A @ A^(-1) =
# [[1. 0.]
#  [0. 1.]]
#
# È l'identità? True
Esempio con Matrice Non Invertibile
$$B = \begin{bmatrix} 2 & 4 \\ 1 & 2 \end{bmatrix}$$
$\det(B) = 2 \cdot 2 - 4 \cdot 1 = 4 - 4 = 0$

La matrice $B$ non è invertibile (è singolare). 
import numpy as np

B = np.array([[2, 4],
              [1, 2]])

det_B = np.linalg.det(B)
print(f"det(B) = {det_B}")

try:
    B_inv = np.linalg.inv(B)
    print("\nB^(-1) =")
    print(B_inv)
except np.linalg.LinAlgError:
    print("\nErrore: la matrice è singolare (non invertibile)")

# Output:
# det(B) = 0.0
# Errore: la matrice è singolare (non invertibile)
6. Proprietà Generali delle Operazioni Matriciali
Proprietà Algebriche Somma:
  • Commutativa: $A + B = B + A$
  • Associativa: $(A + B) + C = A + (B + C)$
  • Elemento neutro: $A + O = A$ (dove $O$ è la matrice nulla)

Prodotto:
  • Non commutativa: in generale $AB \neq BA$
  • Associativa: $(AB)C = A(BC)$
  • Distributiva rispetto alla somma: $A(B + C) = AB + AC$
  • Elemento neutro: $AI = IA = A$ (dove $I$ è la matrice identità)
Note Computazionali Complessità computazionale:
  • Somma di matrici $n \times n$: $O(n^2)$
  • Prodotto di matrici $n \times n$ (algoritmo standard): $O(n^3)$
  • Inversa di una matrice $n \times n$: $O(n^3)$

Precisione numerica: Quando si lavora con numeri in virgola mobile, usare np.allclose() invece di == per confrontare matrici, per tenere conto degli errori di arrotondamento.