Un vector propio señala una dirección que una transformación conserva. Puede cambiar su longitud o sentido, pero el resultado permanece sobre la misma recta.
Los valores propios indican factores de escala, pero necesitan direcciones asociadas para describir el comportamiento de una transformación.
Esas direcciones están representadas por los vectores propios o autovectores. Juntos, valores y vectores propios permiten encontrar coordenadas especialmente simples para una matriz.
Sea A una matriz cuadrada. Un vector no nulo v es vector propio de A asociado al valor propio λ si:
El resultado Av puede apuntar en el mismo sentido, en el opuesto o ser cero cuando λ = 0, pero siempre permanece en la recta generada por v.
const A = [[2, 1], [1, 2]];
const v = [1, 1];
const lambda = 3;
const Av = A.map(fila => fila.reduce((suma, valor, i) => suma + valor * v[i], 0));
console.log(Av); // [3, 3]
console.log(v.map(valor => lambda * valor)); // [3, 3]Si v es vector propio asociado a λ, cualquier múltiplo no nulo cv también lo es:
Por eso los vectores propios aparecen en direcciones completas, no como flechas aisladas.
const A = [[2, 1], [1, 2]];
const vectores = [[1, 1], [2, 2], [-3, -3]];
for (const v of vectores) {
const Av = A.map(fila => fila.reduce((s, valor, i) => s + valor * v[i], 0));
console.log(v, Av); // cada resultado es 3v
}Una vez conocido un valor propio λ:
Para A = [[2, 1], [1, 2]] y λ = 3:
Todo múltiplo no nulo de (1, 1) es vector propio asociado a 3.
const lambda = 3;
const A = [[2, 1], [1, 2]];
const AmenosLambdaI = A.map((fila, i) =>
fila.map((valor, j) => valor - Number(i === j) * lambda)
);
console.log(AmenosLambdaI); // [[-1, 1], [1, -1]]Para la misma matriz y λ = 1:
Así, (1, −1) determina la segunda dirección propia.
const A = [[2, 1], [1, 2]];
const v = [1, -1];
const Av = A.map(fila => fila.reduce((s, valor, i) => s + valor * v[i], 0));
console.log(Av); // [1, -1] = 1vPara comprobar un candidato se calcula Av y λv y se comparan con una tolerancia. También debe verificarse que v no sea cero.
function esVectorPropio(A, v, lambda, tolerancia = 1e-10) {
if (Math.hypot(...v) <= tolerancia) return false;
const Av = A.map(fila => fila.reduce((suma, valor, i) => suma + valor * v[i], 0));
return Av.every((valor, i) => Math.abs(valor - lambda * v[i]) <= tolerancia);
}
const A = [[2, 1], [1, 2]];
console.log(esVectorPropio(A, [1, 1], 3)); // true
console.log(esVectorPropio(A, [1, 0], 2)); // false
console.log(esVectorPropio(A, [0, 0], 99)); // falseEl espacio propio asociado a λ es:
A diferencia del conjunto de vectores propios, Eλ sí incluye al vector cero para ser un subespacio. Los vectores propios son precisamente sus elementos no nulos.
La dimensión del espacio propio Eλ se denomina multiplicidad geométrica de λ.
Siempre se cumple:
La diferencia entre ambas multiplicidades determina si hay suficientes vectores propios para diagonalizar.
Dos matrices pueden tener el mismo valor propio repetido y distinta cantidad de direcciones propias.
| Matriz | Valor propio | Espacio propio |
|---|---|---|
| [[2, 0], [0, 2]] | 2, multiplicidad 2 | Todo ℝ2, dimensión 2 |
| [[2, 1], [0, 2]] | 2, multiplicidad 2 | gen{(1, 0)}, dimensión 1 |
const identidadEscalada = [[2, 0], [0, 2]];
const bloqueJordan = [[2, 1], [0, 2]];
const aplicar = (A, v) => A.map(fila =>
fila.reduce((suma, valor, i) => suma + valor * v[i], 0)
);
console.log(aplicar(identidadEscalada, [1, 1])); // [2, 2]
console.log(aplicar(bloqueJordan, [1, 1])); // [3, 2], no es 2[1,1]Los vectores propios asociados a valores propios distintos son linealmente independientes.
Por tanto, una matriz n × n con n valores propios distintos posee n vectores propios independientes y puede diagonalizarse.
const v1 = [1, 1]; // asociado a lambda = 3
const v2 = [1, -1]; // asociado a lambda = 1
const determinante = v1[0] * v2[1] - v2[0] * v1[1];
console.log(determinante); // -2, son independientesLos vectores propios suelen normalizarse para trabajar con longitud uno. La normalización no cambia el valor propio asociado.
Tanto v como −v representan la misma dirección propia, por lo que un algoritmo puede devolver cualquiera de los dos signos.
function normalizar(v) {
const longitud = Math.hypot(...v);
return longitud === 0 ? null : v.map(valor => valor / longitud);
}
console.log(normalizar([1, 1]));
console.log(normalizar([-1, -1]));
// Ambos representan la misma dirección propia.Los vectores propios asociados a λ = 0 son los vectores no nulos del núcleo de A:
const A = [[1, 2], [2, 4]];
const v = [-2, 1];
const Av = A.map(fila => fila.reduce((s, valor, i) => s + valor * v[i], 0));
console.log(Av); // [0, 0]
// v es vector propio asociado a lambda = 0.Estas direcciones son las que la transformación colapsa completamente.
Las matrices reales simétricas poseen propiedades especialmente favorables:
const v1 = [1, 1];
const v2 = [1, -1];
const producto = v1.reduce((suma, valor, i) => suma + valor * v2[i], 0);
console.log(producto); // 0: direcciones propias ortogonalesDado un valor propio real, una fila no nula (p, q) de A − λI es perpendicular a cualquier solución. Por eso (−q, p) ofrece una dirección del núcleo.
function vectorPropio2x2(A, lambda, tolerancia = 1e-10) {
const filas = [
[A[0][0] - lambda, A[0][1]],
[A[1][0], A[1][1] - lambda]
];
const normas = filas.map(fila => Math.hypot(...fila));
const indice = normas[1] > normas[0] ? 1 : 0;
if (normas[indice] <= tolerancia) return [1, 0];
const [p, q] = filas[indice];
const candidato = [-q, p];
const longitud = Math.hypot(...candidato);
return candidato.map(valor => valor / longitud);
}
const A = [[2, 1], [1, 2]];
console.log(vectorPropio2x2(A, 3));
console.log(vectorPropio2x2(A, 1));Si A − λI es la matriz cero, todo vector no nulo es propio y la función devuelve una dirección representativa.
El método de la potencia aproxima un vector propio dominante aplicando A repetidamente y normalizando. Funciona bajo condiciones adecuadas, especialmente cuando un valor propio domina en magnitud.
function potencia(A, inicial, iteraciones = 20) {
let v = [...inicial];
for (let paso = 0; paso < iteraciones; paso++) {
const Av = A.map(fila => fila.reduce((s, valor, i) => s + valor * v[i], 0));
const norma = Math.hypot(...Av);
if (norma === 0) return null;
v = Av.map(valor => valor / norma);
}
const Av = A.map(fila => fila.reduce((s, valor, i) => s + valor * v[i], 0));
const lambda = v.reduce((s, valor, i) => s + valor * Av[i], 0);
return { vector: v, valor: lambda };
}
console.log(potencia([[2, 1], [1, 2]], [1, 0]));
// vector cercano a [0.707, 0.707] y valor cercano a 3En procesos de transición, un estado estacionario satisface Av = v. Es un vector propio asociado a λ = 1.
const transicion = [[0.9, 0.2], [0.1, 0.8]];
let estado = [1, 0];
for (let paso = 0; paso < 50; paso++) {
estado = transicion.map(fila =>
fila.reduce((suma, valor, i) => suma + valor * estado[i], 0)
);
}
console.log(estado); // aproximadamente [2/3, 1/3]Esta idea aparece en cadenas de Markov, rankings y modelos dinámicos.
Los vectores propios se utilizan en análisis de componentes principales, vibraciones, estabilidad, sistemas dinámicos, gráficos, compresión y clasificación de datos.
En matrices reales con valores propios complejos, los vectores propios asociados también pueden requerir componentes complejas.
Errores habituales:
Los vectores propios muestran las direcciones intrínsecas de una transformación. Al resolver el núcleo de A − λI obtenemos espacios completos de direcciones que se escalan de forma simple.
En el próximo tema utilizaremos suficientes vectores propios independientes para diagonalizar matrices.