bool SimpSMTSolver::asymm(Var v, Clause& c)
{
assert(decisionLevel() == 0);
if (c.mark() || satisfied(c)) return true;
trail_lim.push(trail.size());
Lit l = lit_Undef;
for (int i = 0; i < c.size(); i++)
if (var(c[i]) != v && value(c[i]) != l_False)
{
uncheckedEnqueue(~c[i]);
}
else
l = c[i];
if (propagate() != NULL){
cancelUntil(0);
asymm_lits++;
if (!strengthenClause(c, l))
return false;
}else
cancelUntil(0);
return true;
}
void SimpSolver::removeClause(Clause& c)
{
assert(!c.learnt());
if (use_simplification)
for (int i = 0; i < c.size(); i++){
n_occ[toInt(c[i])]--;
updateElimHeap(var(c[i]));
}
detachClause(c);
c.mark(1);
}
bool SimpSolver::strengthenClause(Clause& c, Lit l)
{
assert(decisionLevel() == 0);
assert(c.mark() == 0);
assert(!c.learnt());
assert(find(watches[toInt(~c[0])], &c));
assert(find(watches[toInt(~c[1])], &c));
// FIX: this is too inefficient but would be nice to have (properly implemented)
// if (!find(subsumption_queue, &c))
subsumption_queue.insert(&c);
// If l is watched, delete it from watcher list and watch a new literal
if (c[0] == l || c[1] == l){
Lit other = c[0] == l ? c[1] : c[0];
if (c.size() == 2){
removeClause(c);
c.strengthen(l);
}else{
c.strengthen(l);
remove(watches[toInt(~l)], &c);
// Add a watch for the correct literal
watches[toInt(~(c[1] == other ? c[0] : c[1]))].push(&c);
// !! this version assumes that remove does not change the order !!
//watches[toInt(~c[1])].push(&c);
clauses_literals -= 1;
}
}
else{
c.strengthen(l);
clauses_literals -= 1;
}
// if subsumption-indexing is active perform the necessary updates
if (use_simplification){
remove(occurs[var(l)], &c);
n_occ[toInt(l)]--;
updateElimHeap(var(l));
}
return c.size() == 1 ? enqueue(c[0]) && propagate() == NULL : true;
}