Example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "78e2036c",
   "metadata": {},
   "source": [
    "# Materialize the probabilistic model of LUBM1 and query it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "caa2b55f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.insert(0, 'glog-python/build/')\n",
    "import tgs\n",
    "import json\n",
    "from IPython.display import JSON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "91aa315e",
   "metadata": {},
   "outputs": [],
   "source": [
    "loglevel = 2 # INFO level\n",
    "main_dir = 'TGs/lubm/lubm_1/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "91a40c2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.chdir(main_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67141fa0",
   "metadata": {},
   "source": [
    "Load the EDB layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f61225b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "edb_file = 'edb.conf'\n",
    "layer = tgs.EDBLayer(edb_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6cbd9ba",
   "metadata": {},
   "source": [
    "Load the program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "97e5144f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rules 127\n"
     ]
    }
   ],
   "source": [
    "program = tgs.Program(layer)\n",
    "rules = 'TGs/lubm/rules/LUBM_L_csv.dlog'\n",
    "program.load_from_file(rules)\n",
    "print(\"Number of rules\", program.get_n_rules())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a4b275ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"max_mem_mb\" : \"10623.367188\",\"n_derivations\" : \"7957292\",\"n_edges\" : \"870\",\"n_nodes\" : \"411\",\"n_triggers\" : \"16942486\",\"runtime_ms\" : \"7462.180587\",\"steps\" : \"10\"}\n"
     ]
    }
   ],
   "source": [
    "chaseProcedure = \"probtgchase\" # If you want to use the standard chase, use \"tgchase\"\n",
    "typeProv = \"FULLPROV\"\n",
    "\n",
    "reasoner = tgs.Reasoner(chaseProcedure, layer, program, typeProv=typeProv, edbCheck=False, queryCont=False)\n",
    "statistics = reasoner.create_model(0)\n",
    "print(statistics)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ad565c7",
   "metadata": {},
   "source": [
    "We can retrieve the trigger graph (TG) that we just computed as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "31edf45e",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg = reasoner.get_TG()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bf7010d",
   "metadata": {},
   "source": [
    "Now, we add a rule that specifies the query that we want to execute. This command returns the ID of the rule that we just added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1dbcc597",
   "metadata": {},
   "outputs": [],
   "source": [
    "queries = [\n",
    "\"Q1(X) :- GraduateStudent(X), takesCourse(X,C), mgc_q01_fb(C)\", \n",
    "\"Q2(X,Y,Z) :- Department(Z), subOrganizationOf(Z,Y), University(Y), undergraduateDegreeFrom(X,Y), GraduateStudent(X), memberOf(X,Z)\",  \n",
    "\"Q3(X) :- Publication(X), publicationAuthor(X,C), mgc_q03_fb(C)\", \n",
    "\"Q4(X,Y1,Y2,Y3) :- worksFor(X,C), mgc_q04_ffffb(C), Professor(X), name(X,Y1), emailAddress(X,Y2), telephone(X,Y3)\", \n",
    "\"Q5(X) :- memberOf(X,C), mgc_q05_fb(C), Person(X)\", \n",
    "\"Q6(X) :-  Student(X)\", \n",
    "\"Q7(X,Y) :- teacherOf(C,Y), mgc_q07_ffb(C), Course(Y), takesCourse(X,Y), Student(X)\", \n",
    "\"Q8(X,Y,Z) :- subOrganizationOf(Y,C), mgc_q08_fffb(C), Department(Y), memberOf(X,Y), Student(X), emailAddress(X,Z)\", \n",
    "\"Q9(X,Y,Z) :- Course(Z), takesCourse(X,Z), teacherOf(Y,Z), advisor(X,Y), Student(X), Faculty(Y)\", \n",
    "\"Q10(X) :- takesCourse(X,C), mgc_q10_fb(C), Student(X)\", \n",
    "\"Q11(X) :- subOrganizationOf(X,C), mgc_q11_fb(C), ResearchGroup(X)\", \n",
    "\"Q12(X,Y) :- subOrganizationOf(Y,C), mgc_q12_ffb(C), Department(Y), worksFor(X,Y), Chair(X)\", \n",
    "\"Q13(X) :-hasAlumnus(C,X), mgc_q13_fb(C), Person(X)\", \n",
    "\"Q14(X) :- UndergraduateStudent(X)\"\n",
    "]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6a644279",
   "metadata": {},
   "outputs": [],
   "source": [
    "newRuleId = program.add_rule(queries[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d061671c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ts, stats_query = reasoner.execute_rule(newRuleId)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1c409894",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The rule that we executed returnd 4 answers\n"
     ]
    }
   ],
   "source": [
    "n_answers = ts.get_n_facts()\n",
    "print(\"The rule that we executed returnd {:n} answers\".format(n_answers))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b94ca60",
   "metadata": {},
   "source": [
    "Additional statistics collected during the execution of the rule:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9c4788da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'n_answers': 4, 'runtime_ms': 4.591233}\n"
     ]
    }
   ],
   "source": [
    "print(stats_query)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03a6672a",
   "metadata": {},
   "source": [
    "In order to query the TG or the answers of a query, we create a special object. We can also use the same object to compute the derivation trees of each fact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "01887599",
   "metadata": {},
   "outputs": [],
   "source": [
    "querier = tgs.Querier(tg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b5f68f",
   "metadata": {},
   "source": [
    "Print the answers of the new rule that we just executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4f74b12c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answers 0: ['Department0-University0-GraduateStudent44'])\n",
      "Answers 1: ['Department0-University0-GraduateStudent101'])\n",
      "Answers 2: ['Department0-University0-GraduateStudent124'])\n",
      "Answers 3: ['Department0-University0-GraduateStudent142'])\n"
     ]
    }
   ],
   "source": [
    "for i in range(n_answers):\n",
    "    sFact = querier.get_fact_in_TupleSet(ts,i)\n",
    "    print(\"Answers {:n}: {})\".format(i, str(sFact)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18222b79",
   "metadata": {},
   "source": [
    "We can check the derivation tree of a certain answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "895d1c7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/json": {
       "fact": "Q1(Department0-University0-GraduateStudent142)",
       "factId": "3",
       "nodeId": "18446744073709551615",
       "parents": [
        {
         "fact": "GraduateStudent(Department0-University0-GraduateStudent142)",
         "factId": "142",
         "nodeId": "9",
         "parents": [
          {
           "fact": "src_GraduateStudent(Department0-University0-GraduateStudent142)",
           "factId": "142",
           "nodeId": "none",
           "rule": "none",
           "ruleIdx": "none",
           "step": "none",
           "tupleIds": "[2231]"
          }
         ],
         "rule": "GraduateStudent(A1) :- src_GraduateStudent(A1)",
         "ruleIdx": "9",
         "step": "1",
         "tupleIds": "[2231]"
        },
        {
         "fact": "takesCourse(Department0-University0-GraduateStudent142,Department0-University0-GraduateCourse0)",
         "factId": "270",
         "nodeId": "21",
         "parents": [
          {
           "fact": "src_takesCourse(Department0-University0-GraduateStudent142,Department0-University0-GraduateCourse0)",
           "factId": "270",
           "nodeId": "none",
           "rule": "none",
           "ruleIdx": "none",
           "step": "none",
           "tupleIds": "[2231,1290]"
          }
         ],
         "rule": "takesCourse(A1,A2) :- src_takesCourse(A1,A2)",
         "ruleIdx": "21",
         "step": "1",
         "tupleIds": "[2231,1290]"
        },
        {
         "fact": "mgc_q01_fb(Department0-University0-GraduateCourse0)",
         "factId": "0",
         "nodeId": "none",
         "rule": "none",
         "ruleIdx": "none",
         "step": "none",
         "tupleIds": "[1290]"
        }
       ],
       "rule": "Q1(A1) :- GraduateStudent(A1),takesCourse(A1,A2),mgc_q01_fb(A2)",
       "ruleIdx": "127",
       "step": "18446744073709551615",
       "tupleIds": "[2231]"
      },
      "text/plain": [
       "<IPython.core.display.JSON object>"
      ]
     },
     "metadata": {
      "application/json": {
       "expanded": true,
       "root": "root"
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "answerNumber = 3\n",
    "dertree = querier.get_derivation_tree_in_TupleSet(ts, answerNumber)\n",
    "dertree = json.loads(dertree)\n",
    "display(JSON(dertree, expanded=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c380100",
   "metadata": {},
   "source": [
    "We can also retrieve all the nodes with a certain predicate, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "89f516b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The answers are 1874  found in 1 nodes.\n"
     ]
    }
   ],
   "source": [
    "nodes = querier.get_node_details_predicate('GraduateStudent')\n",
    "nodes = json.loads(nodes)\n",
    "n_answers = 0\n",
    "for n in nodes:\n",
    "    n_answers += int(n['n_facts'])\n",
    "print(\"The answers are\", n_answers, \" found in\", len(nodes), \"nodes.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f458cca8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}