protected OWLReasoner createHermiTOWLReasoner(Configuration configuration,OWLOntology ontology) { return new Reasoner(configuration,ontology); } }
public boolean hasDataPropertyRelationship(OWLNamedIndividual subject,OWLDataProperty property,OWLLiteral object) { checkPreConditions(subject,property); if (!m_isConsistent) return true; OWLDataFactory factory=getDataFactory(); OWLAxiom notAssertion=factory.getOWLNegativeDataPropertyAssertionAxiom(property,subject,object); Tableau tableau=getTableau(notAssertion); boolean result=tableau.isSatisfiable(true,true,null,null,null,null,null,new ReasoningTaskDescription(true,"is {0} connected to {1} via {2}",H(subject),object,H(property))); tableau.clearAdditionalDLOntology(); return !result; } protected Set<HierarchyNode<AtomicConcept>> getDirectSuperConceptNodes(final Individual individual) {
@Override public Node<OWLClass> getBottomClassNode() { classifyClasses(); return atomicConceptHierarchyNodeToNode(m_atomicConceptHierarchy.getBottomNode()); } @Override
public Node<OWLClass> getEquivalentClasses(OWLClassExpression classExpression) { HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression); return atomicConceptHierarchyNodeToNode(node); } public NodeSet<OWLClass> getSuperClasses(OWLClassExpression classExpression,boolean direct) {
public boolean isEntailed(OWLAxiom axiom) { checkPreConditions(axiom); if (!isConsistent()) return true; EntailmentChecker checker=new EntailmentChecker(this,getDataFactory()); return checker.entails(axiom); } public boolean isEntailed(Set<? extends OWLAxiom> axioms) {
public NodeSet<OWLClass> getObjectPropertyRanges(OWLObjectPropertyExpression propertyExpression,boolean direct) { checkPreConditions(propertyExpression); classifyClasses(); if (!isConsistent()) return new OWLClassNodeSet(getBottomClassNode()); final Role role=H(propertyExpression); Set<HierarchyNode<AtomicConcept>> nodes=m_directObjectRoleRanges.get(role); if (nodes==null) { final Individual freshIndividualB=Individual.createAnonymous("fresh-individual-B"); final Set<Atom> roleAssertion=Collections.singleton(role.getRoleAssertion(freshIndividualA,freshIndividualB)); final Tableau tableau=getTableau(); HierarchySearch.SearchPredicate<HierarchyNode<AtomicConcept>> searchPredicate=new HierarchySearch.SearchPredicate<HierarchyNode<AtomicConcept>>() { public Set<HierarchyNode<AtomicConcept>> getSuccessorElements(HierarchyNode<AtomicConcept> u) { return atomicConceptHierarchyNodesToNodeSet(nodes);
public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression classExpression) { checkPreConditions(classExpression); classifyClasses(); if (classExpression.isOWLNothing() || !m_isConsistent) { HierarchyNode<AtomicConcept> node=m_atomicConceptHierarchy.getBottomNode(); return atomicConceptHierarchyNodesToNodeSet(node.getAncestorNodes()); return atomicConceptHierarchyNodesToNodeSet(Collections.singleton(node)); HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression); if (node==null || node==m_atomicConceptHierarchy.getTopNode()) { return new OWLClassNodeSet(getDataFactory().getOWLNothing()); return atomicConceptHierarchyNodesToNodeSet(node.getAncestorNodes()); else { Set<HierarchyNode<AtomicConcept>> directDisjoints=getDisjointConceptNodes(node); Set<HierarchyNode<AtomicConcept>> result=new HashSet<HierarchyNode<AtomicConcept>>(); for (HierarchyNode<AtomicConcept> directDisjoint : directDisjoints) { result.addAll(directDisjoint.getDescendantNodes()); return atomicConceptHierarchyNodesToNodeSet(result); Node<OWLClass> equivalentToComplement=getEquivalentClasses(classExpression.getObjectComplementOf()); NodeSet<OWLClass> subsDisjoint=getSubClasses(classExpression.getObjectComplementOf(),false); Set<Node<OWLClass>> result=new HashSet<Node<OWLClass>>(); if (equivalentToComplement.getSize()>0)
protected boolean isIrreflexive(OWLObjectPropertyExpression propertyExpression) { checkPreConditions(propertyExpression); if (!m_isConsistent.booleanValue()) return true; Role role=H(propertyExpression); Individual freshIndividual=Individual.createAnonymous("fresh-individual"); return !getTableau().isSatisfiable(false,Collections.singleton(role.getRoleAssertion(freshIndividual,freshIndividual)),null,null,null,null,new ReasoningTaskDescription(true,"irreflexivity of {0}",role)); } protected boolean isReflexive(OWLObjectPropertyExpression propertyExpression) {
public NodeSet<OWLNamedIndividual> getDifferentIndividuals(OWLNamedIndividual namedIndividual) { checkPreConditions(namedIndividual); if (!m_isConsistent) { Node<OWLNamedIndividual> node=new OWLNamedIndividualNode(getAllNamedIndividuals()); return new OWLNamedIndividualNodeSet(Collections.singleton(node)); } Individual individual=H(namedIndividual); Tableau tableau=getTableau(); Set<Individual> result=new HashSet<Individual>(); for (Individual potentiallyDifferentIndividual : m_dlOntology.getAllIndividuals()) if (isResultRelevantIndividual(potentiallyDifferentIndividual) && !individual.equals(potentiallyDifferentIndividual)) if (!tableau.isSatisfiable(true,true,Collections.singleton(Atom.create(Equality.INSTANCE,individual,potentiallyDifferentIndividual)),null,null,null,null,new ReasoningTaskDescription(true,"is {0} different from {1}",individual,potentiallyDifferentIndividual))) result.add(potentiallyDifferentIndividual); return sortBySameAsIfNecessary(result); } public NodeSet<OWLNamedIndividual> getObjectPropertyValues(OWLNamedIndividual namedIndividual,OWLObjectPropertyExpression propertyExpression) {
public NodeSet<OWLClass> getTypes(OWLNamedIndividual namedIndividual,boolean direct) { checkPreConditions(namedIndividual); Set<HierarchyNode<AtomicConcept>> result; if (!isDefined(namedIndividual)) { classifyClasses(); result=new HashSet<HierarchyNode<AtomicConcept>>(); result.add(m_atomicConceptHierarchy.getTopNode()); } else { if (direct) classifyClasses(); initialiseClassInstanceManager(); if (direct) m_instanceManager.setToClassifiedConceptHierarchy(m_atomicConceptHierarchy); result=m_instanceManager.getTypes(H(namedIndividual),direct); } return atomicConceptHierarchyNodesToNodeSet(result); } public boolean hasType(OWLNamedIndividual namedIndividual,OWLClassExpression type,boolean direct) {
public Node<OWLNamedIndividual> getSameIndividuals(OWLNamedIndividual namedIndividual) { checkPreConditions(namedIndividual); if (!m_isConsistent) return new OWLNamedIndividualNode(getAllNamedIndividuals()); if (m_dlOntology.getAllIndividuals().size()==0 || !m_dlOntology.containsIndividual(H(namedIndividual))) return new OWLNamedIndividualNode(namedIndividual); else { initialiseClassInstanceManager(); Set<Individual> sameIndividuals=m_instanceManager.getSameAsIndividuals(H(namedIndividual)); OWLDataFactory factory=getDataFactory(); Set<OWLNamedIndividual> result=new HashSet<OWLNamedIndividual>(); for (Individual individual : sameIndividuals) result.add(factory.getOWLNamedIndividual(IRI.create(individual.getIRI()))); return new OWLNamedIndividualNode(result); } } public NodeSet<OWLNamedIndividual> getDifferentIndividuals(OWLNamedIndividual namedIndividual) {
@Override public Boolean visit(OWLDatatypeDefinitionAxiom axiom) { reasoner.throwInconsistentOntologyExceptionIfNecessary(); if (!reasoner.isConsistent()) return Boolean.TRUE; if (reasoner.m_dlOntology.hasDatatypes()) { OWLDataFactory df=reasoner.getDataFactory(); OWLIndividual freshIndividual=df.getOWLAnonymousIndividual("fresh-individual"); OWLDataProperty freshDataProperty=df.getOWLDataProperty(IRI.create("fresh-data-property")); OWLDataRange dataRange=axiom.getDataRange(); OWLDatatype dt=axiom.getDatatype(); OWLDataIntersectionOf dr1=df.getOWLDataIntersectionOf(df.getOWLDataComplementOf(dataRange),dt); OWLDataIntersectionOf dr2=df.getOWLDataIntersectionOf(df.getOWLDataComplementOf(dt),dataRange); OWLDataUnionOf union=df.getOWLDataUnionOf(dr1,dr2); OWLClassExpression c=df.getOWLDataSomeValuesFrom(freshDataProperty,union); OWLClassAssertionAxiom ax=df.getOWLClassAssertionAxiom(c,freshIndividual); Tableau tableau=reasoner.getTableau(ax); return Boolean.valueOf(!tableau.isSatisfiable(true,true,null,null,null,null,null,ReasoningTaskDescription.isAxiomEntailed(axiom))); } else return Boolean.FALSE; }
checkPreConditions(); if (m_dataRoleHierarchy==null) { Set<AtomicRole> relevantDataRoles=new HashSet<>(); OWLDataFactory factory=getDataFactory(); OWLDatatype unknownDatatypeA=factory.getOWLDatatype(IRI.create("internal:unknown-datatype#","A")); for (AtomicRole dataRole : relevantDataRoles) { additionalAxioms.toArray(additionalAxiomsArray); Tableau tableau=getTableau(additionalAxiomsArray); try { final int numberOfRoles=relevantDataRoles.size(); Hierarchy<AtomicConcept> atomicConceptHierarchyForRoles=classifyAtomicConcepts(tableau,progressMonitor,conceptsForRoles.get(AtomicRole.TOP_DATA_ROLE),conceptsForRoles.get(AtomicRole.BOTTOM_DATA_ROLE),rolesForConcepts.keySet(),m_configuration.forceQuasiOrderClassification); Hierarchy.Transformer<AtomicConcept,AtomicRole> transformer=new Hierarchy.Transformer<AtomicConcept,AtomicRole>() { @Override
public void classifyObjectProperties() { checkPreConditions(); if (m_objectRoleHierarchy==null) { Set<Role> relevantObjectRoles=new HashSet<Role>(); OWLDataFactory factory=getDataFactory(); OWLClass freshConcept=factory.getOWLClass(IRI.create("internal:fresh-concept")); for (Role objectRole : relevantObjectRoles) { additionalAxioms.toArray(additionalAxiomsArray); Tableau tableau=getTableau(additionalAxiomsArray); try { final int numberOfRoles=relevantObjectRoles.size(); Hierarchy<AtomicConcept> atomicConceptHierarchyForRoles=classifyAtomicConceptsForRoles(tableau,progressMonitor,conceptsForRoles.get(AtomicRole.TOP_OBJECT_ROLE),conceptsForRoles.get(AtomicRole.BOTTOM_OBJECT_ROLE),rolesForConcepts.keySet(),m_dlOntology.hasInverseRoles(),conceptsForRoles,rolesForConcepts,m_configuration.forceQuasiOrderClassification); Hierarchy.Transformer<AtomicConcept,Role> transformer=new Hierarchy.Transformer<AtomicConcept,Role>() { public Role transform(AtomicConcept atomicConcept) {
protected boolean isSymmetric(OWLObjectPropertyExpression propertyExpression) { checkPreConditions(propertyExpression); if (!m_isConsistent.booleanValue() || propertyExpression.getNamedProperty().isOWLTopObjectProperty()) return true; OWLDataFactory factory=getDataFactory(); OWLClass pseudoNominal=factory.getOWLClass(PSEUDO_NOMINAL); OWLClassExpression allNotPseudoNominal=factory.getOWLObjectAllValuesFrom(propertyExpression,pseudoNominal.getObjectComplementOf()); OWLIndividual freshIndividualA=factory.getOWLAnonymousIndividual("fresh-individual-A"); OWLIndividual freshIndividualB=factory.getOWLAnonymousIndividual("fresh-individual-B"); OWLAxiom assertion1=factory.getOWLObjectPropertyAssertionAxiom(propertyExpression,freshIndividualA,freshIndividualB); OWLAxiom assertion2=factory.getOWLClassAssertionAxiom(allNotPseudoNominal,freshIndividualB); OWLAxiom assertion3=factory.getOWLClassAssertionAxiom(pseudoNominal,freshIndividualA); Tableau tableau=getTableau(assertion1,assertion2,assertion3); boolean result=tableau.isSatisfiable(true,null,null,null,null,null,new ReasoningTaskDescription(true,"symmetry of {0}",propertyExpression)); tableau.clearAdditionalDLOntology(); return !result; } protected boolean isTransitive(OWLObjectPropertyExpression propertyExpression) {
checkPreConditions(); if (m_atomicConceptHierarchy==null) { Set<AtomicConcept> relevantAtomicConcepts=new HashSet<>(); m_atomicConceptHierarchy=classifyAtomicConcepts(getTableau(),progressMonitor,AtomicConcept.THING,AtomicConcept.NOTHING,relevantAtomicConcepts,m_configuration.forceQuasiOrderClassification); if (m_instanceManager!=null) m_instanceManager.setToClassifiedConceptHierarchy(m_atomicConceptHierarchy);
hermiT = new Reasoner(rewrittenOntology); tableau = hermiT.getTableau();
protected void realise() { checkPreConditions(); if (!m_dlOntology.getAllIndividuals().isEmpty()) { classifyClasses(); initialiseClassInstanceManager(); m_instanceManager.realize(m_configuration.reasonerProgressMonitor); } } /**
/** * Realise object properties. */ public void realiseObjectProperties() { checkPreConditions(); if (!m_dlOntology.getAllIndividuals().isEmpty()) { classifyObjectProperties(); initialisePropertiesInstanceManager(); m_instanceManager.realizeObjectRoles(m_configuration.reasonerProgressMonitor); } } /**
protected HierarchyNode<Role> getHierarchyNode(OWLObjectPropertyExpression propertyExpression) { checkPreConditions(propertyExpression); classifyObjectProperties(); if (!m_isConsistent.booleanValue()) return m_objectRoleHierarchy.getBottomNode(); else { Role role=H(propertyExpression); HierarchyNode<Role> node=m_objectRoleHierarchy.getNodeForElement(role); if (node==null) node=new HierarchyNode<>(role,Collections.singleton(role),Collections.singleton(m_objectRoleHierarchy.getTopNode()),Collections.singleton(m_objectRoleHierarchy.getBottomNode())); return node; } }