AL_010.000_Composición.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sympy import * \n",
    "from ubogsla18p import *\n",
    "#from sympy import init_printing # mejora la presentacion\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Composición de transformaciones y vectores propios\n",
    "Nakos pg 357\n",
    "\n",
    "## Definición\n",
    "Sean $T_A:U \\rightarrow V$ y $T_B:V \\rightarrow W$ transformaciones matriciales correspondientes a las matrices $A$ y $B$, la composición de $T_A$ con $T_B$ es la transformación $T_B \\circ T_A: U \\rightarrow W $ definida por\n",
    "$$ (T_B \\circ T_A)(u)=T_B(T_A(u))$$\n",
    "para todo $u \\in U$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"300\" width=\"300\"><circle cx=\"100\" cy=\"100\" r=\"5\"/><text x=\"100\" y=\"120\">U</text><circle cx=\"200\" cy=\"100\" r=\"5\"/><text x=\"200\" y=\"120\">V</text><circle cx=\"200\" cy=\"200\" r=\"5\"/><text x=\"200\" y=\"220\">W</text><polyline points=\"100,100 190.0,100.0 183.7,93.7 183.7,106.3 190.0,100.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"120.0\">T_A</text><polyline points=\"200,100 200.0,190.0 206.3,183.7 193.70000000000002,183.7 200.0,190.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"200.0\" y=\"170.0\">T_B</text><polyline points=\"100,100 190.0,190.0 190.0,177.4 177.4,190.0 190.0,190.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"170.0\"/><text x=\"170.0\" y=\"150.0\">=</text></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grafo({\"U\":(1,1,\"U\"),\"V\":(2,1,\"V\"),\"W\":(2,2,\"W\")},[(\"T_A\",\"U\",\"V\"),(\"T_B\",\"V\",\"W\"),(\"\",\"U\",\"W\")],[(1.7,1.5,\"=\")])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El símbolo \"=\" significa que da igual cualquiera de los dos caminos de $U$ a $W$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Propiedades\n",
    "De las muchas propiedades de las matrices, sólo vamos a retomar las siguientes. \n",
    "Sean $A$, $B$ y $C$ matrices de tamaños adecuados, entonces:\n",
    "* $T_B \\circ T_A = T_{BA}$, En donde $BA$ es la multiplicación matricial.\n",
    "* $ (T_C \\circ T_B) \\circ T_A = T_C \\circ (T_B \\circ T_A) $\n",
    "* $T^{-1}_A$ existe si y solo si $T_A$ es biyectiva.\n",
    "\n",
    "Si $A$ es una matriz invertible, entonces:\n",
    "* $T^{-1}_A=T_{A^{-1}}$, En donde $A^{-1}$ es la matriz inversa.\n",
    "* $T_A \\circ T^{-1}_A = T_I$, En donde $I$ es la matriz identidad.\n",
    "\n",
    "## Ejercicios y ejemplos del libro\n",
    "Ejemplo 5.5.51 pg 358 \n",
    "\n",
    "Ejemplo 5.5.52 pg 360 \n",
    "\n",
    "Ejemplo 5.5.53 pg 362 \n",
    "\n",
    "Ejercicios 5.5.[9,11,13] pg 363\n",
    "\n",
    "Ejercicios 5.5.[15,18,19,21] pg 364\n",
    "\n",
    "\n",
    "# Cambio de base y  Matrices semejantes\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recorderis:\n",
    "\n",
    "Sabemos que las siguientes afirmaciones se cumplen para una matriz $B$ cuadrada de orden $n$ con $n$ pivotes.\n",
    "* Las columnas de $B$ forman una base de $\\mathbb{R}^n$, ya que:\n",
    "  * es linealmente independiente, \n",
    "  * genera a $\\mathbb{R}^n$.\n",
    "* $B$ es invertible.\n",
    "* $T_B$ es un isomorfismo.\n",
    "\n",
    "## Cambio de base\n",
    "\n",
    "Sea $T_A:\\mathbb{R}^n \\rightarrow \\mathbb{R}^m$ una transformación lineal, Además, sean $B$ y $C$ dos matrices invertibles de tamaños $n \\times n$  y $m \\times m$ respectivamente. Entonces las columnas de $B$ forman una base de $\\mathbb{R}^n$. Además,  $T_B:\\mathbb{R}^n \\rightarrow \\mathbb{R}^n$ es un isomorfismo. Algo similar ocurre con $C$ para  $\\mathbb{R}^m$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"300\" width=\"300\"><circle cx=\"100\" cy=\"100\" r=\"5\"/><text x=\"100\" y=\"120\">V</text><circle cx=\"200\" cy=\"100\" r=\"5\"/><text x=\"200\" y=\"120\">W</text><circle cx=\"100\" cy=\"200\" r=\"5\"/><text x=\"100\" y=\"220\">V</text><circle cx=\"200\" cy=\"200\" r=\"5\"/><text x=\"200\" y=\"220\">W</text><polyline points=\"100,100 190.0,100.0 183.7,93.7 183.7,106.3 190.0,100.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"120.0\">T_A</text><polyline points=\"100,200 100.0,110.00000000000001 93.7,116.3 106.3,116.3 100.0,110.00000000000001\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"100.0\" y=\"170.0\">T_B</text><polyline points=\"200,200 200.0,110.00000000000001 193.70000000000002,116.3 206.3,116.3 200.0,110.00000000000001\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"200.0\" y=\"170.0\">T_C</text><text x=\"150.0\" y=\"150.0\">=</text></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grafo({\"V\":(1,1,\"V\"),\"W\":(2,1,\"W\"),\"V1\":(1,2,\"V\"),\"W1\":(2,2,\"W\")},[(\"T_A\",\"V\",\"W\"),(\"T_B\",\"V1\",\"V\"),(\"T_C\",\"W1\",\"W\")],[(1.5,1.5,\"=\")])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La transformación $T_D:\\mathbb{R}^n \\rightarrow \\mathbb{R}^m$ dada por \n",
    "$$T_D= T_C^{-1} \\circ T_A \\circ T_B = T_{C^{-1}AB}$$\n",
    "Se conoce como la __transformación $T_A$ en las bases $B$ y $C$__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"300\" width=\"300\"><circle cx=\"100\" cy=\"100\" r=\"5\"/><text x=\"100\" y=\"120\">V</text><circle cx=\"200\" cy=\"100\" r=\"5\"/><text x=\"200\" y=\"120\">W</text><circle cx=\"100\" cy=\"200\" r=\"5\"/><text x=\"100\" y=\"220\">V</text><circle cx=\"200\" cy=\"200\" r=\"5\"/><text x=\"200\" y=\"220\">W</text><polyline points=\"100,100 190.0,100.0 183.7,93.7 183.7,106.3 190.0,100.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"120.0\">T_A</text><polyline points=\"100,200 100.0,110.00000000000001 93.7,116.3 106.3,116.3 100.0,110.00000000000001\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"100.0\" y=\"170.0\">T_B</text><polyline points=\"200,200 200.0,110.00000000000001 193.70000000000002,116.3 206.3,116.3 200.0,110.00000000000001\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"200.0\" y=\"170.0\">T_C</text><polyline points=\"100,200 190.0,200.0 183.7,193.70000000000002 183.7,206.3 190.0,200.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"220.0\">T_D</text><text x=\"150.0\" y=\"150.0\">=</text></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grafo({\"V\":(1,1,\"V\"),\"W\":(2,1,\"W\"),\"V1\":(1,2,\"V\"),\"W1\":(2,2,\"W\")},[(\"T_A\",\"V\",\"W\"),(\"T_B\",\"V1\",\"V\"),(\"T_C\",\"W1\",\"W\"),(\"T_D\",\"V1\",\"W1\")],[(1.5,1.5,\"=\")])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si $m=n$ y $B=C$ entonces \n",
    "$$T_D=T_{B^{-1}AB}$$\n",
    "y\n",
    "$$D=B^{-1}AB$$\n",
    "En este caso $T_D$ y $T_A$ se llaman __transformaciones semejantes__. Adicionalmente, $D$ y $A$ se llaman __matrices semejantes__.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"300\" width=\"300\"><circle cx=\"100\" cy=\"100\" r=\"5\"/><text x=\"100\" y=\"120\">V</text><circle cx=\"200\" cy=\"100\" r=\"5\"/><text x=\"200\" y=\"120\">v</text><circle cx=\"100\" cy=\"200\" r=\"5\"/><text x=\"100\" y=\"220\">V</text><circle cx=\"200\" cy=\"200\" r=\"5\"/><text x=\"200\" y=\"220\">V</text><polyline points=\"100,100 190.0,100.0 183.7,93.7 183.7,106.3 190.0,100.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"120.0\">T_A</text><polyline points=\"100,200 100.0,110.00000000000001 93.7,116.3 106.3,116.3 100.0,110.00000000000001\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"100.0\" y=\"170.0\">T_B</text><polyline points=\"200,200 200.0,110.00000000000001 193.70000000000002,116.3 206.3,116.3 200.0,110.00000000000001\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"200.0\" y=\"170.0\">T_B</text><polyline points=\"100,200 190.0,200.0 183.7,193.70000000000002 183.7,206.3 190.0,200.0\" stroke=\"black\" stroke-width=\"3\"/> <text x=\"150.0\" y=\"220.0\">T_D</text><text x=\"150.0\" y=\"150.0\">=</text></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grafo({\"V\":(1,1,\"V\"),\"W\":(2,1,\"v\"),\"V1\":(1,2,\"V\"),\"W1\":(2,2,\"V\")},[(\"T_A\",\"V\",\"W\"),(\"T_B\",\"V1\",\"V\"),(\"T_B\",\"W1\",\"W\"),(\"T_D\",\"V1\",\"W1\")],[(1.5,1.5,\"=\")])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vectores propios\n",
    "El objetivo de cambiar de base es poder definir la misma transformación, pero en términos más sencillos. \n",
    "\n",
    "Las condiciones que debe cumplir $B=\\begin{bmatrix}\\vec{v}_0 & \\vec{v}_1 & \\cdots & \\vec{v}_{(n-1)} \\end{bmatrix}$ para que sea diagonal la matriz semejante $D=\\begin{bmatrix}\\lambda_0 & 0 & \\cdots & 0 \\\\ 0 & \\lambda_1 & \\cdots & 0 \\\\\\vdots & \\vdots & \\ddots & \\vdots \\\\ 0 & 0 & \\cdots & \\lambda_{(n-1)}   \\end{bmatrix}$   es la siguiente.\n",
    "\n",
    "\\begin{align}\n",
    "D&=B^{-1}AB\\\\\n",
    "BD&=AB\\\\\n",
    "B\\begin{bmatrix}\\lambda_0 & 0 & \\cdots & 0 \\\\ 0 & \\lambda_1 & \\cdots & 0 \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\0 & 0 & \\cdots & \\lambda_{(n-1)}   \\end{bmatrix}\n",
    "&=A\\begin{bmatrix}\\vec{v}_0 & \\vec{v}_1 & \\cdots & \\vec{v}_{(n-1)} \\end{bmatrix}\\\\\n",
    "\\begin{bmatrix} \\lambda_0 \\vec{v}_0  & \\lambda_1 \\vec{v}_1 & \\cdots &  \\lambda_{(n-1)} \\vec{v}_{(n-1)} \\end{bmatrix}\n",
    "&=\\begin{bmatrix} A \\vec{v}_0 & A \\vec{v}_1 & \\cdots & A \\vec{v}_{(n-1)} \\end{bmatrix}\\\\\n",
    "\\end{align}\n",
    "Es decir que \n",
    "$$A \\vec{v}_i = \\lambda_i \\vec{v}_i$$\n",
    "para $i \\in \\{0,1,\\ldots ,n-1\\}.$ Cada $\\lambda_i$ se llama __eigenvalor__ y cada $\\vec{v}_i$ se llama __ eigenvector__.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Informalmente podemos decir que los eigenvectores son aquellos vectores que al ser transformados no cambian su dirección, sólo cambian su magnitud según el eigenvalor. La anterior ecuación se puede escribir de la siguiente forma.\n",
    "\n",
    "\\begin{align}\n",
    "A \\vec{v}_i &= \\lambda_i \\vec{v}_i\\\\\n",
    "A \\vec{v}_i - \\lambda_i \\vec{v}_i = \\vec{0}\\\\\n",
    "A \\vec{v}_i - \\lambda_i (I \\vec{v}_i) = \\vec{0}\\\\\n",
    "A \\vec{v}_i - (\\lambda_i I) \\vec{v}_i = \\vec{0}\\\\\n",
    "(A  - \\lambda_i I) \\vec{v}_i = \\vec{0}\\\\\n",
    "C_i \\vec{v}_i = \\vec{0}\\\\\n",
    "\\end{align}\n",
    "\n",
    "Donde $I$ es la matriz identidad y $C_i=A  - \\lambda_i I$. La matriz $A  - \\lambda_i I$ se llama la __matriz característica__. La última ecuación implica que los eigenvectores corresponden al núcleo de la matriz caracterísitca. Pero si la matriz es invertible el único eigenvector es el cero. Por lo tanto, la matriz característica no debe ser invertible lo cual implica que su determinante es cero.\n",
    "\n",
    "\\begin{align}\n",
    "\\text{Det}(C_i)=0\\\\\n",
    "\\text{Det}(A  - \\lambda_i I)=0\\\\\n",
    "\\end{align}\n",
    "\n",
    "Por otro lado $\\text{Det}(A  - \\lambda_i I)$ es un polinomio  en $\\lambda$ y sus raíces corresponden a los eigenvalores $\\lambda_i$. La multiplicidad de cada raíz del polinomio característico se llama __multiplicidad algebraica__ (M.A.) y la nulidad de cada $C_i$ se llama __multiplicidad geométrica__ (M.G.). Se tiene que $1 \\leq M.G. \\leq M.A.$.  \n",
    "\n",
    "Para que la matriz sea diagonalizable es necesario que todas las M.G. sean iguales a las M.A.. En este caso la base de eigenvectores está formada por las bases de cada núcleo de $C_i$.\n",
    "\n",
    "## Ejercicios\n",
    "\n",
    "Nakos 7.1.[1,3,5,7,9,13,14] pg 453\n",
    "\n",
    "Nakos 7.2.[3,7,9,11,15,23,27,28] pgs. 465-467\n",
    "\n",
    "Grossman Ejemplos 6.1.[1,2,3,4,5,6,7,8,9,10,11,12,] pgs 525-533\n",
    "\n",
    "Avanzado 7.1.[47,48,49,50,51,52,53] ver eninciado previo. pg 455\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Forma canónica de Jordan\n",
    "\n",
    "Cuando no es posible diagonalizar una matriz cuadrada, es posible encontrar la __forma canónica de Jordan__. Vamos a ilustrar el proceso con una matriz $A$ de $4 \\times 4$ con un sólo eigenvalor $\\lambda$ y un sólo eigenvector $v_0$.\n",
    "\n",
    "Para este caso la forma canónica de Jordan está dada por un __bloque de Jordan__\n",
    "$$J=\\begin{bmatrix}\\lambda & 1 & 0 & 0\\\\ 0 & \\lambda & 1  & 0\\\\ 0 & 0 & \\lambda & 1 \\\\ 0 & 0 & 0 & \\lambda \\\\ \\end{bmatrix}$$\n",
    "Ahora el objetivo es encontrar una matriz $B$ inverible tal que $J=B^{-1}AB$.\n",
    "\\begin{align}\n",
    "J&=B^{-1}AB\\\\\n",
    "BJ&=AB\\\\\n",
    "\\begin{bmatrix}\\vec{v}_0 & \\vec{v}_1 & \\vec{v}_2 & \\vec{v}_3 \\end{bmatrix}\n",
    "\\begin{bmatrix}\\lambda & 1 & 0 & 0\\\\ 0 & \\lambda & 1  & 0\\\\ 0 & 0 & \\lambda & 1 \\\\ 0 & 0 & 0 & \\lambda \\\\ \\end{bmatrix}\n",
    "&=A\\begin{bmatrix}\\vec{v}_0 & \\vec{v}_1 & \\vec{v}_2 & \\vec{v}_3 \\end{bmatrix}\\\\\n",
    "\\begin{bmatrix} \\lambda \\vec{v}_0  & \\vec{v}_0+\\lambda \\vec{v}_1 & \\vec{v}_1+\\lambda \\vec{v}_2 &  \\vec{v}_2+\\lambda \\vec{v}_3 \\end{bmatrix}\n",
    "&=\\begin{bmatrix} A \\vec{v}_0 & A \\vec{v}_1 & A \\vec{v}_2 & A \\vec{v}_3 \\end{bmatrix}\\\\\n",
    "\\end{align}\n",
    "\n",
    "De la primera columna se obtiene $$ A \\vec{v}_0 = \\lambda \\vec{v}_0$$, lo cual corresponde a que $v_0$ es un vector propio de $A$. Ahora hay encontrar los vectores $v_1$, $v_2$ y $v_3$, los cuales cumplen para cada $i\\in\\{1,2,3\\}$.\n",
    "\\begin{align}\n",
    "A \\vec{v}_i &= \\vec{v}_{i-1}+\\lambda \\vec{v}_i \\\\\n",
    "A \\vec{v}_i - \\lambda \\vec{v}_i &= \\vec{v}_{i-1} \\\\\n",
    "(A-\\lambda I) \\vec{v}_i &= \\vec{v}_{i-1} \\\\\n",
    "[(A-\\lambda I) &:\\vec{v}_{i-1}] \\\\\n",
    "[E &:\\vec{v}_{i}] \\\\\n",
    "\\end{align}\n",
    "\n",
    "En donde $[E :\\vec{v}_{i}]$ es la forma escalón reducida de $[(A-\\lambda I) :\\vec{v}_{i-1}]$. Esto permite encontrar los vectores $v_1$, $v_2$ y $v_3$  de forma recursiva.\n",
    "\n",
    "A continuación se dan algunas matrices en forma canónica de Jordan con varios bloques de Jordan (tomadas del libro de Chen).\n",
    "\n",
    "| -------------------- Matriz -------------------- | M.A.$\\lambda_0$ | M.G.$\\lambda_0$ | M.A.$\\lambda_1$ | M.G.$\\lambda_1$ |\n",
    "|-|-|-|\n",
    "|$$A_0=\\begin{bmatrix}\n",
    "\\lambda_0 & 1 & 0 & 0 & 0 \\\\ \n",
    "0 & \\lambda_0 & 1 & 0 & 0 \\\\ \n",
    "0 & 0 & \\lambda_0 & 1 & 0 \\\\ \n",
    "0 & 0 & 0 & \\lambda_0 & 0 \\\\ \n",
    "0 & 0 & 0 & 0 & \\lambda_1 \\\\ \n",
    "\\end{bmatrix} $$|4|1|1|1|\n",
    "|$$A_1=\\begin{bmatrix}\n",
    "\\lambda_0 & 1 & 0 & 0 & 0 \\\\ \n",
    "0 & \\lambda_0 & 1 & 0 & 0 \\\\ \n",
    "0 & 0 & \\lambda_0 & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & \\lambda_0 & 0 \\\\ \n",
    "0 & 0 & 0 & 0 & \\lambda_1 \\\\ \n",
    "\\end{bmatrix} $$|4|2|1|1|\n",
    "|$$A_3=\\begin{bmatrix}\n",
    "\\lambda_0 & 1 & 0 & 0 & 0 \\\\ \n",
    "0 & \\lambda_0 & 0 & 0 & 0 \\\\ \n",
    "0 & 0 & \\lambda_0 & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & \\lambda_0 & 0 \\\\ \n",
    "0 & 0 & 0 & 0 & \\lambda_1 \\\\ \n",
    "\\end{bmatrix} $$|4|3|1|1|\n",
    "|$$A_4=\\begin{bmatrix}\n",
    "\\lambda_0 & 0 & 0 & 0 & 0 \\\\ \n",
    "0 & \\lambda_0 & 0 & 0 & 0 \\\\ \n",
    "0 & 0 & \\lambda_0 & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & \\lambda_0 & 0 \\\\ \n",
    "0 & 0 & 0 & 0 & \\lambda_1 \\\\ \n",
    "\\end{bmatrix} $$|4|4|1|1|\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "E0r=juntar(C0,v0).rref()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$A=$$\\left[\\begin{matrix}-5 & -5 & -9\\\\8 & 9 & 18\\\\-2 & -3 & -7\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=symbols('\\lambda')\n",
    "A=mat('-5 -5 -9;8 9 18;-2 -3 -7')\n",
    "imprimir('A=',A)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$A-\\lambda I=$$\\left[\\begin{matrix}- \\lambda - 5 & -5 & -9\\\\8 & - \\lambda + 9 & 18\\\\-2 & -3 & - \\lambda - 7\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C=A-l*eye(3)\n",
    "imprimir(r'A-\\lambda I=',C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{Det}(A-\\lambda I)=$$- \\lambda^{3} - 3 \\lambda^{2} - 3 \\lambda - 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d=det(C)\n",
    "imprimir(r'\\text{Det}(A-\\lambda I)=',d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{Det}(A-\\lambda I)=$$- \\left(\\lambda + 1\\right)^{3}$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r=factor(d)\n",
    "imprimir(r'\\text{Det}(A-\\lambda I)=',r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$A-(-1) I=$$\\left[\\begin{matrix}-4 & -5 & -9\\\\8 & 10 & 18\\\\-2 & -3 & -6\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C0=C.applyfunc(lambda x:x.subs(l,-1))\n",
    "imprimir(r'A-(-1) I=',C0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$v_0=$$\\left[\\begin{matrix}\\frac{3}{2}\\\\-3\\\\1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v0=C0.nullspace()[0]\n",
    "imprimir('v_0=',v0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$E_0=$$\\left[\\begin{matrix}-4 & -5 & -9 & \\frac{3}{2}\\\\8 & 10 & 18 & -3\\\\-2 & -3 & -6 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E0=juntar(C0,v0)\n",
    "imprimir('E_0=',E0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$R_0=$$\\left[\\begin{matrix}1 & 0 & - \\frac{3}{2} & \\frac{1}{4}\\\\0 & 1 & 3 & - \\frac{1}{2}\\\\0 & 0 & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R0=E0.rref()[0]\n",
    "imprimir('R_0=',R0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$v_1=$$\\left[\\begin{matrix}\\frac{1}{4}\\\\- \\frac{1}{2}\\\\0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1=E0r.col(3)\n",
    "imprimir('v_1=',v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$E_1=$$\\left[\\begin{matrix}-4 & -5 & -9 & \\frac{1}{4}\\\\8 & 10 & 18 & - \\frac{1}{2}\\\\-2 & -3 & -6 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E1=juntar(C0,v1)\n",
    "imprimir('E_1=',E1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$R1=$$\\left[\\begin{matrix}1 & 0 & - \\frac{3}{2} & - \\frac{3}{8}\\\\0 & 1 & 3 & \\frac{1}{4}\\\\0 & 0 & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R1=E1.rref()[0]\n",
    "imprimir('R1=',R1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$v_2=$$\\left[\\begin{matrix}- \\frac{3}{8}\\\\\\frac{1}{4}\\\\0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2=R1.col(3)\n",
    "imprimir('v_2=',v2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$B=$$\\left[\\begin{matrix}\\frac{3}{2} & \\frac{1}{4} & - \\frac{3}{8}\\\\-3 & - \\frac{1}{2} & \\frac{1}{4}\\\\1 & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=juntar(v0,v1,v2)\n",
    "imprimir('B=',B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$J=$$\\left[\\begin{matrix}-1 & 1 & 0\\\\0 & -1 & 1\\\\0 & 0 & -1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J=B.inv()*A*B\n",
    "imprimir('J=',J)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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
}