bool ClingoPropagator::addClause(Solver& s, uint32 st) {
if (s.hasConflict()) { todo_.clear(); return false; }
if (todo_.empty()) { return true; }
const ClauseRep& clause = todo_.clause;
Literal w0 = clause.size > 0 ? clause.lits[0] : lit_false();
Literal w1 = clause.size > 1 ? clause.lits[1] : lit_false();
uint32 cs = (ClauseCreator::status(s, clause) & (ClauseCreator::status_unit|ClauseCreator::status_unsat));
if (cs && s.level(w1.var()) < s.decisionLevel() && s.isUndoLevel()) {
if ((st & state_ctrl) != 0u) { return false; }
if ((st & state_prop) != 0u) { ClingoPropagator::reset(); cancelPropagation(); }
s.undoUntil(s.level(w1.var()));
}
bool local = (todo_.flags & ClauseCreator::clause_no_add) != 0;
if (!s.isFalse(w0) || local || s.force(w0, this)) {
ClauseCreator::Result res = ClauseCreator::create(s, clause, todo_.flags);
if (res.local && local) { db_.push_back(res.local); }
}
todo_.clear();
return !s.hasConflict();
}
bool TheoryPropagator::PP::addClause(const Potassco::LitSpan& clause) {
CLASP_FAIL_IF(solver_->hasConflict(), "invalid addClause()!");
clause_.clear();
for (const Potassco::Lit_t* it = Potassco::begin(clause); it != Potassco::end(clause); ++it) {
clause_.push_back(decodeLit(*it));
}
ClauseRep rep = ClauseCreator::prepare(*solver_, clause_, Clasp::ClauseCreator::clause_force_simplify, Constraint_t::Other);
if (clause_.size() < 2) { clause_.resize(2, lit_false()); }
status_ = ClauseCreator::status(*solver_, rep);
uint32 impLevel = (status_ & ClauseCreator::status_asserting) != 0 ? solver_->level(clause_[1].var()) : UINT32_MAX;
if (!inProp_ || impLevel >= solver_->decisionLevel()) {
status_ = ClauseCreator::status_open;
return ClauseCreator::create(*solver_, rep, ccFlags_s);
}
return false;
}
void ClingoPropagator::toClause(Solver& s, const Potassco::LitSpan& clause, Potassco::Clause_t prop) {
POTASSCO_REQUIRE(todo_.empty(), "Assignment not propagated");
Literal max;
LitVec& mem = todo_.mem;
for (const Potassco::Lit_t* it = Potassco::begin(clause); it != Potassco::end(clause); ++it) {
Literal p = decodeLit(*it);
if (max < p) { max = p; }
mem.push_back(p);
}
if (aux_ < max) { aux_ = max; }
if ((Potassco::Clause_t::isVolatile(prop) || s.auxVar(max.var())) && !isSentinel(s.sharedContext()->stepLiteral())) {
mem.push_back(~s.sharedContext()->stepLiteral());
}
todo_.clause = ClauseCreator::prepare(s, mem, Clasp::ClauseCreator::clause_force_simplify, Constraint_t::Other);
todo_.flags = ccFlags_s[int(Potassco::Clause_t::isStatic(prop))];
if (mem.empty()) {
mem.push_back(lit_false());
}
}
void ModelEnumerator::BacktrackFinder::doCommitModel(Enumerator& ctx, Solver& s) {
ModelEnumerator& en = static_cast<ModelEnumerator&>(ctx);
uint32 dl = s.decisionLevel();
solution.assign(1, dl ? ~s.decision(dl) : lit_false());
if (en.projectionEnabled()) {
// Remember the current projected assignment as a nogood.
solution.clear();
for (Var i = 1, end = s.numProblemVars(); i <= end; ++i) {
if (s.varInfo(i).project()) {
solution.push_back(~s.trueLit(i));
}
}
// Remember initial decisions that are projection vars.
for (dl = s.backtrackLevel(); dl < s.decisionLevel(); ++dl) {
if (!s.varInfo(s.decision(dl+1).var()).project()) { break; }
}
s.setProjectLevel(dl);
}
else {
s.setBacktrackLevel(dl);
}
}
ClauseHead::ClauseHead(const ClauseInfo& init) : info_(init){
static_assert(sizeof(ClauseHead)<=32, "Unsupported Alignment");
head_[2] = lit_false();
}