@Test public void intersectIntegerNotDecimal() throws InvalidConstrainingFacetException, InvalidLiteralException, UnrecognizedDatatypeException { assertUnsatisfiable(INTEGER, not(DECIMAL)); }
@Test public void testNot() { final StringWriter s = new StringWriter(); final ATermRenderer r = new ATermManchesterSyntaxRenderer(); r.setWriter(new PrintWriter(s)); final ATermAppl C = term("C"); r.visit(not(C)); final String expected = "not C"; final String actual = s.toString(); assertEquals(expected, actual); }
@Override public void visit(final DifferentIndividualsAtom atom) { final ATermAppl ind1 = _binding.get(atom.getArgument1()).getName(); final ATermAppl ind2 = _binding.get(atom.getArgument2()).getName(); final ATermAppl cls = not(value(ind2)); addType(ind1, cls); }
@Test public void testCyclicTBox1() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl C = term("C"); kb.addEquivalentClass(C, not(C)); assertFalse(kb.isConsistent()); }
@Test public void testFindPrimitives() { testFindPrimitives(some(_p, not(_c)), new ATermAppl[] { _c }); testFindPrimitives(and(_c, _b, all(_p, _a)), new ATermAppl[] { _a, _b, _c }); testFindPrimitives(max(_p, 1, not(some(_p, or(_a, _b)))), new ATermAppl[] { _a, _b }); testFindPrimitives(min(_p, 2, or(_a, and(_b, not(_c)))), new ATermAppl[] { _a, _b, _c }); testFindPrimitives(and(some(_p, ATermUtils.TOP), all(_p, _a), and(some(_p, value(_r)), or(self(_p), max(_p, 1, _b)))), new ATermAppl[] { ATermUtils.TOP, _a, _b }); testFindPrimitives(and(_d1, _d2, _d3), new ATermAppl[] { _d3 }); testFindPrimitives(not(and(not(_d1), _d2, _d3)), new ATermAppl[] { _d3 }); testFindPrimitives(some(_p, and(_d1, _d3)), new ATermAppl[] { _d3 }); }
@Test public void testFindPrimitives() { testFindPrimitives(some(_p, not(_c)), new ATermAppl[] { _c }); testFindPrimitives(and(_c, _b, all(_p, _a)), new ATermAppl[] { _a, _b, _c }); testFindPrimitives(max(_p, 1, not(some(_p, or(_a, _b)))), new ATermAppl[] { _a, _b }); testFindPrimitives(min(_p, 2, or(_a, and(_b, not(_c)))), new ATermAppl[] { _a, _b, _c }); testFindPrimitives(and(some(_p, ATermUtils.TOP), all(_p, _a), and(some(_p, value(_r)), or(self(_p), max(_p, 1, _b)))), new ATermAppl[] { ATermUtils.TOP, _a, _b }); testFindPrimitives(and(_d1, _d2, _d3), new ATermAppl[] { _d3 }); testFindPrimitives(not(and(not(_d1), _d2, _d3)), new ATermAppl[] { _d3 }); testFindPrimitives(some(_p, and(_d1, _d3)), new ATermAppl[] { _d3 }); }
@Test public void testDomainRangeSymmetric() { classes(_A); objectProperties(_p); individuals(_a, _b); _kb.addDomain(_p, _A); _kb.addRange(_p, not(_A)); _kb.addSymmetricProperty(_p); _kb.addPropertyValue(_p, _a, _b); explainInconsistency(ATermUtils.makeDomain(_p, _A), ATermUtils.makeRange(_p, not(_A)), ATermUtils.makeSymmetric(_p), ATermUtils.makePropAtom(_p, _a, _b)); }
@Test public void intersectFloatIntervalNotFloat() throws InvalidConstrainingFacetException, InvalidLiteralException, UnrecognizedDatatypeException { final ATermAppl floatInterval = restrict(FLOAT, minInclusive(literal(0.0f)), maxInclusive(literal(1.0f))); assertUnsatisfiable(floatInterval, not(FLOAT)); }
@Test public void testDomainExpression() { classes(_A, _B); objectProperties(_p); individuals(_a, _b); _kb.addDomain(_p, or(_A, _B)); _kb.addType(_a, not(or(_A, _B))); _kb.addPropertyValue(_p, _a, _b); explainInconsistency(ATermUtils.makeDomain(_p, or(_A, _B)), ATermUtils.makeTypeAtom(_a, not(or(_A, _B))), ATermUtils.makePropAtom(_p, _a, _b)); }
@Test public void intersectTextNegatedTextValue() throws InvalidConstrainingFacetException, InvalidLiteralException, UnrecognizedDatatypeException { final Collection<ATermAppl> types = Arrays.asList(PLAIN_LITERAL, not(value(literal("http://example.org")))); assertTrue(reasoner.isSatisfiable(types)); assertTrue(reasoner.containsAtLeast(2, types)); assertTrue(reasoner.isSatisfiable(types, literal("http://example.com"))); assertFalse(reasoner.isSatisfiable(types, literal("http://example.org"))); }
@Test public void somePQallAnonInvR2() { classes(_C); objectProperties(_p, _q, _r); _kb.addSubProperty(list(_p, _q), _r); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSatisfiable(_C)); assertTrue(_kb.isSatisfiable(some(_q, all(inv(_r), not(_C))))); assertFalse(_kb.isSatisfiable(and(_C, some(_p, some(_q, all(inv(_r), not(_C))))))); }
@Test public void doubleBlockingExample() { classes(_C, _D); objectProperties(_f, _r); _kb.addTransitiveProperty(_r); _kb.addSubProperty(_f, _r); _kb.addEquivalentClass(_D, and(_C, some(_f, not(_C)))); _kb.addSubClass(TOP, max(_f, 1, TOP)); assertTrue(_kb.isConsistent()); assertFalse(_kb.isSatisfiable(and(not(_C), some(inv(_f), _D), all(inv(_r), some(inv(_f), _D))))); }
@Test public void bottomObjectInverseManual() { final KnowledgeBaseImpl kb = new KnowledgeBaseImpl(); final ATermAppl c = term("_C_"); final ATermAppl notC = not(c); final ATermAppl r = BOTTOM_OBJECT_PROPERTY; final ATermAppl test = and(c, or(some(r, all(r, notC)), some(r, all(r, notC)))); assertFalse(kb.isSatisfiable(test)); }
@Test public void intersectNegatedIntegerInterval() throws InvalidConstrainingFacetException, InvalidLiteralException, UnrecognizedDatatypeException { final ATermAppl intInterval1 = restrict(INTEGER, minInclusive(literal(0)), maxInclusive(literal(1))); final ATermAppl intInterval2 = restrict(INTEGER, minInclusive(literal(2)), maxInclusive(literal(3))); assertSatisfiable(intInterval1, not(intInterval2)); }
@Test public void someFunctionalP() { classes(_C, _D); objectProperties(_p); _kb.addFunctionalProperty(_p); _kb.addSubClass(_D, some(inv(_p), _C)); _kb.addSubClass(_C, some(_p, not(_D))); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSatisfiable(_C)); assertFalse(_kb.isSatisfiable(_D)); }
@Test public void cachedIntersectionWithTop1() { classes(_B, _C, _D); objectProperties(_p); _kb.addEquivalentClass(_C, TOP); _kb.addSubClass(_B, some(_p, and(_C, _D))); assertTrue(_kb.isConsistent()); assertFalse(_kb.isSatisfiable(not(_C))); assertTrue(_kb.isSatisfiable(_D)); assertTrue(_kb.isSatisfiable(_B)); }
@Test public void somePallInvPwithReflexivity() { classes(_C, _D); objectProperties(_p, _r); _kb.addReflexiveProperty(_r); _kb.addSubClass(_D, some(_p, _C)); _kb.addSubClass(_C, all(inv(_p), not(_D))); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSatisfiable(_C)); assertFalse(_kb.isSatisfiable(_D)); }
@Test public void propertyChainInverse() { classes(_C, _D); objectProperties(_p, _q, _r); _kb.addSubProperty(list(_r, _p), _q); _kb.addSubClass(_D, all(_q, _C)); assertTrue(_kb.isConsistent()); assertFalse(_kb.isSatisfiable(some(_p, and(_D, some(_p, and(some(inv(_r), _D), some(_p, not(_C)))))))); }