public void classify() { prepare(); _kb.classify(); }
/** * {@inheritDoc} */ @Override public void prepareReasoner() throws ReasonerInterruptedException, TimeOutException { refreshCheck(); if (_kb.isConsistent()) _kb.realize(); }
@Override protected boolean isSubsumedBy(final ATermAppl a, final ATermAppl b) { final ATermAppl someB = ATermUtils.makeSomeValues(_p, b); return _kb.isSubClassOf(a, someB); } }
public static void printCounts(final KnowledgeBase kb) { final int classCount = kb.getClasses().size(); final int objPropertyCount = kb.getObjectProperties().size(); final int dataPropertyCount = kb.getDataProperties().size(); System.out.println("Expressivity : " + kb.getExpressivity()); System.out.println("Classes : " + classCount); System.out.println("Obj Properties : " + objPropertyCount); System.out.println("Data Properties: " + dataPropertyCount); printCounts(kb.getABox()); } }
@Override public boolean contains(final KnowledgeBase kb, final GraphLoader loader, final Node s, final Node p, final Node o) { final ATermAppl prop = loader.node2term(p); if (!kb.isProperty(prop)) return false; for (final ATermAppl ind : kb.getIndividuals()) if (kb.hasKnownPropertyValue(ind, prop, null).isTrue()) return true; return false; }
@Test public void validLiteralRestrictedDatatype() { dataProperties(_p); individuals(_a); final ATermAppl uri = term("http//example.com/datatype"); _kb.addRange(_p, INTEGER); _kb.addDatatypeDefinition(uri, restrict(INTEGER, minExclusive(literal(0)))); _kb.addPropertyValue(_p, _a, literal("1", uri)); assertTrue(_kb.isConsistent()); }
@Test public void testIrreflexive() { _kb.addObjectProperty(mbox); _kb.addIrreflexiveProperty(mbox); _kb.addIndividual(robert); _kb.addPropertyValue(mbox, robert, robert); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeIrreflexive(mbox), ATermUtils.makePropAtom(mbox, robert, robert), }); }
@Test public void testRuleIndividuals() { final ATermAppl c = term("C"), d = term("D"), i = term("i"); _kb.addClass(c); _kb.addClass(d); _kb.addIndividual(i); _kb.addType(i, c); _kb.addRule(new Rule(Arrays.asList(new RuleAtom[] { new ClassAtom(d, new AtomIConstant(i)) }), Arrays.asList(new RuleAtom[] { new ClassAtom(c, new AtomIConstant(i)) }))); _kb.realize(); assertTrue(_kb.getTypes(i).contains(Collections.singleton(d))); }
@Test public void cdClassificationWithInverses() { classes(_C, _D, _E); objectProperties(_p); _kb.addSubClass(_C, some(_p, _D)); _kb.addSubClass(_D, all(inv(_p), _E)); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSubClassOf(_C, _E)); _kb.classify(); assertTrue(_kb.isSubClassOf(_C, _E)); }
@Test public void testDifferentFrom2() { final KnowledgeBase kb = new KnowledgeBaseImpl(); kb.addClass(term("C")); kb.addClass(term("D")); kb.addDisjointClass(term("C"), term("D")); kb.addIndividual(term("a")); kb.addType(term("a"), term("C")); kb.addIndividual(term("b")); kb.addType(term("b"), term("D")); kb.classify(); assertTrue(kb.getDifferents(term("a")).contains(term("b"))); assertTrue(kb.getDifferents(term("b")).contains(term("a"))); }
@Override public void run() { final KnowledgeBase kb = getKB(); startTask("consistency check"); final boolean isConsistent = kb.isConsistent(); finishTask("consistency check"); if (!isConsistent) throw new OpenlletCmdException("Ontology is inconsistent, run \"openllet explain\" to get the reason"); startTask("classification"); kb.classify(); finishTask("classification"); startTask("realization"); kb.realize(); finishTask("realization"); final TaxonomyPrinter<ATermAppl> printer = new ClassTreePrinter(); printer.print(kb.getTaxonomy()); }
@Test public void testRoleAbsorptionWithPropertyChain() { classes(_A, _B, _C, _D); objectProperties(_p, _q, _r); _kb.addSubProperty(list(_p, _q), _r); _kb.addSubClass(_C, _B); _kb.addEquivalentClass(_C, some(_r, _D)); _kb.addSubClass(_A, some(_p, some(_q, _D))); assertTrue(_kb.isSubClassOf(_A, _C)); _kb.classify(); assertTrue(_kb.isSubClassOf(_A, _C)); }
@Test public void testDisjointSelf() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl A = term("A"); final ATermAppl p = term("p"); kb.addClass(A); kb.addObjectProperty(p); kb.addDisjointClasses(Arrays.asList(A, self(p))); kb.classify(); assertTrue(kb.isSatisfiable(A)); }
/** * not A subClassOf B does not imply disjointness between concepts A and B. */ @Test public void testNonDisjointness() { classes(_A, _B, _C); _kb.addSubClass(not(_A), _B); _kb.addSubClass(_C, and(_A, _B)); assertTrue(_kb.isConsistent()); _kb.classify(); assertTrue(_kb.isSatisfiable(_C)); }
@Test public void testBottomSub() { // See also: http://cvsdude.com/trac/clark-parsia/pellet-devel/ticket/7 final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl c = term("c"); kb.addClass(c); kb.addSubClass(ATermUtils.BOTTOM, c); kb.classify(); assertTrue(kb.isSubClassOf(ATermUtils.BOTTOM, c)); }
/** * not A subClassOf A implies A is TOP */ @Test public void testTopClass4() { classes(_A, _B, _C); _kb.addSubClass(not(_A), _A); _kb.addSubClass(_B, _A); assertTrue(_kb.isConsistent()); _kb.classify(); assertTrue(_kb.isEquivalentClass(_A, TOP)); }
@Test public void testGuessingRule() { classes(_C, _D); objectProperties(_p); individuals(_a, _b); _kb.addEquivalentClass(_C, hasValue(inv(_p), _a)); _kb.addType(_a, card(_p, 2, _D)); _kb.addType(_a, card(_p, 3, TOP)); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSatisfiable(_C)); }
protected void reset() { _kb.prepare(); _classes = new ArrayList<>(_kb.getClasses()); _useCD = OpenlletOptions.USE_CD_CLASSIFICATION && !_kb.getTBox().unfold(ATermUtils.TOP).hasNext() && !_kb.getExpressivity().hasNominal(); init(); }
@Test public void testFunctionalSubDataProperty() { // test for ticket #551 individuals(_a); dataProperties(_p, _q); _kb.addFunctionalProperty(_p); _kb.addSubProperty(_q, _p); _kb.addPropertyValue(_p, _a, literal("val1")); _kb.addPropertyValue(_q, _a, literal("val2")); assertFalse(_kb.isConsistent()); }
@Test public void irreflexivePropertyCausingDifferentFrom() { // test #433 individuals(_a, _b); objectProperties(_p); _kb.addIrreflexiveProperty(_p); _kb.addPropertyValue(_p, _a, _b); assertTrue(_kb.isConsistent()); assertTrue(_kb.isDifferentFrom(_a, _b)); } }