From 313d3f835977f4d7f59e32e1b6cf4a508e1a3431 Mon Sep 17 00:00:00 2001 From: Federico Igne Date: Sat, 14 Nov 2020 14:00:55 +0000 Subject: 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. --- src/main/scala/rsacomb/FilteringProgram.scala | 30 +++++++-------- src/main/scala/rsacomb/Main.scala | 54 ++++++++++++++++++++++----- src/main/scala/rsacomb/RSA.scala | 2 + src/main/scala/rsacomb/RSAOntology.scala | 27 ++++++++------ 4 files changed, 76 insertions(+), 37 deletions(-) (limited to 'src') 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 -- cgit v1.2.3