introducao_logica_com_ttg_colab.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/chicolucio/exercicios-logica-ttg/blob/master/introducao_logica_com_ttg_colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k1YNaM0CTpDh"
      },
      "source": [
        "Logo no início do estudo de qualquer linguagem de programação nos deparamos com a palavra \"lógica\". Usualmente tal palavra é utilizada para se referir ou ao processo de elaboração de um algoritmo, ou a estruturas condicionais da linguagem, ou a operadores como E e OU. Nestes dois últimos contextos, estamos nos referindo à chamada lógica matemática. Neste artigo, abordo o básico de lógica matemática para estudantes de programação.\n",
        "\n",
        "## Introdução\n",
        "\n",
        "Este artigo tem por objetivo ser um material resumido de introdução ao estudo de lógica matemática. Tentei colocar o que considero o mínimo de material de partida para quem desejar se aprofundar depois com outros materiais. É um artigo construído com base nas minhas próprias anotações quando estava estudando para entender melhor operadores lógicos quando estudava Python. Correções e sugestões são bem vindas. Aqueles que desejarem um estudo mais aprofundado, podem procurar o livro Filho, E. A. *Iniciação à lógica matemática*, Editora Nobel, 2002.\n",
        "\n",
        "A lógica matemática (ou lógica simbólica ou, ainda, lógica proposicional), trata do estudo das sentenças declarativas também conhecidas como *proposições*. Chama-se proposição todo o conjunto de palavras ou símbolos que exprimem um pensamento de sentido completo. Por exemplo, \"A Lua é um satélite da Terra\" é uma proposição, assim como \"<span>&pi; > <span style=\"white-space: nowrap; font-size:larger\">\n",
        "&radic;<span style=\"text-decoration:overline;\">&nbsp;5&nbsp;</span></span></span>\".\n",
        "\n",
        "As proposições devem satisfazer aos dois princípios fundamentais seguintes:\n",
        "\n",
        "- **Princípio do terceiro excluído**: uma proposição só pode ser *verdadeira* ou *falsa*, não havendo outra alternativa.\n",
        "- **Princípio da não contradição**: uma proposição não pode ser ao mesmo tempo *verdadeira* e *falsa*. \n",
        "\n",
        "Diz-se, então, que uma proposição verdadeira possui *valor lógico* V (verdade) e uma proposição falsa possui *valor lógico* F (falso). Os valores lógicos também costumam ser representados por 0 (zero) para proposições falsas e 1 (um) para proposições verdadeiras. Em inglês, *True* (T) ou *False* (F).\n",
        "\n",
        "As duas proposições usadas de exemplo anteriormente são verdadeiras, mas a proposição \"O número &pi; é racional\" é falsa.\n",
        "\n",
        "Aqui alguns já irão reconhecer alguns aspectos que surgem quando começamos o estudo de alguma linguagem de programação. Boa parte das linguagens possuem um tipo de dados chamado *booleano*, nome derivado do matemático [George Boole](https://en.wikipedia.org/wiki/George_Boole), que é justamente um tipo que assume apenas dois valores possíveis.\n",
        "\n",
        "Apenas para ilustrar, vejamos alguns exemplos simples em Python:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7g8j5uKVTpDl",
        "outputId": "0aa7053f-bfcf-43bd-be8f-f94cd017288b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "3 > 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "09w7X2wnTpDn",
        "outputId": "322141ec-f8ec-4fef-ad73-6d470354c8a6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "2 > 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LJsVQITXTpDo",
        "outputId": "db1386e6-1450-4531-c33e-9b647b7118a2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a = 2\n",
        "b = 2\n",
        "\n",
        "a == b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F7zR2nnwTpDo"
      },
      "source": [
        "Veja que nas comparações acima temos como resultado `True` ou `False`. Podemos associar tais valores à uma variavél:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IGwK5iCLTpDo",
        "outputId": "7833fd3a-fab5-4a0a-ec88-25cda92f0682"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "t = True\n",
        "\n",
        "type(t)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MHGRm3lXTpDp"
      },
      "source": [
        "Veja que o tipo é `bool` que vem de booleano.\n",
        "\n",
        "Uma aplicação imediata de retornos booleanos é o controle de fluxo de estruturas condicionais. Veja o simples exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kq6ovluITpDp",
        "outputId": "c874b9cf-76bd-443a-8cb3-0c8a86c742be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "João NÃO pode consumir bebidas alcoólicas.\n",
            "Maria pode consumir bebidas alcoólicas.\n",
            "Tibúrcio pode consumir bebidas alcoólicas.\n"
          ]
        }
      ],
      "source": [
        "pessoas = {'João': 17,\n",
        "           'Maria': 20,\n",
        "           'Tibúrcio': 18}\n",
        "\n",
        "idade_adulta = 18\n",
        "\n",
        "for pessoa, idade in pessoas.items():\n",
        "    if idade >= idade_adulta:\n",
        "        print(f'{pessoa} pode consumir bebidas alcoólicas.')\n",
        "    else:\n",
        "        print(f'{pessoa} NÃO pode consumir bebidas alcoólicas.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ynxMBjGHTpDq"
      },
      "source": [
        "Veja que criamos um dicionário com nomes de pessoas e suas idades e verificamos se cada pessoa possui ao menos 18 anos. Se possuir, tal pessoa pode consumir bebidas alcoólicas. Veja que há uma checagem `idade >= idade_adulta`. A saída de tal checagem é um booleano, só pode ser `True` ou `False`. O resultado determina o fluxo que o programa vai seguir, entrando no bloco `if` ou no bloco `else`. Vejamos o resultado da checagem para cada entrada no dicionário:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fi7JBCoxTpDr",
        "outputId": "ab1be23c-3101-40ec-aa02-ee0de55d643c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "for pessoa, idade in pessoas.items():\n",
        "    print(idade >= idade_adulta)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gADDxOcRTpDr"
      },
      "source": [
        "## Alguns símbolos utilizados na lógica matemática\n",
        "\n",
        "Já vimos que há relação do assunto com programação. Vamos nos aprofundar um pouco mais. Independentemente da linguagem que tiver contato, haverá o conceito de operadores lógicos sendo os mais conhecidos os operadores E e OU. O símbolo referente a cada operador varia de linguagem para linguagem. Em Python, por exemplo, E e OU são representados pelas palavras em inglês `and` e `or`, respectivamente. No estudo de lógica, são chamados de conjunção e disjunção.\n",
        "\n",
        "Os operadores formam novas proposições a partir de outras. Em livros e materiais de lógica os seguintes símbolos são utilizados para os principais operadores lógicos:\n",
        "\n",
        "| Símbolo                   | Significado          |\n",
        "| -------                   | ---------            |\n",
        "| ~ ou $\\neg$               | negação              |\n",
        "| $\\land$                   | conjunção            |\n",
        "| $\\lor$                    | disjunção            |\n",
        "| $\\rightarrow$             | condicional          |\n",
        "| $\\leftrightarrow$         | bicondicional        |\n",
        "| $|$                       | tal que              |\n",
        "| NOR ou $\\downarrow$       | NOR                  |\n",
        "| XOR ou $\\underline{\\vee}$ | disjunção exclusiva  |\n",
        "| NAND ou $\\uparrow$        | NAND                 |\n",
        "\n",
        "Considere a proposição \"O número 6 é par **e** o número 8 é cubo perfeito\". Vemos em negrito uma conjunção de duas proposições: \"O número 6 é par\", \"O número 8 é cubo perfeito\". É comum representarmos proposições simples por letras minúsculas. Assim, poderíamos expressar a proposição composta deste exemplo como *p ^ q*. Mas como determinar o valor lógico de uma dada proposição composta?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r71dR2hPTpDr"
      },
      "source": [
        "## Tabelas verdades\n",
        "\n",
        "Com os operadores acima citados, proposições compostas podem ser criadas. Consequentemente, é de interesse verificar a validade lógica de uma dada proposição composta. Para isso servem as chamadas tabelas verdades.\n",
        "\n",
        "Há diversos materiais online e livros sobre lógica matemática para quem deseja uma apresentação mais formal do assunto. Aqui neste artigo quero mostrar de uma forma mais prática, que o leitor possa replicar facilmente e até mesmo possa verificar o resultado de exercícios simples de lógica. Assim, vou utilizar um pequeno pacote Python, o [*ttg - truth-table-generator*](https://github.com/chicolucio/truth-table-generator) que, como o nome mostra, permite construir tabelas verdades.\n",
        "\n",
        "A instalação é bem simples: `pip install truth-table-generator`\n",
        "\n",
        "Para usar o *ttg*, os seguintes termos são utilizados como símbolos. Estão entre aspas simples para deixar explícito que o programa os recebe como *strings*. São apresentados os nomes em português e em ingês.\n",
        "\n",
        "| Português           | Inglês                    | Termo                |\n",
        "| --------            | ------                    |  -----               |\n",
        "| negação             | *negation*                | `'not'`, `'-'`, `'~'`|\n",
        "| disjunção           | *logical disjunction*     | `'or'`               |\n",
        "| nor                 | *logical nor*             | `'nor'`              |\n",
        "| disjunção exclusiva | *exclusive disjunction*   | `'xor'`, `'!='`      |\n",
        "| conjunção           | *logical conjunction*     |  `'and'`             |\n",
        "| nand                | *logical NAND*            | `'nand'`             |\n",
        "| condicional         | *material implication*    | `'=>'`, `'implies'`  |\n",
        "| bicondicional       | *logical biconditional*   | `'='`                |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DyGc7-xCTpDs"
      },
      "source": [
        "Precisamos importar o construtor de tabelas do pacote, denominado de `Truths`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:39.712811Z",
          "start_time": "2019-10-22T13:19:39.425149Z"
        },
        "id": "OYqtOQeyTpDs"
      },
      "outputs": [],
      "source": [
        "from ttg import Truths"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HTdOVe9GTpDs"
      },
      "source": [
        "Suponha que você gostaria de construir uma tabela verdade manualmente. Se uma proposição composta é formada por $n$ proposições simples, a sua tabela verdade possuirá $2^n$ linhas. Na primeira coluna, supondo que esta possui *x* linhas, coloque nas $\\frac{x}{2}$ primeiras linhas V (ou qualquer referência ao valor de verdadeiro) e nas demais F (ou qualquer referência ao valor de falso). Na segunda coluna, coloque nas $\\frac{x}{4}$ primeiras linhas V nas próximas $\\frac{x}{4}$, F e alterne assim até  o fim das linhas. A linha de raciocínio prossegue para as próximas colunas. Pratique, por exemplo, com 4 proposições simples.\n",
        "\n",
        "Verifique sua resposta com a tabela a seguir gerada pelo *ttg* para 4 proposições simples *p*, *q*, *r* e *s*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:40.084468Z",
          "start_time": "2019-10-22T13:19:39.713964Z"
        },
        "id": "L3x4slV8TpDs",
        "outputId": "ac46d6e7-e9cd-49a0-976f-40a9fc6a25da"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-----+-----+-----+-----+\n",
            "|  p  |  q  |  r  |  s  |\n",
            "|-----+-----+-----+-----|\n",
            "|  1  |  1  |  1  |  1  |\n",
            "|  1  |  1  |  1  |  0  |\n",
            "|  1  |  1  |  0  |  1  |\n",
            "|  1  |  1  |  0  |  0  |\n",
            "|  1  |  0  |  1  |  1  |\n",
            "|  1  |  0  |  1  |  0  |\n",
            "|  1  |  0  |  0  |  1  |\n",
            "|  1  |  0  |  0  |  0  |\n",
            "|  0  |  1  |  1  |  1  |\n",
            "|  0  |  1  |  1  |  0  |\n",
            "|  0  |  1  |  0  |  1  |\n",
            "|  0  |  1  |  0  |  0  |\n",
            "|  0  |  0  |  1  |  1  |\n",
            "|  0  |  0  |  1  |  0  |\n",
            "|  0  |  0  |  0  |  1  |\n",
            "|  0  |  0  |  0  |  0  |\n",
            "+-----+-----+-----+-----+\n"
          ]
        }
      ],
      "source": [
        "print(Truths(['p', 'q', 'r', 's']))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GmuRIL-2TpDt"
      },
      "source": [
        "Repare que o padrão do *ttg* é colocar `1` como símbolo para verdadeiro e `0` para falso. Passando um parâmetro denominado *ints* (significando números inteiros - 0 e 1) como *False* a tabela passa a apresentar as palavras em inglês *True* e *False*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:40.698995Z",
          "start_time": "2019-10-22T13:19:40.085747Z"
        },
        "id": "3XYXXfwRTpDt",
        "outputId": "35eb845b-230d-4b57-c749-0a866a0ee529"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+-------+-------+\n",
            "|   p   |   q   |   r   |   s   |\n",
            "|-------+-------+-------+-------|\n",
            "| True  | True  | True  | True  |\n",
            "| True  | True  | True  | False |\n",
            "| True  | True  | False | True  |\n",
            "| True  | True  | False | False |\n",
            "| True  | False | True  | True  |\n",
            "| True  | False | True  | False |\n",
            "| True  | False | False | True  |\n",
            "| True  | False | False | False |\n",
            "| False | True  | True  | True  |\n",
            "| False | True  | True  | False |\n",
            "| False | True  | False | True  |\n",
            "| False | True  | False | False |\n",
            "| False | False | True  | True  |\n",
            "| False | False | True  | False |\n",
            "| False | False | False | True  |\n",
            "| False | False | False | False |\n",
            "+-------+-------+-------+-------+\n"
          ]
        }
      ],
      "source": [
        "print(Truths(['p', 'q', 'r', 's'], ints=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2dXnwhnjTpDt"
      },
      "source": [
        "Essa última forma de representação será a adotada no restante do artigo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ErzFWaSRTpDt"
      },
      "source": [
        "## Operações lógicas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k-fOnxG0TpDu"
      },
      "source": [
        "Vamos verificar a tabela verdade para cada operador binário presente no *ttg*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:41.231554Z",
          "start_time": "2019-10-22T13:19:40.700197Z"
        },
        "id": "2igpXRguTpDu",
        "outputId": "66051a13-cd43-4fd1-d0e5-462fa0dae12c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+-----------+----------+----------+---------+-----------+------------+-----------+\n",
            "|   p   |   q   |  p and q  |  p or q  |  p => q  |  p = q  |  p xor q  |  p nand q  |  p nor q  |\n",
            "|-------+-------+-----------+----------+----------+---------+-----------+------------+-----------|\n",
            "| True  | True  |   True    |   True   |   True   |  True   |   False   |   False    |   False   |\n",
            "| True  | False |   False   |   True   |  False   |  False  |   True    |    True    |   False   |\n",
            "| False | True  |   False   |   True   |   True   |  False  |   True    |    True    |   False   |\n",
            "| False | False |   False   |  False   |   True   |  True   |   False   |    True    |   True    |\n",
            "+-------+-------+-----------+----------+----------+---------+-----------+------------+-----------+\n"
          ]
        }
      ],
      "source": [
        "print(Truths(['p', 'q'], \n",
        "             ['p and q', 'p or q', 'p => q', 'p = q', 'p xor q',\n",
        "              'p nand q', 'p nor q'],\n",
        "             ints=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4hqMkEk7TpDu"
      },
      "source": [
        "São essas pequenas tabelas que costumam ser apresentadas em materiais de lógica de operadores para programação. Já vimos [neste artigo](https://cienciaprogramada.com.br/2021/08/curto-circuito-em-python/) que o comportamento de curto circuito de operadores pode ser compreendido a partir dessas tabelas verdades. Da mesma forma, são essenciais para o entendimento de [circuitos digitais](https://pt.wikipedia.org/wiki/Circuito_digital) e das chamadas [operações bitwise](https://en.wikipedia.org/wiki/Bitwise_operation)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IYjpp5xvTpDu"
      },
      "source": [
        "O *ttg* permite apresentar as tabelas de forma mais agradável visualmente nos Jupyter Notebooks, pois utiliza o [*Pandas*](https://pandas.pydata.org/) internamente. Abaixo são declaradas duas funções para aplicar cores nas tabelas verdade. Você pode alterar as funções caso queira cores diferentes ou outros efeitos não implementados. Fica o convite para fazer alterações e as compartilhar."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:42.666902Z",
          "start_time": "2019-10-22T13:19:42.396572Z"
        },
        "id": "Lh_T_SGNTpDv"
      },
      "outputs": [],
      "source": [
        "def color_false_red(val):\n",
        "    \"\"\"Color red False (0) and green True (1) values\"\"\"\n",
        "    \n",
        "    color = 'red' if (val == False) else 'green'\n",
        "    return 'color: %s' % color\n",
        "\n",
        "\n",
        "def df_style(logic, hl_rows=[], hl_cols=[]):\n",
        "    \"\"\"Applies style to logical expression (logic) pandas truth table. \n",
        "    Text: center. Table: no index column. Highlight yellow rows and columns in \n",
        "    lists (hl_rows and hl_cols). At the end applies color_false_red function\"\"\"\n",
        "    \n",
        "    d = logic.as_pandas().style.set_table_styles(\n",
        "        [{'selector':'th', \n",
        "          'props': [('font-size', '12pt')]}]).set_properties(\n",
        "        **{'text-align': 'center', 'font-size': '115%'}).apply(\n",
        "        lambda x: ['background: lightyellow' if x.name in hl_rows else '' for i in x],\n",
        "        axis=1).apply(lambda x: ['background: lightyellow' if x.name in hl_cols else '' for i in x],\n",
        "                      axis=0).hide_index()\n",
        "    d = d.applymap(color_false_red)\n",
        "    return d"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IL8R5vPHTpDv"
      },
      "source": [
        "Vamos ver como utilizar essas funções e aproveitar para ter mais exemplos de lógica. Considere que você quer construir uma tabela verdade para a proposição $(p \\land q) \\rightarrow (p \\lor q)$. Para praticar, construa manualmente a tabela antes de continuar.\n",
        "\n",
        "Utilizando a forma já vista anteriormente, mas declarando uma variável para ficar mais fácil de reproduzir a tabela:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:43.002651Z",
          "start_time": "2019-10-22T13:19:42.670409Z"
        },
        "id": "GnDxC1TOTpDv",
        "outputId": "348f7a99-e07d-4a93-f967-0f4327006517"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+-------------------------+\n",
            "|   p   |   q   |  (p and q) => (p or q)  |\n",
            "|-------+-------+-------------------------|\n",
            "| True  | True  |          True           |\n",
            "| True  | False |          True           |\n",
            "| False | True  |          True           |\n",
            "| False | False |          True           |\n",
            "+-------+-------+-------------------------+\n"
          ]
        }
      ],
      "source": [
        "proposicao01 = Truths(['p', 'q'], ['(p and q) => (p or q)'], ints=False)\n",
        "\n",
        "print(proposicao01)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a3kcAVcJTpDv"
      },
      "source": [
        "Agora utilizando a visualização com uma tabela do tipo Pandas DataFrame:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:43.493789Z",
          "start_time": "2019-10-22T13:19:43.003887Z"
        },
        "id": "ZVHVLC-nTpDv",
        "outputId": "89aef109-71dc-4828-aec2-6b16de282dbb"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_8d6eb_ th {\n",
              "  font-size: 12pt;\n",
              "}\n",
              "#T_8d6eb_row0_col0, #T_8d6eb_row0_col1, #T_8d6eb_row0_col2, #T_8d6eb_row1_col0, #T_8d6eb_row1_col2, #T_8d6eb_row2_col1, #T_8d6eb_row2_col2, #T_8d6eb_row3_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: green;\n",
              "}\n",
              "#T_8d6eb_row1_col1, #T_8d6eb_row2_col0, #T_8d6eb_row3_col0, #T_8d6eb_row3_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: red;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_8d6eb_\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"col_heading level0 col0\" >p</th>\n",
              "      <th class=\"col_heading level0 col1\" >q</th>\n",
              "      <th class=\"col_heading level0 col2\" >(p and q) => (p or q)</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <td id=\"T_8d6eb_row0_col0\" class=\"data row0 col0\" >True</td>\n",
              "      <td id=\"T_8d6eb_row0_col1\" class=\"data row0 col1\" >True</td>\n",
              "      <td id=\"T_8d6eb_row0_col2\" class=\"data row0 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_8d6eb_row1_col0\" class=\"data row1 col0\" >True</td>\n",
              "      <td id=\"T_8d6eb_row1_col1\" class=\"data row1 col1\" >False</td>\n",
              "      <td id=\"T_8d6eb_row1_col2\" class=\"data row1 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_8d6eb_row2_col0\" class=\"data row2 col0\" >False</td>\n",
              "      <td id=\"T_8d6eb_row2_col1\" class=\"data row2 col1\" >True</td>\n",
              "      <td id=\"T_8d6eb_row2_col2\" class=\"data row2 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_8d6eb_row3_col0\" class=\"data row3 col0\" >False</td>\n",
              "      <td id=\"T_8d6eb_row3_col1\" class=\"data row3 col1\" >False</td>\n",
              "      <td id=\"T_8d6eb_row3_col2\" class=\"data row3 col2\" >True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ],
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7fb6243e26d0>"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df_style(proposicao01)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yQAeCkxGTpDw"
      },
      "source": [
        "Vamos supor que você gostaria de destacar a última coluna:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:43.750641Z",
          "start_time": "2019-10-22T13:19:43.495030Z"
        },
        "id": "CI_3gtWJTpDw",
        "outputId": "f860103b-6a0d-45b9-b8e6-c72237d6413e"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_5907f_ th {\n",
              "  font-size: 12pt;\n",
              "}\n",
              "#T_5907f_row0_col0, #T_5907f_row0_col1, #T_5907f_row1_col0, #T_5907f_row2_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: green;\n",
              "}\n",
              "#T_5907f_row0_col2, #T_5907f_row1_col2, #T_5907f_row2_col2, #T_5907f_row3_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: green;\n",
              "}\n",
              "#T_5907f_row1_col1, #T_5907f_row2_col0, #T_5907f_row3_col0, #T_5907f_row3_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: red;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_5907f_\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"col_heading level0 col0\" >p</th>\n",
              "      <th class=\"col_heading level0 col1\" >q</th>\n",
              "      <th class=\"col_heading level0 col2\" >(p and q) => (p or q)</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <td id=\"T_5907f_row0_col0\" class=\"data row0 col0\" >True</td>\n",
              "      <td id=\"T_5907f_row0_col1\" class=\"data row0 col1\" >True</td>\n",
              "      <td id=\"T_5907f_row0_col2\" class=\"data row0 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_5907f_row1_col0\" class=\"data row1 col0\" >True</td>\n",
              "      <td id=\"T_5907f_row1_col1\" class=\"data row1 col1\" >False</td>\n",
              "      <td id=\"T_5907f_row1_col2\" class=\"data row1 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_5907f_row2_col0\" class=\"data row2 col0\" >False</td>\n",
              "      <td id=\"T_5907f_row2_col1\" class=\"data row2 col1\" >True</td>\n",
              "      <td id=\"T_5907f_row2_col2\" class=\"data row2 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_5907f_row3_col0\" class=\"data row3 col0\" >False</td>\n",
              "      <td id=\"T_5907f_row3_col1\" class=\"data row3 col1\" >False</td>\n",
              "      <td id=\"T_5907f_row3_col2\" class=\"data row3 col2\" >True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ],
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7fb5d719db20>"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df_style(proposicao01, hl_cols=['(p and q) => (p or q)'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZnhOL2esTpDw"
      },
      "source": [
        "Agora, vamos supor que você gostaria de destacar a última linha:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:44.063333Z",
          "start_time": "2019-10-22T13:19:43.751713Z"
        },
        "id": "U0SdZ-sBTpDw",
        "outputId": "f26cdf40-1aac-44a9-c358-0fc060578a43"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_5015a_ th {\n",
              "  font-size: 12pt;\n",
              "}\n",
              "#T_5015a_row0_col0, #T_5015a_row0_col1, #T_5015a_row0_col2, #T_5015a_row1_col0, #T_5015a_row1_col2, #T_5015a_row2_col1, #T_5015a_row2_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: green;\n",
              "}\n",
              "#T_5015a_row1_col1, #T_5015a_row2_col0 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: red;\n",
              "}\n",
              "#T_5015a_row3_col0, #T_5015a_row3_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: red;\n",
              "}\n",
              "#T_5015a_row3_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: green;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_5015a_\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"col_heading level0 col0\" >p</th>\n",
              "      <th class=\"col_heading level0 col1\" >q</th>\n",
              "      <th class=\"col_heading level0 col2\" >(p and q) => (p or q)</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <td id=\"T_5015a_row0_col0\" class=\"data row0 col0\" >True</td>\n",
              "      <td id=\"T_5015a_row0_col1\" class=\"data row0 col1\" >True</td>\n",
              "      <td id=\"T_5015a_row0_col2\" class=\"data row0 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_5015a_row1_col0\" class=\"data row1 col0\" >True</td>\n",
              "      <td id=\"T_5015a_row1_col1\" class=\"data row1 col1\" >False</td>\n",
              "      <td id=\"T_5015a_row1_col2\" class=\"data row1 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_5015a_row2_col0\" class=\"data row2 col0\" >False</td>\n",
              "      <td id=\"T_5015a_row2_col1\" class=\"data row2 col1\" >True</td>\n",
              "      <td id=\"T_5015a_row2_col2\" class=\"data row2 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_5015a_row3_col0\" class=\"data row3 col0\" >False</td>\n",
              "      <td id=\"T_5015a_row3_col1\" class=\"data row3 col1\" >False</td>\n",
              "      <td id=\"T_5015a_row3_col2\" class=\"data row3 col2\" >True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ],
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7fb5d71c1f10>"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df_style(proposicao01, hl_rows=[4])  # a linha de cabeçalho é contada como zero"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y0mxGtkoTpDw"
      },
      "source": [
        "É possível destacar linhas e colunas ao mesmo tempo:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:44.354732Z",
          "start_time": "2019-10-22T13:19:44.064508Z"
        },
        "id": "tVV8tN69TpDw",
        "outputId": "929dffef-60e8-44bf-a615-84424915fde5"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_0ffa1_ th {\n",
              "  font-size: 12pt;\n",
              "}\n",
              "#T_0ffa1_row0_col0, #T_0ffa1_row0_col1, #T_0ffa1_row1_col0, #T_0ffa1_row2_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: green;\n",
              "}\n",
              "#T_0ffa1_row0_col2, #T_0ffa1_row1_col2, #T_0ffa1_row2_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: green;\n",
              "}\n",
              "#T_0ffa1_row1_col1, #T_0ffa1_row2_col0 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: red;\n",
              "}\n",
              "#T_0ffa1_row3_col0, #T_0ffa1_row3_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: red;\n",
              "}\n",
              "#T_0ffa1_row3_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  background: lightyellow;\n",
              "  color: green;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_0ffa1_\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"col_heading level0 col0\" >p</th>\n",
              "      <th class=\"col_heading level0 col1\" >q</th>\n",
              "      <th class=\"col_heading level0 col2\" >(p and q) => (p or q)</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <td id=\"T_0ffa1_row0_col0\" class=\"data row0 col0\" >True</td>\n",
              "      <td id=\"T_0ffa1_row0_col1\" class=\"data row0 col1\" >True</td>\n",
              "      <td id=\"T_0ffa1_row0_col2\" class=\"data row0 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_0ffa1_row1_col0\" class=\"data row1 col0\" >True</td>\n",
              "      <td id=\"T_0ffa1_row1_col1\" class=\"data row1 col1\" >False</td>\n",
              "      <td id=\"T_0ffa1_row1_col2\" class=\"data row1 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_0ffa1_row2_col0\" class=\"data row2 col0\" >False</td>\n",
              "      <td id=\"T_0ffa1_row2_col1\" class=\"data row2 col1\" >True</td>\n",
              "      <td id=\"T_0ffa1_row2_col2\" class=\"data row2 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_0ffa1_row3_col0\" class=\"data row3 col0\" >False</td>\n",
              "      <td id=\"T_0ffa1_row3_col1\" class=\"data row3 col1\" >False</td>\n",
              "      <td id=\"T_0ffa1_row3_col2\" class=\"data row3 col2\" >True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ],
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7fb5d71a9340>"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df_style(proposicao01, hl_rows=[4], hl_cols=['(p and q) => (p or q)'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LvRaf9v-TpDw"
      },
      "source": [
        "### Exercício resolvido\n",
        "\n",
        "Vamos resolver um exercício onde as formas de visualização anteriores irão se mostrar úteis. Para praticar, faça os exercícios manualmente e compare com o resultado apresentado pelo *ttg* a seguir.\n",
        "\n",
        "**Sendo $p$ uma proposição verdadeira e $q$ uma proposição falsa, qual o valor lógico \n",
        "da proposição composta $(p \\land \\neg q) \\rightarrow q$?**\n",
        "\n",
        "----\n",
        "\n",
        "**Resolução**: Vamos começar declarando uma variável e apresentar uma tabela simples com `print`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:44.636674Z",
          "start_time": "2019-10-22T13:19:44.355756Z"
        },
        "id": "XiCeQSLITpDx"
      },
      "outputs": [],
      "source": [
        "exercicio01 = Truths(['p', 'q'], ['(p and (~q)) => q'], ints = False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3ZEzdU2TpDx"
      },
      "source": [
        "**Atenção**: Repare no cuidado com os parênteses, especialmente com o operador negação."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:44.933090Z",
          "start_time": "2019-10-22T13:19:44.639675Z"
        },
        "id": "enyxfPb3TpDx",
        "outputId": "b352c376-8baf-4092-a4e1-dc090dcdb976"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+---------------------+\n",
            "|   p   |   q   |  (p and (~q)) => q  |\n",
            "|-------+-------+---------------------|\n",
            "| True  | True  |        True         |\n",
            "| True  | False |        False        |\n",
            "| False | True  |        True         |\n",
            "| False | False |        True         |\n",
            "+-------+-------+---------------------+\n"
          ]
        }
      ],
      "source": [
        "print(exercicio01)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h9BXEqiuTpDx"
      },
      "source": [
        "O enunciado atribuiu valores lógicos específicos para as proposições simples. Podemos utilizar os recursos visuais apresentados anteriormente para destacar a linha da tabela referente a esses valores e achar a resposta do exercício:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:45.283854Z",
          "start_time": "2019-10-22T13:19:44.934297Z"
        },
        "id": "wjAZznNPTpDx",
        "outputId": "3e9849f5-de2b-4903-bd30-d3f1b5b0696c"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_4c88c_ th {\n",
              "  font-size: 12pt;\n",
              "}\n",
              "#T_4c88c_row0_col0, #T_4c88c_row0_col1, #T_4c88c_row0_col2, #T_4c88c_row2_col1, #T_4c88c_row2_col2, #T_4c88c_row3_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: green;\n",
              "}\n",
              "#T_4c88c_row1_col0 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: green;\n",
              "}\n",
              "#T_4c88c_row1_col1, #T_4c88c_row1_col2 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  background: lightyellow;\n",
              "  color: red;\n",
              "}\n",
              "#T_4c88c_row2_col0, #T_4c88c_row3_col0, #T_4c88c_row3_col1 {\n",
              "  text-align: center;\n",
              "  font-size: 115%;\n",
              "  color: red;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_4c88c_\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"col_heading level0 col0\" >p</th>\n",
              "      <th class=\"col_heading level0 col1\" >q</th>\n",
              "      <th class=\"col_heading level0 col2\" >(p and (~q)) => q</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <td id=\"T_4c88c_row0_col0\" class=\"data row0 col0\" >True</td>\n",
              "      <td id=\"T_4c88c_row0_col1\" class=\"data row0 col1\" >True</td>\n",
              "      <td id=\"T_4c88c_row0_col2\" class=\"data row0 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_4c88c_row1_col0\" class=\"data row1 col0\" >True</td>\n",
              "      <td id=\"T_4c88c_row1_col1\" class=\"data row1 col1\" >False</td>\n",
              "      <td id=\"T_4c88c_row1_col2\" class=\"data row1 col2\" >False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_4c88c_row2_col0\" class=\"data row2 col0\" >False</td>\n",
              "      <td id=\"T_4c88c_row2_col1\" class=\"data row2 col1\" >True</td>\n",
              "      <td id=\"T_4c88c_row2_col2\" class=\"data row2 col2\" >True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td id=\"T_4c88c_row3_col0\" class=\"data row3 col0\" >False</td>\n",
              "      <td id=\"T_4c88c_row3_col1\" class=\"data row3 col1\" >False</td>\n",
              "      <td id=\"T_4c88c_row3_col2\" class=\"data row3 col2\" >True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ],
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7fb5d719da60>"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df_style(exercicio01, hl_rows=[2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYTdf15BTpDx"
      },
      "source": [
        "Logo, o valor lógico da proposição composta no contexto apresentado é *Falso*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bwjfEnRxTpDx"
      },
      "source": [
        "## Tautologias, contradições e contingências"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UuI_m_jwTpDy"
      },
      "source": [
        "**Tautologia** é toda proposição composta cujo valor lógico é sempre verdade quaisquer que sejam os valores lógicos das proposições simples componentes. Ou seja, em qualquer contexto.\n",
        "\n",
        "**Contradição** é toda proposição composta cujo valor lógico é sempre falso quaisquer que sejam os valores lógicos das proposições simples componentes. Ou seja, em qualquer contexto.\n",
        "\n",
        "**Contingência** é toda proposição composta que não é tautologia nem contradição."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R37oSZhETpDy"
      },
      "source": [
        "O *ttg* possui o método *valuation* que, por padrão, analisa a última coluna de uma tabela-verdade e avalia se é uma tautologia, contradição ou  contingência. É possível passar parâmetros para *valuation* em tabelas com várias colunas, veja a [documentação](https://github.com/chicolucio/truth-table-generator) para detalhes se for de interesse."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t5uupukjTpDy",
        "outputId": "f590e8ce-1a70-419e-ee1f-f06da7d26f2f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+-------------------------+\n",
            "|   p   |   q   |  (p and q) => (p or q)  |\n",
            "|-------+-------+-------------------------|\n",
            "| True  | True  |          True           |\n",
            "| True  | False |          True           |\n",
            "| False | True  |          True           |\n",
            "| False | False |          True           |\n",
            "+-------+-------+-------------------------+\n"
          ]
        }
      ],
      "source": [
        "print(proposicao01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:45.610367Z",
          "start_time": "2019-10-22T13:19:45.284980Z"
        },
        "id": "Tsx824FHTpDy",
        "outputId": "084b8dba-33e5-4a13-ba5a-9cf3b8409e8a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Tautology'"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "proposicao01.valuation()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:45.926905Z",
          "start_time": "2019-10-22T13:19:45.612483Z"
        },
        "id": "oD89OGQeTpDy",
        "outputId": "15b86882-20eb-407b-c0e4-d00c7869f4a9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+--------------+\n",
            "|   p   |  p and (~p)  |\n",
            "|-------+--------------|\n",
            "| True  |    False     |\n",
            "| False |    False     |\n",
            "+-------+--------------+\n"
          ]
        }
      ],
      "source": [
        "proposicao02 = Truths(['p'], ['p and (~p)'], ints=False)\n",
        "\n",
        "print(proposicao02)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:46.222604Z",
          "start_time": "2019-10-22T13:19:45.929473Z"
        },
        "id": "tPSNzKu5TpDy",
        "outputId": "e8ae1366-a4fe-4941-e71a-d5e48c97fbc1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Contradiction'"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "proposicao02.valuation()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:46.541924Z",
          "start_time": "2019-10-22T13:19:46.224087Z"
        },
        "id": "RRWf1TcgTpDy",
        "outputId": "55d02c85-b2e6-4294-be92-429d78a922b6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+-------+------------------+\n",
            "|   p   |   q   |   r   |  (p and q) or r  |\n",
            "|-------+-------+-------+------------------|\n",
            "| True  | True  | True  |       True       |\n",
            "| True  | True  | False |       True       |\n",
            "| True  | False | True  |       True       |\n",
            "| True  | False | False |      False       |\n",
            "| False | True  | True  |       True       |\n",
            "| False | True  | False |      False       |\n",
            "| False | False | True  |       True       |\n",
            "| False | False | False |      False       |\n",
            "+-------+-------+-------+------------------+\n"
          ]
        }
      ],
      "source": [
        "proposicao03 = Truths(['p', 'q', 'r'], ['(p and q) or r'], ints=False)\n",
        "\n",
        "print(proposicao03)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:46.894927Z",
          "start_time": "2019-10-22T13:19:46.543021Z"
        },
        "id": "L0Tcmk1fTpDz",
        "outputId": "a84f5865-f538-43da-d4e9-af08210414a8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Contingency'"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "proposicao03.valuation()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I24iZPAwTpDz"
      },
      "source": [
        "### Exercício resolvido\n",
        "\n",
        "Demonstre que são tautologias as seguintes proposições compostas.\n",
        "\n",
        "a. $ (p \\land q) \\rightarrow p $\n",
        "\n",
        "b. $ p \\rightarrow (p \\lor q) $\n",
        "\n",
        "c. $ [p \\land (p \\rightarrow q)] \\rightarrow q $ (conhecido como *modus ponens*)\n",
        " \n",
        "d. $ [(p \\rightarrow q) \\land (\\neg q)] \\rightarrow (\\neg p) $ (conhecido como *modus tollens*)\n",
        "\n",
        "*Obs*.: Essas tautologias são conhecidas como *regras de inferência*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:47.168312Z",
          "start_time": "2019-10-22T13:19:46.896823Z"
        },
        "id": "v2J5rINTTpDz"
      },
      "outputs": [],
      "source": [
        "exercicio02 = Truths(\n",
        "    ['p', 'q'], \n",
        "    ['(p and q) => p', 'p => (p or q)',\n",
        "     '(p and (p => q)) => q', '((p => q) and (~q)) => (~p)'],\n",
        "    ints=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:47.905996Z",
          "start_time": "2019-10-22T13:19:47.179202Z"
        },
        "id": "NZHwA792TpDz",
        "outputId": "7eaa7e0d-62a5-4a13-d852-1c7fb9b9abaa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-------+-------+------------------+-----------------+-------------------------+-------------------------------+\n",
            "|   p   |   q   |  (p and q) => p  |  p => (p or q)  |  (p and (p => q)) => q  |  ((p => q) and (~q)) => (~p)  |\n",
            "|-------+-------+------------------+-----------------+-------------------------+-------------------------------|\n",
            "| True  | True  |       True       |      True       |          True           |             True              |\n",
            "| True  | False |       True       |      True       |          True           |             True              |\n",
            "| False | True  |       True       |      True       |          True           |             True              |\n",
            "| False | False |       True       |      True       |          True           |             True              |\n",
            "+-------+-------+------------------+-----------------+-------------------------+-------------------------------+\n"
          ]
        }
      ],
      "source": [
        "print(exercicio02)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R3UDDGDRTpDz"
      },
      "source": [
        "Vemos que são todas tautologias. Podemos passar cada coluna para o método `valuation` e verificar usando o *ttg* também:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:48.279275Z",
          "start_time": "2019-10-22T13:19:47.908452Z"
        },
        "id": "T64MGHOWTpDz",
        "outputId": "a1685e18-2733-40a8-de5d-6af402051ea1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tautology\n",
            "Tautology\n",
            "Tautology\n",
            "Tautology\n"
          ]
        }
      ],
      "source": [
        "print(exercicio02.valuation(3))\n",
        "print(exercicio02.valuation(4))\n",
        "print(exercicio02.valuation(5))\n",
        "print(exercicio02.valuation(6))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fuuQt50aTpDz"
      },
      "source": [
        "## Equivalência lógica\n",
        "\n",
        "Sejam $p$, $q$ e $r$ três proposições simples quaisquer. A seguir, o símbolo $\\Leftrightarrow$ é utilizado no sentido de equivalência entre a proposição anterior e a posterior ao símbolo. Duas proposições são equivalentes se possuem tabelas verdades idênticas. Assim, o leitor pode praticar construindo tabelas para as proposições antes e depois do símbolo de equivalência em cada caso a seguir e verificando que são iguais.\n",
        "\n",
        "- Leis idempotentes\n",
        "    - $p \\land p \\Leftrightarrow p$\n",
        "    - $p \\lor p \\Leftrightarrow p$\n",
        "\n",
        "- Leis comutativas\n",
        "    - $p \\land q \\Leftrightarrow q \\land p$\n",
        "    - $p \\lor q \\Leftrightarrow q \\lor p$\n",
        "    \n",
        "- Leis de identidade\n",
        "    - $p \\land V \\Leftrightarrow p$\n",
        "    - $p \\land F \\Leftrightarrow F$\n",
        "    - $p \\lor V \\Leftrightarrow V$\n",
        "    - $p \\lor F \\Leftrightarrow p$\n",
        "\n",
        "- Leis complementares\n",
        "    - $\\neg (\\neg p) \\Leftrightarrow p$\n",
        "    - $p \\land \\neg p \\Leftrightarrow F$\n",
        "    - $p \\lor \\neg p \\Leftrightarrow V$\n",
        "    - $\\neg V \\Leftrightarrow F$\n",
        "    - $\\neg F \\Leftrightarrow V$\n",
        "    \n",
        "- Leis associativas\n",
        "    - $(p \\land q) \\land r \\Leftrightarrow p \\land (q \\land r)$\n",
        "    - $(p \\lor q) \\lor r \\Leftrightarrow p \\lor (q \\lor r)$\n",
        "    \n",
        "- Leis distributivas\n",
        "    - $p \\land (q \\lor r) \\Leftrightarrow (p \\land q) \\lor (p \\land r)$\n",
        "    - $p \\lor (q \\land r) \\Leftrightarrow (p \\lor q) \\land (p \\lor r)$\n",
        "\n",
        "- Leis de absorção\n",
        "    - $p \\land (p \\lor q) \\Leftrightarrow p$\n",
        "    - $p \\lor (p \\land q) \\Leftrightarrow p$\n",
        "\n",
        "- Leis de Augustus de Morgan\n",
        "    - $\\neg (p \\land q) \\Leftrightarrow \\neg p \\lor \\neg q $\n",
        "    - $\\neg (p \\lor q) \\Leftrightarrow \\neg p \\land \\neg q $\n",
        "    - $\\neg (p \\land q \\land r) \\Leftrightarrow \\neg p \\lor \\neg q \\lor \\neg r $\n",
        "    - $\\neg (p \\lor q \\lor r) \\Leftrightarrow \\neg p \\land \\neg q \\land \\neg r $\n",
        "    \n",
        "- Negação da condicional\n",
        "    - $\\neg (p \\rightarrow q) \\Leftrightarrow p \\land \\neg q$\n",
        "    \n",
        "- Negação da bicondicional\n",
        "    - $\\neg (p \\leftrightarrow q) \\Leftrightarrow (p \\land \\neg q) \\lor (\\neg p \\land q)$\n",
        "    \n",
        "    \n",
        "Além disso, os seguintes termos são utilizados no estudo de condicionais:\n",
        "\n",
        "| Proposição                  | Termo          |\n",
        "|-----                        | ------         |\n",
        "| $p \\rightarrow q$           | condicional    |\n",
        "| $q \\rightarrow p$           | recíproca      |\n",
        "| $\\neg p \\rightarrow \\neg q$ | inversa        |\n",
        "| $\\neg q \\rightarrow \\neg p$ | contrapositiva |\n",
        "\n",
        "A condicional e a contrapositiva são equivalentes: $(p \\rightarrow q) \\Leftrightarrow (\\neg q \\rightarrow \\neg p)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cK6e4WNOTpD0"
      },
      "source": [
        "Vamos verificar as duas primeiras leis de Morgan apresentadas e a negação da condicional com o *ttg*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:48.555061Z",
          "start_time": "2019-10-22T13:19:48.280496Z"
        },
        "id": "aUNDBufHTpD0"
      },
      "outputs": [],
      "source": [
        "lei_morgan01 = Truths(['p','q'], ['~(p and q)', '(~p) or (~q)'])\n",
        "lei_morgan02 = Truths(['p','q'], ['~(p or q)', '(~p) and (~q)'])\n",
        "negacao_condicional = Truths(['p','q'], ['~(p => q)', 'p and (~q)'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:48.852434Z",
          "start_time": "2019-10-22T13:19:48.559205Z"
        },
        "id": "S061becCTpD0",
        "outputId": "6f30fdd3-34b8-4d20-f0d4-4bc0c502c9a1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-----+-----+--------------+----------------+\n",
            "|  p  |  q  |  ~(p and q)  |  (~p) or (~q)  |\n",
            "|-----+-----+--------------+----------------|\n",
            "|  1  |  1  |      0       |       0        |\n",
            "|  1  |  0  |      1       |       1        |\n",
            "|  0  |  1  |      1       |       1        |\n",
            "|  0  |  0  |      1       |       1        |\n",
            "+-----+-----+--------------+----------------+\n"
          ]
        }
      ],
      "source": [
        "print(lei_morgan01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:49.166011Z",
          "start_time": "2019-10-22T13:19:48.853659Z"
        },
        "id": "gb-Q_4qkTpD0",
        "outputId": "e263cf3e-fa5b-422b-8a90-b8b3ce6c862f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-----+-----+-------------+-----------------+\n",
            "|  p  |  q  |  ~(p or q)  |  (~p) and (~q)  |\n",
            "|-----+-----+-------------+-----------------|\n",
            "|  1  |  1  |      0      |        0        |\n",
            "|  1  |  0  |      0      |        0        |\n",
            "|  0  |  1  |      0      |        0        |\n",
            "|  0  |  0  |      1      |        1        |\n",
            "+-----+-----+-------------+-----------------+\n"
          ]
        }
      ],
      "source": [
        "print(lei_morgan02)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2019-10-22T13:19:49.479235Z",
          "start_time": "2019-10-22T13:19:49.167052Z"
        },
        "id": "lrkSQVaZTpD0",
        "outputId": "0857d4ac-703b-404f-c27f-12b2b037ff16"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "+-----+-----+-------------+--------------+\n",
            "|  p  |  q  |  ~(p => q)  |  p and (~q)  |\n",
            "|-----+-----+-------------+--------------|\n",
            "|  1  |  1  |      0      |      0       |\n",
            "|  1  |  0  |      1      |      1       |\n",
            "|  0  |  1  |      0      |      0       |\n",
            "|  0  |  0  |      0      |      0       |\n",
            "+-----+-----+-------------+--------------+\n"
          ]
        }
      ],
      "source": [
        "print(negacao_condicional)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5EuI1OGxTpD0"
      },
      "source": [
        "Repare que as duas colunas para cada um dos três últimos exemplos são iguais, demonstrando as equivalências apresentadas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Ul4AmWNTpD0"
      },
      "source": [
        "## Exercícios complementares\n",
        "\n",
        "A seguir são sugeridos alguns exercícios. O gabarito se encontra em um notebook [neste repositório](https://github.com/chicolucio/exercicios-logica-ttg). No arquivo de gabarito algumas considerações e discussões também são feitas durante as resoluções. Sugiro que resolva os exercícios manualmente em papel, para praticar e ter certeza que compreendeu o conteúdo, e depois utilize o *ttg* para conferir suas respostas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HGAcxaPETpD1"
      },
      "source": [
        "**Exercício 1**: Construa a tabela verdade para as proposições e as classifique como tautologia, contradição ou contingência.\n",
        "\n",
        "a. $\\neg p \\lor \\neg q$\n",
        "\n",
        "b. $ [ (p \\land \\neg q) \\lor \\neg r] \\land [ (\\neg p \\lor q) \\land r ] $\n",
        "\n",
        "c. $(p \\land q) \\rightarrow (p \\lor q)$\n",
        "\n",
        "d. $(p \\land q) \\lor r$\n",
        "\n",
        "e. $(p \\land q) \\rightarrow p$\n",
        "\n",
        "f. $p \\rightarrow (p \\lor q)$\n",
        "\n",
        "g. $ [ p \\land (p \\rightarrow q) ] \\rightarrow q $\n",
        "\n",
        "h. $ [ (p \\rightarrow q) \\land \\neg q ] \\rightarrow \\neg q $\n",
        "\n",
        "i. $ (p \\land q) \\land \\neg p $\n",
        "\n",
        "j. $ [ (p \\lor \\neg q) \\land r ] \\land [ (p \\land q) \\lor \\neg r ] $\n",
        "\n",
        "k. $ [ (p \\leftrightarrow q) \\rightarrow r ] \\leftrightarrow [ \\neg (p \\land r) \\rightarrow q ] $"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w46d_GJ9TpD1"
      },
      "source": [
        "**Exercício 2**: Sendo $p$ uma proposição de valor lógico verdadeiro e $q$ uma proposição de valor lógico falso, qual o valor lógico da proposição composta $R: (p \\land \\neg q) \\rightarrow q$?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q1Ucp5VfTpD1"
      },
      "source": [
        "**Exercício 3**: Atribua valor lógico verdadeiro ou falso a cada uma das afirmações a seguir:\n",
        "\n",
        "a. Se Marte é um planeta então $3 = 7 - 4$.\n",
        "\n",
        "b. A soma de dois números pares é um número par e $7^2 = 49$.\n",
        "\n",
        "c. $3=5$ se e somente se o urso é um animal invertebrado.\n",
        "\n",
        "d. Se $10^2 = 100$ então todo número inteiro é natural.\n",
        "\n",
        "e. $2 = 3^2 - 7$ ou a Terra é plana.\n",
        "\n",
        "f. $3 > 1$ e $4 > 2$\n",
        "\n",
        "g. $3 > 1$ ou $3 = 1$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oeZjyoFSTpD1"
      },
      "source": [
        "**Exercício 4**: Sejam:\n",
        "\n",
        "- $p$: Londres é a capital da Inglaterra.\n",
        "- $q$: A Torre Eiffel situa-se em Londres.\n",
        "- $r$: O meridiano de Greenwich passa por Londres.\n",
        "\n",
        "Traduza para a linguagem natural cada uma das proposições compostas abaixo e determine o respectivo valor lógico.\n",
        "\n",
        "a. $\\neg q \\land \\neg p$\n",
        "\n",
        "b. $\\neg q \\lor \\neg p$\n",
        "\n",
        "c. $\\neg (p \\land q)$\n",
        "\n",
        "d. $\\neg p \\lor r$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ZUAUE2NTpD1"
      },
      "source": [
        "**Exercício 5**: Prove que uma condicional é equivalente a $\\neg (p \\land q)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D17ox4MOTpD1"
      },
      "source": [
        "**Exercício 6**: Comprove que $\\neg (p \\rightarrow q)$ é equivalente a $p \\land \\neg q$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GR3VgEYbTpD1"
      },
      "source": [
        "**Exercício 7**: Mostre simbolicamente que são logicamente equivalentes: \"Se um aluno estuda, então ele é aprovado\" e \"Não é verdade que um aluno estuda e não é aprovado\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u8WFVyryTpD1"
      },
      "source": [
        "**Exercício 8**: Mostre simbolicamente que a negação de \"Se um aluno estuda, então ele é aprovado\" é \"Há alunos que estudam e não são aprovados\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IRzcWuCkTpD1"
      },
      "source": [
        "**Exercício 9**: Considere a proposição: \"Se o Edson se candidatar a presidente, então ele se elegerá\". Em qual dos casos abaixo essa proposição condicional deve ser considerada falsa?\n",
        "\n",
        "a. O Edson se candidatou a presidente e se elegeu.\n",
        "\n",
        "b. O Edson se candidatou a presidente e não se elegeu.\n",
        "\n",
        "c. O Edson não se candidatou a presidente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sNc0UQZlTpD2"
      },
      "source": [
        "**Exercício 10**: Considere a condicional: \"Se o seu dente está cariado, você precisa de um dentista\".\n",
        "\n",
        "a. Suponha que \"o seu dente não está cariado e você precisa de um dentista\". Isto significa uma negação da anterior?\n",
        "\n",
        "b. Escreva uma proposição que não seja condicional e que corresponde à negação da proposição acima."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AO4XlL0HTpD2"
      },
      "source": [
        "**Exercício 11**: Escreva na linguagem simbólica e verifique se são logicamente equivalentes as proposições \"Se eu me chamo João, então eu passo no vestibular\", e \"Eu passo no vestibular ou não me chamo João\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QTfdarDgTpD2"
      },
      "source": [
        "**Exercício 12**: Sendo a proposição $p \\rightarrow (r \\lor s)$ falsa e a proposição $(q \\land \\neg s) \\rightarrow p$ verdadeira, classifique em verdadeira ou falsa as afirmações $p$, $q$, $r$ e $s$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tdwABWNlTpD2"
      },
      "source": [
        "**Exercício 13**: Sabendo que as proposições $p$ e $q$ são verdadeiras e que a proposição $r$ é falsa, determine o valor lógico da seguinte proposição: $(\\neg p \\downarrow q) \\land (q \\uparrow \\neg r)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QaqdBiVaTpD2"
      },
      "source": [
        "## Conclusão\n",
        "\n",
        "Neste artigo vimos o básico de lógica matemática para programadores com o auxílio do pacote Python [*ttg - truth-table-generator*](https://github.com/chicolucio/truth-table-generator). É um assunto vasto e com o básico demonstrado aqui quem precisar pode pesquisar mais. O notebook deste artigo e o com as respostas dos exercícios propostos se encontram [neste repositório](https://github.com/chicolucio/exercicios-logica-ttg).\n",
        "\n",
        "Até a próxima."
      ]
    }
  ],
  "metadata": {
    "hide_input": false,
    "kernelspec": {
      "display_name": "ttg",
      "language": "python",
      "name": "ttg"
    },
    "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.10"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": false,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {
        "height": "calc(100% - 180px)",
        "left": "10px",
        "top": "150px",
        "width": "309.2px"
      },
      "toc_section_display": true,
      "toc_window_display": true
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    },
    "colab": {
      "name": "introducao_logica_com_ttg_colab.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "I24iZPAwTpDz",
        "QaqdBiVaTpD2"
      ],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}