public ElkEquivalentClassesAxiom getPremise( final ElkObject.Factory factory) { final List<ElkObjectOneOf> equivalent = new ArrayList<ElkObjectOneOf>( same_.size()); for (final ElkIndividual individual : same_) { equivalent.add(factory .getObjectOneOf(Collections.singletonList(individual))); } return factory.getEquivalentClassesAxiom(equivalent); }
@Override public ElkSubClassOfAxiom getConclusion(ElkObject.Factory factory) { return factory.getSubClassOfAxiom( factory.getObjectOneOf(Collections.<ElkIndividual> emptyList()), factory.getOwlNothing()); }
@Override public ElkSubClassOfAxiom getConclusion(ElkObject.Factory factory) { return factory.getSubClassOfAxiom(factory.getOwlThing(), factory.getObjectIntersectionOf( Collections.<ElkClassExpression> emptyList())); }
public ElkClassAssertionAxiom getPremise(ElkObject.Factory factory) { return factory.getClassAssertionAxiom(type_, instance_); }
public ElkClassAssertionAxiom getPremise(ElkObject.Factory factory) { return factory.getClassAssertionAxiom(type_, instance_); }
public ElkClassAssertionAxiom getPremise(ElkObject.Factory factory) { return factory.getClassAssertionAxiom(type_, instance_); }
@Test public void testSimpleSubsumption() throws ElkException { TestLoader loader = new TestLoader(); Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); ElkClass A = objectFactory.getClass(new ElkFullIri(":A")); ElkClass B = objectFactory.getClass(new ElkFullIri(":B")); loader.add(objectFactory.getSubClassOfAxiom(A, B)); assertFalse(reasoner.isSatisfiable(objectFactory .getObjectIntersectionOf(A, objectFactory.getObjectComplementOf(B)))); assertTrue(reasoner.isSatisfiable(objectFactory .getObjectIntersectionOf(B, objectFactory.getObjectComplementOf(A)))); }
@Override public ElkClass getClass(ElkIri iri) { return filter(factory_.getClass(iri)); }
@Override public ElkClass getClass(ElkIri iri) { return filter(factory_.getClass(iri)); }
@Test @SuppressWarnings("static-method") public void testRecursiveTracingComposition() throws Exception { ElkObject.Factory factory = new ElkObjectEntityRecyclingFactory(); Reasoner reasoner = TestReasonerUtils .loadAndClassify(TestReasonerUtils.loadAxioms("tracing/RecursiveComposition.owl")); ElkClass a = factory.getClass(new ElkFullIri("http://example.org/A")); ElkObjectProperty r = factory .getObjectProperty(new ElkFullIri("http://example.org/R")); ElkClass c = factory.getClass(new ElkFullIri("http://example.org/C")); ElkClassExpression rSomeC = factory.getObjectSomeValuesFrom(r, c); TracingTestUtils.checkTracingCompleteness(a, rSomeC, reasoner); }
@Override public ElkClass getClass(ElkIri iri) { return filter(factory_.getClass(iri)); }
@Test @SuppressWarnings("static-method") public void testRecursiveTracingExistential() throws Exception { ElkObject.Factory factory = new ElkObjectEntityRecyclingFactory(); Reasoner reasoner = TestReasonerUtils .loadAndClassify(TestReasonerUtils.loadAxioms("tracing/RecursiveExistential.owl")); ElkClass a = factory.getClass(new ElkFullIri("http://example.org/A")); ElkObjectProperty r = factory .getObjectProperty(new ElkFullIri("http://example.org/R")); ElkClass c = factory.getClass(new ElkFullIri("http://example.org/C")); ElkClassExpression rSomeC = factory.getObjectSomeValuesFrom(r, c); TracingTestUtils.checkTracingCompleteness(a, rSomeC, reasoner); }
@Test public void testEquivalentClasses() throws ElkException { Reasoner reasoner = TestReasonerUtils.createTestReasoner( new EmptyAxiomLoader()); // empty ontology, query for conjunction ElkClass A = objectFactory.getClass(new ElkFullIri(":A")); ElkClass B = objectFactory.getClass(new ElkFullIri(":B")); ElkClassExpression queryExpression = objectFactory .getObjectIntersectionOf(A, B); assertEquals(0, reasoner.getEquivalentClasses(queryExpression).size()); // the following has reproduced Issue 23: assertEquals(0, reasoner.getEquivalentClasses(queryExpression).size()); }
@Override public ElkDisjointClassesAxiom getConclusion(ElkObject.Factory factory) { List<ElkObjectOneOf> disjoint = new ArrayList<ElkObjectOneOf>( different_.size()); for (ElkIndividual individual : different_) { disjoint.add(factory .getObjectOneOf(Collections.singletonList(individual))); } return factory.getDisjointClassesAxiom(disjoint); }
@Override public ElkDisjointClassesAxiom getDisjointClassesAxiom( List<? extends ElkClassExpression> disjointClassExpressions) { return filter( factory_.getDisjointClassesAxiom(disjointClassExpressions)); }
@Override public ElkDisjointClassesAxiom getConclusion(ElkObject.Factory factory) { List<ElkObjectOneOf> disjoint = new ArrayList<ElkObjectOneOf>( different_.size()); for (ElkIndividual individual : different_) { disjoint.add(factory .getObjectOneOf(Collections.singletonList(individual))); } return factory.getDisjointClassesAxiom(disjoint); }
@Override public ElkSameIndividualAxiom getConclusion( final ElkObject.Factory factory) { return factory.getSameIndividualAxiom(same_); }
@Override public ElkSameIndividualAxiom getSameIndividualAxiom( List<? extends ElkIndividual> individuals) { return filter(factory_.getSameIndividualAxiom(individuals)); }
@Override public ElkSameIndividualAxiom getSameIndividualAxiom( List<? extends ElkIndividual> individuals) { return filter(factory_.getSameIndividualAxiom(individuals)); }
@Override public ElkAxiom visit(final ElkNamedIndividual ind) { return factory.getSameIndividualAxiom( new ArrayList<ElkNamedIndividual>( Operations.getCollection( Operations.filter(equivalent, ElkNamedIndividual.class), equivalent.size()))); }