7 Matrices-espacios-vectoriales.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrices y espacios vectoriales\n",
    "\n",
    "Las matrices en `gap` se representan como una lista de listas, de forma que todas ellas tengan la misma longitud y el mismo tipo de elementos. Por tanto hay que tener cuidado con qué comandos son 'destructivos'.  La suma, producto e inverso se calculan con las operaciones usuales.\n",
    "\n",
    "Esto cambiará en las versiones futuras de `gap` (véase el proyecto [MatrixObj](http://gapdays.de/gapdays2017-fall/slides/slides-Horn-MatrixObj.html))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2 ], [ 3, 4 ] ]"
      ]
     },
     "execution_count": 1,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[ [ 5, 6 ], [ 7, 8 ] ]"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2],[3,4]];\n",
    "b:=[[5,6],[7,8]];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 6, 8 ], [ 10, 12 ] ]"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 19, 22 ], [ 43, 50 ] ]"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ -2, 1 ], [ 3/2, -1/2 ] ]"
      ]
     },
     "execution_count": 5,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a^(-1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 0 ], [ 0, 1 ] ]"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a^0;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y el determinante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Determinant(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para calcular la forma normal de Hermite sobre los enteros disponemos de la siguiente función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,6]];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 0, 3, 6 ] ]"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HermiteNormalFormIntegerMat(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos las matrices te transformaciones para llegar a la forma de Hermite:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( normal := [ [ 1, 2, 3 ], [ 0, 3, 6 ] ], rank := 2, rowC := [ [ 1, 0 ], [ 0, 1 ] ], rowQ := [ [ 1, 0 ], [ 4, -1 ] ], rowtrans := [ [ 1, 0 ], [ 4, -1 ] ] )"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HermiteNormalFormIntegerMatTransform(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos hacer el cálculo sobre los racionales, usamos `TriangulizeMat`, pero ojo, que esta función destruye el argumento que le pasamos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,6]];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "TriangulizeMat(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 0, -1 ], [ 0, 1, 2 ] ]"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con `TriangulizedMat` el argumento no se modifica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 14,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,6]];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 0, -1 ], [ 0, 1, 2 ] ]"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TriangulizedMat(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "P:=PolynomialRing(Rationals,\"x\");;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, x ] ]"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,x]];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "x:=Indeterminate(Rationals,\"x\");;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Error, no method found! For debugging hints type ?Recovery from NoMethodFound\n",
      "Error, no 1st choice method found for `TriangulizedMat' on 1 arguments at /home/pedro/lib/gap-4.10.0/lib/methsel2.g:250 called from\n",
      "<function \"HANDLE_METHOD_NOT_FOUND\">( <arguments> )\n",
      " called from read-eval loop at stream:1\n"
     ]
    }
   ],
   "source": [
    "TriangulizedMat(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El error se debe a que en este caso `a` es una lista de listas con enteros (que no se consideran polinomios) y un polinomio (`x`). Para arreglar esto, multiplicamos toda la matriz por `One(P)` convirtiendo todos los enteros en polinomios (constantes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 0, 2/3*x-5 ], [ 0, 1, -1/3*x+4 ] ]"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TriangulizedMat(a*One(P));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos hacer las cuentas sobre un cuerpo finito, podemos usar el comando `GF` (cuerpo de Galois), y luego embeber la matriz dada en dicho cuerpo con `One`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GF(7)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F:=GF(7);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,6]];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ Z(7)^0, Z(7)^2, Z(7) ], [ Z(7)^4, Z(7)^5, Z(7)^3 ] ]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "az7:=a*One(F);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "TriangulizeMat(az7);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ Z(7)^0, 0*Z(7), Z(7)^3 ], [ 0*Z(7), Z(7)^0, Z(7)^2 ] ]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "az7;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u0003#I  \u0003\u0003Teaching mode is turned \u0003\u0003ON\u0003\u0003\n",
      "\u0003"
     ]
    }
   ],
   "source": [
    "TeachingMode(true);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ ZmodnZObj(1,7), ZmodnZObj(0,7), ZmodnZObj(6,7) ], [ ZmodnZObj(0,7), ZmodnZObj(1,7), ZmodnZObj(2,7) ] ]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "az7;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nótese que `a` no ha sido destruida, pues la operación `a*One(F)` genera una nueva matriz a partir de ella."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sistemas de ecuaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para encontrar una solución de un sistema de la forma $x A=b$ usando `gap`, utilizamos el comando `SolutionMat` junto con `NullspaceMat`. \n",
    "El primero nos da una solución particular (en caso de existir) y el segundo nos da las soluciones del sistema homogéneo asociado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[ 1, 1, 1 ]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,6]]; b:=[1,1,1];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ -1/3, 1/3 ]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SolutionMat(a,b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[  ]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NullspaceMat(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con lo que en este caso la solución es única."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[ 1, 1 ]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2],[3,4],[5,6]];b:=[1,1];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ -1/2, 1/2, 0 ]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SolutionMat(a,b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, -2, 1 ] ]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NullspaceMat(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y en este caso las soluciones son de la forma $(-\\frac{1}2,\\frac{1}2,0)+\\lambda (1,-2,1)$. \n",
    "\n",
    "En caso de no existir solución recibimos un `fail` a cambio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[ 1, 1, 2 ]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2,3],[4,5,6]]; b:=[1,1,2];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fail"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SolutionMat(a,b);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos hacer las cuentas sobre un cuerpo finito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[ 1, 1 ]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,2],[3,4],[5,6]];b:=[1,1];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GF(5)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F:=GF(5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ ZmodnZObj(2,5), ZmodnZObj(3,5), ZmodnZObj(0,5) ]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SolutionMat(a*One(F),b*One(F));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Espacios vectoriales\n",
    "\n",
    "`gap` ya sabe que algunos de sus objetos son espacios vectoriales, y además podemos definir nuevos espacios vectoriales de diferentes formas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "InstallMethod(ViewString, [IsPolynomial], String);\n",
    "InstallMethod(ViewString, [IsVectorSpace], function(v) return(\"Espacio vectorial\"); end);\n",
    "InstallMethod(ViewString, [IsSubspacesVectorSpace], function(v) return(\"Subespacios vectoriales\"); end);\n",
    "InstallMethod(ViewString, [IsGeneralMapping], function(v) return(\"Aplicación\"); end);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x:=Indeterminate(Rationals,\"x\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rationals[x]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P:=PolynomialRing(Rationals,[x]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsVectorSpace(P);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsVectorSpace(Rationals^4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V:=VectorSpace(Rationals, [[1,2,3],[4,5,6]]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[3,3,3] in V;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2, 3 ], [ 0, 1, 2 ] ]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B:=Basis(V);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dimension(V);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos calcular los coeficientes de un vector respecto de una base, o las combinaciones lineales de los elementos de una base."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, -1 ]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Coefficients(B,[1,1,1]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fail"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Coefficients(B,[1,0,1]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 3, 5 ]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LinearCombination(B,[1,1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los subespacios se pueden definir con la orden `Subspace`, y los cocientes se hacen como en grupos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "( Rationals^4 )"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V:=Rationals^4;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W:=Subspace(V,[[1,2,3,4],[1,1,1,1]]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos hacer cocientes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "( Rationals^2 )"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V/W;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También intersecciones y sumas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U:=Subspace(V,[[3,3,3,3],[2,2,0,0]]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Intersection(U,W);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 1, 1, 1 ] ]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Basis(Intersection(U,W));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 1, 1, 1 ], [ 0, 1, 0, 1 ], [ 0, 0, 1, 1 ] ]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Basis(U+W);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si nuestro espacio vectorial es finito, podemos calcular todos sus subespacios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Subespacios vectoriales"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sz22:= Subspaces(GF(2)^2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [  ], [ [ ZmodnZObj(1,2), ZmodnZObj(0,2) ] ], [ [ ZmodnZObj(1,2), ZmodnZObj(1,2) ] ], [ [ ZmodnZObj(0,2), ZmodnZObj(1,2) ] ], [ [ ZmodnZObj(1,2), ZmodnZObj(0,2) ], [ ZmodnZObj(0,2), ZmodnZObj(1,2) ] ] ]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List(sz22,w->BasisVectors(Basis(w)));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [  ], [ [ ZmodnZObj(1,2), ZmodnZObj(0,2) ] ], [ [ ZmodnZObj(1,2), ZmodnZObj(1,2) ] ], [ [ ZmodnZObj(0,2), ZmodnZObj(1,2) ] ], [ [ ZmodnZObj(1,2), ZmodnZObj(0,2) ], [ ZmodnZObj(0,2), ZmodnZObj(1,2) ] ] ]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List(sz22,w->Basis(w));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ [ ZmodnZObj(0,2), ZmodnZObj(0,2) ] ], [ [ ZmodnZObj(0,2), ZmodnZObj(0,2) ], [ ZmodnZObj(1,2), ZmodnZObj(0,2) ] ], [ [ ZmodnZObj(0,2), ZmodnZObj(0,2) ], [ ZmodnZObj(1,2), ZmodnZObj(1,2) ] ], [ [ ZmodnZObj(0,2), ZmodnZObj(0,2) ], [ ZmodnZObj(0,2), ZmodnZObj(1,2) ] ], [ [ ZmodnZObj(0,2), ZmodnZObj(0,2) ], [ ZmodnZObj(0,2), ZmodnZObj(1,2) ], [ ZmodnZObj(1,2), ZmodnZObj(0,2) ], [ ZmodnZObj(1,2), ZmodnZObj(1,2) ] ] ]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List(sz22,Elements);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir una aplicación lineal entre subespacios podemos usar la función `LeftModuleGeneralMappingByImages`, pues en `gap`, los espacios vectoriales son considerados como módulos a izquierda.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Un complemento de un subespacio $W$ de $V$ lo podemos calcular usando el homomorfismo natural de $V$ a $V/W$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "( Rationals^4 )"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Aplicación"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V:=Rationals^4;\n",
    "W:=Subspace(V,[[1,0,0,0],[0,0,0,1]]);\n",
    "p:=NaturalHomomorphismBySubspace(V,W);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 0, 1, 0, 0 ]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PreImagesRepresentative(p,[1,0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 0, 0, 1, 0 ]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PreImagesRepresentative(p,[0,1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al no ser la aplicación biyectiva no podemos usar `PreImage` a secas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "( Rationals^4 )"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Aplicación"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V1:=Rationals^4;;\n",
    "V2:=VectorSpace(Rationals,[[1,2],[3,4]]);;\n",
    "f:=LeftModuleGeneralMappingByImages(V1,V2,Basis(V1), [[1,2],[3,4],[1,0],[0,1]]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Espacio vectorial"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(f);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, 2 ], [ 0, 1 ] ]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Basis(Image(f));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 1, -1/2, 1/2, 0 ], [ 0, 1, -3, -4 ] ]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Basis(Kernel(f));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y teorema de isomorfía al canto..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V1/Kernel(f)=Image(f);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos usar notación matricial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aplicación"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g:=LeftModuleHomomorphismByMatrix(Basis(V1),[[1,0],[0,1],[1,1],[-1,1]], Basis(V2));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 0, 9 ]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(g,[1,2,3,4]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsInjective(g);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsSurjective(g);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diagonalización"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos cómo calcular el polinomio característico y sus ceros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ ZmodnZObj(1,7), ZmodnZObj(0,7), ZmodnZObj(1,7) ], [ ZmodnZObj(3,7), ZmodnZObj(1,7), ZmodnZObj(0,7) ], [ ZmodnZObj(0,7), ZmodnZObj(1,7), ZmodnZObj(0,7) ] ]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[[1,0,1],[3,1,0],[0,1,0]]*One(GF(7));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x_1^3+ZmodnZObj(5,7)*x_1^2+x_1+ZmodnZObj(4,7)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p:=CharacteristicPolynomial(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ ZmodnZObj(6,7), ZmodnZObj(5,7), ZmodnZObj(5,7) ]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rs:=RootsOfPolynomial(p);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprobemos si `a` es diagonalizable, para ello calculamos sus subespacios propios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ [ ZmodnZObj(3,7), ZmodnZObj(6,7), ZmodnZObj(1,7) ] ], [ [ ZmodnZObj(2,7), ZmodnZObj(5,7), ZmodnZObj(1,7) ] ] ]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List(Set(rs),r->NullspaceMat(TransposedMat(a-r*a^0)));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos, el elemento $5\\in \\mathbb{Z}_7$ es una raíz doble cuyo subespacio propio tiene dimensión uno, por lo que la matriz no es diagonalizable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos otro ejemplo que sí es diagonalizable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ -1, 0, -1 ], [ 0, -2, 0 ], [ -3, 0, 1 ] ]"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[ [ -1, 0, -1 ], [ 0, -2, 0 ], [ -3, 0, 1 ] ];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x^3+2*x^2-4*x-8"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p:=CharacteristicPolynomial(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2, -2, -2 ]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rs:=RootsOfPolynomial(p);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ [ 0, 1, 0 ], [ 1, 0, 1 ] ], [ [ -1/3, 0, 1 ] ] ]"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp:=List(Set(rs),r->NullspaceMat(TransposedMat(a-r*a^0)));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 0, 1, -1/3 ], [ 1, 0, 0 ], [ 0, 1, 1 ] ]"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P:=TransposedMat(Concatenation(sp));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ -2, 0, 0 ], [ 0, -2, 0 ], [ 0, 0, 2 ] ]"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P^(-1)*a*P;"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "GAP 4",
   "language": "gap",
   "name": "gap-4"
  },
  "language_info": {
   "codemirror_mode": "gap",
   "file_extension": ".g",
   "mimetype": "text/x-gap",
   "name": "GAP 4",
   "nbconvert_exporter": "",
   "pygments_lexer": "gap",
   "version": "4.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}