aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/main/scala/rsacomb/CanonicalModel.scala62
-rw-r--r--src/main/scala/rsacomb/FilteringProgram.scala284
-rw-r--r--src/main/scala/rsacomb/Main.scala232
-rw-r--r--src/main/scala/rsacomb/RDFoxAxiomConverter.scala2
-rw-r--r--src/main/scala/rsacomb/RDFoxClassExprConverter.scala19
-rw-r--r--src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala2
-rw-r--r--src/main/scala/rsacomb/RDFoxUtil.scala113
-rw-r--r--src/main/scala/rsacomb/RSA.scala105
-rw-r--r--src/main/scala/rsacomb/RSAAtom.scala6
-rw-r--r--src/main/scala/rsacomb/RSAAxiom.scala13
-rw-r--r--src/main/scala/rsacomb/RSAOntology.scala31
-rw-r--r--src/main/scala/rsacomb/implicits/JavaCollections.scala13
-rw-r--r--src/main/scala/rsacomb/implicits/RDFox.scala20
-rw-r--r--src/main/scala/rsacomb/util/RDFoxHelpers.scala100
-rw-r--r--src/test/scala/rsacomb/CanonicalModelSpec.scala59
-rw-r--r--src/test/scala/rsacomb/FilteringProgramSpecs.scala82
-rw-r--r--src/test/scala/rsacomb/OWLAxiomSpec.scala8
-rw-r--r--src/test/scala/rsacomb/OWLClassSpec.scala5
18 files changed, 591 insertions, 565 deletions
diff --git a/src/main/scala/rsacomb/CanonicalModel.scala b/src/main/scala/rsacomb/CanonicalModel.scala
index f7a45a7..5f781d1 100644
--- a/src/main/scala/rsacomb/CanonicalModel.scala
+++ b/src/main/scala/rsacomb/CanonicalModel.scala
@@ -24,16 +24,15 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{
24} 24}
25 25
26import suffix.{Empty, Forward, Backward, Inverse} 26import suffix.{Empty, Forward, Backward, Inverse}
27import util.RSA
27 28
28class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom { 29class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
29 30
30 // Makes working with IRIs less painful 31 import implicits.RDFox._
31 import RDFoxUtil._ 32 import implicits.JavaCollections._
32 33
33 val named: List[Rule] = 34 val named: List[Rule] =
34 ontology.individuals.map(a => 35 ontology.individuals.map(a => Rule.create(RSA.Named(a)))
35 Rule.create(TupleTableAtom.rdf(a, IRI.RDF_TYPE, RSA.Named))
36 )
37 36
38 val rolesAdditionalRules: List[Rule] = { 37 val rolesAdditionalRules: List[Rule] = {
39 // Given a role (predicate) compute additional logic rules 38 // Given a role (predicate) compute additional logic rules
@@ -69,7 +68,7 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
69 val varY = Variable.create("Y") 68 val varY = Variable.create("Y")
70 val concepts = ontology.concepts.map(c => { 69 val concepts = ontology.concepts.map(c => {
71 Rule.create( 70 Rule.create(
72 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, IRI.THING), 71 RSA.Thing(varX),
73 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, c.getIRI) 72 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, c.getIRI)
74 ) 73 )
75 }) 74 })
@@ -80,10 +79,7 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
80 x.getInverse.getNamedProperty.getIRI.getIRIString :: Inverse 79 x.getInverse.getNamedProperty.getIRI.getIRIString :: Inverse
81 } 80 }
82 Rule.create( 81 Rule.create(
83 List( 82 List(RSA.Thing(varX), RSA.Thing(varY)),
84 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, IRI.THING),
85 TupleTableAtom.rdf(varY, IRI.RDF_TYPE, IRI.THING)
86 ),
87 List(TupleTableAtom.rdf(varX, name, varY)) 83 List(TupleTableAtom.rdf(varX, name, varY))
88 ) 84 )
89 }) 85 })
@@ -95,18 +91,15 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
95 val varY = Variable.create("Y") 91 val varY = Variable.create("Y")
96 val varZ = Variable.create("Z") 92 val varZ = Variable.create("Z")
97 List( 93 List(
94 // Reflexivity
95 Rule.create(RSA.EquivTo(varX, varX), RSA.Thing(varX)),
96 // Simmetry
97 Rule.create(RSA.EquivTo(varY, varX), RSA.EquivTo(varX, varY)),
98 // Transitivity
98 Rule.create( 99 Rule.create(
99 TupleTableAtom.rdf(varX, RSA.EquivTo, varX), 100 RSA.EquivTo(varX, varZ),
100 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, IRI.THING) 101 RSA.EquivTo(varX, varY),
101 ), 102 RSA.EquivTo(varY, varZ)
102 Rule.create(
103 TupleTableAtom.rdf(varY, RSA.EquivTo, varX),
104 TupleTableAtom.rdf(varX, RSA.EquivTo, varY)
105 ),
106 Rule.create(
107 TupleTableAtom.rdf(varX, RSA.EquivTo, varZ),
108 TupleTableAtom.rdf(varX, RSA.EquivTo, varY),
109 TupleTableAtom.rdf(varY, RSA.EquivTo, varZ)
110 ) 103 )
111 ) 104 )
112 } 105 }
@@ -129,21 +122,14 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
129 private def rules1(axiom: OWLSubClassOfAxiom): List[Rule] = { 122 private def rules1(axiom: OWLSubClassOfAxiom): List[Rule] = {
130 val unfold = ontology.unfold(axiom).toList 123 val unfold = ontology.unfold(axiom).toList
131 // Fresh Variables 124 // Fresh Variables
132 val v0 = RSA.rsa("v0_" ++ RSA.hashed(axiom)) 125 val v0 = RSA("v0_" ++ axiom.hashed)
133 val varX = Variable.create("X") 126 val varX = Variable.create("X")
134 // Predicates 127 implicit val unfoldTerm = RSA(unfold.hashCode.toString)
128 // TODO: use axiom.toTriple instead
135 val atomA: TupleTableAtom = { 129 val atomA: TupleTableAtom = {
136 val cls = axiom.getSubClass.asInstanceOf[OWLClass].getIRI 130 val cls = axiom.getSubClass.asInstanceOf[OWLClass].getIRI
137 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, cls) 131 TupleTableAtom.rdf(varX, IRI.RDF_TYPE, cls)
138 } 132 }
139 def predIN(t: Term): TupleTableAtom = {
140 TupleTableAtom.rdf(
141 t,
142 RSA.rsa("IN"),
143 RSA.rsa(unfold.hashCode.toString)
144 )
145 }
146 def notIn(t: Term): Negation = Negation.create(predIN(t))
147 val roleRf: TupleTableAtom = { 133 val roleRf: TupleTableAtom = {
148 val visitor = 134 val visitor =
149 new RDFoxPropertyExprConverter(varX, v0, Forward) 135 new RDFoxPropertyExprConverter(varX, v0, Forward)
@@ -165,10 +151,10 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
165 // returning facts as `Rule`s with true body. While this is correct 151 // returning facts as `Rule`s with true body. While this is correct
166 // there is an easier way to import facts into RDFox. Are we able to 152 // there is an easier way to import facts into RDFox. Are we able to
167 // do that? 153 // do that?
168 val facts = unfold.map(x => Rule.create(predIN(x))) 154 val facts = unfold.map(x => Rule.create(RSA.In(x)))
169 val rules = List( 155 val rules = List(
170 Rule.create(roleRf, atomA, notIn(varX)), 156 Rule.create(roleRf, atomA, RSA.notIn(varX)),
171 Rule.create(atomB, atomA, notIn(varX)) 157 Rule.create(atomB, atomA, RSA.notIn(varX))
172 ) 158 )
173 facts ++ rules 159 facts ++ rules
174 } 160 }
@@ -180,9 +166,9 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
180 .getProperty 166 .getProperty
181 if (ontology.confl(roleR) contains roleR) { 167 if (ontology.confl(roleR) contains roleR) {
182 // Fresh Variables 168 // Fresh Variables
183 val v0 = RSA.rsa("v0_" ++ RSA.hashed(axiom)) 169 val v0 = RSA("v0_" ++ axiom.hashed)
184 val v1 = RSA.rsa("v1_" ++ RSA.hashed(axiom)) 170 val v1 = RSA("v1_" ++ axiom.hashed)
185 val v2 = RSA.rsa("v2_" ++ RSA.hashed(axiom)) 171 val v2 = RSA("v2_" ++ axiom.hashed)
186 // Predicates 172 // Predicates
187 def atomA(t: Term): TupleTableAtom = { 173 def atomA(t: Term): TupleTableAtom = {
188 val cls = axiom.getSubClass.asInstanceOf[OWLClass].getIRI 174 val cls = axiom.getSubClass.asInstanceOf[OWLClass].getIRI
@@ -220,7 +206,7 @@ class CanonicalModel(val ontology: RSAOntology) extends RSAAxiom {
220 .asInstanceOf[OWLObjectSomeValuesFrom] 206 .asInstanceOf[OWLObjectSomeValuesFrom]
221 .getProperty 207 .getProperty
222 // Fresh Variables 208 // Fresh Variables
223 val v1 = RSA.rsa("v1_" ++ RSA.hashed(axiom)) 209 val v1 = RSA("v1_" ++ axiom.hashed)
224 // Predicates 210 // Predicates
225 def atomA(t: Term): TupleTableAtom = { 211 def atomA(t: Term): TupleTableAtom = {
226 val cls = axiom.getSubClass.asInstanceOf[OWLClass].getIRI 212 val cls = axiom.getSubClass.asInstanceOf[OWLClass].getIRI
diff --git a/src/main/scala/rsacomb/FilteringProgram.scala b/src/main/scala/rsacomb/FilteringProgram.scala
index af07ac3..5aaf5b0 100644
--- a/src/main/scala/rsacomb/FilteringProgram.scala
+++ b/src/main/scala/rsacomb/FilteringProgram.scala
@@ -29,44 +29,43 @@ import scala.collection.JavaConverters._
29 29
30import implicits.RSAAtom 30import implicits.RSAAtom
31import suffix.{RSASuffix, Forward, Backward} 31import suffix.{RSASuffix, Forward, Backward}
32import util.RSA
32 33
33class FilteringProgram(query: SelectQuery, constants: List[Term]) 34class FilteringProgram(query: SelectQuery, constants: List[Term])
34 extends RSAAtom { 35 extends RSAAtom {
35 36
36 /* Makes mplicit conversion OWLAPI IRI <-> RDFox IRI available */ 37 /* Makes mplicit conversion OWLAPI IRI <-> RDFox IRI available */
37 import RDFoxUtil._ 38 // import implicits.RDFox._
38 39
39 lazy val variables = { 40 implicit val variables: (List[Term], List[Term]) = {
40 query.getQueryBody.getWherePattern match { 41 val all: Set[Variable] = query.getQueryBody.getWherePattern match {
41 case b: ConjunctionPattern => { 42 case b: ConjunctionPattern => {
42 b.getConjuncts.asScala.toSet.flatMap { conj: QueryPattern => 43 b.getConjuncts.asScala.toSet.flatMap { conj: QueryPattern =>
43 conj match { 44 conj match {
44 case c: TriplePattern => 45 case c: TriplePattern =>
45 Set(c.getSubject, c.getPredicate, c.getObject) 46 Set(c.getSubject, c.getPredicate, c.getObject).collect {
46 .filter(_.isInstanceOf[Variable]) 47 case v: Variable => v
48 }
47 case _ => Set() 49 case _ => Set()
48 } 50 }
49 } 51 }
50 } 52 }
51 case _ => Set() 53 case _ => Set()
52 } 54 }
53 }.toList
54
55 val answer: List[Term] =
56 if (query.getAllPossibleVariables) { 55 if (query.getAllPossibleVariables) {
57 variables 56 (all.toList, List())
58 } else { 57 } else {
59 query.getSelection.asScala.map(_.getVariable).toList 58 val answer = query.getSelection.asScala.map(_.getVariable).toSet
59 (answer.toList, (all &~ answer).toList)
60 } 60 }
61 val bounded: List[Term] = this.variables.filterNot(answer.contains(_)) 61 }
62
63 val (answer, bounded) = variables
62 64
63 val facts: List[Rule] = constants.map(c => Rule.create(predNI(c))) 65 val facts: List[Rule] = constants.map(c => Rule.create(RSA.NI(c)))
64 val rules: List[Rule] = 66 val rules: List[Rule] =
65 this.generateFilteringProgram().map(reifyRule) ++ facts 67 this.generateFilteringProgram().map(reifyRule) ++ facts
66 68
67 private def predNI(t: Term): TupleTableAtom =
68 TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA.rsa("NI"))
69
70 /* NOTE: we are restricting to queries that contain conjunctions of 69 /* NOTE: we are restricting to queries that contain conjunctions of
71 * atoms for the time being. This might need to be reviewed in the 70 * atoms for the time being. This might need to be reviewed in the
72 * future. 71 * future.
@@ -97,64 +96,54 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
97 val body = queryToBody(query.getQueryBody.getWherePattern) 96 val body = queryToBody(query.getQueryBody.getWherePattern)
98 // Auxiliar predicates/helpers 97 // Auxiliar predicates/helpers
99 def not(atom: TupleTableAtom): BodyFormula = Negation.create(atom) 98 def not(atom: TupleTableAtom): BodyFormula = Negation.create(atom)
100 val predQM = 99 // val predQM =
101 TupleTableAtom.create( 100 // TupleTableAtom.create(
102 TupleTableName.create(RSA.rsa("QM").getIRI), 101 // TupleTableName.create(RSA.Qm.getIRI),
103 (answer ++ bounded): _* 102 // (answer ++ bounded): _*
104 ) 103 // )
105 def predID(t1: Term, t2: Term) = 104 // def predID(t1: Term, t2: Term) =
106 TupleTableAtom.create( 105 // TupleTableAtom.create(
107 TupleTableName.create(RSA.rsa("ID").getIRI), 106 // TupleTableName.create(RSA.rsa("ID").getIRI),
108 (answer ++ bounded).appended(t1).appended(t2): _* 107 // (answer ++ bounded).appended(t1).appended(t2): _*
109 ) 108 // )
110 def predNAMED(t1: Term): TupleTableAtom = 109 // def predNAMED(t1: Term): TupleTableAtom =
111 TupleTableAtom.rdf(t1, IRI.RDF_TYPE, RSA.rsa("NAMED")) 110 // TupleTableAtom.rdf(t1, IRI.RDF_TYPE, RSA.rsa("NAMED"))
112 def predTQ(t1: Term, t2: Term, sx: RSASuffix) = 111 // def predTQ(t1: Term, t2: Term, sx: RSASuffix) =
113 TupleTableAtom.create( 112 // TupleTableAtom.create(
114 TupleTableName.create(RSA.rsa("TQ" :: sx).getIRI), 113 // TupleTableName.create(RSA.rsa("TQ" :: sx).getIRI),
115 (answer ++ bounded).appended(t1).appended(t2): _* 114 // (answer ++ bounded).appended(t1).appended(t2): _*
116 ) 115 // )
117 def predAQ(t1: Term, t2: Term, sx: RSASuffix) = 116 // def predAQ(t1: Term, t2: Term, sx: RSASuffix) =
118 TupleTableAtom.create( 117 // TupleTableAtom.create(
119 TupleTableName.create(RSA.rsa("AQ" :: sx).getIRI), 118 // TupleTableName.create(RSA.rsa("AQ" :: sx).getIRI),
120 (answer ++ bounded).appended(t1).appended(t2): _* 119 // (answer ++ bounded).appended(t1).appended(t2): _*
121 ) 120 // )
122 val predFK = 121 // val predFK =
123 TupleTableAtom.create( 122 // TupleTableAtom.create(
124 TupleTableName.create(RSA.rsa("FK").getIRI), 123 // TupleTableName.create(RSA.rsa("FK").getIRI),
125 (answer ++ bounded): _* 124 // (answer ++ bounded): _*
126 ) 125 // )
127 val predSP = 126 // val predSP =
128 TupleTableAtom.create( 127 // TupleTableAtom.create(
129 TupleTableName.create(RSA.rsa("SP").getIRI), 128 // TupleTableName.create(RSA.rsa("SP").getIRI),
130 (answer ++ bounded): _* 129 // (answer ++ bounded): _*
131 ) 130 // )
132 val predANS = 131 // val predANS =
133 TupleTableAtom.create( 132 // TupleTableAtom.create(
134 TupleTableName.create(RSA.rsa("ANS").getIRI), 133 // TupleTableName.create(RSA.rsa("ANS").getIRI),
135 answer: _* 134 // answer: _*
136 ) 135 // )
137 136
138 /* Rule 1 */ 137 /* Rule 1 */
139 val r1 = Rule.create(predQM, body: _*) 138 val r1 = Rule.create(RSA.QM, body: _*)
140 139
141 /* Rules 3x */ 140 /* Rules 3x */
142 val r3a = 141 val r3a =
143 for ((v, i) <- bounded.zipWithIndex) 142 for ((v, i) <- bounded.zipWithIndex)
144 yield Rule.create( 143 yield Rule.create(RSA.ID(RSA(i), RSA(i)), RSA.QM, not(RSA.NI(v)))
145 predID(RSA.rsa(i), RSA.rsa(i)), 144 val r3b = Rule.create(RSA.ID(varV, varU), RSA.ID(varU, varV))
146 predQM, 145 val r3c =
147 not(predNI(v)) 146 Rule.create(RSA.ID(varU, varW), RSA.ID(varU, varV), RSA.ID(varV, varW))
148 )
149 val r3b = Rule.create(
150 predID(varV, varU),
151 predID(varU, varV)
152 )
153 val r3c = Rule.create(
154 predID(varU, varW),
155 predID(varU, varV),
156 predID(varV, varW)
157 )
158 147
159 /* Rules 4x */ 148 /* Rules 4x */
160 val r4a = for { 149 val r4a = for {
@@ -163,20 +152,14 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
163 role2 <- body.filter(_.isRoleAssertion) 152 role2 <- body.filter(_.isRoleAssertion)
164 if bounded contains (role2.getArguments.get(2)) 153 if bounded contains (role2.getArguments.get(2))
165 } yield Rule.create( 154 } yield Rule.create(
166 predFK, 155 RSA.FK,
167 role1 << Forward, 156 role1 << Forward,
168 role2 << Forward, 157 role2 << Forward,
169 predID( 158 RSA.ID(
170 RSA.rsa(bounded.indexOf(role1.getArguments.get(2))), 159 RSA(bounded.indexOf(role1.getArguments.get(2))),
171 RSA.rsa(bounded.indexOf(role2.getArguments.get(2))) 160 RSA(bounded.indexOf(role2.getArguments.get(2)))
172 ), 161 ),
173 not( 162 not(RSA.EquivTo(role1.getArguments.get(0), role2.getArguments.get(0)))
174 TupleTableAtom.rdf(
175 role1.getArguments.get(0),
176 RSA.EquivTo,
177 role2.getArguments.get(0)
178 )
179 )
180 ) 163 )
181 val r4b = for { 164 val r4b = for {
182 role1 <- body.filter(_.isRoleAssertion) 165 role1 <- body.filter(_.isRoleAssertion)
@@ -184,20 +167,14 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
184 role2 <- body.filter(_.isRoleAssertion) 167 role2 <- body.filter(_.isRoleAssertion)
185 if bounded contains (role2.getArguments.get(0)) 168 if bounded contains (role2.getArguments.get(0))
186 } yield Rule.create( 169 } yield Rule.create(
187 predFK, 170 RSA.FK,
188 role1 << Forward, 171 role1 << Forward,
189 role2 << Backward, 172 role2 << Backward,
190 predID( 173 RSA.ID(
191 RSA.rsa(bounded.indexOf(role1.getArguments.get(2))), 174 RSA(bounded.indexOf(role1.getArguments.get(2))),
192 RSA.rsa(bounded.indexOf(role2.getArguments.get(0))) 175 RSA(bounded.indexOf(role2.getArguments.get(0)))
193 ), 176 ),
194 not( 177 not(RSA.EquivTo(role1.getArguments.get(0), role2.getArguments.get(2)))
195 TupleTableAtom.rdf(
196 role1.getArguments.get(0),
197 RSA.EquivTo,
198 role2.getArguments.get(2)
199 )
200 )
201 ) 178 )
202 val r4c = for { 179 val r4c = for {
203 role1 <- body.filter(_.isRoleAssertion) 180 role1 <- body.filter(_.isRoleAssertion)
@@ -205,20 +182,14 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
205 role2 <- body.filter(_.isRoleAssertion) 182 role2 <- body.filter(_.isRoleAssertion)
206 if bounded contains (role2.getArguments.get(0)) 183 if bounded contains (role2.getArguments.get(0))
207 } yield Rule.create( 184 } yield Rule.create(
208 predFK, 185 RSA.FK,
209 role1 << Backward, 186 role1 << Backward,
210 role2 << Backward, 187 role2 << Backward,
211 predID( 188 RSA.ID(
212 RSA.rsa(bounded.indexOf(role1.getArguments.get(0))), 189 RSA(bounded.indexOf(role1.getArguments.get(0))),
213 RSA.rsa(bounded.indexOf(role2.getArguments.get(0))) 190 RSA(bounded.indexOf(role2.getArguments.get(0)))
214 ), 191 ),
215 not( 192 not(RSA.EquivTo(role1.getArguments.get(2), role2.getArguments.get(2)))
216 TupleTableAtom.rdf(
217 role1.getArguments.get(2),
218 RSA.EquivTo,
219 role2.getArguments.get(2)
220 )
221 )
222 ) 193 )
223 194
224 /* Rules 5x */ 195 /* Rules 5x */
@@ -234,18 +205,18 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
234 if bounded contains role2arg0 205 if bounded contains role2arg0
235 if bounded contains role2arg2 206 if bounded contains role2arg2
236 } yield Rule.create( 207 } yield Rule.create(
237 predID( 208 RSA.ID(
238 RSA.rsa(bounded indexOf role1arg0), 209 RSA(bounded indexOf role1arg0),
239 RSA.rsa(bounded indexOf role2arg0) 210 RSA(bounded indexOf role2arg0)
240 ), 211 ),
241 role1 << Forward, 212 role1 << Forward,
242 role2 << Forward, 213 role2 << Forward,
243 predID( 214 RSA.ID(
244 RSA.rsa(bounded indexOf role1arg2), 215 RSA(bounded indexOf role1arg2),
245 RSA.rsa(bounded indexOf role2arg2) 216 RSA(bounded indexOf role2arg2)
246 ), 217 ),
247 TupleTableAtom.rdf(role1arg0, RSA.EquivTo, role2arg0), 218 RSA.EquivTo(role1arg0, role2arg0),
248 not(predNI(role1arg0)) 219 not(RSA.NI(role1arg0))
249 ) 220 )
250 val r5b = for { 221 val r5b = for {
251 role1 <- body.filter(_.isRoleAssertion) 222 role1 <- body.filter(_.isRoleAssertion)
@@ -259,18 +230,18 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
259 if bounded contains role2arg0 230 if bounded contains role2arg0
260 if bounded contains role2arg2 231 if bounded contains role2arg2
261 } yield Rule.create( 232 } yield Rule.create(
262 predID( 233 RSA.ID(
263 RSA.rsa(bounded indexOf role1arg0), 234 RSA(bounded indexOf role1arg0),
264 RSA.rsa(bounded indexOf role2arg2) 235 RSA(bounded indexOf role2arg2)
265 ), 236 ),
266 role1 << Forward, 237 role1 << Forward,
267 role2 << Backward, 238 role2 << Backward,
268 predID( 239 RSA.ID(
269 RSA.rsa(bounded indexOf role1arg2), 240 RSA(bounded indexOf role1arg2),
270 RSA.rsa(bounded indexOf role2arg0) 241 RSA(bounded indexOf role2arg0)
271 ), 242 ),
272 TupleTableAtom.rdf(role1arg0, RSA.EquivTo, role2arg2), 243 RSA.EquivTo(role1arg0, role2arg2),
273 not(predNI(role1arg0)) 244 not(RSA.NI(role1arg0))
274 ) 245 )
275 val r5c = for { 246 val r5c = for {
276 role1 <- body.filter(_.isRoleAssertion) 247 role1 <- body.filter(_.isRoleAssertion)
@@ -284,18 +255,18 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
284 if bounded contains role2arg0 255 if bounded contains role2arg0
285 if bounded contains role2arg2 256 if bounded contains role2arg2
286 } yield Rule.create( 257 } yield Rule.create(
287 predID( 258 RSA.ID(
288 RSA.rsa(bounded indexOf role1arg2), 259 RSA(bounded indexOf role1arg2),
289 RSA.rsa(bounded indexOf role2arg2) 260 RSA(bounded indexOf role2arg2)
290 ), 261 ),
291 role1 << Backward, 262 role1 << Backward,
292 role2 << Backward, 263 role2 << Backward,
293 predID( 264 RSA.ID(
294 RSA.rsa(bounded indexOf role1arg0), 265 RSA(bounded indexOf role1arg0),
295 RSA.rsa(bounded indexOf role2arg0) 266 RSA(bounded indexOf role2arg0)
296 ), 267 ),
297 TupleTableAtom.rdf(role1arg2, RSA.EquivTo, role2arg2), 268 RSA.EquivTo(role1arg2, role2arg2),
298 not(predNI(role1arg2)) 269 not(RSA.NI(role1arg2))
299 ) 270 )
300 271
301 /* Rules 6 */ 272 /* Rules 6 */
@@ -308,10 +279,10 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
308 if bounded contains arg2 279 if bounded contains arg2
309 suffix <- Seq(Forward, Backward) 280 suffix <- Seq(Forward, Backward)
310 } yield Rule.create( 281 } yield Rule.create(
311 predAQ(varV, varW, suffix), 282 RSA.AQ(varV, varW, suffix),
312 role << suffix, 283 role << suffix,
313 predID(RSA.rsa(bounded indexOf arg0), varV), 284 RSA.ID(RSA(bounded indexOf arg0), varV),
314 predID(RSA.rsa(bounded indexOf arg2), varW) 285 RSA.ID(RSA(bounded indexOf arg2), varW)
315 ) 286 )
316 } 287 }
317 288
@@ -319,52 +290,33 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
319 val r7a = { 290 val r7a = {
320 for (suffix <- List(Forward, Backward)) 291 for (suffix <- List(Forward, Backward))
321 yield Rule.create( 292 yield Rule.create(
322 predTQ(varU, varV, suffix), 293 RSA.TQ(varU, varV, suffix),
323 predAQ(varU, varV, suffix) 294 RSA.AQ(varU, varV, suffix)
324 ) 295 )
325 } 296 }
326 val r7b = { 297 val r7b = {
327 for (suffix <- List(Forward, Backward)) 298 for (suffix <- List(Forward, Backward))
328 yield Rule.create( 299 yield Rule.create(
329 predTQ(varU, varW, suffix), 300 RSA.TQ(varU, varW, suffix),
330 predAQ(varU, varV, suffix), 301 RSA.AQ(varU, varV, suffix),
331 predTQ(varV, varW, suffix) 302 RSA.TQ(varV, varW, suffix)
332 ) 303 )
333 } 304 }
334 305
335 /* Rules 8x */ 306 /* Rules 8x */
336 val r8a = 307 val r8a =
337 for (v <- answer) yield Rule.create(predSP, predQM, not(predNAMED(v))) 308 for (v <- answer) yield Rule.create(RSA.SP, RSA.QM, not(RSA.Named(v)))
338 val r8b = 309 val r8b =
339 Rule.create(predSP, predFK) 310 Rule.create(RSA.SP, RSA.FK)
340 val r8c = 311 val r8c =
341 for (suffix <- List(Forward, Backward)) 312 for (suffix <- List(Forward, Backward))
342 yield Rule.create( 313 yield Rule.create(
343 predSP, 314 RSA.SP,
344 predTQ(varV, varV, suffix) 315 RSA.TQ(varV, varV, suffix)
345 ) 316 )
346 317
347 /* Rule 9 */ 318 /* Rule 9 */
348 val r9 = Rule.create(predANS, predQM, not(predSP)) 319 val r9 = Rule.create(RSA.Ans, RSA.QM, not(RSA.SP))
349
350 // List.empty
351 // .prepended(r9)
352 // .prependedAll(r8c)
353 // .prepended(r8b)
354 // .prependedAll(r8a)
355 // .prependedAll(r7b)
356 // .prependedAll(r7a)
357 // .prependedAll(r6)
358 // .prependedAll(r5c)
359 // .prependedAll(r5b)
360 // .prependedAll(r5a)
361 // .prependedAll(r4c)
362 // .prependedAll(r4b)
363 // .prependedAll(r4a)
364 // .prepended(r3c)
365 // .prepended(r3b)
366 // .prependedAll(r3a)
367 // .prepended(r1)
368 320
369 r1 :: 321 r1 ::
370 r3a ::: r3b :: r3c :: 322 r3a ::: r3b :: r3c ::
@@ -377,26 +329,6 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
377 List() 329 List()
378 } 330 }
379 331
380 // private def reifyTupleTableAtom(
381 // atom: TupleTableAtom
382 // ): (Option[BindAtom], List[TupleTableAtom]) = {
383 // if (!atom.isRDF) {
384 // // Compute binding atom
385 // val bvar = RSA.getFreshVariable()
386 // val name =
387 // Literal.create(atom.getTupleTableName.toString(), Datatype.XSD_STRING)
388 // val args = atom.getArguments.asScala.toList.prepended(name)
389 // val bind = BindAtom.create(FunctionCall.create("SKOLEM", args: _*), bvar)
390 // // Compute reified atom
391 // def reifiedIRI(i: Int) = atom.getTupleTableName.getName ++ s"_$i"
392 // val atoms = atom.getArguments.asScala.toList.zipWithIndex
393 // .map { case (t, i) => TupleTableAtom.rdf(bvar, reifiedIRI(i), t) }
394 // (Some(bind), atoms)
395 // } else {
396 // (None, List(atom))
397 // }
398 // }
399
400 private def reifyAtom(atom: Atom): (Option[BindAtom], List[Atom]) = { 332 private def reifyAtom(atom: Atom): (Option[BindAtom], List[Atom]) = {
401 atom match { 333 atom match {
402 case atom: TupleTableAtom => atom.reified 334 case atom: TupleTableAtom => atom.reified
diff --git a/src/main/scala/rsacomb/Main.scala b/src/main/scala/rsacomb/Main.scala
index 8270205..31dd5a0 100644
--- a/src/main/scala/rsacomb/Main.scala
+++ b/src/main/scala/rsacomb/Main.scala
@@ -10,7 +10,7 @@ import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
10import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term} 10import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term}
11 11
12/* Local imports */ 12/* Local imports */
13import rsacomb.RSA._ 13import util.{RDFoxHelpers, RSA}
14 14
15object RSAComb extends App { 15object RSAComb extends App {
16 16
@@ -56,8 +56,10 @@ object RSAComb extends App {
56 if (ontology.isRSA) { 56 if (ontology.isRSA) {
57 57
58 /* Load query */ 58 /* Load query */
59 val query = RDFoxUtil.parseQuery( 59 val query = RDFoxHelpers.parseSelectQuery(
60 """ 60 """
61 PREFIX : <http://example.com/rsa_example.owl#>
62
61 SELECT ?X 63 SELECT ?X
62 WHERE { 64 WHERE {
63 ?X a :D ; 65 ?X a :D ;
@@ -71,8 +73,11 @@ object RSAComb extends App {
71 /* Compute answers to query */ 73 /* Compute answers to query */
72 query match { 74 query match {
73 case Some(query) => { 75 case Some(query) => {
76
77 import implicits.JavaCollections._
78
74 // Open connection to RDFox 79 // Open connection to RDFox
75 val (server, data) = RDFoxUtil.openConnection("AnswerComputation") 80 val (server, data) = RDFoxHelpers.openConnection("AnswerComputation")
76 81
77 { 82 {
78 println("\nQuery") 83 println("\nQuery")
@@ -81,7 +86,7 @@ object RSAComb extends App {
81 86
82 // Step 1. Computing the canonical model 87 // Step 1. Computing the canonical model
83 val canon = ontology.canonicalModel 88 val canon = ontology.canonicalModel
84 data.addRules(canon.rules.asJava) 89 data.addRules(canon.rules)
85 90
86 { 91 {
87 println("\nCanonical Model rules:") 92 println("\nCanonical Model rules:")
@@ -90,129 +95,136 @@ object RSAComb extends App {
90 95
91 // Step 2. Computing the canonical model 96 // Step 2. Computing the canonical model
92 val nis = { 97 val nis = {
93 val query = 98 val query = "SELECT ?Y WHERE { ?X rsa:EquivTo ?Y ; a rsa:Named . }"
94 "SELECT ?Y WHERE { ?X rsa:EquivTo ?Y ; a rsa:NAMED . }" 99 RDFoxHelpers.submitSelectQuery(data, query, RSA.Prefixes).flatten
95 val cursor =
96 data.createCursor(
97 RSA.Prefixes,
98 query,
99 new HashMap[String, String]()
100 );
101 var mul = cursor.open()
102 var iris: List[IRI] = List()
103 while (mul > 0) {
104 println(cursor.getResource(0))
105 iris = cursor.getResource(0) match {
106 case iri: IRI => iri :: iris
107 case _ => iris
108 }
109 mul = cursor.advance()
110 }
111 iris
112 } 100 }
113 val filter = ontology.filteringProgram(query, nis) 101 val filter = ontology.filteringProgram(query, nis)
114 data.addRules(filter.rules.asJava) 102 data.addRules(filter.rules)
115 103
116 { 104 {
117 println("\nFiltering rules") 105 println("\nFiltering rules")
118 filter.rules.foreach(println) 106 filter.rules.foreach(println)
119 } 107 }
120 108
121 def retrieveInstances(pred: String, arity: Int): Unit = {
122 // Build query
123 var query = "SELECT"
124 for (i <- 0 until arity) {
125 query ++= s" ?X$i"
126 }
127 query ++= " WHERE {"
128 for (i <- 0 until arity) {
129 query ++= s" ?S rsa:${pred}_$i ?X$i ."
130 }
131 query ++= " }"
132 // Collect answers
133 RDFoxUtil.submitQuery(
134 data,
135 RSA.Prefixes,
136 query,
137 arity
138 )
139 }
140
141 // Retrieve answers 109 // Retrieve answers
142 println("\nAnswers:") 110 println("\nAnswers:")
143 retrieveInstances("ANS", filter.answer.length) 111 val ans =
112 RDFoxHelpers.queryInternalPredicate(data, "Ans", filter.answer.length)
113 println(ans)
144 114
145 /* DEBUG: adding additional checks 115 /* DEBUG: adding additional checks
146 */ 116 */
147 println("\nIndividuals:")
148 ontology.individuals.foreach(println)
149
150 println("\nThings:")
151 RDFoxUtil.submitQuery(
152 data,
153 RSA.Prefixes,
154 "SELECT ?X { ?X a owl:Thing }",
155 1
156 )
157
158 println("\nNAMEDs:")
159 RDFoxUtil.submitQuery(
160 data,
161 RSA.Prefixes,
162 "SELECT ?X { ?X a rsa:NAMED }",
163 1
164 )
165
166 println("\nNIs:")
167 RDFoxUtil.submitQuery(
168 data,
169 RSA.Prefixes,
170 "SELECT ?X { ?X a rsa:NI }",
171 1
172 )
173
174 // ID instances
175 println("\nID instances:")
176 retrieveInstances("ID", filter.variables.length + 2)
177
178 println("\nSameAs instances:")
179 RDFoxUtil.submitQuery(
180 data,
181 RSA.Prefixes,
182 "SELECT ?X ?Y { ?X rsa:EquivTo ?Y }",
183 2
184 )
185
186 // Unfiltered answers
187 println("\nPossible answers:")
188 retrieveInstances("QM", filter.variables.length)
189
190 // Cycle detected
191 println("\nCycle detection:")
192 retrieveInstances("AQ_f", filter.variables.length + 2)
193 retrieveInstances("AQ_b", filter.variables.length + 2)
194
195 // Forks detected
196 println("\nForks:")
197 retrieveInstances("FK", filter.variables.length)
198
199 // Spurious answers
200 println("\nSpurious answers")
201 retrieveInstances("SP", filter.variables.length)
202
203 { 117 {
204 val cursor = data.createCursor( 118 import suffix.{Forward, Backward}
205 RSA.Prefixes, 119
206 "ASK { :a a :D }", 120 val arity = filter.answer.length + filter.bounded.length
207 new HashMap[String, String]() 121
208 ); 122 println("\nIndividuals:")
209 var mul = cursor.open() 123 ontology.individuals.foreach(println)
210 println(s"Answer: ${mul > 0}") 124
211 cursor.close(); 125 println("\nThings:")
126 val things = RDFoxHelpers.submitSelectQuery(
127 data,
128 """
129 PREFIX owl: <http://www.w3.org/2002/07/owl#>
130
131 SELECT ?X {
132 ?X a owl:Thing
133 }
134 """
135 )
136 println(things)
137
138 println("\nNAMEDs:")
139 val named = RDFoxHelpers.submitSelectQuery(
140 data,
141 """
142 SELECT ?X {
143 ?X a rsa:Named
144 }
145 """,
146 RSA.Prefixes
147 )
148 println(named)
149
150 println("\nNIs:")
151 val nis = RDFoxHelpers.submitSelectQuery(
152 data,
153 """
154 SELECT ?X {
155 ?X a rsa:NI
156 }
157 """,
158 RSA.Prefixes
159 )
160 println(nis)
161
162 // ID instances
163 println("\nIDs:")
164 val ids = RDFoxHelpers.queryInternalPredicate(
165 data,
166 "ID",
167 arity + 2
168 )
169 println(ids)
170
171 println("\nEquivTo:")
172 val equivs = RDFoxHelpers.submitSelectQuery(
173 data,
174 """
175 SELECT ?X ?Y {
176 ?X rsa:EquivTo ?Y
177 }
178 """,
179 RSA.Prefixes
180 )
181 println(equivs)
182
183 // Unfiltered answers
184 println("\nPossible answers:")
185 val qms = RDFoxHelpers.queryInternalPredicate(
186 data,
187 "QM",
188 arity
189 )
190 println(qms)
191
192 // Cycle detected
193 println("\nCycle detection:")
194 val aqf = RDFoxHelpers.queryInternalPredicate(
195 data,
196 "AQ" :: Forward,
197 arity + 2
198 )
199 val aqb = RDFoxHelpers.queryInternalPredicate(
200 data,
201 "AQ" :: Backward,
202 arity + 2
203 )
204 println(aqf)
205 println(aqb)
206
207 // Forks detected
208 println("\nForks:")
209 val fk = RDFoxHelpers.queryInternalPredicate(
210 data,
211 "FK",
212 arity
213 )
214 println(fk)
215
216 // Spurious answers
217 println("\nSpurious answers")
218 val sp = RDFoxHelpers.queryInternalPredicate(
219 data,
220 "SP",
221 arity
222 )
223 println(sp)
212 } 224 }
213 225
214 // Close connection to RDFox 226 // Close connection to RDFox
215 RDFoxUtil.closeConnection(server, data) 227 RDFoxHelpers.closeConnection(server, data)
216 } 228 }
217 case None => {} 229 case None => {}
218 } 230 }
diff --git a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
index 0368b7c..9b78e8e 100644
--- a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
@@ -78,7 +78,7 @@ class RDFoxAxiomConverter(
78 } 78 }
79 79
80 override def visit(axiom: OWLSubObjectPropertyOfAxiom): List[Rule] = { 80 override def visit(axiom: OWLSubObjectPropertyOfAxiom): List[Rule] = {
81 val term1 = RSA.getFreshVariable() 81 val term1 = RSAOntology.genFreshVariable()
82 val subVisitor = 82 val subVisitor =
83 new RDFoxPropertyExprConverter(term, term1, suffix) 83 new RDFoxPropertyExprConverter(term, term1, suffix)
84 val superVisitor = new RDFoxPropertyExprConverter(term, term1, suffix) 84 val superVisitor = new RDFoxPropertyExprConverter(term, term1, suffix)
diff --git a/src/main/scala/rsacomb/RDFoxClassExprConverter.scala b/src/main/scala/rsacomb/RDFoxClassExprConverter.scala
index f3a0dfc..f4187ed 100644
--- a/src/main/scala/rsacomb/RDFoxClassExprConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxClassExprConverter.scala
@@ -26,12 +26,11 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{
26 IRI 26 IRI
27} 27}
28 28
29import rsacomb.SkolemStrategy
30import rsacomb.RDFoxRuleShards
31import org.semanticweb.owlapi.model.OWLObjectPropertyExpression 29import org.semanticweb.owlapi.model.OWLObjectPropertyExpression
32import org.semanticweb.owlapi.model.OWLObjectProperty 30import org.semanticweb.owlapi.model.OWLObjectProperty
33 31
34import suffix.{RSASuffix, Empty} 32import suffix.{RSASuffix, Empty}
33import util.RSA
35 34
36object RDFoxClassExprConverter { 35object RDFoxClassExprConverter {
37 36
@@ -61,7 +60,7 @@ class RDFoxClassExprConverter(
61 suffix: RSASuffix 60 suffix: RSASuffix
62) extends OWLClassExpressionVisitorEx[RDFoxRuleShards] { 61) extends OWLClassExpressionVisitorEx[RDFoxRuleShards] {
63 62
64 import RDFoxUtil.owlapi2rdfox; 63 import implicits.RDFox._
65 64
66 // OWLClass 65 // OWLClass
67 override def visit(expr: OWLClass): RDFoxRuleShards = { 66 override def visit(expr: OWLClass): RDFoxRuleShards = {
@@ -99,7 +98,7 @@ class RDFoxClassExprConverter(
99 98
100 // OWLObjectSomeValuesFrom 99 // OWLObjectSomeValuesFrom
101 override def visit(expr: OWLObjectSomeValuesFrom): RDFoxRuleShards = { 100 override def visit(expr: OWLObjectSomeValuesFrom): RDFoxRuleShards = {
102 val y = RSA.getFreshVariable() 101 val y = RSAOntology.genFreshVariable()
103 // Here we are assuming a role name 102 // Here we are assuming a role name
104 val prop = expr.getProperty() 103 val prop = expr.getProperty()
105 // Computes the result of rule skolemization. Depending on the used 104 // Computes the result of rule skolemization. Depending on the used
@@ -110,14 +109,7 @@ class RDFoxClassExprConverter(
110 case SkolemStrategy.Constant(c) => (List(), List(), c) 109 case SkolemStrategy.Constant(c) => (List(), List(), c)
111 case SkolemStrategy.ConstantRSA(c) => { 110 case SkolemStrategy.ConstantRSA(c) => {
112 if (unsafe.contains(prop)) 111 if (unsafe.contains(prop))
113 ( 112 (List(RSA.PE(term, c), RSA.U(c)), List(), c)
114 List(
115 TupleTableAtom.rdf(term, RSA.rsa("PE"), c),
116 TupleTableAtom.rdf(c, IRI.RDF_TYPE, RSA.rsa("U"))
117 ),
118 List(),
119 c
120 )
121 else 113 else
122 (List(), List(), c) 114 (List(), List(), c)
123 } 115 }
@@ -143,7 +135,8 @@ class RDFoxClassExprConverter(
143 // OWLObjectMaxCardinality 135 // OWLObjectMaxCardinality
144 override def visit(expr: OWLObjectMaxCardinality): RDFoxRuleShards = { 136 override def visit(expr: OWLObjectMaxCardinality): RDFoxRuleShards = {
145 // TODO: again, no hardcoded variables 137 // TODO: again, no hardcoded variables
146 val vars = List(RSA.getFreshVariable(), RSA.getFreshVariable()) 138 val vars =
139 List(RSAOntology.genFreshVariable(), RSAOntology.genFreshVariable())
147 val classResult = RDFoxClassExprConverter.merge( 140 val classResult = RDFoxClassExprConverter.merge(
148 vars 141 vars
149 .map(new RDFoxClassExprConverter(_, unsafe, skolem, suffix)) 142 .map(new RDFoxClassExprConverter(_, unsafe, skolem, suffix))
diff --git a/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala b/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala
index 525ec62..826e965 100644
--- a/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala
@@ -17,7 +17,7 @@ class RDFoxPropertyExprConverter(
17) extends OWLPropertyExpressionVisitorEx[List[TupleTableAtom]] { 17) extends OWLPropertyExpressionVisitorEx[List[TupleTableAtom]] {
18 18
19 // Automatically converts OWLAPI types into RDFox equivalent types. 19 // Automatically converts OWLAPI types into RDFox equivalent types.
20 import RDFoxUtil.owlapi2rdfox; 20 import implicits.RDFox._
21 21
22 override def visit(expr: OWLObjectProperty): List[TupleTableAtom] = { 22 override def visit(expr: OWLObjectProperty): List[TupleTableAtom] = {
23 val base = expr.getIRI.getIRIString 23 val base = expr.getIRI.getIRIString
diff --git a/src/main/scala/rsacomb/RDFoxUtil.scala b/src/main/scala/rsacomb/RDFoxUtil.scala
deleted file mode 100644
index 653c51f..0000000
--- a/src/main/scala/rsacomb/RDFoxUtil.scala
+++ /dev/null
@@ -1,113 +0,0 @@
1package rsacomb
2
3/* Java imports */
4import java.util.HashMap
5import java.io.StringReader
6import tech.oxfordsemantic.jrdfox.Prefixes
7import tech.oxfordsemantic.jrdfox.logic.sparql.statement.{Query, SelectQuery}
8import tech.oxfordsemantic.jrdfox.client.{
9 ConnectionFactory,
10 ServerConnection,
11 DataStoreConnection
12}
13import tech.oxfordsemantic.jrdfox.formats.SPARQLParser
14
15import tech.oxfordsemantic.jrdfox.logic.expression.{IRI => RDFox_IRI}
16import org.semanticweb.owlapi.model.{IRI => OWL_IRI}
17
18import scala.collection.JavaConverters._
19
20object RDFoxUtil {
21
22 implicit def rdfox2owlapi(iri: RDFox_IRI): OWL_IRI = {
23 OWL_IRI.create(iri.getIRI)
24 }
25
26 implicit def owlapi2rdfox(iri: OWL_IRI): RDFox_IRI = {
27 RDFox_IRI.create(iri.getIRIString())
28 }
29
30 implicit def stringToRDFoxIRI(iri: String): RDFox_IRI = {
31 RDFox_IRI.create(iri)
32 }
33
34 implicit def javaToScalaList[A](list: java.util.List[A]): List[A] = {
35 list.asScala.toList
36 }
37
38 implicit def scalaToJavaList[A](list: List[A]): java.util.List[A] = {
39 list.asJava
40 }
41
42 def openConnection(
43 dataStore: String
44 ): (ServerConnection, DataStoreConnection) = {
45 /* Create local server connection
46 */
47 val serverUrl = "rdfox:local"
48 val role = ""
49 val password = ""
50 val server =
51 ConnectionFactory.newServerConnection(serverUrl, role, password)
52
53 /* Create datastore connection
54 */
55 val parameters = new HashMap[String, String]()
56 parameters.put("owl-in-rdf-support", "relaxed")
57 //parameters.put("equality", "noUNA")
58 server.createDataStore(dataStore, "par-complex-nn", parameters)
59 val data = server.newDataStoreConnection(dataStore)
60
61 (server, data)
62 }
63
64 def parseQuery(
65 query: String,
66 prefixes: Prefixes = RSA.Prefixes
67 ): Option[SelectQuery] = {
68 val parser = new SPARQLParser(
69 prefixes,
70 new StringReader(query)
71 )
72 // NOTE: return only conjunctive queries for now (SelectQuery)
73 parser.parseSingleQuery() match {
74 case q: SelectQuery => Some(q)
75 case _ => None
76 }
77 }
78
79 def submitQuery(
80 data: DataStoreConnection,
81 prefixes: Prefixes,
82 query: String,
83 answers: Int
84 ): Unit = {
85 println(s"\nQUERY {\n$query\n}")
86 val cursor = data.createCursor(
87 prefixes,
88 query,
89 new HashMap[String, String]()
90 );
91 var mul = cursor.open()
92 while (mul > 0) {
93 print("Answer: ")
94 for (i <- 0 until answers) {
95 val res = cursor.getResource(i)
96 print(s"$res ")
97 }
98 println()
99 mul = cursor.advance()
100 }
101 cursor.close();
102 println(s"QUERY END")
103 }
104
105 def closeConnection(
106 server: ServerConnection,
107 data: DataStoreConnection
108 ): Unit = {
109 server.close();
110 data.close();
111 }
112
113} // object RDFoxUtil
diff --git a/src/main/scala/rsacomb/RSA.scala b/src/main/scala/rsacomb/RSA.scala
index b0e140b..1b2aa9c 100644
--- a/src/main/scala/rsacomb/RSA.scala
+++ b/src/main/scala/rsacomb/RSA.scala
@@ -1,11 +1,16 @@
1package rsacomb 1package rsacomb.util
2 2
3/* Java imports */ 3/* Java imports */
4import java.util.Map 4import java.util.Map
5 5
6import tech.oxfordsemantic.jrdfox.formats.SPARQLParser 6import tech.oxfordsemantic.jrdfox.formats.SPARQLParser
7import tech.oxfordsemantic.jrdfox.Prefixes 7import tech.oxfordsemantic.jrdfox.Prefixes
8import tech.oxfordsemantic.jrdfox.logic.expression.{Variable, IRI} 8import tech.oxfordsemantic.jrdfox.logic.datalog.{
9 TupleTableAtom,
10 TupleTableName,
11 Negation
12}
13import tech.oxfordsemantic.jrdfox.logic.expression.{Term, Variable, IRI}
9import org.semanticweb.owlapi.model.OWLOntology 14import org.semanticweb.owlapi.model.OWLOntology
10import org.semanticweb.owlapi.model.{ 15import org.semanticweb.owlapi.model.{
11 OWLAxiom, 16 OWLAxiom,
@@ -13,51 +18,83 @@ import org.semanticweb.owlapi.model.{
13 OWLObjectPropertyExpression 18 OWLObjectPropertyExpression
14} 19}
15 20
21import rsacomb.suffix.RSASuffix
22
16// Debug only 23// Debug only
17import scala.collection.JavaConverters._ 24import scala.collection.JavaConverters._
18 25
19object RSA extends RSAAxiom { 26object RSA {
20 27
21 val Prefixes: Prefixes = new Prefixes() 28 val Prefixes: Prefixes = new Prefixes()
22 Prefixes.declarePrefix(":", "http://example.com/rsa_example.owl#")
23 Prefixes.declarePrefix("rsa:", "http://127.0.0.1/") 29 Prefixes.declarePrefix("rsa:", "http://127.0.0.1/")
24 Prefixes.declarePrefix("rdf:", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
25 Prefixes.declarePrefix("rdfs:", "http://www.w3.org/2000/01/rdf-schema#")
26 Prefixes.declarePrefix("owl:", "http://www.w3.org/2002/07/owl#")
27 30
28 val EquivTo: IRI = this.rsa("EquivTo") 31 private def atom(name: IRI, vars: List[Term]) =
29 val Named: IRI = this.rsa("NAMED") 32 TupleTableAtom.create(TupleTableName.create(name.getIRI), vars: _*)
33
34 def PE(t1: Term, t2: Term) =
35 TupleTableAtom.rdf(t1, RSA("PE"), t2)
36
37 def U(t: Term) =
38 TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("U"))
39
40 def In(t: Term)(implicit set: Term) =
41 TupleTableAtom.rdf(t, RSA("In"), set)
42
43 def notIn(t: Term)(implicit set: Term) = Negation.create(In(t)(set))
30 44
31 // Counter used to implement a simple fresh variable generator 45 def EquivTo(t1: Term, t2: Term) =
32 private var counter = -1; 46 TupleTableAtom.rdf(t1, RSA("EquivTo"), t2)
33 47
34 def getFreshVariable(): Variable = { 48 def QM(implicit variables: (List[Term], List[Term])) = {
35 counter += 1 49 val (answer, bounded) = variables
36 Variable.create(f"I$counter%03d") 50 atom(RSA("QM"), answer ::: bounded)
37 } 51 }
38 52
39 def base(name: Any): IRI = 53 def ID(t1: Term, t2: Term)(implicit variables: (List[Term], List[Term])) = {
40 IRI.create( 54 val (answer, bounded) = variables
41 Prefixes.getPrefixIRIsByPrefixName.get(":").getIRI 55 atom(RSA("ID"), (answer ::: bounded) :+ t1 :+ t2)
42 + name.toString 56 }
43 )
44 57
45 def rsa(name: Any): IRI = 58 def Named(t: Term) =
46 IRI.create( 59 TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("Named"))
47 Prefixes.getPrefixIRIsByPrefixName.get("rsa:").getIRI 60
48 + name.toString 61 def Thing(t: Term) =
49 ) 62 TupleTableAtom.rdf(t, IRI.RDF_TYPE, IRI.THING)
50 63
51 def hashed( 64 def NI(t: Term) =
52 cls1: OWLClass, 65 TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("NI"))
53 prop: OWLObjectPropertyExpression,
54 cls2: OWLClass
55 ): String =
56 (cls1, prop, cls2).hashCode.toString
57 66
58 def hashed(axiom: OWLAxiom): String = { 67 def TQ(t1: Term, t2: Term, sx: RSASuffix)(implicit
59 val (cls1, prop, cls2) = axiom.toTriple.get 68 variables: (List[Term], List[Term])
60 this.hashed(cls1, prop, cls2) 69 ) = {
70 val (answer, bounded) = variables
71 atom(RSA("TQ" :: sx), (answer ::: bounded) :+ t1 :+ t2)
61 } 72 }
62 73
63} // object RSA 74 def AQ(t1: Term, t2: Term, sx: RSASuffix)(implicit
75 variables: (List[Term], List[Term])
76 ) = {
77 val (answer, bounded) = variables
78 atom(RSA("AQ" :: sx), (answer ::: bounded) :+ t1 :+ t2)
79 }
80
81 def FK(implicit variables: (List[Term], List[Term])) = {
82 val (answer, bounded) = variables
83 atom(RSA("FK"), answer ::: bounded)
84 }
85
86 def SP(implicit variables: (List[Term], List[Term])) = {
87 val (answer, bounded) = variables
88 atom(RSA("SP"), answer ::: bounded)
89 }
90
91 def Ans(implicit variables: (List[Term], List[Term])) = {
92 val (answer, _) = variables
93 atom(RSA("Ans"), answer)
94 }
95
96 def apply(name: Any): IRI =
97 IRI.create(
98 Prefixes.getPrefixIRIsByPrefixName.get("rsa:").getIRI + name.toString
99 )
100}
diff --git a/src/main/scala/rsacomb/RSAAtom.scala b/src/main/scala/rsacomb/RSAAtom.scala
index a65c168..8832226 100644
--- a/src/main/scala/rsacomb/RSAAtom.scala
+++ b/src/main/scala/rsacomb/RSAAtom.scala
@@ -11,7 +11,7 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{IRI}
11import scala.collection.JavaConverters._ 11import scala.collection.JavaConverters._
12 12
13import rsacomb.suffix.{RSASuffix, Nth} 13import rsacomb.suffix.{RSASuffix, Nth}
14import rsacomb.RSA 14import rsacomb.RSAOntology
15 15
16/* Is this the best way to determine if an atom is an RDF triple? 16/* Is this the best way to determine if an atom is an RDF triple?
17 * Note that we can't use `getNumberOfArguments()` because is not 17 * Note that we can't use `getNumberOfArguments()` because is not
@@ -32,7 +32,7 @@ trait RSAAtom {
32 32
33 implicit class RSAAtom(val atom: TupleTableAtom) { 33 implicit class RSAAtom(val atom: TupleTableAtom) {
34 34
35 import rsacomb.RDFoxUtil.stringToRDFoxIRI 35 import RDFox._
36 36
37 val name: String = atom.getTupleTableName.getName 37 val name: String = atom.getTupleTableName.getName
38 38
@@ -74,7 +74,7 @@ trait RSAAtom {
74 if (isRDF) { 74 if (isRDF) {
75 (None, List(atom)) 75 (None, List(atom))
76 } else { 76 } else {
77 val bvar = RSA.getFreshVariable() 77 val bvar = RSAOntology.genFreshVariable()
78 val str = Literal.create(name, Datatype.XSD_STRING) 78 val str = Literal.create(name, Datatype.XSD_STRING)
79 val args = atom.getArguments.asScala.toList 79 val args = atom.getArguments.asScala.toList
80 val skolem = FunctionCall.create("SKOLEM", str :: args: _*) 80 val skolem = FunctionCall.create("SKOLEM", str :: args: _*)
diff --git a/src/main/scala/rsacomb/RSAAxiom.scala b/src/main/scala/rsacomb/RSAAxiom.scala
index 3cd9a9d..08de5b7 100644
--- a/src/main/scala/rsacomb/RSAAxiom.scala
+++ b/src/main/scala/rsacomb/RSAAxiom.scala
@@ -38,6 +38,17 @@ trait RSAAxiom {
38 case object T5 extends RSAAxiomType // A ⊑ ∃R.B 38 case object T5 extends RSAAxiomType // A ⊑ ∃R.B
39 } 39 }
40 40
41 object RSAAxiom {
42
43 def hashed(
44 cls1: OWLClass,
45 prop: OWLObjectPropertyExpression,
46 cls2: OWLClass
47 ): String =
48 (cls1, prop, cls2).hashCode.toString
49
50 }
51
41 /* Implements additional features on top of `OWLAxiom` from 52 /* Implements additional features on top of `OWLAxiom` from
42 * the OWLAPI. 53 * the OWLAPI.
43 */ 54 */
@@ -137,6 +148,8 @@ trait RSAAxiom {
137 } 148 }
138 cls2 <- Some(someValues.getFiller) collect { case a: OWLClass => a } 149 cls2 <- Some(someValues.getFiller) collect { case a: OWLClass => a }
139 } yield (cls1, prop, cls2) 150 } yield (cls1, prop, cls2)
151
152 lazy val hashed: String = (RSAAxiom.hashed _) tupled toTriple.get
140 } 153 }
141 154
142} // trait RSAAxiom 155} // trait RSAAxiom
diff --git a/src/main/scala/rsacomb/RSAOntology.scala b/src/main/scala/rsacomb/RSAOntology.scala
index 52bff37..1a5e4ca 100644
--- a/src/main/scala/rsacomb/RSAOntology.scala
+++ b/src/main/scala/rsacomb/RSAOntology.scala
@@ -47,14 +47,23 @@ import tech.oxfordsemantic.jrdfox.logic._
47import org.semanticweb.owlapi.model.OWLObjectInverseOf 47import org.semanticweb.owlapi.model.OWLObjectInverseOf
48 48
49import suffix.{Empty, Forward, Backward, Inverse} 49import suffix.{Empty, Forward, Backward, Inverse}
50import util.{RDFoxHelpers, RSA}
50 51
51object RSAOntology { 52object RSAOntology {
52 53
54 // Counter used to implement a simple fresh variable generator
55 private var counter = -1;
56
53 def apply(ontology: OWLOntology): RSAOntology = new RSAOntology(ontology) 57 def apply(ontology: OWLOntology): RSAOntology = new RSAOntology(ontology)
54 58
55 def apply(ontology: File): RSAOntology = 59 def apply(ontology: File): RSAOntology =
56 new RSAOntology(loadOntology(ontology)) 60 new RSAOntology(loadOntology(ontology))
57 61
62 def genFreshVariable(): Variable = {
63 counter += 1
64 Variable.create(f"I$counter%03d")
65 }
66
58 private def loadOntology(onto: File): OWLOntology = { 67 private def loadOntology(onto: File): OWLOntology = {
59 val manager = OWLManager.createOWLOntologyManager() 68 val manager = OWLManager.createOWLOntologyManager()
60 manager.loadOntologyFromOntologyDocument(onto) 69 manager.loadOntologyFromOntologyDocument(onto)
@@ -94,7 +103,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
94 .getIndividualsInSignature() 103 .getIndividualsInSignature()
95 .asScala 104 .asScala
96 .map(_.getIRI) 105 .map(_.getIRI)
97 .map(RDFoxUtil.owlapi2rdfox) 106 .map(implicits.RDFox.owlapiToRdfoxIri)
98 .toList 107 .toList
99 108
100 val concepts: List[OWLClass] = 109 val concepts: List[OWLClass] =
@@ -133,7 +142,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
133 val datalog = for { 142 val datalog = for {
134 axiom <- axioms 143 axiom <- axioms
135 visitor = new RDFoxAxiomConverter( 144 visitor = new RDFoxAxiomConverter(
136 RSA.getFreshVariable(), 145 RSAOntology.genFreshVariable(),
137 unsafe, 146 unsafe,
138 SkolemStrategy.ConstantRSA(axiom.toString), 147 SkolemStrategy.ConstantRSA(axiom.toString),
139 Empty 148 Empty
@@ -146,9 +155,9 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
146 //datalog.foreach(println) 155 //datalog.foreach(println)
147 156
148 // Open connection with RDFox 157 // Open connection with RDFox
149 val (server, data) = RDFoxUtil.openConnection("RSACheck") 158 val (server, data) = RDFoxHelpers.openConnection("RSACheck")
150 // Add Data (hardcoded for now) 159 // Add Data (hardcoded for now)
151 data.importData(UpdateType.ADDITION, RSA.Prefixes, ":a a :A .") 160 //data.importData(UpdateType.ADDITION, RSA.Prefixes, ":a a :A .")
152 161
153 /* Add built-in rules 162 /* Add built-in rules
154 */ 163 */
@@ -176,7 +185,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
176 //println(graph) 185 //println(graph)
177 186
178 // Close connection to RDFox 187 // Close connection to RDFox
179 RDFoxUtil.closeConnection(server, data) 188 RDFoxHelpers.closeConnection(server, data)
180 189
181 /* To check if the graph is tree-like we check for acyclicity in a 190 /* To check if the graph is tree-like we check for acyclicity in a
182 * undirected graph. 191 * undirected graph.
@@ -291,8 +300,8 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
291 val role = axiom.objectPropertyExpressionsInSignature(0) 300 val role = axiom.objectPropertyExpressionsInSignature(0)
292 if (this.confl(role).contains(role)) { 301 if (this.confl(role).contains(role)) {
293 Set( 302 Set(
294 RSA.rsa("v0_" ++ RSA.hashed(axiom)), 303 RSA("v0_" ++ axiom.hashed),
295 RSA.rsa("v1_" ++ RSA.hashed(axiom)) 304 RSA("v1_" ++ axiom.hashed)
296 ) 305 )
297 } else { 306 } else {
298 Set() 307 Set()
@@ -354,15 +363,15 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
354 classC <- classes 363 classC <- classes
355 // Keeping this check for now 364 // Keeping this check for now
356 if !unsafeRoles.contains(roleS) 365 if !unsafeRoles.contains(roleS)
357 tripleARB = RSA.hashed(classA, roleR, classB) 366 tripleARB = RSAAxiom.hashed(classA, roleR, classB)
358 tripleDSC = RSA.hashed(classD, roleS, classC) 367 tripleDSC = RSAAxiom.hashed(classD, roleS, classC)
359 individual = 368 individual =
360 if (tripleARB > tripleDSC) { 369 if (tripleARB > tripleDSC) {
361 RSA.rsa("v1_" ++ tripleDSC) 370 RSA("v1_" ++ tripleDSC)
362 } else { 371 } else {
363 // Note that this is also the case for 372 // Note that this is also the case for
364 // `tripleARB == tripleDSC` 373 // `tripleARB == tripleDSC`
365 RSA.rsa("v0_" ++ tripleDSC) 374 RSA("v0_" ++ tripleDSC)
366 } 375 }
367 } yield individual 376 } yield individual
368 } 377 }
diff --git a/src/main/scala/rsacomb/implicits/JavaCollections.scala b/src/main/scala/rsacomb/implicits/JavaCollections.scala
new file mode 100644
index 0000000..69e825b
--- /dev/null
+++ b/src/main/scala/rsacomb/implicits/JavaCollections.scala
@@ -0,0 +1,13 @@
1package rsacomb.implicits
2
3import scala.collection.JavaConverters._
4
5object JavaCollections {
6
7 implicit def javaToScalaList[A](list: java.util.List[A]): List[A] =
8 list.asScala.toList
9
10 implicit def scalaToJavaList[A](list: List[A]): java.util.List[A] =
11 list.asJava
12
13}
diff --git a/src/main/scala/rsacomb/implicits/RDFox.scala b/src/main/scala/rsacomb/implicits/RDFox.scala
new file mode 100644
index 0000000..44b7c01
--- /dev/null
+++ b/src/main/scala/rsacomb/implicits/RDFox.scala
@@ -0,0 +1,20 @@
1package rsacomb.implicits
2
3import tech.oxfordsemantic.jrdfox.logic.expression.{IRI => RDFoxIRI}
4import org.semanticweb.owlapi.model.{IRI => OWLIRI}
5
6object RDFox {
7
8 implicit def rdfoxToOwlapiIri(iri: RDFoxIRI): OWLIRI = {
9 OWLIRI.create(iri.getIRI)
10 }
11
12 implicit def owlapiToRdfoxIri(iri: OWLIRI): RDFoxIRI = {
13 RDFoxIRI.create(iri.getIRIString())
14 }
15
16 implicit def stringToRdfoxIri(iri: String): RDFoxIRI = {
17 RDFoxIRI.create(iri)
18 }
19
20}
diff --git a/src/main/scala/rsacomb/util/RDFoxHelpers.scala b/src/main/scala/rsacomb/util/RDFoxHelpers.scala
new file mode 100644
index 0000000..9856e27
--- /dev/null
+++ b/src/main/scala/rsacomb/util/RDFoxHelpers.scala
@@ -0,0 +1,100 @@
1package rsacomb.util
2
3import java.util.{Map => JMap, HashMap => JHashMap}
4import java.io.StringReader
5import tech.oxfordsemantic.jrdfox.Prefixes
6import tech.oxfordsemantic.jrdfox.client.{
7 ConnectionFactory,
8 ServerConnection,
9 DataStoreConnection
10}
11import tech.oxfordsemantic.jrdfox.formats.SPARQLParser
12import tech.oxfordsemantic.jrdfox.logic.expression.Resource
13import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
14
15import rsacomb.suffix.Nth
16
17object RDFoxHelpers {
18
19 def openConnection(
20 dataStore: String,
21 opts: JMap[String, String] = new JHashMap[String, String]()
22 ): (ServerConnection, DataStoreConnection) = {
23 /* Create local server connection
24 */
25 val serverUrl = "rdfox:local"
26 val role = ""
27 val password = ""
28 val server =
29 ConnectionFactory.newServerConnection(serverUrl, role, password)
30
31 /* Create datastore connection
32 */
33 // parameters.put("owl-in-rdf-support", "relaxed")
34 // parameters.put("equality", "noUNA")
35 server.createDataStore(dataStore, "par-complex-nn", opts)
36 val data = server.newDataStoreConnection(dataStore)
37
38 (server, data)
39 }
40
41 def parseSelectQuery(
42 query: String,
43 prefixes: Prefixes = new Prefixes()
44 ): Option[SelectQuery] = {
45 val parser = new SPARQLParser(
46 prefixes,
47 new StringReader(query)
48 )
49 parser.parseSingleQuery() match {
50 case q: SelectQuery => Some(q)
51 case _ => None
52 }
53 }
54
55 def submitSelectQuery(
56 data: DataStoreConnection,
57 query: String,
58 prefixes: Prefixes = new Prefixes(),
59 opts: JMap[String, String] = new JHashMap[String, String]()
60 ): List[List[Resource]] = {
61 val cursor = data.createCursor(prefixes, query, opts)
62 var answers: List[List[Resource]] = List()
63 var mul = cursor.open()
64 while (mul > 0) {
65 val answer =
66 (0 until cursor.getArity).map(cursor.getResource(_)).toList
67 answers = answer :: answers
68 mul = cursor.advance()
69 }
70 cursor.close();
71 answers
72 }
73
74 def queryInternalPredicate(
75 data: DataStoreConnection,
76 pred: String,
77 arity: Int,
78 opts: JMap[String, String] = new JHashMap[String, String]()
79 ): List[List[Resource]] = {
80 var query = "SELECT"
81 for (i <- 0 until arity) {
82 query ++= s" ?X$i"
83 }
84 query ++= " WHERE {"
85 for (i <- 0 until arity) {
86 query ++= s" ?S rsa:${pred :: Nth(i)} ?X$i ."
87 }
88 query ++= " }"
89 submitSelectQuery(data, query, RSA.Prefixes, opts)
90 }
91
92 def closeConnection(
93 server: ServerConnection,
94 data: DataStoreConnection
95 ): Unit = {
96 server.close();
97 data.close();
98 }
99
100}
diff --git a/src/test/scala/rsacomb/CanonicalModelSpec.scala b/src/test/scala/rsacomb/CanonicalModelSpec.scala
index cac40a3..06602e3 100644
--- a/src/test/scala/rsacomb/CanonicalModelSpec.scala
+++ b/src/test/scala/rsacomb/CanonicalModelSpec.scala
@@ -14,61 +14,63 @@ import tech.oxfordsemantic.jrdfox.logic.expression.Variable
14 14
15import scala.collection.JavaConverters._ 15import scala.collection.JavaConverters._
16 16
17import rsacomb.RSA._ 17import rsacomb.util.{RDFoxHelpers, RSA}
18import rsacomb.RDFoxUtil._
19 18
20object Ontology1_CanonicalModelSpec { 19object Ontology1_CanonicalModelSpec {
21 20
22 /* Renderer to display OWL Axioms with DL syntax*/ 21 /* Renderer to display OWL Axioms with DL syntax*/
23 val renderer = new DLSyntaxObjectRenderer() 22 val renderer = new DLSyntaxObjectRenderer()
24 23
24 def base(str: String): IRI =
25 IRI.create("http://example.com/rsa_example.owl#" + str)
26
25 val ontology_path: File = new File("examples/example1.ttl") 27 val ontology_path: File = new File("examples/example1.ttl")
26 val ontology = RSAOntology(ontology_path) 28 val ontology = RSAOntology(ontology_path)
27 val program = ontology.canonicalModel 29 val program = ontology.canonicalModel
28 30
29 val roleR = new OWLObjectPropertyImpl(RSA.base("R")) 31 val roleR = new OWLObjectPropertyImpl(base("R"))
30 val roleS = new OWLObjectPropertyImpl(RSA.base("S")) 32 val roleS = new OWLObjectPropertyImpl(base("S"))
31 val roleT = new OWLObjectPropertyImpl(RSA.base("T")) 33 val roleT = new OWLObjectPropertyImpl(base("T"))
32 val roleR_inv = roleR.getInverseProperty() 34 val roleR_inv = roleR.getInverseProperty()
33 val roleS_inv = roleS.getInverseProperty() 35 val roleS_inv = roleS.getInverseProperty()
34 val roleT_inv = roleT.getInverseProperty() 36 val roleT_inv = roleT.getInverseProperty()
35 37
36 val AsubClassOfD = new OWLSubClassOfAxiomImpl( 38 val AsubClassOfD = new OWLSubClassOfAxiomImpl(
37 new OWLClassImpl(RSA.base("A")), 39 new OWLClassImpl(base("A")),
38 new OWLClassImpl(RSA.base("D")), 40 new OWLClassImpl(base("D")),
39 Seq().asJava 41 Seq().asJava
40 ) 42 )
41 43
42 val DsomeValuesFromRB = new OWLSubClassOfAxiomImpl( 44 val DsomeValuesFromRB = new OWLSubClassOfAxiomImpl(
43 new OWLClassImpl(RSA.base("D")), 45 new OWLClassImpl(base("D")),
44 new OWLObjectSomeValuesFromImpl( 46 new OWLObjectSomeValuesFromImpl(
45 roleR, 47 roleR,
46 new OWLClassImpl(RSA.base("B")) 48 new OWLClassImpl(base("B"))
47 ), 49 ),
48 Seq().asJava 50 Seq().asJava
49 ) 51 )
50 52
51 val BsomeValuesFromSD = new OWLSubClassOfAxiomImpl( 53 val BsomeValuesFromSD = new OWLSubClassOfAxiomImpl(
52 new OWLClassImpl(RSA.base("B")), 54 new OWLClassImpl(base("B")),
53 new OWLObjectSomeValuesFromImpl( 55 new OWLObjectSomeValuesFromImpl(
54 roleS, 56 roleS,
55 new OWLClassImpl(RSA.base("D")) 57 new OWLClassImpl(base("D"))
56 ), 58 ),
57 Seq().asJava 59 Seq().asJava
58 ) 60 )
59 61
60 val AsomeValuesFromSiC = new OWLSubClassOfAxiomImpl( 62 val AsomeValuesFromSiC = new OWLSubClassOfAxiomImpl(
61 new OWLClassImpl(RSA.base("A")), 63 new OWLClassImpl(base("A")),
62 new OWLObjectSomeValuesFromImpl( 64 new OWLObjectSomeValuesFromImpl(
63 roleS_inv, 65 roleS_inv,
64 new OWLClassImpl(RSA.base("C")) 66 new OWLClassImpl(base("C"))
65 ), 67 ),
66 Seq().asJava 68 Seq().asJava
67 ) 69 )
68 70
69 val SsubPropertyOfT = new OWLSubObjectPropertyOfAxiomImpl( 71 val SsubPropertyOfT = new OWLSubObjectPropertyOfAxiomImpl(
70 new OWLObjectPropertyImpl(RSA.base("S")), 72 new OWLObjectPropertyImpl(base("S")),
71 new OWLObjectPropertyImpl(RSA.base("T")), 73 new OWLObjectPropertyImpl(base("T")),
72 Seq().asJava 74 Seq().asJava
73 ) 75 )
74 76
@@ -219,51 +221,54 @@ object Ontology2_CanonicalModelSpec {
219 /* Renderer to display OWL Axioms with DL syntax*/ 221 /* Renderer to display OWL Axioms with DL syntax*/
220 val renderer = new DLSyntaxObjectRenderer() 222 val renderer = new DLSyntaxObjectRenderer()
221 223
224 def base(str: String): IRI =
225 IRI.create("http://example.com/rsa_example.owl#" + str)
226
222 val ontology_path: File = new File("examples/example2.owl") 227 val ontology_path: File = new File("examples/example2.owl")
223 val ontology = RSAOntology(ontology_path) 228 val ontology = RSAOntology(ontology_path)
224 val program = ontology.canonicalModel 229 val program = ontology.canonicalModel
225 230
226 val roleR = new OWLObjectPropertyImpl(RSA.base("R")) 231 val roleR = new OWLObjectPropertyImpl(base("R"))
227 val roleS = new OWLObjectPropertyImpl(RSA.base("S")) 232 val roleS = new OWLObjectPropertyImpl(base("S"))
228 val roleT = new OWLObjectPropertyImpl(RSA.base("T")) 233 val roleT = new OWLObjectPropertyImpl(base("T"))
229 val roleP = new OWLObjectPropertyImpl(RSA.base("P")) 234 val roleP = new OWLObjectPropertyImpl(base("P"))
230 val roleR_inv = roleR.getInverseProperty() 235 val roleR_inv = roleR.getInverseProperty()
231 val roleS_inv = roleS.getInverseProperty() 236 val roleS_inv = roleS.getInverseProperty()
232 val roleT_inv = roleT.getInverseProperty() 237 val roleT_inv = roleT.getInverseProperty()
233 val roleP_inv = roleP.getInverseProperty() 238 val roleP_inv = roleP.getInverseProperty()
234 239
235 val AsomeValuesFromRB = new OWLSubClassOfAxiomImpl( 240 val AsomeValuesFromRB = new OWLSubClassOfAxiomImpl(
236 new OWLClassImpl(RSA.base("A")), 241 new OWLClassImpl(base("A")),
237 new OWLObjectSomeValuesFromImpl( 242 new OWLObjectSomeValuesFromImpl(
238 roleR, 243 roleR,
239 new OWLClassImpl(RSA.base("B")) 244 new OWLClassImpl(base("B"))
240 ), 245 ),
241 Seq().asJava 246 Seq().asJava
242 ) 247 )
243 248
244 val BsomeValuesFromSC = new OWLSubClassOfAxiomImpl( 249 val BsomeValuesFromSC = new OWLSubClassOfAxiomImpl(
245 new OWLClassImpl(RSA.base("B")), 250 new OWLClassImpl(base("B")),
246 new OWLObjectSomeValuesFromImpl( 251 new OWLObjectSomeValuesFromImpl(
247 roleS, 252 roleS,
248 new OWLClassImpl(RSA.base("C")) 253 new OWLClassImpl(base("C"))
249 ), 254 ),
250 Seq().asJava 255 Seq().asJava
251 ) 256 )
252 257
253 val CsomeValuesFromTD = new OWLSubClassOfAxiomImpl( 258 val CsomeValuesFromTD = new OWLSubClassOfAxiomImpl(
254 new OWLClassImpl(RSA.base("C")), 259 new OWLClassImpl(base("C")),
255 new OWLObjectSomeValuesFromImpl( 260 new OWLObjectSomeValuesFromImpl(
256 roleT, 261 roleT,
257 new OWLClassImpl(RSA.base("D")) 262 new OWLClassImpl(base("D"))
258 ), 263 ),
259 Seq().asJava 264 Seq().asJava
260 ) 265 )
261 266
262 val DsomeValuesFromPA = new OWLSubClassOfAxiomImpl( 267 val DsomeValuesFromPA = new OWLSubClassOfAxiomImpl(
263 new OWLClassImpl(RSA.base("D")), 268 new OWLClassImpl(base("D")),
264 new OWLObjectSomeValuesFromImpl( 269 new OWLObjectSomeValuesFromImpl(
265 roleP, 270 roleP,
266 new OWLClassImpl(RSA.base("A")) 271 new OWLClassImpl(base("A"))
267 ), 272 ),
268 Seq().asJava 273 Seq().asJava
269 ) 274 )
diff --git a/src/test/scala/rsacomb/FilteringProgramSpecs.scala b/src/test/scala/rsacomb/FilteringProgramSpecs.scala
index 79e675f..66c1cae 100644
--- a/src/test/scala/rsacomb/FilteringProgramSpecs.scala
+++ b/src/test/scala/rsacomb/FilteringProgramSpecs.scala
@@ -14,7 +14,7 @@ import tech.oxfordsemantic.jrdfox.Prefixes
14 14
15import scala.collection.JavaConverters._ 15import scala.collection.JavaConverters._
16 16
17import rsacomb.RDFoxUtil._ 17import rsacomb.util.RDFoxHelpers
18 18
19object FilteringProgramSpec { 19object FilteringProgramSpec {
20 20
@@ -33,12 +33,14 @@ object FilteringProgramSpec {
33 33
34 // QUERY 0 34 // QUERY 0
35 35
36 val query0 = parseQuery(""" 36 val query0 = RDFoxHelpers
37 SELECT ?subj 37 .parseSelectQuery("""
38 WHERE { 38 SELECT ?subj
39 ?subj ?pred ?obj 39 WHERE {
40 } 40 ?subj ?pred ?obj
41 """, prefixes).get 41 }
42 """, prefixes)
43 .get
42 44
43 // val query0 = Query.create( 45 // val query0 = Query.create(
44 // QueryType.SELECT, 46 // QueryType.SELECT,
@@ -49,12 +51,14 @@ object FilteringProgramSpec {
49 51
50 // QUERY 1 52 // QUERY 1
51 53
52 val query1 = parseQuery(""" 54 val query1 = RDFoxHelpers
55 .parseSelectQuery("""
53 SELECT * 56 SELECT *
54 WHERE { 57 WHERE {
55 ?w a :Wellbore 58 ?w a :Wellbore
56 } 59 }
57 """, prefixes).get 60 """, prefixes)
61 .get
58 62
59 // val query1 = Query.create( 63 // val query1 = Query.create(
60 // QueryType.SELECT, 64 // QueryType.SELECT,
@@ -65,8 +69,9 @@ object FilteringProgramSpec {
65 69
66 // QUERY 2 70 // QUERY 2
67 71
68 val query2 = parseQuery( 72 val query2 = RDFoxHelpers
69 """ 73 .parseSelectQuery(
74 """
70 SELECT * 75 SELECT *
71 WHERE { 76 WHERE {
72 ?w a :Wellbore ; 77 ?w a :Wellbore ;
@@ -74,8 +79,9 @@ object FilteringProgramSpec {
74 ?doc :hasURL ?document_hyperlink 79 ?doc :hasURL ?document_hyperlink
75 } 80 }
76 """, 81 """,
77 prefixes 82 prefixes
78 ).get 83 )
84 .get
79 85
80 // val query2 = Query.create( 86 // val query2 = Query.create(
81 // QueryType.SELECT, 87 // QueryType.SELECT,
@@ -90,8 +96,9 @@ object FilteringProgramSpec {
90 96
91 // QUERY 3 97 // QUERY 3
92 98
93 val query3 = parseQuery( 99 val query3 = RDFoxHelpers
94 """ 100 .parseSelectQuery(
101 """
95 SELECT ?wellbore ?formation_pressure 102 SELECT ?wellbore ?formation_pressure
96 WHERE { 103 WHERE {
97 ?w a :Wellbore ; 104 ?w a :Wellbore ;
@@ -100,8 +107,9 @@ object FilteringProgramSpec {
100 ?fp :valueInStandardUnit ?formation_pressure 107 ?fp :valueInStandardUnit ?formation_pressure
101 } 108 }
102 """, 109 """,
103 prefixes 110 prefixes
104 ).get 111 )
112 .get
105 113
106 // val query3 = Query.create( 114 // val query3 = Query.create(
107 // QueryType.SELECT, 115 // QueryType.SELECT,
@@ -117,8 +125,9 @@ object FilteringProgramSpec {
117 125
118 // QUERY 4 126 // QUERY 4
119 127
120 val query4 = parseQuery( 128 val query4 = RDFoxHelpers
121 """ 129 .parseSelectQuery(
130 """
122 SELECT * 131 SELECT *
123 WHERE { 132 WHERE {
124 ?w a :Wellbore ; 133 ?w a :Wellbore ;
@@ -129,8 +138,9 @@ object FilteringProgramSpec {
129 :peakAmount ?peak_amount 138 :peakAmount ?peak_amount
130 } 139 }
131 """, 140 """,
132 prefixes 141 prefixes
133 ).get 142 )
143 .get
134 144
135 // val query4 = Query.create( 145 // val query4 = Query.create(
136 // QueryType.SELECT, 146 // QueryType.SELECT,
@@ -155,8 +165,9 @@ object FilteringProgramSpec {
155 165
156 // QUERY 5 166 // QUERY 5
157 167
158 val query5 = parseQuery( 168 val query5 = RDFoxHelpers
159 """ 169 .parseSelectQuery(
170 """
160 SELECT ?wellbore ?unit_name ?discovery 171 SELECT ?wellbore ?unit_name ?discovery
161 WHERE { 172 WHERE {
162 ?w a :Wellbore ; 173 ?w a :Wellbore ;
@@ -170,8 +181,9 @@ object FilteringProgramSpec {
170 :overlapsWellboreInterval ?c_int 181 :overlapsWellboreInterval ?c_int
171 } 182 }
172 """, 183 """,
173 prefixes 184 prefixes
174 ).get 185 )
186 .get
175 187
176 // val query5 = Query.create( 188 // val query5 = Query.create(
177 // QueryType.SELECT, 189 // QueryType.SELECT,
@@ -192,8 +204,9 @@ object FilteringProgramSpec {
192 204
193 // QUERY 6 205 // QUERY 6
194 206
195 val query6 = parseQuery( 207 val query6 = RDFoxHelpers
196 """ 208 .parseSelectQuery(
209 """
197 SELECT DISTINCT ?wellbore ?content 210 SELECT DISTINCT ?wellbore ?content
198 WHERE { 211 WHERE {
199 ?w a :Wellbore ; 212 ?w a :Wellbore ;
@@ -203,8 +216,9 @@ object FilteringProgramSpec {
203 :fluidZoneContent ?content 216 :fluidZoneContent ?content
204 } 217 }
205 """, 218 """,
206 prefixes 219 prefixes
207 ).get 220 )
221 .get
208 222
209 // val query6 = Query.create( 223 // val query6 = Query.create(
210 // QueryType.SELECT, 224 // QueryType.SELECT,
@@ -221,8 +235,9 @@ object FilteringProgramSpec {
221 235
222 // QUERY 7 236 // QUERY 7
223 237
224 val query7 = parseQuery( 238 val query7 = RDFoxHelpers
225 """ 239 .parseSelectQuery(
240 """
226 SELECT ?wName ?sample ?porosity ?top_depth_md ?bot_depth_md 241 SELECT ?wName ?sample ?porosity ?top_depth_md ?bot_depth_md
227 WHERE { 242 WHERE {
228 ?w a :Wellbore ; 243 ?w a :Wellbore ;
@@ -246,8 +261,9 @@ object FilteringProgramSpec {
246 :valueInStandardUnit ?bot_depth_md 261 :valueInStandardUnit ?bot_depth_md
247 } 262 }
248 """, 263 """,
249 prefixes 264 prefixes
250 ).get 265 )
266 .get
251 267
252 // val query7 = Query.create( 268 // val query7 = Query.create(
253 // QueryType.SELECT, 269 // QueryType.SELECT,
diff --git a/src/test/scala/rsacomb/OWLAxiomSpec.scala b/src/test/scala/rsacomb/OWLAxiomSpec.scala
index 056f428..65333f5 100644
--- a/src/test/scala/rsacomb/OWLAxiomSpec.scala
+++ b/src/test/scala/rsacomb/OWLAxiomSpec.scala
@@ -36,6 +36,8 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{
36import org.semanticweb.owlapi.model.{IRI => OWLIRI} 36import org.semanticweb.owlapi.model.{IRI => OWLIRI}
37import tech.oxfordsemantic.jrdfox.logic.expression.{IRI => RDFIRI} 37import tech.oxfordsemantic.jrdfox.logic.expression.{IRI => RDFIRI}
38 38
39import rsacomb.util.RSA
40
39object OWLAxiomSpec { 41object OWLAxiomSpec {
40 42
41 // IRI 43 // IRI
@@ -53,8 +55,8 @@ object OWLAxiomSpec {
53 val term_x = Variable.create("x") 55 val term_x = Variable.create("x")
54 val term_y = Variable.create("y") 56 val term_y = Variable.create("y")
55 val term_z = Variable.create("z") 57 val term_z = Variable.create("z")
56 val term_c1 = RSA.rsa("c_1") 58 val term_c1 = RSA("c_1")
57 val term_c2 = RSA.rsa("c_2") 59 val term_c2 = RSA("c_2")
58 val term_alice = RDFIRI.create("univ:alice") 60 val term_alice = RDFIRI.create("univ:alice")
59 61
60 // RDFox Predicates 62 // RDFox Predicates
@@ -181,7 +183,7 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
181 // Import required data 183 // Import required data
182 import OWLAxiomSpec._ 184 import OWLAxiomSpec._
183 // Implicit convertion from IRI in OWLAPI to IRI in JRDFox 185 // Implicit convertion from IRI in OWLAPI to IRI in JRDFox
184 import RDFoxUtil._ 186 import rsacomb.implicits.RDFox._
185 187
186 // OWLSubClassOfAxiom #1 188 // OWLSubClassOfAxiom #1
187 axiom_OWLSubClassOf1.toString should "be converted into a singleton List[Rule]" in { 189 axiom_OWLSubClassOf1.toString should "be converted into a singleton List[Rule]" in {
diff --git a/src/test/scala/rsacomb/OWLClassSpec.scala b/src/test/scala/rsacomb/OWLClassSpec.scala
index 505c4aa..27e0872 100644
--- a/src/test/scala/rsacomb/OWLClassSpec.scala
+++ b/src/test/scala/rsacomb/OWLClassSpec.scala
@@ -34,6 +34,7 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{
34} 34}
35 35
36import rsacomb.RDFoxRuleShards 36import rsacomb.RDFoxRuleShards
37import rsacomb.util.RSA
37 38
38object OWLClassSpec { 39object OWLClassSpec {
39 40
@@ -49,8 +50,8 @@ object OWLClassSpec {
49 // RDFox Terms 50 // RDFox Terms
50 val term_x = Variable.create("x") 51 val term_x = Variable.create("x")
51 val term_y = Variable.create("y") 52 val term_y = Variable.create("y")
52 val term_c1 = RSA.rsa("c_1") 53 val term_c1 = RSA("c_1")
53 val term_c2 = RSA.rsa("c_2") 54 val term_c2 = RSA("c_2")
54 val term_alice = RDFIRI.create("univ:alice") 55 val term_alice = RDFIRI.create("univ:alice")
55 56
56 // RDFox Predicates 57 // RDFox Predicates
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-07 03:46:39 +0000