{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Pravdivostní tabulky - řešení\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "nECGmqDPwfjV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Instalace a import"
      ],
      "metadata": {
        "id": "QqlKMVNESnAy"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "YKaRYO1pA_Cu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb885a06-89a8-4253-d97b-0abcb3b38e5d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting truth-table-generator\n",
            "  Downloading truth_table_generator-1.1.2.tar.gz (14 kB)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from truth-table-generator) (1.21.6)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from truth-table-generator) (1.3.5)\n",
            "Collecting PTable\n",
            "  Downloading PTable-0.9.2.tar.gz (31 kB)\n",
            "Requirement already satisfied: pyparsing in /usr/local/lib/python3.7/dist-packages (from truth-table-generator) (3.0.9)\n",
            "Requirement already satisfied: tabulate in /usr/local/lib/python3.7/dist-packages (from truth-table-generator) (0.8.10)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from truth-table-generator) (2.11.3)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->truth-table-generator) (2.0.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->truth-table-generator) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->truth-table-generator) (2022.4)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->truth-table-generator) (1.15.0)\n",
            "Building wheels for collected packages: truth-table-generator, PTable\n",
            "  Building wheel for truth-table-generator (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for truth-table-generator: filename=truth_table_generator-1.1.2-py3-none-any.whl size=13960 sha256=667a7a227470f9cf9e09ca560459380909fb7648aabd60866c1348632842ef1b\n",
            "  Stored in directory: /root/.cache/pip/wheels/9a/55/b5/77f5756832494eafda92c7a94c1365ac31088a18a3a97dd480\n",
            "  Building wheel for PTable (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for PTable: filename=PTable-0.9.2-py3-none-any.whl size=22925 sha256=0c8949fa3532f12d59738d3dfc17d329f10e8e26b42d6ad0d99d8e11e53ce994\n",
            "  Stored in directory: /root/.cache/pip/wheels/33/df/2f/674985b3f8a2de3f96357d1eadef5110f74fa91b3785e52a54\n",
            "Successfully built truth-table-generator PTable\n",
            "Installing collected packages: PTable, truth-table-generator\n",
            "Successfully installed PTable-0.9.2 truth-table-generator-1.1.2\n"
          ]
        }
      ],
      "source": [
        "%pip install truth-table-generator"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import ttg"
      ],
      "metadata": {
        "id": "1GC4peTNwz5H"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Výroky, přepis pomocí formulí\n",
        "\n",
        "### Logické spojky\n",
        "* negace\n",
        "    * v ttg zápis pomocí `not`, případně `-`, nebo `~` (`not p`, `-p`, `~p`)\n",
        "    * `not p` je pravdivé tehdy, když `p` není pravdivé\n",
        "* a zároveň\n",
        "    * v ttg zápis pomocí `and`, například `p and q`\n",
        "    * `p and q` je pravdivé pouze v případě, kdy jsou obě formule `p` i `q` pravdivé\n",
        "* nebo\n",
        "    * v ttg t zápis pomocí `or`, například `p or q`\n",
        "    * `p or q` je pravdivé pouze v případě, kdy je pravdivá alespoň jedna z formulí `p` a `q`\n",
        "* implikace\n",
        "    * v ttg zápis pomocí `=>`, například `p => q`\n",
        "    * `p => q` je pravdivé, pokud `p` není pravdivé nebo je `q` pravdivé\n",
        "* ekvivalence\n",
        "    * v ttg zápis pomocí `=`, například `p = q`\n",
        "    * `p = q` je pravdivé, pokud mají `p` a `q` stejnou pravdivostní hodnotu (buď jsou oba nepravdivé, nebo oba pravdivé)\n",
        "\n",
        "### Problémy `ttg`\n",
        "* Balíček `truth-table-generator` má očividně problém s použitím více operátorů na stejné úrovni uzávorkování (například `a and b and c`)\n",
        "* Řešením je doplnění závorek\n",
        "    * `(a and b) and c`, případně `a and (b and c)`\n",
        "    * pozor: `a => (b => c)` a `(a => b) => c)` nejsou ekvivalentní zápisy! Stejně tak `(-a) => b` není ekvivalentní zápisu `-(a => b)`.\n",
        "    * doporučuju závorkovat i negaci (například `a => (-b)`), i když to vypadá, že v tomto případě vše funguje jak má.\n"
      ],
      "metadata": {
        "id": "ddv5IiaBxCsj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Přepis českých vět pomocí formulí\n",
        "\n"
      ],
      "metadata": {
        "id": "igDs9Z43cC7T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 1\n",
        "\n",
        "Text:\n",
        "\n",
        "*Červenáček je členem RŠ, ale není pravda, že zároveň\n",
        "Štětináč pěstuje krysy a Rychlonožka je statečný.*\n",
        "\n",
        "Analýza:\n",
        "* *Červenáček je členem RŠ* --> atomická formule `p`\n",
        "* *Štětináč pěstuje krysy* --> atomická formule `q`\n",
        "* *Rychlonožka je statečný* --> atomická formule `r`\n",
        "* tj. `p and -(q and r)`"
      ],
      "metadata": {
        "id": "_fml7CAVgBHG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"p\", \"q\", \"r\"], [\"p and (-(q and r))\"]))"
      ],
      "metadata": {
        "id": "R42uHwJjhVnl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 2\n",
        "\n",
        "Premisy:\n",
        "* *Není pravda, že zároveň Mirek Dušín je statečný a Bohouš je pravdomluvný.*\n",
        "* *Mirek Dušín je statečný.*\n",
        "\n",
        "Závěr:\n",
        "* *Bohouš není pravdomluvný.*\n",
        "\n",
        "Analýza:\n",
        "* Pokud máme premisy a závěr, víme, že ověřujeme platnost \"pokud platí premisy, pak platí i závěr\"\n",
        "* *Mirek Dušín je statečný* --> atomická formule `m`\n",
        "* *Bohouš je pravdomluvný* --> atomická formule `b`\n",
        "* *Není pravda, že zároveň Mirek Dušín je statečný a Bohouš je pravdomluvný.* --> `-(m and b)`\n",
        "* Z premis vyplývá závěr: `(-(m and b) and m) => -b`\n",
        "* V buňce níže jsem doplnil závorky i kolem `-(m and b)` (tj. `(-(m and b))`), bez toho to zlobilo"
      ],
      "metadata": {
        "id": "CIV8ekuXhvGA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"m\", \"b\"], [\"-(m and b)\", \"((-(m and b)) and m) => -b\"]))"
      ],
      "metadata": {
        "id": "YsgKPABJkxp1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "V tomto případě nám v posledním sloupci vyšly \"samé jedničky,\" tj. jedná se o tautologii a výrok je tzv. \"deduktivně platný.\""
      ],
      "metadata": {
        "id": "EvVJ_JK4lxEm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 3\n",
        "\n",
        "Premisy:\n",
        "* *Rychlonožka, Červenáček a Bohouš běželi závod u Masné ohrady.*\n",
        "* *Není pravda, že Rychlonožka a Štětináč běželi závod u Masné ohrady.*\n",
        "\n",
        "Závěr:\n",
        "* *Není pravda, že Bohouš a Štětináč běželi závod u Masné ohrady.*\n",
        "\n",
        "Analýza:\n",
        "* *Rychlonožka běžel závod* --> atomická formule `r`\n",
        "* *Červenáček běžel závod* --> atomická formule `c`\n",
        "* *Bohouš běžel závod* --> atomická formule `b`\n",
        "* *Štětináč běžel závod* --> atomická formule `s`\n",
        "* *R, Č a B běželi závod* --> `r and c and b`\n",
        "* *Není pravda, že R a Š běželi závod* --> `-(r and s)`\n",
        "* *Není pravda, že B a Š běželi závod* --> `-(b and s)`\n",
        "* Z premis vyplývá závěr: `((r and c and b) and -(r and s)) => -(b and s)`\n",
        "* Níže opět doplněné nějaké závorky"
      ],
      "metadata": {
        "id": "SgBmCeQhlaXP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"r\", \"c\", \"b\", \"s\"], [\"((r and c) and b)\", \"-(r and s)\", \"-(b and s)\", \"(((r and c) and b) and (-(r and s))) => (-(b and s))\"]))"
      ],
      "metadata": {
        "id": "eFWv8KQvnJgM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To, že se opět jedná o výrok deduktivně platný, může v tomto případě působit poněkud neintuitivně. Při bližším pohledu na premisy je jasné, že nikdy nemohou být současně platné (Rychlonožka nemůže současně závod běžet i neběžet). V takových případech je argument deduktivně platný nezávisle na závěru. V těchto případech také nedokážeme nic říct o pravdivosti závěru."
      ],
      "metadata": {
        "id": "nrFsAGlpnjEB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 4\n",
        "\n",
        "Text:\n",
        "\n",
        "*Jestli Mirek Dušín potkal v klubovně Červenáčka, tak\n",
        "Červenáček byl v klubovně. Jestli tam Červenáček byl, tak\n",
        "Červenáček nezametá doma chodník. Pokud ale\n",
        "Červenáčkův tatínek přijel domů, tak Červenáček zametá\n",
        "chodník. Z toho plyne, že potkal-li MD v klubovně\n",
        "Červenáčka, tak Červenáčkův tatínek nepřijel domů.*\n",
        "\n",
        "Analýza:\n",
        "\n",
        "* *Jestli Mirek Dušín potkal v klubovně Červenáčka, tak\n",
        "Červenáček byl v klubovně.*\n",
        "    * *Mirek Dušín potkal v klubovně Červenáčka* --> atomická formule `p`\n",
        "    * *Červenáček byl v klubovně* --> atomická formule `q`\n",
        "    * tj. `p => q`\n",
        "* *Jestli tam Červenáček byl, tak Červenáček nezametá doma chodník.*\n",
        "    * *Červenáček byl v klubovně* --> už je přiřazena atomická formule `q`\n",
        "    * *Červenáček **zametá** doma chodník* --> atomická formule `r`\n",
        "    * tj. `q => -r` (v textu je \"nezametá\"!)\n",
        "* *Pokud ale Červenáčkův tatínek přijel domů, tak Červenáček zametá chodník.*\n",
        "    * *Červenáčkův tatínek přijel domů* --> atomická formule `s`\n",
        "    * *Červenáček zametá chodník* --> už máme přiřaženo `r`\n",
        "    * tj. `s => r`\n",
        "* *Z toho plyne, že potkal-li MD v klubovně Červenáčka, tak Červenáčkův tatínek nepřijel domů.*\n",
        "    * Tohle je trochu složitější k přepisu, zkusím to tedy trochu víc komentovat:\n",
        "        * *Z toho plyne* nás může vést k pravidlu modus ponens (pokud platí výroky `a` a `a => b`, pak nutně platí i výrok `b`)\n",
        "        * V tomto případě by se dalo *Z toho plyne, že potkal-li MD v klubovně Červenáčka,* intepretovat jako \"Pokud platí výrok `p => q` (první věta) a zároveň `q => -r` (druhá věta) a zároveň `s => r` (třetí věta) a zároveň `p` (Mirek Dušín potkal v klubovně Červenáčka),\"\n",
        "        * *Červenáčkův tatínek nepřijel domů* --> víme, že odpovídá `-s`\n",
        "        * Pokud to celé přepíšeme pomocí logických spojek, dostáváme: `((p => q) and (q => -r) and (s => r) and p) => -s`, což je formule, jejíž pravdivost nás zajímá\n",
        "        * Aby ttg fungoval jak má, v kódu níže jsem doplnil potřebné závorky"
      ],
      "metadata": {
        "id": "7-F2u1ARWJW0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"p\", \"q\", \"r\", \"s\"], [\"p => q\", \"q => (-r)\", \"s => r\", \"((((p => q) and (q => (-r))) and (s => r)) and p) => (-s)\"]))"
      ],
      "metadata": {
        "id": "dB_tNXX9w2aE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 5 - k procvičení\n",
        "\n",
        "Premisa:\n",
        "* *Mažňák je porazitelný.*\n",
        "\n",
        "Závěr:\n",
        "* *Mažňák není neporazitelný.*\n",
        "\n",
        "Analýza:\n",
        "* *Mažňák je porazitelný.* --> formule `m`\n",
        "* *Mažňák není neporazitelný.* --> `(-(-m))`\n",
        "* Tj. zajímá nás `m => (-(-m))`"
      ],
      "metadata": {
        "id": "yLvnzHT3o7mh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"m\"], [\"(-(-m))\", \"m => (-(-m))\"]))"
      ],
      "metadata": {
        "id": "8iNDrAfJpOLc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8efc7759-6d95-4978-9e82-23a22892cd0c"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+-----+-----------+----------------+\n",
            "|  m  |  (-(-m))  |  m => (-(-m))  |\n",
            "|-----+-----------+----------------|\n",
            "|  1  |     1     |       1        |\n",
            "|  0  |     0     |       1        |\n",
            "+-----+-----------+----------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 6 - k procvičení\n",
        "\n",
        "Text:\n",
        "\n",
        "*Karel nebo Petr, ale ne Marie šli na výlet. Karel nešel na\n",
        "výlet, takže Petr šel na výlet.*\n",
        "\n",
        "Analýza:\n",
        "* *Karel šel na výlet* --> `k`\n",
        "* *Petr šel na výlet* --> `p`\n",
        "* *Marie šla na výlet* --> `m`\n",
        "* *Karel nebo Petr, ale ne Marie šli na výlet.* --> `(k or p) and (-m)`\n",
        "* Tj. `(((k or p) and (-m)) and (-k)) => p`"
      ],
      "metadata": {
        "id": "wmValPzxpPou"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"k\", \"p\", \"m\"], [\"(((k or p) and (-m)) and (-k)) => p\"]))"
      ],
      "metadata": {
        "id": "TyvjFSBHppRJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "044b93a8-e3a0-4717-d040-76b4d662b217"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+-----+-----+-----+---------------------------------------+\n",
            "|  k  |  p  |  m  |  (((k or p) and (-m)) and (-k)) => p  |\n",
            "|-----+-----+-----+---------------------------------------|\n",
            "|  1  |  1  |  1  |                   1                   |\n",
            "|  1  |  1  |  0  |                   1                   |\n",
            "|  1  |  0  |  1  |                   1                   |\n",
            "|  1  |  0  |  0  |                   1                   |\n",
            "|  0  |  1  |  1  |                   1                   |\n",
            "|  0  |  1  |  0  |                   1                   |\n",
            "|  0  |  0  |  1  |                   1                   |\n",
            "|  0  |  0  |  0  |                   1                   |\n",
            "+-----+-----+-----+---------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 7 - k procvičení\n",
        "\n",
        "Text:\n",
        "\n",
        "*Protože ani Karel, ani Petr nešli na výstavu, není pravda, že\n",
        "Karel a Pavel šli na výstavu.*\n",
        "\n",
        "Analýza:\n",
        "* *Karel šel na výstavu* --> `k`\n",
        "* *Petr šel na výstavu* --> `p`\n",
        "* tj. `((-k) and (-p)) => (-(k and p))`"
      ],
      "metadata": {
        "id": "yx3IaTMSqTq1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"k\", \"p\"], [\"((-k) and (-p)) => (-(k and p))\"]))"
      ],
      "metadata": {
        "id": "o1PQ4W3dqTPx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73543580-8173-4694-d754-7bc38bac62fe"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+-----+-----+-----------------------------------+\n",
            "|  k  |  p  |  ((-k) and (-p)) => (-(k and p))  |\n",
            "|-----+-----+-----------------------------------|\n",
            "|  1  |  1  |                 1                 |\n",
            "|  1  |  0  |                 1                 |\n",
            "|  0  |  1  |                 1                 |\n",
            "|  0  |  0  |                 1                 |\n",
            "+-----+-----+-----------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cvičení 8 - k procvičení\n",
        "\n",
        "Text:\n",
        "\n",
        "*Plicní rakovina není způsobena kouřením, protože: rakovina\n",
        "plic je častější mezi kouřícími muži než mezi kouřícími\n",
        "ženami. Bylo-li by kouření příčinou rakoviny plic, nemohlo\n",
        "by toto být pravda. Fakt, že plicní rakovina je obvyklejší\n",
        "mezi kuřáky než mezi kuřačkami implikuje, že je způsobena\n",
        "něčím v mužské genetické výbavě. Ale je-li způsobena\n",
        "genomem, pak není způsobena kouřením.*\n",
        "\n",
        "Analýza:\n",
        "* *Plicní rakovina je způsobena kouřením* --> `k`\n",
        "* *Rakovina je častější mezi muži než mezi ženami* --> `f`\n",
        "    * Tohle je možné zapsat i jako dva výroky: *Rakovina je častější mezi muži* a *Rakovina je častější mezi ženami*\n",
        "    * Pak by se zapisovalo jako `(m and (-z))` (je potřeba všude důsledně závorkovat)\n",
        "    * Protože se ale výrok vždy vyskytuje ve stejné podobě, můžeme ho celý pro jednoduchost označit jako `f`\n",
        "* *Rakovina je způsobena genomem* --> `g`\n",
        "* 1. souvětí --> `(-k) <= f` (ttg neumí implikaci opačným směrem, takže musíme otočit na `f => (-k)`)\n",
        "* 2. souvětí --> `k => (-f)`\n",
        "* 3. souvětí --> `f => g`\n",
        "* 4. souvětí --> `g => (-k)`\n",
        "* Jako závěr lze považovat výrok *není způsobena kouřením*, pak by výsledná formule vypadala takto: `(((f => (-k)) and (k => (-f))) and (f => g)) and g) => (-k)`"
      ],
      "metadata": {
        "id": "iQp6nWwMpqXA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(ttg.Truths([\"f\", \"g\", \"k\"], [\"f => (-k)\", \"k => (-f)\", \"f => g\", \"g => (-k)\", \"((((f => (-k)) and (k => (-f))) and (f => g)) and g) => (-k)\"]))"
      ],
      "metadata": {
        "id": "lC3x2ZC-qRof",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "31532a81-a571-4603-8b28-1fffa8d19ff4"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+-----+-----+-----+-------------+-------------+----------+-------------+----------------------------------------------------------------+\n",
            "|  f  |  g  |  k  |  f => (-k)  |  k => (-f)  |  f => g  |  g => (-k)  |  ((((f => (-k)) and (k => (-f))) and (f => g)) and g) => (-k)  |\n",
            "|-----+-----+-----+-------------+-------------+----------+-------------+----------------------------------------------------------------|\n",
            "|  1  |  1  |  1  |      0      |      0      |    1     |      0      |                               1                                |\n",
            "|  1  |  1  |  0  |      1      |      1      |    1     |      1      |                               1                                |\n",
            "|  1  |  0  |  1  |      0      |      0      |    0     |      1      |                               1                                |\n",
            "|  1  |  0  |  0  |      1      |      1      |    0     |      1      |                               1                                |\n",
            "|  0  |  1  |  1  |      1      |      1      |    1     |      0      |                               0                                |\n",
            "|  0  |  1  |  0  |      1      |      1      |    1     |      1      |                               1                                |\n",
            "|  0  |  0  |  1  |      1      |      1      |    1     |      1      |                               1                                |\n",
            "|  0  |  0  |  0  |      1      |      1      |    1     |      1      |                               1                                |\n",
            "+-----+-----+-----+-------------+-------------+----------+-------------+----------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xb4246taXwlZ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}