Adding (not completed) a new upper bound technique, namely Limited Skolemisation.

14 files changed, 160 insertions, 140 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java b/src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java
new file mode 100644
index 0000000..0ee2035
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java
@@ -0,0 +1,15 @@
+package uk.ac.ox.cs.pagoda.multistage;
+
+import org.semanticweb.HermiT.model.DLClause;
+
+import java.util.Collection;
+
+/**
+ * An approximator for existential rules.
+ * */
+public interface ExistApproximator {
+
+    Collection<DLClause> convert(DLClause clause,
+                                 DLClause originalClause,
+                                 Collection<AnswerTupleID> violationTuples);
+}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java b/src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java
new file mode 100644
index 0000000..5df66bc
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java
@@ -0,0 +1,23 @@
+package uk.ac.ox.cs.pagoda.multistage;
+
+import org.semanticweb.HermiT.model.DLClause;
+import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
+
+import java.util.Collection;
+
+/**
+ * A wrapper for <tt>OverApproxExist</tt>.
+ * */
+public class ExistConstantApproximator implements ExistApproximator {
+
+    private final OverApproxExist overApproxExist;
+
+    public ExistConstantApproximator() {
+        overApproxExist = new OverApproxExist();
+    }
+
+    @Override
+    public Collection<DLClause> convert(DLClause clause, DLClause originalClause, Collection<AnswerTupleID> violationTuples) {
+        return overApproxExist.convert(clause, originalClause);
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java
new file mode 100644
index 0000000..b0068e7
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java
@@ -0,0 +1,16 @@
+package uk.ac.ox.cs.pagoda.multistage;
+
+
+import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
+import uk.ac.ox.cs.pagoda.rules.Program;
+
+public class LimitedSkolemisationApplication extends RestrictedApplication {
+
+
+    public LimitedSkolemisationApplication(Program program, BottomStrategy upperBottom) {
+        super(program, upperBottom);
+    }
+
+
+    // TODO override methods properly
+}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java
new file mode 100644
index 0000000..348e849
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java
@@ -0,0 +1,36 @@
+package uk.ac.ox.cs.pagoda.multistage;
+
+import org.semanticweb.HermiT.model.DLClause;
+
+import java.util.Collection;
+
+/**
+ * Approximates existential rules by a limited form of Skolemisation.
+ * <p>
+ * Given a rule and a grounding substitution,
+ * it Skolemises the rule if
+ * all the terms in the substitution have depth less than a given depth,
+ * otherwise it approximates using an alternative <tt>ExistApproximator</tt>.
+ *
+ * */
+public class LimitedSkolemisationApproximator implements ExistApproximator {
+
+    private final int maxTermDepth;
+    private final ExistApproximator alternativeApproximator;
+
+    public LimitedSkolemisationApproximator(int maxTermDepth) {
+        this(maxTermDepth, new ExistConstantApproximator());
+    }
+
+    public LimitedSkolemisationApproximator(int maxTermDepth, ExistApproximator alternativeApproximator) {
+        this.maxTermDepth = maxTermDepth;
+        this.alternativeApproximator = alternativeApproximator;
+    }
+
+    @Override
+    public Collection<DLClause> convert(DLClause clause,
+                                        DLClause originalClause,
+                                        Collection<AnswerTupleID> violationTuples) {
+        return null;
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageQueryEngine.java b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageQueryEngine.java
index b77c264..7e40faf 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageQueryEngine.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageQueryEngine.java
@@ -1,16 +1,18 @@
 package uk.ac.ox.cs.pagoda.multistage;
 
-import java.util.Collection;
-
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
 import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
-import uk.ac.ox.cs.pagoda.multistage.treatement.*;
+import uk.ac.ox.cs.pagoda.multistage.treatement.Pick4NegativeConceptNaive;
+import uk.ac.ox.cs.pagoda.multistage.treatement.Pick4NegativeConceptQuerySpecific;
+import uk.ac.ox.cs.pagoda.multistage.treatement.Treatment;
 import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.rules.Program;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+
+import java.util.Collection;
 
 public class MultiStageQueryEngine extends StageQueryEngine {
 
@@ -42,7 +44,7 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                 RestrictedApplication program = new RestrictedApplication(generalProgram, dProgram.getUpperBottomStrategy());
                 Treatment treatment = new Pick4NegativeConceptNaive(this, program);
                 int ret = materialise(program, treatment, gap);
-                treatment.dispose();
+                treatment.dispose(); // does nothing
                 return ret; 
         }
         
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java
index 4239ccc..daf7c2c 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java
@@ -1,46 +1,21 @@
 package uk.ac.ox.cs.pagoda.multistage;
 
-import java.io.BufferedWriter;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Set;
-
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-import org.semanticweb.HermiT.model.AtLeast;
-import org.semanticweb.HermiT.model.AtLeastConcept;
-import org.semanticweb.HermiT.model.AtLeastDataRange;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicNegationConcept;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.Equality;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.InverseRole;
-import org.semanticweb.HermiT.model.Variable;
-
+import org.semanticweb.HermiT.model.*;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
-import uk.ac.ox.cs.pagoda.constraints.*;
+import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
 import uk.ac.ox.cs.pagoda.hermit.RuleHelper;
 import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
-import uk.ac.ox.cs.pagoda.rules.Approximator;
 import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.Program;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.SparqlHelper;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+
+import java.io.*;
+import java.util.*;
 
 public abstract class MultiStageUpperProgram {
         
@@ -49,7 +24,7 @@ public abstract class MultiStageUpperProgram {
         Collection<DLClause> clauses; 
 
         BottomStrategy m_bottom = null; 
-        Approximator m_approxExist = new OverApproxExist();
+        ExistApproximator m_approxExist = new ExistConstantApproximator();
 
         protected static final Variable X = Variable.create("X"); 
         
@@ -397,9 +372,15 @@ public abstract class MultiStageUpperProgram {
         }
 
         public Collection<DLClause> convertExist(DLClause clause, DLClause originalDLClause) {
-                return m_bottom.process(m_approxExist.convert(clause, originalDLClause)); 
+                return m_bottom.process(m_approxExist.convert(clause, originalDLClause, null));
+        }
+
+        public Collection<DLClause> convertExist(DLClause clause, DLClause originalDLClause, List<AnswerTupleID> violationTuples) {
+                return m_bottom.process(m_approxExist.convert(clause, originalDLClause, null));
         }
 
+
+
         public void save(String filename) {
                 try {
                         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename)));
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication.java b/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication.java
index f8e6524..174175f 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication.java
@@ -1,22 +1,14 @@
 package uk.ac.ox.cs.pagoda.multistage;
 
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedList;
-
-import org.semanticweb.HermiT.model.AtLeastConcept;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicNegationConcept;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.InverseRole;
-
+import org.semanticweb.HermiT.model.*;
 import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
 import uk.ac.ox.cs.pagoda.rules.Program;
 import uk.ac.ox.cs.pagoda.util.Timer;
 
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+
 public class RestrictedApplication extends MultiStageUpperProgram {
 
         Normalisation norm;
@@ -34,13 +26,14 @@ public class RestrictedApplication extends MultiStageUpperProgram {
                 Collection<DLClause> allRules = new LinkedList<DLClause>(rules); 
                 allRules.addAll(constraints); 
                 for (DLClause clause: allRules) {
-                        for (DLClause newClause: addAddtionalDatalogRules(clause, m_bottom, norm))
+                        for (DLClause newClause: addAdditionalDatalogRules(clause, m_bottom, norm))
                                 addDatalogRule(newClause);
                 }
                 allRules.clear();
         }
-        
-        public static Collection<DLClause> addAddtionalDatalogRules(DLClause clause, BottomStrategy bottom, Normalisation norm) {
+
+        // It should be c-Skolemisation + shifting
+        public static Collection<DLClause> addAdditionalDatalogRules(DLClause clause, BottomStrategy bottom, Normalisation norm) {
                 LinkedList<DLClause> newClauses = new LinkedList<DLClause>(); 
                 Atom[] headAtoms = clause.getHeadAtoms(); 
                 Atom[] bodyAtoms = clause.getBodyAtoms(); 
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConcept.java b/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConcept.java
index f40ae31..3917efc 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConcept.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConcept.java
@@ -1,25 +1,8 @@
 package uk.ac.ox.cs.pagoda.multistage.treatement;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Set;
-
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.Equality;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.Variable;
-
+import org.semanticweb.HermiT.model.*;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 import uk.ac.ox.cs.pagoda.constraints.PredicateDependency;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
@@ -31,8 +14,8 @@ import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.SparqlHelper;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+
+import java.util.*;
 
 public abstract class Pick4NegativeConcept implements Treatment {
         
@@ -140,7 +123,8 @@ public abstract class Pick4NegativeConcept implements Treatment {
                                         else headAtoms.add(tHeadAtom); 
                                 }
                                 else {
-                                        Utility.logError("There might be an error here... Can't happend!!!"); 
+                                        Utility.logError("There might be an error here... Can't happend!!!");
+                                        throw new Error("This condition should not happen!");
                                 }
                         }
                         if (!tuples.isEmpty())
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/treatement/SkolemTreatment.java b/src/uk/ac/ox/cs/pagoda/multistage/treatement/SkolemTreatment.java
index c65fdf9..7a92b79 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/treatement/SkolemTreatment.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/treatement/SkolemTreatment.java
@@ -1,11 +1,11 @@
 package uk.ac.ox.cs.pagoda.multistage.treatement;
 
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
 import uk.ac.ox.cs.pagoda.multistage.FoldedApplication;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
 import uk.ac.ox.cs.pagoda.multistage.Violation;
 
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-
+// TODO should I implement something like this?
 public class SkolemTreatment implements Treatment {
 
         public SkolemTreatment(MultiStageQueryEngine multiStageQueryEngine,     FoldedApplication program) {
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
index 4465764..7999daa 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
@@ -44,7 +44,7 @@ public class MyQueryReasoner extends QueryReasoner {
         
         boolean equalityTag; 
         boolean multiStageTag;
-        
+
         public MyQueryReasoner() {
                 setup(true, true); 
         }
@@ -210,14 +210,14 @@ public class MyQueryReasoner extends QueryReasoner {
                 queryUpperBound(upperStore, queryRecord, queryRecord.getQueryText(), queryRecord.getAnswerVariables());
 
                 // TODO log correct partial answers
-                Utility.logDebug(toJson("upperBound1", queryRecord));
+//              Utility.logDebug(toJson("upperBound1", queryRecord));
                 if (!queryRecord.processed() && !queryRecord.getQueryText().equals(extendedQuery[0])) {
                         queryUpperBound(upperStore, queryRecord, extendedQuery[0], queryRecord.getAnswerVariables());
-                        Utility.logDebug(toJson("upperBound2", queryRecord));
+//                      Utility.logDebug(toJson("upperBound2", queryRecord));
                 }
                 if (!queryRecord.processed() && queryRecord.hasNonAnsDistinguishedVariables()) {
                         queryUpperBound(upperStore, queryRecord, extendedQuery[1], queryRecord.getDistinguishedVariables());
-                        Utility.logDebug(toJson("upperBound3", queryRecord));
+//                      Utility.logDebug(toJson("upperBound3", queryRecord));
                 }
                         
                 queryRecord.addProcessingTime(Step.UpperBound, t.duration());
diff --git a/src/uk/ac/ox/cs/pagoda/rules/Approximator.java b/src/uk/ac/ox/cs/pagoda/rules/Approximator.java
index b2edd56..66e676b 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/Approximator.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/Approximator.java
@@ -1,16 +1,16 @@
 package uk.ac.ox.cs.pagoda.rules;
 
-import java.util.Collection;
-import java.util.LinkedList;
-
 import org.semanticweb.HermiT.model.AtLeast;
 import org.semanticweb.HermiT.model.Atom;
 import org.semanticweb.HermiT.model.DLClause;
 import org.semanticweb.HermiT.model.DLPredicate;
 
+import java.util.Collection;
+import java.util.LinkedList;
+
 public interface Approximator {
 
-        public Collection<DLClause> convert(DLClause clause, DLClause originalClause); 
+        Collection<DLClause> convert(DLClause clause, DLClause originalClause);
         
 }
 
diff --git a/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java b/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java
index 6e17f02..a664ba1 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java
@@ -1,23 +1,9 @@
 package uk.ac.ox.cs.pagoda.rules;
 
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Set;
-
 import org.semanticweb.HermiT.Reasoner;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.Variable;
-import org.semanticweb.owlapi.model.OWLClass;
-import org.semanticweb.owlapi.model.OWLObjectInverseOf;
-import org.semanticweb.owlapi.model.OWLObjectProperty;
-import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
-import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.HermiT.model.*;
+import org.semanticweb.owlapi.model.*;
 import org.semanticweb.owlapi.reasoner.Node;
-
 import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
 import uk.ac.ox.cs.pagoda.constraints.NullaryBottom;
 import uk.ac.ox.cs.pagoda.constraints.UnaryBottom;
@@ -27,6 +13,11 @@ import uk.ac.ox.cs.pagoda.multistage.RestrictedApplication;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
 
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Set;
+
 public class LowerDatalogProgram extends ApproxProgram implements IncrementalProgram {
         
         boolean m_toClassify; 
@@ -68,7 +59,7 @@ public class LowerDatalogProgram extends ApproxProgram implements IncrementalPro
                 norm.process();
                 for (DLClause nClause: norm.getNormlisedClauses()) {
                         if (nClause.getHeadLength() != 1)
-                                for (DLClause newClause: RestrictedApplication.addAddtionalDatalogRules(nClause, tBottom, norm)) {
+                                for (DLClause newClause: RestrictedApplication.addAdditionalDatalogRules(nClause, tBottom, norm)) {
 //                                      System.out.println(newClause); 
                                         if (newClause.getHeadAtom(0).getDLPredicate() instanceof AtomicConcept || newClause.getHeadAtom(0).getDLPredicate() instanceof AtomicRole) {
 //                                              System.out.println(newClause); 
diff --git a/src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java b/src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java
index 5edb08e..5b298e8 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java
@@ -1,22 +1,19 @@
 package uk.ac.ox.cs.pagoda.rules;
 
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Set;
-
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.Term;
-import org.semanticweb.HermiT.model.Variable;
-
+import org.semanticweb.HermiT.model.*;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 
+import java.util.*;
+
 public class OverApproxDisj implements Approximator {
 
+        /**
+         * Splits a disjunctive rule into a bunch of rules.
+         * <p>
+         * It returns a collection containing a rule for each atom in the head of the input rule.
+         * Each rule has the same body of the input rule,
+         * and the relative head atom as head.
+         * */
         @Override
         public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
                 LinkedList<DLClause> distincts = new LinkedList<DLClause>();
diff --git a/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java b/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java
index 7e66411..2ff1673 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java
@@ -1,30 +1,11 @@
 package uk.ac.ox.cs.pagoda.rules;
 
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map;
-
-import org.semanticweb.HermiT.model.AtLeast;
-import org.semanticweb.HermiT.model.AtLeastConcept;
-import org.semanticweb.HermiT.model.AtLeastDataRange;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicNegationConcept;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.Individual;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.InverseRole;
-import org.semanticweb.HermiT.model.LiteralConcept;
-import org.semanticweb.HermiT.model.Role;
-import org.semanticweb.HermiT.model.Term;
-import org.semanticweb.HermiT.model.Variable;
+import org.semanticweb.HermiT.model.*;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 
+import java.util.*;
+
 public class OverApproxExist implements Approximator {
 
         @Override
@@ -142,6 +123,7 @@ public class OverApproxExist implements Approximator {
                         AtomicConcept atomicConcept = null;
                         
                         if (concept instanceof AtomicNegationConcept) {
+                                // is this already in MultiStageUpperProgram?
                                 Atom atom1 = Atom.create(atomicConcept = ((AtomicNegationConcept) concept).getNegatedAtomicConcept(), X);
                                 Atom atom2 = Atom.create(atomicConcept = getNegationConcept(atomicConcept), X);
                                 ret.add(DLClause.create(new Atom[0], new Atom[] {atom1, atom2}));