38. Valores propios (autovalores)

38.1 Introducción

Una matriz puede cambiar la longitud y dirección de casi todos los vectores. Sin embargo, ciertas direcciones especiales conservan su línea de acción: la transformación solo las escala o invierte.

El factor aplicado en una de esas direcciones se denomina valor propio o autovalor.

38.2 Definición

Sea A una matriz cuadrada. Un escalar λ es un valor propio de A si existe un vector v no nulo tal que:

v es un vector propio asociado. El requisito v ≠ 0 es indispensable, porque A0 = λ0 se cumple para cualquier escalar y no aporta información.

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));
const lambdaV = v.map(valor => lambda * valor);

console.log(Av);      // [3, 3]
console.log(lambdaV); // [3, 3]

38.3 Interpretación geométrica

El valor propio es un escalar; no indica por sí solo cuál es la dirección afectada.

38.4 Ecuación característica

Partimos de Av = λv y agrupamos términos:

Para que este sistema homogéneo tenga una solución v no nula, A − λI debe ser singular:

Esta igualdad se denomina ecuación característica.

38.5 Por qué aparece el determinante

Si det(A − λI) fuera distinto de cero, la matriz tendría inversa y el sistema (A − λI)v = 0 solo admitiría v = 0.

Un valor propio debe hacer que la matriz pierda rango y posea un núcleo no trivial.

38.6 Polinomio característico de orden 2

Para A = [[a, b], [c, d]]:

Como a + d = tr(A) y ad − bc = det(A):

38.7 Ejemplo con una matriz diagonal

Sea A = [[4, 0], [0, −2]]. Entonces:

Los valores propios son 4 y −2. En una matriz diagonal, los valores propios son directamente sus elementos diagonales.

const diagonal = [[4, 0], [0, -2]];
const valoresPropios = diagonal.map((fila, i) => fila[i]);

console.log(valoresPropios); // [4, -2]

38.8 Ejemplo completo 2 × 2

Para A = [[2, 1], [1, 2]]:

Los valores propios son λ₁ = 1 y λ₂ = 3.

const traza = 2 + 2;
const determinante = 2 * 2 - 1 * 1;
const discriminante = traza ** 2 - 4 * determinante;
const lambda1 = (traza + Math.sqrt(discriminante)) / 2;
const lambda2 = (traza - Math.sqrt(discriminante)) / 2;

console.log({ lambda1, lambda2 }); // { lambda1: 3, lambda2: 1 }

38.9 Discriminante en matrices reales 2 × 2

Las raíces de λ² − tr(A)λ + det(A) dependen de:

38.10 Cálculo general para matrices 2 × 2

La siguiente función devuelve raíces reales o pares con parte real e imaginaria.

function valoresPropios2x2(A, tolerancia = 1e-12) {
  if (A.length !== 2 || A.some(fila => fila.length !== 2)) {
    throw new Error("Se requiere una matriz 2 × 2");
  }
  const traza = A[0][0] + A[1][1];
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  const delta = traza ** 2 - 4 * det;

  if (delta > tolerancia) {
    const raiz = Math.sqrt(delta);
    return [(traza + raiz) / 2, (traza - raiz) / 2];
  }
  if (Math.abs(delta) <= tolerancia) return [traza / 2, traza / 2];

  const imaginaria = Math.sqrt(-delta) / 2;
  return [
    { real: traza / 2, imaginaria },
    { real: traza / 2, imaginaria: -imaginaria }
  ];
}

console.log(valoresPropios2x2([[2, 1], [1, 2]])); // [3, 1]

38.11 Relación con traza y determinante

Para una matriz 2 × 2 con valores propios λ₁ y λ₂, contando multiplicidades:

Estas relaciones sirven para verificar los resultados. En matrices de orden n, la suma de los valores propios es la traza y su producto es el determinante, contando multiplicidades sobre los números complejos.

const A = [[2, 1], [1, 2]];
const lambdas = [3, 1];
const suma = lambdas.reduce((a, b) => a + b, 0);
const producto = lambdas.reduce((a, b) => a * b, 1);

console.log(suma, A[0][0] + A[1][1]);          // 4, 4
console.log(producto, A[0][0] * A[1][1] - 1); // 3, 3

38.12 Matrices triangulares

En una matriz triangular, el determinante de A − λI es el producto de sus entradas diagonales a_ii − λ. Por tanto, sus valores propios son los elementos de la diagonal.

const triangular = [
  [5, 2, -1],
  [0, 3, 4],
  [0, 0, -2]
];

const valoresPropios = triangular.map((fila, i) => fila[i]);
console.log(valoresPropios); // [5, 3, -2]

La matriz no necesita ser diagonal para aprovechar esta regla.

38.13 Multiplicidad algebraica

La cantidad de veces que un valor aparece como raíz del polinomio característico se denomina multiplicidad algebraica.

Un valor propio repetido no garantiza por sí solo que existan suficientes vectores propios independientes. Esa diferencia será importante al estudiar diagonalización.

const diagonal = [2, 2, 2, -1];
const multiplicidades = diagonal.reduce((conteo, valor) => {
  conteo[valor] = (conteo[valor] ?? 0) + 1;
  return conteo;
}, {});

console.log(multiplicidades); // { "2": 3, "-1": 1 }

38.14 El valor propio cero

λ = 0 es valor propio exactamente cuando existe v ≠ 0 con Av = 0. Esto significa que el núcleo no es trivial y A es singular.

const A = [[1, 2], [2, 4]];
const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
const v = [-2, 1];
const Av = A.map(fila => fila.reduce((s, valor, i) => s + valor * v[i], 0));

console.log(det); // 0
console.log(Av);  // [0, 0]

38.15 Valores propios complejos

Una matriz real puede no tener valores propios reales. La rotación de 90°:

Geométricamente, ninguna dirección real no nula permanece sobre su misma recta después de una rotación de 90°.

const traza = 0;
const determinante = 1;
const delta = traza ** 2 - 4 * determinante;
const parteImaginaria = Math.sqrt(-delta) / 2;

console.log([
  { real: 0, imaginaria: parteImaginaria },
  { real: 0, imaginaria: -parteImaginaria }
]); // ±i

38.16 Invariancia ante cambio de base

Las matrices semejantes A y P^-1AP representan la misma transformación en bases diferentes y poseen el mismo polinomio característico y los mismos valores propios.

const A = [[2, 0], [0, 3]];
const B = [[2, 1], [0, 3]]; // semejante a A para una P adecuada
const datos = M => ({
  traza: M[0][0] + M[1][1],
  determinante: M[0][0] * M[1][1] - M[0][1] * M[1][0]
});

console.log(datos(A)); // { traza: 5, determinante: 6 }
console.log(datos(B)); // { traza: 5, determinante: 6 }

38.17 Potencias y procesos iterativos

Si Av = λv, aplicar A repetidamente produce:

Por eso |λ| describe el comportamiento a largo plazo sobre una dirección propia.

const lambda = 0.5;
const v = [2, -4];

for (let k = 0; k <= 4; k++) {
  console.log(k, v.map(valor => lambda ** k * valor));
}

38.18 Cálculo numérico y errores frecuentes

Para matrices grandes no se expande el determinante simbólicamente ni se buscan raíces del polinomio de forma directa. Las bibliotecas numéricas utilizan algoritmos especializados, como métodos basados en factorización QR.

Errores habituales:

• Buscar valores propios de una matriz rectangular.
• Olvidar restar λ solo en la diagonal de A.
• Confundir valores propios con vectores propios.
• Permitir v = 0 en la definición.
• Cometer errores de signo en det(A − λI).
• Ignorar raíces complejas cuando el discriminante es negativo.
• Comparar valores calculados mediante igualdad exacta.

38.19 Qué debes recordar de este tema

• λ es valor propio si existe v ≠ 0 tal que Av = λv.
• Los valores propios son las raíces de det(A − λI) = 0.
• Para una matriz 2 × 2, p(λ) = λ² − tr(A)λ + det(A).
• En matrices triangulares, los valores propios están en la diagonal.
• La suma de valores propios es la traza y su producto es el determinante, contando multiplicidades.
• Cero es valor propio exactamente cuando A es singular.
• Las matrices reales pueden tener valores propios complejos.
• Las matrices semejantes tienen los mismos valores propios.

38.20 Conclusión

Los valores propios revelan los factores fundamentales de escala de una transformación. La ecuación característica permite encontrarlos y conecta su comportamiento con determinante, traza, invertibilidad y procesos iterativos.

En el próximo tema estudiaremos cómo calcular los vectores propios asociados a cada valor propio.