Python/clases/3_algebra_lineal/1_ecuaciones_lineales.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notas para contenedor de docker:**\n",
    "\n",
    "Comando de docker para ejecución de la nota de forma local:\n",
    "\n",
    "nota: cambiar `dir_montar` por la ruta de directorio que se desea mapear a `/datos` dentro del contenedor de docker.\n",
    "\n",
    "```\n",
    "dir_montar=<ruta completa de mi máquina a mi directorio>#aquí colocar la ruta al directorio a montar, por ejemplo: \n",
    "#dir_montar=/Users/erick/midirectorio.\n",
    "```\n",
    "\n",
    "Ejecutar:\n",
    "\n",
    "```\n",
    "VERSION=<versión imagen de docker>\n",
    "docker run --rm -v $dir_montar:/datos --name jupyterlab_prope_r_kernel_tidyverse -p 8888:8888 -d palmoreck/jupyterlab_prope_r_kernel_tidyverse:$VERSION\n",
    "\n",
    "```\n",
    "\n",
    "Ir a `localhost:8888` y escribir el password para jupyterlab: `qwerty`\n",
    "\n",
    "\n",
    "Detener el contenedor de docker:\n",
    "\n",
    "```\n",
    "docker stop jupyterlab_prope_r_kernel_tidyverse\n",
    "```\n",
    "\n",
    "Documentación de la imagen de docker `palmoreck/jupyterlab_prope_r_kernel_tidyverse:<versión imagen de docker>` en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/prope_r_kernel_tidyverse)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecución de la nota usar:\n",
    "\n",
    "[docker](https://www.docker.com/) (instalación de forma **local** con [Get docker](https://docs.docker.com/install/)) y ejecutar comandos que están al inicio de la nota de forma **local**. \n",
    "\n",
    "O bien dar click en alguno de los botones siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/palmoreck/dockerfiles-for-binder/jupyterlab_prope_r_kernel_tidyverse?urlpath=lab/tree/Propedeutico/Python/clases/3_algebra_lineal/1_ecuaciones_lineales.ipynb) esta opción crea una máquina individual en un servidor de Google, clona el repositorio y permite la ejecución de los notebooks de jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Run on Repl.it](https://repl.it/badge/github/palmoreck/dummy)](https://repl.it/languages/python3) esta opción no clona el repositorio, no ejecuta los notebooks de jupyter pero permite ejecución de instrucciones de Python de forma colaborativa con [repl.it](https://repl.it/). Al dar click se crearán nuevos ***repl*** debajo de sus users de ***repl.it***.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lo siguiente está basado en el capítulo 2 y apéndice del libro de texto de J. Kiusalas Numerical Methods in Engineering with Python 3 y el libro de Matrix Analysis and Applied Linear Algebra de C. D. Meyer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Se sugiere haber revisado la sección 1.5 del libro de texto de J. Kiusalas Numerical Methods in Engineering with Python 3: uso de *NumPy***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sistemas de ecuaciones lineales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En general son de la forma: $$\\begin{array}{ccc} a_{11}x_1 + a_{12}x_2 + \\cdots + a_{1n}x_n  &= & b_1 \\\\ a_{21}x_1 + a_{22}x_2 +  \\cdots + a_{2n}x_n &= & b_2 \\\\ \\vdots & & \\\\ a_{m1}x_1 + a_{m2}x_2 + \\cdots + a_{mn}x_n &=& b_m \\end{array}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "donde: las $x_i$'s son las incógnitas y las $a_{ij}$'s y $b_i$'s son constantes conocidas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las entradas $a_{ij}$'s son llamadas coeficientes del sistema y el conjunto de $b_i$'s se le llama lado derecho del sistema. Si todas las $b_i$'s son iguales a $0$ el sistema se le nombra **homogéneo**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3 posibilidades para solución del sistema anterior:**\n",
    "\n",
    "* Una única solución: sólo existe uno y sólo un conjunto de valores de $x_i$'s que satisfacen todas las ecuaciones simultáneamente.\n",
    "\n",
    "* Ninguna solución: no existe ningún conjunto de valores de $x_i$'s que satisfacen todas las ecuaciones simultáneamente (el conjunto solución es vacío).\n",
    "\n",
    "* Infinitas soluciones: hay una infinidad de conjuntos (distintos) de valores de las $x_i$'s que satisfacen todas las ecuaciones simultáneamente.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Definición**\n",
    "\n",
    "\n",
    "En el caso de una o infinitas soluciones el sistema de ecuaciones lineales se nombra consistente o no singular, si no existe solución se nombra inconsistente o singular.\n",
    "\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpretación geométrica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resolver un sistema de ecuaciones lineales equivale a encontrar la intersección entre rectas, planos o hiperplanos (2,3 o n dimensiones respectivamente). Por ejemplo para un caso de dos dimensiones se tiene:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://dl.dropboxusercontent.com/s/p92z7zlquo1adbm/algebra_lineal_1.jpg?dl=0\" heigth=\"700\" width=\"700\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El inciso a) representa un sistema de ecuaciones lineales sin solución, el inciso b) infinitas soluciones (en el dibujo ligeramente se desplazó hacia abajo una de las rectas para mostrar ambas) y el inciso c) una única solución. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algoritmos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen una gran cantidad de algoritmos para resolver los sistemas de ecuaciones. Típicamente se elige el algoritmo de acuerdo a las características de los coeficientes de la matriz del sistema y sus dimensiones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sistemas triangulares\n",
    "\n",
    "Son sistemas cuya matriz es triangular inferior o superior. Un sistema triangular inferior se resuelve con el método de sustitución hacia delante. Si es triangular superior se resuelve con el método de sustitución hacia atrás.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo matriz triangular inferior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [1., 1., 0., 0.],\n",
       "       [1., 1., 1., 0.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tril(np.ones(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [1., 1., 0., 0.],\n",
       "       [1., 1., 1., 0.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tril(np.ones((4,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo matriz triangular superior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [0., 1., 1., 1.],\n",
       "       [0., 0., 1., 1.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.triu(np.ones(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [0., 1., 1., 1.],\n",
       "       [0., 0., 1., 1.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.triu(np.ones((4,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sistemas no triangulares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para sistemas de ecuaciones lineales más generales (no tienen estructura identificable) se tienen métodos iterativos y directos o basados en factorizaciones matriciales.\n",
    "\n",
    "Entre los directos o basados en factorizaciones matriciales se encuentran:\n",
    "\n",
    "\n",
    "* Eliminación Gaussiana o factorización LU.\n",
    "* Factorización de Cholesky (la matriz del sistema debe ser simétrica definida positiva).\n",
    "* Factorización QR.\n",
    "* Descomposición en valores singulares o SVD por sus siglas en inglés.\n",
    "\n",
    "y como ejemplo de métodos iterativos están:\n",
    "\n",
    "* Jacobi.\n",
    "* Gauss-Seidel.\n",
    "* Gradiente conjugado.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ambos métodos: iterativos y directos o basados en factorizaciones matriciales encuentran sistemas de ecuaciones equivalentes a partir de operaciones básicas del álgebra lineal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Definición**\n",
    "\n",
    "Dos sistemas de ecuaciones lineales son equivalentes si tienen el mismo conjunto solución.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algoritmos iterativos para sistemas de ecuaciones lineales generales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferencia de los algoritmos directos que utilizan un número finito de pasos para resolver un sistema de ecuaciones lineales, esta clase de algoritmos utilizan un punto inicial y con un proceso iterativo van mejorando la solución hasta que se satisfaga un criterio de paro. Típicamente tienen un desempeño más lento que los directos pero aprovechan mejor la estructura de las matrices. Dependiendo de las características de las matrices convergen o no a la solución.\n",
    "\n",
    "Revisar los siguientes algoritmos que encuentran en la sección 2.7 del libro de texto de J. Kiusalas Numerical Methods in Engineering with Python 3:\n",
    "\n",
    "* Gauss-Seidel.\n",
    "* Gradiente conjugado.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos de uso de los paquetes *NumPy* y *SciPy* para resolver ecuaciones lineales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1)Resolver: $$\\begin{array}{ccc} 8x_1 -6x_2 + 2x_3  &= & 28 \\\\ -4x_1 + 11x_2 -7x_3 &= & -40 \\\\ 4x_1 -7x_2 + 6x_3 &=& 33\\end{array} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[8, -6, 2], \n",
    "              [-4, 11, -7], \n",
    "              [4, -7, 6]])\n",
    "b = np.array([28,-40,33])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      "array([[ 8, -6,  2],\n",
      "       [-4, 11, -7],\n",
      "       [ 4, -7,  6]])\n",
      "b:\n",
      "array([ 28, -40,  33])\n"
     ]
    }
   ],
   "source": [
    "print('A:')\n",
    "pprint.pprint(A)\n",
    "print('b:')\n",
    "pprint.pprint(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usamos la función de [solve](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html) dentro de [numpy.linalg](https://numpy.org/doc/stable/reference/routines.linalg.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.linalg.solve(A,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x:\n",
      "array([ 2., -1.,  3.])\n"
     ]
    }
   ],
   "source": [
    "print('x:')\n",
    "pprint.pprint(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verificando resultado Ax = b\n",
      "b:\n",
      "array([ 28, -40,  33])\n",
      "Ax:\n",
      "array([ 28., -40.,  33.])\n"
     ]
    }
   ],
   "source": [
    "print('Verificando resultado Ax = b')\n",
    "print('b:')\n",
    "pprint.pprint(b)\n",
    "print('Ax:')\n",
    "pprint.pprint(A@x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cómo verificamos que son iguales las cantidades?\n",
    "**1era opción**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33m  WARNING: The scripts py.test and pytest are installed in '/home/propeuser/.local/bin' which is not on PATH.\n",
      "  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip3 install -q --user pytest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pytest import approx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sol_numpy = A@x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 28., -40.,  33.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sol_numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 28, -40,  33])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sol_numpy == approx(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2a opción**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(sol_numpy, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2)Resolver $AX = B$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{array}{l}\n",
    "\\left[\n",
    "\\begin{array}{ccc}\n",
    "6 &4 &1\\\\\n",
    "-4 & 6 & -4\\\\\n",
    "1 &-4 & 6\n",
    "\\end{array}\n",
    "\\right]\n",
    "\\left[\n",
    "\\begin{array}{cc}\n",
    "x_{11} &x_{12} \\\\\n",
    "x_{21} & x_{22}\\\\\n",
    "x_{31} & x_{32}\n",
    "\\end{array}\n",
    "\\right]\n",
    "=\n",
    "\\left[\\begin{array}{cc}\n",
    "-14 & 22\\\\\n",
    "36 & -18\\\\\n",
    "6 & 7\n",
    "\\end{array}\n",
    "\\right] \n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[6,-4,1], \n",
    "              [-4,6,-4], \n",
    "              [1,-4,6]])\n",
    "B = np.array([[-14,22],\n",
    "              [36,-18],\n",
    "              [6,7]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      "array([[ 6, -4,  1],\n",
      "       [-4,  6, -4],\n",
      "       [ 1, -4,  6]])\n",
      "B:\n",
      "array([[-14,  22],\n",
      "       [ 36, -18],\n",
      "       [  6,   7]])\n"
     ]
    }
   ],
   "source": [
    "print('A:')\n",
    "pprint.pprint(A)\n",
    "print('B:')\n",
    "pprint.pprint(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=np.linalg.solve(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      "array([[10.,  3.],\n",
      "       [22., -1.],\n",
      "       [14.,  0.]])\n"
     ]
    }
   ],
   "source": [
    "print('X:')\n",
    "pprint.pprint(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verificando resultado AX = B\n",
      "B:\n",
      "array([[-14,  22],\n",
      "       [ 36, -18],\n",
      "       [  6,   7]])\n",
      "AX:\n",
      "array([[-14.,  22.],\n",
      "       [ 36., -18.],\n",
      "       [  6.,   7.]])\n"
     ]
    }
   ],
   "source": [
    "print('Verificando resultado AX = B')\n",
    "print('B:')\n",
    "pprint.pprint(B)\n",
    "print('AX:')\n",
    "pprint.pprint(A@X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo factorización PLU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**¿Dado el sistema $Ax=b$, $A \\in \\mathbb{R}^{n \\times n}$ cómo se resuelve con la factorización $PLU$?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paso 1: encontrar factores $P,L,U$ tales que $PA=LU$.\n",
    "\n",
    "Paso 2: resolver con el método de sustitución hacia delante el sistema triangular inferior $Ld=Pb$.\n",
    "\n",
    "Paso 3: resolver con el método de sustitución hacia atrás el sistema triangular superior $Ux=d$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtener los factores $P, L, U$ de la matriz $A$: $$A = \\begin{bmatrix} 2& -1&2 \\\\ 1& 6& -1 \\\\ 1& 4& 1\\end{bmatrix}$$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y utilizarlos para resolver $AX = B$ con $$B=\\begin{bmatrix}7 & -1\\\\13 & 6\\\\5 & 7\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La factorización P,L,U la calculamos con la función [lu](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.lu.html) dentro de [scipy.linalg](https://docs.scipy.org/doc/scipy/reference/linalg.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy\n",
    "import scipy.linalg "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -1,  2],\n",
       "       [ 1,  6, -1],\n",
       "       [ 1,  4,  1]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[2,-1,2], [1,6,-1], [1,4,1]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "P, L, U = scipy.linalg.lu(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      "array([[ 2, -1,  2],\n",
      "       [ 1,  6, -1],\n",
      "       [ 1,  4,  1]])\n",
      "P:\n",
      "array([[1., 0., 0.],\n",
      "       [0., 1., 0.],\n",
      "       [0., 0., 1.]])\n",
      "L:\n",
      "array([[1.        , 0.        , 0.        ],\n",
      "       [0.5       , 1.        , 0.        ],\n",
      "       [0.5       , 0.69230769, 1.        ]])\n",
      "U:\n",
      "array([[ 2.        , -1.        ,  2.        ],\n",
      "       [ 0.        ,  6.5       , -2.        ],\n",
      "       [ 0.        ,  0.        ,  1.38461538]])\n"
     ]
    }
   ],
   "source": [
    "print('A:')\n",
    "pprint.pprint(A)\n",
    "print('P:')\n",
    "pprint.pprint(P)\n",
    "print('L:')\n",
    "pprint.pprint(L)\n",
    "print('U:')\n",
    "pprint.pprint(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verificando que es igual PA al producto LU\n",
      "L*U:\n",
      "array([[ 2., -1.,  2.],\n",
      "       [ 1.,  6., -1.],\n",
      "       [ 1.,  4.,  1.]])\n",
      "P*A\n",
      "array([[ 2., -1.,  2.],\n",
      "       [ 1.,  6., -1.],\n",
      "       [ 1.,  4.,  1.]])\n"
     ]
    }
   ],
   "source": [
    "print('Verificando que es igual PA al producto LU')\n",
    "print('L*U:')\n",
    "pprint.pprint(L@U)\n",
    "print('P*A')\n",
    "pprint.pprint(P@A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usando los factores P,L,U para resolver AX = B\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 7, -1],\n",
       "       [13,  6],\n",
       "       [ 5,  7]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Usando los factores P,L,U para resolver AX = B')\n",
    "B = np.array([[7,-1],[13,6],[5,7]])\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resolvemos paso 2: $LD = PB$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.        , -1.        ],\n",
       "       [ 9.5       ,  6.5       ],\n",
       "       [-5.07692308,  3.        ]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = scipy.linalg.solve_triangular(L,P@B,lower=True)\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resolver paso 3: $UX = D$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = scipy.linalg.solve_triangular(U,D) #by default parameter lower is False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      "array([[ 7.33333333, -1.83333333],\n",
      "       [ 0.33333333,  1.66666667],\n",
      "       [-3.66666667,  2.16666667]])\n"
     ]
    }
   ],
   "source": [
    "print('X:')\n",
    "pprint.pprint(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verificando resultado AX = B\n",
      "B:\n",
      "array([[ 7, -1],\n",
      "       [13,  6],\n",
      "       [ 5,  7]])\n",
      "AX:\n",
      "array([[ 7., -1.],\n",
      "       [13.,  6.],\n",
      "       [ 5.,  7.]])\n"
     ]
    }
   ],
   "source": [
    "print('Verificando resultado AX = B')\n",
    "print('B:')\n",
    "pprint.pprint(B)\n",
    "print('AX:')\n",
    "pprint.pprint(A@X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Nota**\n",
    "\n",
    "En la factorización LU, la matriz $P$ es una matriz de permutación que cumple con tener un $1$ exactamente en cada renglón y cada columna. Por ejemplo:\n",
    "\n",
    "$$\n",
    "\\left[\n",
    "\\begin{array}{ccc}\n",
    "0 & 1 & 0\\\\\n",
    "1 & 0 & 0\\\\\n",
    "0 & 0 & 1\n",
    "\\end{array}\n",
    "\\right ]\n",
    "$$\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo anterior utilizando la factorización QR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**¿Dado el sistema $Ax=b$, $A \\in \\mathbb{R}^{n \\times n}$ cómo se resuelve con la factorización $QR$?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paso 1: encontrar factores $Q,R$ tales que $A=QR$. \n",
    "\n",
    "Paso 2: resolver con el método de sustitución hacia atrás el sistema triangular superior $Rx=Q^Tb$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "Q, R = np.linalg.qr(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      "array([[ 2, -1,  2],\n",
      "       [ 1,  6, -1],\n",
      "       [ 1,  4,  1]])\n",
      "Q:\n",
      "array([[-0.81649658,  0.56354707, -0.12549116],\n",
      "       [-0.40824829, -0.71724173, -0.56471022],\n",
      "       [-0.40824829, -0.40985242,  0.81569255]])\n",
      "R:\n",
      "array([[-2.44948974, -3.26598632, -1.63299316],\n",
      "       [ 0.        , -6.5064071 ,  1.43448345],\n",
      "       [ 0.        ,  0.        ,  1.12942045]])\n"
     ]
    }
   ],
   "source": [
    "print('A:')\n",
    "pprint.pprint(A)\n",
    "print('Q:')\n",
    "pprint.pprint(Q)\n",
    "print('R:')\n",
    "pprint.pprint(R)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Q^TQ = I$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Norma de la primer columna de Q:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(Q[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Norma de la segunda columna de Q:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(Q[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Norma de la tercera columna de Q:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(Q[:,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Producto punto entre primera y segunda columna de Q:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.7755575615628914e-17"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q[:,0].dot(Q[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$QQ^T = I$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Producto punto entre primer y segundo renglón de Q:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5265566588595902e-16"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q[0,:].dot(Q[1,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Producto punto entre segundo y tercer renglón de Q:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5.551115123125783e-17"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q[1,:].dot(Q[2,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Norma de primer renglón:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(Q[0,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Norma de segundo renglón:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(Q[1,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Norma de tercer renglón:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(Q[2,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q@Q.T == approx(np.eye(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q.T@Q == approx(np.eye(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verificando que es igual A al producto QR\n",
      "QR:\n",
      "array([[ 2., -1.,  2.],\n",
      "       [ 1.,  6., -1.],\n",
      "       [ 1.,  4.,  1.]])\n",
      "A\n",
      "array([[ 2, -1,  2],\n",
      "       [ 1,  6, -1],\n",
      "       [ 1,  4,  1]])\n"
     ]
    }
   ],
   "source": [
    "print('Verificando que es igual A al producto QR')\n",
    "print('QR:')\n",
    "pprint.pprint(Q@R)\n",
    "print('A')\n",
    "pprint.pprint(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resolvemos: $ RX = Q^T B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usando los factores Q,R para resolver AX = B\n"
     ]
    }
   ],
   "source": [
    "print('Usando los factores Q,R para resolver AX = B')\n",
    "X = scipy.linalg.solve_triangular(R, Q.T@B) #by default parameter lower is False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      "array([[ 7.33333333, -1.83333333],\n",
      "       [ 0.33333333,  1.66666667],\n",
      "       [-3.66666667,  2.16666667]])\n"
     ]
    }
   ],
   "source": [
    "print('X:')\n",
    "pprint.pprint(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verificando resultado AX = B\n",
      "B:\n",
      "array([[ 7, -1],\n",
      "       [13,  6],\n",
      "       [ 5,  7]])\n",
      "AX:\n",
      "array([[ 7., -1.],\n",
      "       [13.,  6.],\n",
      "       [ 5.,  7.]])\n"
     ]
    }
   ],
   "source": [
    "print('Verificando resultado AX = B')\n",
    "print('B:')\n",
    "pprint.pprint(B)\n",
    "print('AX:')\n",
    "pprint.pprint(A@X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Tarea) Ejercicio: resolver sistemas de ecuaciones lineales $Ax = b$ con la factorización P,L,U y QR. Para esto crear un módulo con nombre `solve_linear_system_of_equations.py` y colocar en tal módulo las siguientes funciones de Python:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para factorización `PLU`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "def PLU(matrix, rhs):\n",
    "    \"\"\"\n",
    "    Compute numerical approximation to linear system of equations Ax=b using\n",
    "    factorization PLU via scipy.\n",
    "    Args:\n",
    "        matrix (numpy 2d array of floats): Square system matrix.\n",
    "        rhs (numpy 1d array of floats): Right hand side of linear system of equations.\n",
    "    Returns:\n",
    "        x (numpy 1d array of floats or string): solution of Ax=b if A is square, if not returns string \n",
    "        \"System matrix must be square\"\n",
    "    \"\"\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para factorización `QR`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "def QR(matrix, rhs):\n",
    "    \"\"\"\n",
    "    Compute numerical approximation to linear system of equations Ax=b using\n",
    "    factorization QR via numpy.\n",
    "    Args:\n",
    "        matrix (numpy 2d array of floats): Square system matrix.\n",
    "        rhs (numpy 1d array of floats): Right hand side of linear system of equations.\n",
    "    Returns:\n",
    "        x (numpy 1d array of floats or string): solution of Ax=b if A is square, if not returns string \n",
    "        \"System matrix must be square\"\n",
    "    \"\"\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**La implementación de ambas funciones deben realizar un chequeo de dimensiones (ver *docstring* anteriores para saber qué mensaje deben regresar si la matriz del sistema no es cuadrada)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos de uso del paquete *SymPy* para resolver ecuaciones lineales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1)Considérese las variables $x,y$ del siguiente sistema y resuélvase con *SymPy* para $p, q$ constantes arbitrarias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{array}{ccc}\n",
    "x +  py &=& b_1 \\\\\n",
    "qx + y &=& b_2\n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos reescribir este sistema como:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{array}{l}\n",
    "\\left[\n",
    "\\begin{array}{cc}\n",
    "1 &p\\\\\n",
    "q & 1\\\\\n",
    "\\end{array}\n",
    "\\right]\n",
    "\\left[\n",
    "\\begin{array}{c}\n",
    "x \\\\\n",
    "y\n",
    "\\end{array}\n",
    "\\right]\n",
    "=\n",
    "\\left[\\begin{array}{c}\n",
    "b_1 \\\\\n",
    "b_2 \\\\\n",
    "\\end{array}\n",
    "\\right] \n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "p,q = sympy.symbols(\"p, q\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = sympy.Matrix([[1, p],\n",
    "                  [q, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & p\\\\q & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, p],\n",
       "[q, 1]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1, b2 = sympy.symbols(\"b1, b2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = sympy.Matrix([b1,b2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}b_{1}\\\\b_{2}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[b1],\n",
       "[b2]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\frac{- b_{1} + b_{2} p}{p q - 1}\\\\\\frac{b_{1} q - b_{2}}{p q - 1}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[(-b1 + b2*p)/(p*q - 1)],\n",
       "[ (b1*q - b2)/(p*q - 1)]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.solve(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2)El sistema:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{array}{l}\n",
    "Ax=\\left [\n",
    "\\begin{array}{cc}\n",
    "1 & -3 \\\\\n",
    "-2 & 6\n",
    "\\end{array}\n",
    "\\right ]\n",
    "\\left [\n",
    "\\begin{array}{c}\n",
    "x_1 \\\\\n",
    "x_2\n",
    "\\end{array}\n",
    "\\right ]\n",
    "=\n",
    "\\left [\n",
    "\\begin{array}{c}\n",
    "-1 \\\\\n",
    "2\n",
    "\\end{array}\n",
    "\\right ]\n",
    "=b\n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "tiene infinitas soluciones, su conjunto solución está dado por:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$S = \n",
    "\\left \\{\n",
    "\\left [ \n",
    "\\begin{array}{c}\n",
    "-1 + 3t \\\\\n",
    "t\\\\\n",
    "\\end{array}\n",
    "\\right ] | t \\in \\mathbb{R}\n",
    "\\right \\}\n",
    "=\n",
    "\\left \\{\n",
    "\\left [ \n",
    "\\begin{array}{c}\n",
    "-1\\\\\n",
    "0\\\\\n",
    "\\end{array} \n",
    "\\right ]\n",
    "+ \n",
    "t\\left [\n",
    "\\begin{array}{c}\n",
    "3\\\\\n",
    "1\\\\\n",
    "\\end{array}\n",
    "\\right ] | t \\in \\mathbb{R}\n",
    "\\right \\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Verificamos lo anterior con *SymPy*.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_vars = sympy.symbols(\"x1, x2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = sympy.Matrix([[1, -3],\n",
    "                  [-2, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = sympy.Matrix(x_vars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = sympy.Matrix([-1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{x1: 3*x2 - 1}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.solve(A*x - b, x_vars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hacemos la gráfica con *NumPy* y *Matplotlib*.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, -3],\n",
    "              [-2, 6.0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([-1,2.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas soluciones del sistema anterior están dadas por los siguientes puntos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "point1 = [-1, 0]\n",
    "point2 = [0, 1/3]\n",
    "point3 = [(point2[0]+point1[0])/2, \n",
    "           (point2[1] + point1[1])/2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  2.])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@point1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  2.])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@point2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  2.])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@point3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos dar la solución y graficar la solución del sistema anterior que tiene mínima norma 2 o Euclidiana $||x||_2 = \\sqrt{x_1^2 + x_2^2}$ utilizando *NumPy*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solución que tiene mínima norma $2$ o Euclidiana con [pinv](https://numpy.org/doc/stable/reference/generated/numpy.linalg.pinv.html):**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.1,  0.3])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point4 = np.row_stack((np.zeros(2), np.linalg.pinv(A)@b))\n",
    "point4[1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  2.])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@point4[1,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente punto satisface al sistema homogéneo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "point_homogeneous_system = [3, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0.])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@point_homogeneous_system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Gráfica.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.linspace(-1,1,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "plt.plot(3*t, t, 'b')\n",
    "plt.plot(-1+3*t, t, 'r')\n",
    "plt.scatter(point_homogeneous_system[0], point_homogeneous_system[1], color='b')\n",
    "plt.scatter(point1[0], point1[1], color = 'r')\n",
    "plt.scatter(point2[0], point2[1], color='r')\n",
    "plt.scatter(point3[0], point3[1], color = 'r')\n",
    "plt.plot(point4[:,0], point4[:,1], color='c')\n",
    "plt.axhline(color='k')\n",
    "plt.axvline(color='k')\n",
    "plt.axis(\"equal\")\n",
    "plt.legend([\"Solución sistema homogéneo\",\n",
    "            \"Solución sistema no homogéneo\",\n",
    "            \"Solución que minimiza norma Euclidiana\"], \n",
    "            bbox_to_anchor=(1, 1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(point1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3333333333333333"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(point2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5270462766947299"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(point3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.316227766016838"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(point4[1,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**El vector que tiene mínima norma $2$ es.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.1,  0.3])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point4[1,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias:\n",
    "* [numpy.linalg.solve](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.solve.html)\n",
    "* [scipy.linalg.lu](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.lu.html)\n",
    "* [scipy.linalg.solve_triangular](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.solve_triangular.html)\n",
    "* [numpy.linalg.qr](https://numpy.org/doc/stable/reference/generated/numpy.linalg.qr.html)"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}