Método de Montante

 -Fundamento Teórico-

La característica principal de dicho algoritmo es que trabaja con enteros, lo cual hace que el resultado sea exacto aunque se resuelva con computadora, ya que evita que se redondeen los números.

Aunque al parecer Montante lo redescubrió en sus estudios, un método idéntico ya era conocido con anterioridad creado por matemático Erwin H. Bareiss quien 5 años antes (en 1968) publicó un documento titulado "Sylvester's Identity and Multistep Integer Preserving Gaussian Elimination" en donde se describe como resolver matrices con números enteros. Debido a que dicho estudio no fue muy difundido, en gran parte de Latinoamérica se conoce como Montante, aunque correctamente debería ser Bareiss-Montante.

El método consiste en ir "pivoteando" en la diagonal principal Se comienza en el extremo superior izquierdo, el renglón donde está el pivote va a ser el renglón base de todo el sistema y la columna donde esta el pivote va a ser la columna base. Con respecto a ese renglón y esa columna, donde está el pivote, se forman determinantes de dos por dos, y siempre se trabaja con números enteros, si apareciera alguna fracción hay un error.

-Algoritmo del Método-

1. 1. Preparación de la matriz:

   Se escribe la matriz de coeficientes del sistema de ecuaciones lineales
2. 2. Pivoteo:

   Se selecciona un elemento de la matriz como "pivote" (generalmente un elemento de la diagonal principal). Se utilizan operaciones de fila y columna para hacer ceros en la columna y fila del pivote, excepto el propio pivote. 
3. 3. Determinantes 2x2:

   Se utilizan determinantes 2x2 formados por los elementos restantes de la matriz para transformar los elementos de la matriz. 
4. 4. Repetición:

   Se repiten los pasos 2 y 3, utilizando el nuevo elemento de la diagonal principal como pivote, hasta que la matriz quede en forma triangular superior o escalonada. 
5. 5. Resolución:

   Se despeja la incógnita en la última fila (o ecuación) y se sustituye en las filas (o ecuaciones) anteriores para encontrar las soluciones del sistema. 

-Ejemplo Resuelto Paso a Paso-

Resolvamos el siguiente sistema de ecuaciones:

$$\{\begin{array}{l}2x-y+3z=9\\ x+y+z=6\\ x-y+z=2\end{array}$$\begin{cases} 2x - y + 3z = 9 \\ x + y + z = 6 \\ x - y + z = 2 \end{cases}

---

🔢 Paso 1: Matriz Aumentada

$$A = \begin{pmatrix} 2 & -1 & 3 & 9 \\ 1 & 1 & 1 & 6 \\ 1 & -1 & 1 & 2 \end{pmatrix}$$

---

🔁 Método del Montante

Usamos esta fórmula para cada elemento que no esté en la fila del pivote ni en la columna del pivote:

$$a_{ij}^{(k+1)} = \frac{a_{kk}^{(k)} \cdot a_{ij}^{(k)} - a_{ik}^{(k)} \cdot a_{kj}^{(k)}}{m_{k-1}}$$

Donde $m_{k-1}$ es el pivote anterior (empezamos con 1).

---

🔹 Iteración 1 (pivote: 2, fila 1)

$$A = \begin{pmatrix} 2 & -1 & 3 & 9 \\ 0 & 3 & -1 & 3 \\ 0 & 0 & -2 & -7 \end{pmatrix}$$

(Se calculan todos los elementos excepto los de la fila 1 y columna 1, usando la fórmula)

---

🔹 Iteración 2 (pivote: 3, fila 2)

$$A = \begin{pmatrix} 2 & -1 & 3 & 9 \\ 0 & 3 & -1 & 3 \\ 0 & 0 & -2 & -7 \end{pmatrix}$$

En este caso no hay más elementos fuera de la fila y columna del nuevo pivote que debamos actualizar. Seguimos.

---

🔹 Iteración 3 (pivote: -2, fila 3)

Ya no hay más filas ni columnas por actualizar, así que ahora simplemente despejamos las incógnitas dividiendo cada término independiente por su pivote correspondiente:

---

✅ Solución

$$\begin{align*} z &= \frac{-7}{-2} = 3.5 \\ y &= \frac{3}{3} = 1 \\ x &= \frac{9}{2} = 4.5 \end{align*}$$

⚠️ Espera… algo está mal. El resultado no coincide con lo esperado. Revisemos el ejemplo corrigiendo errores numéricos (usamos un sistema más sencillo a propósito). El sistema original que propuse en la versión con gráfico es:

$$\begin{cases} 2x - y + 3z = 9 \\ x + y + z = 6 \\ x - y + z = 2 \end{cases}$$

Rehago el proceso con operaciones correctas ahora.

---

✅ Paso a paso corregido

Matriz aumentada:

$$\begin{bmatrix} 2 & -1 & 3 & 9 \\ 1 & 1 & 1 & 6 \\ 1 & -1 & 1 & 2 \end{bmatrix}$$

Paso 1: Pivote = 2

Eliminamos los elementos de la columna 0 (excepto el pivote):

F2 = (2×F2 - 1×F1)/1
F3 = (2×F3 - 1×F1)/1

$$F2: (2×[1,1,1,6] - 1×[2,-1,3,9]) = [0, 3, -1, 3] F3: (2×[1,-1,1,2] - 1×[2,-1,3,9]) = [0, -1, -1, -5]$$

Nueva matriz:

$$\begin{bmatrix} 2 & -1 & 3 & 9 \\ 0 & 3 & -1 & 3 \\ 0 & -1 & -1 & -5 \end{bmatrix}$$

---

Paso 2: Pivote = 3 (F2)

F3 = (3×F3 - (-1)×F2) / 2

$$F3: (3×[0, -1, -1, -5] + [0, 3, -1, 3]) / 2 = [0, 0, -4, -12] / 2 = [0, 0, -2, -6]$$

Nueva matriz:

$$\begin{bmatrix} 2 & -1 & 3 & 9 \\ 0 & 3 & -1 & 3 \\ 0 & 0 & -2 & -6 \end{bmatrix}$$

---

Paso 3: Pivote = -2 (F3)

Ya no hay más filas que modificar. Ahora despejamos:

• z = -6 / -2 = 3

• y = (3 - (-1)*3)/3 = (3 + 3)/3 = 2

• x = (9 + 12 - 33)/2 = (9 + 2 - 9)/2 = 2/2 = 1

---

🎉 Resultado final

$$\boxed{ x = 1, \quad y = 2, \quad z = 3 }$$

-Código del Método-

import numpy as np

import matplotlib.pyplot as plt

# Matriz aumentada del sistema 3x3

A = np.array([

    [2, -1, 3, 9],

    [1, 1, 1, 6],

    [1, -1, 1, 2]

], dtype=float)

def montante(matrix):

    n = len(matrix)

    A = matrix.copy()

    m_prev = 1  # pivote anterior (empieza en 1)

    for k in range(n):

        pivot = A[k][k]

        for i in range(n):

            if i != k:

                for j in range(n+1):

                    if j != k:

                        A[i][j] = (A[k][k]*A[i][j] - A[i][k]*A[k][j]) / m_prev

        for i in range(n):

            if i != k:

                A[i][k] = 0

        m_prev = pivot

    # La solución está en la última columna dividida por la diagonal

    solution = np.zeros(n)

    for i in range(n):

        solution[i] = A[i][-1] / A[i][i]

    return A, solution

# Aplicar método del Montante

final_matrix, sol = montante(A)

# Mostrar matriz resultante

print("Matriz final tras el método del Montante:")

print(np.round(final_matrix, 4))

# Mostrar soluciones

variables = ['x', 'y', 'z']

print("\nSolución del sistema:")

for i, val in enumerate(sol):

    print(f"{variables[i]} = {val:.4f}")

# Graficar superficies (z en función de x e y)

x_vals = np.linspace(-5, 5, 50)

y_vals = np.linspace(-5, 5, 50)

X, Y = np.meshgrid(x_vals, y_vals)

Z1 = (9 - 2*X + Y)/3      # de 2x - y + 3z = 9

Z2 = (6 - X - Y)          # de x + y + z = 6

Z3 = (2 - X + Y)          # de x - y + z = 2

fig = plt.figure(figsize=(12, 8))

ax = fig.add_subplot(111, projection='3d')

ax.plot_surface(X, Y, Z1, alpha=0.5, color='blue', label='Ecuación 1')

ax.plot_surface(X, Y, Z2, alpha=0.5, color='green', label='Ecuación 2')

ax.plot_surface(X, Y, Z3, alpha=0.5, color='red', label='Ecuación 3')

# Solución

ax.scatter(sol[0], sol[1], sol[2], color='black', s=80, label='Solución')

ax.set_xlabel('x')

ax.set_ylabel('y')

ax.set_zlabel('z')

ax.set_title('Solución del sistema por Método del Montante')

plt.legend()

plt.show()

-Grafica-

-Video Explicativo-

-Conclusión- 

El método Montante es una técnica de álgebra lineal desarrollada por René Mario Montante Pardo para resolver sistemas de ecuaciones lineales utilizando números enteros. La principal ventaja de este método es que evita los errores de redondeo que pueden ocurrir al trabajar con números reales, lo que asegura que el resultado sea exacto, incluso cuando se utiliza una computadora