UIAI4012_pyswip_examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b7f33a5f-6a9c-4cd5-bbe5-0fb69b8bb360",
   "metadata": {},
   "source": [
    "## Introduction to Prolog\n",
    "\n",
    "- **Prolog (Programming in Logic) is a programming language based on logical reasoning and formal logic.**\n",
    "  - Example: `likes(john, pizza).` (This fact states that John likes pizza.)\n",
    "- **It was developed in the 1970s and is widely used in areas such as artificial intelligence, natural language processing, and expert systems.**\n",
    "  - Example: Prolog is used to build expert systems that provide medical diagnosis based on symptoms and patient data.\n",
    "- **Unlike traditional programming languages that focus on algorithms and procedures, Prolog focuses on declarative programming, where you specify what you want rather than how to achieve it.**\n",
    "  - Example: `parent(john, jim).` (This fact specifies that John is the parent of Jim without providing the details of how it is determined.)\n",
    "- **Prolog allows you to define facts, rules, and queries to solve problems using logical inference.**\n",
    "  - Example: `sibling(X, Y) :- parent(Z, X), parent(Z, Y), X \\= Y.` (This rule defines that X and Y are siblings if they share the same parent and are not the same person.)\n",
    "- **It excels in tasks that involve knowledge representation, pattern matching, and rule-based reasoning.**\n",
    "  - Example: Prolog can be used to build a knowledge base of animals and their characteristics and answer queries about them, such as \"Is a cat a mammal?\" or \"What are the characteristics of birds?\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a7fc506-436a-425a-af0c-4ea1c1b41480",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Key Features of Prolog\n",
    "\n",
    "1. **Logical Programming**: Prolog is based on logical reasoning, allowing you to define facts and rules using first-order logic. It leverages the power of formal logic to solve problems.\n",
    "   - Example: `mortal(X) :- human(X).` (This rule states that X is mortal if X is a human.)\n",
    "2. **Declarative Syntax**: In Prolog, you declare what you want to achieve rather than specifying a step-by-step procedure. You describe relationships and constraints, and Prolog's inference engine finds solutions.\n",
    "   - Example: `ancestor(X, Y) :- parent(X, Y).` (This rule declares that X is an ancestor of Y if X is a parent of Y.)\n",
    "3. **Pattern Matching**: Prolog uses pattern matching extensively. It matches facts and rules with the given queries to find solutions. It searches for combinations that satisfy the specified.\n",
    "   - Example: `animal(X) :- mammal(X).` (This rule matches X as an animal if X is a mammal.)\n",
    "\n",
    "These examples illustrate how Prolog is used to represent knowledge, define relationships, and find solutions through logical inference and pattern matching.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a69d18ba-0524-43b7-8999-b790b22c3b52",
   "metadata": {
    "tags": []
   },
   "source": [
    "## PySWIP: Python Interface for SWI-Prolog\n",
    "\n",
    "- PySWIP is a Python library that provides an interface to SWI-Prolog, allowing you to use Prolog within your Python programs.\n",
    "\n",
    "- SWI-Prolog is a widely used Prolog implementation that offers a powerful and efficient Prolog environment.\n",
    "\n",
    "- PySWIP enables seamless integration between Prolog and Python, leveraging the strengths of both languages.\n",
    "\n",
    "- With PySWIP, you can easily define Prolog rules, facts, and queries directly from your Python code.\n",
    "\n",
    "- PySWIP provides a bridge between Prolog and Python, allowing you to leverage the expressive power of Prolog for logical reasoning and knowledge representation, while harnessing the versatility and rich ecosystem of Python.\n",
    "\n",
    "- PySWIP is a valuable tool for tasks such as expert systems, natural language processing, constraint satisfaction problems, and more.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "245fd034-8152-49ee-b9d3-40740c3a4ee1",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Installing pyswip"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9bf3d75-e248-423a-8510-502d477ad75a",
   "metadata": {
    "tags": []
   },
   "source": [
    "- You can install pyswip, using the instructions from the follwing link:\n",
    "- https://pypi.org/project/pyswip/)`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b77d8ba-e333-40bf-8776-ff59d5502311",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting pyswip\n",
      "  Using cached pyswip-0.2.10-py2.py3-none-any.whl (27 kB)\n",
      "Installing collected packages: pyswip\n",
      "Successfully installed pyswip-0.2.10\n"
     ]
    }
   ],
   "source": [
    "!pip install pyswip"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3ea864f-7fcf-479b-9763-0850c8f1c562",
   "metadata": {
    "tags": []
   },
   "source": [
    "### First Example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "525c869a-7dba-4166-96fc-8e15a6f9a8dc",
   "metadata": {
    "tags": []
   },
   "source": [
    "- In the first cell of the notebook, import the required libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0cfb054d-b867-478f-b487-997f878c66d9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T00:14:17.764868200Z",
     "start_time": "2023-06-16T00:14:17.712973600Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from pyswip import Prolog"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "902d4667-75bd-47b9-b2fa-2629d13f4701",
   "metadata": {},
   "source": [
    "- Create an instance of the Prolog class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8dd074a7-2bbf-4302-a7e8-b20c3c5a7f86",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T00:14:18.934357500Z",
     "start_time": "2023-06-16T00:14:18.918251400Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "prolog = Prolog()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6555ae8f-413a-4483-977d-3eb4b71de195",
   "metadata": {},
   "source": [
    "- You can define your Prolog rules and facts using the assertz method. For example, let's define a simple rule:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "014344ed-548c-415a-8517-e7c64b2a8cb2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "prolog.assertz(\"parent(john, jim)\") # john is jim's parent\n",
    "prolog.assertz(\"parent(john, ann)\")\n",
    "prolog.assertz(\"parent(sue, jim)\") # sue is jim's parent\n",
    "prolog.assertz(\"parent(sue, ann)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f83d1d98-f3b0-4cc2-8d47-80a80ae08dd1",
   "metadata": {},
   "source": [
    "- you can query Prolog using the query method. For example, let's query for all the parents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0525ba82-2278-4a7f-81ed-ff10db4dadfd",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'X': 'john', 'Y': 'jim'},\n",
       " {'X': 'john', 'Y': 'ann'},\n",
       " {'X': 'sue', 'Y': 'jim'},\n",
       " {'X': 'sue', 'Y': 'ann'}]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"parent(X, Y)\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "08bb6968-39f2-4d52-afcd-8cf0f53ca370",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'Y': 'jim'}, {'Y': 'ann'}]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"parent(john, Y)\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1d7cc22a-7930-4d10-828f-956b5cc2763d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{}]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"parent(john, ann)\")) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b6fb8346-5b33-45df-9d02-257c136c1cd9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'X': 'john'}, {'X': 'sue'}]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"parent(X, ann)\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6b27ca51-2fa3-43a6-84db-c7d845474d42",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"parent(jim, hesam)\")) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4787556-c4b3-49aa-96bb-174e278362b2",
   "metadata": {},
   "source": [
    "- To iterate over the query results, you can use a for loop. For example, to print all the parents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e88e5793-9892-4a36-a96e-1cf38381c872",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "john is the parent of jim\n",
      "john is the parent of ann\n",
      "sue is the parent of jim\n",
      "sue is the parent of ann\n"
     ]
    }
   ],
   "source": [
    "for solution in prolog.query(\"parent(X, Y)\"):\n",
    "    print(solution[\"X\"], \"is the parent of\", solution[\"Y\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f16be62a-68bd-44ec-a31c-63a3d46ba71b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T00:14:22.989349400Z",
     "start_time": "2023-06-16T00:14:22.971340500Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define some example facts about fruits\n",
    "prolog.assertz(\"fruit(apple)\")\n",
    "prolog.assertz(\"fruit(banana)\")\n",
    "prolog.assertz(\"fruit(orange)\")\n",
    "prolog.assertz(\"fruit(mango)\")\n",
    "\n",
    "# Define some example rules to associate properties with fruits\n",
    "prolog.assertz(\"property(apple, red)\")\n",
    "prolog.assertz(\"property(apple, round)\")\n",
    "prolog.assertz(\"property(banana, red)\")\n",
    "prolog.assertz(\"property(banana, round)\")\n",
    "prolog.assertz(\"property(orange, orange)\")\n",
    "prolog.assertz(\"property(orange, round)\")\n",
    "prolog.assertz(\"property(mango, yellow)\")\n",
    "prolog.assertz(\"property(mango, oblong)\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "921ad18c-5e0d-469a-8620-37a92626d412",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T00:14:26.652167800Z",
     "start_time": "2023-06-16T00:14:26.640445300Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "properties = [\"red\", \"round\"]\n",
    "\n",
    "query = \"fruit(X), {}.\".format(\", \".join([\"property(X, {})\".format(prop) for prop in properties]))\n",
    "fruits = list(prolog.query(query))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cb69146c-b017-4529-81a4-3b4ad67205ec",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T00:14:29.836308900Z",
     "start_time": "2023-06-16T00:14:29.830760900Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fruits with properties: ['apple', 'banana']\n"
     ]
    }
   ],
   "source": [
    "print(\"Fruits with properties:\", [fruit[\"X\"] for fruit in fruits])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9dae457f-7e22-4334-b2cb-9c02d7bfaeef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'X': 'apple'}, {'X': 'banana'}, {'X': 'orange'}, {'X': 'mango'}]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"fruit(X)\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "13ba8e0c-7390-4844-b6fa-bba9c905fd86",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'X': 'apple', 'S': Variable(141), 'L': [Atom('301573'), Atom('90501')]},\n",
       " {'X': 'banana', 'S': Variable(141), 'L': [Atom('301573'), Atom('90501')]},\n",
       " {'X': 'orange', 'S': Variable(141), 'L': [Atom('486149'), Atom('90501')]},\n",
       " {'X': 'mango', 'S': Variable(76), 'L': [Atom('390277'), Atom('487557')]}]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(prolog.query(\"fruit(X), findall(S, property(X, S), L)\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5a3c5a85-d6c2-43be-a749-2ed5befc10a4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'X': 'apple',\n",
       "  'S': Variable(158),\n",
       "  'L': [Atom('301573'), Atom('90501')],\n",
       "  'R': [Atom('301573')],\n",
       "  'N': 1},\n",
       " {'X': 'banana',\n",
       "  'S': Variable(158),\n",
       "  'L': [Atom('301573'), Atom('90501')],\n",
       "  'R': [Atom('301573')],\n",
       "  'N': 1},\n",
       " {'X': 'orange',\n",
       "  'S': Variable(158),\n",
       "  'L': [Atom('486149'), Atom('90501')],\n",
       "  'R': [],\n",
       "  'N': 0},\n",
       " {'X': 'mango',\n",
       "  'S': Variable(76),\n",
       "  'L': [Atom('390277'), Atom('487557')],\n",
       "  'R': [],\n",
       "  'N': 0}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiple query\n",
    "list(prolog.query(\"fruit(X), findall(S, property(X, S), L), intersection(L, {}, R), length(R, N)\".format(['red'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1cc74f58-1190-4519-9b94-6719167793dc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'S': 'red'}, {'S': 'round'}]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find all atoms related to another atom\n",
    "fruits = ['apple', 'orange', 'banana']\n",
    "list(prolog.query(\"property({}, S).\".format(fruits[0])))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6c74d95-b5a7-42c4-8c07-a41d39c40773",
   "metadata": {},
   "source": [
    "### learn more:\n",
    "- Tutorials in https://www.swi-prolog.org/\n",
    "- https://www.swi-prolog.org/pldoc/man?predicate=intersection/3\n",
    "- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "227b9667-fad7-4707-820a-fcc752273c31",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  },
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}