@Test public void testUnsatClasses2() { classes(_B, _C, _D); _kb.addDisjointClass(_C, _D); _kb.addSubClass(_B, and(_C, _D)); assertEquals(singleton(_B), _kb.getUnsatisfiableClasses()); assertEquals(SetUtils.create(_B, BOTTOM), _kb.getAllUnsatisfiableClasses()); assertFalse(_kb.isClassified()); assertEquals(singleton(_B), _kb.getUnsatisfiableClasses()); assertEquals(SetUtils.create(_B, BOTTOM), _kb.getAllUnsatisfiableClasses()); }
@Test public void testDisjointWithSome2() { classes(_A, _B, _C, _D, _E, _F, _G); objectProperties(_p, _q, _r, _s); _kb.addSubClass(_A, some(_p, and(_B, _C))); _kb.addDisjointClass(_B, _C); final Taxonomy<ATermAppl> hierarchy = getHierarchy(); assertEquals(SetUtils.create(_A), hierarchy.getEquivalents(ATermUtils.BOTTOM)); }
@Test public void testDisjointRange() { classes(_A, _B, _C, _D, _E, _F, _G); objectProperties(_p, _q, _r, _s); _kb.addRange(_p, _C); _kb.addSubClass(_A, some(_p, _B)); _kb.addDisjointClass(_B, _C); final Taxonomy<ATermAppl> hierarchy = getHierarchy(); assertEquals(SetUtils.create(_A), hierarchy.getEquivalents(ATermUtils.BOTTOM)); }
assertEquals(expectedTypes, actualTypes); kb.addDisjointClass(A, B); assertFalse(kb.isConsistent());
assertFalse(_kb.isConsistent()); _kb.addDisjointClass(_A, _B); assertFalse(_kb.isConsistent());
@Test public void testDisjoint() { classes(_A, _B, _C, _D, _E, _F, _G); objectProperties(_p, _q, _r, _s); _kb.addSubClass(and(_A, _B), ATermUtils.BOTTOM); _kb.addSubClass(_A, _B); _kb.addDisjointClass(_C, _D); _kb.addEquivalentClass(_C, _D); final Taxonomy<ATermAppl> hierarchy = getHierarchy(); assertEquals(SetUtils.create(_A, _C, _D), hierarchy.getEquivalents(ATermUtils.BOTTOM)); }
@Test public void testDisjointRangeSuper() { classes(_A, _B, _C, _D, _E, _F, _G); objectProperties(_p, _q, _r, _s); _kb.addRange(_p, _C); _kb.addSubClass(_A, some(_p, _B)); _kb.addSubClass(_B, _D); _kb.addDisjointClass(_D, _C); _kb.addSubClass(_A, _E); _kb.addSubClass(_B, _F); final Taxonomy<ATermAppl> hierarchy = getHierarchy(); assertEquals(SetUtils.create(_A), hierarchy.getEquivalents(ATermUtils.BOTTOM)); }
@Test public void testDisjointWithSome1() { classes(_A, _B, _C, _D, _E, _F, _G); objectProperties(_p, _q, _r, _s); _kb.addSubProperty(_p, _q); _kb.addSubClass(_A, some(_p, _B)); _kb.addSubClass(_A, _D); _kb.addSubClass(some(_p, _B), some(_p, _C)); _kb.addDisjointClass(some(_q, _C), _D); final Taxonomy<ATermAppl> hierarchy = getHierarchy(); assertEquals(SetUtils.create(_A), hierarchy.getEquivalents(ATermUtils.BOTTOM)); }
@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"))); }
@Test public void cachedIntersectionUnsat() { classes(_B, _C, _D); objectProperties(_p); _kb.addDisjointClass(_C, _D); _kb.addSubClass(_B, some(_p, some(inv(_p), and(_C, _D)))); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSatisfiable(_C)); assertTrue(_kb.isSatisfiable(_D)); assertFalse(_kb.isSatisfiable(_B)); }
@Test public void propertyChain() { classes(_C, _D); objectProperties(_p, _q, _r, _s); _kb.addDisjointClass(_C, _D); _kb.addSubProperty(list(_p, inv(_q), _r, _s), _s); _kb.addSubClass(_D, all(_s, _C)); _kb.addSubClass(_D, some(_p, some(inv(_q), some(_r, some(_s, _D))))); assertTrue(_kb.isConsistent()); assertFalse(_kb.isSatisfiable(_D)); }
@Test public void testIncrementalTBoxDisjointRemove5() { // Same as testIncrementalTBoxDisjointRemove4 but // uses n-ary disjointness axioms final Properties newOptions = new PropertiesBuilder().set("USE_TRACING", "true").set("USE_ROLE_ABSORPTION", "true").build(); final Properties savedOptions = OpenlletOptions.setOptions(newOptions); try { final ATermAppl A = ATermUtils.makeTermAppl("A"); final ATermAppl B = ATermUtils.makeTermAppl("B"); final ATermAppl p = ATermUtils.makeTermAppl("p"); final KnowledgeBase kb = new KnowledgeBaseImpl(); kb.addClass(A); kb.addClass(B); kb.addObjectProperty(p); final ATermAppl or1 = or(A, some(p, A)); final ATermAppl or2 = or(B, some(p, B)); kb.addDisjointClass(or1, or2); assertTrue(kb.isConsistent()); final ATermAppl disjoint = ATermUtils.makeDisjoint(or1, or2); assertFalse(kb.removeAxiom(disjoint)); } finally { OpenlletOptions.setOptions(savedOptions); } }
@Test public void testNegatedBooleanQueries1() { classes(_A, _B); individuals(_a); _kb.addType(_a, _A); final Query q1 = query(NotKnownAtom(TypeAtom(_a, _A))); final Query q2 = query(NotKnownAtom(TypeAtom(_a, _B))); final Query q3 = query(NotKnownAtom(TypeAtom(_a, not(_A)))); final Query q4 = query(NotKnownAtom(TypeAtom(_a, not(_B)))); testQuery(false, q1); testQuery(true, q2); testQuery(true, q3); testQuery(true, q4); _kb.addDisjointClass(_A, _B); testQuery(false, q1); testQuery(true, q2); testQuery(true, q3); testQuery(false, q4); } }
@Test public void testQualifiedCardinality3() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl c = term("z"); final ATermAppl d = term("d"); final ATermAppl e = term("e"); final ATermAppl notD = term("notD"); final ATermAppl p = term("p"); final ATermAppl x = term("x"); final ATermAppl y3 = term("y3"); kb.addObjectProperty(p); kb.addClass(c); kb.addClass(d); kb.addClass(e); kb.addClass(notD); kb.addDisjointClass(d, notD); // _kb.addSubClass( c, or(e,not(d)) ); kb.addIndividual(x); kb.addIndividual(y3); kb.addType(x, and(min(p, 2, and(d, e)), max(p, 2, d))); kb.addType(y3, not(e)); kb.addType(y3, some(inv(p), value(x))); kb.addType(y3, or(d, c)); assertTrue(kb.isConsistent()); }
kb.addPropertyValue(term("p"), term("x"), term("x4")); kb.addDisjointClass(term("E1"), term("E2")); kb.addDisjointClass(term("E1"), term("E4")); kb.addDisjointClass(term("E2"), term("E3"));
kb.addEquivalentClass(A, oneOf(a)); kb.addEquivalentClass(B, oneOf(b)); kb.addDisjointClass(A, B);
_kb.addClass(Man); _kb.addClass(Woman); _kb.addDisjointClass(Man, Woman);
_kb.addDisjointClass(_person, not(_person));
_kb.addClass(_dog); _kb.addClass(_cat); _kb.addDisjointClass(_dog, _cat);