PythonLogic1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "PythonLogic1.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMq/TnrBTDO53tb0AqbiR4P",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JoTaijiquan/Python/blob/master/PythonLogic1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RdymzNva_uXt"
      },
      "source": [
        "#นิยาม\n",
        "\n",
        "**ประพจน์ (proposition)** คือประโยคที่สามารถบอกได้ว่าเป็นจริงหรือเป็นเท็จ\n",
        "\n",
        "```\n",
        "เช่น \n",
        "\n",
        "โลกเป็นบริวาลของดวงอาทิตย์ (เป็นจริง)\n",
        "ดวงอาทิตย์ขึ้นทางทิศตะวันตก (เป็นเท็จ)\n",
        "ฉันชอบกินไก่ (อาจจะจริงหรือเท็จอย่างใดอย่างหนึ่ง)\n",
        "ลิงออกลูกเป็นไก่ (เป็นเท็จ)\n",
        "ม้ามีสี่ขา (เป็นจริง)\n",
        "```\n",
        "\n",
        "**ตารางความจริง (Truth Table)**\n",
        "\n",
        "เช่น\n",
        "\n",
        "A,B แทนประพจน์ใดๆ\n",
        "\n",
        "True แทนค่าจริง และ False แทนค่าเท็จ\n",
        "```\n",
        "A       B        A and B\n",
        "\n",
        "True    True     True\n",
        "True    False    False\n",
        "False   True     False\n",
        "False   False    False\n",
        "```\n",
        "\n",
        "**ตัวเชื่อม (connective)**\n",
        "\n",
        "คือตัวเชื่อมสองประพจน์เข้าด้วยกันเช่น and (และ), or (หรือ), imply (ถ้า..แล้ว), if and only if (ก็ต่อเมื่อ)\n",
        "\n",
        "**(Negation)**\n",
        "\n",
        "ประพจน์นิเสธของประพจน์ใดๆ คือประพจน์ที่มีค่าความจริงตรงข้ามกับประพจน์นั้น\n",
        "\n",
        "เช่น \n",
        "```\n",
        "A      B      A and B  not(A)  not(A and B)\n",
        "\n",
        "True   True   True     False     False\n",
        "True   False  False    False     True\n",
        "False  True   False    True      True\n",
        "False  False  False    True      True\n",
        "```\n",
        "\n",
        "***ประพจน์สมมูลกัน (Propositional Equivalence)***\n",
        "\n",
        "คือประพจน์ที่มีตารางความจริงตรงกัน และสามารถใช้แทนกันได้\n",
        "\n",
        "เช่น\n",
        "```\n",
        "A      B        not(A or B)   not(A) and not(B)\n",
        "\n",
        "True   True     False         Fasle\n",
        "True   False    False         False\n",
        "False  True     False         False\n",
        "False  False    True          True\n",
        "```\n",
        "\n",
        "***สัจนิรันดร์ (Tautology)***\n",
        "\n",
        "คือประพจน์ที่มีค่าเป็นจริงในทุกกรณี\n",
        "\n",
        "เช่น\n",
        "```\n",
        "A\t      B\t    not(A and B) == (not A) or (not B)\n",
        "\n",
        "True     True         True\n",
        "True     False        True\n",
        "False    True         True\n",
        "False    False        True\n",
        "```\n",
        "\n",
        "***ตัวบ่งปริมาณ(Quantified statement)***\n",
        "\n",
        "all([..]) จะเป็น True เมื่อทุกค่าใน list[..] เป็น True\n",
        "เช่น\n",
        "\n",
        "```\n",
        "all([True,True,True,True,True,True,True]) จะได้ True\n",
        "all([True,True,True,True,False,True,True]) จะได้ False\n",
        "```\n",
        "\n",
        "any([..]) จะเป็น True เมื่อมีบางค่าใน list[..] เป็น True เช่น\n",
        "```\n",
        "any([False,False,False,False,True,False]) จะได้ True\n",
        "any([False,False,False,False,False,False]) จะได้ False\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sIwr8yYdgc-L"
      },
      "source": [
        "#Example 1\n",
        "\n",
        "โปรแกรมแสดงสัญลักษณ์ทางตรรกศาสตร์ของภาษา Python \n",
        "```\n",
        "and & คือ และ\n",
        "or |  คือ หรือ\n",
        "xor   คือ เฉพาะหรือ\n",
        "==    คือ ก็ต่อเมื่อ \n",
        "not   คือ นิเสธ\n",
        ">     คือ มากกว่า เป็น True เมื่อ True มากกว่า False\n",
        "<     คือ น้อยกว่า เป็น True เมื่อ False น้อยกว่า True\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dUUACDeTgr1l",
        "outputId": "13d5b741-5d11-49e2-c6d9-8a14c39448ab"
      },
      "source": [
        "# Example 1\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"  A\\t   B\\t  A&B\\t  A|B\\t  A^B\\t A==B\\t  A>B\\t  A<B\\t not A\")\n",
        "print (\"   \\t   \\t  and\\t  or\\t  xor\\t  =\\t   >\\t   <\\t not\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A&B, \"\\t\", A|B, \"\\t\", A^B,\"\\t\",A==B,\"\\t\",A>B,\"\\t\",A<B,\"\\t\",not A)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  A\t   B\t  A&B\t  A|B\t  A^B\t A==B\t  A>B\t  A<B\t not A\n",
            "   \t   \t  and\t  or\t  xor\t  =\t   >\t   <\t not\n",
            "\n",
            "True \t True \t True \t True \t False \t True \t False \t False \t False\n",
            "True \t False \t False \t True \t True \t False \t True \t False \t False\n",
            "False \t True \t False \t True \t True \t False \t False \t True \t True\n",
            "False \t False \t False \t False \t False \t True \t False \t False \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78xmmgcWw_58"
      },
      "source": [
        "#Example 2\n",
        "ตัวดำเนินการ or หรือ | (หรือ)\n",
        "\n",
        "```\n",
        "A   B   A or B\n",
        "\n",
        "T   T     T\n",
        "T   F     T\n",
        "F   T     T\n",
        "F   F     F\n",
        "```\n",
        "\n",
        "โปรแกรมแสดงผลของตัวดำเนินการ or"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uzJ29DUn8gdJ",
        "outputId": "a20c4c20-c3c3-4ab5-844f-e8fb1e8de645"
      },
      "source": [
        "#Example 2\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\tA or B\\t  A|B\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A or B,\"\\t\",A|B)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\tA or B\t  A|B\n",
            "\n",
            "True \t True \t True \t True\n",
            "True \t False \t True \t True\n",
            "False \t True \t True \t True\n",
            "False \t False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tjR_rKAw7l7"
      },
      "source": [
        "#Example 3\n",
        "\n",
        "ตัวดำเนินการ and หรือ & (และ)\n",
        "\n",
        "```\n",
        "A   B   A and B\n",
        "\n",
        "T   T     T\n",
        "T   F     F\n",
        "F   T     F\n",
        "F   F     F\n",
        "```\n",
        "\n",
        "โปรแกรมแสดงผลของตัวดำเนินการ and"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JZNR--2QmCS1",
        "outputId": "ea5fb5d1-8a50-4b97-97d4-67a4e8da8802"
      },
      "source": [
        "#Example 3\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\tA and B\\t A&B\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A and B,\"\\t\",A&B)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\tA and B\t A&B\n",
            "\n",
            "True \t True \t True \t True\n",
            "True \t False \t False \t False\n",
            "False \t True \t False \t False\n",
            "False \t False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ERu-Jsl5dMaB"
      },
      "source": [
        "#Example 4\n",
        "ตัวดำเนินการ not (นิเสธ)\n",
        "\n",
        "```\n",
        "not T = F\n",
        "not F = T\n",
        "```\n",
        "\n",
        "โปรแกรมแสดงผลของตัวดำเนินการ not"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lRNhD8sIKIaF",
        "outputId": "5402dcef-4bb5-4ac8-97ee-810c5d9d1dc8"
      },
      "source": [
        "#Example 4\n",
        "\n",
        "print (\"A\\tnot A\\n\")\n",
        "\n",
        "A = True\n",
        "print (A,\"\\t\",not A)\n",
        "A = False\n",
        "print (A,\"\\t\",not A)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\tnot A\n",
            "\n",
            "True \t False\n",
            "False \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pHjY8c4KNyba",
        "outputId": "17b15a68-37ff-44b1-bbfd-3a1edd3f43ec"
      },
      "source": [
        "#Quit 1\n",
        "#ให้ A=True, B=False หา (A&B)|(not(A)&B)\n",
        "\n",
        "A = True\n",
        "B = False\n",
        "\n",
        "print ((A&B)|(not(A)&B))"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mZp9IOFFDJNE",
        "outputId": "c123f10f-0c1f-44b0-a6dd-e6e046b9b1af"
      },
      "source": [
        "#Quiz 2\n",
        "#สร้างตารางความจริงของ A&(A|B)\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\t A&(A|B)\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A&(A|B))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\t A&(A|B)\n",
            "True \t True \t True\n",
            "True \t False \t True\n",
            "False \t True \t False\n",
            "False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7BpYWKBeD34y",
        "outputId": "b73e8b3e-07c0-42a1-adfb-30337eafa9f7"
      },
      "source": [
        "#Quiz 3\n",
        "#สร้างตารางความจริงของ A|(A&B)\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\t A|(A&B)\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A|(A&B))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\t A|(A&B)\n",
            "\n",
            "True \t True \t True\n",
            "True \t False \t True\n",
            "False \t True \t False\n",
            "False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vtHz6-b7Efje",
        "outputId": "3eb51d76-2ae1-4ee0-e76c-a13a8ee0f7c5"
      },
      "source": [
        "#Quiz 4\n",
        "#สร้างตารางความจริงของ A|(A|B) และ (A|A)|B\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\t A|(A|B)\\t (A|A)|B\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A|(A|B),\"\\t\\t\",(A|A)|B)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\t A|(A|B)\t (A|A)|B\n",
            "\n",
            "True \t True \t True \t\t True\n",
            "True \t False \t True \t\t True\n",
            "False \t True \t True \t\t True\n",
            "False \t False \t False \t\t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PU3bRyQtEvXA",
        "outputId": "2071f00b-13d3-49a2-8413-56afd8444a57"
      },
      "source": [
        " #Quiz 5\n",
        " #สร้างตารางความจริงของ A&(A&B) เปรียบเทียบกับ A&B\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\t A&(A&B)\\t A&B\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",A&(A&B),\"\\t\\t\",A&B)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\t A&(A&B)\t A&B\n",
            "\n",
            "True \t True \t True \t\t True\n",
            "True \t False \t False \t\t False\n",
            "False \t True \t False \t\t False\n",
            "False \t False \t False \t\t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rAZc4GAXFCNQ",
        "outputId": "d9b079a8-aa7b-4228-9d1e-8354c40e1cdb"
      },
      "source": [
        "#Quiz 6\n",
        "#สร้างตารางความจริงของ (A&B)|(not(A)|B) เปรียบเทียบกับ A^B\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A\\t  B\\t (A&B)|(not(A)|B)\\t A^B\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",(A&B)|(not(A)|B),\"\\t\\t\\t\",A^B)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\t (A&B)|(not(A)|B)\t A^B\n",
            "True \t True \t True \t\t\t False\n",
            "True \t False \t False \t\t\t True\n",
            "False \t True \t False \t\t\t True\n",
            "False \t False \t True \t\t\t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ttqm6Eb5FivI",
        "outputId": "b3587a1c-31ee-46db-d3b0-f1da606543fb"
      },
      "source": [
        "#Quiz 7\n",
        "#สร้างตารางความจริงของ (A&B)|(A&C)\n",
        "\n",
        "U = (True,True,True),(True,True,False),(True,False,True),(True,False,False),\\\n",
        "(False,True,True),(False,True,False),(False,False,True),(False,False,False)\n",
        "\n",
        "print (\"  A\\t  B\\t  C\\t(A&B)|(A&C)\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  C = i[2]\n",
        "\n",
        "  print (A,\"\\t\",B,\"\\t\",C,\"\\t\",(A&B)|(A&C))"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  A\t  B\t  C\t(A&B)|(A&C)\n",
            "\n",
            "True \t True \t True \t True\n",
            "True \t True \t False \t True\n",
            "True \t False \t True \t True\n",
            "True \t False \t False \t False\n",
            "False \t True \t True \t False\n",
            "False \t True \t False \t False\n",
            "False \t False \t True \t False\n",
            "False \t False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VrBBui0TM6fL",
        "outputId": "1d31838f-d47d-4d31-edc4-90cf87a0218f"
      },
      "source": [
        "#Quiz 8\n",
        "#หาค่า A,B,C ที่ทำให้ (A&B)|(not(A)&C) = False\n",
        "\n",
        "U = (True,True,True),(True,True,False),(True,False,True),(True,False,False),\\\n",
        "(False,True,True),(False,True,False),(False,False,True),(False,False,False)\n",
        "\n",
        "\n",
        "print (\"  A\\t  B\\t  C\\t(A&B)|(not(A)&C)\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  C = i[2]\n",
        "  O = (A&B)|(not(A)&C)\n",
        "  if O==False:\n",
        "    print (A,\"\\t\",B,\"\\t\",C,\"\\t\",(A&B)|(not(A)&C))"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  A\t  B\t  C\t(A&B)|(not(A)&C)\n",
            "\n",
            "True \t False \t True \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-kk2_tTyU6d"
      },
      "source": [
        "#Example 5\n",
        "\n",
        "ตัวดำเนินการ -> (ถ้า..แล้ว)\n",
        "\n",
        "```\n",
        "A   B   A->B\n",
        "\n",
        "T   T     T\n",
        "T   F     F\n",
        "F   T     T\n",
        "F   F     T\n",
        "```\n",
        "\n",
        "โปรแกรมแสดงว่า A->B สามารถเขียนแทนด้วย not(A) or B\n",
        "\n",
        "หรือกล่าวได้ว่า A->B สมมูลกับ not (A) or B"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tZMuTrNgy7Ko",
        "outputId": "f80bd126-e007-463d-e54b-247258a4d426"
      },
      "source": [
        "#Example 5\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"A -> B = (not A) or B\\n\")\n",
        "print (\"  A\\t  B\\t(not A) or B\")\n",
        "print()\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  O = (not A) or B\n",
        "  \n",
        "  print (A,\"\\t\",B,\"\\t\",O)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A -> B = (not A) or B\n",
            "\n",
            "  A\t  B\t(not A) or B\n",
            "\n",
            "True \t True \t True\n",
            "True \t False \t False\n",
            "False \t True \t True\n",
            "False \t False \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E-nSEwRg9x9n"
      },
      "source": [
        "#Example 6\n",
        "\n",
        "A->B = (not A) or B\n",
        "\n",
        "เขียนฟังก์ชันสำหรับตัวดำเนินการ -> \n",
        "\n",
        "ให้ imply(A,B) = A->B\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5xX0agbQ90X2",
        "outputId": "535b029e-f706-458d-811a-84afff2268b9"
      },
      "source": [
        "#Example 6\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "imply = lambda x,y:not(x) or y\n",
        "\n",
        "print (\"A\\t  B\\tA->B\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  print (A,\"\\t\",B,\"\\t\",imply(A,B))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\t  B\tA->B\n",
            "\n",
            "True \t True \t True\n",
            "True \t False \t False\n",
            "False \t True \t True\n",
            "False \t False \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yzzJAKnNazXZ"
      },
      "source": [
        "#Example 7\n",
        "\n",
        "ตัวดำเนินการ <-> (ก็ต่อเมื่อ)\n",
        "\n",
        "```\n",
        "A   B   A<->B\n",
        "\n",
        "T   T     T\n",
        "T   F     F\n",
        "F   T     F\n",
        "F   F     T\n",
        "```\n",
        "\n",
        "ให้เขียนโปรแกรมแสดงผลของตัวดำเนินการ <->\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ga7Ipi_XbFFT",
        "outputId": "5b9e89d4-1566-40d6-9195-f00462586531"
      },
      "source": [
        "#Example 7\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"  A\\t  B\\tA <-> B\")\n",
        "print()\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  \n",
        "  print (A,\"\\t\",B,\"\\t\",A==B)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  A\t  B\tA <-> B\n",
            "\n",
            "True \t True \t True\n",
            "True \t False \t False\n",
            "False \t True \t False\n",
            "False \t False \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wsok1lCcYXW0"
      },
      "source": [
        "#Example 8\n",
        "\n",
        "จากตัวดำเนินการ <-> (ก็ต่อเมื่อ)\n",
        "```\n",
        "A   B   A<->B\n",
        "\n",
        "T   T     T\n",
        "T   F     F\n",
        "F   T     F\n",
        "F   F     T\n",
        "```\n",
        "\n",
        "\n",
        "ให้แสดงว่า A<->B สมมูลกับ (not A) or B  and  (not B) or A"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "npx2OyLYY-md",
        "outputId": "87b36f1c-7bc5-4441-f1db-77384a665289"
      },
      "source": [
        "#Example 8\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"O1 = A==B\")\n",
        "print (\"O2 = (not A) or B and (not B) or A\\n\")\n",
        "print (\"  A\\t  B\\t  O1\\t  O2\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  O1 = A==B\n",
        "  O2 = ((not A) or B) and ((not B) or A)\n",
        "  \n",
        "  print (A,\"\\t\",B,\"\\t\",O1,\"\\t\",O2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O1 = A==B\n",
            "O2 = (not A) or B and (not B) or A\n",
            "\n",
            "  A\t  B\t  O1\t  O2\n",
            "True \t True \t True \t True\n",
            "True \t False \t False \t False\n",
            "False \t True \t False \t False\n",
            "False \t False \t True \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VbJQdu1E0Ajw"
      },
      "source": [
        "#Example 9\n",
        "\n",
        "โปรแกรมแสดงว่า (not A) or B สมมูลกับ not(A and not (B))"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4pJpfcny_eRr",
        "outputId": "4217526d-9b4d-49a1-ba30-e853a30efa61"
      },
      "source": [
        "#Example 9\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"O1 = (not A) or B\")\n",
        "print (\"O2 = not(A and not(B))\\n\")\n",
        "print (\"  A\\t  B\\t  O1\\t  O2\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  O1 = (not A) or B\n",
        "  O2 = not(A and not(B))\n",
        "  print (A,\"\\t\",B,\"\\t\",O1,\"\\t\",O2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O1 = (not A) or B\n",
            "O2 = not(A and not(B))\n",
            "\n",
            "  A\t  B\t  O1\t  O2\n",
            "\n",
            "True \t True \t True \t True\n",
            "True \t False \t False \t False\n",
            "False \t True \t True \t True\n",
            "False \t False \t True \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MDL5uSOtrjBl"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MC9J2d1hrkb2"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d2glHak_1qEz"
      },
      "source": [
        "#Example 10\n",
        "\n",
        "โปรแกรมแสดงว่า (A or B) and (not(A and B)) \n",
        "สมมูลกับ (A and (not B)) or ((not A) and B)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sQCVCy8cCriJ",
        "outputId": "814052bb-9b3f-4fe7-b58c-c7932214386b"
      },
      "source": [
        "#Example 10\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"O1 = (A or B) and (not(A and B))\")\n",
        "print (\"O2 = (A and (not B)) or ((not A) and B)\\n\")\n",
        "print (\"  A\\t  B\\t  O1\\t  O2\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  O1 = (A or B) and (not(A and B))\n",
        "  O2 = (A and (not B)) or ((not A) and B)\n",
        "  print (A,\"\\t\",B,\"\\t\",O1,\"\\t\",O2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O1 = (A or B) and (not(A and B))\n",
            "O2 = (A and (not B)) or ((not A) and B)\n",
            "\n",
            "  A\t  B\t  O1\t  O2\n",
            "\n",
            "True \t True \t False \t False\n",
            "True \t False \t True \t True\n",
            "False \t True \t True \t True\n",
            "False \t False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A18FqXXew6ML"
      },
      "source": [
        "#Example 11\n",
        "\n",
        "โปรแกรมแสดงว่า A or (B and C)\n",
        "สมมูลกับ (A or B) and (A or C)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5o8qPNOfAH-Z",
        "outputId": "39674bd6-dac2-47fa-b4a6-f2452dd2fb2c"
      },
      "source": [
        "#Example 11\n",
        "\n",
        "U = (True,True,True),(True,True,False),(True,False,True),(True,False,False),\\\n",
        "(False,True,True),(False,True,False),(False,False,True),(False,False,False)\n",
        "\n",
        "print (\"O1 = A or (B and C)\")\n",
        "print (\"O2 = (A or B) and (A or C)\\n\")\n",
        "print (\"  A\\t  B\\t  C\\t  O1\\t  O2\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  C = i[2]\n",
        "\n",
        "  O1 = A or (B and C)\n",
        "  O2 = (A or B) and (A or C)\n",
        "  print (A,\"\\t\",B,\"\\t\",C,\"\\t\",O1,\"\\t\",O2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O1 = A or (B and C)\n",
            "O2 = (A or B) and (A or C)\n",
            "\n",
            "  A\t  B\t  C\t  O1\t  O2\n",
            "\n",
            "True \t True \t True \t True \t True\n",
            "True \t True \t False \t True \t True\n",
            "True \t False \t True \t True \t True\n",
            "True \t False \t False \t True \t True\n",
            "False \t True \t True \t True \t True\n",
            "False \t True \t False \t False \t False\n",
            "False \t False \t True \t False \t False\n",
            "False \t False \t False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5qmmx3Qy3YcW"
      },
      "source": [
        "#Example 12\n",
        "ถ้า (not (A and B)) and (not (A or B)) เป็น True แล้ว \n",
        "\n",
        "A and B *จะมีค่าเป็นอะไร*\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p-Wy_nrw3y0s",
        "outputId": "eb3a30ae-318c-4a44-c8eb-d222a48c65cc"
      },
      "source": [
        "#Example 12\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "\n",
        "print (\"O = (not (A and B)) and (not (A or B))\\n\")\n",
        "print (\" A\\t  B\\t  O\\n\")\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  O = (not (A & B)) & (not (A | B))\n",
        "  print (A,\"\\t\",B,\"\\t\",O)\n",
        "\n",
        "print()\n",
        "print (\"not (A & B)) & (not (A | B) = True เมื่อ A=False และ B=False\\n\")\n",
        "print (\"ดังนั้น\\n\")\n",
        "print (\"A(False) and B(False) = \", False&False )\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O = (not (A and B)) and (not (A or B))\n",
            "\n",
            " A\t  B\t  O\n",
            "\n",
            "True \t True \t False\n",
            "True \t False \t False\n",
            "False \t True \t False\n",
            "False \t False \t True\n",
            "\n",
            "not (A & B)) & (not (A | B) = True เมื่อ A=False และ B=False\n",
            "\n",
            "ดังนั้น\n",
            "\n",
            "A(False) and B(False) =  False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5L2GxFB263mz"
      },
      "source": [
        "#Example 13\n",
        "\n",
        "ถ้า (A -> B) -> (A -> (B and C)) เป็น False\n",
        "\n",
        "A, B, C มีค่าเป็นอะไรได้บ้าง"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q3l3rJgO7XSM",
        "outputId": "727083d9-045c-48b4-d05e-393f13d95df1"
      },
      "source": [
        "#Example 13\n",
        "\n",
        "U = (True,True,True),(True,True,False),(True,False,True),(True,False,False),\\\n",
        "(False,True,True),(False,True,False),(False,False,True),(False,False,False)\n",
        "\n",
        "imply = lambda x,y:not(x) or y\n",
        "\n",
        "print (\"เนื่องจาก A-> = not(A) or B = imply(A,B)\")\n",
        "print (\"ดังนั้น (A->B -> (A->(B and C)) = imply(imply(A,B),imply(A,(B&C)))\\n\")\n",
        "\n",
        "print (\"O1 = imply(imply(A,B),imply(A,(B&C)))\")\n",
        "print (\"O2 = not((not(A)|B) | ((not A)|(B&C)))\")\n",
        "\n",
        "print (\"O3 = ทำทีละขั้น โดย\\n \\\n",
        "  A1 = not (A) or B\\n \\\n",
        "  B1 = B and C\\n \\\n",
        "  A2 = not (A) or B1\\n \\\n",
        "  O3 = not (A1) or A2\\n \\\n",
        "  \")\n",
        "\n",
        "print (\"  A\\t  B\\t  C\\t  O1\\t  O2\\t  O3\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  C = i[2]\n",
        "\n",
        "  #O = (A -> B) -> (A -> (B and C))\n",
        "  O1 = not (not(A) or B) or (not(A) or (B and C))\n",
        "  O2 = imply(imply(A,B),imply(A,(B&C)))\n",
        "\n",
        "  A1 = not (A) or B\n",
        "  B1 = B and C\n",
        "  A2 = not (A) or B1\n",
        "  O3 = not (A1) or A2\n",
        "\n",
        "  print (A,\"\\t\",B,\"\\t\",C,\"\\t\",O1,\"\\t\",O2,\"\\t\",O3)\n",
        "\n",
        "print (\"\\nค่า A,B,C ที่ทำให้ (A -> B) -> (A -> (B and C)) = False คือ\\n\")\n",
        "print (\"A=True, B= True, C= False\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "เนื่องจาก A-> = not(A) or B = imply(A,B)\n",
            "ดังนั้น (A->B -> (A->(B and C)) = imply(imply(A,B),imply(A,(B&C)))\n",
            "\n",
            "O1 = imply(imply(A,B),imply(A,(B&C)))\n",
            "O2 = not((not(A)|B) | ((not A)|(B&C)))\n",
            "O3 = ทำทีละขั้น โดย\n",
            "   A1 = not (A) or B\n",
            "   B1 = B and C\n",
            "   A2 = not (A) or B1\n",
            "   O3 = not (A1) or A2\n",
            "   \n",
            "  A\t  B\t  C\t  O1\t  O2\t  O3\n",
            "\n",
            "True \t True \t True \t True \t True \t True\n",
            "True \t True \t False \t False \t False \t False\n",
            "True \t False \t True \t True \t True \t True\n",
            "True \t False \t False \t True \t True \t True\n",
            "False \t True \t True \t True \t True \t True\n",
            "False \t True \t False \t True \t True \t True\n",
            "False \t False \t True \t True \t True \t True\n",
            "False \t False \t False \t True \t True \t True\n",
            "\n",
            "ค่า A,B,C ที่ทำให้ (A -> B) -> (A -> (B and C)) = False คือ\n",
            "\n",
            "A=True, B= True, C= False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9jw5KgdMG4jQ"
      },
      "source": [
        "#Example 14\n",
        "\n",
        "จาก Example 13\n",
        "\n",
        "ถ้า (A -> B) -> (A -> (B and C)) เป็น False\n",
        "\n",
        "A, B, C มีค่าเป็นอะไรได้บ้าง แสดงผลเฉพาะค่าที่ตรงกับเงื่อนไข"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vtEARbsgHELJ",
        "outputId": "89a2cfee-660f-4036-f157-edb1126537f0"
      },
      "source": [
        "#Example 14\n",
        "\n",
        "U = (True,True,True),(True,True,False),(True,False,True),(True,False,False),\\\n",
        "(False,True,True),(False,True,False),(False,False,True),(False,False,False)\n",
        "\n",
        "imply = lambda x,y:not(x) or y #imply = ->\n",
        "\n",
        "print (\"O= (A->B)->(A->(B and C))\\n\")\n",
        "print (\"หา A,B,C เมื่อ O = False\\n\")\n",
        "print (\"  A\\t  B\\t  C\\t  O\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  C = i[2]\n",
        "\n",
        "  O = imply(imply(A,B),imply(A,(B&C)))\n",
        "  if O==False:\n",
        "    print (A,\"\\t\",B,\"\\t\",C,\"\\t\",O)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O= (A->B)->(A->(B and C))\n",
            "\n",
            "หา A,B,C เมื่อ O = False\n",
            "\n",
            "  A\t  B\t  C\t  O\n",
            "\n",
            "True \t True \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KJtALgmXUgRd"
      },
      "source": [
        "#Example 15\n",
        "\n",
        "โปรแกรมแสดงตารางความจริงของประพจน์ ((A and (not B)) -> not(A)) -> (A -> B)\n",
        "\n",
        "เป็นสัจจะนิรันดร์"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j4OAVN3NUxB4",
        "outputId": "35a3a35b-7aa4-419c-fe66-c8e3cf107c53"
      },
      "source": [
        "It#Example 15\n",
        "#find ((A and (not B)) -> not(A)) -> (A -> B)\n",
        " \n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "imply = lambda x,y:not(x) or y\n",
        " \n",
        "print (\"O=((A and (not B)) -> not(A)) -> (A -> B)\\n\")\n",
        "print (\" A\\t  B\\t  O\\n\")\n",
        " \n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        " \n",
        "  A1 = A and (not B)\n",
        "  A2 = not A\n",
        "  A3 = imply (A1,A2)\n",
        "  A4 = imply (A,B)\n",
        "  O = imply (A3,A4)\n",
        " \n",
        "  print (A,\"\\t\",B,\"\\t\",O)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O=((A and (not B)) -> not(A)) -> (A -> B)\n",
            "\n",
            " A\t  B\t  O\n",
            "\n",
            "True \t True \t True\n",
            "True \t False \t True\n",
            "False \t True \t True\n",
            "False \t False \t True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZENZKkkxYJTE"
      },
      "source": [
        "Example 16\n",
        "\n",
        "โปรแกรมแสดงว่า ((not A) -> B) == (A->B) \n",
        "\n",
        "สมมูลกับ B"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ip9via5NYkEr",
        "outputId": "b8a35057-ba6d-4d82-f7f5-93a6b56e03f1"
      },
      "source": [
        "#Example 16\n",
        "#find ((not A) -> B) == (A->B)\n",
        "\n",
        "U = (True,True),(True,False),(False,True),(False,False)\n",
        "imply = lambda x,y:not(x) or y\n",
        "\n",
        "print (\"O = ((not A) -> B) == (A->B)\\n\")\n",
        "print (\" A\\t  B\\t  O\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "\n",
        "  A1 = imply(not(A),B)\n",
        "  A2 = imply(A,B)\n",
        "  O = A1==A2\n",
        "\n",
        "  print (A,\"\\t\",B,\"\\t\",O)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O = ((not A) -> B) == (A->B)\n",
            "\n",
            " A\t  B\t  O\n",
            "\n",
            "True \t True \t True\n",
            "True \t False \t False\n",
            "False \t True \t True\n",
            "False \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CdR-QEG5GWOs",
        "outputId": "a222b629-73ba-4cfc-df78-6e8a646a83bf"
      },
      "source": [
        "#Example 13\n",
        "\n",
        "'''\n",
        "ถ้า (A -> B) -> (A -> (B and C)) เป็น False\n",
        "\n",
        "A, B, C มีค่าเป็นอะไรได้บ้าง\n",
        "'''\n",
        "\n",
        "U = (True,True,True),(True,True,False),(True,False,True),(True,False,False),\\\n",
        "(False,True,True),(False,True,False),(False,False,True),(False,False,False)\n",
        "\n",
        "imply = lambda x,y:not(x) or y\n",
        "\n",
        "print (\"เนื่องจาก A-> = not(A) or B = imply(A,B)\")\n",
        "print (\"ดังนั้น (A->B -> (A->(B and C)) = imply(imply(A,B),imply(A,(B&C)))\\n\")\n",
        "\n",
        "print (\"O = imply(imply(A,B),imply(A,(B&C)))\\n\")\n",
        "\n",
        "print (\"  A\\t  B\\t  C\\t  O\\t\\n\")\n",
        "\n",
        "for i in U:\n",
        "  A = i[0]\n",
        "  B = i[1]\n",
        "  C = i[2]\n",
        "\n",
        "  #O = (A -> B) -> (A -> (B and C))\n",
        "  O = imply(imply(A,B),imply(A,(B&C)))\n",
        "  if O==False:\n",
        "    print (A,\"\\t\",B,\"\\t\",C,\"\\t\",O)\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "เนื่องจาก A-> = not(A) or B = imply(A,B)\n",
            "ดังนั้น (A->B -> (A->(B and C)) = imply(imply(A,B),imply(A,(B&C)))\n",
            "\n",
            "O = imply(imply(A,B),imply(A,(B&C)))\n",
            "\n",
            "  A\t  B\t  C\t  O\t\n",
            "\n",
            "True \t True \t False \t False\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}