23 #include <minisat/core/Solver.h>
24 #include <minisat/simp/SimpSolver.h>
27 #error "Expected HAVE_MINISAT2"
30 void convert(
const bvt &bv, Minisat::vec<Minisat::Lit> &dest)
33 bv.size() <=
static_cast<std::size_t
>(std::numeric_limits<int>::max()));
34 dest.capacity(
static_cast<int>(bv.size()));
36 for(
const auto &literal : bv)
38 if(!literal.is_false())
39 dest.push(Minisat::mkLit(literal.var_no(), literal.sign()));
81 catch(Minisat::OutOfMemoryException)
83 log.error() <<
"SAT checker ran out of memory" <<
messaget::eom;
84 status = statust::ERROR;
85 throw std::bad_alloc();
103 return "MiniSAT 2.2.1 without simplifier";
108 return "MiniSAT 2.2.1 with simplifier";
114 while((
unsigned)
solver->nVars()<no_variables())
125 for(
const auto &literal : bv)
127 if(literal.is_true())
129 else if(!literal.is_false())
132 literal.var_no() < (
unsigned)
solver->nVars(),
133 "variable not added yet");
137 Minisat::vec<Minisat::Lit> c;
153 static size_t cnf_clause_index = 0;
155 bool clause_removed = process_clause(bv, cnf);
165 catch(
const Minisat::OutOfMemoryException &)
167 log.error() <<
"SAT checker ran out of memory" <<
messaget::eom;
168 status = statust::ERROR;
169 throw std::bad_alloc();
185 template <
typename T>
190 log.statistics() << (no_variables() - 1) <<
" variables, "
199 log.status() <<
"SAT checker inconsistent: instance is UNSATISFIABLE"
201 status = statust::UNSAT;
202 return resultt::P_UNSATISFIABLE;
206 for(
const auto &assumption : assumptions)
208 if(assumption.is_false())
210 log.status() <<
"got FALSE as assumption: instance is UNSATISFIABLE"
212 status = statust::UNSAT;
213 return resultt::P_UNSATISFIABLE;
217 Minisat::vec<Minisat::Lit> solver_assumptions;
218 convert(assumptions, solver_assumptions);
220 using Minisat::lbool;
224 void (*old_handler)(int) = SIG_ERR;
226 if(time_limit_seconds != 0)
230 if(old_handler == SIG_ERR)
231 log.warning() <<
"Failed to set solver time limit" <<
messaget::eom;
233 alarm(time_limit_seconds);
236 lbool solver_result =
solver->solveLimited(solver_assumptions);
238 if(old_handler != SIG_ERR)
241 signal(SIGALRM, old_handler);
247 if(time_limit_seconds != 0)
249 log.warning() <<
"Time limit ignored (not supported on Win32 yet)"
253 lbool solver_result =
solver->solve(solver_assumptions) ? l_True : l_False;
257 if(solver_result == l_True)
259 log.status() <<
"SAT checker: instance is SATISFIABLE" <<
messaget::eom;
261 status = statust::SAT;
262 return resultt::P_SATISFIABLE;
265 if(solver_result == l_False)
267 log.status() <<
"SAT checker: instance is UNSATISFIABLE" <<
messaget::eom;
268 status = statust::UNSAT;
269 return resultt::P_UNSATISFIABLE;
272 log.status() <<
"SAT checker: timed out or other error" <<
messaget::eom;
273 status = statust::ERROR;
274 return resultt::P_ERROR;
276 catch(
const Minisat::OutOfMemoryException &)
278 log.error() <<
"SAT checker ran out of memory" <<
messaget::eom;
279 status=statust::ERROR;
280 return resultt::P_ERROR;
292 bool sign = a.
sign();
295 solver->model.growTo(v + 1);
297 solver->model[v] = Minisat::lbool(value);
299 catch(
const Minisat::OutOfMemoryException &)
301 log.error() <<
"SAT checker ran out of memory" <<
messaget::eom;
302 status = statust::ERROR;
303 throw std::bad_alloc();
307 template <
typename T>
332 for(
int i=0; i<
solver->conflict.size(); i++)
333 if(var(
solver->conflict[i])==v)
345 for(
const auto &assumption : bv)
347 if(!assumption.is_true())
349 assumptions.push_back(assumption);
380 catch(
const Minisat::OutOfMemoryException &)
384 throw std::bad_alloc();
bool is_in_conflict(literalt a) const override
Returns true if an assumption is in the final conflict.
satcheck_minisat2_baset(T *, message_handlert &message_handler)
void set_polarity(literalt a, bool value)
void lcnf(const bvt &bv) override final
tvt l_get(literalt a) const override final
resultt do_prop_solve() override
void set_assignment(literalt a, bool value) override
virtual ~satcheck_minisat2_baset()
void set_assumptions(const bvt &_assumptions) override
satcheck_minisat_no_simplifiert(message_handlert &message_handler)
const std::string solver_text() override
satcheck_minisat_simplifiert(message_handlert &message_handler)
void set_frozen(literalt a) override final
bool is_eliminated(literalt a) const
const std::string solver_text() override final
void with_solver_hardness(T &maybe_hardness_collector, hardness_collectort::handlert handler)
std::vector< literalt > bvt
static Minisat::Solver * solver_to_interrupt
static void interrupt_solver(int signum)
void convert(const bvt &bv, Minisat::vec< Minisat::Lit > &dest)
int solver(std::istream &in)
#define CHECK_RETURN(CONDITION)
#define PRECONDITION(CONDITION)
#define INVARIANT(CONDITION, REASON)
This macro uses the wrapper function 'invariant_violated_string'.
A structure that facilitates collecting the complexity statistics from a decision procedure.
void register_clause(const bvt &bv, const bvt &cnf, const size_t cnf_clause_index, bool register_cnf)
Called e.g.