Eliminación gaussiana: método y ejemplos

¿Quieres explorar más? 📂 Explorar Categorías 🔥 Tendencias 🎓 Cursos

¿Resolver un sistema de ecuaciones lineales te parece un laberinto sin salida? La eliminación gaussiana es el mapa que necesitas. En pocas palabras: convierte un sistema complicado en una matriz triangular superior fácil de resolver. En este artículo aprenderás el método desde cero, con ejemplos numéricos, trucos para evitar errores comunes y aplicaciones reales. Al final, tendrás claro cómo aplicarlo en tus exámenes o proyectos de programación.

¿Qué es la eliminación gaussiana?

La eliminación gaussiana (o método de Gauss) es un algoritmo sistemático para resolver sistemas de ecuaciones lineales de la forma: ${\begin{cases} a_{11} x_{1} + a_{12} x_{2} + \dots + a_{1 n} x_{n} = b_{1} \\ a_{21} x_{1} + a_{22} x_{2} + \dots + a_{2 n} x_{n} = b_{2} \\ ⋮ \\ a_{m 1} x_{1} + a_{m 2} x_{2} + \dots + a_{m n} x_{n} = b_{m} \end{cases}$

Consiste en dos fases principales:

Eliminación progresiva (triangulación): mediante operaciones elementales de fila, transformamos la matriz aumentada del sistema en una matriz escalonada (triangular superior).
Sustitución regresiva: una vez triangulada, resolvemos las incógnitas de abajo hacia arriba.

Este método es la base del cálculo numérico y se usa en ingeniería, economía, inteligencia artificial (por ejemplo, en redes neuronales pequeñas) y gráficos por computadora.

Operaciones elementales de fila (pilares del método)

Para manipular la matriz sin cambiar la solución del sistema, solo permitimos tres movimientos:

Tema relacionado:
Método de Porcentaje de Finalización: Definición, fórmula y cálculo

Intercambiar dos filas (útil si un pivote es cero).
Multiplicar una fila por un escalar no nulo.
Sumar a una fila el múltiplo de otra.

Estas operaciones mantienen la equivalencia del sistema.

Paso a paso: algoritmo de eliminación gaussiana

Fase 1 – Eliminación hacia adelante

Escribe la matriz aumentada [A|b].
Para cada columna k (desde 1 hasta n-1):
- Si el elemento $a_{k k}$ (pivote) es cero, intercambia la fila k con otra inferior que tenga un valor no nulo en esa columna.
- Para cada fila i > k, calcula el factor $m = a_{i k} / a_{k k}$ .
- Realiza: $F_{i} \leftarrow F_{i} - m \cdot F_{k}$ .
Al final obtienes una matriz triangular superior.

Fase 2 – Sustitución regresiva

Desde la última fila hacia arriba: $x_{n} = \frac{b_{n}^{'}}{a_{n n}^{'}}, x_{n - 1} = \frac{b_{n - 1}^{'} - a_{n - 1, n}^{'} x_{n}}{a_{n - 1, n - 1}^{'}}, etc.$

Ejemplo 1: Sistema 3×3 (paso a paso)

Resolvamos: ${\begin{cases} 2 x + 3 y - z = 5 \\ 4 x + 7 y + z = 11 \\ - 2 x + y + 4 z = 9 \end{cases}$

Paso 0 – Matriz aumentada: $[\begin{array}{cccc} 2 & 3 & - 1 & 5 \\ 4 & 7 & 1 & 11 \\ - 2 & 1 & 4 & 9 \end{array}]$

Paso 1 – Eliminar x debajo del pivote 2:

Tema relacionado:
¿Quién fue Sócrates y cuál fue su Método?

$m_{21} = 4 / 2 = 2$ → $F_{2} \leftarrow F_{2} - 2 F_{1}$ :
(4-4=0, 7-6=1, 1-(-2)=3, 11-10=1) → [0,1,3 | 1]
$m_{31} = - 2 / 2 = - 1$ → $F_{3} \leftarrow F_{3} - (- 1) F_{1} = F_{3} + F_{1}$ :
(-2+2=0, 1+3=4, 4+(-1)=3, 9+5=14) → [0,4,3 | 14]

Matriz después del primer pivote: $[\begin{array}{cccc} 2 & 3 & - 1 & 5 \\ 0 & 1 & 3 & 1 \\ 0 & 4 & 3 & 14 \end{array}]$

Paso 2 – Eliminar y debajo del pivote 1 (fila 2, col 2):

$m_{32} = 4 / 1 = 4$ → $F_{3} \leftarrow F_{3} - 4 F_{2}$ :
(0-0=0, 4-4=0, 3-12=-9, 14-4=10) → [0,0,-9 | 10]

Matriz triangular superior: $[\begin{array}{cccc} 2 & 3 & - 1 & 5 \\ 0 & 1 & 3 & 1 \\ 0 & 0 & - 9 & 10 \end{array}]$

Paso 3 – Sustitución regresiva:

$- 9 z = 10 \Rightarrow z = - \frac{10}{9}$
$y + 3 z = 1 \Rightarrow y = 1 - 3 (- \frac{10}{9}) = 1 + \frac{30}{9} = 1 + \frac{10}{3} = \frac{13}{3}$
$2 x + 3 y - z = 5 \Rightarrow 2 x = 5 - 3 (\frac{13}{3}) + (- \frac{10}{9}) ?$ Cuidado: $- z = - (- \frac{10}{9}) = + \frac{10}{9}$ −z=−(−910)=+910
$5 - 13 = - 8$ ; luego $- 8 + \frac{10}{9} = \frac{- 72}{9} + \frac{10}{9} = \frac{- 62}{9}$
$x = \frac{- 62}{18} = \frac{- 31}{9}$

Solución: $x = - \frac{31}{9}, y = \frac{13}{3}, z = - \frac{10}{9}$

Tema relacionado:
¿Qué es el método científico y cómo funciona?

Ejemplo 2: Sistema con pivote cero (intercambio de filas)

${\begin{cases} 0 x + 2 y + 3 z = 8 \\ 4 x + 5 y + 6 z = 7 \\ 7 x + 8 y + 9 z = 10 \end{cases}$

Matriz aumentada: $[\begin{array}{cccc} 0 & 2 & 3 & 8 \\ 4 & 5 & 6 & 7 \\ 7 & 8 & 9 & 10 \end{array}]$

El pivote (1,1) es 0 → intercambiamos fila 1 con fila 2: $[\begin{array}{cccc} 4 & 5 & 6 & 7 \\ 0 & 2 & 3 & 8 \\ 7 & 8 & 9 & 10 \end{array}]$

Ahora continuamos normalmente (eliminar debajo del 4 en col1, etc.). El resto es análogo al ejemplo 1.

Eliminación gaussiana vs. Gauss-Jordan

Método	Ventaja	Desventaja
Gauss (triangular + sustitución)	Menos operaciones aritméticas	Necesita sustitución final
Gauss-Jordan (matriz identidad)	Da solución directamente	Más cálculos (≈50% más)

En la práctica, para computadoras se prefiere Gauss con pivoteo parcial por eficiencia y estabilidad numérica.

Pivoteo parcial y total: ¿por qué son importantes?

Cuando los pivotes son muy pequeños (cerca de cero), los errores de redondeo se amplifican. Pivoteo parcial: antes de eliminar, intercambiamos la fila actual con la fila debajo que tenga el mayor valor absoluto en esa columna. Pivoteo total: buscamos el mayor valor en toda la submatriz (filas y columnas restantes), pero es más costoso.

Ejemplo de problema sin pivoteo: ${\begin{cases} 0.0001 x + y = 1 \\ x + y = 2 \end{cases}$

Con aritmética de 4 dígitos, usar pivoteo parcial evita errores catastróficos.

Aplicaciones reales del método de Gauss

Circuitos eléctricos: resuelve las leyes de Kirchhoff.
Estructuras (ingeniería civil): cálculo de fuerzas en armaduras.
Economía: equilibrio general (modelos input-output de Leontief).
Computación gráfica: transformaciones y detección de colisiones.
Machine learning: regresión lineal con múltiples variables (mínimos cuadrados).

Errores comunes y cómo evitarlos

Dividir por cero → Siempre revisa el pivote. Usa intercambio de filas.
Olvidar aplicar la misma operación a la columna de términos independientes → Usa la matriz aumentada desde el inicio.
Acumular errores de redondeo → En cálculos manuales, trabaja con fracciones. En código, usa double y pivoteo.
Confundir orden de sustitución → Empieza desde la última ecuación hacia arriba.

Implementación en pseudocódigo (para programadores)

text

función gauss(A, b):
    n = filas(A)
    M = matriz_aumentada(A, b)
    
    para k = 0 hasta n-2:
        // Pivoteo parcial
        fila_max = k
        para i = k+1 hasta n-1:
            si |M[i][k]| > |M[fila_max][k]|:
                fila_max = i
        intercambiar_filas(M, k, fila_max)
        
        // Eliminación
        para i = k+1 hasta n-1:
            factor = M[i][k] / M[k][k]
            para j = k hasta n:
                M[i][j] -= factor * M[k][j]
    
    // Sustitución regresiva
    x = vector(n)
    para i = n-1 hasta 0 paso -1:
        suma = 0
        para j = i+1 hasta n-1:
            suma += M[i][j] * x[j]
        x[i] = (M[i][n] - suma) / M[i][i]
    
    retornar x

Ejercicio propuesto para practicar

Resuelve por eliminación gaussiana: ${\begin{cases} x + y + z = 6 \\ 2 x - y + 3 z = 14 \\ - x + 4 y - z = - 2 \end{cases}$

(Solución al final del artículo).

¿Cuándo un sistema no tiene solución o infinitas?

Durante la triangulación:

Si aparece una fila 0 0 … 0 | b con b ≠ 0 → Sistema incompatible (sin solución).
Si aparece una fila completamente nula (0 0 … 0 | 0) y hay menos pivotes que incógnitas → Infinitas soluciones (grados de libertad).

Solución del ejercicio propuesto

Matriz aumentada: $[\begin{array}{cccc} 1 & 1 & 1 & 6 \\ 2 & - 1 & 3 & 14 \\ - 1 & 4 & - 1 & - 2 \end{array}]$

$F_{2} \leftarrow F_{2} - 2 F_{1}$ → [0, -3, 1, 2]
$F_{3} \leftarrow F_{3} + F_{1}$ → [0, 5, 0, 4]
$F_{3} \leftarrow F_{3} + (5 / 3) F_{2}$ (para eliminar y debajo):
(0, 0, 5/3, 22/3) → $z = 22 / 5 = 4.4$ z
Regresiva: $y = (2 - 4.4) / - 3 = 0.8$ , $x = 6 - 0.8 - 4.4 = 0.8$

Solución: $x = 0.8, y = 0.8, z = 4.4$

Resultados de aprendizaje

Al finalizar la lectura de este artículo, el estudiante será capaz de:

Explicar en sus propias palabras el objetivo y las fases de la eliminación gaussiana.
Aplicar las tres operaciones elementales de fila para transformar una matriz aumentada en su forma escalonada.
Resolver sistemas de ecuaciones lineales de hasta 4 incógnitas mediante sustitución regresiva.
Identificar cuándo es necesario intercambiar filas (pivoteo parcial) para evitar división por cero o errores numéricos.
Diferenciar entre sistemas compatibles determinados, indeterminados e incompatibles según la forma escalonada resultante.
Implementar un algoritmo básico de eliminación gaussiana en pseudocódigo o lenguaje de programación.
Reconocer aplicaciones prácticas del método en ingeniería, economía y ciencias de la computación.

Twittear

Explora más sobre este tema

Selecciona un tema y sigue aprendiendo...

Rodrigo Ricardo Editor y fundador