dpll_solver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b1fe3e41c37f472f5e8dca7543336d2450aa8a1
+  data.tar.gz: 34ac78a5ab53680c20c94ba820763cd5b054e599
+SHA512:
+  metadata.gz: a6313282bb0ff87f335a751a5bf0bab610b0df0d81f8c2a074c0919a34151dc59548849107e4060bc9a70ddd1d01fab316c96e29dd5bfe4ed4dfe59c2d50530f
+  data.tar.gz: 54390da348247318cd7657eaef7fa1024cdc23ddf216f0bc8cd8fe236b1b67a1de2cf7cdbb485df515fac26fb69a78493d149ef841b1bb1fc3576198f4a4cd97

data/.gitignore

@@ -0,0 +1,18 @@
+*.sw?
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 thebluber
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,62 @@
+# DpllSolver
+
+This is a small SAT solving tool using [DPLL algorithm](http://en.wikipedia.org/wiki/DPLL_algorithm). It can evaluate both a DIMACS file (max. 20 variables, 80 lines) and a boolean expression in string format i.e. '(x1 * (x3 + x4))' and determin wether the input is satisfiable.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dpll_solver'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dpll_solver
+
+## Usage
+
+#### Utilities
+```ruby
+require 'dpll_solver'
+
+#to_cnf converts a boolean string to formula in conjunctive normal form
+DpllSolver::Util.to_cnf('(x1 + -x6)').to_s # => "(x1 OR -x6)"
+
+#to_clause converts a boolean expression to a set of clauses
+class Set
+  def to_s
+    map(&:to_s)
+  end
+end
+DpllSolver::Util.to_clause('(x1 + -x6)').to_s # => ["{x1, -x6}"]
+
+#SAT? determins wether a boolean expression is satisfiable
+DpllSolver::Util.SAT?('T') # => true
+DpllSolver::Util.SAT?('1') # => true
+DpllSolver::Util.SAT?('F') # => false
+DpllSolver::Util.SAT?('0') # => false
+DpllSolver::Util.SAT?('(x1 + -x6)') # => true
+
+#dimacs_SAT? determins wether a cnf file in DIMACS format is satisfiable
+DpllSolver::Util.dimacs_SAT?('resources/dimacs/yes/uf20-01.cnf') # => true
+DpllSolver::Util.dimacs_SAT?('resources/dimacs/no/uf20-01.cnf') # => false
+
+#tautology?
+DpllSolver::Util.tautology?('1') # => true
+DpllSolver::Util.tautology?('(x1 + -x6)') # => false
+
+#contradiction?
+DpllSolver::Util.contradiction?('0') # => true
+DpllSolver::Util.contradiction?('(x1 + -x6)') # => false
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+require "rspec/core/rake_task"
+
+Bundler::GemHelper.install_tasks
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+end

data/dpll_solver.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dpll_solver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dpll_solver"
+  spec.version       = DpllSolver::VERSION
+  spec.authors       = ["thebluber"]
+  spec.email         = ["thebluber@gmail.com"]
+  spec.description   = "This is a small SAT solving tool for either DIMACS file input (max. 20 variables, 80 lines) or boolean expressions in string format i.e. '(x1 * (x3 + x4))'."
+  spec.summary       = "SAT solver using DPLL algorithm"
+  spec.homepage      = "https://github.com/thebluber/dpll_solver"
+  spec.license       = "MIT"
+  
+  resource_files = [
+    'resources/dimacs/no/uf20-01.cnf',
+    'resources/dimacs/no/uf20-02.cnf',
+    'resources/dimacs/yes/uf20-01.cnf',
+    'resources/dimacs/yes/uf20-02.cnf',
+    'resources/dimacs/yes/uf20-03.cnf',
+    'resources/dimacs/yes/uf20-04.cnf'
+  ]
+  spec.files         = `git ls-files`.split($/).reject{|file| resource_files.include? file}
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "binding_of_caller"
+  spec.add_development_dependency "pry"
+  spec.add_dependency "parslet"
+end

data/lib/dpll_solver.rb

@@ -0,0 +1,115 @@
+# Require all of the Ruby files in the given directory.
+# #
+# # path - The String relative path from here to the directory.
+# #
+# # Returns nothing.
+def require_all(path)
+  glob = File.join(File.dirname(__FILE__), path, '*.rb')
+  Dir[glob].each do |f|
+    require f
+  end
+end
+require 'parslet'
+require 'set'
+require 'dpll_solver/version'
+require 'dpll_solver/atomic_formula'
+require_all 'dpll_solver/formulas'
+require_all 'dpll_solver/parsers'
+require_all 'dpll_solver/heuristics'
+
+module DpllSolver
+  class Util
+    @@grammar = DpllSolver::Parsers::Grammar.new
+    @@transformer = DpllSolver::Parsers::Transformer.new
+    def self.to_cnf(str)
+      formula = @@grammar.parse(str)
+      @@transformer.apply(formula).simplify().cnf()
+    end
+
+    def self.to_clause(str)
+      formula = @@grammar.parse(str)
+      DpllSolver::Parsers::Parser.formula_to_clause(@@transformer.apply(formula))
+    end
+
+    def self.dimacs_to_clause(file)
+      parser = DpllSolver::Parsers::DimacsParser.new(file)
+      parser.clauseset
+    end
+
+    def self.dimacs_SAT?(file)
+      solver = DPLL.new(DpllSolver::Heuristics::MostFrequentLiteral)
+      solver.apply_dpll(self.dimacs_to_clause(file))
+    end
+
+    def self.SAT?(str)
+      solver = DPLL.new(DpllSolver::Heuristics::MostFrequentLiteral)
+      solver.apply_dpll(self.to_clause(str))
+    end
+
+    def self.contradiction?(str)
+      !self.SAT?(str)
+    end
+
+    def self.tautology?(str)
+      formula = @@grammar.parse(str)
+      #negate formula
+      clause = DpllSolver::Parsers::Parser.formula_to_clause(DpllSolver::Formulas::Not.new(@@transformer.apply(formula)))
+      solver = DPLL.new(DpllSolver::Heuristics::MostFrequentLiteral)
+      !solver.apply_dpll(clause)
+    end
+  end
+
+  class DPLL
+    attr_accessor :heuristics
+    def initialize(heuristics)
+      @heuristics = heuristics
+    end
+
+    def apply_dpll(clauseset)
+      literal = get_unit_clause_literal(clauseset)
+      while literal do
+        clauseset = unit_propagation(clauseset, literal)
+        literal = get_unit_clause_literal(clauseset)
+      end
+      if clauseset.empty?
+        return true
+      elsif contains_empty_clause?(clauseset)
+        return false
+      end
+      literal = @heuristics.choose_literal(clauseset)
+      return apply_dpll(union_unit_clause(clauseset, literal)) || apply_dpll(union_unit_clause(clauseset, literal.negate()))
+    end
+
+    def contains_empty_clause?(clauseset)
+      clauseset.each do |clause|
+        return true if clause.empty?
+      end
+      return false
+    end
+
+    def get_unit_clause_literal(clauseset)
+      clauseset.each do |clause|
+        if clause.unit?
+          return clause.literals.first
+        end
+      end
+      return false
+    end
+
+    def unit_propagation(clauseset, literal)
+      result = Set.new
+      clauseset.each do |clause|
+        if clause.include?(literal.negate())
+          result.add(clause.delete(literal.negate()))
+        elsif !clause.include?(literal)
+          result.add(clause)
+        end
+      end
+      result
+    end
+
+    def union_unit_clause(clauseset, literal)
+      clauseset.dup.add(DpllSolver::Formulas::Clause.new(literal))
+    end
+  end
+end

data/lib/dpll_solver/atomic_formula.rb

@@ -0,0 +1,34 @@
+module AtomicFormula
+  #syntactic equivalenz
+  def ==(other)
+    other.class == self.class
+  end
+
+  def atomic_formula?
+    true
+  end
+
+  alias literal? atomic_formula?
+  alias min_term? atomic_formula?
+  alias clause? atomic_formula?
+  alias nnf? atomic_formula?
+  alias cnf? atomic_formula?
+  alias dnf? atomic_formula?
+
+  def simplify
+    self
+  end
+
+  alias nnf simplify
+  alias cnf simplify
+  alias dnf simplify
+
+  def not?
+    false
+  end
+
+  alias and? not?
+  alias or? not?
+  alias variable? not?
+end
+

data/lib/dpll_solver/formulas/and.rb

@@ -0,0 +1,54 @@
+module DpllSolver
+  module Formulas
+    class And < BinaryFormula
+      def to_s
+        "(#{@f1.to_s} AND #{@f2.to_s})"
+      end
+
+      def clause?
+        false
+      end
+
+      def min_term?
+        @f1.min_term? && @f2.min_term?
+      end
+
+      def cnf?
+        @f1.cnf? && @f2.cnf?
+      end
+
+      def and?
+        true
+      end
+
+      def verum?
+        false
+      end
+      alias falsum? verum?
+      alias not? verum?
+      alias or? verum?
+      alias variable? verum?
+
+      def simplify
+        res_f1 = @f1.simplify
+        res_f2 = @f2.simplify
+        if res_f1.verum? #identity
+          return res_f2
+        elsif res_f2.verum? #identity
+          return res_f1
+        elsif res_f1.falsum? || res_f2.falsum? #anihilator
+          return DpllSolver::Formulas::Falsum
+        elsif res_f1 == res_f2 #idempotence
+          return res_f1
+        else
+          return self.class.new(res_f1, res_f2)
+        end
+      end
+
+      def cnf
+        nnf? ? self.class.new(@f1.cnf, @f2.cnf) : nnf.cnf
+      end
+
+    end
+  end
+end

data/lib/dpll_solver/formulas/binary_formula.rb

@@ -0,0 +1,33 @@
+class BinaryFormula
+  attr_accessor :f1, :f2
+  def initialize(f1, f2)
+    @f1 = f1
+    @f2 = f2
+  end
+  #syntactic equivalenz
+  def ==(other)
+    other.class == self.class && other.f1 == @f1 && other.f2 == @f2
+  end
+  alias eql? ==
+
+  def literal?
+    false
+  end
+
+  def atomic_formula?
+    false
+  end
+
+  def nnf?
+    @f1.nnf? && @f2.nnf?
+  end
+
+  def dnf?
+    @f1.dnf? && @f2.dnf?
+  end
+
+  def nnf
+    self.class.new(@f1.nnf, @f2.nnf)
+  end
+end
+

data/lib/dpll_solver/formulas/clause.rb

@@ -0,0 +1,52 @@
+module DpllSolver
+  module Formulas
+    class Clause
+      attr_accessor :literals
+      def initialize(*args)
+        @literals = Set.new(args)
+      end
+
+      def add(literal)
+        @literals.add(literal)
+        self
+      end
+
+      def delete(literal)
+        literal_array = @literals.to_a
+        literal_array.delete(literal)
+        @literals = Set.new(literal_array)
+        self
+      end
+
+      def unit?
+        @literals.count == 1
+      end
+
+      def empty?
+        @literals.empty?
+      end
+
+      def include?(literal)
+        @literals.to_a.include?(literal)
+      end
+
+      def union(other)
+        @literals = @literals + other.literals
+        self
+      end
+
+      def get_unit_literal
+        @literals.first if unit?
+      end
+
+      def ==(other)
+        other.class == self.class && other.literals == @literals
+      end
+
+      def to_s
+        "{#{@literals.to_a.map(&:to_s).join(', ')}}"
+      end
+      alias eql? ==
+    end
+  end
+end