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()));
