dpll_solver 0.0.1

data/spec/formulas/verum_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::Verum do
+  let(:verum) { DpllSolver::Formulas::Verum }
+  it 'should be "1" as string' do
+    expect(verum.to_s).to eql "1"
+  end
+
+  it 'should test syntactic eqivalenz' do
+    expect(verum == DpllSolver::Formulas::Verum).to eql true
+    expect(verum == DpllSolver::Formulas).to eql false
+  end
+
+  it 'should be a literal' do
+    expect(verum.literal?).to eql true
+  end
+
+  it 'should be a atomic formula' do
+    expect(verum.atomic_formula?).to eql true
+  end
+
+  it 'should be a min term' do
+    expect(verum.min_term?).to eql true
+  end
+
+  it 'should be a nnf' do
+    expect(verum.nnf?).to eql true
+  end
+
+  it 'should be a cnf' do
+    expect(verum.cnf?).to eql true
+  end
+
+  it 'should be a dnf' do
+    expect(verum.dnf?).to eql true
+  end
+
+  it 'should simplify verum' do
+    expect(verum.simplify).to eql verum
+  end
+end
+

data/spec/heuristics/most_frequent_literal_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe DpllSolver::Heuristics::MostFrequentLiteral do
+  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([DpllSolver::Formulas::Clause.new(lit1, lit2), DpllSolver::Formulas::Clause.new(n_lit1)])}
+  let(:c3) { Set.new([DpllSolver::Formulas::Clause.new(n_lit1, lit2), DpllSolver::Formulas::Clause.new(n_lit1)])}
+  
+  it 'should return the most frequent literal in clause set' do
+    expect{ DpllSolver::Heuristics::MostFrequentLiteral.choose_literal(Set.new)}.to raise_error
+    expect(DpllSolver::Heuristics::MostFrequentLiteral.choose_literal(c1)).to eql lit1
+    expect{ DpllSolver::Heuristics::MostFrequentLiteral.choose_literal(c2)}.not_to raise_error
+    expect(DpllSolver::Heuristics::MostFrequentLiteral.choose_literal(c3)).to eql n_lit1
+  end
+end

data/spec/parsers/dimacs_parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe DpllSolver::Parsers::DimacsParser do
+  let(:f1) { "resources/dimacs/yes/aim-50-1_6-yes1-1.cnf" }
+  let(:f2) { "resources/dimacs/no/aim-50-1_6-no-1.cnf" }
+  let(:f3) { "resources/dimacs/yes/aim-50-6_0-yes1-4.cnf" }
+
+  it 'should parse files in DIMACS format' do
+    parser = DpllSolver::Parsers::DimacsParser.new(f1)
+    expect(parser.num_vars).to eql 50
+    expect(parser.num_clauses).to eql 80
+    expect(parser.clauseset.count).to eql 80
+    parser = DpllSolver::Parsers::DimacsParser.new(f2)
+    expect(parser.num_vars).to eql 50
+    expect(parser.num_clauses).to eql 80
+    expect(parser.clauseset.count).to eql 80
+    parser = DpllSolver::Parsers::DimacsParser.new(f3)
+    expect(parser.num_vars).to eql 50
+    expect(parser.num_clauses).to eql 300
+    expect(parser.clauseset.count).to eql 300
+  end
+
+end

data/spec/parsers/grammar_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+describe DpllSolver::Parsers::Grammar do
+  let(:g){ DpllSolver::Parsers::Grammar.new }
+
+  describe '#verum' do
+    let(:verum){ g.verum }
+    it 'should parse verum' do
+      verum.should parse('T')
+      verum.should parse('1')
+    end
+  end
+  describe '#falsum' do
+    let(:falsum){ g.falsum }
+    it 'should parse falsum' do
+      falsum.should parse('F')
+      falsum.should parse('0')
+    end
+  end
+  describe '#variable' do
+    let(:var){ g.variable }
+    it 'should parse variable' do
+      var.should parse('x')
+      var.should parse('x1')
+      var.should parse('x12')
+      var.should_not parse('xy')
+    end
+  end
+  describe '#not' do
+    let(:not_op){ g.not_operation }
+    it 'should parse not_operation' do
+      not_op.should parse('-x')
+      not_op.should parse('-(x+y)')
+      not_op.should parse('--x')
+    end
+  end
+  describe '#or' do
+    let(:or_op){ g.or_operation }
+    it 'should parse or_operation' do
+      or_op.should parse('(x + y)')
+      or_op.should parse('(x | y)')
+      or_op.should parse('(x OR y)')
+    end
+  end
+  describe '#and' do
+    let(:and_op){ g.and_operation }
+    it 'should parse and_operation' do
+      and_op.should parse('(x * y)')
+      and_op.should parse('(x & y)')
+      and_op.should parse('(x AND y)')
+    end
+  end
+end

data/spec/parsers/parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe DpllSolver::Parsers::Parser do
+  let(:falsum) { DpllSolver::Formulas::Falsum }
+  let(:verum) { DpllSolver::Formulas::Verum }
+  let(:var1) { DpllSolver::Formulas::Variable.new("x1") }
+  let(:var2) { DpllSolver::Formulas::Variable.new("x2") }
+  let(:f) { DpllSolver::Formulas::Not.new(var2) }
+  let(:f1) { DpllSolver::Formulas::Not.new(DpllSolver::Formulas::And.new(var1, falsum)) }
+  let(:f2) { DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(var1, var2), DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(falsum, var2)))) }
+  let(:f3) { DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(var1, falsum), var2)), verum) }
+
+  it 'should convert a formula to a set of clauses' do
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(falsum).map(&:to_s).join).to eql "{}"
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(verum).empty?).to eql true
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(var1).map(&:to_s).join).to eql "{x1}"
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(f).map(&:to_s).join).to eql "{-x2}"
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(f1).empty?).to eql true
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(f2).map(&:to_s).join).to match "{-x1, -x2}"
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(f2).map(&:to_s).join).to match "{x2}"
+    expect(DpllSolver::Parsers::Parser.formula_to_clause(f3).empty?).to eql true
+  end
+end

data/spec/parsers/transformer_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe DpllSolver::Parsers::Transformer do
+  let(:g){ DpllSolver::Parsers::Grammar.new }
+  let(:trans){ DpllSolver::Parsers::Transformer.new }
+
+  it 'should transform literals' do
+    verum = g.parse('T')
+    falsum = g.parse('F')
+    var = g.parse('x1')
+    expect(trans.apply(verum)).to eql DpllSolver::Formulas::Verum
+    expect(trans.apply(falsum)).to eql DpllSolver::Formulas::Falsum
+    expect(trans.apply(var)).to eql DpllSolver::Formulas::Variable.new('x1')
+  end
+
+  it 'should transform functions' do
+    not_op = g.parse('-z')
+    or_op = g.parse('(x OR y)')
+    and_op = g.parse('(x AND y)')
+    expect(trans.apply(not_op)).to eql DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Variable.new('z'))
+    expect(trans.apply(or_op)).to eql DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Variable.new('x'), DpllSolver::Formulas::Variable.new('y'))
+    expect(trans.apply(and_op)).to eql DpllSolver::Formulas::And.new(DpllSolver::Formulas::Variable.new('x'), DpllSolver::Formulas::Variable.new('y'))
+  end
+
+  it 'should transform nested functions' do
+    f = g.parse('-(a OR ((b OR -c) AND d))')
+    parsed = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Variable.new('a'), DpllSolver::Formulas::And.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Variable.new('b'), DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Variable.new('c'))), DpllSolver::Formulas::Variable.new('d'))))
+    expect(trans.apply(f)).to eql parsed
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'dpll_solver'
+require 'pry'

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: dpll_solver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- thebluber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+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))'.
+email:
+- thebluber@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dpll_solver.gemspec
+- lib/dpll_solver.rb
+- lib/dpll_solver/atomic_formula.rb
+- lib/dpll_solver/formulas/and.rb
+- lib/dpll_solver/formulas/binary_formula.rb
+- lib/dpll_solver/formulas/clause.rb
+- lib/dpll_solver/formulas/falsum.rb
+- lib/dpll_solver/formulas/literal.rb
+- lib/dpll_solver/formulas/not.rb
+- lib/dpll_solver/formulas/or.rb
+- lib/dpll_solver/formulas/variable.rb
+- lib/dpll_solver/formulas/verum.rb
+- lib/dpll_solver/heuristics/most_frequent_literal.rb
+- lib/dpll_solver/parsers/dimacs_parser.rb
+- lib/dpll_solver/parsers/parser.rb
+- lib/dpll_solver/version.rb
+- spec/dpll/dpll_solver_spec.rb
+- spec/formulas/and_spec.rb
+- spec/formulas/clause_spec.rb
+- spec/formulas/falsum_spec.rb
+- spec/formulas/formulas_spec.rb
+- spec/formulas/literal_spec.rb
+- spec/formulas/not_spec.rb
+- spec/formulas/or_spec.rb
+- spec/formulas/variable_spec.rb
+- spec/formulas/verum_spec.rb
+- spec/heuristics/most_frequent_literal_spec.rb
+- spec/parsers/dimacs_parser_spec.rb
+- spec/parsers/grammar_spec.rb
+- spec/parsers/parser_spec.rb
+- spec/parsers/transformer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/thebluber/dpll_solver
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: SAT solver using DPLL algorithm
+test_files:
+- spec/dpll/dpll_solver_spec.rb
+- spec/formulas/and_spec.rb
+- spec/formulas/clause_spec.rb
+- spec/formulas/falsum_spec.rb
+- spec/formulas/formulas_spec.rb
+- spec/formulas/literal_spec.rb
+- spec/formulas/not_spec.rb
+- spec/formulas/or_spec.rb
+- spec/formulas/variable_spec.rb
+- spec/formulas/verum_spec.rb
+- spec/heuristics/most_frequent_literal_spec.rb
+- spec/parsers/dimacs_parser_spec.rb
+- spec/parsers/grammar_spec.rb
+- spec/parsers/parser_spec.rb
+- spec/parsers/transformer_spec.rb
+- spec/spec_helper.rb