Add setup code to compute the RSA filtering program

Not all rules of the filtering program have been implemented, but the
code for the generation and reification of the rules seems to work.

1 files changed, 163 insertions, 2 deletions

diff --git a/src/main/scala/rsacomb/RSAOntology.scala b/src/main/scala/rsacomb/RSAOntology.scala
index 3d9210e..9d52612 100644
--- a/src/main/scala/rsacomb/RSAOntology.scala
+++ b/src/main/scala/rsacomb/RSAOntology.scala
@@ -19,6 +19,7 @@ import scalax.collection.GraphEdge.UnDiEdge
 
 /* Debug only */
 import org.semanticweb.owlapi.dlsyntax.renderer.DLSyntaxObjectRenderer
+import tech.oxfordsemantic.jrdfox.logic._
 
 /* Wrapper trait for the implicit class `RSAOntology`.
  */
@@ -163,8 +164,9 @@ trait RSAOntology {
       } yield role1
 
       /* TODO: We should be able to avoid this last conversion to List.
-       * Maybe we should just move everything to Sets instead of Lists, since
-       * they have a more straightforward conversion from Java collections.
+       * Maybe we should just move everything to Sets instead of Lists,
+       * since they have a more straightforward conversion from Java
+       * collections.
        */
       (unsafe1 ++ unsafe2).toList
     }
@@ -184,6 +186,165 @@ trait RSAOntology {
       Graph(edges: _*)
     }
 
+    def getFilteringProgram(query: Query): List[Rule] = {
+
+      // Import implicit conversion to RDFox IRI
+      import RDFoxUtil._
+
+      sealed trait Reified;
+      case class ReifiedHead(bind: BindAtom, atoms: List[Atom]) extends Reified
+      case class ReifiedBody(atoms: List[Atom]) extends Reified
+      case class Unaltered(formula: BodyFormula) extends Reified
+
+      def getBindAtom(atom: Atom): BindAtom = {
+        // TODO: We need to implement another way to introduce fresh
+        // variables.
+        val varA = Variable.create("A")
+        val args = atom
+          .getArguments()
+          .asScala
+          .toSeq
+        //.prepended(atom.getTupleTableName.getIRI)
+        BindAtom.create(
+          BuiltinFunctionCall
+            .create("SKOLEM", args: _*),
+          varA
+        )
+      }
+
+      def reifyAtom(atom: Atom, variable: Variable): List[Atom] = {
+        def iri(i: Int) = atom.getTupleTableName().getIRI() ++ s"_$i"
+        atom
+          .getArguments()
+          .asScala
+          .zipWithIndex
+          .map { case (t, i) => Atom.rdf(variable, iri(i), t) }
+          .toList
+      }
+
+      // Is this the best way to determine if an atom is an RDF triple?
+      // Note that we can't use `getNumberOfArguments()` because is not
+      // "consistent":
+      // - for an atom created with `rdf(<term1>, <term2>, <term3>)`,
+      // `getNumberOfArguments` returns 3
+      // - for an atom created with `Atom.create(<tupletablename>, <term1>,
+      // <term2>, <term3>)`, `getNumberOfArguments()` returns 3
+      //
+      // This is probably because `Atom.rdf(...) is implemented as:
+      // ```scala
+      //  def rdf(term1: Term, term2: Term, term3: Term): Atom =
+      //    Atom.create(TupleTableName.create("internal:triple"), term1, term2, term3)
+      // ```
+      def isRdfTriple(atom: Atom): Boolean =
+        atom.getTupleTableName.getIRI.equals("internal:triple")
+
+      def reify(
+          formula: BodyFormula,
+          head: Boolean
+      ): Reified = {
+        def default[A <: BodyFormula](x: A) = Unaltered(x)
+        formula match {
+          case a: Atom => {
+            if (!isRdfTriple(a)) {
+              if (head) {
+                val b = getBindAtom(a)
+                ReifiedHead(b, reifyAtom(a, b.getBoundVariable))
+              } else {
+                val varA = Variable.create("A")
+                ReifiedBody(reifyAtom(a, varA))
+              }
+            } else {
+              default(a)
+            }
+          }
+          case a => default(a)
+        }
+      }
+
+      def skolemizeRule(rule: Rule): Rule = {
+        // Rule body
+        val body =
+          rule.getBody.asScala.map(reify(_, false)).flatMap {
+            case ReifiedHead(_, _) => List(); /* handle impossible case */
+            case ReifiedBody(x)    => x;
+            case Unaltered(x)      => List(x)
+          }
+        // Rule head
+        val reified = rule.getHead.asScala.map(reify(_, true))
+        val skols = reified.flatMap {
+          case ReifiedHead(x, _) => Some(x);
+          case ReifiedBody(_)    => None; /* handle impossible case */
+          case Unaltered(_)      => None
+        }
+        val head = reified.flatMap {
+          case ReifiedHead(_, x) => x;
+          case ReifiedBody(_)    => List(); /* handle impossible case */
+          case Unaltered(x) =>
+            List(x.asInstanceOf[Atom]) /* Can we do better that a cast? */
+        }
+        Rule.create(head.asJava, (skols ++ body).asJava)
+      }
+
+      def formulaToRuleBody(body: Formula): List[BodyFormula] = {
+        body match {
+          case a: BodyFormula => List(a);
+          case a: Conjunction =>
+            a.getConjuncts().asScala.toList.flatMap(formulaToRuleBody(_));
+          case _ => List() /* We don't handle this for now */
+        }
+      }
+
+      val body = formulaToRuleBody(query.getQueryFormula)
+      val vars: List[Term] = query.getAnswerVariables.asScala.toList
+      def id(t1: Term, t2: Term) =
+        Atom.create(
+          TupleTableName.create("http://127.0.0.1/ID"),
+          vars.appendedAll(List(t1, t2)).asJava
+        )
+      val qm = Atom.create(TupleTableName.create("QM"), vars.asJava)
+
+      /* Filtering program */
+      val rule1 = Rule.create(qm, body.asJava)
+      val rule3a =
+        for ((v, i) <- vars.zipWithIndex)
+          yield Rule.create(
+            id(
+              IRI.create(s"http://127.0.0.1/$i"),
+              IRI.create(s"http://127.0.0.1/$i")
+            ),
+            List(
+              qm,
+              Negation.create(
+                Atom.rdf(v, IRI.RDF_TYPE, IRI.create("http://127.0.0.1/NI"))
+              )
+            ).asJava
+          )
+      val rule3b = Rule.create(
+        id(Variable.create("V"), Variable.create("U")),
+        id(Variable.create("U"), Variable.create("V"))
+      )
+      val rule3c = Rule.create(
+        id(Variable.create("U"), Variable.create("W")),
+        List[BodyFormula](
+          id(Variable.create("U"), Variable.create("V")),
+          id(Variable.create("V"), Variable.create("W"))
+        ).asJava
+      )
+
+      var rules: List[Rule] =
+        List.empty
+          .prepended(rule3c)
+          .prepended(rule3b)
+          .prependedAll(rule3a)
+          .prepended(rule1)
+
+      // DEBUG
+      println("FILTERING PROGRAM:")
+      rules.map(skolemizeRule(_)).foreach(println(_))
+
+      List()
+    }
+
   } // implicit class RSAOntology
 
 } // trait RSAOntology