AL003.500_Gauss.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sympy import * # Librería para operaciones simbólicas\n",
    "from ubogsla18p import * # Librería personal\n",
    "import u_bog_gauss_18p as gauss # Librería personal parea reducción por el método de Gauss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operaciones elementales\n",
    "[Nakos, Sec. 1.1]\n",
    "\n",
    "Las siguientes operaciones entre los renglones de una matriz: \n",
    "* Intercambio de renglón. $R_i \\leftrightarrow R_j$ \n",
    "* Multiplica un renglones por un escalar (diferente de cero). $kR_i \\rightarrow R_i$ \n",
    "* Suma un múltiplo (no nulo) de un renglón a otro. $kR_j + R_i \\rightarrow R_i$ \n",
    "\n",
    "se llaman __operaciones elementales__ y cumplen que:\n",
    "* no alteran la solución del sistema de ecuaciones,\n",
    "* permiten modificar la matriz para que cumplan las propiedades E1, E2, E3 y E4. \n",
    "\n",
    "Dos matrices se dice que son __equivalentes__ si es posible pasar de una a la otra por medio de operaciones elementales y se denota $A \\sim B$.  \n",
    "\n",
    "La operación $k_jR_j + k_iR_i \\rightarrow R_i$ corresponde a realizar:\n",
    "* primero  $k_iR_i \\rightarrow R_i$, \n",
    "* luego $k_jR_j + R_i \\rightarrow R_i$. \n",
    "\n",
    "A continuación, se dan ejemplos de las operaciones elementales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$A=$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=mat(\"0 3 -6 ;-1 3 -10  ; 4 -9 34 ;2 -6 20\")\n",
    "imprimir('A=',A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R0 <-> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$ \\stackrel{r0 <-> r1}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10\\\\0 & 3 & -6\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imprimir(A,r' \\stackrel{r0 <-> r1}{\\longrightarrow} ',\n",
    "         gauss.op(A,'r0 <-> r1'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2R1 -> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$ \\stackrel{2r1->r1}{\\longrightarrow} $$\\left[\\begin{matrix}0 & 3 & -6\\\\-2 & 6 & -20\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imprimir(A,r' \\stackrel{2r1->r1}{\\longrightarrow} ',\n",
    "         gauss.op(A,'2r1->r1'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2R1+1R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$ \\stackrel{2r1+r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\2 & -3 & 14\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imprimir(A,r' \\stackrel{2r1+r2 -> r2}{\\longrightarrow} ',\n",
    "         gauss.op(A,'2r1+r2 -> r2'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2R1+2R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$ \\stackrel{2r1-2r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\10 & -24 & 88\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imprimir(A,r' \\stackrel{2r1-2r2 -> r2}{\\longrightarrow} ',\n",
    "         gauss.op(A,'2r1-2r2 -> r2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrices elementales\n",
    "[Nakos, Sec. 3.3]\n",
    "\n",
    "Una __ matriz elemental__ $E$ resulta de aplicar una operación elemental $op$ a la matriz identidad $I_m$\n",
    "$$E=op(I_m)$$\n",
    "\n",
    "y cumple que $EA=op(A)$ para cualquier matriz $A$ de $m$ renglones.\n",
    "\n",
    "A continuación, se presentan las respectivas matrices elementales de los ejemplos anteriores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$I=$$\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I=eye(A.rows)\n",
    "imprimir('I=',I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R0 <-> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}0 & 1 & 0 & 0\\\\1 & 0 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$=$$\\left[\\begin{matrix}-1 & 3 & -10\\\\0 & 3 & -6\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E1=gauss.op(I,'r0 <-> r1')\n",
    "imprimir(E1,A,'=',E1*A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2R1 -> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 2 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$=$$\\left[\\begin{matrix}0 & 3 & -6\\\\-2 & 6 & -20\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E2=gauss.op(I,'2r1->r1')\n",
    "imprimir(E2,A,'=',E2*A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2R1+1R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & 2 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$=$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\2 & -3 & 14\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E3=gauss.op(I,'2r1+r2 -> r2')\n",
    "imprimir(E3,A,'=',E3*A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2R1+2R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & -2 & 2 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\4 & -9 & 34\\\\2 & -6 & 20\\end{matrix}\\right]$$=$$\\left[\\begin{matrix}0 & 3 & -6\\\\-1 & 3 & -10\\\\10 & -24 & 88\\\\2 & -6 & 20\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E1=gauss.op(I,'2r1-2r2 -> r2')\n",
    "imprimir(E1,A,'=',E1*A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Eliminación de Gauss\n",
    "[Nakos, Sec. 1.2]\n",
    "\n",
    "\n",
    "Una matriz se puede transformar a la forma escalón mediante los siguientes cuatro pasos. El último paso la convierte a la forma escalón reducida.\n",
    "1. Vaya a la columna extrema izquierda que no sea de ceros.\n",
    "2. Si el primer renglón tiene un cero en la columna del paso (1), intercámbielo con uno que tenga un elemento no cero en la misma columna.\n",
    "3. Obtenga ceros abajo del elemento delantero, sumando múltiplos adecuados del renglón superior a los renglones debajo de él.\n",
    "4. Cubra el renglón superior y repita el mismo proceso comenzando por el paso (1) aplicado a la sub-matriz restante. Repita este proceso con el resto de los renglones.\n",
    "\\5. Comenzando con el último renglón no cero, avance hacia arriba: para cada renglón obtenga un 1 delantero e introduzca ceros arriba de él, sumando múltiplos adecuados a los renglones correspondientes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$A=$$\\left[\\begin{matrix}0 & 3 & -6 & -4 & -3 & -5\\\\-1 & 3 & -10 & -4 & -4 & -2\\\\4 & -9 & 34 & 0 & 1 & -21\\\\2 & -6 & 20 & 2 & 8 & -8\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=mat(\"0 3 -6 -4 -3 -5;-1 3 -10 -4 -4 -2 ; 4 -9 34 0 1 -21;2 -6 20 2 8 -8\")\n",
    "imprimir('A=',A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nuestro objetivo ahora es obtener un pivote en la columna 0, pero observe que en el renglón 0 hay un cero\n",
      "R1 <-> R0\n",
      "Super bien, ya no es cero el elemento delantero 0,0\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}0 & 3 & -6 & -4 & -3 & -5\\\\-1 & 3 & -10 & -4 & -4 & -2\\\\4 & -9 & 34 & 0 & 1 & -21\\\\2 & -6 & 20 & 2 & 8 & -8\\end{matrix}\\right]$$ \\stackrel{r1 <-> r0}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\4 & -9 & 34 & 0 & 1 & -21\\\\2 & -6 & 20 & 2 & 8 & -8\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gauss.evaluar(A,'sugerir',1)\n",
    "oper='r1 <-> r0'\n",
    "A1= gauss.evaluar(A,oper)\n",
    "imprimir(A,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahora hay que obtener ceros bajo el pivite\n",
      "4R0+1R2 -> R2\n",
      "Bien, obtuvo un cero más\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\4 & -9 & 34 & 0 & 1 & -21\\\\2 & -6 & 20 & 2 & 8 & -8\\end{matrix}\\right]$$ \\stackrel{4r0+r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 3 & -6 & -16 & -15 & -29\\\\2 & -6 & 20 & 2 & 8 & -8\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gauss.evaluar(A1,'sugerir',1)\n",
    "oper='4r0+r2 -> r2'\n",
    "A2= gauss.evaluar(A1,oper)\n",
    "imprimir(A1,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahora hay que obtener ceros bajo el pivite\n",
      "2R0+1R3 -> R3\n",
      "Muy bien, avanzó otra columna\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 3 & -6 & -16 & -15 & -29\\\\2 & -6 & 20 & 2 & 8 & -8\\end{matrix}\\right]$$ \\stackrel{2r0 + r3 -> r3}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 3 & -6 & -16 & -15 & -29\\\\0 & 0 & 0 & -6 & 0 & -12\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gauss.evaluar(A2,'sugerir',1)\n",
    "oper='2r0 + r3 -> r3'\n",
    "A3= gauss.evaluar(A2,oper)\n",
    "imprimir(A2,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahora hay que obtener ceros bajo el pivite\n",
      "-1R1+1R2 -> R2\n",
      "Muy bien, avanzó otra columna\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 3 & -6 & -16 & -15 & -29\\\\0 & 0 & 0 & -6 & 0 & -12\\end{matrix}\\right]$$ \\stackrel{-r1 + r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -12 & -12 & -24\\\\0 & 0 & 0 & -6 & 0 & -12\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gauss.evaluar(A3,'sugerir',1)\n",
    "oper='-r1 + r2 -> r2'\n",
    "A4= gauss.evaluar(A3,oper)\n",
    "imprimir(A3,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahora hay que obtener ceros bajo el pivite\n",
      "1/12R2 -> R2\n",
      "Ya obtuvo un divisor en el elemento delantero\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -12 & -12 & -24\\\\0 & 0 & 0 & -6 & 0 & -12\\end{matrix}\\right]$$ \\stackrel{1/12r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & -1 & -2\\\\0 & 0 & 0 & -6 & 0 & -12\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gauss.evaluar(A4,'sugerir',1)\n",
    "oper='1/12r2 -> r2'\n",
    "A5= gauss.evaluar(A4,oper)\n",
    "imprimir(A4,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahora hay que obtener ceros bajo el pivite\n",
      "-6R2+1R3 -> R3\n",
      "Felicitaciones!! la matriz ya está en forma escalón\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & -1 & -2\\\\0 & 0 & 0 & -6 & 0 & -12\\end{matrix}\\right]$$ \\stackrel{-6r2+r3 -> r3}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & -1 & -2\\\\0 & 0 & 0 & 0 & 6 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gauss.evaluar(A5,'sugerir',1)\n",
    "oper='-6r2+r3 -> r3'\n",
    "A6= gauss.evaluar(A5,oper)\n",
    "imprimir(A5,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/6R3 -> R3\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & -1 & -2\\\\0 & 0 & 0 & 0 & 6 & 0\\end{matrix}\\right]$$ \\stackrel{1/6r3 -> r3}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & -1 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='1/6r3 -> r3'\n",
    "A7= gauss.op(A6,oper)\n",
    "imprimir(A6,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1R3+1R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & -1 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{r3 + r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & 0 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='r3 + r2 -> r2'\n",
    "A8= gauss.op(A7,oper)\n",
    "imprimir(A7,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3R3+1R1 -> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & -3 & -5\\\\0 & 0 & 0 & -1 & 0 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{3r3 +r1 -> r1}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & 0 & -5\\\\0 & 0 & 0 & -1 & 0 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='3r3 +r1 -> r1'\n",
    "A9= gauss.op(A8,oper)\n",
    "imprimir(A8,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4R3+1R0 -> R0\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & -4 & -2\\\\0 & 3 & -6 & -4 & 0 & -5\\\\0 & 0 & 0 & -1 & 0 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{4r3+r0 -> r0}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & 0 & -2\\\\0 & 3 & -6 & -4 & 0 & -5\\\\0 & 0 & 0 & -1 & 0 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='4r3+r0 -> r0'\n",
    "A10= gauss.op(A9,oper)\n",
    "imprimir(A9,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & 0 & -2\\\\0 & 3 & -6 & -4 & 0 & -5\\\\0 & 0 & 0 & -1 & 0 & -2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{-r2 -> r2}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & 0 & -2\\\\0 & 3 & -6 & -4 & 0 & -5\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='-r2 -> r2'\n",
    "A11= gauss.op(A10,oper)\n",
    "imprimir(A10,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4R2+1R1 -> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & 0 & -2\\\\0 & 3 & -6 & -4 & 0 & -5\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{4r2 +r1 -> r1}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & 0 & -2\\\\0 & 3 & -6 & 0 & 0 & 3\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='4r2 +r1 -> r1'\n",
    "A12= gauss.op(A11,oper)\n",
    "imprimir(A11,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4R2+1R0 -> R0\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & -4 & 0 & -2\\\\0 & 3 & -6 & 0 & 0 & 3\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{4r2 + r0 -> r0}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & 0 & 0 & 6\\\\0 & 3 & -6 & 0 & 0 & 3\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='4r2 + r0 -> r0'\n",
    "A13= gauss.op(A12,oper)\n",
    "imprimir(A12,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/3R1 -> R1\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & 0 & 0 & 6\\\\0 & 3 & -6 & 0 & 0 & 3\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{1/3 r1 -> r1}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 3 & -10 & 0 & 0 & 6\\\\0 & 1 & -2 & 0 & 0 & 1\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='1/3 r1 -> r1'\n",
    "A14= gauss.op(A13,oper)\n",
    "imprimir(A13,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3R1+1R0 -> R0\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 3 & -10 & 0 & 0 & 6\\\\0 & 1 & -2 & 0 & 0 & 1\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{-3r1 + r0 -> r0}{\\longrightarrow} $$\\left[\\begin{matrix}-1 & 0 & -4 & 0 & 0 & 3\\\\0 & 1 & -2 & 0 & 0 & 1\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='-3r1 + r0 -> r0'\n",
    "A15= gauss.op(A14,oper)\n",
    "imprimir(A14,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1R0 -> R0\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left[\\begin{matrix}-1 & 0 & -4 & 0 & 0 & 3\\\\0 & 1 & -2 & 0 & 0 & 1\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$$ \\stackrel{-r0 -> r0}{\\longrightarrow} $$\\left[\\begin{matrix}1 & 0 & 4 & 0 & 0 & -3\\\\0 & 1 & -2 & 0 & 0 & 1\\\\0 & 0 & 0 & 1 & 0 & 2\\\\0 & 0 & 0 & 0 & 1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oper='-r0 -> r0'\n",
    "A16= gauss.op(A15,oper)\n",
    "imprimir(A15,r' \\stackrel{'+oper+r'}{\\longrightarrow} ',A16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Propiedades:\n",
    "\n",
    "* Una matriz extendida es equivalente a muchas matrices en forma escalón, pero sólo a una matriz escalón reducida. Es decir, que dos matrices son equivalentes si ambas son equivalentes a la misma matriz escalón reducida.\n",
    "\n",
    "* Como las matrices equivalentes en forma escalón tienen los pivotes en las mismas posiciones, entonces se extienden estas  __posiciones de los pivotes__ a todas las matrices equivalentes, aunque no estén en forma escalón."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejercicios:\n",
    "\n",
    "Para la matriz extendida $E=\\begin{bmatrix}\n",
    "2 & 4 & 0 & 5 & 3 & : & 4 \\\\\n",
    "1 & 0 & 2 & 5 & 6 & : & 2 \\\\\n",
    "1 & 1 & 3 & 0 & 1 & : & 3\n",
    "\\end{bmatrix}$ diga:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[2, 4, 0, 5, 3, 4],\n",
       "[1, 0, 2, 5, 6, 2],\n",
       "[1, 1, 3, 0, 1, 3]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=mat(\"2 4 0 5 3 4; 1 0 2 5 6 2; 1 1 3 0 1 3\")\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R1 <-> R0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[1, 0, 2, 5, 6, 2],\n",
       "[2, 4, 0, 5, 3, 4],\n",
       "[1, 1, 3, 0, 1, 3]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B1=gauss.op(B,\"r1<->r0\")\n",
    "B1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2R0+1R1 -> R1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[1, 0,  2,  5,  6, 2],\n",
       "[0, 4, -4, -5, -9, 0],\n",
       "[1, 1,  3,  0,  1, 3]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B1=gauss.op(B1,\"-2r0+r1->r1\")\n",
    "B1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1R0+1R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[1, 0,  2,  5,  6, 2],\n",
       "[0, 4, -4, -5, -9, 0],\n",
       "[0, 1,  1, -5, -5, 1]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B1=gauss.op(B1,\"-r0+r2->r2\")\n",
    "B1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R1 <-> R2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[1, 0,  2,  5,  6, 2],\n",
       "[0, 1,  1, -5, -5, 1],\n",
       "[0, 4, -4, -5, -9, 0]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B1=gauss.op(B1,\"r1<->r2\")\n",
    "B1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4R1+1R2 -> R2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[1, 0,  2,  5,  6,  2],\n",
       "[0, 1,  1, -5, -5,  1],\n",
       "[0, 0, -8, 15, 11, -4]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B1=gauss.op(B1,\"-4r1+r2->r2\")\n",
    "B1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1  ¿Cuantas columnas tiene la matriz de coeficientes de $E$? %R. 5\n",
    "\n",
    "2  ¿Cuál es el elemento del renglón 1 de los términos constantes de $E$? %R. 2\n",
    "\n",
    "3  ¿Cuál es el elemento 2,5 de $E$?%R. 3\n",
    "\n",
    "4  ¿Cuantas ecuaciones tiene $E$? %R. 3\n",
    "\n",
    "5  ¿Cuantas variables tiene $E$? %R. 5\n",
    "\n",
    "6  ¿Cómo queda el elemento 0,4 después de restarle el renglón 1 al renglón 0?%R. -3\n",
    "\n",
    "7   Encuentre la forma escalón. ¿Cuantos pivotes tiene? %3\n",
    "\n",
    "8  ¿Máximo cuantos pivotes puede tener una matriz de $5 \\times 8$? % 5\n",
    "\n",
    "9  ¿Máximo Cuantos pivotes puede tener una matriz de $7 \\times 4$?%4\n",
    "\n",
    "10  ¿Máximo cuantos parámetros puede tener una matriz extendida de $5 \\times 8$? %7\n",
    "\n",
    "11  ¿Máximo cuantos parámetros puede tener una matriz extendida de $7 \\times 4$?%3\n",
    "\n",
    "12  ¿Cuantos parámetros tiene $E$? %2\n",
    "\n",
    "13  Encuentre la forma reducida de $E$ ¿Cuál es el valor del primer término constante?%1\n",
    "\n",
    "14   ¿Cuál es el valor del segundo término constante?%0.5\n",
    "\n",
    "15   ¿Cuál es el valor del tercer término constante?%0.5\n",
    "\n",
    "16  Escriba: 0 si $E$ es inconsistente, 1 si $E$ es consistente y tiene solución única o 2 si $E$ es consistente y tiene infinitas soluciones.%2\n",
    "\n",
    "17   ¿Por cuánto hay que multiplicar el primer renglón para que al sumarlo al segundo renglón elimine el primer elemento? % -0.5"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}