Merge branch 'upstream' into Query-dependent-skolemisation

Conflicts:
	src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java
	src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
	src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
	src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
	src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
	src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
	src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java
	src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
	src/uk/ac/ox/cs/pagoda/util/Utility.java
	test/uk/ac/ox/cs/pagoda/junit/ClauseTester.java
	test/uk/ac/ox/cs/pagoda/junit/TestGapMappedToLower.java

2 files changed, 82 insertions, 70 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
index 862fdc8..4e2fc5f 100644
--- a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
+++ b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
@@ -1,81 +1,88 @@
 package uk.ac.ox.cs.pagoda.endomorph.plan;
 
-import uk.ac.ox.cs.pagoda.endomorph.Clique;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.atomic.AtomicInteger;
+
 import uk.ac.ox.cs.pagoda.endomorph.DependencyGraph;
+import uk.ac.ox.cs.pagoda.endomorph.Clique;
 import uk.ac.ox.cs.pagoda.query.AnswerTuple;
 import uk.ac.ox.cs.pagoda.reasoner.full.Checker;
 import uk.ac.ox.cs.pagoda.reasoner.full.HermitChecker;
 import uk.ac.ox.cs.pagoda.util.Utility;
 
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedDeque;
-import java.util.concurrent.atomic.AtomicInteger;
-
 public class OpenEndMultiThreadPlan implements CheckPlan {
         
-        Checker checker;
-        DependencyGraph dGraph;
-        //      Clique[] topo;
-//      AtomicInteger open, end;
-        ConcurrentLinkedDeque<Clique> topo;
-        Set<Clique> validated, falsified;
-        AtomicInteger counter = new AtomicInteger();
-        
+        Checker checker; 
+        DependencyGraph dGraph; 
+
         public OpenEndMultiThreadPlan(Checker checker, DependencyGraph dGraph) {
-                this.checker = checker;
+                this.checker = checker; 
                 this.dGraph = dGraph;
         }
-
+        
+//      Clique[] topo;
+//      AtomicInteger open, end; 
+        ConcurrentLinkedDeque<Clique> topo; 
+        
+        Set<Clique> validated, falsified; 
+        
         @Override
         public int check() {
                 Collection<Clique> cliques = dGraph.getTopologicalOrder();
 //              topo = new LinkedBlockingDeque<Clique>(cliques);
-                topo = new ConcurrentLinkedDeque<Clique>(cliques);
-
+                topo = new ConcurrentLinkedDeque<Clique>(cliques); 
+                
 //              topo = new Clique[cliques.size()];
-//              int index = 0;
+//              int index = 0; 
 //              for (Clique clique: cliques) topo[index++] = clique;
-//              open = new AtomicInteger();
-//              end = new AtomicInteger(cliques.size() - 1);
-
-//              validated = Collections.synchronizedSet(new HashSet<Clique>());
+//              open = new AtomicInteger(); 
+//              end = new AtomicInteger(cliques.size() - 1); 
+                        
+//              validated = Collections.synchronizedSet(new HashSet<Clique>()); 
 //              falsified = Collections.synchronizedSet(new HashSet<Clique>());
-                validated = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>());
-                falsified = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>());
+                validated = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>()); 
+                falsified = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>()); 
 
-                int numOfThreads = 10;
-                Collection<Thread> threads = new LinkedList<Thread>();
-                for(int i = 0; i < numOfThreads; ++i)
+                int numOfThreads = 10; 
+                Collection<Thread> threads = new LinkedList<Thread>(); 
+                for (int i = 0; i < numOfThreads; ++i) 
                         threads.add(new Thread(new SubThread(new HermitChecker(checker), i)));
-
+                
                 for (Thread thread: threads) thread.start();
-
+                
                 for (Thread thread: threads) {
                         try {
                                 thread.join();
                         } catch (InterruptedException e) {
                                 e.printStackTrace();
-                        }
+                        } 
                 }
-
-                Utility.logDebug("HermiT was called " + counter.get() + " times.");
-
-                int count = 0;
+                
+                Utility.logDebug("HermiT was called " + counter.get() + " times."); 
+                
+                int count = 0; 
                 for (Clique c: dGraph.getTopologicalOrder()) {
                         if (validated.contains(c))
-                                count += c.getNodeTuples().size();
+                                count += c.getNodeTuples().size(); 
                 }
-                return count;
+                return count;           
         }
 
         private void setMarkCascadely(Clique clique, Set<Clique> marked, Map<Clique, Collection<Clique>> edges) {
-                marked.add(clique);
+                marked.add(clique); 
                 if (edges.containsKey(clique))
                         for (Clique c: edges.get(clique))
-                                if(!marked.contains(c))
+                                if (!marked.contains(c)) 
                                         setMarkCascadely(c, marked, edges);
         }
+        
+        AtomicInteger counter = new AtomicInteger(); 
 
         class SubThread implements Runnable {
                 
diff --git a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
index 3294c31..a740833 100644
--- a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
+++ b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
@@ -1,7 +1,12 @@
 package uk.ac.ox.cs.pagoda.endomorph.plan;
 
-import uk.ac.ox.cs.pagoda.endomorph.Clique;
-import uk.ac.ox.cs.pagoda.endomorph.DependencyGraph;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+
+import uk.ac.ox.cs.pagoda.endomorph.*;
 import uk.ac.ox.cs.pagoda.query.AnswerTuple;
 import uk.ac.ox.cs.pagoda.query.QueryRecord;
 import uk.ac.ox.cs.pagoda.query.QueryRecord.Step;
@@ -10,40 +15,40 @@ import uk.ac.ox.cs.pagoda.summary.NodeTuple;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
 
-import java.util.*;
-
 public class OpenEndPlan implements CheckPlan {
         
         public static final int TIME_OUT_MIN = 1; 
         
         Checker checker; 
-        DependencyGraph dGraph;
-        QueryRecord m_record;
-        int m_answerArity;
-        Set<Clique> validated = new HashSet<Clique>();
-        Set<Clique> falsified = new HashSet<Clique>();
-        Set<AnswerTuple> passedAnswers = new HashSet<AnswerTuple>();
+        DependencyGraph dGraph; 
+        QueryRecord m_record; 
+        int m_answerArity; 
+
         public OpenEndPlan(Checker checker, DependencyGraph dGraph, QueryRecord record) {
-                this.checker = checker;
+                this.checker = checker; 
                 this.dGraph = dGraph;
                 m_record = record;
                 m_answerArity = record.getAnswerVariables().length;
         }
         
+        Set<Clique> validated = new HashSet<Clique>(); 
+        Set<Clique> falsified = new HashSet<Clique>(); 
+        Set<AnswerTuple> passedAnswers = new HashSet<AnswerTuple>();
+        
         @Override
         public int check() {
                 LinkedList<Clique> topo = new LinkedList<Clique>(dGraph.getTopologicalOrder());
                 Utility.logInfo("Entrances: " + dGraph.getEntrances().size() + " Exists: " + dGraph.getExits().size()); 
 
                 boolean flag = true;
-                Clique clique;
-                Timer t = new Timer();
-
+                Clique clique; 
+                Timer t = new Timer(); 
+                
                 AnswerTuple answerTuple;
                 while (!topo.isEmpty()) { 
                         if (flag) {
                                 clique = topo.removeFirst();
-                                if(redundant(clique)) continue;
+                                if (redundant(clique)) continue; 
                                 if (validated.contains(clique)) continue; 
                                 if (falsified.contains(clique)) { flag = false; continue; }
                                 Utility.logDebug("start checking front ... " + (answerTuple = clique.getRepresentative().getAnswerTuple())); 
@@ -60,8 +65,8 @@ public class OpenEndPlan implements CheckPlan {
                                 clique = topo.removeLast(); 
                                 if (falsified.contains(clique)) continue; 
                                 if (validated.contains(clique)) { flag = true; continue; }
-                                Utility.logDebug("start checking back ... " + (answerTuple = clique.getRepresentative().getAnswerTuple()));
-                                if(!checker.check(answerTuple))
+                                Utility.logDebug("start checking back ... " + (answerTuple = clique.getRepresentative().getAnswerTuple())); 
+                                if (!checker.check(answerTuple)) 
                                         setMarkCascadelyFasified(clique); 
                                 else {
                                         Utility.logDebug(answerTuple.toString() + " is verified.");
@@ -88,38 +93,38 @@ public class OpenEndPlan implements CheckPlan {
                         }
                 
                 m_record.addLowerBoundAnswers(validAnswers);
-                m_record.addProcessingTime(Step.FULL_REASONING, t.duration());
+                m_record.addProcessingTime(Step.FullReasoning, t.duration());
                 return count;           
         }
 
         private boolean redundant(Clique clique) {
-                for(NodeTuple nodeTuple : clique.getNodeTuples())
-                        if(!passedAnswers.contains(AnswerTuple.getInstance(nodeTuple.getAnswerTuple(), m_answerArity)))
-                                return false;
+                for (NodeTuple nodeTuple: clique.getNodeTuples())
+                        if (!passedAnswers.contains(AnswerTuple.create(nodeTuple.getAnswerTuple(), m_answerArity))) 
+                                return false; 
                 return true;
         }
 
         private void addProjections(Clique clique) {
-                for(NodeTuple nodeTuple : clique.getNodeTuples())
-                        passedAnswers.add(AnswerTuple.getInstance(nodeTuple.getAnswerTuple(), m_answerArity));
+                for (NodeTuple nodeTuple: clique.getNodeTuples()) 
+                        passedAnswers.add(AnswerTuple.create(nodeTuple.getAnswerTuple(), m_answerArity)); 
         }
 
-        private void setMarkCascadelyValidated(Clique clique) {
+        private void setMarkCascadelyValidated(Clique clique) { 
                 validated.add(clique);
                 addProjections(clique);
                 Map<Clique, Collection<Clique>> edges = dGraph.getOutGoingEdges(); 
                 if (edges.containsKey(clique))
                         for (Clique c: edges.get(clique))
-                                if(!validated.contains(c))
+                                if (!validated.contains(c)) 
                                         setMarkCascadelyValidated(c);
         }
 
-        private void setMarkCascadelyFasified(Clique clique) {
-                falsified.add(clique);
-                Map<Clique, Collection<Clique>> edges = dGraph.getInComingEdges();
-                if(edges.containsKey(clique))
-                        for(Clique c : edges.get(clique))
-                                if(!falsified.contains(c))
+        private void setMarkCascadelyFasified(Clique clique) { 
+                        falsified.add(clique);
+                Map<Clique, Collection<Clique>> edges = dGraph.getInComingEdges(); 
+                if (edges.containsKey(clique))
+                        for (Clique c: edges.get(clique))
+                                if (!falsified.contains(c)) 
                                         setMarkCascadelyFasified(c);
         }