diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
b1b6afe801
yap-6.3/packages/bee/cryptominisat-2.5.1/Solver/Solver.cpp
Vitor Santos Costa 16015bd8e6 bee
2019-04-22 12:15:21 +01:00

2701 lines
87 KiB
C++
Executable File
Raw Blame History

/****************************************************************************************[Solver.C]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
CryptoMiniSat -- Copyright (c) 2009 Mate Soos
glucose -- Gilles Audemard, Laurent Simon (2008)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or
substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************************************/
#include "Solver.h"
#include <cmath>
#include <string.h>
#include <algorithm>
#include <limits.h>
#include <vector>
#include <iomanip>
#include "Clause.h"
#include "time_mem.h"
#include "VarReplacer.h"
#include "FindUndef.h"
#include "XorFinder.h"
#include "ClauseCleaner.h"
#include "RestartTypeChooser.h"
#include "FailedVarSearcher.h"
#include "Subsumer.h"
#include "PartHandler.h"
#include "XorSubsumer.h"
#include "StateSaver.h"
#ifdef USE_GAUSS
#include "Gaussian.h"
#include "MatrixFinder.h"
#endif //USE_GAUSS
#ifdef _MSC_VER
#define __builtin_prefetch(a,b,c)
//#define __builtin_prefetch(a,b)
#endif //_MSC_VER
//#define DEBUG_UNCHECKEDENQUEUE_LEVEL0
//#define VERBOSE_DEBUG_POLARITIES
//#define DEBUG_DYNAMIC_RESTART
//=================================================================================================
// Constructor/Destructor:
Solver::Solver() :
// Parameters: (formerly in 'SearchParams')
random_var_freq(0.02)
, clause_decay (1 / 0.999)
, restart_first(100), restart_inc(1.5), learntsize_factor((double)1/(double)3), learntsize_inc(1)
// More parameters:
//
, expensive_ccmin (true)
, polarity_mode (polarity_auto)
, verbosity (0)
, restrictedPickBranch(0)
, findNormalXors (true)
, findBinaryXors (true)
, regularlyFindBinaryXors(true)
, performReplace (true)
, conglomerateXors (true)
, heuleProcess (true)
, schedSimplification(true)
, doSubsumption (true)
, doXorSubsumption (true)
, doPartHandler (true)
, doHyperBinRes (true)
, doBlockedClause (true)
, doVarElim (true)
, doSubsume1 (true)
, failedVarSearch (true)
, readdOldLearnts (false)
, addExtraBins (true)
, removeUselessBins(true)
, regularRemoveUselessBins(true)
, subsumeWithNonExistBinaries(true)
, regularSubsumeWithNonExistBinaries(true)
, libraryUsage (true)
, greedyUnbound (false)
, fixRestartType (auto_restart)
// Statistics: (formerly in 'SolverStats')
//
, starts(0), dynStarts(0), staticStarts(0), fullStarts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0)
, clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0)
, nbDL2(0), nbBin(0), lastNbBin(0), becameBinary(0), lastSearchForBinaryXor(0), nbReduceDB(0)
, improvedClauseNo(0), improvedClauseSize(0)
#ifdef USE_GAUSS
, sum_gauss_called (0)
, sum_gauss_confl (0)
, sum_gauss_prop (0)
, sum_gauss_unit_truths (0)
#endif //USE_GAUSS
, ok (true)
, var_inc (128)
, cla_inc (1)
, curRestart (1)
, nbclausesbeforereduce (NBCLAUSESBEFOREREDUCE)
, nbCompensateSubsumer (0)
, qhead (0)
, simpDB_assigns (-1)
, simpDB_props (0)
, order_heap (VarOrderLt(activity))
, progress_estimate(0)
, remove_satisfied (true)
, mtrand((unsigned long int)0)
, restartType (static_restart)
, lastSelectedRestartType (static_restart)
#ifdef STATS_NEEDED
, logger(verbosity)
, dynamic_behaviour_analysis(false) //do not document the proof as default
#endif
, maxRestarts(UINT_MAX)
, MYFLAG (0)
, learnt_clause_group(0)
, libraryCNFFile (NULL)
, simplifying (false)
{
varReplacer = new VarReplacer(*this);
clauseCleaner = new ClauseCleaner(*this);
failedVarSearcher = new FailedVarSearcher(*this);
partHandler = new PartHandler(*this);
subsumer = new Subsumer(*this);
xorSubsumer = new XorSubsumer(*this);
restartTypeChooser = new RestartTypeChooser(*this);
#ifdef USE_GAUSS
matrixFinder = new MatrixFinder(*this);
#endif //USE_GAUSS
#ifdef STATS_NEEDED
logger.setSolver(this);
#endif
}
Solver::~Solver()
{
for (uint32_t i = 0; i != learnts.size(); i++) clauseFree(learnts[i]);
for (uint32_t i = 0; i != clauses.size(); i++) clauseFree(clauses[i]);
for (uint32_t i = 0; i != binaryClauses.size(); i++) clauseFree(binaryClauses[i]);
for (uint32_t i = 0; i != xorclauses.size(); i++) clauseFree(xorclauses[i]);
for (uint32_t i = 0; i != removedLearnts.size(); i++) clauseFree(removedLearnts[i]);
#ifdef USE_GAUSS
clearGaussMatrixes();
delete matrixFinder;
#endif
for (uint32_t i = 0; i != freeLater.size(); i++) clauseFree(freeLater[i]);
delete varReplacer;
delete clauseCleaner;
delete failedVarSearcher;
delete partHandler;
delete subsumer;
delete xorSubsumer;
delete restartTypeChooser;
if (libraryCNFFile)
fclose(libraryCNFFile);
}
//=================================================================================================
// Minor methods:
// Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be
// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
Var Solver::newVar(bool dvar)
{
Var v = nVars();
watches .push(); // (list for positive literal)
watches .push(); // (list for negative literal)
binwatches.push(); // (list for positive literal)
binwatches.push(); // (list for negative literal)
xorwatches.push(); // (list for variables in xors)
reason .push((Clause*)NULL);
assigns .push(l_Undef);
level .push(-1);
activity .push(0);
seen .push_back(0);
seen .push_back(0);
permDiff .push(0);
polarity .push_back(defaultPolarity());
#ifdef USE_OLD_POLARITIES
oldPolarity.push_back(defaultPolarity());
#endif //USE_OLD_POLARITIES
decision_var.push_back(dvar);
insertVarOrder(v);
varReplacer->newVar();
partHandler->newVar();
subsumer->newVar();
xorSubsumer->newVar();
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
logger.new_var(v);
#endif
if (libraryCNFFile)
fprintf(libraryCNFFile, "c Solver::newVar() called\n");
return v;
}
template<class T>
XorClause* Solver::addXorClauseInt(T& ps, bool xor_clause_inverted, const uint32_t group)
{
assert(qhead == trail.size());
assert(decisionLevel() == 0);
if (ps.size() > (0x01UL << 18)) {
std::cout << "Too long clause!" << std::endl;
exit(-1);
}
std::sort(ps.getData(), ps.getDataEnd());
Lit p;
uint32_t i, j;
for (i = j = 0, p = lit_Undef; i != ps.size(); i++) {
if (ps[i].var() == p.var()) {
//added, but easily removed
j--;
p = lit_Undef;
if (!assigns[ps[i].var()].isUndef())
xor_clause_inverted ^= assigns[ps[i].var()].getBool();
} else if (assigns[ps[i].var()].isUndef()) //just add
ps[j++] = p = ps[i];
else //modify xor_clause_inverted instead of adding
xor_clause_inverted ^= (assigns[ps[i].var()].getBool());
}
ps.shrink(i - j);
switch(ps.size()) {
case 0: {
if (!xor_clause_inverted) ok = false;
return NULL;
}
case 1: {
uncheckedEnqueue(Lit(ps[0].var(), xor_clause_inverted));
ok = (propagate() == NULL);
return NULL;
}
case 2: {
#ifdef VERBOSE_DEBUG
cout << "--> xor is 2-long, replacing var " << ps[0].var()+1 << " with " << (!xor_clause_inverted ? "-" : "") << ps[1].var()+1 << endl;
#endif
learnt_clause_group = std::max(group+1, learnt_clause_group);
ps[0] = ps[0].unsign();
ps[1] = ps[1].unsign();
varReplacer->replace(ps, xor_clause_inverted, group);
return NULL;
}
default: {
learnt_clause_group = std::max(group+1, learnt_clause_group);
XorClause* c = XorClause_new(ps, xor_clause_inverted, group);
attachClause(*c);
return c;
}
}
}
template XorClause* Solver::addXorClauseInt(vec<Lit>& ps, bool xor_clause_inverted, const uint32_t group);
template XorClause* Solver::addXorClauseInt(XorClause& ps, bool xor_clause_inverted, const uint32_t group);
template<class T>
bool Solver::addXorClause(T& ps, bool xor_clause_inverted, const uint group, char* group_name)
{
assert(decisionLevel() == 0);
if (ps.size() > (0x01UL << 18)) {
std::cout << "Too long clause!" << std::endl;
exit(-1);
}
if (libraryCNFFile) {
fprintf(libraryCNFFile, "x");
for (uint32_t i = 0; i < ps.size(); i++) ps[i].print(libraryCNFFile);
fprintf(libraryCNFFile, "0\n");
}
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
logger.set_group_name(group, group_name);
#endif
if (!ok)
return false;
assert(qhead == trail.size());
// Check if clause is satisfied and remove false/duplicate literals:
if (varReplacer->getNumLastReplacedVars() || subsumer->getNumElimed() || xorSubsumer->getNumElimed()) {
for (uint32_t i = 0; i != ps.size(); i++) {
if (subsumer->getVarElimed()[ps[i].var()] && !subsumer->unEliminate(ps[i].var()))
return false;
else if (xorSubsumer->getVarElimed()[ps[i].var()] && !xorSubsumer->unEliminate(ps[i].var()))
return false;
else {
Lit otherLit = varReplacer->getReplaceTable()[ps[i].var()];
if (otherLit.var() != ps[i].var()) {
ps[i] = Lit(otherLit.var(), false);
xor_clause_inverted ^= otherLit.sign();
}
}
}
}
XorClause* c = addXorClauseInt(ps, xor_clause_inverted, group);
if (c != NULL) xorclauses.push(c);
return ok;
}
template bool Solver::addXorClause(vec<Lit>& ps, bool xor_clause_inverted, const uint group, char* group_name);
template bool Solver::addXorClause(XorClause& ps, bool xor_clause_inverted, const uint group, char* group_name);
template<class T>
bool Solver::addLearntClause(T& ps, const uint group, const uint32_t activity)
{
Clause* c = addClauseInt(ps, group);
if (c == NULL) return ok;
//compensate for addClauseInt's attachClause, which doesn't know
//that this is a learnt clause.
clauses_literals -= c->size();
learnts_literals += c->size();
c->makeLearnt(activity);
if (c->size() > 2) learnts.push(c);
else {
nbBin++;
binaryClauses.push(c);
}
return ok;
}
template bool Solver::addLearntClause(Clause& ps, const uint group, const uint32_t activity);
template bool Solver::addLearntClause(vec<Lit>& ps, const uint group, const uint32_t activity);
template <class T>
Clause* Solver::addClauseInt(T& ps, uint group)
{
assert(ok);
std::sort(ps.getData(), ps.getDataEnd());
Lit p = lit_Undef;
uint32_t i, j;
for (i = j = 0; i != ps.size(); i++) {
if (value(ps[i]).getBool() || ps[i] == ~p)
return NULL;
else if (value(ps[i]) != l_False && ps[i] != p)
ps[j++] = p = ps[i];
}
ps.shrink(i - j);
if (ps.size() == 0) {
ok = false;
return NULL;
} else if (ps.size() == 1) {
uncheckedEnqueue(ps[0]);
ok = (propagate() == NULL);
return NULL;
}
learnt_clause_group = std::max(group+1, learnt_clause_group);
Clause* c = Clause_new(ps, group);
attachClause(*c);
return c;
}
template Clause* Solver::addClauseInt(Clause& ps, const uint group);
template Clause* Solver::addClauseInt(vec<Lit>& ps, const uint group);
template<class T>
bool Solver::addClause(T& ps, const uint group, char* group_name)
{
assert(decisionLevel() == 0);
if (ps.size() > (0x01UL << 18)) {
std::cout << "Too long clause!" << std::endl;
exit(-1);
}
if (libraryCNFFile) {
for (uint32_t i = 0; i != ps.size(); i++) ps[i].print(libraryCNFFile);
fprintf(libraryCNFFile, "0\n");
}
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
logger.set_group_name(group, group_name);
#endif
if (!ok)
return false;
assert(qhead == trail.size());
// Check if clause is satisfied and remove false/duplicate literals:
if (varReplacer->getNumLastReplacedVars() || subsumer->getNumElimed() || xorSubsumer->getNumElimed()) {
for (uint32_t i = 0; i != ps.size(); i++) {
ps[i] = varReplacer->getReplaceTable()[ps[i].var()] ^ ps[i].sign();
if (subsumer->getVarElimed()[ps[i].var()] && !subsumer->unEliminate(ps[i].var()))
return false;
if (xorSubsumer->getVarElimed()[ps[i].var()] && !xorSubsumer->unEliminate(ps[i].var()))
return false;
}
}
Clause* c = addClauseInt(ps, group);
if (c != NULL) {
if (c->size() > 2)
clauses.push(c);
else
binaryClauses.push(c);
}
return ok;
}
template bool Solver::addClause(vec<Lit>& ps, const uint group, char* group_name);
template bool Solver::addClause(Clause& ps, const uint group, char* group_name);
void Solver::attachClause(XorClause& c)
{
assert(c.size() > 2);
#ifdef DEBUG_ATTACH
assert(assigns[c[0].var()] == l_Undef);
assert(assigns[c[1].var()] == l_Undef);
#endif //DEBUG_ATTACH
xorwatches[c[0].var()].push(&c);
xorwatches[c[1].var()].push(&c);
clauses_literals += c.size();
}
void Solver::attachClause(Clause& c)
{
assert(c.size() > 1);
int index0 = (~c[0]).toInt();
int index1 = (~c[1]).toInt();
if (c.size() == 2) {
binwatches[index0].push(WatchedBin(&c, c[1]));
binwatches[index1].push(WatchedBin(&c, c[0]));
} else {
watches[index0].push(Watched(&c, c[c.size()/2]));
watches[index1].push(Watched(&c, c[c.size()/2]));
}
if (c.learnt()) learnts_literals += c.size();
else clauses_literals += c.size();
}
void Solver::detachClause(const XorClause& c)
{
assert(c.size() > 1);
assert(find(xorwatches[c[0].var()], &c));
assert(find(xorwatches[c[1].var()], &c));
remove(xorwatches[c[0].var()], &c);
remove(xorwatches[c[1].var()], &c);
clauses_literals -= c.size();
}
void Solver::detachClause(const Clause& c)
{
assert(c.size() > 1);
if (c.size() == 2) {
assert(findWatchedBinCl(binwatches[(~c[0]).toInt()], &c));
assert(findWatchedBinCl(binwatches[(~c[1]).toInt()], &c));
removeWatchedBinCl(binwatches[(~c[0]).toInt()], &c);
removeWatchedBinCl(binwatches[(~c[1]).toInt()], &c);
} else {
assert(findWatchedCl(watches[(~c[0]).toInt()], &c));
assert(findWatchedCl(watches[(~c[1]).toInt()], &c));
removeWatchedCl(watches[(~c[0]).toInt()], &c);
removeWatchedCl(watches[(~c[1]).toInt()], &c);
}
if (c.learnt()) learnts_literals -= c.size();
else clauses_literals -= c.size();
}
void Solver::detachModifiedClause(const Lit lit1, const Lit lit2, const uint origSize, const Clause* address)
{
assert(origSize > 1);
if (origSize == 2) {
assert(findWatchedBinCl(binwatches[(~lit1).toInt()], address));
assert(findWatchedBinCl(binwatches[(~lit2).toInt()], address));
removeWatchedBinCl(binwatches[(~lit1).toInt()], address);
removeWatchedBinCl(binwatches[(~lit2).toInt()], address);
} else {
assert(findW(watches[(~lit1).toInt()], address));
assert(findW(watches[(~lit2).toInt()], address));
removeW(watches[(~lit1).toInt()], address);
removeW(watches[(~lit2).toInt()], address);
}
if (address->learnt()) learnts_literals -= origSize;
else clauses_literals -= origSize;
}
void Solver::detachModifiedClause(const Var var1, const Var var2, const uint origSize, const XorClause* address)
{
assert(origSize > 2);
assert(find(xorwatches[var1], address));
assert(find(xorwatches[var2], address));
remove(xorwatches[var1], address);
remove(xorwatches[var2], address);
clauses_literals -= origSize;
}
// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
//
void Solver::cancelUntil(int level)
{
#ifdef VERBOSE_DEBUG
cout << "Canceling until level " << level;
if (level > 0) cout << " sublevel: " << trail_lim[level];
cout << endl;
#endif
if ((int)decisionLevel() > level) {
#ifdef USE_GAUSS
for (vector<Gaussian*>::iterator gauss = gauss_matrixes.begin(), end= gauss_matrixes.end(); gauss != end; gauss++)
(*gauss)->canceling(trail_lim[level]);
#endif //USE_GAUSS
for (int sublevel = trail.size()-1; sublevel >= (int)trail_lim[level]; sublevel--) {
Var var = trail[sublevel].var();
#ifdef VERBOSE_DEBUG
cout << "Canceling var " << var+1 << " sublevel: " << sublevel << endl;
#endif
#ifdef USE_OLD_POLARITIES
polarity[var] = oldPolarity[var];
#endif //USE_OLD_POLARITIES
assigns[var] = l_Undef;
insertVarOrder(var);
}
qhead = trail_lim[level];
trail.shrink_(trail.size() - trail_lim[level]);
trail_lim.shrink_(trail_lim.size() - level);
}
#ifdef VERBOSE_DEBUG
cout << "Canceling finished. (now at level: " << decisionLevel() << " sublevel: " << trail.size()-1 << ")" << endl;
#endif
}
void Solver::printLit(const Lit l) const
{
printf("%s%d:%c", l.sign() ? "-" : "", l.var()+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
}
void Solver::needLibraryCNFFile(const char* fileName)
{
libraryCNFFile = fopen(fileName, "w");
assert(libraryCNFFile != NULL);
}
#ifdef USE_GAUSS
void Solver::clearGaussMatrixes()
{
for (uint i = 0; i < gauss_matrixes.size(); i++)
delete gauss_matrixes[i];
gauss_matrixes.clear();
}
#endif //USE_GAUSS
inline bool Solver::defaultPolarity()
{
switch(polarity_mode) {
case polarity_false:
return true;
case polarity_true:
return false;
case polarity_rnd:
return mtrand.randInt(1);
case polarity_auto:
return true;
default:
assert(false);
}
return true;
}
void Solver::tallyVotes(const vec<Clause*>& cs, vector<double>& votes) const
{
for (const Clause * const*it = cs.getData(), * const*end = it + cs.size(); it != end; it++) {
const Clause& c = **it;
if (c.learnt()) continue;
double divider;
if (c.size() > 63) divider = 0.0;
else divider = 1.0/(double)((uint64_t)1<<(c.size()-1));
for (const Lit *it2 = &c[0], *end2 = it2 + c.size(); it2 != end2; it2++) {
if (it2->sign()) votes[it2->var()] += divider;
else votes[it2->var()] -= divider;
}
}
}
void Solver::tallyVotes(const vec<XorClause*>& cs, vector<double>& votes) const
{
for (const XorClause * const*it = cs.getData(), * const*end = it + cs.size(); it != end; it++) {
const XorClause& c = **it;
double divider;
if (c.size() > 63) divider = 0.0;
else divider = 1.0/(double)((uint64_t)1<<(c.size()-1));
for (const Lit *it2 = &c[0], *end2 = it2 + c.size(); it2 != end2; it2++)
votes[it2->var()] += divider;
}
}
void Solver::calculateDefaultPolarities()
{
#ifdef VERBOSE_DEBUG_POLARITIES
std::cout << "Default polarities: " << std::endl;
#endif
assert(decisionLevel() == 0);
if (polarity_mode == polarity_auto) {
double time = cpuTime();
vector<double> votes;
votes.resize(nVars(), 0.0);
tallyVotes(clauses, votes);
tallyVotes(binaryClauses, votes);
tallyVotes(varReplacer->getClauses(), votes);
tallyVotes(xorclauses, votes);
Var i = 0;
uint32_t posPolars = 0;
uint32_t undecidedPolars = 0;
for (vector<double>::const_iterator it = votes.begin(), end = votes.end(); it != end; it++, i++) {
polarity[i] = (*it >= 0.0);
posPolars += (*it < 0.0);
undecidedPolars += (*it == 0.0);
#ifdef VERBOSE_DEBUG_POLARITIES
std::cout << !defaultPolarities[i] << ", ";
#endif //VERBOSE_DEBUG_POLARITIES
}
if (verbosity >= 2) {
std::cout << "c | Calc default polars - "
<< " time: " << std::fixed << std::setw(6) << std::setprecision(2) << cpuTime()-time << " s"
<< " pos: " << std::setw(7) << posPolars
<< " undec: " << std::setw(7) << undecidedPolars
<< " neg: " << std::setw(7) << nVars()- undecidedPolars - posPolars
<< std::setw(8) << " |" << std:: endl;
}
} else {
std::fill(polarity.begin(), polarity.end(), defaultPolarity());
}
#ifdef VERBOSE_DEBUG_POLARITIES
std::cout << std::endl;
#endif //VERBOSE_DEBUG_POLARITIES
}
//=================================================================================================
// Major methods:
Lit Solver::pickBranchLit()
{
#ifdef VERBOSE_DEBUG
cout << "decision level: " << decisionLevel() << " ";
#endif
Var next = var_Undef;
bool random = mtrand.randDblExc() < random_var_freq;
// Random decision:
if (random && !order_heap.empty()) {
if (restrictedPickBranch == 0)
next = order_heap[mtrand.randInt(order_heap.size()-1)];
else
next = order_heap[mtrand.randInt(std::min((uint32_t)order_heap.size()-1, restrictedPickBranch))];
if (assigns[next] == l_Undef && decision_var[next])
rnd_decisions++;
}
// Activity based decision:
while (next == var_Undef || assigns[next] != l_Undef || !decision_var[next])
if (order_heap.empty()) {
#ifdef VERBOSE_DEBUG
cout << "SAT!" << endl;
#endif
return lit_Undef;
} else {
next = order_heap.removeMin();
}
bool sign;
if (simplifying && random)
sign = mtrand.randInt(1);
#ifdef RANDOM_LOOKAROUND_SEARCHSPACE
else if (avgBranchDepth.isvalid())
sign = polarity[next] ^ (mtrand.randInt(avgBranchDepth.getavg() * ((lastSelectedRestartType == static_restart) ? 2 : 1) ) == 1);
#endif
else
sign = polarity[next];
Lit lit(next,sign);
#ifdef VERBOSE_DEBUG
assert(decision_var[lit.var()]);
cout << "decided on: " << lit.var()+1 << " to set:" << !lit.sign() << endl;
#endif
return lit;
}
// Assumes 'seen' is cleared (will leave it cleared)
template<class T1, class T2>
bool subset(const T1& A, const T2& B, vector<bool>& seen)
{
for (uint i = 0; i != B.size(); i++)
seen[B[i].toInt()] = 1;
for (uint i = 0; i != A.size(); i++) {
if (!seen[A[i].toInt()]) {
for (uint i = 0; i != B.size(); i++)
seen[B[i].toInt()] = 0;
return false;
}
}
for (uint i = 0; i != B.size(); i++)
seen[B[i].toInt()] = 0;
return true;
}
/*_________________________________________________________________________________________________
|
| analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&) -> [void]
|
| Description:
| Analyze conflict and produce a reason clause.
|
| Pre-conditions:
| * 'out_learnt' is assumed to be cleared.
| * Current decision level must be greater than root level.
|
| Post-conditions:
| * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
|
| Effect:
| Will undo part of the trail, upto but not beyond the assumption of the current decision level.
|________________________________________________________________________________________________@*/
Clause* Solver::analyze(Clause* confl, vec<Lit>& out_learnt, int& out_btlevel, uint32_t &nbLevels, const bool update)
{
int pathC = 0;
Lit p = lit_Undef;
Clause* oldConfl = NULL;
// Generate conflict clause:
//
out_learnt.push(); // (leave room for the asserting literal)
int index = trail.size() - 1;
out_btlevel = 0;
do {
assert(confl != NULL); // (otherwise should be UIP)
Clause& c = *confl;
if (p != lit_Undef)
reverse_binary_clause(c);
if (update && restartType == static_restart && c.learnt())
claBumpActivity(c);
for (uint j = (p == lit_Undef) ? 0 : 1; j != c.size(); j++) {
const Lit& q = c[j];
const Var my_var = q.var();
if (!seen[my_var] && level[my_var] > 0) {
varBumpActivity(my_var);
seen[my_var] = 1;
if (level[my_var] >= (int)decisionLevel()) {
pathC++;
#ifdef UPDATEVARACTIVITY
if (lastSelectedRestartType == dynamic_restart && reason[q.var()] != NULL && reason[q.var()]->learnt())
lastDecisionLevel.push(q.var());
#endif
} else {
out_learnt.push(q);
if (level[my_var] > out_btlevel)
out_btlevel = level[my_var];
}
}
}
// Select next clause to look at:
while (!seen[trail[index--].var()]);
p = trail[index+1];
oldConfl = confl;
confl = reason[p.var()];
__builtin_prefetch(confl, 1, 0);
seen[p.var()] = 0;
pathC--;
} while (pathC > 0);
out_learnt[0] = ~p;
// Simplify conflict clause:
//
uint32_t i, j;
if (expensive_ccmin) {
uint32_t abstract_level = 0;
for (i = 1; i < out_learnt.size(); i++)
abstract_level |= abstractLevel(out_learnt[i].var()); // (maintain an abstraction of levels involved in conflict)
out_learnt.copyTo(analyze_toclear);
for (i = j = 1; i < out_learnt.size(); i++)
if (reason[out_learnt[i].var()] == NULL || !litRedundant(out_learnt[i], abstract_level))
out_learnt[j++] = out_learnt[i];
} else {
out_learnt.copyTo(analyze_toclear);
for (i = j = 1; i < out_learnt.size(); i++) {
Clause& c = *reason[out_learnt[i].var()];
reverse_binary_clause(c);
for (uint k = 1; k < c.size(); k++)
if (!seen[c[k].var()] && level[c[k].var()] > 0) {
out_learnt[j++] = out_learnt[i];
break;
}
}
}
max_literals += out_learnt.size();
out_learnt.shrink(i - j);
tot_literals += out_learnt.size();
// Find correct backtrack level:
//
if (out_learnt.size() == 1)
out_btlevel = 0;
else {
uint32_t max_i = 1;
for (uint32_t i = 2; i < out_learnt.size(); i++)
if (level[out_learnt[i].var()] > level[out_learnt[max_i].var()])
max_i = i;
Lit p = out_learnt[max_i];
out_learnt[max_i] = out_learnt[1];
out_learnt[1] = p;
out_btlevel = level[p.var()];
}
if (lastSelectedRestartType == dynamic_restart) {
nbLevels = calcNBLevels(out_learnt);
#ifdef UPDATEVARACTIVITY
for(uint32_t i = 0; i != lastDecisionLevel.size(); i++) {
if (reason[lastDecisionLevel[i]]->activity() < nbLevels)
varBumpActivity(lastDecisionLevel[i]);
}
lastDecisionLevel.clear();
#endif
} else {
nbLevels = 1000;
}
for (uint32_t j = 0; j != analyze_toclear.size(); j++)
seen[analyze_toclear[j].var()] = 0; // ('seen[]' is now cleared)
if (out_learnt.size() == 1)
return NULL;
if (!oldConfl->isXor() && out_learnt.size() < oldConfl->size()) {
if (!subset(out_learnt, *oldConfl, seen)) return NULL;
improvedClauseNo++;
improvedClauseSize += oldConfl->size() - out_learnt.size();
return oldConfl;
}
return NULL;
}
// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
// visiting literals at levels that cannot be removed later.
bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
{
analyze_stack.clear();
analyze_stack.push(p);
int top = analyze_toclear.size();
while (analyze_stack.size() > 0) {
assert(reason[analyze_stack.last().var()] != NULL);
Clause& c = *reason[analyze_stack.last().var()];
reverse_binary_clause(c);
analyze_stack.pop();
for (uint i = 1; i < c.size(); i++) {
Lit p = c[i];
if (!seen[p.var()] && level[p.var()] > 0) {
if (reason[p.var()] != NULL && (abstractLevel(p.var()) & abstract_levels) != 0) {
seen[p.var()] = 1;
analyze_stack.push(p);
analyze_toclear.push(p);
} else {
for (uint32_t j = top; j != analyze_toclear.size(); j++)
seen[analyze_toclear[j].var()] = 0;
analyze_toclear.shrink(analyze_toclear.size() - top);
return false;
}
}
}
}
return true;
}
/*_________________________________________________________________________________________________
|
| analyzeFinal : (p : Lit) -> [void]
|
| Description:
| Specialized analysis procedure to express the final conflict in terms of assumptions.
| Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
| stores the result in 'out_conflict'.
|________________________________________________________________________________________________@*/
void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
{
out_conflict.clear();
out_conflict.push(p);
if (decisionLevel() == 0)
return;
seen[p.var()] = 1;
for (int32_t i = (int32_t)trail.size()-1; i >= (int32_t)trail_lim[0]; i--) {
Var x = trail[i].var();
if (seen[x]) {
if (reason[x] == NULL) {
assert(level[x] > 0);
out_conflict.push(~trail[i]);
} else {
const Clause& c = *reason[x];
for (uint j = 1; j < c.size(); j++)
if (level[c[j].var()] > 0)
seen[c[j].var()] = 1;
}
seen[x] = 0;
}
}
seen[p.var()] = 0;
}
void Solver::uncheckedEnqueue(Lit p, ClausePtr from)
{
#ifdef DEBUG_UNCHECKEDENQUEUE_LEVEL0
#ifndef VERBOSE_DEBUG
if (decisionLevel() == 0)
#endif //VERBOSE_DEBUG
std::cout << "uncheckedEnqueue var " << p.var()+1 << " to " << !p.sign() << " level: " << decisionLevel() << " sublevel: " << trail.size() << std::endl;
#endif //DEBUG_UNCHECKEDENQUEUE_LEVEL0
//assert(decisionLevel() == 0 || !subsumer->getVarElimed()[p.var()]);
assert(assigns[p.var()].isUndef());
const Var v = p.var();
assigns [v] = boolToLBool(!p.sign());//lbool(!sign(p)); // <<== abstract but not uttermost effecient
level [v] = decisionLevel();
reason [v] = from;
#ifdef USE_OLD_POLARITIES
oldPolarity[p.var()] = polarity[p.var()];
#endif //USE_OLD_POLARITIES
polarity[p.var()] = p.sign();
trail.push(p);
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
logger.propagation(p, from);
#endif
}
/*_________________________________________________________________________________________________
|
| propagate : [void] -> [Clause*]
|
| Description:
| Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
| otherwise NULL.
|
| Post-conditions:
| * the propagation queue is empty, even if there was a conflict.
|________________________________________________________________________________________________@*/
Clause* Solver::propagate(const bool update)
{
Clause* confl = NULL;
uint32_t num_props = 0;
#ifdef VERBOSE_DEBUG
cout << "Propagation started" << endl;
#endif
uint32_t qheadBin = qhead;
while (qhead < trail.size()) {
//First propagate binary clauses
while (qheadBin < trail.size()) {
Lit p = trail[qheadBin++];
vec<WatchedBin> & wbin = binwatches[p.toInt()];
num_props += wbin.size()/2;
for(WatchedBin *k = wbin.getData(), *end = wbin.getDataEnd(); k != end; k++) {
lbool val = value(k->impliedLit);
if (val.isUndef()) {
uncheckedEnqueue(k->impliedLit, k->clause);
} else if (val == l_False) {
confl = k->clause;
//goto EndPropagate;
}
}
}
if (confl != NULL)
goto EndPropagate;
//Next, propagate normal clauses
Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
vec<Watched>& ws = watches[p.toInt()];
Watched *i, *j, *end;
num_props += ws.size();
#ifdef VERBOSE_DEBUG
cout << "Propagating lit " << (p.sign() ? '-' : ' ') << p.var()+1 << endl;
#endif
for (i = j = ws.getData(), end = ws.getDataEnd(); i != end;) {
if (i+1 != end)
__builtin_prefetch((i+1)->clause, 1, 0);
if(value(i->blockedLit).getBool()) { // Clause is sat
*j++ = *i++;
continue;
}
Lit bl = i->blockedLit;
Clause& c = *(i->clause);
i++;
// Make sure the false literal is data[1]:
const Lit false_lit(~p);
if (c[0] == false_lit)
c[0] = c[1], c[1] = false_lit;
assert(c[1] == false_lit);
// If 0th watch is true, then clause is already satisfied.
const Lit& first = c[0];
if (value(first).getBool()) {
j->clause = &c;
j->blockedLit = first;
j++;
} else {
// Look for new watch:
for (Lit *k = &c[2], *end2 = c.getDataEnd(); k != end2; k++) {
if (value(*k) != l_False) {
c[1] = *k;
*k = false_lit;
watches[(~c[1]).toInt()].push(Watched(&c, c[0]));
goto FoundWatch;
}
}
// Did not find watch -- clause is unit under assignment:
j->clause = &c;
j->blockedLit = bl;
j++;
if (value(first) == l_False) {
confl = &c;
qhead = trail.size();
// Copy the remaining watches:
while (i < end)
*j++ = *i++;
} else {
uncheckedEnqueue(first, &c);
#ifdef DYNAMICNBLEVEL
if (update && c.learnt() && c.activity() > 2) { // GA
uint32_t nbLevels = calcNBLevels(c);
if (nbLevels+1 < c.activity())
c.setActivity(nbLevels);
}
#endif
}
}
FoundWatch:
;
}
ws.shrink_(i - j);
//Finally, propagate XOR-clauses
if (xorclauses.size() > 0 && !confl) confl = propagate_xors(p);
}
EndPropagate:
propagations += num_props;
simpDB_props -= num_props;
#ifdef VERBOSE_DEBUG
cout << "Propagation ended." << endl;
#endif
return confl;
}
Clause* Solver::propagateLight()
{
Clause* confl = NULL;
uint32_t num_props = 0;
uint32_t qheadBin = qhead;
while (qhead < trail.size()) {
//First propagate binary clauses
while (qheadBin < trail.size()) {
Lit p = trail[qheadBin++];
vec<WatchedBin> & wbin = binwatches[p.toInt()];
num_props += wbin.size()/2;
for(WatchedBin *k = wbin.getData(), *end = wbin.getDataEnd(); k != end; k++) {
lbool val = value(k->impliedLit);
if (val.isUndef()) {
uncheckedEnqueueLight(k->impliedLit);
} else if (val == l_False) {
confl = k->clause;
goto EndPropagate;
}
}
}
//Next, propagate normal clauses
Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
vec<Watched>& ws = watches[p.toInt()];
Watched *i, *j, *end;
num_props += ws.size();
for (i = j = ws.getData(), end = ws.getDataEnd(); i != end;) {
if (i+1 != end)
__builtin_prefetch((i+1)->clause, 1, 0);
if(value(i->blockedLit).getBool()) { // Clause is sat
*j++ = *i++;
continue;
}
Lit bl = i->blockedLit;
Clause& c = *(i->clause);
i++;
// Make sure the false literal is data[1]:
const Lit false_lit(~p);
if (c[0] == false_lit)
c[0] = c[1], c[1] = false_lit;
assert(c[1] == false_lit);
// If 0th watch is true, then clause is already satisfied.
const Lit& first = c[0];
if (value(first).getBool()) {
j->clause = &c;
j->blockedLit = first;
j++;
} else {
// Look for new watch:
for (Lit *k = &c[2], *end2 = c.getDataEnd(); k != end2; k++) {
if (value(*k) != l_False) {
c[1] = *k;
*k = false_lit;
watches[(~c[1]).toInt()].push(Watched(&c, c[0]));
goto FoundWatch;
}
}
// Did not find watch -- clause is unit under assignment:
j->clause = &c;
j->blockedLit = bl;
j++;
if (value(first) == l_False) {
confl = &c;
qhead = trail.size();
// Copy the remaining watches:
while (i < end)
*j++ = *i++;
} else {
uncheckedEnqueueLight(first);
}
}
FoundWatch:
;
}
ws.shrink_(i - j);
//Finally, propagate XOR-clauses
if (xorclauses.size() > 0 && !confl) confl = propagate_xors(p);
}
EndPropagate:
propagations += num_props;
simpDB_props -= num_props;
return confl;
}
Clause* Solver::propagateBin()
{
while (qhead < trail.size()) {
Lit p = trail[qhead++];
vec<WatchedBin> & wbin = binwatches[p.toInt()];
propagations += wbin.size()/2;
for(WatchedBin *k = wbin.getData(), *end = wbin.getDataEnd(); k != end; k++) {
lbool val = value(k->impliedLit);
if (val.isUndef()) {
//uncheckedEnqueue(k->impliedLit, k->clause);
uncheckedEnqueueLight(k->impliedLit);
} else if (val == l_False) {
return k->clause;
}
}
}
return NULL;
}
Clause* Solver::propagateBinNoLearnts()
{
while (qhead < trail.size()) {
Lit p = trail[qhead++];
vec<WatchedBin> & wbin = binwatches[p.toInt()];
propagations += wbin.size()/2;
for(WatchedBin *k = wbin.getData(), *end = wbin.getDataEnd(); k != end; k++) {
if (k->clause->learnt()) continue;
lbool val = value(k->impliedLit);
if (val.isUndef()) {
//uncheckedEnqueue(k->impliedLit, k->clause);
uncheckedEnqueueLight(k->impliedLit);
} else if (val == l_False) {
return k->clause;
}
}
}
return NULL;
}
template<bool dontCareLearnt>
Clause* Solver::propagateBinExcept(const Lit& exceptLit)
{
while (qhead < trail.size()) {
Lit p = trail[qhead++];
vec<WatchedBin> & wbin = binwatches[p.toInt()];
propagations += wbin.size()/2;
for(WatchedBin *k = wbin.getData(), *end = wbin.getDataEnd(); k != end; k++) {
if (!dontCareLearnt && k->clause->learnt()) continue;
lbool val = value(k->impliedLit);
if (val.isUndef() && k->impliedLit != exceptLit) {
//uncheckedEnqueue(k->impliedLit, k->clause);
uncheckedEnqueueLight(k->impliedLit);
} else if (val == l_False) {
return k->clause;
}
}
}
return NULL;
}
template Clause* Solver::propagateBinExcept <true>(const Lit& exceptLit);
template Clause* Solver::propagateBinExcept <false>(const Lit& exceptLit);
template<bool dontCareLearnt>
Clause* Solver::propagateBinOneLevel()
{
Lit p = trail[qhead];
vec<WatchedBin> & wbin = binwatches[p.toInt()];
propagations += wbin.size()/2;
for(WatchedBin *k = wbin.getData(), *end = wbin.getDataEnd(); k != end; k++) {
if (!dontCareLearnt && k->clause->learnt()) continue;
lbool val = value(k->impliedLit);
if (val.isUndef()) {
//uncheckedEnqueue(k->impliedLit, k->clause);
uncheckedEnqueueLight(k->impliedLit);
} else if (val == l_False) {
return k->clause;
}
}
return NULL;
}
template Clause* Solver::propagateBinOneLevel <true>();
template Clause* Solver::propagateBinOneLevel <false>();
template<class T>
inline const uint32_t Solver::calcNBLevels(const T& ps)
{
MYFLAG++;
uint32_t nbLevels = 0;
for(const Lit *l = ps.getData(), *end = ps.getDataEnd(); l != end; l++) {
int32_t lev = level[l->var()];
if (permDiff[lev] != MYFLAG) {
permDiff[lev] = MYFLAG;
nbLevels++;
}
}
return nbLevels;
}
Clause* Solver::propagate_xors(const Lit& p)
{
#ifdef VERBOSE_DEBUG_XOR
cout << "Xor-Propagating variable " << p.var()+1 << endl;
#endif
Clause* confl = NULL;
vec<XorClausePtr>& ws = xorwatches[p.var()];
XorClausePtr *i, *j, *end;
for (i = j = ws.getData(), end = i + ws.size(); i != end;) {
XorClause& c = **i++;
if (i != end)
__builtin_prefetch(*i, 1, 0);
// Make sure the false literal is data[1]:
if (c[0].var() == p.var()) {
Lit tmp(c[0]);
c[0] = c[1];
c[1] = tmp;
}
assert(c[1].var() == p.var());
#ifdef VERBOSE_DEBUG_XOR
cout << "--> xor thing -- " << endl;
printClause(c);
cout << endl;
#endif
bool final = c.xor_clause_inverted();
for (uint32_t k = 0, size = c.size(); k != size; k++ ) {
const lbool& val = assigns[c[k].var()];
if (val.isUndef() && k >= 2) {
Lit tmp(c[1]);
c[1] = c[k];
c[k] = tmp;
#ifdef VERBOSE_DEBUG_XOR
cout << "new watch set" << endl << endl;
#endif
xorwatches[c[1].var()].push(&c);
goto FoundWatch;
}
c[k] = c[k].unsign() ^ val.getBool();
final ^= val.getBool();
}
{
// Did not find watch -- clause is unit under assignment:
*j++ = &c;
#ifdef VERBOSE_DEBUG_XOR
cout << "final: " << std::boolalpha << final << " - ";
#endif
if (assigns[c[0].var()].isUndef()) {
c[0] = c[0].unsign()^final;
#ifdef VERBOSE_DEBUG_XOR
cout << "propagating ";
printLit(c[0]);
cout << endl;
cout << "propagation clause -- ";
printClause(*(Clause*)&c);
cout << endl << endl;
#endif
uncheckedEnqueue(c[0], (Clause*)&c);
} else if (!final) {
#ifdef VERBOSE_DEBUG_XOR
printf("conflict clause -- ");
printClause(*(Clause*)&c);
cout << endl << endl;
#endif
confl = (Clause*)&c;
qhead = trail.size();
// Copy the remaining watches:
while (i < end)
*j++ = *i++;
} else {
#ifdef VERBOSE_DEBUG_XOR
printf("xor satisfied\n");
#endif
Lit tmp(c[0]);
c[0] = c[1];
c[1] = tmp;
}
}
FoundWatch:
;
}
ws.shrink_(i - j);
return confl;
}
/*_________________________________________________________________________________________________
|
| reduceDB : () -> [void]
|
| Description:
| Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
| clauses are clauses that are reason to some assignment. Binary clauses are never removed.
|________________________________________________________________________________________________@*/
bool reduceDB_ltMiniSat::operator () (const Clause* x, const Clause* y) {
const uint xsize = x->size();
const uint ysize = y->size();
// First criteria
if (xsize > 2 && ysize == 2) return 1;
if (ysize > 2 && xsize == 2) return 0;
if (x->oldActivity() == y->oldActivity())
return xsize > ysize;
else return x->oldActivity() < y->oldActivity();
}
bool reduceDB_ltGlucose::operator () (const Clause* x, const Clause* y) {
const uint xsize = x->size();
const uint ysize = y->size();
// First criteria
if (xsize > 2 && ysize == 2) return 1;
if (ysize > 2 && xsize == 2) return 0;
if (x->activity() > y->activity()) return 1;
if (x->activity() < y->activity()) return 0;
return xsize > ysize;
}
void Solver::reduceDB()
{
uint32_t i, j;
nbReduceDB++;
if (lastSelectedRestartType == dynamic_restart)
std::sort(learnts.getData(), learnts.getData()+learnts.size(), reduceDB_ltGlucose());
else
std::sort(learnts.getData(), learnts.getData()+learnts.size(), reduceDB_ltMiniSat());
#ifdef VERBOSE_DEBUG
std::cout << "Cleaning clauses" << std::endl;
for (uint i = 0; i != learnts.size(); i++) {
std::cout << "activity:" << learnts[i]->activity()
<< " \toldActivity:" << learnts[i]->oldActivity()
<< " \tsize:" << learnts[i]->size() << std::endl;
}
#endif
const uint removeNum = (double)learnts.size() / (double)RATIOREMOVECLAUSES;
for (i = j = 0; i != removeNum; i++){
//NOTE: The next instruciton only works if removeNum < learnts.size() (strictly smaller!!)
__builtin_prefetch(learnts[i+1], 0, 0);
if (learnts[i]->size() > 2 && !locked(*learnts[i]) && learnts[i]->activity() > 2) {
if (readdOldLearnts) {
detachClause(*learnts[i]);
removedLearnts.push(learnts[i]);
} else {
removeClause(*learnts[i]);
}
} else
learnts[j++] = learnts[i];
}
for (; i < learnts.size(); i++) {
learnts[j++] = learnts[i];
}
learnts.shrink(i - j);
}
const vec<Clause*>& Solver::get_learnts() const
{
return learnts;
}
const vec<Clause*>& Solver::get_sorted_learnts()
{
if (lastSelectedRestartType == dynamic_restart)
std::sort(learnts.getData(), learnts.getData()+learnts.size(), reduceDB_ltGlucose());
else
std::sort(learnts.getData(), learnts.getData()+learnts.size(), reduceDB_ltMiniSat());
return learnts;
}
const vector<Lit> Solver::get_unitary_learnts() const
{
vector<Lit> unitaries;
if (decisionLevel() > 0) {
for (uint32_t i = 0; i != trail_lim[0]; i++) {
unitaries.push_back(trail[i]);
}
}
return unitaries;
}
void Solver::dumpSortedLearnts(const char* file, const uint32_t maxSize)
{
FILE* outfile = fopen(file, "w");
if (!outfile) {
printf("Error: Cannot open file '%s' to write learnt clauses!\n", file);
exit(-1);
}
fprintf(outfile, "c \nc ---------\n");
fprintf(outfile, "c unitaries\n");
fprintf(outfile, "c ---------\n");
for (uint32_t i = 0, end = (trail_lim.size() > 0) ? trail_lim[0] : trail.size() ; i < end; i++) {
trail[i].printFull(outfile);
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
fprintf(outfile, "c name of var: %s\n", logger.get_var_name(trail[i].var()).c_str());
#endif //STATS_NEEDED
}
fprintf(outfile, "c conflicts %lu\n", (long unsigned int)conflicts);
fprintf(outfile, "c \nc ---------------------------------\n");
fprintf(outfile, "c learnt clauses from binaryClauses\n");
fprintf(outfile, "c ---------------------------------\n");
if (maxSize >= 2) {
for (uint i = 0; i != binaryClauses.size(); i++) {
if (binaryClauses[i]->learnt()) {
binaryClauses[i]->print(outfile);
}
}
}
fprintf(outfile, "c \nc ---------------------------------------\n");
fprintf(outfile, "c clauses representing 2-long XOR clauses\n");
fprintf(outfile, "c ---------------------------------------\n");
const vector<Lit>& table = varReplacer->getReplaceTable();
for (Var var = 0; var != table.size(); var++) {
Lit lit = table[var];
if (lit.var() == var)
continue;
fprintf(outfile, "%s%d %d 0\n", (!lit.sign() ? "-" : ""), lit.var()+1, var+1);
fprintf(outfile, "%s%d -%d 0\n", (lit.sign() ? "-" : ""), lit.var()+1, var+1);
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
fprintf(outfile, "c name of two vars that are anti/equivalent: '%s' and '%s'\n", logger.get_var_name(lit.var()).c_str(), logger.get_var_name(var).c_str());
#endif //STATS_NEEDED
}
fprintf(outfile, "c \nc --------------------n");
fprintf(outfile, "c clauses from learnts\n");
fprintf(outfile, "c --------------------n");
if (lastSelectedRestartType == dynamic_restart)
std::sort(learnts.getData(), learnts.getData()+learnts.size(), reduceDB_ltGlucose());
else
std::sort(learnts.getData(), learnts.getData()+learnts.size(), reduceDB_ltMiniSat());
for (int i = learnts.size()-1; i >= 0 ; i--) {
if (learnts[i]->size() <= maxSize) {
learnts[i]->print(outfile);
}
}
fclose(outfile);
}
const uint32_t Solver::getNumElimSubsume() const
{
return subsumer->getNumElimed();
}
const uint32_t Solver::getNumElimXorSubsume() const
{
return xorSubsumer->getNumElimed();
}
const uint32_t Solver::getNumXorTrees() const
{
return varReplacer->getNumTrees();
}
const uint32_t Solver::getNumXorTreesCrownSize() const
{
return varReplacer->getNumReplacedVars();
}
const double Solver::getTotalTimeSubsumer() const
{
return subsumer->getTotalTime();
}
const double Solver::getTotalTimeXorSubsumer() const
{
return xorSubsumer->getTotalTime();
}
void Solver::setMaxRestarts(const uint num)
{
maxRestarts = num;
}
inline int64_t abs64(int64_t a)
{
if (a < 0) return -a;
return a;
}
/*_________________________________________________________________________________________________
|
| simplify : [void] -> [bool]
|
| Description:
| Simplify the clause database according to the current top-level assigment. Currently, the only
| thing done here is the removal of satisfied clauses, but more things can be put here.
|________________________________________________________________________________________________@*/
const bool Solver::simplify()
{
testAllClauseAttach();
assert(decisionLevel() == 0);
if (!ok || propagate() != NULL) {
ok = false;
return false;
}
if (simpDB_props > 0) {
return true;
}
double slowdown = (100000.0/(double)binaryClauses.size());
slowdown = std::min(3.5, slowdown);
slowdown = std::max(0.2, slowdown);
double speedup = 50000000.0/(double)(propagations-lastSearchForBinaryXor);
speedup = std::min(3.5, speedup);
speedup = std::max(0.2, speedup);
/*std::cout << "new:" << nbBin - lastNbBin + becameBinary << std::endl;
std::cout << "left:" << ((double)(nbBin - lastNbBin + becameBinary)/BINARY_TO_XOR_APPROX) * slowdown << std::endl;
std::cout << "right:" << (double)order_heap.size() * PERCENTAGEPERFORMREPLACE * speedup << std::endl;*/
if (findBinaryXors && regularlyFindBinaryXors &&
(((double)abs64((int64_t)nbBin - (int64_t)lastNbBin + (int64_t)becameBinary)/BINARY_TO_XOR_APPROX) * slowdown) >
((double)order_heap.size() * PERCENTAGEPERFORMREPLACE * speedup)) {
lastSearchForBinaryXor = propagations;
clauseCleaner->cleanClauses(clauses, ClauseCleaner::clauses);
clauseCleaner->cleanClauses(learnts, ClauseCleaner::learnts);
clauseCleaner->removeSatisfied(binaryClauses, ClauseCleaner::binaryClauses);
if (!ok) return false;
testAllClauseAttach();
XorFinder xorFinder(*this, binaryClauses, ClauseCleaner::binaryClauses);
if (!xorFinder.doNoPart(2, 2)) return false;
testAllClauseAttach();
lastNbBin = nbBin;
becameBinary = 0;
}
// Remove satisfied clauses:
clauseCleaner->removeAndCleanAll();
testAllClauseAttach();
if (!ok) return false;
if (performReplace && !varReplacer->performReplace())
return false;
// Remove fixed variables from the variable heap:
order_heap.filter(VarFilter(*this));
#ifdef USE_GAUSS
for (vector<Gaussian*>::iterator gauss = gauss_matrixes.begin(), end = gauss_matrixes.end(); gauss != end; gauss++) {
if (!(*gauss)->full_init()) return false;
}
#endif //USE_GAUSS
simpDB_assigns = nAssigns();
simpDB_props = clauses_literals + learnts_literals; // (shouldn't depend on stats really, but it will do for now)
testAllClauseAttach();
return true;
}
/*_________________________________________________________________________________________________
|
| 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_conflicts_fullrestart, const bool update)
{
assert(ok);
int conflictC = 0;
vec<Lit> learnt_clause;
llbool ret;
starts++;
if (restartType == static_restart)
staticStarts++;
else
dynStarts++;
#ifdef USE_GAUSS
for (vector<Gaussian*>::iterator gauss = gauss_matrixes.begin(), end = gauss_matrixes.end(); gauss != end; gauss++) {
if (!(*gauss)->full_init())
return l_False;
}
#endif //USE_GAUSS
testAllClauseAttach();
findAllAttach();
for (;;) {
Clause* confl = propagate(update);
if (confl != NULL) {
ret = handle_conflict(learnt_clause, confl, conflictC, update);
if (ret != l_Nothing) return ret;
} else {
#ifdef USE_GAUSS
bool at_least_one_continue = false;
for (vector<Gaussian*>::iterator gauss = gauss_matrixes.begin(), end= gauss_matrixes.end(); gauss != end; gauss++) {
ret = (*gauss)->find_truths(learnt_clause, conflictC);
if (ret == l_Continue) at_least_one_continue = true;
else if (ret != l_Nothing) return ret;
}
if (at_least_one_continue) continue;
#endif //USE_GAUSS
ret = new_decision(nof_conflicts, nof_conflicts_fullrestart, conflictC);
if (ret != l_Nothing) return ret;
}
}
}
llbool Solver::new_decision(const int& nof_conflicts, const int& nof_conflicts_fullrestart, int& conflictC)
{
// Reached bound on number of conflicts?
switch (restartType) {
case dynamic_restart:
if (nbDecisionLevelHistory.isvalid() &&
((nbDecisionLevelHistory.getavg()) > (totalSumOfDecisionLevel / (double)(conflicts - conflictsAtLastSolve)))) {
#ifdef DEBUG_DYNAMIC_RESTART
if (nbDecisionLevelHistory.isvalid()) {
std::cout << "nbDecisionLevelHistory.getavg():" << nbDecisionLevelHistory.getavg() <<std::endl;
//std::cout << "calculated limit:" << ((double)(nbDecisionLevelHistory.getavg())*0.9*((double)fullStarts + 20.0)/20.0) << std::endl;
std::cout << "totalSumOfDecisionLevel:" << totalSumOfDecisionLevel << std::endl;
std::cout << "conflicts:" << conflicts<< std::endl;
std::cout << "conflictsAtLastSolve:" << conflictsAtLastSolve << std::endl;
std::cout << "conflicts-conflictsAtLastSolve:" << conflicts-conflictsAtLastSolve<< std::endl;
std::cout << "fullStarts:" << fullStarts << std::endl;
}
#endif
nbDecisionLevelHistory.fastclear();
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
progress_estimate = progressEstimate();
#endif
cancelUntil(0);
return l_Undef;
}
break;
case static_restart:
if (nof_conflicts >= 0 && conflictC >= nof_conflicts) {
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
progress_estimate = progressEstimate();
#endif
cancelUntil(0);
return l_Undef;
}
break;
case auto_restart:
assert(false);
break;
}
if (nof_conflicts_fullrestart >= 0 && (int)conflicts >= nof_conflicts_fullrestart) {
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
progress_estimate = progressEstimate();
#endif
cancelUntil(0);
return l_Undef;
}
// Simplify the set of problem clauses:
if (decisionLevel() == 0 && !simplify()) {
return l_False;
}
// Reduce the set of learnt clauses:
if (conflicts >= curRestart * nbclausesbeforereduce + nbCompensateSubsumer) {
curRestart ++;
reduceDB();
nbclausesbeforereduce += 500;
}
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();
if (next == lit_Undef)
return l_True;
}
// Increase decision level and enqueue 'next'
assert(value(next) == l_Undef);
newDecisionLevel();
uncheckedEnqueue(next);
return l_Nothing;
}
llbool Solver::handle_conflict(vec<Lit>& learnt_clause, Clause* confl, int& conflictC, const bool update)
{
#ifdef VERBOSE_DEBUG
cout << "Handling conflict: ";
for (uint i = 0; i < learnt_clause.size(); i++)
cout << learnt_clause[i].var()+1 << ",";
cout << endl;
#endif
int backtrack_level;
uint32_t nbLevels;
conflicts++;
conflictC++;
if (decisionLevel() == 0)
return l_False;
learnt_clause.clear();
Clause* c = analyze(confl, learnt_clause, backtrack_level, nbLevels, update);
if (update) {
#ifdef RANDOM_LOOKAROUND_SEARCHSPACE
avgBranchDepth.push(decisionLevel());
#endif //RANDOM_LOOKAROUND_SEARCHSPACE
if (restartType == dynamic_restart)
nbDecisionLevelHistory.push(nbLevels);
totalSumOfDecisionLevel += nbLevels;
} else {
conflictsAtLastSolve++;
}
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
logger.conflict(Logger::simple_confl_type, backtrack_level, confl->getGroup(), learnt_clause);
#endif
cancelUntil(backtrack_level);
#ifdef VERBOSE_DEBUG
cout << "Learning:";
for (uint i = 0; i < learnt_clause.size(); i++) printLit(learnt_clause[i]), cout << " ";
cout << endl;
cout << "reverting var " << learnt_clause[0].var()+1 << " to " << !learnt_clause[0].sign() << endl;
#endif
assert(value(learnt_clause[0]) == l_Undef);
//Unitary learnt
if (learnt_clause.size() == 1) {
uncheckedEnqueue(learnt_clause[0]);
assert(backtrack_level == 0 && "Unit clause learnt, so must cancel until level 0, right?");
#ifdef VERBOSE_DEBUG
cout << "Unit clause learnt." << endl;
#endif
//Normal learnt
} else {
if (c) {
detachClause(*c);
for (uint32_t i = 0; i != learnt_clause.size(); i++)
(*c)[i] = learnt_clause[i];
c->resize(learnt_clause.size());
if (c->learnt()) {
if (c->activity() > nbLevels)
c->setActivity(nbLevels); // LS
if (c->size() == 2)
nbBin++;
}
c->setStrenghtened();
} else {
c = Clause_new(learnt_clause, learnt_clause_group++, true);
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis)
logger.set_group_name(c->getGroup(), "learnt clause");
#endif
if (c->size() > 2) {
learnts.push(c);
c->setActivity(nbLevels); // LS
} else {
binaryClauses.push(c);
nbBin++;
}
}
if (nbLevels <= 2) nbDL2++;
attachClause(*c);
uncheckedEnqueue(learnt_clause[0], c);
}
varDecayActivity();
if (update && restartType == static_restart) claDecayActivity();
return l_Nothing;
}
double Solver::progressEstimate() const
{
double progress = 0;
double F = 1.0 / nVars();
for (uint32_t i = 0; i <= decisionLevel(); i++) {
int beg = i == 0 ? 0 : trail_lim[i - 1];
int end = i == decisionLevel() ? trail.size() : trail_lim[i];
progress += pow(F, (int)i) * (end - beg);
}
return progress / nVars();
}
#ifdef USE_GAUSS
void Solver::print_gauss_sum_stats()
{
if (gauss_matrixes.size() == 0 && verbosity >= 2) {
printf(" no matrixes found |\n");
return;
}
uint called = 0;
uint useful_prop = 0;
uint useful_confl = 0;
uint disabled = 0;
for (vector<Gaussian*>::const_iterator gauss = gauss_matrixes.begin(), end= gauss_matrixes.end(); gauss != end; gauss++) {
disabled += (*gauss)->get_disabled();
called += (*gauss)->get_called();
useful_prop += (*gauss)->get_useful_prop();
useful_confl += (*gauss)->get_useful_confl();
sum_gauss_unit_truths += (*gauss)->get_unit_truths();
//gauss->print_stats();
//gauss->print_matrix_stats();
}
sum_gauss_called += called;
sum_gauss_confl += useful_confl;
sum_gauss_prop += useful_prop;
if (verbosity >= 2) {
if (called == 0) {
printf(" disabled |\n");
} else {
printf(" %3.0lf%% |", (double)useful_prop/(double)called*100.0);
printf(" %3.0lf%% |", (double)useful_confl/(double)called*100.0);
printf(" %3.0lf%% |\n", 100.0-(double)disabled/(double)gauss_matrixes.size()*100.0);
}
}
}
#endif //USE_GAUSS
const bool Solver::chooseRestartType(const uint& lastFullRestart)
{
uint relativeStart = starts - lastFullRestart;
if (relativeStart > RESTART_TYPE_DECIDER_FROM && relativeStart < RESTART_TYPE_DECIDER_UNTIL) {
if (fixRestartType == auto_restart)
restartTypeChooser->addInfo();
if (relativeStart == (RESTART_TYPE_DECIDER_UNTIL-1)) {
RestartType tmp;
if (fixRestartType == auto_restart)
tmp = restartTypeChooser->choose();
else
tmp = fixRestartType;
if (tmp == dynamic_restart) {
nbDecisionLevelHistory.fastclear();
nbDecisionLevelHistory.initSize(100);
if (verbosity >= 2)
printf("c | Decided on dynamic restart strategy |\n");
} else {
if (verbosity >= 2)
printf("c | Decided on static restart strategy |\n");
#ifdef USE_GAUSS
if (!matrixFinder->findMatrixes()) return false;
#endif //USE_GAUSS
}
lastSelectedRestartType = tmp;
restartType = tmp;
restartTypeChooser->reset();
}
}
return true;
}
inline void Solver::setDefaultRestartType()
{
if (fixRestartType != auto_restart) restartType = fixRestartType;
else restartType = static_restart;
if (restartType == dynamic_restart) {
nbDecisionLevelHistory.fastclear();
nbDecisionLevelHistory.initSize(100);
}
lastSelectedRestartType = restartType;
}
const lbool Solver::simplifyProblem(const uint32_t numConfls)
{
testAllClauseAttach();
#ifdef USE_GAUSS
bool gauss_was_cleared = (gauss_matrixes.size() == 0);
clearGaussMatrixes();
#endif //USE_GAUSS
StateSaver savedState(*this);;
#ifdef BURST_SEARCH
if (verbosity >= 2)
std::cout << "c | " << std::setw(24) << " "
<< "Simplifying problem for " << std::setw(8) << numConfls << " confls"
<< std::setw(24) << " |" << std::endl;
random_var_freq = 1;
simplifying = true;
uint64_t origConflicts = conflicts;
#endif //BURST_SEARCH
lbool status = l_Undef;
#ifdef BURST_SEARCH
restartType = static_restart;
while(status == l_Undef && conflicts-origConflicts < numConfls) {
printRestartStat();
status = search(100, -1, false);
starts--;
}
if (status != l_Undef)
goto end;
printRestartStat();
#endif //BURST_SEARCH
if (doXorSubsumption && !xorSubsumer->simplifyBySubsumption()) {
status = l_False;
goto end;
}
testAllClauseAttach();
if (failedVarSearch && !failedVarSearcher->search((nClauses() < 500000 && order_heap.size() < 50000) ? 9000000 : 3000000)) {
status = l_False;
goto end;
}
testAllClauseAttach();
if (regularRemoveUselessBins
&& !failedVarSearcher->removeUslessBinFull<false>()) {
status = l_False;
goto end;
}
if (regularSubsumeWithNonExistBinaries
&& !subsumer->subsumeWithBinaries(false)) {
status = l_False;
goto end;
}
if (doSubsumption && !subsumer->simplifyBySubsumption()) {
status = l_False;
goto end;
}
testAllClauseAttach();
/*if (findNormalXors && xorclauses.size() > 200 && clauses.size() < MAX_CLAUSENUM_XORFIND/8) {
XorFinder xorFinder(*this, clauses, ClauseCleaner::clauses);
if (!xorFinder.doNoPart(3, 7)) {
status = l_False;
goto end;
}
} else*/ if (xorclauses.size() <= 200 && xorclauses.size() > 0 && nClauses() > 10000) {
XorFinder x(*this, clauses, ClauseCleaner::clauses);
x.addAllXorAsNorm();
}
end:
#ifdef BURST_SEARCH
if (verbosity >= 2)
printf("c Simplifying finished |\n");
#endif //#ifdef BURST_SEARCH
savedState.restore();
simplifying = false;
#ifdef USE_GAUSS
if (status == l_Undef && !gauss_was_cleared && !matrixFinder->findMatrixes())
status = l_False;
#endif //USE_GAUSS
testAllClauseAttach();
return status;
}
const bool Solver::checkFullRestart(int& nof_conflicts, int& nof_conflicts_fullrestart, uint& lastFullRestart)
{
if (nof_conflicts_fullrestart > 0 && (int)conflicts >= nof_conflicts_fullrestart) {
#ifdef USE_GAUSS
clearGaussMatrixes();
#endif //USE_GAUSS
if (verbosity >= 2)
printf("c | Fully restarting |\n");
nof_conflicts = restart_first + (double)restart_first*restart_inc;
nof_conflicts_fullrestart = (double)nof_conflicts_fullrestart * FULLRESTART_MULTIPLIER_MULTIPLIER;
restartType = static_restart;
lastFullRestart = starts;
/*if (findNormalXors && clauses.size() < MAX_CLAUSENUM_XORFIND) {
XorFinder xorFinder(this, clauses, ClauseCleaner::clauses);
if (!xorFinder.doNoPart(3, 10))
return false;
}*/
if (doPartHandler && !partHandler->handle())
return false;
//calculateDefaultPolarities();
fullStarts++;
}
return true;
}
inline void Solver::performStepsBeforeSolve()
{
assert(qhead == trail.size());
testAllClauseAttach();
if (performReplace && !varReplacer->performReplace()) return;
if (conflicts == 0 && learnts.size() == 0
&& noLearntBinaries()) {
if (subsumeWithNonExistBinaries && !subsumer->subsumeWithBinaries(true)) return;
if (removeUselessBins && !failedVarSearcher->removeUslessBinFull<true>()) return;
}
if(!ok) return;
testAllClauseAttach();
if (doSubsumption
&& !libraryUsage
&& clauses.size() + binaryClauses.size() + learnts.size() < 4800000
&& !subsumer->simplifyBySubsumption())
return;
if (conflicts == 0 && learnts.size() == 0
&& noLearntBinaries()) {
if (subsumeWithNonExistBinaries && !subsumer->subsumeWithBinaries(true)) return;
if (removeUselessBins && !failedVarSearcher->removeUslessBinFull<true>()) return;
}
if(!ok) return;
testAllClauseAttach();
if (findBinaryXors && binaryClauses.size() < MAX_CLAUSENUM_XORFIND) {
XorFinder xorFinder(*this, binaryClauses, ClauseCleaner::binaryClauses);
if (!xorFinder.doNoPart(2, 2)) return;
if (performReplace && !varReplacer->performReplace(true)) return;
}
testAllClauseAttach();
if (findNormalXors && clauses.size() < MAX_CLAUSENUM_XORFIND) {
XorFinder xorFinder(*this, clauses, ClauseCleaner::clauses);
if (!xorFinder.doNoPart(3, 7)) return;
}
if (xorclauses.size() > 1) {
testAllClauseAttach();
if (doXorSubsumption && !xorSubsumer->simplifyBySubsumption())
return;
testAllClauseAttach();
if (performReplace && !varReplacer->performReplace())
return;
}
}
void Solver::checkSolution()
{
// Extend & check:
model.growTo(nVars());
for (Var var = 0; var != nVars(); var++) model[var] = value(var);
verifyModel();
model.clear();
}
lbool Solver::solve(const vec<Lit>& assumps)
{
#ifdef VERBOSE_DEBUG
std::cout << "Solver::solve() called" << std::endl;
#endif
if (!ok) return l_False;
assert(qhead == trail.size());
if (libraryCNFFile)
fprintf(libraryCNFFile, "c Solver::solve() called\n");
model.clear();
conflict.clear();
#ifdef USE_GAUSS
clearGaussMatrixes();
#endif //USE_GAUSS
setDefaultRestartType();
totalSumOfDecisionLevel = 0;
conflictsAtLastSolve = conflicts;
#ifdef RANDOM_LOOKAROUND_SEARCHSPACE
avgBranchDepth.fastclear();
avgBranchDepth.initSize(500);
#endif //RANDOM_LOOKAROUND_SEARCHSPACE
starts = 0;
assumps.copyTo(assumptions);
if(assumptions.size()>0 && varReplacer->getNumLastReplacedVars())
for (uint32_t i = 0; i != assumptions.size(); i++)
assumptions[i] = varReplacer->getReplaceTable()[assumptions[i].var()] ^ assumptions[i].sign();
int nof_conflicts = restart_first;
int nof_conflicts_fullrestart = restart_first * FULLRESTART_MULTIPLIER + conflicts;
//nof_conflicts_fullrestart = -1;
uint lastFullRestart = starts;
lbool status = l_Undef;
uint64_t nextSimplify = restart_first * SIMPLIFY_MULTIPLIER + conflicts;
if (nClauses() * learntsize_factor < nbclausesbeforereduce) {
if (nClauses() * learntsize_factor < nbclausesbeforereduce/2)
nbclausesbeforereduce = nbclausesbeforereduce/4;
else
nbclausesbeforereduce = (nClauses() * learntsize_factor)/2;
}
testAllClauseAttach();
findAllAttach();
if (conflicts == 0) {
performStepsBeforeSolve();
if (!ok) return l_False;
printStatHeader();
}
if(assumptions.size()>0 &&
(varReplacer->getNumLastReplacedVars() || subsumer->getNumElimed() || xorSubsumer->getNumElimed())) {
for (uint32_t i = 0; i != assumptions.size(); i++) {
assumptions[i] = varReplacer->getReplaceTable()[assumptions[i].var()] ^ assumptions[i].sign();
if (subsumer->getVarElimed()[assumptions[i].var()] && !subsumer->unEliminate(assumptions[i].var())) {
ok = false;
return l_False;
}
if (xorSubsumer->getVarElimed()[assumptions[i].var()] && !xorSubsumer->unEliminate(assumptions[i].var())) {
ok = false;
return l_False;
}
}
}
calculateDefaultPolarities();
// Search:
while (status == l_Undef && starts < maxRestarts) {
#ifdef DEBUG_VARELIM
assert(subsumer->checkElimedUnassigned());
assert(xorSubsumer->checkElimedUnassigned());
#endif //DEBUG_VARELIM
if (schedSimplification && conflicts >= nextSimplify) {
status = simplifyProblem(500);
nextSimplify = conflicts * 1.5;
if (status != l_Undef) break;
}
printRestartStat();
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis) {
logger.end(Logger::restarting);
logger.begin();
}
#endif
status = search(nof_conflicts, nof_conflicts_fullrestart);
nof_conflicts = (double)nof_conflicts * restart_inc;
if (status != l_Undef) break;
if (!checkFullRestart(nof_conflicts, nof_conflicts_fullrestart, lastFullRestart))
return l_False;
if (!chooseRestartType(lastFullRestart))
return l_False;
#ifdef RANDOM_LOOKAROUND_SEARCHSPACE
//if (avgBranchDepth.isvalid())
// std::cout << "avg branch depth:" << avgBranchDepth.getavg() << std::endl;
#endif //RANDOM_LOOKAROUND_SEARCHSPACE
}
printEndSearchStat();
#ifdef USE_GAUSS
for (uint i = 0; i < gauss_matrixes.size(); i++)
delete gauss_matrixes[i];
gauss_matrixes.clear();
#endif //USE_GAUSS
#ifdef VERBOSE_DEBUG
if (status == l_True)
std::cout << "Solution is SAT" << std::endl;
else if (status == l_False)
std::cout << "Solution is UNSAT" << std::endl;
else
std::cout << "Solutions is UNKNOWN" << std::endl;
#endif //VERBOSE_DEBUG
if (status == l_True) {
if (greedyUnbound) {
double time = cpuTime();
FindUndef finder(*this);
const uint unbounded = finder.unRoll();
if (verbosity >= 1)
printf("c Greedy unbounding :%5.2lf s, unbounded: %7d vars\n", cpuTime()-time, unbounded);
}
partHandler->addSavedState();
varReplacer->extendModelPossible();
#ifndef NDEBUG
checkSolution();
#endif
if (subsumer->getNumElimed() || xorSubsumer->getNumElimed()) {
#ifdef VERBOSE_DEBUG
std::cout << "Solution needs extension. Extending." << std::endl;
#endif //VERBOSE_DEBUG
Solver s;
s.doSubsumption = false;
s.performReplace = false;
s.findBinaryXors = false;
s.findNormalXors = false;
s.failedVarSearch = false;
s.conglomerateXors = false;
s.greedyUnbound = greedyUnbound;
for (Var var = 0; var < nVars(); var++) {
s.newVar(decision_var[var] || subsumer->getVarElimed()[var] || varReplacer->varHasBeenReplaced(var) || xorSubsumer->getVarElimed()[var]);
//assert(!(xorSubsumer->getVarElimed()[var] && (decision_var[var] || subsumer->getVarElimed()[var] || varReplacer->varHasBeenReplaced(var))));
if (value(var) != l_Undef) {
vec<Lit> tmp;
tmp.push(Lit(var, value(var) == l_False));
s.addClause(tmp);
}
}
varReplacer->extendModelImpossible(s);
subsumer->extendModel(s);
xorSubsumer->extendModel(s);
status = s.solve();
if (status != l_True) {
printf("c ERROR! Extension of model failed!\n");
assert(status == l_True);
exit(-1);
}
#ifdef VERBOSE_DEBUG
std::cout << "Solution extending finished." << std::endl;
#endif
for (Var var = 0; var < nVars(); var++) {
if (assigns[var] == l_Undef && s.model[var] != l_Undef) uncheckedEnqueue(Lit(var, s.model[var] == l_False));
}
ok = (propagate() == NULL);
if (!ok) {
printf("c ERROR! Extension of model failed!\n");
assert(ok);
exit(-1);
}
}
#ifndef NDEBUG
checkSolution();
#endif
//Copy model:
model.growTo(nVars());
for (Var var = 0; var != nVars(); var++) model[var] = value(var);
}
if (status == l_False) {
if (conflict.size() == 0)
ok = false;
}
#ifdef STATS_NEEDED
if (dynamic_behaviour_analysis) {
if (status == l_True)
logger.end(Logger::model_found);
else if (status == l_False)
logger.end(Logger::unsat_model_found);
else if (status == l_Undef)
logger.end(Logger::restarting);
}
#endif
#ifdef LS_STATS_NBBUMP
for(int i=0;i<learnts.size();i++)
printf("## %d %d %d\n", learnts[i]->size(),learnts[i]->activity(),
(uint)learnts[i]->nbBump());
#endif
cancelUntil(0);
if (doPartHandler && status != l_False) partHandler->readdRemovedClauses();
restartTypeChooser->reset();
#ifdef VERBOSE_DEBUG
std::cout << "Solver::solve() finished" << std::endl;
#endif
return status;
}
//=================================================================================================
// Debug methods:
bool Solver::verifyXorClauses(const vec<XorClause*>& cs) const
{
#ifdef VERBOSE_DEBUG
cout << "Checking xor-clauses whether they have been properly satisfied." << endl;;
#endif
bool failed = false;
for (uint32_t i = 0; i != xorclauses.size(); i++) {
XorClause& c = *xorclauses[i];
bool final = c.xor_clause_inverted();
#ifdef VERBOSE_DEBUG
XorClause* c2 = XorClause_new(c, c.xor_clause_inverted(), c.getGroup());
std::sort(c2->getData(), c2->getData()+ c2->size());
c2->plainPrint();
clauseFree(c2);
#endif
for (uint j = 0; j < c.size(); j++) {
assert(modelValue(c[j].unsign()) != l_Undef);
final ^= (modelValue(c[j].unsign()) == l_True);
}
if (!final) {
printf("unsatisfied clause: ");
xorclauses[i]->plainPrint();
failed = true;
}
}
return failed;
}
bool Solver::verifyClauses(const vec<Clause*>& cs) const
{
#ifdef VERBOSE_DEBUG
cout << "Checking clauses whether they have been properly satisfied." << endl;;
#endif
bool failed = false;
for (uint32_t i = 0; i != cs.size(); i++) {
Clause& c = *cs[i];
for (uint j = 0; j < c.size(); j++)
if (modelValue(c[j]) == l_True)
goto next;
printf("unsatisfied clause: ");
cs[i]->plainPrint();
failed = true;
next:
;
}
return failed;
}
void Solver::verifyModel()
{
assert(!verifyClauses(clauses));
assert(!verifyClauses(binaryClauses));
assert(!verifyXorClauses(xorclauses));
if (verbosity >=1)
printf("c Verified %d clauses.\n", clauses.size() + xorclauses.size());
}
void Solver::checkLiteralCount()
{
// Check that sizes are calculated correctly:
int cnt = 0;
for (uint32_t i = 0; i != clauses.size(); i++)
cnt += clauses[i]->size();
for (uint32_t i = 0; i != xorclauses.size(); i++)
cnt += xorclauses[i]->size();
if ((int)clauses_literals != cnt) {
fprintf(stderr, "literal count: %d, real value = %d\n", (int)clauses_literals, cnt);
assert((int)clauses_literals == cnt);
}
}
void Solver::printStatHeader() const
{
#ifdef STATS_NEEDED
if (verbosity >= 1 && !(dynamic_behaviour_analysis && logger.statistics_on)) {
#else
if (verbosity >= 1) {
#endif
printf("c ============================[ Search Statistics ]========================================\n");
printf("c | Conflicts | ORIGINAL | LEARNT | GAUSS |\n");
printf("c | | Vars Clauses Literals | Limit Clauses Lit/Cl | Prop Confl On |\n");
printf("c =========================================================================================\n");
}
}
void Solver::printRestartStat()
{
if (verbosity >= 2) {
printf("c | %9d | %7d %8d %8d | %8d %8d %6.0f |", (int)conflicts, (int)order_heap.size(), (int)(nClauses()-nbBin), (int)clauses_literals, (int)(nbclausesbeforereduce*curRestart+nbCompensateSubsumer), (int)(nLearnts()+nbBin), (double)learnts_literals/(double)(nLearnts()+nbBin));
}
#ifdef USE_GAUSS
print_gauss_sum_stats();
#else //USE_GAUSS
if (verbosity >= 2) {
printf(" |\n");
}
#endif //USE_GAUSS
}
void Solver::printEndSearchStat()
{
#ifdef STATS_NEEDED
if (verbosity >= 1 && !(dynamic_behaviour_analysis && logger.statistics_on)) {
#else
if (verbosity >= 1) {
#endif //STATS_NEEDED
printf("c ====================================================================");
#ifdef USE_GAUSS
print_gauss_sum_stats();
if (verbosity == 1) printf("=====================\n");
#else //USE_GAUSS
printf("\n");
#endif //USE_GAUSS
}
}
#ifdef DEBUG_ATTACH
void Solver::testAllClauseAttach() const
{
for (Clause *const*it = clauses.getData(), *const*end = clauses.getDataEnd(); it != end; it++) {
const Clause& c = **it;
if (c.size() > 2) {
assert(findWatchedCl(watches[(~c[0]).toInt()], &c));
assert(findWatchedCl(watches[(~c[1]).toInt()], &c));
} else {
assert(findWatchedBinCl(binwatches[(~c[0]).toInt()], &c));
assert(findWatchedBinCl(binwatches[(~c[1]).toInt()], &c));
}
}
for (Clause *const*it = binaryClauses.getData(), *const*end = binaryClauses.getDataEnd(); it != end; it++) {
const Clause& c = **it;
assert(c.size() == 2);
assert(findWatchedBinCl(binwatches[(~c[0]).toInt()], &c));
assert(findWatchedBinCl(binwatches[(~c[1]).toInt()], &c));
}
for (XorClause *const*it = xorclauses.getData(), *const*end = xorclauses.getDataEnd(); it != end; it++) {
const XorClause& c = **it;
assert(find(xorwatches[c[0].var()], &c));
assert(find(xorwatches[c[1].var()], &c));
if (assigns[c[0].var()]!=l_Undef || assigns[c[1].var()]!=l_Undef) {
for (uint i = 0; i < c.size();i++) {
assert(assigns[c[i].var()] != l_Undef);
}
}
}
}
void Solver::findAllAttach() const
{
for (uint32_t i = 0; i < binwatches.size(); i++) {
for (uint32_t i2 = 0; i2 < binwatches[i].size(); i2++) {
assert(findClause(binwatches[i][i2].clause));
}
}
for (uint32_t i = 0; i < watches.size(); i++) {
for (uint32_t i2 = 0; i2 < watches[i].size(); i2++) {
assert(findClause(watches[i][i2].clause));
}
}
for (uint32_t i = 0; i < xorwatches.size(); i++) {
for (uint32_t i2 = 0; i2 < xorwatches[i].size(); i2++) {
assert(findClause(xorwatches[i][i2]));
}
}
}
const bool Solver::findClause(XorClause* c) const
{
for (uint32_t i = 0; i < xorclauses.size(); i++) {
if (xorclauses[i] == c) return true;
}
return false;
}
const bool Solver::findClause(Clause* c) const
{
for (uint32_t i = 0; i < binaryClauses.size(); i++) {
if (binaryClauses[i] == c) return true;
}
for (uint32_t i = 0; i < clauses.size(); i++) {
if (clauses[i] == c) return true;
}
for (uint32_t i = 0; i < learnts.size(); i++) {
if (learnts[i] == c) return true;
}
vec<Clause*> cs = varReplacer->getClauses();
for (uint32_t i = 0; i < cs.size(); i++) {
if (cs[i] == c) return true;
}
return false;
}
#endif //DEBUG_ATTACH
const bool Solver::noLearntBinaries() const
{
for (uint32_t i = 0; i < binaryClauses.size(); i++) {
if (binaryClauses[i]->learnt()) return false;
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink