private boolean isSatisfiable(final OpenlletReasoner pellet, final OWLClassExpression unsatClass, final boolean doExplanation) { pellet.getKB().setDoExplanation(doExplanation); final boolean sat = unsatClass.isOWLThing() ? pellet.isConsistent() : pellet.isSatisfiable(unsatClass); pellet.getKB().setDoExplanation(false); return sat; }
@Override public void dispose() { _reasoner.dispose(); _reasoner = null; _ontology = null; } }
/** * {@inheritDoc} */ @Override public boolean isConsistent() throws ReasonerInterruptedException, TimeOutException { _reasoner.flush(); return _reasoner.isConsistent(); }
/** * {@inheritDoc} */ @Override public Set<OWLLiteral> getDataPropertyValues(final OWLNamedIndividual ind, final OWLDataProperty pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException { _reasoner.flush(); return _reasoner.getDataPropertyValues(ind, pe); }
/** * {@inheritDoc} */ @Override public NodeSet<OWLObjectPropertyExpression> getDisjointObjectProperties(final OWLObjectPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException { _reasoner.flush(); return _reasoner.getDisjointObjectProperties(pe); }
System.out.println("done."); reasoner.getKB().realize(); reasoner.getKB().printClassTree(); final NodeSet<OWLNamedIndividual> individuals = reasoner.getInstances(Person, false); for (final Node<OWLNamedIndividual> sameInd : individuals) final Set<OWLLiteral> names = reasoner.getDataPropertyValues(ind, foafName); final NodeSet<OWLClass> types = reasoner.getTypes(ind, true); final NodeSet<OWLNamedIndividual> homepages = reasoner.getObjectPropertyValues(ind, workHomepage);
public void explainClassHierarchy() throws OWLException { final Set<OWLClass> visited = new HashSet<>(); _reasoner.flush(); startTask("Classification"); _reasoner.getKB().classify(); finishTask("Classification"); startTask("Realization"); _reasoner.getKB().realize(); finishTask("Realization"); _monitor = new ConsoleProgressMonitor(); _monitor.setProgressTitle("Explaining"); _monitor.setProgressLength((int) _reasoner.getRootOntology().classesInSignature().count()); _monitor.taskStarted(); final Node<OWLClass> bottoms = _reasoner.getEquivalentClasses(OWL.Nothing); explainClassHierarchy(OWL.Nothing, bottoms, visited); final Node<OWLClass> tops = _reasoner.getEquivalentClasses(OWL.Thing); explainClassHierarchy(OWL.Thing, tops, visited); _monitor.taskFinished(); }
public AxiomConverter(final OpenlletReasoner reasoner) { this(reasoner.getKB(), reasoner.getManager().getOWLDataFactory()); }
/** * {@inheritDoc} */ @Override public KnowledgeBase getKB() { return _reasoner.getKB(); }
@Override protected boolean isConsistent(final OWLOntology o) { final OpenlletReasoner reasoner = _reasonerFactory.createReasoner(o); reasoner.getKB().setTimeout(_timeout); return reasoner.isConsistent(); }
reasoner.getKB().classify(); for (final OWLSubClassOfAxiom axiom : it) final boolean entailed = reasoner.getSubClasses(axiom.getSuperClass(), true).containsEntity((OWLClass) axiom.getSubClass()); for (final OWLEquivalentClassesAxiom axiom : it) final boolean entailed = reasoner.isEntailed(axiom); for (final OWLClassAssertionAxiom axiom : it) final boolean entailed = reasoner.getInstances(axiom.getClassExpression(), true).containsEntity((OWLNamedIndividual) axiom.getIndividual());
@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()); }
@Test public void testPropertyChain() { final String ns = "http://www.example.org/test#"; final OWLOntology ont = loadOntology(OWLManager.createOWLOntologyManager(), _base + "propertyChain.owl"); final OpenlletReasoner reasoner = OpenlletReasonerFactory.getInstance().createReasoner(ont); final OWLClass C = Class(ns + "C"); final OWLClass S0 = Class(ns + "S0"); final OWLClass R0 = Class(ns + "R0"); final OWLClass R1 = Class(ns + "R1"); final OWLObjectProperty r = ObjectProperty(ns + "r"); final OWLObjectProperty s = ObjectProperty(ns + "s"); final OWLNamedIndividual[] a = new OWLNamedIndividual[17]; for (int i = 0; i < a.length; i++) a[i] = Individual(ns + "a" + i); final OWLIndividual[] theList = new OWLIndividual[] { a[1], a[2], a[3], a[4], a[5], a[6], a[8], a[10], a[12], a[14], a[16] }; assertTrue(reasoner.isConsistent()); assertTrue(reasoner.isEntailed(OWL.transitive(r))); assertFalse(reasoner.isEntailed(OWL.transitive(s))); assertIteratorValues(reasoner.getInstances(C, false).entities().iterator(), theList); assertIteratorValues(reasoner.getInstances(S0, false).entities().iterator(), theList); assertIteratorValues(reasoner.getInstances(R0, false).entities().iterator(), new OWLIndividual[] { a[7], a[9] }); assertIteratorValues(reasoner.getInstances(R1, false).entities().iterator(), new OWLIndividual[] { a[2], a[3], a[4], a[5], a[6] }); assertIteratorValues(reasoner.getObjectPropertyValues(a[0], r).entities().iterator(), new OWLIndividual[] { a[7], a[9] }); assertIteratorValues(reasoner.getObjectPropertyValues(a[1], r).entities().iterator(), new OWLIndividual[] { a[2], a[3], a[4], a[5], a[6] }); assertIteratorValues(reasoner.getObjectPropertyValues(a[0], s).entities().iterator(), theList); }
public IncrementalClassifier(final OpenlletReasoner reasoner, final ModuleExtractor extractor) { _reasoner = reasoner; _extractor = extractor; final OWLOntology ontology = reasoner.getRootOntology(); ontology.importsClosure().map(OWLOntology::axioms).forEach(extractor::addAxioms); reasoner.getManager().addOntologyChangeListener(this); }
@Override public boolean isConsistent() { return _reasoner.isConsistent(); }
@Override protected boolean isEntailed(final OWLOntology premise, final OWLOntology conclusion) { final OpenlletReasoner reasoner = _reasonerFactory.createReasoner(premise); reasoner.getKB().setTimeout(_timeout); return reasoner.isEntailed(conclusion.logicalAxioms()); }
@Override public void dispose() { _reasoner.getManager().removeOntologyChangeListener(this); _reasoner.dispose(); }
final OWLLiteral valBoolean = EntitySearcher.getDataPropertyValues(ind, pBoolean, ont).iterator().next(); assertTrue(reasoner.isConsistent()); assertFalse(reasoner.getDataPropertyValues(ind, pDouble).isEmpty()); reasoner.flush(); assertTrue(reasoner.getDataPropertyValues(ind, pDouble).isEmpty()); assertFalse(reasoner.getDataPropertyValues(ind, pInt).isEmpty()); reasoner.flush(); assertTrue(reasoner.getDataPropertyValues(ind, pInt).isEmpty()); assertFalse(reasoner.getDataPropertyValues(ind, pBoolean).isEmpty()); reasoner.flush(); assertTrue(reasoner.getDataPropertyValues(ind, pBoolean).isEmpty()); ont.add(propertyAssertion(ind, pDouble, newVal)); if (buffering) reasoner.flush(); assertTrue(reasoner.isConsistent());
@Test public void removeType() { createReasoner(OWL.classAssertion(_a, _C), OWL.classAssertion(_a, _D)); assertTrue(_reasoner.isConsistent()); assertTrue(_reasoner.isEntailed(classAssertion(_a, _C))); assertTrue(_reasoner.isEntailed(classAssertion(_a, _D))); final boolean changeApplied = processRemove(OWL.classAssertion(_a, _D)); assertTrue(changeApplied); assertTrue(_reasoner.isEntailed(classAssertion(_a, _C))); assertFalse(_reasoner.isEntailed(classAssertion(_a, _D))); }
assertTrue(_reasoner.isEntailed(OWL.subPropertyOf(_p, OWL.topObjectProperty))); assertTrue(_reasoner.isEntailed(OWL.subPropertyOf(OWL.bottomObjectProperty, _p))); assertTrue(_reasoner.isEntailed(OWL.subPropertyOf(_dp, OWL.topDataProperty))); assertTrue(_reasoner.isEntailed(OWL.subPropertyOf(OWL.bottomDataProperty, _dp))); assertStreamAsSetEquals(Stream.of(_p), _reasoner.getSubObjectProperties(OWL.topObjectProperty, true).entities()); assertStreamAsSetEquals(Stream.of(OWL.bottomObjectProperty), _reasoner.getSubObjectProperties(_p, true).entities()); assertStreamAsSetEquals(Stream.of(_dp), _reasoner.getSubDataProperties(OWL.topDataProperty, true).entities()); assertStreamAsSetEquals(Stream.of(OWL.bottomDataProperty), _reasoner.getSubDataProperties(_dp, true).entities()); assertTrue(_reasoner.isEntailed(propertyAssertion(_a, _p, _b))); assertFalse(_reasoner.isEntailed(propertyAssertion(_b, _p, _a))); assertTrue(_reasoner.isEntailed(propertyAssertion(_a, OWL.topObjectProperty, _b))); assertTrue(_reasoner.isEntailed(propertyAssertion(_b, OWL.topObjectProperty, _a))); assertTrue(_reasoner.isEntailed(propertyAssertion(_a, _dp, _lit))); assertFalse(_reasoner.isEntailed(propertyAssertion(_b, _dp, _lit))); assertTrue(_reasoner.isEntailed(propertyAssertion(_a, OWL.topDataProperty, _lit))); assertTrue(_reasoner.isEntailed(propertyAssertion(_b, OWL.topDataProperty, _lit))); assertTrue(!_reasoner.getObjectPropertyValues(_b, _p).entities().findAny().isPresent()); assertPropertyValues(_reasoner, _a, OWL.topObjectProperty, _a, _b, _c); assertPropertyValues(_reasoner, _b, OWL.topObjectProperty, _a, _b, _c);