protected void addAxioms(OWLNamedIndividual entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLPropertyAssertionAxiom> result) { for (OWLObjectProperty prop : reasoner.getRootOntology().getObjectPropertiesInSignature(true)) { for (OWLNamedIndividual value : reasoner.getObjectPropertyValues(entity, prop).getFlattened()) { result.add(dataFactory.getOWLObjectPropertyAssertionAxiom(prop, entity, value)); } } for (OWLDataProperty prop : reasoner.getRootOntology().getDataPropertiesInSignature(true)) { for (OWLLiteral value : reasoner.getDataPropertyValues(entity, prop)) { result.add(dataFactory.getOWLDataPropertyAssertionAxiom(prop, entity, value)); } } }
@Override protected void addAxioms(OWLNamedIndividual entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLPropertyAssertionAxiom<?, ?>> result) { checkNotNull(dataFactory, "dataFactory cannot be null"); checkNotNull(reasoner, "reasoner cannot be null"); checkNotNull(result, "result cannot be null"); checkNotNull(entity, "entity cannot be null"); reasoner.getRootOntology().objectPropertiesInSignature(INCLUDED) .forEach(p -> reasoner.getObjectPropertyValues(entity, p).entities() .forEach( i -> result.add(dataFactory.getOWLObjectPropertyAssertionAxiom(p, entity, i)))); reasoner.getRootOntology().dataPropertiesInSignature(INCLUDED) .forEach(p -> reasoner.getDataPropertyValues(entity, p) .forEach( v -> result.add(dataFactory.getOWLDataPropertyAssertionAxiom(p, entity, v)))); }
private void recalculateInferredOwlClass(OWLReasoner reasoner) { if (inferredOwlClass == null || !reasoner.getInstances(owlClass, true).containsEntity(individual.asOWLNamedIndividual())) { inferredOwlClass = null; for (OWLClass cls : reasoner.getTypes(individual.asOWLNamedIndividual(), true).getFlattened()) { inferredOwlClass = cls; break; } } }
final OWLNamedIndividual b = OWL.Individual("B"); ontology.addAxioms(// Assert.assertTrue(reasoner.getObjectPropertyValues(a, r).containsEntity(b)); Assert.assertTrue(reasoner.getObjectPropertyValues(b, inverseR).containsEntity(a)); ontology.remove(OWL.propertyAssertion(a, inverseR, b)); ontology.remove(// reasoner.inverseObjectProperties(inverseR)// Removing every way of getting the inverse. .map(inverse -> OWL.propertyAssertion(a, inverse, b))// ); reasoner.flush(); Assert.assertFalse(reasoner.getObjectPropertyValues(a, r).containsEntity(b)); Assert.assertFalse(reasoner.getObjectPropertyValues(b, inverseR).containsEntity(a)); reasoner.equivalentObjectProperties(inverseR).forEach(System.out::println); Assert.assertTrue(reasoner.equivalentObjectProperties(inverseR)// .anyMatch(OWLObjectInverseOf.class::isInstance));
@Override public NodeSet<OWLClass> getObjectPropertyDomains(OWLObjectPropertyExpression pe, boolean direct) { ensurePrepared(); DefaultNodeSet<OWLClass> result = new OWLClassNodeSet(); Consumer<? super OWLObjectPropertyDomainAxiom> domains = axiom -> { result.addNode(getEquivalentClasses(axiom.getDomain())); if (!direct) { result.addAllNodes(getSuperClasses(axiom.getDomain(), false).nodes()); } }; Consumer<? super OWLObjectPropertyRangeAxiom> inverseRanges = ax -> { result.addNode(getEquivalentClasses(ax.getRange())); if (!direct) { result.addAllNodes(getSuperClasses(ax.getRange(), false).nodes()); } }; getRootOntology().importsClosure().flatMap(o -> o.objectPropertyDomainAxioms(pe)) .forEach(domains); getRootOntology().importsClosure() .forEach(o -> getInverseObjectProperties(pe).entities().forEach(invPe -> o .objectPropertyRangeAxioms(invPe).forEach(inverseRanges))); return result; }
@Override public Set<OWLLiteral> getDataPropertyValues(OWLNamedIndividual ind, OWLDataProperty pe) { ensurePrepared(); Set<OWLLiteral> literals = new HashSet<>(); Set<OWLDataProperty> superProperties = asUnorderedSet( Stream.concat(getSuperDataProperties(pe, false) .entities(), getEquivalentDataProperties(pe).entities())); getRootOntology().importsClosure().flatMap(o -> o.dataPropertyAssertionAxioms(ind)) .forEach(ax -> { if (superProperties.contains(ax.getProperty().asOWLDataProperty())) { literals.add(ax.getObject()); } }); return literals; }
@Override public NodeSet<OWLDataProperty> getDisjointDataProperties(OWLDataPropertyExpression pe) { ensurePrepared(); DefaultNodeSet<OWLDataProperty> result = new OWLDataPropertyNodeSet(); getRootOntology().importsClosure() .flatMap(o -> o.disjointDataPropertiesAxioms(pe.asOWLDataProperty())).forEach( axiom -> { for (OWLDataPropertyExpression dpe : axiom.getPropertiesMinus(pe)) { if (!dpe.isAnonymous()) { result.addNode( dataPropertyHierarchyInfo.getEquivalents(dpe.asOWLDataProperty())); result.addAllNodes( getSubDataProperties(dpe.asOWLDataProperty(), false).nodes()); } } }); return result; }
@SafeVarargs final protected static <E extends OWLObject> void assertEquals(final NodeSet<E> actual, final Set<E>... expected) { final Set<Set<E>> expectedSet = SetUtils.create(expected); final Iterable<Node<E>> it = actual.nodes()::iterator; for (final Node<E> node : it) { final Set<E> entities = node.entities().collect(Collectors.toSet()); assertTrue("Unexpected value: " + entities + "\tremaing:{" + expectedSet + "}", expectedSet.remove(entities)); } assertTrue("Missing values: " + expectedSet, expectedSet.isEmpty()); }
@Override protected void addAxioms(OWLClass entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLSubClassOfAxiom> result) { checkNotNull(dataFactory, "dataFactory cannot be null"); checkNotNull(reasoner, "reasoner cannot be null"); checkNotNull(result, "result cannot be null"); checkNotNull(entity, "entity cannot be null"); if (reasoner.isSatisfiable(entity)) { reasoner.getSuperClasses(entity, true).entities() .forEach(sup -> result.add(dataFactory.getOWLSubClassOfAxiom(entity, sup))); } else { result.add(dataFactory.getOWLSubClassOfAxiom(entity, dataFactory.getOWLNothing())); } }
@Override protected void addAxioms(OWLClass entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLDisjointClassesAxiom> result) { reasoner.precomputeInferences(InferenceType.DISJOINT_CLASSES); reasoner.getDisjointClasses(entity).forEach(cls -> cls.entities() .forEach(c -> result.add(dataFactory.getOWLDisjointClassesAxiom(entity, c)))); }
@Override protected void addAxioms(OWLNamedIndividual entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLClassAssertionAxiom> result) { reasoner.getTypes(entity, false).entities() .forEach(t -> result.add(dataFactory.getOWLClassAssertionAxiom(t, entity))); }
@Override protected void addAxioms(OWLDataProperty entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLSubDataPropertyOfAxiom> result) { checkNotNull(dataFactory, "dataFactory cannot be null"); checkNotNull(reasoner, "reasoner cannot be null"); checkNotNull(result, "result cannot be null"); checkNotNull(entity, "entity cannot be null"); reasoner.getSuperDataProperties(entity, true).entities() .forEach(sup -> result.add(dataFactory.getOWLSubDataPropertyOfAxiom(entity, sup))); }
@Override protected void addAxioms(OWLObjectProperty entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLSubObjectPropertyOfAxiom> result, Set<OWLObjectPropertyExpression> nonSimpleProperties) { checkNotNull(dataFactory, "dataFactory cannot be null"); checkNotNull(reasoner, "reasoner cannot be null"); checkNotNull(result, "result cannot be null"); checkNotNull(entity, "entity cannot be null"); reasoner.getSuperObjectProperties(entity, true).entities().forEach( p -> addIfSimple(p, entity, dataFactory, result, nonSimpleProperties, reasoner)); }
@Test public void testObjectRangeWithEquivalents() { createReasoner(OWL.equivalentClasses(_C, some(inverse(_p), OWL.Thing)), OWL.range(_p, _D), OWL.subClassOf(_C, _E)); _reasoner.getKB().printClassTree(); assertTrue(_reasoner.isEntailed(OWL.range(_p, _C))); assertStreamAsSetEquals(Stream.of(_C), _reasoner.getEquivalentClasses(some(inverse(_p), OWL.Thing)).entities()); assertStreamAsSetEquals(Stream.of(_C), _reasoner.getObjectPropertyRanges(_p, true).entities()); assertStreamAsSetEquals(Stream.of(_C, _D, _E, OWL.Thing), _reasoner.getObjectPropertyRanges(_p, false).entities()); }
private void rebuild() { typeNodes.clear(); if (reasoner != null){ Set<OWLOntology> importsClosure = reasoner.getRootOntology().getImportsClosure(); for (OWLOntology ont : importsClosure){ for (OWLClass cls : ont.getClassesInSignature()) { final Set<OWLNamedIndividual> inds = reasoner.getInstances(cls, showDirect).getFlattened(); if (!inds.isEmpty()){ typeNodes.put(cls, new HashSet<>(inds)); } } } } fireHierarchyChanged(); }
for (OWLAxiom a : ontology.getAxioms(Imports.INCLUDED)) { if (a instanceof OWLSubClassOfAxiom || a instanceof OWLObjectPropertyCharacteristicAxiom) { manager.addAxiom(subOntology, a); Set<OWLSubClassOfAxiom> assertedSubClassAxioms = ontology.getAxioms(AxiomType.SUBCLASS_OF); OWLAxiom ax = dataFactory.getOWLEquivalentClassesAxiom(exprToNamedClassMap.get(x), x); manager.addAxiom(subOntology, ax); if (!reasoner.isConsistent()) { logger.info("Ontology is not consistent!"); return; if (reasoner.getSuperClasses(assertedSuper, false).containsEntity(superClass)) { isRedundant = true; logger.debug("GCI:" + subClassExpr); for (OWLClass intermediateParent : reasoner.getSuperClasses(subClass, false).getFlattened()) { if (assertedSubClassMap.containsKey(intermediateParent)) { logger.debug("GCI intermediate parent:" + intermediateParent); if (reasoner.getSuperClasses(intermediateParent, false).containsEntity(superClass)) { isRedundant = true; break;
protected void addAxioms(OWLClass entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLSubClassOfAxiom> result) { if (reasoner.isSatisfiable(entity)) { for (OWLClass sup : reasoner.getSuperClasses(entity, true).getFlattened()) { result.add(dataFactory.getOWLSubClassOfAxiom(entity, sup)); } } else { result.add(dataFactory.getOWLSubClassOfAxiom(entity, dataFactory.getOWLNothing())); } }
public NodeSet<OWLClass> getObjectPropertyRanges(OWLObjectPropertyExpression pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException { DefaultNodeSet<OWLClass> result = new OWLClassNodeSet(); for (OWLOntology ontology : getRootOntology().getImportsClosure()) { for (OWLObjectPropertyRangeAxiom axiom : ontology.getObjectPropertyRangeAxioms(pe)) { result.addNode(getEquivalentClasses(axiom.getRange())); if (!direct) { result.addAllNodes(getSuperClasses(axiom.getRange(), false).getNodes()); } } for (OWLObjectPropertyExpression invPe : getInverseObjectProperties(pe).getEntities()) { for (OWLObjectPropertyDomainAxiom axiom : ontology.getObjectPropertyDomainAxioms(invPe)) { result.addNode(getEquivalentClasses(axiom.getDomain())); if (!direct) { result.addAllNodes(getSuperClasses(axiom.getDomain(), false).getNodes()); } } } } return result; }