Autovalori e autovettori
Calcoli le decomposizioni agli autovalori con eigen() e interpreti i risultati
Autovalori e autovettori è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.
Che cosa sono gli autovalori?
Un autovettore v della matrice A è un vettore non nullo che, quando viene moltiplicato per A, cambia solo scala (non direzione): Av = λv. Lo scalare λ è l'autovalore. Gli autovalori e gli autovettori rivelano le direzioni intrinseche di dilatazione di una matrice.
# Intuition: A simple scaling matrix
A <- matrix(c(3, 0,
0, 2), nrow = 2, byrow = TRUE)
# The eigenvectors are the standard basis vectors
# A * c(1,0) = 3 * c(1,0) -> eigenvalue 3
# A * c(0,1) = 2 * c(0,1) -> eigenvalue 2
v1 <- c(1, 0)
A %*% v1 # c(3, 0) = 3 * v1
v2 <- c(0, 1)
A %*% v2 # c(0, 2) = 2 * v2
cat('Eigenvalues of a diagonal matrix are its diagonal entries')eigen(): calcolo degli autovalori
eigen(A) restituisce una lista con $values (gli autovalori ordinati per modulo decrescente) e $vectors (la matrice degli autovettori disposti per colonne). Gli autovettori sono normalizzati a norma unitaria.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
# Compute eigendecomposition
eig <- eigen(A)
# Eigenvalues
eig$values
# [1] 5 2 (descending order)
# Eigenvectors (columns)
eig$vectors
# [,1] [,2]
# [1,] 0.7071068 -0.4472136
# [2,] 0.7071068 0.8944272
cat('Each column is one eigenvector (unit length)')Verifica di Av = lambda * v
Per verificare il risultato, controlli che A %*% v - lambda * v sia essenzialmente zero. A causa dell'aritmetica in virgola mobile, utilizzi max(abs(...)) e verifichi che il valore sia vicino all'epsilon di macchina, invece di testare l'uguaglianza esatta.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
eig <- eigen(A)
lambda1 <- eig$values[1] # 5
v1 <- eig$vectors[, 1]
# Verify: Av - lambda*v should be ~0
residual <- A %*% v1 - lambda1 * v1
max(abs(residual)) # ~ 1e-16
# Check all eigenpairs at once
# A V = V diag(lambda) where V = eigenvectors matrix
V <- eig$vectors
Lambda <- diag(eig$values)
err <- A %*% V - V %*% Lambda
max(abs(err)) # near zeroMatrici simmetriche: autovalori reali
Le matrici simmetriche (A = t(A)) hanno sempre autovalori reali e autovettori ortogonali. Questo è il teorema spettrale, fondamentale in statistica (le matrici di covarianza sono simmetriche semidefinite positive).
# Symmetric matrix
S <- matrix(c(4, 2, 2,
2, 3, 1,
2, 1, 5), nrow = 3, byrow = TRUE)
# All symmetric: A = t(A)
all.equal(S, t(S)) # TRUE
# Eigenvalues are real
eig <- eigen(S)
eig$values # All real numbers
Im(eig$values) # All zero
# Eigenvectors are orthogonal: V'V = I
V <- eig$vectors
round(t(V) %*% V, 10) # Identity matrix
cat('Symmetric -> real eigenvalues, orthogonal eigenvectors')Matrici asimmetriche: autovalori complessi
Le matrici non simmetriche possono avere autovalori complessi (in coppie di coniugati complessi). R li restituisce come numeri complessi. La parte reale determina la crescita o il decadimento; la parte immaginaria determina la rotazione o l'oscillazione.
# Rotation-like matrix -> complex eigenvalues
A <- matrix(c(0, -1,
1, 0), nrow = 2, byrow = TRUE)
# This is a 90-degree rotation matrix
eig <- eigen(A)
eig$values
# [1] 0+1i 0-1i (pure imaginary!)
# Real part: zero -> neither grows nor decays
Re(eig$values) # 0 0
# Imaginary part: indicates rotation
Im(eig$values) # 1 -1
# Another example: stable spiral
B <- matrix(c(-1, -2,
2, -1), nrow = 2, byrow = TRUE)
eigen(B)$values # -1 +/- 2iDecomposizione agli autovalori A = VLV^-1
Una matrice diagonalizzabile A può essere scritta come A = V Λ V⁻¹, dove V è la matrice degli autovettori e Λ = diag(autovalori). Questa decomposizione consente di calcolare le potenze della matrice: A^n = V Λ^n V⁻¹.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
eig <- eigen(A)
V <- eig$vectors
Lambda <- diag(eig$values)
# Reconstruct A = V %*% Lambda %*% solve(V)
A_reconstructed <- V %*% Lambda %*% solve(V)
all.equal(A, A_reconstructed) # TRUE
# Matrix power A^3 using eigendecomposition
A_cubed_eig <- V %*% diag(eig$values^3) %*% solve(V)
A_cubed_direct <- A %*% A %*% A
all.equal(Re(A_cubed_eig), A_cubed_direct) # TRUEIl concetto di PCA tramite gli autovalori della covarianza
L'Analisi delle Componenti Principali (PCA) utilizza la decomposizione agli autovalori della matrice di covarianza. Gli autovettori indicano le direzioni di massima varianza (le componenti principali); gli autovalori indicano la varianza lungo ciascuna direzione.
set.seed(42)
# Correlated 2D data
x1 <- rnorm(100)
x2 <- 0.8 * x1 + 0.6 * rnorm(100)
X <- cbind(x1, x2)
# Covariance matrix
C <- cov(X)
print(round(C, 3))
# Eigendecomposition of covariance matrix
eig <- eigen(C)
cat('Eigenvalues (variance explained):\n')
print(eig$values)
cat('PC1 direction:\n')
print(eig$vectors[, 1])
# Variance explained by PC1
prop_var <- eig$values[1] / sum(eig$values)
cat('PC1 explains:', round(100 * prop_var, 1), '%')Raggio spettrale
Il raggio spettrale ρ(A) = max|λᵢ| è il massimo autovalore in valore assoluto. Determina la stabilità degli algoritmi iterativi: se ρ < 1, le iterazioni convergono; se ρ > 1, divergono.
spectral_radius <- function(A) {
max(Mod(eigen(A)$values))
}
# Convergent matrix: spectral radius < 1
A_conv <- matrix(c(0.5, 0.2,
0.1, 0.3), nrow = 2, byrow = TRUE)
spectral_radius(A_conv) # < 1 -> iterations converge
# Divergent matrix: spectral radius > 1
A_div <- matrix(c(2, 0.5,
0.3, 1.5), nrow = 2, byrow = TRUE)
spectral_radius(A_div) # > 1 -> iterations diverge
# For positive definite A, spectral radius = max eigenvalue
cat('Spectral radius determines iterative stability')Determinante e traccia tramite gli autovalori
Il determinante è uguale al prodotto degli autovalori; la traccia è uguale alla loro somma. Queste relazioni collegano le proprietà algebriche agli autovalori e forniscono controlli di coerenza per i risultati di eigen().
A <- matrix(c(5, 2,
1, 4), nrow = 2, byrow = TRUE)
eig_vals <- eigen(A)$values
# det(A) = product of eigenvalues
det(A)
prod(eig_vals) # Same!
# trace = sum of eigenvalues
sum(diag(A))
sum(eig_vals) # Same!
# For numeric precision, use Re() on complex
A2 <- matrix(c(3, -1, 2, 5), nrow = 2, byrow = TRUE)
ev <- eigen(A2)$values
all.equal(det(A2), prod(Re(ev)), tolerance = 1e-10)
all.equal(sum(diag(A2)), sum(Re(ev)), tolerance = 1e-10)Matrici definite positive
Una matrice simmetrica è definita positiva (PD) se tutti gli autovalori sono positivi. Le matrici di covarianza sono semidefinite positive (autovalori ≥ 0). Le matrici PD sono invertibili e ammettono decomposizioni di Cholesky.
# Check positive definiteness
is_positive_definite <- function(A) {
# Symmetric check
if (!isTRUE(all.equal(A, t(A)))) return(FALSE)
all(eigen(A)$values > 0)
}
# Positive definite covariance matrix
S <- matrix(c(4, 2,
2, 3), nrow = 2, byrow = TRUE)
is_positive_definite(S) # TRUE
eigen(S)$values # Both positive
# Not PD (one negative eigenvalue)
Q <- matrix(c(1, 3,
3, 2), nrow = 2, byrow = TRUE)
is_positive_definite(Q) # FALSE
eigen(Q)$values # One negativeIterazione delle potenze per l'autovalore dominante
Per le matrici di grandi dimensioni, calcolare tutti gli autovalori è costoso. L'iterazione delle potenze trova iterativamente l'autovalore più grande ed è alla base dell'algoritmo PageRank di Google. Moltiplichi ripetutamente per A e quindi normalizzi.
# Power iteration: finds dominant eigenvalue
power_iteration <- function(A, tol = 1e-10, max_iter = 1000) {
n <- nrow(A)
v <- rnorm(n); v <- v / sqrt(sum(v^2)) # random unit vector
lambda_old <- 0
for (i in seq_len(max_iter)) {
w <- A %*% v
lambda <- max(abs(w))
v <- w / lambda
if (abs(lambda - lambda_old) < tol) break
lambda_old <- lambda
}
list(value = lambda, vector = v)
}
A <- matrix(c(4, 1, 2, 3), nrow = 2, byrow = TRUE)
result <- power_iteration(A)
result$value # Should be ~5 (dominant eigenvalue)
eigen(A)$values[1] # CompareVerifica rapida
Verifichi la Sua comprensione di autovalori e autovettori in R.
Riepilogo: autovalori e autovettori
Punti fondamentali: eigen(A) restituisce $values e $vectors. Verifichi il risultato con A %*% v - lambda*v ≈ 0. Le matrici simmetriche hanno autovalori reali e autovettori ortogonali. Le matrici non simmetriche possono avere autovalori complessi. det(A) = prodotto degli autovalori; trace = somma. La PCA scompone la matrice di covarianza. Definita positiva ↔ tutti gli autovalori > 0.
A <- matrix(c(6, 2, 2, 3), nrow = 2)
eig <- eigen(A)
# Key eigen operations:
eig$values # eigenvalues
eig$vectors # eigenvectors (columns)
# Verify Av = lambda*v
v1 <- eig$vectors[, 1]
max(abs(A %*% v1 - eig$values[1] * v1)) # ~0
# Properties
all.equal(det(A), prod(eig$values)) # TRUE
all.equal(sum(diag(A)), sum(eig$values)) # TRUE
# Reconstruct A = V Lambda V^{-1}
V <- eig$vectors
all.equal(A, Re(V %*% diag(eig$values) %*% solve(V)))Domande Frequenti
La lezione «Autovalori e autovettori» è gratuita?
Sì — il testo completo di «Autovalori e autovettori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.
Cosa imparerò in «Autovalori e autovettori»?
Calcoli le decomposizioni agli autovalori con eigen() e interpreti i risultati Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare R Academy?
Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Autovalori e autovettori»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione R Academy?
Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Moltiplicazione di matrici e determinanti
- Risoluzione di sistemi lineari con solve()
- Autovalori e autovettori
- Decomposizioni SVD, QR e di Cholesky