dpll_solver 0.0.1

data/lib/dpll_solver/formulas/falsum.rb

@@ -0,0 +1,18 @@
+module DpllSolver
+  module Formulas
+    class Falsum
+      extend AtomicFormula
+      def self.to_s
+        '0'
+      end
+
+      def self.falsum?
+        true
+      end
+      def self.verum?
+        false
+      end
+    end
+  end
+end
+

data/lib/dpll_solver/formulas/literal.rb

@@ -0,0 +1,25 @@
+module DpllSolver
+  module Formulas
+    class Literal
+      attr_accessor :var, :phase
+      def initialize(var, phase)
+        @var   = var
+        @phase = phase
+      end
+
+      def negate
+        self.class.new(@var, !@phase)
+      end
+
+      def to_s
+        phase ? @var.to_s : "-#{@var.to_s}"
+      end
+
+      def ==(other)
+        other.class == self.class && other.var == @var && other.phase == @phase
+      end
+
+      alias eql? ==
+    end
+  end
+end

data/lib/dpll_solver/formulas/not.rb

@@ -0,0 +1,84 @@
+module DpllSolver
+  module Formulas
+    class Not
+      attr_accessor :f
+
+      def initialize(f)
+        @f = f
+      end
+
+      def ==(other)
+        other.class == self.class && other.f == @f
+      end
+
+      alias eql? ==
+
+      def to_s
+        "-#{@f.to_s}"
+      end
+
+      def literal?
+        @f.atomic_formula?
+      end
+
+      def atomic_formula?
+        false
+      end
+      alias :nnf? :literal?
+      alias :clause? :literal?
+      alias :min_term? :literal?
+      alias :cnf? :nnf?
+      alias :dnf? :nnf?
+
+      def not?
+        true
+      end
+
+      def verum?
+        false
+      end
+      alias falsum? verum?
+      alias and? verum?
+      alias or? verum?
+      alias variable? verum?
+
+      def simplify
+        result = @f.simplify
+        if result.not?
+          result = result.f.simplify
+        elsif result.verum?
+          result = DpllSolver::Formulas::Falsum
+        elsif result.falsum?
+          result = DpllSolver::Formulas::Verum
+        else
+          result = self.class.new(result)
+        end
+        result
+      end
+
+      def nnf
+        if @f.and? || @f.or?
+          return apply_DeMorgan.nnf
+        elsif @f.not?
+          return @f.f.nnf
+        else
+          return self
+        end
+      end
+
+      def cnf
+        nnf? ? self : nnf.cnf
+      end
+
+      def apply_DeMorgan
+        if @f.and?
+          return DpllSolver::Formulas::Or.new(self.class.new(@f.f1), self.class.new(@f.f2))
+        elsif @f.or?
+          return DpllSolver::Formulas::And.new(self.class.new(@f.f1), self.class.new(@f.f2))
+        else
+          raise ArgumentError, 'DeMorgan can not be applied unless @f is either AND or OR'
+        end
+      end
+    end
+  end
+end

data/lib/dpll_solver/formulas/or.rb

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

data/lib/dpll_solver/formulas/variable.rb

@@ -0,0 +1,26 @@
+module DpllSolver
+  module Formulas
+    class Variable
+      include AtomicFormula
+      attr_accessor :name
+      alias :to_s :name
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        other.class == self.class && other.to_s == self.to_s
+      end
+      alias :eql? :==
+
+      def variable?
+        true
+      end
+      def verum?
+        false
+      end
+      alias falsum? verum?
+
+    end
+  end
+end

data/lib/dpll_solver/formulas/verum.rb

@@ -0,0 +1,18 @@
+module DpllSolver
+  module Formulas
+    class Verum
+      extend AtomicFormula
+      def self.to_s
+        '1'
+      end
+
+      def self.verum?
+        true
+      end
+      def self.falsum?
+        false
+      end
+    end
+  end
+end
+

data/lib/dpll_solver/heuristics/most_frequent_literal.rb

@@ -0,0 +1,22 @@
+module DpllSolver
+  module Heuristics
+    class MostFrequentLiteral
+      def self.choose_literal(clauseset)
+        raise ArgumentError, "clauseset must be a set of Clauses and not be empty!" if clauseset.empty?
+        counter = Hash.new(0)
+        most_frequent = nil
+        clauseset.each do |clause|
+          clause.literals.each do |literal|
+            counter[literal] += 1
+            if most_frequent
+              most_frequent = literal if counter[literal] > counter[most_frequent]
+            else
+              most_frequent = literal
+            end
+          end
+        end
+        most_frequent
+      end
+    end
+  end
+end

data/lib/dpll_solver/parsers/dimacs_parser.rb

@@ -0,0 +1,46 @@
+module DpllSolver
+  module Parsers
+    class DimacsParser
+      attr_accessor :file, :num_vars, :num_clauses, :clauseset
+      def initialize(file_path)
+        @file = file_path
+        @clauseset = Set.new
+        @num_clauses = 0
+        @num_vars = 0
+        parse
+      end
+
+      private
+      def parse
+        begin
+          lines = open(@file).readlines
+          lines.each do |line|
+            line = line.gsub("\n", "").strip.split
+            next if line[0] == "c"
+            if line[0] == "p"
+              @num_vars = line[2].to_i
+              @num_clauses = line[3].to_i
+            else
+              line.pop
+              if line.count > 0
+                clause = DpllSolver::Formulas::Clause.new
+                line.each do |num|
+                  clause.add(create_literal(num))
+                end
+                @clauseset.add(clause)
+              end
+            end
+          end
+        rescue Exception => e
+          puts e
+          raise IOError, "Could not parse file #{@file}!"
+        end
+      end
+
+      def create_literal(num)
+        var = DpllSolver::Formulas::Variable.new("x#{num.to_i.abs}")
+        DpllSolver::Formulas::Literal.new(var, num.to_i > 0)
+      end
+    end
+  end
+end

data/lib/dpll_solver/parsers/parser.rb

@@ -0,0 +1,53 @@
+module DpllSolver
+  module Parsers
+    class Grammar < Parslet::Parser
+      root :formula
+      rule(:formula) { falsum.as(:falsum) | verum.as(:verum) | variable.as(:var) | not_operation.as(:not) | and_operation.as(:and) | or_operation.as(:or) }
+      rule(:space) { str(" ").maybe }
+      rule(:verum) { match('[1T]') }
+      rule(:falsum) { match('[0F]') }
+      rule(:variable) { match('[a-z]') >> match('[0-9]').repeat(0,3) }
+      rule(:not_operation) { str("-") >> formula.as(:root_formula) }
+      rule(:or_operation) { str("(") >> formula.as(:left) >> space >> (match('[+|]') | str('OR')) >> space >> formula.as(:right) >> str(")") }
+      rule(:and_operation) { str("(") >> formula.as(:left) >> space >> (match('[*&]') | str('AND')) >> space >> formula.as(:right) >> str(")") }
+    end
+
+    class Transformer < Parslet::Transform
+      rule(:verum => simple(:verum)) { DpllSolver::Formulas::Verum }
+      rule(:falsum => simple(:falsum)) { DpllSolver::Formulas::Falsum }
+      rule(:var => simple(:var)) { DpllSolver::Formulas::Variable.new(var) }
+      rule(:not => { root_formula: subtree(:root_formula) }) { DpllSolver::Formulas::Not.new(root_formula) }
+      rule(:or => {left: subtree(:left), right: subtree(:right) }) { DpllSolver::Formulas::Or.new(left, right) }
+      rule(:and => {left: subtree(:left), right: subtree(:right) }) { DpllSolver::Formulas::And.new(left, right) }
+    end
+
+    class Parser
+
+      def self.formula_to_clause(formula)
+        f_cnf = formula.simplify.cnf
+        if f_cnf.verum?
+          return Set.new
+        elsif f_cnf.falsum?
+          return Set.new([DpllSolver::Formulas::Clause.new])
+        elsif f_cnf.variable?
+          literal = DpllSolver::Formulas::Literal.new(f_cnf, true)
+          return Set.new([DpllSolver::Formulas::Clause.new(literal)])
+        elsif f_cnf.not?
+          literal = DpllSolver::Formulas::Literal.new(f_cnf.f, false)
+          return Set.new([DpllSolver::Formulas::Clause.new(literal)])
+        elsif f_cnf.and?
+          c1 = self.formula_to_clause(f_cnf.f1)
+          c2 = self.formula_to_clause(f_cnf.f2)
+          return c1 + c2
+        elsif f_cnf.or?
+          c1 = self.formula_to_clause(f_cnf.f1)
+          c2 = self.formula_to_clause(f_cnf.f2)
+          return Set.new([c1.first.union(c2.first)])
+        else
+          raise TypeError, "Formula has to be one of these classes: Verum, Falsum, Variable, And, Or, Not"
+        end
+      end
+
+    end
+  end
+end

data/lib/dpll_solver/version.rb

@@ -0,0 +1,3 @@
+module DpllSolver
+  VERSION = "0.0.1"
+end

data/spec/dpll/dpll_solver_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe DpllSolver::DPLL do
+  let(:solver) { DpllSolver::DPLL.new(DpllSolver::Heuristics::MostFrequentLiteral) }
+  let(:var1) { DpllSolver::Formulas::Variable.new("x1") }
+  let(:var2) { DpllSolver::Formulas::Variable.new("x2") }
+  let(:lit1) { DpllSolver::Formulas::Literal.new(var1, true)}
+  let(:n_lit1) { DpllSolver::Formulas::Literal.new(var1, false)}
+  let(:lit2) { DpllSolver::Formulas::Literal.new(var2, true)}
+  let(:c1) { Set.new([DpllSolver::Formulas::Clause.new(lit1, lit2), DpllSolver::Formulas::Clause.new(lit1)])}
+  let(:c2) { Set.new()}
+  let(:c3) { Set.new([DpllSolver::Formulas::Clause.new(n_lit1, lit2), DpllSolver::Formulas::Clause.new(n_lit1)])}
+  let(:c4) { Set.new([DpllSolver::Formulas::Clause.new(n_lit1), DpllSolver::Formulas::Clause.new(lit1)])}
+  let(:c5) { Set.new([DpllSolver::Formulas::Clause.new, DpllSolver::Formulas::Clause.new(lit1)])}
+
+  it 'should return the literal of a uni clause' do
+    expect(solver.get_unit_clause_literal(c2)).to eql false
+    expect(solver.get_unit_clause_literal(c1)).to eql lit1
+    expect(solver.get_unit_clause_literal(c3)).to eql n_lit1
+  end
+
+  it 'should apply unit propagation on clauseset' do
+    expect(solver.unit_propagation(c1, lit1)).to eql Set.new
+    expect(solver.get_unit_clause_literal(solver.unit_propagation(c1, lit2))).to eql lit1
+    expect(solver.unit_propagation(c3, lit1).count).to eql 2
+    expect(solver.contains_empty_clause?(solver.unit_propagation(c3, lit1))).to eql true
+  end
+
+  it 'should apply dpll algorithm' do
+    expect(solver.apply_dpll(c1)).to eql true
+    expect(solver.apply_dpll(c2)).to eql true
+    expect(solver.apply_dpll(c3)).to eql true
+    expect(solver.apply_dpll(c4)).to eql false
+    expect(solver.apply_dpll(c5)).to eql false
+    l1 = DpllSolver::Formulas::Literal.new(DpllSolver::Formulas::Variable.new("x1"), true)
+    l2 = DpllSolver::Formulas::Literal.new(DpllSolver::Formulas::Variable.new("x1"), true)
+    l3 = DpllSolver::Formulas::Literal.new(DpllSolver::Formulas::Variable.new("x4"), true)
+    c = Set.new([DpllSolver::Formulas::Clause.new(l1), DpllSolver::Formulas::Clause.new(l2, l3)])
+    expect(solver.apply_dpll(c)).to eql true
+  end
+
+end
+
+class Set
+  def to_s
+    map(&:to_s)
+  end
+end
+
+describe DpllSolver::Util do
+  let(:util) { DpllSolver::Util }
+  let(:verum) { DpllSolver::Formulas::Verum }
+  let(:falsum) { DpllSolver::Formulas::Falsum }
+  let(:var) { DpllSolver::Formulas::Variable.new("x1") }
+  let(:not_var) { DpllSolver::Formulas::Not.new(var) }
+  let(:f1) { "resources/dimacs/yes/uf20-01.cnf" }
+  let(:f2) { "resources/dimacs/yes/uf20-02.cnf" }
+  let(:f3) { "resources/dimacs/yes/uf20-03.cnf" }
+  let(:f4) { "resources/dimacs/yes/uf20-04.cnf" }
+  let(:f5) { "resources/dimacs/no/uf20-01.cnf" }
+  let(:f6) { "resources/dimacs/no/uf20-02.cnf" }
+
+  it 'should transform a formula string into cnf' do
+    expect(util.to_cnf('1')).to eql verum
+    expect(util.to_cnf('0')).to eql falsum
+    expect(util.to_cnf('x1')).to eql var
+    expect(util.to_cnf('-x1')).to eql not_var
+    expect(util.to_cnf('((a OR -b) AND (0 OR c))').to_s).to eql '((a OR -b) AND c)'
+    expect(util.to_cnf('((a AND -b) OR (1 AND c))').to_s).to eql '((a OR c) AND (-b OR c))'
+  end
+
+  it 'should transform a formula string into clause' do
+    expect(util.to_clause('1')).to eql Set.new
+    expect(util.to_clause('0').to_s).to eql ["{}"]
+    expect(util.to_clause('a').to_s).to eql ["{a}"]
+    expect(util.to_clause('(a OR b)').to_s).to eql ["{a, b}"]
+    expect(util.to_clause('(a AND b)').to_s).to eql ["{a}", "{b}"]
+    expect(util.to_clause('(a AND (-b OR c))').to_s).to eql ["{a}", "{-b, c}"]
+    expect(util.to_clause('((a AND -b) OR (1 AND c))').to_s).to eql ["{a, c}", "{-b, c}"]
+  end
+
+  it 'should check wether a formula is satisfiable' do
+    expect(util.SAT?('1')).to eql true
+    expect(util.SAT?('0')).to eql false
+    expect(util.SAT?('x1')).to eql true
+    expect(util.SAT?('(0 AND x1)')).to eql false
+    expect(util.SAT?('-(0 AND x1)')).to eql true
+    expect(util.SAT?('-(1 OR x1)')).to eql false
+  end
+
+  it 'should check wether a formula is tautology' do
+    expect(util.tautology?('1')).to eql true
+    expect(util.tautology?('x1')).to eql false
+    expect(util.tautology?('-(0 AND x1)')).to eql true
+    expect(util.tautology?('-(1 OR x1)')).to eql false
+  end
+
+  it 'should check wether a formula is contradiction' do
+    expect(util.contradiction?('0')).to eql true
+    expect(util.contradiction?('x1')).to eql false
+    expect(util.contradiction?('(0 AND x1)')).to eql true
+    expect(util.contradiction?('-(0 AND x1)')).to eql false
+    expect(util.contradiction?('-(1 OR x1)')).to eql true
+  end
+
+  it 'should solve SAT problem of given file' do
+    expect(util.dimacs_SAT?(f1)).to eql true
+    expect(util.dimacs_SAT?(f2)).to eql true
+    expect(util.dimacs_SAT?(f3)).to eql true
+    expect(util.dimacs_SAT?(f4)).to eql true
+    expect(util.dimacs_SAT?(f5)).to eql false
+    expect(util.dimacs_SAT?(f6)).to eql false
+  end
+end