Kanren_Reasoner.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "636e4654",
   "metadata": {},
   "source": [
    "# Kanren Reasoner\n",
    "miniKanren-based Inference Engine for Non-Axiomatic Logic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b04792c8",
   "metadata": {},
   "source": [
    "#### Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d05344ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install lark\n",
    "%pip install pyyaml\n",
    "%pip install miniKanren\n",
    "\n",
    "import os\n",
    "import yaml\n",
    "\n",
    "# download required files\n",
    "if not os.path.isfile('Narsese/rules.yml'):\n",
    "  !mkdir Narsese\n",
    "  !wget -P Narsese https://raw.githubusercontent.com/maxeeem/nars-workshop-2024/main/Narsese/rules.yml\n",
    "  !wget -P Narsese https://raw.githubusercontent.com/maxeeem/nars-workshop-2024/main/Narsese/Narsese.py\n",
    "  !wget -P Narsese https://raw.githubusercontent.com/maxeeem/nars-workshop-2024/main/Narsese/narsese.lark\n",
    "  !wget -P Narsese https://raw.githubusercontent.com/maxeeem/nars-workshop-2024/main/Narsese/narsese_lark.py\n",
    "  !wget -P Narsese https://raw.githubusercontent.com/maxeeem/nars-workshop-2024/main/Narsese/parser.py\n",
    "\n",
    "from Narsese.Narsese import *\n",
    "from Narsese.parser import parse\n",
    "from cons import cons, car, cdr\n",
    "from kanren import var, run, eq"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7e14650-9a55-4a4a-acae-5c170a8fdf6d",
   "metadata": {},
   "source": [
    "## Parser\n",
    "Uses grammar defined in `narsese.lark`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "760022f8",
   "metadata": {},
   "source": [
    "#### String → Narsese"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36eb94bc-a1a8-4559-b207-efe63707ae90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Judgement: <dog --> animal>. %1.00;0.90% \n",
      "\n",
      "Subject: dog\n",
      "Copula: -->\n",
      "Predicate: animal\n",
      "\n",
      "Narsese: <dog --> animal>\n"
     ]
    }
   ],
   "source": [
    "# generate narsese_lark.py from grammar definition in narsese.lark\n",
    "os.system(f'python -m lark.tools.standalone ./Narsese/narsese.lark > ./Narsese/narsese_lark.py')\n",
    "\n",
    "task = parse(\"<dog --> animal>.\")\n",
    "\n",
    "print('Judgement:', task, '\\n')\n",
    "\n",
    "statement = task.term\n",
    "\n",
    "print('Subject:', statement.subject)\n",
    "print('Copula:', statement.copula)\n",
    "print('Predicate:', statement.predicate)\n",
    "\n",
    "print('\\nNarsese:', statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "060ee8a4",
   "metadata": {},
   "source": [
    "#### Narsese → Logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "29fbeac1-3988-49c4-9a7d-0a56fb9b8a18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logic: (--> . (dog . animal))\n"
     ]
    }
   ],
   "source": [
    "def logic(term: Term, rule=False):\n",
    "    if term.is_atom:\n",
    "        return var(term) if rule else term\n",
    "    if term.is_statement:\n",
    "        subject = logic(term.subject, rule)\n",
    "        copula = term.copula\n",
    "        predicate = logic(term.predicate, rule)\n",
    "        return cons(copula, subject, predicate)\n",
    "    \n",
    "print('Logic:', logic(statement))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09aea99e",
   "metadata": {},
   "source": [
    "#### Logic → Narsese"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "57c95f1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Narsese: <dog --> animal>\n"
     ]
    }
   ],
   "source": [
    "def term(logic):\n",
    "    if type(logic) is Term:\n",
    "        return logic\n",
    "    if type(logic) is cons:\n",
    "        subject = car(cdr(logic))\n",
    "        copula = car(logic)\n",
    "        predicate = cdr(cdr(logic))\n",
    "        return Statement(term(subject), copula, term(predicate))\n",
    "    return logic # var\n",
    "\n",
    "print('Narsese:', term(logic(statement)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1de73e8f-5b70-4a54-a708-4a5b9d261a60",
   "metadata": {},
   "source": [
    "## Rules\n",
    "Stored in a human-readable format in `rules.yml`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe34002a",
   "metadata": {},
   "source": [
    "#### Load rules from a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "af1dea76",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert(rule):\n",
    "    # split rule string into components\n",
    "    # ex: {<M --> P>. <S --> M>} |- <S --> P> .ded\n",
    "    \n",
    "    # p1: <M --> P>, p2: <S --> M>\n",
    "    # c: <S --> P>, r: ded\n",
    "    \n",
    "    components = rule.split(\" |- \")\n",
    "    p1, p2 = components[0].strip(\"{}\").split(\". \")\n",
    "    c, r = components[1].split(\" .\")\n",
    "\n",
    "    # convert string to narsese \n",
    "    p1 = parse(p1 + '.', True)\n",
    "    p2 = parse(p2 + '.', True)\n",
    "    c  = parse(c  + '.', True)\n",
    "\n",
    "    # convert narsese to logic\n",
    "    p1 = logic(p1, True)\n",
    "    p2 = logic(p2, True)\n",
    "    c  = logic(c , True)\n",
    "\n",
    "    return (p1, p2, c, r)\n",
    "\n",
    "truth_functions = {\n",
    "    'ded': Truth_deduction,\n",
    "    'abd': Truth_abduction,\n",
    "    'ind': Truth_induction,\n",
    "    'exe': Truth_exemplification,\n",
    "    'ana': Truth_analogy,\n",
    "    'com': Truth_comparison,\n",
    "    'res': Truth_resemblance\n",
    "}\n",
    "\n",
    "with open('Narsese/rules.yml', 'r') as file:\n",
    "    config = yaml.safe_load(file)\n",
    "    \n",
    "nal1 = config['rules']['nal1'].splitlines()\n",
    "nal2 = config['rules']['nal2'].splitlines()\n",
    "\n",
    "rules = [convert(rule) for rule in nal1 + nal2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79a6f32f",
   "metadata": {},
   "source": [
    "#### Sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "682e1bf1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " {<M --> P>. <S --> M>} |- <S --> P> .ded \n",
      "\n",
      "DED rule\n",
      "Premise 1  (--> . (~M . ~P))\n",
      "Premise 2  (--> . (~S . ~M))\n",
      "Conclusion (--> . (~S . ~P))\n",
      "\n",
      " {<M --> P>. <M --> S>} |- <S --> P> .ind \n",
      "\n",
      "IND rule\n",
      "Premise 1  (--> . (~M . ~P))\n",
      "Premise 2  (--> . (~M . ~S))\n",
      "Conclusion (--> . (~S . ~P))\n",
      "\n",
      " {<P --> M>. <S --> M>} |- <S --> P> .abd \n",
      "\n",
      "ABD rule\n",
      "Premise 1  (--> . (~P . ~M))\n",
      "Premise 2  (--> . (~S . ~M))\n",
      "Conclusion (--> . (~S . ~P))\n"
     ]
    }
   ],
   "source": [
    "def print_rule(rule):\n",
    "    (p1, p2, c, r) = rule\n",
    "    print(r.upper(), 'rule')\n",
    "    print('Premise 1 ', p1)\n",
    "    print('Premise 2 ', p2)\n",
    "    print('Conclusion', c)\n",
    "\n",
    "for i in range(3):\n",
    "    print('\\n', nal1[i], '\\n')\n",
    "    print_rule(rules[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3738ded",
   "metadata": {},
   "source": [
    "## Inference\n",
    "Applying rules using miniKanren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4d7615e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def inference(t1: Sentence, t2: Sentence) -> list:\n",
    "    results = []\n",
    "\n",
    "    l1 = logic(t1.term)\n",
    "    l2 = logic(t2.term)\n",
    "\n",
    "    for rule in rules:\n",
    "        (p1, p2, c, r) = rule\n",
    "    \n",
    "        result = run(1, c, eq((p1, p2), (l1, l2)))\n",
    "        \n",
    "        if result:\n",
    "            conclusion = term(result[0])\n",
    "            truth = truth_functions[r](t1.truth, t2.truth)\n",
    "            results.append(((conclusion, r), truth))\n",
    "\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad47839",
   "metadata": {},
   "source": [
    "## Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "60fe7494",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((Statement: <Sandy --> animal>, 'ded'), %1.00;0.81%)]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = parse(\"<dog --> animal>.\")\n",
    "t2 = parse(\"<Sandy --> dog>.\")\n",
    "\n",
    "inference(t1, t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "636d1a4d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((Statement: <Sandy --> pet>, 'ana'), %0.80;0.65%)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = parse(\"<Sandy --> dog>.\")\n",
    "t2 = parse(\"<dog <-> pet>. %0.80%\")\n",
    "\n",
    "inference(t1, t2)"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}