aboutsummaryrefslogtreecommitdiff
path: root/src/main/java/uk/ac/ox/cs/pagoda/tracking
diff options
context:
space:
mode:
authorFederico Igne <federico.igne@cs.ox.ac.uk>2022-05-10 18:17:06 +0100
committerFederico Igne <federico.igne@cs.ox.ac.uk>2022-05-11 12:34:47 +0100
commit17bd9beaf7f358a44e5bf36a5855fe6727d506dc (patch)
tree47e9310a0cff869d9ec017dcb2c81876407782c8 /src/main/java/uk/ac/ox/cs/pagoda/tracking
parent8651164cd632a5db310b457ce32d4fbc97bdc41c (diff)
downloadACQuA-17bd9beaf7f358a44e5bf36a5855fe6727d506dc.tar.gz
ACQuA-17bd9beaf7f358a44e5bf36a5855fe6727d506dc.zip
[pagoda] Move project to Scala
This commit includes a few changes: - The repository still uses Maven to manage dependency but it is now a Scala project. - The code has been ported from OWLAPI 3.4.10 to 5.1.20 - A proof of concept program using both RSAComb and PAGOdA has been added.
Diffstat (limited to 'src/main/java/uk/ac/ox/cs/pagoda/tracking')
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/AnswerTuplesWriter.java59
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/BottomFragmentManager.java101
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java440
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java387
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java163
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java175
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java112
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java425
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java230
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java116
-rw-r--r--src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithoutGap.java103
11 files changed, 2311 insertions, 0 deletions
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/AnswerTuplesWriter.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/AnswerTuplesWriter.java
new file mode 100644
index 0000000..a83a4e9
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/AnswerTuplesWriter.java
@@ -0,0 +1,59 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import java.io.BufferedWriter;
4import java.io.FileNotFoundException;
5import java.io.FileOutputStream;
6import java.io.IOException;
7import java.io.OutputStreamWriter;
8import java.util.Collection;
9
10import uk.ac.ox.cs.pagoda.query.AnswerTuples;
11
12public class AnswerTuplesWriter {
13
14 private static final String QUERY_SEPARATOR = "---------------------------------------------";
15
16 BufferedWriter writer = null;
17
18 public AnswerTuplesWriter(String fileName) {
19 try {
20 writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName)));
21 } catch (FileNotFoundException e) {
22 e.printStackTrace();
23 }
24 }
25
26 public void write(String[] answerVariables, Collection<String> answerTuples)throws IOException {
27 for (int i = 0; i < answerVariables.length; ++i)
28 writer.write(answerVariables[i] + "\t");
29 writer.newLine();
30 writer.write(QUERY_SEPARATOR);
31 writer.newLine();
32
33 if (answerTuples == null) {
34 writer.newLine();
35 return ;
36 }
37
38 for (String answerTuple: answerTuples) {
39 writer.write(answerTuple);
40 writer.newLine();
41 }
42 writer.newLine();
43 }
44
45 public void close() {
46 if (writer != null)
47 try {
48 writer.close();
49 } catch (IOException e) {
50 e.printStackTrace();
51 }
52 }
53
54 public void write(String[] answerVariables, AnswerTuples answerTuples) {
55 // TODO Auto-generated method stub
56
57 }
58
59}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/BottomFragmentManager.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/BottomFragmentManager.java
new file mode 100644
index 0000000..6521e72
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/BottomFragmentManager.java
@@ -0,0 +1,101 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import java.util.HashSet;
4import java.util.Set;
5
6import org.semanticweb.HermiT.model.AtomicConcept;
7import org.semanticweb.HermiT.model.AtomicRole;
8import org.semanticweb.HermiT.model.DLClause;
9import org.semanticweb.HermiT.model.DLPredicate;
10import org.semanticweb.owlapi.model.OWLAxiom;
11import org.semanticweb.owlapi.model.OWLClass;
12import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
13import org.semanticweb.owlapi.model.OWLDataProperty;
14import org.semanticweb.owlapi.model.OWLDataPropertyAssertionAxiom;
15import org.semanticweb.owlapi.model.OWLObjectProperty;
16import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
17import org.semanticweb.owlapi.model.parameters.Imports;
18
19import uk.ac.ox.cs.pagoda.constraints.PredicateDependency;
20import uk.ac.ox.cs.pagoda.query.QueryRecord;
21import uk.ac.ox.cs.pagoda.rules.ApproxProgram;
22import uk.ac.ox.cs.pagoda.rules.GeneralProgram;
23import uk.ac.ox.cs.pagoda.util.Utility;
24
25public class BottomFragmentManager {
26
27 QueryRecord m_record;
28 GeneralProgram m_program;
29 PredicateDependency m_graph;
30
31 public BottomFragmentManager(QueryRecord record) {
32 m_record = record;
33 m_program = new GeneralProgram(record.getRelevantClauses(), record.getRelevantOntology());
34 m_graph = m_program.buildDependencyGraph();
35 }
36
37 public Set<DLClause> relevantClauses(Set<DLClause> disjuntiveRules) {
38 Set<DLClause> relevant = new HashSet<DLClause>();
39 Set<DLClause> now = new HashSet<DLClause>();
40 Set<DLClause> last = new HashSet<DLClause>();
41
42 for (DLClause rule: disjuntiveRules)
43 for (DLPredicate p: m_graph.collectPredicate(rule.getHeadAtoms()))
44 now.addAll(m_graph.pathToBottom(p));
45
46 while (!relevant.containsAll(now)) {
47 relevant.addAll(now);
48 last.clear();
49 last = now;
50 now = new HashSet<DLClause>();
51
52 for (DLClause rule: last) {
53 for (DLPredicate p: m_graph.collectPredicate(rule.getHeadAtoms()))
54 now.addAll(m_graph.pathToBottom(p));
55 for (DLPredicate p: m_graph.collectPredicate(rule.getBodyAtoms()))
56 now.addAll(m_graph.pathTo(p));
57 }
58 }
59
60 Utility.logDebug("There are " + relevant.size() + " clauses in the bottom fragment related to this query.");
61 return relevant;
62 }
63
64 public Set<OWLAxiom> relevantOntology(Set<DLClause> clauses, ApproxProgram upperProgram) {
65 Set<OWLAxiom> axioms = new HashSet<OWLAxiom>();
66 Set<DLPredicate> predicates = new HashSet<DLPredicate>();
67 for (DLClause clause: clauses) {
68 OWLAxiom axiom = upperProgram.getEquivalentAxiom(clause);
69 axioms.add(axiom);
70 predicates.addAll(m_graph.collectPredicate(clause.getHeadAtoms()));
71 predicates.addAll(m_graph.collectPredicate(clause.getBodyAtoms()));
72 }
73
74 int tboxCounter = axioms.size();
75 Utility.logDebug("There are " + tboxCounter + " TBox axioms in the bottom fragment related to this query.");
76 String name;
77 for (OWLAxiom axiom: m_record.getRelevantOntology().getABoxAxioms(Imports.INCLUDED)) {
78 if (axiom instanceof OWLClassAssertionAxiom) {
79 OWLClass cls = (OWLClass) ((OWLClassAssertionAxiom) axiom).getClassExpression();
80 name = cls.getIRI().toString();
81 if (predicates.contains(AtomicConcept.create(name)))
82 axioms.add(axiom);
83 }
84 else if (axiom instanceof OWLObjectPropertyAssertionAxiom) {
85 OWLObjectProperty prop = (OWLObjectProperty) ((OWLObjectPropertyAssertionAxiom) axiom).getProperty();
86 name = prop.getIRI().toString();
87 if (predicates.contains(AtomicRole.create(name)))
88 axioms.add(axiom);
89 }
90 else if (axiom instanceof OWLDataPropertyAssertionAxiom) {
91 OWLDataProperty prop = (OWLDataProperty) ((OWLDataPropertyAssertionAxiom) axiom).getProperty();
92 name = prop.getIRI().toString();
93 if (predicates.contains(AtomicRole.create(name)))
94 axioms.add(axiom);
95 }
96 }
97
98 Utility.logDebug("There are " + (axioms.size() - tboxCounter) + " ABox axioms in the bottom fragment related to this query.");
99 return axioms;
100 }
101}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java
new file mode 100644
index 0000000..27d3a53
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java
@@ -0,0 +1,440 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.DLClause;
4import org.semanticweb.owlapi.model.*;
5import uk.ac.ox.cs.JRDFox.JRDFStoreException;
6import uk.ac.ox.cs.JRDFox.model.Datatype;
7import uk.ac.ox.cs.JRDFox.store.DataStore;
8import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
9import uk.ac.ox.cs.JRDFox.store.Resource;
10import uk.ac.ox.cs.JRDFox.store.TupleIterator;
11import uk.ac.ox.cs.pagoda.MyPrefixes;
12import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
13import uk.ac.ox.cs.pagoda.owl.OWLHelper;
14import uk.ac.ox.cs.pagoda.query.AnswerTuple;
15import uk.ac.ox.cs.pagoda.query.QueryRecord;
16import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
17import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
18import uk.ac.ox.cs.pagoda.util.Namespace;
19import uk.ac.ox.cs.pagoda.util.Timer;
20import uk.ac.ox.cs.pagoda.util.UFS;
21import uk.ac.ox.cs.pagoda.util.Utility;
22
23import java.util.HashSet;
24import java.util.Iterator;
25import java.util.LinkedList;
26import java.util.Set;
27
28public class QueryTracker {
29
30 QueryRecord m_record;
31 BasicQueryEngine m_dataStore;
32 TrackingRuleEncoder m_encoder;
33
34 OWLOntologyManager m_manager;
35 Set<OWLAxiom> m_tBoxAxioms;
36
37 UFS<String> equalityGroups;
38
39 public QueryTracker(TrackingRuleEncoder encoder, BasicQueryEngine lowerStore, QueryRecord queryRecord) {
40 m_encoder = encoder;
41 m_dataStore = lowerStore;
42 m_record = queryRecord;
43
44 m_manager = m_encoder.getOntology().getOWLOntologyManager();
45 equalityGroups = m_dataStore.getEqualityGroups(true);
46
47 }
48
49 public OWLOntology extract(BasicQueryEngine trackingStore, QueryRecord[] botQuerRecords, boolean incrementally) {
50 try {
51 if (m_record.getRelevantOntology() != null) {
52 m_manager.removeOntology(m_record.getRelevantOntology());
53 m_record.setRelevantOntology(null);
54 m_record.clearClauses();
55 }
56 m_record.setRelevantOntology(m_manager.createOntology());
57 } catch (OWLOntologyCreationException e) {
58 e.printStackTrace();
59 }
60
61 m_encoder.setCurrentQuery(m_record);
62
63// m_encoder.encodingQuery(botQuerRecords);
64// m_encoder.saveTrackingRules("tracking_query" + m_record.getQueryID() + ".dlog");
65
66 DataStore store = trackingStore.getDataStore();
67 long oldTripleCount, tripleCount;
68 try {
69 Timer t1 = new Timer();
70 oldTripleCount = store.getTriplesCount();
71 // store.addRules(new String[] {m_encoder.getTrackingProgram()});
72 store.importRules(m_encoder.getTrackingProgram(), UpdateType.ScheduleForAddition);
73 store.applyReasoning(incrementally);
74 tripleCount = store.getTriplesCount();
75
76 Utility.logDebug("tracking store after materialising tracking program: "
77 + tripleCount
78 + " ("
79 + (tripleCount - oldTripleCount)
80 + " new)");
81 Utility.logDebug("tracking store finished the materialisation of tracking program in "
82 + t1.duration() + " seconds.");
83 } catch (JRDFStoreException e) {
84 e.printStackTrace();
85 }
86 extractAxioms(trackingStore);
87
88 trackingStore.clearRulesAndIDBFacts(m_encoder.getAddedData());
89
90 if (!m_record.isBottom()
91 && !(m_encoder instanceof TrackingRuleEncoderDisj2))
92 addRelatedAxiomsAndClauses(botQuerRecords);
93
94 return m_record.getRelevantOntology();
95 }
96
97 public void extractAxioms(BasicQueryEngine trackingStore) {
98 Set<String> unaryPredicates = new HashSet<String>();
99 Set<String> binaryPredicates = new HashSet<String>();
100
101 getDerivedPredicates(trackingStore, unaryPredicates, binaryPredicates);
102
103 /**
104 * To add all the relavant ABox assertions to the fragment
105 */
106
107 int aboxAxiomCounter = extractUnaryTuples(trackingStore,
108 m_manager.getOWLDataFactory(), unaryPredicates)
109 + extractBinaryTuples(trackingStore,
110 m_manager.getOWLDataFactory(), binaryPredicates);
111
112 /**
113 * To all all the relavant TBox rules to the fragment
114 */
115 String queryText = m_encoder.getSelectedSPARQLQuery();
116
117 DLClause clause;
118 m_tBoxAxioms = new HashSet<OWLAxiom>();
119 OWLAxiom tBoxAxiom;
120 TupleIterator answers = null;
121 String answer;
122 try {
123 answers = trackingStore.internal_evaluate(queryText);
124 for (long multi = answers.open(); multi != 0; multi = answers.getNext()) {
125 answer = answers.getResource(0).m_lexicalForm;
126 clause = m_encoder.getSelectedClause(MyPrefixes.PAGOdAPrefixes.expandIRI(answer));
127 if (DLClauseHelper.isTautologyAboutDifferentFrom(clause))
128 continue;
129 tBoxAxiom = m_encoder.getProgram().getEquivalentAxiom(clause);
130 m_record.addRelevantClauses(clause);
131 m_tBoxAxioms.add(tBoxAxiom);
132 }
133 } catch (JRDFStoreException e) {
134 e.printStackTrace();
135 } finally {
136 if (answers != null) answers.dispose();
137 }
138
139 Utility.logTrace("Extracted TBox axioms: ");
140 for (OWLAxiom axiom : m_tBoxAxioms) {
141 Utility.logTrace(axiom);
142 m_manager.addAxiom(m_record.getRelevantOntology(), axiom);
143 }
144 Utility.logDebug("TBox extraction Done");
145
146 Utility.logDebug("Before adding bottom fragment:\nABoxAxiomsCount = "
147 + aboxAxiomCounter + ", TBoxAxiomsCount = "
148 + m_tBoxAxioms.size());
149
150 }
151
152 public void addRelatedAxiomsAndClauses(QueryRecord[] botQueryRecords) {
153 LinkedList<QueryRecord> toAddedRecords = new LinkedList<QueryRecord>();
154
155 for(QueryRecord botQueryRecord : botQueryRecords)
156 if(overlappingDisjunctiveClauses(botQueryRecord) != null)
157 toAddedRecords.add(botQueryRecord);
158
159 for(QueryRecord botQueryRecord : toAddedRecords) {
160 m_manager.addAxioms(m_record.getRelevantOntology(), botQueryRecord.getRelevantOntology().getAxioms());
161 for(DLClause clause : botQueryRecord.getRelevantClauses())
162 m_record.addRelevantClauses(clause);
163 }
164
165 if(!toAddedRecords.isEmpty())
166 Utility.logDebug("Part of bottom fragments is added for this query.");
167 else
168 Utility.logDebug("None of bottom fragments is added for this query.");
169 }
170
171 private int extractBinaryTuples(BasicQueryEngine trackingStore, OWLDataFactory factory, Set<String> binaryPredicates) {
172 OWLOntology fragment = m_record.getRelevantOntology();
173 int count;
174 int aboxAxiomCounter = 0;
175 Resource sub, obj;
176 OWLAxiom aboxAxiom;
177 String trackingIRI;
178 Set<Integer> trackedIDEqualities = new HashSet<Integer>();
179 Set<String> trackedEntityEqualities = new HashSet<String>();
180 TupleIterator trackingAnswers, lowerAnswers;
181
182 for (Iterator<String> iter = binaryPredicates.iterator(); iter.hasNext(); ) {
183 trackingIRI = iter.next();
184 String propIRI = m_encoder.getOriginalPredicate(trackingIRI);
185 if(propIRI == null) continue;
186 if (!propIRI.equals(Namespace.EQUALITY_QUOTED)) continue;
187 trackingAnswers = null;
188 try {
189 trackingAnswers = trackingStore.internal_evaluateAgainstIDBs(getSPARQLQuery4Binary(trackingIRI));
190 for (long multi = trackingAnswers.open(); multi != 0; multi = trackingAnswers.getNext()) {
191 if (trackingAnswers.getResourceID(0) != trackingAnswers.getResourceID(1)) {
192 for(int i = 0; i < 2; ++i)
193 if (trackedIDEqualities.add(trackingAnswers.getResourceID(i))) {
194 trackedEntityEqualities.add(trackingAnswers.getResource(i).m_lexicalForm);
195 }
196 }
197 }
198 } catch (JRDFStoreException e) {
199 e.printStackTrace();
200 } finally {
201 if(trackingAnswers != null) trackingAnswers.dispose();
202 }
203 iter.remove();
204 break;
205 }
206
207 String sub_rep, obj_rep;
208
209 for (Iterator<String> iter = binaryPredicates.iterator(); iter.hasNext(); ) {
210 trackingIRI = iter.next();
211 count = 0;
212 String propIRI = m_encoder.getOriginalPredicate(trackingIRI);
213 if(propIRI == null) continue;
214 iter.remove();
215 lowerAnswers = null;
216 trackingAnswers = null;
217 Set<String> lower = new HashSet<String>();
218 OWLObject prop = null;
219 try {
220 trackingAnswers = trackingStore.internal_evaluateAgainstIDBs(getSPARQLQuery4Binary(trackingIRI));
221 trackingAnswers.open();
222 if(trackingAnswers.getMultiplicity() == 0) continue;
223
224 lowerAnswers = m_dataStore.internal_evaluateNotExpanded(getSPARQLQuery4Binary(propIRI));
225 lowerAnswers.open();
226 if(lowerAnswers.getMultiplicity() == 0) continue;
227
228 StringBuilder builder = new StringBuilder();
229 for (long multi = lowerAnswers.getMultiplicity(); multi != 0; multi = lowerAnswers.getNext()) {
230 sub = lowerAnswers.getResource(0);
231 obj = lowerAnswers.getResource(1);
232 builder.setLength(0);
233 builder.append(equalityGroups.find(sub.m_lexicalForm))
234 .append(AnswerTuple.SEPARATOR)
235 .append(equalityGroups.find(obj.m_lexicalForm));
236 lower.add(builder.toString());
237 }
238
239 for (long multi = trackingAnswers.getMultiplicity(); multi != 0; multi = trackingAnswers.getNext()) {
240 sub = trackingAnswers.getResource(0);
241 obj = trackingAnswers.getResource(1);
242 builder.setLength(0);
243 sub_rep = equalityGroups.find(sub.m_lexicalForm);
244 obj_rep = equalityGroups.find(obj.m_lexicalForm);
245 if (!sub_rep.equals(sub.m_lexicalForm) || !obj_rep.equals(obj.m_lexicalForm)) continue;
246
247 builder.append(sub_rep).append(AnswerTuple.SEPARATOR).append(obj_rep);
248 if (lower.contains(builder.toString())) {
249 OWLObject owlObj = getOWLObject(obj, factory);
250 if (owlObj instanceof OWLIndividual) {
251 if (prop == null)
252 prop = factory.getOWLObjectProperty(IRI.create(propIRI.startsWith("<") ? OWLHelper.removeAngles(propIRI) : propIRI));
253 aboxAxiom = factory.getOWLObjectPropertyAssertionAxiom(
254 (OWLObjectProperty) prop,
255 factory.getOWLNamedIndividual(IRI.create(sub_rep)),
256 factory.getOWLNamedIndividual(IRI.create(obj_rep)));
257 }
258 else if (owlObj instanceof OWLLiteral) {
259 if (prop == null)
260 prop = factory.getOWLDataProperty(IRI.create(propIRI.startsWith("<") ? OWLHelper.removeAngles(propIRI) : propIRI));
261 aboxAxiom = factory.getOWLDataPropertyAssertionAxiom(
262 (OWLDataProperty) prop,
263 factory.getOWLNamedIndividual(IRI.create(sub_rep)),
264 (OWLLiteral) owlObj);
265 }
266 else {
267 Utility.logError("There might be an error here ... ");
268 continue;
269 }
270 if (!fragment.containsAxiom(aboxAxiom)) {
271 m_manager.addAxiom(fragment, aboxAxiom);
272 ++aboxAxiomCounter;
273 ++count;
274 }
275 }
276 }
277 } catch (JRDFStoreException e) {
278 e.printStackTrace();
279 } finally {
280 if (trackingAnswers != null) trackingAnswers.dispose();
281 if (lowerAnswers != null) lowerAnswers.dispose();
282 lower.clear();
283 }
284 Utility.logDebug("property: " + propIRI + " " + count);
285 }
286
287 count = 0;
288 String value;
289 OWLObjectProperty sameAs = factory.getOWLObjectProperty(IRI.create(Namespace.EQUALITY));
290 for (String key: equalityGroups.keySet()) {
291 if(!trackedEntityEqualities.contains(key)) continue;
292 value = equalityGroups.find(key);
293 m_manager.addAxiom(fragment, factory.getOWLObjectPropertyAssertionAxiom(
294 sameAs,
295 factory.getOWLNamedIndividual(IRI.create(key)),
296 factory.getOWLNamedIndividual(IRI.create(value))));
297 ++aboxAxiomCounter;
298 ++count;
299 }
300 Utility.logDebug("property: " + Namespace.EQUALITY_QUOTED + " " + count);
301
302 trackedEntityEqualities.clear();
303 trackedIDEqualities.clear();
304 Utility.logTrace(Namespace.EQUALITY_QUOTED + " " + count);
305
306 Utility.logDebug("ABox extraction Done");
307 return aboxAxiomCounter;
308 }
309
310 private OWLObject getOWLObject(Resource rdfoxTerm, OWLDataFactory factory) {
311 if (rdfoxTerm.m_datatype.equals(Datatype.IRI_REFERENCE))
312 return factory.getOWLNamedIndividual(IRI.create(rdfoxTerm.m_lexicalForm));
313// if (rdfoxTerm.m_datatype.equals(Datatype.OWL_REAL) || rdfoxTerm.m_datatype.equals(Datatype.OWL_RATIONAL) ||
314// rdfoxTerm.m_datatype.equals(Datatype.XSD_DECIMAL) || rdfoxTerm.m_datatype.equals(Datatype.XSD_INTEGER) ||
315// rdfoxTerm.m_datatype.equals(Datatype.XSD_NON_NEGATIVE_INTEGER) || rdfoxTerm.m_datatype.equals(Datatype.XSD_POSITIVE_INTEGER) ||
316// rdfoxTerm.m_datatype.equals(Datatype.XSD_NEGATIVE_INTEGER) || rdfoxTerm.m_datatype.equals(Datatype.XSD_LONG) ||
317// rdfoxTerm.m_datatype.equals(Datatype.XSD_INT) || rdfoxTerm.m_datatype.equals(Datatype.XSD_SHORT) ||
318// rdfoxTerm.m_datatype.equals(Datatype.XSD_BYTE) || rdfoxTerm.m_datatype.equals(Datatype.XSD_UNSIGNED_LONG) ||
319// rdfoxTerm.m_datatype.equals(Datatype.XSD_UNSIGNED_INT) || rdfoxTerm.m_datatype.equals(Datatype.XSD_UNSIGNED_SHORT) ||
320// rdfoxTerm.m_datatype.equals(Datatype.XSD_UNSIGNED_BYTE))
321 if (rdfoxTerm.m_datatype.equals(Datatype.XSD_DATE))
322 return factory.getOWLLiteral(rdfoxTerm.m_lexicalForm, factory.getOWLDatatype(IRI.create(Namespace.XSD_STRING)));
323
324 else
325 return factory.getOWLLiteral(rdfoxTerm.m_lexicalForm, factory.getOWLDatatype(IRI.create(rdfoxTerm.m_datatype
326 .getIRI())));
327 }
328
329 private int extractUnaryTuples(BasicQueryEngine trackingStore, OWLDataFactory factory, Set<String> unaryPredicates) {
330 OWLOntology fragment = m_record.getRelevantOntology();
331 int count;
332 int aboxAxiomCounter = 0;
333 String answer;
334 OWLAxiom aboxAxiom;
335 for (String trackingIRI : unaryPredicates) {
336 count = 0;
337 String clsIRI = m_encoder.getOriginalPredicate(trackingIRI);
338 if (clsIRI == null)
339 continue;
340 TupleIterator answers = null, lowerAnswers = null;
341 Set<String> lower = new HashSet<String>();
342 OWLClass cls = factory.getOWLClass(IRI.create(clsIRI.startsWith("<") ? OWLHelper.removeAngles(clsIRI) : clsIRI));
343 try {
344 answers = trackingStore.internal_evaluateAgainstIDBs(getSPARQLQuery4Unary(trackingIRI));
345 answers.open();
346 if(answers.getMultiplicity() == 0) continue;
347
348 lowerAnswers = m_dataStore.internal_evaluateNotExpanded(getSPARQLQuery4Unary(clsIRI));
349 lowerAnswers.open();
350 if (lowerAnswers.getMultiplicity() == 0) continue;
351
352 for (long multi = lowerAnswers.getMultiplicity(); multi != 0; multi = lowerAnswers.getNext())
353 lower.add(equalityGroups.find(lowerAnswers.getResource(0).m_lexicalForm));
354
355 for (long multi = answers.getMultiplicity(); multi != 0; multi = answers.getNext()) {
356 answer = equalityGroups.find(answers.getResource(0).m_lexicalForm);
357 if (lower.contains(answer)) {
358 OWLIndividual instance = factory.getOWLNamedIndividual(IRI.create(answer));
359 aboxAxiom = factory.getOWLClassAssertionAxiom(cls,instance);
360 if (!fragment.containsAxiom(aboxAxiom)) {
361 m_manager.addAxiom(fragment, aboxAxiom);
362 ++aboxAxiomCounter;
363 ++count;
364 }
365 }
366 }
367 } catch (JRDFStoreException e) {
368 e.printStackTrace();
369 } finally {
370 if (answers != null) answers.dispose();
371 if (lowerAnswers != null) lowerAnswers.dispose();
372 lower.clear();
373 }
374 Utility.logDebug("class: " + clsIRI + " " + count);
375 }
376 return aboxAxiomCounter;
377 }
378
379 private void getDerivedPredicates(BasicQueryEngine trackingStore, Set<String> unaryPredicates, Set<String> binaryPredicates) {
380 TupleIterator derivedTuples = null;
381 String selectedPredicate = OWLHelper.addAngles(m_encoder.getSelectedPredicate());
382 try {
383 derivedTuples = trackingStore.internal_evaluateAgainstIDBs("select distinct ?z where { ?x <" + Namespace.RDF_TYPE + "> ?z . }");
384 for (long multi = derivedTuples.open(); multi != 0; multi = derivedTuples.getNext()) {
385 String p = RDFoxTripleManager.getQuotedTerm(derivedTuples.getResource(0));
386 if (p.equals(selectedPredicate)) ;
387 else if (m_encoder.isAuxPredicate(p)) ;
388 else unaryPredicates.add(p);
389 }
390 } catch (JRDFStoreException e) {
391 e.printStackTrace();
392 } finally {
393 if (derivedTuples != null) derivedTuples.dispose();
394 }
395
396 derivedTuples = null;
397 try {
398 derivedTuples = trackingStore.internal_evaluateAgainstIDBs("select distinct ?y where { ?x ?y ?z . }");
399 for (long multi = derivedTuples.open(); multi != 0; multi = derivedTuples.getNext()) {
400 String p = RDFoxTripleManager.getQuotedTerm(derivedTuples.getResource(0));
401 if (p.equals(Namespace.RDF_TYPE_ABBR) || p.equals(Namespace.RDF_TYPE_QUOTED)) ;
402 else if (p.equals(Namespace.EQUALITY_ABBR) || p.equals(Namespace.EQUALITY_QUOTED)) ;
403 else if (m_encoder.isAuxPredicate(p)) ;
404 else binaryPredicates.add(p);
405 }
406 } catch (JRDFStoreException e) {
407 e.printStackTrace();
408 } finally {
409 if (derivedTuples != null) derivedTuples.dispose();
410 }
411 }
412
413 private Set<DLClause> overlappingDisjunctiveClauses(
414 QueryRecord botQueryRecord) {
415 if (m_tBoxAxioms == null)
416 return null;
417
418 Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
419 Set<DLClause> clauses = m_record.getRelevantClauses();
420 for (DLClause clause : botQueryRecord.getRelevantClauses())
421 if (clause.getHeadLength() > 1 && clauses.contains(clause))
422 disjunctiveRules.add(clause);
423
424 return disjunctiveRules.isEmpty() ? null : disjunctiveRules;
425 }
426
427 private String getSPARQLQuery4Unary(String p) {
428 StringBuilder builder = new StringBuilder();
429 builder.append("select ?x where { ?x <").append(Namespace.RDF_TYPE).append("> ");
430 builder.append(p).append(" . }");
431 return builder.toString();
432 }
433
434 private String getSPARQLQuery4Binary(String p) {
435 StringBuilder builder = new StringBuilder();
436 builder.append("select ?x ?y where { ?x ").append(p).append(" ?y . }");
437 return builder.toString();
438 }
439
440}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java
new file mode 100644
index 0000000..d05731a
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java
@@ -0,0 +1,387 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import org.semanticweb.owlapi.model.OWLOntology;
5import uk.ac.ox.cs.JRDFox.model.Datatype;
6import uk.ac.ox.cs.JRDFox.model.GroundTerm;
7import uk.ac.ox.cs.JRDFox.model.Literal;
8import uk.ac.ox.cs.pagoda.MyPrefixes;
9import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
10import uk.ac.ox.cs.pagoda.query.AnswerTuple;
11import uk.ac.ox.cs.pagoda.query.AnswerTuples;
12import uk.ac.ox.cs.pagoda.query.GapTupleIterator;
13import uk.ac.ox.cs.pagoda.query.QueryRecord;
14import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
15import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
16import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
17import uk.ac.ox.cs.pagoda.util.Namespace;
18import uk.ac.ox.cs.pagoda.util.Utility;
19import uk.ac.ox.cs.pagoda.util.disposable.Disposable;
20import uk.ac.ox.cs.pagoda.util.disposable.DisposedException;
21
22import java.io.BufferedWriter;
23import java.io.FileOutputStream;
24import java.io.IOException;
25import java.io.OutputStreamWriter;
26import java.util.*;
27
28public abstract class TrackingRuleEncoder extends Disposable {
29 public static final String trackingPredicateRelation = Namespace.PAGODA_AUX + "isTrackingPredicateFor";
30 public static final String QueryPredicate = Namespace.PAGODA_AUX + "Query";
31 protected BasicQueryEngine store;
32 protected QueryRecord currentQuery;
33 protected Set<String> unaryPredicates = new HashSet<String>();
34 protected Set<String> binaryPredicates = new HashSet<String>();
35 UpperDatalogProgram program;
36 Collection<DLClause> trackingClauses = new HashSet<DLClause>();
37 Collection<DLClause> queryClauses = new LinkedList<DLClause>();
38 Map<Integer, DLClause> index2clause = new HashMap<Integer, DLClause>();
39 Map<DLClause, Integer> clause2index = new HashMap<DLClause, Integer>();
40 String equalityRelatedRuleText = null;
41 boolean ruleEncoded = false;
42 DLPredicate selected;
43 private boolean queryEncoded = false;
44 private LinkedList<int[]> addedData = new LinkedList<int[]>();
45 private String trackingSuffix;
46
47 public TrackingRuleEncoder(UpperDatalogProgram program, BasicQueryEngine store) {
48 this.program = program;
49 this.store = store;
50 }
51
52 public static String getRawTerm(GroundTerm r) {
53 if(r instanceof uk.ac.ox.cs.JRDFox.model.Individual)
54 return ((uk.ac.ox.cs.JRDFox.model.Individual) r).getIRI();
55 else {
56 Literal l = (Literal) r;
57 if(l.getDatatype().equals(Datatype.XSD_STRING) && l.getDatatype().equals(Datatype.RDF_PLAIN_LITERAL))
58 return "\"" + l.getLexicalForm() + "\"";
59 else
60 return "\"" + l.getLexicalForm() + "\"^^<" + l.getDatatype().getIRI() + ">";
61 }
62 }
63
64 protected static String getTrackingSuffix(String queryID) {
65 return "_AUXt" + queryID;
66 }
67
68 public boolean encodingRules() {
69 if(isDisposed()) throw new DisposedException();
70 if(ruleEncoded) return false;
71 ruleEncoded = true;
72
73// for (DLClause clause: program.getClauses(currentQuery.getClause())) {
74 for(DLClause clause : program.getClauses()) {
75 encodingRule(clause);
76 }
77 return true;
78 }
79
80 public Collection<int[]> getAddedData() {
81 if(isDisposed()) throw new DisposedException();
82 return addedData;
83 }
84
85 public String getTrackingPredicate(String predicateIRI) {
86 if(isDisposed()) throw new DisposedException();
87 if(predicateIRI.startsWith("<"))
88 return predicateIRI.replace(">", getTrackingSuffix(currentQuery.getQueryID()) + ">");
89 else
90 return predicateIRI + getTrackingSuffix(currentQuery.getQueryID());
91 }
92
93 public void setCurrentQuery(QueryRecord record) {
94 if(isDisposed()) throw new DisposedException();
95 deprecateTrackingAndQueryRules();
96 currentQuery = record;
97 selected = AtomicConcept.create(getSelectedPredicate());
98 trackingSuffix = "_AUXt" + currentQuery.getQueryID();
99 }
100
101 @Override
102 public void dispose() {
103 super.dispose();
104 deprecateTrackingAndQueryRules();
105 }
106
107 public String getTrackingProgram() {
108 if(isDisposed()) throw new DisposedException();
109 StringBuilder sb = getTrackingProgramBody();
110 sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText());
111 return sb.toString();
112 }
113
114 public void saveTrackingRules(String fileName) {
115 if(isDisposed()) throw new DisposedException();
116 BufferedWriter writer = null;
117 try {
118 writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName)));
119 writer.write(getTrackingProgram());
120 writer.close();
121 } catch(IOException e) {
122 e.printStackTrace();
123 return;
124 }
125 Utility.logDebug("The tracking rules are saved in " + fileName + ".");
126 }
127
128 public String getSelectedPredicate() {
129 if(isDisposed()) throw new DisposedException();
130 return getIRI("_selected" + currentQuery.getQueryID());
131 }
132
133 public DLClause getSelectedClause(String iri) {
134 if(isDisposed()) throw new DisposedException();
135 int index = iri.lastIndexOf("_r") + 2;
136 int ruleIndex = Integer.parseInt(iri.substring(index));
137 return index2clause.get(ruleIndex);
138 }
139
140 /**
141 * SELECT ?X
142 * WHERE {
143 * ?X <http://www.w3.org/1999/02/22-rdf-syntax-ns#:type> :_selected?
144 * }
145 */
146 public String getSelectedSPARQLQuery() {
147 if(isDisposed()) throw new DisposedException();
148 StringBuilder builder = new StringBuilder();
149 builder.append("SELECT ?X\nWHERE {\n?X <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ");
150 builder.append(selected.toString()).append("\n}");
151 return builder.toString();
152 }
153
154 public OWLOntology getOntology() {
155 if(isDisposed()) throw new DisposedException();
156 return program.getOntology();
157 }
158
159 public UpperDatalogProgram getProgram() {
160 if(isDisposed()) throw new DisposedException();
161 return program;
162 }
163
164 public String getOriginalPredicate(String p) {
165 if(isDisposed()) throw new DisposedException();
166 if(p.startsWith("<")) {
167 if(!p.endsWith(trackingSuffix + ">")) return null;
168 }
169 else if(!p.endsWith(trackingSuffix)) return null;
170
171 return p.replace(trackingSuffix, "");
172 }
173
174 public boolean isAuxPredicate(String p) {
175 if(isDisposed()) throw new DisposedException();
176 return false;
177 }
178
179 protected abstract String getEqualityRelatedRuleText();
180
181 protected String getIRI(String name) {
182 return program.getOntology().getOntologyID().getOntologyIRI().toString() + "#" + name;
183 }
184
185 protected abstract void encodingRule(DLClause clause);
186
187 protected Individual getIndividual4GeneralRule(DLClause clause) {
188 clause = program.getCorrespondingClause(clause);
189// if (clause == null)
190// return Individual.create(getIRI("_r0"));
191
192 int index;
193 if(clause2index.containsKey(clause))
194 index = clause2index.get(clause);
195 else {
196 index = clause2index.size() + 1;
197 index2clause.put(index, clause);
198 clause2index.put(clause, index);
199 }
200
201 return Individual.create(getIRI("_r" + index));
202 }
203
204 private void encodingQuery(QueryRecord[] botQuerRecords) {
205 if(queryEncoded) return;
206 queryEncoded = true;
207
208 if(currentQuery.getArity() > 0 && currentQuery.getArity() < 3) {
209 encodingAtomicQuery(botQuerRecords);
210
211 }
212 else {
213 DLClause queryClause = currentQuery.getClause();
214 Atom[] bodyAtoms = queryClause.getBodyAtoms();
215 for(Atom bodyAtom : bodyAtoms)
216 addQueryRule(bodyAtom, bodyAtoms);
217 }
218 }
219
220 private void addQueryRule(Atom atom, Atom[] atoms) {
221 DLClause newClause;
222 Atom headAtom;
223
224 headAtom = Atom.create(
225 getTrackingDLPredicate(atom.getDLPredicate()),
226 DLClauseHelper.getArguments(atom));
227 newClause = DLClause.create(new Atom[]{headAtom}, atoms);
228 queryClauses.add(newClause);
229 }
230
231 protected String getCurrentQueryPredicate() {
232 return QueryPredicate + currentQuery.getQueryID();
233 }
234
235 protected void encodingAtomicQuery(QueryRecord[] botQuerRecords) {
236 encodingAtomicQuery(botQuerRecords, false);
237 }
238
239 protected void encodingAtomicQuery(QueryRecord[] botQuerRecords, boolean includingBottom) {
240 DLClause queryClause = currentQuery.getClause();
241 AnswerTuples answerTuples = currentQuery.getGapAnswers();
242 String[] answerVariables = currentQuery.getAnswerVariables();
243
244 String currentQueryPredicate = getCurrentQueryPredicate();
245 Atom newAtom;
246 if(answerVariables.length == 1) {
247 AtomicConcept queryConcept = AtomicConcept.create(currentQueryPredicate);
248 newAtom = Atom.create(queryConcept, Variable.create(answerVariables[0]));
249 }
250 else {
251 AtomicRole queryRole = AtomicRole.create(currentQueryPredicate);
252 newAtom = Atom.create(queryRole, Variable.create(answerVariables[0]), Variable.create(answerVariables[1]));
253 }
254
255 Atom[] bodyAtoms = queryClause.getBodyAtoms();
256 Atom[] newBodyAtoms = new Atom[queryClause.getBodyLength() + 1];
257 for(int i = 0; i < bodyAtoms.length; ++i)
258 newBodyAtoms[i + 1] = bodyAtoms[i];
259 newBodyAtoms[0] = newAtom;
260
261 for(Atom bodyAtom : bodyAtoms)
262 addQueryRule(bodyAtom, newBodyAtoms);
263
264 RDFoxTripleManager tripleManager = new RDFoxTripleManager(store.getDataStore(), true);
265// MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes;
266 int[] triple;
267 int predicate = tripleManager.getResourceID(AtomicConcept.create(currentQueryPredicate));
268 int rdftype = tripleManager.getResourceID(AtomicRole.create(Namespace.RDF_TYPE));
269 if(answerVariables.length == 1) {
270 for(AnswerTuple answer; answerTuples.isValid(); answerTuples.moveNext()) {
271 answer = answerTuples.getTuple();
272 triple =
273 new int[]{tripleManager.getResourceID(getRawTerm(answer.getGroundTerm(0))), rdftype, predicate};
274 addedData.add(triple);
275 tripleManager.addTripleByID(triple);
276// System.out.println("To be removed ... \n" + tripleManager.getRawTerm(tripleManager.getResourceID(prefixes.expandIRI(answer.getRawTerm(0)))) + " " + tripleManager.getRawTerm(rdftype) + " " + tripleManager.getRawTerm(predicate));
277 }
278 }
279 else {
280 for(AnswerTuple answer; answerTuples.isValid(); answerTuples.moveNext()) {
281 answer = answerTuples.getTuple();
282 triple =
283 new int[]{tripleManager.getResourceID(getRawTerm(answer.getGroundTerm(0))), predicate, tripleManager
284 .getResourceID(getRawTerm(answer.getGroundTerm(1)))};
285 addedData.add(triple);
286 tripleManager.addTripleByID(triple);
287 }
288 }
289// answerTuples.dispose();
290
291 if(includingBottom && botQuerRecords != null) {
292 int index = 0;
293 GroundTerm t;
294 String raw;
295 for(QueryRecord botQueryRecord : botQuerRecords) {
296 answerTuples = botQueryRecord.getGapAnswers();
297 int subID = 0;//botQueryRecord.getSubID();
298 String p = subID == 0 ? AtomicConcept.NOTHING.getIRI() : Namespace.OWL_NS + "Nothing_final" + (++index);
299 predicate = tripleManager.getResourceID(AtomicConcept.create(p = getTrackingPredicate(p)));
300 for(AnswerTuple answer; answerTuples.isValid(); answerTuples.moveNext()) {
301 answer = answerTuples.getTuple();
302// System.out.println("To be removed ... " + answer.getRawTerm(0));
303 raw = ((t =
304 answer.getGroundTerm(0)) instanceof uk.ac.ox.cs.JRDFox.model.Individual) ? ((uk.ac.ox.cs.JRDFox.model.Individual) t)
305 .getIRI() : t.toString();
306 triple = new int[]{tripleManager.getResourceID(raw), rdftype, predicate};
307 addedData.add(triple);
308 tripleManager.addTripleByID(triple);
309 }
310// answerTuples.dispose();
311 }
312 }
313
314 Utility.logDebug(addedData.size() + " triples are added into the store.");
315 }
316
317 protected DLPredicate getGapDLPredicate(DLPredicate dlPredicate) {
318 return getDLPredicate(dlPredicate, GapTupleIterator.gapPredicateSuffix);
319 }
320
321 DLPredicate getDLPredicate(DLPredicate p, String suffix) {
322 if(isDisposed()) throw new DisposedException();
323 if(p instanceof AtomicConcept)
324 return AtomicConcept.create(((AtomicConcept) p).getIRI() + suffix);
325 else if(p instanceof DatatypeRestriction) {
326 DatatypeRestriction restriction = (DatatypeRestriction) p;
327 String newURI = restriction.getDatatypeURI() + suffix;
328 return getDatatypeRestriction(restriction, newURI);
329 }
330 else if(p instanceof AtomicRole)
331 return AtomicRole.create(((AtomicRole) p).getIRI() + suffix);
332 else if(p instanceof AnnotatedEquality || p instanceof Equality)
333 return AtomicRole.create(Namespace.EQUALITY + suffix);
334 else if(p instanceof Inequality)
335 return AtomicRole.create(Namespace.INEQUALITY + suffix);
336 else if(p instanceof DatatypeRestriction)
337 return AtomicConcept.create(((DatatypeRestriction) p).getDatatypeURI() + suffix);
338 else {
339 Utility.logDebug("strange DL predicate appeared ... " + p,
340 "the program paused here in TrackingRuleEncoderDisj.java");
341 return null;
342 }
343 }
344
345 protected DLPredicate getTrackingDLPredicate(DLPredicate dlPredicate) {
346 return getDLPredicate(dlPredicate, getTrackingSuffix(currentQuery.getQueryID()));
347 }
348
349 protected DLPredicate getDatatypeRestriction(DatatypeRestriction restriction, String newName) {
350 int length = restriction.getNumberOfFacetRestrictions();
351 String[] facets = new String[length];
352 Constant[] values = new Constant[length];
353 for(int i = 0; i < length; ++i) {
354 facets[i] = restriction.getFacetURI(i);
355 values[i] = restriction.getFacetValue(i);
356 }
357 return DatatypeRestriction.create(newName, facets, values);
358 }
359
360 private String getTrackingRuleText() {
361 return DLClauseHelper.toString(trackingClauses);
362 }
363
364 private String getQueryRuleText() {
365 return DLClauseHelper.toString(queryClauses);
366 }
367
368 protected StringBuilder getTrackingProgramBody() {
369 encodingRules();
370 encodingQuery(new QueryRecord[0]);
371
372 StringBuilder sb = new StringBuilder();
373 sb.append(getTrackingRuleText());
374 sb.append(getEqualityRelatedRuleText());
375 sb.append(getQueryRuleText());
376 return sb;
377 }
378
379 private void deprecateTrackingAndQueryRules() {
380 trackingClauses.clear();
381 queryClauses.clear();
382 addedData.clear();
383 ruleEncoded = false;
384 queryEncoded = false;
385 }
386
387}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java
new file mode 100644
index 0000000..b169053
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java
@@ -0,0 +1,163 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
5import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
6import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
7import uk.ac.ox.cs.pagoda.rules.approximators.SkolemTermsManager;
8import uk.ac.ox.cs.pagoda.util.Namespace;
9
10import java.util.*;
11
12public abstract class TrackingRuleEncoderDisj extends TrackingRuleEncoderWithGap {
13
14 public TrackingRuleEncoderDisj(UpperDatalogProgram program, BasicQueryEngine store) {
15 super(program, store);
16 }
17
18 protected Map<DLClause, Collection<DLClause>> disjunctiveRules = new HashMap<DLClause, Collection<DLClause>>();
19
20 /**
21 *
22 */
23 protected void processDisjunctiveRules() {
24 Map<Atom, Collection<DLClause>> auxiliaryAtoms = new HashMap<Atom, Collection<DLClause>>();
25 Map<Individual, Collection<DLClause>> skolemisedAtoms = new HashMap<Individual, Collection<DLClause>>();
26 SkolemTermsManager termsManager = SkolemTermsManager.getInstance();
27
28 for (Map.Entry<DLClause, Collection<DLClause>> entry: disjunctiveRules.entrySet()) {
29 DLClause original = entry.getKey();
30 Collection<DLClause> overClauses = entry.getValue();
31
32 int index = 0;
33 for (Iterator<DLClause> iter = overClauses.iterator(); iter.hasNext();) {
34 DLClause subClause = iter.next();
35 if (DLClauseHelper.hasSubsetBodyAtoms(subClause, original)) {
36 Atom headAtom = subClause.getHeadAtom(0);
37 if ((index = SkolemTermsManager.indexOfSkolemisedIndividual(headAtom)) != -1) {
38 Individual i = (Individual) headAtom.getArgument(index);
39 Collection<DLClause> clauses = skolemisedAtoms.get(i);
40 if (clauses == null) {
41 clauses = new HashSet<DLClause>();
42 skolemisedAtoms.put(i, clauses);
43 }
44 clauses.add(subClause);
45 }
46 else
47 auxiliaryAtoms.put(getAuxiliaryAtom(original, subClause.getHeadAtom(0)), Collections.singleton(subClause));
48 }
49 else
50 super.encodingRule(subClause);
51 }
52
53 for (Atom headAtom: original.getHeadAtoms())
54 if (headAtom.getDLPredicate() instanceof AtLeastConcept) {
55 AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate();
56 Collection<DLClause> clauses = new HashSet<DLClause>();
57 Individual[] individuals = new Individual[alc.getNumber()];
58 for (int i = 0; i < alc.getNumber(); ++i) {
59 individuals[i] = termsManager.getFreshIndividual(original, i);
60 clauses.addAll(skolemisedAtoms.get(individuals[i]));
61 }
62 auxiliaryAtoms.put(getAuxiliaryAtom(original, headAtom, individuals), clauses);
63 }
64
65 index = 0;
66 Atom[] auxAtoms = auxiliaryAtoms.keySet().toArray(new Atom[0]);
67 for (Atom atom: auxAtoms) {
68 for (DLClause subClause: auxiliaryAtoms.get(atom))
69 encodingDisjunctiveRule(subClause, index, auxAtoms);
70 index++;
71 }
72
73 auxiliaryAtoms.clear();
74 }
75 }
76
77 private Atom getAuxiliaryAtom(DLClause original, Atom headAtom, Individual... individuals) {
78 DLPredicate p = headAtom.getDLPredicate();
79 if (p instanceof AtLeastConcept) {
80// AtLeastConcept alc = (AtLeastConcept) p;
81// Individual[] individuals = new Individual[alc.getNumber()];
82// for (int i = 0; i < alc.getNumber(); ++i)
83// individuals[i] = OverApproxExist.getNewIndividual(original, i);
84 return Atom.create(generateAuxiliaryRule((AtLeastConcept) p, original, individuals), headAtom.getArgument(0));
85 }
86 if (p instanceof AtomicConcept)
87 return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0));
88 if (p instanceof AtomicRole)
89 return Atom.create(generateAuxiliaryRule((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
90 if (p instanceof Equality || p instanceof AnnotatedEquality)
91 return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
92 if (p instanceof Inequality)
93 return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1));
94
95 return null;
96 }
97
98 private void encodingDisjunctiveRule(DLClause clause, int index, Atom[] auxAtoms) {
99 int validHeadLength = auxAtoms.length;
100 Atom headAtom = clause.getHeadAtom(0);
101 Atom[] bodyAtoms = clause.getBodyAtoms();
102
103 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
104 DLPredicate selected = AtomicConcept.create(getSelectedPredicate());
105 newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
106
107 for (Atom atom: bodyAtoms) {
108 Atom newAtom = Atom.create(
109 getTrackingDLPredicate(atom.getDLPredicate()),
110 DLClauseHelper.getArguments(atom));
111 newHeadAtoms.add(newAtom);
112 }
113
114 DLClause newClause;
115 Atom[] newBodyAtoms = new Atom[bodyAtoms.length + validHeadLength + 1];
116
117 newBodyAtoms[0] = Atom.create(
118 getTrackingDLPredicate(headAtom.getDLPredicate()),
119 DLClauseHelper.getArguments(headAtom));
120
121 newBodyAtoms[1] = Atom.create(
122 getGapDLPredicate(headAtom.getDLPredicate()),
123 DLClauseHelper.getArguments(headAtom));
124
125 for (int i = 0; i < validHeadLength; ++i)
126 if (i != index)
127 newBodyAtoms[i + (i < index ? 2 : 1)] = auxAtoms[i];
128
129 for (int i = 0; i < bodyAtoms.length; ++i)
130 newBodyAtoms[i + validHeadLength + 1] = bodyAtoms[i];
131
132 for (Atom atom: newHeadAtoms) {
133 newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms);
134 addTrackingClause(newClause);
135 }
136 }
137
138 protected void addTrackingClause(DLClause clause) {
139 trackingClauses.add(clause);
140 }
141
142 protected void addDisjunctiveRule(DLClause key, DLClause clause) {
143 Collection<DLClause> value = disjunctiveRules.get(key);
144 if (value == null) {
145 value = new LinkedList<DLClause>();
146 disjunctiveRules.put(key, value);
147 }
148 value.add(clause);
149 }
150
151 protected abstract DLPredicate generateAuxiliaryRule(AtLeastConcept p, DLClause original, Individual[] individuals);
152
153 protected abstract DLPredicate generateAuxiliaryRule(AtomicRole p);
154
155 protected abstract DLPredicate generateAuxiliaryRule(AtomicConcept p);
156
157 protected DLPredicate generateAuxiliaryRule(Equality instance) {
158 return generateAuxiliaryRule(AtomicRole.create(Namespace.EQUALITY));
159 }
160
161 protected abstract DLPredicate generateAuxiliaryRule(Inequality instance);
162
163}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java
new file mode 100644
index 0000000..d6b5e8b
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java
@@ -0,0 +1,175 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import uk.ac.ox.cs.pagoda.MyPrefixes;
5import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
6import uk.ac.ox.cs.pagoda.multistage.Normalisation;
7import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
8import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
9import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
10
11import java.util.LinkedList;
12
13public class TrackingRuleEncoderDisj1 extends TrackingRuleEncoderDisj {
14
15 public TrackingRuleEncoderDisj1(UpperDatalogProgram program, BasicQueryEngine store) {
16 super(program, store);
17 }
18
19 @Override
20 public boolean encodingRules() {
21 if (super.encodingRules()) {
22 processDisjunctiveRules();
23 return true;
24 }
25 return false;
26 }
27
28 @Override
29 protected void encodingRule(DLClause clause) {
30 if (currentQuery.isBottom()) {
31 super.encodingRule(clause);
32 return ;
33 }
34
35 DLClause original = program.getCorrespondingClause(clause);
36 if (original.getHeadLength() <= 1) {
37 super.encodingRule(clause);
38 }
39 else addDisjunctiveRule(original, clause);
40 }
41
42 private DLPredicate getAuxPredicate(DLPredicate p, Individual... individuals) {
43 if (p instanceof AtLeastConcept) {
44 StringBuilder builder = new StringBuilder(
45 Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p, individuals));
46 builder.append("_AUXa").append(currentQuery.getQueryID());
47 return AtomicConcept.create(builder.toString());
48 }
49
50 return getDLPredicate(p, "_AUXa" + currentQuery.getQueryID());
51 }
52
53 private DLPredicate getTrackingBottomDLPredicate(DLPredicate p) {
54 return getDLPredicate(p, getTrackingSuffix("0"));
55 }
56
57 protected DLPredicate generateAuxiliaryRule(AtLeastConcept p, DLClause original, Individual[] individuals) {
58 DLPredicate ret = getAuxPredicate(p, individuals);
59 Atom[] headAtom = new Atom[] {Atom.create(ret, X)};
60
61 AtomicRole role = p.getOnRole() instanceof AtomicRole ?
62 (AtomicRole) p.getOnRole():
63 ((InverseRole) p.getOnRole()).getInverseOf();
64
65 AtomicConcept concept = p.getToConcept() instanceof AtomicConcept ?
66 (AtomicConcept) p.getToConcept() :
67 OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
68
69 Term[] roleArgs, conceptArg;
70 for (Individual i: individuals) {
71// Variable i = Variable.create("Y");
72 if (p.getOnRole() instanceof AtomicRole) {
73 roleArgs = new Term[] {X, i};
74 conceptArg = new Term[] {i};
75 }
76 else {
77 roleArgs = new Term[] {i, X};
78 conceptArg = new Term[] {i};
79 }
80
81 addTrackingClause(
82 DLClause.create(headAtom,
83 new Atom[] {Atom.create(getTrackingDLPredicate(role), roleArgs)}));
84
85 addTrackingClause(
86 DLClause.create(headAtom,
87 new Atom[] {Atom.create(getTrackingBottomDLPredicate(role), roleArgs)}));
88
89 Atom guard = Atom.create(role, roleArgs);
90
91 if (!concept.equals(AtomicConcept.THING)) {
92 addTrackingClause(
93 DLClause.create(headAtom,
94 new Atom[] {guard, Atom.create(getTrackingDLPredicate(concept), conceptArg)}));
95
96 addTrackingClause(
97 DLClause.create(headAtom,
98 new Atom[] {guard, Atom.create(getTrackingBottomDLPredicate(concept), conceptArg)}));
99 }
100 }
101
102 return ret;
103 }
104
105 protected DLPredicate generateAuxiliaryRule(AtomicRole p) {
106 DLPredicate ret = getAuxPredicate(p);
107 Atom[] headAtom = new Atom[] {Atom.create(ret, X, Y)};
108
109 addTrackingClause(
110 DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingDLPredicate(p), X, Y)}));
111 addTrackingClause(
112 DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingBottomDLPredicate(p), X, Y)}));
113
114 return ret;
115 }
116
117 private Variable X = Variable.create("X"), Y = Variable.create("Y");
118
119 protected DLPredicate generateAuxiliaryRule(AtomicConcept p) {
120 DLPredicate ret = getAuxPredicate(p);
121 Atom[] headAtom = new Atom[] {Atom.create(ret, X)};
122 addTrackingClause(
123 DLClause.create(headAtom,
124 new Atom[] { Atom.create(getTrackingDLPredicate(p), X)}));
125 addTrackingClause(
126 DLClause.create(headAtom,
127 new Atom[] { Atom.create(getTrackingBottomDLPredicate(p), X)}));
128
129 return ret;
130 }
131
132 protected DLPredicate generateAuxiliaryRule(Inequality instance) {
133 // TODO:
134 return null;
135 }
136
137 @Override
138 public boolean isAuxPredicate(String iri) {
139 return iri.contains("_AUXa");
140// if (iri.startsWith("<"))
141// return iri.endsWith("_AUXa" + currentQuery.getQueryID() + ">");
142// return iri.endsWith("_AUXa" + currentQuery.getQueryID());
143 }
144
145 @Override
146 public String getTrackingProgram() {
147 StringBuilder sb = getTrackingProgramBody();
148 if (currentQuery.isBottom())
149 sb.append(getBottomTrackingProgram());
150 sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText());
151 return sb.toString();
152 }
153
154 private String bottomTrackingProgram = null;
155
156 private String getBottomTrackingProgram() {
157 if (bottomTrackingProgram != null) return bottomTrackingProgram.replace("_tn", getTrackingPredicate(""));
158
159 String bottomSuffix = getTrackingSuffix("0");
160 LinkedList<DLClause> clauses = new LinkedList<DLClause>();
161 Variable X = Variable.create("X");
162 for (String concept: unaryPredicates)
163 clauses.add(DLClause.create(new Atom[] {Atom.create(AtomicConcept.create(concept + bottomSuffix) , X)},
164 new Atom[] {Atom.create(AtomicConcept.create(concept + "_tn"), X)}));
165 Variable Y = Variable.create("Y");
166 for (String role: binaryPredicates)
167 clauses.add(DLClause.create(new Atom[] {Atom.create(AtomicRole.create(role + bottomSuffix) , X, Y)},
168 new Atom[] {Atom.create(AtomicRole.create(role + "_tn"), X, Y) }));
169
170 StringBuilder builder = new StringBuilder(DLClauseHelper.toString(clauses));
171 bottomTrackingProgram = builder.toString();
172 return bottomTrackingProgram.replace("_tn", getTrackingPredicate(""));
173 }
174
175}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
new file mode 100644
index 0000000..8d79090
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
@@ -0,0 +1,112 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import uk.ac.ox.cs.pagoda.MyPrefixes;
5import uk.ac.ox.cs.pagoda.multistage.Normalisation;
6import uk.ac.ox.cs.pagoda.query.QueryRecord;
7import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
8import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
9import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
10
11public class TrackingRuleEncoderDisj2 extends TrackingRuleEncoderDisj {
12
13 public TrackingRuleEncoderDisj2(UpperDatalogProgram program, BasicQueryEngine store) {
14 super(program, store);
15 }
16
17 @Override
18 public boolean encodingRules() {
19 if (ruleEncoded) return false;
20 ruleEncoded = true;
21
22 for (DLClause clause: program.getClauses()) {
23 encodingRule(clause);
24 }
25
26 if (disjunctiveRules.isEmpty())
27 return true;
28
29 processDisjunctiveRules();
30 return false;
31 }
32
33 @Override
34 protected DLPredicate generateAuxiliaryRule(AtomicConcept p) {
35 return getTrackingDLPredicate(p);
36 }
37
38 @Override
39 protected DLPredicate generateAuxiliaryRule(AtomicRole p) {
40 return getTrackingDLPredicate(p);
41 }
42
43 private Variable X = Variable.create("X");
44
45 @Override
46 protected DLPredicate generateAuxiliaryRule(AtLeastConcept p, DLClause original, Individual[] individuals) {
47 DLPredicate ret = AtomicConcept.create(getTrackingPredicate(Normalisation.getAuxiliaryConcept4Disjunct(p, individuals)));
48 Atom[] headAtom = new Atom[] {Atom.create(ret, X)};
49
50 AtomicRole role = p.getOnRole() instanceof AtomicRole ?
51 (AtomicRole) p.getOnRole():
52 ((InverseRole) p.getOnRole()).getInverseOf();
53
54 AtomicConcept concept = p.getToConcept() instanceof AtomicConcept ?
55 (AtomicConcept) p.getToConcept() :
56 OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
57
58 Term[] roleArgs, conceptArg;
59 for (Individual i: individuals) {
60// Variable i = Variable.create("Y");
61 if (p.getOnRole() instanceof AtomicRole) {
62 roleArgs = new Term[] {X, i};
63 conceptArg = new Term[] {i};
64 }
65 else {
66 roleArgs = new Term[] {i, X};
67 conceptArg = new Term[] {i};
68 }
69
70 addTrackingClause(
71 DLClause.create(headAtom,
72 new Atom[] {Atom.create(getTrackingDLPredicate(role), roleArgs)}));
73
74 Atom guard = Atom.create(role, roleArgs);
75
76 if (!concept.equals(AtomicConcept.THING)) {
77 addTrackingClause(
78 DLClause.create(headAtom,
79 new Atom[] {guard, Atom.create(getTrackingDLPredicate(concept), conceptArg)}));
80 }
81 }
82
83 return ret;
84 }
85
86 @Override
87 protected void encodingRule(DLClause clause) {
88 DLClause original = program.getCorrespondingClause(clause);
89 if (original.getHeadLength() <= 1) {
90 super.encodingRule(clause);
91 }
92 else addDisjunctiveRule(original, clause);
93 }
94
95 @Override
96 public String getTrackingProgram() {
97 StringBuilder sb = getTrackingProgramBody();
98 sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText());
99 return sb.toString();
100 }
101
102 @Override
103 protected void encodingAtomicQuery(QueryRecord[] botQuerRecords) {
104 super.encodingAtomicQuery(botQuerRecords, true);
105 }
106
107 @Override
108 protected DLPredicate generateAuxiliaryRule(Inequality instance) {
109 // TODO Auto-generated method stub
110 return null;
111 }
112}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
new file mode 100644
index 0000000..d96c747
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
@@ -0,0 +1,425 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import uk.ac.ox.cs.pagoda.MyPrefixes;
5import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
6import uk.ac.ox.cs.pagoda.multistage.Normalisation;
7import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
8import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
9import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
10import uk.ac.ox.cs.pagoda.util.Namespace;
11import uk.ac.ox.cs.pagoda.util.Utility;
12
13import java.util.Collection;
14import java.util.HashSet;
15import java.util.LinkedList;
16import java.util.Set;
17
18public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
19
20 private Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
21 private Variable X = Variable.create("X"), Y = Variable.create("Y");
22 private String bottomTrackingProgram = null;
23
24 public TrackingRuleEncoderDisjVar1(UpperDatalogProgram program, BasicQueryEngine store) {
25 super(program, store);
26 }
27
28 @Override
29 public boolean encodingRules() {
30 if (super.encodingRules()) {
31 processDisjunctiveRules();
32 return true;
33 }
34 return false;
35 }
36
37 @Override
38 protected void encodingRule(DLClause clause) {
39 if (currentQuery.isBottom()) {
40// super.encodingRule(clause);
41 encodingBottomQueryClause(clause);
42 return;
43 }
44
45 DLClause original = program.getCorrespondingClause(clause);
46 if (original.getHeadLength() <= 1) {
47 super.encodingRule(clause);
48 }
49 else {
50 if (!DLClauseHelper.hasSubsetBodyAtoms(clause, original))
51 super.encodingRule(clause);
52 addDisjunctiveRule(original);
53 }
54
55 }
56
57 private void processDisjunctiveRules() {
58 for (DLClause clause: disjunctiveRules)
59 encodingDisjunctiveRule(clause);
60 }
61
62 private Atom getAuxiliaryAtom(Atom headAtom) {
63 DLPredicate p = headAtom.getDLPredicate();
64 if (p instanceof AtLeast || p instanceof AtLeast) {
65 return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0));
66 }
67 if(p instanceof AtomicConcept)
68 return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0));
69 if(p instanceof AtomicRole)
70 return Atom.create(generateAuxiliaryRule((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
71 if(p instanceof Equality || p instanceof AnnotatedEquality)
72 return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
73 if(p instanceof Inequality)
74 return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1));
75
76 return null;
77 }
78
79 private Atom getTrackingAtom(Atom headAtom) {
80 DLPredicate p = headAtom.getDLPredicate();
81 if (p instanceof AtLeast) {
82 p = Normalisation.toAtLeastConcept((AtLeast) p);
83 return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom
84 .getArgument(0));
85 }
86 if(p instanceof AtomicConcept)
87 return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0));
88 if(p instanceof AtomicRole)
89 return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
90 if(p instanceof Equality || p instanceof AnnotatedEquality)
91 return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
92 if(p instanceof Inequality)
93 return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
94
95 return null;
96 }
97
98 private Atom getGapAtom(Atom headAtom) {
99 DLPredicate p = headAtom.getDLPredicate();
100 if (p instanceof AtLeast) {
101 p = Normalisation.toAtLeastConcept((AtLeast) p);
102 return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom
103 .getArgument(0));
104 }
105 if(p instanceof AtomicConcept)
106 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
107 if(p instanceof AtomicRole)
108 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
109 if(p instanceof Equality || p instanceof AnnotatedEquality)
110 return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
111 if(p instanceof Inequality)
112 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
113 if (p instanceof DatatypeRestriction)
114 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
115 Utility.logError(p + " is not recognised.");
116 return null;
117 }
118
119 private void encodingDisjunctiveRule(DLClause clause) {
120 int headLength = clause.getHeadLength();
121
122 Atom[] auxAtoms = new Atom[headLength];
123 for (int i = 0; i < headLength; ++i)
124 auxAtoms[i] = getAuxiliaryAtom(clause.getHeadAtom(i));
125
126 Atom[] trackingAtoms = new Atom[headLength];
127 for (int i = 0; i < headLength; ++i)
128 trackingAtoms[i] = getTrackingAtom(clause.getHeadAtom(i));
129
130 Atom[] gapAtoms = new Atom[headLength];
131 for (int i = 0; i < headLength; ++i)
132 gapAtoms[i] = getGapAtom(clause.getHeadAtom(i));
133
134 Atom[] bodyAtoms = clause.getBodyAtoms();
135
136 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
137 DLPredicate selected = AtomicConcept.create(getSelectedPredicate());
138 newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
139
140 for (Atom atom: bodyAtoms) {
141 Atom newAtom = Atom.create(
142 getTrackingDLPredicate(atom.getDLPredicate()),
143 DLClauseHelper.getArguments(atom));
144 newHeadAtoms.add(newAtom);
145 }
146
147 DLClause newClause;
148 int index;
149 for (int j = 0; j < headLength; ++j) {
150 Atom[] newBodyAtoms = new Atom[headLength * 2 + bodyAtoms.length];
151 index = 0;
152 for (int i = 0; i < headLength; ++i, ++index)
153 newBodyAtoms[index] = gapAtoms[i];
154 for (int i = 0; i < headLength; ++i, ++index)
155 if (i != j)
156 newBodyAtoms[index] = auxAtoms[i];
157 else
158 newBodyAtoms[index] = trackingAtoms[i];
159
160 for (int i = 0; i < bodyAtoms.length; ++i, ++index)
161 newBodyAtoms[index] = bodyAtoms[i];
162
163 for (Atom atom: newHeadAtoms) {
164 newClause = DLClause.create(new Atom[]{atom}, newBodyAtoms);
165 addTrackingClause(newClause);
166 }
167 }
168 }
169
170 private void addTrackingClause(DLClause clause) {
171 trackingClauses.add(clause);
172 }
173
174 private void addDisjunctiveRule(DLClause clause) {
175 disjunctiveRules.add(clause);
176 }
177
178 private DLPredicate getAuxPredicate(DLPredicate p) {
179 if (p instanceof AtLeastConcept) {
180 StringBuilder builder = new StringBuilder(
181 Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p));
182 builder.append("_AUXa").append(currentQuery.getQueryID());
183 return AtomicConcept.create(builder.toString());
184 }
185
186 return getDLPredicate(p, "_AUXa" + currentQuery.getQueryID());
187 }
188
189 private DLPredicate getTrackingBottomDLPredicate(DLPredicate p) {
190 return getDLPredicate(p, getTrackingSuffix("0"));
191 }
192
193 private DLPredicate generateAuxiliaryRule(AtLeast p1, boolean withAux) {
194 AtLeastConcept p = Normalisation.toAtLeastConcept(p1);
195
196 int num = p.getNumber();
197 Variable[] Ys = new Variable[num];
198 if (num > 1)
199 for(int i = 0; i < num; ++i)
200 Ys[i] = Variable.create("Y" + (i + 1));
201 else
202 Ys[0] = Y;
203
204 Collection<Atom> expandedAtom = new LinkedList<Atom>();
205 Collection<Atom> representativeAtom = new LinkedList<Atom>();
206 if (p.getOnRole() instanceof AtomicRole) {
207 AtomicRole r = (AtomicRole) p.getOnRole();
208 for(int i = 0; i < num; ++i)
209 expandedAtom.add(Atom.create(r, X, Ys[i]));
210 representativeAtom.add(Atom.create(r, X, Ys[0]));
211 }
212 else {
213 AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf();
214 for(int i = 0; i < num; ++i)
215 expandedAtom.add(Atom.create(r, Ys[i], X));
216 representativeAtom.add(Atom.create(r, Ys[0], X));
217 }
218
219 if (num > 1) {
220 representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1]));
221 }
222 for (int i = 0; i < num; ++i)
223 for (int j = i + 1; j < num; ++j)
224 expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j]));
225
226 if (!p.getToConcept().equals(AtomicConcept.THING)) {
227 AtomicConcept c;
228 if(p.getToConcept() instanceof AtomicConcept)
229 c = (AtomicConcept) p.getToConcept();
230 else {
231 c = OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
232 }
233 for (int i = 0; i < num; ++i)
234 expandedAtom.add(Atom.create(c, Ys[i]));
235 representativeAtom.add(Atom.create(c, Ys[0]));
236 }
237
238 AtomicConcept ac = AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct(p));
239 DLPredicate trackingPredicate = getTrackingDLPredicate(ac);
240 DLPredicate gapPredicate = getGapDLPredicate(ac);
241 DLPredicate auxPredicate = withAux ? getAuxPredicate(p) : null;
242
243 for (Atom atom: representativeAtom) {
244 Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1];
245 if (atom.getArity() == 1)
246 bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
247 else
248 bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
249 int i = 0;
250 for (Atom bodyAtom: expandedAtom)
251 bodyAtoms[++i] = bodyAtom;
252 addTrackingClause(DLClause.create(new Atom[] {Atom.create(trackingPredicate, X)}, bodyAtoms));
253
254 bodyAtoms = new Atom[expandedAtom.size() + 1];
255 if (atom.getArity() == 1)
256 bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
257 else
258 bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
259 i = 0;
260 for (Atom bodyAtom: expandedAtom)
261 bodyAtoms[++i] = bodyAtom;
262 addTrackingClause(DLClause.create(new Atom[] {Atom.create(gapPredicate, X)}, bodyAtoms));
263
264 if (withAux) {
265 bodyAtoms = new Atom[expandedAtom.size() + 1];
266 bodyAtoms[0] = getAuxiliaryAtom(atom);
267 i = 0;
268 for (Atom bodyAtom: expandedAtom)
269 bodyAtoms[++i] = bodyAtom;
270 addTrackingClause(DLClause.create(new Atom[] {Atom.create(auxPredicate, X)}, bodyAtoms));
271 }
272 }
273
274 return withAux ? auxPredicate : trackingPredicate;
275 }
276
277 private DLPredicate generateAuxiliaryRule(AtomicRole p) {
278 if(currentQuery.isBottom())
279 return getTrackingDLPredicate(p);
280
281 DLPredicate ret = getAuxPredicate(p);
282 Atom[] headAtom = new Atom[] {Atom.create(ret, X, Y)};
283
284 addTrackingClause(
285 DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingDLPredicate(p), X, Y)}));
286 addTrackingClause(
287 DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingBottomDLPredicate(p), X, Y)}));
288
289 return ret;
290 }
291
292 private DLPredicate generateAuxiliaryRule(AtomicConcept p) {
293 if (currentQuery.isBottom())
294 return getTrackingDLPredicate(p);
295
296 DLPredicate ret = getAuxPredicate(p);
297 Atom[] headAtom = new Atom[]{Atom.create(ret, X)};
298 addTrackingClause(
299 DLClause.create(headAtom,
300 new Atom[]{Atom.create(getTrackingDLPredicate(p), X)}));
301 addTrackingClause(
302 DLClause.create(headAtom,
303 new Atom[] { Atom.create(getTrackingBottomDLPredicate(p), X)}));
304
305 return ret;
306 }
307
308 private DLPredicate generateAuxiliaryRule(Equality instance) {
309 return generateAuxiliaryRule(AtomicRole.create(Namespace.EQUALITY));
310 }
311
312 private DLPredicate generateAuxiliaryRule(Inequality instance) {
313 return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY));
314 }
315
316 @Override
317 public String getTrackingProgram() {
318 StringBuilder sb = getTrackingProgramBody();
319 if (currentQuery.isBottom())
320 sb.append(getBottomTrackingProgram());
321 sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText());
322 return sb.toString();
323 }
324
325 private String getBottomTrackingProgram() {
326 if (bottomTrackingProgram != null) return bottomTrackingProgram.replace("_tn", getTrackingPredicate(""));
327
328 String bottomSuffix = getTrackingSuffix("0");
329 LinkedList<DLClause> clauses = new LinkedList<DLClause>();
330 Variable X = Variable.create("X");
331 for (String concept: unaryPredicates)
332 clauses.add(DLClause.create(new Atom[] {Atom.create(AtomicConcept.create(concept + bottomSuffix) , X)},
333 new Atom[] {Atom.create(AtomicConcept.create(concept + "_tn"), X)}));
334 Variable Y = Variable.create("Y");
335 for (String role: binaryPredicates)
336 clauses.add(DLClause.create(new Atom[] {Atom.create(AtomicRole.create(role + bottomSuffix) , X, Y)},
337 new Atom[] {Atom.create(AtomicRole.create(role + "_tn"), X, Y) }));
338
339 StringBuilder builder = new StringBuilder(DLClauseHelper.toString(clauses));
340 bottomTrackingProgram = builder.toString();
341 return bottomTrackingProgram.replace("_tn", getTrackingPredicate(""));
342 }
343
344 private void encodingBottomQueryClause(DLClause clause) {
345 if (!clause.toString().contains("owl:Nothing"))
346 clause = program.getCorrespondingClause(clause);
347
348// Term t;
349// for (Atom tAtom: clause.getHeadAtoms()) {
350// for (int i = 0; i < tAtom.getArity(); ++i)
351// if ((t = tAtom.getArgument(i)) instanceof Individual)
352// if (((Individual) t).getIRI().startsWith(OverApproxExist.SKOLEMISED_INDIVIDUAL_PREFIX))
353// clause = program.getCorrespondingClause(clause);
354// }
355
356 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
357 Atom selectAtom = Atom.create(selected, getIndividual4GeneralRule(program.getCorrespondingClause(clause)));
358
359 for (Atom atom: clause.getBodyAtoms()) {
360 atom = Atom.create(
361 getTrackingDLPredicate(atom.getDLPredicate()),
362 DLClauseHelper.getArguments(atom));
363 newHeadAtoms.add(atom);
364 }
365
366 DLClause newClause;
367
368 boolean botInHead = clause.getBodyLength() == 1 && clause.getBodyAtom(0).getDLPredicate().toString().contains("owl:Nothing");
369
370 DLPredicate[] trackingPredicates = new DLPredicate[clause.getHeadLength()];
371 DLPredicate[] predicates = new DLPredicate[clause.getHeadLength()];
372 int headIndex = 0;
373 DLPredicate trackingPredicate, p;
374 for (Atom headAtom: clause.getHeadAtoms()) {
375 if ((p = headAtom.getDLPredicate()) instanceof AtLeastConcept) {
376 trackingPredicate = generateAuxiliaryRule((AtLeastConcept) p, false);
377 p = AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p));
378 trackingClauses.add(DLClause.create(
379 new Atom[] { Atom.create(getDLPredicate(p, getTrackingSuffix("0")), X) },
380 new Atom[] { Atom.create(trackingPredicate, X) }));
381 }
382 else
383 trackingPredicate = getTrackingDLPredicate(p);
384
385 trackingPredicates[headIndex] = trackingPredicate;
386 predicates[headIndex] = p;
387 ++headIndex;
388 }
389
390 headIndex = 0;
391 int headLength = clause.getHeadLength();
392 Atom[] gapAtoms = new Atom[headLength];
393 for (int i = 0; i < headLength; ++i)
394 gapAtoms[i] = getGapAtom(clause.getHeadAtom(i));
395// Atom.create(getGapDLPredicate(predicates[headIndex]), DLClauseHelper.getArguments(clause.getHeadAtom(i)));
396 int index, selectIndex;
397 for (Atom headAtom: clause.getHeadAtoms()) {
398 index = 0; selectIndex = 0;
399 Atom[] newBodyAtoms = new Atom[clause.getBodyLength() + 1 + headLength - 1 + (botInHead ? 0 : headLength)];
400 Atom[] selectBodyAtoms = new Atom[clause.getBodyLength() + 1 + (botInHead ? 0 : headLength)];
401 newBodyAtoms[index++] = selectBodyAtoms[selectIndex++] = Atom.create(trackingPredicates[headIndex], DLClauseHelper.getArguments(headAtom));
402
403 if (!botInHead) {
404 for (int i = 0; i < headLength; ++i)
405 newBodyAtoms[index++] = selectBodyAtoms[selectIndex++] = gapAtoms[i];
406 }
407
408 for (int i = 0; i < headLength; ++i)
409 if (i != headIndex) {
410 newBodyAtoms[index++] = Atom.create(getDLPredicate(predicates[i], getTrackingSuffix("0")), DLClauseHelper.getArguments(clause.getHeadAtom(i)));
411 }
412
413 for (int i = 0; i < clause.getBodyLength(); ++i)
414 newBodyAtoms[index++] = selectBodyAtoms[selectIndex++] = clause.getBodyAtom(i);
415
416 for (Atom atom: newHeadAtoms) {
417 newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms);
418 trackingClauses.add(newClause);
419 }
420 trackingClauses.add(DLClause.create(new Atom[] {selectAtom}, selectBodyAtoms));
421 ++headIndex;
422 }
423 }
424
425}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java
new file mode 100644
index 0000000..7311a86
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java
@@ -0,0 +1,230 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
5import uk.ac.ox.cs.pagoda.multistage.Normalisation;
6import uk.ac.ox.cs.pagoda.query.QueryRecord;
7import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
8import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
9import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
10import uk.ac.ox.cs.pagoda.util.Namespace;
11
12import java.util.Collection;
13import java.util.HashSet;
14import java.util.LinkedList;
15import java.util.Set;
16
17public class TrackingRuleEncoderDisjVar2 extends TrackingRuleEncoderWithGap {
18
19 public TrackingRuleEncoderDisjVar2(UpperDatalogProgram program, BasicQueryEngine store) {
20 super(program, store);
21 }
22
23 private Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
24
25 @Override
26 public boolean encodingRules() {
27 if (ruleEncoded) return false;
28 ruleEncoded = true;
29
30 for (DLClause clause: program.getClauses()) {
31 encodingRule(clause);
32 }
33
34 if (disjunctiveRules.isEmpty())
35 return true;
36
37 processDisjunctiveRules();
38 return false;
39 }
40
41 @Override
42 protected void encodingRule(DLClause clause) {
43 DLClause original = program.getCorrespondingClause(clause);
44 if (original.getHeadLength() <= 1) {
45 super.encodingRule(clause);
46 }
47 else {
48 if (!DLClauseHelper.hasSubsetBodyAtoms(clause, original))
49 super.encodingRule(clause);
50 addDisjunctiveRule(original);
51 }
52 }
53
54 private void processDisjunctiveRules() {
55 for (DLClause clause: disjunctiveRules)
56 encodingDisjunctiveRule(clause);
57 }
58
59 private Atom getAuxiliaryAtom(Atom headAtom) {
60 DLPredicate p = headAtom.getDLPredicate();
61 if (p instanceof AtLeastConcept) {
62 return Atom.create(generateAuxiliaryRule((AtLeastConcept) p), headAtom.getArgument(0));
63 }
64 if (p instanceof AtomicConcept)
65 return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0));
66 if (p instanceof AtomicRole)
67 return Atom.create(generateAuxiliaryRule((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
68 if (p instanceof Equality || p instanceof AnnotatedEquality)
69 return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
70 if (p instanceof Inequality)
71 return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1));
72
73 return null;
74 }
75
76 private Atom getGapAtom(Atom headAtom) {
77 DLPredicate p = headAtom.getDLPredicate();
78 if (p instanceof AtLeastConcept) {
79 return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0));
80 }
81 if (p instanceof AtomicConcept)
82 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
83 if (p instanceof AtomicRole)
84 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
85 if (p instanceof Equality || p instanceof AnnotatedEquality)
86 return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
87 if (p instanceof Inequality)
88 return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
89
90 return null;
91 }
92
93 private void encodingDisjunctiveRule(DLClause clause) {
94 int headLength = clause.getHeadLength();
95
96 Atom[] auxAtoms = new Atom[headLength];
97 for (int i = 0; i < headLength; ++i)
98 auxAtoms[i] = getAuxiliaryAtom(clause.getHeadAtom(i));
99
100 Atom[] gapAtoms = new Atom[headLength];
101 for (int i = 0; i < headLength; ++i)
102 gapAtoms[i] = getGapAtom(clause.getHeadAtom(i));
103
104 Atom[] bodyAtoms = clause.getBodyAtoms();
105
106 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
107 DLPredicate selected = AtomicConcept.create(getSelectedPredicate());
108 newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
109
110 for (Atom atom: bodyAtoms) {
111 Atom newAtom = Atom.create(
112 getTrackingDLPredicate(atom.getDLPredicate()),
113 DLClauseHelper.getArguments(atom));
114 newHeadAtoms.add(newAtom);
115 }
116
117 DLClause newClause;
118 for (int j = 0; j < headLength; ++j) {
119 Atom[] newBodyAtoms = new Atom[headLength + bodyAtoms.length + 1];
120 newBodyAtoms[0] = gapAtoms[j];
121
122 for (int i = 0; i < headLength; ++i)
123// newBodyAtoms[i] = auxAtoms[i];
124 newBodyAtoms[i + 1] = auxAtoms[i];
125
126 for (int i = 0; i < bodyAtoms.length; ++i)
127// newBodyAtoms[i + headLength] = bodyAtoms[i];
128 newBodyAtoms[i + headLength + 1] = bodyAtoms[i];
129
130 for (Atom atom: newHeadAtoms) {
131 newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms);
132 addTrackingClause(newClause);
133 }
134 }
135 }
136
137 private void addTrackingClause(DLClause clause) {
138 trackingClauses.add(clause);
139 }
140
141 private void addDisjunctiveRule(DLClause clause) {
142 disjunctiveRules.add(clause);
143 }
144
145 protected DLPredicate generateAuxiliaryRule(AtLeastConcept p) {
146 AtomicConcept ac = AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct(p));
147 int num = p.getNumber();
148 Variable X = Variable.create("X");
149 Variable[] Ys = new Variable[num];
150 for (int i = 0; i < num; ++i) Ys[i] = Variable.create("Y" + (i + 1));
151 Collection<Atom> expandedAtom = new LinkedList<Atom>();
152 Collection<Atom> representativeAtom = new LinkedList<Atom>();
153 if (p.getOnRole() instanceof AtomicRole) {
154 AtomicRole r = (AtomicRole) p.getOnRole();
155 for (int i = 0; i < num; ++i)
156 expandedAtom.add(Atom.create(r, X, Ys[i]));
157 representativeAtom.add(Atom.create(r, X, Ys[0]));
158 }
159 else {
160 AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf();
161 for (int i = 0; i < num; ++i)
162 expandedAtom.add(Atom.create(r, Ys[i], X));
163 representativeAtom.add(Atom.create(r, Ys[0], X));
164
165 }
166
167 if (num > 1) {
168 representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1]));
169 }
170 for (int i = 0; i < num; ++i)
171 for (int j = i + 1; j < num; ++i)
172 expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j]));
173
174 if (!p.getToConcept().equals(AtomicConcept.THING)) {
175 AtomicConcept c;
176 if (p.getToConcept() instanceof AtomicConcept)
177 c = (AtomicConcept) p.getToConcept();
178 else
179 c = OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
180 for (int i = 0; i < num; ++i)
181 expandedAtom.add(Atom.create(c, Ys[i]));
182 representativeAtom.add(Atom.create(c, Ys[0]));
183 }
184
185 DLPredicate auxPredicate = getTrackingDLPredicate(ac);
186 DLPredicate gapPredicate = getGapDLPredicate(ac);
187 for (Atom atom: representativeAtom) {
188 Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1];
189 bodyAtoms[0] = getAuxiliaryAtom(atom);
190 int i = 0;
191 for (Atom bodyAtom: expandedAtom)
192 bodyAtoms[++i] = bodyAtom;
193 addTrackingClause(DLClause.create(new Atom[] {Atom.create(auxPredicate, X)}, bodyAtoms));
194
195 bodyAtoms = new Atom[expandedAtom.size() + 1];
196 if (atom.getArity() == 1)
197 bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
198 else
199 bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
200 i = 0;
201 for (Atom bodyAtom: expandedAtom)
202 bodyAtoms[++i] = bodyAtom;
203 addTrackingClause(DLClause.create(new Atom[] {Atom.create(gapPredicate, X)}, bodyAtoms));
204 }
205
206 return auxPredicate;
207 }
208
209 private DLPredicate generateAuxiliaryRule(AtomicConcept p) {
210 return getTrackingDLPredicate(p);
211 }
212
213 private DLPredicate generateAuxiliaryRule(AtomicRole p) {
214 return getTrackingDLPredicate(p);
215 }
216
217 protected DLPredicate generateAuxiliaryRule(Equality instance) {
218 return getTrackingDLPredicate(AtomicRole.create(Namespace.EQUALITY));
219 }
220
221 protected DLPredicate generateAuxiliaryRule(Inequality instance) {
222 return getTrackingDLPredicate(AtomicRole.create(Namespace.INEQUALITY));
223 }
224
225 @Override
226 protected void encodingAtomicQuery(QueryRecord[] botQuerRecords) {
227 encodingAtomicQuery(botQuerRecords, true);
228 }
229
230}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
new file mode 100644
index 0000000..4ece796
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
@@ -0,0 +1,116 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import org.semanticweb.owlapi.model.IRI;
5import org.semanticweb.owlapi.model.OWLClass;
6import org.semanticweb.owlapi.model.OWLObjectProperty;
7import org.semanticweb.owlapi.model.OWLOntology;
8import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
9import uk.ac.ox.cs.pagoda.query.GapTupleIterator;
10import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
11import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
12import uk.ac.ox.cs.pagoda.util.Namespace;
13
14import java.util.Collection;
15import java.util.HashSet;
16import java.util.LinkedList;
17import java.util.Set;
18
19public class TrackingRuleEncoderWithGap extends TrackingRuleEncoder {
20
21 public TrackingRuleEncoderWithGap(UpperDatalogProgram program, BasicQueryEngine store) {
22 super(program, store);
23 }
24
25 @Override
26 protected String getEqualityRelatedRuleText() {
27 if (equalityRelatedRuleText != null) return equalityRelatedRuleText.replace("_tn", getTrackingPredicate(""));
28
29 Collection<DLClause> equalityRelatedClauses = new LinkedList<DLClause>();
30 Variable X = Variable.create("X");
31 AtomicRole trackingSameAs = AtomicRole.create(Namespace.EQUALITY + "_tn");
32 OWLOntology onto = program.getOntology();
33 Atom[] headAtom = new Atom[]{Atom.create(trackingSameAs, X, X)}, bodyAtom;
34 for(OWLOntology o : onto.getImportsClosure())
35 for(OWLClass cls : o.getClassesInSignature()) {
36 String clsIRI = cls.getIRI().toString();
37 unaryPredicates.add(clsIRI);
38 bodyAtom = new Atom[] {
39 Atom.create(AtomicConcept.create(clsIRI + "_tn"), X),
40 Atom.create(AtomicConcept.create(GapTupleIterator.getGapPredicate(clsIRI)), X)};
41 equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom));
42 }
43
44 Variable Y = Variable.create("Y");
45 Set<OWLObjectProperty> setOfProperties = new HashSet<OWLObjectProperty>();
46 for(OWLOntology o : onto.getImportsClosure())
47 for(OWLObjectProperty prop : o.getObjectPropertiesInSignature())
48 setOfProperties.add(prop);
49 setOfProperties.add(onto.getOWLOntologyManager()
50 .getOWLDataFactory()
51 .getOWLObjectProperty(IRI.create(Namespace.INEQUALITY)));
52 for(OWLObjectProperty prop : setOfProperties) {
53 String propIRI = prop.getIRI().toString();
54 binaryPredicates.add(propIRI);
55 AtomicRole trackingRole = AtomicRole.create(propIRI + "_tn");
56 AtomicRole gapRole = AtomicRole.create(GapTupleIterator.getGapPredicate(propIRI));
57// AtomicRole role = AtomicRole.create(propIRI);
58 bodyAtom = new Atom[] {
59 Atom.create(trackingRole, X, Y),
60 Atom.create(gapRole, X, Y)};
61 equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom));
62
63 bodyAtom = new Atom[] {
64 Atom.create(trackingRole, Y, X),
65 Atom.create(gapRole, Y, X)};
66 equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom));
67 }
68
69 equalityRelatedClauses.add(
70 DLClause.create(
71 new Atom[] {Atom.create(trackingSameAs, Y, X)},
72 new Atom[] {Atom.create(trackingSameAs, X, Y)}));
73
74 equalityRelatedRuleText = DLClauseHelper.toString(equalityRelatedClauses).toString();
75 return equalityRelatedRuleText.replace("_tn", getTrackingPredicate(""));
76 }
77
78 @Override
79 protected void encodingRule(DLClause clause) {
80 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
81 newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
82
83 Atom headAtom;
84 for (Atom atom: clause.getBodyAtoms()) {
85 headAtom = Atom.create(
86 getTrackingDLPredicate(atom.getDLPredicate()),
87 DLClauseHelper.getArguments(atom));
88 newHeadAtoms.add(headAtom);
89 }
90
91 DLClause newClause;
92 headAtom = clause.getHeadAtom(0);
93
94 boolean equalityHead = headAtom.getDLPredicate() instanceof Equality || headAtom.getDLPredicate() instanceof AnnotatedEquality;
95 int offset = (equalityHead || (clause.getBodyLength() == 1 && clause.getBodyAtom(0).getDLPredicate().toString().contains("owl:Nothing"))) ? 1 : 2;
96
97 Atom[] newBodyAtoms = new Atom[clause.getBodyLength() + offset];
98 newBodyAtoms[0] = Atom.create(
99 getTrackingDLPredicate(headAtom.getDLPredicate()),
100 DLClauseHelper.getArguments(headAtom));
101
102 if (offset == 2)
103 newBodyAtoms[1] = Atom.create(
104 getGapDLPredicate(headAtom.getDLPredicate()),
105 DLClauseHelper.getArguments(headAtom));
106
107 for (int i = 0; i < clause.getBodyLength(); ++i)
108 newBodyAtoms[i + offset] = clause.getBodyAtom(i);
109
110 for (Atom atom: newHeadAtoms) {
111 newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms);
112 trackingClauses.add(newClause);
113 }
114
115 }
116}
diff --git a/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithoutGap.java b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithoutGap.java
new file mode 100644
index 0000000..f898114
--- /dev/null
+++ b/src/main/java/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithoutGap.java
@@ -0,0 +1,103 @@
1package uk.ac.ox.cs.pagoda.tracking;
2
3import org.semanticweb.HermiT.model.*;
4import org.semanticweb.owlapi.model.OWLClass;
5import org.semanticweb.owlapi.model.OWLObjectProperty;
6import org.semanticweb.owlapi.model.OWLOntology;
7import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
8import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
9import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
10import uk.ac.ox.cs.pagoda.util.Namespace;
11
12import java.util.Collection;
13import java.util.LinkedList;
14
15public class TrackingRuleEncoderWithoutGap extends TrackingRuleEncoder {
16
17 public TrackingRuleEncoderWithoutGap(UpperDatalogProgram program, BasicQueryEngine store) {
18 super(program, store);
19 }
20
21 @Override
22 protected String getEqualityRelatedRuleText() {
23 if (equalityRelatedRuleText != null) return equalityRelatedRuleText.replace("_tn", getTrackingPredicate(""));
24
25 Collection<DLClause> equalityRelatedClauses = new LinkedList<DLClause>();
26 Variable X = Variable.create("X");
27 AtomicRole trackingSameAs = AtomicRole.create(Namespace.EQUALITY + "_tn");
28 OWLOntology onto = program.getOntology();
29 Atom[] headAtom, bodyAtom;
30 for (OWLClass cls: onto.getClassesInSignature(true)) {
31 String clsIRI = cls.getIRI().toString();
32 unaryPredicates.add(clsIRI);
33 headAtom = new Atom[] {Atom.create(trackingSameAs, X, X)};
34 bodyAtom = new Atom[] {
35 Atom.create(AtomicConcept.create(clsIRI + "_tn"), X),
36// Atom.create(AtomicConcept.create(GapTupleIterator.getGapPredicate(clsIRI)), X1),
37 Atom.create(AtomicConcept.create(clsIRI), X)};
38 equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom));
39 }
40 Variable Y = Variable.create("Y");
41 for (OWLObjectProperty prop: onto.getObjectPropertiesInSignature(true)) {
42 String propIRI = prop.getIRI().toString();
43 binaryPredicates.add(propIRI);
44 AtomicRole trackingRole = AtomicRole.create(propIRI + "_tn");
45// AtomicRole gapRole = AtomicRole.create(GapTupleIterator.getGapPredicate(propIRI));
46 AtomicRole role = AtomicRole.create(propIRI);
47 headAtom = new Atom[] {Atom.create(trackingSameAs, X, X)};
48 bodyAtom = new Atom[] {
49 Atom.create(trackingRole, X, Y),
50// Atom.create(gapRole, X1, Y),
51 Atom.create(role, X, Y)};
52 equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom));
53
54 bodyAtom = new Atom[] {
55 Atom.create(trackingRole, Y, X),
56// Atom.create(gapRole, Y, X1),
57 Atom.create(role, Y, X)};
58 equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom));
59 }
60
61 equalityRelatedClauses.add(
62 DLClause.create(
63 new Atom[] {Atom.create(trackingSameAs, Y, X)},
64 new Atom[] {Atom.create(trackingSameAs, X, Y)}));
65
66 equalityRelatedRuleText = DLClauseHelper.toString(equalityRelatedClauses).toString();
67 return equalityRelatedRuleText.replace("_tn", getTrackingPredicate(""));
68 }
69
70 @Override
71 protected void encodingRule(DLClause clause) {
72 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
73 newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
74
75 Atom headAtom;
76 for (Atom atom: clause.getBodyAtoms()) {
77 headAtom = Atom.create(
78 getTrackingDLPredicate(atom.getDLPredicate()),
79 DLClauseHelper.getArguments(atom));
80 newHeadAtoms.add(headAtom);
81 }
82
83 DLClause newClause;
84 Atom[] newBodyAtoms = new Atom[clause.getBodyLength() + 1];
85 headAtom = clause.getHeadAtom(0);
86 newBodyAtoms[0] = Atom.create(
87 getTrackingDLPredicate(headAtom.getDLPredicate()),
88 DLClauseHelper.getArguments(headAtom));
89
90// newBodyAtoms[1] = Atom.create(
91// getGapDLPredicate(headAtom.getDLPredicate()),
92// DLClauseHelper.getArguments(headAtom));
93
94 for (int i = 0; i < clause.getBodyLength(); ++i)
95 newBodyAtoms[i + 1] = clause.getBodyAtom(i);
96
97 for (Atom atom: newHeadAtoms) {
98 newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms);
99 trackingClauses.add(newClause);
100 }
101
102 }
103}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-05 21:02:32 +0000