propt::resultt qbf_bdd_coret::prop_solve()
{
{
std::string msg=
solver_text() + ": "+
i2string(no_variables())+" variables, "+
i2string(matrix->nodeCount())+" nodes";
messaget::status(msg);
}
model_bdds.resize(no_variables()+1, NULL);
// Eliminate variables
for(quantifierst::const_reverse_iterator it=quantifiers.rbegin();
it!=quantifiers.rend();
it++)
{
unsigned var=it->var_no;
if(it->type==quantifiert::EXISTENTIAL)
{
#if 0
std::cout << "BDD E: " << var << ", " <<
matrix->nodeCount() << " nodes" << std::endl;
#endif
BDD* model = new BDD();
const BDD &varbdd=*bdd_variable_map[var];
*model = matrix->AndAbstract(varbdd.Xnor(bdd_manager->bddOne()),
varbdd);
model_bdds[var]=model;
*matrix = matrix->ExistAbstract(*bdd_variable_map[var]);
}
else if(it->type==quantifiert::UNIVERSAL)
{
#if 0
std::cout << "BDD A: " << var << ", " <<
matrix->nodeCount() << " nodes" << std::endl;
#endif
*matrix = matrix->UnivAbstract(*bdd_variable_map[var]);
}
else
throw ("Unquantified variable");
}
if(*matrix==bdd_manager->bddOne())
{
compress_certificate();
return P_SATISFIABLE;
}
else if(*matrix==bdd_manager->bddZero())
{
model_bdds.clear();
return P_UNSATISFIABLE;
}
else
return P_ERROR;
}
tvt satcheck_booleforce_baset::l_get(literalt a) const
{
assert(status==SAT);
if(a.is_true())
return tvt(true);
else if(a.is_false())
return tvt(false);
tvt result;
unsigned v=a.var_no();
assert(v<no_variables());
int r=booleforce_deref(v);
if(r>0)
result=tvt(true);
else if(r<0)
result=tvt(false);
else
result=tvt(tvt::tv_enumt::TV_UNKNOWN);
if(a.sign())
result=!result;
return result;
}
propt::resultt satcheck_precosatt::prop_solve()
{
assert(status!=ERROR);
// We start counting at 1, thus there is one variable fewer.
{
std::string msg=
std::to_string(no_variables()-1)+" variables, "+
std::to_string(solver->getAddedOrigClauses())+" clauses";
messaget::status() << msg << messaget::eom;
}
std::string msg;
const int res=solver->solve();
if(res==1)
{
msg="SAT checker: instance is SATISFIABLE";
messaget::status() << msg << messaget::eom;
status=SAT;
return P_SATISFIABLE;
}
else
{
assert(res==-1);
msg="SAT checker: instance is UNSATISFIABLE";
messaget::status() << msg << messaget::eom;
}
status=UNSAT;
return P_UNSATISFIABLE;
}
propt::resultt qbf_squolem_coret::prop_solve()
{
{
std::string msg=
"Squolem: "+
i2string(no_variables())+" variables, "+
i2string(no_clauses())+" clauses";
messaget::status() << msg << messaget::eom;
}
squolem->endOfOriginals();
bool result = squolem->decide();
if(result)
{
messaget::status() << "Squolem: VALID" << messaget::eom;
return P_SATISFIABLE;
}
else
{
messaget::status() << "Squolem: INVALID" << messaget::eom;
return P_UNSATISFIABLE;
}
return P_ERROR;
}
propt::resultt satcheck_lingelingt::prop_solve()
{
assert(status!=ERROR);
// We start counting at 1, thus there is one variable fewer.
{
std::string msg=
std::to_string(no_variables()-1)+" variables, "+
std::to_string(clause_counter)+" clauses";
messaget::status() << msg << messaget::eom;
}
std::string msg;
forall_literals(it, assumptions)
lglassume(solver, it->dimacs());
const int res=lglsat(solver);
if(res==10)
{
msg="SAT checker: instance is SATISFIABLE";
messaget::status() << msg << messaget::eom;
status=SAT;
return P_SATISFIABLE;
}
else
{
assert(res==20);
msg="SAT checker: instance is UNSATISFIABLE";
messaget::status() << msg << messaget::eom;
}
status=UNSAT;
return P_UNSATISFIABLE;
}
satcheck_smvsatt::satcheck_smvsatt()
{
satsolver=
sat_instance_new_type(SATSOLVERCORE1, no_variables(), true);
// now we can do l_const
init_const();
}
void qdimacs_cnft::write_prefix(std::ostream &out) const
{
std::vector<bool> quantified;
quantified.resize(no_variables(), false);
for(quantifierst::const_iterator
it=quantifiers.begin();
it!=quantifiers.end();
it++)
{
const quantifiert &quantifier=*it;
assert(quantifier.var_no<no_variables());
// double quantification?
assert(!quantified[quantifier.var_no]);
quantified[quantifier.var_no]=true;
switch(quantifier.type)
{
case quantifiert::UNIVERSAL:
out << "a";
break;
case quantifiert::EXISTENTIAL:
out << "e";
break;
default:
assert(false);
}
out << " " << quantifier.var_no << " 0" << std::endl;
}
// variables that are not quantified
// will be quantified existentially in the innermost scope
for(std::size_t i=1; i<no_variables(); i++)
if(!quantified[i])
out << "e " << i << " 0" << std::endl;
}
void cnf_clause_list_assignmentt::copy_assignment_from(const propt &prop)
{
assignment.resize(no_variables());
// we don't use index 0, start with 1
for(unsigned v=1; v<assignment.size(); v++)
{
literalt l;
l.set(v, false);
assignment[v]=prop.l_get(l);
}
}
propt::resultt satcheck_minisat1_coret::prop_solve()
{
propt::resultt r;
r=satcheck_minisat1_prooft::prop_solve();
if(status==UNSAT)
{
in_core.resize(no_variables(), false);
minisat_proof->resolution_proof.build_core(in_core);
}
return r;
}
void dimacs_cnft::write_problem_line(std::ostream &out)
{
out << "p cnf " << no_variables() << " "
<< clauses.size() << std::endl;
}
propt::resultt satcheck_zcoret::prop_solve()
{
// We start counting at 1, thus there is one variable fewer.
{
std::string msg=
i2string(no_variables()-1)+" variables, "+
i2string(no_clauses())+" clauses";
messaget::status() << msg << messaget::eom;
}
// get the core
std::string cnf_file="cnf.dimacs";
std::string core_file="unsat_core.cnf";
std::string trace_file="resolve_trace";
std::string output_file="cnf.out";
{
std::ofstream out(cnf_file.c_str(), std::ios::out);
write_dimacs_cnf(out);
}
// generate resolve_trace
system(std::string("zchaff_verify "+cnf_file+" > "+output_file).c_str());
// get core
system(std::string("zcore "+cnf_file+" "+trace_file+" >> "+output_file).c_str());
in_core.clear();
// read result
{
std::ifstream in(core_file.c_str());
while(true)
{
std::string line;
if(!std::getline(in, line)) break;
if(!(line.substr(0,1)=="c" || line.substr(0,1)=="p"))
{
const char *p=line.c_str();
while(true)
{
int l=unsafe_str2int(p);
if(l==0) break;
if(l<0) l=-l;
in_core.insert(l);
// next one
const char *q=strchr(p, ' ');
while(*q==' ') q++;
if(q==NULL) break;
p=q;
}
}
}
}
if(in_core.empty())
return P_ERROR;
remove(cnf_file.c_str());
//remove(core_file.c_str());
remove(trace_file.c_str());
//remove(output_file.c_str());
return P_UNSATISFIABLE;
}
void satcheck_minisat1_baset::add_variables()
{
while((unsigned)solver->nVars()<no_variables())
solver->newVar();
}
propt::resultt qbf_qube_coret::prop_solve()
{
if(no_clauses()==0)
return resultt::P_SATISFIABLE;
{
messaget::status() << "QuBE: "
<< no_variables() << " variables, "
<< no_clauses() << " clauses" << eom;
}
std::string result_tmp_file="qube.out";
{
std::ofstream out(qbf_tmp_file.c_str());
// write it
break_lines=false;
write_qdimacs_cnf(out);
}
std::string options="";
// solve it
int res=system((
"QuBE "+options+" "+qbf_tmp_file+" > "+result_tmp_file).c_str());
assert(0==res);
bool result=false;
// read result
{
std::ifstream in(result_tmp_file.c_str());
bool result_found=false;
while(in)
{
std::string line;
std::getline(in, line);
if(line!="" && line[line.size()-1]=='\r')
line.resize(line.size()-1);
if(line[0]=='V')
{
mp_integer b(line.substr(2).c_str());
if(b<0)
assignment[integer2unsigned(b.negate())]=false;
else
assignment[integer2unsigned(b)]=true;
}
else if(line=="s cnf 1")
{
result=true;
result_found=true;
break;
}
else if(line=="s cnf 0")
{
result=false;
result_found=true;
break;
}
}
if(!result_found)
{
messaget::error() << "QuBE failed: unknown result" << eom;
return resultt::P_ERROR;
}
}
int remove_result=remove(result_tmp_file.c_str());
if(remove_result!=0)
{
messaget::error() << "Remove failed: " << std::strerror(errno) << eom;
return resultt::P_ERROR;
}
remove_result=remove(qbf_tmp_file.c_str());
if(remove_result!=0)
{
messaget::error() << "Remove failed: " << std::strerror(errno) << eom;
return resultt::P_ERROR;
}
if(result)
{
messaget::status() << "QuBE: TRUE" << eom;
return resultt::P_SATISFIABLE;
}
else
{
messaget::status() << "QuBE: FALSE" << eom;
return resultt::P_UNSATISFIABLE;
}
}
void dimacs_cnft::write_problem_line(std::ostream &out)
{
// We start counting at 1, thus there is one variable fewer.
out << "p cnf " << (no_variables()-1) << " "
<< clauses.size() << "\n";
}
propt::resultt qbf_qubet::prop_solve()
{
// sKizzo crashes on empty instances
if(no_clauses()==0)
return P_SATISFIABLE;
{
messaget::status() <<
"QuBE: " <<
no_variables() << " variables, " <<
no_clauses() << " clauses" << eom;
}
std::string qbf_tmp_file="qube.qdimacs";
std::string result_tmp_file="qube.out";
{
std::ofstream out(qbf_tmp_file.c_str());
// write it
write_qdimacs_cnf(out);
}
//std::string options=" --equivalences=0";
std::string options="";
// solve it
int res=system(("QuBE "+qbf_tmp_file+
options+
" > "+result_tmp_file).c_str());
assert(0 == res);
bool result=false;
// read result
{
std::ifstream in(result_tmp_file.c_str());
bool result_found=false;
while(in)
{
std::string line;
std::getline(in, line);
if(line!="" && line[line.size()-1]=='\r')
line.resize(line.size()-1);
if(line=="s cnf 0")
{
result=true;
result_found=true;
break;
}
else if(line=="s cnf 1")
{
result=false;
result_found=true;
break;
}
}
if(!result_found)
{
messaget::error() << "QuBE failed: unknown result" << eom;
return P_ERROR;
}
}
if(result)
{
messaget::status() << "QuBE: TRUE" << eom;
return P_SATISFIABLE;
}
else
{
messaget::status() << "QuBE: FALSE" << eom;
return P_UNSATISFIABLE;
}
return P_ERROR;
}
propt::resultt qbf_quantort::prop_solve()
{
{
std::string msg=
"Quantor: "+
i2string(no_variables())+" variables, "+
i2string(no_clauses())+" clauses";
messaget::status(msg);
}
std::string qbf_tmp_file="quantor.qdimacs";
std::string result_tmp_file="quantor.out";
{
std::ofstream out(qbf_tmp_file.c_str());
// write it
write_qdimacs_cnf(out);
}
//std::string options=" --equivalences=0";
std::string options="";
// solve it
system(("quantor "+qbf_tmp_file+
options+
" -o "+result_tmp_file).c_str());
bool result=false;
// read result
{
std::ifstream in(result_tmp_file.c_str());
bool result_found=false;
while(in)
{
std::string line;
str_getline(in, line);
if(line!="" && line[line.size()-1]=='\r')
line.resize(line.size()-1);
if(line=="s TRUE")
{
result=true;
result_found=true;
break;
}
else if(line=="s FALSE")
{
result=false;
result_found=true;
break;
}
}
if(!result_found)
{
messaget::error("Quantor failed: unknown result");
return P_ERROR;
}
}
if(result)
{
messaget::status("Quantor: TRUE");
return P_SATISFIABLE;
}
else
{
messaget::status("Quantor: FALSE");
return P_UNSATISFIABLE;
}
return P_ERROR;
}
propt::resultt qbf_skizzo_coret::prop_solve()
{
// sKizzo crashes on empty instances
if(no_clauses()==0)
return P_SATISFIABLE;
{
std::string msg=
"Skizzo: "+
i2string(no_variables())+" variables, "+
i2string(no_clauses())+" clauses";
messaget::status(msg);
}
std::string result_tmp_file="sKizzo.out";
{
std::ofstream out(qbf_tmp_file.c_str());
// write it
break_lines=false;
write_qdimacs_cnf(out);
}
std::string options="";
// solve it
system(("sKizzo -log "+qbf_tmp_file+
options+
" > "+result_tmp_file).c_str());
bool result=false;
// read result
{
std::ifstream in(result_tmp_file.c_str());
bool result_found=false;
while(in)
{
std::string line;
std::getline(in, line);
if(line!="" && line[line.size()-1]=='\r')
line.resize(line.size()-1);
if(line=="The instance evaluates to TRUE.")
{
result=true;
result_found=true;
break;
}
else if(line=="The instance evaluates to FALSE.")
{
result=false;
result_found=true;
break;
}
}
if(!result_found)
{
messaget::error("Skizzo failed: unknown result");
return P_ERROR;
}
}
remove(result_tmp_file.c_str());
remove(qbf_tmp_file.c_str());
if(result)
{
messaget::status("Skizzo: TRUE");
if(get_certificate())
return P_ERROR;
return P_SATISFIABLE;
}
else
{
messaget::status("Skizzo: FALSE");
return P_UNSATISFIABLE;
}
}
bool pbs_dimacs_cnft::pbs_solve()
{
//std::cout << "solve: No Lit. = " << no_variables () << std::endl;
std::string command;
if(!pbs_path.empty()) {
command += pbs_path;
if (command.substr(command.length(),1) != "/")
command += "/";
}
command += "pbs";
//std::cout << "PBS COMMAND IS: " << command << std::endl;
/*
if (!(getenv("PBS_PATH") == NULL))
{
command = getenv("PBS_PATH");
}
else
{
error ("Unable to read PBS_PATH environment variable.\n");
return false;
}
*/
command += " -f temp.cnf";
#if 1
if (optimize)
{
if (binary_search) {
command += " -S 1000 -D 1 -H -I -a";
}
else {
//std::cout << "NO BINARY SEARCH" << std::endl;
command += " -S 1000 -D 1 -I -a";
}
}
else
{
command += " -S 1000 -D 1 -a";
}
#else
command += " -z";
#endif
command += " -a > temp.out";
system(command.c_str());
std::ifstream file("temp.out");
std::string line;
int v;
bool satisfied = false;
if(file.fail())
{
error("Unable to read SAT results!\n");
return false;
}
opt_sum = -1;
while(file && !file.eof ())
{
str_getline(file,line);
if(strstr(line.c_str(),
"Variable Assignments Satisfying CNF Formula:")!=NULL)
{
//print ("Reading assignments...\n");
//std::cout << "No literals: " << no_variables() << std::endl;
satisfied = true;
assigned.clear ();
for (size_t i = 0; (file && (i < no_variables())); ++i)
{
file >> v;
if (v > 0)
{
//std::cout << v << " ";
assigned.insert(v);
}
}
//std::cout << std::endl;
//print ("Finished reading assignments.\n");
}
else if (strstr(line.c_str(),"SAT... SUM") != NULL)
