TEST(normal_interface, start)
{
SATSolver s;
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ( s.okay(), true);
}
SATSolver* STP::get_new_sat_solver()
{
SATSolver* newS = NULL;
switch (bm->UserFlags.solver_to_use)
{
case UserDefinedFlags::SIMPLIFYING_MINISAT_SOLVER:
newS = new SimplifyingMinisat;
break;
case UserDefinedFlags::CRYPTOMINISAT_SOLVER:
newS = new CryptoMinisat;
break;
case UserDefinedFlags::CRYPTOMINISAT4_SOLVER:
#ifdef USE_CRYPTOMINISAT4
newS = new CryptoMinisat4;
#else
std::cerr << "WARNING: Falling back to CryptoMiniSatv2 since v4 \
was not available at STP library compile time" << std::endl;
newS = new CryptoMinisat;
#endif
break;
case UserDefinedFlags::MINISAT_SOLVER:
newS = new MinisatCore;
if (bm->UserFlags.solver_verbosity > 1)
newS->setVerbosity(bm->UserFlags.solver_verbosity);
break;
default:
std::cerr << "ERROR: Undefined solver to use." << endl;
exit(-1);
break;
};
return newS;
}
void ToSATAIG::add_cnf_to_solver(SATSolver& satSolver, Cnf_Dat_t* cnfData)
{
bm->GetRunTimes()->start(RunTimes::SendingToSAT);
// Create a new sat variable for each of the variables in the CNF.
int satV = satSolver.nVars();
for (int i = 0; i < cnfData->nVars - satV; i++)
satSolver.newVar();
SATSolver::vec_literals satSolverClause;
for (int i = 0; i < cnfData->nClauses; i++)
{
satSolverClause.clear();
for (int* pLit = cnfData->pClauses[i], *pStop = cnfData->pClauses[i + 1];
pLit < pStop; pLit++)
{
uint32_t var = (*pLit) >> 1;
assert((var < satSolver.nVars()));
Minisat::Lit l = SATSolver::mkLit(var, (*pLit) & 1);
satSolverClause.push(l);
}
satSolver.addClause(satSolverClause);
if (!satSolver.okay())
break;
}
bm->GetRunTimes()->stop(RunTimes::SendingToSAT);
}
void ToSATAIG::mark_variables_as_frozen(SATSolver& satSolver)
{
for (ArrayTransformer::ArrType::iterator it =
arrayTransformer->arrayToIndexToRead.begin();
it != arrayTransformer->arrayToIndexToRead.end(); it++)
{
const ArrayTransformer::arrTypeMap& atm = it->second;
for (ArrayTransformer::arrTypeMap::const_iterator arr_it = atm.begin();
arr_it != atm.end(); arr_it++)
{
const ArrayTransformer::ArrayRead& ar = arr_it->second;
ASTNodeToSATVar::iterator it = nodeToSATVar.find(ar.index_symbol);
if (it != nodeToSATVar.end())
{
const vector<unsigned>& v = it->second;
for (size_t i = 0, size = v.size(); i < size; ++i)
satSolver.setFrozen(v[i]);
}
ASTNodeToSATVar::iterator it2 = nodeToSATVar.find(ar.symbol);
if (it2 != nodeToSATVar.end())
{
const vector<unsigned>& v = it2->second;
for (size_t i = 0, size = v.size(); i < size; ++i)
satSolver.setFrozen(v[i]);
}
}
}
}
void SIGINT_handler(int)
{
SATSolver* solver = solverToInterrupt;
cout << "c " << endl;
std::cerr << "*** INTERRUPTED ***" << endl;
if (!redDumpFname.empty() || !irredDumpFname.empty() || need_clean_exit) {
solver->interrupt_asap();
std::cerr
<< "*** Please wait. We need to interrupt cleanly" << endl
<< "*** This means we might need to finish some calculations"
<< endl;
} else {
if (solver->nVars() > 0) {
//if (conf.verbosity >= 1) {
solver->add_in_partial_solving_stats();
solver->print_stats();
//}
} else {
cout
<< "No clauses or variables were put into the solver, exiting without stats"
<< endl;
}
_exit(1);
}
}
TEST(error_throw, multithread_newvar)
{
SATSolver s;
s.new_vars(3);
EXPECT_THROW({
s.set_num_threads(3);}
, std::runtime_error);
TEST(normal_interface, onelit)
{
SATSolver s;
s.new_var();
s.add_clause(vector<Lit>{Lit(0, false)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ( s.okay(), true);
}
TEST(normal_interface, onelit)
{
SATSolver s;
s.new_var();
s.add_clause(str_to_cl("1"));
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ( s.okay(), true);
}
TEST(xor_interface, xor_check_solution_values3)
{
SATSolver s;
s.new_var();
s.new_var();
s.add_xor_clause(vector<uint32_t>{0U, 0U}, true);
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
}
TEST(stp_test, no_simp_at_startup)
{
SATSolver s;
s.set_no_simplify();
add_clauses_for_simp_check(s);
s.solve();
auto eq_xors = s.get_all_binary_xors();
EXPECT_EQ(eq_xors.size(), 0U);
}
void signalHandler(int signum) {
std::cerr << "*** INTERRUPTED ***\n";
SATSolver* solver = solverToInterrupt;
solver->interrupt_asap();
solver->add_in_partial_solving_stats();
solver->print_stats();
_exit(1);
}
bool ToSATAIG::runSolver(SATSolver& satSolver)
{
bm->GetRunTimes()->start(RunTimes::Solving);
satSolver.solve(bm->soft_timeout_expired);
bm->GetRunTimes()->stop(RunTimes::Solving);
if (bm->UserFlags.stats_flag)
satSolver.printStats();
return satSolver.okay();
}
TEST(xor_interface, unit)
{
SATSolver s;
s.new_vars(3);
s.add_clause(vector<Lit>{Lit(0, false)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
vector<Lit> units = s.get_zero_assigned_lits();
EXPECT_EQ( units.size(), 1u);
EXPECT_EQ( units[0], Lit(0, false));
}
int main(int argc, const char* argv[]) {
if (argc < 2) {
std::cout << "Run: incremental-cryptominisat <varNumber> <timeLimit in seconds>" << std::endl;
return 1;
}
int var_number = atoi(argv[1]);
int time_limit = atoi(argv[2]);
SolverConf conf;
conf.maxTime = time_limit;
SATSolver solver (conf, NULL);
solver.new_vars(var_number);
while (true) {
std::string line;
std::getline(std::cin, line);
if (line == "solve") {
lbool res = solver.solve();
if (res == l_True) {
std::cout << "SAT" << std::endl;
std::vector<lbool> model = solver.get_model();
std::cout << "v ";
for (int i = 0; i < model.size(); i++) {
std::cout << (model[i] == l_True ? "" : "-") << (i + 1) << " ";
}
std::cout << std::endl;
} else if (res == l_False) {
std::cout << "UNSAT" << std::endl;
} else {
std::cout << "UNKNOWN" << std::endl;
}
} else if (line == "halt") {
break;
} else {
std::vector<Lit> lits;
std::istringstream iss(line);
do {
std::string sub;
iss >> sub;
int literal = atoi(sub.c_str());
if (literal == 0) {
break;
}
lits.push_back(Lit(abs(literal) - 1, literal < 0));
} while (iss);
solver.add_clause(lits);
}
}
return 0;
}
TEST(normal_interface, logfile2)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(vector<Lit>{Lit(0, false)});
s->add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
lbool ret = s->solve();
s->add_clause(vector<Lit>{Lit(1, false)});
ret = s->solve();
delete s;
std::ifstream infile("testfile");
std::string line;
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::new_vars( 2 )");
std::getline(infile, line);
EXPECT_EQ(line, "1 0");
std::getline(infile, line);
EXPECT_EQ(line, "1 2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( )");
std::getline(infile, line);
EXPECT_EQ(line, "2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( )");
}
TEST(normal_interface, logfile2_assumps)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(vector<Lit>{Lit(0, false)});
s->add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
std::vector<Lit> assumps {Lit(0, false), Lit(1, true)};
lbool ret = s->solve(&assumps);
s->add_clause(vector<Lit>{Lit(1, false)});
assumps.clear();
assumps.push_back(Lit(1, true));
ret = s->solve(&assumps);
delete s;
std::ifstream infile("testfile");
std::string line;
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::new_vars( 2 )");
std::getline(infile, line);
EXPECT_EQ(line, "1 0");
std::getline(infile, line);
EXPECT_EQ(line, "1 2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( 1 -2 )");
std::getline(infile, line);
EXPECT_EQ(line, "2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( -2 )");
}
void add_clauses_for_simp_check(SATSolver& s)
{
s.new_vars(4);
// 1 = 2
s.add_clause(str_to_cl("1, -2"));
s.add_clause(str_to_cl("-1, 2"));
// 3 = 4
s.add_clause(str_to_cl("3, -4"));
s.add_clause(str_to_cl("-3, 4"));
//no elimination
s.add_clause(str_to_cl("3, 2"));
s.add_clause(str_to_cl("4, 1"));
}
TEST(xor_interface, abort_early)
{
SATSolver s;
s.set_no_simplify();
s.set_no_equivalent_lit_replacement();
s.set_num_threads(2);
s.set_max_confl(0);
s.new_vars(2);
s.add_clause(str_to_cl("1, 2"));
s.add_clause(str_to_cl("1, -2"));
s.add_clause(str_to_cl("-1, 2"));
s.add_clause(str_to_cl("-1, -2"));
lbool ret = s.solve();
EXPECT_EQ( ret, l_Undef);
}
TEST(xor_interface, abort_early)
{
SATSolver s;
s.set_no_simplify();
s.set_no_equivalent_lit_replacement();
s.set_num_threads(2);
s.set_max_confl(0);
s.new_vars(2);
s.add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
s.add_clause(vector<Lit>{Lit(0, false), Lit(1, true)});
s.add_clause(vector<Lit>{Lit(0, true), Lit(1, false)});
s.add_clause(vector<Lit>{Lit(0, true), Lit(1, true)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_Undef);
}
extern "C" int LLVMFuzzerTestOneInput(const unsigned char *data, size_t size) {
SATSolver S;
S.set_verbosity(0);
//solver->set_num_threads(num_threads);
DimacsParser<StreamBuffer<MyText, fread_op_text, text_read> > parser(&S, "", 0);
parser.max_var = 1000;
MyText t;
t.at = 0;
t.size = size;
t.txt = data;
if (!parser.parse_DIMACS(t)) {
return 0;
}
S.solve();
//cout << "Ret is sat: " << (ret == l_True) << endl;
return 0;
}
TEST(normal_interface, logfile)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(str_to_cl("1, 2"));
lbool ret = s->solve();
EXPECT_EQ( ret, l_True);
delete s;
std::ifstream infile("testfile");
std::string line;
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::new_vars( 2 )");
std::getline(infile, line);
EXPECT_EQ(line, "1 2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( )");
}
void
applyAxiomToSAT(SATSolver & SatSolver, AxiomToBe& toBe, ToSATBase::ASTNodeToSATVar & satVar)
{
Minisat::Var a = getEquals(SatSolver, toBe.index0, toBe.index1, satVar, LEFT_ONLY);
Minisat::Var b = getEquals(SatSolver, toBe.value0, toBe.value1, satVar, RIGHT_ONLY);
SATSolver::vec_literals satSolverClause;
satSolverClause.push(SATSolver::mkLit(a, true));
satSolverClause.push(SATSolver::mkLit(b, false));
SatSolver.addClause(satSolverClause);
}
TEST(xor_interface, xor_check_unsat_multi_thread)
{
SATSolver s;
s.set_num_threads(3);
s.new_vars(3);
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, true);
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.okay(), false);
EXPECT_EQ( s.nVars(), 3u);
}
TEST(xor_interface, xor_4_long2)
{
SATSolver s;
s.new_var();
s.new_var();
s.new_var();
s.new_var();
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U, 3U}, true);
s.add_xor_clause(vector<uint32_t>{0U}, false);
s.add_xor_clause(vector<uint32_t>{1U}, false);
s.add_xor_clause(vector<uint32_t>{2U}, true);
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ(s.get_model()[0], l_False);
EXPECT_EQ(s.get_model()[1], l_False);
EXPECT_EQ(s.get_model()[2], l_True);
EXPECT_EQ(s.get_model()[3], l_False);
EXPECT_EQ( s.nVars(), 4u);
}
TEST(normal_interface, multi_solve_unsat_multi_thread)
{
SATSolver s;
s.set_num_threads(2);
s.new_var();
s.add_clause(str_to_cl("1"));
s.add_clause(str_to_cl("-1"));
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.okay(), false);
for(size_t i = 0;i < 10; i++) {
ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.okay(), false);
}
}
TEST(normal_interface, multi_solve_unsat_multi_thread)
{
SATSolver s;
s.set_num_threads(2);
s.new_var();
s.add_clause(vector<Lit>{Lit(0, false)});
s.add_clause(vector<Lit>{Lit(0, true)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.okay(), false);
for(size_t i = 0;i < 10; i++) {
ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.okay(), false);
}
}
TEST(xor_interface, xor_3_long)
{
SATSolver s;
s.new_var();
s.new_var();
s.new_var();
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, true);
s.add_xor_clause(vector<uint32_t>{0}, true);
s.add_xor_clause(vector<uint32_t>{1}, true);
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ(s.get_model()[0], l_True);
EXPECT_EQ(s.get_model()[1], l_True);
EXPECT_EQ(s.get_model()[2], l_True);
EXPECT_EQ( s.nVars(), 3u);
}
TEST(stp_test, set_num_threads_false)
{
SATSolver s;
s.set_no_simplify_at_startup();
s.set_num_threads(5);
s.new_vars(2);
s.add_clause(str_to_cl("1,2"));
s.add_clause(str_to_cl("1,-2"));
s.add_clause(str_to_cl("-1,2"));
s.add_clause(str_to_cl("-1,-2"));
lbool ret = s.solve();
EXPECT_EQ(ret, l_False);
}
void getSatVariables(const ASTNode& a, vector<unsigned>& v_a,
SATSolver& SatSolver, ToSATBase::ASTNodeToSATVar& satVar)
{
ToSATBase::ASTNodeToSATVar::iterator it = satVar.find(a);
if (it != satVar.end())
v_a = it->second;
else if (!a.isConstant())
{
assert(a.GetKind() == SYMBOL);
// It was ommitted from the initial problem, so assign it freshly.
for (unsigned i = 0; i < a.GetValueWidth(); i++)
{
uint32_t v = SatSolver.newVar();
// We probably don't want the variable eliminated.
SatSolver.setFrozen(v);
v_a.push_back(v);
}
satVar.insert(make_pair(a, v_a));
}
}
TEST(normal_interface, max_time)
{
SATSolver* s = new SATSolver();
s->new_vars(200);
s->add_clause(str_to_cl("1"));
s->add_clause(str_to_cl("1, 2"));
s->set_max_time(3);
lbool ret = s->solve();
s->add_clause(vector<Lit>{Lit(1, false)});
ret = s->solve();
delete s;
EXPECT_EQ(ret, l_True);
}
