Álgebra Lineal

1 Matrices
2 Resolución de sistemas de ecuaciones lineales
- 2.1 Método de eliminación de Gauss Jordan
- 2.2 Ahora con Python
3 Determinantes

Álgebra Lineal - Fundamentos

Pensemos en la siguiente situación:

Cada uno de los vendedores entregarán tablas como las siguientes:

Vendedor 1	Lunes	Martes	Miércoles	Jueves	Viernes
Producto 1	30	50	40	20	50
Producto 2	35	25	45	15	20
Producto 3	30	10	25	22	15

Vendedor 2	Lunes	Martes	Miércoles	Jueves	Viernes
Producto 1	10	70	30	60	20
Producto 2	35	25	75	25	45
Producto 3	34	12	15	15	25

¿Cómo sintetiza la información entregada por los dos vendedores?
¿Obtendría una información similar?
¿Cómo expresaría la diferencia de ventas entre vendedores de acuerdo al día de la semana?
¿Cómo expresaría las ventas de la distribuidora en esa semana si quiere evaluar el desempeño diario de sus vendedores?

Esperamos que tratando de responder las anteriores preguntas hayan surgido varias ideas, sin embargo, teniendo en cuenta que hablamos de productos diferentes en días distintos un ejercicio conveniente es presentar una tabla de las mismas dimensiones tanto para presentar el informe totalizado de ventas como para presentar el desempeño de cada vendedor y su diferencia. Es claro que la suma se hace componente a componente y la tabla se estructura como un elemento que se puede sumar y restar. Este elemnto se abstrae con el concepto de matriz, una generalización de lo que conocemos como tablas con la posibilidad de dotarlas con operaciones algebraicas.

Matrices¶

Una matriz es un arreglo bidimensional, en Python se representa como una lista de listas y es preferible usar array del paquete numpy para poder hacer todo tipo de operaciones matriciales.

Escribimos primero

import numpy as np,

con el fin de llamar todas las funciones de numpy con el prefijo np.funcion.

import numpy as np

Veamos algunos ejemplos, dos matrices 3x3 A y B (observe que cada lista se define con corchetes "[", "]", para nuestro caso, como es una arreglo bidimensional usamos dos niveles de corchetes para lograr la lista de listas):

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

B = np.array([[1, 0, 5],
              [7, 5, 0],
              [2, 1, 1]])

A

array([[1, 3, 2],
       [1, 0, 0],
       [1, 2, 2]])

B

array([[1, 0, 5],
       [7, 5, 0],
       [2, 1, 1]])

Propiedades de la matriz y algunas matrices elementales¶

La cantidad de elementos y el tamaño son algunas propiedades de cualquier matriz, en Python contamos con funciones para encontrar esos valores y además tenemos la oportunidad de crear algunas matrices elementales.

Para las propiedades elementales escribimos el nombre de la matriz y luego la función:

Dimensión: [nombre de la matriz].shape

Cantidad de elementos: [nombre de la matriz].size

Para las matrices elementales usamos el paqueter numpy:

Matriz de unos de mxn: np.ones([m,n])

Matriz de ceros de mxn: np.zeros([m,n])

Matriz idéntidad de nxn: np.identity(n)

A.shape

(3, 3)

B.size

9

np.ones([4,5])

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

np.zeros([3,2])

array([[0., 0.],
       [0., 0.],
       [0., 0.]])

np.identity(5)

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

Suma y resta¶

La suma/resta de matrices se hace componente a componente, esto nos indica que las matrices deben tener las mimas dimensiones, a esto se le conoce en ser compatibles para la suma/resta. Por ejemplo, si tenemos dos matrices de tamaño $2\times2$

$$A=\begin{bmatrix}a&b\\c&d\end{bmatrix} \\ B=\begin{bmatrix}e&f\\ g&h \end{bmatrix}\\ A\pm B= \begin{bmatrix}a\pm e & b \pm f\\ c \pm g & d\pm h\end{bmatrix}$$

Si $C$ fuera una matriz de un tamaño diferente a $2\times2$ la suma con $A$ o $B$ sería imposible de calcular.

Ejemplo:¶

Verifique la suma y la resta de las matrices definidas en la celda de código anterior:

Solución:¶

A+B

array([[2, 3, 7],
       [8, 5, 0],
       [3, 3, 3]])

A-B

array([[ 0,  3, -3],
       [-6, -5,  0],
       [-1,  1,  1]])

Multiplicación por escalar¶

Com osu nombre lo indica se está multiplicando una matriz por un número real cualquiera, el número real $r$ podrá ser positivo negativo o inluso cero, y la matriz $A$ podrá ser de cualquier tamaño, el resultado de $rA$ es simplemente multiplicar cada entrada de $A$ por $r$.

Si $A$ es una matriz de $n$ filas y $m$ columnas

$$A=\left[ \begin{array}{llll} a_{11}& a_{12}&\ldots& a_{1m}\\ a_{21}& a_{22}&\ldots& a_{2m}\\ \ \ \ \vdots& \ \ \ \vdots& \ \vdots& \ \ \ \vdots\\ a_{n1}& a_{n2}&\ldots& a_{nm} \end{array} \right],\\ rA=\left[ \begin{array}{llll} ra_{11}& ra_{12}&\ldots& ra_{1m}\\ ra_{21}& ra_{22}&\ldots& ra_{2m}\\ \ \ \ \vdots& \ \ \ \vdots& \ \vdots& \ \ \ \vdots\\ ra_{n1}& ra_{n2}&\ldots& ra_{nm} \end{array} \right].$$

Ejemplo:¶

Teniendo en cuenta las matrices definidas anteriormente,calcule $3A$, $-2A$ y $\pi B$.

Solución:¶

3*A

array([[3, 9, 6],
       [3, 0, 0],
       [3, 6, 6]])

-2*A

array([[-2, -6, -4],
       [-2,  0,  0],
       [-2, -4, -4]])

np.pi*B ## Usamos un valor irracional muy conocido, el número PI

array([[ 3.14159265,  0.        , 15.70796327],
       [21.99114858, 15.70796327,  0.        ],
       [ 6.28318531,  3.14159265,  3.14159265]])

Transpuesta¶

La transpuesta es la operación sobre una matriz que cambia filas por columnas, para esta sección usaremos unas matrices rectangulares, observe que hacemos el arreglo bidimensional haciendo una lista de listas con la función np.array, cada lista interna representa una fila de la matriz:

M=np.array([[1,2,3,4],[-5,-6,-7,-8],[9,10,11,12]])

M

array([[ 1,  2,  3,  4],
       [-5, -6, -7, -8],
       [ 9, 10, 11, 12]])

np.transpose(M)

array([[ 1, -5,  9],
       [ 2, -6, 10],
       [ 3, -7, 11],
       [ 4, -8, 12]])

Multiplicación¶

A diferencia de las otras operaciones, la multiplicación no se hace componente a componente, se multiplican filas por columnas, y para que sean compatibles las matrices para el producto, la cantidad de columnas de la primera matriz debe coincidir con la cantidad de filas de la segunda, es decir

$$A_{nm}B_{ml}=C_{nl}$$

Debido a su definición tan estricta con el orden, se convierte en una de las primeras operaciones conocidas por nosotros que no es conmutativa.

Para que nos demos a una idea de la operación haremos un ejemplo:

$$A=\begin{bmatrix}1&2\\3&0\\5&-1\end{bmatrix},\ B=\begin{bmatrix}0&3&4&-1\\ 1&2&-1&0\end{bmatrix}$$

Como la matriz $A$ es de tamaño $3\times2$ y la matriz B es $2\times4$ el resultado será una matriz $3\times4$ $$A\times B=\begin{bmatrix}1\cdot0+2\cdot1&1\cdot3+2\cdot2& 1\cdot4+2\cdot(-1)&1\cdot(-1)+2\cdot0\\ 3\cdot0+0\cdot1&3\cdot3+0\cdot2& 3\cdot4+0\cdot(-1)&3\cdot(-1)+0\cdot0\\ 5\cdot0+(-1)\cdot1&5\cdot3+(-1)\cdot2& 5\cdot4+(-1)\cdot(-1)&5\cdot(-1)+(-1)\cdot0\end{bmatrix}\\ =\begin{bmatrix} 2&7&2&-1\\0&9&12&-3\\-1&13&21&-5\end{bmatrix}$$

Notemos que el producto de $B$ por $A$ no se puede realizar ya que $4\neq3.$

En Python usamos el comando @ para hacer esta multiplicación.

print(A) ## El comando print() permite visualizar un poco mejor la matriz.
print(M)

print("\n El resultado es:")
print(A@M)

[[1 3 2]
 [1 0 0]
 [1 2 2]]
[[ 1  2  3  4]
 [-5 -6 -7 -8]
 [ 9 10 11 12]]

 El resultado es:
[[ 4  4  4  4]
 [ 1  2  3  4]
 [ 9 10 11 12]]

Observe lo que ocurre cuando multiplicamos matrices con dimensiones no apropiadas

Ejercicio¶

Verifique las operaciones realizadas en la explicación con código de Python.

Matrices Inversas¶

Si una matriz cuadrada $A$ de $n\times n$ se multiplica por derecha e izquierda por una matriz $B$ y se obtiene la identidad en ambos casos, es decir $$AB=BA=I_n$$ La matriz $B$ se conoce como el inverso multiplicativo de la matriz $A$ o más comunmente como la matriz inversa de $A$.

No todas las matrices cuadradas tienen inversa, la forma de determinarla empleando Python es meduante la función np.linalg.inv

N = np.array([[1, 0, 1], [2, -1, 3], [4, 3, 2]])

Ninv=np.linalg.inv(N)
Ninv

array([[ 11.,  -3.,  -1.],
       [ -8.,   2.,   1.],
       [-10.,   3.,   1.]])

Comprobamos este resultado:

Ninv @ N

array([[ 1.00000000e+00, -2.22044605e-16, -4.44089210e-16],
       [ 0.00000000e+00,  1.00000000e+00,  4.44089210e-16],
       [ 0.00000000e+00,  2.22044605e-16,  1.00000000e+00]])

Observe que la anterior es la matriz idéntica.

Resolución de sistemas de ecuaciones lineales¶

El método más común para solucionar sistemas de ecuaciones es el conocido como Método de eliminación de Gauss-Jordan, el cual consiste básicamente en aplicar operaciones elementales a la matriz de coeficientes para hallar la solución del sistema, también se emplea para hallar inversas de martices.

Método de eliminación de Gauss Jordan¶

Si se tiene el sistema de ecuaciones

$$\begin{cases}2x-4y=6\\ -4x+6y=-14 \end{cases}$$

Se puede verificar de manera sencilla que su solución es $x=5$ y $y=1$.

Si se remplaza la segunda ecuación por la suma de las dos veces la primera más la segunda, obtendremos un nuevo sistema, el cual tiene como solución la misma de antes

$$\begin{cases}2x-4y=6\\ -y=-1 \end{cases}$$

Si se divide la segunda ecuación del primer sistema entre dos, obtenemos $$\begin{cases}2x-4y=6\\ -2x+3y=-7 \end{cases}$$ sistema el cual también posee la misma solución.

Y si cambiamos el orden en las ecuaciones $$\begin{cases}-4x+6y=-14\\2x-4y=6 \end{cases}$$ el sistema evidentemente tendrá las mismas soluciones.

Estas operaciones que acabamos de realizar sobre el sistema de ecuaciones son las conocidas como operaciones elementales, y éstas nunca van a cambiar las soluciones del sistema de ecuaciones. Éstas también pueden hacerse en columnas pero no es tan utilizado.

Operaciones elementales de fila¶

Cambio de filas.
Multiplicar una fila por una constante.
Sumar a una fila un múltiplo de ota.

Con esto en mente vale la pena trabajar con ellas para hallar la solución de un sistema de ecuaciones.

Como vimos anteriormente un sistema de ecuaciones se puede representar de manera matricial, por ejemplo

$$\begin{cases}2x-4y=6\\ -4x+6y=-14 \end{cases}$$

se puede ver como $$\begin{bmatrix} 2&-4\\-4&6\end{bmatrix}\begin{bmatrix} x\\y\end{bmatrix}=\begin{bmatrix} 6\\-14\end{bmatrix}$$ La idea fundamental de escribir el sistema de esta manera es aplicar las operaciones elementales, para obtener lo siguiente $$\begin{bmatrix} 1&0\\0&1\end{bmatrix}\begin{bmatrix} x\\y\end{bmatrix}=\begin{bmatrix} 5\\1\end{bmatrix}$$ ya que al realizar las operaciones de matrices obtendremos que $x=5$ y que $y$=1.

Realizaremos el procedimiento para la matriz que se tiene, con el fin de verificar la respuesta $$ \left[ \begin{array}{cc|c} 2&-4&6\\ -4&6&-14 \end{array} \right] $$ El primer paso será convertir el 2 que está en la diagonal principal en un 1, esto lo podemos hacer dividiendo toda la fila entre 2,

$$ \left[ \begin{array}{cc|c} 2&-4&6\\ -4&6&-14 \end{array} \right]\xrightarrow{f_1=\frac{1}{2}f_1}\left[ \begin{array}{cc|c} 1&-2&3\\ -4&6&-14 \end{array} \right] $$

Ya que tenemos el 1 en la diagonal principal debemos transformar en cero las demás entradas de la columna, en este caso al -4, esto se logra fácilmente sumando 4 veces la fila 1 a la fila 2 $$\left[ \begin{array}{cc|c} 1&-2&3\\ -4&6&-14 \end{array} \right]\xrightarrow{f_2=f_2+4f_1}\left[ \begin{array}{cc|c} 1&-2&3\\ 0&-2&-2 \end{array} \right] $$

Como ya se han anulado todos los elementos que no están en la diagonal principal, procedemos a volver 1 el siguiente elemento de la diagonal principal, en este caso al -2 que está en la segunda fila segunda columna.

$$\left[ \begin{array}{cc|c} 1&-2&3\\ 0&-2&-2 \end{array} \right]\xrightarrow{f_2=\frac{-1}{2}}\left[ \begin{array}{cc|c} 1&-2&3\\ 0&1&1 \end{array} \right] $$

Y finalmente anulamos todos los elementos que no estén sobre la diagonal principal $$\left[ \begin{array}{cc|c} 1&-2&3\\ 0&1&1 \end{array} \right]\xrightarrow{f_1=f_1+2f_2}\left[ \begin{array}{cc|c} 1&0&5\\ 0&1&1 \end{array} \right] $$ De modo que $x=5$ mientras que $y=1$.

Algoritmo¶

Si la entrada $a_{11}$ de la matriz no es un 1, debe transformase utilizando lasoperaciones elementales.
Volver cero todas las entradas de esa columnas que no estén sobre la diagonal principal.
Si la entrada $a_{22}$ de la matriz no es un 1, debe transformase utilizando lasoperaciones elementales.
Volver cero todas las entradas de esa columnas que no estén sobre la diagonal principal.
Repetir el proceso hasta agotar todas las columnas de la matriz.

Ejemplos:¶

Solucione el siguiente sistema de ecuaciones utilizando Gauss-Jordan $$\begin{cases}3x-15y=9\\ -6x+30y=0 \end{cases}$$

$$\left[ \begin{array}{cc|c} 3&-15&9\\ -6&30&0 \end{array} \right]\xrightarrow{f_1=\frac{1}{3}f_1}\left[ \begin{array}{cc|c} 1&-5&3\\ -6&30&0 \end{array} \right] \xrightarrow{f_2=f_2+6f_1}\left[ \begin{array}{cc|c} 1&-5&3\\ 0&0&18 \end{array} \right] $$

Como es imposible transformar la entrada de la diagonal principal en uno, el proceso termina con un nuevo sistema de ecuaciones $$\begin{cases}x-5y=3\\ 0=18\end{cases}$$

como la segunda ecuación representa algo falso, lo que se puede decir del sistema es que no tiene soluciones.

Emplee Gauss-Jordan para solucionar el sistema de ecuaciones $$\begin{cases} 3x+6y-9z=18\\ -6x+8y-10z=4\\ -2x+6y-8z=8\end{cases}$$

$$\left[ \begin{array}{ccc|c} 3&6&-9&18\\ -6&8&-10&4\\ -2&6&-8&8 \end{array} \right] \xrightarrow{f_1=\frac{1}{3}f_1}\left[ \begin{array}{ccc|c} 1&2&-3&6\\ -6&8&-10&4\\ -2&6&-8&8 \end{array} \right] \xrightarrow{f_2=f_2+6f_1}\left[ \begin{array}{ccc|c} 1&2&-3&6\\ 0&20&-28&40\\ -2&6&-8&8 \end{array} \right]\xrightarrow{f_3=f_3+2f_1}\left[ \begin{array}{ccc|c} 1&2&-3&6\\ 0&20&-28&40\\ 0&10&-14&20 \end{array} \right] \xrightarrow{f_2=\frac{1}{20}f_2}\left[ \begin{array}{ccc|c} 1&2&-3&6\\ 0&1&-\frac{7}{5}&2\\ 0&10&-14&20 \end{array} \right] \xrightarrow{f_3=f_3-10f_2}\left[ \begin{array}{ccc|c} 1&2&-3&6\\ 0&1&-\frac{7}{5}&2\\ 0&0&0&0 \end{array} \right] $$

Como los elementos de la última fila son todos nulos, podemos afirmar que el sistema tiene infinitas soluciones.

Ahora con Python¶

El método que utilizamos para encontrar la solución de un sistema de ecuaciones lineales fue el método de eliminación de Gauss Jordan, si bien con la tabla definida en clase es muy sencillo definir un algoritmo para dicho proceso, es útil conocer funciones que nos permitan hacer ese cálculo.

Para esta sección usaremos otro paquete bien conocido en Python, el paquete sympy, iniciamos importandolo:

from sympy import *
init_printing()

La forma de importar este paquete nos permite usar todas las funciones de sympy sin necesidad del prefijo. init_printing() es una función que nos facilitara la lectura de las matrices que usamos.

el paquete sympy es un paquete de matemática simbólica, es decir, buscará ser lo más fiel al lenguaje usado en clase.

Iniciamos definiendo una matriz con la función Matrix.

Matrix([[1, -1], [3, 4], [0, 2]])

Con este paque se pueden redefinir las operaciones descritas en la sección anterior con numpy, tenemos por ejemplo:

A=Matrix([[1,2,3],[0,1,2],[-1,1,3]])
B=Matrix([[1,-1,1],[0,1,1],[-1,10,31]])
A , B

Suma

A+B

Resta

A-B

Sumando como en el tablero, usando simbolos matriciales:

s=MatrixSymbol("+",3,3)
e=MatrixSymbol("=",3,3)
(A *s*B)*e*(A+B)

Producto

A*B

Transpuesta

Transpose(A)##Escrita

A.T ##Calculada

Inversa

B**(-1)

No obstante, lo que queremos es hacer la reducción de Gauss Jordan para las matrices que pueden asociarse o bien a un problema de sistemas o a un problema de inversas. Para esto usamos la función rref:

Resolveremos el siguiente sistema:

$$ \begin{cases}x+y+z=1\\ 2x+2y+4z=0 \\ x+z=0 \end{cases}$$

Iniciamos definiendo la matriz aumentada del sistema:

S=Matrix([[1,1,1,1],[2,2,4,0],[1,0,1,0]])
S

Ahora lo reducimos:

S.rref()

La primera parte de la respuesta nos entrega la forma escalonada reducida de la matriz y la segunda indica el indice de los pivotes que se encontraron en dicha forma. De aquí es fácil notar que la solución del sistema es:

$$ \begin{cases} x=1\\ y=1 \\z=-1 \end{cases} $$

Otro ejemplo, para el sistema:

$$\begin{cases}x+z=3\\ 2x+3y+4z=7\\ -x-3y-z=-4 \end{cases}$$

S2=Matrix([[1, 0, 1, 3], [2, 3, 4, 7], [-1, -3, -3, -4]])
S2

S2.rref()

La solución aquí es infinita, tenemos:

$$\begin{cases} x=3-t\\ y=\frac{1}{3}-\frac{2}{3}t \\ z=t \end{cases} $$

para todo $ t\in \mathbb{R}$.

Determinantes¶

Muchas veces necesitamos conocer de antemano si el problema al que nos enfrentamos tiene una solución única, para ello basta realizar un cálculo sencillo sobre el cual hablaremos enseguida.

¿Qué es un determinante?

El determinante es un número real asociado a cada matriz cuadrada, el cual nos permitirá, primero que nada, saber la cantidad de soluciones que tiene un sistema y en segundo lugar el valor de la solución cuando ésta sea única. El determinante de una matriz puede ser cualquier número real.

Es conveniente entender primero como calcular determinantes de matrices $2\times 2$ para luego calcular los deteminantes de mayor orden.

Notación: Para indicar que se va a calcular el determinante de la matriz $A$ es común encontrar las notaciones $det(A)$ o $|A|$.

Ejemplo: Halle el determinante de la matriz $\begin{pmatrix}1&3\\ \:4&2\end{pmatrix}$.

Podemos escribir $det\begin{pmatrix}1&3\\ \:4&2\end{pmatrix}=\begin{vmatrix}1&3\\ \:4&2\end{vmatrix}$

¿Cómo se calcula?¶

En realidad es una cuenta bastante simple, es el producto de la diagonal menos el producto de la antidiagonal, es decir $$\begin{vmatrix}a_{11}&a_{12}\\ \:a_{21}&a_{22}\end{vmatrix}=a_{11}a_{22}-a_{12}a_{21}$$

Ejemplos

$$\begin{vmatrix}1&3\\ \:4&2\end{vmatrix}=(1)(2)-(3)(4)=-10$$
$$\begin{vmatrix}-4&3\\ \:-1&-6\end{vmatrix}=(-4)(-6)-(-1)(3)=27$$
$$\begin{vmatrix}2&4\\ \:-4&-8\end{vmatrix}=(2)(-8)-(4)(-4)=0$$

¿Qué pasa si la matriz es de mayor orden?¶

Primero que nada se deben definir los cofactores: el cofactor asociado al elemento $a_{ij}$ de una matriz de tamaño $n\times n$ se define como $$C_{ij}=(-1)^{i+j}M_{ij}$$ Siendo $M_{ij}$ la matriz obtenida al eliminar la fila $i$ y la columna $j$ de la matriz original.

Ejemplo: Hallar el cofactor $C_{23}$ correspondiente a la matriz $A=\begin{pmatrix}1&2&0\\ \:-1&1&1\\ \:2&-1&0\end{pmatrix}$.

Al eliminar la segunda fila y la tercera columna se obtiene la matriz Imagen por lo cual $$C_{23}=(-1)^{2+3}\begin{vmatrix}1&2\\ \:2&-1\end{vmatrix}=(-1)(-5)=5$$

Algoritmo¶

La idea será la siguiente:

Elegir una fila (o una columna) .
Hallar los cofactores correspondientes a cada uno de los elementos de la fila (o columna).
Multiplicar los valores de las entradas por sus respectivos cofactores .
Realizar la suma de los resultados obtenidos en el paso 3.

Vamos a hallar el determinante de la matriz anterior utilizando la primera fila, como también la tercera columna, esto con el fin de mostrar que no importa cual se elija, el resultado será el mismo y también para que siempre se elija la fila o columna con mayor cantidad de entradas nulas.

Determinante seleccionando la primera fila:

Imagen Notemos que como la entrada $A_{23}$ es cero, el sumando asociado a ésta no aporta nada para calcular el determinante.

Determinante seleccionando la tercera columna:

Siguiendo la observación anterior en la tercera columna se tienen 2 entradas cuyo valor es cero, por lo que su aporte al determinante es nulo, basta calcular únicamente el cofactor $C_{23}$ multiplicarlo por su respectiva entrada y obtendríamos el valor del determinante así Imagen

Ejercicios:¶

Calcule:
1. $\begin{vmatrix}0&1\\ \:5&2\end{vmatrix}$
2. $\begin{vmatrix}4&4\\ \:-2&-2\end{vmatrix}$
3. $\begin{vmatrix}-4&3\\ \:0&1\end{vmatrix}$
4. $\begin{vmatrix}0&0&0\\ \:4&2&3\\ \:-1&3&9\end{vmatrix}$
5. $\begin{vmatrix}0&0&0\\ \:4&2&3\\ \:-1&3&9\end{vmatrix}$
6. Haga una función en Python que le permita calcular el cofactor indicado por el usuario en una matriz arbitraria.

¿Cómo lo hago en Python?¶

En realidad es bastante simple, ya que la librería Sympy tiene una función que premite hallar el determinante directamente.

matriz.det()

from sympy import *

init_printing(use_unicode=True)

M=Matrix([[1,2,0], [1,1,1], [2,-1,0]])
M

M.col(2)

M.row(1)

M.det()

Matrix([[-3,2,4], [2,0,3], [0.5,1,2]]).det()

Ejercicio¶

Utilice la función .det() para corroborar los resultados obtenidos anteriormente.

¿Cómo puedo aplicar los determinantes?¶

Como vimos anteriormente los sistemas de ecuaciones se pueden representar de manera matricial de la siguiente manera: $$Ax=b$$ Si el determinante de $A$ fuese nulo, el sistema puede tener infinitas o ninguna solución, mientras que si es diferente de cero tendrá una única solución.

Ejemplo:¶

¿El siguiente sistema tiene una única solución? $$\begin{cases} 3x+y=0\\ 2x-6y=5\end{cases}$$

Para responder a la pregunta formulada basta hallar el determinante de la matriz de coeficientes del sistema $$\begin{vmatrix}3&1\\ \:2&-6\end{vmatrix}=-20\neq0$$ por lo tanto el sistema posee una única solución.

¿Se puede hallar la solución del sistema utilizando determinantes?¶

A éste proceso se le conoce como la Regla de Cramer y consiste en lo siguiente:

Se debe calcular el determinante de la matriz de coeficientes.
Se remplaza la columna correspondiente a la primera variable por los elementos que conforman al vector $b$, obteniendo una nueva matriz.
El proceso anterior se repite con todas las variables que tenga el sistema, es decir, se obtendrán tantas matrices como variables tiene el sistema.
Se calculan los determinantes de las matrices anteriores.
El valor de cada variable será el obtenido al dividir el determinante de la matriz en la cual se remplazó en vector $b$ por tal variable, entre el determinante de la matriz $A$.

Ejemplo:¶

Para tener una guía de lo que se está realizando es sano escribir como sub-índice la variable que se está remplazando por el vector $b$, por ejemplo $$|A_x|=\begin{vmatrix}0&1\\ \:5&-6\end{vmatrix}=-5.$$ $$|A_y|=\begin{vmatrix}3&0\\ \:2&5\end{vmatrix}=15.$$ Por lo tanto $$x=\frac{|A_x|}{|A|}=\frac{-5}{-20}=\frac{1}{4}.$$ $$y=\frac{|A_y|}{|A|}=\frac{15}{-20}=-\frac{3}{4}.$$

Problema¶

Un carpintero fabrica sillas, mesas y repisas.Se necesitan 15 minutos para lijar una silla, 5 para pintarla y 10 para barnizarla. Se necesitan 30 minutos para lijar una mesa, 12 para pintarla y 20 para barnizarla. Se necesitan 20 minutos para lijar una repisa, 10 para pintarla y 15 para barnizarla. La mesa de lijado está disponible 235 horas al mes, la mesa de pintura 95 horas al mes y la mesa de barnizado 160 horas. ¿Cuántas unidades de cada mueble deben fabricarse por mes de modo que las mesas de trabajo se ocupen todo el tiempo disponible?

Solución¶

Dado que las unidades de fabricación vienen dada en minutos y la catidad de tiempo total viene dada en horas, procederemos a convertir las horas en minutos, así

$$\text{Conversión de horas a minutos, debemos multiplicar por 60 }\ \ \begin{cases} 235h\rightarrow14100m\\95h\rightarrow5700m\\160h\rightarrow9600m\end{cases}$$

Por lo tanto el sistema se puede expresar como $$\begin{cases} 15s+30m+20r=14100\\ 5s+12m+10r=5700\\ 10s+20m+15r=9600 \end{cases}$$

A=Matrix([[15,30,20],[5,12,10],[10,20,15]])
A

A.det()

En vista que el determinante de la matriz de coeficientes es diferente de cero, sabemos que el sistema tendrá una única solución, aplicando la regla de Cramer tenemos lo siguiente

As=Matrix([[14100,30,20],[5700,12,10],[9600,20,15]])
As

Am=Matrix([[15,14100,20],[5,5700,10],[10,9600,15]])
Am

Ar=Matrix([[15,30,14100],[5,12,5700],[10,20,9600]])
Ar

Por lo tanto la solución del sistema de ecuaciones viene dada por:

s=As.det()/A.det()
s

m=Am.det()/A.det()
m

r=Ar.det()/A.det()
r

Se deben fabricar mensualmete 180 sillas, 300 mesas y 120 repisas.