Cómo comprobar la solución de un sistema de ecuaciones lineal

tengan cuidado. lo que el profesor puso al final de x =b/? es un error tremendo a pesar de que lo hace solo con fines educativos. Realmente la división de vectores o matrices “NO EXISTE”.

ACLARACION: Al final de la clase el profesor hace un despeje dudoso ya que se esta trabajando con matrices, como tenemos Ax = b = (Matriz 2x2)(Matriz 2x1) = (Matriz 2x1). Lo correcto para despejar la matriz (o vector) x seria multiplicar por la izquierda la inversa de A y por tanto nos quedaria como: x = A_inv * b

import numpy as np
A = np.array([[-3,1],[-2,1]])
b = np.array([5,3])
A_inv = np.linalg.inv(A) 

El valor de x es

x =  A_inv.dot(b)
print(x)

output

array([-2., -1.])

Lo cual coincide analíticamente con nuestros resultados.

Equivalencia entre sistemas de ecuaciones y multiplicación de matrices

Sistema de Ecuaciones lineales:
Podemos resolver un sistema de ecuaciones lineales a través de una operación matricial. La ventaja de este método es que es mucho más ordenado y transferible a la computadora.
La representación matricial AX=B es equivalente a un sistema de ecuaciones puesto que el producto interno también se puede ver como combinaciones lineales.

Nota:
Representación gráfica de rectas a través de matplotlib (plt)

x = xp.arange(0,5,1) #genera un intervalo de datos con (inicio, fin, pasos)
y = 3*x + 2 #genera los las coordenadas y a traves de las coordenadas x
plt.figure() #genera el grafico
plt,plot(x,y) #genera el grafico con las coordenadas indicadas (se puede generar mas de una)
plt.xlim(0,5) #limites del eje x
plt.ylim(-5,-5,) #limites del eje y
plt.axvline(x=0, color = 'grey') #eje vertical
plt.axhline(y=0, color = 'grey') #eje horizontal

Si alguien quiere resolver el sistema de ecuaciones con NumPy, aquí está el código:

A = np.matrix([[-3, 1], [-2,1]])
b = np.matrix([[5],[3]])
x = (A**-1)*b
print(x)

este curso ha estado bastante interesante, le deberian poner en el titulo numpy porque si se aprende bastante de np y sus funciones

Wao que gran clase, nunca había visto esta forma de comprobación.

Hacer las operaciones con matrices ofrece una gran ventaja para resolverlas de forma computacional. De hecho, es una de sus principales aplicaciones.
Al tener todo expresado como matrices, el sistema de ecuaciones se convierte en una simple ecuación que se resuelve con un despeje. Debido a que no existe tal cosa como “división de matrices” lo que se hace es obtener la matriz inversa.

import numpy as np
import numpy.linalg as lin	#librería para obtener la inversa
import matplotlib.pyplot as plt
A = np.array([ [-3, 1], [-2, 1] ])
C = np.array([ [5], [3] ])
B = lin.inv(A) @ C
print(B)

Como resultado de este despeje, es la matriz B que es la que contiene las incógnitas.

[[-2.]
 [-1.]]

Por si a alguien le interesa, hasta aca todo se puede hacer con Deepnote en lugar de Jupyter.

Otra forma de resolver ecuaciones usando la librería numpy:

• 3*x + y = 1
• 1x + 2y = 0

	import numpy as np

	ig = np.array([1,0])
	coe = np.array([[3,1],[1,2]])

	solv = np.linalg.solve(coe, ig)

	x = solv[0]
	y = solv[1]

	{'x':x,'y':y}

Hola, si te pareció frustrante esta clase como a mi.(mas que todo al ver los comentarios de personas que ya estan en este ambito).
no te preocupes.
solo trata de entender lo que el profesor esta haciendo con los conocimientos que ya tienes.
si no entiendes nada sobre despeje de ecuaciones lineales.
dale, ve al curso de fundamentos matematicos en platzi.(https://platzi.com/cursos/fundamentos-matematicas/)
ahora, lo que hizo el profesor es lo siguiente.

1. identificó el problema y lo graficó en python(algo que ya tu conoces).
2. comprobó la informacion con despejando Y.
3. implementó el 2 punto en el concepto de matrices.

Dale, que puedes, es complejo al inicio por la familiarizacion de terminos y procesos.
pero, dale, sigue.

Otra opción para resolver sistemas de ecuaciones con matrices es con el uso de determinantes les dejo un ejemplo por si a alguien le interesa:

• El hecho que las dos funciones tengan un punto donde se crucen hacen verdadera la solución de las dos ecuaciones al mismo tiempo.

%matplotlib inline 
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-5,5)

y_1 = 3*x + 5 
y_2 = 2*x + 3

plt.figure()

plt.plot(x, y_1)
plt.plot(x, y_2)

plt.xlim(-5, 5)
plt.ylim(-5, 5)

plt.axvline(x=0, color='grey')
plt.axhline(y=0, color='grey')

A = np.array([[-3, 1],[-2, 1]])
print(A)

b = np.array([[5],[3]])
print(b)

sol_1 = np.array([-2, -1])
print(sol_1)

print(A.dot(sol_1))

Interesante, hay cosas que del todo no entendí, pero algunos compañeros lo complementaron en los comentarios

Cómo comprobar la solución de un sistema de ecuaciones lineal

¿Qué es un sistema de ecuaciones lineales?

Supongamos que tenemos $y= 3x + 5$ y $y = 2x + 3$, sabemos que es un sistema de ecuaciones lineales (se operan en base 1).

Ya sabemos despejar esta ecuación manualmente. Pero ahora veamos como lo podemos resolver con Python.

Primero tenemos que importar un par de librerías:

import numpy as np

# Importamos "matplotlib" para graficar los resultados
%matplotlib inline

# Y de "matplotlib" importamos el metodo "pyplot"
import matplotlib.pyplot as plt

Para graficar una función necesitamos poder evaluarla a lo largo de diversos puntos, en este caso, en un eje cartesiano.

Para graficar nuestros puntos, vamos a usar la función **np.arange()**:

x = np.arange(-5, 5)

Ahora, empecemos a representar nuestro problema algebraico en código, empecemos con $y= 3x + 5$ y luego con $y = 2x + 3$:

y_1 = 3*x + 5
y_2 = 2*x + 3

Una vez tenemos estos valores estamos listos para graficar:

# Pedimos a plt que genere una figura
plt.figure()

# Esa figura contendrá los valores de "x",  y "y_1"
plt.plot(x, y_1)

# Y contendrá los valores de "x",  y "y_1"
plt.plot(x, y_2)

# definimos entre que valores queremos que nos muestrecada eje
plt.xlim(-5, 5)
plt.ylim(-5, 5)

# Añadimos nuestras coordenadas
plt.axvline(x=0, color="grey")
plt.axhline(y=0, color="grey")

Ahora deberíamos ver en nuestra terminal nuestra gráfica:

Vemos que nuestro sistema de ecuaciones lineales se está cruzando, pero ¿Qué quiere decir esto? Esto significa que existe un valor de $x$ y un valor de $y$, que hacen verdadera esas ecuaciones al mismo tiempo.

Tambien podemos escribir nuestras ecuaciones $y= 3x + 5$ y $y = 2x + 3$ en forma de matrices:

# La primera fila representa la matriz de "y = 3x +"
# La segunda fila representa la matriz de "y = 2x +"
A = np.array([[-3,1], [-2,1]])

# Representación de los últimos dígitos de su respectiva ecuación "5" y "3"
b = np.array([5,3])

# Ahora calculamos la solución a nuestro problema
sol = np.linalg.solve(A, b) 
print(sol) # Output = [-2. -1.]

Así podemos comprobar la solución de un sistema de ecuaciones lineales.

• Para comprobar la solución de un sistema de ecuaciones lineales
  Supongamos que tenemos el siguiente sistema de ecuaciones lineales:

3x + 2y - z = 1
2x - 2y + 4z = -2
-x + (1/2)y - z = 0

• Podemos representar este sistema de ecuaciones en forma matricial como Ax = b, donde Aes la matriz de coeficientes, xes el vector de incógnitas y bes el vector de términos independientes. En este caso, tendremos:

| 3  2 -1 |   | x |   |  1 |
| 2 -2  4 | x | y | = |-2 |
|-1  1/2 -1|   | z |   |  0 |

• Para resolver este sistema de ecuaciones en Python, podemos utilizar la función solve()de NumPy. A continuación, mostramos cómo hacerlo:

import numpy as np

# Definir la matriz de coeficientes y el vector de términos independientes
A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]])
b = np.array([1, -2, 0])

# Resolver el sistema de ecuaciones lineales
x = np.linalg.solve(A, b)

# Imprimir la solución
print("La solución del sistema es:", x)

• Este código nos dará la solución del sistema de ecuaciones lineales, que en este caso es x = 1, y = -2y z = -2.

• Para comprobar que esta solución es correcta, podemos multiplicar la matriz de coeficientes Apor el vector de solución x, y comprobar que obtenemos el vector de términos independientes b. Podemos hacer esto usando la función dot()de NumPy, de la siguiente manera:

# Comprobar la solución multiplicando A por x
comprobacion = np.dot(A, x)

# Imprimir la comprobación
print("Comprobación: A * x = b ->", comprobacion, "=", b)

• Este código nos dará como resultado el vector de términos independientes b, lo que indica que la solución es correcta.

Para seguir la misma lógica que venimos llevando, considero que es mejor que el profesor escriba la solución de la siguiente manera, para evitar confusiones:

sol_1 = np.array([[-2],[-1]])
print(sol_1)
[[-2]
[-1]]

print(A.dot(sol_1))
[[5]
[3]]

Para ver todo el desarrollo de la gráfica hice este pequeño truco:

x = np.arange(-5,5)

y_1 = 3 * x + 5
y_2 = 2 * x + 3

plt.figure()

plt.plot(x, y_1,color='r')
plt.plot(x, y_2,color='y')

plt.xlim(-20,20)
plt.ylim(-20,20)

plt.axvline(x=0, color='black')
plt.axhline(y=0, color='black')

plt.show()

Poniendo los límites de la gráfica en -20 a 20 tanto en las X como en las Y se puede ver todo el desarrollo de la gráfica.

Creo que se entiende claramente, aparte que el profe no dijo que existían divisiones de matrices.

Me sorprende lo fácil que hace ver cómo se grafica una ecuación de 2 incognitas en plt.

Para resolver el sistema con Python:

import numpy as np

A = np.array([[-3, 1],
              [-2, 1]])

res_vec = np.array([[5],
                    [3]])

x = np.linalg.solve(A, res_vec)
print(x)

buena explicacion

x = np.arange(-5,5) - para que pone eso si después vuelve a definir el rango de -5 a 5 en
plt.xlim(-5,5)
plt.ylim(-5,5)

Muy buena explicación

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x = np.arange(-5,5,0.5)
y_1 = 3x+5
y_2 = 2x+3
plt.figure()
plt.plot(x,y_1)
plt.plot(x,y_2)
plt.xlim(-5,5)
plt.ylim(-5,5)

plt.axvline(x=0, color=‘grey’)
plt.axhline(y=0, color=‘grey’)```

print("-3x +y = 5")
print("-2x +y = 3")
print("|-3 1|.|x|=|5|")
print("|-2 1|.|y|=|3|\n")

-3x +y = 5
-2x +y = 3
|-3 1|.|x|=|5|
|-2 1|.|y|=|3|

A.dot(sol_1) == b
array([ True, True])
print(A.dot(sol_1))
[5 3]

La verdad no me gusto la clase, pense que iba a mostrar la forma de calcular la solucion de manera automatica con matrices y python.

Me gusto la clase, bastante intrigado por la siguiente.

Todo este tema de algebra lineal por fín le veo la aplicación y su posible programación. Se pone más interesante el tema…

Lo que realmente se hace es multiplicar a ambos lados de la igualdad por la matriz inversa