public void explainEntailment(final boolean entailment, final ATermAppl... expected) { assertTrue(entailment); final Set<ATermAppl> actual = _kb.getExplanationSet(); assertEquals(SetUtils.create(expected), actual); }
public void explainInconsistency(final ATermAppl... expected) { assertFalse(_kb.isConsistent()); final Set<ATermAppl> actual = _kb.getExplanationSet(); assertEquals(SetUtils.create(expected), actual); }
@Test public void testTopBottom() { _kb = new KnowledgeBaseImpl(); _kb.addSubClass(ATermUtils.TOP, ATermUtils.BOTTOM); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeSub(ATermUtils.TOP, ATermUtils.BOTTOM), }); }
@Test public void testSameDifferent() { _kb.addIndividual(robert); _kb.addIndividual(bob); _kb.addSame(robert, bob); _kb.addDifferent(robert, bob); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertTrue(explanation.contains(ATermUtils.makeSameAs(robert, bob))); assertTrue(explanation.contains(ATermUtils.makeDifferent(robert, bob))); assertTrue(explanation.size() == 2); }
@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), }); }
private static void testExplanation(final OWLAxiom axiom) { OWLOntology ont = null; try { ont = OWL.Ontology(axiom); final OpenlletReasoner reasoner = OpenlletReasonerFactory.getInstance().createReasoner(ont); reasoner.getKB().setDoExplanation(true); assertTrue("Entailment failed", reasoner.isEntailed(axiom)); final Set<ATermAppl> terms = reasoner.getKB().getExplanationSet(); assertTrue("Explanation incorrect " + terms, terms.size() == 1); final OWLAxiom explanation = new AxiomConverter(reasoner).convert(terms.iterator().next()); assertEquals("Unexpected explanation", axiom, explanation); } finally { if (ont != null) _manager.removeOntology(ont); } }
/** * Test explanations for bad datatypes. Not implemented, known to fail. */ @Test public void testDatatypeStatement() { _kb.addDatatypeProperty(ssn); _kb.addIndividual(robert); final ATermAppl ssn1 = ATermUtils.makeTypedLiteral("bob", XSD.nonNegativeInteger.toString()); _kb.addPropertyValue(ssn, robert, ssn1); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertTrue(explanation.contains(ATermUtils.makePropAtom(ssn, robert, ssn1))); }
@Test public void testSameAllDifferent() { _kb.addIndividual(robert); _kb.addIndividual(bob); _kb.addIndividual(mary); ATermList list = ATermUtils.makeList(robert); list = ATermUtils.makeList(bob, list); list = ATermUtils.makeList(mary, list); _kb.addAllDifferent(list); _kb.addSame(robert, bob); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertTrue(explanation.contains(ATermUtils.makeSameAs(robert, bob))); assertTrue(explanation.contains(ATermUtils.makeAllDifferent(list))); assertTrue(explanation.size() == 2); }
@Test public void testFunctionalDataProp2() { _kb.addDatatypeProperty(ssn); _kb.addFunctionalProperty(ssn); _kb.addIndividual(robert); final ATermAppl ssn1 = ATermUtils.makePlainLiteral("012345678"); final ATermAppl ssn2 = ATermUtils.makePlainLiteral("123456789"); _kb.addPropertyValue(ssn, robert, ssn1); _kb.addPropertyValue(ssn, robert, ssn2); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makePropAtom(ssn, robert, ssn1), ATermUtils.makePropAtom(ssn, robert, ssn2), ATermUtils.makeFunctional(ssn), }); assertTrue(explanation.size() == 3); }
@Test public void testSubProp1() { final ATermAppl noRelatives = ATermUtils.makeMax(relative, 0, ATermUtils.TOP); _kb.addIndividual(mary); _kb.addIndividual(bob); _kb.addObjectProperty(relative); _kb.addObjectProperty(sibling); _kb.addSubProperty(sibling, relative); _kb.addType(bob, noRelatives); _kb.addPropertyValue(sibling, bob, mary); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeSubProp(sibling, relative), ATermUtils.makePropAtom(sibling, bob, mary), ATermUtils.makeTypeAtom(bob, noRelatives), }); }
@Test public void testRange() { final ATermAppl notPerson = ATermUtils.makeNot(person); _kb.addClass(person); _kb.addObjectProperty(sibling); _kb.addRange(sibling, person); _kb.addIndividual(robert); _kb.addIndividual(victor); _kb.addType(victor, notPerson); _kb.addPropertyValue(sibling, robert, victor); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeRange(sibling, person), ATermUtils.makeTypeAtom(victor, notPerson), ATermUtils.makePropAtom(sibling, robert, victor), }); }
@Test public void testInverseFunctionalDataProp() { final ATermList different = ATermUtils.makeList(robert).insert(mary); System.out.println("Different: " + different); _kb.addObjectProperty(mbox); _kb.addInverseFunctionalProperty(mbox); _kb.addIndividual(robert); _kb.addIndividual(mary); _kb.addIndividual(email); _kb.addAllDifferent(different); _kb.addPropertyValue(mbox, robert, email); _kb.addPropertyValue(mbox, mary, email); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); // System.out.println(explanation); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makePropAtom(mbox, robert, email), ATermUtils.makePropAtom(mbox, mary, email), ATermUtils.makeInverseFunctional(mbox), ATermUtils.makeAllDifferent(different), }); }
@Test public void testRestrictedDatatypeRange() { classes(_C, _D); dataProperties(_p); individuals(_a, _b, _c); _kb.addRange(_p, restrict(Datatypes.INTEGER, minInclusive(literal(10)))); _kb.addPropertyValue(_p, _a, literal(5)); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeRange(_p, restrict(Datatypes.INTEGER, minInclusive(literal(10)))), ATermUtils.makePropAtom(_p, _a, literal(5)) }); }
@Test public void testSubProp2() { final ATermAppl nonHumanRelatives = ATermUtils.makeAllValues(relative, ATermUtils.makeNot(person)); _kb.addIndividual(mary); _kb.addIndividual(bob); _kb.addObjectProperty(relative); _kb.addObjectProperty(sibling); _kb.addSubProperty(sibling, relative); _kb.addType(bob, nonHumanRelatives); _kb.addType(mary, person); _kb.addPropertyValue(sibling, bob, mary); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeSubProp(sibling, relative), ATermUtils.makePropAtom(sibling, bob, mary), ATermUtils.makeTypeAtom(bob, nonHumanRelatives), ATermUtils.makeTypeAtom(mary, person), }); }
@Test public void testReflexive() { final ATermAppl notPerson = ATermUtils.makeNot(person); final ATermAppl bobsType = ATermUtils.makeAllValues(relative, notPerson); _kb.addClass(person); _kb.addObjectProperty(relative); _kb.addReflexiveProperty(relative); _kb.addIndividual(robert); _kb.addType(robert, person); _kb.addType(robert, bobsType); _kb.addIndividual(victor); _kb.addType(victor, notPerson); // _kb.addPropertyValue(relative, robert, victor); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeReflexive(relative), ATermUtils.makeTypeAtom(robert, person), ATermUtils.makeTypeAtom(robert, bobsType), // ATermUtils.makePropAtom(relative, robert, victor), }); }
@Test public void testMaxOneDataProp() { _kb.addClass(person); _kb.addDatatypeProperty(ssn); final ATermAppl max1ssn = ATermUtils.makeMax(ssn, 1, ATermUtils.TOP_LIT); _kb.addSubClass(person, max1ssn); _kb.addSubClass(person, ATermUtils.makeMin(ssn, 1, ATermUtils.TOP_LIT)); _kb.addIndividual(robert); _kb.addType(robert, person); final ATermAppl ssn1 = ATermUtils.makePlainLiteral("012345678"); final ATermAppl ssn2 = ATermUtils.makePlainLiteral("123456789"); _kb.addPropertyValue(ssn, robert, ssn1); _kb.addPropertyValue(ssn, robert, ssn2); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makePropAtom(ssn, robert, ssn1), ATermUtils.makePropAtom(ssn, robert, ssn2), ATermUtils.makeSub(person, max1ssn), ATermUtils.makeTypeAtom(robert, person), }); }
@Test public void testInverseAllValues2() { classes(_C, _D); objectProperties(_p, _q); individuals(_a, _b, _c); _kb.addSubClass(_C, all(_q, _D)); _kb.addTransitiveProperty(_p); _kb.addInverseProperty(_p, _q); _kb.addPropertyValue(_p, _a, _b); _kb.addPropertyValue(_p, _b, _c); _kb.addType(_c, _C); _kb.addType(_a, not(_D)); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeSub(_C, all(_q, _D)), ATermUtils.makeTransitive(_p), ATermUtils.makeInvProp(_p, _q), ATermUtils.makePropAtom(_p, _a, _b), ATermUtils.makePropAtom(_p, _b, _c), ATermUtils.makeTypeAtom(_a, not(_D)), ATermUtils.makeTypeAtom(_c, _C) }); }
@Test public void testFunctionalDataProp1() { final ATermAppl C = term("C"); final ATermAppl D = XSDInteger.getInstance().getName(); final ATermAppl p = term("p"); final ATermAppl a = term("a"); final ATermAppl b = literal("012345678", Datatypes.INTEGER); _kb.addClass(C); _kb.addClass(D); _kb.addDatatypeProperty(p); _kb.addIndividual(a); _kb.addEquivalentClass(C, all(p, D)); _kb.addFunctionalProperty(p); _kb.addPropertyValue(p, a, b); assertTrue(_kb.isConsistent()); assertTrue(_kb.isType(a, C)); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeEqClasses(C, all(p, D)), ATermUtils.makeFunctional(p), ATermUtils.makePropAtom(p, a, b) }); }
@Test public void testInverseCardinality1() { final ATermAppl C = term("C"); final ATermAppl p = term("p"); final ATermAppl invP = term("invP"); final ATermAppl a = term("a"); final ATermAppl b = term("b"); _kb.addClass(C); _kb.addObjectProperty(p); _kb.addObjectProperty(invP); _kb.addIndividual(a); _kb.addIndividual(b); _kb.addSubClass(C, max(invP, 0, TOP)); _kb.addInverseProperty(p, invP); _kb.addPropertyValue(p, b, a); _kb.addType(a, C); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeSub(C, max(invP, 0, TOP)), ATermUtils.makeInvProp(p, invP), ATermUtils.makePropAtom(p, b, a), ATermUtils.makeTypeAtom(a, C) }); }
@Test public void testFunctionalObjectProp1() { final ATermAppl C = term("C"); final ATermAppl D = term("D"); final ATermAppl p = term("p"); final ATermAppl a = term("a"); final ATermAppl b = term("b"); _kb.addClass(C); _kb.addClass(D); _kb.addObjectProperty(p); _kb.addIndividual(a); _kb.addIndividual(b); _kb.addEquivalentClass(C, all(p, D)); _kb.addFunctionalProperty(p); _kb.addPropertyValue(p, a, b); _kb.addType(b, D); assertTrue(_kb.isConsistent()); assertTrue(_kb.isType(a, C)); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertIteratorValues(explanation.iterator(), new Object[] { ATermUtils.makeEqClasses(C, all(p, D)), ATermUtils.makeFunctional(p), ATermUtils.makePropAtom(p, a, b), ATermUtils.makeTypeAtom(b, D) }); }