{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cadeias de Markov\n",
    "#### Vamos descrever um modelo geral de um sistema que muda de estado para estado. Uma cadeia de Markov é um caso particular de processo estocástico com estados discretos (o parâmetro, em geral o tempo, pode ser discreto ou contínuo) com a propriedade de que a distribuição de probabilidade do próximo estado depende apenas do estado atual e não na sequência de eventos que precederam."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Álgebra Linear com aplicações / Anton Howard e Chris Rorres; trad. Claus Ivo Doering. - 8. ed. - Porto Alegre: Bookman, 2001."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Um Processo de Markov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponha que um sistema físico ou matemático está sofrendo mudanças tais que a cada momento ele pode ocupar um dentre um número infinito de estados. Por exemplo, o tempo de uma certa cidade poderia estar em um dentre três estados possíveis: ensolarado, nublado ou chuvoso; ou então, um indivíduo poderia estar em um dentre quatro estados emocionais possíveis: feliz, triste, irritado ou apreensivo. Suponha que um tal sistema muda com o tempo de um estado para o outro e que em instantes pré-determinados observamos o estado do sistema. Se o estado do sistema em qualquer observação não puder ser predito com certeza, mas se a probabilidade de um certo estado ocorrer puder ser predita unicamente a partir do conhecimento do estado do sistema na observação imediatamente anterior, então o processo de mudança de um estado para o outro é chamado uma cadeia ou um processo de Markov."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Denotamos por **1, 2, ..., k** os **k** estados possíveis de uma cadeia de Markov. A probabilidade de o sistema estar no estado **i** em qualquer observação, se na observação imediatamente precedente estava no estado **j**, é denotada por $p_{ij}$ e é chamada a probabilidade de transição do estado **j** ao estado **i**. A matriz P = [$p_{ij}$] é chamada a **matriz de transição** da cadeia de Markov."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por exemplo, em uma cadeia de Markov de três estados, a matriz de transição tem o formato"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ EstadoPrecedente(j)\n",
    "\\\\\n",
    "\\begin{bmatrix}\n",
    "          p_{11} & p_{12} & p_{13} \\\\\n",
    "          p_{21} & p_{22} & p_{23} \\\\\n",
    "          p_{31} & p_{32} & p_{33} \\\\\n",
    "          \\end{bmatrix} NovoEstado(i)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesta matriz $p_{32}$ é a probabilidade que o sistema vai mudar do estado 2 para o estado 3, $p_{11}$ é a probabilidade que o sistema vai continuar no estado 1 imediatamente depois de ter sido observado no estado 1, e assim por diante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemplo: Locadora de Automóveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma locadora de automóveis tem três lojas de atendimento, denotadas por 1, 2 e 3. Um cliente pode alugar um carro de qualquer uma das três lojas e devolver o carro para qualquer uma das três lojas. O gerente nota que os clientes costuma devolver os carros de acordo com as seguintes probabilidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importando a biblioteca de funções numpy do Python\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo a matriz de transição A\n",
    "A = np.array([[80/100, 30/100, 20/100],\n",
    "              [10/100, 20/100, 60/100],\n",
    "              [10/100, 50/100, 20/100]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A matriz de transição A é:\n",
      "\n",
      "[[0.8 0.3 0.2]\n",
      " [0.1 0.2 0.6]\n",
      " [0.1 0.5 0.2]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matriz aluguelCarro\n",
    "print(\"A matriz de transição A é:\\n\\n{}\".format(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta é a matriz de transição do sistema se ele for considerado uma cadeia de Markov. A partir desta matriz, a probabilidade que um carro alugado na loja 3 vá ser devolvido na loja 2 é de 60%, a probabilidade que um carro alugado na loja 1 vá ser devolvido na loja 1 é 80%, e assim por diante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adiante vamos trabalhar mais com esse exemplo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemplo: Doações na Universidade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conferindo os registros de doações recebidas, a secretaria da associação de ex-alunos de uma universidade norte-americana observa que 80% de seus ex-alunos que contribuem ao fundo da associação em um certo ano também contribuem no ano seguinte e que 30% dos que não contribuem em um certo ano contribuem no ano seguinte. Isto pode ser visto como uma cadeia de Markov de dois estados: o estado 1 corresponde a um ex-aluno que contribui em um ano qualquer e o estado 2 corresponde a um ex-aluno que não contribuiu naquele ano. A matrriz de transição é:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo a matriz de transição P\n",
    "P = np.array([[80/100, 30/100],\n",
    "              [20/100, 70/100]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A matriz de transição P é: \n",
      "\n",
      "[[0.8 0.3]\n",
      " [0.2 0.7]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matriz P\n",
    "print(\"A matriz de transição P é: \\n\\n{}\".format(P))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos exemplos acima, as matrizes de transição das cadeias de Markov têm a propiedade que as entradas em qualquer coluna somam 1. Isto não é acidental. Se **P** = [$P_{ij}$] é a matriz de transição de uma cadeia de Markov qualquer de **k** estados, então para cada **j** nós devemos ter \n",
    "$$p_{1j} + p_{2j} + ... p_{kj} = 1$$\n",
    "por que se o sistema está no estado **j** em uma observação, é certo que estará em um dos **k** estados possíveis na próxima observação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma matriz com essa propiedade é chamada **matriz estocástica**, **matriz de probabilidade** ou **matriz de Markov**. Pelo que observamos acima, a matriz de transição de uma cadeia de Markov é sempre uma matriz estocástica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em geral, não pode ser determinado com certeza o estado de um sistema em uma cadeia de Markov numa observação arbitrária. O melhor que podemos fazr é especificar probabilidades para cada um dos estados possíveis. Por exemplo, nós podemos descrever o estado possível do sistema em uma certa observação em uma cadeia de Markov com três estados, por um vetor-coluna:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$x = \\begin{bmatrix}\n",
    "              x_{1} \\\\\n",
    "              x_{2} \\\\\n",
    "              x_{3} \\\\\n",
    "              \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na qual $x_{1}$ é a probabilidade que o sistema está no estado 1, $x_{2}$ é a probabilidade que ele está no estado 2 e $x_{3}$ é a probabilidade que ele está no estado 3. Em geral, temos a seguinte definição:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> O **vetor-estado** de uma observação de uma cadeia de Markov com **k** estados é um vetor-coluna **x** cujo i-ésimo componente $x_{i}$ é a probabilidade do sistema estar, naquela observação, no i-ésimo estado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que as entradas em qualquer vetor-estado de uma cadeia de Markov são não-negativas e têm soma 1. (Por que?) Um vetor-coluna com está propiedade é chamado **vetor de probabilidade**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponha agora, que nós sabemos o vetor-estado $x^{(0)}$ de uma cadeia de Markov em alguma observação inicial. O teorema seguinte nos permitirá determinar os vetores-estado\n",
    "$$x^{(1)}, x^{(2)}, ..., x^{(n), ...}$$\n",
    "nas observações subsequentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Teorema**: Se *P* é a matriz de transição de uma cadeia de Markov e $x^{(n)}$ é o vetor-estado da n-ésima observação, então $x^{(n + 1)} = Px^{n}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A prova deste teorema envolver ideias de teorias da probabilidades e não será dada aqui. Deste teorema, segue que"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|                                         |\n",
    "|-----------------------------------------|\n",
    "|$$x^{(1)} = PX^{(0)}$$                   |\n",
    "|$$x^{(2)} = PX^{(1)} = P^{2}x^{(0)}$$    |\n",
    "|$$x^{(3)} = PX^{(2)} = P^{3}x^{(0)}$$    |\n",
    "|<center> &vellip; <center>               |\n",
    "|$$x^{(n)} = PX^{(n - 1)} = P^{n}x^{(0)}$$|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desta maneira, o vetor-estado inicial $x^{(0)}$ e a matriz de transição **P** determinam $x^{(n)}$ para **n = 1, 2, ...**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemplo: Doação de Universidade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A matriz de transição no exemplo 2 era:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A matriz de transição P: \n",
      "\n",
      "[[0.8 0.3]\n",
      " [0.2 0.7]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matriz P\n",
    "print(\"A matriz de transição P: \\n\\n{}\".format(P))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nós agora iremos construir um registro futuro provável de doações de um novo graduando que não doou no primeiro ano após a formatura. Para um tal graduando, o sistema está, inicialmente, com certeza no estado 2, de modo que o vetor-estado inicial é:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo o vetor-estado x\n",
    "x = np.array([[0],\n",
    "              [1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado é: \n",
      "\n",
      "[[0]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o vetor-estado x\n",
    "print(\"O vetor-estado é: \\n\\n{}\".format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pelo Teorema acima, nós temos, então,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# função que realizará a mudança de estado até o ano a ser definido\n",
    "def estado(matrizTransicao, vetorEstado, transicao):\n",
    "    \n",
    "    # estrutura de repetição for de 0 até (anos - 1)\n",
    "    for indice in  range(0, transicao):\n",
    "        \n",
    "        # realiza o calculo definido no teorema acima\n",
    "        vetorEstado = np.dot(matrizTransicao, vetorEstado)\n",
    "    \n",
    "    # retorna o vetor estado após sofrer todas as mudanças de estado até o ano informado\n",
    "    return vetorEstado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado após 1 ano é: \n",
      "\n",
      "[[0.3]\n",
      " [0.7]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após 1 ano\n",
    "print(\"O vetor-estado após 1 ano é: \\n\\n{}\".format(estado(P, x, transicao = 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "assim, após 1 ano é esperado que o aluno tenha 30% de chance de doar nesse ano (estado 1) e 70% de chance de não doar nesse ano (estado 2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado após 8 anos é: \n",
      "\n",
      "[[0.59765625]\n",
      " [0.40234375]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após 8 ano\n",
    "print(\"O vetor-estado após 8 anos é: \\n\\n{}\".format(estado(P, x, transicao = 8)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado após 11 ano é: \n",
      "\n",
      "[[0.59970703]\n",
      " [0.40029297]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após 11 ano\n",
    "print(\"O vetor-estado após 11 ano é: \\n\\n{}\".format(estado(P, x, transicao = 11)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que entre os vetores-estado após 8 anos e 11 anos, a mudança de probabilidade não mudou de forma brusca. Em outras palavras, os vetores-estado convergem a um vetor fixo à medida que cresce o número de observações."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemplo: Locadora de Automóveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos voltar ao exemplo 1 para aplicar os nossos novos conhecimentos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A matriz de transição A do exemplo 1 é: \n",
      "\n",
      "[[0.8 0.3 0.2]\n",
      " [0.1 0.2 0.6]\n",
      " [0.1 0.5 0.2]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matriz de transição do exemplo 1\n",
    "print(\"A matriz de transição A do exemplo 1 é: \\n\\n{}\".format(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se um carro é inicialmente alugado na loja 2, então o vetor estado inicial é"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo o vetor-estado inicial\n",
    "w = np.array([[0],\n",
    "              [1],\n",
    "              [0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado w é: \n",
      "\n",
      "[[0]\n",
      " [1]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o vetor w\n",
    "print(\"O vetor-estado w é: \\n\\n{}\".format(w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Esse é o vetor-estado no estado 2, o qual indica que o carro foi alugado na loja 2 no aluguel inicial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 1º observação é: \n",
      "\n",
      "[[0.3]\n",
      " [0.2]\n",
      " [0.5]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 1º observação\n",
    "print(\"O vetor-estado na 1º observação é: \\n\\n{}\".format(estado(A, w, transicao = 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Após a 1º observação temos 30% de chance do carro ser devolvido na loja 1, 20% de chance na loja 2 e 50% de chance na loja 3. Para a próxima observação, sempre consideramos a observação atual e a relacionamos com a matriz de transição. Então, tendo agora o vetor-estado com as caracteristicas acima do carro ser devolvido nessas lojas, teremos na 2º observação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 2º observação é: \n",
      "\n",
      "[[0.4 ]\n",
      " [0.37]\n",
      " [0.23]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 2º observação\n",
    "print(\"O vetor-estado na 2º observação é: \\n\\n{}\".format(estado(A, w, transicao = 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e na 4º observação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 4º observação é: \n",
      "\n",
      "[[0.5114]\n",
      " [0.2607]\n",
      " [0.2279]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 4º observação\n",
    "print(\"O vetor-estado na 4º observação é: \\n\\n{}\".format(estado(A, w, transicao = 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, no 4º aluguel de carros, temos a probabilidade de 51% do carro ser devolvido na loja 1, 26% do carro ser devolvido na loja 2 e 22% do carro ser devolvido na loja 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 10º observação é: \n",
      "\n",
      "[[0.556162  ]\n",
      " [0.23016171]\n",
      " [0.21367629]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 10º observação\n",
    "print(\"O vetor-estado na 10º observação é: \\n\\n{}\".format(estado(A, w, transicao = 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 11º observação é: \n",
      "\n",
      "[[0.55671337]\n",
      " [0.22985432]\n",
      " [0.21343231]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 11º observação\n",
    "print(\"O vetor-estado na 11º observação é: \\n\\n{}\".format(estado(A, w, transicao = 11)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Duas coisas  deveriam ser observadas neste exemplo. Em primeiro lugar, não foi necessário saber por quanto tempo o cliente permaneceu com o carro. Ou seja, num processo de Markov o tempo entre as observações não precisa ser regular. Em segundo lugar, os vetores-estado comvergem a um vetor fixo à medida que n cresce, exatamente como no exemplo anterior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemplo: Guarda de trânsito"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma guarda de trânsito é designada para controlar o trâfego nos oito cruzametos da rua central. Ela é instruida a permanecer em cada cruzamento por uma hora e, em seguida, ou permanecer no mesmo cruzamento ou seguir para um cruzamento adjacente. Para evitar que ela estabeleça um padrão, ela deve escolher o novo cruzamento de maneira aleatória, com qualquer escolha igualmente provável. Por exemplo, se ela está no cruzamento 5, seu próximo cruzamento pode ser 2, 4, 5 ou 8, cada um com probabilidade de $\\frac{1}{4}$. Cada dia ela começa no cruzamento em que parou no dia anterior. A matriz de transição desta cadeia de Markov é"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo a matriz de transição C\n",
    "C = np.array([[1/3, 1/3, 0  , 1/5, 0  , 0  , 0  , 0  ],\n",
    "              [1/3, 1/3, 0  , 0  , 1/4, 0  , 0  , 0  ],\n",
    "              [0  , 0  , 1/3, 1/5, 0  , 1/3, 0  , 0  ],\n",
    "              [1/3, 0  , 1/3, 1/5, 1/4, 0  , 1/4, 0  ],\n",
    "              [0  , 1/3, 0  , 1/5, 1/4, 0  , 0  , 1/3],\n",
    "              [0  , 0  , 1/3, 0  , 0  , 1/3, 1/4, 0  ],\n",
    "              [0  , 0  , 0  , 1/5, 0  , 1/3, 1/4, 1/3],\n",
    "              [0  , 0  , 0  , 0  , 1/4, 0  , 1/4, 1/3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A matriz de transição C é: \n",
      "\n",
      "[[0.33333333 0.33333333 0.         0.2        0.         0.\n",
      "  0.         0.        ]\n",
      " [0.33333333 0.33333333 0.         0.         0.25       0.\n",
      "  0.         0.        ]\n",
      " [0.         0.         0.33333333 0.2        0.         0.33333333\n",
      "  0.         0.        ]\n",
      " [0.33333333 0.         0.33333333 0.2        0.25       0.\n",
      "  0.25       0.        ]\n",
      " [0.         0.33333333 0.         0.2        0.25       0.\n",
      "  0.         0.33333333]\n",
      " [0.         0.         0.33333333 0.         0.         0.33333333\n",
      "  0.25       0.        ]\n",
      " [0.         0.         0.         0.2        0.         0.33333333\n",
      "  0.25       0.33333333]\n",
      " [0.         0.         0.         0.         0.25       0.\n",
      "  0.25       0.33333333]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matric C\n",
    "print(\"A matriz de transição C é: \\n\\n{}\".format(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Temos que a probabilidade da guarda, que está localizada no cruzamento velho **j**, querer ir para o cruzamento **i**, está dada na matriz acima."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se a guarda inicialmente começa no cruzamento 5, suas prováveis localizações, hora a hora, são dadas pelos vetores abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# determinando o vetor-estado inicial y se ela começar no cruzamento 5\n",
    "y = np.array([[0],\n",
    "              [0],\n",
    "              [0],\n",
    "              [0],\n",
    "              [1],\n",
    "              [0],\n",
    "              [0],\n",
    "              [0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado y é: \n",
      "\n",
      "[[0]\n",
      " [0]\n",
      " [0]\n",
      " [0]\n",
      " [1]\n",
      " [0]\n",
      " [0]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo o vetor-estado y\n",
    "print(\"O vetor-estado y é: \\n\\n{}\".format(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 1º observação é: \n",
      "\n",
      "[[0.  ]\n",
      " [0.25]\n",
      " [0.  ]\n",
      " [0.25]\n",
      " [0.25]\n",
      " [0.  ]\n",
      " [0.  ]\n",
      " [0.25]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 1º observação\n",
    "print(\"O vetor-estado na 1º observação é: \\n\\n{}\".format(estado(C, y, transicao = 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, no 1º, 3º, 6º e 7º estados há 0% de chance da guarda ir para o cruzamento novo 1, 3, 6 e 7, respectivamente,e 25% nos 2º, 4º, 5º e 8º estados de chance da guarda mudar para o cruzamento 2, 4, 5 e 8, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 10º observação é: \n",
      "\n",
      "[[0.11289968]\n",
      " [0.11487928]\n",
      " [0.10035458]\n",
      " [0.17818898]\n",
      " [0.1486313 ]\n",
      " [0.09887482]\n",
      " [0.13813863]\n",
      " [0.10803273]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 10º observação\n",
    "print(\"O vetor-estado na 10º observação é: \\n\\n{}\".format(estado(C, y, transicao = 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O vetor-estado na 22º observação é: \n",
      "\n",
      "[[0.10736939]\n",
      " [0.1074327 ]\n",
      " [0.10691423]\n",
      " [0.17857082]\n",
      " [0.14304836]\n",
      " [0.1068521 ]\n",
      " [0.14266778]\n",
      " [0.10714462]]\n"
     ]
    }
   ],
   "source": [
    "# vetor-estado após a 22º observação\n",
    "print(\"O vetor-estado na 22º observação é: \\n\\n{}\".format(estado(C, y, transicao = 22)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para todos valores de n maiores do que 22, todos os vetores-estado são iguais a $x^{(22)}$ até três casas decimais. Assim, como nos dois exemplos anteriores, os vetores-estado convergem a um vetor fixo à medida que n cresce."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alguma Dúvida? Entre em Contato Comigo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}