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, unit2)
{
SATSolver s;
s.new_vars(3);
s.add_clause(str_to_cl("1"));
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));
s.add_clause(vector<Lit>{Lit(1, true)});
ret = s.solve();
EXPECT_EQ( ret, l_True);
units = s.get_zero_assigned_lits();
EXPECT_EQ( units.size(), 2u);
EXPECT_EQ( units[0], Lit(0, false));
EXPECT_EQ( units[1], Lit(1, true));
}
TEST(stp_test, default_polar_false)
{
SATSolver s;
s.set_no_simplify_at_startup();
s.set_default_polarity(false);
s.new_vars(4);
s.add_clause(str_to_cl("-1, -2, -3, -4"));
lbool ret = s.solve();
EXPECT_EQ(ret, l_True);
for(size_t i = 0; i < 4; i++) {
EXPECT_EQ(s.get_model()[0], l_False);
}
}
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);
}
TEST(xor_interface, xor_norm_mix_unsat_multi_thread)
{
SATSolver s;
//s.set_num_threads(3);
s.new_vars(3);
s.add_clause(vector<Lit>{Lit(0, false)});
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
s.add_clause(vector<Lit>{Lit(1, false)});
s.add_clause(vector<Lit>{Lit(2, false)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.nVars(), 3u);
}
TEST(xor_interface, xor_check_solution_values6)
{
SATSolver s;
s.new_var();
s.new_var();
s.add_xor_clause(vector<uint32_t>{0U, 1U}, false);
vector<Lit> assump = {Lit(0, true)};
lbool ret = s.solve(&assump);
EXPECT_EQ( ret, l_True);
EXPECT_EQ(s.get_model()[0], l_False);
EXPECT_EQ(s.get_model()[1], l_False);
EXPECT_EQ( s.nVars(), 2u);
}
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;
}
int main()
{
SATSolver solver;
vector<Lit> clause;
//We need 3 variables
solver.new_var();
solver.new_var();
solver.new_var();
//adds "1 0"
clause.push_back(Lit(0, false));
solver.add_clause(clause);
//adds "-1 2 3 0"
clause.clear();
clause.push_back(Lit(0, true));
clause.push_back(Lit(1, false));
clause.push_back(Lit(2, false));
solver.add_clause(clause);
lbool ret = l_True;
while(ret == l_True) {
ret = solver.solve();
if (ret == l_True) {
std::cout
<< "Solution is: "
<< solver.get_model()[0]
<< ", " << solver.get_model()[1]
<< ", " << solver.get_model()[2]
<< std::endl;
clause.clear();
for(size_t i = 0; i < 3; i++) {
if (solver.get_model()[i] != l_Undef) {
clause.push_back(Lit(i, solver.get_model()[i] == l_True));
}
}
solver.add_clause(clause);
} else if (ret == l_False) {
std::cout << "No more solutions." << std::endl;
} else {
std::cout << "Solver returned that it didn't finish running."
"maybe you put a limit on its runtime?" << std::endl;
}
}
return 0;
}
TEST(xor_interface, xor_3_long2)
{
SATSolver s;
s.new_var();
s.new_var();
s.new_var();
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
s.add_xor_clause(vector<uint32_t>{0U}, true);
s.add_xor_clause(vector<uint32_t>{1U}, 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_False);
EXPECT_EQ( s.nVars(), 3u);
}
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(xor_interface, xor_very_long)
{
SATSolver s;
vector<uint32_t> vars;
for(unsigned i = 0; i < 30; i++) {
s.new_var();
vars.push_back(i);
}
s.add_xor_clause(vars, false);
for(unsigned i = 0; i < 29; i++) {
s.add_xor_clause(vector<uint32_t>{i}, false);
}
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
for(unsigned i = 0; i < 30; i++) {
EXPECT_EQ(s.get_model()[i], l_False);
}
EXPECT_EQ( s.nVars(), 30u);
}
TEST(normal_interface, logfile)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
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( )");
}
int main()
{
SATSolver solver;
vector<Lit> clause;
//We need 3 variables
solver.new_var();
solver.new_var();
solver.new_var();
//adds "1 0"
clause.push_back(Lit(0, false));
solver.add_clause(clause);
//adds "-2 0"
clause.clear();
clause.push_back(Lit(1, true));
solver.add_clause(clause);
//adds "-1 2 3 0"
clause.clear();
clause.push_back(Lit(0, true));
clause.push_back(Lit(1, false));
clause.push_back(Lit(2, false));
solver.add_clause(clause);
lbool ret = solver.solve();
assert(ret == l_True);
assert(solver.get_model()[0] == l_True);
assert(solver.get_model()[1] == l_False);
assert(solver.get_model()[2] == l_True);
std::cout
<< "Solution is: "
<< solver.get_model()[0]
<< ", " << solver.get_model()[1]
<< ", " << solver.get_model()[2]
<< std::endl;
return 0;
}
TEST(xor_interface, xor_very_long2)
{
for(size_t num = 3; num < 30; num++) {
SATSolver s;
vector<uint32_t> vars;
for(unsigned i = 0; i < num; i++) {
s.new_var();
vars.push_back(i);
}
s.add_xor_clause(vars, true);
for(unsigned i = 0; i < num-1; i++) {
s.add_xor_clause(vector<uint32_t>{i}, false);
}
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
for(unsigned i = 0; i < num-1; i++) {
EXPECT_EQ(s.get_model()[i], l_False);
}
EXPECT_EQ(s.get_model()[num-1], l_True);
EXPECT_EQ( s.nVars(), num);
}
}
int main() {
signal(SIGINT, signalHandler);
// https://blockexplorer.com/block/000000000000003e3d9fc1d3ffb3a502302797beb27c28a3fbb7000003efd472
uint32_t input_1[32] = {
// version, prev block
0x01000000, 0x660675bc, 0xaf38efda, 0xc1d8d4f1, 0xac71425e, 0x7ee406b7, 0x55524edb, 0xe3040000,
// , merkle
0x00000000, 0x6b7e2727, 0x1fc5ae0a, 0xb735c5d1, 0x56bdfaf1, 0xee344164, 0xf4a9107d, 0x6cf0411c,
// , time , bits , nonce , padding
0xfd6fd7ea, 2004092497, 0xb1a6051a, 0xf103fe2a, 0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000280
};
uint32_t input_2[16] = {
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,
0x80000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000100
};
uint32_t state_2[8] = {0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19};
sha256_calc(input_2, input_1);
// sha256_calc(input_2, input_1 + 16);
// sha256_calc(state_2, input_2);
for (unsigned i = 0; i < 8; i++) {
printf("%08x ", state_2[i]);
}
printf("\n");
long numCPU = sysconf( _SC_NPROCESSORS_ONLN );
cout << "CPUNUM: " << numCPU << "\n";
SATSolver solver;
solver.set_verbosity(0);
solver.set_num_threads(numCPU);
// solver.log_to_file("solver.txt");
time_t rawtime;
time(&rawtime);
char filename[64];
strftime(filename, 64, "sha256_7 %Y-%m-%d %H:%M:%S", localtime(&rawtime));
solver.add_sql_tag("filename", filename);
solverToInterrupt = &solver;
SolverPrinter printer(&solver);
// Eingabe
for (unsigned i = 0; i < 16; i++) {
if (i == 3) continue; // nonce
Const c(32, input_1[i + 16]);
c.setStart(i * 32);
c.create(&printer);
}
for (unsigned i = 0; i < 16; i++) {
Const c(32, input_2[i]);
c.setStart(512 + i * 32);
c.create(&printer);
}
for (unsigned i = 0; i < 8; i++) {
Const c(32, state_2[i]);
c.setStart(1024 + i * 32);
c.create(&printer);
}
cout << " 1 / 3: Eingabe gesetzt.\n";
Sha256 sha256_1;
sha256_1.setStart(1280);
sha256_1.create(&printer);
cout << " 2 / 3: Kern 1/2 definiert.\n";
vector<unsigned> subinputs;
for (unsigned i = 0; i < 8; i++) subinputs.push_back(sha256_1.getOutput() + i * 32);
for (unsigned i = 0; i < 16; i++) subinputs.push_back(768 + i * 32);
Sha256 sha256_2;
sha256_2.setInputs(subinputs);
sha256_2.setStart(sha256_1.getOutput() + 256);
sha256_2.create(&printer);
cout << " 3 / 3: Kern 2/2 definiert.\n";
vector<Lit> assumptions;
AssumptionPrinter ap(&assumptions);
// Ausgabe setzen
for (unsigned i = 0; i < 8; i++) {
Const c(32, 0);
c.setStart(sha256_2.getOutput() + (7 - i) * 32);
c.create(&ap);
}
time_t start_time = time(0);
for (unsigned r = 1; r <= assumptions.size(); r++) {
cout << setw(3) << r << " / " << assumptions.size() << ":" << flush;
vector<Lit> as(assumptions.begin(), assumptions.begin() + r);
lbool ret = solver.solve(&as);
if (ret == l_False) {
cout << "Nicht lösbar.\n";
return 0;
}
printf(" Lösung gefunden zum Zeitpunkt ");
printTime(cout, time(0) - start_time);
printf(" mit Nonce: %08lx\n Ausgabe:", solver_readInt(solver, 96, 32));
for (unsigned i = 0; i < 8; i++) {
printf(" %08lx", solver_readInt(solver, sha256_2.getOutput() + i * 32, 32));
}
printf("\n");
}
solver.print_stats();
return 0;
}
