{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a4c93ebd",
   "metadata": {},
   "source": [
    "# CLIPS Constructs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7b1132e",
   "metadata": {},
   "source": [
    "* Install **clipspy 1.0.5 version, updated on 17 March 2025** for integrating with **CLIPS**\n",
    "* This integration is able to create interactive solution.\n",
    "* References: https://clipspy.readthedocs.io/en/latest/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3beb03ea",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pip install clipspy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65600576",
   "metadata": {},
   "source": [
    "## Section A: Basic CLIPS Working Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37964653",
   "metadata": {},
   "source": [
    "* Example below shows how to **setup working environment** in **clipspy**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa39309b",
   "metadata": {},
   "source": [
    "1. **Basic environment**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d972af8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Reset the environment:\n",
    "# Method 1: Call the reset function.\n",
    "#env.reset()\n",
    "\n",
    "# Method 2: Same command in CLIPS\n",
    "env.eval(\"(reset)\")\n",
    "\n",
    "# Inference:\n",
    "# Method 1: Call the run function.\n",
    "#env.run()\n",
    "\n",
    "# Method 2: Same command in CLIPS\n",
    "env.eval(\"(run)\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "511a1577",
   "metadata": {},
   "source": [
    "2. **Saving** to the extension of clp file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df3d3c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define a rule\n",
    "env.build(\"\"\"(defrule my-rule\n",
    "              =>\n",
    "             (printout t \"Hello, World!\" crlf))\"\"\")\n",
    "\n",
    "# Save the current environment to a file\n",
    "env.save(\"p-clip.clp\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "782430db",
   "metadata": {},
   "source": [
    "3. **Loading** from the extension of clp file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "917b0c41",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Load CLIPS file\n",
    "env.load('p-clip.clp')\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Inference\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c5bf3d3",
   "metadata": {},
   "source": [
    "## Section B: Manipulate Fact(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "879b4a6e",
   "metadata": {},
   "source": [
    "* **Define Ordered Fact(s)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eebb46d3",
   "metadata": {},
   "source": [
    "1. Add **initial fact(s)** to **working memory** and **display fact(s)**.<br> \n",
    "   Initial fact(s) are added when **(reset)** is called.<br> \n",
    "   Can be used for define **more than one fact**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4082eab",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "\n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Add intitial fact(s) to working memory\n",
    "env.build('(deffacts initial-state (system-status ready))')\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Inference\n",
    "env.run()\n",
    "\n",
    "# Display facts:\n",
    "# Method 1: Cycle through the facts()\n",
    "# for fact in env.facts():\n",
    "#     print(fact)\n",
    "\n",
    "# Method 2: Same command in CLIPS\n",
    "env.eval(\"(facts)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5a56bbb",
   "metadata": {},
   "source": [
    "2. Add a **fact** to working memory at **runtime**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b94abea3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a fact to working memory\n",
    "env.assert_string(\"(I fall in love expert system!)\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n",
    "\n",
    "# Display facts\n",
    "for fact in env.facts():\n",
    "    print(fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48dc8bb5",
   "metadata": {},
   "source": [
    "3. Remove/**retract fact(s)** in **runtime**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2962828",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Modify a fact to working memory\n",
    "env.assert_string(\"(I fall in love!)\")\n",
    "env.assert_string(\"(He fall in love either!)\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n",
    "\n",
    "# Remove/retract the 2nd fact\n",
    "# Method 1: Cycle through the facts()\n",
    "# for index,fact in enumerate(env.facts(),start=0):\n",
    "#     if index == 1:\n",
    "#         fact.retract()    \n",
    "        \n",
    "# Method 2: Same command in CLIPS\n",
    "env.eval(\"(retract 2)\")\n",
    "        \n",
    "# Inference\n",
    "env.run()\n",
    "\n",
    "# Check again the facts\n",
    "for fact in env.facts():\n",
    "    print(fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2de68822",
   "metadata": {},
   "source": [
    "* **Unordered Fact(s)**\n",
    "  * A **deftemplate** is used to describe groups of facts sharing the same relation name and contain common information.\n",
    "  * **Unordered fact** is the actual data entries that adhere to defined template.\n",
    "  * **deftemplate** is stored in **knowledge base** and **unordered fact** is stored in **working memory**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2216f98b",
   "metadata": {},
   "source": [
    "1. Define a template (**deftemplate**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00b90372",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define template in knowledge base\n",
    "env.build(\"\"\"(deftemplate student\n",
    "                (slot name)\n",
    "                (slot age)\n",
    "                (slot major))\"\"\")\n",
    "\n",
    "# Add facts to working memory\n",
    "\n",
    "env.assert_string(\"\"\"(student (name \"Jolin Tsai\")\n",
    "                              (age 40)\n",
    "                              (major \"Music Education\"))\"\"\")\n",
    "\n",
    "# Method 1: assert_string function \n",
    "# env.assert_string(\"\"\"(student (name \"Ooi Ci Jie\")\n",
    "#                               (age 18)\n",
    "#                               (major \"Information Technology\"))\"\"\")\n",
    "\n",
    "# Method 2: Same command in CLIPS \n",
    "env.eval(\"\"\"(assert (student (name \"Ooi Ci Jie\")\n",
    "                              (age 18)\n",
    "                              (major \"Information Technology\")))\"\"\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n",
    "\n",
    "# Display facts (template)\n",
    "for fact in env.facts():\n",
    "    if fact.template.name == 'student':\n",
    "        print('Name:' + fact['name'])\n",
    "        print('Age:' + str(fact['age']))\n",
    "        print('Major:' + str(fact['major']))\n",
    "        print(' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4241aa47",
   "metadata": {},
   "source": [
    "2. Modify **slots**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "218b19a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modify slots:\n",
    "# Method 1: Modify through the facts()\n",
    "# for index, fact in enumerate(env.facts(), start=0):\n",
    "#     if index == 0:\n",
    "#         fact.modify_slots(name='James')\n",
    "#     if fact.template.name == 'student':\n",
    "#         print('Name:' + fact['name'])\n",
    "#         print('Age:' + str(fact['age']))\n",
    "#         print('Major:' + str(fact['major']))\n",
    "#         print(' ')\n",
    "\n",
    "# Method 2: Same command in CLIPS \n",
    "env.eval(\"(modify 1 (name 'James'))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2330d277",
   "metadata": {},
   "source": [
    "## Section C: Define Rule(s) using defrule"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22121cc5",
   "metadata": {},
   "source": [
    "* **Define Rule(s)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b073d73",
   "metadata": {},
   "source": [
    "1. Define a **rule** in **knowledge base**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cbf864c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define a rule in knowledge base\n",
    "env.build('(defrule my-rule => (printout t \"My Rule fired!\" crlf))')\n",
    "\n",
    "# Reset\n",
    "env.reset()\n",
    "\n",
    "# Add a fact to working memory\n",
    "# Method 1: assert_string function \n",
    "#env.assert_string(\"(my-fact)\")\n",
    "\n",
    "# Method 2: Same command in CLIPS \n",
    "env.eval(\"(assert (my-fact))\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51066aa0",
   "metadata": {},
   "source": [
    "2. Define **rules** to representing **recipe knowledge base**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee51e6f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define rules in knowledge base\n",
    "env.build(\"\"\"(defrule omelette\n",
    "                (eggs)\n",
    "             =>\n",
    "             (printout t \"You can make an Omelette!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule egg-sandwich\n",
    "                (eggs)\n",
    "                (bread)\n",
    "             =>\n",
    "             (printout t \"You can make Egg sandwich!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule pancakes\n",
    "                (eggs)\n",
    "                (milk)\n",
    "                (flour)\n",
    "                (margarine)\n",
    "              =>\n",
    "            (printout t \"You can make Pancakes!\" crlf))\"\"\")\n",
    "\n",
    "\n",
    "# Reset\n",
    "env.reset()\n",
    "\n",
    "# Add facts to working memory\n",
    "# Remove the comment and see the effect 1. Explain why?\n",
    "#env.assert_string('(eggs)(bread)')\n",
    "\n",
    "# Remove the comment and see the effect 2\n",
    "#env.eval('(assert (eggs)(bread))')\n",
    "\n",
    "# Remove the comment and see the effect 3\n",
    "#env.assert_string('(eggs)')\n",
    "#env.assert_string('(bread)')\n",
    "\n",
    "# Inference\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb5a5d4e",
   "metadata": {},
   "source": [
    "3. Example from notes of lecture 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c80b2b05",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define a template\n",
    "env.build(\"\"\"(deftemplate mood\n",
    "               (slot condition))\"\"\")\n",
    "\n",
    "# Define rules\n",
    "env.build(\"\"\"(defrule R1\n",
    "               (mood (condition bad))\n",
    "             =>\n",
    "             (printout t \"keep quiet!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R2\n",
    "               (mood (condition bad))\n",
    "             =>\n",
    "             (printout t \"buy her lunch..!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R3\n",
    "               (mood (condition happy))\n",
    "             =>\n",
    "             (printout t \"cinema with her!\" crlf))\"\"\")\n",
    "\n",
    "# Reset\n",
    "env.reset()\n",
    "\n",
    "# Assert a fact to working memory\n",
    "env.assert_string(\"(mood (condition bad))\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5486562a",
   "metadata": {},
   "source": [
    "3. Define **rules** in **logical AND**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbafba14",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Implicitly define the rule to print \"AND Logic ABC\" if facts A, B, and C are present\n",
    "env.build(\"\"\"(defrule ABC\n",
    "               (A)\n",
    "               (B)\n",
    "               (C)\n",
    "              =>\n",
    "             (printout t \"AND Logic - ABC\" crlf))\n",
    "         \"\"\")\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Assert facts A, B, and C\n",
    "env.assert_string(\"(A)\")\n",
    "env.assert_string(\"(B)\")\n",
    "env.assert_string(\"(C)\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f79ec673",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Explitcitly define the rule to print \"AND Logic ABC\" if facts A, B, and C are present\n",
    "env.build(\"\"\"(defrule ABC\n",
    "               (and (A)\n",
    "                    (B)\n",
    "                    (C))\n",
    "              =>\n",
    "             (printout t \"AND Logic - ABC\" crlf))\n",
    "         \"\"\")\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Assert facts A, B, and C\n",
    "env.assert_string(\"(A)\")\n",
    "env.assert_string(\"(B)\")\n",
    "env.assert_string(\"(C)\")\n",
    "\n",
    "# Inference\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e82b110d",
   "metadata": {},
   "source": [
    "4 Define **rules** in **logical OR**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf552e74",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Implicitly define the rule to print \"A\" if facts A is present\n",
    "env.build(\"\"\"(defrule A\n",
    "               (A)\n",
    "              =>\n",
    "             (printout t \"A\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule B\n",
    "               (B)\n",
    "             =>\n",
    "             (printout t \"B\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule C\n",
    "               (C)\n",
    "             =>\n",
    "             (printout t \"C\" crlf))\"\"\")\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Assert facts A, B, and C\n",
    "env.assert_string(\"(C)\")\n",
    "env.assert_string(\"(B)\")\n",
    "env.assert_string(\"(A)\")\n",
    "\n",
    "# Inference\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3548c7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Explicitly define the rule to print \"AND Logic ABC\" if facts A, B, and C are present\n",
    "env.build(\"\"\"(defrule ABC\n",
    "               (or (A)\n",
    "                   (B)\n",
    "                   (C))\n",
    "              =>\n",
    "             (printout t \"OR Logic - ABC\" crlf))\n",
    "         \"\"\")\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "# Assert facts A, B, and C\n",
    "env.assert_string(\"(A)\")\n",
    "env.assert_string(\"(B)\")\n",
    "env.assert_string(\"(C)\")\n",
    "\n",
    "# Inference\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6012cdfa",
   "metadata": {},
   "source": [
    "* **Type of Variables**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5eb4dec2",
   "metadata": {},
   "source": [
    "1. Define **single-field variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15acc114",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define rules in knowledge base\n",
    "env.build(\"\"\"(defrule omelette (egg ?type) \n",
    "                  => (printout t \"You can make an \" ?type crlf))\"\"\")\n",
    "\n",
    "# Add facts to working memory\n",
    "env.assert_string('(egg scrambled)')\n",
    "\n",
    "# Inference\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6555e3d6",
   "metadata": {},
   "source": [
    "2. Define **multi-variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0c73894",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "#Multi-variables\n",
    "env.build(\"\"\"(defrule person (name ?first ?last)\n",
    "             => (printout t ?last \" has children \" ?first crlf))\"\"\")\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "env.assert_string('(name Jack Fun)')\n",
    "\n",
    "# Inference\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb0223ae",
   "metadata": {},
   "source": [
    "3. Define **multislot** in **deftemplate**. **Method 1**: Display template based on facts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "febc5456",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Define template with multislot\n",
    "env.build(\"\"\"(deftemplate person\n",
    "                 (multislot name))\"\"\")\n",
    "\n",
    "# Reset the environment\n",
    "env.reset()\n",
    "\n",
    "env.assert_string(\"(person (name 'Jack' 'Fun'))\")\n",
    "env.assert_string(\"(person (name 'Jocker' 'Funny'))\")\n",
    "\n",
    "# Inference\n",
    "env.run()\n",
    "\n",
    "# Display multislot values\n",
    "for fact in env.facts():\n",
    "    if fact.template.name == 'person':\n",
    "        val = list(fact['name'])\n",
    "        print('Last Name:'+val[0])\n",
    "        print('First Name:'+val[1])\n",
    "        print(' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69b62b49",
   "metadata": {},
   "source": [
    "4. Define **multifields** in **deftemplate**. **Method 2**: Display template based on rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b546e73",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=15,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "\n",
    "env.build(\"\"\"(deftemplate person\n",
    "               (multislot name)\n",
    "               (multislot children))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(deffacts some-people\n",
    "               (person (name John Q. Public)\n",
    "                   (children Jane Paul Mary))\n",
    "               (person (name Jack R. Public)\n",
    "                   (children Risk)))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule print-children\n",
    "               (person (name $?name) ;; notice the $?\n",
    "                   (children $?children))\n",
    "             =>(printout t $?name \" has children \" $?children crlf))\"\"\")\n",
    "\n",
    "env.reset()\n",
    "\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ba2355a",
   "metadata": {},
   "source": [
    "# Section D: Simple Expert System "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc4a79ab",
   "metadata": {},
   "source": [
    "Install easygui for simple GUI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aac630b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install easygui"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57877a24",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips\n",
    "import easygui\n",
    "\n",
    "env = clips.Environment()\n",
    "\n",
    "# input\n",
    "name = easygui.enterbox(\"Enter a name:\")\n",
    "\n",
    "# knowledge base\n",
    "env.build('(deftemplate result (slot name))')\n",
    "# add facts to working memory\n",
    "env.assert_string(f'(result (name \"{name}\"))')\n",
    "# inference\n",
    "env.run()\n",
    "\n",
    "# output\n",
    "results = []\n",
    "for fact in env.facts():\n",
    "    if fact.template.name == 'result':\n",
    "        results.append(fact['name']) #Why assert the fact? \n",
    "        \n",
    "easygui.msgbox(results[0],\"Output\")\n",
    " "
   ]
  },
  {
   "attachments": {
    "image-3.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "f728a08f",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "Create CLIPS constructs according to the knowledge representation (decision tree) below. \n",
    "![image-3.png](attachment:image-3.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:base] *",
   "language": "python",
   "name": "conda-base-py"
  },
  "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.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}