Álgebra Linear/Algebra_Linear-Introducao(SymPy-NumPy).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Àlgebra Linear com Python: uma breve introdução**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este notebook objetiva demonstrar a resolução de problemas comuns da Álgebra Linear utilizando NumPy e SymPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primeiro iremos importar as bibliotecas que iremos utilizar no decorrer deste notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sympy\n",
    "from sympy.matrices import zeros,eye,ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da Álgebra linear sabemos que uma matriz A sobre um corpo K ou, simplesmente, uma matriz A (quando K estiver subentendido) é uma tabela\n",
    "retangular de escalares, costumeiramente representada no formato que segue:$$A= \\left[\n",
    "\\begin{array}{c c c}\n",
    "a_{11}&\\ldots& a_{1n}\\\\\n",
    "a_{21}& \\ldots& a_{2n}\\\\\n",
    "\\vdots&\\ddots &\\vdots\\\\ a_{m1}&\\ldots& a_{mn}\n",
    "\\end{array}\\right]\n",
    "$$ \n",
    "\n",
    "Dizemos que uma matriz com m linhas e n colunas é uma matriz m $\\times $ n . O par de\n",
    "números $m$ e $n$ é dito o tamanho da matriz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos especiais de matrizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consideremos uma matriz com $m$ linhas e $n$ colunas que denotaremos por $A_{m\\times n}$. Apresentaremos brevemente algumas matrizes importantes em Álgebra Linear. Utilizaremos o construtor Matrix() da biblioteca SymPy para definir as matrizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Matriz Quadrada: matriz em que o número de linhas é igual ao número de colunas ($m=n$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}-1 & 2\\\\4 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[-1, 2],\n",
       "[ 4, 5]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = sympy.Matrix(2,2,[-1, 2, 4, 5])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Matriz Nula: matriz em que todos os elementos são nulos, ou seja, $a_{ij}=0$ para todo $i$ e $j$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0\\\\0 & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 0, 0],\n",
       "[0, 0, 0]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = sympy.zeros(2,3)\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Matriz-Coluna:matriz que possui uma única coluna ($A_{m \\times 1}$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}-1\\\\2\\\\10\\\\5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[-1],\n",
       "[ 2],\n",
       "[10],\n",
       "[ 5]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = sympy.Matrix(4,1, [-1, 2, 10, 5])\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Matriz-Linha: matriz com uma única linha ($A_{1 \\times n}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = sympy.symbols(['x','y','z'])  #transform string em símbolos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}x & y & z\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[x, y, z]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = sympy.Matrix(1,3, [x,y,z])\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Matriz diagonal: matriz quadrada em que qualquer elemento fora da diagonal principal é nulo, isto é, $a_{ij}=0$ para $ i \\neq j$.<br>\n",
    "\n",
    "Assim, dizemos que uma matriz quadrada S $=$$[s_{ij}]$ é diagonal se todos os seus elementos fora da diagonal principal forem\n",
    "nulos. Às vezes, denotamos uma tal matriz por S $=$diag $s_{11},s_{22}, ..., s_{nn}$  onde alguns $s_{ii}$, ou todos, podem ser nulos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & -2 & 0 & 0\\\\0 & 0 & -7 & 0\\\\0 & 0 & 0 & 4\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1,  0,  0, 0],\n",
       "[0, -2,  0, 0],\n",
       "[0,  0, -7, 0],\n",
       "[0,  0,  0, 4]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E = sympy.diag(1, -2, -7, 4)\n",
    "E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Matriz identidade: matriz em que $a_{ij}=1$ ,  $\\forall i=j$ e $a_{ij}=0$, $\\forall i \\neq j$. Assim, a matriz identidade, ou matriz unitária, de ordem $n$, denotada por $I{_n}$ ou, simplesmente, por $I$, é a matriz quadrada\n",
    "com 1 na diagonal principal e 0 em todas as demais entradas. A matriz identidade $I$ é análoga ao escalar $1$, pois,\n",
    "dada qualquer matriz $A_{m \\times n}$, temos que $\\mathbf{AI =IA = A}$. Para uma matriz $B_{n \\times 1}$, verifica-se $\\mathbf{IB=B}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 0, 0, 0],\n",
       "[0, 1, 0, 0],\n",
       "[0, 0, 1, 0],\n",
       "[0, 0, 0, 1]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I = sympy.eye(4)\n",
    "I "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Matriz triangular superior: matriz quadrada em que todos os elementos abaixo da diagonal principal são nulos, ou seja, $a_{ij}=0$ se $i>j$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 & -1 & 4\\\\0 & -1 & 4\\\\0 & 0 & 4\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[2, -1, 4],\n",
       "[0, -1, 4],\n",
       "[0,  0, 4]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = sympy.Matrix(np.triu([2,-1,4],k=0))\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Matriz triangular inferior: matriz quadrada em que todos os elementos acima da diagonal principal são nulos, ou seja, $a_{ij} = 0$, $\\forall i<j$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 & 0 & 0\\\\1 & -1 & 0\\\\1 & 1 & 2\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[2,  0, 0],\n",
       "[1, -1, 0],\n",
       "[1,  1, 2]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = sympy.Matrix(np.tril([[2,1,1],[1,-1,1], [1,1,2]]))\n",
    "F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Matriz simétrica: matriz quadrada em que $a_{ij} = a_{ji}$ para quaisquer $i,j$ e $A^{T} = A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}4 & 3 & -1\\\\3 & 2 & 0\\\\-1 & 0 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[ 4, 3, -1],\n",
       "[ 3, 2,  0],\n",
       "[-1, 0,  5]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = sympy.Matrix(3, 3, [4, 3, -1, 3, 2, 0, -1, 0, 5])\n",
    "G"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Matriz Idempotente: matriz quadrada em que $A \\cdot A = A$ ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}5 & -5\\\\4 & -4\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[5, -5],\n",
       "[4, -4]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H = sympy.Matrix(2, 2, [5, -5, 4, -4])\n",
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}5 & -5\\\\4 & -4\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[5, -5],\n",
       "[4, -4]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H*H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. Matriz Ortogonal: toda matriz em que $A^{-1}=A^{T}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operações com matrizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adição e multiplicação por escalar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sejam A $=$ $a_{ij}$ e B  $=$ $b_{ij}$ duas matrizes de mesmo tamanho, digamos, m $\\times $ n  . A soma de A e B, denotada por\n",
    "A $+$ B, é a matriz obtida pela soma de elementos correspondentes de A e B, \n",
    "ou seja \n",
    "\n",
    " $$A+B =\\left[\n",
    "\\begin{array}{c c c}\n",
    "a_{11}+ b_{11}&\\ldots& a_{1n}+b_{1n}\\\\\n",
    "a_{21}+b_{21}& \\ldots& a_{2n}+b_{2n}\\\\\n",
    "\\vdots&\\ddots &\\vdots\\\\ a_{m1}+b_{m1}&\\ldots& a_{mn}+ b_{mn}\n",
    "\\end{array}\\right]\n",
    "$$\n",
    "\n",
    "O múltiplo da matriz A pelo escalar k, denotado por simplesmente $kA$, é a matriz obtida pelo produto de\n",
    "cada elemento de A por k, ou seja,\n",
    "\n",
    "\n",
    "$$kA=\\left[ \n",
    "\\begin{array}{c c c}\n",
    "ka_{11}&\\ldots& ka_{1n}\\\\\n",
    "ka_{21}& \\ldots& ka_{2n}\\\\\n",
    "\\vdots&\\ddots &\\vdots\\\\ ka_{m1}&\\ldots& ka_{mn}\n",
    "\\end{array}\\right]\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vejamos uma implementação da soma de duas matrizes utilizando o NumPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seja \n",
    "A = $\\begin{bmatrix}\n",
    "1 & 2 & 3\\\\\n",
    "4 & 5 & 6 \n",
    "\\end{bmatrix}$ e B =$\\begin{bmatrix}\n",
    "2 &  4 & 6\\\\\n",
    "1 & 3 & 5  \\end{bmatrix}$ iremos encontrar a matriz C, dada por $\\mathrm{A+B}$. Iremos simplesmente definir $A$ e $B$ e posteriormente usar o operador $+$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2,3], [4,5,6]])\n",
    "B = np.array([[2,4,6],[1,3,5]])\n",
    "C = A+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  6,  9],\n",
       "       [ 5,  8, 11]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encontrada a matriz C, iremos encontrar a matriz D, dada por kC, onde k = -2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = np.array ([[3,6,9], [5,8,11]])\n",
    "k = -2\n",
    "D = k*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -6, -12, -18],\n",
       "       [-10, -16, -22]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poderíamos resolver este mesmo problema usando a função np.dot() - utilizada para efetuar o produto matricial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "D = np.dot(k,C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -6, -12, -18],\n",
       "       [-10, -16, -22]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Propriedades da soma de matrizes</b> <br>\n",
    "Considerando as matrizes A,B e C de mesma ordem $m x n$ temos que: \n",
    "1. $\\mathbf {A} +\\mathbf {B} = \\mathbf{B+A} $ (comutatividade)\n",
    "2. $\\mathbf {A}+\\mathbf{(B+C)} = \\mathbf{(A+B)}+C$ (associatividade)\n",
    "3. $\\mathbf {A}+\\mathbf{0} = \\mathbf{A}$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iremos demonstrar a validade de tais propriedades usando funções de Álgebra Linear do SymPy.Para tanto, definiremos três matrizes quadradas genéricas de ordem 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "a11, a12, a21, a22 = sympy.symbols('a_11, a_12, a_21, a_22')\n",
    "b11, b12, b21, b22 = sympy.symbols('b_11, b_12, b_21, b_22')\n",
    "c11, c12, c21, c22 = sympy.symbols('c_11, c_12, c_21, c_22')\n",
    "A = sympy.Matrix(2, 2, [a11, a12, a21, a22])\n",
    "B = sympy.Matrix(2, 2, [b11, b12, b21, b22])\n",
    "C = sympy.Matrix(2, 2, [c11, c12, c21, c22])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vejamos as matrizes definidas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} & a_{12}\\\\a_{21} & a_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11, a_12],\n",
       "[a_21, a_22]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}b_{11} & b_{12}\\\\b_{21} & b_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[b_11, b_12],\n",
       "[b_21, b_22]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}c_{11} & c_{12}\\\\c_{21} & c_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[c_11, c_12],\n",
       "[c_21, c_22]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da propriedade <b>1</b> temos que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} + b_{11} & a_{12} + b_{12}\\\\a_{21} + b_{21} & a_{22} + b_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11 + b_11, a_12 + b_12],\n",
       "[a_21 + b_21, a_22 + b_22]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} + b_{11} & a_{12} + b_{12}\\\\a_{21} + b_{21} & a_{22} + b_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11 + b_11, a_12 + b_12],\n",
       "[a_21 + b_21, a_22 + b_22]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B+A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A+B) == (B+A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da propriedade <b>2</b> temos que: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} + b_{11} + c_{11} & a_{12} + b_{12} + c_{12}\\\\a_{21} + b_{21} + c_{21} & a_{22} + b_{22} + c_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11 + b_11 + c_11, a_12 + b_12 + c_12],\n",
       "[a_21 + b_21 + c_21, a_22 + b_22 + c_22]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+(B+C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} + b_{11} + c_{11} & a_{12} + b_{12} + c_{12}\\\\a_{21} + b_{21} + c_{21} & a_{22} + b_{22} + c_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11 + b_11 + c_11, a_12 + b_12 + c_12],\n",
       "[a_21 + b_21 + c_21, a_22 + b_22 + c_22]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A+B)+C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+(B+C) == (A+B)+C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, precisaremos criar uma matriz nula para verificar a última propriedade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.matrices import zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "zero = zeros(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 0],\n",
       "[0, 0]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desta forma, podemos verificar que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+zero == A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Propriedades da multiplicação por escalar </b> <br>\n",
    "Sejam as matrizes A e B de mesma ordem e as constantes reais $k$, $k_1$, $k_2$, temos que:\n",
    "1. $k(\\mathbf{A+B}) = k\\mathbf{A}+k\\mathbf{B}$\n",
    "2. $(k_1+k_2)\\mathbf{A} = k_1\\mathbf{A}+k_2\\mathbf{A}$\n",
    "3. $k\\mathbf{A} = \\mathbf{0} $, em que k=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voltando para as matrizes... Observe que ambas, A $+$ B e kA, são matrizes m $\\times $ n . Podemos definir\n",
    "–A $=$(–1)A e A $-$ B $=$ A $+$ (–B).\n",
    "Dizemos que –A é a matriz simétrica de A e que A $-$ B é a matriz diferença de A e B. Não se define a soma de matrizes\n",
    "de tamanhos distintos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seja A = $\\begin{bmatrix}\n",
    "1 & 2 & 3\\\\\n",
    "4 & 5 & 6 \n",
    "\\end{bmatrix}$ encontremos a matriz simétrica de A. Definiremos a matriz A e seguidamente obteremos sua matriz simétrica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2,3],[4,5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1, -2, -3],\n",
       "       [-4, -5, -6]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poderíamos também ter obtido a matriz simétrica de A como segue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=-1\n",
    "A_simetrica = np.dot(k,A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1, -2, -3],\n",
       "       [-4, -5, -6]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_simetrica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos recuperar a matriz B definida anteriormente e calcular $\\mathbf{A-B}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([[2,4,6],[1,3,5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1, -2, -3],\n",
       "       [ 3,  2,  1]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A-B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dadas as matrizes H = $\\begin{bmatrix}\n",
    "1 & 2 & 3\\\\\n",
    "4 & -2 & -9\\\\\n",
    "0 & -12 & -29\\\\\n",
    "\\end{bmatrix}$ e G =  $\\begin{bmatrix}\n",
    "11 & 0 & 0\\\\\n",
    "41 & -21 & 0\\\\\n",
    "0 & -1 & -2\\\\\n",
    "\\end{bmatrix}$ encontraremos a matriz J dada por J = H+G."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizando NumPy obtemos o seguinte resultado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = np.array([[1, 2, 3], [4, -2, -9], [0, -12, -29]])\n",
    "G = np.array([[11, 0, 0], [41, -21, 0], [0, -1, -2]])\n",
    "J = H+G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 12,   2,   3],\n",
       "       [ 45, -23,  -9],\n",
       "       [  0, -13, -31]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos resolver o mesmo problema com SymPy. Usaremos a função Matrix para construir as matrizes H e G. Informaremos a ordem das respectivas matrizes e passaremos uma lista contendo seus elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = sympy.Matrix(3, 3, [1, 2, 3, 4, -2, -9, 0, -12, -29])\n",
    "G = sympy.Matrix(3, 3, [11, 0, 0, 41, -21, 0, 0, -1, -2])\n",
    "J = G+H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}12 & 2 & 3\\\\45 & -23 & -9\\\\0 & -13 & -31\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[12,   2,   3],\n",
       "[45, -23,  -9],\n",
       "[ 0, -13, -31]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transposta de uma matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A transposta de uma matriz A, denotada por $A^{T}$ ou $A' $, é a matriz obtida escrevendo as colunas de A, na mesma ordem, como linhas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Propriedades</b>\n",
    "1. Uma matriz é simétrica se, e somente se ela é igual à sua transposta, ou seja, $\\mathbf{A=A'}$.\n",
    "2. $\\mathbf{A''=A}$.\n",
    "3. $\\mathbf{(A+B)'=A'+B'}$.\n",
    "4. $\\mathbf{(kA)'=kA'}$, em que k é um escalar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seja,  I =  $\\begin{bmatrix}\n",
    "2 & 0 \\\\\n",
    "-4 & 11 \\\\\n",
    "5 &-2 \\\\\n",
    " 6 & 0 \\\\\n",
    "\\end{bmatrix}$ então $I^{T}$ $= $ $\\begin{bmatrix}\n",
    "2 & -4 & 5 & 6\\\\   \n",
    "0 &11 & -2 & 0\\\\\n",
    "\\end{bmatrix}$. Em linhas gerais, a linha de uma matriz passa a ser coluna e a coluna se torna linha. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dada a matriz K =  $\\begin{bmatrix}\n",
    "-1 & 0 & 0\\\\\n",
    "-4 & 11  & 1 \\\\\n",
    "5 &-2 & -9\\\\\n",
    " 6 & 0 &7\\\\\n",
    "\\end{bmatrix}$, encontremos sua matriz transposta $K^{T}$ utilizando o NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "K = np.array([[-1, 0, 0], [-4, 11, 1], [5, -2, -9], [6, 0, 7]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1,  0,  0],\n",
       "       [-4, 11,  1],\n",
       "       [ 5, -2, -9],\n",
       "       [ 6,  0,  7]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, a transposta de K é obtida como segue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1, -4,  5,  6],\n",
       "       [ 0, 11, -2,  0],\n",
       "       [ 0,  1, -9,  7]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1, -4,  5,  6],\n",
       "       [ 0, 11, -2,  0],\n",
       "       [ 0,  1, -9,  7]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dada a matriz L =  $\\begin{bmatrix}\n",
    "0 & 1 & 0\\\\\n",
    "-4 & 11  & 1 \\\\\n",
    "5 &-2 & -9\\\\\n",
    " 6 & 0 &7\\\\\n",
    " 36 & 10 &57\\\\\n",
    "\\end{bmatrix}$ encontremos $L+L^{T}$ utilizando NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  0],\n",
       "       [-4, 11,  1],\n",
       "       [ 5, -2, -9],\n",
       "       [ 6,  0,  7],\n",
       "       [36, 10, 57]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = np.array([[0, 1, 0], [-4, 11, 1], [5, -2, -9], [6, 0, 7], [36, 10, 57]])\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, -4,  5,  6, 36],\n",
       "       [ 1, 11, -2,  0, 10],\n",
       "       [ 0,  1, -9,  7, 57]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste caso, não poderemos obter $L+L^{T}$, pois $L^{T}$ não apresenta a mesma ordem de L."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3, 5), (5, 3))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(L).shape, np.shape(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiplicação de matrizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O produto das matrizes $A$ e $B$ é denotado por $AB$. Particularmente, iremos começar com um caso\n",
    "especial.\n",
    "O produto $AB$ de uma matriz linha A $=$ $[a_i]$ e uma matriz coluna B  $=$  $[b_j]$ com o mesmo número de elementos\n",
    "é definido como o escalar (ou a matriz ) obtido pela soma dos produtos das entradas correspondentes, ou seja, AB= $\\begin{bmatrix}\n",
    "a_{1}, & a_{2}, & ...,&a_{n}\\\\\n",
    "\\end{bmatrix} $$\\begin{bmatrix}\n",
    "b_{1} \\\\ \n",
    "b_{2} \\\\ \n",
    "... \\\\  \n",
    "b_{n}\\\\\n",
    "\\end{bmatrix}$ $= $$a_{1}b_{1}$+$ $$a_{2}b_{2}$$+$ ... $+$$a_{n}b_{n}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfatizamos que, nesse caso, $AB$ é um escalar (ou, então, uma matriz $1 \\times 1$). Não definimos o produto AB se a\n",
    "matriz linha A e a matriz coluna B possuírem um número distinto de elementos. Esta definição é particularmente importante para definição de um problema de regressão linear múltipla."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dadas as matrizes M = $\\begin{bmatrix}\n",
    "7, & -4,& 5 \\\\\n",
    "\\end{bmatrix}$ e N = $\\begin{bmatrix}\n",
    "3 \\\\ \n",
    "2 \\\\ \n",
    "-1\\\\\n",
    "\\end{bmatrix}$ encontremos a matriz $O = M \\cdot N$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.array([[7, -4, 5]])\n",
    "N = np.array([[3],[2],[-1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7, -4,  5]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3],\n",
       "       [ 2],\n",
       "       [-1]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para realizar a multiplicação das matrizes é necessário encontrar o número de linhas e colunas da matriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acima vemos que nossa matriz M possui uma linha e três colunas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acima vemos que nossa matriz N possui três linhas e uma coluna. Assim, para efetuar o produto matricial o número de colunas da primeira matriz, deve ser igual ao número de linhas da segunda matriz. Assim, a matriz O, será :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O = np.dot(M,N)\n",
    "O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dadas as matrizes Q =  $\\begin{bmatrix}\n",
    "6, & -1,& 8 & 3  \\\\\n",
    "\\end{bmatrix}$ e S = $\\begin{bmatrix}\n",
    "4 \\\\ \n",
    "-9 \\\\ \n",
    "-2\\\\\n",
    "5\\\\\n",
    "\\end{bmatrix}$ encontraremos a matriz P fruto de QS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "Q = np.array([[6, -1, 8, 3]])\n",
    "S = np.array ([[4], [-9], [-2], [5]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificaremos se o número de colunas de Q é igual ao número de linhas de S:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q.shape[1] == S.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então a matriz P é obtida da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[32]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = np.dot(Q,S)\n",
    "P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De um modo geral, dadas A $=$ $[a_{ik}]$ e B  $=$  $[b_{kj}]$ duas matrizes tais que o número de colunas de A seja igual ao número\n",
    "de linhas de B, digamos p, supomos assim que A seja uma matriz m $\\times$ n e B uma matriz p $\\times$ n. Então o produto AB de A e B é a matriz  m $\\times$ n cuja ij-ésima entrada é dada pelo produto da i-ésima linha de A com a j-ésima coluna de B. Assim,\n",
    "\n",
    "$\\begin{bmatrix}\n",
    "a_{11} & ... & a_{1p}\\\\   \n",
    ". & ... & . \\\\\n",
    "a_{i1}& ...&  a_{1p}\\\\\n",
    ". & ... & . \\\\\n",
    "a_{m1}& ...&  a_{mp}\n",
    "\\end{bmatrix}$\n",
    "$\\begin{bmatrix}\n",
    "b_{11} & ... & b_{ij} & ... & b_{1n}\\\\\n",
    ". & ... & .  & ... & . \\\\\n",
    ". & ... & .  & ... & . \\\\\n",
    ". & ... & .  & ... & . \\\\\n",
    "b_{p1}& ...& b_{pj} &...& b_{pn}\n",
    "\\end{bmatrix}$ onde $c_{ij}$ $= $$a_{i1}b_{ij}$+$ $$a_{i2}b_{j2}$$+$ ... $+$$a_{ip}b_{pj}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Não definimos o produto AB quando A é uma matriz m $\\times$ p e B é uma matriz com q $\\times$ n com p $\\neq$ q."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Propriedades da Multiplicação de Matrizes</b>\n",
    "1. Em geral $\\mathbf{AB}\\neq\\mathbf{BA}$.\n",
    "2. $\\mathbf{AI} = \\mathbf{IA} = \\mathbf{A} $ (o que justifica o nome da matriz identidade)\n",
    "3. $\\mathbf{A(B+C)} = \\mathbf{AB}+\\mathbf{AC}$ (distributividade à esquerda da multiplicação)\n",
    "4. $\\mathbf{(A+B)C} = \\mathbf{AC+BC} $ (distributividade à direita da multiplicação)\n",
    "5. $\\mathbf{(AB)C = A(BC)} $ (associatividade)\n",
    "6. $\\mathbf{(AB)' = B'A'} $\n",
    "7. $\\mathbf{0 \\cdot A = 0}$ e $\\mathbf{A \\cdot 0 = 0}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demonstremos algumas destas propriedades utilizando matrizes genéricas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.matrices import eye\n",
    "a11, a12, a21, a22 = sympy.symbols('a_11, a_12, a_21, a_22')\n",
    "b11, b12, b21, b22 = sympy.symbols('b_11, b_12, b_21, b_22')\n",
    "c11, c12, c21, c22 = sympy.symbols('c_11, c_12, c_21, c_22')\n",
    "A = sympy.Matrix(2, 2, [a11, a12, a21, a22])\n",
    "B = sympy.Matrix(2, 2, [b11, b12, b21, b22])\n",
    "C = sympy.Matrix(2, 2, [c11, c12, c21, c22])\n",
    "I = eye(2)\n",
    "zero = zeros(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Respectivamente temos as matrizes A,B,C,I e a matriz nula:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} & a_{12}\\\\a_{21} & a_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11, a_12],\n",
       "[a_21, a_22]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}b_{11} & b_{12}\\\\b_{21} & b_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[b_11, b_12],\n",
       "[b_21, b_22]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}c_{11} & c_{12}\\\\c_{21} & c_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[c_11, c_12],\n",
       "[c_21, c_22]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 0],\n",
       "[0, 1]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 0],\n",
       "[0, 0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(A)\n",
    "display(B)\n",
    "display(C)\n",
    "display(I)\n",
    "display(zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. $\\mathbf{AI} = \\mathbf{IA} = \\mathbf{I} $ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*I == I*A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. $\\mathbf{A(B+C)} = \\mathbf{AB}+\\mathbf{AC}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} \\left(b_{11} + c_{11}\\right) + a_{12} \\left(b_{21} + c_{21}\\right) & a_{11} \\left(b_{12} + c_{12}\\right) + a_{12} \\left(b_{22} + c_{22}\\right)\\\\a_{21} \\left(b_{11} + c_{11}\\right) + a_{22} \\left(b_{21} + c_{21}\\right) & a_{21} \\left(b_{12} + c_{12}\\right) + a_{22} \\left(b_{22} + c_{22}\\right)\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11*(b_11 + c_11) + a_12*(b_21 + c_21), a_11*(b_12 + c_12) + a_12*(b_22 + c_22)],\n",
       "[a_21*(b_11 + c_11) + a_22*(b_21 + c_21), a_21*(b_12 + c_12) + a_22*(b_22 + c_22)]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*(B+C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} b_{11} + a_{11} c_{11} + a_{12} b_{21} + a_{12} c_{21} & a_{11} b_{12} + a_{11} c_{12} + a_{12} b_{22} + a_{12} c_{22}\\\\a_{21} b_{11} + a_{21} c_{11} + a_{22} b_{21} + a_{22} c_{21} & a_{21} b_{12} + a_{21} c_{12} + a_{22} b_{22} + a_{22} c_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11*b_11 + a_11*c_11 + a_12*b_21 + a_12*c_21, a_11*b_12 + a_11*c_12 + a_12*b_22 + a_12*c_22],\n",
       "[a_21*b_11 + a_21*c_11 + a_22*b_21 + a_22*c_21, a_21*b_12 + a_21*c_12 + a_22*b_22 + a_22*c_22]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*B+A*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand(A*(B+C)) == A*B+A*C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. $\\mathbf{(A+B)C} = \\mathbf{AC+BC} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}c_{11} \\left(a_{11} + b_{11}\\right) + c_{21} \\left(a_{12} + b_{12}\\right) & c_{12} \\left(a_{11} + b_{11}\\right) + c_{22} \\left(a_{12} + b_{12}\\right)\\\\c_{11} \\left(a_{21} + b_{21}\\right) + c_{21} \\left(a_{22} + b_{22}\\right) & c_{12} \\left(a_{21} + b_{21}\\right) + c_{22} \\left(a_{22} + b_{22}\\right)\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[c_11*(a_11 + b_11) + c_21*(a_12 + b_12), c_12*(a_11 + b_11) + c_22*(a_12 + b_12)],\n",
       "[c_11*(a_21 + b_21) + c_21*(a_22 + b_22), c_12*(a_21 + b_21) + c_22*(a_22 + b_22)]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A+B)*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} c_{11} + a_{12} c_{21} + b_{11} c_{11} + b_{12} c_{21} & a_{11} c_{12} + a_{12} c_{22} + b_{11} c_{12} + b_{12} c_{22}\\\\a_{21} c_{11} + a_{22} c_{21} + b_{21} c_{11} + b_{22} c_{21} & a_{21} c_{12} + a_{22} c_{22} + b_{21} c_{12} + b_{22} c_{22}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11*c_11 + a_12*c_21 + b_11*c_11 + b_12*c_21, a_11*c_12 + a_12*c_22 + b_11*c_12 + b_12*c_22],\n",
       "[a_21*c_11 + a_22*c_21 + b_21*c_11 + b_22*c_21, a_21*c_12 + a_22*c_22 + b_21*c_12 + b_22*c_22]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*C+B*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand((A+B)*C) == A*C+B*C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. $\\mathbf{(AB)C = A(BC)} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}c_{11} \\left(a_{11} b_{11} + a_{12} b_{21}\\right) + c_{21} \\left(a_{11} b_{12} + a_{12} b_{22}\\right) & c_{12} \\left(a_{11} b_{11} + a_{12} b_{21}\\right) + c_{22} \\left(a_{11} b_{12} + a_{12} b_{22}\\right)\\\\c_{11} \\left(a_{21} b_{11} + a_{22} b_{21}\\right) + c_{21} \\left(a_{21} b_{12} + a_{22} b_{22}\\right) & c_{12} \\left(a_{21} b_{11} + a_{22} b_{21}\\right) + c_{22} \\left(a_{21} b_{12} + a_{22} b_{22}\\right)\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[c_11*(a_11*b_11 + a_12*b_21) + c_21*(a_11*b_12 + a_12*b_22), c_12*(a_11*b_11 + a_12*b_21) + c_22*(a_11*b_12 + a_12*b_22)],\n",
       "[c_11*(a_21*b_11 + a_22*b_21) + c_21*(a_21*b_12 + a_22*b_22), c_12*(a_21*b_11 + a_22*b_21) + c_22*(a_21*b_12 + a_22*b_22)]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A*B)*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a_{11} \\left(b_{11} c_{11} + b_{12} c_{21}\\right) + a_{12} \\left(b_{21} c_{11} + b_{22} c_{21}\\right) & a_{11} \\left(b_{11} c_{12} + b_{12} c_{22}\\right) + a_{12} \\left(b_{21} c_{12} + b_{22} c_{22}\\right)\\\\a_{21} \\left(b_{11} c_{11} + b_{12} c_{21}\\right) + a_{22} \\left(b_{21} c_{11} + b_{22} c_{21}\\right) & a_{21} \\left(b_{11} c_{12} + b_{12} c_{22}\\right) + a_{22} \\left(b_{21} c_{12} + b_{22} c_{22}\\right)\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a_11*(b_11*c_11 + b_12*c_21) + a_12*(b_21*c_11 + b_22*c_21), a_11*(b_11*c_12 + b_12*c_22) + a_12*(b_21*c_12 + b_22*c_22)],\n",
       "[a_21*(b_11*c_11 + b_12*c_21) + a_22*(b_21*c_11 + b_22*c_21), a_21*(b_11*c_12 + b_12*c_22) + a_22*(b_21*c_12 + b_22*c_22)]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*(B*C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand((A*B)*C) == sympy.expand(A*(B*C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. $\\mathbf{(AB)' = B'A'} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A*B).transpose() == B.transpose()*A.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. $\\mathbf{0 \\cdot A = 0}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 0],\n",
       "[0, 0]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero*A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iremos abordar outros exemplos numéricos de multiplicação de matrizes utilizando o NumPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encontraremos XY sendo X = $\\begin{bmatrix}\n",
    "1 & 3 \\\\   \n",
    "2 &-1\\\\\n",
    "\\end{bmatrix}$ e Y =  $\\begin{bmatrix}\n",
    "2 & 0 & -4 \\\\   \n",
    "5 &-2 & 6 \\\\\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Devemos inicialmente verificar a condição do produto matricial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array([[1, 3], [2, -1]])\n",
    "Y = np.array([[2, 0, -4], [5, -2, 6]])\n",
    "X.shape[1] == Y.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 17,  -6,  14],\n",
       "       [ -1,   2, -14]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(X,Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traço de uma matriz "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O traço de uma matriz quadrada A, denotado por tr(A), é a soma dos elementos da diagonal principal, a saber, $ tr\\mathbf{(A)}= a_{11}+a_{22}+a_{33}+...+a_{nn}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Propriedades</b>\n",
    "1. $tr\\mathbf{(A+B)} = tr\\mathbf{(B+A)}$\n",
    "2. $tr\\mathbf{(\\alpha \\cdot A)} = \\alpha \\cdot tr\\mathbf{(A)}$, com $\\alpha \\in \\mathbb{R} $\n",
    "3. $tr\\mathbf{(A)} = tr\\mathbf{(A')} $\n",
    "4. $tr\\mathbf{(I_{n})} = n$\n",
    "5. $tr\\mathbf{(AB)} = tr\\mathbf{(BA)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir das matrizes definidas a seguir, calcularemos o traço utilizando SymPy e NumPy. Nosso primeiro exemplo será com uma matriz Identidade $I_{2}$. Para construir uma matriz identidade no NumPy podemos utilizar o comando: np.eye(). Por exemplo, a matriz "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = np.eye(2)\n",
    "F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O traço da matriz F é dado pela função np.trace(). Assim, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.trace()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiremos uma matriz identidade 10 $\\times$ 10 e calcularemos seu traço."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "O = np.eye(10) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(O)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiremos uma matriz diagonal e em seguida obteremos seu traço utilizando o NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0, 0],\n",
       "       [0, 2, 0, 0, 0],\n",
       "       [0, 0, 3, 0, 0],\n",
       "       [0, 0, 0, 4, 0],\n",
       "       [0, 0, 0, 0, 5]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = np.diag(np.arange(1,6))\n",
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.trace()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para recuperar a diagonal principal podemos utilizar o método np.diagonal() ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diagonal(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou ainda, acessando como um método do objeto criado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.diagonal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para encontra a diagonal secundária, podemos utilizar o método: np.flipl()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 3, 0, 0])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diagonal(np.fliplr(P))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiremos agora duas matrizes genéricas A e B utilizando o SymPy, em seguida calcularemos o traço associado a cada matriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import a, b, c, d,e,f,g,h\n",
    "A = sympy.Matrix(2, 2, [a, b, c, d])\n",
    "B = sympy.Matrix(2, 2, [e, f, g, h])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a & b\\\\c & d\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a, b],\n",
       "[c, d]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}e & f\\\\g & h\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[e, f],\n",
       "[g, h]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Traço de A:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a + d$"
      ],
      "text/plain": [
       "a + d"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Traço de B:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle e + h$"
      ],
      "text/plain": [
       "e + h"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.trace(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos verificar as propriedade (1), (3) e (5) definidas anteriormente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$tr\\mathbf{(A+B)} = tr \\mathbf{(B+A)} $ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a + d + e + h$"
      ],
      "text/plain": [
       "a + d + e + h"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.trace(A+B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a + d + e + h$"
      ],
      "text/plain": [
       "a + d + e + h"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.trace(B+A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$tr\\mathbf{(A)} = tr\\mathbf{(A')}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.trace(A) == sympy.trace(A.transpose())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$tr\\mathbf{(AB)} = tr\\mathbf{(BA)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Temos que $\\mathbf{AB}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a e + b g & a f + b h\\\\c e + d g & c f + d h\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a*e + b*g, a*f + b*h],\n",
       "[c*e + d*g, c*f + d*h]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}a e + c f & b e + d f\\\\a g + c h & b g + d h\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[a*e + c*f, b*e + d*f],\n",
       "[a*g + c*h, b*g + d*h]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B*A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.trace(A*B) == sympy.trace(B*A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determinante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos pensar no determinante como um número associado a uma matriz quadrada $A_{m \\times n}$. Denotamos $\\det A$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\left| \\begin{array}{cccc}\n",
    "a_{11} & a_{12} & \\ldots & a_{1n}\\\\\n",
    "a_{21} & a_{22} & \\ldots & a_{2n}\\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots\\\\\n",
    "a_{n1} & a_{n2} & \\ldots & a_{nn}\\\\\n",
    "\\end{array}\n",
    "\\right|$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculemos o determinante de uma matriz usando o NumPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dada a matriz V = $\\begin{bmatrix}\n",
    "1 & 2 & 3 & 4\\\\\n",
    "4& 3 & 2 & 1\\\\\n",
    "0 & 2 & 4  & 6 \\\\\n",
    " 5 & 7 & 9 & 11 \\\\\n",
    "\\end{bmatrix}$ encontremos det (V)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basta utilizar a função np.linalg.det()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "V=np.array([[1, 2, 3, 4], [4, 3, 1, 1], [0, 2, 4, 6], [5, 7, 9, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-20"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round (np.linalg.det(V))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrizes invertiveis ou não singulares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma matriz quadrada $A$ é dita invertível, ou não singular, se existir uma matriz $B$ tal que\n",
    "$AB = BA = I$ onde $I$ é a matriz identidade. Uma tal matriz $B$ é única. \n",
    "\n",
    "Dizemos que uma tal matriz $B$ é a inversa de $A$ e a denotamos por $A^{-1}$.Observe que a relação que define a inversa é\n",
    "simétrica; ou seja, se $B$ for a inversa de $A$, então $A$ será a inversa de $B$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponha que A =  $\\begin{bmatrix}\n",
    "2 & 5 \\\\   \n",
    "1 & 3\\\\\n",
    "\\end{bmatrix}$ e B  =  $\\begin{bmatrix}\n",
    "3 & -5 \\\\   \n",
    "-1 & 2\\\\\n",
    "\\end{bmatrix}$, verifiquemos se estas matrizes admitem inversa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "A= np.array ([[2,5],[1,3]])\n",
    "B = np.array ([[3,-5], [-1,2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(B,A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, B é inversa de A e A é inversa de B."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determinemos a inversa da matriz Z =  $\\begin{bmatrix}\n",
    "3 & 4 \\\\   \n",
    "1 & 0\\\\\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.array([[3,4],[1,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.  ,  1.  ],\n",
       "       [ 0.25, -0.75]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sistemas Lineares "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De uma maneira geral, denomina-se sistema linear de m equações e n incógnitas $x_{1}, x_{2},..., x_{n}$ a todo sistema linear da forma :$\\begin{cases}\n",
    "a_{11}x_{1}+a_{12}x_{2}+...+a_{1n}x_{n}=b_{1} \\\\\n",
    "a_{21}x_{1}+a_{22}x_{2}+...+a_{2n}x_{n}=b_{2} \\\\\n",
    "..............................\\\\\n",
    "a_{m1}x_{1}+a_{m2}x_{2}+...+a_{mn}x_{n}=b_{m}\\\\\n",
    "\\end{cases}$ em que $a_{11}, a_{12},..., a_{1n}, b_{1}, b_{2}, ..., b_{m}$ são números reais. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matriz associadas a um sistema linear:\n",
    "\n",
    "Seja o sistema linear de m equações e n incógnitas $\\begin{cases}\n",
    "a_{11}x_{1}+a_{12}x_{2}+...+a_{1n}x_{n}=b_{1} \\\\\n",
    "a_{21}x_{1}+a_{22}x_{2}+...+a_{2n}x_{n}=b_{2} \\\\\n",
    "..............................\\\\\n",
    "a_{m1}x_{1}+a_{m2}x_{2}+...+a_{mn}x_{n}=b_{m}\\\\\n",
    "\\end{cases}$\n",
    "\n",
    "Desse sistema, destacamos as seguintes matrizes:\n",
    "- matriz completa do sistema \n",
    "$\\begin{bmatrix}\n",
    "a_{11} & a_{12} & ... & a_{1n} &b_{1}\\\\\n",
    "a_{21} & a_{22} & ... & a_{2n} & b_{2}\\\\\n",
    "... & ... & ... & ...&....\\\\\n",
    "a_{n1} & a_{n2} & ... & a_{nn}&b_{1m}\\\\\n",
    "\\end{bmatrix}$\n",
    "\n",
    "\n",
    "- matriz incompleta do sistema \n",
    "$\\begin{bmatrix}\n",
    "a_{11} & a_{12} & ... & a_{1n}\\\\\n",
    "a_{21} & a_{22} & ... & a_{2n}\\\\\n",
    "... & ... & ... & ...\\\\\n",
    "a_{n1} & a_{n2} & ... & a_{nn}\\\\\n",
    "\\end{bmatrix}$\n",
    "\n",
    "Consideremos ainda as seguintes matrizes-colunas assosciadas ao sistema:\n",
    "X = $\\begin{bmatrix}\n",
    "x_{1} \\\\\n",
    "x_{2} \\\\\n",
    "\\vdots\\\\\n",
    "x_{n}\\\\\n",
    "\\end{bmatrix}$    $\\space$, B = $\\begin{bmatrix}\n",
    "b_{1} \\\\\n",
    "b_{2} \\\\\n",
    "\\vdots\\\\\n",
    "b_{m}\\\\\n",
    "\\end{bmatrix}$\n",
    "\n",
    "Multiplicando - se a matriz incompleta pela matriz das incognitas, obtemos a matriz dos temos independentes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{bmatrix}\n",
    "a_{11} & a_{12} & ... & a_{1n}\\\\\n",
    "a_{21} & a_{22} & ... & a_{2n}\\\\\n",
    "... & ... & ... & ...\\\\\n",
    "a_{n1} & a_{n2} & ... & a_{nn}\\\\\n",
    "\\end{bmatrix}\\cdot \\begin{bmatrix}\n",
    "x_{1} \\\\\n",
    "x_{2} \\\\\n",
    "\\vdots\\\\\n",
    "x_{n}\\\\\n",
    "\\end{bmatrix}=\\begin{bmatrix}\n",
    "b_{1} \\\\\n",
    "b_{2} \\\\\n",
    "\\vdots\\\\\n",
    "b_{m}\\\\\n",
    "\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Denominamos então que o modelo acima é a forma matricial do sistema linear.\n",
    "Em notação simplificada temos:  $A \\cdot X = B $.\n",
    "Se a matriz incompleta do sistema for uma matriz quadrada, o seu determinante D$_{A}$ é dito determinante do sistema. \n",
    "Se D$_{A}$ $\\neq$ 0 então a matriz A é invertivel, isto é, existe A$^{-1}$, inversa de A. \n",
    "Se D$_{A}$ $\\neq$ 0, o sistema admite solução única e , portanto, é possível e determinado.\n",
    "                \n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Representemos o sistema $\\begin{cases}\n",
    "3a-7b=1\\\\\n",
    "5a+2b=4 \\\\\n",
    "\\end{cases}$ na forma matricial e encontremos sua solução."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array ([[3, -7], [5, 2]])\n",
    "B = np.array([[1], [4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = (np.linalg.solve(A, B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.73170732],\n",
       "       [0.17073171]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X  #solução do sistema"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <b>Exercícios <b/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Encontre WI sendo W = $\\begin{bmatrix}\n",
    "1 & 3 & 0 & 20\\\\   \n",
    "2 &-1 & 10 & 13\\\\\n",
    "3 & 4 & 10 & 0\\\\\n",
    "4 & 9 & -1 & 0 \\\\\n",
    "\\end{bmatrix}$ e I =  $\\begin{bmatrix}\n",
    "2 & 0 \\\\\n",
    "-4 & 11 \\\\\n",
    "5 &-2 \\\\\n",
    " 6 & 0 \\\\\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Construa uma matriz $5 \\times 5$ e encontre traço, diagonal principal e secundária. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Crie uma matriz $2 \\times 2$ somente com elementos pares e calcule seu determinante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Represente os sistemas abaixo  na forma matricial e encontre as respectivas soluções.\n",
    "\n",
    "a) $\\begin{cases}\n",
    "2x+y=5\\\\\n",
    "x-3y=0 \\\\\n",
    "\\end{cases}$ \n",
    "\n",
    "b)$\\begin{cases}\n",
    "2a+b+c=-1\\\\\n",
    "a+c=0 \\\\\n",
    "-3a+5b-c=2\\\\\n",
    "\\end{cases}$ \n",
    "\n",
    "c) $\\begin{cases}\n",
    "x+y+z+t=2\\\\\n",
    "x-y-2z-3t=5 \\\\\n",
    "2x+y-3z+t=-9\\\\\n",
    "3x-y-z+t=6\\\\\n",
    "\\end{cases}$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  Determine a inversa das matrizes: \n",
    "<br>\n",
    "a) H =  $\\begin{bmatrix}\n",
    "1 & 0 \\\\   \n",
    "3 & 0\\\\\n",
    "\\end{bmatrix}$\n",
    "<br>\n",
    "b) I = $\\begin{bmatrix}\n",
    "1 & 0 & 0\\\\   \n",
    "1 & 3 & 1\\\\\n",
    "1 & 2 & 0\\\\\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Todos os conceitos, proposições e teoremas aqui apresentados foram retirados do livro cujo autor é Seymour Lipschutz e/ou Simon e Blume "
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}