ALG10-Sistemas_de_Ecuaciones_COMPLETO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sistema de Ecuaciones\n",
    "\n",
    "## 7.1-  ¿Qué es un sistema de ecuaciones?\n",
    "\n",
    "Un sistema de $m$ ecuaciones con $n$ incógnitas se puede escribir de la siguiente forma:<br><br>\n",
    "  \n",
    "\n",
    "<center>$a_{11}\\cdot x_1+a_{12}\\cdot x_2+...+a_{1n}\\cdot x_n=b_1$<br></center>\n",
    "<center>$a_{21}\\cdot x_1+a_{22}\\cdot x_2+...+a_{1n}\\cdot x_n=b_2$<br></center>\n",
    "<center>...</center>\n",
    "<center>$a_{m1}\\cdot x_1+a_{m2}\\cdot x_2+...+a_{mn}\\cdot x_n=b_m$<br></center>  \n",
    "\n",
    "Como hemos visto en el módulo anterior podemos escribirlo también de la siguiente forma:<br><br>\n",
    "\n",
    "<center>\n",
    "$\\left( {\\begin{array}{cc}\n",
    "   a_{11} & a_{12} & ... & a_{1n}\\\\\n",
    "   a_{21} & a_{22} & ... & a_{2n}\\\\\n",
    "   ... & ... & ... & ...\\\\\n",
    "   a_{m1} & a_{m2} & ... & a_{mn}\\\\\n",
    "  \\end{array} } \\right)\\left( {\\begin{array}{cc}\n",
    "   x_{1}\\\\\n",
    "   x_{2}\\\\\n",
    "   ... \\\\\n",
    "   x_{n}\\\\\n",
    "  \\end{array} } \\right) = \\left( {\\begin{array}{cc}\n",
    "   b_{11}\\\\\n",
    "   b_{21}\\\\\n",
    "   ... \\\\\n",
    "   b_{m1}\\\\\n",
    "  \\end{array} } \\right)$ \n",
    "</center><br><br>\n",
    "\n",
    "Donde se llama **matriz de coeficientes** a:<br>\n",
    "\n",
    "<center>$A=\\left( {\\begin{array}{cc}\n",
    "   a_{11} & a_{12} & ... & a_{1n}\\\\\n",
    "   a_{21} & a_{22} & ... & a_{2n}\\\\\n",
    "   ... & ... & ... & ...\\\\\n",
    "   a_{m1} & a_{m2} & ... & a_{mn}\\\\\n",
    "  \\end{array} } \\right)$ \n",
    "</center><br><br>\n",
    "  \n",
    "Y **matriz ampliada** a:<br><br>\n",
    "\n",
    "<center>$A^{*}=\\left( {\\begin{array}{cc}\n",
    "   a_{11} & a_{12} & ... & a_{1n} & b_{1n}\\\\\n",
    "   a_{21} & a_{22} & ... & a_{2n} & b_{2n}\\\\\n",
    "   ... & ... & ... & ... & ...\\\\\n",
    "   a_{m1} & a_{m2} & ... & a_{mn} & b_{mn}\\\\\n",
    "  \\end{array} } \\right)$ \n",
    "</center><br><br>\n",
    "\n",
    "## 7.2-  Reescribiendo el sistema de ecuaciones\n",
    "\n",
    "Aunque el título de este apartado suene muy pomposo 🙂, vamos simplemente a aplicar lo que ya sabemos para reescribirlo usando una forma más compacta. Para ello, teniendo en cuenta la **matriz de coeficientes**:<br><br>\n",
    "\n",
    "<center>$Ax = B$</center>\n",
    "\n",
    "Donde $A$ es una matriz de $mxn$, $x$ y $B$ son dos vectores columna de longitud $n$. Para poder resolver esta ecuación $Ax = B$ debemos simplemente despejar $x$, para ello:<br>\n",
    "\n",
    "<center>$Ax = B$</center><br>\n",
    "<center>$A^{-1}Ax = A^{-1}B$</center><br>\n",
    "<center>$Ix = A^{-1}B$</center><br>\n",
    "<center>$x = A^{-1}B$</center><br>\n",
    "\n",
    "\n",
    "## 7.3-  Determinar si el sistema se puede resolver\n",
    "\n",
    "Un sistema de ecuaciones lineales pueden tener:\n",
    "- Una única solución - **sistema compatible determinado**\n",
    "- Infinitas soluciones - **sistema compatible indeterminado**\n",
    "- Sin solución - **sistema incompatible**\n",
    "\n",
    "Vamos allá!\n",
    "\n",
    "### 7.3.1 -   Sistema compatible determinado\n",
    "\n",
    "Un sistema de ecuaciones lineales será un **sistema compatible determinado**, es decir tendrá una única solución, cuando el determinante de la matriz $A$ sea distinto de 0.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b><center>$det(A) \\neq 0$ - Sistema Compatible Determinado</center></b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Resuelva el siguiente sistema de ecuaciones</b><br><br>\n",
    "    \n",
    "<center>\n",
    "\\begin{cases} -x_1 + 2x_3 = 1 \\\\ x_1 - x_2=-2 \\\\ x_2 + x_3=-1\\end{cases}\n",
    "</center>\n",
    "</div> \n",
    "\n",
    "Antes que nada vamos descomponerlo y escribirlo como una ecuación matricial de la forma $AX=B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  0  2]\n",
      " [ 1 -1  0]\n",
      " [ 0  1  1]]\n",
      "[[ 1]\n",
      " [-2]\n",
      " [-1]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "A = np.array([[-1, 0, 2],\n",
    "              [1, -1, 0],\n",
    "              [0, 1, 1]])\n",
    "\n",
    "B = np.array([[1],\n",
    "              [-2],\n",
    "              [-1]])\n",
    "\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sabiendo que: $X = A^{-1}B$. El siguiente paso es calcular la matriz inversa de $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0000000000000004"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(A) # Es distinto de 0, tiene una única solución - Deshacemos la transformación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.33333333,  0.66666667,  0.66666667],\n",
       "       [-0.33333333, -0.33333333,  0.66666667],\n",
       "       [ 0.33333333,  0.33333333,  0.33333333]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_inv = np.linalg.inv(A)\n",
    "A_inv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplicando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.33333333],\n",
       "       [-0.33333333],\n",
       "       [-0.66666667]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.dot(A_inv, B)\n",
    "X # Vector que ha generado la transformación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos resolverlo usando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.33333333],\n",
       "       [-0.33333333],\n",
       "       [-0.66666667]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.linalg.solve(A, B)\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos podido calcular la inversa de $A$ porque es cuadrada y el determinante de $A$ es distinto de $0$, sino no podríamos haberlo calcularlo. Podemos comprobar como el determinante de $A$ es distinto de $0$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0000000000000004"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Porque el determinante es distinto de 0\n",
    "np.linalg.det(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.2-   Sistema compatible indeterminado + Sin solución\n",
    "\n",
    "Considerando el siguiente sistema de ecuaciones:\n",
    "\n",
    "<center>\n",
    "\\begin{cases} x + 2y -z = 1 \\\\ -x + y + 2z = 3 \\\\ x + 5y = 5\\end{cases}\n",
    "</center>\n",
    "\n",
    "Podemos expresarlo como:\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1\\\\\n",
    "   -1 & 1 & 2\\\\\n",
    "   1 & 5 & 0\\\\\n",
    "  \\end{array} } \\right)\\left( {\\begin{array}{cc}\n",
    "   x\\\\\n",
    "   y\\\\\n",
    "   z\\\\\n",
    "  \\end{array} } \\right) = \\left( {\\begin{array}{cc}\n",
    "   1\\\\\n",
    "   3\\\\\n",
    "   5\\\\\n",
    "  \\end{array} } \\right)$ </center>\n",
    " \n",
    "Vamos a intentar resolverlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 2, -1],\n",
    "              [-1, 1, 2],\n",
    "              [1, 5, 0]])\n",
    "\n",
    "B = np.array([[1],\n",
    "              [3],\n",
    "              [5]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes que nada vamos a calcular el determinante de $A$ para saber si es $0$ y en ese caso el sistema tiene una única solución, o por lo contratio $det(A)=0$ y por ello es indeterminado o no tiene solución.\n",
    "\n",
    "Como esperaréis, va a salir $det(A)=0$, de ahí el título de esta sección 🙂\n",
    "\n",
    "<img src=\"./Images/einstein.gif\" width=20%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det_A = np.linalg.det(A)\n",
    "det_A # Determinante igual a 0 - No existe inversa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Perfecto!**, el determinante de $A$ es $0$, por lo que o tiene **infinitas soluciones** o no tiene **solución** - ¿Qué podemos hacer para averiguarlo?.\n",
    "\n",
    "Pues vamos a aplicar el maravilloso **método de eliminación de Gauss** que ya usamos en el módulo de matrices para ver si podemos encontrar un sistema equivalente. En este caso vamos a usar la **matriz ampliada**, por lo que a la matriz $A$ vamos añadirle a la derecha la matriz $B$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [-1,  1,  2,  3],\n",
       "       [ 1,  5,  0,  5]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.concatenate((A, B), axis=1)\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recordemos que el objetivo del **método de Gauss** es transformar un sistema en otro equivalente que tiene el mismo conjunto solución.<br><br>\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   -1 & 1 & 2 & 3\\\\\n",
    "   1 & 5 & 0 & 5\\\\\n",
    "  \\end{array} } \\right)\\xrightarrow{f_3 \\rightarrow f_3 - f_1}\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   -1 & 1 & 2 & 3\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "  \\end{array} } \\right)$ </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [-1,  1,  2,  3],\n",
       "       [ 0,  3,  1,  4]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.array([AB[0], AB[1], AB[2]-AB[0]])\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente pase que podemos hacer es:\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   -1 & 1 & 2 & 3\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "  \\end{array} } \\right)\\xrightarrow{f_2 \\rightarrow f_2 + f_1}\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "  \\end{array} } \\right)$ </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [ 0,  3,  1,  4],\n",
       "       [ 0,  3,  1,  4]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.array([AB[0], AB[1]+AB[0], AB[2]])\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último:\n",
    "\n",
    "El siguiente pase que podemos hacer es:\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "  \\end{array} } \\right)\\xrightarrow{f_3 \\rightarrow f_3 - f_2}\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "   0 & 0 & 0 & 0\\\\\n",
    "  \\end{array} } \\right)$ </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [ 0,  3,  1,  4],\n",
       "       [ 0,  0,  0,  0]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.array([AB[0], AB[1], AB[2]-AB[1]])\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con los pasos que hemos realizado hemos obtenido un sistema equivalente de ecuaciones al inicial, podemos intentar resolverlo, usando `numpy` directamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1],\n",
       "       [ 0,  3,  1],\n",
       "       [ 0,  0,  0]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_simplificado = AB[:, :3]\n",
    "A_simplificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 0])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B_simplificado = AB[:, -1]\n",
    "B_simplificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "LinAlgError",
     "evalue": "Singular matrix",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mLinAlgError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/zb/r_57byp97tx0mcljd3fd0_640000gn/T/ipykernel_84946/2204145131.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA_simplificado\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mB_simplificado\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36msolve\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;32m~/.pyenv/versions/3.8.3/lib/python3.8/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36msolve\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m    391\u001b[0m     \u001b[0msignature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'DD->D'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misComplexType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'dd->d'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    392\u001b[0m     \u001b[0mextobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_linalg_error_extobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_raise_linalgerror_singular\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 393\u001b[0;31m     \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgufunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mextobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    394\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    395\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult_t\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.pyenv/versions/3.8.3/lib/python3.8/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36m_raise_linalgerror_singular\u001b[0;34m(err, flag)\u001b[0m\n\u001b[1;32m     86\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_raise_linalgerror_singular\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 88\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mLinAlgError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Singular matrix\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     89\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_raise_linalgerror_nonposdef\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mLinAlgError\u001b[0m: Singular matrix"
     ]
    }
   ],
   "source": [
    "X = np.linalg.solve(A_simplificado, B_simplificado)\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos `numpy` no es capaz de resolver este tipo de sistema de ecuaciones lineales, vamos a intentar resolverlo usando `sympy`.\n",
    "\n",
    "Simplemente debemos escribir la ecuación $AB$ y usar `solve()`<br><br>\n",
    "\n",
    "<center>\n",
    "\\begin{cases} x + 2y -z = 1 \\\\ 3y + z = 4\\end{cases}\n",
    "</center>\n",
    "\n",
    "Igualando a $0$:<br><br>\n",
    "\n",
    "<center>\n",
    "\\begin{cases} x + 2y -z -1 = 0 \\\\ 3y + z -4 = 0\\end{cases}\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1],\n",
       "       [ 0,  3,  1],\n",
       "       [ 0,  0,  0]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_simplificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 0])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B_simplificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.solvers import *\n",
    "from sympy import *\n",
    "\n",
    "x = Symbol('x')\n",
    "y = Symbol('y')\n",
    "z = Symbol('z')\n",
    "\n",
    "fun1 = x + 2*y - 1*z - 1\n",
    "fun2 = 3*y + z - 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "solucion = solve([fun1, fun2], [x, y, z])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{x: 5*z/3 - 5/3, y: 4/3 - z/3}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solucion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultado para z: 234567\n",
      "x:  390943.3333333333\n",
      "y:  -78187.66666666667\n"
     ]
    }
   ],
   "source": [
    "z=234567\n",
    "x = 5*z/3 - 5/3\n",
    "y = 4/3 - z/3\n",
    "\n",
    "print(\"Resultado para z:\", z)\n",
    "print(\"x: \", x)\n",
    "print(\"y: \", y)\n",
    "# Infinitas soluciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**mmmm que raro...** Nuestra solución depende de $z$, si lo pensamos bien eso se debe a que tiene $\\infty$ soluciones, ya que depende directamente de $z$. Habrá una solución para $z=1$, $z=20$, ... $z=1324573$. Más en profundidad, dicha solución es un conjunto de rectas. [Aquí lo explican muy bien.](https://www.montereyinstitute.org/courses/DevelopmentalMath/TEXTGROUP-9-14_RESOURCE/U14_L1_T1_text_final_es.html)\n",
    "\n",
    "<img src=\"./Images/planos.png\" width=60%>\n",
    "\n",
    "Podemos evaluar la solución usando `evalf`, por ejemplo para <b>$z=6$</b>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultado para z: 6\n",
      "x:  8.333333333333334\n",
      "y:  -0.6666666666666667\n"
     ]
    }
   ],
   "source": [
    "z = 6\n",
    "print(f'Soluciones para z = {z}')\n",
    "print(f'x = {solucion[x].evalf(subs={Symbol(\"z\"):6})}')\n",
    "print(f'x = {solucion[y].evalf(subs={Symbol(\"z\"):6})}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sin solución\n",
    "\n",
    "Ya hemos encontrado un sistema de ecuaciones lineales que tiene infinitas soluciones, vamos a intentar resolver uno para ver que sucede cuando **el sistema de ecuaciones no tiene solución.**\n",
    "\n",
    "<center>\n",
    "\\begin{cases} x + 2y -z = 1 \\\\ -x + y + 2z = 3 \\\\ x + 5y = 0\\end{cases}\n",
    "</center>\n",
    "\n",
    "Podemos expresarlo como:\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1\\\\\n",
    "   -1 & 1 & 2\\\\\n",
    "   1 & 5 & 0\\\\\n",
    "  \\end{array} } \\right)\\left( {\\begin{array}{cc}\n",
    "   x\\\\\n",
    "   y\\\\\n",
    "   z\\\\\n",
    "  \\end{array} } \\right) = \\left( {\\begin{array}{cc}\n",
    "   1\\\\\n",
    "   3\\\\\n",
    "   0\\\\\n",
    "  \\end{array} } \\right)$ </center>\n",
    " \n",
    "Vamos a usar el mismo proceso que antes para poder encontrar un sistema de ecuaciones similar al inicial:<br><br>\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   -1 & 1 & 2 & 3\\\\\n",
    "   1 & 5 & 0 & 0\\\\\n",
    "  \\end{array} } \\right)\\xrightarrow{f_3 \\rightarrow f_3 - f_1}\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   -1 & 1 & 2 & 3\\\\\n",
    "   0 & 3 & 1 & -1\\\\\n",
    "  \\end{array} } \\right)$ </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [-1,  1,  2,  3],\n",
       "       [ 1,  5,  0,  0]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2, -1],\n",
    "              [-1, 1, 2],\n",
    "              [1, 5, 0]])\n",
    "\n",
    "B = np.array([[1], [3], [0]])\n",
    "\n",
    "AB = np.concatenate((A, B), axis=1)\n",
    "AB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [-1,  1,  2,  3],\n",
       "       [ 0,  3,  1, -1]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.array([AB[0], AB[1], AB[2]-AB[0]])\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente paso que podemos realizar es:<br><br>\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   -1 & 1 & 2 & 3\\\\\n",
    "   0 & 3 & 1 & -1\\\\\n",
    "  \\end{array} } \\right)\\xrightarrow{f_2 \\rightarrow f_2 + f_1}\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "   0 & 3 & 1 & -1\\\\\n",
    "  \\end{array} } \\right)$ </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [ 0,  3,  1,  4],\n",
       "       [ 0,  3,  1, -1]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.array([AB[0], AB[1] + AB[0], AB[2]])\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último:<br><br>\n",
    "\n",
    "<center>$\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "   0 & 3 & 1 & -1\\\\\n",
    "  \\end{array} } \\right)\\xrightarrow{f_3 \\rightarrow f_3 - f_2}\\left( {\\begin{array}{cc}\n",
    "   1 & 2 & -1 & 1\\\\\n",
    "   0 & 3 & 1 & 4\\\\\n",
    "   0 & 0 & 0 & -5\\\\\n",
    "  \\end{array} } \\right)$ </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2, -1,  1],\n",
       "       [ 0,  3,  1,  4],\n",
       "       [ 0,  0,  0, -5]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = np.array([AB[0], AB[1], AB[2] - AB[1]])\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La última fila de la matriz ya nos indica que algo raro sucede, porque $0 = -5$ no tiene sentido. Aún así vamos a resolverlo usando `sympy`:<br><br>\n",
    "\n",
    "<center>\n",
    "\\begin{cases} x + 2y -z = 1 \\\\ 3y + z = 4 \\\\ 0 = -5\\end{cases}\n",
    "</center>\n",
    "\n",
    "Igualando a $0$:<br><br>\n",
    "\n",
    "<center>\n",
    "\\begin{cases} x + 2y -z -1 = 0 \\\\ 3y + z -4 = 0 \\\\ 0 = -5\\end{cases}\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.solvers import *\n",
    "from sympy import *\n",
    "\n",
    "x = Symbol('x')\n",
    "y = Symbol('y')\n",
    "z = Symbol('z')\n",
    "\n",
    "fun1 = x + 2*y - z - 1\n",
    "fun2 = 3*y + z - 4\n",
    "fun3 = -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "solucion = solve([fun1, fun2, fun3], [x, y, z])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solucion:  []\n"
     ]
    }
   ],
   "source": [
    "print(\"Solucion: \", solucion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La solución está vacía, lo que indica que este sistema de ecuaciones lineales no tiene solución y por tanto es un **sistema incompatible**.\n",
    "\n",
    "### Resumiendo\n",
    "\n",
    "<img src=\"./Images/secuaciones.png\" width=50%>\n",
    "\n",
    "Esto es válido para cuando $B \\neq 0 $, pero si en el sistema de ecuaciones $B = 0$ dicho sistema se denomina **sistema homogéneo** y son siempre **compatibles**, es decir siempre tiene alguna solución. Y la verdad es que tiene sentido porque siempre van a admitir la solución trivial de $X=0$.\n",
    "\n",
    "<img src=\"./Images/secuaciones_h.png\" width=50%>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo\n",
    "¿Sabéis típico juego que te aparece en facebook de calcular el valor de distintos objetos?\n",
    "\n",
    "<img src=\"./Images/ejemplo_eq.jpg\" width=50%>\n",
    "\n",
    "Bueno pues todos ellos se resuelven siempre de la misma forma, usando un **sistema de ecuaciones lineales**. Así que vamos a intentar resolver uno de ellos!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>EL MERCADO GANADERO</b><br><br>\n",
    "    \n",
    "<img src=\"Images/ganado.jpg\" style=\"width: 300px;\"/>\n",
    "\n",
    "Tres campesinos se encontraron en el mercado ganadero.\n",
    "- Mira, le dijo Luis a Juan, te daré 6 de mis cerdos por 1 de tus caballos y así tendrás el doble de animales que yo.\n",
    "- Si ése es tu modo de hacer negocios, le dijo Pepe a Luis, te daré 14 ovejas por 1 caballo, y entonces tendrás el triple de animales que yo.\n",
    "- Bien, le dijo Juan a Pepe. Te daré 4 vacas por un caballo y entonces tendrás seis veces más animales que yo.\n",
    "\n",
    "<b>¿Cuántos animales llevaron al mercado Juan, Luis y Pepe?</b>\n",
    "</div><br>\n",
    "\n",
    "Llamemos $L$ al número de animales que tiene Luis, $J$ al número de animales que posee Juan y $P$ al número de animales pertenecientes a Pepe. Si analizamos el párrafo y lo convertimos a ecuaciones:<br><br>\n",
    "\n",
    "<center>$J-1+6=2·(L-6+1)$</center>\n",
    "<center>$L-1+14=3·(P-14+1)$</center>\n",
    "<center>$P+4-1=6·(J+1-4)$</center>\n",
    "  \n",
    "Reagrupando:<br>\n",
    "\n",
    "<center>$J-2L = -15$</center>\n",
    "<center>$L-3P = -52$</center>\n",
    "<center>$P-6J = -21$</center>\n",
    "\n",
    "Usando `numpy':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinante -35.00000000000001\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "A = np.array([[1, -2, 0],\n",
    "              [0, 1, -3],\n",
    "              [-6, 0, 1]])\n",
    "\n",
    "B = np.array([[-15],\n",
    "              [-52],\n",
    "              [-21]])\n",
    "\n",
    "print(\"Determinante\", np.linalg.det(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solucion: \n",
      "[[ 7.]\n",
      " [11.]\n",
      " [21.]]\n"
     ]
    }
   ],
   "source": [
    "X = np.linalg.solve(A, B)\n",
    "print(f\"Solucion: \\n{X}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Juan llevó 7 animales\n",
    "# Luis llevó 11 animales\n",
    "# Pepe llevó 21 animales"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}