La eliminación de Gauss conserva el conjunto de soluciones

Un sistema para recuperar parámetros puede contener la información correcta y aun así comenzar con un cero incómodo. Si el primer pivote es cero, la respuesta segura no es inventar una ecuación nueva ni dividir entre cero. Reescribe las mismas restricciones hasta que su estructura sea visible.

Esa es la promesa de la eliminación de Gauss: usar operaciones elementales de fila reversibles para simplificar un sistema lineal y conservar exactamente el mismo conjunto de soluciones. Al terminar esta lección podrás aplicar las tres operaciones de fila legales, resolver un pequeño problema de recuperación de parámetros, implementar las operaciones en NumPy y diagnosticar pivotes cero, filas redundantes, contradicciones y residuos de coma flotante.

Resultado de aprendizaje: aplicar operaciones elementales de fila sin cambiar las soluciones.

La lección 13: sin solución, una solución o muchas soluciones clasificó los sistemas lineales según sus conjuntos de soluciones. La lección 18: las matrices organizan reglas lineales nos dio una forma compacta de almacenar los coeficientes. El sitio complementario oficial de Mathematics for Machine Learning sitúa el siguiente paso en la sección 2.3 de su PDF actual. La fuente explica las transformaciones elementales y las matrices aumentadas; los números, el escenario de parámetros, el código, la visualización y las evaluaciones de esta lección son originales.

El objetivo es un sistema más sencillo, no una pregunta diferente

Considera un sistema con $m$ ecuaciones lineales y $n$ incógnitas. Podemos escribirlo como

$$A\boldsymbol{\theta}=\boldsymbol{b},$$

donde $A\in\mathbb{R}^{m\times n}$ es la matriz de coeficientes, $\boldsymbol{\theta}\in\mathbb{R}^{n}$ contiene los parámetros desconocidos y $\boldsymbol{b}\in\mathbb{R}^{m}$ contiene los lados derechos observados. Cada fila de la ecuación matricial representa una ecuación escalar:

$$a_{i1}\theta_1+a_{i2}\theta_2+\cdots+a_{in}\theta_n=b_i.$$

La eliminación de Gauss cambia el aspecto de esas filas para que sea más fácil leer los pivotes y las incógnitas. No debe cambiar qué vectores de parámetros hacen verdaderas todas las ecuaciones. El invariante es el conjunto

$$\mathcal{S}=\left\{\boldsymbol{\theta}\in\mathbb{R}^{n}: A\boldsymbol{\theta}=\boldsymbol{b}\right\}.$$

La notación matricial resulta más útil cuando añadimos el lado derecho a la fila de coeficientes:

$$\left[\begin{array}{ccc|c} a_{11}&a_{12}&\cdots&a_{1n}&b_1\\ a_{21}&a_{22}&\cdots&a_{2n}&b_2\\ \vdots&\vdots&&\vdots&\vdots\\ a_{m1}&a_{m2}&\cdots&a_{mn}&b_m \end{array}\right].$$

Esta es una matriz aumentada. La barra vertical recuerda que la última columna no es otro coeficiente desconocido. Es la salida de la ecuación y debe desplazarse con su fila cada vez que esa fila cambia.

Tres movimientos reversibles mantienen fijo el conjunto de soluciones

Sea $R_i$ una fila completa de una matriz aumentada. Hay exactamente tres operaciones elementales de fila:

Operación legal	Notación	Por qué es reversible
Intercambiar dos filas	$R_i\leftrightarrow R_j$	Volver a intercambiarlas.
Multiplicar una fila por un escalar no nulo	$R_i\leftarrow\lambda R_i$, $\lambda\ne0$	Multiplicar por $1/\lambda$.
Sumar un múltiplo de una fila a otra	$R_i\leftarrow R_i+\lambda R_j$, $i\ne j$	Restar $\lambda R_j$ de $R_i$.

La tercera operación suele llamarse sustitución de fila. Incluye sumar una ecuación a otra, restar una ecuación de otra y eliminar un coeficiente con un múltiplo elegido cuidadosamente.

La condición de no nulidad importa. Convertir $R_i$ en $0R_i$ borra una restricción; no existe una operación inversa que la recupere. También importa la regla de la fila completa: multiplicar los coeficientes sin multiplicar la entrada correspondiente del lado derecho crea una ecuación nueva.

Por qué la matriz aumentada lleva la ecuación completa

Supón que una fila representa

$$\theta_1+2\theta_2=5.$$

Su fila aumentada es $[1\;\;2\mid5]$. Escalar la ecuación por $3$ significa

$$3(\theta_1+2\theta_2)=3(5) \quad\Longleftrightarrow\quad 3\theta_1+6\theta_2=15,$$

por lo que la operación matricial legal es

$$[1\;\;2\mid5]\longrightarrow[3\;\;6\mid15].$$

La fila $[3\;\;6\mid5]$ describiría en cambio $3\theta_1+6\theta_2=5$. Es una restricción distinta. La eliminación de Gauss no permite editar independientemente el lado izquierdo y el derecho; es una reescritura controlada de la ecuación completa.

El mismo principio explica la sustitución de filas. Si

$$\begin{aligned} R_i &: \boldsymbol{a}_i^{\mathsf T}\boldsymbol{\theta}=b_i,\\ R_j &: \boldsymbol{a}_j^{\mathsf T}\boldsymbol{\theta}=b_j, \end{aligned}$$

entonces sustituir $R_i$ por $R_i+\lambda R_j$ significa

$$(\boldsymbol{a}_i+\lambda\boldsymbol{a}_j)^{\mathsf T} \boldsymbol{\theta} =b_i+\lambda b_j.$$

Cada coeficiente y el lado derecho reciben la misma combinación. La nueva fila es más fácil de utilizar, pero sigue codificando información que ya estaba presente en el par anterior.

Ejemplo resuelto: recuperar tres parámetros de una puntuación

Imagina una puntuación lineal de juguete construida a partir de tres señales medidas:

• $f_1$: una característica de coincidencia de recuperación;
• $f_2$: una característica de verificación; y
• $f_3$: una característica de confirmación de herramientas.

La regla de puntuación es

$$s=\theta_1f_1+\theta_2f_2+\theta_3f_3.$$

Los recuentos y puntuaciones siguientes son deliberadamente pequeños. Son un problema didáctico de identificación de parámetros, no una afirmación de que un sistema de clasificación en producción deba utilizar estas características o pesos.

Observación	$f_1$	$f_2$	$f_3$	puntuación observada $s$
A	0	2	1	5
B	1	1	1	4
C	2	4	5	15

Las tres filas se convierten en

$$\begin{aligned} 0\theta_1+2\theta_2+\theta_3&=5,\\ \theta_1+\theta_2+\theta_3&=4,\\ 2\theta_1+4\theta_2+5\theta_3&=15. \end{aligned}$$

En forma matricial,

$$\left[\begin{array}{ccc|c} 0&2&1&5\\ 1&1&1&4\\ 2&4&5&15 \end{array}\right].$$

La primera entrada es cero, así que la primera fila no puede escalarse para convertirse en el primer pivote. Es un problema de organización, no una prueba de que el sistema no tenga solución. Podemos intercambiar una fila no nula. La visualización estática registra cada estado, incluida la etiqueta de la operación y la matriz aumentada completa:

Cada operación de fila en el ejemplo de recuperación de tres parámetros

Registro estático completo

Todos los estados permanecen visibles debajo de los controles opcionales. La operación cambia una fila completa, por lo que cada estado representa un sistema equivalente.

1. Paso 0Inicio: matriz aumentada original

   Matriz aumentada original

   	θ₁	θ₂	θ₃	b
   R1	0	2	1	5
   R2	1	1	1	4
   R3	2	4	5	15

2. Paso 1R₁ ↔ R₃

   Matriz después del paso 1

   	θ₁	θ₂	θ₃	b
   R1	2	4	5	15
   R2	1	1	1	4
   R3	0	2	1	5

3. Paso 2R₁ ← ½R₁

   Matriz después del paso 2

   	θ₁	θ₂	θ₃	b
   R1	1	2	5/2	15/2
   R2	1	1	1	4
   R3	0	2	1	5

4. Paso 3R₂ ← R₂ − R₁

   Matriz después del paso 3

   	θ₁	θ₂	θ₃	b
   R1	1	2	5/2	15/2
   R2	0	-1	-3/2	-7/2
   R3	0	2	1	5

5. Paso 4R₂ ↔ R₃

   Matriz después del paso 4

   	θ₁	θ₂	θ₃	b
   R1	1	2	5/2	15/2
   R2	0	2	1	5
   R3	0	-1	-3/2	-7/2

6. Paso 5R₂ ← ½R₂

   Matriz después del paso 5

   	θ₁	θ₂	θ₃	b
   R1	1	2	5/2	15/2
   R2	0	1	1/2	5/2
   R3	0	-1	-3/2	-7/2

7. Paso 6R₁ ← R₁ − 2R₂

   Matriz después del paso 6

   	θ₁	θ₂	θ₃	b
   R1	1	0	3/2	5/2
   R2	0	1	1/2	5/2
   R3	0	-1	-3/2	-7/2

8. Paso 7R₃ ← R₃ + R₂

   Matriz después del paso 7

   	θ₁	θ₂	θ₃	b
   R1	1	0	3/2	5/2
   R2	0	1	1/2	5/2
   R3	0	0	-1	-1

9. Paso 8R₃ ← −R₃

   Matriz después del paso 8

   	θ₁	θ₂	θ₃	b
   R1	1	0	3/2	5/2
   R2	0	1	1/2	5/2
   R3	0	0	1	1

10. Paso 9R₁ ← R₁ − 3/2R₃

    Matriz después del paso 9

    	θ₁	θ₂	θ₃	b
    R1	1	0	0	1
    R2	0	1	1/2	5/2
    R3	0	0	1	1

11. Paso 10R₂ ← R₂ − 1/2R₃

    Matriz después del paso 10

    	θ₁	θ₂	θ₃	b
    R1	1	0	0	1
    R2	0	1	0	2
    R3	0	0	1	1

Avanza por una transformación legal cada vez

Enfoca este panel y usa los botones o las flechas izquierda y derecha para moverte entre estados.

Paso 0 / 10

Primer pasoAnteriorSiguienteÚltimo paso

OperaciónInicio: matriz aumentada original

Matriz aumentada actual

	θ₁	θ₂	θ₃	b
R1	0	2	1	5
R2	1	1	1	4
R3	2	4	5	15

La primera entrada de la primera columna es cero, así que escalar esa fila sería ilegal. Una fila no nula inferior puede proporcionar el primer pivote.

Las etiquetas de fila, el texto de la operación y la barra vertical antes de b comunican el significado sin depender del color. La secuencia estática es el recurso alternativo si JavaScript no está disponible.

Este es el mismo cálculo en orden algebraico. Usamos pivoteo parcial en las dos primeras columnas: cuando hay varios candidatos no nulos, elegimos el de mayor magnitud en la columna actual. La visualización de la lección conserva las fracciones para que cada operación pueda comprobarse a mano.

Los parámetros recuperados pasan una comprobación directa por sustitución:

$$\begin{aligned} \begin{bmatrix} 0&2&1\\ 1&1&1\\ 2&4&5 \end{bmatrix} \begin{bmatrix}1\\2\\1\end{bmatrix} &= \begin{bmatrix} 0+4+1\\ 1+2+1\\ 2+8+5 \end{bmatrix}\\ &= \begin{bmatrix}5\\4\\15\end{bmatrix} =\boldsymbol{b}. \end{aligned}$$

La solución no apareció porque una operación de fila adivinara nuevos parámetros. Cada paso cambió la representación de las mismas tres restricciones. El bloque identidad final hace que la respuesta sea fácil de leer.

Una implementación de NumPy refleja las matemáticas

La implementación siguiente hace explícitas las tres operaciones legales. Trabaja sobre una copia de un arreglo aumentado bidimensional, real y finito. La última columna se trata como el lado derecho, y atol es el umbral por debajo del cual un valor de coma flotante se considera cero. La implementación realiza eliminación de Gauss–Jordan, por lo que elimina entradas tanto por debajo como por encima de cada pivote.

import numpy as np


def swap_rows(matrix, first, second):
    result = np.array(matrix, dtype=float, copy=True)
    result[[first, second], :] = result[[second, first], :]
    return result


def scale_row(matrix, row, factor):
    if factor == 0:
        raise ValueError("row scaling needs a nonzero factor")
    result = np.array(matrix, dtype=float, copy=True)
    result[row, :] *= factor
    return result


def replace_row(matrix, target, source, factor):
    if target == source:
        raise ValueError("target and source rows must be different")
    result = np.array(matrix, dtype=float, copy=True)
    result[target, :] += factor * result[source, :]
    return result


def gauss_jordan(augmented, atol=1e-12):
    work = np.array(augmented, dtype=float, copy=True)
    if work.ndim != 2 or work.shape[1] < 2:
        raise ValueError("expected a 2D augmented matrix")
    if not np.all(np.isfinite(work)):
        raise ValueError("all entries must be finite")

    row_count, column_count = work.shape
    variable_count = column_count - 1
    pivot_row = 0

    for pivot_column in range(variable_count):
        if pivot_row == row_count:
            break

        candidates = np.abs(work[pivot_row:, pivot_column])
        pivot_offset = int(np.argmax(candidates))
        if candidates[pivot_offset] <= atol:
            continue

        pivot = pivot_row + pivot_offset
        if pivot != pivot_row:
            work = swap_rows(work, pivot_row, pivot)

        pivot_value = work[pivot_row, pivot_column]
        work = scale_row(work, pivot_row, 1.0 / pivot_value)

        for row in range(row_count):
            if row == pivot_row:
                continue
            coefficient = work[row, pivot_column]
            if abs(coefficient) > atol:
                work = replace_row(
                    work, row, pivot_row, -coefficient
                )

        pivot_row += 1

    work[np.abs(work) <= atol] = 0.0
    return work


A = np.array(
    [
        [0.0, 2.0, 1.0],
        [1.0, 1.0, 1.0],
        [2.0, 4.0, 5.0],
    ]
)
b = np.array([5.0, 4.0, 15.0])
augmented = np.column_stack((A, b))

rref = gauss_jordan(augmented)
theta = rref[:, -1]  # valid here because the coefficient block is full rank
residual = A @ theta - b

assert np.allclose(residual, 0.0, rtol=1e-12, atol=1e-12)
assert np.allclose(
    theta,
    np.linalg.solve(A, b),
    rtol=1e-12,
    atol=1e-12,
)

print(theta)
print(np.linalg.norm(residual, ord=np.inf))

La salida verificada es

[1. 2. 1.]
0.0

La última aserción compara el resultado de la eliminación construida a mano con numpy.linalg.solve, que la documentación actual de NumPy define para un sistema cuadrado de rango completo e indica que produce LinAlgError para una matriz de coeficientes singular o no cuadrada. La comparación es una comprobación cruzada, no un motivo para ocultar las operaciones de fila: el objetivo de esta lección es hacer inspeccionable el mecanismo que conserva la equivalencia.

El residuo

$$\boldsymbol{r}=A\widehat{\boldsymbol{\theta}}-\boldsymbol{b}$$

mide hasta qué punto los parámetros calculados satisfacen las ecuaciones proporcionadas. La norma infinito usada en el código es la mayor coordenada absoluta del residuo. En aritmética exacta, este ejemplo produce el vector cero. En coma flotante, un resultado correcto puede producir valores del orden del redondeo de máquina.

Los casos límite revelan qué significan los pivotes

Un pivote cero es un punto de ramificación del algoritmo, no un veredicto. Si la posición de pivote actual es cero y aparece una entrada no nula más abajo en la misma columna, intercambia las filas. Si todas las entradas inferiores son cero, pasa a la columna siguiente; esa columna puede simplemente no contener información independiente nueva.

Después de la eliminación, inspecciona las filas cuyos coeficientes son todos cero. Hay dos resultados distintos:

1. Una fila completamente nula con lado derecho cero, $[0\;\;0\;\;0\mid0]$, es redundante. No añade ninguna restricción. Si una variable tampoco tiene pivote, el sistema puede tener infinitas soluciones.
2. Una fila completamente nula con lado derecho no nulo, como $[0\;\;0\;\;0\mid1]$, afirma $0=1$. El sistema es incompatible y no tiene solución.

Por ejemplo, las dos filas

$$\left[\begin{array}{cc|c} 1&2&3\\ 2&4&6 \end{array}\right] \xrightarrow{R_2\leftarrow R_2-2R_1} \left[\begin{array}{cc|c} 1&2&3\\ 0&0&0 \end{array}\right]$$

codifican dos veces la misma recta. Si cambias únicamente el segundo lado derecho, obtienes un resultado distinto:

$$\left[\begin{array}{cc|c} 1&2&3\\ 2&4&7 \end{array}\right] \xrightarrow{R_2\leftarrow R_2-2R_1} \left[\begin{array}{cc|c} 1&2&3\\ 0&0&1 \end{array}\right],$$

que es una contradicción. Las filas de coeficientes parecen dependientes en ambos ejemplos; el lado derecho decide si las restricciones observadas son compatibles. La eliminación debe transportar esa entrada para que el algoritmo pueda distinguir redundancia de contradicción.

La prueba de concepto erróneo más breve es preguntar qué ocurre con $\theta_1+\theta_2=3$ cuando se multiplica por $2$ el lado izquierdo. El resultado legal es $2\theta_1+2\theta_2=6$, no $2\theta_1+2\theta_2=3$. Las operaciones de fila conservan un conjunto de soluciones porque las ecuaciones completas se transforman de forma reversible.

Por qué importa en una canalización de IA

La puntuación de juguete muestra el uso directo: varias observaciones pueden recuperar pesos desconocidos cuando las ecuaciones identifican un único vector de parámetros. En una canalización real, la matriz puede describir pesos de calibración, un pequeño modelo físico, un sistema de restricciones o un segmento de diagnóstico de un modelo mayor. La eliminación ayuda a responder tres preguntas prácticas:

• ¿Las observaciones proporcionan un pivote para cada parámetro?
• ¿Una observación aparentemente repetida es simplemente redundante?
• ¿Los objetivos medidos contradicen la regla lineal asumida?

El método también marca el límite del problema exacto. Las mediciones ruidosas suelen hacer incompatibles las ecuaciones, y un conjunto de datos sobredeterminado puede no tener ningún vector que satisfaga exactamente todas las filas. En esa situación, eliminar una contradicción a la fuerza cambiaría la pregunta. Un método de mínimos cuadrados hace una pregunta diferente —encontrar un vector con un error agregado pequeño— y pertenece a las siguientes decisiones de álgebra lineal numérica, no a una afirmación de equivalencia exacta por filas. Del mismo modo, numpy.linalg.solve espera una matriz de coeficientes cuadrada y de rango completo; un problema singular o no cuadrado necesita un método elegido para su objetivo real.

La lección siguiente da nombre al patrón escalonado que revela la eliminación: pivotes, variables básicas, variables libres y la forma de una solución general. El invariante que debes conservar es sencillo: cada operación legal de fila cambia la perspectiva del sistema, no el conjunto de respuestas.

Comprueba tu comprensión

Question 1

¿Por qué multiplicar una fila por cero no es una operación elemental, mientras que multiplicarla por 5 sí es legal?

Show the step-by-step solution

Empieza con una ecuación de fila $g(\boldsymbol{\theta})=0$. Multiplicar por $5$ produce $5g(\boldsymbol{\theta})=0$. Como $5\ne0$, la ecuación original se puede recuperar multiplicando por $1/5$. El conjunto de soluciones no cambia.

Multiplicar por cero produce $0=0$ para cualquier $\boldsymbol{\theta}$. La restricción original desaparece y ninguna multiplicación puede recuperarla. Por tanto, la operación no es reversible y puede ampliar el conjunto de soluciones.

Question 2

Aplica R₁ ← R₁ − 2R₂ a la matriz aumentada [[1, 2 | 7], [0, 1 | 3]]. ¿Cuál es la nueva primera fila?

Show the step-by-step solution

Usa la segunda fila completa, incluida su entrada del lado derecho:

$$R_1=[1\;\;2\mid7], \qquad R_2=[0\;\;1\mid3].$$

Multiplica la segunda fila por $2$:

$$2R_2=[0\;\;2\mid6].$$

Resta componente a componente:

$$R_1-2R_2 =[1-0\;\;2-2\mid7-6] =[1\;\;0\mid1].$$

La nueva primera fila es $[1\;\;0\mid1]$. Omitir la resta del lado derecho produciría una ecuación diferente.

Question 3

Resuelve el sistema 0x + y = 2 y x + y = 3 usando un intercambio de filas antes de eliminar.

Show the step-by-step solution

Escribe la matriz aumentada:

$$\left[\begin{array}{cc|c} 0&1&2\\ 1&1&3 1&1&3 \end{array}\right].$$

La primera posición de pivote es cero, así que intercambia las filas:

$$\left[\begin{array}{cc|c} 1&1&3\\ 0&1&2 \end{array}\right].$$

Elimina la entrada que está encima del segundo pivote:

$$R_1\leftarrow R_1-R_2 \quad\Longrightarrow\quad \left[\begin{array}{cc|c} 1&0&1\\ 0&1&2 \end{array}\right].$$

El bloque identidad da $x=1$ y $y=2$. La sustitución comprueba las dos ecuaciones originales: $0(1)+2=2$ y $1+2=3$.

Question 4

¿Qué significa una fila completamente nula en cada caso: [0, 0 | 0] y [0, 0 | 4]?

Show the step-by-step solution

La fila $[0\;\;0\mid0]$ representa $0=0$. Es redundante y no restringe las variables. Si otra variable no tiene pivote, esa libertad puede producir infinitas soluciones.

La fila $[0\;\;0\mid4]$ representa $0=4$, lo cual es imposible. Una sola fila contradictoria hace que todo el sistema no tenga solución, aunque las demás filas parezcan consistentes.

La diferencia está por completo en el lado derecho. La eliminación debe transportar esa entrada para que el algoritmo distinga redundancia de contradicción.

Question 5

Un desarrollador transforma [1, 1 | 3] en [2, 2 | 3] y dice que solo está escalando la fila. ¿Es correcta la afirmación?

Show the step-by-step solution

Escalar una fila por $2$ debe multiplicar todas las entradas:

$$2[1\;\;1\mid3]=[2\;\;2\mid6].$$

La fila afirmada $[2\;\;2\mid3]$ representa $2\theta_1+2\theta_2=3$. Dividir esa ecuación entre $2$ da $\theta_1+\theta_2=3/2$, no la ecuación original $\theta_1+\theta_2=3$. La afirmación es falsa porque el lado derecho se cambió de forma independiente.

Question 6

¿Por qué la implementación de NumPy usa una tolerancia al decidir si un pivote o un residuo es cero?

Show the step-by-step solution

En aritmética exacta, cero es un valor exacto. Las operaciones de coma flotante almacenan muchas fracciones de forma aproximada, así que un resultado matemáticamente cero puede aparecer como un valor diminuto, como $10^{-16}$. Tratar cada patrón de bits no nulo como un pivote real puede crear una operación de fila sin sentido.

Por eso la implementación compara magnitudes con atol. También comprueba el residuo con tolerancias relativa y absoluta. La tolerancia debe coincidir con la escala de los datos: un umbral razonable para valores cercanos a $1$ puede ser demasiado grande para mediciones cercanas a $10^{-9}$ o demasiado pequeño para valores muy grandes. Un residuo pequeño es una evidencia de ajuste, no una prueba de que la estimación de parámetros de un sistema mal condicionado sea estable.

Question 7

Un sistema de recuperación tiene tres parámetros desconocidos, pero la eliminación termina con solo dos pivotes y una fila completamente nula. ¿Qué debes concluir antes de elegir un método numérico?

Show the step-by-step solution

Dos pivotes restringen dos direcciones de parámetros independientes. La fila completamente nula no añade información, así que al menos una dirección de parámetros es libre, a menos que otra fila revele una contradicción.

Si ninguna fila tiene la forma $[0\;\;0\;\;0\mid c]$ con $c\ne0$, el sistema es compatible y tiene infinitas soluciones. Los datos no identifican un único vector de parámetros bajo este modelo. Añadir números arbitrarios al pivote que falta sería una decisión de modelado, no una consecuencia de la eliminación; el siguiente paso es informar de la variable libre o recopilar una medición independiente.

Fuentes

1. Mathematics for Machine Learning companion website
2. Mathematics for Machine Learning book PDF
3. NumPy documentation: numpy.linalg.solve
4. NumPy documentation: numpy.allclose
5. NumPy documentation: numpy.finfo
6. NumPy documentation: numpy.linalg.norm
7. NumPy documentation: numpy.linalg.cond