Matrices y álgebra lineal - 17. Propiedades de los determinantes

17.1 Introducción

Calcular un determinante directamente mediante cofactores puede requerir muchas operaciones. Las propiedades permiten simplificar matrices antes de calcular y también ayudan a demostrar si una matriz es singular sin desarrollar fórmulas extensas.

Las reglas más importantes describen el efecto de la transposición, la multiplicación y las operaciones elementales por filas o columnas.

Antes de calcular, observa la estructura: ceros, filas proporcionales, forma triangular y factores comunes pueden revelar el resultado rápidamente.

17.2 Identidad y matriz nula

La matriz identidad no cambia áreas ni volúmenes, mientras que la matriz nula colapsa todas las direcciones.

det(I_n) = 1
det(O_n×n) = 0

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

const I2 = [[1, 0], [0, 1]];
const O2 = [[0, 0], [0, 0]];

console.log(det2(I2));
console.log(det2(O2));

17.3 Determinante de la transpuesta

Transponer una matriz no cambia su determinante.

det(A^T) = det(A)

Las filas de A se convierten en columnas de A^T, pero el factor de escala y la orientación permanecen iguales.

const det3 = 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);
};
const transponer = A => A[0].map((_, j) => A.map(fila => fila[j]));

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

console.log(det3(A));
console.log(det3(transponer(A)));

17.4 Determinante de un producto

El determinante del producto de dos matrices cuadradas del mismo orden es el producto de sus determinantes.

det(AB) = det(A) · det(B)

La propiedad se cumple aunque AB y BA sean matrices diferentes.

const det2 = A => A[0][0] * A[1][1] - A[0][1] * A[1][0];
const multiplicar = (A, B) => A.map(fila =>
  B[0].map((_, j) =>
    fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
  )
);

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

console.log(det2(multiplicar(A, B)));
console.log(det2(A) * det2(B));

17.5 Determinante de la inversa

Si A es invertible, entonces AA^-1 = I. Aplicando la propiedad del producto:

det(A)det(A^-1) = 1

det(A^-1) = 1 / det(A)

function inversa2x2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  if (det === 0) throw new Error("La matriz no es invertible");

  return [
    [ A[1][1] / det, -A[0][1] / det],
    [-A[1][0] / det,  A[0][0] / det]
  ];
}

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

console.log(det2(A));
console.log(det2(inversa2x2(A)));
console.log(1 / det2(A));

17.6 Determinante de una potencia

Para una matriz cuadrada A y un entero positivo m:

det(A^m) = det(A)^m

La propiedad surge al aplicar repetidamente det(AB) = det(A)det(B).

const det2 = A => A[0][0] * A[1][1] - A[0][1] * A[1][0];
const multiplicar = (A, B) => A.map(fila =>
  B[0].map((_, j) =>
    fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
  )
);

const A = [[2, 1], [1, 2]];
const A2 = multiplicar(A, A);
const A3 = multiplicar(A2, A);

console.log(det2(A3));
console.log(det2(A) ** 3);

17.7 Multiplicar toda la matriz por un escalar

Si A es de orden n y multiplicamos todos sus elementos por k, cada una de las n filas queda multiplicada por k.

det(kA) = kⁿdet(A)

No debe confundirse con multiplicar una sola fila por k, lo que produce únicamente el factor k.

const det3 = 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);
};

const A = [[2, 1, 0], [0, 3, 1], [1, 0, 4]];
const k = 2;
const kA = A.map(fila => fila.map(valor => k * valor));

console.log(det3(kA));
console.log(k ** A.length * det3(A));

17.8 Intercambiar dos filas

Intercambiar dos filas cambia el signo del determinante, pero no su magnitud.

det(A con dos filas intercambiadas) = -det(A)

const det3 = 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);
};

const A = [[2, 1, 3], [0, 4, 5], [1, 2, 6]];
const B = A.map(fila => [...fila]);
[B[0], B[1]] = [B[1], B[0]];

console.log(det3(A));
console.log(det3(B));

17.9 Multiplicar una fila por un escalar

Si una sola fila se multiplica por k, el determinante completo también se multiplica por k.

det(A con F_i reemplazada por kF_i) = k·det(A)

const det3 = 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);
};

const A = [[2, 1, 3], [0, 4, 5], [1, 2, 6]];
const k = 5;
const B = A.map((fila, i) => i === 1 ? fila.map(valor => k * valor) : [...fila]);

console.log(det3(A));
console.log(det3(B));
console.log(k * det3(A));

17.10 Sumar un múltiplo de una fila a otra

Reemplazar una fila por ella misma más un múltiplo de otra fila no cambia el determinante.

F_i ← F_i + kF_j mantiene det(A)

const det3 = 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);
};

const A = [[2, 1, 3], [0, 4, 5], [1, 2, 6]];
const k = 3;
const B = A.map(fila => [...fila]);
B[1] = B[1].map((valor, columna) => valor + k * B[0][columna]);

console.log(det3(A));
console.log(det3(B));

Esta propiedad permite eliminar elementos sin alterar el determinante.

17.11 Filas iguales, proporcionales o dependientes

Si dos filas son iguales o proporcionales, el determinante es cero. Más generalmente, si las filas son linealmente dependientes, el determinante es cero.

const det3 = 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);
};

const iguales = [[1, 2, 3], [1, 2, 3], [4, 5, 6]];
const proporcionales = [[1, 2, 3], [2, 4, 6], [4, 5, 6]];

console.log(det3(iguales));
console.log(det3(proporcionales));

Geométricamente, las filas no generan todas las dimensiones necesarias y el volumen orientado se anula.

17.12 Fila de ceros

Si una matriz posee una fila completa de ceros, su determinante es cero.

A = [ 2   1   3 ]
    [ 0   0   0 ]
    [ 1   2   6 ]

det(A) = 0

Puede verse como un caso particular de dependencia lineal o como una expansión por esa fila, cuyos términos son todos cero.

17.13 Matrices diagonales y triangulares

El determinante de una matriz diagonal, triangular superior o triangular inferior es el producto de la diagonal principal.

det(T) = t₁₁t₂₂...t_nn

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

const superior = [[2, 5, 7], [0, -3, 4], [0, 0, 6]];
const inferior = [[4, 0, 0], [2, 5, 0], [1, 3, 2]];

console.log(determinanteTriangular(superior));
console.log(determinanteTriangular(inferior));

Si algún elemento de la diagonal es cero, el determinante completo es cero.

17.14 Las mismas reglas para columnas

Las propiedades de las operaciones por filas también se aplican a columnas.

Intercambiar dos columnas cambia el signo.
Multiplicar una columna por k multiplica el determinante por k.
Sumar a una columna un múltiplo de otra no cambia el determinante.
Columnas iguales, proporcionales o dependientes producen determinante cero.

Esto también se deduce de det(A^T) = det(A), ya que las columnas de A son las filas de A^T.

17.15 Expansión por cualquier fila o columna

La expansión por cofactores produce el mismo determinante al utilizar cualquier fila o columna.

det(A) = Σ a_ijC_ij sobre una fila fija i
det(A) = Σ a_ijC_ij sobre una columna fija j

Para reducir cálculos conviene elegir la fila o columna con mayor cantidad de ceros.

17.16 El determinante no se distribuye sobre la suma

No existe una propiedad general que permita separar el determinante de una suma.

det(A + B) ≠ det(A) + det(B), en general

const det2 = A => A[0][0] * A[1][1] - A[0][1] * A[1][0];
const sumar = (A, B) => A.map((fila, i) =>
  fila.map((valor, j) => valor + B[i][j])
);

const A = [[1, 0], [0, 1]];
const B = [[1, 0], [0, 1]];

console.log(det2(sumar(A, B)));
console.log(det2(A) + det2(B));

En este ejemplo, det(A + B) = 4, mientras que det(A) + det(B) = 2.

17.17 Cálculo por eliminación y seguimiento de cambios

Al triangular una matriz debemos registrar los intercambios y escalados. Sumar múltiplos de filas no necesita corrección.

function determinantePorEliminacion(matriz, tolerancia = 1e-12) {
  const A = matriz.map(fila => [...fila]);
  const n = A.length;
  let signo = 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;
    }

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

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

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

17.18 Resumen y errores frecuentes

Operación	Efecto sobre el determinante
Intercambiar dos filas	Cambia el signo
Multiplicar una fila por k	Multiplica por k
Sumar k veces una fila a otra	No cambia
Transponer	No cambia
Multiplicar matrices	det(AB) = det(A)det(B)
Multiplicar toda A por k	Multiplica por kⁿ

Los errores frecuentes son olvidar el cambio de signo al intercambiar filas, aplicar k en lugar de kⁿ al escalar toda la matriz, suponer que el determinante se distribuye sobre la suma y no registrar operaciones durante la eliminación.

17.19 Qué debes recordar de este tema

det(I) = 1 y det(O) = 0.
det(A^T) = det(A).
det(AB) = det(A)det(B).
Si A es invertible, det(A^-1) = 1/det(A).
Para A de orden n, det(kA) = kⁿdet(A).
Intercambiar dos filas cambia el signo.
Escalar una fila escala el determinante por el mismo factor.
Sumar un múltiplo de una fila a otra no cambia el determinante.
Filas o columnas dependientes producen determinante cero.
El determinante de una matriz triangular es el producto de su diagonal.

17.20 Conclusión

Las propiedades permiten calcular determinantes de manera estratégica y comprender cómo cada transformación elemental afecta el área, el volumen y la orientación. También explican por qué la eliminación conduce a un método eficiente.

En el próximo tema practicaremos el cálculo de determinantes de órdenes 2 y 3 mediante fórmulas, cofactores y la regla de Sarrus.

Volver al índice