From 7e0ecc07285209e65f9d4d022065d06a4997fc86 Mon Sep 17 00:00:00 2001 From: RncLsn Date: Wed, 13 May 2015 11:57:06 +0100 Subject: Implementing Limited Skolemisation, in particular SkolemTermsDispenser. --- .../cs/pagoda/constraints/PredicateDependency.java | 138 +++++++++------------ 1 file changed, 59 insertions(+), 79 deletions(-) (limited to 'src/uk/ac/ox/cs/pagoda/constraints') 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 java.util.HashMap; -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 org.semanticweb.HermiT.model.*; +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.*; + public class PredicateDependency extends DependencyGraph { - - Collection m_clauses; - Map> edgeLabels = new HashMap>(); - + + private static final DLPredicate equality = AtomicRole.create(Namespace.EQUALITY); + private static final DLPredicate inequality = AtomicRole.create(Namespace.INEQUALITY); + Collection m_clauses; + Map> edgeLabels = new HashMap>(); + Set reachableToBottom = null; + public PredicateDependency(Collection 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); - LinkedList value; - if ((value = edgeLabels.get(key)) == null) - edgeLabels.put(key, value = new LinkedList()); + PredicatePair key = new PredicatePair(body, head); + LinkedList value; + if ((value = edgeLabels.get(key)) == null) + edgeLabels.put(key, value = new LinkedList()); 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 collectPredicate(Atom[] atoms) { Set predicates = new HashSet(); - for (Atom atom: atoms) - predicates.addAll(getAtomicPredicates(atom.getDLPredicate())); + for (Atom atom : atoms) + 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 getAtomicPredicates(DLPredicate predicate) { - Set predicates = new HashSet(); + Set predicates = new HashSet(); 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 getAtomicPredicates(AtLeastConcept alc) { Set set = new HashSet(); - if (alc.getOnRole() instanceof AtomicRole) - set.add((AtomicRole) alc.getOnRole()); - else + if (alc.getOnRole() instanceof AtomicRole) + set.add((AtomicRole) alc.getOnRole()); + else set.add(((InverseRole) alc.getOnRole()).getInverseOf()); - - if (alc.getToConcept() instanceof AtomicConcept) - if (alc.getToConcept().equals(AtomicConcept.THING)); - else set.add((AtomicConcept) alc.getToConcept()); - else + + if (alc.getToConcept() instanceof AtomicConcept) + if (alc.getToConcept().equals(AtomicConcept.THING)) ; + else set.add((AtomicConcept) alc.getToConcept()); + 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; - if (aldr.getOnRole() instanceof AtomicRole) - return (AtomicRole) aldr.getOnRole(); - else - return ((InverseRole) aldr.getOnRole()).getInverseOf(); + AtLeastDataRange aldr = (AtLeastDataRange) p; + if (aldr.getOnRole() instanceof AtomicRole) + return (AtomicRole) aldr.getOnRole(); + else + return ((InverseRole) aldr.getOnRole()).getInverseOf(); } Utility.logDebug("Unknown DLPredicate in PredicateDependency: " + p); - return null; + return null; } public Set pathTo(DLPredicate p) { - Set rules = new HashSet(); - Set visited = new HashSet(); - - Queue queue = new LinkedList(); - queue.add(p); + Set rules = new HashSet(); + Set visited = new HashSet(); + + Queue queue = new LinkedList(); + queue.add(p); visited.add(p); - - Set edge; - Collection clauses; - + + Set edge; + Collection clauses; + while (!queue.isEmpty()) { if ((edge = reverseEdges.get(p = queue.poll())) != null) { for (DLPredicate pred: edge) { if (!visited.contains(pred)) { - queue.add(pred); - visited.add(pred); + queue.add(pred); + visited.add(pred); } - clauses = edgeLabelsBetween(pred, p); - if (clauses != null) rules.addAll(clauses); + clauses = edgeLabelsBetween(pred, p); + if (clauses != null) rules.addAll(clauses); } } } - return rules; + return rules; } - + private LinkedList edgeLabelsBetween(DLPredicate p, DLPredicate q) { PredicatePair pair = new PredicatePair(p, q); - return edgeLabels.get(pair); + return edgeLabels.get(pair); } - - Set reachableToBottom = null; public Set pathToBottom(DLPredicate p) { if (reachableToBottom == null) { -- cgit v1.2.3