aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/rsacomb/Main.scala
diff options
context:
space:
mode:
authorFederico Igne <federico.igne@cs.ox.ac.uk>2020-11-18 18:07:53 +0000
committerFederico Igne <federico.igne@cs.ox.ac.uk>2020-11-18 18:07:53 +0000
commit4df351d3b1d11fc045005323c38ba3528de631ea (patch)
tree35f809e3def7d55602ed124f7b194db29407ba33 /src/main/scala/rsacomb/Main.scala
parente1a04294ed8737444e40323474f4084cb64c1d55 (diff)
downloadRSAComb-4df351d3b1d11fc045005323c38ba3528de631ea.tar.gz
RSAComb-4df351d3b1d11fc045005323c38ba3528de631ea.zip
Rework RSA as a utility object
Diffstat (limited to 'src/main/scala/rsacomb/Main.scala')
-rw-r--r--src/main/scala/rsacomb/Main.scala232
1 files changed, 122 insertions, 110 deletions
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 }