<h1>Álgebra Lineal<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Matrices" data-toc-modified-id="Matrices-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>Matrices</a></span><ul class="toc-item"><li><span><a href="#Propiedades-de-la-matriz-y-algunas-matrices-elementales" data-toc-modified-id="Propiedades-de-la-matriz-y-algunas-matrices-elementales-1.1"><span class="toc-item-num">1.1&nbsp;&nbsp;</span>Propiedades de la matriz y algunas matrices elementales</a></span></li><li><span><a href="#Exploración-de-matrices" data-toc-modified-id="Exploración-de-matrices-1.2"><span class="toc-item-num">1.2&nbsp;&nbsp;</span>Exploración de matrices</a></span></li><li><span><a href="#Suma-y-resta" data-toc-modified-id="Suma-y-resta-1.3"><span class="toc-item-num">1.3&nbsp;&nbsp;</span>Suma y resta</a></span></li><li><span><a href="#Ejemplo:" data-toc-modified-id="Ejemplo:-1.4"><span class="toc-item-num">1.4&nbsp;&nbsp;</span>Ejemplo:</a></span><ul class="toc-item"><li><span><a href="#Solución:" data-toc-modified-id="Solución:-1.4.1"><span class="toc-item-num">1.4.1&nbsp;&nbsp;</span>Solución:</a></span></li></ul></li><li><span><a href="#Multiplicación-por-escalar" data-toc-modified-id="Multiplicación-por-escalar-1.5"><span class="toc-item-num">1.5&nbsp;&nbsp;</span>Multiplicación por escalar</a></span></li><li><span><a href="#Ejemplo:" data-toc-modified-id="Ejemplo:-1.6"><span class="toc-item-num">1.6&nbsp;&nbsp;</span>Ejemplo:</a></span><ul class="toc-item"><li><span><a href="#Solución:" data-toc-modified-id="Solución:-1.6.1"><span class="toc-item-num">1.6.1&nbsp;&nbsp;</span>Solución:</a></span></li></ul></li><li><span><a href="#Transpuesta" data-toc-modified-id="Transpuesta-1.7"><span class="toc-item-num">1.7&nbsp;&nbsp;</span>Transpuesta</a></span></li><li><span><a href="#Multiplicación" data-toc-modified-id="Multiplicación-1.8"><span class="toc-item-num">1.8&nbsp;&nbsp;</span>Multiplicación</a></span></li><li><span><a href="#Ejercicio" data-toc-modified-id="Ejercicio-1.9"><span class="toc-item-num">1.9&nbsp;&nbsp;</span>Ejercicio</a></span></li><li><span><a href="#Análisis-de-la-multiplicación-en-las-aplicaciones" data-toc-modified-id="Análisis-de-la-multiplicación-en-las-aplicaciones-1.10"><span class="toc-item-num">1.10&nbsp;&nbsp;</span>Análisis de la multiplicación en las aplicaciones</a></span></li><li><span><a href="#Matrices-Inversas" data-toc-modified-id="Matrices-Inversas-1.11"><span class="toc-item-num">1.11&nbsp;&nbsp;</span>Matrices Inversas</a></span></li></ul></li><li><span><a href="#Resolución-de-sistemas-de-ecuaciones-lineales" data-toc-modified-id="Resolución-de-sistemas-de-ecuaciones-lineales-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>Resolución de sistemas de ecuaciones lineales</a></span><ul class="toc-item"><li><span><a href="#Método-de-eliminación-de-Gauss-Jordan" data-toc-modified-id="Método-de-eliminación-de-Gauss-Jordan-2.1"><span class="toc-item-num">2.1&nbsp;&nbsp;</span>Método de eliminación de Gauss Jordan</a></span><ul class="toc-item"><li><span><a href="#Operaciones-elementales-de-fila" data-toc-modified-id="Operaciones-elementales-de-fila-2.1.1"><span class="toc-item-num">2.1.1&nbsp;&nbsp;</span>Operaciones elementales de fila</a></span></li><li><span><a href="#Algoritmo" data-toc-modified-id="Algoritmo-2.1.2"><span class="toc-item-num">2.1.2&nbsp;&nbsp;</span>Algoritmo</a></span></li><li><span><a href="#Ejemplos:" data-toc-modified-id="Ejemplos:-2.1.3"><span class="toc-item-num">2.1.3&nbsp;&nbsp;</span>Ejemplos:</a></span></li></ul></li><li><span><a href="#Ahora-con-Python" data-toc-modified-id="Ahora-con-Python-2.2"><span class="toc-item-num">2.2&nbsp;&nbsp;</span>Ahora con Python</a></span></li></ul></li><li><span><a href="#Determinantes" data-toc-modified-id="Determinantes-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>Determinantes</a></span><ul class="toc-item"><li><span><a href="#¿Cómo-se-calcula?" data-toc-modified-id="¿Cómo-se-calcula?-3.1"><span class="toc-item-num">3.1&nbsp;&nbsp;</span>¿Cómo se calcula?</a></span></li><li><span><a href="#¿Qué-pasa-si-la-matriz-es-de-mayor-orden?" data-toc-modified-id="¿Qué-pasa-si-la-matriz-es-de-mayor-orden?-3.2"><span class="toc-item-num">3.2&nbsp;&nbsp;</span>¿Qué pasa si la matriz es de mayor orden?</a></span><ul class="toc-item"><li><span><a href="#Algoritmo" data-toc-modified-id="Algoritmo-3.2.1"><span class="toc-item-num">3.2.1&nbsp;&nbsp;</span>Algoritmo</a></span></li></ul></li><li><span><a href="#Ejercicios:" data-toc-modified-id="Ejercicios:-3.3"><span class="toc-item-num">3.3&nbsp;&nbsp;</span>Ejercicios:</a></span></li><li><span><a href="#¿Cómo-lo-hago-en-Python?" data-toc-modified-id="¿Cómo-lo-hago-en-Python?-3.4"><span class="toc-item-num">3.4&nbsp;&nbsp;</span>¿Cómo lo hago en Python?</a></span><ul class="toc-item"><li><span><a href="#Ejercicio" data-toc-modified-id="Ejercicio-3.4.1"><span class="toc-item-num">3.4.1&nbsp;&nbsp;</span>Ejercicio</a></span></li></ul></li><li><span><a href="#¿Cómo-puedo-aplicar-los-determinantes?" data-toc-modified-id="¿Cómo-puedo-aplicar-los-determinantes?-3.5"><span class="toc-item-num">3.5&nbsp;&nbsp;</span>¿Cómo puedo aplicar los determinantes?</a></span><ul class="toc-item"><li><span><a href="#Ejemplo:" data-toc-modified-id="Ejemplo:-3.5.1"><span class="toc-item-num">3.5.1&nbsp;&nbsp;</span>Ejemplo:</a></span></li></ul></li><li><span><a href="#¿Se-puede-hallar-la-solución-del-sistema-utilizando-determinantes?" data-toc-modified-id="¿Se-puede-hallar-la-solución-del-sistema-utilizando-determinantes?-3.6"><span class="toc-item-num">3.6&nbsp;&nbsp;</span>¿Se puede hallar la solución del sistema utilizando determinantes?</a></span><ul class="toc-item"><li><span><a href="#Ejemplo:" data-toc-modified-id="Ejemplo:-3.6.1"><span class="toc-item-num">3.6.1&nbsp;&nbsp;</span>Ejemplo:</a></span></li><li><span><a href="#Problema" data-toc-modified-id="Problema-3.6.2"><span class="toc-item-num">3.6.2&nbsp;&nbsp;</span>Problema</a></span></li><li><span><a href="#Solución" data-toc-modified-id="Solución-3.6.3"><span class="toc-item-num">3.6.3&nbsp;&nbsp;</span>Solución</a></span></li></ul></li></ul></li></ul></div>


```python

```

 <div style="background-color: #023324; "><p><br></p>
    
         <h1  style="color: white;font-family:Lucida Sans Unicode, Lucida Grande, sans-serif" align="center">Álgebra Lineal - Fundamentos     </h1> 
<p><br></p>
</div>    


<p><br></p>

Pensemos en la siguiente situación:



Cada uno de los vendedores entregarán tablas como las siguientes:
<table >
  <tr>
    <th style="background-color:tomato; color:white">Vendedor 1</th>
    <th>Lunes</th>      
    <th>Martes</th>
    <th>Miércoles</th>
    <th>Jueves</th>
    <th>Viernes</th>
  </tr>
  <tr>
    <td> <b>Producto1</b> </td>
    <td>30</td>
    <td>50</td>
    <td>40</td>
    <td>20</td>
    <td>50</td>
  </tr>

  <tr>
    <td> <b>Producto2</b> </td>
    <td>35</td>
    <td>25</td>
    <td>45</td>
    <td>15</td>
    <td>20</td>
  </tr>
    
  <tr>
    <td> <b>Producto3</b> </td>
    <td>30</td>
    <td>10</td>
    <td>25</td>
    <td>25</td>
    <td>15</td>
  </tr>
  
</table>
<table >
  <tr>
    <th style="background-color:slateblue; color:white">Vendedor 2</th>
    <th>Lunes</th>      
    <th>Martes</th>
    <th>Miércoles</th>
    <th>Jueves</th>
    <th>Viernes</th>
  </tr>
  <tr>
    <td> <b>Producto1</b> </td>
    <td>10</td>
    <td>70</td>
    <td>30</td>
    <td>60</td>
    <td>20</td>
  </tr>

  <tr>
    <td> <b>Producto2</b> </td>
    <td>35</td>
    <td>25</td>
    <td>75</td>
    <td>25</td>
    <td>45</td>
  </tr>
    
  <tr>
    <td> <b>Producto3</b> </td>
    <td>35</td>
    <td>15</td>
    <td>15</td>
    <td>15</td>
    <td>25</td>
  </tr>
  
</table>
<ul>
<li > ¿Cómo sintetiza la información entregada por los dos vendedores?</li>
<li > ¿Obtendría una información similar?</li>
<li > ¿Cómo expresaría la diferencia de ventas entre vendedores de acuerdo al día de la semana?</li>
<li > ¿Cómo expresaría las ventas de la distribuidora en esa semana si quiere evaluar el desempeño diario de sus vendedores?</li>
</ul>

 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 <b>dimensiones</b> 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 <b>componente a componente</b> y la tabla se estructura como un elemento que se puede <i>"sumar"</i>  y  <i>"restar"</i>. 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*. 


```python
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):


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

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


```python
A
```




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




```python
B
```




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




```python
## Una matriz 4x5
C=np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20]])
```


```python
C
```




    array([[ 1,  2,  3,  4,  5],
           [ 6,  7,  8,  9, 10],
           [11, 12, 13, 14, 15],
           [16, 17, 18, 19, 20]])




```python
C.dtype
```




    dtype('int64')



### 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)*



```python
C.shape
```




    (4, 5)




```python
A.shape
```




    (3, 3)




```python
## Una matriz de 3x5

V1=np.array([[30,50,40,20,50],[35,25,45,15,20],[30,10,25,25,15]])

```


```python
V1
```




    array([[30, 50, 40, 20, 50],
           [35, 25, 45, 15, 20],
           [30, 10, 25, 25, 15]])




```python
V1.shape
```




    (3, 5)




```python
V1.size
```




    15




```python
B.size
```




    9




```python
Matriz_de_unos=np.ones([4,5])
```


```python
Matriz_de_unos
```




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




```python
Matriz_de_ceros=np.zeros([3,2])
Matriz_de_ceros
```




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




```python
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.]])



**Algunas definiciones**

*Matriz cuadrada:* Es una matriz con la misma cantidad de filas y columnas.

*Matriz identidad:* Es una matriz cuadrada que en la diagonal (elementos que están ubicados en la misma fila y columna)  tiene unos y fuera de la diagonal tiene ceros. 

**Ejemplo**

$$\begin{pmatrix}1&0&0\\ 0&1&0\\ 0&0&1\end{pmatrix}$$

### Exploración de matrices

En general, una matriz de mxn tiene m filas y n columnas, y nos referimos a ella de manera unívoca cuando conocemos todos sus elementos y sus posiciones.

En otras palabras, una matriz es igual a otra si tiene la misma dimensión, los mismo elementos y ellos ocupan los mismos lugares:


$$\begin{pmatrix}1&2&3\\ 0&1&0\\ 0&4&1\end{pmatrix}\neq\begin{pmatrix}1&2&3\\ 0&1&0\\ 0&1&4\end{pmatrix}$$

**Notación de los elementos de una matriz**

Sea $A$ una matriz mxn, el elemento $a_{i j}$ cooresponde al elemento de la fila i-ésima y la columna j-ésima de la matriz. En Python se maneja la misma idea pero contando desde ***cero***.


```python
## Una matriz 3x3

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

```


```python
A
```




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




```python
B
```




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




```python
A==B
```




    array([[ True,  True,  True],
           [ True,  True,  True],
           [ True, False, False]])




```python
A[3,2] #Genera error porque no cuenta desde cero
```


```python
A[2,1]
```




    4




```python
B[2,1]
```




    1



**Muy importante tener en cuenta que las posiciones en Python están afectadas por iniciar siempre desde cero**

### 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:


```python
A
```




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




```python
B
```




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




```python
A+B
```




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




```python
A-B
```




    array([[ 0,  0,  0],
           [ 0,  0,  0],
           [ 0,  3, -3]])



### Multiplicación por escalar
Como su 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:


```python
A
```




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




```python
3*A
```




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




```python
-2*A
```




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




```python
B
```




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




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




    array([[ 3.14159265,  6.28318531,  9.42477796],
           [ 0.        ,  3.14159265,  0.        ],
           [ 0.        ,  3.14159265, 12.56637061]])



**Otros Ejemplos**

Ingresemos la matrices de ventas expuesta en el inicio de este cuaderno:

<table >
  <tr>
    <th style="background-color:tomato; color:white">Vendedor 1</th>
    <th>Lunes</th>      
    <th>Martes</th>
    <th>Miércoles</th>
    <th>Jueves</th>
    <th>Viernes</th>
  </tr>
  <tr>
    <td> <b>Producto1</b> </td>
    <td>30</td>
    <td>50</td>
    <td>40</td>
    <td>20</td>
    <td>50</td>
  </tr>

  <tr>
    <td> <b>Producto2</b> </td>
    <td>35</td>
    <td>25</td>
    <td>45</td>
    <td>15</td>
    <td>20</td>
  </tr>
    
  <tr>
    <td> <b>Producto3</b> </td>
    <td>30</td>
    <td>10</td>
    <td>25</td>
    <td>25</td>
    <td>15</td>
  </tr>
  
</table>
<table >
  <tr>
    <th style="background-color:slateblue; color:white">Vendedor 2</th>
    <th>Lunes</th>      
    <th>Martes</th>
    <th>Miércoles</th>
    <th>Jueves</th>
    <th>Viernes</th>
  </tr>
  <tr>
    <td> <b>Producto1</b> </td>
    <td>10</td>
    <td>70</td>
    <td>30</td>
    <td>60</td>
    <td>20</td>
  </tr>

  <tr>
    <td> <b>Producto2</b> </td>
    <td>35</td>
    <td>25</td>
    <td>75</td>
    <td>25</td>
    <td>45</td>
  </tr>
    
  <tr>
    <td> <b>Producto3</b> </td>
    <td>35</td>
    <td>15</td>
    <td>15</td>
    <td>15</td>
    <td>25</td>
  </tr>
  
</table>


```python
V1 = np.array ([[30, 50, 40, 20, 50],[35,25,45,15,20],[30,10,25,25,15]]) 
V2=np.array([[10, 70, 30, 60, 20],[35, 25, 75, 25, 45],[35, 15, 15, 15, 25]]) 
```


```python
print("Vendedor 1:")
print(V1)
print("\n\nVendedor 2:")
print(V2)
```

    Vendedor 1:
    [[30 50 40 20 50]
     [35 25 45 15 20]
     [30 10 25 25 15]]
    
    
    Vendedor 2:
    [[10 70 30 60 20]
     [35 25 75 25 45]
     [35 15 15 15 25]]


**¿Cómo interpretamos la siguiente operación?**


```python
V1+V2
```




    array([[ 40, 120,  70,  80,  70],
           [ 70,  50, 120,  40,  65],
           [ 65,  25,  40,  40,  40]])



> Obtenemos una matriz que expresa la venta realizada por los dos vendedores durante esa semana.

**Suponga que el vendedor 1 tuvo el mismo desempeño en ventas durante 4 semanas ¿Cómo expreso una tabla que me permita determinar el total de ventas que el vendedor 1 hizo cada día de la semana, por producto?**

> Usamos multiplicación por escalar, particularmente, 4*V1.


```python
4*V1
```




    array([[120, 200, 160,  80, 200],
           [140, 100, 180,  60,  80],
           [120,  40, 100, 100,  60]])



**Ayuda visual para entender la matriz**


```python
import seaborn as sns
ax=sns.heatmap(V1,annot=True)
```

### 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:


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


```python
M
```




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




```python
np.transpose(M)
```




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



## Multiplicación falsa (componente a componente) de Python

Lo que obtenemos al multiplicar dos matrices en Python con el símbolo *, es una multiplicación componente a componente que no tiene sentido en matemáticas:


```python
V1
```




    array([[30, 50, 40, 20, 50],
           [35, 25, 45, 15, 20],
           [30, 10, 25, 25, 15]])




```python
V2
```




    array([[10, 70, 30, 60, 20],
           [35, 25, 75, 25, 45],
           [35, 15, 15, 15, 25]])




```python
V1*V2
```




    array([[ 300, 3500, 1200, 1200, 1000],
           [1225,  625, 3375,  375,  900],
           [1050,  150,  375,  375,  375]])




### 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.


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

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

    [[1 2 3]
     [0 1 0]
     [0 4 1]]
    [[ 1  2  3  4]
     [-5 -6 -7 -8]
     [ 9 10 11 12]]
    
     El resultado es:
    [[ 18  20  22  24]
     [ -5  -6  -7  -8]
     [-11 -14 -17 -20]]



```python
print(M.shape)
print(A.shape)
A@M
```

    (3, 4)
    (3, 3)





    array([[ 18,  20,  22,  24],
           [ -5,  -6,  -7,  -8],
           [-11, -14, -17, -20]])



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.


```python
V1
```




    array([[30, 50, 40, 20, 50],
           [35, 25, 45, 15, 20],
           [30, 10, 25, 25, 15]])




```python
P=np.array([[40],[60],[80],[80],[20]])
P
```




    array([[40],
           [60],
           [80],
           [80],
           [20]])




```python
Ventas_V1=V1@P
Ventas_V1
```




    array([[10000],
           [ 8100],
           [ 6100]])




```python
Ventas_V2=V2@P
Ventas_V2
```




    array([[12200],
           [11800],
           [ 5200]])



### Análisis de la multiplicación en las aplicaciones

El vendedor 1 del ejemplo anterior tenía estas ventas semanales:

<table >
  <tr>
    <th style="background-color:tomato; color:white">Vendedor 1</th>
    <th>Lunes</th>      
    <th>Martes</th>
    <th>Miércoles</th>
    <th>Jueves</th>
    <th>Viernes</th>
  </tr>
  <tr>
    <td> <b>Producto1</b> </td>
    <td>30</td>
    <td>50</td>
    <td>40</td>
    <td>20</td>
    <td>50</td>
  </tr>

  <tr>
    <td> <b>Producto2</b> </td>
    <td>35</td>
    <td>25</td>
    <td>45</td>
    <td>15</td>
    <td>20</td>
  </tr>
    
  <tr>
    <td> <b>Producto3</b> </td>
    <td>30</td>
    <td>10</td>
    <td>25</td>
    <td>25</td>
    <td>15</td>
  </tr>
  
</table>
Suponga que vamos a darle una comisión según el producto a cada integrante del equipo de ventas, según la siguiente tabla:

||Producto 1|Producto 2|Producto 3|
|:---:|:---:|:---:|:---:|
|Comisión|\$20.000 |\$30.000|\$50.000|


```python
Comision=np.array([[20,30,50]])
```


```python
V1
```




    array([[30, 50, 40, 20, 50],
           [35, 25, 45, 15, 20],
           [30, 10, 25, 25, 15]])




```python
Comision_dia=Comision@V1
print(Comision_dia.sum())
print(Ventas_V1.sum())
```

    13250
    24200


**Observaciones profundas de este caso:**


```python
P=np.array([[40],[80],[80],[20],[60]])
P
```




    array([[40],
           [80],
           [80],
           [20],
           [60]])




```python
Ventas_V1_nueva=V1@P
Ventas_V1_nueva.sum()
```




    25700




```python
Ventas_V2_nueva=V2@P
Ventas_V2_nueva.sum()
```




    29000



## Utilidad del ejercicio de ventas

Calculamos la utilidad, aprovechando que ya sabemos como calcular las ventas y las comisiones. Es claro que:

> **U=V-C**



```python
Ventas_Totales=(V1+V2)@P
Ventas_Totales
```




    array([[22600],
           [21100],
           [11000]])




```python
Comision_Total=Comision@(V1+V2)
Comision_Total
```




    array([[6150, 5150, 7000, 4800, 5350]])




```python
Utilidad=Ventas_Totales.sum()-Comision_Total.sum()
Utilidad
```




    26250




```python
P=np.array([[40],[80],[80],[20],[60]])
Comision=np.array([[20,30,50]])

Ventas_Totales=(V1+V2)@P
Comision_Total=Comision@(V1+V2)
Utilidad=Ventas_Totales.sum()-Comision_Total.sum()

print('Total de ventas es:',Ventas_Totales.sum())
print('Comision_Total es: ',Comision_Total.sum())
print('Utilidad es: ',Utilidad)
```

    Total de ventas es: 54700
    Comision_Total es:  28450
    Utilidad es:  26250



```python
P=np.array([[60],[80],[80],[20],[40]])
Comision=np.array([[30,20,50]])

Ventas_Totales=(V1+V2)@P
Comision_Total=Comision@(V1+V2)
Utilidad=Ventas_Totales.sum()-Comision_Total.sum()

print('Total de ventas es:',Ventas_Totales.sum())
print('Comision_Total es: ',Comision_Total.sum())
print('Utilidad es: ',Utilidad)
```

    Total de ventas es: 54700
    Comision_Total es:  28800
    Utilidad es:  25900


La idea de unificar el proces es crear una función que me permita trabajar con más libertad:


```python
def Utilidaddelej(p1,p2,p3,p4,p5,c1,c2,c3):
    P=np.array([[p1],[p2],[p3],[p4],[p5]])
    Comision=np.array([[c1,c2,c3]])

    Ventas_Totales=(V1+V2)@P
    Comision_Total=Comision@(V1+V2)
    Utilidad=Ventas_Totales.sum()-Comision_Total.sum()

    print('Total de ventas es:',Ventas_Totales.sum())
    print('Comision_Total es: ',Comision_Total.sum())
    print('Utilidad es: ',Utilidad)
    return Utilidad
```


```python
Utilidaddelej(50,80,80,40,60,20,30,50)
```

    Total de ventas es: 59650
    Comision_Total es:  28450
    Utilidad es:  31200





    31200




```python
import ipywidgets as widgets
from ipywidgets import interact

interact(Utilidaddelej,p1=40,p2=80,p3=80,p4=20,p5=60,c1=20,c2=30,c3=50)
```


    interactive(children=(IntSlider(value=40, description='p1', max=120, min=-40), IntSlider(value=80, description…





    <function __main__.Utilidaddelej(p1, p2, p3, p4, p5, c1, c2, c3)>




```python
np.array([1,1,1])@(V1+V2)
```


```python
ax=sns.heatmap(V1+V2,annot=True,fmt=".0f")
```

## Otro problema aplicado

Trabajamos en una textilera que produce 3 tipos de telas producidas a partir de 5 materiales como sigue:

||Algodon|Poliester|Caucho|Lana|Hilo|
|:--:|:--:|:--:|:--:|:--:|:--:|
|Tela 1|400|400|50|75|25|
|Tela 2|500|400|0|50|50|
|Tela 3|500|300|150|20|30|

Los precios de los materiales se relacionan a continuación:

||Precio|
|:--:|:--:|
|Algodon|20.000|
|Poliester|15.000|
|Caucho|10.000|
|Lana|12.000|
|Hilo|7.000|

Hay un pedido que requiere que se entreguen la siguiente cantidad de tela:

|Tela|Cantidad|
|:--:|:--:|
|Tela 1|320 ton|
|Tela 2|240 ton|
|Tela 3|150 ton|

¿Cuanto tengo que invertir?


```python
Cant_Tela=np.array([320,240,150])
Precio_Material=np.array([20000,15000,10000,12000,7000])
Tela_Material=np.array([[400,400,50,75,25],
                       [500,400,0,50,50],
                       [500,300,150,20,30]])
```


```python
Cant_Tela@Tela_Material@np.transpose(Precio_Material)
```

### 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**


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




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




```python
Ninv=np.linalg.inv(N)
Ninv
```




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



Comprobamos este resultado:


```python
(Ninv@N).round()
```




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



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
1. Cambio de filas.
2. Multiplicar una fila por una constante.
3. 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
1. Si la entrada $a_{11}$ de la matriz no es un 1, debe transformase utilizando lasoperaciones elementales.
2. Volver cero todas las entradas de esa columnas que no estén sobre la diagonal principal.
3. Si la entrada $a_{22}$ de la matriz no es un 1, debe transformase utilizando lasoperaciones elementales.
4. Volver cero todas las entradas de esa columnas que no estén sobre la diagonal principal.
5. Repetir el proceso hasta agotar todas las columnas de la matriz.
_____


####  Ejemplos:
1. 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.

2. 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.


```python
135/5
```

### 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:


```python
!pip install sympy
```

    Collecting sympy
      Using cached sympy-1.7.1-py3-none-any.whl (5.9 MB)
    Collecting mpmath>=0.19
      Using cached mpmath-1.2.1-py3-none-any.whl (532 kB)
    Installing collected packages: mpmath, sympy
    Successfully installed mpmath-1.2.1 sympy-1.7.1



```python
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*.


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




$\displaystyle \left[\begin{matrix}1 & -1\\3 & 4\\0 & 2\end{matrix}\right]$



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


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




$\displaystyle \left( \left[\begin{matrix}1 & 2 & 3\\0 & 1 & 2\\-1 & 1 & 3\end{matrix}\right], \  \left[\begin{matrix}1 & -1 & 1\\0 & 1 & 1\\-1 & 10 & 31\end{matrix}\right]\right)$



Suma


```python
A+B
```




$\displaystyle \left[\begin{matrix}2 & 1 & 4\\0 & 2 & 3\\-2 & 11 & 34\end{matrix}\right]$



Resta


```python
A-B
```




$\displaystyle \left[\begin{matrix}0 & 3 & 2\\0 & 0 & 1\\0 & -9 & -28\end{matrix}\right]$



Sumando como en el tablero, usando simbolos matriciales:


```python
3*A
```




$\displaystyle \left[\begin{matrix}3 & 6 & 9\\0 & 3 & 6\\-3 & 3 & 9\end{matrix}\right]$




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




$\displaystyle \left[\begin{matrix}1 & 2 & 3\\0 & 1 & 2\\-1 & 1 & 3\end{matrix}\right] + \left[\begin{matrix}1 & -1 & 1\\0 & 1 & 1\\-1 & 10 & 31\end{matrix}\right] = \left[\begin{matrix}2 & 1 & 4\\0 & 2 & 3\\-2 & 11 & 34\end{matrix}\right]$



Producto


```python
A*B #En sympy ESTE SÍ es el producto de matrices
```




$\displaystyle \left[\begin{matrix}-2 & 31 & 96\\-2 & 21 & 63\\-4 & 32 & 93\end{matrix}\right]$



Transpuesta


```python
Transpose(A)##Escrita
```




$\displaystyle \left(\left[\begin{matrix}1 & 2 & 3\\0 & 1 & 2\\-1 & 1 & 3\end{matrix}\right]\right)^{T}$




```python
A.T ##Calculada
```




$\displaystyle \left[\begin{matrix}1 & 0 & -1\\2 & 1 & 1\\3 & 2 & 3\end{matrix}\right]$



Inversa


```python
B**(-1)
```




$\displaystyle \left[\begin{matrix}\frac{21}{23} & \frac{41}{23} & - \frac{2}{23}\\- \frac{1}{23} & \frac{32}{23} & - \frac{1}{23}\\\frac{1}{23} & - \frac{9}{23} & \frac{1}{23}\end{matrix}\right]$



## Método de Gauss Jordan

Reducción de matrices:

Vamos a resolver el siguiente sistema:

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

Su matriz aumentada es:


```python
A=Matrix([[1,0,1,2],[2,-1,3,3],[4,3,2,12]])
A
```




$\displaystyle \left[\begin{matrix}1 & 0 & 1 & 2\\2 & -1 & 3 & 3\\4 & 3 & 2 & 12\end{matrix}\right]$



Ahora la reducimos:


```python
A.rref()
```




$\displaystyle \left( \left[\begin{matrix}1 & 0 & 0 & 1\\0 & 1 & 0 & 2\\0 & 0 & 1 & 1\end{matrix}\right], \  \left( 0, \  1, \  2\right)\right)$



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:


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




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\2 & 2 & 4 & 0\\1 & 0 & 1 & 0\end{matrix}\right]$



Ahora lo reducimos:


```python
S.rref()
```




$\displaystyle \left( \left[\begin{matrix}1 & 0 & 0 & 1\\0 & 1 & 0 & 1\\0 & 0 & 1 & -1\end{matrix}\right], \  \left( 0, \  1, \  2\right)\right)$



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-3z=-4 \end{cases}$$


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




$\displaystyle \left[\begin{matrix}1 & 0 & 1 & 3\\2 & 3 & 4 & 7\\-1 & -3 & -3 & -4\end{matrix}\right]$




```python
S2.rref()
```




$\displaystyle \left( \left[\begin{matrix}1 & 0 & 1 & 3\\0 & 1 & \frac{2}{3} & \frac{1}{3}\\0 & 0 & 0 & 0\end{matrix}\right], \  \left( 0, \  1\right)\right)$



Escribiendo la reducción como el sistema:

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

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}$.


```python
S3=Matrix([[1, 0, 1, 5], [2, 3, 4, 7], [-1, -3, -3, -4]])
S3
```




$\displaystyle \left[\begin{matrix}1 & 0 & 1 & 5\\2 & 3 & 4 & 7\\-1 & -3 & -3 & -4\end{matrix}\right]$




```python
S3.rref()
```




$\displaystyle \left( \left[\begin{matrix}1 & 0 & 1 & 0\\0 & 1 & \frac{2}{3} & 0\\0 & 0 & 0 & 1\end{matrix}\right], \  \left( 0, \  1, \  3\right)\right)$



Si se convierte en ecuaciones al final tendré:
    
$0x+0y+0z=1$

Lo cual es absurdo, luego ese sistema no tiene solución.

**Otra forma de ver un sistema**

Sea el sistema:
$$\begin{cases}x+y-z=1\\x+2y-2z=1\\x+5y-z=5\end{cases}$$

La matriz aumentada es:

$\begin{pmatrix}1&1&-1&1\\1&2&-2&1\\1&5&-1&5\end{pmatrix}$

Expresión usando operaciones matriciales para el sistema:

$\begin{pmatrix}1&1&-1\\1&2&-2\\1&5&-1\end{pmatrix}\cdot \begin{pmatrix}x\\y\\z\end{pmatrix}=\begin{pmatrix} x+y-z\\x+2y-2z \\x+5y-z \end{pmatrix}=\begin{pmatrix}1\\1\\5\end{pmatrix}$

$\begin{pmatrix}1&1&-1\\1&2&-2\\1&5&-1\end{pmatrix}^{-1}\begin{pmatrix}1&1&-1\\1&2&-2\\1&5&-1\end{pmatrix}\cdot \begin{pmatrix}x\\y\\z\end{pmatrix}=\begin{pmatrix}1&1&-1\\1&2&-2\\1&5&-1\end{pmatrix}^{-1}\begin{pmatrix}1\\1\\5\end{pmatrix}$

$\begin{pmatrix}1&0&0\\0&1&0\\0&0&1\end{pmatrix}\cdot \begin{pmatrix}x\\y\\z\end{pmatrix}=\begin{pmatrix}1&1&-1\\1&2&-2\\1&5&-1\end{pmatrix}^{-1}\begin{pmatrix}1\\1\\5\end{pmatrix}$

$\begin{pmatrix}x\\y\\z\end{pmatrix}=\begin{pmatrix}1&1&-1\\1&2&-2\\1&5&-1\end{pmatrix}^{-1}\begin{pmatrix}1\\1\\5\end{pmatrix}$


```python
from sympy import *
A=Matrix([[1,1,-1],[1,2,-2],[1,5,-1]])
B=Matrix([[1],[1],[5]])
B
```


```python
Sol=A.inv()*B
Sol
```


```python
A1=Matrix([[1,2,3],[1,0,1],[0,2,2]])
A1
```


```python
A1.inv()
```


```python
A.det()
```


```python
A1.det()
```

## 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**
1. $$\begin{vmatrix}1&3\\ \:4&2\end{vmatrix}=(1)(2)-(3)(4)=-10$$
2. $$\begin{vmatrix}-4&3\\ \:-1&-6\end{vmatrix}=(-4)(-6)-(-1)(3)=27$$
3. $$\begin{vmatrix}2&4\\ \:-4&-8\end{vmatrix}=(2)(-8)-(4)(-4)=0$$




```python
M1=Matrix([[1,3],[4,2]])
M1.det()
```

**Para una matriz de 3x3 el determinante se calcula usando Sarrus**

Sea $A=\begin{pmatrix}a_{11}&a_{12}&a_{13}\\
a_{21}&a_{22}&a_{23}\\
a_{31}&a_{32}&a_{33}\\
\end{pmatrix}$
Utiliza el siguiente arreglo auxiliar:

$\begin{bmatrix}{\color{green} a_{11}}&a_{12}&a_{13}&a_{11}&a_{12}\\
a_{21}&\color{green}  a_{22}&a_{23}&a_{21}&a_{22}\\
a_{31}&a_{32}& \color{green} a_{33}&a_{31}&a_{32}\\
\end{bmatrix} = \tiny  a_{11}a_{22}a_{33}+a_{12}a_{23}a_{31}+a_{13}a_{21}a_{32}-a_{13}a_{22}a_{31}-a_{11}a_{23}a_{32}-a_{12}a_{21}a_{33}$ 


### ¿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

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:
1. Elegir una fila (o una columna) .
2. Hallar los cofactores correspondientes a cada uno de los elementos de la fila (o columna).
3. Multiplicar los valores de las entradas por sus respectivos cofactores .
4. 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:**


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í


### Ejercicios:
1. 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()`


```python
from sympy import *
```


```python
init_printing(use_unicode=True)
```


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


```python
M.col(2)
```


```python
M.row(1)
```


```python
M.det()
```


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

#### Ejercicio
1. 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:
1. Se debe calcular el determinante de la matriz de coeficientes.
2. Se remplaza la columna correspondiente a la primera variable por los elementos que conforman al vector $b$, obteniendo una nueva matriz.
3. 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.
4. Se calculan los determinantes de las matrices anteriores.
5. 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}$$


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


```python
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


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


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


```python
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:


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


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


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

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


```python
A=Matrix([[3,1,0],[2,-6,5]])
```


```python
A
```


```python
A_p=Matrix([[3,1],[2,-6]])
A_p
```


```python
A_x=Matrix([[0,1],[5,-6]])
A_x
```


```python
A_y=Matrix([[3,0],[2,5]])
A_y
```


```python
x=A_x.det()/A_p.det()
x
```


```python
y=A_y.det()/A_p.det()
y
```

$$\begin{cases} 3x+y=0\\ 2x-6y=5\end{cases}$$


```python
3*(1/4)+(-3/4)
```


```python
2*(1/4)-6*(-3/4)
```


```python

```

4f972a56ee09812bee259e0dde2339f8d2f57037
ipynb
Jupyter Notebook
Cuadernos/Módulo Álgebra Lineal.ipynb
Izainea/modelosdeoptimizacion
7151512c386c16e6f224136a97360c6db4c9ef0f
MIT
Cuadernos/Módulo Álgebra Lineal.ipynb
Izainea/modelosdeoptimizacion
7151512c386c16e6f224136a97360c6db4c9ef0f
MIT
Cuadernos/Módulo Álgebra Lineal.ipynb
Izainea/modelosdeoptimizacion
7151512c386c16e6f224136a97360c6db4c9ef0f
MIT
Qwen/Qwen-72B
1. YES
2. YES