/*_________________________________________________________________________________________________
|
| search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&) -> [lbool]
|
| Description:
| Search for a model the specified number of conflicts, keeping the number of learnt clauses
| below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to
| indicate infinity.
|
| Output:
| 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
| all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
| if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
|________________________________________________________________________________________________@*/
lbool Solver::search(int nof_conflicts, int nof_learnts)
{
assert(ok);
int backtrack_level;
int conflictC = 0;
vec<Lit> learnt_clause;
starts++;
for (;;){
#ifdef _DEBUGSEARCH
for(int k=0; k<decisionLevel(); ++k)
std::cout << " ";
std::cout << "propagate" << std::endl;
#endif
Clause* confl = propagate();
if (confl != NULL){
// CONFLICT
conflicts++; conflictC++;
if (decisionLevel() <= init_level) {
#ifdef _DEBUGSEARCH
std::cout << "infeasible" << std::endl;
#endif
return l_False;
}
learnt_clause.clear();
analyze(confl, learnt_clause, backtrack_level);
cancelUntil(backtrack_level);
#ifdef _DEBUGSEARCH
for(int k=0; k<decisionLevel(); ++k)
std::cout << " ";
std::cout << "backtrack to " << decisionLevel() << std::endl;
#endif
assert(value(learnt_clause[0]) == l_Undef);
if (learnt_clause.size() == 1){
uncheckedEnqueue(learnt_clause[0]);
#ifdef _DEBUGSEARCH
for(int k=0; k<decisionLevel(); ++k)
std::cout << " ";
std::cout << "deduce " ;
printLit(learnt_clause[0]);
std::cout << std::endl;
#endif
}else{
Clause* c = Clause_new(learnt_clause, true);
#ifdef _DEBUGSEARCH
for(int k=0; k<decisionLevel(); ++k)
std::cout << " ";
std::cout << "deduce ";
printClause(*c);
std::cout << std::endl;
#endif
learnts.push(c);
attachClause(*c);
claBumpActivity(*c);
uncheckedEnqueue(learnt_clause[0], c);
}
varDecayActivity();
claDecayActivity();
}else{
// NO CONFLICT
if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
// Reached bound on number of conflicts:
progress_estimate = progressEstimate();
cancelUntil(0);
return l_Undef; }
// Simplify the set of problem clauses:
if (decisionLevel() == 0 && !simplify())
return l_False;
if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts)
// Reduce the set of learnt clauses:
reduceDB();
Lit next = lit_Undef;
while (decisionLevel() < assumptions.size()){
// Perform user provided assumption:
Lit p = assumptions[decisionLevel()];
if (value(p) == l_True){
// Dummy decision level:
newDecisionLevel();
}else if (value(p) == l_False){
analyzeFinal(~p, conflict);
return l_False;
}else{
next = p;
break;
}
}
if (next == lit_Undef){
// New variable decision:
decisions++;
next = pickBranchLit(polarity_mode, random_var_freq);
if (next == lit_Undef)
// Model found:
return l_True;
}
#ifdef _DEBUGSEARCH
for(int k=0; k<decisionLevel(); ++k)
std::cout << " ";
std::cout << "branch on " ;
printLit(next);
std::cout << std::endl;
#endif
// Increase decision level and enqueue 'next'
assert(value(next) == l_Undef);
newDecisionLevel();
uncheckedEnqueue(next);
}
}
}
lbool Solver::search(int nof_conflicts, int nof_learnts)
{
assert(ok);
int backtrack_level;
int conflictsC = 0;
vec<Lit> learnt_clause;
int nblevels=0,nbCC=0,merged=0;
starts++;
bool first = true;
for (;;){
Clause* confl = propagate();
//Conflict at a later stage.
if (backup.running
&& confl != NULL
&& backup.stage == 1
) {
#ifdef RESTORE_FULL
printf("Somebody else (maybe bin clause) did the conflict -- stage is one, going 2\n");
#endif
fullCancelUntil(backup.level, backup.sublevel);
backup.stage = 2;
continue;
}
if (confl != NULL){
assert(backup.stage == 0);
// CONFLICT
conflicts++; conflictsC++;cons++;nbCC++;
if (decisionLevel() == 0) return l_False;
first = false;
learnt_clause.clear();
analyze(confl, learnt_clause, backtrack_level,nblevels,merged);
conf4Stats++;
nbDecisionLevelHistory.push(nblevels);
totalSumOfDecisionLevel += nblevels;
cancelUntil(backtrack_level);
assert(value(learnt_clause[0]) == l_Undef);
if (learnt_clause.size() == 1){
assert(decisionLevel() == 0);
uncheckedEnqueue(learnt_clause[0]);
nbUn++;
}else{
Clause* c = Clause_new(learnt_clause, clIndex++, conflicts, true);
dumpFile << "INSERT INTO clausedata(runID, idx, timeofcreation, size) VALUES("
<< runID << ","
<< c->getIndex() << ","
<< c->getTimeOfCreation() << ","
<< c->size()
<< ");" << std::endl;
learnts.push(c);
c->setActivity(nblevels); // LS
if(nblevels<=2) nbDL2++;
if(c->size()==2) nbBin++;
attachClause(*c);
uncheckedEnqueue(learnt_clause[0], c);
if (backup.running
&& backup.stage == 0
) {
saveState();
#ifdef RESTORE
printf("Saving state after conflict at dec level: %d, sublevel: %d\n", decisionLevel(), trail.size());
#endif
}
}
varDecayActivity();
}else{
if (backup.stage == 0
&& nbDecisionLevelHistory.isvalid()
&& ((nbDecisionLevelHistory.getavg()*0.7) > (totalSumOfDecisionLevel / conf4Stats))
) {
nbDecisionLevelHistory.fastclear();
progress_estimate = progressEstimate();
cancelUntil(0);
return l_Undef;
}
// Simplify the set of problem clauses:
if (backup.stage == 0
&& decisionLevel() == 0 && !simplify()
) {
return l_False;
}
Lit next = lit_Undef;
if (backup.stage == 0
&& ((cons-curRestart * nbclausesbeforereduce) >=0)
) {
curRestart = (conflicts/ nbclausesbeforereduce)+1;
reduceDB();
nbclausesbeforereduce += 500;
}
if (next == lit_Undef){
// New variable decision:
decisions++;
next = pickBranchLit(polarity_mode, random_var_freq);
if (next == lit_Undef)
// Model found:
return l_True;
}
// Increase decision level and enqueue 'next'
assert(value(next) == l_Undef);
newDecisionLevel();
uncheckedEnqueue(next);
if (backup.running
&& backup.stage == 0
) {
saveState();
#ifdef RESTORE
printf("Saving state after pickbranch at dec level: %d, sublevel: %d\n", decisionLevel(), trail.size());
printf("sublevel: %d, level: %d, qhead:%d\n", trail.size(), decisionLevel(), qhead);
#endif
}
}
}
}
/*_________________________________________________________________________________________________
|
| search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&) -> [lbool]
|
| Description:
| Search for a model the specified number of conflicts, keeping the number of learnt clauses
| below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to
| indicate infinity.
|
| Output:
| 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
| all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
| if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
|________________________________________________________________________________________________@*/
lbool MiniSATP::search(int nof_conflicts, int nof_learnts)
{
assert(ok);
int backtrack_level;
int conflictC = 0;
vec<Lit> learnt_clause;
starts++;
bool first = true;
for (;;){
Clause* confl = propagate();
if (confl != NULL){
// CONFLICT
conflicts++; conflictC++;
if (decisionLevel() == 0)
{
// Added Lines
fillExplanation(confl);
return l_False;
}
first = false;
learnt_clause.clear();
analyze(confl, learnt_clause, backtrack_level);
cancelUntil(backtrack_level);
assert(value(learnt_clause[0]) == l_Undef);
if (learnt_clause.size() == 1){
uncheckedEnqueue(learnt_clause[0]);
}else{
Clause* c = Clause_new(learnt_clause, true);
learnts.push(c);
attachClause(*c);
claBumpActivity(*c);
uncheckedEnqueue(learnt_clause[0], c);
}
varDecayActivity();
claDecayActivity();
}else{
// NO CONFLICT
if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
// Reached bound on number of conflicts:
progress_estimate = progressEstimate();
cancelUntil(0);
return l_Undef; }
// Simplify the set of problem clauses:
if (decisionLevel() == 0 && !simplify())
{
return l_False;
}
if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts)
// Reduce the set of learnt clauses:
reduceDB();
Lit next = lit_Undef;
while (decisionLevel() < assumptions.size()){
// Perform user provided assumption:
Lit p = assumptions[decisionLevel()];
if (value(p) == l_True){
// Dummy decision level:
newDecisionLevel();
}else if (value(p) == l_False){
analyzeFinal(~p, conflict);
return l_False;
}else{
next = p;
break;
}
}
if (next == lit_Undef){
// New variable decision:
decisions++;
next = pickBranchLit(polarity_mode, random_var_freq);
if (next == lit_Undef)
{
// Added Line
// Clear explanation vector if satisfiable
explanation.clear( );
// Model found:
return l_True;
}
}
// Increase decision level and enqueue 'next'
assert(value(next) == l_Undef);
newDecisionLevel();
uncheckedEnqueue(next);
}
}
}
RESULT Engine::search() {
int starts = 0;
int nof_conflicts = so.restart_base;
int conflictC = 0;
while (true) {
if (so.parallel && slave.checkMessages()) return RES_UNK;
if (!propagate()) {
clearPropState();
Conflict:
conflicts++; conflictC++;
if (time(NULL) > so.time_out) {
printf("Time limit exceeded!\n");
return RES_UNK;
}
if (decisionLevel() == 0) { return RES_GUN; }
// Derive learnt clause and perform backjump
if (so.lazy) {
sat.analyze();
} else {
sat.confl = NULL;
DecInfo& di = dec_info.last();
sat.btToLevel(decisionLevel()-1);
makeDecision(di, 1);
}
if (!so.vsids && !so.toggle_vsids && conflictC >= so.switch_to_vsids_after) {
if (so.restart_base >= 1000000000) so.restart_base = 100;
sat.btToLevel(0);
toggleVSIDS();
}
} else {
if (conflictC >= nof_conflicts) {
starts++;
nof_conflicts += getRestartLimit((starts+1)/2);
sat.btToLevel(0);
sat.confl = NULL;
if (so.lazy && so.toggle_vsids && (starts % 2 == 0)) toggleVSIDS();
continue;
}
if (decisionLevel() == 0) {
topLevelCleanUp();
if (opt_var && so.verbosity >= 3) {
printf("%% root level bounds on objective: min %d max %d\n", opt_var->getMin(), opt_var->getMax());
}
}
DecInfo *di = NULL;
// Propagate assumptions
while (decisionLevel() < assumptions.size()) {
int p = assumptions[decisionLevel()];
if (sat.value(toLit(p)) == l_True) {
// Dummy decision level:
assert(sat.trail.last().size() == sat.qhead.last());
engine.dec_info.push(DecInfo(NULL, p));
newDecisionLevel();
} else if (sat.value(toLit(p)) == l_False) {
return RES_LUN;
} else {
di = new DecInfo(NULL, p);
break;
}
}
if (!di) di = branching->branch();
if (!di) {
solutions++;
if (so.print_sol) {
problem->print();
printf("----------\n");
fflush(stdout);
}
if (!opt_var) {
if (solutions == so.nof_solutions) return RES_SAT;
if (so.lazy) blockCurrentSol();
goto Conflict;
}
if (!constrain()) {
return RES_GUN;
}
continue;
}
engine.dec_info.push(*di);
newDecisionLevel();
doFixPointStuff();
makeDecision(*di, 0);
delete di;
}
}
}
lbool Solver::search(int nof_conflicts, int nof_learnts)
{
assert(ok);
int backtrack_level;
int conflictsC = 0;
vec<Lit> learnt_clause;
int nblevels=0,nbCC=0,merged=0;
starts++;
bool first = true;
for (;;){
Clause* confl = propagate();
if (confl != NULL){
// CONFLICT
conflicts++; conflictsC++;cons++;nbCC++;
if (decisionLevel() == 0) return l_False;
first = false;
learnt_clause.clear();
analyze(confl, learnt_clause, backtrack_level,nblevels,merged);
conf4Stats++;
nbDecisionLevelHistory.push(nblevels);
totalSumOfDecisionLevel += nblevels;
cancelUntil(backtrack_level);
assert(value(learnt_clause[0]) == l_Undef);
if (learnt_clause.size() == 1){
uncheckedEnqueue(learnt_clause[0]);
nbUn++;
}else{
Clause* c = Clause_new(learnt_clause, true);
learnts.push(c);
c->setActivity(nblevels); // LS
if(nblevels<=2) nbDL2++;
if(c->size()==2) nbBin++;
attachClause(*c);
claBumpActivity(*c);
uncheckedEnqueue(learnt_clause[0], c);
}
varDecayActivity();
claDecayActivity();
}else{
if (
( nbDecisionLevelHistory.isvalid() &&
((nbDecisionLevelHistory.getavg()*0.7) > (totalSumOfDecisionLevel / conf4Stats)))) {
nbDecisionLevelHistory.fastclear();
progress_estimate = progressEstimate();
cancelUntil(0);
return l_Undef; }
// Simplify the set of problem clauses:
if (decisionLevel() == 0 && !simplify())
return l_False;
//
Lit next = lit_Undef;
if(cons-curRestart* nbclausesbeforereduce>=0)
{
curRestart = (conflicts/ nbclausesbeforereduce)+1;
reduceDB();
nbclausesbeforereduce += 500;
}
if (next == lit_Undef){
// New variable decision:
decisions++;
next = pickBranchLit(polarity_mode, random_var_freq);
if (next == lit_Undef)
// Model found:
return l_True;
}
// Increase decision level and enqueue 'next'
assert(value(next) == l_Undef);
newDecisionLevel();
uncheckedEnqueue(next);
}
}
}
/*_________________________________________________________________________________________________
|
| search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&) -> [lbool]
|
| Description:
| Search for a model the specified number of conflicts, keeping the number of learnt clauses
| below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to
| indicate infinity.
|
| Output:
| 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
| all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
| if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
|________________________________________________________________________________________________@*/
lbool Solver::search(int nof_conflicts, int nof_learnts)
{
int backtrack_level;
int conflictC = 0;
vec<Lit> learnt_clause;
starts++;
// bool first = true;
for (;;){
Clause* confl = propagate();
if (confl != NULL){
// CONFLICT
conflicts++; conflictC++;
if (decisionLevel() == 0) return l_False;
// first = false;
learnt_clause.clear();
analyze(confl, learnt_clause, backtrack_level);
cancelUntil(backtrack_level);
#ifdef __PRINT
char c1 = sign(learnt_clause[0]) ? '-' : '+';
char c2 = polarity[var(learnt_clause[0])] == 0 ? '-' : '+';
if (decisionLevel() < minDecisionLevel &&
original_activity[var(learnt_clause[0])] > 0) {
printf("Conflict record: ");
printLit(learnt_clause[0]);
printf(" .%d.\t.%d. %c .%c .%g\n", decisionLevel(), trail.size(),
c1, c2, original_activity[var(learnt_clause[0])]);
if (decisionLevel() == 0) {
minDecisionLevel = (unsigned)(-1);
} else {
minDecisionLevel = decisionLevel();
}
}
#endif
if (learnt_clause.size() == 1){
uncheckedEnqueue(learnt_clause[0]);
}else{
Clause* c = Clause::Clause_new(learnt_clause, true);
learnts.push(c);
attachClause(*c);
claBumpActivity(*c);
uncheckedEnqueue(learnt_clause[0], c);
}
#ifdef _MINISAT_DEFAULT_VSS
varDecayActivity();
#endif
claDecayActivity();
}else{
// NO CONFLICT
if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
// Reached bound on number of conflicts:
progress_estimate = progressEstimate();
// cancelUntil(0);
return l_Undef; }
// Simplify the set of problem clauses:
if (decisionLevel() == 0 && !simplify())
return l_False;
if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts)
// Reduce the set of learnt clauses:
reduceDB();
Lit next = lit_Undef;
while (decisionLevel() < assumptions.size()){
// Perform user provided assumption:
Lit p = assumptions[decisionLevel()];
if (value(p) == l_True){
// Dummy decision level:
newDecisionLevel();
}else if (value(p) == l_False){
analyzeFinal(~p, conflict);
return l_False;
}else{
next = p;
break;
}
}
if (next == lit_Undef){
// New variable decision:
decisions++;
next = pickBranchLit(polarity_mode, random_var_freq);
if (next == lit_Undef)
// Model found:
return l_True;
#ifdef __PRINT
printf("Decision: ");
printLit(next);
printf("\t.%f.\t.%d.\t.%d.", activity[var(next)], decisionLevel(), trail.size());
printf("\n");
#endif
}
// Increase decision level and enqueue 'next'
newDecisionLevel();
uncheckedEnqueue(next);
}
//#ifdef __PRINT
// printTrail();
//#endif
}
}
