diff options
author | Federico Igne <federico.igne@cs.ox.ac.uk> | 2020-11-18 18:07:53 +0000 |
---|---|---|
committer | Federico Igne <federico.igne@cs.ox.ac.uk> | 2020-11-18 18:07:53 +0000 |
commit | 4df351d3b1d11fc045005323c38ba3528de631ea (patch) | |
tree | 35f809e3def7d55602ed124f7b194db29407ba33 /src/main/scala/rsacomb/Main.scala | |
parent | e1a04294ed8737444e40323474f4084cb64c1d55 (diff) | |
download | RSAComb-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.scala | 232 |
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 | |||
10 | import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term} | 10 | import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term} |
11 | 11 | ||
12 | /* Local imports */ | 12 | /* Local imports */ |
13 | import rsacomb.RSA._ | 13 | import util.{RDFoxHelpers, RSA} |
14 | 14 | ||
15 | object RSAComb extends App { | 15 | object 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 | } |