@Override public void visitTerm(final ATermAppl term) { _kb.addClass(term); }
@Override public void visitTerm(final ATermAppl term) { _kb.addClass(term); }
protected void classes(final ATermAppl... classes) { for (final ATermAppl cls : classes) _kb.addClass(cls); }
protected boolean defineClass(final ATermAppl c) { if (ATermUtils.isPrimitive(c)) { _kb.addClass(c); return true; } else return ATermUtils.isComplexClass(c); }
protected boolean defineClass(final ATermAppl c) { if (ATermUtils.isPrimitive(c)) { _kb.addClass(c); return true; } else return ATermUtils.isComplexClass(c); }
protected boolean defineClass(final ATermAppl c) { if (ATermUtils.isPrimitive(c)) { _kb.addClass(c); return true; } else return ATermUtils.isComplexClass(c); }
@Override public void visit(final OWLClass c) { if (c.isOWLThing()) _term = ATermUtils.TOP; else if (c.isOWLNothing()) _term = ATermUtils.BOTTOM; else _term = ATermUtils.makeTermAppl(c.getIRI().toString()); if (_addAxioms) _kb.addClass(_term); }
@Override public void visit(final OWLClass c) { if (c.isOWLThing()) _term = ATermUtils.TOP; else if (c.isOWLNothing()) _term = ATermUtils.BOTTOM; else _term = ATermUtils.makeTermAppl(c.getIRI().toString()); if (_addAxioms) _kb.addClass(_term); }
@Override public void visit(final OWLClass c) { if (c.isOWLThing()) _term = ATermUtils.TOP; else if (c.isOWLNothing()) _term = ATermUtils.BOTTOM; else _term = ATermUtils.makeTermAppl(c.getIRI().toString()); if (_addAxioms) _kb.addClass(_term); }
@Test public void testBottomSatisfiable() { _kb.addClass(human); explainEntailment(!_kb.isSatisfiable(ATermUtils.makeAnd(ATermUtils.makeNot(human), ATermUtils.BOTTOM))); }
@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 testEmptyRuleHead1() { final ATermAppl i = term("i"); final ATermAppl C = term("C"); final AtomIVariable x = new AtomIVariable("x"); _kb.addClass(C); _kb.addIndividual(i); _kb.addType(i, C); final List<RuleAtom> body = new ArrayList<>(); final List<RuleAtom> head = new ArrayList<>(); body.add(new ClassAtom(C, x)); _kb.addRule(new Rule(head, body)); assertFalse(_kb.isConsistent()); }
@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 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)); }
@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)); }
@Test public void testSimpleABoxRemove() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl a = term("a"); final ATermAppl C = term("C"); final ATermAppl D = term("D"); kb.addClass(C); kb.addClass(D); kb.addIndividual(a); kb.addType(a, C); kb.addType(a, D); kb.removeType(a, D); assertTrue(kb.isConsistent()); assertTrue(kb.isType(a, C)); assertFalse(kb.isType(a, D)); }
@Test public void testSelfRestrictions() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl c = term("c"); final ATermAppl d = term("d"); final ATermAppl p = term("p"); kb.addClass(c); kb.addClass(d); kb.addObjectProperty(p); kb.addRange(p, d); kb.addSubClass(c, and(self(p), some(p, TOP))); assertTrue(kb.isConsistent()); assertTrue(kb.isSatisfiable(c)); assertTrue(kb.isSubClassOf(c, d)); }
@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 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 testReflexive2() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl a = term("a"); final ATermAppl c = term("c"); final ATermAppl r = term("r"); kb.addIndividual(a); kb.addClass(c); kb.addSubClass(c, all(r, BOTTOM)); kb.addSubClass(c, oneOf(a)); kb.addObjectProperty(r); kb.addReflexiveProperty(r); assertSatisfiable(kb, c, false); }