Sistemas lineales y eliminación de Gauss

01 · El problema

Varias ecuaciones, una solución común

Un sistema lineal reúne ecuaciones cuyas incógnitas aparecen elevadas a la primera potencia. Por ejemplo:

Resolverlo significa encontrar valores de x, y y z que satisfagan simultáneamente las tres ecuaciones. Estos sistemas aparecen en circuitos, estructuras, gráficos, ajuste de datos, simulaciones, optimización y discretización de ecuaciones diferenciales.

02 · Representación

De las ecuaciones a Ax=b

Los coeficientes se organizan en una matriz A, las incógnitas en un vector x y los términos independientes en un vector b:

La matriz aumentada coloca b como una columna adicional:

Guardar únicamente números evita repetir los nombres de las variables y facilita aplicar el mismo algoritmo a sistemas de cualquier tamaño.

03 · Equivalencia

Operaciones elementales por filas

Podemos transformar la matriz aumentada sin cambiar su conjunto de soluciones mediante tres operaciones:

Intercambiar filas

Fᵢ ↔ Fⱼ. Cambia el orden de las ecuaciones.

Multiplicar una fila

Fᵢ ← cFᵢ, con c≠0. Escala una ecuación.

Sumar un múltiplo

Fᵢ ← Fᵢ+cFⱼ. Combina dos ecuaciones.

Conservar equivalencia

Cada operación es reversible, por lo que no crea ni elimina soluciones.

Gauss utiliza principalmente la tercera operación para crear ceros debajo de la diagonal principal.

04 · Primera fase

Eliminación hacia adelante

En la columna k, el elemento diagonal a[k][k] actúa como pivote. Para anular el elemento a[i][k] de una fila inferior calculamos:

Al repetir el proceso columna por columna obtenemos un sistema triangular superior:

1. 1
   Seleccionar el pivote.

   Comenzar en la primera posición diagonal disponible.

2. 2
   Calcular multiplicadores.

   Uno por cada fila situada debajo del pivote.

3. 3
   Actualizar filas.

   Restar el múltiplo apropiado desde la columna actual hasta el término independiente.

4. 4
   Avanzar.

   Repetir sobre la submatriz inferior derecha.

05 · Ejemplo manual

Triangularizar un sistema de 3×3

Partimos de:

Usamos el primer pivote, 2. Para la segunda fila, m₂₁=−3/2; para la tercera, m₃₁=−1:

Ahora 1/2 es el segundo pivote. Como m₃₂=2/(1/2)=4:

La matriz ya es triangular superior. Todavía no terminamos: falta recuperar las incógnitas.

06 · Segunda fase

Sustitución regresiva

La última ecuación contiene una sola incógnita. Después de resolverla, sustituimos su valor en la fila anterior y continuamos hacia arriba:

En el ejemplo:

1. −z=1, por lo tanto z=−1.
2. (1/2)y+(1/2)(−1)=1, por lo tanto y=3.
3. 2x+3−(−1)=8, por lo tanto x=2.

07 · Implementación

Eliminación de Gauss en JavaScript

La siguiente versión educativa copia sus entradas, comprueba dimensiones y rechaza un pivote nulo o demasiado pequeño. El intercambio automático de filas se estudiará en el próximo tema.

function gauss(A, b, toleranciaPivote = 1e-12) {
  const n = A.length;
  if (n === 0 || b.length !== n || A.some(fila => fila.length !== n)) {
    throw new Error("Dimensiones incompatibles");
  }
  if (A.some(fila => fila.some(valor => !Number.isFinite(valor)))
      || b.some(valor => !Number.isFinite(valor))) {
    throw new Error("Todos los coeficientes deben ser finitos");
  }

  // Copiar para no modificar los datos recibidos.
  const M = A.map((fila, i) => [...fila, b[i]]);

  // Eliminación hacia adelante.
  for (let k = 0; k < n - 1; k++) {
    const pivote = M[k][k];
    if (!Number.isFinite(pivote) || Math.abs(pivote) <= toleranciaPivote) {
      throw new Error(`Pivote inadecuado en la columna ${k}`);
    }

    for (let i = k + 1; i < n; i++) {
      const multiplicador = M[i][k] / pivote;
      M[i][k] = 0;
      for (let j = k + 1; j <= n; j++) {
        M[i][j] -= multiplicador * M[k][j];
      }
    }
  }

  // Sustitución regresiva.
  const x = Array(n).fill(0);
  for (let i = n - 1; i >= 0; i--) {
    if (!Number.isFinite(M[i][i]) || Math.abs(M[i][i]) <= toleranciaPivote) {
      throw new Error(`No hay pivote válido en la fila ${i}`);
    }
    let suma = 0;
    for (let j = i + 1; j < n; j++) suma += M[i][j] * x[j];
    x[i] = (M[i][n] - suma) / M[i][i];
  }
  return { solucion: x, triangular: M };
}

const A = [[2, 1, -1], [-3, -1, 2], [-2, 1, 2]];
const b = [8, -11, -3];
console.log(gauss(A, b).solucion); // [2, 3, -1]

08 · Lectura del código

Qué representan k, i y j

La asignación M[i][k]=0 impone el valor que matemáticamente debería resultar de la resta. Esto evita conservar un pequeño residuo de redondeo, como 2.22e−16, en una posición estructuralmente nula.

09 · Escalabilidad

Costo computacional y memoria

La eliminación contiene tres recorridos anidados cuyo tamaño disminuye en cada etapa. Su operación dominante requiere aproximadamente:

La sustitución regresiva utiliza aproximadamente n² operaciones. Para valores grandes de n, domina el término cúbico de la eliminación:

Las matrices dispersas, con gran cantidad de ceros, suelen requerir estructuras y algoritmos especializados para evitar almacenar y operar sobre todos los elementos.

10 · Existencia y unicidad

Una, ninguna o infinitas soluciones

Durante la eliminación pueden aparecer filas que revelan la naturaleza del sistema:

Solución única

Hay un pivote válido para cada incógnita y la sustitución regresiva determina todos los valores.

Sistema incompatible

Una fila [0 0 … 0 | c] con c≠0 representa la contradicción 0=c.

Infinitas soluciones

Una fila completamente nula y menos pivotes que incógnitas deja una o más variables libres.

Caso numérico

En coma flotante, «cero» significa una magnitud pequeña respecto de una escala elegida.

11 · Límite del método básico

Un pivote cero no siempre significa que no hay solución

Consideremos:

La primera posición diagonal es cero, pero el sistema tiene la solución (1,2). Basta intercambiar las ecuaciones antes de eliminar:

También conviene evitar pivotes extremadamente pequeños, porque producen multiplicadores grandes y amplifican errores de redondeo. El pivoteo parcial elige, en cada columna, una fila con coeficiente de mayor magnitud.

En el tema siguiente estudiaremos esta estrategia y la factorización PA=LU de forma detallada.

12 · Verificación numérica

Calcular el vector residuo

Después de obtener una aproximación x̃, calculamos:

Una norma del residuo resume la discrepancia. La norma infinito toma el mayor valor absoluto:

function residuoInfinito(A, x, b) {
  let maximo = 0;
  for (let i = 0; i < A.length; i++) {
    let producto = 0;
    for (let j = 0; j < x.length; j++) producto += A[i][j] * x[j];
    maximo = Math.max(maximo, Math.abs(b[i] - producto));
  }
  return maximo;
}

const A = [[2, 1, -1], [-3, -1, 2], [-2, 1, 2]];
const b = [8, -11, -3];
console.log(residuoInfinito(A, [2, 3, -1], b)); // 0

Un residuo pequeño es necesario, pero no siempre garantiza un error pequeño en x. En sistemas mal condicionados, pequeñas perturbaciones pueden cambiar mucho la solución.

13 · Coma flotante

Redondeo, escala y condicionamiento

En aritmética exacta, las operaciones por filas preservan perfectamente la solución. En una computadora, cada suma, multiplicación y división puede redondearse.

• Un pivote pequeño genera un multiplicador potencialmente grande.
• Restar números cercanos puede causar cancelación.
• Coeficientes con escalas muy diferentes dificultan elegir una tolerancia absoluta.
• Un sistema mal condicionado amplifica perturbaciones en datos y cálculos.

No debemos decidir si un valor es cero mediante valor === 0. Una prueba escalada compara su magnitud con una tolerancia y con los coeficientes relevantes.

14 · Exploración interactiva

Laboratorio: observar la matriz durante la eliminación

Elegí un sistema, una política de pivote y una etapa. El gráfico muestra la matriz aumentada; la celda dorada es el pivote y la fila resaltada es la que se modifica.

Preguntas para explorar

1. En el sistema clásico, identificá los multiplicadores de cada operación.
2. En «Requiere intercambio», compará ambas políticas de pivote.
3. Observá la última fila de los sistemas sin solución y con infinitas soluciones.
4. En «Pivotes pequeños», compará el tamaño de los números intermedios.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: una eliminación

Para [2 1 | 5; 4 3 | 11], anulá el primer elemento de la segunda fila.

Ejercicio 2: sustitución regresiva

Resolvé el sistema triangular 3x−y+2z=7, 2y+z=5, 4z=8.

Ejercicio 3: clasificar una fila

¿Qué indica la fila aumentada [0 0 0 | 4]?

Ejercicio 4: costo

Si el tamaño del sistema se duplica, ¿cómo cambian aproximadamente el trabajo y la memoria de una matriz densa?

Ejercicio 5: multiplicación matriz-vector

Implementá una función que calcule Ax y valide las dimensiones.

function matrizPorVector(A, x) {
  if (!Array.isArray(A) || A.some(fila => fila.length !== x.length)) {
    throw new Error("Dimensiones incompatibles");
  }
  return A.map(fila =>
    fila.reduce((suma, valor, j) => suma + valor * x[j], 0)
  );
}

console.log(matrizPorVector([[2, 1], [4, 3]], [2, 1])); // [5, 11]

17 · Síntesis

Ideas para recordar

En el próximo tema reforzaremos la eliminación mediante pivoteo y separaremos el proceso en una factorización LU reutilizable.