public static void assertSubClass(final KnowledgeBase kb, final ATermAppl c1, final ATermAppl c2) { assertSubClass(kb, c1, c2, true); }
public static void assertNotSubClass(final KnowledgeBase kb, final ATermAppl c1, final ATermAppl c2) { assertSubClass(kb, c1, c2, false); }
public static void assertSubClass(final KnowledgeBase kb, final ATermAppl c1, final ATermAppl c2) { assertSubClass(kb, c1, c2, true); }
public static void assertNotSubClass(final KnowledgeBase kb, final ATermAppl c1, final ATermAppl c2) { assertSubClass(kb, c1, c2, false); }
public static void assertSubClass(final KnowledgeBase kb, final String c1, final String c2) { assertSubClass(kb, term(c1), term(c2)); }
public static void assertSubClass(final KnowledgeBase kb, final String c1, final String c2) { assertSubClass(kb, term(c1), term(c2)); }
@Test public void anyURI383() { final ATermAppl C = TermFactory.term("C"); final ATermAppl D = TermFactory.term("D"); final ATermAppl p = TermFactory.term("p"); final ATermAppl uri = TermFactory.literal(URI.create("http://www.example.org")); final KnowledgeBaseImpl kb = new KnowledgeBaseImpl(); kb.addClass(C); kb.addClass(D); kb.addDatatypeProperty(p); kb.addRange(p, ANY_URI); kb.addEquivalentClass(C, hasValue(p, uri)); kb.addEquivalentClass(D, min(p, 1, TOP_LIT)); assertSubClass(kb, C, D, true); assertSubClass(kb, D, C, false); }
@Test public void testInternalization() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl A = term("A"); final ATermAppl B = term("B"); final ATermAppl C = term("C"); kb.addClass(A); kb.addClass(B); kb.addClass(C); kb.addSubClass(TOP, and(or(B, not(A)), or(C, not(B)))); assertSubClass(kb, A, B); assertSubClass(kb, B, C); kb.classify(); }
@Test public void testQualifiedCardinalityObjectProperty() { final ATermAppl sub = term("sub"); final ATermAppl sup = term("sup"); classes(_c, _d, sub, sup); objectProperties(_p, _f); _kb.addFunctionalProperty(_f); _kb.addSubClass(sub, sup); assertSatisfiable(_kb, and(min(_p, 2, and(_c, _d)), max(_p, 2, _c), some(_p, or(and(_c, not(_d)), _c)))); assertSubClass(_kb, min(_p, 4, TOP), min(_p, 2, TOP)); assertNotSubClass(_kb, min(_p, 1, TOP), min(_p, 2, TOP)); assertNotSubClass(_kb, min(_p, 1, _c), min(_p, 1, _d)); assertNotSubClass(_kb, and(some(_p, _c), some(_p, not(_c))), min(_p, 2, _d)); assertSubClass(_kb, min(_p, 3, _c), min(_p, 2, _c)); assertSubClass(_kb, min(_p, 3, _c), min(_p, 2, TOP)); assertSubClass(_kb, min(_p, 2, _c), min(_p, 2, TOP)); assertNotSubClass(_kb, min(_p, 2, _c), min(_p, 2, _d)); assertSubClass(_kb, min(_p, 2, and(_c, _d)), some(_p, _c)); assertSubClass(_kb, max(_p, 1, sup), max(_p, 2, sub)); assertSubClass(_kb, and(max(_f, 1, TOP), all(_f, _c)), max(_f, 1, _c)); assertSubClass(_kb, and(min(_p, 2, _c), min(_p, 2, not(_c))), min(_p, 4, TOP)); }
@Test public void testSynoymClassification() { // Fixes the problem identified in #270. If there are two equivalent concepts // where one is primitive and the other is non-primitive CD classifier was // picking primitive flag and returning incorrect classification results. final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl A = term("A"); final ATermAppl B = term("B"); final ATermAppl C = term("C"); final ATermAppl p = term("p"); kb.addClass(A); kb.addClass(B); kb.addClass(C); kb.addDatatypeProperty(p); // B is completely defined except this equivalence kb.addEquivalentClass(A, B); // A is not primitive because of the domain axiom kb.addDomain(p, A); // C should be inferred to be a subclass of A and B kb.addSubClass(C, some(p, TOP_LIT)); kb.classify(); assertSubClass(kb, C, A); assertSubClass(kb, C, B); }
@Test public void testQualifiedCardinalityDataProperty() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl c = restrict(Datatypes.INTEGER, minInclusive(literal(10))); final ATermAppl d = restrict(Datatypes.INTEGER, maxInclusive(literal(20))); final ATermAppl p = term("p"); final ATermAppl f = term("f"); final ATermAppl sub = Datatypes.SHORT; final ATermAppl sup = Datatypes.INTEGER; kb.addDatatype(sub); kb.addDatatype(sup); kb.addDatatypeProperty(p); kb.addDatatypeProperty(f); kb.addFunctionalProperty(f); assertSatisfiable(kb, and(min(p, 2, and(c, d)), max(p, 2, c), some(p, or(and(c, not(d)), c)))); assertSubClass(kb, min(p, 4, TOP_LIT), min(p, 2, TOP_LIT)); assertNotSubClass(kb, min(p, 1, TOP_LIT), min(p, 2, TOP_LIT)); assertNotSubClass(kb, min(p, 1, c), min(p, 1, d)); assertNotSubClass(kb, and(some(p, c), some(p, not(c))), min(p, 2, d)); assertSubClass(kb, min(p, 3, c), min(p, 2, c)); assertSubClass(kb, min(p, 3, c), min(p, 2, TOP_LIT)); assertSubClass(kb, min(p, 2, c), min(p, 2, TOP_LIT)); assertNotSubClass(kb, min(p, 2, c), min(p, 2, d)); assertSubClass(kb, min(p, 2, and(c, d)), some(p, c)); assertSubClass(kb, max(p, 1, sup), max(p, 2, sub)); assertSubClass(kb, and(max(f, 1, TOP_LIT), all(f, c)), max(f, 1, c)); assertSubClass(kb, and(min(p, 2, c), min(p, 2, not(c))), min(p, 4, TOP_LIT)); }
@Test public void test375() { // test case for issue #375. classes(_A, _B, _C); dataProperties(_p); final ATermAppl dt = restrict(Datatypes.INTEGER, minExclusive(literal(1))); _kb.addRange(_p, XSDInteger.getInstance().getName()); _kb.addSubClass(_A, _C); _kb.addEquivalentClass(_A, some(_p, dt)); _kb.addSubClass(_B, _C); _kb.addEquivalentClass(_B, hasValue(_p, literal(2))); assertTrue(_kb.isConsistent()); assertSubClass(_kb, _B, _A); _kb.classify(); _kb.printClassTree(); assertSubClass(_kb, _B, _A); }