25. Regla de Cramer

25.1 Introducción

Los métodos de Gauss y Gauss-Jordan resuelven sistemas mediante operaciones por fila. La regla de Cramer ofrece otra perspectiva: calcula cada incógnita reemplazando una columna de la matriz y evaluando determinantes.

Su importancia es principalmente teórica y didáctica. Muestra de forma explícita cómo la solución depende de los coeficientes y de los términos independientes.

25.2 Condiciones para aplicar la regla

La regla de Cramer requiere simultáneamente:

• El mismo número de ecuaciones e incógnitas.
• Una matriz de coeficientes A cuadrada.
• Un determinante principal distinto de cero.

25.3 Determinante principal y matrices auxiliares

Sea A la matriz de coeficientes y b el vector de términos independientes. Definimos:

• D = det(A).
• A_i: matriz obtenida al reemplazar la columna i de A por b.
• D_i = det(A_i).

Solo se reemplaza una columna por vez; las demás permanecen en su posición original.

25.4 Construir una matriz auxiliar

Para A = [[a, b], [c, d]] y términos independientes [e, f]:

function reemplazarColumna(A, b, columna) {
  return A.map((fila, i) =>
    fila.map((valor, j) => j === columna ? b[i] : valor)
  );
}

const A = [[1, 1], [2, -1]];
const b = [5, 1];
console.log(reemplazarColumna(A, b, 0)); // [[5, 1], [1, -1]]
console.log(reemplazarColumna(A, b, 1)); // [[1, 5], [2, 1]]

25.5 Fórmulas para un sistema 2 × 2

Para el sistema ax + by = e, cx + dy = f:

Estas expresiones son válidas cuando D ≠ 0.

25.6 Ejemplo 2 × 2: determinante principal

Resolvamos x + y = 5 y 2x − y = 1. La matriz de coeficientes es A = [[1, 1], [2, −1]].

Como D no es cero, el sistema tiene solución única y puede aplicarse Cramer.

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

const A = [[1, 1], [2, -1]];
console.log(det2(A)); // -3

25.7 Ejemplo 2 × 2: determinantes auxiliares

Reemplazamos la primera columna por b = [5, 1] para calcular D_x, y luego la segunda para calcular D_y:

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

const Dx = det2([[5, 1], [1, -1]]);
const Dy = det2([[1, 5], [2, 1]]);
console.log({ Dx, Dy }); // { Dx: -6, Dy: -9 }

25.8 Ejemplo 2 × 2: solución y verificación

Dividimos cada determinante auxiliar por D:

const D = -3;
const x = -6 / D;
const y = -9 / D;

console.log({ x, y });
console.log(x + y, 2 * x - y); // 5, 1

25.9 Función directa para sistemas 2 × 2

La implementación debe validar dimensiones y evitar dividir por un determinante nulo o numéricamente muy pequeño.

function cramer2x2(A, b, tolerancia = 1e-12) {
  if (A.length !== 2 || A.some(fila => fila.length !== 2) || b.length !== 2) {
    throw new Error("Se requiere un sistema 2 × 2");
  }
  const det = m => m[0][0] * m[1][1] - m[0][1] * m[1][0];
  const D = det(A);
  if (Math.abs(D) <= tolerancia) return null;

  const Dx = det([[b[0], A[0][1]], [b[1], A[1][1]]]);
  const Dy = det([[A[0][0], b[0]], [A[1][0], b[1]]]);
  return [Dx / D, Dy / D];
}

console.log(cramer2x2([[1, 1], [2, -1]], [5, 1])); // [2, 3]

25.10 Ejemplo de orden 3

Consideremos el sistema:

Sus datos matriciales son:

25.11 Determinante principal de orden 3

Aplicando expansión por cofactores o la regla de Sarrus:

El resultado distinto de cero garantiza una solución única.

function det3(m) {
  const [[a, b, c], [d, e, f], [g, h, i]] = m;
  return a * (e * i - f * h)
       - b * (d * i - f * g)
       + c * (d * h - e * g);
}

const A = [[1, 1, 1], [2, -1, 1], [1, 2, -1]];
console.log(det3(A)); // 7

25.12 Determinantes auxiliares de orden 3

Se reemplaza por b una columna diferente en cada matriz:

const det3 = m =>
  m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) -
  m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) +
  m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);

const Dx = det3([[6, 1, 1], [3, -1, 1], [2, 2, -1]]);
const Dy = det3([[1, 6, 1], [2, 3, 1], [1, 2, -1]]);
const Dz = det3([[1, 1, 6], [2, -1, 3], [1, 2, 2]]);
console.log({ Dx, Dy, Dz }); // { Dx: 7, Dy: 14, Dz: 21 }

25.13 Solución del ejemplo de orden 3

const D = 7;
const solucion = [7, 14, 21].map(determinante => determinante / D);
const [x, y, z] = solucion;

console.log(solucion); // [1, 2, 3]
console.log(x + y + z, 2 * x - y + z, x + 2 * y - z); // 6, 3, 2

25.14 Determinante genérico por cofactores

Para mostrar una implementación general puede usarse expansión recursiva por cofactores. Es clara, pero su costo crece muy rápido y no es apropiada para matrices grandes.

function determinante(matriz) {
  const n = matriz.length;
  if (n === 0 || matriz.some(fila => fila.length !== n)) {
    throw new Error("La matriz debe ser cuadrada y no vacía");
  }
  if (n === 1) return matriz[0][0];
  if (n === 2) return matriz[0][0] * matriz[1][1] - matriz[0][1] * matriz[1][0];

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

console.log(determinante([[1, 1, 1], [2, -1, 1], [1, 2, -1]])); // 7

25.15 Implementación general de Cramer

Combinando el determinante y el reemplazo de columnas se obtiene una función para sistemas cuadrados pequeños.

function determinante(m) {
  if (m.length === 1) return m[0][0];
  if (m.length === 2) return m[0][0] * m[1][1] - m[0][1] * m[1][0];
  return m[0].reduce((total, valor, columna) => {
    const menor = m.slice(1).map(fila => fila.filter((_, j) => j !== columna));
    return total + (-1) ** columna * valor * determinante(menor);
  }, 0);
}

function resolverCramer(A, b, tolerancia = 1e-12) {
  const n = A.length;
  if (n === 0 || b.length !== n || A.some(fila => fila.length !== n)) {
    throw new Error("Se requiere un sistema cuadrado");
  }
  const D = determinante(A);
  if (Math.abs(D) <= tolerancia) return null;

  return Array.from({ length: n }, (_, columna) => {
    const auxiliar = A.map((fila, i) =>
      fila.map((valor, j) => j === columna ? b[i] : valor)
    );
    return determinante(auxiliar) / D;
  });
}

const A = [[1, 1, 1], [2, -1, 1], [1, 2, -1]];
console.log(resolverCramer(A, [6, 3, 2])); // [1, 2, 3]

25.16 Qué ocurre cuando D = 0

Si D = 0, la división D_i/D no está definida. El sistema puede ser incompatible o compatible indeterminado; Cramer por sí solo no proporciona la clasificación completa.

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

console.log(D); // 0
console.log("Se necesita Gauss o comparar rangos para clasificar el sistema");

25.17 Relación con la matriz inversa

Cramer puede deducirse de x = A^-1b y de la fórmula A^-1 = adj(A)/det(A). Los determinantes auxiliares reúnen exactamente las combinaciones que aparecen al multiplicar la adjunta por b.

Esta relación conecta cuatro conceptos estudiados: determinante, inversa, rango completo y solución única.

25.18 Ventajas, limitaciones y errores frecuentes

Errores habituales son reemplazar una fila en lugar de una columna, alterar el orden de las variables, usar distintos D en los cocientes, continuar cuando D = 0 y cometer errores de signo en los determinantes.

25.19 Qué debes recordar de este tema

• Cramer se aplica a sistemas cuadrados con det(A) distinto de cero.
• D es el determinante de la matriz de coeficientes.
• A_i reemplaza solamente la columna i de A por b.
• Cada incógnita se obtiene con x_i = D_i/D.
• Si D = 0, Cramer no clasifica el sistema.
• El método es claro para orden 2 y 3, pero ineficiente para matrices grandes.
• La solución debe verificarse sustituyéndola en Ax = b.
• Determinante no nulo, invertibilidad, rango completo y solución única están relacionados.

25.20 Conclusión

La regla de Cramer convierte la resolución de un sistema en el cálculo de varios determinantes. Su fórmula es compacta y revela de manera directa la dependencia de cada incógnita respecto de los datos del problema.

En el próximo tema comenzaremos el estudio de los espacios vectoriales, una estructura que generaliza las operaciones y propiedades conocidas de los vectores.