Fix NI predicate computation

Now NAMED is introduced during the canonical model computation, while
NI instances are computed and introduced in the filtering program
generation phase.

4 files changed, 76 insertions, 37 deletions

diff --git a/src/main/scala/rsacomb/FilteringProgram.scala b/src/main/scala/rsacomb/FilteringProgram.scala
index 4d5a5c0..e9a69ff 100644
--- a/src/main/scala/rsacomb/FilteringProgram.scala
+++ b/src/main/scala/rsacomb/FilteringProgram.scala
@@ -57,16 +57,12 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
     }
   val bounded: List[Term] = this.variables.filterNot(answer.contains(_))
 
-  val facts: List[TupleTableAtom] = constants.map(named)
+  val facts: List[Rule] = constants.map(c => Rule.create(predNI(c)))
   val rules: List[Rule] =
-    this.generateFilteringProgram().map(reifyRule) ++ facts.map(Rule.create(_))
+    this.generateFilteringProgram().map(reifyRule) ++ facts
 
-  private def named(t: Term): TupleTableAtom =
-    TupleTableAtom.rdf(
-      t,
-      IRI.RDF_TYPE,
-      RSA.internal("NAMED")
-    )
+  private def predNI(t: Term): TupleTableAtom =
+    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA.internal("NI"))
 
   /* NOTE: we are restricting to queries that contain conjunctions of
    * atoms for the time being. This might need to be reviewed in the
@@ -104,8 +100,8 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
         TupleTableName.create(RSA.internal("ID").getIRI),
         (answer ++ bounded).appended(t1).appended(t2): _*
       )
-    def predNI(t1: Term): TupleTableAtom =
-      TupleTableAtom.rdf(t1, IRI.RDF_TYPE, RSA.internal("NI"))
+    def predNAMED(t1: Term): TupleTableAtom =
+      TupleTableAtom.rdf(t1, IRI.RDF_TYPE, RSA.internal("NAMED"))
     def predTQ(sx: String, t1: Term, t2: Term) =
       TupleTableAtom.create(
         TupleTableName.create(RSA.internal(s"TQ_$sx").getIRI),
@@ -170,7 +166,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
       not(
         TupleTableAtom.rdf(
           role1.getArguments.get(0),
-          IRI.SAME_AS,
+          RSA.EquivTo,
           role2.getArguments.get(0)
         )
       )
@@ -191,7 +187,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
       not(
         TupleTableAtom.rdf(
           role1.getArguments.get(0),
-          IRI.SAME_AS,
+          RSA.EquivTo,
           role2.getArguments.get(2)
         )
       )
@@ -212,7 +208,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
       not(
         TupleTableAtom.rdf(
           role1.getArguments.get(2),
-          IRI.SAME_AS,
+          RSA.EquivTo,
           role2.getArguments.get(2)
         )
       )
@@ -241,7 +237,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
         RSA.internal(bounded indexOf role1arg2),
         RSA.internal(bounded indexOf role2arg2)
       ),
-      TupleTableAtom.rdf(role1arg0, IRI.SAME_AS, role2arg0),
+      TupleTableAtom.rdf(role1arg0, RSA.EquivTo, role2arg0),
       not(predNI(role1arg0))
     )
     val r5b = for {
@@ -266,7 +262,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
         RSA.internal(bounded indexOf role1arg2),
         RSA.internal(bounded indexOf role2arg0)
       ),
-      TupleTableAtom.rdf(role1arg0, IRI.SAME_AS, role2arg2),
+      TupleTableAtom.rdf(role1arg0, RSA.EquivTo, role2arg2),
       not(predNI(role1arg0))
     )
     val r5c = for {
@@ -291,7 +287,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
         RSA.internal(bounded indexOf role1arg0),
         RSA.internal(bounded indexOf role2arg0)
       ),
-      TupleTableAtom.rdf(role1arg2, IRI.SAME_AS, role2arg2),
+      TupleTableAtom.rdf(role1arg2, RSA.EquivTo, role2arg2),
       not(predNI(role1arg2))
     )
 
@@ -333,7 +329,7 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
 
     /* Rules 8x */
     val r8a =
-      for (v <- answer) yield Rule.create(predSP, predQM, not(named(v)))
+      for (v <- answer) yield Rule.create(predSP, predQM, not(predNAMED(v)))
     val r8b =
       Rule.create(predSP, predFK)
     val r8c =
diff --git a/src/main/scala/rsacomb/Main.scala b/src/main/scala/rsacomb/Main.scala
index 39040fc..596ef33 100644
--- a/src/main/scala/rsacomb/Main.scala
+++ b/src/main/scala/rsacomb/Main.scala
@@ -7,6 +7,7 @@ import scala.collection.JavaConverters._
 
 import tech.oxfordsemantic.jrdfox.client.UpdateType
 import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
+import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term}
 
 /* Local imports */
 import rsacomb.RSA._
@@ -73,23 +74,50 @@ object RSAComb extends App {
         // Open connection to RDFox
         val (server, data) = RDFoxUtil.openConnection("AnswerComputation")
 
-        // Gather canonical model and filtering rules
+        {
+          println("\nQuery")
+          println(query)
+        }
+
+        // Step 1. Computing the canonical model
         val canon = ontology.canonicalModel
-        val filter = ontology.filteringProgram(query)
+        data.addRules(canon.rules.asJava)
 
         {
           println("\nCanonical Model rules:")
           canon.rules.foreach(println)
-          println("\nFiltering rules")
-          filter.rules.foreach(println)
-          println("\nQuery")
-          println(query)
         }
 
-        // Add canonical model and filtering rules
-        data.addRules(canon.rules.asJava)
+        // Step 2. Computing the canonical model
+        val nis = {
+          val query =
+            "SELECT ?Y WHERE { ?X internal:EquivTo ?Y ; a internal:NAMED . }"
+          val cursor =
+            data.createCursor(
+              RSA.Prefixes,
+              query,
+              new HashMap[String, String]()
+            );
+          var mul = cursor.open()
+          var iris: List[IRI] = List()
+          while (mul > 0) {
+            println(cursor.getResource(0))
+            iris = cursor.getResource(0) match {
+              case iri: IRI => iri :: iris
+              case _        => iris
+            }
+            mul = cursor.advance()
+          }
+          iris
+        }
+        val filter = ontology.filteringProgram(query, nis)
         data.addRules(filter.rules.asJava)
 
+        {
+          println("\nFiltering rules")
+          filter.rules.foreach(println)
+        }
+
         def retrieveInstances(pred: String, arity: Int): Unit = {
           // Build query
           var query = "SELECT"
@@ -127,6 +155,14 @@ object RSAComb extends App {
           1
         )
 
+        println("\nNAMEDs:")
+        RDFoxUtil.submitQuery(
+          data,
+          RSA.Prefixes,
+          "SELECT ?X { ?X a internal:NAMED }",
+          1
+        )
+
         println("\nNIs:")
         RDFoxUtil.submitQuery(
           data,
@@ -143,7 +179,7 @@ object RSAComb extends App {
         RDFoxUtil.submitQuery(
           data,
           RSA.Prefixes,
-          "SELECT ?X ?Y { ?X owl:sameAs ?Y }",
+          "SELECT ?X ?Y { ?X internal:EquivTo ?Y }",
           2
         )
 
diff --git a/src/main/scala/rsacomb/RSA.scala b/src/main/scala/rsacomb/RSA.scala
index 66de974..10a9d47 100644
--- a/src/main/scala/rsacomb/RSA.scala
+++ b/src/main/scala/rsacomb/RSA.scala
@@ -28,6 +28,8 @@ object RSA extends RSAOntology with RSAAxiom {
   Prefixes.declarePrefix("rdfs:", "http://www.w3.org/2000/01/rdf-schema#")
   Prefixes.declarePrefix("owl:", "http://www.w3.org/2002/07/owl#")
 
+  val EquivTo: IRI = this.internal("EquivTo")
+
   // Counter used to implement a simple fresh variable generator
   private var counter = -1;
 
diff --git a/src/main/scala/rsacomb/RSAOntology.scala b/src/main/scala/rsacomb/RSAOntology.scala
index dcd9c63..9220434 100644
--- a/src/main/scala/rsacomb/RSAOntology.scala
+++ b/src/main/scala/rsacomb/RSAOntology.scala
@@ -245,8 +245,11 @@ trait RSAOntology {
       Graph(edges: _*)
     }
 
-    def filteringProgram(query: SelectQuery): FilteringProgram =
-      FilteringProgram(query, individuals)
+    def filteringProgram(
+        query: SelectQuery,
+        nis: List[Term]
+    ): FilteringProgram =
+      new FilteringProgram(query, nis)
 
     // TODO: the following functions needs testing
     def confl(
@@ -359,9 +362,11 @@ trait RSAOntology {
 
       import RDFoxUtil._
 
-      val NIs: List[Rule] =
+      val named: List[Rule] =
         individuals.map(a =>
-          Rule.create(TupleTableAtom.rdf(a, IRI.RDF_TYPE, RSA.internal("NI")))
+          Rule.create(
+            TupleTableAtom.rdf(a, IRI.RDF_TYPE, RSA.internal("NAMED"))
+          )
         )
 
       val rolesAdditionalRules: List[Rule] = {
@@ -500,17 +505,17 @@ trait RSAOntology {
         val z = Variable.create("Z")
         List(
           Rule.create(
-            TupleTableAtom.rdf(x, IRI.SAME_AS, x),
+            TupleTableAtom.rdf(x, RSA.EquivTo, x),
             TupleTableAtom.rdf(x, IRI.RDF_TYPE, IRI.THING)
           ),
           Rule.create(
-            TupleTableAtom.rdf(y, IRI.SAME_AS, x),
-            TupleTableAtom.rdf(x, IRI.SAME_AS, y)
+            TupleTableAtom.rdf(y, RSA.EquivTo, x),
+            TupleTableAtom.rdf(x, RSA.EquivTo, y)
           ),
           Rule.create(
-            TupleTableAtom.rdf(x, IRI.SAME_AS, z),
-            TupleTableAtom.rdf(x, IRI.SAME_AS, y),
-            TupleTableAtom.rdf(y, IRI.SAME_AS, z)
+            TupleTableAtom.rdf(x, RSA.EquivTo, z),
+            TupleTableAtom.rdf(x, RSA.EquivTo, y),
+            TupleTableAtom.rdf(y, RSA.EquivTo, z)
           )
         )
       }
@@ -519,7 +524,7 @@ trait RSAOntology {
         // Compute rules from ontology axioms
         val rules = axioms.flatMap(_.accept(this.ProgramGenerator))
         // Return full set of rules
-        rules ++ rolesAdditionalRules ++ topAxioms ++ equalityAxioms ++ NIs
+        rules ++ rolesAdditionalRules ++ topAxioms ++ equalityAxioms ++ named
       }
 
       object ProgramGenerator