16. Determinantes

16.1 Introducción

El determinante resume información importante de una matriz cuadrada en un único número. Su valor indica cómo una transformación modifica áreas o volúmenes y si aplasta el espacio en una dimensión menor.

También permite decidir si una matriz tiene inversa y si un sistema cuadrado de ecuaciones puede tener una solución única.

16.2 Definición y notación

El determinante de una matriz A se representa de dos formas habituales:

La notación |A| no significa tomar el valor absoluto de cada elemento. Representa una función que recibe una matriz cuadrada y devuelve un escalar.

Existen varias definiciones equivalentes. En este curso comenzaremos con fórmulas de órdenes pequeños, menores, cofactores y eliminación.

16.3 Solo para matrices cuadradas

El determinante se define para matrices con la misma cantidad de filas y columnas.

Para estudiar matrices rectangulares existen conceptos relacionados, como el rango y los menores cuadrados, pero no un determinante único de la matriz completa.

16.4 Determinantes de orden 1 y 2

El determinante de una matriz de orden 1 es su único elemento.

Para una matriz de orden 2, multiplicamos las diagonales y restamos los resultados.

function determinante2x2(A) {
  return A[0][0] * A[1][1] - A[0][1] * A[1][0];
}

const A = [[3, 8], [4, 6]];

console.log(determinante2x2(A));

El resultado es 3·6 - 8·4 = -14.

16.5 Interpretación geométrica en 2D

Las columnas de una matriz 2 × 2 pueden verse como dos vectores que forman un paralelogramo. El valor absoluto del determinante es su área.

const A = [[3, 1], [0, 2]];
const determinante = A[0][0] * A[1][1] - A[0][1] * A[1][0];
const area = Math.abs(determinante);

console.log("Determinante:", determinante);
console.log("Área:", area);

La transformación representada por A multiplica las áreas por un factor 6.

16.6 Signo y orientación

El signo del determinante indica si la transformación conserva o invierte la orientación.

const det2 = A => A[0][0] * A[1][1] - A[0][1] * A[1][0];

const identidad = [[1, 0], [0, 1]];
const reflexionX = [[1, 0], [0, -1]];

console.log("Identidad:", det2(identidad));
console.log("Reflexión:", det2(reflexionX));

16.7 Determinante cero

Si el determinante es cero, las filas o columnas son linealmente dependientes. Geométricamente, el área o volumen transformado se vuelve cero.

La segunda fila es el doble de la primera. La matriz no contiene dos direcciones independientes.

const A = [[1, 2], [2, 4]];
const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];

console.log("Determinante:", det);
console.log("¿Es singular?", det === 0);

16.8 Menores de una matriz

El menor M_ij se obtiene eliminando la fila i y la columna j, y calculando el determinante de la matriz restante.

function submatriz(A, filaEliminada, columnaEliminada) {
  return A
    .filter((_, i) => i !== filaEliminada)
    .map(fila => fila.filter((_, j) => j !== columnaEliminada));
}

const A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

console.log(submatriz(A, 0, 1));

En JavaScript usamos índices desde cero, por eso el menor matemático M₁₂ elimina los índices 0 y 1.

16.9 Cofactores

El cofactor C_ij agrega al menor un signo que alterna según la posición.

function cofactor2x2Desde3x3(A, i, j) {
  const menor = A
    .filter((_, fila) => fila !== i)
    .map(fila => fila.filter((_, columna) => columna !== j));

  const detMenor = menor[0][0] * menor[1][1] - menor[0][1] * menor[1][0];
  const signo = (i + j) % 2 === 0 ? 1 : -1;

  return signo * detMenor;
}

const A = [[2, 1, 3], [0, 4, 5], [1, 2, 6]];
console.log(cofactor2x2Desde3x3(A, 0, 1));

16.10 Expansión por cofactores

El determinante puede calcularse expandiendo por cualquier fila o columna. Al expandir por la fila i:

Conviene elegir una fila o columna con muchos ceros para reducir la cantidad de cálculos.

function det2(A) {
  return A[0][0] * A[1][1] - A[0][1] * A[1][0];
}

function menor(A, i, j) {
  return A.filter((_, fila) => fila !== i)
    .map(fila => fila.filter((_, columna) => columna !== j));
}

function det3PorPrimeraFila(A) {
  return A[0].reduce((suma, valor, j) => {
    const signo = j % 2 === 0 ? 1 : -1;
    return suma + signo * valor * det2(menor(A, 0, j));
  }, 0);
}

console.log(det3PorPrimeraFila([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

16.11 Fórmula de orden 3

Para una matriz 3 × 3, la expansión por la primera fila produce:

function determinante3x3(A) {
  const [[a, b, c], [d, e, f], [g, h, i]] = A;

  return a * (e * i - f * h)
       - b * (d * i - f * g)
       + c * (d * h - e * g);
}

console.log(determinante3x3([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

En el tema 18 practicaremos con detalle determinantes de órdenes 2 y 3.

16.12 Algoritmo recursivo

La expansión por cofactores puede implementarse recursivamente para cualquier orden pequeño.

function determinante(A) {
  const n = A.length;
  if (n === 1) return A[0][0];
  if (n === 2) return A[0][0] * A[1][1] - A[0][1] * A[1][0];

  return A[0].reduce((suma, valor, j) => {
    const menor = A.slice(1).map(fila =>
      fila.filter((_, columna) => columna !== j)
    );
    const signo = j % 2 === 0 ? 1 : -1;
    return suma + signo * valor * determinante(menor);
  }, 0);
}

const A = [[1, 2, 0, 1], [3, 0, 2, 1], [1, 1, 1, 0], [2, 0, 1, 3]];
console.log(determinante(A));

Este algoritmo es claro para aprender, pero genera muchas submatrices y se vuelve costoso al crecer n.

16.13 Cálculo mediante eliminación

Para matrices grandes es más eficiente transformar la matriz en triangular mediante eliminación. El determinante se obtiene a partir de la diagonal, ajustando los intercambios de filas.

function determinantePorEliminacion(matriz, tolerancia = 1e-12) {
  const A = matriz.map(fila => [...fila]);
  const n = A.length;
  let signo = 1;
  let producto = 1;

  for (let i = 0; i < n; i++) {
    let pivote = i;
    for (let fila = i + 1; fila < n; fila++) {
      if (Math.abs(A[fila][i]) > Math.abs(A[pivote][i])) pivote = fila;
    }

    if (Math.abs(A[pivote][i]) <= tolerancia) return 0;

    if (pivote !== i) {
      [A[i], A[pivote]] = [A[pivote], A[i]];
      signo *= -1;
    }

    const valorPivote = A[i][i];
    producto *= valorPivote;

    for (let fila = i + 1; fila < n; fila++) {
      const factor = A[fila][i] / valorPivote;
      for (let columna = i + 1; columna < n; columna++) {
        A[fila][columna] -= factor * A[i][columna];
      }
    }
  }

  return signo * producto;
}

console.log(determinantePorEliminacion([[2, 1, 3], [0, 4, 5], [1, 2, 6]]));

16.14 Matrices diagonales y triangulares

El determinante de una matriz diagonal o triangular es el producto de su diagonal principal.

function determinanteTriangular(A) {
  return A.reduce(
    (producto, fila, i) => producto * fila[i],
    1
  );
}

const T = [[2, 5, 7], [0, 3, 4], [0, 0, 6]];

console.log(determinanteTriangular(T));

El resultado es 2·3·6 = 36.

16.15 Determinante e invertibilidad

Una matriz cuadrada tiene inversa si y solo si su determinante es distinto de cero.

function det2(A) {
  return A[0][0] * A[1][1] - A[0][1] * A[1][0];
}

const A = [[2, 1], [5, 3]];
const B = [[1, 2], [2, 4]];

console.log("A invertible:", det2(A) !== 0);
console.log("B invertible:", det2(B) !== 0);

Una matriz con determinante cero se denomina singular.

16.16 Determinante y sistemas lineales

En un sistema cuadrado Ax = b, un determinante no nulo garantiza una única solución para cualquier vector b. Si el determinante es cero, el sistema puede no tener solución o tener infinitas soluciones.

function clasificarMatrizSistema(A, tolerancia = 1e-12) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];

  return Math.abs(det) > tolerancia
    ? "El sistema tiene solución única para cualquier b"
    : "Se necesita analizar el sistema completo";
}

console.log(clasificarMatrizSistema([[2, 1], [5, 3]]));
console.log(clasificarMatrizSistema([[1, 2], [2, 4]]));

El determinante por sí solo no distingue entre ninguna solución e infinitas soluciones cuando vale cero.

16.17 Aplicaciones en programación

• Comprobar si una transformación geométrica puede revertirse.
• Medir el cambio de área en 2D o volumen en 3D.
• Detectar cambios de orientación y reflexiones.
• Determinar si vectores forman una base.
• Analizar la existencia de una solución única en sistemas cuadrados.
• Detectar triángulos o volúmenes degenerados en gráficos.

function areaOrientadaDoble(a, b, c) {
  const ab = [b[0] - a[0], b[1] - a[1]];
  const ac = [c[0] - a[0], c[1] - a[1]];

  return ab[0] * ac[1] - ab[1] * ac[0];
}

const valor = areaOrientadaDoble([0, 0], [4, 0], [1, 3]);

console.log("Área:", Math.abs(valor) / 2);
console.log("Orientación:", Math.sign(valor));

16.18 Precisión y errores frecuentes

Con números decimales, un determinante matemáticamente nulo puede aparecer como un valor muy pequeño. La tolerancia debe considerar la escala de los elementos.

function esCasiSingular2x2(A, factor = 100) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  const escala = Math.max(...A.flat().map(Math.abs));
  const tolerancia = factor * Number.EPSILON * Math.max(1, escala ** 2);

  return Math.abs(det) <= tolerancia;
}

console.log(esCasiSingular2x2([[0.1, 0.2], [0.2, 0.4]]));

Otros errores frecuentes son calcular determinantes de matrices rectangulares, confundir |A| con valor absoluto, olvidar los signos de los cofactores, aplicar mal las dimensiones y usar expansión recursiva en matrices grandes.

16.19 Qué debes recordar de este tema

• El determinante es un escalar asociado a una matriz cuadrada.
• En orden 2 se calcula como ad - bc.
• Su valor absoluto mide el factor de escala de área o volumen.
• Su signo indica si la orientación se conserva o se invierte.
• Un determinante cero indica pérdida de dimensión y una matriz singular.
• Una matriz es invertible si y solo si su determinante es distinto de cero.
• Los menores y cofactores permiten expandir determinantes de órdenes mayores.
• La eliminación es más eficiente que la expansión recursiva para matrices grandes.

16.20 Conclusión

El determinante conecta el cálculo matricial con la geometría, la invertibilidad y los sistemas lineales. Su valor permite detectar si una transformación conserva toda la información o colapsa el espacio.

En el próximo tema estudiaremos las propiedades de los determinantes y cómo cambian al intercambiar, escalar o combinar filas y columnas.