void Ontology::subsumption(const Concept* c, const Concept* d) { if (c->type() == 'B' || d->type() == 'T') return; if (c->type() == 'T' && d->type() == 'U') { const UniversalConcept* u = (const UniversalConcept*) d; role_range.insert(make_pair(u->role()->ID(), Disjunction(Concept::concept_decompose(u->concept())))); u->concept()->accept(*pos_str); c->accept(*neg_str); return; } c->accept(*neg_str); d->accept(*pos_str); unary(c->ID(), Disjunction(Concept::concept_decompose(d))); }
TEST(CPTest, Unsat2) { SolverOption options; options.verbosity = 0; auto space = new Space(options); vector<VarID> elemx; uint n = 4; for(uint i=1; i<n; ++i){ VarID x = {i}; extAdd(*space, IntVarRange(DEFAULTCONSTRID,x, 1, 3)); elemx.push_back(x); } int c = 1; for(uint i=0; i<elemx.size(); ++i){ for(uint j=0; j<elemx.size(); ++j, ++c){ extAdd(*space, CPBinaryRelVar(DEFAULTCONSTRID,mkPosLit(c), elemx[i], EqType::NEQ, elemx[j])); extAdd(*space, Disjunction(DEFAULTCONSTRID, {mkPosLit(c)})); } } ModelExpandOptions mxoptions(0, Models::NONE, Models::NONE); auto mx = ModelExpand(space, mxoptions, {}); mx.execute(); ASSERT_TRUE(mx.isUnsat()); delete(space); }
void Ontology::NegativeStructuralTransformation::universal(const UniversalConcept *c) { if (not_seen(c)) { const ExistentialConcept* e = factory.existential(c->role(), factory.negation(c->concept())); ontology->nullary(Disjunction(c->ID(), Concept::concept_decompose(e))); e->accept(*positive); } }
void Ontology::NegativeStructuralTransformation::disjunction(const DisjunctionConcept* c) { if (not_seen(c)) for (vector<const Concept*>::const_iterator i = c->elements().begin(); i != c->elements().end(); i++) { ontology->unary((*i)->ID(), Disjunction(c->ID())); (*i)->accept(*this); } }
void Ontology::PositiveStructuralTransformation::disjunction(const DisjunctionConcept* c) { if (not_seen(c)) { ontology->unary(Concept::concept_decompose(c), Disjunction(c->elements(), true)); for (vector<const Concept*>::const_iterator i = c->elements().begin(); i != c->elements().end(); i++) (*i)->accept(*this); } }
TEST(CPTest, UnSatCPSum) { SolverOption options; options.verbosity = 0; auto space = new Space(options); extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkPosLit(1), mkNegLit(2), mkPosLit(3)})); extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkPosLit(1), mkPosLit(2), mkPosLit(3)})); extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkNegLit(3)})); VarID groundone={1}, groundtwo={2}; extAdd(*space, IntVarRange(DEFAULTCONSTRID,groundone, -3, 7)); extAdd(*space, IntVarRange(DEFAULTCONSTRID,groundtwo, 7, 10)); extAdd(*space, CPSumWeighted(DEFAULTCONSTRID,mkPosLit(1), {mkNegLit(3),mkNegLit(3)}, {groundone, groundtwo}, {Weight(1),Weight(1)}, EqType::GEQ, Weight(18))); ModelExpandOptions mxoptions(0, Models::NONE, Models::NONE); auto mx = ModelExpand(space, mxoptions, {}); mx.execute(); ASSERT_TRUE(mx.isUnsat()); delete(space); }
void Ontology::NegativeStructuralTransformation::conjunction(const ConjunctionConcept *c) { if (not_seen(c)) { vector<const Concept*> u, q(c->elements()); set<ConceptID, Concept::DecomposeLess> s; for (int i = 0; i < q.size(); i++) { if (q[i]->type() == 'C') { FOREACH(x, ((const ConjunctionConcept*) q[i])->elements()) q.push_back(*x); } else if (q[i]->type() == 'N') { const NegationConcept* x = (const NegationConcept*) q[i]; s.insert(Concept::concept_decompose(x->concept())); x->concept()->accept(*positive); } else if (q[i]->type() == 'U') { const UniversalConcept* y = (const UniversalConcept*) q[i]; const ExistentialConcept* x = factory.existential(y->role(), factory.negation(y->concept())); s.insert(Concept::concept_decompose(x)); x->accept(*positive); } else { u.push_back(q[i]); q[i]->accept(*this); } } s.insert(c->ID()); if (u.empty()) ontology->nullary(Disjunction(s)); else if (u.size() == 1) ontology->unary(u[0]->ID(), Disjunction(s)); else { const Concept *d = u[0]; vector<const Concept*> t; t.push_back(d); for (int i = 1; i < u.size()-1; i++) { t.push_back(u[i]); const Concept *conj = factory.conjunction(t); ontology->binary(d->ID(), u[i]->ID(), Disjunction(conj->ID())); d = conj; } ontology->binary(d->ID(), u.back()->ID(), Disjunction(s)); } } }
//Magic sequence problem TEST(CPTest, DISABLED_MagicSeq) { SolverOption options; options.verbosity = 0; auto space = new Space(options); extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkPosLit(42)})); extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkPosLit(1), mkPosLit(2), mkPosLit(3)})); vector<Weight> mult; vector<VarID> elemx; uint n = 100; for(uint i=0; i<n; ++i){ mult.push_back(Weight(((int)i)-1)); VarID x = {i}; extAdd(*space, IntVarRange(DEFAULTCONSTRID,x, Weight(0), Weight(n))); elemx.push_back(x); } vector<Weight> weights; weights.resize(elemx.size(),Weight(1)); for(uint i=0; i<n; ++i){ extAdd(*space, CPCount(DEFAULTCONSTRID,elemx, Weight((int)i), EqType::EQ, elemx[i])); } extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkPosLit(4)})); extAdd(*space, CPSumWeighted(DEFAULTCONSTRID,mkPosLit(4), vector<Lit>(elemx.size(), mkPosLit(42)), elemx, weights, EqType::EQ, n)); extAdd(*space, Disjunction(DEFAULTCONSTRID,{mkPosLit(5)})); extAdd(*space, CPSumWeighted(DEFAULTCONSTRID,mkPosLit(5),vector<Lit>(elemx.size(), mkPosLit(42)), elemx, mult, EqType::EQ, 0)); int literalcount = 6; for(uint i=0; i<n; ++i){ for(uint j=0; j<n; ++j){ extAdd(*space, CPBinaryRel(DEFAULTCONSTRID,mkPosLit(literalcount++), elemx[i], EqType::EQ, Weight((int)j))); extAdd(*space, CPBinaryRel(DEFAULTCONSTRID,mkPosLit(literalcount++), elemx[i], EqType::GEQ, Weight((int)j))); } } ModelExpandOptions mxoptions(2, Models::NONE, Models::NONE); auto mx = ModelExpand(space, mxoptions, {}); mx.execute(); ASSERT_TRUE(mx.isUnsat()); delete(space); }
void Ontology::normalize() { hierarchy.closure(); //reduce transitivity for universals set<const UniversalConcept *> s; FOREACH(u, positive_universals) FOREACH(i, transitive_roles) if (hierarchy(*i, (*u)->role()->ID())) { const Role *t = factory.role(*i); const UniversalConcept *c = factory.universal(t, factory.universal(t, (*u)->concept())); if (t != (*u)->role()) unary(Concept::concept_decompose(*u), Disjunction(Concept::concept_decompose(c))); s.insert(c); } FOREACH(u, s) { unary(Concept::concept_decompose((*u)->concept()), Disjunction(Concept::concept_decompose(*u))); positive_universals.insert(*u); positive_universals.insert((const UniversalConcept *) (*u)->concept()); }
//duals of universals FOREACH(u, positive_universals) { const ExistentialConcept *e = factory.existential((*u)->role(), factory.negation((*u)->concept())); negative_existentials.insert(e); binary(Concept::concept_decompose(*u), e->ID(), Disjunction()); }
void Ontology::disjoint(const Concept* c, const Concept* d) { c->accept(*neg_str); d->accept(*neg_str); binary(c->ID(), d->ID(), Disjunction()); }
void Ontology::PositiveStructuralTransformation::negation(const NegationConcept *c) { if (not_seen(c)) { ontology->binary(Concept::concept_decompose(c), c->concept()->ID(), Disjunction()); c->concept()->accept(*negative); } }
void Ontology::PositiveStructuralTransformation::bottom(const BottomConcept *c) { if (not_seen(c)) ontology->unary(c->ID(), Disjunction()); }
void Ontology::NegativeStructuralTransformation::top(const TopConcept *c) { if (not_seen(c)) ontology->nullary(Disjunction(c->ID())); }
//duals of universals FOREACH(u, positive_universals) { const ExistentialConcept *e = factory.existential((*u)->role(), factory.negation((*u)->concept())); negative_existentials.insert(e); binary(Concept::concept_decompose(*u), e->ID(), Disjunction()); } //reduce number of neighbours in binary_axioms map<ConceptID, ConceptID> dummy; FOREACH(i, binary_count) if (i->second > 100) { ConceptID d = factory.dummy(Concept::minimal_ID())->ID(); dummy[i->first] = d; EQRANGE(j, binary_axioms, i->first) unary(j->second.first, Disjunction(d, j->second.second)); } FOREACH(i, binary_axioms) if (dummy.find(i->first) != dummy.end() || dummy.find(i->second.first) != dummy.end()) binary_axioms.erase(i); FOREACH(i, dummy) { binary_axioms.insert(make_pair(i->first, make_pair(i->second, Disjunction()))); binary_axioms.insert(make_pair(i->second, make_pair(i->first, Disjunction()))); } //unfold role hierarchy into existential axioms FOREACH(e, negative_existentials) FOREACH(r, positive_roles) if (hierarchy(*r, (*e)->role()->ID())) universal_axioms.insert(make_pair(make_pair((*e)->concept()->ID(), *r), (*e)->ID()));