ruby-minisat 1.14.2

data/minisat/MiniSat_v1.14/Main.C

@@ -0,0 +1,244 @@
+/******************************************************************************************[Main.C]
+MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
+
+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 <ctime>
+#include <unistd.h>
+#include <signal.h>
+#include <zlib.h>
+
+
+//=================================================================================================
+// BCNF Parser:
+
+
+#define CHUNK_LIMIT 1048576
+
+static void parse_BCNF(cchar* filename, Solver& S)
+{
+    FILE*   in = fopen(filename, "rb");
+    if (in == NULL) fprintf(stderr, "ERROR! Could not open file: %s\n", filename), exit(1);
+
+    char    header[16];
+    fread(header, 1, 16, in);
+    if (strncmp(header, "BCNF", 4) != 0) fprintf(stderr, "ERROR! Not a BCNF file: %s\n", filename), exit(1);
+    if (*(int*)(header+4) != 0x01020304) fprintf(stderr, "ERROR! BCNF file in unsupported byte-order: %s\n", filename), exit(1);
+
+    int      n_vars    = *(int*)(header+ 8);
+    //int    n_clauses = *(int*)(header+12);
+    int*     buf       = xmalloc<int>(CHUNK_LIMIT);
+    int      buf_sz;
+    vec<Lit> c;
+
+    for (int i = 0; i < n_vars; i++) S.newVar();
+
+    for(;;){
+        int n = fread(&buf_sz, 4, 1, in);
+        if (n != 1) break;
+        assert(buf_sz <= CHUNK_LIMIT);
+        fread(buf, 4, buf_sz, in);
+
+        int* p = buf;
+        while (*p != -1){
+            int size = *p++;
+            c.clear();
+            c.growTo(size);
+            for (int i = 0; i < size; i++)
+                c[i] = toLit(p[i]);
+            p += size;
+
+            S.addClause(c);     // Add clause.
+            if (!S.okay()){
+                xfree(buf); fclose(in);
+                return; }
+        }
+    }
+
+    xfree(buf);
+    fclose(in);
+}
+
+
+//=================================================================================================
+// DIMACS Parser:
+
+
+class StreamBuffer {
+    gzFile  in;
+    char    buf[CHUNK_LIMIT];
+    int     pos;
+    int     size;
+
+    void assureLookahead() {
+        if (pos >= size) {
+            pos  = 0;
+            size = gzread(in, buf, sizeof(buf)); } }
+
+public:
+    StreamBuffer(gzFile i) : in(i), pos(0), size(0) {
+        assureLookahead(); }
+
+    int  operator *  () { return (pos >= size) ? EOF : buf[pos]; }
+    void operator ++ () { pos++; assureLookahead(); }
+};
+
+//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+template<class B>
+static void skipWhitespace(B& in) {
+    while ((*in >= 9 && *in <= 13) || *in == 32)
+        ++in; }
+
+template<class B>
+static void skipLine(B& in) {
+    for (;;){
+        if (*in == EOF) return;
+        if (*in == '\n') { ++in; return; }
+        ++in; } }
+
+template<class B>
+static int parseInt(B& in) {
+    int     val = 0;
+    bool    neg = false;
+    skipWhitespace(in);
+    if      (*in == '-') neg = true, ++in;
+    else if (*in == '+') ++in;
+    if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+    while (*in >= '0' && *in <= '9')
+        val = val*10 + (*in - '0'),
+        ++in;
+    return neg ? -val : val; }
+
+template<class B>
+static void readClause(B& in, Solver& S, vec<Lit>& lits) {
+    int     parsed_lit, var;
+    lits.clear();
+    for (;;){
+        parsed_lit = parseInt(in);
+        if (parsed_lit == 0) break;
+        var = abs(parsed_lit)-1;
+        while (var >= S.nVars()) S.newVar();
+        lits.push( (parsed_lit > 0) ? Lit(var) : ~Lit(var) );
+    }
+}
+
+template<class B>
+static void parse_DIMACS_main(B& in, Solver& S) {
+    vec<Lit> lits;
+    for (;;){
+        skipWhitespace(in);
+        if (*in == EOF)
+            break;
+        else if (*in == 'c' || *in == 'p')
+            skipLine(in);
+        else
+            readClause(in, S, lits),
+            S.addClause(lits);
+    }
+}
+
+// Inserts problem into solver.
+//
+static void parse_DIMACS(gzFile input_stream, Solver& S) {
+    StreamBuffer in(input_stream);
+    parse_DIMACS_main(in, S); }
+
+
+//=================================================================================================
+
+
+void printStats(SolverStats& stats)
+{
+    double  cpu_time = cpuTime();
+    int64   mem_used = memUsed();
+    reportf("restarts              : %"I64_fmt"\n", stats.starts);
+    reportf("conflicts             : %-12"I64_fmt"   (%.0f /sec)\n", stats.conflicts   , stats.conflicts   /cpu_time);
+    reportf("decisions             : %-12"I64_fmt"   (%.0f /sec)\n", stats.decisions   , stats.decisions   /cpu_time);
+    reportf("propagations          : %-12"I64_fmt"   (%.0f /sec)\n", stats.propagations, stats.propagations/cpu_time);
+    reportf("conflict literals     : %-12"I64_fmt"   (%4.2f %% deleted)\n", stats.tot_literals, (stats.max_literals - stats.tot_literals)*100 / (double)stats.max_literals);
+    if (mem_used != 0) reportf("Memory used           : %.2f MB\n", mem_used / 1048576.0);
+    reportf("CPU time              : %g s\n", cpu_time);
+}
+
+Solver* solver;
+static void SIGINT_handler(int signum) {
+    reportf("\n"); reportf("*** INTERRUPTED ***\n");
+    printStats(solver->stats);
+    reportf("\n"); reportf("*** INTERRUPTED ***\n");
+    exit(1); }
+
+
+//=================================================================================================
+// Main:
+
+
+int main(int argc, char** argv)
+{
+    Solver      S;
+
+    if (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0))
+        reportf("USAGE: %s <input-file> <result-output-file>\n  where the input may be either in plain/gzipped DIMACS format or in BCNF.\n", argv[0]),
+        exit(0);
+
+    if (argc >= 2 && strlen(argv[1]) >= 5 && strcmp(&argv[1][strlen(argv[1])-5], ".bcnf") == 0)
+        parse_BCNF(argv[1], S);
+    else{
+        if (argc == 1)
+            reportf("Reading from standard input... Use '-h' or '--help' for help.\n");
+
+        gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
+        if (in == NULL)
+            fprintf(stderr, "ERROR! Could not open file: %s\n", argc == 1 ? "<stdin>" : argv[1]),
+            exit(1);
+        parse_DIMACS(in, S);
+        gzclose(in);
+    }
+    FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL;
+
+    if (!S.okay()){
+        if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res);
+        reportf("Trivial problem\n");
+        reportf("UNSATISFIABLE\n");
+        exit(20);
+    }
+
+    S.verbosity = 1;
+    solver = &S;
+    signal(SIGINT,SIGINT_handler);
+    signal(SIGHUP,SIGINT_handler);
+
+    S.solve();
+    printStats(S.stats);
+    reportf("\n");
+    reportf(S.okay() ? "SATISFIABLE\n" : "UNSATISFIABLE\n");
+
+    if (res != NULL){
+        if (S.okay()){
+            fprintf(res, "SAT\n");
+            for (int i = 0; i < S.nVars(); i++)
+                if (S.model[i] != l_Undef)
+                    fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
+            fprintf(res, " 0\n");
+        }else
+            fprintf(res, "UNSAT\n");
+        fclose(res);
+    }
+
+    exit(S.okay() ? 10 : 20);     // (faster than "return", which will invoke the destructor for 'Solver')
+}

data/minisat/MiniSat_v1.14/Makefile

@@ -0,0 +1,88 @@
+##
+##  Makefile for Standard, Profile, Debug, Release, and Release-static versions of MiniSat
+##
+##    eg: "make rs" for a statically linked release version.
+##        "make d"  for a debug version (no optimizations).
+##        "make"    for the standard version (optimized, but with debug information and assertions active)
+
+CSRCS     = $(wildcard *.C)
+CHDRS     = $(wildcard *.h)
+COBJS     = $(addsuffix .o, $(basename $(CSRCS)))
+
+PCOBJS    = $(addsuffix p,  $(COBJS))
+DCOBJS    = $(addsuffix d,  $(COBJS))
+RCOBJS    = $(addsuffix r,  $(COBJS))
+
+EXEC      = minisat
+
+CXX       = g++
+CFLAGS    = -Wall -ffloat-store
+COPTIMIZE = -O3
+
+
+.PHONY : s p d r build clean depend
+
+s:	WAY=standard
+p:	WAY=profile
+d:	WAY=debug
+r:	WAY=release
+rs:	WAY=release static
+
+s:	CFLAGS+=$(COPTIMIZE) -ggdb -D DEBUG
+p:	CFLAGS+=$(COPTIMIZE) -pg -ggdb -D DEBUG
+d:	CFLAGS+=-O0 -ggdb -D DEBUG
+r:	CFLAGS+=$(COPTIMIZE) -D NDEBUG
+rs:	CFLAGS+=$(COPTIMIZE) -D NDEBUG
+
+s:	build $(EXEC)
+p:	build $(EXEC)_profile
+d:	build $(EXEC)_debug
+r:	build $(EXEC)_release
+rs:	build $(EXEC)_static
+
+build:
+	@echo Building $(EXEC) "("$(WAY)")"
+
+clean:
+	@rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \
+	  $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) depend.mak
+
+## Build rule
+%.o %.op %.od %.or:	%.C
+	@echo Compiling: $<
+	@$(CXX) $(CFLAGS) -c -o $@ $<
+
+## Linking rules (standard/profile/debug/release)
+$(EXEC): $(COBJS)
+	@echo Linking $(EXEC)
+	@$(CXX) $(COBJS) -lz -ggdb -Wall -o $@ 
+
+$(EXEC)_profile: $(PCOBJS)
+	@echo Linking $@
+	@$(CXX) $(PCOBJS) -lz -ggdb -Wall -pg -o $@
+
+$(EXEC)_debug:	$(DCOBJS)
+	@echo Linking $@
+	@$(CXX) $(DCOBJS) -lz -ggdb -Wall -o $@
+
+$(EXEC)_release: $(RCOBJS)
+	@echo Linking $@
+	@$(CXX) $(RCOBJS) -lz -Wall -o $@
+
+$(EXEC)_static: $(RCOBJS)
+	@echo Linking $@
+	@$(CXX) --static $(RCOBJS) -lz -Wall -o $@
+
+
+## Make dependencies
+depend:	depend.mak
+depend.mak: $(CSRCS) $(CHDRS)
+	@echo Making dependencies ...
+	@$(CXX) -MM $(CSRCS) > depend.mak
+	@cp depend.mak /tmp/depend.mak.tmp
+	@sed "s/o:/op:/" /tmp/depend.mak.tmp >> depend.mak
+	@sed "s/o:/od:/" /tmp/depend.mak.tmp >> depend.mak
+	@sed "s/o:/or:/" /tmp/depend.mak.tmp >> depend.mak
+	@rm /tmp/depend.mak.tmp
+
+include depend.mak

data/minisat/MiniSat_v1.14/README

@@ -0,0 +1,30 @@
+MiniSat v1.14 / MiniSat-p v1.14
+========================================
+
+This version is a cleaned up version of the MiniSat solver entering
+the SAT 2005 competition.  Some of the most low-level optimization has
+been removed for the sake of clarity, resulting in a 5-10% performance
+degradation. The guard on "too-many-calls" in 'simplifyDB()' has also
+been improved. If uttermost performance is needed, use the competition
+version, also available at the MiniSat page
+(www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/).
+
+Several things has changed inside MiniSat since the first version,
+documented in the paper "An Extensible SAT Solver". The most important
+is the lack of support for non-clausal constraints in this
+version. Please use MiniSat v1.12b if you need this. Other changes are
+special treatment of binary clauses for efficiency (messes up the code
+a bit, but gives quite a speedup), improved variable order (still
+VSIDS based, but works MUCH better than in previous MiniSat
+versions!), conflict clause minimization (by Niklas S�rensson), and a
+better Main module (for those of you who use MiniSat as a stand-alone
+solver).
+
+The MiniSat-p version also supports proof logging, sacrificing the
+binary clauses trick for clarity (some 10-20% slower). For
+scalability, we decided to keep the proof only on disk. This frees up
+memory for the working set of conflict clauses, and allows for
+bigger-than-memory proofs to be produced (which can happen, even if
+you garbage collect the proof).
+
+For information about upcomming changes, please review the TODO file.

data/minisat/MiniSat_v1.14/Solver.C

@@ -0,0 +1,781 @@
+/****************************************************************************************[Solver.C]
+MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
+
+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 "Sort.h"
+#include <cmath>
+
+
+//=================================================================================================
+// Helper functions:
+
+
+bool removeWatch(vec<GClause>& ws, GClause elem)    // Pre-condition: 'elem' must exists in 'ws' OR 'ws' must be empty.
+{
+    if (ws.size() == 0) return false;     // (skip lists that are already cleared)
+    int j = 0;
+    for (; ws[j] != elem  ; j++) assert(j < ws.size());
+    for (; j < ws.size()-1; j++) ws[j] = ws[j+1];
+    ws.pop();
+    return true;
+}
+
+
+//=================================================================================================
+// Operations on clauses:
+
+
+/*_________________________________________________________________________________________________
+|
+|  newClause : (ps : const vec<Lit>&) (learnt : bool)  ->  [void]
+|  
+|  Description:
+|    Allocate and add a new clause to the SAT solvers clause database. If a conflict is detected,
+|    the 'ok' flag is cleared and the solver is in an unusable state (must be disposed).
+|  
+|  Input:
+|    ps     - The new clause as a vector of literals.
+|    learnt - Is the clause a learnt clause? For learnt clauses, 'ps[0]' is assumed to be the
+|             asserting literal. An appropriate 'enqueue()' operation will be performed on this
+|             literal. One of the watches will always be on this literal, the other will be set to
+|             the literal with the highest decision level.
+|  
+|  Effect:
+|    Activity heuristics are updated.
+|________________________________________________________________________________________________@*/
+void Solver::newClause(const vec<Lit>& ps_, bool learnt)
+{
+    if (!ok) return;
+
+    vec<Lit>    qs;
+    if (!learnt){
+        assert(decisionLevel() == 0);
+        ps_.copyTo(qs);             // Make a copy of the input vector.
+
+        // Remove duplicates:
+        sortUnique(qs);
+
+        // Check if clause is satisfied:
+        for (int i = 0; i < qs.size()-1; i++){
+            if (qs[i] == ~qs[i+1])
+                return; }
+        for (int i = 0; i < qs.size(); i++){
+            if (value(qs[i]) == l_True)
+                return; }
+
+        // Remove false literals:
+        int     i, j;
+        for (i = j = 0; i < qs.size(); i++)
+            if (value(qs[i]) != l_False)
+                qs[j++] = qs[i];
+        qs.shrink(i - j);
+    }
+    const vec<Lit>& ps = learnt ? ps_ : qs;     // 'ps' is now the (possibly) reduced vector of literals.
+
+    if (ps.size() == 0){
+        ok = false;
+
+    }else if (ps.size() == 1){
+        // NOTE: If enqueue takes place at root level, the assignment will be lost in incremental use (it doesn't seem to hurt much though).
+        if (!enqueue(ps[0]))
+            ok = false;
+
+    }else if (ps.size() == 2){
+        // Create special binary clause watch:
+        watches[index(~ps[0])].push(GClause_new(ps[1]));
+        watches[index(~ps[1])].push(GClause_new(ps[0]));
+
+        if (learnt){
+            check(enqueue(ps[0], GClause_new(~ps[1])));
+            stats.learnts_literals += ps.size();
+        }else
+            stats.clauses_literals += ps.size();
+        n_bin_clauses++;
+
+    }else{
+        // Allocate clause:
+        Clause* c   = Clause_new(learnt, ps);
+
+        if (learnt){
+            // Put the second watch on the literal with highest decision level:
+            int     max_i = 1;
+            int     max   = level[var(ps[1])];
+            for (int i = 2; i < ps.size(); i++)
+                if (level[var(ps[i])] > max)
+                    max   = level[var(ps[i])],
+                    max_i = i;
+            (*c)[1]     = ps[max_i];
+            (*c)[max_i] = ps[1];
+
+            // Bump, enqueue, store clause:
+            claBumpActivity(c);         // (newly learnt clauses should be considered active)
+            check(enqueue((*c)[0], GClause_new(c)));
+            learnts.push(c);
+            stats.learnts_literals += c->size();
+        }else{
+            // Store clause:
+            clauses.push(c);
+            stats.clauses_literals += c->size();
+        }
+        // Watch clause:
+        watches[index(~(*c)[0])].push(GClause_new(c));
+        watches[index(~(*c)[1])].push(GClause_new(c));
+    }
+}
+
+
+// Disposes a clauses and removes it from watcher lists. NOTE! Low-level; does NOT change the 'clauses' and 'learnts' vector.
+//
+void Solver::remove(Clause* c, bool just_dealloc)
+{
+    if (!just_dealloc){
+        if (c->size() == 2)
+            removeWatch(watches[index(~(*c)[0])], GClause_new((*c)[1])),
+            removeWatch(watches[index(~(*c)[1])], GClause_new((*c)[0]));
+        else
+            removeWatch(watches[index(~(*c)[0])], GClause_new(c)),
+            removeWatch(watches[index(~(*c)[1])], GClause_new(c));
+    }
+
+    if (c->learnt()) stats.learnts_literals -= c->size();
+    else             stats.clauses_literals -= c->size();
+
+    xfree(c);
+}
+
+
+// Can assume everything has been propagated! (esp. the first two literals are != l_False, unless
+// the clause is binary and satisfied, in which case the first literal is true)
+// Returns True if clause is satisfied (will be removed), False otherwise.
+//
+bool Solver::simplify(Clause* c) const
+{
+    assert(decisionLevel() == 0);
+    for (int i = 0; i < c->size(); i++){
+        if (value((*c)[i]) == l_True)
+            return true;
+    }
+    return false;
+}
+
+
+//=================================================================================================
+// 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() {
+    int     index;
+    index = nVars();
+    watches     .push();          // (list for positive literal)
+    watches     .push();          // (list for negative literal)
+    reason      .push(GClause_NULL);
+    assigns     .push(toInt(l_Undef));
+    level       .push(-1);
+    activity    .push(0);
+    order       .newVar();
+    analyze_seen.push(0);
+    return index; }
+
+
+// Returns FALSE if immediate conflict.
+bool Solver::assume(Lit p) {
+    trail_lim.push(trail.size());
+    return enqueue(p); }
+
+
+// Revert to the state at given level.
+void Solver::cancelUntil(int level) {
+    if (decisionLevel() > level){
+        for (int c = trail.size()-1; c >= trail_lim[level]; c--){
+            Var     x  = var(trail[c]);
+            assigns[x] = toInt(l_Undef);
+            reason [x] = GClause_NULL;
+            order.undo(x); }
+        trail.shrink(trail.size() - trail_lim[level]);
+        trail_lim.shrink(trail_lim.size() - level);
+        qhead = trail.size(); } }
+
+
+//=================================================================================================
+// Major methods:
+
+
+/*_________________________________________________________________________________________________
+|
+|  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.
+|________________________________________________________________________________________________@*/
+void Solver::analyze(Clause* _confl, vec<Lit>& out_learnt, int& out_btlevel)
+{
+    GClause confl = GClause_new(_confl);
+    vec<char>&     seen  = analyze_seen;
+    int            pathC = 0;
+    Lit            p     = lit_Undef;
+
+    // Generate conflict clause:
+    //
+    out_learnt.push();      // (leave room for the asserting literal)
+    out_btlevel = 0;
+    int index = trail.size()-1;
+    do{
+        assert(confl != GClause_NULL);          // (otherwise should be UIP)
+
+        Clause& c = confl.isLit() ? ((*analyze_tmpbin)[1] = confl.lit(), *analyze_tmpbin)
+                                  : *confl.clause();
+        if (c.learnt())
+            claBumpActivity(&c);
+
+        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
+            Lit q = c[j];
+            if (!seen[var(q)] && level[var(q)] > 0){
+                varBumpActivity(q);
+                seen[var(q)] = 1;
+                if (level[var(q)] == decisionLevel())
+                    pathC++;
+                else{
+                    out_learnt.push(q);
+                    out_btlevel = max(out_btlevel, level[var(q)]);
+                }
+            }
+        }
+
+        // Select next clause to look at:
+        while (!seen[var(trail[index--])]);
+        p     = trail[index+1];
+        confl = reason[var(p)];
+        seen[var(p)] = 0;
+        pathC--;
+
+    }while (pathC > 0);
+    out_learnt[0] = ~p;
+
+    int     i, j;
+    if (expensive_ccmin){
+        // Simplify conflict clause (a lot):
+        //
+        uint    min_level = 0;
+        for (i = 1; i < out_learnt.size(); i++)
+            min_level |= 1 << (level[var(out_learnt[i])] & 31);         // (maintain an abstraction of levels involved in conflict)
+
+        out_learnt.copyTo(analyze_toclear);
+        for (i = j = 1; i < out_learnt.size(); i++)
+            if (reason[var(out_learnt[i])] == GClause_NULL || !analyze_removable(out_learnt[i], min_level))
+                out_learnt[j++] = out_learnt[i];
+    }else{
+        // Simplify conflict clause (a little):
+        //
+        out_learnt.copyTo(analyze_toclear);
+        for (i = j = 1; i < out_learnt.size(); i++){
+            GClause r = reason[var(out_learnt[i])];
+            if (r == GClause_NULL)
+                out_learnt[j++] = out_learnt[i];
+            else if (r.isLit()){
+                Lit q = r.lit();
+                if (!seen[var(q)] && level[var(q)] != 0)
+                    out_learnt[j++] = out_learnt[i];
+            }else{
+                Clause& c = *r.clause();
+                for (int k = 1; k < c.size(); k++)
+                    if (!seen[var(c[k])] && level[var(c[k])] != 0){
+                        out_learnt[j++] = out_learnt[i];
+                        break; }
+            }
+        }
+    }
+
+    stats.max_literals += out_learnt.size();
+    out_learnt.shrink(i - j);
+    stats.tot_literals += out_learnt.size();
+
+    for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;    // ('seen[]' is now cleared)
+}
+
+
+// Check if 'p' can be removed. 'min_level' is used to abort early if visiting literals at a level that cannot be removed.
+//
+bool Solver::analyze_removable(Lit p, uint min_level)
+{
+    assert(reason[var(p)] != GClause_NULL);
+    analyze_stack.clear(); analyze_stack.push(p);
+    int top = analyze_toclear.size();
+    while (analyze_stack.size() > 0){
+        assert(reason[var(analyze_stack.last())] != GClause_NULL);
+        GClause r = reason[var(analyze_stack.last())]; analyze_stack.pop();
+        Clause& c = r.isLit() ? ((*analyze_tmpbin)[1] = r.lit(), *analyze_tmpbin)
+                              : *r.clause();
+        for (int i = 1; i < c.size(); i++){
+            Lit p = c[i];
+            if (!analyze_seen[var(p)] && level[var(p)] != 0){
+                if (reason[var(p)] != GClause_NULL && ((1 << (level[var(p)] & 31)) & min_level) != 0){
+                    analyze_seen[var(p)] = 1;
+                    analyze_stack.push(p);
+                    analyze_toclear.push(p);
+                }else{
+                    for (int j = top; j < analyze_toclear.size(); j++)
+                        analyze_seen[var(analyze_toclear[j])] = 0;
+                    analyze_toclear.shrink(analyze_toclear.size() - top);
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (confl : Clause*) (skip_first : bool)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    'root_level' is allowed to point beyond end of trace (useful if called after conflict while
+|    making assumptions). If 'skip_first' is TRUE, the first literal of 'confl' is  ignored (needed
+|    if conflict arose before search even started).
+|________________________________________________________________________________________________@*/
+void Solver::analyzeFinal(Clause* confl, bool skip_first)
+{
+    // -- NOTE! This code is relatively untested. Please report bugs!
+    conflict.clear();
+    if (root_level == 0) return;
+
+    vec<char>&     seen  = analyze_seen;
+    for (int i = skip_first ? 1 : 0; i < confl->size(); i++){
+        Var     x = var((*confl)[i]);
+        if (level[x] > 0)
+            seen[x] = 1;
+    }
+
+    int     start = (root_level >= trail_lim.size()) ? trail.size()-1 : trail_lim[root_level];
+    for (int i = start; i >= trail_lim[0]; i--){
+        Var     x = var(trail[i]);
+        if (seen[x]){
+            GClause r = reason[x];
+            if (r == GClause_NULL){
+                assert(level[x] > 0);
+                conflict.push(~trail[i]);
+            }else{
+                if (r.isLit()){
+                    Lit p = r.lit();
+                    if (level[var(p)] > 0)
+                        seen[var(p)] = 1;
+                }else{
+                    Clause& c = *r.clause();
+                    for (int j = 1; j < c.size(); j++)
+                        if (level[var(c[j])] > 0)
+                            seen[var(c[j])] = 1;
+                }
+            }
+            seen[x] = 0;
+        }
+    }
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  enqueue : (p : Lit) (from : Clause*)  ->  [bool]
+|  
+|  Description:
+|    Puts a new fact on the propagation queue as well as immediately updating the variable's value.
+|    Should a conflict arise, FALSE is returned.
+|  
+|  Input:
+|    p    - The fact to enqueue
+|    from - [Optional] Fact propagated from this (currently) unit clause. Stored in 'reason[]'.
+|           Default value is NULL (no reason).
+|  
+|  Output:
+|    TRUE if fact was enqueued without conflict, FALSE otherwise.
+|________________________________________________________________________________________________@*/
+bool Solver::enqueue(Lit p, GClause from)
+{
+    if (value(p) != l_Undef)
+        return value(p) != l_False;
+    else{
+        assigns[var(p)] = toInt(lbool(!sign(p)));
+        level  [var(p)] = decisionLevel();
+        reason [var(p)] = from;
+        trail.push(p);
+        return true;
+    }
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  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()
+{
+    Clause* confl = NULL;
+    while (qhead < trail.size()){
+        stats.propagations++;
+        simpDB_props--;
+
+        Lit            p   = trail[qhead++];     // 'p' is enqueued fact to propagate.
+        vec<GClause>&  ws  = watches[index(p)];
+        GClause*       i,* j, *end;
+
+        for (i = j = (GClause*)ws, end = i + ws.size();  i != end;){
+            if (i->isLit()){
+                if (!enqueue(i->lit(), GClause_new(p))){
+                    if (decisionLevel() == 0)
+                        ok = false;
+                    confl = propagate_tmpbin;
+                    (*confl)[1] = ~p;
+                    (*confl)[0] = i->lit();
+
+                    qhead = trail.size();
+                    // Copy the remaining watches:
+                    while (i < end)
+                        *j++ = *i++;
+                }else
+                    *j++ = *i++;
+            }else{
+                Clause& c = *i->clause(); i++;
+                assert(c.size() > 2);
+                // Make sure the false literal is data[1]:
+                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.
+                Lit   first = c[0];
+                lbool val   = value(first);
+                if (val == l_True){
+                    *j++ = GClause_new(&c);
+                }else{
+                    // Look for new watch:
+                    for (int k = 2; k < c.size(); k++)
+                        if (value(c[k]) != l_False){
+                            c[1] = c[k]; c[k] = false_lit;
+                            watches[index(~c[1])].push(GClause_new(&c));
+                            goto FoundWatch; }
+
+                    // Did not find watch -- clause is unit under assignment:
+                    *j++ = GClause_new(&c);
+                    if (!enqueue(first, GClause_new(&c))){
+                        if (decisionLevel() == 0)
+                            ok = false;
+                        confl = &c;
+                        qhead = trail.size();
+                        // Copy the remaining watches:
+                        while (i < end)
+                            *j++ = *i++;
+                    }
+                  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.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt { bool operator () (Clause* x, Clause* y) { return x->size() > 2 && (y->size() == 2 || x->activity() < y->activity()); } };
+void Solver::reduceDB()
+{
+    int     i, j;
+    double  extra_lim = cla_inc / learnts.size();    // Remove any clause below this activity
+
+    sort(learnts, reduceDB_lt());
+    for (i = j = 0; i < learnts.size() / 2; i++){
+        if (learnts[i]->size() > 2 && !locked(learnts[i]))
+            remove(learnts[i]);
+        else
+            learnts[j++] = learnts[i];
+    }
+    for (; i < learnts.size(); i++){
+        if (learnts[i]->size() > 2 && !locked(learnts[i]) && learnts[i]->activity() < extra_lim)
+            remove(learnts[i]);
+        else
+            learnts[j++] = learnts[i];
+    }
+    learnts.shrink(i - j);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  simplifyDB : [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.
+|________________________________________________________________________________________________@*/
+void Solver::simplifyDB()
+{
+    if (!ok) return;    // GUARD (public method)
+    assert(decisionLevel() == 0);
+
+    if (propagate() != NULL){
+        ok = false;
+        return; }
+
+    if (nAssigns() == simpDB_assigns || simpDB_props > 0)   // (nothing has changed or preformed a simplification too recently)
+        return;
+
+    // Clear watcher lists:
+    for (int i = simpDB_assigns; i < nAssigns(); i++){
+        Lit           p  = trail[i];
+        vec<GClause>& ws = watches[index(~p)];
+        for (int j = 0; j < ws.size(); j++)
+            if (ws[j].isLit())
+                if (removeWatch(watches[index(~ws[j].lit())], GClause_new(p)))  // (remove binary GClause from "other" watcher list)
+                    n_bin_clauses--;
+        watches[index( p)].clear(true);
+        watches[index(~p)].clear(true);
+    }
+
+    // Remove satisfied clauses:
+    for (int type = 0; type < 2; type++){
+        vec<Clause*>& cs = type ? learnts : clauses;
+        int     j  = 0;
+        for (int i = 0; i < cs.size(); i++){
+            if (!locked(cs[i]) && simplify(cs[i]))  // (the test for 'locked()' is currently superfluous, but without it the reason-graph is not correctly maintained for decision level 0)
+                remove(cs[i]);
+            else
+                cs[j++] = cs[i];
+        }
+        cs.shrink(cs.size()-j);
+    }
+
+    simpDB_assigns = nAssigns();
+    simpDB_props   = stats.clauses_literals + stats.learnts_literals;   // (shouldn't depend on 'stats' really, but it will do for now)
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  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, const SearchParams& params)
+{
+    if (!ok) return l_False;    // GUARD (public method)
+    assert(root_level == decisionLevel());
+
+    stats.starts++;
+    int     conflictC = 0;
+    var_decay = 1 / params.var_decay;
+    cla_decay = 1 / params.clause_decay;
+    model.clear();
+
+    for (;;){
+        Clause* confl = propagate();
+        if (confl != NULL){
+            // CONFLICT
+
+            stats.conflicts++; conflictC++;
+            vec<Lit>    learnt_clause;
+            int         backtrack_level;
+            if (decisionLevel() == root_level){
+                // Contradiction found:
+                analyzeFinal(confl);
+                return l_False; }
+            analyze(confl, learnt_clause, backtrack_level);
+            cancelUntil(max(backtrack_level, root_level));
+            newClause(learnt_clause, true);
+            if (learnt_clause.size() == 1) level[var(learnt_clause[0])] = 0;    // (this is ugly (but needed for 'analyzeFinal()') -- in future versions, we will backtrack past the 'root_level' and redo the assumptions)
+            varDecayActivity();
+            claDecayActivity();
+
+        }else{
+            // NO CONFLICT
+
+            if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
+                // Reached bound on number of conflicts:
+                progress_estimate = progressEstimate();
+                cancelUntil(root_level);
+                return l_Undef; }
+
+            if (decisionLevel() == 0)
+                // Simplify the set of problem clauses:
+                simplifyDB(), assert(ok);
+
+            if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts)
+                // Reduce the set of learnt clauses:
+                reduceDB();
+
+            // New variable decision:
+            stats.decisions++;
+            Var next = order.select(params.random_var_freq);
+
+            if (next == var_Undef){
+                // Model found:
+                model.growTo(nVars());
+                for (int i = 0; i < nVars(); i++) model[i] = value(i);
+                cancelUntil(root_level);
+                return l_True;
+            }
+
+            check(assume(~Lit(next)));
+        }
+    }
+}
+
+
+// Return search-space coverage. Not extremely reliable.
+//
+double Solver::progressEstimate()
+{
+    double  progress = 0;
+    double  F = 1.0 / nVars();
+    for (int i = 0; i < nVars(); i++)
+        if (value(i) != l_Undef)
+            progress += pow(F, level[i]);
+    return progress / nVars();
+}
+
+
+// Divide all variable activities by 1e100.
+//
+void Solver::varRescaleActivity()
+{
+    for (int i = 0; i < nVars(); i++)
+        activity[i] *= 1e-100;
+    var_inc *= 1e-100;
+}
+
+
+// Divide all constraint activities by 1e100.
+//
+void Solver::claRescaleActivity()
+{
+    for (int i = 0; i < learnts.size(); i++)
+        learnts[i]->activity() *= 1e-20;
+    cla_inc *= 1e-20;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  solve : (assumps : const vec<Lit>&)  ->  [bool]
+|  
+|  Description:
+|    Top-level solve. If using assumptions (non-empty 'assumps' vector), you must call
+|    'simplifyDB()' first to see that no top-level conflict is present (which would put the solver
+|    in an undefined state).
+|________________________________________________________________________________________________@*/
+bool Solver::solve(const vec<Lit>& assumps)
+{
+    simplifyDB();
+    if (!ok) return false;
+
+    SearchParams    params(default_params);
+    double  nof_conflicts = 100;
+    double  nof_learnts   = nClauses() / 3;
+    lbool   status        = l_Undef;
+
+    // Perform assumptions:
+    root_level = assumps.size();
+    for (int i = 0; i < assumps.size(); i++){
+        Lit p = assumps[i];
+        assert(var(p) < nVars());
+        if (!assume(p)){
+            GClause r = reason[var(p)];
+            if (r != GClause_NULL){
+                Clause* confl;
+                if (r.isLit()){
+                    confl = propagate_tmpbin;
+                    (*confl)[1] = ~p;
+                    (*confl)[0] = r.lit();
+                }else
+                    confl = r.clause();
+                analyzeFinal(confl, true);
+                conflict.push(~p);
+            }else
+                conflict.clear(),
+                conflict.push(~p);
+            cancelUntil(0);
+            return false; }
+        Clause* confl = propagate();
+        if (confl != NULL){
+            analyzeFinal(confl), assert(conflict.size() > 0);
+            cancelUntil(0);
+            return false; }
+    }
+    assert(root_level == decisionLevel());
+
+    // Search:
+    if (verbosity >= 1){
+        reportf("==================================[MINISAT]===================================\n");
+        reportf("| Conflicts |     ORIGINAL     |              LEARNT              | Progress |\n");
+        reportf("|           | Clauses Literals |   Limit Clauses Literals  Lit/Cl |          |\n");
+        reportf("==============================================================================\n");
+    }
+
+    while (status == l_Undef){
+        if (verbosity >= 1)
+            reportf("| %9d | %7d %8d | %7d %7d %8d %7.1f | %6.3f %% |\n", (int)stats.conflicts, nClauses(), (int)stats.clauses_literals, (int)nof_learnts, nLearnts(), (int)stats.learnts_literals, (double)stats.learnts_literals/nLearnts(), progress_estimate*100);
+        status = search((int)nof_conflicts, (int)nof_learnts, params);
+        nof_conflicts *= 1.5;
+        nof_learnts   *= 1.1;
+    }
+    if (verbosity >= 1)
+        reportf("==============================================================================\n");
+
+    cancelUntil(0);
+    return status == l_True;
+}