jupyter_notebooks/linear_algebra.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Álgebra Linear com SymPy\n",
    "\n",
    "Um vetor $\\vec{v} \\in \\mathbb{R}$ é uma **n-tupla** de números reais. Por exemplo, considere um vetor com três componentes:\n",
    "\n",
    "\\begin{equation}\\vec{v} = (v1, v2, v3) \\in (\\mathbb{R}, \\mathbb{R}, \\mathbb{R}) \\equiv \\mathbb{R}³\\end{equation}\n",
    "\n",
    "Uma matriz $A \\in \\mathbb{R}^{m \\times n}$ é um array retangular de números reais com $m$ linhas e $n$ colunas. \n",
    "\n",
    "Um vetor é uma matriz especial. Nós podemos pensar o vetor como $\\vec{v} \\in \\mathbb{R}^n$\n",
    "\n",
    "- Ou um vetor de linhas: $(1 \\times n ~ matriz)$\n",
    "\n",
    "- Ou um vetor de colunas: $(n \\times 1 ~ matriz)$\n",
    "\n",
    "Por causa dessa equivalência, não há um objeto vetor especial em SymPy e objetos de Matriz são utilizados para vetores também."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplos\n",
    "\n",
    "Para iniciamors com os nossos exemplos, primeiro é necessário importar a biblioteca [SymPy](https://docs.sympy.org/latest/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "init_printing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definimos um vetor de linhas (1x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = Matrix(1,3,[4,5,6]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}4 & 5 & 6\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "[4  5  6]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definimos um vetor de colunas (3x1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Matrix([7,8,9]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}7\\\\8\\\\9\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡7⎤\n",
       "⎢ ⎥\n",
       "⎢8⎥\n",
       "⎢ ⎥\n",
       "⎣9⎦"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fazemos a transposição do vetor **v**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}7 & 8 & 9\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "[7  8  9]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Apresenta o primeiro componente do vetor **u** (índices começam por 0, assim como no Python tradicional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAABHNCSVQICAgIfAhkiAAAAMlJREFUOI290jFOQkEQxvEfxNIr0JJYamFFxT0sSKg9gIm6JQ0JxoYECCHexJh4Bi3p6TRIBcXbjRvMA54JfMkWuzv/+WZ2pxZC8B/V99zfYB1X91CwgWd8VXGsYYoFhlXAW7TRwfeh4AV6eMJrSeI/4BleMMddGZQCcz3gEi0sd4G543V06eN9F5SDqcRP3O+DcvAcTcXD/Pj99DUeY8wo7gfJCVaYlCS/UvT9ho/URgKXtkYqU4jgDOPtUivrqGBQzO44Pzx9qRu2oCPfWoik3gAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle 4$"
      ],
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u[0] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mostra o comprimento do vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACwAAAAbCAYAAAAH+20UAAAABHNCSVQICAgIfAhkiAAAAbNJREFUWIXt179qVEEUx/FPooIiglF8BIWID2DEQLCI/0CrCIIBK30KYQVfQjFt+igatZE02i5YiLZGsBFBxSJotJibTVjmxjPLHUIgPxjmMsxvz3d2z5mzd6zX69lNGt9pgFLtL9x/BN9rgERV+g1fxCWM7dQoBZ7B60JPpyoB3teMtUosIZUAn8ObWiBRlQBfwfNaIFGVAB/H11ogUUWBT+JDZv02/v5n/OnAM1D0Hr6Gp5n1Pu63eKZxAcsdeAaKAp/Cx8x6vxk5vW3mRx14Bhofen6Ay0N7jinP3TM4i8941qVnK/AspjA3tGeU2+FuMy/YJh9H8WxNiRf4glfSQdab9SksRklxCLca/+OuPcO3RB+/pCYBB6TTrovrBo5KhfOpa0/uWnuC683zDFaCQTd0p5kf1vDkgJdsAs/iZUHg09Kvsyqe90WeHPAKTmASh/EzGJiKxbahHPBv6aT38C4YFA5iXsr3hVqetta8hJvy3a1Nc5iQDhsttmJPG/Cy1HVWg4HZLJzWLtWFpw34B64WBJ7EeWXFNopn2/8S36IfgvfSO1eJRvHsvtf8PeDa+gcbXG3xXNGbgwAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle \\sqrt{77}$"
      ],
      "text/plain": [
       "√77"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.norm() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Computamos o vetor de comprimento de unidade, (mesma direção de **u**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix([[4*sqrt(77)/77, 5*sqrt(77)/77, 6*sqrt(77)/77]])\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAABHNCSVQICAgIfAhkiAAAAIdJREFUKJHt0SEOwmAMBeBvBD2NJAiCG5ZbIPDTSJJJxH8HLoDgHghOQoJEEfxmftVkyzBTNHlpX9OX17RFSsmvMQv8gAse+KDFLYrmgZ9R4YsXNmOcTlijxLFvveh07xscchoVf9HkovjcfQYsct7hmus3mijaog69VQY80cT1EooBLJnyEB2yexAji7I9mAAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uhat = u / u.norm() \n",
    "print(uhat)\n",
    "uhat.norm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O produto escalar dos vetores $\\vec{u}$ e $\\vec{v}$ pode ser definido como:\n",
    "\n",
    "\\begin{equation}\\vec{u} \\cdot \\vec{v} \\equiv u_x v_x + u_y v_y + u_z v_z \\equiv ||{\\vec{u}}|| ~ ||{\\vec{v}}|| \\cos (\\varphi) \\in \\mathbb{R}\\end{equation}\n",
    "\n",
    "onde $\\varphi$ é o ângulo entre os vetores $\\vec{u}$ e $\\vec{v}$.\n",
    "\n",
    "Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAASCAYAAABFGc6jAAAABHNCSVQICAgIfAhkiAAAAVJJREFUOI3V1T9Im0EYx/FPxM2igqLFMSAEOiilg6KQrbgIIt110aFbwMVSMEuhxU03J7GdXFwFlYCCo0IHB/8MEgf7VygtdSntcPdCeBOaUhPFHxzP3Y+7+74899y9mWKx6DbUkho/wzL28A2/8e4v699gB2X8xFccYgFdlRNbUwtfYgDfcYFcnQ8t4ABb+Ig2DKGI2dgv1wIVIuAUeZTqgNpxXcN/hReYx3OqU1fCiZCyf1EtCKzH2J8YaVCjNB7j+8RIp+5/NYcH6MATjEbI62aAeivGm5jGp8RoVOoeIhPjJLJCmT9uNCjRB2zgqXCP1poFSnSOIzxCdzNB0Bfjr5uCcsKZpNUiXNge7OOK6qqbiE3FJsNYjf3PQoXBGBaxizN8ESovLxTDJWaSjdOgQUylvGxshNwnoG2sYER4HzvxA8d4iyXhkQWZu/pN3H/QHz5kPwTyPxiXAAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$\\displaystyle 13$"
      ],
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = Matrix(1,3,[4,5,6])\n",
    "v = Matrix([-1,1,2])\n",
    "u.dot(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para calcular o ângulo entre dois vetores, nós transformamos a equação anterior para:\n",
    "\n",
    "\\begin{equation} \\cos(\\varphi) = \\frac{\\vec{u} \\cdot \\vec{v}}{||\\vec{u}|| ~ ||\\vec{v}||}\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle 0.921263115666387$"
      ],
      "text/plain": [
       "0.921263115666387"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acos(u.dot(v)/(u.norm()*v.norm())).evalf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O produto escalar é uma operação comutativa:\n",
    "\n",
    "\\begin{equation} \\vec{u} \\cdot \\vec{v} = \\vec{v} \\cdot \\vec{u} \\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dot(v) == v.dot(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O produto escalar também é utilizado para calcular projeções. \n",
    "\n",
    "Assumindo que você tenha dois vetores $\\vec{v}$ e $\\vec{n}$ e você deseja encontrar o componente de $\\vec{v}$ que aponta para a direção $\\vec{n}$\n",
    "\n",
    "\\begin{equation} \\prod_\\vec{n}(\\vec{v}) \\equiv \\frac{\\vec{v} \\cdot \\vec{n}}{||\\vec{n}||^2}\\vec{n} \\end{equation}\n",
    "\n",
    "Em SymPy, isso se traduziria como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}5\\\\5\\\\5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡5⎤\n",
       "⎢ ⎥\n",
       "⎢5⎥\n",
       "⎢ ⎥\n",
       "⎣5⎦"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Matrix([4,5,6])\n",
    "n = Matrix([1,1,1])\n",
    "projeção = (u.dot(n)/n.norm()**2) * n # \n",
    "projeção"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acima estamos calculando a **projeção** de **v** na direção **n**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O produto vetorial, denotado por $\\times$, recebe dois vetores como input e produz um vetor como output:\n",
    "\n",
    "\\begin{equation}\\vec{u} \\times \\vec{v} = (u_yv_z - u_zv_y,u_zv_x - u_xv_z,u_xv_y - u_y,v_x)\\end{equation}\n",
    "\n",
    "Definindo símbolos individuais para as entradas dos dois vetores, nós podemos fazer SymPy nos mostrar a fórmula do produto vetorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}u_{2} v_{3} - u_{3} v_{2}\\\\- u_{1} v_{3} + u_{3} v_{1}\\\\u_{1} v_{2} - u_{2} v_{1}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡u₂⋅v₃ - u₃⋅v₂ ⎤\n",
       "⎢              ⎥\n",
       "⎢-u₁⋅v₃ + u₃⋅v₁⎥\n",
       "⎢              ⎥\n",
       "⎣u₁⋅v₂ - u₂⋅v₁ ⎦"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u1, u2, u3 = symbols('u1:4')\n",
    "v1, v2, v3 = symbols('v1:4')\n",
    "Matrix([u1,u2,u3]).cross(Matrix([v1,v2,v3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O produto vetorial é anticomutativo $\\vec{u} \\times \\vec{v} = -\\vec{v} \\times \\vec{u}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\left[\\begin{matrix}4\\\\-14\\\\9\\end{matrix}\\right], \\  \\left[\\begin{matrix}-4\\\\14\\\\-9\\end{matrix}\\right]\\right)$"
      ],
      "text/plain": [
       "⎛⎡ 4 ⎤  ⎡-4⎤⎞\n",
       "⎜⎢   ⎥  ⎢  ⎥⎟\n",
       "⎜⎢-14⎥, ⎢14⎥⎟\n",
       "⎜⎢   ⎥  ⎢  ⎥⎟\n",
       "⎝⎣ 9 ⎦  ⎣-9⎦⎠"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = Matrix([4,5,6])\n",
    "v = Matrix([-1,1,2])\n",
    "u.cross(v), v.cross(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora olhar algumas particularidades das Matrizes.\n",
    "\n",
    "Começaremos definindo uma nova Matriz $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 & -3 & -8 & 7\\\\-2 & -2 & 2 & -7\\\\1 & 0 & -3 & 6\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡2   -3  -8  7 ⎤\n",
       "⎢              ⎥\n",
       "⎢-2  -2  2   -7⎥\n",
       "⎢              ⎥\n",
       "⎣1   0   -3  6 ⎦"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = Matrix([[2, -3, -8, 7], [-2, -2 , 2, -7], [1, 0, -3, 6]])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como visto anteriormente, nós podemos usar a indexação de Python para acessarmos elementos e submatrizes.\n",
    "\n",
    "A seguir, acessamos a linha **0**, coluna **1** da matriz $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB4AAAASCAYAAABM8m7ZAAAABHNCSVQICAgIfAhkiAAAASlJREFUSInN1b8rhVEcx/HXvdkIRUhZlDIoko0yWCwWf4HFwqQsLJ5FkYnR6MdisSosBiN1k0EpUiK/JjEQw/M8pdtz49Zx+dTp2/meb+fdOedzzslFUeQvlA883yL2cYUXPOIYc2j4TfAUqrGLZWziDREKaEsLqwKDa/GakZ/HLGYwQfgVZ0FhK4kdaSI0uJRGklhIE6G3OtU0alCHPgwk0IVKgJu/9Hcwhrs0UbzVF/goo22UALcgl8RRtIuvVW9aULzic6UNkqXrb8ZvsY0jnGENXVngoTKg5egSp+hBI+4r5WpoTeI7Ya9Tp/hMi5UXPyBNOMQTYV09jCUciL3yIHb2oNhcNxhPi0OC97CKfnSjHs9iU61jRfxpBAefYPKnxZU01/8AfwIzFD6QwSD+FgAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle -3$"
      ],
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[0,1] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos selecionar uma submatriz de $A$.\n",
    "\n",
    "Neste exemplo, vamos selecionar as duas primeiras linhas e 3 primeiras colunas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 & -3 & -8\\\\-2 & -2 & 2\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡2   -3  -8⎤\n",
       "⎢          ⎥\n",
       "⎣-2  -2  2 ⎦"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[0:2, 0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algumas matrizes usadas com frequência podem ser definidas através dos seguintes atalhos.\n",
    "\n",
    "**eye** nos permite criar uma matriz identidade:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡1  0⎤\n",
       "⎢    ⎥\n",
       "⎣0  1⎦"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eye(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**zeros** nos permite criar uma matriz com zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0\\\\0 & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡0  0  0⎤\n",
       "⎢       ⎥\n",
       "⎣0  0  0⎦"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ones** nos permite criar uma matriz somente de um:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "[1  1  1  1  1]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones(1,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**diag** nos permite criar uma matriz diagonal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 2 & 0\\\\0 & 0 & 3\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡1  0  0⎤\n",
       "⎢       ⎥\n",
       "⎢0  2  0⎥\n",
       "⎢       ⎥\n",
       "⎣0  0  3⎦"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operações algébricas padrões como **adição**, **subtração**, **multiplicação** e **exponenciação** funcionam como esperados para objetos de Matriz.\n",
    "\n",
    "O método **transpose()** gira a matriz através de sua diagonal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 & -2 & 1\\\\-3 & -2 & 0\\\\-8 & 2 & -3\\\\7 & -7 & 6\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡2   -2  1 ⎤\n",
       "⎢          ⎥\n",
       "⎢-3  -2  0 ⎥\n",
       "⎢          ⎥\n",
       "⎢-8  2   -3⎥\n",
       "⎢          ⎥\n",
       "⎣7   -7  6 ⎦"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O determinante de uma matriz é denotado como $det(M)$ ou $|M|$ e pode ser calculado em SymPy como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAABHNCSVQICAgIfAhkiAAAAPZJREFUKJGd0r8rxWEUx/HX5f4HBrPdH3FlshjIiIFNSRmUUt9MNinFYLj/gAwiFhKTUgZJMsjiJimTwc/h+6jTt2/3fvnU0zmd57xP5/P01LIs81d1hbwH09jBHd7wijNMxd56gMawgUcc4wG9GMEWhlLPd4RuMYw9fIX6Is4xmgZsx/WOsFsAoIXNlDeKntrpPcWPqlAdEyk/qAqtoB/7OKwCzWIeNxj/LbaDZrCGawzgpRM0h3VcJaAVL8ugBaziMgFPxYYitCQ3foFBPJetEX/EJJbxiVP5IxR1j2aE+lLslnsq0wmacb0MtQ6nUeapkv4F/QC4NjEPV14CWgAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle 2$"
      ],
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = Matrix([[1, 2, 3], [2, -2, 4], [2, 2, 5]])\n",
    "\n",
    "M.det()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para cada Matriz $A$ invertível, existe uma Matriz inversa $A^{-1}$.\n",
    "\n",
    "O efeito cumulativo do produto de $A$ e $A^{-1}$ é a matriz identidade: $AA^{-1} = A^{-1}A = \\mathbb{1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 9\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡1  2⎤\n",
       "⎢    ⎥\n",
       "⎣3  9⎦"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = Matrix([[1,2],[3,9]])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir podemos ver a relação de equivalência à $A^{-1}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\left[\\begin{matrix}3 & - \\frac{2}{3}\\\\-1 & \\frac{1}{3}\\end{matrix}\\right], \\  \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right], \\  \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]\\right)$"
      ],
      "text/plain": [
       "⎛⎡3   -2/3⎤  ⎡1  0⎤  ⎡1  0⎤⎞\n",
       "⎜⎢        ⎥, ⎢    ⎥, ⎢    ⎥⎟\n",
       "⎝⎣-1  1/3 ⎦  ⎣0  1⎦  ⎣0  1⎦⎠"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.inv(), A.inv()*A, A*A.inv()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando uma matriz é multiplicada por um de seus autovetores o output é o mesmo autovetor multiplicado por uma constante\n",
    "$A\\vec{e}\\lambda = \\lambda\\vec{e}_\\lambda$. \n",
    "\n",
    "A constante $\\lambda$ é chamada de autovalor de $A$.\n",
    "\n",
    "Para encontrar os autovalores de uma matriz, começa-se pela definição $A\\vec{e}_\\lambda = \\lambda\\vec{e}_\\lambda$, insere-se a identidade $\\mathbb{1}$ e reescreve-se como um problema de espaço nulo:\n",
    "\n",
    "\\begin{equation}A\\vec{e}\\lambda = \\lambda\\mathbb{1}\\vec{e}_\\lambda \\Longrightarrow (A - \\lambda\\mathbb{1})\\vec{e}\\lambda = \\vec{0} \\end{equation}\n",
    "\n",
    "Essa equação terá uma solução quando $|A - \\lambda\\mathbb{1}| = 0$. Os autovalores de $A \\in \\mathbb{R}^{n \\times m}$, denotados $\\{ \\lambda1, \\lambda2, ..., \\lambda n \\}$ são raízes do polinômio característico $p(\\lambda) = | A - \\lambda\\mathbb{1}|$\n",
    "\n",
    "É dessa forma que autovetores e autovalores funcionam no SymPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[ \\left( 5, \\  1, \\  \\left[ \\left[\\begin{matrix}\\frac{1}{2}\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( 10, \\  1, \\  \\left[ \\left[\\begin{matrix}-2\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$"
      ],
      "text/plain": [
       "⎡⎛      ⎡⎡1/2⎤⎤⎞  ⎛       ⎡⎡-2⎤⎤⎞⎤\n",
       "⎢⎜5, 1, ⎢⎢   ⎥⎥⎟, ⎜10, 1, ⎢⎢  ⎥⎥⎟⎥\n",
       "⎣⎝      ⎣⎣ 1 ⎦⎦⎠  ⎝       ⎣⎣1 ⎦⎦⎠⎦"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = Matrix([[9, -2],[-2, 6]])\n",
    "\n",
    "A.eigenvals()\n",
    "A.eigenvects()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certas matrizes podem ser escritas inteiramente em termos de seus autovetores e seus autovalores. \n",
    "\n",
    "Considere a Matrix $\\Lambda$ que tem os autovalores da Matriz $A$ em sua diagonal, e a Matriz $Q$ construída dos autovetores de A como colunas:\n",
    "\n",
    "\\begin{equation}\n",
    "\\Lambda =\n",
    "\\begin{bmatrix}\n",
    "\\lambda_1 & ... & 0 \\\\\n",
    "... & ... & 0 \\\\\n",
    "0 & 0 & \\lambda_n\n",
    "\\end{bmatrix} , \n",
    "Q =\n",
    "\\begin{bmatrix}\n",
    "| & ~ & | \\\\\n",
    "e\\vec{\\lambda}_1 & ... & e\\vec{\\lambda}_n \\\\\n",
    "| & ~ & | \n",
    "\\end{bmatrix} \n",
    "\\end{equation}\n",
    "\n",
    "então $ A = Q \\Lambda Q^{-1} $\n",
    "\n",
    "Matrizes que podem ser escritas dessa maneira são chamadas de diagonalizável.\n",
    "\n",
    "Para diagonalizar uma Matriz $A$ é encontrar suas matrizes $Q$ e $\\Lambda$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Matrix([[9, -2], [-2, 6]])\n",
    "Q, L = A.diagonalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matriz de autovetores $Q$, como colunas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & -2\\\\2 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡1  -2⎤\n",
       "⎢     ⎥\n",
       "⎣2  1 ⎦"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Q^{-1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\frac{1}{5} & \\frac{2}{5}\\\\- \\frac{2}{5} & \\frac{1}{5}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡1/5   2/5⎤\n",
       "⎢         ⎥\n",
       "⎣-2/5  1/5⎦"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q.inv() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$L$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}5 & 0\\\\0 & 10\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡5  0 ⎤\n",
       "⎢     ⎥\n",
       "⎣0  10⎦"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Realizamos a autodecomposição de $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}9 & -2\\\\-2 & 6\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡9   -2⎤\n",
       "⎢      ⎥\n",
       "⎣-2  6 ⎦"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q * L * Q.inv() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nem todas as matrizes são diagonalizáveis. Você pode checar se uma matriz é diagonalizável chamando o método **is_diagonalizable**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.is_diagonalizable()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = Matrix([[1,3],[0,1]])\n",
    "B.is_diagonalizable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Autovalores de $B$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEEAAAAWCAYAAACffPEKAAAABHNCSVQICAgIfAhkiAAAAo1JREFUWIXt2FuITVEYB/DfmJGU3HNJCkVuD/Mg5W27lZLQePLgEkUpPCheRCQeKOVlnuRh5kUKoebJpZkimijJAw9D0jxQLmWUy3hY63SO45x99j6cQc2/dmu31///fd/61t7fWmszjJrYjHt4j29o/bvh5MZRfEE/rmBeXgML8R0fcR7HMa2Mswnn0I0PGERHvRGnYBJ24jKeY0CYmB7swIgqugSn0BVju5/X8Z4o3JvCeRQ5H/FU45KwO9p+jU6cFCbmXXx+CU01bPQKkzomj+PD0cHqFM5yzI0BJBqXhBVY59cZn4aX0W9bDRudkTezvKPaawTNsf2SwrmFZ9F4I3ET14SZLEU/2uN9UsNGYRzN5R1pSRgqXBCSuK1OfWFwX+sNIC0J42M7UK/xIUALtsT7rhrcz7Edl9V4k2IhKV8RqiFRX02Yjvl5givB6ejzRgbuocjdV4u4BmfwIAra0+k/IdG4wlgJe6O/p5iYgT8DfcLncxEnMKsS8Ww0PIjHWJQjqMTQJaGwfD+R/U2FXfikOMakGnEs1gu14JUK1bQKEkOThP2KkzQlh25t1PUIkzsyi6gjihZndJJofBIORh8PMTmn9kzUrirvSFsdXsQ2y/f2O8haGA8LW+BerMSbnH4mxLavvKMlRVRYf9MStSFeFL/NZcLaTwj0QI3gTmIrtpfoyrEVx4RDXLfKW/m+FD3Fcfyyn0hLQpZdYGsMsBRz4kV4m2olIQtmx7ZZqAmVcEd6EgrItbstrKsb84j+YVwVxjM1j6gtiq4Lh45/YYtdD0ZhqXD0fi/nOEYLy9BgyfU//lQpjf9IJVJaTRjAEuEYu0A4h/f/0RAbj9tCIXyLu8L/j2EMowp+AMX3mt7VCX3LAAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$$\\left \\{ 1 : 2\\right \\}$$"
      ],
      "text/plain": [
       "{1: 2}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.eigenvals()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Autovetores de $B$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[ \\left( 1, \\  2, \\  \\left[ \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right]\\right]\\right)\\right]$"
      ],
      "text/plain": [
       "⎡⎛      ⎡⎡1⎤⎤⎞⎤\n",
       "⎢⎜1, 2, ⎢⎢ ⎥⎥⎟⎥\n",
       "⎣⎝      ⎣⎣0⎦⎦⎠⎦"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.eigenvects()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A matriz $B$ não é diagonalizável, porque ela não tem um conjunto completo de autovetores. Para diagonalizar uma matriz $2 \\times 2$ nós precisamos de dois autovetores ortogonais, porém B tem somente um único autovetor."
   ]
  }
 ],
 "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}