71 files changed, 3224 insertions, 3420 deletions
diff --git a/src/uk/ac/ox/cs/pagoda/Pagoda.java b/src/uk/ac/ox/cs/pagoda/Pagoda.java
new file mode 100644
index 0000000..aeb85a7
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/Pagoda.java
@@ -0,0 +1,187 @@
+package uk.ac.ox.cs.pagoda;
+import org.apache.commons.cli.*;
+import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner;
+import uk.ac.ox.cs.pagoda.util.PagodaProperties;
+import uk.ac.ox.cs.pagoda.util.Timer;
+import uk.ac.ox.cs.pagoda.util.Utility;
+import java.nio.file.Path;
+/**
+ * Executable command line user interface.
+ */
+public class Pagoda implements Runnable {
+    private static final String OPTION_ONTOLOGY = "o";
+    private static final String OPTION_DATA = "d";
+    private static final String OPTION_QUERY = "q";
+    private static final String OPTION_ANSWER = "a";
+    private static final String OPTION_CLASSIFY = "c";
+    private static final String OPTION_HERMIT = "f";
+    private final PagodaProperties properties;
+    /**
+     * Do not use it
+     * */
+    private Pagoda() {
+        properties = new PagodaProperties();
+    }
+    public static void main(String... args) {
+        // TODO treat the mandatory options as simple args
+        Options options = new Options();
+        options.addOption(Option.builder(OPTION_ONTOLOGY)
+                                .argName(OPTION_ONTOLOGY)
+                                .required()
+                                .hasArg()
+                                .desc("The ontology path")
+                                .build());
+        options.addOption(Option.builder(OPTION_DATA).argName(OPTION_DATA).hasArg().desc("The data path").build());
+        options.addOption(Option.builder(OPTION_QUERY)
+                                .argName(OPTION_QUERY)
+                                .required()
+                                .hasArg()
+                                .desc("The query path")
+                                .build());
+        options.addOption(Option.builder(OPTION_ANSWER)
+                                .argName(OPTION_ANSWER)
+                                .hasArg()
+                                .desc("The answer path")
+                                .build());
+        options.addOption(Option.builder(OPTION_CLASSIFY)
+                                .argName(OPTION_CLASSIFY)
+                                .desc("Tell whether to classify")
+                                .type(Boolean.class)
+                                .build());
+        options.addOption(Option.builder(OPTION_HERMIT)
+                                .argName(OPTION_HERMIT)
+                                .desc("Tell whether to call Hermit")
+                                .type(Boolean.class)
+                                .build());
+        CommandLineParser parser = new DefaultParser();
+        try {
+            CommandLine cmd = parser.parse(options, args);
+            PagodaBuilder pagodaBuilder = Pagoda.builder()
+                                                .ontology(cmd.getOptionValue(OPTION_ONTOLOGY))
+                                                .query(cmd.getOptionValue(OPTION_QUERY));
+            if(cmd.hasOption(OPTION_DATA)) pagodaBuilder.data(cmd.getOptionValue(OPTION_DATA));
+            if(cmd.hasOption(OPTION_ANSWER)) pagodaBuilder.answer(cmd.getOptionValue(OPTION_ANSWER));
+            if(cmd.hasOption(OPTION_CLASSIFY))
+                pagodaBuilder.classify(Boolean.parseBoolean(cmd.getOptionValue(OPTION_CLASSIFY)));
+            if(cmd.hasOption(OPTION_HERMIT))
+                pagodaBuilder.hermit(Boolean.parseBoolean(cmd.getOptionValue(OPTION_HERMIT)));
+            pagodaBuilder.build().run();
+        } catch(ParseException exp) {
+            HelpFormatter formatter = new HelpFormatter();
+            formatter.printHelp("PAGOdA", options);
+            Utility.logError("Parsing failed.  Reason: " + exp.getMessage());
+            System.exit(0);
+        }
+    }
+    /**
+     * Get a builder.
+     * */
+    public static PagodaBuilder builder() {
+        return new PagodaBuilder();
+    }
+    @Override
+    public void run() {
+        Utility.logInfo("Ontology file: " + properties.getOntologyPath());
+        Utility.logInfo("Data files: " + properties.getDataPath());
+        Utility.logInfo("Query files: " + properties.getQueryPath());
+        Utility.logInfo("Answer file: " + properties.getAnswerPath());
+        QueryReasoner pagoda = null;
+        try {
+            Timer t = new Timer();
+            pagoda = QueryReasoner.getInstance(properties);
+            if (pagoda == null) return;
+            Utility.logInfo("Preprocessing Done in " + t.duration()     + " seconds.");
+            if (properties.getQueryPath() != null)
+                for (String queryFile: properties.getQueryPath().split(";"))
+                    pagoda.evaluate(pagoda.getQueryManager().collectQueryRecords(queryFile));
+        } finally {
+            if (pagoda != null) pagoda.dispose();
+        }
+    }
+    /**
+     * Allows to set the parameters before creating a Pagoda instance.
+     * */
+    public static class PagodaBuilder {
+        private Pagoda instance;
+        private PagodaBuilder() {
+            instance = new Pagoda();
+        }
+        public PagodaBuilder ontology(String ontologyPath) {
+            if(instance == null) return null;
+            instance.properties.setOntologyPath(ontologyPath);
+            return this;
+        }
+        public PagodaBuilder ontology(Path ontologyPath) {
+            return ontology(ontologyPath.toString());
+        }
+        public PagodaBuilder data(String dataPath) {
+            if(instance == null) return null;
+            instance.properties.setDataPath(dataPath);
+            return this;
+        }
+        public PagodaBuilder data(Path dataPath) {
+            return data(dataPath.toString());
+        }
+        public PagodaBuilder query(String queryPath) {
+            if(instance == null) return null;
+            instance.properties.setQueryPath(queryPath);
+            return this;
+        }
+        public PagodaBuilder query(Path queryPath) {
+            return query(queryPath.toString());
+        }
+        public PagodaBuilder answer(String answerPath) {
+            if(instance == null) return null;
+            instance.properties.setAnswerPath(answerPath);
+            return this;
+        }
+        public PagodaBuilder answer(Path answerPath) {
+            return answer(answerPath.toString());
+        }
+        public PagodaBuilder classify(Boolean toClassify) {
+            if(instance == null) return null;
+            instance.properties.setToClassify(toClassify);
+            return this;
+        }
+        public PagodaBuilder hermit(Boolean callHermit) {
+            if(instance == null) return null;
+            instance.properties.setToCallHermiT(callHermit);
+            return this;
+        }
+        public Pagoda build() {
+            Pagoda builtInstance = instance;
+            instance = null;
+            return builtInstance;
+        }
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java b/src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java
index 1ed8ba6..d961223 100644
--- a/src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java
+++ b/src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java
@@ -1,159 +1,121 @@
 package uk.ac.ox.cs.pagoda.approx;
-import java.io.BufferedOutputStream;
+import org.apache.commons.io.FilenameUtils;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.ObjectOutput;
-import java.io.ObjectOutputStream;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Random;
-import java.util.Set;
 import org.semanticweb.HermiT.Configuration;
 import org.semanticweb.HermiT.model.DLClause;
 import org.semanticweb.HermiT.model.DLOntology;
 import org.semanticweb.HermiT.structural.OWLClausification;
-import org.semanticweb.owlapi.model.IRI;
+import org.semanticweb.owlapi.model.*;
-import org.semanticweb.owlapi.model.OWLAnnotationAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLAxiom;
-import org.semanticweb.owlapi.model.OWLClass;
-import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLClassExpression;
-import org.semanticweb.owlapi.model.OWLDataFactory;
-import org.semanticweb.owlapi.model.OWLDataHasValue;
-import org.semanticweb.owlapi.model.OWLDataMaxCardinality;
-import org.semanticweb.owlapi.model.OWLDataMinCardinality;
-import org.semanticweb.owlapi.model.OWLDataPropertyAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLDataSomeValuesFrom;
-import org.semanticweb.owlapi.model.OWLDatatype;
-import org.semanticweb.owlapi.model.OWLDifferentIndividualsAxiom;
-import org.semanticweb.owlapi.model.OWLIndividual;
-import org.semanticweb.owlapi.model.OWLNamedIndividual;
-import org.semanticweb.owlapi.model.OWLObjectAllValuesFrom;
-import org.semanticweb.owlapi.model.OWLObjectComplementOf;
-import org.semanticweb.owlapi.model.OWLObjectHasValue;
-import org.semanticweb.owlapi.model.OWLObjectMaxCardinality;
-import org.semanticweb.owlapi.model.OWLObjectMinCardinality;
-import org.semanticweb.owlapi.model.OWLObjectOneOf;
-import org.semanticweb.owlapi.model.OWLObjectProperty;
-import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
-import org.semanticweb.owlapi.model.OWLObjectSomeValuesFrom;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyCreationException;
-import org.semanticweb.owlapi.model.OWLOntologyManager;
-import org.semanticweb.owlapi.model.OWLOntologyStorageException;
-import org.semanticweb.owlapi.model.OWLSameIndividualAxiom;
 import org.semanticweb.owlapi.profiles.OWL2RLProfile;
 import org.semanticweb.owlapi.profiles.OWLProfileReport;
 import org.semanticweb.owlapi.profiles.OWLProfileViolation;
 import uk.ac.ox.cs.pagoda.constraints.NullaryBottom;
 import uk.ac.ox.cs.pagoda.constraints.UnaryBottom;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.io.*;
+import java.nio.file.Paths;
+import java.util.*;
 public class RLPlusOntology implements KnowledgeBase {
-        
+        private static final String DEFAULT_ONTOLOGY_FILE_EXTENSION = "owl";
        OWLOntologyManager manager;
        OWLDataFactory factory;
        String ontologyIRI;
        String corrFileName = null;
        String outputPath, aBoxPath;
-        
        OWLOntology inputOntology = null;
        OWLOntology tBox = null;
        OWLOntology aBox = null;
        OWLOntology restOntology = null;
        OWLOntology outputOntology = null; //RL ontology
-        
        DLOntology dlOntology = null;
        int rlCounter = 0;
-        
+        LinkedList<Clause> clauses;
-        LinkedList<Clause> clauses; 
        Map<OWLAxiom, OWLAxiom> correspondence;
-        
+        BottomStrategy botStrategy;
-        BottomStrategy botStrategy; 
+        Random random = new Random(19900114);
-        
+        private Map<OWLClassExpression, Integer> subCounter = null;
+        private Map<OWLClass, OWLClass> atomic2negation = new HashMap<OWLClass, OWLClass>();
+        // FIXME multiple anonymous ontologies
        @Override
-        public void load(OWLOntology o, uk.ac.ox.cs.pagoda.constraints.BottomStrategy bottomStrategy) {
+        public void load(OWLOntology ontology, uk.ac.ox.cs.pagoda.constraints.BottomStrategy bottomStrategy) {
                if (bottomStrategy instanceof UnaryBottom)
-                        botStrategy = BottomStrategy.UNARY; 
+                        botStrategy = BottomStrategy.UNARY;
                else if (bottomStrategy instanceof NullaryBottom)
-                        botStrategy = BottomStrategy.NULLARY; 
+                        botStrategy = BottomStrategy.NULLARY;
-                else 
+                else
-                        botStrategy = BottomStrategy.TOREMOVE; 
+                        botStrategy = BottomStrategy.TOREMOVE;
-                
-                if (corrFileName == null) 
+                if(corrFileName == null)
                        corrFileName = "rlplus.crr";
-                manager = o.getOWLOntologyManager();
+                manager = ontology.getOWLOntologyManager();
 //              manager = OWLManager.createOWLOntologyManager();
-                factory = manager.getOWLDataFactory(); 
+                factory = manager.getOWLDataFactory();
-                inputOntology = o; 
+                inputOntology = ontology;
-                
                try {
-                        String path = OWLHelper.getOntologyPath(inputOntology);
+                        IRI ontologyIri;
-                        String name; 
+                        if(ontology.isAnonymous()) {
-                        if (path.contains(Utility.JAVA_FILE_SEPARATOR))
+                                String anonymousOntologySuffix = Long.toString(System.currentTimeMillis());
-                                name = path.substring(path.lastIndexOf(Utility.JAVA_FILE_SEPARATOR));
+                                ontologyIri = IRI.create("http://www.example.org/", "anonymous-ontology-"
-                        else 
+                                                + anonymousOntologySuffix + "." + DEFAULT_ONTOLOGY_FILE_EXTENSION);
-                                name = path.substring(path.lastIndexOf(":")); 
+                        }
-                        
+                        else
-                        String originalExtension = name.lastIndexOf(".") >= 0 ? name.substring(name.lastIndexOf(".")) : "";
+                                ontologyIri = inputOntology.getOntologyID().getOntologyIRI();
-                        
-                        if (inputOntology.getOntologyID().getOntologyIRI() == null)
+                        String ontologyIriPrefix = ontologyIri.getNamespace();
-                                ontologyIRI = "http://www.example.org/anonymous-ontology" + originalExtension; 
+                        ontologyIRI = ontologyIri.toString();
-                        else 
+                        String ontologyIriFragment = ontologyIri.getFragment();
-                                ontologyIRI = inputOntology.getOntologyID().getOntologyIRI().toString();
+                        String originalFileName = FilenameUtils.removeExtension(ontologyIriFragment);
-                        
+                        String originalExtension = FilenameUtils.getExtension(ontologyIriFragment);
-                        String tOntoIRI = ontologyIRI; 
+                        if(originalExtension.isEmpty()) originalExtension = DEFAULT_ONTOLOGY_FILE_EXTENSION;
-                        if (!tOntoIRI.endsWith(originalExtension)) tOntoIRI += originalExtension;
-                        
-                        String rlOntologyIRI = originalExtension.isEmpty() ? tOntoIRI + "-RL.owl" : tOntoIRI.replaceFirst(originalExtension, "-RL.owl");
+                        IRI rlOntologyIRI = IRI.create(ontologyIriPrefix, originalFileName + "-RL." + originalExtension);
-                        String rlDocumentIRI = (outputPath = Utility.TempDirectory + "RL.owl");
+                        outputPath = Paths.get(Utility.getGlobalTempDirAbsolutePath(),
-                        outputOntology = manager.createOntology(IRI.create(rlOntologyIRI));
+                                                                   originalFileName + "-RL." + originalExtension).toString();
-                        manager.setOntologyDocumentIRI(outputOntology, IRI.create(Utility.toFileIRI(rlDocumentIRI)));
+                        IRI rlDocumentIRI = IRI.create(outputPath);
-                        
+                        outputOntology = manager.createOntology(rlOntologyIRI);
-                        String tBoxOntologyIRI, aBoxOntologyIRI; 
+                        manager.setOntologyDocumentIRI(outputOntology, rlDocumentIRI);
-                        tBoxOntologyIRI = originalExtension.isEmpty() ? tOntoIRI + "-TBox.owl" : tOntoIRI.replaceFirst(originalExtension, "-TBox.owl"); 
-                        aBoxOntologyIRI = originalExtension.isEmpty() ? tOntoIRI + "-ABox.owl" : tOntoIRI.replaceFirst(originalExtension, "-ABox.owl");
+                        String tBoxOntologyFragment = originalFileName + "-TBox." + originalExtension;
-                        
+                        IRI tBoxOntologyIRI = IRI.create(ontologyIriPrefix, tBoxOntologyFragment);
-                        String tBoxDocumentIRI = (Utility.TempDirectory + "TBox.owl");
+                        IRI tBoxDocumentIRI =
-                        String aBoxDocumentIRI = (aBoxPath = Utility.TempDirectory + "ABox.owl");
+                                        IRI.create("file://" + Paths.get(Utility.getGlobalTempDirAbsolutePath(), tBoxOntologyFragment));
-                        tBox = manager.createOntology(IRI.create(tBoxOntologyIRI));
-                        aBox = manager.createOntology(IRI.create(aBoxOntologyIRI));
+                        String aBoxOntologyFragment = originalFileName + "-ABox." + originalExtension;
-                        manager.setOntologyDocumentIRI(tBox, IRI.create(Utility.toFileIRI(tBoxDocumentIRI)));
+                        IRI aBoxOntologyIRI = IRI.create(ontologyIriPrefix, aBoxOntologyFragment);
-                        manager.setOntologyDocumentIRI(aBox, IRI.create(Utility.toFileIRI(aBoxDocumentIRI)));
+                        aBoxPath = Paths.get(Utility.getGlobalTempDirAbsolutePath()) + aBoxOntologyFragment;
+                        IRI aBoxDocumentIRI =
-                        FileOutputStream aBoxOut = new FileOutputStream(aBoxPath); 
+                                        IRI.create("file://" + Paths.get(Utility.getGlobalTempDirAbsolutePath(), aBoxOntologyFragment));
+                        tBox = manager.createOntology(tBoxOntologyIRI);
+                        aBox = manager.createOntology(aBoxOntologyIRI);
+                        manager.setOntologyDocumentIRI(tBox, tBoxDocumentIRI);
+                        manager.setOntologyDocumentIRI(aBox, aBoxDocumentIRI);
+                        FileOutputStream aBoxOut = new FileOutputStream(aBoxPath);
                        manager.saveOntology(aBox, aBoxOut);
                        aBoxOut.close();
-                        
                        restOntology = manager.createOntology();
-                }
+                } catch(OWLOntologyCreationException | OWLOntologyStorageException | IOException e) {
-                catch (OWLOntologyCreationException e) {
-                        e.printStackTrace();
-                } catch (OWLOntologyStorageException e) {
-                        // TODO Auto-generated catch block
-                        e.printStackTrace();
-                } catch (IOException e) {
-                        // TODO Auto-generated catch block
                        e.printStackTrace();
+                        System.exit(1);
                }
        }
        
        public OWLOntology getTBox() {
-                return tBox; 
+                return tBox;
        }
        
        public String getABoxPath() {
-                return aBoxPath; 
+                return aBoxPath;
        }
        
        private void add2SubCounter(OWLClassExpression exp) {
@@ -164,24 +126,23 @@ public class RLPlusOntology implements KnowledgeBase {
        }
        
        public void simplify() {
-                if (simplifyABox()) { 
+                if(simplifyABox()) {
                        save(aBox);
 //                      save(tBox);
-                }
+                } else
-                else 
+                        tBox = inputOntology;
-                        tBox = inputOntology; 
        }
-        
        @Override
        public void transform() {
                simplify();
                filter();
                clausify();
-                
                subCounter = new HashMap<OWLClassExpression, Integer>();
                clauses = new LinkedList<Clause>();
-                Clausifier clausifier = Clausifier.getInstance(restOntology); 
+                Clausifier clausifier = Clausifier.getInstance(restOntology);
-                
                for (DLClause c: dlOntology.getDLClauses()) {
                        Clause clause = new Clause(clausifier, c);
                        clauses.add(clause);
@@ -190,7 +151,7 @@ public class RLPlusOntology implements KnowledgeBase {
                         * count the expressions in the left
                         */
                        for (OWLClassExpression exp: clause.getSubClasses()) {
-                                if (exp instanceof OWLClass) 
+                                if(exp instanceof OWLClass)
                                        add2SubCounter(exp);
                                else if (exp instanceof OWLObjectSomeValuesFrom) {
                                        OWLObjectSomeValuesFrom someValue = (OWLObjectSomeValuesFrom)exp;
@@ -201,8 +162,7 @@ public class RLPlusOntology implements KnowledgeBase {
                                        OWLObjectMinCardinality minCard = (OWLObjectMinCardinality)exp;
                                        add2SubCounter(factory.getOWLObjectSomeValuesFrom(minCard.getProperty(), factory.getOWLThing()));
                                        add2SubCounter(minCard.getFiller());
-                                }
+                                } else
-                                else 
                                        Utility.logError("strange class expression: " + exp);
                        }
@@ -216,12 +176,12 @@ public class RLPlusOntology implements KnowledgeBase {
                        addedAxioms.clear();
                        for (OWLClassExpression exp: getDisjunctionApprox0(clause.getSuperClasses())) {
                                addedAxioms.add(factory.getOWLSubClassOfAxiom(subExp, transform(exp, addedAxioms)));
-                                for (OWLAxiom a: addedAxioms) 
+                                for(OWLAxiom a : addedAxioms)
-                                        addAxiom2output(a, factory.getOWLSubClassOfAxiom(subExp, 
+                                        addAxiom2output(a, factory.getOWLSubClassOfAxiom(subExp,
                                                        OWLHelper.getSimplifiedDisjunction(factory, clause.getSuperClasses())));
                        }
                }
-                
                subCounter.clear();
        }
        
@@ -231,7 +191,7 @@ public class RLPlusOntology implements KnowledgeBase {
                        save(correspondence, corrFileName);
                save(outputOntology);
        }
-        
        private void save(Map<OWLAxiom, OWLAxiom> map, String corrFileName) {
                if (corrFileName == null) return ;
                ObjectOutput output;
@@ -251,63 +211,61 @@ public class RLPlusOntology implements KnowledgeBase {
                        e.printStackTrace();
                }
        }
-        
        /*
         * treat disjunction as conjunction
         */
        private Set<OWLClassExpression> getDisjunctionApprox0(Set<OWLClassExpression> superClasses) {
                return superClasses;
        }
+        
        /*
         * choose one simple class disjunct
         */
        @SuppressWarnings("unused")
        private Set<OWLClassExpression> getDisjunctionApprox1(Set<OWLClassExpression> superClasses) {
-                if (superClasses.isEmpty() || superClasses.size() == 1) 
+                if(superClasses.isEmpty() || superClasses.size() == 1)
                        return superClasses;
-                
                OWLClassExpression rep = null;
                int min = Integer.MAX_VALUE, o;
-                for (OWLClassExpression exp: superClasses)
+                for(OWLClassExpression exp : superClasses)
-                        if (exp instanceof OWLClass && (o = getOccurrence(exp)) < min) {
+                        if(exp instanceof OWLClass && (o = getOccurrence(exp)) < min) {
                                min = o;
                                rep = exp;
                        }
-                
-                if (rep == null) rep = superClasses.iterator().next();
+                if(rep == null) rep = superClasses.iterator().next();
-                
                return Collections.singleton(rep);
        }
-        
-        Random random = new Random(19900114);
        /*
         * randomly choose a class expression to represent this disjunction
         */
        @SuppressWarnings("unused")
        private Set<OWLClassExpression> getDisjunctionApprox2(Set<OWLClassExpression> superClasses) {
-                if (superClasses.isEmpty() || superClasses.size() == 1) 
+                if(superClasses.isEmpty() || superClasses.size() == 1)
                        return superClasses;
-                
                int index = random.nextInt() % superClasses.size();
                if (index < 0) index += superClasses.size();
-                        
                int i = 0;
-                for (OWLClassExpression exp: superClasses) 
+                for(OWLClassExpression exp : superClasses)
                        if (i++ == index)
                                return Collections.singleton(exp);
                return null;
        }
        
-        private Map<OWLClassExpression, Integer> subCounter = null;
        /*
         * choose the one that appears least in the l.h.s.
         */
        @SuppressWarnings("unused")
        private Set<OWLClassExpression> getDisjunctionApprox3(Set<OWLClassExpression> superClasses) {
-                if (superClasses.isEmpty() || superClasses.size() == 1) 
+                if(superClasses.isEmpty() || superClasses.size() == 1)
                        return superClasses;
-                
                OWLClassExpression rep = null, exp1;
                int occurrence = Integer.MAX_VALUE, o;
                for (OWLClassExpression exp: superClasses) {
@@ -318,16 +276,16 @@ public class RLPlusOntology implements KnowledgeBase {
                                if (minCard.getCardinality() == 1)
                                        exp1 = factory.getOWLObjectSomeValuesFrom(minCard.getProperty(), minCard.getFiller());
                        }
-                        
                        if (!subCounter.containsKey(exp1) || (o = subCounter.get(exp1)) < occurrence) {
                                rep = exp;
                                occurrence = o;
                        }
                }
-                
                return Collections.singleton(rep);
        }
-        
        private int getOccurrence(OWLClassExpression exp) {
                if (!subCounter.containsKey(exp))
                        return 0;
@@ -336,9 +294,9 @@ public class RLPlusOntology implements KnowledgeBase {
        @SuppressWarnings("unused")
        private Set<OWLClassExpression> getDisjunctionApprox4(Set<OWLClassExpression> superClasses) {
-                if (superClasses.isEmpty() || superClasses.size() == 1) 
+                if(superClasses.isEmpty() || superClasses.size() == 1)
                        return superClasses;
-                
                OWLClassExpression rep = null;
                int occurrence = Integer.MAX_VALUE, o;
                for (OWLClassExpression exp: superClasses) {
@@ -350,10 +308,9 @@ public class RLPlusOntology implements KnowledgeBase {
                                        o += getOccurrence(minCard.getFiller());
 //                                      if (o < o1) o = o1;
                                }
-                        }
+                        } else
-                        else 
                                o = getOccurrence(exp);
-                        
                        if (o < occurrence || o == occurrence && !(rep instanceof OWLClass)) {
                                rep = exp;
                                occurrence = o;
@@ -366,11 +323,11 @@ public class RLPlusOntology implements KnowledgeBase {
        private boolean simplifyABox() {
                boolean flag = false;
                Map<OWLClassExpression, OWLClass> complex2atomic= new HashMap<OWLClassExpression, OWLClass>();
-                
-                OWLDatatype anyURI = factory.getOWLDatatype(IRI.create(Namespace.XSD_NS + "anyURI")); 
+                OWLDatatype anyURI = factory.getOWLDatatype(IRI.create(Namespace.XSD_NS + "anyURI"));
                OWLObjectProperty sameAs = factory.getOWLObjectProperty(IRI.create(Namespace.EQUALITY));
                OWLObjectProperty differentFrom = factory.getOWLObjectProperty(IRI.create(Namespace.INEQUALITY));
-                
                for (OWLOntology imported: inputOntology.getImportsClosure())
                        for (OWLAxiom axiom: imported.getAxioms()) {
                                if (axiom instanceof OWLClassAssertionAxiom) {
@@ -380,7 +337,7 @@ public class RLPlusOntology implements KnowledgeBase {
                                        OWLClass cls;
                                        if (clsExp instanceof OWLClass) {
                                                if (((OWLClass) clsExp).toStringID().startsWith("owl:"))
-                                                        manager.addAxiom(tBox, axiom); 
+                                                        manager.addAxiom(tBox, axiom);
                                                else manager.addAxiom(aBox, axiom);
                                        }
                                        else {
@@ -389,40 +346,38 @@ public class RLPlusOntology implements KnowledgeBase {
                                                        manager.addAxiom(tBox, factory.getOWLSubClassOfAxiom(cls, clsExp));
                                                }
                                                manager.addAxiom(aBox, factory.getOWLClassAssertionAxiom(cls, assertion.getIndividual()));
-                                        } 
+                                        }
                                }
                                else if (axiom instanceof OWLObjectPropertyAssertionAxiom || axiom instanceof OWLDataPropertyAssertionAxiom || axiom instanceof OWLAnnotationAssertionAxiom) {
-                                        if (axiom.getDataPropertiesInSignature().contains(anyURI)) continue; 
+                                        if(axiom.getDataPropertiesInSignature().contains(anyURI)) continue;
                                        flag = true;
                                        manager.addAxiom(aBox, axiom);
                                }
                                else if (axiom instanceof OWLSameIndividualAxiom) {
-                                        OWLIndividual firstIndividual = null, previousIndividual = null, lastIndividual = null; 
+                                        OWLIndividual firstIndividual = null, previousIndividual = null, lastIndividual = null;
                                        for (OWLIndividual next: ((OWLSameIndividualAxiom) axiom).getIndividuals()) {
-                                                if (firstIndividual == null) firstIndividual = previousIndividual = next; 
+                                                if(firstIndividual == null) firstIndividual = previousIndividual = next;
-                                                else                                            
+                                                else
                                                        manager.addAxiom(aBox, factory.getOWLObjectPropertyAssertionAxiom(sameAs, previousIndividual, next));
                                                previousIndividual = lastIndividual = next;
                                        }
                                        manager.addAxiom(aBox, factory.getOWLObjectPropertyAssertionAxiom(sameAs, lastIndividual, firstIndividual));
                                }
                                else if (axiom instanceof OWLDifferentIndividualsAxiom) {
-                                        int index1 = 0, index2; 
+                                        int index1 = 0, index2;
                                        for (OWLIndividual individual1: ((OWLDifferentIndividualsAxiom) axiom).getIndividuals()) {
                                                ++index1;
-                                                index2 = 0; 
+                                                index2 = 0;
                                                for (OWLIndividual individual2: ((OWLDifferentIndividualsAxiom) axiom).getIndividuals()) {
                                                        if (index2++ < index1) {
-                                                                manager.addAxiom(aBox, factory.getOWLObjectPropertyAssertionAxiom(differentFrom, individual1, individual2));                                                    
+                                                                manager.addAxiom(aBox, factory.getOWLObjectPropertyAssertionAxiom(differentFrom, individual1, individual2));
-                                                        }
+                                                        } else break;
-                                                        else break; 
                                                }
                                        }
-                                }
+                                } else
-                                else 
                                        manager.addAxiom(tBox, axiom);
                        }
-                
                return flag;
        }
@@ -430,15 +385,15 @@ public class RLPlusOntology implements KnowledgeBase {
                OWL2RLProfile profile = new OWL2RLProfile();
                OWLProfileReport report = profile.checkOntology(tBox);
                Set<OWLAxiom> rlAxioms = tBox.getAxioms();
-                OWLAxiom axiom; 
+                OWLAxiom axiom;
-                
                for (OWLProfileViolation violation: report.getViolations()) {
                        manager.addAxiom(restOntology, axiom = violation.getAxiom());
-                        rlAxioms.remove(axiom); 
+                        rlAxioms.remove(axiom);
                }
-                
                for (Iterator<OWLAxiom> iter = rlAxioms.iterator(); iter.hasNext(); )
-                        addAxiom2output(iter.next(), null); 
+                        addAxiom2output(iter.next(), null);
        }
        
        private void clausify() {
@@ -453,8 +408,6 @@ public class RLPlusOntology implements KnowledgeBase {
                if (correspondingAxiom != null)
                        correspondence.put(axiom, correspondingAxiom);
        }
-        
-        private Map<OWLClass, OWLClass> atomic2negation = new HashMap<OWLClass, OWLClass>();
        private OWLClassExpression transform(OWLClassExpression exp, Set<OWLAxiom> addedAxioms) {
                if (exp instanceof OWLClass) 
@@ -493,7 +446,7 @@ public class RLPlusOntology implements KnowledgeBase {
                                                addedAxioms.add(factory.getOWLObjectPropertyRangeAxiom(r, tExp));
                                }
                                else if (botStrategy != BottomStrategy.TOREMOVE) {
-                                                OWLClass cls = (OWLClass) ((OWLObjectComplementOf) tExp).getComplementNNF();
+                                                OWLClass cls = (OWLClass) tExp.getComplementNNF();
                                                OWLClass neg;
                                                if ((neg = atomic2negation.get(cls)) == null) {
                                                        neg = getNewConcept(outputOntology, rlCounter);
@@ -637,6 +590,6 @@ public class RLPlusOntology implements KnowledgeBase {
                corrFileName = path; 
        }
        
-        private static enum BottomStrategy { TOREMOVE, NULLARY, UNARY }
+        private enum BottomStrategy { TOREMOVE, NULLARY, UNARY }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/constraints/PredicateDependency.java b/src/uk/ac/ox/cs/pagoda/constraints/PredicateDependency.java
index b201918..70f841f 100644
--- a/src/uk/ac/ox/cs/pagoda/constraints/PredicateDependency.java
+++ b/src/uk/ac/ox/cs/pagoda/constraints/PredicateDependency.java
@@ -1,155 +1,135 @@
 package uk.ac.ox.cs.pagoda.constraints;
-import java.util.Collection;
+import org.semanticweb.HermiT.model.*;
-import java.util.HashMap;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-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 uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.util.*;
 public class PredicateDependency extends DependencyGraph<DLPredicate> {
-        
-        Collection<DLClause> m_clauses; 
+        private static final DLPredicate equality = AtomicRole.create(Namespace.EQUALITY);
-        Map<PredicatePair, LinkedList<DLClause>> edgeLabels = new HashMap<PredicatePair, LinkedList<DLClause>>();  
+        private static final DLPredicate inequality = AtomicRole.create(Namespace.INEQUALITY);
-                
+        Collection<DLClause> m_clauses;
+        Map<PredicatePair, LinkedList<DLClause>> edgeLabels = new HashMap<PredicatePair, LinkedList<DLClause>>();
+        Set<DLPredicate> reachableToBottom = null;
        public PredicateDependency(Collection<DLClause> clauses) {
                m_clauses = clauses;
-                build(); 
+                build();
        }
        @Override
        protected void build() {
                update(m_clauses);
-                
                addLink(equality, AtomicConcept.NOTHING);
                addLink(inequality, AtomicConcept.NOTHING);
        }
-        
        private void addEdgeLabel(DLPredicate body, DLPredicate head, DLClause clause) {
-                PredicatePair key = new PredicatePair(body, head); 
+                PredicatePair key = new PredicatePair(body, head);
-                LinkedList<DLClause> value; 
+                LinkedList<DLClause> value;
-                if ((value = edgeLabels.get(key)) == null) 
+                if ((value = edgeLabels.get(key)) == null)
-                        edgeLabels.put(key, value = new LinkedList<DLClause>()); 
+                        edgeLabels.put(key, value = new LinkedList<DLClause>());
                value.add(clause);
        }
        private void addLinks4Negation(AtomicConcept c, DLClause clause) {
                addLink(c, AtomicConcept.NOTHING);
                addEdgeLabel(c, AtomicConcept.NOTHING, clause);
-                String iri = c.getIRI(); 
+                String iri = c.getIRI();
                addLink(c = AtomicConcept.create(iri.substring(0, iri.length() - 4)), AtomicConcept.NOTHING);
                addEdgeLabel(c, AtomicConcept.NOTHING, clause);
        }
        public Set<DLPredicate> collectPredicate(Atom[] atoms) {
                Set<DLPredicate> predicates = new HashSet<DLPredicate>();
-                for (Atom atom: atoms) 
+                for (Atom atom : atoms)
-                        predicates.addAll(getAtomicPredicates(atom.getDLPredicate())); 
+                        predicates.addAll(getAtomicPredicates(atom.getDLPredicate()));
                return predicates;
        }
-        private static final DLPredicate equality = AtomicRole.create(Namespace.EQUALITY); 
-        private static final DLPredicate inequality = AtomicRole.create(Namespace.INEQUALITY);
        
        private Set<DLPredicate> getAtomicPredicates(DLPredicate predicate) {
-                Set<DLPredicate> predicates = new HashSet<DLPredicate>(); 
+                Set<DLPredicate> predicates = new HashSet<DLPredicate>();
                if (predicate instanceof AtLeastConcept)
                        predicates.addAll(getAtomicPredicates((AtLeastConcept) predicate));
                else {
-                        if ((predicate = getAtomicPredicate(predicate)) != null) 
+                        if ((predicate = getAtomicPredicate(predicate)) != null)
                                predicates.add(predicate);
                }
-                return predicates; 
+                return predicates;
        }
        
        private Set<DLPredicate> getAtomicPredicates(AtLeastConcept alc) {
                Set<DLPredicate> set = new HashSet<DLPredicate>();
-                if (alc.getOnRole() instanceof AtomicRole) 
+                if (alc.getOnRole() instanceof AtomicRole)
-                        set.add((AtomicRole) alc.getOnRole()); 
+                        set.add((AtomicRole) alc.getOnRole());
-                else 
+                else
                        set.add(((InverseRole) alc.getOnRole()).getInverseOf());
-                
-                if (alc.getToConcept() instanceof AtomicConcept) 
+                if (alc.getToConcept() instanceof AtomicConcept)
-                        if (alc.getToConcept().equals(AtomicConcept.THING)); 
+                        if (alc.getToConcept().equals(AtomicConcept.THING)) ;
-                        else set.add((AtomicConcept) alc.getToConcept()); 
+                        else set.add((AtomicConcept) alc.getToConcept());
-                else 
+                else
                        set.add(OverApproxExist.getNegationConcept(((AtomicNegationConcept) alc.getToConcept()).getNegatedAtomicConcept()));
-                return set; 
+                return set;
        }
        
        private DLPredicate getAtomicPredicate(DLPredicate p) {
                if (p instanceof Equality || p instanceof AnnotatedEquality)
                        return equality;
                if (p instanceof Inequality)
-                        return inequality; 
+                        return inequality;
                if (p instanceof AtomicConcept)
-                        if (p.equals(AtomicConcept.THING)) 
+                        if (p.equals(AtomicConcept.THING))
                                return null;
-                        else return p; 
+                        else return p;
                if (p instanceof AtomicRole)
-                        return p; 
+                        return p;
                if (p instanceof AtLeastDataRange) {
-                        AtLeastDataRange aldr = (AtLeastDataRange) p; 
+                        AtLeastDataRange aldr = (AtLeastDataRange) p;
-                        if (aldr.getOnRole() instanceof AtomicRole) 
+                        if (aldr.getOnRole() instanceof AtomicRole)
-                                return (AtomicRole) aldr.getOnRole(); 
+                                return (AtomicRole) aldr.getOnRole();
-                        else 
+                        else
-                                return ((InverseRole) aldr.getOnRole()).getInverseOf(); 
+                                return ((InverseRole) aldr.getOnRole()).getInverseOf();
                }
                Utility.logDebug("Unknown DLPredicate in PredicateDependency: " + p);
-                return null; 
+                return null;
        }
        
        public Set<DLClause> pathTo(DLPredicate p) {
-                Set<DLClause> rules = new HashSet<DLClause>(); 
+                Set<DLClause> rules = new HashSet<DLClause>();
-                Set<DLPredicate> visited = new HashSet<DLPredicate>(); 
+                Set<DLPredicate> visited = new HashSet<DLPredicate>();
-                
-                Queue<DLPredicate> queue = new LinkedList<DLPredicate>(); 
+                Queue<DLPredicate> queue = new LinkedList<DLPredicate>();
-                queue.add(p); 
+                queue.add(p);
                visited.add(p);
-                
-                Set<DLPredicate> edge; 
+                Set<DLPredicate> edge;
-                Collection<DLClause> clauses; 
+                Collection<DLClause> clauses;
-                
                while (!queue.isEmpty()) {
                        if ((edge = reverseEdges.get(p = queue.poll())) != null) {
                                for (DLPredicate pred: edge) {
                                        if (!visited.contains(pred)) {
-                                                queue.add(pred); 
+                                                queue.add(pred);
-                                                visited.add(pred); 
+                                                visited.add(pred);
                                        }
-                                        clauses = edgeLabelsBetween(pred, p); 
+                                        clauses = edgeLabelsBetween(pred, p);
-                                        if (clauses != null) rules.addAll(clauses); 
+                                        if (clauses != null) rules.addAll(clauses);
                                }
                        }
                }
-                return rules; 
+                return rules;
        }
-        
        private LinkedList<DLClause> edgeLabelsBetween(DLPredicate p, DLPredicate q) {
                PredicatePair pair = new PredicatePair(p, q);
-                return edgeLabels.get(pair); 
+                return edgeLabels.get(pair);
        }
-        Set<DLPredicate> reachableToBottom = null; 
        
        public Set<DLClause> pathToBottom(DLPredicate p) {
                if (reachableToBottom == null) {
diff --git a/src/uk/ac/ox/cs/pagoda/endomorph/Clique.java b/src/uk/ac/ox/cs/pagoda/endomorph/Clique.java
index 9daea7e..9b0d88e 100644
--- a/src/uk/ac/ox/cs/pagoda/endomorph/Clique.java
+++ b/src/uk/ac/ox/cs/pagoda/endomorph/Clique.java
@@ -1,11 +1,11 @@
 package uk.ac.ox.cs.pagoda.endomorph;
+import uk.ac.ox.cs.pagoda.summary.NodeTuple;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
-import uk.ac.ox.cs.pagoda.summary.NodeTuple;
 public class Clique {
        NodeTuple representative; 
        Set<NodeTuple> nodeTuples = null; 
diff --git a/src/uk/ac/ox/cs/pagoda/endomorph/plan/PlainPlan.java b/src/uk/ac/ox/cs/pagoda/endomorph/plan/PlainPlan.java
index 6931ccc..5e1a700 100644
--- a/src/uk/ac/ox/cs/pagoda/endomorph/plan/PlainPlan.java
+++ b/src/uk/ac/ox/cs/pagoda/endomorph/plan/PlainPlan.java
@@ -1,12 +1,12 @@
 package uk.ac.ox.cs.pagoda.endomorph.plan;
-import java.util.Set;
 import uk.ac.ox.cs.pagoda.endomorph.Clique;
 import uk.ac.ox.cs.pagoda.reasoner.full.Checker;
 import uk.ac.ox.cs.pagoda.summary.NodeTuple;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.util.Set;
 public class PlainPlan implements CheckPlan {
        
        Checker checker; 
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication.java b/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication.java
index 22f1d1d..c75083b 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication.java
@@ -1,14 +1,14 @@
 package uk.ac.ox.cs.pagoda.multistage;
-import java.util.Collection;
-import java.util.LinkedList;
 import org.semanticweb.HermiT.model.DLClause;
 import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
-import uk.ac.ox.cs.pagoda.rules.OverApproxDisj;
 import uk.ac.ox.cs.pagoda.rules.Program;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxDisj;
 import uk.ac.ox.cs.pagoda.util.Timer;
+import java.util.Collection;
+import java.util.LinkedList;
 public class FoldedApplication extends MultiStageUpperProgram {
        public FoldedApplication(Program program, BottomStrategy upperBottom) {
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication2.java b/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication2.java
deleted file mode 100644
index 8212733..0000000
--- a/src/uk/ac/ox/cs/pagoda/multistage/FoldedApplication2.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package uk.ac.ox.cs.pagoda.multistage;
-import java.util.Collection;
-import org.semanticweb.HermiT.model.AtLeastConcept;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.DLClause;
-import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
-import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
-import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
-import uk.ac.ox.cs.pagoda.rules.Program;
-public class FoldedApplication2 extends TwoStageApplication {
-        public FoldedApplication2(TwoStageQueryEngine engine, DatalogProgram program, GapByStore4ID gap) {
-                super(engine, program, gap);
-        }
-        
-        @Override
-        protected void addAuxiliaryRules() {
-                Collection<DLClause> overClauses; 
-                DLClause disjunct;
-                Atom[] bodyAtoms; 
-                int i; 
-                for (DLClause constraint: constraints) 
-                        for (Atom headAtom: constraint.getHeadAtoms()) 
-                                if (headAtom.getDLPredicate() instanceof AtLeastConcept) {
-                                        disjunct = DLClause.create(new Atom[] {headAtom}, constraint.getBodyAtoms());
-                                        overClauses = overExist.convert(disjunct, getOriginalClause(constraint));
-                                        bodyAtoms = new Atom[constraint.getBodyLength() + 1]; 
-                                        bodyAtoms[0] = getNAFAtom(headAtom);
-                                        i = 0; 
-                                        for (Atom bodyAtom: constraint.getBodyAtoms())
-                                                bodyAtoms[++i] = bodyAtom; 
-                                        for (DLClause overClause: overClauses) 
-                                                if (DLClauseHelper.hasSubsetBodyAtoms(disjunct, constraint)) 
-                                                        addDatalogRule(DLClause.create(new Atom[] {overClause.getHeadAtom(0)}, bodyAtoms));
-                                }
-                                else 
-                                        addDatalogRule(DLClause.create(new Atom[] {headAtom}, constraint.getBodyAtoms())); 
-        }
-        @Override
-        protected Collection<DLClause> getInitialClauses(Program program) {
-                return program.getClauses();
-        }
-        
-        
-}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/IndividualCollector.java b/src/uk/ac/ox/cs/pagoda/multistage/IndividualCollector.java
deleted file mode 100644
index 3d78f0a..0000000
--- a/src/uk/ac/ox/cs/pagoda/multistage/IndividualCollector.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package uk.ac.ox.cs.pagoda.multistage;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import org.openrdf.model.Resource;
-import org.openrdf.model.Statement;
-import org.openrdf.model.Value;
-import org.openrdf.model.impl.URIImpl;
-import org.openrdf.rio.RDFHandler;
-import org.openrdf.rio.RDFHandlerException;
-import uk.ac.ox.cs.JRDFox.model.Individual;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
-import uk.ac.ox.cs.pagoda.util.Namespace;
-public class IndividualCollector implements RDFHandler {
-        boolean addedSkolemised = false; 
-        Set<Individual> individuals = new HashSet<Individual>(); 
-        
-        @Override
-        public void startRDF() throws RDFHandlerException {
-                // TODO Auto-generated method stub
-        }
-        @Override
-        public void endRDF() throws RDFHandlerException {
-                // TODO Auto-generated method stub
-        }
-        @Override
-        public void handleNamespace(String prefix, String uri)
-                        throws RDFHandlerException {
-                // TODO Auto-generated method stub
-        }
-        @Override
-        public void handleStatement(Statement st) throws RDFHandlerException {
-                Resource sub = st.getSubject(); 
-                if (sub instanceof URIImpl)
-                        individuals.add(Individual.create(((URIImpl) sub).toString())); 
-                if (!st.getPredicate().toString().equals(Namespace.RDF_TYPE)) {
-                        Value obj = st.getObject();
-                        if (obj instanceof URIImpl)
-                                individuals.add(Individual.create(((URIImpl) sub).toString())); 
-                }
-        }
-        @Override
-        public void handleComment(String comment) throws RDFHandlerException {
-                // TODO Auto-generated method stub
-        }
-        public Collection<Individual> getAllIndividuals() {
-                if (!addedSkolemised) {
-                        int number = OverApproxExist.getNumberOfSkolemisedIndividual();
-                        for (int i = 0; i < number; ++i)
-                                individuals.add(Individual.create(OverApproxExist.skolemisedIndividualPrefix + i));
-                        addedSkolemised = true; 
-                }
-                return individuals; 
-        }
-}
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..b548d39
--- /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;
+import uk.ac.ox.cs.pagoda.rules.approximators.LimitedSkolemisationApproximator;
+public class LimitedSkolemisationApplication extends RestrictedApplication {
+    public static final int MAX_DEPTH = 1;
+    public LimitedSkolemisationApplication(Program program, BottomStrategy upperBottom) {
+        super(program, upperBottom);
+        m_approxExist = new LimitedSkolemisationApproximator(MAX_DEPTH);
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageQueryEngine.java b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageQueryEngine.java
index b77c264..50996d0 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; 
        }
        
@@ -53,6 +55,18 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                treatment.dispose();
                return ret; 
        }
+        /**
+         * delta-chase
+         */
+        @Override
+        public int materialiseSkolemly(DatalogProgram dProgram, GapByStore4ID gap) {
+                materialise("lower program", dProgram.getLower().toString());
+                Program generalProgram = dProgram.getGeneral();
+                LimitedSkolemisationApplication program = new LimitedSkolemisationApplication(generalProgram, dProgram.getUpperBottomStrategy());
+                Treatment treatment = new Pick4NegativeConceptNaive(this, program);
+                return materialise(program, treatment, gap);
+        }
        
        private int materialise(MultiStageUpperProgram program, Treatment treatment, GapByStore4ID gap) {
                if (gap != null) 
@@ -67,11 +81,11 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                // TODO to be removed ... 
 //              if (gap == null)
 //                      program.save("output/multi.dlog");
-                
-                Collection<Violation> violations = null;
+                Collection<Violation> violations;
                int iteration = 0;
-                Timer subTimer = new Timer(); 
+                Timer subTimer = new Timer();
-                boolean incrementally = false; 
+                boolean incrementally;
                try {
                        while (true) {
                                long oldTripleCount = store.getTriplesCount();
@@ -104,7 +118,7 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                                
                                if (!isValid()) {
                                        if (iteration == 1) {
-                                                Utility.logInfo("The ontology is incosistent.");
+                                                Utility.logInfo("The ontology is inconsistent.");
                                                return -1; 
                                        }
                                        Utility.logInfo(name + " store FAILED for multi-stage materialisation in " + t.duration() + " seconds.");
@@ -119,8 +133,8 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                                subTimer.reset(); 
                                if ((violations = program.isIntegrated(this, incrementally)) == null || violations.size() == 0) {
                                        store.clearRulesAndMakeFactsExplicit();
-                                        Utility.logDebug(name + " store after materialising " + programName + ": " + tripleCount + " (" + (tripleCount - tripleCountBeforeMat) + " new)");
+                                        Utility.logInfo(name + " store after materialising " + programName + ": " + tripleCount + " (" + (tripleCount - tripleCountBeforeMat) + " new)");
-                                        Utility.logInfo(name + " store is DONE for multi-stage materialising in " + t.duration() + " seconds."); 
+                                        Utility.logInfo(name + " store is DONE for multi-stage materialising in " + t.duration() + " seconds.");
                                        return isValid() ? 1 : 0;
                                }
                                Utility.logDebug("Time to detect violations: " + subTimer.duration()); 
@@ -129,6 +143,10 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                                subTimer.reset(); 
                                oldTripleCount = store.getTriplesCount(); 
                                for (Violation v : violations) {
+                                        Utility.logDebug("Dealing with violation: " + v.constraint);
+                                        Utility.logDebug("Number of violation tuples: " + v.size());
                                        Timer localTimer = new Timer(); 
                                        int number = v.size(); 
                                        long vOldCounter = store.getTriplesCount();  
@@ -137,8 +155,8 @@ public class MultiStageQueryEngine extends StageQueryEngine {
                                                Utility.logInfo(name + " store FAILED for multi-stage materialisation in " + t.duration() + " seconds."); 
                                                return 0; 
                                        }
-                                        Utility.logDebug("Time to make the constraint being satisfied: " + localTimer.duration() + " " + number + " tuples for " + v.constraint); 
+                                        Utility.logDebug("Time to make the constraint being satisfied: " + localTimer.duration());
-                                        Utility.logDebug("tuple number: " + v.size() + " before: " + vOldCounter + " after: " + store.getTriplesCount() + " (" + (store.getTriplesCount() - vOldCounter) + " new) ." ); 
+                                        Utility.logDebug("Triples in the store: before=" + vOldCounter + ", after=" + store.getTriplesCount() + ", new=" + (store.getTriplesCount() - vOldCounter));
                                }
                                Utility.logDebug(name + " store after adding facts for violations: " + (tripleCount = store.getTriplesCount()) + " (" + (tripleCount - oldTripleCount) + " new)");
                                Utility.logDebug("Time to add triples for violations: " + subTimer.duration()); 
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java
index 4239ccc..1664c99 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/MultiStageUpperProgram.java
@@ -1,254 +1,284 @@
 package uk.ac.ox.cs.pagoda.multistage;
-import java.io.BufferedWriter;
+import org.semanticweb.HermiT.model.*;
-import java.io.FileNotFoundException;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import java.io.FileOutputStream;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
-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 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.ExistConstantApproximator;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.Program;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.approximators.TupleDependentApproximator;
 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.pagoda.util.tuples.Tuple;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
-public abstract class MultiStageUpperProgram {
+import java.io.*;
-        
+import java.util.*;
-        Set<DLClause> constraints = new HashSet<DLClause>(); 
-        Set<DLClause> rules = new HashSet<DLClause>();
-        Collection<DLClause> clauses; 
-        BottomStrategy m_bottom = null; 
+public abstract class MultiStageUpperProgram {
-        Approximator m_approxExist = new OverApproxExist();
-        protected static final Variable X = Variable.create("X"); 
+        protected static final Variable X = Variable.create("X");
-        
+        Set<DLClause> constraints = new HashSet<DLClause>();
+        Set<DLClause> rules = new HashSet<DLClause>();
+        Collection<DLClause> clauses;
+        BottomStrategy m_bottom = null;
+        TupleDependentApproximator m_approxExist = new ExistConstantApproximator();
+        Map<DLClause, DLClause> map = new HashMap<DLClause, DLClause>();
+        Set<DLPredicate> updatedPredicates = new HashSet<DLPredicate>();
        private MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes;
-        Map<DLClause, DLClause> map = new HashMap<DLClause, DLClause>(); 
+        private StringBuilder datalogRuleText = new StringBuilder();
+        private Timer t = new Timer();
        
        public MultiStageUpperProgram(Program program, BottomStrategy upperBottom) {
-                m_bottom = upperBottom; 
+                m_bottom = upperBottom;
                clauses = getInitialClauses(program);
                Collection<DLClause> introducedConstraints = new LinkedList<DLClause>();
-                LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>(); 
+                LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
                for (DLClause clause: m_bottom.process(clauses)) {
-                        if (m_bottom.isBottomRule(clause) || clause.getHeadLength() == 1 && !(clause.getHeadAtom(0).getDLPredicate() instanceof AtLeast)) 
+                        if (m_bottom.isBottomRule(clause) || clause.getHeadLength() == 1 && !(clause.getHeadAtom(0).getDLPredicate() instanceof AtLeast))
-                                addDatalogRule(clause);                         
+                                addDatalogRule(clause);
                        else {
-                                newHeadAtoms.clear(); 
+                                newHeadAtoms.clear();
-                                boolean changed = false; 
+                                boolean changed = false;
                                for (Atom atom: clause.getHeadAtoms()) {
                                        if (atom.getDLPredicate() instanceof AtLeastConcept) {
-                                                AtLeastConcept atLeast = (AtLeastConcept) atom.getDLPredicate(); 
+                                                AtLeastConcept atLeast = (AtLeastConcept) atom.getDLPredicate();
                                                if (atLeast.getToConcept() instanceof AtomicNegationConcept) {
-                                                        AtomicConcept positive = ((AtomicNegationConcept) atLeast.getToConcept()).getNegatedAtomicConcept(); 
+                                                        AtomicConcept positive = ((AtomicNegationConcept) atLeast.getToConcept()).getNegatedAtomicConcept();
-                                                        AtomicConcept negative = OverApproxExist.getNegationConcept(positive); 
+                                                        AtomicConcept negative = OverApproxExist.getNegationConcept(positive);
                                                        Atom atom1 = Atom.create(positive, X);
                                                        Atom atom2 = Atom.create(negative, X);
-                                                        introducedConstraints.add(DLClause.create(new Atom[0], new Atom[] {atom1, atom2})); 
+                                                        introducedConstraints.add(DLClause.create(new Atom[0], new Atom[]{atom1, atom2}));
-                                                        newHeadAtoms.add( 
+                                                        newHeadAtoms.add(
                                                                        Atom.create(
-                                                                                        AtLeastConcept.create(atLeast.getArity(), atLeast.getOnRole(), negative), 
+                                                                                        AtLeastConcept.create(atLeast.getArity(), atLeast.getOnRole(), negative),
                                                                                        atom.getArgument(0)));
-                                                        changed = true; 
+                                                        changed = true;
-                                                        continue; 
+                                                        continue;
                                                }
                                        }
                                        else if (atom.getDLPredicate() instanceof AtLeastDataRange)
-                                                changed = true; 
+                                                changed = true;
-                                        else 
+                                        else
                                                newHeadAtoms.add(atom);
-                                        
                                }
                                if (!changed) constraints.add(clause);
                                else if (!newHeadAtoms.isEmpty()) {
-                                        DLClause newClause = DLClause.create(newHeadAtoms.toArray(new Atom[0]), clause.getBodyAtoms()); 
+                                        DLClause newClause = DLClause.create(newHeadAtoms.toArray(new Atom[0]), clause.getBodyAtoms());
-                                        map.put(newClause, getOriginalClause(clause)); 
+                                        map.put(newClause, getOriginalClause(clause));
-                                        constraints.add(newClause); 
+                                        constraints.add(newClause);
                                }
                        }
                }
-                
                for (DLClause clause: m_bottom.process(introducedConstraints))
                        addDatalogRule(clause);
        }
        
-        protected void addDatalogRule(DLClause clause) {
-                rules.add(clause); 
-                datalogRuleText.append(RuleHelper.getText(clause)).append(Utility.LINE_SEPARATOR);
-        }
-        
        public static Atom getNegativeAtom(Atom atom) {
-                if (atom.getDLPredicate() instanceof AtomicConcept) 
+                if (atom.getDLPredicate() instanceof AtomicConcept)
                        return Atom.create(OverApproxExist.getNegationConcept(atom.getDLPredicate()), atom.getArgument(0));
-                
                if (atom.getDLPredicate() instanceof Inequality)
-                        return Atom.create(Equality.INSTANCE, atom.getArgument(0), atom.getArgument(1)); 
+                        return Atom.create(Equality.INSTANCE, atom.getArgument(0), atom.getArgument(1));
-                
                if (atom.getDLPredicate() instanceof Equality || atom.getDLPredicate() instanceof AnnotatedEquality)
-                        return Atom.create(Inequality.INSTANCE, atom.getArgument(0), atom.getArgument(1));  
+                        return Atom.create(Inequality.INSTANCE, atom.getArgument(0), atom.getArgument(1));
-                                        
                return null;
        }
-        
-        private StringBuilder datalogRuleText = new StringBuilder(); 
+        public static AnswerTupleID project(AnswerTupleID tuple, String[] vars, String[] subVars) {
+                int subArity = 0;
+                for (int i = 0; i < subVars.length; ++i)
+                        if (subVars[i] != null) ++subArity;
+                if (tuple.getArity() == subArity)
+                        return tuple;
+                AnswerTupleID newTuple = new AnswerTupleID(subArity);
+                for (int i = 0, j = 0; i < vars.length; ++i)
+                        if (subVars[i] != null && !subVars[i].isEmpty()) {
+                                newTuple.setTerm(j++, tuple.getTerm(i));
+                        }
+                return newTuple;
+        }
+        public static String[] getVarSubset(String[] vars, Atom... atoms) {
+                String[] newVars = new String[vars.length];
+                Set<Variable> allVars = new HashSet<Variable>();
+                int arity;
+                for (Atom atom : atoms) {
+                        arity = atom.getArity();
+                        if (atom.getDLPredicate() instanceof AnnotatedEquality) arity = 2;
+                        for (int j = 0; j < arity; ++j)
+                                if (atom.getArgument(j) instanceof Variable) {
+                                        allVars.add(atom.getArgumentVariable(j));
+                                }
+                }
+                for (int i = 0; i < vars.length; ++i) {
+                        newVars[i] = allVars.contains(Variable.create(vars[i])) ? vars[i] : null;
+                }
+                return newVars;
+        }
+        public static String[] getCommonVars(DLClause clause) {
+                Set<Variable> headVars = getVariables(clause.getHeadAtoms());
+                Set<Variable> bodyVars = getVariables(clause.getBodyAtoms());
+                Collection<String> common = new LinkedList<String>();
+                for (Variable v : headVars)
+                        if (bodyVars.contains(v)) common.add(v.getName());
+                return common.toArray(new String[0]);
+        }
+        public static Set<Variable> getVariables(Atom[] atoms) {
+                Set<Variable> v = new HashSet<Variable>();
+                for (Atom atom : atoms) atom.getVariables(v);
+                return v;
+        }
+        protected void addDatalogRule(DLClause clause) {
+                rules.add(clause);
+                datalogRuleText.append(RuleHelper.getText(clause)).append(Utility.LINE_SEPARATOR);
+        }
        
        public String getDatalogRuleText() {
-                StringBuilder program = new StringBuilder(); 
+                StringBuilder program = new StringBuilder();
                program.append(prefixes.prefixesText());
-                program.append(datalogRuleText.toString()); 
+                program.append(datalogRuleText.toString());
                return program.toString();
        }
        protected void addDerivedPredicate(MultiStageQueryEngine engine) {
-                TupleIterator derivedTuples = null; 
+                TupleIterator derivedTuples = null;
                try {
-                        derivedTuples = engine.internal_evaluateAgainstIDBs("select distinct ?z where { ?x <" + Namespace.RDF_TYPE + "> ?z . }"); 
+                        derivedTuples = engine.internal_evaluateAgainstIDBs("select distinct ?z where { ?x <" + Namespace.RDF_TYPE + "> ?z . }");
                        for (long multi = derivedTuples.open(); multi != 0; multi = derivedTuples.getNext()) {
                                String p = prefixes.expandIRI(RDFoxTripleManager.getQuotedTerm(derivedTuples.getResource(0)));
-                                updatedPredicates.add(AtomicConcept.create(p)); 
+                                updatedPredicates.add(AtomicConcept.create(p));
                        }
                } catch (JRDFStoreException e) {
                        e.printStackTrace();
                } finally {
-                        if (derivedTuples != null) derivedTuples.dispose(); 
+                        if (derivedTuples != null) derivedTuples.dispose();
                }
-                
-                derivedTuples = null; 
+                derivedTuples = null;
                try {
-                        derivedTuples = engine.internal_evaluateAgainstIDBs("select distinct ?y where { ?x ?y ?z . }"); 
+                        derivedTuples = engine.internal_evaluateAgainstIDBs("select distinct ?y where { ?x ?y ?z . }");
                        for (long multi = derivedTuples.open(); multi != 0; multi = derivedTuples.getNext()) {
-                                String p = RDFoxTripleManager.getQuotedTerm(derivedTuples.getResource(0)); 
+                                String p = RDFoxTripleManager.getQuotedTerm(derivedTuples.getResource(0));
                                if (p.equals(Namespace.RDF_TYPE_ABBR) || p.equals(Namespace.RDF_TYPE_QUOTED)) ;
                                else if (p.equals(Namespace.EQUALITY_ABBR) || p.equals(Namespace.EQUALITY_QUOTED));
-                                else updatedPredicates.add(AtomicRole.create(prefixes.expandIRI(p))); 
+                                else updatedPredicates.add(AtomicRole.create(prefixes.expandIRI(p)));
                        }
                } catch (JRDFStoreException e) {
                        e.printStackTrace();
                } finally {
-                        if (derivedTuples != null) derivedTuples.dispose(); 
+                        if (derivedTuples != null) derivedTuples.dispose();
                }
        }
        public abstract Collection<Violation> isIntegrated(MultiStageQueryEngine engine, boolean incrementally);
-        
        protected Violation violate(MultiStageQueryEngine engine, DLClause clause, boolean incrementally) {
                Utility.logTrace("checking constraint: " + clause);
-                
-                String[] vars = getCommonVars(clause), subVars; 
+                String[] vars = getCommonVars(clause), subVars;
-                
                Set<AnswerTupleID> headAnswers = new HashSet<AnswerTupleID>();
                Set<Integer> rootAnswers = new HashSet<Integer>();
-                
                Set<Atom> restHeadAtoms = new HashSet<Atom>();
-                Atom rootAtom = null; 
+                Atom rootAtom = null;
                for (Atom atom: clause.getHeadAtoms())
-                        if (rootAtom == null && atom.getDLPredicate() instanceof AtomicConcept && atom.getArgument(0).equals(X)) 
+                        if (rootAtom == null && atom.getDLPredicate() instanceof AtomicConcept && atom.getArgument(0).equals(X))
-                                rootAtom = atom; 
+                                rootAtom = atom;
-                        else 
+                        else
-                                restHeadAtoms.add(atom); 
+                                restHeadAtoms.add(atom);
                if (rootAtom != null) {
-                        subVars = getVarSubset(vars, rootAtom); 
+                        subVars = getVarSubset(vars, rootAtom);
                        getHeadAnswers(engine, rootAtom, subVars, headAnswers);
-                        for (AnswerTupleID tuple: headAnswers) rootAnswers.add(tuple.getTerm(0)); 
+                        for (AnswerTupleID tuple : headAnswers) rootAnswers.add(tuple.getTerm(0));
                        headAnswers.clear();
                }
-                        
                if (incrementally) {
-                        boolean affected = false; 
+                        boolean affected = false;
                        for (Atom bodyAtom: clause.getBodyAtoms())
                                if (updatedPredicates.contains(bodyAtom.getDLPredicate())) {
-                                        affected = true; 
+                                        affected = true;
-                                        break; 
+                                        break;
                                }
-                        
                        for (Atom headAtom: clause.getHeadAtoms())
-                                if (headAtom.getDLPredicate() instanceof AtLeastConcept && 
+                                if (headAtom.getDLPredicate() instanceof AtLeastConcept &&
                                                ((AtomicConcept) ((AtLeastConcept) headAtom.getDLPredicate()).getToConcept()).getIRI().endsWith("_neg"))
                                        if (updatedPredicates.contains(OverApproxExist.getNegationConcept(((AtomicConcept) ((AtLeastConcept) headAtom.getDLPredicate()).getToConcept())))) {
-                                                affected = true; 
+                                                affected = true;
-                                                break; 
+                                                break;
                                        }
-                        
                        if (!affected) return null;
                }
-                
-                LinkedList<AnswerTupleID> bodyAnswers = getBodyAnswers(engine, clause, vars, rootAnswers); 
+                LinkedList<AnswerTupleID> bodyAnswers = getBodyAnswers(engine, clause, vars, rootAnswers);
                rootAnswers.clear();
-                
                Utility.logTrace("Time to compute body answers: " + t.duration() + "  number: " + bodyAnswers.size());
-                
                if (bodyAnswers.isEmpty()) return null;
-                
                t.reset();
-                
                for (Atom headAtom: restHeadAtoms) {
-//                      Timer subTimer = new Timer(); 
+//                      Timer subTimer = new Timer();
-                        subVars = getVarSubset(vars, headAtom); 
+                        subVars = getVarSubset(vars, headAtom);
-                        
                        // TODO: conditions check negative existential restrictions
 //                      if (false) {
-                        if (headAtom.getDLPredicate() instanceof AtLeastConcept && 
+                        if (headAtom.getDLPredicate() instanceof AtLeastConcept &&
                                        ((AtomicConcept) ((AtLeastConcept) headAtom.getDLPredicate()).getToConcept()).getIRI().endsWith("_neg")) {
-                                AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate(); 
+                                AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate();
-                                String x = null, y = "Y"; 
+                                String x = null, y = "Y";
                                for (String var: subVars)
                                        if (var != null) x = var;
-                                if (x == "Y") y = "X"; 
+                                if (x == "Y") y = "X";
                                Atom[] atoms = new Atom[2];
-                                if (alc.getOnRole() instanceof AtomicRole) 
+                                if (alc.getOnRole() instanceof AtomicRole)
                                        atoms[0] = Atom.create((AtomicRole) alc.getOnRole(), Variable.create(x), Variable.create(y));
-                                else 
+                                else
                                        atoms[0] = Atom.create(((InverseRole) alc.getOnRole()).getInverseOf(), Variable.create(y), Variable.create(x));
-                                
                                atoms[1] = Atom.create(OverApproxExist.getNegationConcept((AtomicConcept) ((AtLeastConcept) headAtom.getDLPredicate()).getToConcept()), Variable.create(y));
-                                Set<AnswerTupleID> addAnswers = new HashSet<AnswerTupleID>(); 
+                                Set<AnswerTupleID> addAnswers = new HashSet<AnswerTupleID>();
-                                TupleIterator tuples = null; 
+                                TupleIterator tuples = null;
                                try {
-                                        tuples = engine.internal_evaluateNotExpanded(SparqlHelper.getSPARQLQuery(new Atom[] {atoms[0]}, x, y)); 
+                                        tuples = engine.internal_evaluateNotExpanded(SparqlHelper.getSPARQLQuery(new Atom[]{atoms[0]}, x, y));
-                                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext()) 
+                                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext())
                                                addAnswers.add(new AnswerTupleID(tuples));
                                } catch (JRDFStoreException e) {
                                        e.printStackTrace();
                                } finally {
                                        if (tuples != null) tuples.dispose();
                                }
-                                
-                                tuples = null; 
+                                tuples = null;
                                try {
-                                        tuples = engine.internal_evaluateNotExpanded(SparqlHelper.getSPARQLQuery(atoms, x, y)); 
+                                        tuples = engine.internal_evaluateNotExpanded(SparqlHelper.getSPARQLQuery(atoms, x, y));
-                                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext()) 
+                                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext())
                                                addAnswers.remove(new AnswerTupleID(tuples));
                                } catch (JRDFStoreException e) {
                                        e.printStackTrace();
@@ -260,144 +290,95 @@ public abstract class MultiStageUpperProgram {
                                        headAnswers.add(project(tuple, new String[] {x, y}, new String[] {x, null}));
                                addAnswers.clear();
                        }
-                        
-                        getHeadAnswers(engine, headAtom, subVars, headAnswers); 
+                        getHeadAnswers(engine, headAtom, subVars, headAnswers);
-                        for (Iterator<AnswerTupleID> iter = bodyAnswers.iterator(); iter.hasNext(); ) 
+                        for (Iterator<AnswerTupleID> iter = bodyAnswers.iterator(); iter.hasNext(); )
                                if (headAnswers.contains(project(iter.next(), vars, subVars)))
                                        iter.remove();
                        headAnswers.clear();
                }
-                
                Utility.logTrace("Time to rule out all head answers: " + t.duration() + " rest number: " + bodyAnswers.size());
                if (bodyAnswers.isEmpty()) return null;
-                
-                return new Violation(clause, bodyAnswers, vars); 
+                return new Violation(clause, bodyAnswers, vars);
        }
        private void getHeadAnswers(MultiStageQueryEngine engine, Atom headAtom, String[] commonVars, Set<AnswerTupleID> headAnswers) {
-                String headQuery = SparqlHelper.getSPARQLQuery(new Atom[] { headAtom }, commonVars);
+                String headQuery = SparqlHelper.getSPARQLQuery(new Atom[]{headAtom}, commonVars);
-                TupleIterator tuples = null; 
+                TupleIterator tuples = null;
                try {
-                        tuples = engine.internal_evaluateNotExpanded(headQuery); 
+                        tuples = engine.internal_evaluateNotExpanded(headQuery);
-                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext()) 
+                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext())
                                headAnswers.add(new AnswerTupleID(tuples));
                } catch (JRDFStoreException e) {
                        e.printStackTrace();
                } finally {
                        if (tuples != null) tuples.dispose();
-                }               
+                }
        }
-        private Timer t = new Timer();
-        
        protected LinkedList<AnswerTupleID> getBodyAnswers(MultiStageQueryEngine engine, DLClause clause, String[] vars, Set<Integer> rootAnswers) { //, boolean incrementally) {
                Collection<int[]> validIndexes = new LinkedList<int[]>();
-                
-                int rootVarIndex = -1; 
+                int rootVarIndex = -1;
                for (int i = 0; i < vars.length; ++i)
-                        if (vars[i].equals("X")) { rootVarIndex = i; break; }   
+                        if (vars[i].equals("X")) {
-                
+                                rootVarIndex = i;
-                String[] subVars; 
+                                break;
+                        }
+                String[] subVars;
                for (Atom headAtom: clause.getHeadAtoms()) {
                        if ((headAtom.getDLPredicate() instanceof Equality || headAtom.getDLPredicate() instanceof AnnotatedEquality)
                                        &&  headAtom.getArgument(0) instanceof Variable && headAtom.getArgument(1) instanceof Variable) {
-                                int[] validIndex = new int[2]; 
+                                int[] validIndex = new int[2];
-                                subVars = getVarSubset(vars, headAtom); 
+                                subVars = getVarSubset(vars, headAtom);
                                for (int i = 0, j = 0; i < subVars.length; ++i)
                                        if (subVars[i] != null)
-                                                validIndex[j++] = i; 
+                                                validIndex[j++] = i;
-                                validIndexes.add(validIndex); 
+                                validIndexes.add(validIndex);
                        }
                }
-                
                t.reset();
-                
                LinkedList<AnswerTupleID> bodyAnswers = new LinkedList<AnswerTupleID>();
                String bodyQuery = SparqlHelper.getSPARQLQuery(clause.getBodyAtoms(), vars);
                TupleIterator bodyTuples = null;
-                
-                boolean filtered; 
+                boolean filtered;
                try {
-                        bodyTuples = engine.internal_evaluateNotExpanded(bodyQuery);                    
+                        bodyTuples = engine.internal_evaluateNotExpanded(bodyQuery);
                        for (long multi = bodyTuples.open(); multi != 0; multi = bodyTuples.getNext()) {
                                filtered = false;
-                                if (rootVarIndex >= 0 && rootAnswers.contains(bodyTuples.getResourceID(rootVarIndex))) continue; 
+                                if (rootVarIndex >= 0 && rootAnswers.contains(bodyTuples.getResourceID(rootVarIndex))) continue;
                                for (int[] validIndex: validIndexes)
                                        if (bodyTuples.getResourceID(validIndex[0]) == bodyTuples.getResourceID(validIndex[1])) {
-                                                filtered = true; 
+                                                filtered = true;
-                                                break; 
+                                                break;
                                        }
                                if (!filtered)
-                                        bodyAnswers.add(new AnswerTupleID(bodyTuples)); 
+                                        bodyAnswers.add(new AnswerTupleID(bodyTuples));
                        }
                } catch (JRDFStoreException e) {
                        e.printStackTrace();
                } finally {
                        if (bodyTuples != null) bodyTuples.dispose();
                }
-                        
-                validIndexes.clear();
-                Utility.logTrace("Time to get all body answers: " + t.duration()); 
-                return bodyAnswers; 
-        }
-        public static AnswerTupleID project(AnswerTupleID tuple, String[] vars, String[] subVars) {
-                int subArity = 0; 
-                for (int i = 0; i < subVars.length; ++i)
-                        if (subVars[i] != null) ++subArity; 
-                
-                if (tuple.getArity() == subArity) 
-                        return tuple;
-                
-                AnswerTupleID newTuple = new AnswerTupleID(subArity);
-                for (int i = 0, j = 0; i < vars.length; ++i)
-                        if (subVars[i] != null && !subVars[i].isEmpty()) {
-                                newTuple.setTerm(j++, tuple.getTerm(i)); 
-                        }
-                
-                return newTuple; 
-        }
-        public static String[] getVarSubset(String[] vars, Atom... atoms) {
-                String[] newVars = new String[vars.length];
-                Set<Variable> allVars = new HashSet<Variable>();
-                int arity; 
-                for (Atom atom: atoms) {
-                        arity = atom.getArity();
-                        if (atom.getDLPredicate() instanceof AnnotatedEquality) arity = 2; 
-                        for (int j = 0; j < arity; ++j)
-                                if (atom.getArgument(j) instanceof Variable) { 
-                                        allVars.add(atom.getArgumentVariable(j)); 
-                                }
-                }
-                 
-                for (int i = 0; i < vars.length; ++i) {
-                        newVars[i] = allVars.contains(Variable.create(vars[i])) ? vars[i] : null; 
-                }
-                
-                return newVars;
-        }
-        public static String[] getCommonVars(DLClause clause) {
-                Set<Variable> headVars = getVariables(clause.getHeadAtoms()); 
-                Set<Variable> bodyVars = getVariables(clause.getBodyAtoms()); 
-                Collection<String> common = new LinkedList<String>(); 
+                validIndexes.clear();
-                for (Variable v: headVars)
+                Utility.logTrace("Time to get all body answers: " + t.duration());
-                        if (bodyVars.contains(v)) common.add(v.getName()); 
+                return bodyAnswers;
-                        
-                return common.toArray(new String[0]);
        }
-        public static Set<Variable> getVariables(Atom[] atoms) {
+        public Collection<DLClause> convertExist(DLClause clause, DLClause originalDLClause) {
-                Set<Variable> v = new HashSet<Variable>(); 
+                return m_bottom.process(m_approxExist.convert(clause, originalDLClause, null));
-                for (Atom atom: atoms) atom.getVariables(v);
-                return v;
        }
-        public Collection<DLClause> convertExist(DLClause clause, DLClause originalDLClause) {
+        public Collection<DLClause> convertExist(DLClause clause, DLClause originalDLClause, Collection<Tuple<Individual>> violationTuples) {
-                return m_bottom.process(m_approxExist.convert(clause, originalDLClause)); 
+                return m_bottom.process(m_approxExist.convert(clause, originalDLClause, violationTuples));
        }
        public void save(String filename) {
@@ -414,11 +395,9 @@ public abstract class MultiStageUpperProgram {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
-                } 
+                }
        }
        
-        Set<DLPredicate> updatedPredicates = new HashSet<DLPredicate>(); 
-        
 //      public void addUpdatedPredicates(Set<DLPredicate> predicates) {
 //              for (Iterator<DLPredicate> iter = predicates.iterator(); iter.hasNext(); ) {
 //                      updatedPredicate.add(iter.next());
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java b/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java
index 4667747..c5482e7 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java
@@ -1,82 +1,93 @@
 package uk.ac.ox.cs.pagoda.multistage;
-import java.util.Collection;
+import org.semanticweb.HermiT.model.*;
-import java.util.HashMap;
+import org.semanticweb.owlapi.model.*;
-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.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.Constant;
-import org.semanticweb.HermiT.model.ConstantEnumeration;
-import org.semanticweb.HermiT.model.DLClause;
-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.Variable;
-import org.semanticweb.owlapi.model.OWLClass;
-import org.semanticweb.owlapi.model.OWLClassExpression;
-import org.semanticweb.owlapi.model.OWLDataHasValue;
-import org.semanticweb.owlapi.model.OWLDataProperty;
-import org.semanticweb.owlapi.model.OWLDataPropertyExpression;
-import org.semanticweb.owlapi.model.OWLLiteral;
-import org.semanticweb.owlapi.model.OWLObjectHasSelf;
-import org.semanticweb.owlapi.model.OWLObjectInverseOf;
-import org.semanticweb.owlapi.model.OWLObjectMinCardinality;
-import org.semanticweb.owlapi.model.OWLObjectProperty;
-import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
-import org.semanticweb.owlapi.model.OWLObjectSomeValuesFrom;
-import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.approx.Clause;
 import uk.ac.ox.cs.pagoda.approx.Clausifier;
 import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.approximators.SkolemTermsManager;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.util.*;
 public class Normalisation {
-        
-//      MultiStageUpperProgram m_program; 
+        public static final String auxiliaryConceptPrefix = Namespace.PAGODA_AUX + "concept_";
+        private static final Variable X = Variable.create("X"), Y = Variable.create("Y");
+        //      MultiStageUpperProgram m_program;
        OWLOntology m_ontology;
        BottomStrategy m_botStrategy;
        Collection<DLClause> m_rules;
        Set<DLClause> m_normClauses = new HashSet<DLClause>();
-        Map<DLClause, DLClause> exist2original = new HashMap<DLClause, DLClause>(); 
+        Map<DLClause, DLClause> exist2original = new HashMap<DLClause, DLClause>();
-        
+        Map<String, AtLeastConcept> rightAuxiliaryConcept = new HashMap<String, AtLeastConcept>();
+        private Map<AtLeastConcept, AtomicConcept> leftAuxiliaryConcept = new HashMap<AtLeastConcept, AtomicConcept>();
+        private Map<AtomicConcept, AtLeastConcept> leftAuxiliaryConcept_inv = new HashMap<AtomicConcept, AtLeastConcept>();
+        public Normalisation(Collection<DLClause> rules, OWLOntology ontology, BottomStrategy botStrategy) {
+//              m_program = program;
+                m_ontology = ontology;
+                m_rules = rules;
+                m_botStrategy = botStrategy;
+        }
+        public static AtLeastConcept toAtLeastConcept(AtLeast p) {
+                if (p instanceof AtLeastConcept) return (AtLeastConcept) p;
+                AtLeastDataRange aldr = (AtLeastDataRange) p;
+                return AtLeastConcept.create(aldr.getNumber(), aldr.getOnRole(), AtomicConcept.create(MyPrefixes.PAGOdAPrefixes.expandIRI(aldr.getToDataRange().toString())));
+        }
+        private static String getName(String iri) {
+                int index = iri.lastIndexOf("#");
+                if (index != -1) return iri.substring(index + 1);
+                index = iri.lastIndexOf("/");
+                if (index != -1) return iri.substring(index + 1);
+                return iri;
+        }
+        public static String getAuxiliaryConcept4Disjunct(AtLeastConcept alc, Individual... individuals) {
+                Role r = alc.getOnRole();
+                LiteralConcept c = alc.getToConcept();
+                StringBuilder builder = new StringBuilder(auxiliaryConceptPrefix);
+                if (r instanceof AtomicRole)
+                        builder.append(getName(((AtomicRole) r).getIRI()));
+                else
+                        builder.append(getName(((InverseRole) r).getInverseOf().getIRI())).append("_inv");
+                if (alc.getNumber() > 1)
+                        builder.append("_").append(alc.getNumber());
+                if (c instanceof AtomicConcept) {
+                        if (!c.equals(AtomicConcept.THING))
+                                builder.append("_").append(getName(((AtomicConcept) c).getIRI()));
+                } else
+                        builder.append("_").append(getName((OverApproxExist.getNegationConcept(((AtomicNegationConcept) c).getNegatedAtomicConcept()).getIRI())));
+                if (individuals.length > 1)
+                        builder.append("_").append(getName(individuals[0].getIRI()));
+                builder.append("_exist");
+                return builder.toString();
+        }
        public Set<DLClause> getNormlisedClauses() {
                return m_normClauses;
        }
-        
-        public Normalisation(Collection<DLClause> rules, OWLOntology ontology, BottomStrategy botStrategy) {
-//              m_program = program; 
-                m_ontology = ontology; 
-                m_rules = rules; 
-                m_botStrategy = botStrategy; 
-        }
-        
        public void process() {
-                for (DLClause clause: m_rules) 
+                for (DLClause clause : m_rules)
-                        if (m_botStrategy.isBottomRule(clause)) 
+                        if (m_botStrategy.isBottomRule(clause))
                                processBottomRule(clause);
                        else if (clause.getHeadLength() == 1) {
                                if (clause.getHeadAtom(0).getDLPredicate() instanceof AtLeast)
                                        processExistentialRule(clause);
-                                else 
+                                else
                                        m_normClauses.add(clause);
-                        }
+                        } else
-                        else 
                                processDisjunctiveRule(clause);
        }
        
@@ -85,75 +96,71 @@ public class Normalisation {
                        m_normClauses.add(clause);
                        return ;
                }
-                
-                Atom headAtom = clause.getHeadAtom(0); 
+                Atom headAtom = clause.getHeadAtom(0);
                if (headAtom.getDLPredicate() instanceof AtLeastDataRange) {
                        m_normClauses.add(clause);
                        return ;
                }
-                AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate(); 
+                AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate();
-                AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0));
+                // TODO test
-                DLClause newClause; 
+//              AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0));
+                AtomicConcept ac = getRightAuxiliaryConcept(alc, SkolemTermsManager.getInstance().getFreshIndividual(clause, 0));
+                DLClause newClause;
                m_normClauses.add(DLClause.create(new Atom[] {Atom.create(ac, headAtom.getArgument(0)) }, clause.getBodyAtoms()));
                m_normClauses.add(newClause = DLClause.create(new Atom[] {Atom.create(alc, X)}, new Atom[] {Atom.create(ac, X)}));
-                exist2original.put(newClause, clause); 
+                exist2original.put(newClause, clause);
-        }
-        
-        public static AtLeastConcept toAtLeastConcept(AtLeast p) {
-                if (p instanceof AtLeastConcept) return (AtLeastConcept) p; 
-                AtLeastDataRange aldr = (AtLeastDataRange) p; 
-                return AtLeastConcept.create(aldr.getNumber(), aldr.getOnRole(), AtomicConcept.create(MyPrefixes.PAGOdAPrefixes.expandIRI(aldr.getToDataRange().toString()))); 
        }
        private void processDisjunctiveRule(DLClause clause) {
-                boolean toNormalise = false; 
+                boolean toNormalise = false;
                for (Atom atom: clause.getHeadAtoms())
                        if (!(atom.getDLPredicate() instanceof AtomicConcept)) {
                                toNormalise = true;
-                                break; 
+                                break;
                        }
-                
                if (!toNormalise) {
                        m_normClauses.add(clause);
-                        return ; 
+                        return;
                }
-                
                Atom[] newHeadAtoms = new Atom[clause.getHeadLength()];
-                Set<Atom> additionalAtoms = new HashSet<Atom>(); 
+                Set<Atom> additionalAtoms = new HashSet<Atom>();
-                int index = 0; 
+                int index = 0;
-                DLClause newClause; 
+                DLClause newClause;
                for (Atom headAtom: clause.getHeadAtoms()) {
                        if (headAtom.getDLPredicate() instanceof AtLeast) {
                                AtLeast al = (AtLeast) headAtom.getDLPredicate();
                                if (al instanceof AtLeastDataRange && ((AtLeastDataRange) al).getToDataRange() instanceof ConstantEnumeration) {
                                        ConstantEnumeration ldr = (ConstantEnumeration) ((AtLeastDataRange) al).getToDataRange();
                                        newHeadAtoms[index] = null;
-                                        Atom newHeadAtom; 
+                                        Atom newHeadAtom;
                                        for (int i = 0; i < ldr.getNumberOfConstants(); ++i) {
-                                                newHeadAtom = Atom.create(AtomicRole.create(((AtomicRole) ((AtLeastDataRange) al).getOnRole()).getIRI()), headAtom.getArgument(0), ldr.getConstant(i));
+                                                newHeadAtom = Atom.create(AtomicRole.create(((AtomicRole) al.getOnRole()).getIRI()), headAtom.getArgument(0), ldr.getConstant(i));
-                                                if (newHeadAtoms[index] == null) newHeadAtoms[index] = newHeadAtom; 
+                                                if (newHeadAtoms[index] == null) newHeadAtoms[index] = newHeadAtom;
                                                else additionalAtoms.add(newHeadAtom);
-                                        }                                       
+                                        }
                                } else {
-                                        AtLeastConcept alc = toAtLeastConcept((AtLeast) headAtom.getDLPredicate()); 
+                                        AtLeastConcept alc = toAtLeastConcept((AtLeast) headAtom.getDLPredicate());
-                                        AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0)); 
+//                                      AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0));
+                                        AtomicConcept ac = getRightAuxiliaryConcept(alc, SkolemTermsManager.getInstance().getFreshIndividual(clause, 0));
                                        newHeadAtoms[index] = Atom.create(ac, headAtom.getArgument(0));
                                        m_normClauses.add(newClause = DLClause.create(new Atom[] {Atom.create(alc, headAtom.getArgument(0))}, new Atom[] {newHeadAtoms[index]}));
-                                        exist2original.put(newClause, clause); 
+                                        exist2original.put(newClause, clause);
                                }
-                        }
+                        } else
-                        else 
                                newHeadAtoms[index] = headAtom;
-                        ++index; 
+                        ++index;
                }
-                
                if (!additionalAtoms.isEmpty()) {
-                        Atom[] tempHeadAtoms = newHeadAtoms; 
+                        Atom[] tempHeadAtoms = newHeadAtoms;
                        newHeadAtoms = new Atom[newHeadAtoms.length + additionalAtoms.size()];
-                        for (int i = 0; i < tempHeadAtoms.length; ++i) 
+                        for (int i = 0; i < tempHeadAtoms.length; ++i)
                                newHeadAtoms[i] = tempHeadAtoms[i];
-                        int tempI = tempHeadAtoms.length; 
+                        int tempI = tempHeadAtoms.length;
-                        for (Iterator<Atom> iter = additionalAtoms.iterator(); iter.hasNext(); ) 
+                        for (Iterator<Atom> iter = additionalAtoms.iterator(); iter.hasNext(); )
                                newHeadAtoms[tempI++] = iter.next();
                        additionalAtoms.clear();
                }
@@ -169,202 +176,157 @@ public class Normalisation {
                                return ;
                        }
                }
-                
-                boolean toNormalise = false; 
+                boolean toNormalise = false;
                for (Atom atom: clause.getBodyAtoms())
                        if (!(atom.getDLPredicate() instanceof AtomicConcept))
-                                toNormalise = true; 
+                                toNormalise = true;
-                
-                if (!toNormalise) { 
+                if (!toNormalise) {
-                        m_normClauses.add(clause); 
+                        m_normClauses.add(clause);
-                        return ; 
+                        return;
                }
-                
-                Clause myClause = null; 
+                Clause myClause = null;
                try {
                        myClause = new Clause(Clausifier.getInstance(m_ontology), clause);
                } catch (Exception e) {
                        Utility.logError("The clause: " + clause + " cannot be rolled up into GCI.");
-                        m_normClauses.add(clause); 
+                        m_normClauses.add(clause);
-                        return ; 
+                        return;
                }
-                
                Atom[] newBodyAtoms = new Atom [myClause.getSubClasses().size()];
-                int index = 0; 
+                int index = 0;
                for (OWLClassExpression clsExp: myClause.getSubClasses())  {
-                        if (clsExp instanceof OWLClass) 
+                        if (clsExp instanceof OWLClass)
-                                newBodyAtoms[index] = Atom.create(AtomicConcept.create(((OWLClass) clsExp).getIRI().toString()), X); 
+                                newBodyAtoms[index] = Atom.create(AtomicConcept.create(((OWLClass) clsExp).getIRI().toString()), X);
                        else if (clsExp instanceof OWLObjectSomeValuesFrom || clsExp instanceof OWLObjectMinCardinality) {
-                                int number; 
+                                int number;
-                                OWLObjectPropertyExpression prop; 
+                                OWLObjectPropertyExpression prop;
                                OWLClassExpression filler;
                                if (clsExp instanceof OWLObjectSomeValuesFrom) {
                                        OWLObjectSomeValuesFrom owl = (OWLObjectSomeValuesFrom) clsExp;
-                                        number = 1; 
+                                        number = 1;
                                        prop = owl.getProperty();
-                                        filler = owl.getFiller(); 
+                                        filler = owl.getFiller();
                                }
                                else {
-                                        OWLObjectMinCardinality owl = (OWLObjectMinCardinality) clsExp; 
+                                        OWLObjectMinCardinality owl = (OWLObjectMinCardinality) clsExp;
-                                        number = owl.getCardinality(); 
+                                        number = owl.getCardinality();
-                                        prop = owl.getProperty(); 
+                                        prop = owl.getProperty();
-                                        filler = owl.getFiller(); 
+                                        filler = owl.getFiller();
                                }
-                                
-                                Role r = null; 
+                                Role r = null;
-                                if (prop instanceof OWLObjectProperty) 
+                                if (prop instanceof OWLObjectProperty)
                                        r = AtomicRole.create(((OWLObjectProperty) prop).getIRI().toString());
-                                else  
+                                else
                                        r = InverseRole.create(AtomicRole.create(((OWLObjectProperty) (((OWLObjectInverseOf) prop).getInverse())).getIRI().toString()));
-                                
                                LiteralConcept c = AtomicConcept.create(((OWLClass) filler).getIRI().toString());
                                AtomicConcept ac = getLeftAuxiliaryConcept(AtLeastConcept.create(number, r, c), false);
-                                
-                                m_normClauses.add(exists_r_C_implies_A(number, r, c, ac)); 
+                                m_normClauses.add(exists_r_C_implies_A(number, r, c, ac));
                                newBodyAtoms[index] = Atom.create(ac, X);
                        }
 //                      else if (clsExp instanceof OWLDataSomeValuesFrom || clsExp instanceof OWLDataMinCardinality) {
-//                              int number; 
+//                              int number;
-//                              OWLDataPropertyExpression prop; 
+//                              OWLDataPropertyExpression prop;
 //                              OWLDataRange filler;
 //                              if (clsExp instanceof OWLDataSomeValuesFrom) {
 //                                      OWLDataSomeValuesFrom owl = (OWLDataSomeValuesFrom) clsExp;
-//                                      number = 1; 
+//                                      number = 1;
 //                                      prop = owl.getProperty();
-//                                      filler = owl.getFiller(); 
+//                                      filler = owl.getFiller();
 //                              }
 //                              else {
-//                                      OWLDataMinCardinality owl = (OWLDataMinCardinality) clsExp; 
+//                                      OWLDataMinCardinality owl = (OWLDataMinCardinality) clsExp;
-//                                      number = owl.getCardinality(); 
+//                                      number = owl.getCardinality();
-//                                      prop = owl.getProperty(); 
+//                                      prop = owl.getProperty();
-//                                      filler = owl.getFiller(); 
+//                                      filler = owl.getFiller();
 //                              }
-//                              
+//
 //                              Role r = AtomicRole.create(((OWLDataProperty) prop).getIRI().toString());
-//                              
+//
 //                              LiteralConcept c = AtomicConcept.create(((OWLClass) filler).getIRI().toString());
 //                              AtomicConcept ac = getLeftAuxiliaryConcept(AtLeastConcept.create(number, r, c), false);
-//                              
+//
-//                              m_normClauses.add(exists_r_C_implies_A(number, r, c, ac)); 
+//                              m_normClauses.add(exists_r_C_implies_A(number, r, c, ac));
 //                              newBodyAtoms[index] = Atom.create(ac, X);
 //                      }
                        else if (clsExp instanceof OWLObjectHasSelf) {
                                OWLObjectPropertyExpression prop = ((OWLObjectHasSelf) clsExp).getProperty();
-                                AtomicRole r; 
+                                AtomicRole r;
-                                if (prop instanceof OWLObjectProperty) 
+                                if (prop instanceof OWLObjectProperty)
                                        r = AtomicRole.create(((OWLObjectProperty) prop).getIRI().toString());
-                                else  
+                                else
                                        r = AtomicRole.create(((OWLObjectProperty) (((OWLObjectInverseOf) prop).getInverse())).getIRI().toString());
-                                newBodyAtoms[index] = Atom.create(r, X, X);  
+                                newBodyAtoms[index] = Atom.create(r, X, X);
                        }
                        else if (clsExp instanceof OWLDataHasValue) {
-                                OWLDataPropertyExpression prop = ((OWLDataHasValue) clsExp).getProperty(); 
+                                OWLDataPropertyExpression prop = ((OWLDataHasValue) clsExp).getProperty();
                                AtomicRole r = AtomicRole.create(((OWLDataProperty) prop).getIRI().toString());
                                OWLLiteral l =  ((OWLDataHasValue) clsExp).getValue();
                                if (l.getDatatype().toStringID().equals(Namespace.RDF_PLAIN_LITERAL))
-                                        newBodyAtoms[index] = Atom.create(r, X, Constant.create(l.getLiteral() + "@" + l.getLang(), Namespace.RDF_PLAIN_LITERAL));  
+                                        newBodyAtoms[index] = Atom.create(r, X, Constant.create(l.getLiteral() + "@" + l.getLang(), Namespace.RDF_PLAIN_LITERAL));
-                                else 
+                                else
-                                        newBodyAtoms[index] = Atom.create(r, X, Constant.create(l.getLiteral(), l.getDatatype().toStringID()));  
+                                        newBodyAtoms[index] = Atom.create(r, X, Constant.create(l.getLiteral(), l.getDatatype().toStringID()));
-                        }
+                        } else {
-                        else { 
                                newBodyAtoms[index] = null;
                                Utility.logError("counld not translate OWLClassExpression: " + clsExp + " in " + clause);
                        }
-                        ++index; 
+                        ++index;
                }
-                
                m_normClauses.add(DLClause.create(clause.getHeadAtoms(), newBodyAtoms));
        }
        
-        private static final Variable X = Variable.create("X"), Y = Variable.create("Y");
-        
        private DLClause exists_r_C_implies_A(int n, Role r, LiteralConcept c, AtomicConcept a) {
-                Variable[] Ys = new Variable[n]; 
+                Variable[] Ys = new Variable[n];
-                if (n == 1) Ys[0] = Y; 
+                if (n == 1) Ys[0] = Y;
-                else 
+                else
                        for (int i = 0; i < n; ++i)
                                Ys[i] = Variable.create("Y" + (i + 1));
-                Collection<Atom> bodyAtoms = new LinkedList<Atom>(); 
+                Collection<Atom> bodyAtoms = new LinkedList<Atom>();
-                
                for (int i = 0; i < n; ++i) {
-                        Atom rxy = r instanceof AtomicRole ? 
+                        Atom rxy = r instanceof AtomicRole ?
-                                        Atom.create(((AtomicRole) r), X, Ys[i]) : 
+                                        Atom.create(((AtomicRole) r), X, Ys[i]) :
                                                Atom.create(((InverseRole) r).getInverseOf(), Ys[i], X);
-                        bodyAtoms.add(rxy); 
+                        bodyAtoms.add(rxy);
                        if (!c.equals(AtomicConcept.THING))
                                bodyAtoms.add(Atom.create((AtomicConcept) c, Ys[i]));
                }
-                
                for (int i = 0; i < n; ++i)
                        for (int j = i + 1; j < n; ++j)
-                                bodyAtoms.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j])); 
+                                bodyAtoms.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j]));
-                
-                return DLClause.create(new Atom[] {Atom.create(a, X)}, bodyAtoms.toArray(new Atom[0])); 
-        }
-        
-        private Map<AtLeastConcept, AtomicConcept> leftAuxiliaryConcept = new HashMap<AtLeastConcept, AtomicConcept>(); 
-        private Map<AtomicConcept, AtLeastConcept> leftAuxiliaryConcept_inv = new HashMap<AtomicConcept, AtLeastConcept>();
-        
-        public static final String auxiliaryConceptPrefix = Namespace.PAGODA_AUX + "concept_"; 
-        private static String getName(String iri) {
+                return DLClause.create(new Atom[]{Atom.create(a, X)}, bodyAtoms.toArray(new Atom[0]));
-                int index = iri.lastIndexOf("#"); 
-                if (index != -1) return iri.substring(index + 1); 
-                index = iri.lastIndexOf("/"); 
-                if (index != -1) return iri.substring(index + 1); 
-                return iri;
        }
-        
        private AtomicConcept getRightAuxiliaryConcept(AtLeastConcept alc, Individual... individuals) {
                String iri = getAuxiliaryConcept4Disjunct(alc, individuals);
-                rightAuxiliaryConcept.put(iri, alc); 
+                rightAuxiliaryConcept.put(iri, alc);
-                return AtomicConcept.create(iri); 
+                return AtomicConcept.create(iri);
-        }
-        
-        public static String getAuxiliaryConcept4Disjunct(AtLeastConcept alc, Individual... individuals) {
-                Role r = alc.getOnRole(); 
-                LiteralConcept c = alc.getToConcept();
-                StringBuilder builder = new StringBuilder(auxiliaryConceptPrefix); 
-                if (r instanceof AtomicRole)
-                        builder.append(getName(((AtomicRole) r).getIRI()));
-                else 
-                        builder.append(getName(((InverseRole) r).getInverseOf().getIRI())).append("_inv");
-                
-                if (alc.getNumber() > 1)
-                        builder.append("_").append(alc.getNumber()); 
-                        
-                if (c instanceof AtomicConcept) {
-                        if (!c.equals(AtomicConcept.THING))
-                                builder.append("_").append(getName(((AtomicConcept) c).getIRI())); 
-                }
-                else 
-                        builder.append("_").append(getName((OverApproxExist.getNegationConcept(((AtomicNegationConcept) c).getNegatedAtomicConcept()).getIRI())));
-                
-                if (individuals.length > 1)
-                        builder.append("_").append(getName(individuals[0].getIRI()));
-                
-                builder.append("_exist");
-                
-                return builder.toString(); 
        }
        public AtomicConcept getLeftAuxiliaryConcept(AtLeastConcept key, boolean available) {
-//              AtLeastConcept key = AtLeastConcept.create(1, r, c); 
+//              AtLeastConcept key = AtLeastConcept.create(1, r, c);
-                AtomicConcept value = null; 
+                AtomicConcept value = null;
-                if ((value = leftAuxiliaryConcept.get(key)) != null);  
+                if ((value = leftAuxiliaryConcept.get(key)) != null) ;
                else if (!available) {
                        value = AtomicConcept.create(getAuxiliaryConcept4Disjunct(key));
-                        leftAuxiliaryConcept.put(key, value); 
+                        leftAuxiliaryConcept.put(key, value);
                        leftAuxiliaryConcept_inv.put(value, key);
                }
-                return value; 
+                return value;
        }
        public AtLeastConcept getLeftAtLeastConcept(AtomicConcept value) {
-                return leftAuxiliaryConcept_inv.get(value); 
+                return leftAuxiliaryConcept_inv.get(value);
        }
-        
-        Map<String, AtLeastConcept> rightAuxiliaryConcept = new HashMap<String, AtLeastConcept>(); 
        public AtLeastConcept getRightAtLeastConcept(AtomicConcept p) {
                return rightAuxiliaryConcept.get(p.getIRI());
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication.java b/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication.java
index f8e6524..b16e645 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 org.semanticweb.HermiT.model.*;
-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 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;
@@ -30,58 +22,48 @@ public class RestrictedApplication extends MultiStageUpperProgram {
                clauses.addAll(constraints); 
        }
-        private void addNegativeDatalogRules() {
+        // It should be shifting
-                Collection<DLClause> allRules = new LinkedList<DLClause>(rules); 
+        public static Collection<DLClause> addAdditionalDatalogRules(DLClause clause, BottomStrategy bottom, Normalisation norm) {
-                allRules.addAll(constraints); 
+                LinkedList<DLClause> newClauses = new LinkedList<DLClause>();
-                for (DLClause clause: allRules) {
+                Atom[] headAtoms = clause.getHeadAtoms();
-                        for (DLClause newClause: addAddtionalDatalogRules(clause, m_bottom, norm))
+                Atom[] bodyAtoms = clause.getBodyAtoms();
-                                addDatalogRule(newClause);
+                int headLength = headAtoms.length;
-                }
-                allRules.clear();
-        }
-        
-        public static Collection<DLClause> addAddtionalDatalogRules(DLClause clause, BottomStrategy bottom, Normalisation norm) {
-                LinkedList<DLClause> newClauses = new LinkedList<DLClause>(); 
-                Atom[] headAtoms = clause.getHeadAtoms(); 
-                Atom[] bodyAtoms = clause.getBodyAtoms(); 
-                int headLength = headAtoms.length; 
                int bodyLength = bodyAtoms.length;
-                DLClause tClause; 
+                DLClause tClause;
-                if (bottom.isBottomRule(clause)) { 
+                if (bottom.isBottomRule(clause)) {
-                        if (clause.getBodyLength() == 1) return newClauses; 
+                        if (clause.getBodyLength() == 1) return newClauses;
                        for (int i = 0; i < bodyLength; ++i) {
                                if (bodyAtoms[i].getDLPredicate() instanceof AtomicConcept) {
-                                        AtomicConcept ac = (AtomicConcept) bodyAtoms[i].getDLPredicate(); 
+                                        AtomicConcept ac = (AtomicConcept) bodyAtoms[i].getDLPredicate();
                                        if (!ac.getIRI().endsWith("_exist")) {
                                                Atom[] newBodyAtoms = new Atom[bodyLength - 1];
                                                for (int j = 0; j < bodyLength - 1; ++j)
                                                        newBodyAtoms[j] = j < i ? bodyAtoms[j] : bodyAtoms[j + 1];
-                                                        
                                                Atom negativeAtom = getNegativeAtom(bodyAtoms[i]);
                                                tClause = DLClause.create(new Atom[] { negativeAtom }, newBodyAtoms);
        //                                      addDatalogRule(tClause);
                                                newClauses.add(tClause);
-                                        }
+                                        } else {
-                                        else { 
                                                Atom[] newBodyAtoms = new Atom[bodyLength];
-                                                Atom negativeAtom = null; 
+                                                Atom negativeAtom = null;
-                                                org.semanticweb.HermiT.model.Variable E = org.semanticweb.HermiT.model.Variable.create("E"); 
+                                                org.semanticweb.HermiT.model.Variable E = org.semanticweb.HermiT.model.Variable.create("E");
                                                AtLeastConcept alc = norm.getLeftAtLeastConcept(ac);
-                                                
                                                if (alc.getOnRole() instanceof AtomicRole)
                                                        newBodyAtoms[i] = Atom.create((AtomicRole) alc.getOnRole(), bodyAtoms[i].getArgument(0), E);
-                                                else 
+                                                else
                                                        newBodyAtoms[i] = Atom.create(((InverseRole) alc.getOnRole()).getInverseOf(), E, bodyAtoms[i].getArgument(0));
                                                if (alc.getToConcept() instanceof AtomicConcept)
                                                        negativeAtom = getNegativeAtom(Atom.create((AtomicConcept) alc.getToConcept(), E));
-                                                else 
+                                                else
                                                        negativeAtom = getNegativeAtom(Atom.create(((AtomicNegationConcept) alc.getToConcept()).getNegatedAtomicConcept(), E));
-                                                
-                                                for (int j = 0; j < bodyLength; ++j) 
+                                                for (int j = 0; j < bodyLength; ++j)
                                                        if (i != j)
-                                                                newBodyAtoms[j] = bodyAtoms[j]; 
+                                                                newBodyAtoms[j] = bodyAtoms[j];
-                                                        
                                                tClause = DLClause.create(new Atom[] { negativeAtom }, newBodyAtoms);
        //                                      addDatalogRule(tClause);
                                                newClauses.add(tClause);
@@ -91,55 +73,65 @@ public class RestrictedApplication extends MultiStageUpperProgram {
                }
                else if (headLength > 1) {
                        for (int i = 0; i < headLength; ++i) {
-                                DLPredicate p = headAtoms[i].getDLPredicate(); 
+                                DLPredicate p = headAtoms[i].getDLPredicate();
                                if (!(p instanceof AtomicConcept)) {
-                                        return newClauses; 
+                                        return newClauses;
                                }
                        }
                        for (int i = 0; i < headLength; ++i) {
-                                Atom[] newBodyAtoms = new Atom[headLength + bodyLength - 1]; 
+                                Atom[] newBodyAtoms = new Atom[headLength + bodyLength - 1];
                                for (int j = 0; j < headLength + bodyLength - 1; ++j)
-                                        newBodyAtoms[j] = j < bodyLength ?  bodyAtoms[j] : 
+                                        newBodyAtoms[j] = j < bodyLength ? bodyAtoms[j] :
-                                                                                j < bodyLength + i ? getNegativeAtom(headAtoms[j - bodyLength]) : 
+                                                        j < bodyLength + i ? getNegativeAtom(headAtoms[j - bodyLength]) :
-                                                                                        getNegativeAtom(headAtoms[j - bodyLength + 1]); 
+                                                                        getNegativeAtom(headAtoms[j - bodyLength + 1]);
-                                tClause = DLClause.create(new Atom[] { headAtoms[i] }, newBodyAtoms); 
+                                tClause = DLClause.create(new Atom[]{headAtoms[i]}, newBodyAtoms);
 //                              addDatalogRule(tClause);
                                newClauses.add(tClause);
                        }
                }
                else if (headLength == 1) {
-                        DLPredicate p = clause.getHeadAtom(0).getDLPredicate();  
+                        DLPredicate p = clause.getHeadAtom(0).getDLPredicate();
                        if (p instanceof AtomicConcept) {
-                                Atom negativeHeadAtom = getNegativeAtom(clause.getHeadAtom(0)); 
+                                Atom negativeHeadAtom = getNegativeAtom(clause.getHeadAtom(0));
-                                for (int i = 0; i < bodyLength; ++i) 
+                                for (int i = 0; i < bodyLength; ++i)
-                                        if (bodyAtoms[i].getDLPredicate() instanceof AtomicConcept) { 
+                                        if (bodyAtoms[i].getDLPredicate() instanceof AtomicConcept) {
                                                Atom[] newBodyAtoms = new Atom[clause.getBodyLength()];
-                                                newBodyAtoms[0] = negativeHeadAtom; 
+                                                newBodyAtoms[0] = negativeHeadAtom;
                                                for (int j = 1; j < bodyLength; ++j)
                                                        newBodyAtoms[j] = j <= i ? bodyAtoms[j - 1] : bodyAtoms[j];
-                                                        
-                                                tClause = DLClause.create(new Atom[] {getNegativeAtom(bodyAtoms[i])}, newBodyAtoms); 
+                                                tClause = DLClause.create(new Atom[]{getNegativeAtom(bodyAtoms[i])}, newBodyAtoms);
 //                                              addDatalogRule(tClause);
                                                newClauses.add(tClause);
                                        }
                        }
                        else if (p instanceof AtLeastConcept && clause.getBodyLength() == 1 && clause.getBodyAtom(0).getDLPredicate() instanceof AtomicConcept) {
-                                AtLeastConcept alc = (AtLeastConcept) p; 
+                                AtLeastConcept alc = (AtLeastConcept) p;
-                                AtomicConcept ac = norm.getLeftAuxiliaryConcept(alc, true); 
+                                AtomicConcept ac = norm.getLeftAuxiliaryConcept(alc, true);
                                if (ac != null) {
-                                        Atom bodyAtom = clause.getBodyAtom(0);  
+                                        Atom bodyAtom = clause.getBodyAtom(0);
-//                                      addDatalogRule(DLClause.create(new Atom[] {getNegativeAtom(bodyAtom)}, 
+//                                      addDatalogRule(DLClause.create(new Atom[] {getNegativeAtom(bodyAtom)},
 //                                                      new Atom[] {getNegativeAtom(Atom.create(ac, bodyAtom.getArgument(0)))} ));
-                                        newClauses.add(DLClause.create(new Atom[] {getNegativeAtom(bodyAtom)}, 
+                                        newClauses.add(DLClause.create(new Atom[]{getNegativeAtom(bodyAtom)},
-                                                        new Atom[] {getNegativeAtom(Atom.create(ac, bodyAtom.getArgument(0)))} )); 
+                                                                                                   new Atom[]{getNegativeAtom(Atom.create(ac, bodyAtom.getArgument(0)))}));
                                }
                        }
                }
                return newClauses;
        }
+        private void addNegativeDatalogRules() {
+                Collection<DLClause> allRules = new LinkedList<DLClause>(rules);
+                allRules.addAll(constraints);
+                for (DLClause clause : allRules) {
+                        for (DLClause newClause : addAdditionalDatalogRules(clause, m_bottom, norm))
+                                addDatalogRule(newClause);
+                }
+                allRules.clear();
+        }
        public Normalisation getNormalisation() {
                return norm; 
        }
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication2.java b/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication2.java
deleted file mode 100644
index 66e8a17..0000000
--- a/src/uk/ac/ox/cs/pagoda/multistage/RestrictedApplication2.java
+++ /dev/null
@@ -1,177 +0,0 @@
-package uk.ac.ox.cs.pagoda.multistage;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Comparator;
-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.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
-import uk.ac.ox.cs.pagoda.multistage.treatement.SimpleComparator;
-import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
-import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
-import uk.ac.ox.cs.pagoda.rules.Program;
-public class RestrictedApplication2 extends TwoStageApplication {
-        private Normalisation norm;
-        private boolean hasDisjunctions;
-        private Comparator<Atom> disjunctComparator;
-        
-        public RestrictedApplication2(TwoStageQueryEngine engine, DatalogProgram program, GapByStore4ID gap) {
-                super(engine, program, gap);
-                if (hasDisjunctions) {
-                        addNegativeDatalogRules(); 
-                        disjunctComparator = new SimpleComparator();
-                }
-        }
-        private void addNegativeDatalogRules() {
-                Collection<DLClause> allRules = new LinkedList<DLClause>(rules); 
-                allRules.addAll(constraints); 
-                for (DLClause clause: allRules) {
-                        addAddtionalDatalogRules(clause);
-                }
-                allRules.clear();
-        }
-        
-        private void addAddtionalDatalogRules(DLClause clause) {
-                Atom[] headAtoms = clause.getHeadAtoms(); 
-                Atom[] bodyAtoms = clause.getBodyAtoms(); 
-                int headLength = headAtoms.length; 
-                int bodyLength = bodyAtoms.length;
-                DLClause tClause; 
-                if (m_bottom.isBottomRule(clause)) { 
-                        if (clause.getBodyLength() == 1) return ; 
-                        for (int i = 0; i < bodyLength; ++i) 
-                                if (bodyAtoms[i].getDLPredicate() instanceof AtomicConcept) { 
-                                        Atom[] newBodyAtoms = new Atom[bodyLength - 1];
-                                        for (int j = 0; j < bodyLength - 1; ++j)
-                                                newBodyAtoms[j] = j < i ? bodyAtoms[j] : bodyAtoms[j + 1];
-                                                
-                                        Atom negativeAtom = MultiStageUpperProgram.getNegativeAtom(bodyAtoms[i]);
-                                        tClause = DLClause.create(new Atom[] { negativeAtom }, newBodyAtoms); 
-                                        addDatalogRule(tClause);
-                                }
-                }
-                else if (headLength > 1) {
-                        for (int i = 0; i < headLength; ++i) {
-                                DLPredicate p = headAtoms[i].getDLPredicate(); 
-                                if (!(p instanceof AtomicConcept)) {
-                                        return ; 
-                                }
-                        }
-                        for (int i = 0; i < headLength; ++i) {
-                                Atom[] newBodyAtoms = new Atom[headLength + bodyLength - 1]; 
-                                for (int j = 0; j < headLength + bodyLength - 1; ++j)
-                                        newBodyAtoms[j] = j < bodyLength ?  bodyAtoms[j] : 
-                                                                                j < bodyLength + i ? MultiStageUpperProgram.getNegativeAtom(headAtoms[j - bodyLength]) : 
-                                                                                        MultiStageUpperProgram.getNegativeAtom(headAtoms[j - bodyLength + 1]); 
-                                tClause = DLClause.create(new Atom[] { headAtoms[i] }, newBodyAtoms); 
-                                addDatalogRule(tClause);
-                        }
-                }
-                else if (headLength == 1) {
-                        DLPredicate p = clause.getHeadAtom(0).getDLPredicate();  
-                        if (p instanceof AtomicConcept) {
-                                Atom negativeHeadAtom = MultiStageUpperProgram.getNegativeAtom(clause.getHeadAtom(0)); 
-                                for (int i = 0; i < bodyLength; ++i) 
-                                        if (bodyAtoms[i].getDLPredicate() instanceof AtomicConcept) { 
-                                                Atom[] newBodyAtoms = new Atom[clause.getBodyLength()];
-                                                newBodyAtoms[0] = negativeHeadAtom; 
-                                                for (int j = 1; j < bodyLength; ++j)
-                                                        newBodyAtoms[j] = j <= i ? bodyAtoms[j - 1] : bodyAtoms[j];
-                                                        
-                                                tClause = DLClause.create(new Atom[] {MultiStageUpperProgram.getNegativeAtom(bodyAtoms[i])}, newBodyAtoms); 
-                                                addDatalogRule(tClause);
-                                        }
-                        }
-                        else if (p instanceof AtLeastConcept && clause.getBodyLength() == 1 && clause.getBodyAtom(0).getDLPredicate() instanceof AtomicConcept) {
-                                AtLeastConcept alc = (AtLeastConcept) p; 
-                                AtomicConcept ac = norm.getLeftAuxiliaryConcept(alc, true); 
-                                if (ac != null) {
-                                        Atom bodyAtom = clause.getBodyAtom(0);  
-                                        addDatalogRule(DLClause.create(new Atom[] {MultiStageUpperProgram.getNegativeAtom(bodyAtom)}, 
-                                                        new Atom[] {MultiStageUpperProgram.getNegativeAtom(Atom.create(ac, bodyAtom.getArgument(0)))} )); 
-                                }
-                        }
-                }
-        }
-        @Override
-        protected void addAuxiliaryRules() {
-                for (DLClause constraint: constraints) 
-                        if (constraint.getHeadLength() <= 1) 
-                                processExistentialRule(constraint); 
-                        else 
-                                processDisjunctiveRule(constraint); 
-        }
-        private static final Atom[] empty = new Atom[0];
-        
-        private void processDisjunctiveRule(DLClause constraint) {
-                int headLength = constraint.getHeadLength(); 
-                Atom[] orderedAtoms = new Atom[headLength]; 
-                for (int i = 0; i < headLength; ++i)
-                        orderedAtoms[i] = constraint.getHeadAtom(i); 
-                                
-                Arrays.sort(orderedAtoms, disjunctComparator);
-                
-                Collection<Atom> bodyAtoms = new LinkedList<Atom>();
-                for (int i = 0; i < headLength; ++i) {
-                        bodyAtoms.add(getNAFAtom(orderedAtoms[i])); 
-                }
-                for (Atom atom: constraint.getBodyAtoms())
-                        bodyAtoms.add(atom); 
-                
-                Atom negAtom; 
-                for (Atom atom: constraint.getHeadAtoms()) {
-                        negAtom = MultiStageUpperProgram.getNegativeAtom(atom); 
-                        bodyAtoms.add(getNAFAtom(negAtom));
-                        addDatalogRule(DLClause.create(new Atom[] {atom}, bodyAtoms.toArray(empty)));
-                }
-        }
-        private void processExistentialRule(DLClause constraint) {
-                Atom[] bodyAtoms = new Atom[constraint.getBodyLength() + 1]; 
-                bodyAtoms[0] = getNAFAtom(constraint.getHeadAtom(0)); 
-                int i = 0; 
-                for (Atom atom: constraint.getBodyAtoms())
-                        bodyAtoms[++i] = atom; 
-                
-                Collection<DLClause> overClauses = overExist.convert(constraint, getOriginalClause(constraint)); 
-                for (DLClause clause: overClauses) 
-                        if (DLClauseHelper.hasSubsetBodyAtoms(clause, constraint))
-                                addDatalogRule(DLClause.create(new Atom[] {clause.getHeadAtom(0)}, bodyAtoms));
-        }
-        @Override
-        protected Collection<DLClause> getInitialClauses(Program program) {
-                Collection<DLClause> clauses = program.getClauses();
-                hasDisjunctions = false; 
-                for (DLClause clause: clauses)
-                        if (clause.getHeadLength() > 1) {
-                                hasDisjunctions = true; 
-                                break; 
-                        }
-                
-                if (hasDisjunctions) {
-                        norm = new Normalisation(clauses, program.getOntology(), m_bottom);
-                        norm.process();
-                        clauses = norm.m_normClauses; 
-                }
-                return clauses;
-        }
-        
-        protected DLClause getOriginalClause(DLClause clause) {
-                DLClause original = super.getOriginalClause(clause); 
-                return norm.getOriginalClause(original); 
-        }
-}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/StageQueryEngine.java b/src/uk/ac/ox/cs/pagoda/multistage/StageQueryEngine.java
index 5d2e0d1..e652f66 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/StageQueryEngine.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/StageQueryEngine.java
@@ -8,23 +8,24 @@ import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Utility;
 public abstract class StageQueryEngine extends BasicQueryEngine {
-        
-        protected boolean checkValidity; 
+        protected boolean checkValidity;
-        
+        Boolean validMaterialisation = null;
        public StageQueryEngine(String name, boolean checkValidity) {
                super(name);
-                this.checkValidity = checkValidity; 
+                this.checkValidity = checkValidity;
        }
-        public abstract void materialiseFoldedly(DatalogProgram dProgram, GapByStore4ID gap); 
+        public abstract void materialiseFoldedly(DatalogProgram dProgram, GapByStore4ID gap);
-        
-        public abstract int materialiseRestrictedly(DatalogProgram dProgram, GapByStore4ID gap); 
+        public abstract int materialiseRestrictedly(DatalogProgram dProgram, GapByStore4ID gap);
-        
+        public abstract int materialiseSkolemly(DatalogProgram dProgram, GapByStore4ID gap);
        public void dispose() {
                super.dispose();
        }
-        
-        Boolean validMaterialisation = null; 
        public boolean isValid() {
                if (!checkValidity) return true; 
@@ -43,9 +44,9 @@ public abstract class StageQueryEngine extends BasicQueryEngine {
                }
                if (validMaterialisation)
-                        Utility.logInfo("The lazy-upper-bound store is valid."); 
+                        Utility.logInfo("The " + name + " store is valid.");
-                else 
+                else
-                        Utility.logInfo("The lazy-upper-bound store is not valid."); 
+                        Utility.logInfo("The " + name + " store is not valid.");
                return validMaterialisation;
        }
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/TwoStageApplication.java b/src/uk/ac/ox/cs/pagoda/multistage/TwoStageApplication.java
deleted file mode 100644
index f08bfbd..0000000
--- a/src/uk/ac/ox/cs/pagoda/multistage/TwoStageApplication.java
+++ /dev/null
@@ -1,265 +0,0 @@
-package uk.ac.ox.cs.pagoda.multistage;
-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.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.Variable;
-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.BottomStrategy;
-import uk.ac.ox.cs.pagoda.hermit.RuleHelper;
-import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
-import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
-import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
-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.Utility;
-abstract class TwoStageApplication {
-        protected TwoStageQueryEngine engine;
-        protected MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes;
-        private GapByStore4ID gap;
-        
-        Program lowerProgram;
-        
-        boolean m_incrementally = true; 
-        protected Set<DLClause> rules = new HashSet<DLClause>();
-        private StringBuilder datalogRuleText = new StringBuilder();
-        protected Collection<DLClause> constraints = new LinkedList<DLClause>();
-        protected BottomStrategy m_bottom;
-        protected Set<Atom> toGenerateNAFFacts = new HashSet<Atom>();
-        protected OverApproxExist overExist = new OverApproxExist();
-        private Map<DLClause, DLClause> map = new HashMap<DLClause, DLClause>();
-        public TwoStageApplication(TwoStageQueryEngine engine, DatalogProgram program, GapByStore4ID gap) {
-                this.engine = engine;
-                tripleManager = new RDFoxTripleManager(engine.getDataStore(), m_incrementally);
-                this.gap = gap; 
-                m_bottom = program.getUpperBottomStrategy();
-                lowerProgram = program.getLower();
-                Variable X = Variable.create("X");
-                Collection<DLClause> clauses = getInitialClauses(program.getGeneral());
-                Collection<DLClause> introducedConstraints = new LinkedList<DLClause>();
-                LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
-                for (DLClause clause : m_bottom.process(clauses)) {
-                        if (m_bottom.isBottomRule(clause)
-                                        || clause.getHeadLength() == 1
-                                        && !(clause.getHeadAtom(0).getDLPredicate() instanceof AtLeast))
-                                addDatalogRule(clause);
-                        else {
-                                newHeadAtoms.clear();
-                                boolean changed = false;
-                                for (Atom atom : clause.getHeadAtoms()) {
-                                        if (atom.getDLPredicate() instanceof AtLeastConcept) {
-                                                AtLeastConcept atLeast = (AtLeastConcept) atom
-                                                                .getDLPredicate();
-                                                if (atLeast.getToConcept() instanceof AtomicNegationConcept) {
-                                                        AtomicConcept positive = ((AtomicNegationConcept) atLeast
-                                                                        .getToConcept()).getNegatedAtomicConcept();
-                                                        AtomicConcept negative = OverApproxExist
-                                                                        .getNegationConcept(positive);
-                                                        Atom atom1 = Atom.create(positive, X);
-                                                        Atom atom2 = Atom.create(negative, X);
-                                                        introducedConstraints.add(DLClause.create(
-                                                                        new Atom[0], new Atom[] { atom1, atom2 }));
-                                                        newHeadAtoms.add(Atom.create(AtLeastConcept.create(
-                                                                        atLeast.getArity(), atLeast.getOnRole(),
-                                                                        negative), atom.getArgument(0)));
-                                                        changed = true;
-                                                        continue;
-                                                }
-                                        } else if (atom.getDLPredicate() instanceof AtLeastDataRange)
-                                                changed = true;
-                                        else
-                                                newHeadAtoms.add(atom);
-                                }
-                                if (!changed)
-                                        constraints.add(clause);
-                                else if (!newHeadAtoms.isEmpty()) {
-                                        DLClause newClause = DLClause.create(
-                                                        newHeadAtoms.toArray(new Atom[0]),
-                                                        clause.getBodyAtoms());
-                                        map.put(newClause, clause);
-                                        constraints.add(newClause);
-                                }
-                        }
-                }
-                for (DLClause clause : m_bottom.process(introducedConstraints))
-                        addDatalogRule(clause);
-        }
-        int materialise() {
-                StringBuilder builder = new StringBuilder(getDatalogRuleText());
-                for (DLClause clause: lowerProgram.getClauses())
-                        if (!rules.contains(clause))
-                                builder.append(RuleHelper.getText(clause));
-                
-                engine.materialise(builder.toString(), null, false);
-                addAuxiliaryRules();
-                addAuxiliaryNAFFacts();
-                engine.materialise(getDatalogRuleText(), gap, m_incrementally);
-                return engine.isValid() ? 1 : 0;
-        }
-        void checkNAFFacts() {
-                int counter = 0;
-                TupleIterator tuples = null;
-                for (Atom atom : toGenerateNAFFacts) {
-                        try {
-                                counter = 0;
-                                atom = getNAFAtom(atom);
-                                tuples = engine.internal_evaluate(SparqlHelper.getSPARQLQuery(
-                                                new Atom[] { atom }, atom.getArgumentVariable(0)
-                                                                .getName()));
-                                for (long multi = tuples.open(); multi != 0; multi = tuples.getNext()) {
-                                        ++counter;
-                                }
-                                Utility.logDebug(atom + " " + counter);
-                        } catch (JRDFStoreException e) {
-                                // TODO Auto-generated catch block
-                                e.printStackTrace();
-                        } finally {
-                                if (tuples != null)     tuples.dispose();
-                                tuples = null; 
-                        }
-                }
-        }
-        protected void addDatalogRule(DLClause clause) {
-                if (clause.getBodyAtom(0).equals(clause.getHeadAtom(0)))
-                        return;
-                rules.add(clause);
-                datalogRuleText.append(RuleHelper.getText(clause)).append('\n');
-        }
-        public String getDatalogRuleText() {
-                StringBuilder program = new StringBuilder();
-                program.append(prefixes.prefixesText());
-                program.append(datalogRuleText.toString());
-                return program.toString();
-        }
-        protected abstract void addAuxiliaryRules();
-        Set<Integer> allIndividuals = new HashSet<Integer>();
-        RDFoxTripleManager tripleManager; 
-        private void addAuxiliaryNAFFacts() {
-                for (int id : tripleManager.getResourceIDs(engine.getAllIndividuals()))
-                        allIndividuals.add(id);
-                DLPredicate naf;
-                DLPredicate p;
-                for (Atom atom: toGenerateNAFFacts) {
-                        naf = getNAFAtom(atom, false).getDLPredicate();
-                        p = atom.getDLPredicate();
-                        int typeID = tripleManager.getResourceID(Namespace.RDF_TYPE);
-                        int conceptID = tripleManager.getResourceID(((AtomicConcept) naf)
-                                        .getIRI());
-                        for (int answer : generateNAFFacts(p)) {
-                                tripleManager.addTripleByID(new int[] { answer, typeID,
-                                                conceptID });
-                        }
-                }
-        }
-        private Collection<Integer> generateNAFFacts(DLPredicate p) {
-                Variable X = Variable.create("X");
-                TupleIterator tuples = null;
-                Set<Integer> ret = new HashSet<Integer>(allIndividuals);
-                try {
-                        tuples = engine.internal_evaluate(SparqlHelper.getSPARQLQuery(
-                                        new Atom[] { Atom.create(p, X) }, "X"));
-                        for (long multi = tuples.open(); multi != 0; multi = tuples.getNext()) {
-                                ret.remove((int) tuples.getResourceID(0));
-                        }
-                } catch (JRDFStoreException e) {
-                        // TODO Auto-generated catch block
-                        e.printStackTrace();
-                } finally {
-                        if (tuples != null)     tuples.dispose();
-                }
-                return ret;
-        }
-        protected abstract Collection<DLClause> getInitialClauses(Program program);
-        private static final String NAF_suffix = "_NAF";
-        protected Atom getNAFAtom(Atom atom) {
-                return getNAFAtom(atom, true);
-        }
-        private Atom getNAFAtom(Atom atom, boolean update) {
-                DLPredicate p = atom.getDLPredicate();
-                if (update) {
-                        toGenerateNAFFacts.add(atom);
-                }
-                if (p instanceof AtomicConcept) {
-                        AtomicConcept nc = AtomicConcept.create(((AtomicConcept) p)
-                                        .getIRI() + "_NAF");
-                        return Atom.create(nc, atom.getArgument(0));
-                }
-                if (p instanceof Equality || p instanceof AnnotatedEquality)
-                        return Atom.create(
-                                        AtomicRole.create(Namespace.EQUALITY + NAF_suffix),
-                                        atom.getArgument(0), atom.getArgument(1));
-                if (p instanceof Inequality)
-                        atom = Atom.create(
-                                        AtomicRole.create(Namespace.INEQUALITY + NAF_suffix),
-                                        atom.getArgument(0), atom.getArgument(1));
-                // if (p instanceof AtomicRole) {
-                // AtomicRole nr = AtomicRole.create(((AtomicRole) p).getIRI() +
-                // NAF_suffix);
-                // return Atom.create(nr, atom.getArgument(0), atom.getArgument(1));
-                // }
-                if (p instanceof AtLeastConcept) {
-                        AtomicConcept nc = AtomicConcept.create(Normalisation
-                                        .getAuxiliaryConcept4Disjunct((AtLeastConcept) p)
-                                        + NAF_suffix);
-                        return Atom.create(nc, atom.getArgument(0));
-                }
-                Utility.logError("Unknown DLPredicate in an atom: " + atom);
-                return null;
-        }
-        protected DLClause getOriginalClause(DLClause clause) {
-                DLClause original = map.get(clause);
-                if (original == null)
-                        return clause;
-                return original;
-        }
-}
-\ No newline at end of file
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/TwoStageQueryEngine.java b/src/uk/ac/ox/cs/pagoda/multistage/TwoStageQueryEngine.java
deleted file mode 100644
index b7f989f..0000000
--- a/src/uk/ac/ox/cs/pagoda/multistage/TwoStageQueryEngine.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package uk.ac.ox.cs.pagoda.multistage;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.Collection;
-import org.openrdf.rio.RDFHandlerException;
-import org.openrdf.rio.RDFParseException;
-import org.openrdf.rio.turtle.TurtleParser;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.model.Individual;
-import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
-import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner;
-import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
-import uk.ac.ox.cs.pagoda.util.Timer;
-import uk.ac.ox.cs.pagoda.util.Utility;
-public class TwoStageQueryEngine extends StageQueryEngine {
-        
-        IndividualCollector m_collector = new IndividualCollector();
-        public TwoStageQueryEngine(String name, boolean checkValidity) {
-                super(name, checkValidity);
-        }
-        @Override
-        public void materialiseFoldedly(DatalogProgram dProgram, GapByStore4ID gap) {
-                TwoStageApplication program = new FoldedApplication2(this, dProgram, gap);
-                program.materialise();
-        }
-        
-        @Override
-        public void importRDFData(String fileName, String importedFile) {
-                super.importRDFData(fileName, importedFile);
-                TurtleParser parser = new TurtleParser(); 
-                parser.setRDFHandler(m_collector);
-                for (String file: importedFile.split(QueryReasoner.ImportDataFileSeparator)) {
-                        FileInputStream inputStream;
-                        try {
-                                inputStream = new FileInputStream(file);
-                                parser.parse(inputStream, "");
-                                inputStream.close();
-                        } catch (FileNotFoundException e) {
-                                // TODO Auto-generated catch block
-                                e.printStackTrace();
-                        } catch (RDFParseException e) {
-                                // TODO Auto-generated catch block
-                                e.printStackTrace();
-                        } catch (RDFHandlerException e) {
-                                // TODO Auto-generated catch block
-                                e.printStackTrace();
-                        } catch (IOException e) {
-                                // TODO Auto-generated catch block
-                                e.printStackTrace();
-                        } 
-                }
-        }
-        @Override
-        public int materialiseRestrictedly(DatalogProgram dProgram, GapByStore4ID gap) {
-                TwoStageApplication program = new RestrictedApplication2(this, dProgram, gap);
-                return program.materialise();
-        }
-        public void materialise(String programText,     GapByStore4ID gap, boolean incrementally) {
-                try {
-                        if (gap != null) {
-                                try {
-                                        gap.compile(incrementally ? null : programText);
-                                        gap.addBackTo();
-                                } finally {
-                                        gap.clear();
-                                }
-                        } else {
-                                long oldTripleCount = store.getTriplesCount();
-                                Timer t = new Timer(); 
-                                if (!incrementally)
-//                                      store.addRules(new String[] {programText});
-                                        store.importRules(programText);
-                                store.applyReasoning(incrementally);
-                                
-                                long tripleCount = store.getTriplesCount();
-                                
-                                Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)");
-                                Utility.logDebug("current store finished the materialisation of upper related rules in " + t.duration() + " seconds.");
-                        }
-                        store.clearRulesAndMakeFactsExplicit();
-                } catch (JRDFStoreException e) {
-                        e.printStackTrace();
-                }
-        }
-        public Collection<Individual> getAllIndividuals() {
-                return m_collector.getAllIndividuals();
-        }
-}
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/Violation.java b/src/uk/ac/ox/cs/pagoda/multistage/Violation.java
index b872f00..2f98784 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/Violation.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/Violation.java
@@ -1,9 +1,9 @@
 package uk.ac.ox.cs.pagoda.multistage;
-import java.util.LinkedList;
 import org.semanticweb.HermiT.model.DLClause;
+import java.util.LinkedList;
 public class Violation {
        DLClause clause = null; 
@@ -41,6 +41,13 @@ public class Violation {
        public String[] getVariables() {
                return vars; 
        }
-        
-        
+        @Override
+        public String toString() {
+                return "Violation{" +
+                                "constraint=" + constraint +
+                                ", clause=" + clause +
+                                ", tuples=" + tuples +
+                                '}';
+        }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/ViolationTuple.java b/src/uk/ac/ox/cs/pagoda/multistage/ViolationTuple.java
new file mode 100644
index 0000000..129f5dd
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/multistage/ViolationTuple.java
@@ -0,0 +1,19 @@
+package uk.ac.ox.cs.pagoda.multistage;
+import org.semanticweb.HermiT.model.Individual;
+import java.util.ArrayList;
+/**
+ * Just a list of <tt>Individual</tt>s.
+ * */
+public class ViolationTuple extends ArrayList<Individual> {
+    public ViolationTuple() {
+        super();
+    }
+    public ViolationTuple(int size) {
+        super(size);
+    }
+}
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..00e7e2b 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 org.semanticweb.HermiT.model.*;
-import java.util.Collections;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import java.util.Comparator;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
-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 uk.ac.ox.cs.pagoda.constraints.PredicateDependency;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
@@ -31,45 +14,40 @@ 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.pagoda.util.tuples.Tuple;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder;
+import java.util.*;
 public abstract class Pick4NegativeConcept implements Treatment {
-        
-        MultiStageQueryEngine engine; 
+        public Set<Atom> addedGroundAtoms = new HashSet<Atom>();
-        MultiStageUpperProgram program; 
+        MultiStageQueryEngine engine;
-        RDFoxTripleManager tripleManager; 
+        MultiStageUpperProgram program;
+        RDFoxTripleManager tripleManager;
        PredicateDependency dependencyGraph;
-        boolean addGap = false; 
+        boolean addGap = false;
        
        public Pick4NegativeConcept(MultiStageQueryEngine store, MultiStageUpperProgram multiProgram) {
-                this.engine = store; 
+                this.engine = store;
                this.program = multiProgram;
                this.tripleManager = new RDFoxTripleManager(store.getDataStore(), true);
        }
-        
        void addTripleByID(Atom atom, Atom gapAtom, Map<Variable, Integer> assignment) {
-                int[] newTuple = tripleManager.getInstance(atom, assignment); 
+                int[] newTuple = tripleManager.getInstance(atom, assignment);
                tripleManager.addTripleByID(newTuple);
-                if (addGap) 
+                if (addGap)
                        tripleManager.addTripleByID(tripleManager.getInstance(gapAtom, assignment));
        }
-        public Set<Atom> addedGroundAtoms = new HashSet<Atom>(); 
        protected boolean makeSatisfied(Violation violation, Comparator<Atom> comp) {
                LinkedList<AnswerTupleID> tuples = violation.getTuples();
                DLClause constraint = violation.getConstraint();
                Map<Variable, Integer> assignment = new HashMap<Variable, Integer>();
                
                if (constraint.getHeadLength() > 1) {
-                        Atom[] orderedAtoms = new Atom[constraint.getHeadLength()];
+                        Atom[] orderedAtoms = Arrays.copyOf(constraint.getHeadAtoms(), constraint.getHeadLength());
-                        int index = 0; 
-                        
-                        for (Atom headAtom: constraint.getHeadAtoms()) {
-                                orderedAtoms[index++] = headAtom;
-                        }
-                        
                        Arrays.sort(orderedAtoms, comp);
        
                        Set<AnswerTupleID> negTuples = new HashSet<AnswerTupleID>(); 
@@ -103,10 +81,9 @@ public abstract class Pick4NegativeConcept implements Treatment {
                                AnswerTupleID lastAdded = null; 
                                
                                for (Iterator<AnswerTupleID> iter = tuples.iterator(); iter.hasNext(); ) {
-                                        
-                                        AnswerTupleID tuple = iter.next(); 
+                                        AnswerTupleID tuple = iter.next();
-                                        if (negTuples.contains(MultiStageUpperProgram.project(tuple, violation.getVariables(), subVars))) ;
+                                        if (!negTuples.contains(MultiStageUpperProgram.project(tuple, violation.getVariables(), subVars))) {
-                                        else {
                                                if (lastAdded == null || tComp.compare(lastAdded, tuple) != 0) {
                                                        lastAdded = tuple; 
                                                        tuple.getAssignment(violation.getVariables(), assignment);
@@ -120,28 +97,39 @@ public abstract class Pick4NegativeConcept implements Treatment {
                                if (tuples.isEmpty()) 
                                        return true; 
                        }
-                        
+                        if (!tuples.isEmpty()) return false;
-                        if (!tuples.isEmpty()) return false; 
-                        
                }
                else {
-                        Set<Atom> headAtoms = new HashSet<Atom>(); 
+                        Set<Atom> headAtoms = new HashSet<Atom>();
-                        for (DLClause clause: program.convertExist(constraint, violation.getClause())) {
-                                if (DLClauseHelper.hasSubsetBodyAtoms(clause, constraint)) {
+                        ArrayList<Tuple<Individual>> violationTuples = new ArrayList<>(violation.getTuples().size());
-                                        Atom tHeadAtom = clause.getHeadAtom(0);
+                        for (int i = 0; i < violation.getTuples().size(); i++) {
-                                        Atom tGapHeadAtom = addGap ? getGapAtom(tHeadAtom) : null; 
+                                AnswerTupleID answerTupleID = violation.getTuples().get(i);
-                                        if (DLClauseHelper.isGround(tHeadAtom)) {
+                                TupleBuilder<Individual> tupleBuilder = new TupleBuilder<>();
-                                                if (!addedGroundAtoms.contains(tHeadAtom)) {
+                                for (int j = 0; j < answerTupleID.getArity(); j++) {
-                                                        program.addUpdatedPredicate(tHeadAtom.getDLPredicate());
+                                        String rawTerm = tripleManager.getRawTerm(answerTupleID.getTerm(j));
-                                                        addTripleByID(tHeadAtom, tGapHeadAtom, null);
+                                        Individual individual = Individual.create(rawTerm.substring(1, rawTerm.length()-1));
-                                                        addedGroundAtoms.add(tHeadAtom);
+                                        tupleBuilder.append(individual);
-                                                }
-                                        }
-                                        else headAtoms.add(tHeadAtom); 
                                }
-                                else {
+                                violationTuples.add(tupleBuilder.build());
-                                        Utility.logError("There might be an error here... Can't happend!!!"); 
+                        }
+                        for (DLClause clause : program.convertExist(constraint, violation.getClause(), violationTuples)) {
+                                if (!DLClauseHelper.hasSubsetBodyAtoms(clause, constraint)) {
+                                        Utility.logError("There might be an error here... Cannot happen!!!");
+                                        throw new Error("This condition should not happen!!!");
                                }
+                                Atom tHeadAtom = clause.getHeadAtom(0);
+                                Atom tGapHeadAtom = addGap ? getGapAtom(tHeadAtom) : null;
+                                if (DLClauseHelper.isGround(tHeadAtom)) {
+                                        if (!addedGroundAtoms.contains(tHeadAtom)) {
+                                                program.addUpdatedPredicate(tHeadAtom.getDLPredicate());
+                                                addTripleByID(tHeadAtom, tGapHeadAtom, null);
+                                                addedGroundAtoms.add(tHeadAtom);
+                                        }
+                                } else headAtoms.add(tHeadAtom);
                        }
                        if (!tuples.isEmpty())
                                for (Atom atom: headAtoms)
diff --git a/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConceptQuerySpecific.java b/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConceptQuerySpecific.java
index ae168cf..10aa22f 100644
--- a/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConceptQuerySpecific.java
+++ b/src/uk/ac/ox/cs/pagoda/multistage/treatement/Pick4NegativeConceptQuerySpecific.java
@@ -1,18 +1,7 @@
 package uk.ac.ox.cs.pagoda.multistage.treatement;
-import java.util.Comparator;
+import org.semanticweb.HermiT.model.*;
-import java.util.Set;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-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.DLPredicate;
-import org.semanticweb.HermiT.model.Equality;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.InverseRole;
 import uk.ac.ox.cs.pagoda.constraints.PredicateDependency;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
@@ -20,10 +9,11 @@ import uk.ac.ox.cs.pagoda.multistage.Normalisation;
 import uk.ac.ox.cs.pagoda.multistage.RestrictedApplication;
 import uk.ac.ox.cs.pagoda.multistage.Violation;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
 import uk.ac.ox.cs.pagoda.util.Namespace;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import java.util.Comparator;
+import java.util.Set;
 public class Pick4NegativeConceptQuerySpecific extends Pick4NegativeConcept {
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/query/AnswerTuple.java b/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
index 8d7e0b1..54e4837 100644
--- a/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
+++ b/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
@@ -1,13 +1,10 @@
 package uk.ac.ox.cs.pagoda.query;
-import java.util.HashMap;
+import com.google.gson.*;
-import java.util.Map;
 import org.semanticweb.HermiT.model.Constant;
 import org.semanticweb.HermiT.model.Individual;
 import org.semanticweb.HermiT.model.Term;
 import org.semanticweb.HermiT.model.Variable;
 import uk.ac.ox.cs.JRDFox.JRDFStoreException;
 import uk.ac.ox.cs.JRDFox.model.Datatype;
 import uk.ac.ox.cs.JRDFox.model.GroundTerm;
@@ -15,13 +12,21 @@ import uk.ac.ox.cs.JRDFox.model.Literal;
 import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 import uk.ac.ox.cs.pagoda.util.Namespace;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 public class AnswerTuple {
        
        public static final String SEPARATOR = "\t";
+        static final Pattern owlLiteralRegex =
+                        Pattern.compile("^\"(?<lexicalForm>[^@]+(@(?<langTag>.+))?)\"(^^<(?<dataType>.+)>)?$");
+        String m_str = null;
+        GroundTerm[] m_tuple;
        
-        String m_str = null; 
-        GroundTerm[] m_tuple; 
        public AnswerTuple(TupleIterator iter, int arity) {
                m_tuple = new GroundTerm[arity];
                try {
@@ -29,107 +34,157 @@ public class AnswerTuple {
                                m_tuple[i] = iter.getGroundTerm(i);
                } catch (JRDFStoreException e) {
                        e.printStackTrace();
-                } 
+                }
        }
        
        public AnswerTuple(GroundTerm[] terms) {
-                m_tuple = terms; 
+                m_tuple = terms;
        }
-        
+//      private AnswerTuple(String m_str) {
+//              this.m_str = m_str;
+//      }
        private AnswerTuple(AnswerTuple sup, int arity) {
-                m_tuple = new GroundTerm[arity]; 
+                m_tuple = new GroundTerm[arity];
-                for (int i = 0; i < arity; ++i) m_tuple[i] = sup.m_tuple[i]; 
+                for(int i = 0; i < arity; ++i) m_tuple[i] = sup.m_tuple[i];
+        }
+        /**
+         * It returns the first argument if its arity equals length, a new AnswerTuple otherwise.
+         */
+        public static AnswerTuple getInstance(AnswerTuple extendedTuple, int length) {
+                if(length == extendedTuple.getArity()) return extendedTuple;
+                else return new AnswerTuple(extendedTuple, length);
        }
        
        public int getArity() {
-                return m_tuple.length; 
+                return m_tuple.length;
        }
        public int hashCode() {
 //              return toString().hashCode();
-                int code = 0; 
+                int code = 0;
                for (int i = 0; i < m_tuple.length; ++i)
                        code = code * 1997 + m_tuple[i].hashCode();
-                return code; 
+                return code;
        }
-        
        public boolean equals(Object obj) {
                if (!(obj instanceof AnswerTuple)) return false;
-                AnswerTuple that = (AnswerTuple) obj; 
+                AnswerTuple that = (AnswerTuple) obj;
-                if (m_tuple.length != that.m_tuple.length) return false; 
+                if (m_tuple.length != that.m_tuple.length) return false;
                for (int i = 0; i < m_tuple.length; ++i)
                        if (!m_tuple[i].equals(that.m_tuple[i]))
-                                return false; 
+                                return false;
-                return true; 
+                return true;
-//              return toString().equals(obj.toString()); 
+//              return toString().equals(obj.toString());
        }
        
        public String toString() {
-                if (m_str != null) return m_str; 
+                if(m_str != null) return m_str;
-                StringBuilder sb = new StringBuilder();  
+                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < m_tuple.length; ++i) {
                        if (sb.length() != 0) sb.append(SEPARATOR);
                        if (m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)
                                sb.append("<").append(((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[i]).getIRI()).append(">");
                        else if (m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.BlankNode) {
-                                sb.append(((uk.ac.ox.cs.JRDFox.model.BlankNode) m_tuple[i]).toString()); 
+                                sb.append(m_tuple[i].toString());
                        }
                        else {
-                                Literal l = (Literal) m_tuple[i]; 
+                                Literal l = (Literal) m_tuple[i];
                                sb.append('"').append(l.getLexicalForm()).append("\"");
                                if (!l.getDatatype().equals(Datatype.XSD_STRING) && !l.getDatatype().equals(Datatype.RDF_PLAIN_LITERAL))
-                                        sb.append("^^<").append(l.getDatatype().getIRI()).append(">"); 
+                                        sb.append("^^<").append(l.getDatatype().getIRI()).append(">");
                        }
                }
-                return m_str = sb.toString();  
+                return m_str = sb.toString();
        }
        public GroundTerm getGroundTerm(int i) {
-                return m_tuple[i]; 
+                return m_tuple[i];
        }
        
        public Map<Variable, Term> getAssignment(String[] vars) {
-                Map<Variable, Term> map = new HashMap<Variable, Term>(); 
+                Map<Variable, Term> map = new HashMap<Variable, Term>();
-                int index = 0; 
+                int index = 0;
-                Term t; 
+                Term t;
                for (String var: vars) {
-                        if (m_tuple[index] instanceof uk.ac.ox.cs.JRDFox.model.Individual) 
+                        if(m_tuple[index] instanceof uk.ac.ox.cs.JRDFox.model.Individual)
-                                t = Individual.create((((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[index]).getIRI())); 
+                                t = Individual.create((((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[index]).getIRI()));
                        else {
-                                uk.ac.ox.cs.JRDFox.model.Literal l = (uk.ac.ox.cs.JRDFox.model.Literal) m_tuple[index]; 
+                                uk.ac.ox.cs.JRDFox.model.Literal l = (uk.ac.ox.cs.JRDFox.model.Literal) m_tuple[index];
-                                t = Constant.create(l.getLexicalForm(), l.getDatatype().getIRI()); 
+                                t = Constant.create(l.getLexicalForm(), l.getDatatype().getIRI());
                        }
-                        map.put(Variable.create(var), t); 
+                        map.put(Variable.create(var), t);
-                        ++index; 
+                        ++index;
                }
-                return map; 
+                return map;
        }
        public boolean hasAuxPredicate() {
-                String iri; 
+                String iri;
                for (int i = 0; i < m_tuple.length; ++i)
                        if ((m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)) {
                                iri = ((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[i]).getIRI();
-                                if ( iri.startsWith(Namespace.PAGODA_AUX) || iri.contains("_AUX") || iri.contains("_neg") || iri.contains("internal:def"))
+                                if(iri.startsWith(Namespace.PAGODA_AUX) || iri.contains("_AUX") || iri.contains("_neg") || iri.contains("internal:def"))
-                                        return true; 
+                                        return true;
                        }
-                return false; 
+                return false;
        }
-        
-        public boolean hasAnonyIndividual() {
+        public boolean hasAnonymousIndividual() {
-                String iri; 
+                String iri;
-                for (int i = 0; i < m_tuple.length; ++i)
+                for(int i = 0; i < m_tuple.length; ++i)
-                        if ((m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)) {
+                        if((m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)) {
                                iri = ((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[i]).getIRI();
-                                if (iri.startsWith(Namespace.PAGODA_ANONY) || iri.startsWith(Namespace.KARMA_ANONY))
+                                if(iri.startsWith(Namespace.PAGODA_ANONY) || iri.startsWith(Namespace.KARMA_ANONY))
-                                        return true; 
+                                        return true;
                        }
-                return false; 
+                return false;
        }
-        public static AnswerTuple create(AnswerTuple extendedTuple, int length) {
+        public static class AnswerTupleSerializer implements JsonSerializer<AnswerTuple> {
-                if (length == extendedTuple.getArity()) return extendedTuple;
-                else return new AnswerTuple(extendedTuple, length); 
+                public JsonElement serialize(AnswerTuple src, Type typeOfSrc, JsonSerializationContext context) {
+                        return new JsonPrimitive(src.toString());
+                }
        }
-        
+        public static class AnswerTupleDeserializer implements JsonDeserializer<AnswerTuple> {
+                public AnswerTuple deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+                                throws JsonParseException {
+                        String tuplesString = json.getAsJsonPrimitive().getAsString();
+                        StringTokenizer tokenizer = new StringTokenizer(SEPARATOR);
+                        GroundTerm[] terms = new GroundTerm[tokenizer.countTokens()];
+                        // TODO test parsing
+                        for (int i = 0; i < tokenizer.countTokens(); i++) {
+                                String token = tokenizer.nextToken();
+                                if (token.charAt(0) == '<') {
+                                        terms[i] = uk.ac.ox.cs.JRDFox.model.Individual.create(token.substring(1,token.length()-1));
+                                }
+                                else if (token.charAt(0) == '"') {
+                                        Matcher matcher = owlLiteralRegex.matcher(token);
+                                        if(matcher.matches()) {
+                                                String lexicalForm = matcher.group("lexicalForm");
+                                                String dataTypeIRI = matcher.group("dataType");
+                                                Datatype dataType;
+                                                if (dataTypeIRI.isEmpty()) dataType = Datatype.RDF_PLAIN_LITERAL;
+                                                else dataType = uk.ac.ox.cs.JRDFox.model.Datatype.value(dataTypeIRI);
+                                                terms[i] = uk.ac.ox.cs.JRDFox.model.Literal.create(lexicalForm, dataType);
+                                        }
+                                        else {
+                                                throw new IllegalArgumentException("The given json does not represent a valid AnswerTuple");
+                                        }
+                                }
+                                else {
+                                        terms[i] = uk.ac.ox.cs.JRDFox.model.BlankNode.create(token);
+                                }
+                        }
+                        return new AnswerTuple(terms);
+                }
+        }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/query/DeserializedQueryRecord.java b/src/uk/ac/ox/cs/pagoda/query/DeserializedQueryRecord.java
new file mode 100644
index 0000000..3d25eaf
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/query/DeserializedQueryRecord.java
@@ -0,0 +1,9 @@
+package uk.ac.ox.cs.pagoda.query;
+/*
+* A light version of QueryRecord,
+* which can be obtained easily from the Json serialization of QueryRecord.
+* */
+public class DeserializedQueryRecord {
+    // TODO implement
+}
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java b/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java
index d2e9b90..eaa629b 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java
@@ -1,36 +1,29 @@
 package uk.ac.ox.cs.pagoda.query;
-import java.io.BufferedWriter;
+import org.semanticweb.HermiT.model.*;
-import java.io.FileOutputStream;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import java.io.IOException;
+import uk.ac.ox.cs.JRDFox.Prefixes;
-import java.io.OutputStreamWriter;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
-import java.util.Collection;
+import uk.ac.ox.cs.JRDFox.store.Parameters;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
-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.Individual;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.Prefixes;
+import java.io.BufferedWriter;
-import uk.ac.ox.cs.JRDFox.store.DataStore;
+import java.io.FileOutputStream;
-import uk.ac.ox.cs.JRDFox.store.Parameters;
+import java.io.IOException;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import java.io.OutputStreamWriter;
+import java.util.Collection;
 public class GapByTriple extends GapTupleIterator<String> {
        
-        private static final String RDF_TYPE = Namespace.RDF_NS + "type"; 
-        private static final String BRIEF_RDF_TYPE = "rdf:type"; 
-        
        static final String allTripleQuery = "SELECT ?X ?Y ?Z WHERE { ?X ?Y ?Z }";
-        
+        private static final String RDF_TYPE = Namespace.RDF_NS + "type";
+        private static final String BRIEF_RDF_TYPE = "rdf:type";
        DataStore lowerStore, upperStore;
        long multi; 
        TupleIterator iterator;
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
index 61b6364..bf11168 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
@@ -1,10 +1,10 @@
 package uk.ac.ox.cs.pagoda.query;
-import java.util.Iterator;
 import uk.ac.ox.cs.JRDFox.JRDFStoreException;
 import uk.ac.ox.cs.JRDFox.store.DataStore;
+import java.util.Iterator;
 public abstract class GapTupleIterator<T> implements Iterator<T> {
        
        public static final String gapPredicateSuffix = "_AUXg"; 
diff --git a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
index ce92a67..fd20af1 100644
--- a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
+++ b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
@@ -1,311 +1,345 @@
 package uk.ac.ox.cs.pagoda.query;
-import java.io.BufferedWriter;
+import com.google.gson.*;
-import java.io.FileNotFoundException;
+import com.google.gson.reflect.TypeToken;
-import java.io.FileOutputStream;
+import org.semanticweb.HermiT.model.*;
-import java.io.IOException;
+import org.semanticweb.owlapi.model.*;
-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.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.Variable;
-import org.semanticweb.owlapi.model.OWLAxiom;
-import org.semanticweb.owlapi.model.OWLClass;
-import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLDataProperty;
-import org.semanticweb.owlapi.model.OWLDataPropertyAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLIndividual;
-import org.semanticweb.owlapi.model.OWLLiteral;
-import org.semanticweb.owlapi.model.OWLObjectProperty;
-import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyManager;
-import org.semanticweb.owlapi.model.OWLOntologyStorageException;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxAnswerTuples;
 import uk.ac.ox.cs.pagoda.rules.GeneralProgram;
 import uk.ac.ox.cs.pagoda.util.ConjunctiveQueryHelper;
 import uk.ac.ox.cs.pagoda.util.Namespace;
+import uk.ac.ox.cs.pagoda.util.PagodaProperties;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
+import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder;
+import java.io.*;
+import java.lang.reflect.Type;
+import java.util.*;
 public class QueryRecord {
        
        public static final String botQueryText = "SELECT ?X WHERE { ?X <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#Nothing> }";
+        public static final String SEPARATOR = "----------------------------------------";
-        private Step diffculty;
+        private static final String RDF_TYPE = "a"; //"rdf:type"; //RDF.type.toString();
-        
+        boolean processed = false;
-        private String queryText; 
+        String stringQueryID = null;
-        private int queryID = -1; 
+        OWLOntology relevantOntology = null;
-        private String[][] answerVariables = null; 
+        Set<DLClause> relevantClauses = new HashSet<DLClause>();
-        private Set<AnswerTuple> soundAnswerTuples = new HashSet<AnswerTuple>(); 
+        double[] timer;
+        int subID;
+        DLClause queryClause = null;
+        private Step difficulty;
+        private String queryText;
+        private int queryID = -1;
+        private String[][] answerVariables = null;
+        private Set<AnswerTuple> soundAnswerTuples = new HashSet<AnswerTuple>();
        private Set<AnswerTuple> gapAnswerTuples = null;
-        
+        private QueryManager m_manager;
-        private QueryManager m_manager; 
-        
+        private QueryRecord() {
+        }
+//      private boolean containsAuxPredicate(String str) {
+//              return  str.contains(Namespace.PAGODA_AUX) || str.contains("_AUX") || str.contains("owl#Nothing") ||
+//                              str.contains("internal:def"); 
+//      }
        public QueryRecord(QueryManager manager, String text, int id, int subID) {
-                m_manager =manager; 
+                m_manager = manager;
                resetInfo(text, id, subID);
-                resetTimer(); 
+                resetTimer();
        }
-        
+        public static Collection<String> collectQueryTexts(Collection<QueryRecord> queryRecords) {
+                Collection<String> texts = new LinkedList<String>();
+                for(QueryRecord record : queryRecords)
+                        texts.add(record.queryText);
+                return texts;
+        }
        public void resetInfo(String text, int id, int subid) {
                queryID = id;
-                subID = subid; 
+                subID = subid;
                stringQueryID = id + (subID == 0 ? "" : "_" + subID);
-                m_manager.remove(queryText); 
+                m_manager.remove(queryText);
-                m_manager.put(text, this); 
+                m_manager.put(text, this);
                queryClause = null;
                answerVariables = ConjunctiveQueryHelper.getAnswerVariables(text);
-                queryText = text; // .replace("_:", "?"); 
+                queryText = text; // .replace("_:", "?");
        }
        public void resetTimer() {
-                int length = Step.values().length; 
+                int length = Step.values().length;
-                timer = new double[length]; 
+                timer = new double[length];
-                for (int i = 0; i < length; ++i) timer[i] = 0; 
+                for(int i = 0; i < length; ++i) timer[i] = 0;
        }
-        
        public AnswerTuples getAnswers() {
-                if (processed())
+                if(isProcessed())
                        return getLowerBoundAnswers();
-                
-                return getUpperBoundAnswers(); 
+                return getUpperBoundAnswers();
        }
-        
        public AnswerTuples getLowerBoundAnswers() {
-                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples); 
+                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples);
        }
-        
        public AnswerTuples getUpperBoundAnswers() {
-                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples, gapAnswerTuples); 
+                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples, gapAnswerTuples);
        }
-        
        public boolean updateLowerBoundAnswers(AnswerTuples answerTuples) {
-                if (answerTuples == null) return false;                         
+                if(answerTuples == null) return false;
                boolean update = false;
-                for (AnswerTuple tuple; answerTuples.isValid(); answerTuples.moveNext()) {
+                for(AnswerTuple tuple; answerTuples.isValid(); answerTuples.moveNext()) {
                        tuple = answerTuples.getTuple();
-                        if (!soundAnswerTuples.contains(tuple) && (gapAnswerTuples == null || gapAnswerTuples.contains(tuple))) {
+                        if(!soundAnswerTuples.contains(tuple) && (gapAnswerTuples == null || gapAnswerTuples.contains(tuple))) {
                                soundAnswerTuples.add(tuple);
-                                if (gapAnswerTuples != null)
+                                if(gapAnswerTuples != null)
                                        gapAnswerTuples.remove(tuple);
-                                update = true; 
+                                update = true;
                        }
                }
-                Utility.logInfo("The number of answers in the lower bound: " + soundAnswerTuples.size()); 
-                return update; 
+                if(soundAnswerTuples.isEmpty())
+                        Utility.logInfo("Lower bound answers empty");
+                else if(update)
+                        Utility.logInfo("Lower bound answers updated: " + soundAnswerTuples.size());
+                else
+                        Utility.logInfo("Lower bound answers unchanged");
+                return update;
        }
-        
        public boolean updateUpperBoundAnswers(AnswerTuples answerTuples) {
-                return updateUpperBoundAnswers(answerTuples, false); 
+                return updateUpperBoundAnswers(answerTuples, false);
        }
-        
        public boolean updateUpperBoundAnswers(AnswerTuples answerTuples, boolean toCheckAux) {
-                RDFoxAnswerTuples rdfAnswerTuples; 
+                if(!(answerTuples instanceof RDFoxAnswerTuples)) {
-                if (answerTuples instanceof RDFoxAnswerTuples)
+                        String msg = "The upper bound must be computed by RDFox!";
-                        rdfAnswerTuples = (RDFoxAnswerTuples) answerTuples; 
+                        Utility.logError(msg);
-                else {
+                        throw new IllegalArgumentException(msg);
-                        Utility.logError("The upper bound must be computed by RDFox!");
-                        return false;
                }
-                
-                if (soundAnswerTuples.size() > 0) {
+                RDFoxAnswerTuples rdfoxAnswerTuples = (RDFoxAnswerTuples) answerTuples;
-                        int number = 0; 
-                        for (; answerTuples.isValid(); answerTuples.moveNext()) {
+                Set<AnswerTuple> candidateGapAnswerTuples = new HashSet<AnswerTuple>();
-                                ++number; 
+                AnswerTuple tuple;
-                        }
+                for(; rdfoxAnswerTuples.isValid(); rdfoxAnswerTuples.moveNext()) {
-                        Utility.logInfo("The number of answers returned by the upper bound: " + number);
+                        tuple = rdfoxAnswerTuples.getTuple();
-                        if (number <= soundAnswerTuples.size()) {
+                        if(isBottom() || !tuple.hasAnonymousIndividual())
-                                if (gapAnswerTuples != null) gapAnswerTuples.clear(); 
+                                if((!toCheckAux || !tuple.hasAuxPredicate()) && !soundAnswerTuples.contains(tuple))
-                                else gapAnswerTuples = new HashSet<AnswerTuple>();
+                                        candidateGapAnswerTuples.add(tuple);
-                                        
-                                Utility.logInfo("The number of answers in the upper bound: " + (soundAnswerTuples.size() + gapAnswerTuples.size()));
-                                return false;
-                        }
-                        answerTuples.reset();
                }
-                        
-                boolean justCheck = (answerTuples.getArity() != answerVariables[1].length);
+                /*** START: debugging ***/
-        
+                if(PagodaProperties.isDebuggingMode()) {
-                Set<AnswerTuple> tupleSet = new HashSet<AnswerTuple>();
+                        if(rdfoxAnswerTuples.getArity() != getAnswerVariables().length)
-                AnswerTuple tuple, extendedTuple;
+                                throw new IllegalArgumentException(
-                for (; answerTuples.isValid(); answerTuples.moveNext()) {
+                                                "The arity of answers (" + rdfoxAnswerTuples.getArity() + ") " +
-                        extendedTuple = rdfAnswerTuples.getTuple(); 
+                                                                "is different from the number of answer variables (" +
-                        if (isBottom() || !extendedTuple.hasAnonyIndividual()) {
+                                                                getAnswerVariables().length + ")");
-                                tuple = AnswerTuple.create(extendedTuple, answerVariables[0].length); 
-                                if ((!toCheckAux || !tuple.hasAuxPredicate()) && !soundAnswerTuples.contains(tuple)) {
+                        Set<AnswerTuple> namedAnswerTuples = new HashSet<>();
-                                        if (!toCheckAux && justCheck) return false; 
+                        rdfoxAnswerTuples.reset();
-                                        tupleSet.add(extendedTuple);
+                        for(; rdfoxAnswerTuples.isValid(); rdfoxAnswerTuples.moveNext()) {
-                        }
+                                tuple = rdfoxAnswerTuples.getTuple();
+//                              if(isBottom() || !tuple.hasAnonymousIndividual()) {
+                                namedAnswerTuples.add(tuple);
+//                              }
                        }
+                        HashSet<AnswerTuple> difference = new HashSet<>(soundAnswerTuples);
+                        difference.removeAll(namedAnswerTuples);
+                        if(!difference.isEmpty())
+                                throw new IllegalArgumentException("The upper bound does not contain the lower bound! Missing answers: " + difference
+                                                .size());
                }
-                
+                /*** END: debugging ***/
-                if (gapAnswerTuples == null) {
-                        gapAnswerTuples = tupleSet; 
+                boolean update;
-                        
+                if(gapAnswerTuples == null) {
-                        Utility.logInfo("The number of answers in the upper bound: " + (soundAnswerTuples.size() + gapAnswerTuples.size()));
+                        gapAnswerTuples = candidateGapAnswerTuples;
-                        return true; 
+                        update = true;
-                }
+                } else {
-                
+                        update = gapAnswerTuples.retainAll(candidateGapAnswerTuples);
-                boolean update = false; 
-                for (Iterator<AnswerTuple> iter = gapAnswerTuples.iterator(); iter.hasNext(); ) {
-                        tuple = iter.next(); 
-                        if (!tupleSet.contains(tuple)) {
-                                iter.remove(); 
-                                update = true; 
-                        }
                }
-                
-                Utility.logInfo("The number of answers in the upper bound: " + (soundAnswerTuples.size() + gapAnswerTuples.size()));
+                if(update)
-                
+                        Utility.logInfo("Upper bound answers updated: " + getNumberOfAnswers());
-                return update; 
+                else
+                        Utility.logInfo("Upper bound answers unchanged");
+                return update;
+//              boolean update = false;
+//              for(Iterator<AnswerTuple> iter = gapAnswerTuples.iterator(); iter.hasNext(); ) {
+//                      tuple = iter.next();
+//                      if(!candidateGapAnswerTuples.contains(tuple)) {
+//                              iter.remove();
+//                              update = true;
+//                      }
+//              }
        }
-        
-//      private boolean containsAuxPredicate(String str) {
-//              return  str.contains(Namespace.PAGODA_AUX) || str.contains("_AUX") || str.contains("owl#Nothing") ||
-//                              str.contains("internal:def"); 
-//      }
-        boolean processed = false; 
+        public int getNumberOfAnswers() {
+                return soundAnswerTuples.size() + gapAnswerTuples.size();
+        }
        public void markAsProcessed() {
-                processed = true; 
+                processed = true;
        }
-        public boolean processed() {
+        public boolean isProcessed() {
-                if (gapAnswerTuples != null && gapAnswerTuples.isEmpty()) processed = true; 
+                if(gapAnswerTuples != null && gapAnswerTuples.isEmpty()) processed = true;
-                return processed; 
+                return processed;
        }
-        
        public String[] getDistinguishedVariables() {
-                return answerVariables[1]; 
+                return answerVariables[1];
        }
-        
        public String[] getAnswerVariables() {
-                return answerVariables[0]; 
+                return answerVariables[0];
        }
-        
        public String[][] getVariables() {
-                return answerVariables; 
+                return answerVariables;
        }
        
        public String getQueryText() {
-                return queryText; 
+                return queryText;
        }
        
-        String stringQueryID = null; 
-        
        public String getQueryID() {
-                return stringQueryID; 
+                return stringQueryID;
        }
-        
        public AnswerTuples getGapAnswers() {
-                return new AnswerTuplesImp(answerVariables[0], gapAnswerTuples); 
+                return new AnswerTuplesImp(answerVariables[0], gapAnswerTuples);
        }
        public String toString() {
-                return queryText; 
+                return queryText;
        }
-        
-        public static final String SEPARATOR = "----------------------------------------"; 
        public void outputAnswers(BufferedWriter writer) throws IOException {
-                
-                int answerCounter = soundAnswerTuples.size(); 
+                int answerCounter = soundAnswerTuples.size();
-                if (!processed()) answerCounter += gapAnswerTuples.size(); 
+                if(!isProcessed()) answerCounter += gapAnswerTuples.size();
-                
                Utility.logInfo("The number of answer tuples: " + answerCounter);
-                
                if (writer != null) {
                        writer.write("-------------- Query " + queryID + " ---------------------");
                        writer.newLine();
                        writer.write(queryText);
                        writer.newLine();
-                        StringBuilder space = new StringBuilder(); 
+                        StringBuilder space = new StringBuilder();
-                        int arity = getArity(), varSpace = 0; 
+                        int arity = getArity(), varSpace = 0;
                        for (int i = 0; i < arity; ++i)
-                                varSpace += answerVariables[0][i].length(); 
+                                varSpace += answerVariables[0][i].length();
                        for (int i = 0; i < (SEPARATOR.length() - varSpace) / (arity + 1); ++i)
-                                space.append(" "); 
+                                space.append(" ");
                        for (int i = 0; i < getArity(); ++i) {
                                writer.write(space.toString());
                                writer.write(answerVariables[0][i]);
                        }
                        writer.newLine();
                        writer.write(SEPARATOR);
-                        writer.newLine(); 
+                        writer.newLine();
                        for (AnswerTuple tuple: soundAnswerTuples) {
-                                writer.write(tuple.toString()); 
+                                writer.write(tuple.toString());
                                writer.newLine();
                        }
-                        if (!processed())
+                        if(!isProcessed())
                                for (AnswerTuple tuple: gapAnswerTuples) {
                                        writer.write("*");
-                                        writer.write(tuple.toString()); 
+                                        writer.write(tuple.toString());
                                        writer.newLine();
                                }
 //                      writer.write(SEPARATOR);
                        writer.newLine();
                }
-                
        }
-        
+        public void outputAnswerStatistics() {
+                int answerCounter = soundAnswerTuples.size();
+                if(!isProcessed()) answerCounter += gapAnswerTuples.size();
+                Utility.logInfo("The number of answer tuples: " + answerCounter);
+//              if (jsonAnswers != null) {
+//                      JSONObject jsonAnswer = new JSONObject();
+//
+//                      jsonAnswer.put("queryID", queryID);
+//                      jsonAnswer.put("queryText", queryText);
+//
+//                      JSONArray answerVars = new JSONArray();
+//                      int arity = getArity(), varSpace = 0;
+//                      for (int i = 0; i < getArity(); i++)
+//                              answerVars.add(answerVariables[0][i]);
+//                      jsonAnswer.put("answerVars", answerVars);
+//
+//                      JSONArray answerTuples = new JSONArray();
+//                      soundAnswerTuples.stream().forEach(t -> answerTuples.add(t));
+//                      jsonAnswer.put("answerTuples", answerTuples);
+//
+//                      if (!processed) {
+//                              JSONArray gapAnswerTuples = new JSONArray();
+//                              gapAnswerTuples.stream().forEach(t -> gapAnswerTuples.add(t));
+//                      }
+//                      jsonAnswer.put("gapAnswerTuples", gapAnswerTuples);
+//
+//                      jsonAnswers.put(Integer.toString(queryID), jsonAnswer);
+//              }
+        }
        public void outputTimes() {
                for (Step step: Step.values()) {
-                        Utility.logDebug("time for " + step + ": " + timer[step.ordinal()]); 
+                        Utility.logDebug("time for " + step + ": " + timer[step.ordinal()]);
                }
        }
-        
        public String outputSoundAnswerTuple() {
-                StringBuilder builder = new StringBuilder(); 
+                StringBuilder builder = new StringBuilder();
                for (AnswerTuple tuple: soundAnswerTuples)
                        builder.append(tuple.toString()).append(Utility.LINE_SEPARATOR);
-                return builder.toString(); 
+                return builder.toString();
        }
-        
        public String outputGapAnswerTuple() {
-                StringBuilder builder = new StringBuilder(); 
+                StringBuilder builder = new StringBuilder();
-                for (AnswerTuple tuple: gapAnswerTuples)
+                for(AnswerTuple tuple : gapAnswerTuples)
                        builder.append(tuple.toString()).append(Utility.LINE_SEPARATOR);
-                return builder.toString(); 
+                return builder.toString();
-        }
-        
-        public void setDifficulty(Step step) {
-                this.diffculty = step;   
        }
        public Step getDifficulty() {
-                return diffculty; 
+                return difficulty;
        }
-        OWLOntology relevantOntology = null; 
+        public void setDifficulty(Step step) {
-        Set<DLClause> relevantClauses = new HashSet<DLClause>(); 
+                this.difficulty = step;
-        public void setRelevantOntology(OWLOntology knowledgebase) {
-                relevantOntology = knowledgebase; 
        }
-        
        public OWLOntology getRelevantOntology() {
-                return relevantOntology; 
+                return relevantOntology;
+        }
+        public void setRelevantOntology(OWLOntology knowledgebase) {
+                relevantOntology = knowledgebase;
        }
        public void saveRelevantOntology(String filename) {
-                if (relevantOntology == null) return ; 
+                if(relevantOntology == null) return;
-                OWLOntologyManager manager = relevantOntology.getOWLOntologyManager(); 
+                OWLOntologyManager manager = relevantOntology.getOWLOntologyManager();
                try {
-                        FileOutputStream outputStream = new FileOutputStream(filename); 
+                        FileOutputStream outputStream = new FileOutputStream(filename);
                        manager.saveOntology(relevantOntology, outputStream);
                        outputStream.close();
                } catch (OWLOntologyStorageException e) {
@@ -318,12 +352,11 @@ public class QueryRecord {
        }
        public void saveRelevantClause() {
-                if (relevantClauses == null) return ; 
+                if(relevantClauses == null) return;
                GeneralProgram p = new GeneralProgram(relevantClauses, relevantOntology);
                p.save();
        }
        public void removeUpperBoundAnswers(Collection<AnswerTuple> answers) {
                for (AnswerTuple answer: answers) {
 //                      if (soundAnswerTuples.contains(answer))
@@ -334,50 +367,37 @@ public class QueryRecord {
                }
        }
        public void addLowerBoundAnswers(Collection<AnswerTuple> answers) {
                for (AnswerTuple answer: answers) {
                        if (!gapAnswerTuples.contains(answer))
                                Utility.logError("The answer (" + answer + ") cannot be added, because it is not in the upper bound.");
                        gapAnswerTuples.remove(answer);
-                        
-                        answer = AnswerTuple.create(answer, answerVariables[0].length); 
+                        answer = AnswerTuple.getInstance(answer, answerVariables[0].length);
 //                      if (soundAnswerTuples.contains(answer))
 //                              Utility.logError("The answer (" + answer + ") cannot be added, because it is in the lower bound.");
-                        soundAnswerTuples.add(answer); 
+                        soundAnswerTuples.add(answer);
                }
        }
-        
        public int getNoOfSoundAnswers() {
-                return soundAnswerTuples.size(); 
+                return soundAnswerTuples.size();
        }
-        
-        public enum Step {LowerBound, UpperBound, ELLowerBound, 
-                Fragment, FragmentRefinement, Summarisation, Dependency, FullReasoning};  
-        
-        double[] timer; 
        public void addProcessingTime(Step step, double time) {
-                timer[step.ordinal()] += time; 
+                timer[step.ordinal()] += time;
        }
        public int getArity() {
                return answerVariables[0].length;
        }
-        
-        public static Collection<String> collectQueryTexts(Collection<QueryRecord> queryRecords) {
-                Collection<String> texts = new LinkedList<String>(); 
-                for (QueryRecord record: queryRecords)
-                        texts.add(record.queryText); 
-                return texts;
-        }
        public void addRelevantClauses(DLClause clause) {
-                relevantClauses.add(clause);            
+                relevantClauses.add(clause);
        }
-        
        public Set<DLClause> getRelevantClauses() {
-                return relevantClauses; 
+                return relevantClauses;
        }
        public void clearClauses() {
@@ -388,36 +408,40 @@ public class QueryRecord {
                for (DLClause clause: relevantClauses)
                        if (clause.getHeadLength() > 1)
                                return false;
-                return true; 
+                return true;
        }
        public void saveABoxInTurtle(String filename) {
                try {
                        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename)));
                        OWLIndividual a, b;
-                        StringBuilder builder = new StringBuilder(); 
+                        StringBuilder builder = new StringBuilder();
                        for (OWLAxiom axiom: relevantOntology.getABoxAxioms(true)) {
                                if (axiom instanceof OWLClassAssertionAxiom) {
-                                        OWLClassAssertionAxiom classAssertion = (OWLClassAssertionAxiom) axiom; 
+                                        OWLClassAssertionAxiom classAssertion = (OWLClassAssertionAxiom) axiom;
-                                        OWLClass c = (OWLClass) classAssertion.getClassExpression(); 
+                                        OWLClass c = (OWLClass) classAssertion.getClassExpression();
                                        a = classAssertion.getIndividual();
-                                        builder.append(a.toString()).append(" <").append(Namespace.RDF_TYPE).append("> ").append(c.toString()); 
+                                        builder.append(a.toString())
+                                                   .append(" <")
+                                                   .append(Namespace.RDF_TYPE)
+                                                   .append("> ")
+                                                   .append(c.toString());
                                }
                                else if (axiom instanceof OWLObjectPropertyAssertionAxiom) {
-                                        OWLObjectPropertyAssertionAxiom propertyAssertion = (OWLObjectPropertyAssertionAxiom) axiom; 
+                                        OWLObjectPropertyAssertionAxiom propertyAssertion = (OWLObjectPropertyAssertionAxiom) axiom;
-                                        OWLObjectProperty p = (OWLObjectProperty) propertyAssertion.getProperty(); 
+                                        OWLObjectProperty p = (OWLObjectProperty) propertyAssertion.getProperty();
-                                        a = propertyAssertion.getSubject(); 
+                                        a = propertyAssertion.getSubject();
-                                        b = propertyAssertion.getObject(); 
+                                        b = propertyAssertion.getObject();
-                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(b.toString()); 
+                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(b.toString());
                                }
                                else if (axiom instanceof OWLDataPropertyAssertionAxiom) {
-                                        OWLDataPropertyAssertionAxiom propertyAssertion = (OWLDataPropertyAssertionAxiom) axiom; 
+                                        OWLDataPropertyAssertionAxiom propertyAssertion = (OWLDataPropertyAssertionAxiom) axiom;
-                                        OWLDataProperty p = (OWLDataProperty) propertyAssertion.getProperty(); 
+                                        OWLDataProperty p = (OWLDataProperty) propertyAssertion.getProperty();
-                                        a = propertyAssertion.getSubject(); 
+                                        a = propertyAssertion.getSubject();
-                                        OWLLiteral l = propertyAssertion.getObject(); 
+                                        OWLLiteral l = propertyAssertion.getObject();
-                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(l.toString()); 
+                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(l.toString());
                                }
-                                
                                writer.write(builder.toString());
                                writer.write(" .");
                                writer.newLine();
@@ -427,23 +451,19 @@ public class QueryRecord {
                } catch (IOException e) {
                        e.printStackTrace();
                } finally {
-                        
                }
        }
-        int subID; 
        
        public void updateSubID() {
-                ++subID; 
+                ++subID;
                stringQueryID = String.valueOf(queryID) + "_" + subID;
        }
-        
-        DLClause queryClause = null; 
        public DLClause getClause() {
                if (queryClause != null)
-                        return queryClause; 
+                        return queryClause;
-                return queryClause = DLClauseHelper.getQuery(queryText, null); 
+                return queryClause = DLClauseHelper.getQuery(queryText, null);
        }
        public boolean isBottom() {
@@ -453,19 +473,19 @@ public class QueryRecord {
        public int getNoOfCompleteAnswers() {
                return soundAnswerTuples.size() + gapAnswerTuples.size();
        }
-        
        public int getSubID() {
-                return subID; 
+                return subID;
        }
-        
        public boolean hasSameGapAnswers(QueryRecord that) {
-                return gapAnswerTuples.containsAll(that.gapAnswerTuples) && that.gapAnswerTuples.containsAll(gapAnswerTuples); 
+                return gapAnswerTuples.containsAll(that.gapAnswerTuples) && that.gapAnswerTuples.containsAll(gapAnswerTuples);
        }
        public void dispose() {
-                m_manager.remove(queryText); 
+                m_manager.remove(queryText);
-                if (gapAnswerTuples != null) gapAnswerTuples = null; 
+                if(gapAnswerTuples != null) gapAnswerTuples = null;
-                if (soundAnswerTuples != null) soundAnswerTuples = null; 
+                if(soundAnswerTuples != null) soundAnswerTuples = null;
                if (relevantClauses != null) relevantClauses.clear();
                if (relevantOntology != null)
                        relevantOntology.getOWLOntologyManager().removeOntology(relevantOntology);
@@ -473,75 +493,85 @@ public class QueryRecord {
        }
        public boolean canBeEncodedIntoAtom() {
-                // FIXME 
+                // FIXME
-                return true; 
+                return true;
 //              return false;
        }
-        
        public boolean isPredicate(AnswerTuple a, int i) {
-                Atom[] atoms = getClause().getBodyAtoms(); 
+                Atom[] atoms = getClause().getBodyAtoms();
-                Variable v = Variable.create(answerVariables[1][i]); 
+                Variable v = Variable.create(answerVariables[1][i]);
-                String iri; 
+                String iri;
-                for (Atom atom: atoms) { 
+                for(Atom atom : atoms) {
                        DLPredicate p = atom.getDLPredicate();
                        if (p instanceof AtomicConcept) {
-                                if (((AtomicConcept) p).getIRI().equals(v.toString())) return true; 
+                                if(((AtomicConcept) p).getIRI().equals(v.toString())) return true;
                        }
                        else if (p instanceof AtomicRole) {
-                                iri = ((AtomicRole) p).getIRI(); 
+                                iri = ((AtomicRole) p).getIRI();
                                if (iri.equals(v.toString())) return true;
-                                if (iri.startsWith("?")) 
+                                if(iri.startsWith("?"))
-                                        iri = a.getGroundTerm(i).toString(); 
+                                        iri = a.getGroundTerm(i).toString();
-                                if (iri.equals(Namespace.RDF_TYPE) && atom.getArgument(1).equals(v)) return true; 
+                                if(iri.equals(Namespace.RDF_TYPE) && atom.getArgument(1).equals(v)) return true;
                        }
                }
                return false;
        }
-        
-        public String[] getExtendedQueryText() {
+        // TODO remove fully extended query
-                String[] ret = new String[2]; 
+        public Tuple<String> getExtendedQueryText() {
-                int index = queryText.toUpperCase().indexOf(" WHERE"); 
+//              String[] ret = new String[2];s
-                String extendedSelect = queryText.substring(0, index); 
+                int index = queryText.toUpperCase().indexOf(" WHERE");
+                String extendedSelect = queryText.substring(0, index);
                String extendedWhere= queryText.substring(index + 1), fullyExtendedWhere = queryText.substring(index + 1);
-                
-                String sub, obj; 
+                String sub, obj;
                Map<String, Set<String>> links = new HashMap<String, Set<String>>();
-                Set<String> list; 
+                Set<String> list;
                for (Atom atom: getClause().getBodyAtoms())
                        if (atom.getDLPredicate() instanceof AtomicRole && atom.getArgument(0) instanceof Variable && atom.getArgument(1) instanceof Variable) {
-                                sub = atom.getArgumentVariable(0).getName(); 
+                                sub = atom.getArgumentVariable(0).getName();
                                obj = atom.getArgumentVariable(1).getName();
-                                if ((list = links.get(sub)) == null) 
+                                if((list = links.get(sub)) == null)
-                                        links.put(sub, list = new HashSet<String>()); 
+                                        links.put(sub, list = new HashSet<String>());
-                                list.add(obj); 
+                                list.add(obj);
-                                if ((list = links.get(obj)) == null) 
+                                if((list = links.get(obj)) == null)
-                                        links.put(obj, list = new HashSet<String>()); 
+                                        links.put(obj, list = new HashSet<String>());
-                                list.add(sub); 
+                                list.add(sub);
                        }
-                
-                StringBuilder extra = new StringBuilder(), fullyExtra = new StringBuilder(); 
+                StringBuilder extra = new StringBuilder(), fullyExtra = new StringBuilder();
 //              if (answerVariables[0] != answerVariables[1]) {
                        for (int i = answerVariables[0].length; i < answerVariables[1].length; ++i) {
 //                      for (int i = 0; i < answerVariables[1].length; ++i) {
-                                fullyExtra.append(" . ?").append(answerVariables[1][i]).append(" a <").append(Namespace.PAGODA_ORIGINAL).append(">");
+                                fullyExtra.append(" . ?")
+                                                  .append(answerVariables[1][i])
+                                                  .append(" " + RDF_TYPE + " <")
+                                                  .append(Namespace.PAGODA_ORIGINAL)
+                                                  .append(">");
                                if ((list = links.get(answerVariables[1][i])) == null || list.size() < 2) ;
                                else {
-                                        extra.append(" . ?").append(answerVariables[1][i]).append(" a <").append(Namespace.PAGODA_ORIGINAL).append(">");
+                                        extra.append(" . ?")
-                                }                               
+                                                 .append(answerVariables[1][i])
+                                                 .append(" " + RDF_TYPE + " <")
+                                                 .append(Namespace.PAGODA_ORIGINAL)
+                                                 .append(">");
+                                }
                        }
-                        
-                        if (extra.length() > 0) {
+                if(extra.length() > 0) {
-                                extra.append(" }"); 
+                        extra.append(" }");
                                extendedWhere = extendedWhere.replace(" }", extendedWhere.contains(". }") ? extra.substring(2) : extra.toString());
                        }
-                        
-                        if (fullyExtra.length() > 0) {
+                if(fullyExtra.length() > 0) {
-                                fullyExtra.append(" }"); 
+                        fullyExtra.append(" }");
                                fullyExtendedWhere = fullyExtendedWhere.replace(" }", fullyExtendedWhere.contains(". }") ? fullyExtra.substring(2) : fullyExtra.toString());
                        }
 //              }
-                
-                ret[0] = extendedSelect + " " + fullyExtendedWhere; 
+                TupleBuilder result = new TupleBuilder();
+                result.append(extendedSelect + " " + fullyExtendedWhere);
                extra.setLength(0);
                if (answerVariables[0] != answerVariables[1]) {
@@ -549,14 +579,125 @@ public class QueryRecord {
                                extra.append(" ?").append(answerVariables[1][i]);
                        extendedSelect = extendedSelect + extra.toString();
                }
-                ret[1] = extendedSelect + " " + extendedWhere; 
+                result.append(extendedSelect + " " + extendedWhere);
-                
-                return ret; 
+                return result.build();
        }
        public boolean hasNonAnsDistinguishedVariables() {
                return answerVariables[1].length > answerVariables[0].length;
        }
-        
+        /**
+         * Two <tt>QueryRecords</tt> are equal iff
+         * they have the same <tt>queryText</tt>,
+         * <tt>soundAnswerTuples</tt>.
+         */
+        @Override
+        public boolean equals(Object o) {
+                if(!o.getClass().equals(getClass())) return false;
+                QueryRecord that = (QueryRecord) o;
+                return this.queryText.equals(that.queryText)
+                                && soundAnswerTuples.equals(that.soundAnswerTuples);
+        }
+        @Override
+        public int hashCode() {
+                return Objects.hash(queryText, soundAnswerTuples);
+        }
+        public enum Step {
+                LOWER_BOUND,
+                UPPER_BOUND,
+                SIMPLE_UPPER_BOUND,
+                LAZY_UPPER_BOUND,
+                L_SKOLEM_UPPER_BOUND,
+                EL_LOWER_BOUND,
+                FRAGMENT,
+                FRAGMENT_REFINEMENT,
+                SUMMARISATION,
+                DEPENDENCY,
+                FULL_REASONING
+        }
+        /**
+         * A Json serializer, which considers the main attributes.
+         */
+        public static class QueryRecordSerializer implements JsonSerializer<QueryRecord> {
+                public JsonElement serialize(QueryRecord src, Type typeOfSrc, JsonSerializationContext context) {
+                        Gson gson = new GsonBuilder().setPrettyPrinting().create();
+                        JsonObject object = new JsonObject();
+                        object.addProperty("queryID", src.queryID);
+                        object.addProperty("queryText", src.queryText);
+//                      object.addProperty("difficulty", src.difficulty != null ? src.difficulty.toString() : "");
+                        object.add("answerVariables", context.serialize(src.getAnswerVariables()));
+                        object.add("answers", context.serialize(src.soundAnswerTuples));
+//                      object.add("gapAnswers", context.serialize(src.gapAnswerTuples));
+                        return object;
+                }
+        }
+        /**
+         * A Json deserializer, compliant to the output of the serializer defined above.
+         */
+        public static class QueryRecordDeserializer implements JsonDeserializer<QueryRecord> {
+                public QueryRecord deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+                                throws JsonParseException {
+                        QueryRecord record = new QueryRecord();
+                        JsonObject object = json.getAsJsonObject();
+                        record.queryID = object.getAsJsonPrimitive("queryID").getAsInt();
+                        record.queryText = object.getAsJsonPrimitive("queryText").getAsString();
+//                      record.difficulty = Step.valueOf(object.getAsJsonPrimitive("difficulty").getAsString());
+                        JsonArray answerVariablesJson = object.getAsJsonArray("answerVariables");
+                        record.answerVariables = new String[2][];
+                        record.answerVariables[0] = new String[answerVariablesJson.size()];
+                        for(int i = 0; i < answerVariablesJson.size(); i++)
+                                record.answerVariables[0][i] = answerVariablesJson.get(i).getAsString();
+                        record.soundAnswerTuples = new HashSet<>();
+//                      record.gapAnswerTuples = new HashSet<>();
+                        Type type = new TypeToken<AnswerTuple>() { }.getType();
+                        for (JsonElement answer : object.getAsJsonArray("answers")) {
+                                record.soundAnswerTuples.add(context.deserialize(answer, type));
+                        }
+//                      for (JsonElement answer : object.getAsJsonArray("gapAnswers")) {
+//                              record.soundAnswerTuples.add(context.deserialize(answer, type));
+//                      }
+                        return record;
+                }
+        }
+        /**
+         * Provides an instance (singleton) of Gson, having a specific configuration.
+         * */
+        public static class GsonCreator {
+                private static Gson gson;
+                private GsonCreator() {}
+                public static Gson getInstance() {
+                        if(gson == null) {
+                                gson = new GsonBuilder()
+                                                .registerTypeAdapter(AnswerTuple.class, new AnswerTuple.AnswerTupleSerializer())
+                                                .registerTypeAdapter(QueryRecord.class, new QueryRecord.QueryRecordSerializer())
+                                                .registerTypeAdapter(QueryRecord.class, new QueryRecord.QueryRecordDeserializer())
+                                                .registerTypeAdapter(AnswerTuple.class, new AnswerTuple.AnswerTupleDeserializer())
+                                                .disableHtmlEscaping()
+                                                .setPrettyPrinting()
+                                                .create();
+                        }
+                        return gson;
+                }
+//              public static void dispose() {
+//                      gson = null;
+//              }
+        }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager.java b/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager.java
index 9b862ce..ef9338a 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager.java
@@ -1,7 +1,5 @@
 package uk.ac.ox.cs.pagoda.reasoner;
-import java.util.LinkedList;
 import org.semanticweb.HermiT.model.Atom;
 import org.semanticweb.HermiT.model.AtomicConcept;
 import org.semanticweb.HermiT.model.DLClause;
@@ -9,141 +7,146 @@ import org.semanticweb.HermiT.model.Variable;
 import org.semanticweb.owlapi.model.OWLOntology;
 import org.semanticweb.owlapi.model.OWLOntologyCreationException;
 import org.semanticweb.owlapi.model.OWLOntologyManager;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.query.AnswerTuples;
 import uk.ac.ox.cs.pagoda.query.QueryManager;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.reasoner.full.Checker;
+import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
 import uk.ac.ox.cs.pagoda.summary.HermitSummaryFilter;
 import uk.ac.ox.cs.pagoda.tracking.QueryTracker;
 import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoder;
 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.DataStore;
+import java.util.LinkedList;
-import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
 public class ConsistencyManager {
        protected MyQueryReasoner m_reasoner;
        protected QueryManager m_queryManager;  
        
-        Timer t = new Timer(); 
+        Timer t = new Timer();
+        QueryRecord fullQueryRecord;
+        QueryRecord[] botQueryRecords;
+        LinkedList<DLClause> toAddClauses;
+        boolean fragmentExtracted = false;
        
        public ConsistencyManager(MyQueryReasoner reasoner) {
-                m_reasoner = reasoner; 
+                m_reasoner = reasoner;
-                m_queryManager = reasoner.getQueryManager(); 
+                m_queryManager = reasoner.getQueryManager();
        }
        
-        QueryRecord fullQueryRecord; 
-        QueryRecord[] botQueryRecords;
-        
-        LinkedList<DLClause> toAddClauses;
-        
        boolean checkRLLowerBound() {
                fullQueryRecord = m_queryManager.create(QueryRecord.botQueryText, 0);
-                AnswerTuples iter = null; 
+                AnswerTuples iter = null;
-                
                try {
                        iter = m_reasoner.rlLowerStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables());
                        fullQueryRecord.updateLowerBoundAnswers(iter);
                } finally {
                        iter.dispose();
                }
-                
                if (fullQueryRecord.getNoOfSoundAnswers() > 0) {
-                        Utility.logInfo("Answers to bottom in the lower bound: ", fullQueryRecord.outputSoundAnswerTuple()); 
+                        Utility.logInfo("Answers to bottom in the lower bound: ", fullQueryRecord.outputSoundAnswerTuple());
-                        return unsatisfiability(t.duration());
+                        return false;
                }
-                return true; 
+                return true;
        }
-        
        boolean checkELLowerBound() {
                fullQueryRecord.updateLowerBoundAnswers(m_reasoner.elLowerStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables()));
                if (fullQueryRecord.getNoOfSoundAnswers() > 0) {
-                        Utility.logInfo("Answers to bottom in the lower bound: ", fullQueryRecord.outputSoundAnswerTuple()); 
+                        Utility.logInfo("Answers to bottom in the lower bound: ", fullQueryRecord.outputSoundAnswerTuple());
-                        return unsatisfiability(t.duration());
+                        return true;
                }
-                return true; 
+                return true;
        }
-        
-        boolean checkLazyUpper() {
+        boolean checkUpper(BasicQueryEngine upperStore) {
-                if (m_reasoner.lazyUpperStore != null) {
+                if (upperStore != null) {
-                        AnswerTuples tuples = null; 
+                        AnswerTuples tuples = null;
                        try {
-                                tuples = m_reasoner.lazyUpperStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables());
+                                tuples = upperStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables());
                                if (!tuples.isValid()) {
-                                        Utility.logInfo("There are no contradictions derived in the lazy upper bound materialisation."); 
+                                        Utility.logInfo("There are no contradictions derived in "+ upperStore.getName() +" materialisation.");
-                                        return satisfiability(t.duration()); 
+                                        Utility.logDebug("The ontology and dataset is satisfiable.");
+                                        return true;
                                }
                        }
                        finally {
                                if (tuples != null) tuples.dispose();
                        }
                }
-                return false; 
+                return false;
        }
-        
+        void dispose() {
+                fullQueryRecord.dispose();
+        }
+//      protected boolean unsatisfiability(double duration) {
+//              fullQueryRecord.dispose();
+//              Utility.logDebug("The ontology and dataset is unsatisfiable.");
+//              return false;
+//      }
+//      protected boolean satisfiability(double duration) {
+//              fullQueryRecord.dispose();
+//              Utility.logDebug("The ontology and dataset is satisfiable.");
+//              return true;
+//      }
        boolean check() {
-//              if (!checkRLLowerBound()) return false; 
+//              if (!checkRLLowerBound()) return false;
-//              if (!checkELLowerBound()) return false;  
+//              if (!checkELLowerBound()) return false;
-//              if (checkLazyUpper()) return true; 
+//              if (checkLazyUpper()) return true;
-                AnswerTuples iter = null; 
+                AnswerTuples iter = null;
-                
                try {
-                        iter = m_reasoner.trackingStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables()); 
+                        iter =
+                                        m_reasoner.trackingStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables());
                        fullQueryRecord.updateUpperBoundAnswers(iter);
                } finally {
-                        if (iter != null) iter.dispose();
+                        if(iter != null) iter.dispose();
                }
-                
-                if (fullQueryRecord.getNoOfCompleteAnswers() == 0)
+                if(fullQueryRecord.getNoOfCompleteAnswers() == 0)
-                        return satisfiability(t.duration()); 
+                        return true;
-                
                extractBottomFragment();
-                
                try {
                        extractAxioms4Full();
-                } catch (OWLOntologyCreationException e) {
+                } catch(OWLOntologyCreationException e) {
                        e.printStackTrace();
                }
 //              fullQueryRecord.saveRelevantClause();
-                
-                boolean satisfiability; 
+                boolean satisfiability;
-                
-                Checker checker; 
+                Checker checker;
-                for (QueryRecord r: getQueryRecords()) {
+                for(QueryRecord r : getQueryRecords()) {
-                        // TODO to be removed ... 
+                        // TODO to be removed ...
 //                      r.saveRelevantOntology("bottom" + r.getQueryID() + ".owl");
                        checker = new HermitSummaryFilter(r, true); // m_reasoner.factory.getSummarisedReasoner(r);
-                        satisfiability = checker.isConsistent(); 
+                        satisfiability = checker.isConsistent();
                        checker.dispose();
-                        if (!satisfiability) return unsatisfiability(t.duration()); 
+                        if(!satisfiability) return false;
                }
-                
-//              Checker checker = m_reasoner.factory.getSummarisedReasoner(fullQueryRecord); 
-//              boolean satisfiable = checker.isConsistent(); 
-//              checker.dispose();
-//              if (!satisfiable) return unsatisfiability(t.duration()); 
-                
-                return satisfiability(t.duration()); 
-        }
-        protected boolean unsatisfiability(double duration) {
+//              Checker checker = m_reasoner.factory.getSummarisedReasoner(fullQueryRecord);
-                fullQueryRecord.dispose();
+//              boolean satisfiable = checker.isConsistent();
-                Utility.logDebug("The ontology and dataset is unsatisfiable."); 
+//              checker.dispose();
-                return false;
+//              if (!satisfiable) return unsatisfiability(t.duration());
-        }
-        protected boolean satisfiability(double duration) {
-                fullQueryRecord.dispose();
-                Utility.logDebug("The ontology and dataset is satisfiable."); 
                return true;
        }
-        
-        boolean fragmentExtracted = false; 
        public void extractBottomFragment() {
                if (fragmentExtracted) return ;
@@ -174,7 +177,7 @@ public class ConsistencyManager {
                        int[] group = new int[number - 1]; 
                        for (int i = 0; i < number - 1; ++i) group[i] = i; 
                        for (int i = 0; i < number - 1; ++i)
-                                if (tempQueryRecords[i].processed()) tempQueryRecords[i].dispose();
+                                if(tempQueryRecords[i].isProcessed()) tempQueryRecords[i].dispose();
                                else if (group[i] == i) {
                                        ++bottomNumber; 
                                        record = tempQueryRecords[i]; 
@@ -188,8 +191,8 @@ public class ConsistencyManager {
                        int bottomCounter = 0;
                        botQueryRecords = new QueryRecord[bottomNumber];
                        Variable X = Variable.create("X"); 
-                        for (int i = 0; i < number - 1; ++i) 
+                        for (int i = 0; i < number - 1; ++i)
-                                if (!tempQueryRecords[i].processed()) 
+                                if(!tempQueryRecords[i].isProcessed())
                                        if (group[i] == i) {
                                                botQueryRecords[bottomCounter] = record = tempQueryRecords[i];
                                                record.resetInfo(QueryRecord.botQueryText.replace("Nothing", "Nothing_final" + (++bottomCounter)), 0, group[i] = bottomCounter);
@@ -288,5 +291,6 @@ public class ConsistencyManager {
        public QueryRecord[] getQueryRecords() {
                return botQueryRecords; 
        }
-        
 }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager2.java b/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager2.java
deleted file mode 100644
index 9c335f3..0000000
--- a/src/uk/ac/ox/cs/pagoda/reasoner/ConsistencyManager2.java
+++ /dev/null
@@ -1,78 +0,0 @@
-package uk.ac.ox.cs.pagoda.reasoner;
-import org.semanticweb.owlapi.model.OWLOntologyCreationException;
-import org.semanticweb.owlapi.model.OWLOntologyManager;
-import uk.ac.ox.cs.pagoda.query.AnswerTuples;
-import uk.ac.ox.cs.pagoda.query.QueryRecord;
-import uk.ac.ox.cs.pagoda.reasoner.full.Checker;
-import uk.ac.ox.cs.pagoda.summary.HermitSummaryFilter;
-import uk.ac.ox.cs.pagoda.tracking.QueryTracker;
-import uk.ac.ox.cs.pagoda.util.Utility;
-@Deprecated
-public class ConsistencyManager2 extends ConsistencyManager {
-        public ConsistencyManager2(MyQueryReasoner reasoner) {
-                super(reasoner);
-                fragmentExtracted = true; 
-        }
-        
-        protected boolean unsatisfiability(double duration) {
-                Utility.logDebug("The ontology and dataset is unsatisfiable."); 
-                return false;
-        }
-        protected boolean satisfiability(double duration) {
-                Utility.logDebug("The ontology and dataset is satisfiable."); 
-                return true;
-        }
-        
-        @Override
-        boolean check() {
-//              if (!checkRLLowerBound()) return false; 
-//              if (!checkELLowerBound()) return false;  
-                if (checkLazyUpper()) return true; 
-                AnswerTuples iter = null; 
-                
-                try {
-                        iter = m_reasoner.trackingStore.evaluate(fullQueryRecord.getQueryText(), fullQueryRecord.getAnswerVariables());
-                        fullQueryRecord.updateUpperBoundAnswers(iter);
-                } finally {
-                        if (iter != null) iter.dispose();
-                }
-                
-                if (fullQueryRecord.getNoOfCompleteAnswers() == 0)
-                        return satisfiability(t.duration());
-                
-                try {
-                        extractAxioms();
-                } catch (OWLOntologyCreationException e) {
-                        e.printStackTrace();
-                }
-                
-                Checker checker = new HermitSummaryFilter(fullQueryRecord, true);  // m_reasoner.factory.getSummarisedReasoner(fullQueryRecord);
-//              fullQueryRecord.saveRelevantOntology("fragment_bottom.owl");
-                boolean satisfiable = checker.isConsistent(); 
-                checker.dispose();
-                if (!satisfiable) return unsatisfiability(t.duration()); 
-                
-                return satisfiability(t.duration()); 
-        }
-        private void extractAxioms() throws OWLOntologyCreationException {
-                OWLOntologyManager manager = m_reasoner.encoder.getProgram().getOntology().getOWLOntologyManager(); 
-                fullQueryRecord.setRelevantOntology(manager.createOntology());
-                QueryTracker tracker = new QueryTracker(m_reasoner.encoder, m_reasoner.rlLowerStore, fullQueryRecord); 
-                m_reasoner.encoder.setCurrentQuery(fullQueryRecord);
-                tracker.extract(m_reasoner.trackingStore, null, true); 
-        }
-        @Override
-        public QueryRecord[] getQueryRecords() {
-                if (botQueryRecords == null)
-                        botQueryRecords = new QueryRecord[] {fullQueryRecord}; 
-                return botQueryRecords; 
-        }
-}
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/ELHOQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/ELHOQueryReasoner.java
index ab57ccf..f5a8093 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/ELHOQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/ELHOQueryReasoner.java
@@ -2,7 +2,6 @@ package uk.ac.ox.cs.pagoda.reasoner;
 import org.semanticweb.karma2.profile.ELHOProfile;
 import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.constraints.UnaryBottom;
 import uk.ac.ox.cs.pagoda.query.AnswerTuples;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
@@ -12,7 +11,7 @@ import uk.ac.ox.cs.pagoda.rules.LowerDatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
-public class ELHOQueryReasoner extends QueryReasoner {
+class ELHOQueryReasoner extends QueryReasoner {
        LowerDatalogProgram program; 
        
@@ -35,9 +34,9 @@ public class ELHOQueryReasoner extends QueryReasoner {
                } finally {
                        if (elAnswer != null) elAnswer.dispose();
                }
-                queryRecord.addProcessingTime(Step.ELLowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.EL_LOWER_BOUND, t.duration());
-                
-                queryRecord.setDifficulty(Step.ELLowerBound);
+                queryRecord.setDifficulty(Step.EL_LOWER_BOUND);
                queryRecord.markAsProcessed();
        }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/ELHOUQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/ELHOUQueryReasoner.java
index 0d24a02..c74ea58 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/ELHOUQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/ELHOUQueryReasoner.java
@@ -2,7 +2,6 @@ package uk.ac.ox.cs.pagoda.reasoner;
 import org.semanticweb.karma2.profile.ELHOProfile;
 import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
 import uk.ac.ox.cs.pagoda.owl.EqualitiesEliminator;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
@@ -15,7 +14,7 @@ import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
-public class ELHOUQueryReasoner extends QueryReasoner {
+class ELHOUQueryReasoner extends QueryReasoner {
        DatalogProgram program; 
        
@@ -26,81 +25,82 @@ public class ELHOUQueryReasoner extends QueryReasoner {
        KarmaQueryEngine elLowerStore = null; 
        
        boolean multiStageTag, equalityTag;
-        
+        String originalMarkProgram;
+        private Timer t = new Timer();
        public ELHOUQueryReasoner(boolean multiStageTag, boolean considerEqualities) {
                this.multiStageTag = multiStageTag;
                this.equalityTag = considerEqualities;
                rlLowerStore = new BasicQueryEngine("rl-lower-bound");
                elLowerStore = new KarmaQueryEngine("el-lower-bound");
-                
-                if (!multiStageTag) 
+                if(!multiStageTag)
-                        rlUpperStore = new BasicQueryEngine("rl-upper-bound"); 
+                        rlUpperStore = new BasicQueryEngine("rl-upper-bound");
-                else  
+                else
-                        rlUpperStore = new MultiStageQueryEngine("rl-upper-bound", false); 
+                        rlUpperStore = new MultiStageQueryEngine("rl-upper-bound", false);
        }
-        
-        private Timer t = new Timer(); 
        @Override
        public void evaluate(QueryRecord queryRecord) {
                AnswerTuples rlAnswer = null;
                t.reset();
                try {
-                        rlAnswer = rlLowerStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables()); 
+                        rlAnswer = rlLowerStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables());
                        queryRecord.updateLowerBoundAnswers(rlAnswer);
                } finally {
-                        if (rlAnswer != null) rlAnswer.dispose(); 
+                        if(rlAnswer != null) rlAnswer.dispose();
                }
-                queryRecord.addProcessingTime(Step.LowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.LOWER_BOUND, t.duration());
-                
-                String extendedQueryText = queryRecord.getExtendedQueryText()[0];
+                String extendedQueryText = queryRecord.getExtendedQueryText().get(0);
                String[] toQuery = queryRecord.getQueryText().equals(extendedQueryText) ?
-                                new String[] {queryRecord.getQueryText()} : 
+                                new String[]{queryRecord.getQueryText()} :
                                new String[] {queryRecord.getQueryText(), extendedQueryText};
-                                
                for (String queryText: toQuery) {
-                        rlAnswer = null; 
+                        rlAnswer = null;
                        t.reset();
                        try {
-                                rlAnswer = rlUpperStore.evaluate(queryText, queryRecord.getAnswerVariables()); 
+                                rlAnswer = rlUpperStore.evaluate(queryText, queryRecord.getAnswerVariables());
                                queryRecord.updateUpperBoundAnswers(rlAnswer);
                        } finally {
-                                if (rlAnswer != null) rlAnswer.dispose(); 
+                                if(rlAnswer != null) rlAnswer.dispose();
                        }
-                        queryRecord.addProcessingTime(Step.UpperBound, t.duration());
+                        queryRecord.addProcessingTime(Step.UPPER_BOUND, t.duration());
-                        
-                        if (queryRecord.processed()) {
+                        if(queryRecord.isProcessed()) {
-                                queryRecord.setDifficulty(Step.UpperBound);
+                                queryRecord.setDifficulty(Step.UPPER_BOUND);
-                                return ; 
+                                return;
                        }
                }
-                
                AnswerTuples elAnswer = null;
-                t.reset(); 
+                t.reset();
                try {
-                        elAnswer = elLowerStore.evaluate(extendedQueryText, queryRecord.getAnswerVariables(), queryRecord.getLowerBoundAnswers()); 
+                        elAnswer =
+                                        elLowerStore.evaluate(extendedQueryText, queryRecord.getAnswerVariables(), queryRecord.getLowerBoundAnswers());
                        queryRecord.updateLowerBoundAnswers(elAnswer);
                } finally {
                        if (elAnswer != null) elAnswer.dispose();
                }
-                queryRecord.addProcessingTime(Step.ELLowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.EL_LOWER_BOUND, t.duration());
        }
        @Override
        public void evaluateUpper(QueryRecord queryRecord) {
-                AnswerTuples rlAnswer = null; 
+                AnswerTuples rlAnswer = null;
                try {
-                        rlAnswer = rlUpperStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables()); 
+                        rlAnswer = rlUpperStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables());
                        queryRecord.updateUpperBoundAnswers(rlAnswer, true);
                } finally {
-                        if (rlAnswer != null) rlAnswer.dispose(); 
+                        if(rlAnswer != null) rlAnswer.dispose();
                }
        }
        @Override
        public void dispose() {
                if (elLowerStore != null) elLowerStore.dispose();
-                if (rlUpperStore != null) rlUpperStore.dispose();               
+                if(rlUpperStore != null) rlUpperStore.dispose();
                super.dispose();
        }
@@ -110,19 +110,17 @@ public class ELHOUQueryReasoner extends QueryReasoner {
                        EqualitiesEliminator eliminator = new EqualitiesEliminator(o);
                        o = eliminator.getOutputOntology();
                        eliminator.save();
-                }                       
+                }
+                OWLOntology ontology = o;
+                program = new DatalogProgram(ontology, properties.getToClassify());
-                OWLOntology ontology = o; 
-                program = new DatalogProgram(ontology, properties.getToClassify()); 
-                
                importData(program.getAdditionalDataFile());
-                
                elho_ontology = new ELHOProfile().getFragment(ontology);
                elLowerStore.processOntology(elho_ontology);
                originalMarkProgram = OWLHelper.getOriginalMarkProgram(ontology);
        }
-        
-        String originalMarkProgram;  
        @Override
        public boolean preprocess() {
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/HermiTReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/HermiTReasoner.java
index 5511691..d1856c9 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/HermiTReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/HermiTReasoner.java
@@ -1,32 +1,22 @@
 package uk.ac.ox.cs.pagoda.reasoner;
-import java.io.File;
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.Set;
 import org.semanticweb.HermiT.Reasoner;
-import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.*;
-import org.semanticweb.owlapi.model.OWLDataFactory;
-import org.semanticweb.owlapi.model.OWLNamedIndividual;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyCreationException;
-import org.semanticweb.owlapi.model.OWLOntologyStorageException;
 import uk.ac.ox.cs.JRDFox.model.Individual;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
 import uk.ac.ox.cs.pagoda.owl.QueryRoller;
-import uk.ac.ox.cs.pagoda.query.AnswerTuple;
+import uk.ac.ox.cs.pagoda.query.*;
-import uk.ac.ox.cs.pagoda.query.AnswerTuples;
-import uk.ac.ox.cs.pagoda.query.AnswerTuplesImp;
-import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
-import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Utility;
-public class HermiTReasoner extends QueryReasoner {
+import java.io.File;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+class HermiTReasoner extends QueryReasoner {
        
        Reasoner hermit;
        
@@ -54,15 +44,8 @@ public class HermiTReasoner extends QueryReasoner {
                OWLOntology tbox = onto;
                try {
                        onto = OWLHelper.getImportedOntology(tbox, importedData.toString().split(ImportDataFileSeparator));
-                        importedOntologyPath = OWLHelper.getOntologyPath(onto); 
+                        importedOntologyPath = OWLHelper.getOntologyPath(onto);
-                } catch (OWLOntologyCreationException e) {
+                } catch(OWLOntologyCreationException | OWLOntologyStorageException | IOException e) {
-                        // TODO Auto-generated catch block
-                        e.printStackTrace();
-                } catch (OWLOntologyStorageException e) {
-                        // TODO Auto-generated catch block
-                        e.printStackTrace();
-                } catch (IOException e) {
-                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/IterativeRefinement.java b/src/uk/ac/ox/cs/pagoda/reasoner/IterativeRefinement.java
index 447a92d..7847e7c 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/IterativeRefinement.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/IterativeRefinement.java
@@ -1,9 +1,6 @@
 package uk.ac.ox.cs.pagoda.reasoner;
-import java.io.File;
 import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
 import uk.ac.ox.cs.pagoda.constraints.UpperUnaryBottom;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
@@ -14,6 +11,8 @@ import uk.ac.ox.cs.pagoda.rules.GeneralProgram;
 import uk.ac.ox.cs.pagoda.tracking.QueryTracker;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.io.File;
 public class IterativeRefinement {
        
        private static final int depthLimit = 1; 
@@ -23,16 +22,15 @@ public class IterativeRefinement {
        BasicQueryEngine m_trackingStore;
        QueryRecord[] botQueryRecords;  
        
-        int m_depth = 0; 
+        int m_depth = 0;
+        String tempDataFile = "temp.ttl";
+        
        public IterativeRefinement(QueryRecord queryRecord, QueryTracker tracker, BasicQueryEngine trackingStore, QueryRecord[] botQueryRecords) {
-                m_record = queryRecord;                 
+                m_record = queryRecord;
-                m_tracker = tracker; 
+                m_tracker = tracker;
                m_trackingStore = trackingStore;
-                this.botQueryRecords = botQueryRecords; 
+                this.botQueryRecords = botQueryRecords;
        }
-        
-        String tempDataFile = "temp.ttl"; 
        public OWLOntology extractWithFullABox(String dataset, BottomStrategy upperBottom) {
                GeneralProgram program; 
@@ -58,8 +56,8 @@ public class IterativeRefinement {
                        } finally {
                                tEngine.dispose();
                        }
-                        
-                        if (m_record.processed())
+                        if(m_record.isProcessed())
                                return null;
                        
                        if (!update) break; 
@@ -95,8 +93,8 @@ public class IterativeRefinement {
                        } finally {
                                tEngine.dispose();
                        }
-                        
-                        if (m_record.processed())
+                        if(m_record.isProcessed())
                                return null;
                        
                        if (!update) break; 
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
index 55ecb81..618fb70 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
@@ -1,69 +1,75 @@
 package uk.ac.ox.cs.pagoda.reasoner;
-import java.util.Collection;
 import org.semanticweb.karma2.profile.ELHOProfile;
 import org.semanticweb.owlapi.model.OWLOntology;
+import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
-import uk.ac.ox.cs.pagoda.multistage.*; 
 import uk.ac.ox.cs.pagoda.owl.EqualitiesEliminator;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
-import uk.ac.ox.cs.pagoda.query.*;
+import uk.ac.ox.cs.pagoda.query.AnswerTuples;
+import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
+import uk.ac.ox.cs.pagoda.query.GapByStore4ID2;
+import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.query.QueryRecord.Step;
 import uk.ac.ox.cs.pagoda.reasoner.full.Checker;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.reasoner.light.KarmaQueryEngine;
 import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.summary.HermitSummaryFilter;
-import uk.ac.ox.cs.pagoda.tracking.*;
+import uk.ac.ox.cs.pagoda.tracking.QueryTracker;
+import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoder;
+import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoderDisjVar1;
+import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoderWithGap;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
-public class MyQueryReasoner extends QueryReasoner {
+import java.util.Collection;
-        OWLOntology ontology; 
+class MyQueryReasoner extends QueryReasoner {
-//      String additonalDataFile; 
+        OWLOntology ontology;
-        
+        DatalogProgram program;
-        DatalogProgram program; 
+//      String additonalDataFile; 
        BasicQueryEngine rlLowerStore = null;
-        BasicQueryEngine lazyUpperStore = null;  
+        BasicQueryEngine lazyUpperStore = null;
+        //      BasicQueryEngine limitedSkolemUpperStore;
+        OWLOntology elho_ontology;
 //      boolean[] namedIndividuals_lazyUpper; 
-        
+        KarmaQueryEngine elLowerStore = null;
-        OWLOntology elho_ontology; 
-        KarmaQueryEngine elLowerStore = null; 
-        
        BasicQueryEngine trackingStore = null;
-//      boolean[] namedIndividuals_tracking; 
+        //      boolean[] namedIndividuals_tracking;
-        
+        TrackingRuleEncoder encoder;
-        boolean equalityTag; 
+        private boolean equalityTag;
-        boolean multiStageTag;
+        private boolean multiStageTag;
-        
+        private Timer t = new Timer();
+        private Collection<String> predicatesWithGap = null;
+        private SatisfiabilityStatus satisfiable;
+        private ConsistencyManager consistency = new ConsistencyManager(this);
+        private boolean useUpperStores = false;
        public MyQueryReasoner() {
-                setup(true, true); 
+                setup(true, true);
        }
-        
        public MyQueryReasoner(boolean multiStageTag, boolean considerEqualities) {
-                setup(multiStageTag, considerEqualities); 
+                setup(multiStageTag, considerEqualities);
        }
-        
        private BasicQueryEngine getUpperStore(String name, boolean checkValidity) {
                if (multiStageTag)
-                        return new MultiStageQueryEngine(name, checkValidity); 
+                        return new MultiStageQueryEngine(name, checkValidity);
 //                      return new TwoStageQueryEngine(name, checkValidity);
-                else 
+                else
-                        return new BasicQueryEngine(name); 
+                        return new BasicQueryEngine(name);
        }
-        
        public void setup(boolean multiStageTag, boolean considerEqualities) {
-                satisfiable = null; 
+                satisfiable = SatisfiabilityStatus.UNCHECKED;
-                this.multiStageTag = multiStageTag; 
+                this.multiStageTag = multiStageTag;
                this.equalityTag = considerEqualities;
                rlLowerStore = new BasicQueryEngine("rl-lower-bound");
                elLowerStore = new KarmaQueryEngine("elho-lower-bound");
-                
                trackingStore = getUpperStore("tracking", false);
        }
        
@@ -75,119 +81,155 @@ public class MyQueryReasoner extends QueryReasoner {
                elLowerStore.importRDFData(name, datafile);
                trackingStore.importRDFData(name, datafile);
        }
-        
        @Override
        public void loadOntology(OWLOntology o) {
-                if (!equalityTag) {
+                if(!equalityTag) {
                        EqualitiesEliminator eliminator = new EqualitiesEliminator(o);
                        o = eliminator.getOutputOntology();
                        eliminator.save();
-                }                       
+                }
-                ontology = o; 
+                ontology = o;
                program = new DatalogProgram(ontology, properties.getToClassify());
 //              program.getLower().save();
 //              program.getUpper().save();
 //              program.getGeneral().save();
-                
-                if (multiStageTag && !program.getGeneral().isHorn()) { 
+                useUpperStores = multiStageTag && !program.getGeneral().isHorn();
-                        lazyUpperStore =  getUpperStore("lazy-upper-bound", true); // new MultiStageQueryEngine("lazy-upper-bound", true); //
+                if(useUpperStores) {
+                        lazyUpperStore = getUpperStore("lazy-upper-bound", true);
+//                      limitedSkolemUpperStore = getUpperStore("limited-skolem-upper-bound", true);
                }
-                
                importData(program.getAdditionalDataFile());
-        
                elho_ontology = new ELHOProfile().getFragment(ontology);
                elLowerStore.processOntology(elho_ontology);
        }
-        private Collection<String> predicatesWithGap = null; 
-        
        public Collection<String> getPredicatesWithGap() {
-                return predicatesWithGap; 
+                return predicatesWithGap;
-        }       
+        }
-        
        @Override
        public boolean preprocess() {
-                t.reset(); 
+                t.reset();
-                Utility.logInfo("Preprocessing ... checking satisfiability ... ");
+                Utility.logInfo("Preprocessing... checking satisfiability... ");
-                String name = "data", datafile = importedData.toString(); 
+                String name = "data", datafile = importedData.toString();
                rlLowerStore.importRDFData(name, datafile);
                rlLowerStore.materialise("lower program", program.getLower().toString());
 //              program.getLower().save();
-                if (!consistency.checkRLLowerBound()) return false;
+                if(!consistency.checkRLLowerBound()) return false;
                Utility.logInfo("The number of sameAs assertions in RL lower store: " + rlLowerStore.getSameAsNumber());
-                
                String originalMarkProgram = OWLHelper.getOriginalMarkProgram(ontology);
-                
                elLowerStore.importRDFData(name, datafile);
                elLowerStore.materialise("saturate named individuals", originalMarkProgram);
                elLowerStore.materialise("lower program", program.getLower().toString());
                elLowerStore.initialiseKarma();
-                if (!consistency.checkELLowerBound()) return false;                     
+                if(!consistency.checkELLowerBound()) return false;
-                if (lazyUpperStore != null) {
+                if(lazyUpperStore != null) {
                        lazyUpperStore.importRDFData(name, datafile);
                        lazyUpperStore.materialise("saturate named individuals", originalMarkProgram);
-                        int tag = lazyUpperStore.materialiseRestrictedly(program, null);  
+                        int tag = lazyUpperStore.materialiseRestrictedly(program, null);
-                        if (tag != 1) {
+                        if(tag != 1) {
                                lazyUpperStore.dispose();
                                lazyUpperStore = null;
                        }
-                        if (tag == -1) return false; 
+                        if(tag == -1) return false;
                }
-                if (consistency.checkLazyUpper()) {
+                if(consistency.checkUpper(lazyUpperStore)) {
-                        satisfiable = true; 
+                        satisfiable = SatisfiabilityStatus.SATISFIABLE;
-                        Utility.logInfo("time for satisfiability checking: " + t.duration()); 
+                        Utility.logInfo("time for satisfiability checking: " + t.duration());
                }
-                        
+//              if(limitedSkolemUpperStore != null) {
+//                      limitedSkolemUpperStore.importRDFData(name, datafile);
+//                      limitedSkolemUpperStore.materialise("saturate named individuals", originalMarkProgram);
+//                      int tag = limitedSkolemUpperStore.materialiseSkolemly(program, null);
+//                      if(tag != 1) {
+//                              limitedSkolemUpperStore.dispose();
+//                              limitedSkolemUpperStore = null;
+//                      }
+//                      if(tag == -1) return false;
+//              }
+//              if(satisfiable == SatisfiabilityStatus.UNCHECKED && consistency.checkUpper(limitedSkolemUpperStore)) {
+//                      satisfiable = SatisfiabilityStatus.SATISFIABLE;
+//                      Utility.logInfo("time for satisfiability checking: " + t.duration());
+//              }
                trackingStore.importRDFData(name, datafile);
                trackingStore.materialise("saturate named individuals", originalMarkProgram);
-                
 //              materialiseFullUpper();
 //              GapByStore4ID gap = new GapByStore4ID(trackingStore); 
-                GapByStore4ID gap = new GapByStore4ID2(trackingStore, rlLowerStore); 
+                GapByStore4ID gap = new GapByStore4ID2(trackingStore, rlLowerStore);
                trackingStore.materialiseFoldedly(program, gap);
-                predicatesWithGap = gap.getPredicatesWithGap(); 
+                predicatesWithGap = gap.getPredicatesWithGap();
                gap.clear();
-                
-                if (program.getGeneral().isHorn())
+                if(program.getGeneral().isHorn())
                        encoder = new TrackingRuleEncoderWithGap(program.getUpper(), trackingStore);
-                else 
+                else
-                        encoder = new TrackingRuleEncoderDisjVar1(program.getUpper(), trackingStore); 
+                        encoder = new TrackingRuleEncoderDisjVar1(program.getUpper(), trackingStore);
-//                      encoder = new TrackingRuleEncoderDisj1(program.getUpper(), trackingStore); 
+//                      encoder = new TrackingRuleEncoderDisj1(program.getUpper(), trackingStore);
-//                      encoder = new TrackingRuleEncoderDisjVar2(program.getUpper(), trackingStore); 
+//                      encoder = new TrackingRuleEncoderDisjVar2(program.getUpper(), trackingStore);
-//                      encoder = new TrackingRuleEncoderDisj2(program.getUpper(), trackingStore); 
+//                      encoder = new TrackingRuleEncoderDisj2(program.getUpper(), trackingStore);
-                
-                program.deleteABoxTurtleFile(); 
+                program.deleteABoxTurtleFile();
-                if (!isConsistent())
+                if(!isConsistent())
-                        return false; 
+                        return false;
-                
                consistency.extractBottomFragment();
-                return true; 
+                consistency.dispose();
+                return true;
        }
        
-        private Boolean satisfiable;
-        private ConsistencyManager consistency = new ConsistencyManager(this); 
-        
-        TrackingRuleEncoder encoder;
        @Override
        public boolean isConsistent() {
-                if (satisfiable == null) {
+                if(satisfiable == SatisfiabilityStatus.UNCHECKED) {
-                        satisfiable = consistency.check();              
+                        satisfiable = consistency.check() ? SatisfiabilityStatus.SATISFIABLE : SatisfiabilityStatus.UNSATISFIABLE;
                        Utility.logInfo("time for satisfiability checking: " + t.duration());
                }
-                return satisfiable; 
+                return satisfiable == SatisfiabilityStatus.SATISFIABLE;
+        }
+        /**
+         * It deals with blanks nodes differently from variables
+         * according to SPARQL semantics for OWL2 Entailment Regime.
+         * <p>
+         * In particular variables are matched only against named individuals,
+         * and blank nodes against named and anonymous individuals.
+         */
+        private boolean queryUpperStore(BasicQueryEngine upperStore, QueryRecord queryRecord,
+                                                                        Tuple<String> extendedQuery, Step step) {
+                if(queryRecord.hasNonAnsDistinguishedVariables())
+                        queryUpperBound(upperStore, queryRecord, extendedQuery.get(0), queryRecord.getAnswerVariables());
+                else
+                        queryUpperBound(upperStore, queryRecord, queryRecord.getQueryText(), queryRecord.getAnswerVariables());
+                queryRecord.addProcessingTime(step, t.duration());
+                if(queryRecord.isProcessed()) {
+                        queryRecord.setDifficulty(step);
+                        return true;
+                }
+                return false;
        }
-        
-        Timer t = new Timer();
-        private OWLOntology relevantPart(QueryRecord queryRecord) {
+        /**
+         * Returns the part of the ontology relevant for Hermit, while computing the bound answers.
+         * */
+        private boolean queryBounds(QueryRecord queryRecord) {
                AnswerTuples rlAnswer = null, elAnswer = null;
-                
-                t.reset(); 
+                t.reset();
                try {
                        rlAnswer = rlLowerStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables());
                        Utility.logDebug(t.duration());
@@ -195,130 +237,134 @@ public class MyQueryReasoner extends QueryReasoner {
                } finally {
                        if (rlAnswer != null) rlAnswer.dispose();
                }
-                queryRecord.addProcessingTime(Step.LowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.LOWER_BOUND, t.duration());
-                rlAnswer = null;
-                
                t.reset();
-                BasicQueryEngine upperStore = queryRecord.isBottom() || lazyUpperStore == null ? trackingStore : lazyUpperStore;  
-                        
+                Tuple<String> extendedQueryTexts = queryRecord.getExtendedQueryText();
-                String[] extendedQuery = queryRecord.getExtendedQueryText(); 
-                
+                Utility.logDebug("Tracking store");
-                queryUpperBound(upperStore, queryRecord, queryRecord.getQueryText(), queryRecord.getAnswerVariables());
+                if(queryUpperStore(trackingStore, queryRecord, extendedQueryTexts, Step.SIMPLE_UPPER_BOUND))
-                if (!queryRecord.processed() && !queryRecord.getQueryText().equals(extendedQuery[0]))
+                        return true;
-                        queryUpperBound(upperStore, queryRecord, extendedQuery[0], queryRecord.getAnswerVariables());
-                if (!queryRecord.processed() && queryRecord.hasNonAnsDistinguishedVariables()) 
+                if(!queryRecord.isBottom()) {
-                        queryUpperBound(upperStore, queryRecord, extendedQuery[1], queryRecord.getDistinguishedVariables());
+                        Utility.logDebug("Lazy store");
-                        
+                        if(lazyUpperStore != null && queryUpperStore(lazyUpperStore, queryRecord, extendedQueryTexts, Step.LAZY_UPPER_BOUND))
-                queryRecord.addProcessingTime(Step.UpperBound, t.duration());
+                                return true;
-                if (queryRecord.processed()) {
+//                      Utility.logDebug("Skolem store");
-                        queryRecord.setDifficulty(Step.UpperBound); 
+//                      if(limitedSkolemUpperStore != null && queryUpperStore(limitedSkolemUpperStore, queryRecord, extendedQueryTexts, Step.L_SKOLEM_UPPER_BOUND))
-                        return null;
+//                              return null;
                }
-                
                t.reset();
                try {
-                        elAnswer = elLowerStore.evaluate(extendedQuery[0], queryRecord.getAnswerVariables(), queryRecord.getLowerBoundAnswers());
+                        elAnswer = elLowerStore.evaluate(extendedQueryTexts.get(0),
+                                                                                         queryRecord.getAnswerVariables(),
+                                                                                         queryRecord.getLowerBoundAnswers());
                        Utility.logDebug(t.duration());
                        queryRecord.updateLowerBoundAnswers(elAnswer);
                } finally {
                        if (elAnswer != null) elAnswer.dispose();
                }
-                queryRecord.addProcessingTime(Step.ELLowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.EL_LOWER_BOUND, t.duration());
-                if (queryRecord.processed()) {
+                if(queryRecord.isProcessed()) {
-                        queryRecord.setDifficulty(Step.ELLowerBound); 
+                        queryRecord.setDifficulty(Step.EL_LOWER_BOUND);
-                        return null; 
+                        return true;
                }
-                
-                t.reset(); 
+                return false;
-                
-                QueryTracker tracker = new QueryTracker(encoder, rlLowerStore, queryRecord);
-                
-                OWLOntology knowledgebase; 
-                t.reset(); 
-//              if (program.getGeneral().isHorn()) {
-//                      knowledgebase = tracker.extract(lazyUpperStore, consistency.getQueryRecords(), true);
-//                      queryRecord.addProcessingTime(Step.Fragment, t.duration());
-//                      return knowledgebase; 
-//              }
-//              else { 
-                        knowledgebase = tracker.extract(trackingStore, consistency.getQueryRecords(), true);
-                        queryRecord.addProcessingTime(Step.Fragment, t.duration());
-//              }
-                
-                        if (knowledgebase.isEmpty() || queryRecord.isBottom()) 
-                                return knowledgebase; 
-                        
-                if (program.getGeneral().isHorn()) return knowledgebase; 
-//              t.reset(); 
-//              if (queryRecord.isHorn() && lazyUpperStore != null) { 
-////                    knowledgebase = tracker.extract(lazyUpperStore, consistency.getQueryRecords(), true); 
-//              } else if (queryRecord.getArity() < 3) {
-//                      IterativeRefinement iterativeRefinement = new IterativeRefinement(queryRecord, tracker, trackingStore, consistency.getQueryRecords());
-//                      knowledgebase = iterativeRefinement.extractWithFullABox(importedData.toString(), program.getUpperBottomStrategy());
-//              }
-//              
-//              queryRecord.addProcessingTime(Step.FragmentRefinement, t.duration());
-//              
-//              if (knowledgebase == null)
-//                      queryRecord.setDifficulty(Step.FragmentRefinement);
-                
-                return knowledgebase; 
        }
-//      int counter = 0; 
+        private OWLOntology extractRelevantOntologySubset(QueryRecord queryRecord) {
+                t.reset();
+                QueryTracker tracker = new QueryTracker(encoder, rlLowerStore, queryRecord);
+                OWLOntology relevantOntologySubset = tracker.extract(trackingStore, consistency.getQueryRecords(), true);
+                queryRecord.addProcessingTime(Step.FRAGMENT, t.duration());
+                return relevantOntologySubset;
+        }
        private void queryUpperBound(BasicQueryEngine upperStore, QueryRecord queryRecord, String queryText, String[] answerVariables) {
-                AnswerTuples rlAnswer = null; 
+                AnswerTuples rlAnswer = null;
                try {
                        Utility.logDebug(queryText);
                        rlAnswer = upperStore.evaluate(queryText, answerVariables);
                        Utility.logDebug(t.duration());
-                        queryRecord.updateUpperBoundAnswers(rlAnswer); 
+                        queryRecord.updateUpperBoundAnswers(rlAnswer);
                } finally {
-                        if (rlAnswer != null) rlAnswer.dispose();
+                        if(rlAnswer != null) rlAnswer.dispose();
-                        rlAnswer = null;
                }
        }
        @Override
        public void evaluate(QueryRecord queryRecord) {
-                OWLOntology knowledgebase = relevantPart(queryRecord);
+                if(queryBounds(queryRecord))
-                
+                        return;
-                if (knowledgebase == null) {
-                        Utility.logDebug("Difficulty of this query: " + queryRecord.getDifficulty());
+                OWLOntology relevantOntologySubset = extractRelevantOntologySubset(queryRecord);
-                        return ; 
-                }
+                int aBoxCount = relevantOntologySubset.getABoxAxioms(true).size();
-                
+                Utility.logInfo("Relevant ontology subset: ABox_axioms=" + aBoxCount + " TBox_axioms=" + (relevantOntologySubset
-                int aboxcount = knowledgebase.getABoxAxioms(true).size(); 
+                                .getAxiomCount() - aBoxCount));
-                Utility.logDebug("ABox axioms: " + aboxcount + " TBox axioms: " + (knowledgebase.getAxiomCount() - aboxcount)); 
+//              queryRecord.saveRelevantOntology("fragment_query" + queryRecord.getQueryID() + ".owl");
-//              queryRecord.saveRelevantOntology("fragment_query" + queryRecord.getQueryID() + ".owl"); 
-                
+                if(querySkolemisedRelevantSubset(relevantOntologySubset, queryRecord))
-                Timer t = new Timer(); 
+                        return;
-                Checker summarisedChecker = new HermitSummaryFilter(queryRecord, properties.getToCallHermiT()); 
-//              int validNumber = 
+                Timer t = new Timer();
-                summarisedChecker.check(queryRecord.getGapAnswers()); 
+                Checker summarisedChecker = new HermitSummaryFilter(queryRecord, properties.getToCallHermiT());
+                summarisedChecker.check(queryRecord.getGapAnswers());
                summarisedChecker.dispose();
                Utility.logDebug("Total time for full reasoner: " + t.duration());
-//              if (validNumber == 0) { 
+                queryRecord.markAsProcessed();
-                        queryRecord.markAsProcessed(); 
+                Utility.logDebug("Difficulty of this query: " + queryRecord.getDifficulty());
-                        Utility.logDebug("Difficulty of this query: " + queryRecord.getDifficulty());
-//              }
        }
-        
+        private boolean querySkolemisedRelevantSubset(OWLOntology relevantSubset, QueryRecord queryRecord) {
+                MultiStageQueryEngine relevantStore =
+                                new MultiStageQueryEngine("Relevant-store", true); // checkValidity is true
+                DatalogProgram relevantProgram = new DatalogProgram(relevantSubset, false); // toClassify is false
+//        relevantStore.importRDFData("data", importedData.toString()); // 2 answers more
+                relevantStore.importDataFromABoxOf(relevantSubset);
+                int materialisationResult = relevantStore.materialiseSkolemly(relevantProgram, null);
+                if(materialisationResult != 1)
+                        throw new RuntimeException("Skolemised materialisation error"); // TODO check consistency
+//        relevantStore.materialiseRestrictedly(relevantProgram, null); // it has been tried
+                return queryUpperStore(relevantStore, queryRecord, queryRecord.getExtendedQueryText(), Step.L_SKOLEM_UPPER_BOUND);
+                // the following has been tried
+//        Tuple<String> extendedQueryText = queryRecord.getExtendedQueryText();
+//        if(queryRecord.hasNonAnsDistinguishedVariables()) {
+//            queryUpperBound(relevantStore, queryRecord, extendedQueryText.get(0), queryRecord.getAnswerVariables());
+//            queryUpperBound(relevantStore, queryRecord, extendedQueryText.get(1), queryRecord.getDistinguishedVariables());
+//        }
+//        else
+//            queryUpperBound(relevantStore, queryRecord, queryRecord.getQueryText(), queryRecord.getAnswerVariables());
+//
+//              return queryRecord.isProcessed();
+        }
        @Override
        public void evaluateUpper(QueryRecord queryRecord) {
-                AnswerTuples rlAnswer = null; 
+                // TODO add new upper store
-                boolean useFull = queryRecord.isBottom() || lazyUpperStore == null; 
+                AnswerTuples rlAnswer = null;
+                boolean useFull = queryRecord.isBottom() || lazyUpperStore == null;
                try {
-                        rlAnswer = (useFull ? trackingStore: lazyUpperStore).evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables());
+                        rlAnswer =
-                        queryRecord.updateUpperBoundAnswers(rlAnswer, true); 
+                                        (useFull ? trackingStore : lazyUpperStore).evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables());
+                        queryRecord.updateUpperBoundAnswers(rlAnswer, true);
                } finally {
-                        if (rlAnswer != null) rlAnswer.dispose();
+                        if(rlAnswer != null) rlAnswer.dispose();
                }
        }
-        
        @Override
        public void dispose() {
                if (encoder != null) encoder.dispose();
@@ -326,7 +372,11 @@ public class MyQueryReasoner extends QueryReasoner {
                if (lazyUpperStore != null) lazyUpperStore.dispose();
                if (elLowerStore != null) elLowerStore.dispose();
                if (trackingStore != null) trackingStore.dispose();
+//              if(limitedSkolemUpperStore != null) limitedSkolemUpperStore.dispose();
                super.dispose();
        }
+        enum SatisfiabilityStatus {SATISFIABLE, UNSATISFIABLE, UNCHECKED}
 }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/QueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/QueryReasoner.java
index f2b7251..118c1b2 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/QueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/QueryReasoner.java
@@ -1,42 +1,44 @@
 package uk.ac.ox.cs.pagoda.reasoner;
-import java.io.BufferedWriter;
+import com.google.gson.Gson;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.util.Collection;
 import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
 import uk.ac.ox.cs.pagoda.query.AnswerTuples;
 import uk.ac.ox.cs.pagoda.query.QueryManager;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
-import uk.ac.ox.cs.pagoda.util.Properties;
+import uk.ac.ox.cs.pagoda.util.PagodaProperties;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collection;
+// TODO clean APIs
 public abstract class QueryReasoner {
-        
+        public static final String ImportDataFileSeparator = ";";
+        private static final boolean DEFAULT_MULTI_STAGES = true;
+        private static final boolean DEFAULT_EQUALITIES = true;
+        public boolean fullReasoner = this instanceof MyQueryReasoner;
+        protected StringBuilder importedData = new StringBuilder();
 //      protected boolean forSemFacet = false;
-        Properties properties;
+PagodaProperties properties;
-        
+        BufferedWriter answerWriter = null;
-        private static boolean defaultMultiStages = true; 
+        private QueryManager m_queryManager = new QueryManager();
-        private static boolean defaultEqualities = true; 
-        public static enum Type { Full, RLU, ELHOU };  
+        public static QueryReasoner getInstance(PagodaProperties p) {
-        
-        public static QueryReasoner getInstance(Properties p) {
                OWLOntology ontology = OWLHelper.loadOntology(p.getOntologyPath());
                QueryReasoner pagoda = getInstance(ontology, p);
-                pagoda.properties = p; 
+                pagoda.properties = p;
                pagoda.loadOntology(ontology);
                pagoda.importData(p.getDataPath());
                if (pagoda.preprocess()) {
                        Utility.logInfo("The ontology is consistent!");
-                        return pagoda; 
+                        return pagoda;
                }
                else {
                        System.out.println("The ontology is inconsistent!");
@@ -44,60 +46,63 @@ public abstract class QueryReasoner {
                        return null;
                }
        }
-        
        public static QueryReasoner getInstance(OWLOntology o) {
-                QueryReasoner pagoda = getInstance(Type.Full, o, defaultMultiStages, defaultEqualities);
+                QueryReasoner pagoda = getInstance(Type.Full, o, DEFAULT_MULTI_STAGES, DEFAULT_EQUALITIES);
-                pagoda.properties = new Properties(); 
+                pagoda.properties = new PagodaProperties();
-                return pagoda; 
+                return pagoda;
-        }
-        
-        public void setToClassify(boolean flag) {
-                properties.setToClassify(flag);
-        }
-        
-        public void setToCallHermiT(boolean flag) {
-                properties.setToCallHermiT(flag);
        }
-        
-        private static QueryReasoner getInstance(OWLOntology o, Properties p) {
+        private static QueryReasoner getInstance(OWLOntology o, PagodaProperties p) {
-                return getInstance(Type.Full, o, defaultMultiStages, defaultEqualities); 
+                return getInstance(Type.Full, o, DEFAULT_MULTI_STAGES, DEFAULT_EQUALITIES);
        }
-        
        public static QueryReasoner getInstance(Type type, OWLOntology o, boolean performMultiStages, boolean considerEqualities) {
-                Utility.initialise(); 
+//              Utility.initialise();
-                QueryReasoner reasoner; 
+                QueryReasoner reasoner;
                if (OWLHelper.isInOWL2RL(o)) reasoner = new RLQueryReasoner();
                else if (OWLHelper.isInELHO(o)) reasoner = new ELHOQueryReasoner();
-                else 
+                else
                switch (type) {
-                        case RLU: 
+                        case RLU:
-                                reasoner = new RLUQueryReasoner(performMultiStages, considerEqualities); break;   
+                                reasoner = new RLUQueryReasoner(performMultiStages, considerEqualities);
-                        case ELHOU: 
+                                break;
-                                reasoner = new ELHOUQueryReasoner(performMultiStages, considerEqualities); break;  
+                        case ELHOU:
-                        default: 
+                                reasoner = new ELHOUQueryReasoner(performMultiStages, considerEqualities);
-                                reasoner = new MyQueryReasoner(performMultiStages, considerEqualities); 
+                                break;
+                        default:
+                                reasoner = new MyQueryReasoner(performMultiStages, considerEqualities);
                        }
-                return reasoner; 
+                return reasoner;
+        }
+        public static QueryReasoner getHermiTReasoner(boolean toCheckSatisfiability) {
+                return new HermiTReasoner(toCheckSatisfiability);
+        }
+        public void setToClassify(boolean flag) {
+                properties.setToClassify(flag);
+        }
+        public void setToCallHermiT(boolean flag) {
+                properties.setToCallHermiT(flag);
        }
-        
-        public static final String ImportDataFileSeparator = ";"; 
-        protected StringBuilder importedData = new StringBuilder(); 
        
        public void importData(String datafile) {
                if (datafile != null && !datafile.equalsIgnoreCase("null"))
-                        importData(datafile.split(ImportDataFileSeparator)); 
+                        importData(datafile.split(ImportDataFileSeparator));
        }
        public void importData(String[] datafiles) {
                if (datafiles != null) {
                        for (String datafile: datafiles) {
-                                File file = new File(datafile); 
+                                File file = new File(datafile);
                                if (file.exists()) {
                                        if (file.isFile()) importDataFile(file);
                                        else importDataDirectory(file);
                                }
                                else {
-                                        Utility.logError("warning: file " + datafile + " doesn't exists."); 
+                                        Utility.logError("warning: file " + datafile + " doesn't exists.");
                                }
                        }
                }
@@ -115,136 +120,128 @@ public abstract class QueryReasoner {
                        datafile = file.getCanonicalPath();
                } catch (IOException e) {
                        e.printStackTrace();
-                        return ; 
+                        return;
-                } 
+                }
-                importDataFile(datafile); 
+                importDataFile(datafile);
        }
-        
        protected final void importDataFile(String datafile) {
                if (importedData.length() == 0)
-                        importedData.append(datafile); 
+                        importedData.append(datafile);
-                else 
+                else
                        importedData.append(ImportDataFileSeparator).append(datafile);
        }
-        
-        public abstract void loadOntology(OWLOntology ontology);
-        
-        public abstract boolean preprocess(); 
-        public abstract boolean isConsistent(); 
+        public abstract void loadOntology(OWLOntology ontology);
-        public boolean fullReasoner = this instanceof MyQueryReasoner; 
+        public abstract boolean preprocess();
-        public abstract void evaluate(QueryRecord record);
+        public abstract boolean isConsistent();
        
-        public abstract void evaluateUpper(QueryRecord record); 
+        public abstract void evaluate(QueryRecord record);
+        public abstract void evaluateUpper(QueryRecord record);
        
        public AnswerTuples evaluate(String queryText, boolean forFacetGeneration) {
                if (forFacetGeneration) {
                        QueryRecord record = m_queryManager.create(queryText);
                        Utility.logInfo("---------- start evaluating upper bound for Query " + record.getQueryID() + " ----------", queryText);
-                        if (!record.processed()) 
+                        if(!record.isProcessed())
                                evaluateUpper(record);
 //                      AnswerTuples tuples = record.getUpperBoundAnswers();
 //                      for (AnswerTuple tuple; tuples.isValid(); tuples.moveNext()) {
-//                              tuple = tuples.getTuple(); 
+//                              tuple = tuples.getTuple();
 //                              if (tuple.toString().contains("NC"))
-//                                      System.out.println(tuple.toString()); 
+//                                      System.out.println(tuple.toString());
 //                      }
-                        return record.getUpperBoundAnswers(); 
+                        return record.getUpperBoundAnswers();
-                }
+                } else
-                else 
+                        return evaluate(queryText);
-                        return evaluate(queryText); 
        }
        
+//      public void evaluate(Collection<QueryRecord> queryRecords) {
+//              evaluate(queryRecords);
+//      }
        public AnswerTuples evaluate(String queryText) {
-                QueryRecord record = m_queryManager.create(queryText); 
+                QueryRecord record = m_queryManager.create(queryText);
                Utility.logInfo("---------- start evaluating Query " + record.getQueryID() + " ----------", queryText);
-                if (!record.processed())
+                if(!record.isProcessed())
                        evaluate(record);
-                AnswerTuples answer = record.getAnswers(); 
+                AnswerTuples answer = record.getAnswers();
                record.dispose();
                return answer;
-  
        }
-        
        public void evaluate_shell(String queryText) {
-                QueryRecord record = m_queryManager.create(queryText); 
+                QueryRecord record = m_queryManager.create(queryText);
                Utility.logInfo("---------- start evaluating Query " + record.getQueryID() + " ----------", queryText);
-                if (!record.processed())
+                if(!record.isProcessed())
                        evaluate(record);
                Utility.logInfo("Answers to this query: ", record.outputSoundAnswerTuple());
                record.dispose();
-  
        }
        
        public void evaluate(Collection<QueryRecord> queryRecords) {
-                evaluate(queryRecords, null); 
-        }
-        
-        BufferedWriter answerWriter = null; 
-        
-        public void evaluate(Collection<QueryRecord> queryRecords, String answerFile) {
                if (!isConsistent()) {
-                        Utility.logDebug("The ontology and dataset is inconsistent."); 
+                        Utility.logDebug("The ontology and dataset is inconsistent.");
-                        return ; 
+                        return;
                }
-                
-                if (answerWriter == null && answerFile != null) {
+                if(properties.getAnswerPath() != null && answerWriter == null) {
                        try {
-                                answerWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(answerFile)));
+                                answerWriter = Files.newBufferedWriter(Paths.get(properties.getAnswerPath()));
-                        } catch (FileNotFoundException e) {
+                        } catch (IOException e) {
-                                Utility.logInfo("The answer file not found! " + answerFile);
+                                Utility.logError("The answer path is not valid!");
-                                return ; 
+                                e.printStackTrace();
-                        } 
+                        }
                }
-                
-                Timer t = new Timer(); 
+                Timer t = new Timer();
+                Gson gson = QueryRecord.GsonCreator.getInstance();
                for (QueryRecord record: queryRecords) {
-//                      if (Integer.parseInt(record.getQueryID()) != 218) continue; 
+//                      if (Integer.parseInt(record.getQueryID()) != 218) continue;
-                        Utility.logInfo("---------- start evaluating Query " + record.getQueryID() + " ----------", 
+                        Utility.logInfo("---------- start evaluating Query " + record.getQueryID() + " ----------",
                                        record.getQueryText());
-                        if (!record.processed()) {
+                        if(!record.isProcessed()) {
                                t.reset();
-                                if (!record.processed())
+                                if(!record.isProcessed())
-                                        evaluate(record); 
+                                        evaluate(record);
-                                Utility.logInfo("Total time to answer this query: " + t.duration()); 
+                                Utility.logInfo("Total time to answer this query: " + t.duration());
-                                if (!fullReasoner && !record.processed()) {
+                                if(!fullReasoner && !record.isProcessed()) {
-                                        Utility.logInfo("The query has not been fully answered in " + t.duration() + " seconds."); 
+                                        Utility.logInfo("The query has not been fully answered in " + t.duration() + " seconds.");
-                                        continue; 
+                                        continue;
                                }
                        }
-                        // FIXME: change the argument below
+                        record.outputAnswerStatistics();
-                        try {
-                                record.outputAnswers(answerWriter);
-                        } catch (IOException e) {
-                                Utility.logInfo("Error in outputing answers " + answerFile);
-                        }
                        record.outputTimes();
-                        record.dispose();
                }
+                /* TODO it can handle one call only
+                   if you call twice, you will end up with a json file with multiple roots */
+                if(answerWriter != null) gson.toJson(queryRecords, answerWriter);
+//              queryRecords.stream().forEach(record -> Utility.logDebug(gson.toJson(record)));
+                queryRecords.stream().forEach(record -> record.dispose());
        }
-        
        public void dispose() {
-                if (answerWriter != null)
+                if (answerWriter != null) {
                        try {
                                answerWriter.close();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
-                Utility.cleanup();
+                }
-        }  
+//              Utility.cleanup();
+        }
-        private QueryManager m_queryManager = new QueryManager(); 
        
        public QueryManager getQueryManager() {
                return m_queryManager; 
        }
-        public static QueryReasoner getHermiTReasoner(boolean toCheckSatisfiability) {
+        public enum Type {Full, RLU, ELHOU}
-                return new HermiTReasoner(toCheckSatisfiability);
-        }
-        
 }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/RLQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/RLQueryReasoner.java
index 3894874..bea5bbf 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/RLQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/RLQueryReasoner.java
@@ -10,18 +10,17 @@ import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxQueryEngine;
 import uk.ac.ox.cs.pagoda.rules.LowerDatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Timer;
-public class RLQueryReasoner extends QueryReasoner {
+class RLQueryReasoner extends QueryReasoner {
        
        RDFoxQueryEngine rlLowerStore = null;
-        LowerDatalogProgram program; 
+        LowerDatalogProgram program;
+        Timer t = new Timer();
        
        public RLQueryReasoner() {
-                rlLowerStore = new BasicQueryEngine("rl"); 
+                rlLowerStore = new BasicQueryEngine("rl");
        }
        
-        Timer t = new Timer(); 
-        
        @Override
        public void evaluate(QueryRecord queryRecord) {
                AnswerTuples rlAnswer = null; 
@@ -32,8 +31,8 @@ public class RLQueryReasoner extends QueryReasoner {
                } finally {
                        if (rlAnswer != null) rlAnswer.dispose();
                }
-                queryRecord.addProcessingTime(Step.LowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.LOWER_BOUND, t.duration());
-                queryRecord.setDifficulty(Step.LowerBound);
+                queryRecord.setDifficulty(Step.LOWER_BOUND);
                queryRecord.markAsProcessed();
        }
@@ -56,10 +55,8 @@ public class RLQueryReasoner extends QueryReasoner {
        public boolean preprocess() {
                rlLowerStore.importRDFData("data", importedData.toString());
                rlLowerStore.materialise("lower program", program.toString());
-                
-                if (!isConsistent())  
+                return isConsistent();
-                        return false; 
-                return true; 
        }
        @Override
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/RLUQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/RLUQueryReasoner.java
index fe4022d..547140a 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/RLUQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/RLUQueryReasoner.java
@@ -1,7 +1,6 @@
 package uk.ac.ox.cs.pagoda.reasoner;
 import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageQueryEngine;
 import uk.ac.ox.cs.pagoda.owl.EqualitiesEliminator;
 import uk.ac.ox.cs.pagoda.query.AnswerTuples;
@@ -12,26 +11,25 @@ import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
-public class RLUQueryReasoner extends QueryReasoner {
+class RLUQueryReasoner extends QueryReasoner {
        DatalogProgram program; 
        
        BasicQueryEngine rlLowerStore, rlUpperStore;
        
-        boolean multiStageTag, equalityTag; 
+        boolean multiStageTag, equalityTag;
+        Timer t = new Timer();
        
        public RLUQueryReasoner(boolean multiStageTag, boolean considerEqualities) {
                this.multiStageTag = multiStageTag;
-                this.equalityTag = considerEqualities; 
+                this.equalityTag = considerEqualities;
-                rlLowerStore = new BasicQueryEngine("rl-lower-bound"); 
+                rlLowerStore = new BasicQueryEngine("rl-lower-bound");
-                if (!multiStageTag) 
+                if(!multiStageTag)
-                        rlUpperStore = new BasicQueryEngine("rl-upper-bound"); 
+                        rlUpperStore = new BasicQueryEngine("rl-upper-bound");
-                else  
+                else
-                        rlUpperStore = new MultiStageQueryEngine("rl-upper-bound", false); 
+                        rlUpperStore = new MultiStageQueryEngine("rl-upper-bound", false);
        }
        
-        Timer t = new Timer();
-        
        @Override
        public void evaluate(QueryRecord queryRecord) {
                AnswerTuples ans = null;
@@ -43,7 +41,7 @@ public class RLUQueryReasoner extends QueryReasoner {
                } finally {
                        if (ans != null) ans.dispose();
                }
-                queryRecord.addProcessingTime(Step.LowerBound, t.duration());
+                queryRecord.addProcessingTime(Step.LOWER_BOUND, t.duration());
                
                ans = null; 
                t.reset(); 
@@ -54,10 +52,10 @@ public class RLUQueryReasoner extends QueryReasoner {
                } finally {
                        if (ans != null) ans.dispose();
                }
-                queryRecord.addProcessingTime(Step.UpperBound, t.duration());
+                queryRecord.addProcessingTime(Step.UPPER_BOUND, t.duration());
-                
-                if (queryRecord.processed())
+                if(queryRecord.isProcessed())
-                        queryRecord.setDifficulty(Step.UpperBound);
+                        queryRecord.setDifficulty(Step.UPPER_BOUND);
        }
        
        @Override
@@ -100,11 +98,9 @@ public class RLUQueryReasoner extends QueryReasoner {
                
                rlUpperStore.importRDFData("data", datafile);
                rlUpperStore.materialiseRestrictedly(program, null);
-                
-                if (!isConsistent()) 
-                        return false; 
-                return true; 
+                return isConsistent();
        }
        @Override
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/light/DLPredicateComparator.java b/src/uk/ac/ox/cs/pagoda/reasoner/light/DLPredicateComparator.java
index c22902c..05e399e 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/light/DLPredicateComparator.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/light/DLPredicateComparator.java
@@ -1,9 +1,9 @@
 package uk.ac.ox.cs.pagoda.reasoner.light;
-import java.util.Comparator;
 import uk.ac.ox.cs.pagoda.multistage.Normalisation;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
+import java.util.Comparator;
 public class DLPredicateComparator implements Comparator<String> {
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/light/KarmaQueryEngine.java b/src/uk/ac/ox/cs/pagoda/reasoner/light/KarmaQueryEngine.java
index f70dde9..f068164 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/light/KarmaQueryEngine.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/light/KarmaQueryEngine.java
@@ -1,20 +1,22 @@
-package uk.ac.ox.cs.pagoda.reasoner.light; 
+package uk.ac.ox.cs.pagoda.reasoner.light;
-import java.io.File;
+import org.semanticweb.karma2.MyKarma;
-import java.io.FileNotFoundException;
-import java.util.*;
-import org.semanticweb.karma2.*; 
 import org.semanticweb.karma2.clausifier.OntologyProcesser;
 import org.semanticweb.karma2.exception.IllegalInputOntologyException;
 import org.semanticweb.karma2.model.ConjunctiveQuery;
 import org.semanticweb.owlapi.model.OWLOntology;
-import uk.ac.ox.cs.pagoda.query.*; 
-import uk.ac.ox.cs.pagoda.util.ConjunctiveQueryHelper;
-import uk.ac.ox.cs.pagoda.util.Utility;
 import uk.ac.ox.cs.JRDFox.JRDFStoreException;
 import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.pagoda.query.AnswerTuple;
+import uk.ac.ox.cs.pagoda.query.AnswerTuples;
+import uk.ac.ox.cs.pagoda.query.AnswerTuplesImp;
+import uk.ac.ox.cs.pagoda.util.ConjunctiveQueryHelper;
+import uk.ac.ox.cs.pagoda.util.Utility;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.nio.file.Paths;
+import java.util.Set;
 public class KarmaQueryEngine extends RDFoxQueryEngine {
        
@@ -29,8 +31,8 @@ public class KarmaQueryEngine extends RDFoxQueryEngine {
 //              int index = (new Random().nextInt() % Base + Base) % Base;
 //              karmaDataFile = "karma_data" + index + ".ttl"; 
 //              karmaRuleFile = "karma_rule" + index + ".dlog";
-                karmaDataFile = Utility.TempDirectory + "karma_data.ttl"; 
+                karmaDataFile = Paths.get(Utility.getGlobalTempDirAbsolutePath(), "karma_data.ttl").toString();
-                karmaRuleFile = Utility.TempDirectory + "karma_rule.dlog";
+                karmaRuleFile =  Paths.get(Utility.getGlobalTempDirAbsolutePath(), "karma_rule.dlog").toString();
                
                reasoner = new MyKarma(); 
        }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxQueryEngine.java b/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxQueryEngine.java
index 70d0cc9..61500f5 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxQueryEngine.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxQueryEngine.java
@@ -1,8 +1,11 @@
 package uk.ac.ox.cs.pagoda.reasoner.light;
-import java.io.File;
+import org.semanticweb.owlapi.model.OWLOntology;
-import java.util.Collection;
+import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.Prefixes;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.JRDFox.store.DataStore.StoreType;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.query.AnswerTuples;
 import uk.ac.ox.cs.pagoda.reasoner.QueryEngine;
@@ -10,36 +13,51 @@ import uk.ac.ox.cs.pagoda.reasoner.QueryReasoner;
 import uk.ac.ox.cs.pagoda.tracking.AnswerTuplesWriter;
 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.Prefixes;
+import java.io.File;
-import uk.ac.ox.cs.JRDFox.store.DataStore;
+import java.util.Collection;
-import uk.ac.ox.cs.JRDFox.store.DataStore.StoreType;
 public abstract class RDFoxQueryEngine implements QueryEngine {
        
        public static final int matNoOfThreads = Runtime.getRuntime().availableProcessors() * 2;
-        
+        protected String name;
-        protected String name; 
        protected Prefixes prefixes = MyPrefixes.PAGOdAPrefixes.getRDFoxPrefixes();
        public RDFoxQueryEngine(String name) {
-                this.name = name; 
+                this.name = name;
-        } 
+        }
-        
-        public abstract DataStore getDataStore();
+        public static DataStore createDataStore() {
+                DataStore instance = null;
+                try {
+//                      instance = new DataStore("par-head-n");
+                        instance = new DataStore(StoreType.NarrowParallelHead);
+                        instance.setNumberOfThreads(matNoOfThreads);
+                        instance.initialize();
+                } catch(JRDFStoreException e) {
+                        e.printStackTrace();
+                }
+                return instance;
+        }
        
-        public abstract void dispose(); 
+        public String getName() {
+                return name;
+        }
        
+        public abstract DataStore getDataStore();
+        public abstract void dispose();
        public void importRDFData(String fileName, String importedFile) {
-                if (importedFile == null || importedFile.isEmpty()) return ; 
+                if(importedFile == null || importedFile.isEmpty()) return;
-                Timer t = new Timer(); 
+                Timer t = new Timer();
-                DataStore store = getDataStore(); 
+                DataStore store = getDataStore();
                try {
                        long oldTripleCount = store.getTriplesCount(), tripleCount;
                        for (String file: importedFile.split(QueryReasoner.ImportDataFileSeparator)) {
                                store.importTurtleFile(new File(file), prefixes);
                        }
-                        tripleCount = store.getTriplesCount(); 
+                        tripleCount = store.getTriplesCount();
                        Utility.logDebug(name + " store after importing " + fileName + ": " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)");
                        store.clearRulesAndMakeFactsExplicit();
                } catch (JRDFStoreException e) {
@@ -47,17 +65,32 @@ public abstract class RDFoxQueryEngine implements QueryEngine {
                }
                Utility.logDebug(name + " store finished importing " + fileName + " in " + t.duration() + " seconds.");
        }
-        
+        public void importDataFromABoxOf(OWLOntology ontology) {
+                DataStore store = getDataStore();
+                try {
+                        long prevTriplesCount = store.getTriplesCount();
+                        store.importOntology(ontology.getOWLOntologyManager().createOntology(ontology.getABoxAxioms(true)));
+                        long loadedTriples = store.getTriplesCount() - prevTriplesCount;
+                        Utility.logInfo(name + ": loaded " + loadedTriples + " triples from " + ontology.getABoxAxioms(true)
+                                                                                                                                                                                        .size() + " ABox axioms");
+                } catch(JRDFStoreException | OWLOntologyCreationException e) {
+                        e.printStackTrace();
+                        System.exit(1);
+                }
+        }
        public void materialise(String programName, String programText) {
-                if (programText == null) return ; 
+                if(programText == null) return;
                Timer t = new Timer();
-                DataStore store = getDataStore(); 
+                DataStore store = getDataStore();
                try {
                        long oldTripleCount = store.getTriplesCount(), tripleCount;
 //                      store.addRules(new String[] {programText});
                        store.importRules(programText);
                        store.applyReasoning();
-                        tripleCount = store.getTriplesCount(); 
+                        tripleCount = store.getTriplesCount();
                        Utility.logDebug(name + " store after materialising " + programName + ": " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)");
                        store.clearRulesAndMakeFactsExplicit();
                } catch (JRDFStoreException e) {
@@ -70,17 +103,17 @@ public abstract class RDFoxQueryEngine implements QueryEngine {
        public void evaluate(Collection<String> queryTexts, String answerFile) {
                if (queryTexts == null)
                        return ;
-                
-                int queryID = 0; 
+                int queryID = 0;
-                AnswerTuplesWriter answerWriter = new AnswerTuplesWriter(answerFile); 
+                AnswerTuplesWriter answerWriter = new AnswerTuplesWriter(answerFile);
                AnswerTuples answerTuples;
-                Timer t = new Timer(); 
+                Timer t = new Timer();
                try {
                        for (String query: queryTexts) {
                                t.reset();
-                                answerTuples = null; 
+                                answerTuples = null;
                                try {
-                                        answerTuples = evaluate(query); 
+                                        answerTuples = evaluate(query);
                                        Utility.logDebug("time to answer Query " + ++queryID + ": " + t.duration());
                                        answerWriter.write(answerTuples.getAnswerVariables(), answerTuples);
                                } finally {
@@ -90,22 +123,9 @@ public abstract class RDFoxQueryEngine implements QueryEngine {
                } finally {
                        answerWriter.close();
                }
-                
                Utility.logDebug("done computing query answers by RDFox.");
-                
-        }
-        
-        public static DataStore createDataStore() {
-                DataStore instance = null; 
-                try {
-//                      instance = new DataStore("par-head-n");
-                        instance = new DataStore(StoreType.NarrowParallelHead);
-                        instance.setNumberOfThreads(matNoOfThreads);
-                        instance.initialize();
-                } catch (JRDFStoreException e) {
-                        e.printStackTrace();
-                }
-                return instance;
        }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxTripleManager.java b/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxTripleManager.java
index c2065dc..85f8ef9 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxTripleManager.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/light/RDFoxTripleManager.java
@@ -1,35 +1,33 @@
 package uk.ac.ox.cs.pagoda.reasoner.light;
-import java.util.Collection;
+import net.sf.ehcache.Cache;
-import java.util.HashMap;
+import net.sf.ehcache.CacheManager;
-import java.util.LinkedList;
+import net.sf.ehcache.Element;
-import java.util.Map;
+import org.semanticweb.HermiT.model.*;
-import java.util.Queue;
-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.Constant;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.Equality;
-import org.semanticweb.HermiT.model.Individual;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.Term;
-import org.semanticweb.HermiT.model.Variable;
-import uk.ac.ox.cs.pagoda.owl.OWLHelper;
-import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.model.Datatype;
 import uk.ac.ox.cs.JRDFox.model.GroundTerm;
 import uk.ac.ox.cs.JRDFox.store.DataStore;
-import uk.ac.ox.cs.JRDFox.model.Datatype;
-import uk.ac.ox.cs.JRDFox.store.Dictionary;
 import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
+import uk.ac.ox.cs.JRDFox.store.Dictionary;
 import uk.ac.ox.cs.JRDFox.store.Resource;
+import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.util.Namespace;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 public class RDFoxTripleManager {
-        
-        UpdateType m_incrementally; 
+        private final Cache termsCache;
+        private static final int TERMS_CACHE_SIZE = 10000;
+        private static final int CACHE_TTL_DEFAULT = 0;
+        private static final int CACHE_TTI_DEFAULT = 0;
+        private static final boolean CACHE_ETERNAL = true;
+        private static final boolean CACHE_USE_DISK = false;
+        UpdateType m_incrementally;
 //      boolean m_incrementally; 
        DataStore m_store;
@@ -38,7 +36,19 @@ public class RDFoxTripleManager {
        
        public RDFoxTripleManager(DataStore store, boolean incrementally) {
                m_store = store;
-//              m_incrementally = incrementally; 
+//              m_incrementally = incrementally;
+                CacheManager cacheManager = CacheManager.getInstance();
+                String cacheName = "RDFoxTripleManager_" + store.hashCode();
+                if(! cacheManager.cacheExists(cacheName)) {
+                        termsCache = new Cache(cacheName,
+                                                                   TERMS_CACHE_SIZE, CACHE_USE_DISK, CACHE_ETERNAL,
+                                                                   CACHE_TTL_DEFAULT, CACHE_TTI_DEFAULT);
+                        cacheManager.addCache(termsCache);
+                }
+                else
+                        termsCache = cacheManager.getCache(cacheName);
                if (incrementally)
                        m_incrementally = UpdateType.ScheduleForAddition;
                else 
@@ -178,28 +188,25 @@ public class RDFoxTripleManager {
                return m_dict.resolveResources(lexicalForms, types)[0]; 
        }
        
-        Map<Term, Integer> termCache = new HashMap<Term, Integer>(); 
+//      Map<Term, Integer> termCache = new HashMap<Term, Integer>();
-        Queue<Term> termList = new LinkedList<Term>();
+//      Queue<Term> termQueue = new LinkedList<Term>();
-        int sizeLimit = 10000; 
        private int getResourceID(Term arg, Map<Variable, Integer> assignment) {
-                while (termCache.size() > sizeLimit) 
+                if (arg instanceof Variable) return assignment.get(arg);
-                        termCache.remove(termList.poll()); 
+                int id = -1;
-                
+                if(termsCache.isKeyInCache(arg))
-                if (arg instanceof Variable) return assignment.get((Variable) arg); 
+                        return ((int) termsCache.get(arg).getObjectValue());
-                Integer id = null; 
-                if ((id = termCache.get(arg)) != null)
-                        return id; 
-                
 //              if (arg instanceof Individual) {
                        try {
                                if (arg instanceof Individual)
-                                        termCache.put(arg, id = resolveResource(((Individual) arg).getIRI(), Datatype.IRI_REFERENCE.value())); 
+                                        termsCache.put(new Element(arg, id = resolveResource(((Individual) arg).getIRI(), Datatype.IRI_REFERENCE.value())));
                                else if (arg instanceof Constant)
-                                        termCache.put(arg, id = resolveResource(((Constant) arg).getLexicalForm(), getDatatypeID(((Constant) arg).getDatatypeURI()))); 
+                                        termsCache.put(new Element(arg, id = resolveResource(((Constant) arg).getLexicalForm(), getDatatypeID(((Constant) arg).getDatatypeURI()))));
                                
                        } catch (JRDFStoreException e) {
                                e.printStackTrace();
+                                System.exit(1);
                        } 
 //              }
                        
diff --git a/src/uk/ac/ox/cs/pagoda/rules/ApproxProgram.java b/src/uk/ac/ox/cs/pagoda/rules/ApproxProgram.java
index 3b9d6fc..acbf354 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/ApproxProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/ApproxProgram.java
@@ -1,27 +1,22 @@
 package uk.ac.ox.cs.pagoda.rules;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
 import org.semanticweb.HermiT.model.DLClause;
 import org.semanticweb.owlapi.model.OWLAxiom;
 import org.semanticweb.owlapi.model.OWLSubPropertyChainOfAxiom;
 import org.semanticweb.owlapi.model.OWLTransitiveObjectPropertyAxiom;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
+import uk.ac.ox.cs.pagoda.rules.approximators.Approximator;
+import java.util.*;
 public abstract class ApproxProgram extends Program {
-        
+        protected Approximator m_approx = null;
        /**
         * mapping from over-approximated DLClauses to DLClauses from the original ontology
         */
        Map<DLClause, Object> correspondence = new HashMap<DLClause, Object>();
        
-        protected Approximator m_approx = null; 
-        
        protected ApproxProgram() { initApproximator(); }
        
        protected abstract void initApproximator(); 
@@ -76,7 +71,7 @@ public abstract class ApproxProgram extends Program {
        public OWLAxiom getEquivalentAxiom(DLClause clause) {
                Object obj  = correspondence.get(clause);
-                while (obj != null && obj instanceof DLClause && !obj.equals(clause) && correspondence.containsKey((DLClause) obj))
+                while (obj != null && obj instanceof DLClause && !obj.equals(clause) && correspondence.containsKey(obj))
                        obj = correspondence.get(clause);
                if (obj instanceof OWLAxiom) 
                        return (OWLAxiom) obj; 
@@ -98,14 +93,14 @@ public abstract class ApproxProgram extends Program {
 class ClauseSet extends HashSet<DLClause> {
-        public ClauseSet(DLClause first, DLClause second) {
-                add(first);  
-                add(second); 
-        }
        /**
-         * 
+         *
         */
        private static final long serialVersionUID = 1L;
-        
+        public ClauseSet(DLClause first, DLClause second) {
+                add(first);
+                add(second);
+        }
 }
 \ No newline at end of file
diff --git a/src/uk/ac/ox/cs/pagoda/rules/Approximator.java b/src/uk/ac/ox/cs/pagoda/rules/Approximator.java
deleted file mode 100644
index b2edd56..0000000
--- a/src/uk/ac/ox/cs/pagoda/rules/Approximator.java
+++ /dev/null
@@ -1,62 +0,0 @@
-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;
-public interface Approximator {
-        public Collection<DLClause> convert(DLClause clause, DLClause originalClause); 
-        
-}
-class IgnoreExist implements Approximator {
-                
-        @Override
-        public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
-                Collection<DLClause> ret = new LinkedList<DLClause>(); 
-                DLPredicate p; 
-                for (Atom headAtom: clause.getHeadAtoms()) {
-                        p = headAtom.getDLPredicate(); 
-                        if (p instanceof AtLeast) return ret; 
-                }
-                
-                ret.add(clause);
-                return ret; 
-        }
-        
-}
-class IgnoreBoth implements Approximator {
-        
-        @Override
-        public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
-                Collection<DLClause> ret = new LinkedList<DLClause>();
-                
-                if (clause.getHeadLength() > 1) return ret;
-                
-                if (clause.getHeadLength() > 0) {
-                        DLPredicate predicate = clause.getHeadAtom(0).getDLPredicate();
-                        
-                        if (predicate instanceof AtLeast) return ret; 
-                }
-                
-                ret.add(clause); 
-                return ret; 
-        }
-}
-class IgnoreDisj implements Approximator {
-        
-        @Override
-        public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
-                Collection<DLClause> ret = new LinkedList<DLClause>(); 
-                if (clause.getHeadLength() > 1) return ret;  
-                ret.add(clause); 
-                return ret; 
-        }
-}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/DisjunctiveProgram.java b/src/uk/ac/ox/cs/pagoda/rules/DisjunctiveProgram.java
index 6ebe666..d50c2d4 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/DisjunctiveProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/DisjunctiveProgram.java
@@ -1,10 +1,12 @@
 package uk.ac.ox.cs.pagoda.rules;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
 public class DisjunctiveProgram extends UpperProgram {
        @Override
        protected void initApproximator() {
-                m_approx = new OverApproxExist(); 
+                m_approx = new OverApproxExist();
        }
        
 //      @Override
diff --git a/src/uk/ac/ox/cs/pagoda/rules/ExistConstantApproximator.java b/src/uk/ac/ox/cs/pagoda/rules/ExistConstantApproximator.java
new file mode 100644
index 0000000..a7afa2e
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/ExistConstantApproximator.java
@@ -0,0 +1,26 @@
+package uk.ac.ox.cs.pagoda.rules;
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.HermiT.model.Individual;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.approximators.TupleDependentApproximator;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
+import java.util.Collection;
+/**
+ * A wrapper for <tt>OverApproxExist</tt>.
+ * */
+public class ExistConstantApproximator implements TupleDependentApproximator {
+    private final OverApproxExist overApproxExist;
+    public ExistConstantApproximator() {
+        overApproxExist = new OverApproxExist();
+    }
+    @Override
+    public Collection<DLClause> convert(DLClause clause, DLClause originalClause, Collection<Tuple<Individual>> violationTuples) {
+        return overApproxExist.convert(clause, originalClause);
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/ExistentialProgram.java b/src/uk/ac/ox/cs/pagoda/rules/ExistentialProgram.java
index 64d018f..e825917 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/ExistentialProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/ExistentialProgram.java
@@ -1,5 +1,7 @@
 package uk.ac.ox.cs.pagoda.rules;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxDisj;
 public class ExistentialProgram extends UpperProgram {
 //      @Override
@@ -12,7 +14,7 @@ public class ExistentialProgram extends UpperProgram {
        @Override
        protected void initApproximator() {
-                m_approx = new OverApproxDisj();                
+                m_approx = new OverApproxDisj();
        }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/rules/ExistentialToDisjunctive.java b/src/uk/ac/ox/cs/pagoda/rules/ExistentialToDisjunctive.java
index ebe0b7d..2098f73 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/ExistentialToDisjunctive.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/ExistentialToDisjunctive.java
@@ -1,19 +1,17 @@
 package uk.ac.ox.cs.pagoda.rules;
+import org.semanticweb.HermiT.model.*;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
+import org.semanticweb.owlapi.model.OWLOntology;
+import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
+import uk.ac.ox.cs.pagoda.rules.approximators.Approximator;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.Set;
-import org.semanticweb.HermiT.model.AtLeastConcept;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.owlapi.model.OWLObjectProperty;
-import org.semanticweb.owlapi.model.OWLOntology;
-import uk.ac.ox.cs.pagoda.constraints.BottomStrategy;
 public class ExistentialToDisjunctive extends UpperProgram {
        
        Set<String> inverseFuncProperties = new HashSet<String>(); 
diff --git a/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java b/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java
index 6e17f02..199d167 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/LowerDatalogProgram.java
@@ -1,32 +1,24 @@
 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.*;
-import org.semanticweb.HermiT.model.AtomicConcept;
+import org.semanticweb.owlapi.model.*;
-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.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;
 import uk.ac.ox.cs.pagoda.constraints.UpperUnaryBottom;
 import uk.ac.ox.cs.pagoda.multistage.Normalisation;
 import uk.ac.ox.cs.pagoda.multistage.RestrictedApplication;
+import uk.ac.ox.cs.pagoda.rules.approximators.Approximator;
 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 +60,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); 
@@ -115,7 +107,26 @@ public class LowerDatalogProgram extends ApproxProgram implements IncrementalPro
        
        @Override
        protected void initApproximator() {
-                m_approx = new IgnoreBoth(); 
+                m_approx = new IgnoreBoth();
+        }
+        private class IgnoreBoth implements Approximator {
+                @Override
+                public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
+                        Collection<DLClause> ret = new LinkedList<DLClause>();
+                        if (clause.getHeadLength() > 1) return ret;
+                        if (clause.getHeadLength() > 0) {
+                                DLPredicate predicate = clause.getHeadAtom(0).getDLPredicate();
+                                if (predicate instanceof AtLeast) return ret;
+                        }
+                        ret.add(clause);
+                        return ret;
+                }
        }
 }
@@ -125,15 +136,13 @@ class ClassifyThread extends Thread {
        IncrementalProgram m_program; 
        Collection<DLClause> clauses = new LinkedList<DLClause>(); 
        
-        Variable X = Variable.create("X"), Y = Variable.create("Y"); 
+        Variable X = Variable.create("X"), Y = Variable.create("Y");
-        
+        Reasoner hermitReasoner;
+        OWLOntology ontology;
        ClassifyThread(IncrementalProgram program) {
                m_program = program;
        }
        
-        Reasoner hermitReasoner;
-        OWLOntology ontology; 
-        
        @Override
        public void run() {
                ontology = m_program.getOntology();
@@ -224,5 +233,4 @@ class ClassifyThread extends Thread {
        private Atom getAtom(OWLClass c) {
                return Atom.create(AtomicConcept.create(c.toStringID()), X);
        }
 }
 \ No newline at end of file
diff --git a/src/uk/ac/ox/cs/pagoda/rules/Program.java b/src/uk/ac/ox/cs/pagoda/rules/Program.java
index 83cd21a..2e5302b 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/Program.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/Program.java
@@ -1,39 +1,10 @@
 package uk.ac.ox.cs.pagoda.rules;
-import java.io.BufferedWriter;
-import java.io.File;
-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.List;
-import java.util.Map;
-import java.util.Set;
 import org.semanticweb.HermiT.Configuration;
-import org.semanticweb.HermiT.model.AnnotatedEquality;
+import org.semanticweb.HermiT.model.*;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicDataRange;
-import org.semanticweb.HermiT.model.AtomicNegationDataRange;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.ConstantEnumeration;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLOntology;
-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.Term;
-import org.semanticweb.HermiT.model.Variable;
 import org.semanticweb.HermiT.structural.OWLClausification;
 import org.semanticweb.owlapi.model.*;
+import org.semanticweb.simpleETL.SimpleETL;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.approx.KnowledgeBase;
 import uk.ac.ox.cs.pagoda.approx.RLPlusOntology;
@@ -44,7 +15,8 @@ import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import org.semanticweb.simpleETL.SimpleETL;
+import java.io.*;
+import java.util.*;
 public abstract class Program implements KnowledgeBase {
        
@@ -377,7 +349,7 @@ public abstract class Program implements KnowledgeBase {
        }
        
        public final String getDirectory() {
-                return Utility.TempDirectory; 
+                return Utility.getGlobalTempDirAbsolutePath();
        }
        
        public void deleteABoxTurtleFile() {
diff --git a/src/uk/ac/ox/cs/pagoda/rules/UpperDatalogProgram.java b/src/uk/ac/ox/cs/pagoda/rules/UpperDatalogProgram.java
index a4cd790..611e183 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/UpperDatalogProgram.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/UpperDatalogProgram.java
@@ -1,12 +1,13 @@
 package uk.ac.ox.cs.pagoda.rules;
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.HermiT.model.DLPredicate;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxBoth;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.DLPredicate;
 public class UpperDatalogProgram extends UpperProgram {
        
@@ -22,7 +23,7 @@ public class UpperDatalogProgram extends UpperProgram {
        @Override
        protected void initApproximator() {
-                m_approx = new OverApproxBoth();                
+                m_approx = new OverApproxBoth();
        }
        public int getBottomNumber() {
diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/Approximator.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/Approximator.java
new file mode 100644
index 0000000..f910c64
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/Approximator.java
@@ -0,0 +1,42 @@
+package uk.ac.ox.cs.pagoda.rules.approximators;
+import org.semanticweb.HermiT.model.DLClause;
+import java.util.Collection;
+public interface Approximator {
+    Collection<DLClause> convert(DLClause clause, DLClause originalClause);
+}
+// TODO remove
+//class IgnoreExist implements Approximator {
+//
+//      @Override
+//      public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
+//              Collection<DLClause> ret = new LinkedList<DLClause>();
+//              DLPredicate p;
+//              for (Atom headAtom: clause.getHeadAtoms()) {
+//                      p = headAtom.getDLPredicate();
+//                      if (p instanceof AtLeast) return ret;
+//              }
+//
+//              ret.add(clause);
+//              return ret;
+//      }
+//
+//}
+//
+//
+//
+//class IgnoreDisj implements Approximator {
+//
+//      @Override
+//      public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
+//              Collection<DLClause> ret = new LinkedList<DLClause>();
+//              if (clause.getHeadLength() > 1) return ret;
+//              ret.add(clause);
+//              return ret;
+//      }
+//}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
new file mode 100644
index 0000000..3f1ed7e
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
@@ -0,0 +1,150 @@
+package uk.ac.ox.cs.pagoda.rules.approximators;
+import org.semanticweb.HermiT.model.*;
+import uk.ac.ox.cs.pagoda.multistage.MultiStageUpperProgram;
+import uk.ac.ox.cs.pagoda.rules.ExistConstantApproximator;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
+import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+/**
+ * Approximates existential rules through a limited form of Skolemisation.
+ * <p>
+ * Given a rule and a ground 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>TupleDependentApproximator</tt>.
+ * */
+public class LimitedSkolemisationApproximator implements TupleDependentApproximator {
+    private static final Atom[] EMPTY_BODY = new Atom[0];
+    private static final Variable X = Variable.create("X");
+    private final int maxTermDepth;
+    private final TupleDependentApproximator alternativeApproximator;
+    private final SkolemTermsManager skolemTermsManager;
+    public LimitedSkolemisationApproximator(int maxTermDepth) {
+        this(maxTermDepth, new ExistConstantApproximator());
+    }
+    public LimitedSkolemisationApproximator(int maxTermDepth, TupleDependentApproximator alternativeApproximator) {
+        this.maxTermDepth = maxTermDepth;
+        this.alternativeApproximator = alternativeApproximator;
+        this.skolemTermsManager = SkolemTermsManager.getInstance();
+    }
+    @Override
+    public Collection<DLClause> convert(DLClause clause,
+                                        DLClause originalClause,
+                                        Collection<Tuple<Individual>> violationTuples) {
+        switch (clause.getHeadLength()) {
+            case 1:
+                return overApprox(clause, originalClause, violationTuples);
+            case 0:
+                return Arrays.asList(clause);
+            default:
+                throw new IllegalArgumentException(
+                        "Expected clause with head length < 1, but it is " + clause.getHeadLength());
+        }
+    }
+    private Collection<DLClause> overApprox(DLClause clause, DLClause originalClause, Collection<Tuple<Individual>> violationTuples) {
+        ArrayList<DLClause> result = new ArrayList<>();
+        for (Tuple<Individual> violationTuple : violationTuples)
+            if (getMaxDepth(violationTuple) > maxTermDepth)
+                result.addAll(alternativeApproximator.convert(clause, originalClause, null));
+            else
+                result.addAll(getGroundSkolemisation(clause, originalClause, violationTuple));
+        return result;
+    }
+    private Collection<DLClause> getGroundSkolemisation(DLClause clause,
+                                                        DLClause originalClause,
+                                                        Tuple<Individual> violationTuple) {
+        String[] commonVars = MultiStageUpperProgram.getCommonVars(clause);
+        // TODO check: strong assumption, the first tuples are the common ones
+        TupleBuilder<Individual> commonIndividualsBuilder = new TupleBuilder<>();
+        for (int i = 0; i < commonVars.length; i++)
+            commonIndividualsBuilder.append(violationTuple.get(i));
+        Tuple<Individual> commonIndividuals = commonIndividualsBuilder.build();
+        Atom headAtom = clause.getHeadAtom(0);
+//        Atom[] bodyAtoms = clause.getBodyAtoms();
+        int offset = OverApproxExist.indexOfExistential(headAtom, originalClause);
+        // BEGIN: copy and paste
+        ArrayList<DLClause> ret = new ArrayList<>();
+        DLPredicate predicate = headAtom.getDLPredicate();
+        if (predicate instanceof AtLeastConcept) {
+            AtLeastConcept atLeastConcept = (AtLeastConcept) predicate;
+            LiteralConcept concept = atLeastConcept.getToConcept();
+            Role role = atLeastConcept.getOnRole();
+            AtomicConcept atomicConcept;
+            if (concept instanceof AtomicNegationConcept) {
+                // TODO CHECK: is this already in MultiStageUpperProgram?
+                Atom atom1 = Atom.create(atomicConcept = ((AtomicNegationConcept) concept).getNegatedAtomicConcept(), X);
+                Atom atom2 = Atom.create(atomicConcept = OverApproxExist.getNegationConcept(atomicConcept), X);
+                ret.add(DLClause.create(new Atom[0], new Atom[] {atom1, atom2}));
+            }
+            else {
+                atomicConcept = (AtomicConcept) concept;
+                if (atomicConcept.equals(AtomicConcept.THING))
+                    atomicConcept = null;
+            }
+            int card = atLeastConcept.getNumber();
+            Individual[] individuals = new Individual[card];
+            SkolemTermsManager termsManager = SkolemTermsManager.getInstance();
+            for (int i = 0; i < card; ++i)
+                individuals[i] = termsManager.getFreshIndividual(originalClause,
+                                                                 offset + i,
+                                                                 commonIndividuals);
+            for (int i = 0; i < card; ++i) {
+                if (atomicConcept != null)
+                    ret.add(DLClause.create(new Atom[] {Atom.create(atomicConcept, individuals[i])}, EMPTY_BODY));
+                Atom atom = role instanceof AtomicRole ?
+                        Atom.create((AtomicRole) role, commonIndividuals.get(0), individuals[i]) :
+                        Atom.create(((InverseRole) role).getInverseOf(), individuals[i], commonIndividuals.get(0));
+                ret.add(DLClause.create(new Atom[] {atom}, EMPTY_BODY));
+            }
+            for (int i = 0; i < card; ++i)
+                for (int j = i + 1; j < card; ++j)
+                    // TODO to be checked ... different as
+                    ret.add(DLClause.create(new Atom[] {Atom.create(Inequality.INSTANCE, individuals[i], individuals[j])}, EMPTY_BODY));
+        }
+        else if (predicate instanceof AtLeastDataRange) {
+            // TODO to be implemented ...
+        }
+        else
+            ret.add(DLClause.create(new Atom[] {headAtom}, EMPTY_BODY));
+        return ret;
+        // END: copy and paste
+    }
+    public int getMaxDepth(Tuple<Individual> violationTuple) {
+        int maxDepth = 0;
+        for (Individual individual : violationTuple)
+            maxDepth = Integer.max(maxDepth, skolemTermsManager.getDepthOf(individual));
+        return maxDepth;
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/OverApproxBoth.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/OverApproxBoth.java
index 3cc2aba..ae2a2cf 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/OverApproxBoth.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/OverApproxBoth.java
@@ -1,11 +1,11 @@
-package uk.ac.ox.cs.pagoda.rules;
+package uk.ac.ox.cs.pagoda.rules.approximators;
-import java.util.Collection;
-import java.util.LinkedList;
 import org.semanticweb.HermiT.model.AtLeastDataRange;
 import org.semanticweb.HermiT.model.DLClause;
+import java.util.Collection;
+import java.util.LinkedList;
 public class OverApproxBoth implements Approximator {
        
        Approximator approxDist = new OverApproxDisj(), approxExist = new OverApproxExist();
diff --git a/src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/OverApproxDisj.java
index 5edb08e..05d9442 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/OverApproxDisj.java
@@ -1,22 +1,19 @@
-package uk.ac.ox.cs.pagoda.rules;
+package uk.ac.ox.cs.pagoda.rules.approximators;
-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>();
@@ -91,7 +88,7 @@ public class OverApproxDisj implements Approximator {
                        arguments[i] = rename(atom.getArgument(i), unifier);
                return Atom.create(atom.getDLPredicate(), arguments);
        }
-        
        public static Term rename(Term argument, Map<Variable, Term> unifier) {
                Term newArg;
                while ((newArg = unifier.get(argument)) != null) 
diff --git a/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/OverApproxExist.java
index 7e66411..028568c 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/OverApproxExist.java
@@ -1,131 +1,74 @@
-package uk.ac.ox.cs.pagoda.rules;
+package uk.ac.ox.cs.pagoda.rules.approximators;
+import org.semanticweb.HermiT.model.*;
+import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 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 uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
-import uk.ac.ox.cs.pagoda.util.Namespace;
 public class OverApproxExist implements Approximator {
-        @Override
+        public static final String negativeSuffix = "_neg";
-        public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
+        private static final Variable X = Variable.create("X");
-                Collection<DLClause> ret;
-                switch (clause.getHeadLength()) {
-                case 1:
-                        return overApprox(clause.getHeadAtom(0), clause.getBodyAtoms(), originalClause);
-                case 0:
-                        ret = new LinkedList<DLClause>();
-                        ret.add(clause); 
-                        return ret; 
-                default:
-                        ret = new LinkedList<DLClause>();
-                        for (Iterator<DLClause> iter = new DisjunctiveHeads(clause, originalClause); iter.hasNext(); )
-                                ret.add(iter.next());
-                        return ret;
-                }
-        }
-        private static int noOfExistential(DLClause originalClause) {
-                int no = 0; 
-                for (Atom atom: originalClause.getHeadAtoms())
-                        if (atom.getDLPredicate() instanceof AtLeast)
-                                no += ((AtLeast) atom.getDLPredicate()).getNumber(); 
-                return no; 
-        }
-        private static int indexOfExistential(Atom headAtom, DLClause originalClause) {
+        static int indexOfExistential(Atom headAtom, DLClause originalClause) {
-                if (!(headAtom.getDLPredicate() instanceof AtLeast)) return -1; 
+                if (!(headAtom.getDLPredicate() instanceof AtLeast)) return -1;
                AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate();
                if (alc.getToConcept() instanceof AtomicConcept) {
-                        AtomicConcept ac = (AtomicConcept) alc.getToConcept(); 
+                        AtomicConcept ac = (AtomicConcept) alc.getToConcept();
                        if (ac.getIRI().endsWith(negativeSuffix)) {
                                alc = AtLeastConcept.create(alc.getNumber(), alc.getOnRole(), AtomicNegationConcept.create(getNegationConcept(ac)));
-                                headAtom = Atom.create(alc, headAtom.getArgument(0)); 
+                                headAtom = Atom.create(alc, headAtom.getArgument(0));
                        }
                }
-                
-                int index = 0; 
+                int index = 0;
                for (Atom atom: originalClause.getHeadAtoms()) {
-                        if (atom.equals(headAtom)) 
+                        if (atom.equals(headAtom))
-                                return index; 
+                                return index;
                        if (atom.getDLPredicate() instanceof AtLeast)
-                                index += ((AtLeast) atom.getDLPredicate()).getNumber(); 
+                                index += ((AtLeast) atom.getDLPredicate()).getNumber();
                }
-                return -1; 
+                return -1;
        }
-        private static final Variable X = Variable.create("X"); 
-        public static final String negativeSuffix = "_neg"; 
-        
        public static AtomicConcept getNegationConcept(DLPredicate p) {
                if (p.equals(AtomicConcept.THING)) return AtomicConcept.NOTHING;
-                if (p.equals(AtomicConcept.NOTHING)) return AtomicConcept.THING; 
+                if (p.equals(AtomicConcept.NOTHING)) return AtomicConcept.THING;
-                
                if (p instanceof AtomicConcept) {
                        String iri = ((AtomicConcept) p).getIRI();
-                        if (iri.endsWith(negativeSuffix)) 
+                        if (iri.endsWith(negativeSuffix))
                                iri = iri.substring(0, iri.length() - 4);
-                        else 
+                        else
-                                iri += negativeSuffix; 
+                                iri += negativeSuffix;
                        return AtomicConcept.create(iri);
                }
                if (p instanceof AtLeastConcept) {
                        // FIXME !!! here
-                        return null; 
+                        return null;
                }
-                return null; 
+                return null;
-        }       
-        
-        public static final String skolemisedIndividualPrefix = Namespace.PAGODA_ANONY + "individual"; 
-        
-        private static int individualCounter = 0;
-        private static Map<DLClause, Integer> individualNumber = new HashMap<DLClause, Integer>();
-        
-        public static int getNumberOfSkolemisedIndividual() {
-                return individualCounter; 
        }
-        
-        public static Individual getNewIndividual(DLClause originalClause, int offset) {
+        @Override
-                Individual ret; 
+        public Collection<DLClause> convert(DLClause clause, DLClause originalClause) {
-                if (individualNumber.containsKey(originalClause)) {
+                Collection<DLClause> ret;
-                        ret = Individual.create(skolemisedIndividualPrefix + (individualNumber.get(originalClause) + offset));
+                switch (clause.getHeadLength()) {
-                }
+                        case 1:
-                else {
+                                return overApprox(clause.getHeadAtom(0), clause.getBodyAtoms(), originalClause);
-                        individualNumber.put(originalClause, individualCounter);
+                        case 0:
-                        ret = Individual.create(skolemisedIndividualPrefix + (individualCounter + offset));
+                                ret = new LinkedList<DLClause>();
-                        individualCounter += noOfExistential(originalClause);
+                                ret.add(clause);
-                }
+                                return ret;
-                return ret;  
+                        default:
-        }
+                                ret = new LinkedList<DLClause>();
-        
+                                for (Iterator<DLClause> iter = new DisjunctiveHeads(clause, originalClause); iter.hasNext(); )
-        public static int indexOfSkolemisedIndividual(Atom atom) {
+                                        ret.add(iter.next());
-                Term t; 
+                                return ret;
-                for (int index = 0; index < atom.getArity(); ++index) {
-                        t = atom.getArgument(index);
-                        if (t instanceof Individual && ((Individual) t).getIRI().contains(skolemisedIndividualPrefix)) return index;
                }
-                return -1; 
        }
        
        public Collection<DLClause> overApprox(Atom headAtom, Atom[] bodyAtoms, DLClause originalClause) {
@@ -142,6 +85,7 @@ public class OverApproxExist implements Approximator {
                        AtomicConcept atomicConcept = null;
                        
                        if (concept instanceof AtomicNegationConcept) {
+                                // TODO CHECK: 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})); 
@@ -154,7 +98,8 @@ public class OverApproxExist implements Approximator {
                        int card = atLeastConcept.getNumber(); 
                        Individual[] individuals = new Individual[card];
-                        for (int i = 0; i < card; ++i) individuals[i] = getNewIndividual(originalClause, offset + i);
+                        SkolemTermsManager termsManager = SkolemTermsManager.getInstance();
+                        for (int i = 0; i < card; ++i) individuals[i] = termsManager.getFreshIndividual(originalClause, offset + i);
                        
                        for (int i = 0; i < card; ++i) {
                                if (atomicConcept != null)
diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java
new file mode 100644
index 0000000..368c014
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java
@@ -0,0 +1,118 @@
+package uk.ac.ox.cs.pagoda.rules.approximators;
+import org.semanticweb.HermiT.model.*;
+import uk.ac.ox.cs.pagoda.util.Namespace;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
+import java.util.HashMap;
+import java.util.Map;
+/**
+ * If you need a Skolem term (i.e. fresh individual), ask this class.
+ */
+public class SkolemTermsManager {
+    public static final String SKOLEMISED_INDIVIDUAL_PREFIX = Namespace.PAGODA_ANONY + "individual";
+    private static SkolemTermsManager skolemTermsManager;
+    private int termsCounter = 0;
+    private Map<DLClause, Integer> mapClauseToId = new HashMap<>();
+    private Map<Individual, Integer> mapTermToDepth = new HashMap<>();
+    private int dependenciesCounter = 0;
+    // TODO replace with hashcode. in case of collision you get only a different upper bound model.
+    // TODO you can use a cash.
+    private Map<Tuple<Individual>, Integer> mapDependencyToId = new HashMap<>();
+    private SkolemTermsManager() {
+    }
+    public static int indexOfSkolemisedIndividual(Atom atom) {
+        Term t;
+        for(int index = 0; index < atom.getArity(); ++index) {
+            t = atom.getArgument(index);
+            if(t instanceof Individual && ((Individual) t).getIRI().contains(SKOLEMISED_INDIVIDUAL_PREFIX))
+                return index;
+        }
+        return -1;
+    }
+    public static SkolemTermsManager getInstance() {
+        if(skolemTermsManager == null) skolemTermsManager = new SkolemTermsManager();
+        return skolemTermsManager;
+    }
+    /**
+     * Get a fresh Individual, unique for the clause, the offset and the dependency.
+     * */
+    public Individual getFreshIndividual(DLClause originalClause, int offset, Tuple<Individual> dependency) {
+        if(!mapClauseToId.containsKey(originalClause)) {
+            mapClauseToId.put(originalClause, termsCounter);
+            termsCounter += noOfExistential(originalClause);
+        }
+        if (!mapDependencyToId.containsKey(dependency)) {
+            mapDependencyToId.put(dependency, dependenciesCounter++);
+        }
+        String termId = mapClauseToId.get(originalClause) + offset + "_" + mapDependencyToId(dependency);
+        Individual newIndividual = Individual.create(SKOLEMISED_INDIVIDUAL_PREFIX + termId);
+        int depth = 0;
+        for (Individual individual : dependency)
+            depth = Integer.max(depth, mapIndividualToDepth(individual));
+        mapTermToDepth.put(newIndividual, depth);
+        return newIndividual;
+    }
+    /**
+     * Get a fresh Individual, unique for the clause and the offset.
+     * */
+    public Individual getFreshIndividual(DLClause originalClause, int offset) {
+        if(!mapClauseToId.containsKey(originalClause)) {
+            mapClauseToId.put(originalClause, termsCounter);
+            termsCounter += noOfExistential(originalClause);
+        }
+        String termId = "" + mapClauseToId.get(originalClause) + offset;
+        Individual newIndividual = Individual.create(SKOLEMISED_INDIVIDUAL_PREFIX + termId);
+        mapTermToDepth.put(newIndividual, 0);
+        return newIndividual;
+    }
+    /**
+     * Get the depth of a term.
+     * <p>
+     * The term must have been generated by this manager.
+     * */
+    public int getDepthOf(Individual individual) {
+        return mapIndividualToDepth(individual);
+    }
+    /**
+     * Get the number of individuals generated by this manager.
+     * */
+    public int getNumberOfSkolemisedIndividual() {
+        return mapTermToDepth.keySet().size();
+    }
+    private int mapDependencyToId(Tuple<Individual> dependency) {
+        if (mapDependencyToId.containsKey(dependency)) return mapDependencyToId.get(dependency);
+        else return mapDependencyToId.put(dependency, dependenciesCounter++);
+    }
+    private int mapIndividualToDepth(Individual dependency) {
+        if(mapTermToDepth.containsKey(dependency)) return mapTermToDepth.get(dependency);
+        else return 0;
+    }
+    private int noOfExistential(DLClause originalClause) {
+        int no = 0;
+        for (Atom atom : originalClause.getHeadAtoms())
+            if (atom.getDLPredicate() instanceof AtLeast)
+                no += ((AtLeast) atom.getDLPredicate()).getNumber();
+        return no;
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/TupleDependentApproximator.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/TupleDependentApproximator.java
new file mode 100644
index 0000000..c99a1ad
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/TupleDependentApproximator.java
@@ -0,0 +1,19 @@
+package uk.ac.ox.cs.pagoda.rules.approximators;
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.HermiT.model.Individual;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
+import java.util.Collection;
+/**
+ * It can approximate clauses according to a collection of tuples of individuals.
+ * <p>
+ * In particular it can be used to approximate rules given some body instantiations.
+ */
+public interface TupleDependentApproximator {
+    Collection<DLClause> convert(DLClause clause,
+                                 DLClause originalClause,
+                                 Collection<Tuple<Individual>> individualsTuples);
+}
diff --git a/src/uk/ac/ox/cs/pagoda/summary/HermitSummaryFilter.java b/src/uk/ac/ox/cs/pagoda/summary/HermitSummaryFilter.java
index a0ecce8..90a2ed4 100644
--- a/src/uk/ac/ox/cs/pagoda/summary/HermitSummaryFilter.java
+++ b/src/uk/ac/ox/cs/pagoda/summary/HermitSummaryFilter.java
@@ -1,16 +1,6 @@
 package uk.ac.ox.cs.pagoda.summary;
-import java.util.HashSet;
+import org.semanticweb.owlapi.model.*;
-import java.util.Set;
-import org.semanticweb.owlapi.model.IRI;
-import org.semanticweb.owlapi.model.OWLAxiom;
-import org.semanticweb.owlapi.model.OWLClass;
-import org.semanticweb.owlapi.model.OWLDataFactory;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyCreationException;
-import org.semanticweb.owlapi.model.OWLOntologyManager;
 import uk.ac.ox.cs.JRDFox.model.Individual;
 import uk.ac.ox.cs.pagoda.endomorph.Endomorph;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
@@ -25,166 +15,166 @@ import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoder;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.util.HashSet;
+import java.util.Set;
 public class HermitSummaryFilter implements Checker {
-        QueryRecord m_record; 
+        public static final String QueryAnswerTermPrefix = TrackingRuleEncoder.QueryPredicate + "_term";
+        QueryRecord m_record;
        Summary summary = null;
-        HermitChecker summarisedHermiT = null; 
+        HermitChecker summarisedHermiT = null;
        boolean summarisedConsistency;
-        
        Endomorph endomorphismChecker = null;
        
        public HermitSummaryFilter(QueryRecord record, boolean toCallHermiT) {
-                m_record = record; 
+                m_record = record;
-                HermitChecker hermitChecker = new HermitChecker(record.getRelevantOntology(), record, toCallHermiT); 
+                HermitChecker hermitChecker = new HermitChecker(record.getRelevantOntology(), record, toCallHermiT);
                endomorphismChecker = new Endomorph(record, hermitChecker);
-                hermitChecker.setDependencyGraph(endomorphismChecker.getDependencyGraph()); 
+                hermitChecker.setDependencyGraph(endomorphismChecker.getDependencyGraph());
+        }
+        public static OWLOntology addOntologyWithQueryPreciate(OWLOntology ontology, QueryRecord record, AnswerTuples answers) {
+                OWLOntology newOntology = null;
+                OWLOntologyManager manager = ontology.getOWLOntologyManager();
+                OWLDataFactory factory = manager.getOWLDataFactory();
+                try {
+                        newOntology = manager.createOntology();
+                        manager.addAxioms(newOntology, ontology.getAxioms());
+                        OWLClass[] queryClass = new OWLClass[answers.getArity()];
+                        int arity = answers.getArity();
+                        for(int i = 0; i < arity; ++i)
+                                queryClass[i] = factory.getOWLClass(IRI.create(QueryAnswerTermPrefix + i));
+                        AnswerTuple answer;
+                        for(; answers.isValid(); answers.moveNext()) {
+                                answer = answers.getTuple();
+                                for(int i = 0; i < arity; ++i)
+                                        if(answer.getGroundTerm(i) instanceof Individual) {
+                                                String iri = ((Individual) answer.getGroundTerm(i)).getIRI();
+                                                if(!record.isPredicate(answer, i)) {
+                                                        manager.addAxiom(newOntology,
+                                                                                         factory.getOWLClassAssertionAxiom(
+                                                                                                         queryClass[i],
+                                                                                                         factory.getOWLNamedIndividual(IRI.create(iri))));
+                                                }
+                                        }
+                        }
+                        answers.reset();
+                } catch(OWLOntologyCreationException e) {
+                        e.printStackTrace();
+                }
+                return newOntology;
+        }
+        public static void printRelatedABoxAxioms(OWLOntology onto, String str) {
+                if(!str.startsWith("<")) str = OWLHelper.addAngles(str);
+                System.out.println("Axioms in " + onto.getOntologyID().getOntologyIRI() + " related to " + str);
+                for(OWLAxiom axiom : onto.getABoxAxioms(true))
+                        if(axiom.toString().contains(str))
+                                System.out.println(axiom);
+                System.out.println("-----------------------------");
+        }
+        public static void printRelatedTBoxAxioms(OWLOntology onto, String str) {
+                System.out.println("Axioms in " + onto.getOntologyID().getOntologyIRI() + " related to " + str);
+                for(OWLAxiom axiom : onto.getTBoxAxioms(true))
+                        if(axiom.toString().contains(str))
+                                System.out.println(axiom);
+                for(OWLAxiom axiom : onto.getRBoxAxioms(true))
+                        if(axiom.toString().contains(str))
+                                System.out.println(axiom);
+                System.out.println("-----------------------------");
        }
        
        @Override
        public boolean isConsistent() {
                if (summary == null)
-                        summary = new Summary(endomorphismChecker.getOntology(), endomorphismChecker.getGraph()); 
+                        summary = new Summary(endomorphismChecker.getOntology(), endomorphismChecker.getGraph());
-                
-                if (summarisedHermiT == null) 
+                if(summarisedHermiT == null)
                        initialiseSummarisedReasoner();
-                if (summarisedConsistency) return true; 
+                if(summarisedConsistency) return true;
-                return endomorphismChecker.isConsistent(); 
+                return endomorphismChecker.isConsistent();
        }
-        
        private void initialiseSummarisedReasoner() {
-                Timer t = new Timer(); 
+                Timer t = new Timer();
                summarisedHermiT = new HermitChecker(summary.getSummary(), summary.getSummary(m_record));
 //              summary.save("summarised_query" + m_record.getQueryID() + ".owl");
-                if (summarisedConsistency = summarisedHermiT.isConsistent()) 
+                if(summarisedConsistency = summarisedHermiT.isConsistent())
                        Utility.logDebug("The summary of ABox is consistent with the TBox.");
-                else 
+                else
                        Utility.logDebug("The summary of ABox is NOT consistent with the TBox.");
-                m_record.addProcessingTime(Step.Summarisation, t.duration());
+                m_record.addProcessingTime(Step.SUMMARISATION, t.duration());
        }
-        
        @Override
        public int check(AnswerTuples answers) {
-                Timer t = new Timer(); 
+                Timer t = new Timer();
                OWLOntology newOntology = addOntologyWithQueryPreciate(endomorphismChecker.getOntology(), m_record, answers);
-                summary = new Summary(newOntology); 
+                summary = new Summary(newOntology);
-                initialiseSummarisedReasoner(); 
+                initialiseSummarisedReasoner();
-                
                if (summarisedConsistency) {
                        Set<AnswerTuple> passed = new HashSet<AnswerTuple>(), succ = new HashSet<AnswerTuple>();
-                        Set<AnswerTuple> falsified = new HashSet<AnswerTuple>(), fail = new HashSet<AnswerTuple>(); 
+                        Set<AnswerTuple> falsified = new HashSet<AnswerTuple>(), fail = new HashSet<AnswerTuple>();
-                        
-                        int counter = 0; 
+                        int counter = 0;
                        AnswerTuple representative;
                        for (AnswerTuple answer; answers.isValid(); answers.moveNext()) {
-                                ++counter; 
+                                ++counter;
                                answer = answers.getTuple();
-                                representative = summary.getSummary(answer); 
+                                representative = summary.getSummary(answer);
-                                if (fail.contains(representative)) 
+                                if(fail.contains(representative))
                                        falsified.add(answer);
-                                else if (succ.contains(representative)) 
+                                else if(succ.contains(representative))
                                        passed.add(answer);
-                                else 
+                                else if(summarisedHermiT.check(representative)) {
-                                        if (summarisedHermiT.check(representative)) {  
                                                succ.add(representative);
                                                passed.add(answer);
                                        }
                                        else {
                                                fail.add(representative);
-                                                falsified.add(answer); 
+                                        falsified.add(answer);
                                        }
                        }
                        answers.dispose();
-                        
                        Utility.logDebug("@TIME to filter out non-answers by summarisation: " + t.duration());
-        
                        m_record.removeUpperBoundAnswers(falsified);
-                        
-                        if (m_record.processed()) {
+                        if(m_record.isProcessed()) {
-                                m_record.setDifficulty(Step.Summarisation);
+                                m_record.setDifficulty(Step.SUMMARISATION);
-                                m_record.addProcessingTime(Step.Summarisation, t.duration());
+                                m_record.addProcessingTime(Step.SUMMARISATION, t.duration());
-                                return 0; 
+                                return 0;
                        }
-                        
                        Utility.logDebug("The number of answers to be checked with HermiT: " + passed.size() + "/" + counter);
-                        
-                        m_record.setDifficulty(Step.FullReasoning);
+                        m_record.setDifficulty(Step.FULL_REASONING);
-                        m_record.addProcessingTime(Step.Summarisation, t.duration());
+                        m_record.addProcessingTime(Step.SUMMARISATION, t.duration());
-                        
                        return endomorphismChecker.check(new AnswerTuplesImp(m_record.getAnswerVariables(), passed));
                }
                else {
-                        m_record.addProcessingTime(Step.Summarisation, t.duration());
+                        m_record.addProcessingTime(Step.SUMMARISATION, t.duration());
 //                      m_record.saveRelevantOntology("fragment.owl");
-                        m_record.setDifficulty(Step.FullReasoning);
+                        m_record.setDifficulty(Step.FULL_REASONING);
                        return endomorphismChecker.check(answers);
                }
        }
-        public static final String QueryAnswerTermPrefix = TrackingRuleEncoder.QueryPredicate + "_term"; 
-        
-        public static OWLOntology addOntologyWithQueryPreciate(OWLOntology ontology, QueryRecord record, AnswerTuples answers) {
-                OWLOntology newOntology = null; 
-                OWLOntologyManager manager = ontology.getOWLOntologyManager();
-                OWLDataFactory factory = manager.getOWLDataFactory(); 
-                try {
-                         newOntology = manager.createOntology();
-                         manager.addAxioms(newOntology, ontology.getAxioms()); 
-                         
-                         OWLClass[] queryClass = new OWLClass[answers.getArity()];
-                         int arity = answers.getArity(); 
-                         for (int i = 0; i < arity; ++i)
-                                 queryClass[i] = factory.getOWLClass(IRI.create(QueryAnswerTermPrefix + i));
-                         AnswerTuple answer; 
-                         for (; answers.isValid(); answers.moveNext()) {
-                                answer = answers.getTuple();
-                                for (int i = 0; i < arity; ++i) 
-                                        if (answer.getGroundTerm(i) instanceof Individual) {
-                                                String iri = ((Individual) answer.getGroundTerm(i)).getIRI(); 
-                                                if (!record.isPredicate(answer, i)) { 
-                                                        manager.addAxiom(newOntology, 
-                                                                        factory.getOWLClassAssertionAxiom(
-                                                                                        queryClass[i], 
-                                                                                        factory.getOWLNamedIndividual(IRI.create(iri)))); 
-                                                }
-                                        }
-                         }
-                         answers.reset();
-                } catch (OWLOntologyCreationException e) {
-                        e.printStackTrace();
-                } 
-                
-                return newOntology;
-        }
-        public static void printRelatedABoxAxioms(OWLOntology onto, String str) {
-                if (!str.startsWith("<")) str = OWLHelper.addAngles(str); 
-                
-                System.out.println("Axioms in " + onto.getOntologyID().getOntologyIRI() + " related to " + str); 
-                
-                for (OWLAxiom axiom: onto.getABoxAxioms(true))
-                        if (axiom.toString().contains(str))
-                                System.out.println(axiom); 
-                
-                System.out.println("-----------------------------");
-        }
-        public static void printRelatedTBoxAxioms(OWLOntology onto, String str) {
-                
-                System.out.println("Axioms in " + onto.getOntologyID().getOntologyIRI() + " related to " + str); 
-                
-                for (OWLAxiom axiom: onto.getTBoxAxioms(true))
-                        if (axiom.toString().contains(str))
-                                System.out.println(axiom); 
-                
-                for (OWLAxiom axiom: onto.getRBoxAxioms(true))
-                        if (axiom.toString().contains(str))
-                                System.out.println(axiom); 
-                
-                System.out.println("-----------------------------");
-        }
        @Override
        public boolean check(AnswerTuple answer) {
                AnswerTuple representative = summary.getSummary(answer); 
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java b/src/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java
index 2973109..d2d041f 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/QueryTracker.java
@@ -1,24 +1,13 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Set;
 import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.owlapi.model.IRI;
+import org.semanticweb.owlapi.model.*;
-import org.semanticweb.owlapi.model.OWLAxiom;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import org.semanticweb.owlapi.model.OWLClass;
+import uk.ac.ox.cs.JRDFox.model.Datatype;
-import org.semanticweb.owlapi.model.OWLDataFactory;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
-import org.semanticweb.owlapi.model.OWLDataProperty;
+import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
-import org.semanticweb.owlapi.model.OWLLiteral;
+import uk.ac.ox.cs.JRDFox.store.Resource;
-import org.semanticweb.owlapi.model.OWLIndividual;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
-import org.semanticweb.owlapi.model.OWLObject;
-import org.semanticweb.owlapi.model.OWLObjectProperty;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyCreationException;
-import org.semanticweb.owlapi.model.OWLOntologyManager;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
@@ -30,12 +19,11 @@ import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.UFS;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.model.Datatype;
+import java.util.HashSet;
-import uk.ac.ox.cs.JRDFox.store.DataStore;
+import java.util.Iterator;
-import uk.ac.ox.cs.JRDFox.store.Resource;
+import java.util.LinkedList;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import java.util.Set;
-import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
 public class QueryTracker {
@@ -85,7 +73,7 @@ public class QueryTracker {
                        store.applyReasoning(incrementally);
                        tripleCount = store.getTriplesCount();
-                        Utility.logDebug("tracking store after materialising tracking program: "
+                        Utility.logInfo("tracking store after materialising tracking program: "
                                        + tripleCount
                                        + " ("
                                        + (tripleCount - oldTripleCount)
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java
index cee829f..b169053 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj.java
@@ -1,30 +1,14 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import java.util.Collection;
+import org.semanticweb.HermiT.model.*;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map;
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-import org.semanticweb.HermiT.model.AtLeastConcept;
-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.Individual;
-import org.semanticweb.HermiT.model.Inequality;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+import uk.ac.ox.cs.pagoda.rules.approximators.SkolemTermsManager;
 import uk.ac.ox.cs.pagoda.util.Namespace;
+import java.util.*;
 public abstract class TrackingRuleEncoderDisj extends TrackingRuleEncoderWithGap {
        public TrackingRuleEncoderDisj(UpperDatalogProgram program, BasicQueryEngine store) {
@@ -38,8 +22,9 @@ public abstract class TrackingRuleEncoderDisj extends TrackingRuleEncoderWithGap
         */
        protected void processDisjunctiveRules() {
                Map<Atom, Collection<DLClause>> auxiliaryAtoms = new HashMap<Atom, Collection<DLClause>>(); 
-                Map<Individual, Collection<DLClause>> skolemisedAtoms = new HashMap<Individual, Collection<DLClause>>(); 
+                Map<Individual, Collection<DLClause>> skolemisedAtoms = new HashMap<Individual, Collection<DLClause>>();
-                
+                SkolemTermsManager termsManager = SkolemTermsManager.getInstance();
                for (Map.Entry<DLClause, Collection<DLClause>> entry: disjunctiveRules.entrySet()) {
                        DLClause original = entry.getKey();
                        Collection<DLClause> overClauses = entry.getValue(); 
@@ -49,7 +34,7 @@ public abstract class TrackingRuleEncoderDisj extends TrackingRuleEncoderWithGap
                                DLClause subClause = iter.next(); 
                                if (DLClauseHelper.hasSubsetBodyAtoms(subClause, original)) {
                                        Atom headAtom = subClause.getHeadAtom(0);
-                                        if ((index = OverApproxExist.indexOfSkolemisedIndividual(headAtom)) != -1) {
+                                        if ((index = SkolemTermsManager.indexOfSkolemisedIndividual(headAtom)) != -1) {
                                                Individual i = (Individual) headAtom.getArgument(index);
                                                Collection<DLClause> clauses = skolemisedAtoms.get(i);
                                                if (clauses == null) {
@@ -71,7 +56,7 @@ public abstract class TrackingRuleEncoderDisj extends TrackingRuleEncoderWithGap
                                        Collection<DLClause> clauses = new HashSet<DLClause>();
                                        Individual[] individuals = new Individual[alc.getNumber()]; 
                                        for (int i = 0; i < alc.getNumber(); ++i) {
-                                                individuals[i] = OverApproxExist.getNewIndividual(original, i);
+                                                individuals[i] = termsManager.getFreshIndividual(original, i);
                                                clauses.addAll(skolemisedAtoms.get(individuals[i])); 
                                        }
                                        auxiliaryAtoms.put(getAuxiliaryAtom(original, headAtom, individuals), clauses);
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java
index e72ed96..d6b5e8b 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj1.java
@@ -1,26 +1,14 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import java.util.LinkedList;
+import org.semanticweb.HermiT.model.*;
-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.Individual;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.InverseRole;
-import org.semanticweb.HermiT.model.Term;
-import org.semanticweb.HermiT.model.Variable;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.multistage.Normalisation;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
+import java.util.LinkedList;
 public class TrackingRuleEncoderDisj1 extends TrackingRuleEncoderDisj {
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
index 6cf239f..8d79090 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
@@ -1,24 +1,12 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import org.semanticweb.HermiT.model.AtLeastConcept;
+import org.semanticweb.HermiT.model.*;
-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.Term;
-import org.semanticweb.HermiT.model.Variable;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.multistage.Normalisation;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
 public class TrackingRuleEncoderDisj2 extends TrackingRuleEncoderDisj {
@@ -56,7 +44,7 @@ public class TrackingRuleEncoderDisj2 extends TrackingRuleEncoderDisj {
        
        @Override
        protected DLPredicate generateAuxiliaryRule(AtLeastConcept p, DLClause original, Individual[] individuals) {
-                DLPredicate ret = AtomicConcept.create(getTrackingPredicate(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p, individuals))); 
+                DLPredicate ret = AtomicConcept.create(getTrackingPredicate(Normalisation.getAuxiliaryConcept4Disjunct(p, individuals)));
                Atom[] headAtom = new Atom[] {Atom.create(ret, X)};
                
                AtomicRole role = p.getOnRole() instanceof AtomicRole ? 
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
index 37116d4..d96c747 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
@@ -1,199 +1,188 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import java.util.Collection;
+import org.semanticweb.HermiT.model.*;
-import java.util.HashSet;
-import java.util.LinkedList;
-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.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.DatatypeRestriction;
-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 uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.multistage.Normalisation;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Set;
 public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
+        private Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
+        private Variable X = Variable.create("X"), Y = Variable.create("Y");
+        private String bottomTrackingProgram = null;
+        
        public TrackingRuleEncoderDisjVar1(UpperDatalogProgram program, BasicQueryEngine store) {
                super(program, store);
        }
        
-        private Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
        @Override
        public boolean encodingRules() {
                if (super.encodingRules()) {
                        processDisjunctiveRules();
-                        return true; 
+                        return true;
                }
-                return false; 
+                return false;
        }
        
        @Override
        protected void encodingRule(DLClause clause) {
                if (currentQuery.isBottom()) {
 //                      super.encodingRule(clause);
-                        encodingBottomQueryClause(clause); 
+                        encodingBottomQueryClause(clause);
-                        return ; 
+                        return;
                }
-                
                DLClause original = program.getCorrespondingClause(clause);
                if (original.getHeadLength() <= 1) {
                        super.encodingRule(clause);
-                } 
+                }
                else {
                        if (!DLClauseHelper.hasSubsetBodyAtoms(clause, original))
                                super.encodingRule(clause);
                        addDisjunctiveRule(original);
                }
-                        
        }
-        
        private void processDisjunctiveRules() {
                for (DLClause clause: disjunctiveRules)
                        encodingDisjunctiveRule(clause);
        }
-        
        private Atom getAuxiliaryAtom(Atom headAtom) {
-                DLPredicate p = headAtom.getDLPredicate(); 
+                DLPredicate p = headAtom.getDLPredicate();
                if (p instanceof AtLeast || p instanceof AtLeast) {
-                        return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0)); 
+                        return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0));
                }
-                if (p instanceof AtomicConcept) 
+                if(p instanceof AtomicConcept)
-                        return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0)); 
+                        return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0));
-                if (p instanceof AtomicRole) 
+                if(p instanceof AtomicRole)
                        return Atom.create(generateAuxiliaryRule((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Equality || p instanceof AnnotatedEquality) 
+                if(p instanceof Equality || p instanceof AnnotatedEquality)
-                        return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Inequality) 
+                if(p instanceof Inequality)
-                        return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1));
                return null;
        }
        private Atom getTrackingAtom(Atom headAtom) {
-                DLPredicate p = headAtom.getDLPredicate(); 
+                DLPredicate p = headAtom.getDLPredicate();
                if (p instanceof AtLeast) {
-                        p = Normalisation.toAtLeastConcept((AtLeast) p); 
+                        p = Normalisation.toAtLeastConcept((AtLeast) p);
-                        return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); 
+                        return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom
+                                        .getArgument(0));
                }
-                if (p instanceof AtomicConcept) 
+                if(p instanceof AtomicConcept)
-                        return Atom.create(getTrackingDLPredicate((AtomicConcept) p), headAtom.getArgument(0)); 
+                        return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0));
-                if (p instanceof AtomicRole) 
+                if(p instanceof AtomicRole)
-                        return Atom.create(getTrackingDLPredicate((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
+                        return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Equality || p instanceof AnnotatedEquality) 
+                if(p instanceof Equality || p instanceof AnnotatedEquality)
-                        return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Inequality) 
+                if(p instanceof Inequality)
-                        return Atom.create(getTrackingDLPredicate((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
                return null;
        }
        private Atom getGapAtom(Atom headAtom) {
-                DLPredicate p = headAtom.getDLPredicate(); 
+                DLPredicate p = headAtom.getDLPredicate();
                if (p instanceof AtLeast) {
-                        p = Normalisation.toAtLeastConcept((AtLeast) p); 
+                        p = Normalisation.toAtLeastConcept((AtLeast) p);
-                        return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); 
+                        return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom
+                                        .getArgument(0));
                }
-                if (p instanceof AtomicConcept) 
+                if(p instanceof AtomicConcept)
-                        return Atom.create(getGapDLPredicate((AtomicConcept) p), headAtom.getArgument(0)); 
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
-                if (p instanceof AtomicRole) 
+                if(p instanceof AtomicRole)
-                        return Atom.create(getGapDLPredicate((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Equality || p instanceof AnnotatedEquality) 
+                if(p instanceof Equality || p instanceof AnnotatedEquality)
-                        return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Inequality) 
+                if(p instanceof Inequality)
-                        return Atom.create(getGapDLPredicate((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
                if (p instanceof DatatypeRestriction)
-                        return Atom.create(getGapDLPredicate((DatatypeRestriction) p), headAtom.getArgument(0)); 
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
                Utility.logError(p + " is not recognised.");
                return null;
        }
        private void encodingDisjunctiveRule(DLClause clause) {
                int headLength = clause.getHeadLength();
-                
                Atom[] auxAtoms = new Atom[headLength];
                for (int i = 0; i < headLength; ++i)
                        auxAtoms[i] = getAuxiliaryAtom(clause.getHeadAtom(i));
-                
                Atom[] trackingAtoms = new Atom[headLength];
                for (int i = 0; i < headLength; ++i)
                        trackingAtoms[i] = getTrackingAtom(clause.getHeadAtom(i));
-                
                Atom[] gapAtoms = new Atom[headLength];
                for (int i = 0; i < headLength; ++i)
                        gapAtoms[i] = getGapAtom(clause.getHeadAtom(i));
-                
                Atom[] bodyAtoms = clause.getBodyAtoms();
-                
                LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
-                DLPredicate selected = AtomicConcept.create(getSelectedPredicate()); 
+                DLPredicate selected = AtomicConcept.create(getSelectedPredicate());
                newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
-                
                for (Atom atom: bodyAtoms) {
                        Atom newAtom = Atom.create(
-                                        getTrackingDLPredicate(atom.getDLPredicate()), 
+                                        getTrackingDLPredicate(atom.getDLPredicate()),
                                        DLClauseHelper.getArguments(atom));
                        newHeadAtoms.add(newAtom);
                }
                DLClause newClause;
-                int index; 
+                int index;
                for (int j = 0; j < headLength; ++j) {
                        Atom[] newBodyAtoms = new Atom[headLength * 2 + bodyAtoms.length];
-                        index = 0; 
+                        index = 0;
                        for (int i = 0; i < headLength; ++i, ++index)
-                                newBodyAtoms[index] = gapAtoms[i]; 
+                                newBodyAtoms[index] = gapAtoms[i];
                        for (int i = 0; i < headLength; ++i, ++index)
                                if (i != j)
                                        newBodyAtoms[index] = auxAtoms[i];
-                                else 
+                                else
-                                        newBodyAtoms[index] = trackingAtoms[i]; 
+                                        newBodyAtoms[index] = trackingAtoms[i];
-                        
                        for (int i = 0; i < bodyAtoms.length; ++i, ++index)
-                                newBodyAtoms[index] = bodyAtoms[i]; 
+                                newBodyAtoms[index] = bodyAtoms[i];
-                        
                        for (Atom atom: newHeadAtoms) {
-                                newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms); 
+                                newClause = DLClause.create(new Atom[]{atom}, newBodyAtoms);
                                addTrackingClause(newClause);
                        }
                }
        }
        
        private void addTrackingClause(DLClause clause) {
-                trackingClauses.add(clause); 
+                trackingClauses.add(clause);
        }
        private void addDisjunctiveRule(DLClause clause) {
                disjunctiveRules.add(clause);
        }
-        
        private DLPredicate getAuxPredicate(DLPredicate p) {
                if (p instanceof AtLeastConcept) {
                        StringBuilder builder = new StringBuilder(
                                        Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p));
-                        builder.append("_AUXa").append(currentQuery.getQueryID()); 
+                        builder.append("_AUXa").append(currentQuery.getQueryID());
-                        return AtomicConcept.create(builder.toString()); 
+                        return AtomicConcept.create(builder.toString());
                }
-                
                return getDLPredicate(p, "_AUXa" + currentQuery.getQueryID());
        }
@@ -202,120 +191,118 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
        }
        private DLPredicate generateAuxiliaryRule(AtLeast p1, boolean withAux) {
-                AtLeastConcept p = Normalisation.toAtLeastConcept(p1); 
+                AtLeastConcept p = Normalisation.toAtLeastConcept(p1);
-                
-                int num = p.getNumber(); 
+                int num = p.getNumber();
-                Variable[] Ys = new Variable[num]; 
+                Variable[] Ys = new Variable[num];
                if (num > 1)
-                        for (int i = 0; i < num; ++i) 
+                        for(int i = 0; i < num; ++i)
                                Ys[i] = Variable.create("Y" + (i + 1));
-                else 
+                else
-                        Ys[0] = Y; 
+                        Ys[0] = Y;
-                
-                Collection<Atom> expandedAtom = new LinkedList<Atom>(); 
+                Collection<Atom> expandedAtom = new LinkedList<Atom>();
-                Collection<Atom> representativeAtom = new LinkedList<Atom>(); 
+                Collection<Atom> representativeAtom = new LinkedList<Atom>();
                if (p.getOnRole() instanceof AtomicRole) {
-                        AtomicRole r = (AtomicRole) p.getOnRole(); 
+                        AtomicRole r = (AtomicRole) p.getOnRole();
-                        for (int i = 0; i < num; ++i) 
+                        for(int i = 0; i < num; ++i)
                                expandedAtom.add(Atom.create(r, X, Ys[i]));
-                        representativeAtom.add(Atom.create(r, X, Ys[0])); 
+                        representativeAtom.add(Atom.create(r, X, Ys[0]));
                }
                else {
-                        AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf(); 
+                        AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf();
-                        for (int i = 0; i < num; ++i) 
+                        for(int i = 0; i < num; ++i)
                                expandedAtom.add(Atom.create(r, Ys[i], X));
-                        representativeAtom.add(Atom.create(r, Ys[0], X)); 
+                        representativeAtom.add(Atom.create(r, Ys[0], X));
                }
-                
                if (num > 1) {
-                        representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1])); 
+                        representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1]));
                }
                for (int i = 0; i < num; ++i)
                        for (int j = i + 1; j < num; ++j)
-                                expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j])); 
+                                expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j]));
-                
                if (!p.getToConcept().equals(AtomicConcept.THING)) {
-                        AtomicConcept c; 
+                        AtomicConcept c;
-                        if (p.getToConcept() instanceof AtomicConcept) 
+                        if(p.getToConcept() instanceof AtomicConcept)
                                c = (AtomicConcept) p.getToConcept();
                        else {
                                c = OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
                        }
                        for (int i = 0; i < num; ++i)
-                                expandedAtom.add(Atom.create(c, Ys[i])); 
+                                expandedAtom.add(Atom.create(c, Ys[i]));
                        representativeAtom.add(Atom.create(c, Ys[0]));
                }
                AtomicConcept ac = AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct(p));
-                DLPredicate trackingPredicate = getTrackingDLPredicate(ac); 
+                DLPredicate trackingPredicate = getTrackingDLPredicate(ac);
-                DLPredicate gapPredicate = getGapDLPredicate(ac); 
+                DLPredicate gapPredicate = getGapDLPredicate(ac);
                DLPredicate auxPredicate = withAux ? getAuxPredicate(p) : null;
-                
                for (Atom atom: representativeAtom) {
-                        Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1]; 
+                        Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1];
                        if (atom.getArity() == 1)
                                bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
-                        else 
+                        else
                                bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
-                        int i = 0; 
+                        int i = 0;
                        for (Atom bodyAtom: expandedAtom)
-                                bodyAtoms[++i] = bodyAtom;  
+                                bodyAtoms[++i] = bodyAtom;
                        addTrackingClause(DLClause.create(new Atom[] {Atom.create(trackingPredicate, X)}, bodyAtoms));
-                        
-                        bodyAtoms = new Atom[expandedAtom.size() + 1]; 
+                        bodyAtoms = new Atom[expandedAtom.size() + 1];
                        if (atom.getArity() == 1)
                                bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
-                        else 
+                        else
                                bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
-                        i = 0; 
+                        i = 0;
                        for (Atom bodyAtom: expandedAtom)
-                                bodyAtoms[++i] = bodyAtom;  
+                                bodyAtoms[++i] = bodyAtom;
                        addTrackingClause(DLClause.create(new Atom[] {Atom.create(gapPredicate, X)}, bodyAtoms));
-                        
                        if (withAux) {
-                                bodyAtoms = new Atom[expandedAtom.size() + 1]; 
+                                bodyAtoms = new Atom[expandedAtom.size() + 1];
                                bodyAtoms[0] = getAuxiliaryAtom(atom);
-                                i = 0; 
+                                i = 0;
                                for (Atom bodyAtom: expandedAtom)
-                                        bodyAtoms[++i] = bodyAtom;  
+                                        bodyAtoms[++i] = bodyAtom;
                                addTrackingClause(DLClause.create(new Atom[] {Atom.create(auxPredicate, X)}, bodyAtoms));
                        }
                }
-                
                return withAux ? auxPredicate : trackingPredicate;
        }
        private DLPredicate generateAuxiliaryRule(AtomicRole p) {
-                if (currentQuery.isBottom()) 
+                if(currentQuery.isBottom())
                        return getTrackingDLPredicate(p);
-                
-                DLPredicate ret = getAuxPredicate(p); 
+                DLPredicate ret = getAuxPredicate(p);
                Atom[] headAtom = new Atom[] {Atom.create(ret, X, Y)};
                addTrackingClause(
-                                DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingDLPredicate(p), X, Y)})); 
+                                DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingDLPredicate(p), X, Y)}));
                addTrackingClause(
-                                DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingBottomDLPredicate(p), X, Y)})); 
+                                DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingBottomDLPredicate(p), X, Y)}));
-                
-                return ret; 
+                return ret;
        }
-        
-        private Variable X = Variable.create("X"), Y = Variable.create("Y"); 
        private DLPredicate generateAuxiliaryRule(AtomicConcept p) {
                if (currentQuery.isBottom())
-                        return getTrackingDLPredicate(p); 
+                        return getTrackingDLPredicate(p);
-                
-                DLPredicate ret = getAuxPredicate(p); 
+                DLPredicate ret = getAuxPredicate(p);
-                Atom[] headAtom = new Atom[] {Atom.create(ret, X)}; 
+                Atom[] headAtom = new Atom[]{Atom.create(ret, X)};
                addTrackingClause(
-                                DLClause.create(headAtom, 
+                                DLClause.create(headAtom,
-                                                new Atom[] { Atom.create(getTrackingDLPredicate(p), X)})); 
+                                                                new Atom[]{Atom.create(getTrackingDLPredicate(p), X)}));
                addTrackingClause(
-                                DLClause.create(headAtom, 
+                                DLClause.create(headAtom,
                                                new Atom[] { Atom.create(getTrackingBottomDLPredicate(p), X)}));
-                
-                return ret; 
+                return ret;
        }
        private DLPredicate generateAuxiliaryRule(Equality instance) {
@@ -323,20 +310,18 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
        }
        private DLPredicate generateAuxiliaryRule(Inequality instance) {
-                return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY)); 
+                return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY));
        }
-        
        @Override
        public String getTrackingProgram() {
                StringBuilder sb = getTrackingProgramBody();
                if (currentQuery.isBottom())
-                        sb.append(getBottomTrackingProgram()); 
+                        sb.append(getBottomTrackingProgram());
-                sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText()); 
+                sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText());
-                return sb.toString(); 
+                return sb.toString();
        }
-        private String bottomTrackingProgram = null; 
        private String getBottomTrackingProgram() {
                if (bottomTrackingProgram != null) return bottomTrackingProgram.replace("_tn", getTrackingPredicate(""));  
                
@@ -364,7 +349,7 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
 //              for (Atom tAtom: clause.getHeadAtoms()) {
 //                      for (int i = 0; i < tAtom.getArity(); ++i)
 //                              if ((t = tAtom.getArgument(i)) instanceof Individual) 
-//                                      if (((Individual) t).getIRI().startsWith(OverApproxExist.skolemisedIndividualPrefix))
+//                                      if (((Individual) t).getIRI().startsWith(OverApproxExist.SKOLEMISED_INDIVIDUAL_PREFIX))
 //                                              clause = program.getCorrespondingClause(clause);                                
 //              }
                
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java
index d257de3..7311a86 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar2.java
@@ -1,31 +1,19 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import java.util.Collection;
+import org.semanticweb.HermiT.model.*;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Set;
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-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.Equality;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.InverseRole;
-import org.semanticweb.HermiT.model.Variable;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.multistage.Normalisation;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
-import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+import uk.ac.ox.cs.pagoda.rules.approximators.OverApproxExist;
 import uk.ac.ox.cs.pagoda.util.Namespace;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Set;
 public class TrackingRuleEncoderDisjVar2 extends TrackingRuleEncoderWithGap {
        public TrackingRuleEncoderDisjVar2(UpperDatalogProgram program, BasicQueryEngine store) {
@@ -91,13 +79,13 @@ public class TrackingRuleEncoderDisjVar2 extends TrackingRuleEncoderWithGap {
                        return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); 
                }
                if (p instanceof AtomicConcept) 
-                        return Atom.create(getGapDLPredicate((AtomicConcept) p), headAtom.getArgument(0)); 
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
                if (p instanceof AtomicRole) 
-                        return Atom.create(getGapDLPredicate((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
                if (p instanceof Equality || p instanceof AnnotatedEquality) 
                        return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
                if (p instanceof Inequality) 
-                        return Atom.create(getGapDLPredicate((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                        return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
                return null;
        }
diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
index 99028ca..c3694ad 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
@@ -1,28 +1,21 @@
 package uk.ac.ox.cs.pagoda.tracking;
-import java.util.Collection;
+import org.semanticweb.HermiT.model.*;
-import java.util.HashSet;
-import java.util.LinkedList;
-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.Equality;
-import org.semanticweb.HermiT.model.Variable;
 import org.semanticweb.owlapi.model.IRI;
 import org.semanticweb.owlapi.model.OWLClass;
 import org.semanticweb.owlapi.model.OWLObjectProperty;
 import org.semanticweb.owlapi.model.OWLOntology;
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
-import uk.ac.ox.cs.pagoda.query.*; 
+import uk.ac.ox.cs.pagoda.query.GapTupleIterator;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
 import uk.ac.ox.cs.pagoda.util.Namespace;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Set;
 public class TrackingRuleEncoderWithGap extends TrackingRuleEncoder {
        
        public TrackingRuleEncoderWithGap(UpperDatalogProgram program, BasicQueryEngine store) {
@@ -37,9 +30,9 @@ public class TrackingRuleEncoderWithGap extends TrackingRuleEncoder {
                Variable X = Variable.create("X"); 
                AtomicRole trackingSameAs = AtomicRole.create(Namespace.EQUALITY + "_tn");  
                OWLOntology onto = program.getOntology();
-                Atom[] headAtom = new Atom[] {Atom.create(trackingSameAs, X, X)}, bodyAtom; 
+                Atom[] headAtom = new Atom[]{Atom.create(trackingSameAs, X, X)}, bodyAtom;
-                for (OWLOntology o: onto.getImportsClosure())
+                for(OWLOntology o : onto.getImportsClosure())
-                for (OWLClass cls: o.getClassesInSignature()) {
+                        for(OWLClass cls : o.getClassesInSignature()) {
                        String clsIRI = cls.getIRI().toString();
                        unaryPredicates.add(clsIRI); 
                        bodyAtom = new Atom[] {
@@ -47,14 +40,16 @@ public class TrackingRuleEncoderWithGap extends TrackingRuleEncoder {
                                        Atom.create(AtomicConcept.create(GapTupleIterator.getGapPredicate(clsIRI)), X)}; 
                        equalityRelatedClauses.add(DLClause.create(headAtom, bodyAtom)); 
                }
-                
                Variable Y = Variable.create("Y");
                Set<OWLObjectProperty> setOfProperties = new HashSet<OWLObjectProperty>();
-                for (OWLOntology o: onto.getImportsClosure())
+                for(OWLOntology o : onto.getImportsClosure())
-                        for (OWLObjectProperty prop: o.getObjectPropertiesInSignature())
+                        for(OWLObjectProperty prop : o.getObjectPropertiesInSignature())
-                                setOfProperties.add(prop); 
+                                setOfProperties.add(prop);
-                setOfProperties.add(onto.getOWLOntologyManager().getOWLDataFactory().getOWLObjectProperty(IRI.create(Namespace.INEQUALITY)));
+                setOfProperties.add(onto.getOWLOntologyManager()
-                for (OWLObjectProperty prop: setOfProperties) {
+                                                                .getOWLDataFactory()
+                                                                .getOWLObjectProperty(IRI.create(Namespace.INEQUALITY)));
+                for(OWLObjectProperty prop : setOfProperties) {
                        String propIRI = prop.getIRI().toString();
                        binaryPredicates.add(propIRI); 
                        AtomicRole trackingRole = AtomicRole.create(propIRI + "_tn"); 
diff --git a/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java b/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java
new file mode 100644
index 0000000..be6627a
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java
@@ -0,0 +1,126 @@
+package uk.ac.ox.cs.pagoda.util;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+public class PagodaProperties {
+        public static final String CONFIG_FILE = "pagoda.properties";
+        public static final boolean DEFAULT_DEBUG = false;
+        public static boolean shellModeDefault = false;
+        private static boolean debug = DEFAULT_DEBUG;
+        static {
+                try(InputStream in = PagodaProperties.class.getClassLoader().getResourceAsStream(CONFIG_FILE)) {
+                        Properties config = new Properties();
+                        config.load(in);
+                        in.close();
+                        if(config.containsKey("debug")) {
+                                debug = Boolean.parseBoolean(config.getProperty("debug"));
+                        }
+                } catch(IOException e) {
+                        e.printStackTrace();
+                }
+        }
+        String dataPath = null;
+        String ontologyPath;
+        String queryPath = null;
+        String answerPath = null;
+        boolean toClassify = true;
+        boolean toCallHermiT = true;
+        boolean shellMode = shellModeDefault;
+        public PagodaProperties(String path) {
+                java.util.Properties m_properties = new java.util.Properties();
+                InputStream inputStream = null;
+                try {
+                        inputStream = new FileInputStream(path);
+                        m_properties.load(inputStream);
+                        setOntologyPath(m_properties.getProperty("ONTOLOGY"));
+                        setDataPath(m_properties.getProperty("DATA"));
+                        setQueryPath(m_properties.getProperty("QUERY"));
+                        setAnswerPath(m_properties.getProperty("ANSWER"));
+                        setToClassify(Boolean.parseBoolean(m_properties.getProperty("TO_CLASSIFY")));
+                        setToCallHermiT(Boolean.parseBoolean(m_properties.getProperty("CALL_HERMIT")));
+                } catch (IOException e) {
+                        e.printStackTrace();
+                } finally {
+                        if (inputStream != null)
+                                try {
+                                        inputStream.close();
+                                } catch (IOException e) {
+                                        e.printStackTrace();
+                                }
+                }
+        }
+        public PagodaProperties() {
+        }
+        public static boolean isDebuggingMode() {
+                return debug;
+        }
+        public String getDataPath() {
+                return dataPath;
+        }
+        public void setDataPath(String path) {
+                dataPath = path;
+        }
+        public String getOntologyPath() {
+                return ontologyPath;
+        }
+        public void setOntologyPath(String path) {
+                ontologyPath = path;
+        }
+        public String getQueryPath() {
+                return queryPath;
+        }
+        public void setQueryPath(String path) {
+                queryPath = path;
+        }
+        public String getAnswerPath() {
+                return answerPath;
+        }
+        public void setAnswerPath(String path) {
+                answerPath = path;
+        }
+        public boolean getToClassify() {
+                return toClassify;
+        }
+        public void setToClassify(boolean flag) {
+                toClassify = flag;
+        }
+        public boolean getToCallHermiT() {
+                return toCallHermiT;
+        }
+        public void setToCallHermiT(boolean flag) {
+                toCallHermiT = flag;
+        }
+        public boolean getShellMode() {
+                return shellMode;
+        }
+        public void setShellMode(boolean flag) {
+                shellMode = flag;
+        }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/util/Properties.java b/src/uk/ac/ox/cs/pagoda/util/Properties.java
deleted file mode 100644
index b687b53..0000000
--- a/src/uk/ac/ox/cs/pagoda/util/Properties.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package uk.ac.ox.cs.pagoda.util;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-public class Properties {
-        
-        String dataPath = null;
-        public String getDataPath() { return dataPath; }
-        public void setDataPath(String path) { dataPath = path; }
-        
-        String ontologyPath;
-        public String getOntologyPath() { return ontologyPath; }
-        public void setOntologyPath(String path) { ontologyPath = path; }
-        
-        String queryPath = null; 
-        public String getQueryPath() { return queryPath; }
-        public void setQueryPath(String path) { queryPath = path; }
-        
-        String answerPath = null; 
-        public String getAnswerPath() { return answerPath; }
-        public void setAnswerPath(String path) { answerPath = path; }
-        
-        boolean toClassify = true;
-        public boolean getToClassify() { return toClassify; }
-        public void setToClassify(boolean flag) { toClassify = flag; }
-        
-        boolean toCallHermiT = true; 
-        public boolean getToCallHermiT() { return toCallHermiT; }
-        public void setToCallHermiT(boolean flag) { toCallHermiT = flag; }
-        
-        public static boolean ShellModeDefault = false;
-        
-        boolean shellMode = ShellModeDefault; 
-        public boolean getShellMode() { return shellMode; }
-        public void setShellMode(boolean flag) { shellMode = flag; }
-        
-        public Properties(String path) {
-                java.util.Properties m_properties = new java.util.Properties();
-                InputStream inputStream = null; 
-                try {
-                        inputStream = new FileInputStream(path);
-                        m_properties.load(inputStream);
-                        
-                        setOntologyPath(m_properties.getProperty("ONTOLOGY"));
-                        setDataPath(m_properties.getProperty("DATA"));
-                        setQueryPath(m_properties.getProperty("QUERY"));
-                        setAnswerPath(m_properties.getProperty("ANSWER"));
-                        setToClassify(Boolean.parseBoolean(m_properties.getProperty("TO_CLASSIFY")));
-                        setToCallHermiT(Boolean.parseBoolean(m_properties.getProperty("CALL_HERMIT")));
-                        
-                } catch (IOException e) {
-                        e.printStackTrace();
-                } finally {
-                        if (inputStream != null)
-                                try {
-                                        inputStream.close();
-                                } catch (IOException e) {
-                                        e.printStackTrace();
-                                } 
-                }
-        }
-        public Properties() { }
-}
diff --git a/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java b/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java
index 31838bc..1e53b9c 100644
--- a/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java
+++ b/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java
@@ -1,49 +1,18 @@
 package uk.ac.ox.cs.pagoda.util;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import org.semanticweb.HermiT.model.AnnotatedEquality;
-import org.semanticweb.HermiT.model.AtLeastConcept;
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicDataRange;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.Constant;
-import org.semanticweb.HermiT.model.DLPredicate;
-import org.semanticweb.HermiT.model.Equality;
-import org.semanticweb.HermiT.model.Individual;
-import org.semanticweb.HermiT.model.Inequality;
-import org.semanticweb.HermiT.model.Term;
-import org.semanticweb.HermiT.model.Variable;
-import uk.ac.ox.cs.pagoda.MyPrefixes;
-import uk.ac.ox.cs.pagoda.hermit.RuleHelper;
 import com.hp.hpl.jena.graph.Node;
 import com.hp.hpl.jena.query.Query;
 import com.hp.hpl.jena.query.QueryFactory;
 import com.hp.hpl.jena.sparql.core.TriplePath;
 import com.hp.hpl.jena.sparql.core.Var;
-import com.hp.hpl.jena.sparql.syntax.Element;
+import com.hp.hpl.jena.sparql.syntax.*;
-import com.hp.hpl.jena.sparql.syntax.ElementAssign;
+import org.semanticweb.HermiT.model.*;
-import com.hp.hpl.jena.sparql.syntax.ElementBind;
+import uk.ac.ox.cs.pagoda.MyPrefixes;
-import com.hp.hpl.jena.sparql.syntax.ElementData;
+import uk.ac.ox.cs.pagoda.hermit.RuleHelper;
-import com.hp.hpl.jena.sparql.syntax.ElementDataset;
-import com.hp.hpl.jena.sparql.syntax.ElementExists;
+import java.util.Collection;
-import com.hp.hpl.jena.sparql.syntax.ElementFilter;
+import java.util.HashSet;
-import com.hp.hpl.jena.sparql.syntax.ElementGroup;
+import java.util.Set;
-import com.hp.hpl.jena.sparql.syntax.ElementMinus;
-import com.hp.hpl.jena.sparql.syntax.ElementNamedGraph;
-import com.hp.hpl.jena.sparql.syntax.ElementNotExists;
-import com.hp.hpl.jena.sparql.syntax.ElementOptional;
-import com.hp.hpl.jena.sparql.syntax.ElementPathBlock;
-import com.hp.hpl.jena.sparql.syntax.ElementService;
-import com.hp.hpl.jena.sparql.syntax.ElementSubQuery;
-import com.hp.hpl.jena.sparql.syntax.ElementTriplesBlock;
-import com.hp.hpl.jena.sparql.syntax.ElementUnion;
-import com.hp.hpl.jena.sparql.syntax.ElementVisitor;
 public class SparqlHelper {
@@ -52,7 +21,7 @@ public class SparqlHelper {
                for (int i = 0; i < atoms.length; ++i) {
                        atoms[i].getVariables(undistinguishedVars);
                }
-                int xIndex = 1; 
+                int xIndex = 1;
                while (undistinguishedVars.contains(Variable.create("X" + xIndex))) ++xIndex;
                
                for (String var: vars) 
diff --git a/src/uk/ac/ox/cs/pagoda/util/Utility.java b/src/uk/ac/ox/cs/pagoda/util/Utility.java
index 0edfac2..e98cc81 100644
--- a/src/uk/ac/ox/cs/pagoda/util/Utility.java
+++ b/src/uk/ac/ox/cs/pagoda/util/Utility.java
@@ -1,86 +1,89 @@
 package uk.ac.ox.cs.pagoda.util;
-import java.io.BufferedReader;
+import org.apache.log4j.Level;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintStream;
-import java.text.SimpleDateFormat;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.Collection;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Scanner;
-import java.util.Set;
-import java.util.Stack;
 import org.apache.log4j.Logger;
 import org.semanticweb.HermiT.model.Atom;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.text.SimpleDateFormat;
+import java.util.*;
 public class Utility {
        
-        private static final Logger LOGS = Logger.getLogger(""); // null; //  
-        
        public static final String JAVA_FILE_SEPARATOR = "/";
        public static final String FILE_SEPARATOR = System.getProperty("file.separator");
        public static final String LINE_SEPARATOR = System.getProperty("line.separator");
-        
+        public static final int TEST = -1;
-        public static final String TempDirectory = (new File("tmp" + DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(LocalDateTime.now()))).getAbsolutePath() + FILE_SEPARATOR;
-        
-        public static final int TEST = -1; 
        public static final int FLY = 0;
        public static final int UOBM = 1;
        public static final int LUBM = 2;
        public static final int AEO = 3;
        public static final int WINE = 4;
+        private static final String TEMP_DIR_PATH = "pagoda_tmp";
+        static Stack<PrintStream> outs = new Stack<PrintStream>();
+        private static Logger LOGS;
+        private static String tempDir;
+        private static int asciiX = (int) 'X';
+        private static StringBuilder logMessage = new StringBuilder();
-        public static Set<Atom> toSet(Atom[] data)
+        static {
-        {
+                LOGS = Logger.getLogger("PAGOdA");
+                LOGS.setLevel(Level.DEBUG);
+        }
+        static {
+                outs.push(System.out);
+        }
+        public static String getGlobalTempDirAbsolutePath() {
+                if(tempDir == null) {
+                        try {
+                                Path path = Files.createTempDirectory(TEMP_DIR_PATH);
+                                tempDir = path.toString();
+                                new File(tempDir).deleteOnExit();
+                        } catch(IOException e) {
+                                e.printStackTrace();
+                                System.exit(1);
+                        }
+                }
+                return tempDir;
+        }
+        public static Set<Atom> toSet(Atom[] data) {
                HashSet<Atom> ret = new HashSet<Atom>();
-                for (Atom element: data) 
+                for(Atom element : data)
                        ret.add(element);
                return ret;
        }
        
-        static Stack<PrintStream> outs = new Stack<PrintStream>();
-        
-        static {
-                outs.push(System.out); 
-        }
-        
        public static boolean redirectSystemOut()
        {
                String stamp = new SimpleDateFormat( "HH:mm:ss").format(new Date());
-                return redirectCurrentOut("./console" + stamp + ".txt"); 
+                return redirectCurrentOut("./console" + stamp + ".txt");
        }
        
        public static boolean redirectCurrentOut(String fileName)
        {
                File file = new File(fileName);
-                PrintStream out; 
+                PrintStream out;
                try {
                        out = new PrintStream(new FileOutputStream(file));
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                        return false;
                }
-                outs.push(out); 
+                outs.push(out);
                System.setOut(out);
-                return true; 
+                return true;
        }
-        
        public static void closeCurrentOut() {
                if (!outs.isEmpty())
                        outs.pop().close();
-                
-                if (!outs.isEmpty()) 
+                if(!outs.isEmpty())
                        System.setOut(outs.peek());
        }
        
@@ -98,7 +101,7 @@ public class Utility {
                                while ((line = reader.readLine()) != null && !line.startsWith("}"))
                                        if (first) {
                                                first = false;
-                                                query = expression(line.trim()); 
+                                                query = expression(line.trim());
                                        }
                                        else query += ", " + expression(line.trim());
                                writer.write(query);
@@ -117,8 +120,6 @@ public class Utility {
                else return parts[1] + "(?" + variableIndex(parts[0]) + ",?" + variableIndex(parts[2]) + ")";
        }
        
-        private static int asciiX = (int)'X';
-        
        private static int variableIndex(String exp) {
                char var = exp.charAt(1);
                return (int)var - asciiX;
@@ -130,12 +131,12 @@ public class Utility {
                        return null;
                return line.trim();
        }
-        
        public static String getTextfromFile(String fileName) throws FileNotFoundException {
                Scanner scanner = new Scanner(new File(fileName));
                String program = scanner.useDelimiter("\\Z").next();
                scanner.close();
-                return program; 
+                return program;
        }
        public static String[] getPattern(BufferedReader answerReader) throws IOException {
@@ -147,59 +148,57 @@ public class Utility {
        public static void removeRecursively(File file) {
                if (!file.exists()) return;
-                
                if (file.isDirectory())
                        for (File tFile: file.listFiles())
                                removeRecursively(tFile);
                file.delete();
        }
-        
        public static void removeRecursively(String fileName) {
                removeRecursively(new File(fileName));
        }
        public static Collection<String> getQueryTexts(String fileName) throws IOException {
-                BufferedReader queryReader = new BufferedReader(new InputStreamReader(new FileInputStream(fileName))); 
+                BufferedReader queryReader = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
-                String line; 
+                String line;
-                Collection<String> queryTexts = new LinkedList<String>(); 
+                Collection<String> queryTexts = new LinkedList<String>();
                while (true) {
-                        while ((line = queryReader.readLine()) != null && ((line = line.trim()).isEmpty() || line.startsWith("#"))); 
+                        while((line = queryReader.readLine()) != null && ((line = line.trim()).isEmpty() || line.startsWith("#"))) ;
                        if (line == null) {
                                queryReader.close();
                                return queryTexts;
                        }
-                        
                        StringBuffer query = new StringBuffer();
                        if (!line.startsWith("^["))
                                query.append(line).append(LINE_SEPARATOR);
-                        
-                        while ((line = queryReader.readLine()) != null && !line.trim().endsWith("}")) 
+                        while((line = queryReader.readLine()) != null && !line.trim().endsWith("}"))
                                query.append(line).append(LINE_SEPARATOR);
-                        query.append(line); 
+                        query.append(line);
                        queryTexts.add(query.toString());
                }
        }
        /**
-         * 
+         *
         * @param answerReader
         * @return all lines before the next empty line
         * @throws IOException
         */
        public static Collection<String> getLines(BufferedReader answerReader) throws IOException {
-                Collection<String> answerTuples = new LinkedList<String>(); 
+                Collection<String> answerTuples = new LinkedList<String>();
                String line;
                while ((line = answerReader.readLine()) != null) {
                        line = line.trim();
                        if (line.isEmpty())
-                                break; 
+                                break;
                        answerTuples.add(line);
                }
                return answerTuples;
        }
-        private static StringBuilder logMessage = new StringBuilder();
-        
        private static String getLogMessage(Object[] messages) {
                if (messages.length == 1) return messages[0].toString(); 
                else {
@@ -213,7 +212,11 @@ public class Utility {
                }
        }
-        
+        public static void setLogLevel(Level level) {
+                LOGS.setLevel(level);
+        }
        public static void logInfo(Object... messages) {
                if (LOGS != null)
                        LOGS.info(getLogMessage(messages)); 
@@ -233,20 +236,6 @@ public class Utility {
                if (LOGS != null)
                        LOGS.error(getLogMessage(messages));
        }
-        
-        public static void initialise() {
-                File tmp = new File(TempDirectory); 
-                if (!tmp.exists()) tmp.mkdirs(); 
-        }
-        public static void cleanup() {
-                File tmp = new File(TempDirectory);
-                if (tmp.exists()) {
-                        for (File file: tmp.listFiles())
-                                file.delete(); 
-                        tmp.delete();
-                }
-        }
        public static String toFileIRI(String path) {
                String iri; 
diff --git a/src/uk/ac/ox/cs/pagoda/util/tuples/Tuple.java b/src/uk/ac/ox/cs/pagoda/util/tuples/Tuple.java
new file mode 100644
index 0000000..3e72748
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/util/tuples/Tuple.java
@@ -0,0 +1,44 @@
+package uk.ac.ox.cs.pagoda.util.tuples;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+public class Tuple<T> implements Iterable<T> {
+    final ArrayList<T> elements = new ArrayList<>();
+    Tuple() { }
+    public Tuple(T... elements) {
+        for(T t: elements) {
+            this.elements.add(t);
+        }
+    }
+    
+    public Tuple(Iterable<T> iterable) {
+        for (T t : iterable) {
+            this.elements.add(t);
+        }
+    }
+    public T get(int i) {
+        return elements.get(i);
+    }
+    @Override
+    public Iterator<T> iterator() {
+        return elements.iterator();
+    }
+    @Override
+    public void forEach(Consumer<? super T> action) {
+        elements.forEach(action);
+    }
+    @Override
+    public Spliterator<T> spliterator() {
+        return elements.spliterator();
+    }
+}
diff --git a/src/uk/ac/ox/cs/pagoda/util/tuples/TupleBuilder.java b/src/uk/ac/ox/cs/pagoda/util/tuples/TupleBuilder.java
new file mode 100644
index 0000000..ee2b74d
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/util/tuples/TupleBuilder.java
@@ -0,0 +1,25 @@
+package uk.ac.ox.cs.pagoda.util.tuples;
+/**
+ * Allows to create an immutable <tt>Tuple</tt> in a non-atomic way.
+ * It can create only one <tt>Tuple</tt>.
+ * */
+public class TupleBuilder<T> {
+    private Tuple tuple = new Tuple();
+    private boolean building = true;
+    public boolean append(T t) {
+        if(building) tuple.elements.add(t);
+        return building;
+    }
+    public Tuple<T> build() {
+        if(building) {
+            building = false;
+            return tuple;
+        }
+        return null;
+    }
+}