initial version

1 files changed, 124 insertions, 0 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
new file mode 100644
index 0000000..6cf239f
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
@@ -0,0 +1,124 @@
+package uk.ac.ox.cs.pagoda.tracking;
+
+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.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;
+
+public class TrackingRuleEncoderDisj2 extends TrackingRuleEncoderDisj {
+
+        public TrackingRuleEncoderDisj2(UpperDatalogProgram program, BasicQueryEngine store) {
+                super(program, store);
+        }
+
+        @Override
+        public boolean encodingRules() {
+                if (ruleEncoded) return false;
+                ruleEncoded = true; 
+                
+                for (DLClause clause: program.getClauses()) {
+                        encodingRule(clause);
+                }
+                
+                if (disjunctiveRules.isEmpty())
+                        return true;
+                
+                processDisjunctiveRules(); 
+                return false; 
+        }
+        
+        @Override
+        protected DLPredicate generateAuxiliaryRule(AtomicConcept p) {
+                return getTrackingDLPredicate(p); 
+        }
+        
+        @Override
+        protected DLPredicate generateAuxiliaryRule(AtomicRole p) {
+                return getTrackingDLPredicate(p); 
+        }
+
+        private Variable X = Variable.create("X"); 
+        
+        @Override
+        protected DLPredicate generateAuxiliaryRule(AtLeastConcept p, DLClause original, Individual[] individuals) {
+                DLPredicate ret = AtomicConcept.create(getTrackingPredicate(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p, individuals))); 
+                Atom[] headAtom = new Atom[] {Atom.create(ret, X)};
+                
+                AtomicRole role = p.getOnRole() instanceof AtomicRole ? 
+                                (AtomicRole) p.getOnRole(): 
+                                        ((InverseRole) p.getOnRole()).getInverseOf(); 
+                        
+                AtomicConcept concept = p.getToConcept() instanceof AtomicConcept ? 
+                                (AtomicConcept) p.getToConcept() : 
+                                        OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
+                                                
+                Term[] roleArgs, conceptArg;
+                for (Individual i: individuals) {
+//              Variable i = Variable.create("Y"); 
+                        if (p.getOnRole() instanceof AtomicRole) {
+                                roleArgs = new Term[] {X, i};
+                                conceptArg = new Term[] {i}; 
+                        }
+                        else {
+                                roleArgs = new Term[] {i, X};
+                                conceptArg = new Term[] {i}; 
+                        }
+                                
+                        addTrackingClause(
+                                        DLClause.create(headAtom, 
+                                                        new Atom[] {Atom.create(getTrackingDLPredicate(role), roleArgs)}));
+                        
+                        Atom guard = Atom.create(role, roleArgs);  
+                                        
+                        if (!concept.equals(AtomicConcept.THING)) {
+                                addTrackingClause(
+                                                DLClause.create(headAtom, 
+                                                                new Atom[] {guard, Atom.create(getTrackingDLPredicate(concept), conceptArg)}));
+                        }
+                }
+                
+                return ret;  
+        }
+        
+        @Override
+        protected void encodingRule(DLClause clause) {
+                DLClause original = program.getCorrespondingClause(clause);
+                if (original.getHeadLength() <= 1) {
+                        super.encodingRule(clause);
+                }
+                else addDisjunctiveRule(original, clause);
+        }
+        
+        @Override
+        public String getTrackingProgram() {
+                StringBuilder sb = getTrackingProgramBody();
+                sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText()); 
+                return sb.toString(); 
+        }
+
+        @Override
+        protected void encodingAtomicQuery(QueryRecord[] botQuerRecords) {
+                super.encodingAtomicQuery(botQuerRecords, true);
+        }
+
+        @Override
+        protected DLPredicate generateAuxiliaryRule(Inequality instance) {
+                // TODO Auto-generated method stub
+                return null;
+        }
+}