FOLd.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FOLd.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyM0QNVahuPREfvXLP2U/0xU",
      "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/RK22000/FOLd/blob/main/FOLd.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction"
      ],
      "metadata": {
        "id": "wLsfkFRnByoo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This document is divided into 3 sections:\n",
        "\n",
        "1. Helper Methods\n",
        "\n",
        "        Has all the helper methods and their minor tests. (Skipable) (Please skip it, or rather only check it if you know which helper method you are looking for)\n",
        "1. Main Code\n",
        "    \n",
        "        Has the code for the main brains of the First Order Logic.\n",
        "1. Tests\n",
        "    \n",
        "        Shows the FOL engine at work with test cases. Can be checked before reading other sections.\n",
        "\n"
      ],
      "metadata": {
        "id": "Cf4PDHX7CMEP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "My reccommended way to read this document is from the bottom up. First start from the earliest test cases and read up to the higher test cases. By the time you reach the top you will have understood what the FOL_engine is. Then when you look into the FOL_engine in section 2, you will have an idea of what is being done and why. "
      ],
      "metadata": {
        "id": "pHugBqU74jaX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Section 1: Helper methods"
      ],
      "metadata": {
        "id": "hDo6NWDBBWkT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re"
      ],
      "metadata": {
        "id": "V3LreHXAFhxJ"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "re.findall(r'\\(.*\\)', \"Smart(x)(y)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gThEoHYWFfqJ",
        "outputId": "cf12a0a6-0af8-444c-8df0-847db162d135"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['(x)(y)']"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "re.findall(r'\\([^(]*\\)', \"Smart(x)(y)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "950d9847-8ff9-4e84-86fc-cd4a73f1ea46",
        "id": "4Z2oRCJRHb0P"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['(x)', '(y)']"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#match = re.findall(r'\\((?P<arguments>[^()]*)\\)', \"Smart(x, y) Clever(p, (q))\")\n",
        "b1 = r'\\(([^)(]*)\\)'\n",
        "b2 = r'\\(([^)(]*' + r'\\([^)(]\\)' + r'[^()]*)\\)'\n",
        "\n",
        "match = re.findall(b1+'|'+b2, \"Smart(x, y) Clever(p, (q))\")\n",
        "match#.group(\"arguments\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0160d593-f8a5-43e9-8413-d33498bb9c96",
        "id": "0DsKZltuIwz8"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('x, y', ''), ('', 'p, (q)')]"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "def getFuncArgs(predicate: str):\n",
        "    \"\"\"Get the first function and its set of arguments in the predicate.\n",
        "    Basically a text parser so \"\"\"\n",
        "    regex = re.compile(r'(?P<negation>~?)(?P<function>\\w+)\\((?P<arguments>[^()]*)\\)')\n",
        "    match = regex.search(predicate)\n",
        "    arguments = match.group(\"arguments\").split(',')\n",
        "    for i, argument in enumerate(arguments):\n",
        "        arguments[i] = argument.strip()\n",
        "    func = match.group(\"function\")\n",
        "    negation = match.group(\"negation\")\n",
        "    return func, arguments, negation\n"
      ],
      "metadata": {
        "id": "Rx2Kh-_aC8WM"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "getFuncArgs(\"~Smart(x, y)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kuhUVBFEP0TD",
        "outputId": "a7dbd521-1c50-48e3-b3a8-9422ba657542"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Smart', ['x', 'y'], '~')"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "def isFuncArgs(predicate: str):\n",
        "    \"\"\"Check if the predicate is something like a function with arguments\"\"\"\n",
        "    regex = re.compile(r'^(?P<function>~?\\w+)\\((?P<arguments>[^()]*)\\)$')\n",
        "    match = regex.search(predicate)\n",
        "    return True if match else False\n"
      ],
      "metadata": {
        "id": "yrYJiC9YT6uO"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "isFuncArgs(\"Smart(x)^Clever(x)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g0RwoGmyn9i7",
        "outputId": "86a8daaf-1d72-41b4-aeeb-c34dc3af01ed"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "isFuncArgs(\"abc\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kRL44GUOToep",
        "outputId": "191774d2-2d56-4c3a-a735-71fb337d62e1"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def validTerm(term: str):\n",
        "    regex = re.compile(r\"^[A-Za-z]+$\")\n",
        "    return True if regex.search(term) else False\n",
        "\n",
        "def groundTerm(term: str):\n",
        "    if not validTerm(term=term): return False\n",
        "    regex = re.compile(r\"^[a-z]+$\")\n",
        "    return True if regex.search(term) else False\n",
        "\n",
        "def constantTerm(term: str):\n",
        "    if not validTerm(term=term): return False\n",
        "    regex = re.compile(r\"^[A-Z][A-Za-z]+$\")\n",
        "    return True if regex.search(term) else False"
      ],
      "metadata": {
        "id": "fvvMT6eXVLs7"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "groundTerm('x'), constantTerm('RahulKan'), validTerm('XyZ')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "954wPIayV7X-",
        "outputId": "bdcb9f4f-80c8-4953-cd26-6d5ab9c54cd2"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(True, True, True)"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Issue: this does not see a problem in this case [x, x], [A, B]. x cant be A and B\n",
        "# For now the issue hasn't surfaced because I hadn't created a test case for this.\n",
        "def swapable(f_terms: list, p_terms: list):\n",
        "    count=0\n",
        "    if not len(f_terms) == len(p_terms): return False\n",
        "    for f_term, p_term in zip(f_terms, p_terms):\n",
        "        if groundTerm(f_term) or f_term==p_term:\n",
        "            count+=1\n",
        "    return count==len(f_terms)"
      ],
      "metadata": {
        "id": "9u5CcG6mjgEY"
      },
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "None == True, None == False"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gIMqsVcfoKf7",
        "outputId": "e8ee5257-8033-4262-cb96-a0e2a3d2c46e"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(False, False)"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def isRule(sentence: str):\n",
        "    return sentence.count(\"=>\") == 1"
      ],
      "metadata": {
        "id": "7MlphbOgxhCz"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "isRule(\" a => b\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zqnJFhkRxv9P",
        "outputId": "7684c895-6a4d-4686-eebc-26375937ad34"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def getCondImpl(sentence: str):\n",
        "    condition, implication = sentence.split(\"=>\")\n",
        "    return condition.strip(), implication.strip()"
      ],
      "metadata": {
        "id": "sE-QFrUJyL1H"
      },
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "getCondImpl(\" a ^ x=> b \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z3_ePNxNzSgi",
        "outputId": "c4dbae22-1749-40b2-91fe-2d7e814ac4e4"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('a ^ x', 'b')"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def swap_list(f_terms: list, p_terms: list): \n",
        "    \"\"\" Returns a dictionary that maps each ground term with the term to replace it \n",
        "    \"\"\"\n",
        "    swap = dict()\n",
        "    if not len(f_terms) == len(p_terms): return swap\n",
        "    for f_term, p_term in zip(f_terms, p_terms):\n",
        "        if groundTerm(f_term): \n",
        "            swap[f_term] = p_term\n",
        "    return swap"
      ],
      "metadata": {
        "id": "p_qx_p3v2oIB"
      },
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def replace_var(var: str, rpl: str, sentence:str) -> str:\n",
        "    def swap(match: re.Match):\n",
        "        #print(f'Match {match}')\n",
        "        return match.group()[0] + rpl + match.group()[-1]\n",
        "    wrapper = r\"[\\s)(,]\"\n",
        "    pattern = wrapper + f\"(?P<var>{var})\" + wrapper\n",
        "    return re.sub(pattern=pattern, repl=swap, string=sentence)"
      ],
      "metadata": {
        "id": "kvOMKDFV18xc"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "replace_var(\"y\", \"Azula\", \"Prodigy(y)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "FcvsHQhC37xJ",
        "outputId": "0da7dfde-8016-4909-90e7-d2e816c01020"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Prodigy(Azula)'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def conjunction(sentence: str) -> bool:\n",
        "    conjuncts = set( [conj.strip() for conj in sentence.split(\"^\")] )\n",
        "    return \"^\" in sentence and '' not in conjuncts"
      ],
      "metadata": {
        "id": "m04Eradjkm80"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "conjunction(\" a ^ B  ^ ^ x\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kV9d1RgrlAZd",
        "outputId": "085ac2ce-ed51-4ac3-8279-ffeffa93b1aa"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def getConjuncts(sentence: str) -> set:\n",
        "    return set([conj.strip() for conj in sentence.split(\"^\")])\n"
      ],
      "metadata": {
        "id": "3L_EaOuIlTh8"
      },
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "getConjuncts(\" a ^ B ^ x \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WXnoCe-Ol9Rk",
        "outputId": "04a228a8-ea43-46b2-899a-25dbe8995fd8"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'B', 'a', 'x'}"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Issue: this does not see a problem in this case [x, x], [A, B]. x cant be A and B\n",
        "# For now the issue hasn't surfaced because I hadn't created a test case for this.\n",
        "def unifyable(f_terms: list, p_terms: list):\n",
        "    count=0\n",
        "    if not len(f_terms) == len(p_terms): return False\n",
        "    for f_term, p_term in zip(f_terms, p_terms):\n",
        "        if groundTerm(f_term) or groundTerm(p_term) or f_term==p_term:\n",
        "            count+=1\n",
        "    return count==len(f_terms)"
      ],
      "metadata": {
        "id": "ON7SmNhHbVHT"
      },
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "unifyable([\"Aang\"], [\"x\"]), unifyable([\"g\"], [\"Aang\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ze3KePRJcWR1",
        "outputId": "31b95849-7fa7-41f2-e3e7-3ae8051a2098"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(True, True)"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def unified_arguments(f_terms: list, p_terms: list):\n",
        "    \"\"\" Returns a dictionary that maps each ground term with the term to replace it \n",
        "    \"\"\"\n",
        "    swap = dict()\n",
        "    if not len(f_terms) == len(p_terms): return swap\n",
        "    for f_term, p_term in zip(f_terms, p_terms):\n",
        "        if groundTerm(f_term):\n",
        "            swap[f_term] = p_term\n",
        "        elif groundTerm(p_term):\n",
        "            swap[p_term] = f_term\n",
        "    return swap"
      ],
      "metadata": {
        "id": "L4TG4vGPdudl"
      },
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Section 2: Main Code"
      ],
      "metadata": {
        "id": "ksi8zOjdBopU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "id": "HplyfgIi_Rb9"
      },
      "outputs": [],
      "source": [
        "class Fol_engine:\n",
        "    def __init__(self, facts: set = set(), rules: set = set()) -> None:\n",
        "        self.facts = facts\n",
        "        self.rules = rules\n",
        "\n",
        "    def trueCase(self, predicate: str):\n",
        "        \"\"\" This method uses getTrueCases to make an inference.\n",
        "        \"\"\"\n",
        "\n",
        "        # If the predicate is a conjunction, then split in and check if the individual parts are true\n",
        "        if conjunction(sentence=predicate):\n",
        "            conjuncts = getConjuncts(sentence=predicate)\n",
        "            print(f\"Conjunct of {conjuncts}\")\n",
        "            result = True\n",
        "            for conjunct in conjuncts:\n",
        "                val = self.trueCase(conjunct)\n",
        "                if val == False: # val may be False or None\n",
        "                    return False\n",
        "                elif val is None:\n",
        "                    result = None\n",
        "            return result\n",
        "\n",
        "        else:\n",
        "            cases = self.getCases(predicate=predicate)\n",
        "            if predicate in cases[True]: return True\n",
        "            elif predicate in cases[False]: return False\n",
        "            else: return None\n",
        "        \n",
        "\n",
        "\n",
        "    def getCases(self, predicate: str):\n",
        "        \"\"\" This method has the ability to guess.\n",
        "        It takes in a predicate and returns a dictionary mapped to 2 sets\n",
        "        \n",
        "        _key__|_set___________________________________________________________\n",
        "         True | A sets of true predicates where the ground terms in the original \n",
        "        ______|_predicates_have_been_substituted_with_some_constants__________\n",
        "        False | A sets of false predicates where the ground terms in the original \n",
        "        ______|_predicates_have_been_substituted_with_some_constants__________\n",
        "\n",
        "        You can see this in test case 8.0 and 8.0.2\n",
        "\n",
        "        This method also works if there are no ground terms. In which case it \n",
        "        just puts the predicate in either the true list or the false list\n",
        "\n",
        "        You can see this in 8.0.1\n",
        "\n",
        "        I'm not sure how to deal with conjunctions over here. I think I sould be \n",
        "        able to solve the Co. West problem (Test case 8.1) if I figure out how to \n",
        "        deal with conjunctions.\n",
        "        \"\"\"\n",
        "        if conjunction(sentence=predicate):\n",
        "            # I can split the conjunction and get cases for each conjunct, but I dont know what to do next\n",
        "            pass\n",
        "\n",
        "        # The predicate is like ~Abc(x, y)\n",
        "        if isFuncArgs(predicate):\n",
        "            p_func, p_arguments, p_negation = getFuncArgs(predicate) # Abc, [x, y], ~\n",
        "            print(f\"Getting cases for {predicate}\")\n",
        "            true_cases = set()\n",
        "            false_cases = set()\n",
        "            cases = {True: true_cases, False: false_cases}\n",
        "\n",
        "            # First look to see if we know a usefull fact\n",
        "            for fact in self.facts:\n",
        "                if isFuncArgs(fact):\n",
        "                    f_func, f_arguments, f_negation = getFuncArgs(fact)\n",
        "                    if f_func==p_func and len(p_arguments)==len(f_arguments):\n",
        "                        print(f'Fact Function match \\'{fact}\\'')\n",
        "                        if unifyable(f_terms=f_arguments, p_terms=p_arguments):\n",
        "                            print(f'Unifyable with {predicate}')\n",
        "                            swap = unified_arguments(f_terms=f_arguments, p_terms=p_arguments)\n",
        "                            unified = predicate\n",
        "                            for var in swap:\n",
        "                                unified = replace_var(var=var, rpl=swap[var], sentence=unified)\n",
        "                            mod = \"\" if f_negation==p_negation else \"not \"\n",
        "                            print(f'After unification {mod}{unified}')\n",
        "                            cases[f_negation==p_negation].add(unified)\n",
        "                        else:\n",
        "                            print(f'Not unifyable with {predicate}')\n",
        "\n",
        "            # If no Fact is helpfull then maybe a rule inference could be made\n",
        "            for rule in self.rules:\n",
        "                if isRule(rule): # A rule is like Abc(x, y) => Pqr(y)\n",
        "                    condition, implication = getCondImpl(rule) # Abc(x, y), Pqr(y)\n",
        "\n",
        "                    # If an implication matchs the predicate, then check if condition is true\n",
        "\n",
        "                    if isFuncArgs(implication):\n",
        "                        i_func, i_arguments, i_negation = getFuncArgs(implication)\n",
        "                        if i_func==p_func and len(i_arguments)==len(p_arguments):\n",
        "                            print(f'Rule match \\'{rule}\\' for \\'{predicate}\\'')\n",
        "                            \n",
        "                            if unifyable(f_terms=i_arguments, p_terms=p_arguments): # Implication matched\n",
        "                                print(f'{implication} unifyable with {predicate}')\n",
        "                                swap = unified_arguments(f_terms=i_arguments, p_terms=p_arguments)\n",
        "                                unified = predicate\n",
        "                                for var in swap:\n",
        "                                    unified = replace_var(var=var, rpl=swap[var], sentence=unified)\n",
        "                                    rule = replace_var(var=var, rpl=swap[var], sentence=rule)\n",
        "                                print(f'After unification {rule}')\n",
        "                                condition, implication = getCondImpl(rule)\n",
        "                                sub_cases = self.getCases(condition) # Breaks if condition is conjunction\n",
        "                                if condition in sub_cases[True]: # Condition matched\n",
        "                                    _, _, i_negation = getFuncArgs(implication)\n",
        "                                    cases[i_negation==p_negation].add(unified)\n",
        "                                print(sub_cases)\n",
        "\n",
        "            return cases \n",
        "        return None\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    def isTrue(self, predicate: str):\n",
        "        \"\"\"This method takes in a predicate and tries to figure out if the predicate is true.\n",
        "        \n",
        "        Can not work when inference requires making a guess about a ground term to see if the \n",
        "        predicate is true like in test 8.1. \n",
        "\n",
        "        I'm developing method getTrueCases to give the engine the ability to guess (Seen in test 8.0)\n",
        "        \"\"\"\n",
        "\n",
        "        # If the predicate is a conjunction, then split in and check if the individual parts are true\n",
        "        if conjunction(sentence=predicate):\n",
        "            conjuncts = getConjuncts(sentence=predicate)\n",
        "            print(f\"Conjunct of {conjuncts}\")\n",
        "            result = True\n",
        "            for conjunct in conjuncts:\n",
        "                val = self.isTrue(conjunct)\n",
        "                if val == False: # val may be False or None\n",
        "                    return False\n",
        "                elif val is None:\n",
        "                    result = None\n",
        "            return result # A single false makes the whole false, a single None makes the whole None if no false, else its true\n",
        "        \n",
        "\n",
        "        # The predicate is like ~Abc(x, y)\n",
        "        elif isFuncArgs(predicate):\n",
        "            p_func, p_arguments, p_negation = getFuncArgs(predicate) # Abc, [x, y], ~\n",
        "\n",
        "            for arg in p_arguments:\n",
        "                if groundTerm(arg):\n",
        "                    print(f'Predicate {predicate} has groundterm {arg}')\n",
        "                    #return\n",
        "\n",
        "            print(f\"Checking {predicate}\")\n",
        "\n",
        "            # First look to see if we know a usefull fact\n",
        "            for fact in self.facts:\n",
        "                if isFuncArgs(fact):\n",
        "                    f_func, f_arguments, f_negation = getFuncArgs(fact)\n",
        "                    if f_func==p_func and len(p_arguments)==len(f_arguments):\n",
        "                        print(f'Fact Function match \\'{p_func}\\'')\n",
        "                        print(f'p_arguments {p_arguments}, f_arguments {f_arguments}')\n",
        "\n",
        "                        if swapable(f_terms=f_arguments, p_terms=p_arguments):\n",
        "                            mod = \"\" if p_negation == f_negation else \"not \"\n",
        "                            print(f'Fact \\'{fact}\\' |=> {mod}{predicate}')\n",
        "                            return p_negation == f_negation\n",
        "                        else:\n",
        "                            print(f'Fact \\'{fact}\\' ?=> {predicate}')\n",
        "\n",
        "            # If no Fact is helpfull then maybe a rule inference could be made\n",
        "            for rule in self.rules:\n",
        "                if isRule(rule): # A rule is like Abc(x, y) => Pqr(y)\n",
        "                    condition, implication = getCondImpl(rule) # Abc(x, y), Pqr(y)\n",
        "\n",
        "                    # If an implication matchs the predicate, then check if condition is true\n",
        "                    \n",
        "                    if isFuncArgs(implication):  \n",
        "                        i_func, i_arguments, i_negation = getFuncArgs(implication)\n",
        "                        if i_func==p_func and len(i_arguments)==len(p_arguments):\n",
        "                            print(f'Rule match \\'{rule}\\' for \\'{predicate}\\'')\n",
        "\n",
        "                            if swapable(f_terms=i_arguments, p_terms=p_arguments): # Implication matched\n",
        "                                swap = swap_list(f_terms=i_arguments, p_terms=p_arguments)\n",
        "                                print(f'Swaping {swap}')\n",
        "\n",
        "                                for var in swap:\n",
        "                                    condition = replace_var(var=var, rpl=swap[var], sentence=condition)\n",
        "                                    rule = replace_var(var=var, rpl=swap[var], sentence=rule)\n",
        "                                \n",
        "                                print(f'Swapped condition \\'{condition}\\'')\n",
        "                                result = self.isTrue(condition) \n",
        "                                if result == True: # Condition matched\n",
        "                                    print(f'Rule {rule}')\n",
        "                                    return result if p_negation == i_negation else not result\n",
        "\n",
        "\n",
        "        return None # I know I dont need to specify this in python, but its helpfull to see where the unexpected None came from"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Section 3: Tests\n",
        "\n",
        "I think the easiest way to see what has been done is to start from the earliest tests at the bottom and read upwards.  "
      ],
      "metadata": {
        "id": "jPw-bGTKBuCF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test 8\n",
        "\n",
        "These tests are not cleared. They can be ignored if you are simply checking what has been done.\n",
        "\n",
        "If predicate has ground terms, then is doesn't make sense to ask is_true(predicate)\n",
        "\n",
        "Instead ask for a list of true predicates with ground terms filled in."
      ],
      "metadata": {
        "id": "lJqgvBQC_kiz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 8.2.1\") # Not passed\n",
        "def test():\n",
        "    facts = {\n",
        "        \"TeamAvatarMember(Sokka)\",\n",
        "        \"Scarcastic(Sokka)\",\n",
        "        \"Prodigy(Azula)\",\n",
        "        \"Villan(Azula)\",\n",
        "        \"Lethal(Azula)\",\n",
        "    }\n",
        "    rules = {\n",
        "        \"TeamAvatarMember(x) ^ Scarcastic(x) => Funny(x)\",\n",
        "        \"Villan(y) ^ Lethal(y) ^ Prodigy(y) => Scary(y)\", # Prodigy(y) swap y will swap y in both name and argument\n",
        "    }\n",
        "    engine_1 = Fol_engine(facts=facts, rules=rules)\n",
        "    print(engine_1.trueCase(\"Funny(Sokka) ^ Scary(Azula)\"))\n",
        "\n",
        "test()"
      ],
      "metadata": {
        "id": "KjY86OwAEdRr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 470
        },
        "outputId": "22c1cf61-a913-4ee4-b9b8-e7bc4b64142a"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 8.2.1\n",
            "Conjunct of {'Funny(Sokka)', 'Scary(Azula)'}\n",
            "Getting cases for Funny(Sokka)\n",
            "Rule match 'TeamAvatarMember(x) ^ Scarcastic(x) => Funny(x)' for 'Funny(Sokka)'\n",
            "Funny(x) unifyable with Funny(Sokka)\n",
            "After unification TeamAvatarMember(Sokka) ^ Scarcastic(Sokka) => Funny(Sokka)\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-73-2bfc6f4d9fab>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mengine_1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrueCase\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Funny(Sokka) ^ Scary(Azula)\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-73-2bfc6f4d9fab>\u001b[0m in \u001b[0;36mtest\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m     }\n\u001b[1;32m     14\u001b[0m     \u001b[0mengine_1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFol_engine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfacts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfacts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrules\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrules\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mengine_1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrueCase\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Funny(Sokka) ^ Scary(Azula)\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-72-754881941b48>\u001b[0m in \u001b[0;36mtrueCase\u001b[0;34m(self, predicate)\u001b[0m\n\u001b[1;32m     14\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mconjunct\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mconjuncts\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m                 \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrueCase\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconjunct\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mval\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# val may be False or None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-72-754881941b48>\u001b[0m in \u001b[0;36mtrueCase\u001b[0;34m(self, predicate)\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m             \u001b[0mcases\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetCases\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpredicate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpredicate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     25\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mpredicate\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcases\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m             \u001b[0;32melif\u001b[0m \u001b[0mpredicate\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcases\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-72-754881941b48>\u001b[0m in \u001b[0;36mgetCases\u001b[0;34m(self, predicate)\u001b[0m\n\u001b[1;32m    102\u001b[0m                                 \u001b[0mcondition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimplication\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetCondImpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m                                 \u001b[0msub_cases\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetCases\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Breaks if condition is conjunction\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m                                 \u001b[0;32mif\u001b[0m \u001b[0mcondition\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msub_cases\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# Condition matched\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    105\u001b[0m                                     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi_negation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetFuncArgs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimplication\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m                                     \u001b[0mcases\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi_negation\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mp_negation\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0munified\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not subscriptable"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 8.0.3\") # Passed\n",
        "\n",
        "print(\"\\n\\nTest 1\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(Sokka)\", \"Smart(Katara)\", \"Funny(Sokka)\", \"~Funny(Katara)\"})\n",
        "print( engine_1.trueCase(\"Funny(Sokka)\") )\n",
        "\n",
        "print(\"\\n\\nTest 2\")\n",
        "print( engine_1.trueCase(\"~Funny(Sokka)\") )\n",
        "\n",
        "print(\"\\n\\nTest 3\")\n",
        "print( engine_1.trueCase(\"Funny(Katara)\") )\n",
        "\n",
        "print(\"\\n\\nTest 4\")\n",
        "print( engine_1.trueCase(\"Funny(Sokka) ^ ~Funny(Katara)\") )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l3Nb6PthBzI1",
        "outputId": "63c97a83-78f2-462f-eee0-e8ed7da3edb2"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 8.0.3\n",
            "\n",
            "\n",
            "Test 1\n",
            "Getting cases for Funny(Sokka)\n",
            "Fact Function match 'Funny(Sokka)'\n",
            "Unifyable with Funny(Sokka)\n",
            "After unification Funny(Sokka)\n",
            "Fact Function match '~Funny(Katara)'\n",
            "Not unifyable with Funny(Sokka)\n",
            "True\n",
            "\n",
            "\n",
            "Test 2\n",
            "Getting cases for ~Funny(Sokka)\n",
            "Fact Function match 'Funny(Sokka)'\n",
            "Unifyable with ~Funny(Sokka)\n",
            "After unification not ~Funny(Sokka)\n",
            "Fact Function match '~Funny(Katara)'\n",
            "Not unifyable with ~Funny(Sokka)\n",
            "False\n",
            "\n",
            "\n",
            "Test 3\n",
            "Getting cases for Funny(Katara)\n",
            "Fact Function match 'Funny(Sokka)'\n",
            "Not unifyable with Funny(Katara)\n",
            "Fact Function match '~Funny(Katara)'\n",
            "Unifyable with Funny(Katara)\n",
            "After unification not Funny(Katara)\n",
            "False\n",
            "\n",
            "\n",
            "Test 4\n",
            "Conjunct of {'Funny(Sokka)', '~Funny(Katara)'}\n",
            "Getting cases for Funny(Sokka)\n",
            "Fact Function match 'Funny(Sokka)'\n",
            "Unifyable with Funny(Sokka)\n",
            "After unification Funny(Sokka)\n",
            "Fact Function match '~Funny(Katara)'\n",
            "Not unifyable with Funny(Sokka)\n",
            "Getting cases for ~Funny(Katara)\n",
            "Fact Function match 'Funny(Sokka)'\n",
            "Not unifyable with ~Funny(Katara)\n",
            "Fact Function match '~Funny(Katara)'\n",
            "Unifyable with ~Funny(Katara)\n",
            "After unification ~Funny(Katara)\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 8.0.2\") # Passed\n",
        "\n",
        "print(\"\\n\\nTest 1\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(Sokka)\", \"Smart(Katara)\", \"Funny(Sokka)\"})\n",
        "print( engine_1.getCases(\"Funny(x)\") )\n",
        "\n",
        "print(\"\\n\\nTest 2\")\n",
        "print( engine_1.getCases(\"Smart(x)\") )\n",
        "\n",
        "print(\"\\n\\nTest 3\")\n",
        "print( engine_1.getCases(\"Smart(x) ^ Funny(x)\") )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TEmVKdGc-imC",
        "outputId": "eee9061e-1c39-41bf-8c9f-aa9f30f7e9f5"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 8.0.2\n",
            "\n",
            "\n",
            "Test 1\n",
            "Getting cases for Funny(x)\n",
            "Fact Function match 'Funny(Sokka)'\n",
            "Unifyable with Funny(x)\n",
            "After unification Funny(Sokka)\n",
            "{True: {'Funny(Sokka)'}, False: set()}\n",
            "\n",
            "\n",
            "Test 2\n",
            "Getting cases for Smart(x)\n",
            "Fact Function match 'Smart(Sokka)'\n",
            "Unifyable with Smart(x)\n",
            "After unification Smart(Sokka)\n",
            "Fact Function match 'Smart(Katara)'\n",
            "Unifyable with Smart(x)\n",
            "After unification Smart(Katara)\n",
            "{True: {'Smart(Sokka)', 'Smart(Katara)'}, False: set()}\n",
            "\n",
            "\n",
            "Test 3\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 8.0.1\") # Passes\n",
        "\n",
        "print(\"Test 8.0.1.A\")\n",
        "engine_1 = Fol_engine(facts={\"Hostile(FireNation)\"}, rules={\"Hostile(x) => Enemy(x)\"})\n",
        "print( engine_1.getCases(\"Enemy(FireNation)\") )\n",
        "\n",
        "print(\"\\n\\nTest 8.0.1.B\")\n",
        "engine_1 = Fol_engine(facts={\"Hostile(FireNation)\"}, rules={\"Hostile(x) => Enemy(x)\"})\n",
        "print( engine_1.getCases(\"~Enemy(FireNation)\") )\n",
        "\n",
        "print(\"\\n\\nTest 8.0.1.C\")\n",
        "engine_1 = Fol_engine(facts={\"Friendly(AirNomads)\"}, rules={\"Friendly(x) => ~Enemy(x)\"})\n",
        "print( engine_1.getCases(\"Enemy(AirNomads)\") )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U8FweKC2nG_F",
        "outputId": "1401cbb4-e886-4e9c-b6fc-f25ad4c03df7"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 8.0.1\n",
            "Test 8.0.1.A\n",
            "Getting cases for Enemy(FireNation)\n",
            "Rule match 'Hostile(x) => Enemy(x)' for 'Enemy(FireNation)'\n",
            "Enemy(x) unifyable with Enemy(FireNation)\n",
            "After unification Hostile(FireNation) => Enemy(FireNation)\n",
            "Getting cases for Hostile(FireNation)\n",
            "Fact Function match 'Hostile(FireNation)'\n",
            "Unifyable with Hostile(FireNation)\n",
            "After unification Hostile(FireNation)\n",
            "{True: {'Hostile(FireNation)'}, False: set()}\n",
            "{True: {'Enemy(FireNation)'}, False: set()}\n",
            "\n",
            "\n",
            "Test 8.0.1.B\n",
            "Getting cases for ~Enemy(FireNation)\n",
            "Rule match 'Hostile(x) => Enemy(x)' for '~Enemy(FireNation)'\n",
            "Enemy(x) unifyable with ~Enemy(FireNation)\n",
            "After unification Hostile(FireNation) => Enemy(FireNation)\n",
            "Getting cases for Hostile(FireNation)\n",
            "Fact Function match 'Hostile(FireNation)'\n",
            "Unifyable with Hostile(FireNation)\n",
            "After unification Hostile(FireNation)\n",
            "{True: {'Hostile(FireNation)'}, False: set()}\n",
            "{True: set(), False: {'~Enemy(FireNation)'}}\n",
            "\n",
            "\n",
            "Test 8.0.1.C\n",
            "Getting cases for Enemy(AirNomads)\n",
            "Rule match 'Friendly(x) => ~Enemy(x)' for 'Enemy(AirNomads)'\n",
            "~Enemy(x) unifyable with Enemy(AirNomads)\n",
            "After unification Friendly(AirNomads) => ~Enemy(AirNomads)\n",
            "Getting cases for Friendly(AirNomads)\n",
            "Fact Function match 'Friendly(AirNomads)'\n",
            "Unifyable with Friendly(AirNomads)\n",
            "After unification Friendly(AirNomads)\n",
            "{True: {'Friendly(AirNomads)'}, False: set()}\n",
            "{True: set(), False: {'Enemy(AirNomads)'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 8.0\") # Passed\n",
        "\n",
        "facts={\n",
        "    \"TeamAvatarMember(Aang)\", \n",
        "    \"TeamAvatarMember(Sokka)\", \n",
        "    \"TeamAvatarMember(Katara)\", \n",
        "    \"TeamAvatarMember(Toph)\", \n",
        "    \"TeamAvatarMember(Suki)\",\n",
        "    \"~TeamAvatarMember(Bumi)\",\n",
        "    \"~TeamAvatarMember(Iroh)\"\n",
        "}\n",
        "\n",
        "engine_1 = Fol_engine(facts=facts)\n",
        "engine_1.isTrue(\"TeamAvatarMember(x)\")\n",
        "print( engine_1.getCases(\"TeamAvatarMember(x)\") )\n",
        "\n",
        "print(\"\\n\\nTest 8.0.B\")\n",
        "print( engine_1.getCases(\"~TeamAvatarMember(x)\") )\n",
        "\n",
        "print(\"\\n\\nTest 8.0.C\")\n",
        "print( engine_1.getCases(\"TeamAvatarMember(Toph)\") )\n",
        "\n",
        "print(\"\\n\\nTest 8.0.D\")\n",
        "print( engine_1.getCases(\"TeamAvatarMember(Bumi)\") )\n",
        "\n",
        "print(\"\\n\\nTest 8.0.E\")\n",
        "print( engine_1.getCases(\"~TeamAvatarMember(Iroh)\") )\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DVnk55I7NnTZ",
        "outputId": "f58f944e-0693-45c1-972a-d7c7e131585e"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 8.0\n",
            "Predicate TeamAvatarMember(x) has groundterm x\n",
            "Checking TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Toph']\n",
            "Fact 'TeamAvatarMember(Toph)' ?=> TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Katara']\n",
            "Fact 'TeamAvatarMember(Katara)' ?=> TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Sokka']\n",
            "Fact 'TeamAvatarMember(Sokka)' ?=> TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Suki']\n",
            "Fact 'TeamAvatarMember(Suki)' ?=> TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Bumi']\n",
            "Fact '~TeamAvatarMember(Bumi)' ?=> TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Aang']\n",
            "Fact 'TeamAvatarMember(Aang)' ?=> TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['x'], f_arguments ['Iroh']\n",
            "Fact '~TeamAvatarMember(Iroh)' ?=> TeamAvatarMember(x)\n",
            "Getting cases for TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember(Toph)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Katara)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification TeamAvatarMember(Katara)\n",
            "Fact Function match 'TeamAvatarMember(Sokka)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification TeamAvatarMember(Sokka)\n",
            "Fact Function match 'TeamAvatarMember(Suki)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification TeamAvatarMember(Suki)\n",
            "Fact Function match '~TeamAvatarMember(Bumi)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification not TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Aang)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification TeamAvatarMember(Aang)\n",
            "Fact Function match '~TeamAvatarMember(Iroh)'\n",
            "Unifyable with TeamAvatarMember(x)\n",
            "After unification not TeamAvatarMember(Iroh)\n",
            "{True: {'TeamAvatarMember(Toph)', 'TeamAvatarMember(Katara)', 'TeamAvatarMember(Sokka)', 'TeamAvatarMember(Suki)', 'TeamAvatarMember(Aang)'}, False: {'TeamAvatarMember(Bumi)', 'TeamAvatarMember(Iroh)'}}\n",
            "\n",
            "\n",
            "Test 8.0.B\n",
            "Getting cases for ~TeamAvatarMember(x)\n",
            "Fact Function match 'TeamAvatarMember(Toph)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification not ~TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Katara)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification not ~TeamAvatarMember(Katara)\n",
            "Fact Function match 'TeamAvatarMember(Sokka)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification not ~TeamAvatarMember(Sokka)\n",
            "Fact Function match 'TeamAvatarMember(Suki)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification not ~TeamAvatarMember(Suki)\n",
            "Fact Function match '~TeamAvatarMember(Bumi)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification ~TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Aang)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification not ~TeamAvatarMember(Aang)\n",
            "Fact Function match '~TeamAvatarMember(Iroh)'\n",
            "Unifyable with ~TeamAvatarMember(x)\n",
            "After unification ~TeamAvatarMember(Iroh)\n",
            "{True: {'~TeamAvatarMember(Bumi)', '~TeamAvatarMember(Iroh)'}, False: {'~TeamAvatarMember(Toph)', '~TeamAvatarMember(Sokka)', '~TeamAvatarMember(Aang)', '~TeamAvatarMember(Katara)', '~TeamAvatarMember(Suki)'}}\n",
            "\n",
            "\n",
            "Test 8.0.C\n",
            "Getting cases for TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Toph)'\n",
            "Unifyable with TeamAvatarMember(Toph)\n",
            "After unification TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Katara)'\n",
            "Not unifyable with TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Sokka)'\n",
            "Not unifyable with TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Suki)'\n",
            "Not unifyable with TeamAvatarMember(Toph)\n",
            "Fact Function match '~TeamAvatarMember(Bumi)'\n",
            "Not unifyable with TeamAvatarMember(Toph)\n",
            "Fact Function match 'TeamAvatarMember(Aang)'\n",
            "Not unifyable with TeamAvatarMember(Toph)\n",
            "Fact Function match '~TeamAvatarMember(Iroh)'\n",
            "Not unifyable with TeamAvatarMember(Toph)\n",
            "{True: {'TeamAvatarMember(Toph)'}, False: set()}\n",
            "\n",
            "\n",
            "Test 8.0.D\n",
            "Getting cases for TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Toph)'\n",
            "Not unifyable with TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Katara)'\n",
            "Not unifyable with TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Sokka)'\n",
            "Not unifyable with TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Suki)'\n",
            "Not unifyable with TeamAvatarMember(Bumi)\n",
            "Fact Function match '~TeamAvatarMember(Bumi)'\n",
            "Unifyable with TeamAvatarMember(Bumi)\n",
            "After unification not TeamAvatarMember(Bumi)\n",
            "Fact Function match 'TeamAvatarMember(Aang)'\n",
            "Not unifyable with TeamAvatarMember(Bumi)\n",
            "Fact Function match '~TeamAvatarMember(Iroh)'\n",
            "Not unifyable with TeamAvatarMember(Bumi)\n",
            "{True: set(), False: {'TeamAvatarMember(Bumi)'}}\n",
            "\n",
            "\n",
            "Test 8.0.E\n",
            "Getting cases for ~TeamAvatarMember(Iroh)\n",
            "Fact Function match 'TeamAvatarMember(Toph)'\n",
            "Not unifyable with ~TeamAvatarMember(Iroh)\n",
            "Fact Function match 'TeamAvatarMember(Katara)'\n",
            "Not unifyable with ~TeamAvatarMember(Iroh)\n",
            "Fact Function match 'TeamAvatarMember(Sokka)'\n",
            "Not unifyable with ~TeamAvatarMember(Iroh)\n",
            "Fact Function match 'TeamAvatarMember(Suki)'\n",
            "Not unifyable with ~TeamAvatarMember(Iroh)\n",
            "Fact Function match '~TeamAvatarMember(Bumi)'\n",
            "Not unifyable with ~TeamAvatarMember(Iroh)\n",
            "Fact Function match 'TeamAvatarMember(Aang)'\n",
            "Not unifyable with ~TeamAvatarMember(Iroh)\n",
            "Fact Function match '~TeamAvatarMember(Iroh)'\n",
            "Unifyable with ~TeamAvatarMember(Iroh)\n",
            "After unification ~TeamAvatarMember(Iroh)\n",
            "{True: {'~TeamAvatarMember(Iroh)'}, False: set()}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 8.1\") # Not Passed\n",
        "\n",
        "\"\"\"\n",
        "Fact 'Hostile(Nono)' ?=> Hostile(z)\n",
        "Under normal condition asking Hostile(z) would be interpretted as is everyone hostile, since z is a ground term and \n",
        "that means the predicate should remain true regardless of what the ground term is replaced with.\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "\n",
        "def test():\n",
        "    facts = {\n",
        "        \"American(CoWest)\",\n",
        "        \"Sells(CoWest, Missile, Nono)\",\n",
        "        \"Hostile(Nono)\",\n",
        "        \"Has(Nono, Missile)\",\n",
        "        \"Weapon(Missile)\",\n",
        "\n",
        "    }\n",
        "    rules = {\n",
        "        \"American(x) ^ Weapon(y) ^ Enemy(z) ^ Sold(x, y, z) => Criminal(x)\",\n",
        "        \"Hostile(w) => Enemy(w)\",\n",
        "        \"Sells(p, q, r) ^ Has(r, q) => Sold(p, q, r)\"\n",
        "    }\n",
        "    engine_1 = Fol_engine(facts=facts, rules=rules)\n",
        "    print(engine_1.isTrue(\"Criminal(CoWest)\"))\n",
        "\n",
        "test()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8c393402-1077-48c6-9879-b4ea0b4a9a6f",
        "id": "czeBXE_Z_ki1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 8.1\n",
            "Checking Criminal(CoWest)\n",
            "Rule match 'American(x) ^ Weapon(y) ^ Enemy(z) ^ Sold(x, y, z) => Criminal(x)' for 'Criminal(CoWest)'\n",
            "Swaping {'x': 'CoWest'}\n",
            "Swapped condition 'American(CoWest) ^ Weapon(y) ^ Enemy(z) ^ Sold(CoWest, y, z)'\n",
            "Conjunct of {'Enemy(z)', 'Weapon(y)', 'Sold(CoWest, y, z)', 'American(CoWest)'}\n",
            "Predicate Enemy(z) has groundterm z\n",
            "Checking Enemy(z)\n",
            "Rule match 'Hostile(w) => Enemy(w)' for 'Enemy(z)'\n",
            "Swaping {'w': 'z'}\n",
            "Swapped condition 'Hostile(z)'\n",
            "Predicate Hostile(z) has groundterm z\n",
            "Checking Hostile(z)\n",
            "Fact Function match 'Hostile'\n",
            "p_arguments ['z'], f_arguments ['Nono']\n",
            "Fact 'Hostile(Nono)' ?=> Hostile(z)\n",
            "Predicate Weapon(y) has groundterm y\n",
            "Checking Weapon(y)\n",
            "Fact Function match 'Weapon'\n",
            "p_arguments ['y'], f_arguments ['Missile']\n",
            "Fact 'Weapon(Missile)' ?=> Weapon(y)\n",
            "Predicate Sold(CoWest, y, z) has groundterm y\n",
            "Predicate Sold(CoWest, y, z) has groundterm z\n",
            "Checking Sold(CoWest, y, z)\n",
            "Rule match 'Sells(p, q, r) ^ Has(r, q) => Sold(p, q, r)' for 'Sold(CoWest, y, z)'\n",
            "Swaping {'p': 'CoWest', 'q': 'y', 'r': 'z'}\n",
            "Swapped condition 'Sells(CoWest, y, z) ^ Has(z, y)'\n",
            "Conjunct of {'Sells(CoWest, y, z)', 'Has(z, y)'}\n",
            "Predicate Sells(CoWest, y, z) has groundterm y\n",
            "Predicate Sells(CoWest, y, z) has groundterm z\n",
            "Checking Sells(CoWest, y, z)\n",
            "Fact Function match 'Sells'\n",
            "p_arguments ['CoWest', 'y', 'z'], f_arguments ['CoWest', 'Missile', 'Nono']\n",
            "Fact 'Sells(CoWest, Missile, Nono)' ?=> Sells(CoWest, y, z)\n",
            "Predicate Has(z, y) has groundterm z\n",
            "Predicate Has(z, y) has groundterm y\n",
            "Checking Has(z, y)\n",
            "Fact Function match 'Has'\n",
            "p_arguments ['z', 'y'], f_arguments ['Nono', 'Missile']\n",
            "Fact 'Has(Nono, Missile)' ?=> Has(z, y)\n",
            "Checking American(CoWest)\n",
            "Fact Function match 'American'\n",
            "p_arguments ['CoWest'], f_arguments ['CoWest']\n",
            "Fact 'American(CoWest)' |=> American(CoWest)\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test 7\n",
        "\n",
        "These tests (7 and below) have been passed and they demonstrate the current capabalities of my current FOL engine."
      ],
      "metadata": {
        "id": "KKysjLYexz-1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Test 7.1\")\n",
        "def test():\n",
        "    facts = {\n",
        "        \"TeamAvatarMember(Sokka)\",\n",
        "        \"Scarcastic(Sokka)\",\n",
        "        \"Prodigy(Azula)\",\n",
        "        \"Villan(Azula)\",\n",
        "        \"Lethal(Azula)\",\n",
        "    }\n",
        "    rules = {\n",
        "        \"TeamAvatarMember(x) ^ Scarcastic(x) => Funny(x)\",\n",
        "        \"Villan(y) ^ Lethal(y) ^ Prodigy(y) => Scary(y)\", # Prodigy(y) swap y will swap y in both name and argument\n",
        "    }\n",
        "    engine_1 = Fol_engine(facts=facts, rules=rules)\n",
        "    print(engine_1.isTrue(\"Funny(Sokka) ^ Scary(Azula)\"))\n",
        "\n",
        "test()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bgv8O0uvx8ou",
        "outputId": "9b7e04c7-defd-440d-d28b-3f2b4ec6bbe3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 7.1\n",
            "Conjunct of {'Scary(Azula)', 'Funny(Sokka)'}\n",
            "Checking Scary(Azula)\n",
            "Rule match 'Villan(y) ^ Lethal(y) ^ Prodigy(y) => Scary(y)' for 'Scary(Azula)'\n",
            "Swaping {'y': 'Azula'}\n",
            "Swapped condition 'Villan(Azula) ^ Lethal(Azula) ^ Prodigy(Azula)'\n",
            "Conjunct of {'Villan(Azula)', 'Lethal(Azula)', 'Prodigy(Azula)'}\n",
            "Checking Villan(Azula)\n",
            "Fact Function match 'Villan'\n",
            "p_arguments ['Azula'], f_arguments ['Azula']\n",
            "Fact 'Villan(Azula)' |=> Villan(Azula)\n",
            "Checking Lethal(Azula)\n",
            "Fact Function match 'Lethal'\n",
            "p_arguments ['Azula'], f_arguments ['Azula']\n",
            "Fact 'Lethal(Azula)' |=> Lethal(Azula)\n",
            "Checking Prodigy(Azula)\n",
            "Fact Function match 'Prodigy'\n",
            "p_arguments ['Azula'], f_arguments ['Azula']\n",
            "Fact 'Prodigy(Azula)' |=> Prodigy(Azula)\n",
            "Rule Villan(Azula) ^ Lethal(Azula) ^ Prodigy(Azula) => Scary(Azula)\n",
            "Checking Funny(Sokka)\n",
            "Rule match 'TeamAvatarMember(x) ^ Scarcastic(x) => Funny(x)' for 'Funny(Sokka)'\n",
            "Swaping {'x': 'Sokka'}\n",
            "Swapped condition 'TeamAvatarMember(Sokka) ^ Scarcastic(Sokka)'\n",
            "Conjunct of {'TeamAvatarMember(Sokka)', 'Scarcastic(Sokka)'}\n",
            "Checking TeamAvatarMember(Sokka)\n",
            "Fact Function match 'TeamAvatarMember'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'TeamAvatarMember(Sokka)' |=> TeamAvatarMember(Sokka)\n",
            "Checking Scarcastic(Sokka)\n",
            "Fact Function match 'Scarcastic'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Scarcastic(Sokka)' |=> Scarcastic(Sokka)\n",
            "Rule TeamAvatarMember(Sokka) ^ Scarcastic(Sokka) => Funny(Sokka)\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tests 6 and below"
      ],
      "metadata": {
        "id": "paM1HqE9x54Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Test 6\n",
        "# and now the engine understand 'and'\n",
        "print(\"\\nTest 1\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(Sokka)\", \"Funny(Sokka)\"})\n",
        "engine_1.isTrue(\"Smart(Sokka) ^ Funny(Sokka)\")\n",
        "\n",
        "print(\"\\nTest 2\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(x)\", \"Funny(Sokka)\"})\n",
        "engine_1.isTrue(\"Smart(Sokka) ^ Funny(Sokka)\")\n",
        "\n",
        "print(\"\\nTest 3\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(x)\", \"Funny(Sokka)\"})\n",
        "engine_1.isTrue(\"~Smart(Sokka) ^ Funny(Sokka)\")\n",
        "\n",
        "print(\"\\nTest 4\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(x)\", \"~Funny(Sokka)\"})\n",
        "engine_1.isTrue(\"Smart(Sokka) ^ Funny(Sokka)\")\n",
        "\n",
        "print(\"\\nTest 5\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(x)\", \"Funny(Sokka)\"})\n",
        "print(engine_1.isTrue(\"Smart(Sokka) ^ Funny(Azula)\"))\n",
        "\n",
        "print(\"\\nTest 6\")\n",
        "engine_1 = Fol_engine(facts={\"Smart(x)\", \"Funny(Sokka)\", \"~Funny(Azula)\"})\n",
        "print(engine_1.isTrue(\"Smart(Sokka) ^ Funny(Azula)\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fv2gzG2djkGN",
        "outputId": "a37cd488-de8a-40aa-d303-7cab9f46746d"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Test 1\n",
            "Conjunct of {'Funny(Sokka)', 'Smart(Sokka)'}\n",
            "Checking Funny(Sokka)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Funny(Sokka)' |=> Funny(Sokka)\n",
            "Checking Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Smart(Sokka)' |=> Smart(Sokka)\n",
            "\n",
            "Test 2\n",
            "Conjunct of {'Funny(Sokka)', 'Smart(Sokka)'}\n",
            "Checking Funny(Sokka)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Funny(Sokka)' |=> Funny(Sokka)\n",
            "Checking Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['x']\n",
            "Fact 'Smart(x)' |=> Smart(Sokka)\n",
            "\n",
            "Test 3\n",
            "Conjunct of {'Funny(Sokka)', '~Smart(Sokka)'}\n",
            "Checking Funny(Sokka)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Funny(Sokka)' |=> Funny(Sokka)\n",
            "Checking ~Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['x']\n",
            "Fact 'Smart(x)' |=> not ~Smart(Sokka)\n",
            "\n",
            "Test 4\n",
            "Conjunct of {'Funny(Sokka)', 'Smart(Sokka)'}\n",
            "Checking Funny(Sokka)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact '~Funny(Sokka)' |=> not Funny(Sokka)\n",
            "\n",
            "Test 5\n",
            "Conjunct of {'Funny(Azula)', 'Smart(Sokka)'}\n",
            "Checking Funny(Azula)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Azula'], f_arguments ['Sokka']\n",
            "Fact 'Funny(Sokka)' ?=> Funny(Azula)\n",
            "Checking Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['x']\n",
            "Fact 'Smart(x)' |=> Smart(Sokka)\n",
            "None\n",
            "\n",
            "Test 6\n",
            "Conjunct of {'Funny(Azula)', 'Smart(Sokka)'}\n",
            "Checking Funny(Azula)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Azula'], f_arguments ['Sokka']\n",
            "Fact 'Funny(Sokka)' ?=> Funny(Azula)\n",
            "Fact Function match 'Funny'\n",
            "p_arguments ['Azula'], f_arguments ['Azula']\n",
            "Fact '~Funny(Azula)' |=> not Funny(Azula)\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test 5\n",
        "# Bringing in rules so that the engine can do some implication logic\n",
        "\n",
        "print(\"\\nTest 1\")\n",
        "engine_1 = Fol_engine(facts={\"Clever(Sokka)\"}, rules={\"Clever(x) => Smart(x)\"})\n",
        "print( engine_1.isTrue(\"Smart(Sokka)\") )\n",
        "\n",
        "\n",
        "print(\"\\nTest 2\")\n",
        "engine_1 = Fol_engine(facts={\"Clever(y)\"}, rules={\"Clever(x) => Smart(x)\"})\n",
        "print( engine_1.isTrue(\"Smart(Sokka)\") )\n",
        "\n",
        "print(\"\\nTest 3\")\n",
        "engine_1 = Fol_engine(facts={\"Clever(y)\"}, rules={\"Clever(x) => ~Silly(x)\"})\n",
        "print( engine_1.isTrue(\"Silly(Sokka)\") )\n",
        "\n",
        "print(\"\\nTest 4\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(Sokka)\"}, rules={\"Clever(x) => Smart(x)\"})\n",
        "print( engine_1.isTrue(\"Smart(Sokka)\") )\n",
        "\n",
        "print(\"\\nTest 5\")\n",
        "engine_1 = Fol_engine(facts={\"Clever(Sokka)\"}, rules={\"~Clever(x) => Smart(x)\"})\n",
        "print( engine_1.isTrue(\"Smart(Sokka)\") )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "722GPWW4wJof",
        "outputId": "8ad06c90-d055-4944-b6a6-971acf4a568e"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Test 1\n",
            "Checking Smart(Sokka)\n",
            "Rule match 'Clever(x) => Smart(x)' for 'Smart(Sokka)'\n",
            "Swaping {'x': 'Sokka'}\n",
            "Swapped condition 'Clever(Sokka)'\n",
            "Checking Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Clever(Sokka)' |=> Clever(Sokka)\n",
            "Rule Clever(Sokka) => Smart(Sokka)\n",
            "True\n",
            "\n",
            "Test 2\n",
            "Checking Smart(Sokka)\n",
            "Rule match 'Clever(x) => Smart(x)' for 'Smart(Sokka)'\n",
            "Swaping {'x': 'Sokka'}\n",
            "Swapped condition 'Clever(Sokka)'\n",
            "Checking Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['y']\n",
            "Fact 'Clever(y)' |=> Clever(Sokka)\n",
            "Rule Clever(Sokka) => Smart(Sokka)\n",
            "True\n",
            "\n",
            "Test 3\n",
            "Checking Silly(Sokka)\n",
            "Rule match 'Clever(x) => ~Silly(x)' for 'Silly(Sokka)'\n",
            "Swaping {'x': 'Sokka'}\n",
            "Swapped condition 'Clever(Sokka)'\n",
            "Checking Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['y']\n",
            "Fact 'Clever(y)' |=> Clever(Sokka)\n",
            "Rule Clever(Sokka) => ~Silly(Sokka)\n",
            "False\n",
            "\n",
            "Test 4\n",
            "Checking Smart(Sokka)\n",
            "Rule match 'Clever(x) => Smart(x)' for 'Smart(Sokka)'\n",
            "Swaping {'x': 'Sokka'}\n",
            "Swapped condition 'Clever(Sokka)'\n",
            "Checking Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact '~Clever(Sokka)' |=> not Clever(Sokka)\n",
            "None\n",
            "\n",
            "Test 5\n",
            "Checking Smart(Sokka)\n",
            "Rule match '~Clever(x) => Smart(x)' for 'Smart(Sokka)'\n",
            "Swaping {'x': 'Sokka'}\n",
            "Swapped condition '~Clever(Sokka)'\n",
            "Checking ~Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Clever(Sokka)' |=> not ~Clever(Sokka)\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test 4\n",
        "# I've added negation into the mix\n",
        "\n",
        "print(\"\\nTest 1\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(Sokka)\"})\n",
        "print( engine_1.isTrue(\"Clever(Sokka)\") ) # False because it is known that Sokka is not Clever\n",
        "\n",
        "print(\"\\nTest 2\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(Sokka)\"})\n",
        "print( engine_1.isTrue(\"~Clever(Sokka)\") )\n",
        "\n",
        "print(\"\\nTest 3\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(x)\"})\n",
        "print( engine_1.isTrue(\"Clever(Sokka)\") ) # False because it is known that everyone is not clever\n",
        "\n",
        "print(\"\\nTest 4\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(x)\"})\n",
        "print( engine_1.isTrue(\"~Clever(Sokka)\") )\n",
        "\n",
        "print(\"\\nTest 5\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(Sokka)\"})\n",
        "print( engine_1.isTrue(\"Clever(x)\") ) # No idea about everyone, engine just knows about Sokka\n",
        "\"\"\"                                  Future Rahul here:\n",
        "                                        This way of using ground terms kinda comes back to bite me\n",
        "                                        I dont have a way to ask for what cases would make this predicate \n",
        "                                        true or false. \n",
        "\"\"\"\n",
        "\n",
        "print(\"\\nTest 6\")\n",
        "engine_1 = Fol_engine(facts={\"~Clever(Sokka)\"})\n",
        "print( engine_1.isTrue(\"~Clever(x)\") )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cezP2IlLo3Vv",
        "outputId": "2dbeca87-2d94-4a49-d58a-eccb708cd7a4"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Test 1\n",
            "Checking Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact '~Clever(Sokka)' |=> not Clever(Sokka)\n",
            "False\n",
            "\n",
            "Test 2\n",
            "Checking ~Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact '~Clever(Sokka)' |=> ~Clever(Sokka)\n",
            "True\n",
            "\n",
            "Test 3\n",
            "Checking Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['x']\n",
            "Fact '~Clever(x)' |=> not Clever(Sokka)\n",
            "False\n",
            "\n",
            "Test 4\n",
            "Checking ~Clever(Sokka)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['Sokka'], f_arguments ['x']\n",
            "Fact '~Clever(x)' |=> ~Clever(Sokka)\n",
            "True\n",
            "\n",
            "Test 5\n",
            "Predicate Clever(x) has groundterm x\n",
            "Checking Clever(x)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['x'], f_arguments ['Sokka']\n",
            "Fact '~Clever(Sokka)' ?=> Clever(x)\n",
            "None\n",
            "\n",
            "Test 6\n",
            "Predicate ~Clever(x) has groundterm x\n",
            "Checking ~Clever(x)\n",
            "Fact Function match 'Clever'\n",
            "p_arguments ['x'], f_arguments ['Sokka']\n",
            "Fact '~Clever(Sokka)' ?=> ~Clever(x)\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " # Test 3\n",
        "# Just checking if the the engine still works with multi argument predicates\n",
        "\n",
        "print('Test 1')\n",
        "engine_1 = Fol_engine(facts={\"Has(x, Pen)\"})\n",
        "engine_1.isTrue(\"Has(Sokka, Pen)\")\n",
        "\n",
        "print('Test 2')\n",
        "engine_1 = Fol_engine(facts={\"OwnedBy(Pen, x)\"})\n",
        "engine_1.isTrue(\"OwnedBy(Pen, Sokka)\") "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d1102be-99ca-4788-9541-268549b6dd22",
        "id": "0HjfM2hoguG1"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 1\n",
            "Checking Has(Sokka, Pen)\n",
            "Fact Function match 'Has'\n",
            "p_arguments ['Sokka', 'Pen'], f_arguments ['x', 'Pen']\n",
            "Fact 'Has(x, Pen)' |=> Has(Sokka, Pen)\n",
            "Test 2\n",
            "Checking OwnedBy(Pen, Sokka)\n",
            "Fact Function match 'OwnedBy'\n",
            "p_arguments ['Pen', 'Sokka'], f_arguments ['Pen', 'x']\n",
            "Fact 'OwnedBy(Pen, x)' |=> OwnedBy(Pen, Sokka)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " # Test 2\n",
        "'''\n",
        "Engine should unify \"Smart(Rahul)\" with \"Smart(x)\"\n",
        "first recognize \"Smart(x)\" is FuncArg\n",
        "then recognize argument x is ground term, so itmight be unified with something\n",
        "try to unify:\n",
        "    success: is this the result?\n",
        "    fail: move on\n",
        "'''\n",
        "\n",
        "print('Test 1')\n",
        "engine_1 = Fol_engine(facts={\"Smart(x)\"})  # for all x, Smart(x) is true\n",
        "engine_1.isTrue(\"Smart(Sokka)\")\n",
        "\n",
        "print(\"\\nTest 2\")\n",
        "engine_1 = Fol_engine(facts={\"Clever(x)\", \"Smart(y)\"})\n",
        "engine_1.isTrue(\"Smart(Sokka)\")\n",
        "\n",
        "print(\"\\nTest 3\")\n",
        "engine_1 = Fol_engine(facts={\"Clever(x)\"}) # Only known fact is that everyone is Clever\n",
        "engine_1.isTrue(\"Smart(Sokka)\") == None # No idea about being Smart"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mbKRu0znCi_d",
        "outputId": "19709abe-f0ef-40c0-fe4f-8b6d8fcdb27f"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test 1\n",
            "Checking Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['x']\n",
            "Fact 'Smart(x)' |=> Smart(Sokka)\n",
            "\n",
            "Test 2\n",
            "Checking Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['y']\n",
            "Fact 'Smart(y)' |=> Smart(Sokka)\n",
            "\n",
            "Test 3\n",
            "Checking Smart(Sokka)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test 1\n",
        "engine_1 = Fol_engine(facts={\"Smart(Sokka)\"}) # Known Fact Sokka is smart\n",
        "engine_1.isTrue(\"Smart(Sokka)\") # Engine can confidently say that Sokka is indeed smart"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fBQ9mYl6BEOq",
        "outputId": "fa6ab5c3-f174-4ac8-ac37-e5f2d0c6e8c6"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Checking Smart(Sokka)\n",
            "Fact Function match 'Smart'\n",
            "p_arguments ['Sokka'], f_arguments ['Sokka']\n",
            "Fact 'Smart(Sokka)' |=> Smart(Sokka)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    }
  ]
}