ruby-minisat 1.14.2

data/examples/slitherlink.sample

@@ -0,0 +1,11 @@
+# quoted from PencilBox (http://pencilbox.sourceforge.jp/)
+3 2 . . 3 2 . . 2 0
+. . 2 1 . . 3 2 . .
+3 . . . 2 . . . 2 .
+. 1 3 . . 3 1 . . 3
+. . . 0 1 . . 3 1 1
+1 1 2 . . 3 3 . . .
+3 . . 3 2 . . 2 1 .
+. 2 . . . 1 . . . 3
+. . 0 1 . . 1 3 . .
+2 2 . . 2 3 . . 1 2

data/examples/sudoku.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+
+# ruby-minisat example -- sudoku.rb
+# ref: http://en.wikipedia.org/wiki/Sudoku
+
+##
+## SAT configuration:
+##   - Variables: assign to each cell the same number variables as puzzle size
+##   - Clauses: sudoku rules (below)
+##
+##
+## sudoku basic rules:
+##   - rule 1. There is at least one number in each entry
+##   - rule 2. Each number appears at most once in each row
+##   - rule 3. Each number appears at most once in each column
+##   - rule 4. Each number appears at most once in each sub-grid
+##
+## sudoku auxiliary rules (for speed up):
+##   - auxiliary rule 1. There is at most one number in each entry
+##   - auxiliary rule 2. Each number appears at least once in each row
+##   - auxiliary rule 3. Each number appears at least once in each column
+##   - auxiliary rule 4. Each number appears at least once in each sub-grid
+##
+##
+## see [1] in detail.
+##
+## [1] I. Lynce, and J. Ouaknine.  Sudoku as a SAT Problem.  Proceedings of the
+##     Ninth International Symposium on Artificial Intelligence and Mathematics
+##     (AIMATH 2006), Jan. 2006
+##
+
+require "minisat"
+require File.dirname($0) + "/compat18" if RUBY_VERSION < "1.9.0"
+
+
+def error(msg)
+  $stderr.puts msg
+  exit 1
+end
+
+
+def parse_file(file)
+  s_puzz = w_grid = h_grid = nil
+  field = []
+  File.read(file).split(/\n/).each do |line|
+    case line
+    when /^\s*#.*$/, /^\s*$/
+    when /^\s*grid-size\s*:\s*(\d+)x(\d+)\s*$/
+      w_grid = $1.to_i
+      h_grid = $2.to_i
+    else
+      line = line.split.map {|n| n.to_i }
+      s_puzz ||= line.size
+      unless s_puzz == line.size
+        error "illegal width: row #{ field.size + 1 }"
+      end
+      field << line
+    end
+  end
+  error "illegal height" unless field.size == s_puzz
+  unless w_grid * h_grid == s_puzz
+    error "illegal size: #{ s_puzz } != #{ w_grid } * #{ h_grid }"
+  end
+
+  a_puzz = (0...s_puzz).to_a
+  a_grid = (0...s_puzz).step(w_grid).to_a.
+             product((0...s_puzz).step(h_grid).to_a)
+  a_off = (0...w_grid).to_a.product((0...h_grid).to_a)
+
+  [a_puzz, a_grid, a_off, field]
+end
+
+
+def define_sat(solver, a_puzz, a_grid, a_off, field)
+  # define variables
+  vars = a_puzz.map {|x| a_puzz.map {|y| a_puzz.map {|z| solver.new_var }}}
+
+  # define clauses
+  a_puzz.each do |x|
+    a_puzz.each do |y|
+      # rule 1
+      solver << a_puzz.map {|z| vars[x][y][z] }
+
+      # auxiliary rule 1
+      a_puzz.combination(2) do |z1, z2|
+        solver << [-vars[x][y][z1], -vars[x][y][z2]]
+      end
+    end
+  end
+  a_puzz.each do |z|
+    a_puzz.each do |i|
+      a_puzz.combination(2) do |j, k|
+        # rule 2
+        solver << [-vars[j][i][z], -vars[k][i][z]]
+
+        # rule 3
+        solver << [-vars[i][j][z], -vars[i][k][z]]
+      end
+
+      # auxiliary rule 2
+      solver << a_puzz.map {|j| vars[j][i][z] }
+
+      # auxiliary rule 3
+      solver << a_puzz.map {|j| vars[i][j][z] }
+    end
+
+    a_grid.each do |xg, yg|
+      a_off.combination(2) do |(xo1, yo1), (xo2, yo2)|
+        # rule 4
+        solver << [-vars[xg + xo1][yg + yo1][z], -vars[xg + xo2][yg + yo2][z]]
+      end
+
+      # auxiliary rule 4
+      solver << a_off.map {|xo, yo| vars[xg + xo][yg + yo][z] }
+    end
+  end
+
+  vars
+end
+
+
+def make_assumptions(vars, a_puzz, a_grid, a_off, field)
+  # translate fixed cells into assumption
+  assumps = []
+
+  field.zip(a_puzz) do |line, y|
+    line.zip(a_puzz) do |n, x|
+      next if n == 0
+      a_puzz.each do |z|
+        v = vars[x][y][z]
+        assumps << (z == n - 1 ? v : -v)
+      end
+    end
+  end
+
+  assumps
+end
+
+
+def solve_sat(solver, assumps)
+  start = Time.now
+  result = solver.solve(*assumps)
+  eplise = Time.now - start
+  puts "time: %.6f sec." % eplise
+  result
+end
+
+
+def make_solution(solver, vars, a_puzz, a_grid, a_off, field)
+  a_puzz.map do |y|
+    a_puzz.map do |x|
+      1 + a_puzz.find {|z| solver[vars[x][y][z]] }
+    end
+  end
+end
+
+
+def add_constraint(solver, vars)
+  solver << vars.flatten.map {|v| solver[v] ? -v : v }
+end
+
+
+def output_field(field)
+  puts field.map {|l| "  " + l.map {|c| c == 0 ? "." : c }.join(" ") }
+end
+
+
+
+error "usage: sudoku.rb sudoku.sample" if ARGV.empty?
+
+ARGV.each do |file|
+  sudoku = parse_file(file)
+  puts "problem:"
+  output_field(sudoku.last)
+  puts
+
+  solver = MiniSat::Solver.new
+
+  puts "defining SAT..."
+  vars = define_sat(solver, *sudoku)
+  puts "variables : #{ solver.var_size }"
+  puts "clauses : #{ solver.clause_size }"
+  puts
+
+  puts "translating fixed cells into assumptions..."
+  assumps = make_assumptions(vars, *sudoku)
+  puts "assumptions : #{ assumps.size }"
+  puts
+
+  puts "solving SAT..."
+  result = solve_sat(solver, assumps)
+  puts "result: " + (result ? "solvable" : "unsolvable")
+  puts
+  next unless result
+
+  puts "translating model into solution..."
+  solution = make_solution(solver, vars, *sudoku)
+  puts "solution found:"
+  output_field(solution)
+  puts
+
+  puts "checking different solution..."
+  add_constraint(solver, vars)
+  result = solve_sat(solver, assumps)
+  puts "result: " +
+    (result ? "different solution found" : "different solution not found")
+  puts
+  next unless result
+
+  puts "translating model into solution..."
+  solution = make_solution(solver, vars, *sudoku)
+  puts "different solution:"
+  output_field(solution)
+  puts
+  puts
+end

data/examples/sudoku.sample

@@ -0,0 +1,11 @@
+# quoted from PencilBox (http://pencilbox.sourceforge.jp/)
+grid-size: 3x3
+1 . . . . . . . 3
+. 9 . . 5 . . 4 .
+. . 8 . . 7 9 . .
+. . . 3 . 1 2 . .
+. 6 . . . . . 1 .
+. . 9 4 . 8 . . .
+. . 1 6 . . 8 . .
+. 4 . . 9 . . 6 .
+2 . . . . . . . 1

data/ext/minisat/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+CONFIG["CXX"] ||= "g++"
+MINISAT_DIR = File.join(File.dirname(__FILE__), "../../minisat/MiniSat_v1.14")
+
+minisat_include, _ = dir_config("minisat", MINISAT_DIR, "")
+$objs = ["minisat.o", "minisat-wrap.o", minisat_include + "/Solver.o"]
+
+create_makefile("minisat") if have_library("stdc++")

data/ext/minisat/minisat-wrap.cpp

@@ -0,0 +1,88 @@
+/******************************************************************************
+
+  ruby-minisat -- ruby binding for MiniSat
+
+*******************************************************************************
+
+The MIT License
+
+Copyright (c) 2007 Yusuke Endoh
+
+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 "minisat.h"
+
+/***** variable **************************************************************/
+
+extern "C" int wrap_lit_pos_var(int v) {
+    return index(Lit(v, false));
+}
+
+extern "C" int wrap_lit_neg_var(int v) {
+    return index(Lit(v, true));
+}
+
+/***** solver ****************************************************************/
+
+extern "C" wrap_solver wrap_solver_new() {
+    return (wrap_solver) new Solver();
+}
+
+extern "C" void wrap_solver_free(wrap_solver slv) {
+    delete (Solver*) slv;
+}
+
+extern "C" int wrap_solver_new_var(wrap_solver slv) {
+    return ((Solver*) slv)->newVar();
+}
+
+extern "C" int wrap_solver_add_clause(wrap_solver slv, int *lits, int len) {
+    vec<Lit> lit_vec;
+    for(int i = 0; i < len; i++) lit_vec.push(toLit(lits[i]));
+    ((Solver*) slv)->addClause(lit_vec);
+    return ((Solver*) slv)->okay() ? 1 : 0;
+}
+
+extern "C" int wrap_solver_ref_var(wrap_solver slv, int var) {
+    lbool b = ((Solver*) slv)->model[var];
+    return (b == l_False) ? 0 : (b == l_True) ? 1 : 2;
+}
+
+extern "C" int wrap_solver_solve(wrap_solver slv, int *lits, int len) {
+    vec<Lit> lit_vec;
+    for(int i = 0; i < len; i++) lit_vec.push(toLit(lits[i]));
+    return ((Solver*) slv)->solve(lit_vec) ? 1 : 0;
+}
+
+extern "C" int wrap_solver_simplify_db(wrap_solver slv) {
+    ((Solver*) slv)->simplifyDB();
+    return ((Solver*) slv)->okay() ? 1 : 0;
+}
+
+extern "C" int wrap_solver_var_size(wrap_solver slv) {
+    return ((Solver*) slv)->nVars();
+}
+
+extern "C" int wrap_solver_clause_size(wrap_solver slv) {
+    return ((Solver*) slv)->nClauses();
+}

data/ext/minisat/minisat.c

@@ -0,0 +1,497 @@
+/******************************************************************************
+
+  ruby-minisat -- ruby binding for MiniSat
+
+*******************************************************************************
+
+The MIT License
+
+Copyright (c) 2007, 2010 Yusuke Endoh
+
+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.
+
+******************************************************************************/
+
+/*
+ * Author:: Yusuke Endoh
+ * Date:: 2010/07/07
+ * Copyright:: Copyright (c) 2007, 2010 Yusuke Endoh
+ */
+
+#include "ruby.h"
+#include "minisat.h"
+
+VALUE rb_mMiniSat, rb_cSolver, rb_cVariable, rb_cLiteral;
+
+#define SATISFIED                       0 /* satisfied */
+#define NOT_SOLVED_YET                  1 /* not solved yet */
+#define UNSATISFIABLE                   2 /* always unsatisfiable */
+#define UNSATISFIABLE_UNDER_ASSUMPTIONS 3 /* unsatisfiable under assumptions */
+
+/***** type def **************************************************************/
+
+typedef struct csolver_tag {
+    wrap_solver *solver;
+    int result;
+    int clause_count;
+} csolver;
+
+typedef struct cvariable_tag {
+    int value;
+    VALUE solver;
+} cvariable;
+
+static void check_model_available(int result, int check_only_unsatisfied)
+{
+    switch(result) {
+        case NOT_SOLVED_YET:
+            if(!check_only_unsatisfied) {
+              rb_raise(rb_eRuntimeError, "not solved yet");
+            }
+            break;
+        case UNSATISFIABLE:
+            rb_raise(rb_eRuntimeError, "unsatisfied");
+            break;
+        case UNSATISFIABLE_UNDER_ASSUMPTIONS:
+            if(!check_only_unsatisfied) {
+              rb_raise(rb_eRuntimeError, "unsatisfied under assumption");
+            }
+            break;
+    }
+}
+
+
+/***** variable **************************************************************/
+
+static void value_free(cvariable *cvar)
+{
+    free(cvar);
+}
+
+static void value_mark(cvariable *cval)
+{
+    rb_gc_mark(cval->solver);
+}
+
+/*
+ *  call-seq:
+ *     +variable   -> Literal
+ *
+ *  Returns positive literal of variable.
+ *
+ */
+static VALUE variable_pos(VALUE rvar)
+{
+    cvariable *cvar, *clit;
+    VALUE rlit;
+
+    Data_Get_Struct(rvar, cvariable, cvar);
+    rlit = Data_Make_Struct(rb_cLiteral, cvariable, value_mark, value_free, clit);
+    clit->value = wrap_lit_pos_var(cvar->value);
+    clit->solver = cvar->solver;
+    if(OBJ_TAINTED(rvar)) OBJ_TAINT(rlit);
+
+    return rlit;
+}
+
+/*
+ *  call-seq:
+ *     -variable   -> Literal
+ *
+ *  Returns negative literal of variable.
+ *
+ */
+static VALUE variable_neg(VALUE rvar)
+{
+    cvariable *cvar, *clit;
+    VALUE rlit;
+
+    Data_Get_Struct(rvar, cvariable, cvar);
+    rlit = Data_Make_Struct(rb_cLiteral, cvariable, value_mark, value_free, clit);
+    clit->value = wrap_lit_neg_var(cvar->value);
+    clit->solver = cvar->solver;
+    if(OBJ_TAINTED(rvar)) OBJ_TAINT(rlit);
+
+    return rlit;
+}
+
+/*
+ *  call-seq:
+ *     variable.value   -> true or false
+ *
+ *  Returns an assignment if the SAT is satisfiable.  Raises an exception when
+ *  the SAT is not satisfied.
+ *
+ */
+static VALUE variable_value(VALUE rvar)
+{
+    cvariable *cvar;
+    csolver *cslv;
+
+    Data_Get_Struct(rvar, cvariable, cvar);
+    Data_Get_Struct(cvar->solver, csolver, cslv);
+    check_model_available(cslv->result, 0);
+    switch(wrap_solver_ref_var(cslv->solver, cvar->value)) {
+        case 0: return Qfalse;
+        case 1: return Qtrue;
+    }
+
+    return Qnil;
+}
+
+static void convert_lits(int *lits, int argc, VALUE *argv, VALUE rslv)
+{
+    int i;
+    VALUE rval;
+    cvariable *cval;
+
+    for(i = 0; i < argc; i++) {
+        rval = argv[i];
+        if(TYPE(rval) != T_DATA
+           || RDATA(rval)->dfree != (RUBY_DATA_FUNC)value_free) {
+            rb_raise(rb_eTypeError,
+                     "wrong argument type %s (expected Variable or Literal)",
+                     rb_obj_classname(rval));
+        }
+        Data_Get_Struct(rval, cvariable, cval);
+        if(cval->solver != rslv) {
+            rb_raise(rb_eArgError,
+                     "Variable or Literal of different solver");
+        }
+        lits[i] = (CLASS_OF(rval) == rb_cVariable) ?
+                     wrap_lit_pos_var(cval->value) : cval->value;
+    }
+}
+
+
+/***** solver ****************************************************************/
+
+static void solver_free(csolver *cslv)
+{
+    wrap_solver_free(cslv->solver);
+    free(cslv);
+}
+
+static VALUE solver_alloc(VALUE klass)
+{
+    csolver *cslv;
+    VALUE rslv;
+
+    rslv = Data_Make_Struct(klass, csolver, NULL, solver_free, cslv);
+    cslv->solver = wrap_solver_new();
+    cslv->result = NOT_SOLVED_YET;
+
+    return rslv;
+}
+
+/*
+ *  call-seq:
+ *     solver.new_var   -> Variable
+ *
+ *  Returns new variable for constructing SAT formula.  Raises an exception when
+ *  the SAT is already prove to be always unsatisfiable.
+ *
+ */
+static VALUE solver_new_var(VALUE rslv)
+{
+    csolver *cslv;
+    cvariable *cvar;
+    VALUE rvar;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+    check_model_available(cslv->result, 1);
+    rvar =
+      Data_Make_Struct(rb_cVariable, cvariable, value_mark, value_free, cvar);
+    cvar->value = wrap_solver_new_var(cslv->solver);
+    cvar->solver = rslv;
+    cslv->result = NOT_SOLVED_YET;
+    if(OBJ_TAINTED(rslv)) OBJ_TAINT(rvar);
+
+    return rvar;
+}
+
+/*
+ *  call-seq:
+ *     solver.add_clause(var, lit,...)   -> solver
+ *
+ *  Adds clause consisting of the literals to the SAT and returns solver
+ *  itself.  If Variables are passed, they are handled as its positive Literal.
+ *  The SAT may be automatically proved to be always unsatisfiable just after
+ *  the clause added.  In the case, <code>solver.solved?</code> becomes to
+ *  return true.
+ *
+ *     solver.add_clause(a, b, -c)  # add clause: (a or b or not c)
+ *
+ */
+static VALUE solver_add_clause(int argc, VALUE *argv, VALUE rslv)
+{
+    csolver *cslv;
+    int *lits;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+    lits = ALLOCA_N(int, argc);
+    convert_lits(lits, argc, argv, rslv);
+    if(!wrap_solver_add_clause(cslv->solver, lits, argc)) {
+        cslv->result = UNSATISFIABLE;
+    }
+    else {
+        cslv->result = NOT_SOLVED_YET;
+        cslv->clause_count++;
+    }
+
+    return rslv;
+}
+
+/*
+ *  call-seq:
+ *     solver << var_or_lit_or_ary   -> solver
+ *
+ *  Almost same as Solver#add_caluse.  This method receives Array of Variable
+ *  or Literal.
+ *
+ *     solver << a          # equivalent to solver.add_clause(a)
+ *     solver << [a, b, -c] # equivalent to solver.add_clause(a, b, -c)
+ *
+ */
+static VALUE solver_add_clause_2(VALUE rslv, VALUE rcls)
+{
+    if(TYPE(rcls) == T_DATA
+       && RDATA(rcls)->dfree == (RUBY_DATA_FUNC)value_free) {
+      return solver_add_clause(1, &rcls, rslv);
+    }
+    else {
+      rcls = rb_convert_type(rcls, T_ARRAY, "Array", "to_ary");
+      return solver_add_clause(RARRAY_LEN(rcls), RARRAY_PTR(rcls), rslv);
+    }
+}
+
+/*
+ *  call-seq:
+ *     solver[var]   -> true or false
+ *
+ *  Returns a value of specified variable if the SAT is satisfied.  Raises an
+ *  exception if not.
+ *
+ */
+static VALUE solver_ref_var(VALUE rslv, VALUE rvar)
+{
+    csolver *cslv;
+    cvariable *cvar;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+    if(CLASS_OF(rvar) != rb_cVariable) {
+        rb_raise(rb_eTypeError,
+                 "wrong argument type %s (expected Variable)",
+                 rb_obj_classname(rvar));
+    }
+    check_model_available(cslv->result, 0);
+    Data_Get_Struct(rvar, cvariable, cvar);
+    switch(wrap_solver_ref_var(cslv->solver, cvar->value)) {
+        case 0: return Qfalse;
+        case 1: return Qtrue;
+    }
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     solver.solve   -> true or false
+ *
+ *  Determines whether the SAT is satisfiable or not.  Returns true if the SAT
+ *  is satisfied, false otherwise.
+ *
+ */
+static VALUE solver_solve(int argc, VALUE *argv, VALUE rslv)
+{
+    csolver *cslv;
+    int *lits;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+    lits = ALLOCA_N(int, argc);
+    convert_lits(lits, argc, argv, rslv);
+    if(wrap_solver_solve(cslv->solver, lits, argc)) {
+        cslv->result = SATISFIED;
+        return Qtrue;
+    }
+    else {
+        cslv->result =
+          argc == 0 ? UNSATISFIABLE : UNSATISFIABLE_UNDER_ASSUMPTIONS;
+        return Qfalse;
+    }
+}
+
+/*
+ *  call-seq:
+ *     solver.simplify_db   -> true or false
+ *
+ *  Detects conflicts independent of the assumptions.  This is useful when the
+ *  same SAT is solved many times under some different assumptions.
+ *
+ */
+static VALUE solver_simplify_db(VALUE rslv)
+{
+    csolver *cslv;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+
+    check_model_available(cslv->result, 0);
+    if(!wrap_solver_simplify_db(cslv->solver)) {
+        cslv->result = UNSATISFIABLE;
+        return Qfalse;
+    }
+
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     solver.var_size   -> integer
+ *
+ *  Returns the count of defined variables.
+ *
+ */
+static VALUE solver_var_size(VALUE rslv)
+{
+    csolver *cslv;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+
+    return LONG2NUM(wrap_solver_var_size(cslv->solver));
+}
+
+/*
+ *  call-seq:
+ *     solver.clause_size   -> integer
+ *
+ *  Returns the count of added clauses.
+ *
+ */
+static VALUE solver_clause_size(VALUE rslv)
+{
+    csolver *cslv;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+
+    return LONG2NUM(cslv->clause_count);
+}
+
+/*
+ *  call-seq:
+ *     solver.to_s   -> string
+ *
+ *  Creates a printable version of solver.
+ *
+ *     p solver  #=> #<MiniSat::Solver:0xb7d3c1d0 not solved yet>
+ *     p solver  #=> #<MiniSat::Solver:0xb7d3c1d0 satisfied>
+ *     p solver  #=> #<MiniSat::Solver:0xb7d3c1d0 unsatisfiable>
+ */
+static VALUE solver_to_s(VALUE rslv)
+{
+    const char *cname = rb_obj_classname(rslv);
+    const char *msg = NULL;
+    char *buf;
+    csolver *cslv;
+    VALUE str;
+    size_t len;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+    switch(cslv->result) {
+        case NOT_SOLVED_YET:
+            msg = "not solved yet";
+            break;
+        case SATISFIED:
+            msg = "satisfied";
+            break;
+        case UNSATISFIABLE:
+            msg = "unsatisfiable";
+            break;
+        case UNSATISFIABLE_UNDER_ASSUMPTIONS:
+            msg = "unsatisfiable under assumptions";
+            break;
+    }
+    len = strlen(cname) + strlen(msg) + 6 + 16;
+    buf = ALLOCA_N(char, len);
+    snprintf(buf, len + 1, "#<%s:%p %s>", cname, (void*)rslv, msg);
+    str = rb_str_new2(buf);
+    if(OBJ_TAINTED(rslv)) OBJ_TAINT(str);
+
+    return str;
+}
+
+/*
+ *  call-seq:
+ *     solver.solved?   -> true or false
+ *
+ *  Returns true if the SAT is solved, or false if not.
+ *
+ */
+static VALUE solver_solved_p(VALUE rslv)
+{
+    csolver *cslv;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+
+    return (cslv->result != NOT_SOLVED_YET ? Qtrue : Qfalse);
+}
+
+/*
+ *  call-seq:
+ *     solver.satisfied?   -> true or false
+ *
+ *  Returns true if the SAT is satisfied, or false if not.
+ *
+ */
+static VALUE solver_satisfied_p(VALUE rslv)
+{
+    csolver *cslv;
+
+    Data_Get_Struct(rslv, csolver, cslv);
+
+    return (cslv->result == SATISFIED ? Qtrue : Qfalse);
+}
+
+
+void Init_minisat()
+{
+    rb_mMiniSat = rb_define_module("MiniSat");
+
+    rb_cSolver = rb_define_class_under(rb_mMiniSat, "Solver", rb_cObject);
+    rb_define_alloc_func(rb_cSolver, solver_alloc);
+    rb_define_method(rb_cSolver, "new_var", solver_new_var, 0);
+    rb_define_method(rb_cSolver, "add_clause", solver_add_clause, -1);
+    rb_define_method(rb_cSolver, "<<", solver_add_clause_2, 1);
+    rb_define_method(rb_cSolver, "[]", solver_ref_var, 1);
+    rb_define_method(rb_cSolver, "solve", solver_solve, -1);
+    rb_define_method(rb_cSolver, "simplify_db", solver_simplify_db, 0);
+    rb_define_method(rb_cSolver, "var_size", solver_var_size, 0);
+    rb_define_method(rb_cSolver, "clause_size", solver_clause_size, 0);
+    rb_define_method(rb_cSolver, "to_s", solver_to_s, 0);
+    rb_define_method(rb_cSolver, "solved?", solver_solved_p, 0);
+    rb_define_method(rb_cSolver, "satisfied?", solver_satisfied_p, 0);
+
+    rb_cVariable = rb_define_class_under(rb_mMiniSat, "Variable", rb_cObject);
+    rb_undef_method(CLASS_OF(rb_cVariable), "new");
+    rb_define_method(rb_cVariable, "+@", variable_pos, 0);
+    rb_define_method(rb_cVariable, "-@", variable_neg, 0);
+    rb_define_method(rb_cVariable, "value", variable_value, 0);
+
+    rb_cLiteral = rb_define_class_under(rb_mMiniSat, "Literal", rb_cObject);
+    rb_undef_method(CLASS_OF(rb_cLiteral), "new");
+}