From 4fe4ca32d8f45807ab881b6fb8e814842dad0ec6 Mon Sep 17 00:00:00 2001 From: RncLsn Date: Mon, 11 May 2015 18:00:57 +0100 Subject: Adding (not completed) a new upper bound technique, namely Limited Skolemisation. --- ...om_googlecode_json_simple_json_simple_1_1_1.xml | 13 ------ pom.xml | 10 ++--- .../ox/cs/pagoda/multistage/ExistApproximator.java | 15 +++++++ .../multistage/ExistConstantApproximator.java | 23 ++++++++++ .../LimitedSkolemisationApplication.java | 16 +++++++ .../LimitedSkolemisationApproximator.java | 36 ++++++++++++++++ .../pagoda/multistage/MultiStageQueryEngine.java | 12 +++--- .../pagoda/multistage/MultiStageUpperProgram.java | 49 +++++++--------------- .../pagoda/multistage/RestrictedApplication.java | 25 ++++------- .../treatement/Pick4NegativeConcept.java | 30 ++++--------- .../multistage/treatement/SkolemTreatment.java | 4 +- .../ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java | 8 ++-- src/uk/ac/ox/cs/pagoda/rules/Approximator.java | 8 ++-- .../ac/ox/cs/pagoda/rules/LowerDatalogProgram.java | 25 ++++------- src/uk/ac/ox/cs/pagoda/rules/OverApproxDisj.java | 23 +++++----- src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java | 26 ++---------- 16 files changed, 165 insertions(+), 158 deletions(-) delete mode 100644 .idea/libraries/Maven__com_googlecode_json_simple_json_simple_1_1_1.xml create mode 100644 src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java create mode 100644 src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java create mode 100644 src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java create mode 100644 src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java diff --git a/.idea/libraries/Maven__com_googlecode_json_simple_json_simple_1_1_1.xml b/.idea/libraries/Maven__com_googlecode_json_simple_json_simple_1_1_1.xml deleted file mode 100644 index f3f3738..0000000 --- a/.idea/libraries/Maven__com_googlecode_json_simple_json_simple_1_1_1.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/pom.xml b/pom.xml index c6d3bb0..630dfa3 100644 --- a/pom.xml +++ b/pom.xml @@ -108,11 +108,11 @@ testng 6.7 - - com.googlecode.json-simple - json-simple - 1.1.1 - + + + + + com.google.code.gson gson diff --git a/src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java b/src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java new file mode 100644 index 0000000..0ee2035 --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/multistage/ExistApproximator.java @@ -0,0 +1,15 @@ +package uk.ac.ox.cs.pagoda.multistage; + +import org.semanticweb.HermiT.model.DLClause; + +import java.util.Collection; + +/** + * An approximator for existential rules. + * */ +public interface ExistApproximator { + + Collection convert(DLClause clause, + DLClause originalClause, + Collection violationTuples); +} diff --git a/src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java b/src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java new file mode 100644 index 0000000..5df66bc --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/multistage/ExistConstantApproximator.java @@ -0,0 +1,23 @@ +package uk.ac.ox.cs.pagoda.multistage; + +import org.semanticweb.HermiT.model.DLClause; +import uk.ac.ox.cs.pagoda.rules.OverApproxExist; + +import java.util.Collection; + +/** + * A wrapper for OverApproxExist. + * */ +public class ExistConstantApproximator implements ExistApproximator { + + private final OverApproxExist overApproxExist; + + public ExistConstantApproximator() { + overApproxExist = new OverApproxExist(); + } + + @Override + public Collection convert(DLClause clause, DLClause originalClause, Collection violationTuples) { + return overApproxExist.convert(clause, originalClause); + } +} diff --git a/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java new file mode 100644 index 0000000..b0068e7 --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApplication.java @@ -0,0 +1,16 @@ +package uk.ac.ox.cs.pagoda.multistage; + + +import uk.ac.ox.cs.pagoda.constraints.BottomStrategy; +import uk.ac.ox.cs.pagoda.rules.Program; + +public class LimitedSkolemisationApplication extends RestrictedApplication { + + + public LimitedSkolemisationApplication(Program program, BottomStrategy upperBottom) { + super(program, upperBottom); + } + + + // TODO override methods properly +} diff --git a/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java new file mode 100644 index 0000000..348e849 --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/multistage/LimitedSkolemisationApproximator.java @@ -0,0 +1,36 @@ +package uk.ac.ox.cs.pagoda.multistage; + +import org.semanticweb.HermiT.model.DLClause; + +import java.util.Collection; + +/** + * Approximates existential rules by a limited form of Skolemisation. + *

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

+ * 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 convert(DLClause clause, DLClause originalClause) { LinkedList distincts = new LinkedList(); diff --git a/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java b/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java index 7e66411..2ff1673 100644 --- a/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java +++ b/src/uk/ac/ox/cs/pagoda/rules/OverApproxExist.java @@ -1,30 +1,11 @@ package uk.ac.ox.cs.pagoda.rules; -import java.util.Collection; -import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.Map; - -import org.semanticweb.HermiT.model.AtLeast; -import org.semanticweb.HermiT.model.AtLeastConcept; -import org.semanticweb.HermiT.model.AtLeastDataRange; -import org.semanticweb.HermiT.model.Atom; -import org.semanticweb.HermiT.model.AtomicConcept; -import org.semanticweb.HermiT.model.AtomicNegationConcept; -import org.semanticweb.HermiT.model.AtomicRole; -import org.semanticweb.HermiT.model.DLClause; -import org.semanticweb.HermiT.model.DLPredicate; -import org.semanticweb.HermiT.model.Individual; -import org.semanticweb.HermiT.model.Inequality; -import org.semanticweb.HermiT.model.InverseRole; -import org.semanticweb.HermiT.model.LiteralConcept; -import org.semanticweb.HermiT.model.Role; -import org.semanticweb.HermiT.model.Term; -import org.semanticweb.HermiT.model.Variable; +import org.semanticweb.HermiT.model.*; import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper; import uk.ac.ox.cs.pagoda.util.Namespace; +import java.util.*; + public class OverApproxExist implements Approximator { @Override @@ -142,6 +123,7 @@ public class OverApproxExist implements Approximator { AtomicConcept atomicConcept = null; if (concept instanceof AtomicNegationConcept) { + // is this already in MultiStageUpperProgram? Atom atom1 = Atom.create(atomicConcept = ((AtomicNegationConcept) concept).getNegatedAtomicConcept(), X); Atom atom2 = Atom.create(atomicConcept = getNegationConcept(atomicConcept), X); ret.add(DLClause.create(new Atom[0], new Atom[] {atom1, atom2})); -- cgit v1.2.3