dpll_solver 0.0.1

data/spec/formulas/and_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::And 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(:f1) { DpllSolver::Formulas::Not.new(var1)}
+  let(:f2) { DpllSolver::Formulas::And.new(var1, var2)}
+  let(:f3) { DpllSolver::Formulas::And.new(f1, f2)}
+  let(:f4) { DpllSolver::Formulas::And.new(f1, DpllSolver::Formulas::Not.new(f2))}
+  it 'should convert to string' do
+    expect(f2.to_s).to eql "(x1 AND x2)"
+    expect(f3.to_s).to eql "((NOT x1) AND (x1 AND x2))"
+    expect(f4.to_s).to eql "((NOT x1) AND (NOT (x1 AND x2)))"
+  end
+
+  it 'should test syntactic eqivalenz' do
+    expect(f2 == f2).to eql true
+    expect(f2 == DpllSolver::Formulas::And.new(var1, var2)).to eql true
+    expect(f2 == f3).to eql false
+  end
+
+  it 'should not be a literal' do
+    expect(f2.literal?).to eql false
+    expect(f3.literal?).to eql false
+    expect(f4.literal?).to eql false
+  end
+
+  it 'should not be a atomic formula' do
+    expect(f2.atomic_formula?).to eql false
+    expect(f3.atomic_formula?).to eql false
+    expect(f4.atomic_formula?).to eql false
+  end
+
+  it 'should not be a clause' do
+    expect(f2.clause?).to eql false
+    expect(f3.clause?).to eql false
+    expect(f4.clause?).to eql false
+  end
+
+  it 'should be a min term if both formulas are min term' do
+    expect(f2.min_term?).to eql true
+    expect(f3.min_term?).to eql true
+    expect(f4.min_term?).to eql false
+  end
+
+  it 'should be a nnf, cnf, dnf if both formulas are in nnf, cnf or dnf' do
+    expect(f2.nnf?).to eql true
+    expect(f2.cnf?).to eql true
+    expect(f2.dnf?).to eql true
+    expect(f3.nnf?).to eql true
+    expect(f3.cnf?).to eql true
+    expect(f3.dnf?).to eql true
+    expect(f4.nnf?).to eql false
+    expect(f4.cnf?).to eql false
+    expect(f4.dnf?).to eql false
+  end
+
+  it 'should simply and' do
+    and_falsum1= DpllSolver::Formulas::And.new(var1, falsum)
+    and_verum1 = DpllSolver::Formulas::And.new(var1, verum)
+    and_falsum2 = DpllSolver::Formulas::And.new(falsum, var2)
+    and_verum2 = DpllSolver::Formulas::And.new(verum, var2)
+    not_f1 = DpllSolver::Formulas::Not.new(f1)
+    and_not = DpllSolver::Formulas::And.new(not_f1, var1)
+    expect(and_falsum1.simplify).to eql falsum
+    expect(and_falsum2.simplify).to eql falsum
+    expect(and_verum1.simplify).to eql var1
+    expect(and_verum2.simplify).to eql var2
+    expect(and_not.simplify).to eql var1
+  end
+
+end
+

data/spec/formulas/clause_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::Clause do
+  let(:var1) { DpllSolver::Formulas::Variable.new("x1") }
+  let(:var2) { DpllSolver::Formulas::Variable.new("x2") }
+  let(:lit1) { DpllSolver::Formulas::Literal.new(var1, true) }
+  let(:lit1_neg) { DpllSolver::Formulas::Literal.new(var1, false) }
+  let(:lit2) { DpllSolver::Formulas::Literal.new(var2, true) }
+  let(:c) { DpllSolver::Formulas::Clause.new()}
+  let(:c1) { DpllSolver::Formulas::Clause.new(lit1)}
+  let(:c2) { DpllSolver::Formulas::Clause.new(lit1, lit2)}
+
+  it 'should test if clause is a unit clause' do
+    expect(c1.unit?).to eql true
+    expect(c2.unit?).to eql false
+  end
+
+  it 'should add and remove literal to clause' do
+    expect(c1.add(lit2)).to eql c2
+    c2.delete(lit2)
+    expect(c2.unit?).to eql true
+    expect(c2.delete(DpllSolver::Formulas::Literal.new(var1, true)).empty?).to eql true
+  end
+
+  it 'should detect if a clause is empty' do
+    expect(c.empty?).to eql true
+    expect(c1.empty?).to eql false
+  end
+
+  it 'should detect if a clause contains the given literal' do
+    expect(c.include?(lit1)).to eql false
+    expect(c1.include?(lit1)).to eql true
+  end
+
+  it 'should union a clause to an other' do
+    c.union(c1)
+    expect(c).to eql c1
+  end
+
+  it 'should get the unit literal' do
+    c2.add(lit1_neg)
+    expect(c2.get_unit_literal.nil?).to eql true
+    expect(c1.get_unit_literal).to eql lit1
+  end
+
+  it 'should compare two clauses' do
+    expect(c == c).to eql true
+    expect(c1 == DpllSolver::Formulas::Clause.new(lit1)).to eql true
+    expect(c1 == c2).to eql false
+  end
+
+  it 'should convert clause to string' do
+    expect(c2.to_s).to eql "{x1, x2}"
+  end
+end

data/spec/formulas/falsum_spec.rb

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

data/spec/formulas/formulas_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas 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") }
+
+  it 'should convert a formula correctly to nnf' do
+    expect(falsum.nnf).to eql falsum
+    expect(verum.nnf).to eql verum
+    expect(var1.nnf).to eql var1
+
+    #more complex formulas
+    f = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::And.new(var1, falsum))
+    f_nnf = DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var1), DpllSolver::Formulas::Not.new(falsum))
+    expect(f.nnf).to eql f_nnf
+
+    f = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(var1, var2), DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(falsum, var2))))
+    f_nnf = DpllSolver::Formulas::And.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var1), DpllSolver::Formulas::Not.new(var2)), DpllSolver::Formulas::Or.new(falsum, var2))
+    expect(f.nnf).to eql f_nnf
+
+    f = DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(var1, falsum), var2)), verum)
+    f_nnf = DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var1), DpllSolver::Formulas::Not.new(falsum)), DpllSolver::Formulas::Not.new(var2)), verum)
+    expect(f.nnf).to eql f_nnf
+  end
+
+  it 'should convert a formula correctly to cnf' do
+    expect(falsum.cnf).to eql falsum
+    expect(verum.cnf).to eql verum
+    expect(var1.cnf).to eql var1
+
+    #more complex formulas
+    f = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::And.new(var1, falsum))
+    f_cnf = DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var1), DpllSolver::Formulas::Not.new(falsum))
+    expect(f.cnf).to eql f_cnf
+
+    f = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(var1, var2), DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(falsum, var2))))
+    f_cnf = DpllSolver::Formulas::And.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var1), DpllSolver::Formulas::Not.new(var2)), DpllSolver::Formulas::Or.new(falsum, var2))
+    expect(f.cnf).to eql f_cnf
+
+    f = DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::And.new(var1, falsum), var2)), verum)
+    f_cnf = DpllSolver::Formulas::And.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var1), DpllSolver::Formulas::Not.new(falsum)), verum), DpllSolver::Formulas::Or.new(DpllSolver::Formulas::Not.new(var2), verum))
+    expect(f.cnf).to eql f_cnf
+  end
+
+end

data/spec/formulas/literal_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::Literal do
+  let(:var1) { DpllSolver::Formulas::Variable.new("x1") }
+  let(:var2) { DpllSolver::Formulas::Variable.new("x2") }
+  let(:lit1) { DpllSolver::Formulas::Literal.new(var1, true) }
+  let(:lit1_neg) { DpllSolver::Formulas::Literal.new(var1, false) }
+  let(:lit2) { DpllSolver::Formulas::Literal.new(var2, true) }
+
+  it 'should negate the literal' do
+    expect(lit1.negate()).to eql lit1_neg
+    expect(lit1_neg.negate()).to eql lit1
+  end
+
+  it 'should convert literal to string' do
+    expect(lit2.to_s).to eql "x2"
+    expect(lit1.to_s).to eql "x1"
+    expect(lit1_neg.to_s).to eql "-x1"
+  end
+
+  it 'should compare two literals' do
+    expect(lit1 == lit1).to eql true
+    expect(lit1 == lit2).to eql false
+    expect(lit1 == lit1_neg).to eql false
+  end
+end

data/spec/formulas/not_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::Not 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(:f1) { DpllSolver::Formulas::Not.new(var1)}
+  let(:f2) { DpllSolver::Formulas::Not.new(f1)}
+  let(:f3) { DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Falsum)}
+  it 'should convert to string' do
+    expect(f1.to_s).to eql "(NOT x1)"
+    expect(f2.to_s).to eql "(NOT (NOT x1))"
+    expect(f3.to_s).to eql "(NOT 0)"
+  end
+
+  it 'should test syntactic eqivalenz' do
+    expect(f1 == f1).to eql true
+    expect(f1 == DpllSolver::Formulas::Not.new(var1)).to eql true
+    expect(f1 == f2).to eql false
+  end
+
+  it 'should be a literal if contains an atomic formula' do
+    expect(f1.literal?).to eql true
+    expect(f2.literal?).to eql false
+    expect(f3.literal?).to eql true
+  end
+
+  it 'should not be a atomic formula' do
+    expect(f1.atomic_formula?).to eql false
+    expect(f3.atomic_formula?).to eql false
+  end
+
+  it 'should be a min term if contains an atomic formula' do
+    expect(f1.min_term?).to eql true
+    expect(f3.min_term?).to eql true
+    expect(f2.min_term?).to eql false
+  end
+
+  it 'should be a nnf, cnf, dnf if contains an atomic formula' do
+    expect(f1.nnf?).to eql true
+    expect(f1.cnf?).to eql true
+    expect(f1.dnf?).to eql true
+    expect(f3.nnf?).to eql true
+    expect(f3.cnf?).to eql true
+    expect(f3.dnf?).to eql true
+    expect(f2.nnf?).to eql false
+    expect(f2.cnf?).to eql false
+    expect(f2.dnf?).to eql false
+  end
+
+  it 'should simplify not' do
+    not_falsum = DpllSolver::Formulas::Not.new(falsum)
+    not_verum = DpllSolver::Formulas::Not.new(verum)
+    expect(not_falsum.simplify).to eql verum
+    expect(not_verum.simplify).to eql falsum
+    expect(f2.simplify).to eql var1
+    not_f2 = DpllSolver::Formulas::Not.new(f2)
+    expect(not_f2.simplify).to eql f1
+    not_not_f2 = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Not.new(f2))
+    expect(not_not_f2.simplify).to eql var1
+  end
+
+  it 'should apply DeMorgan' do
+    not_var1 = DpllSolver::Formulas::Not.new(var1)
+    not_var2 = DpllSolver::Formulas::Not.new(var2)
+    and_f = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::And.new(var1, var2))
+    and_f_after = DpllSolver::Formulas::Or.new(not_var1, not_var2)
+    or_f = DpllSolver::Formulas::Not.new(DpllSolver::Formulas::Or.new(var1, var2))
+    or_f_after = DpllSolver::Formulas::And.new(not_var1, not_var2)
+    expect(and_f.apply_DeMorgan).to eql and_f_after
+    expect(or_f.apply_DeMorgan).to eql or_f_after
+    expect{ f1.apply_DeMorgan }.to raise_error(ArgumentError)
+    expect{ f2.apply_DeMorgan }.to raise_error(ArgumentError)
+  end
+end
+

data/spec/formulas/or_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::Or 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(:f1) { DpllSolver::Formulas::Not.new(var1)}
+  let(:f2) { DpllSolver::Formulas::Or.new(var1, var2)}
+  let(:f3) { DpllSolver::Formulas::Or.new(f1, f2)}
+  let(:f4) { DpllSolver::Formulas::Or.new(f1, DpllSolver::Formulas::Not.new(f2))}
+  it 'should convert to string' do
+    expect(f2.to_s).to eql "(x1 OR x2)"
+    expect(f3.to_s).to eql "((NOT x1) OR (x1 OR x2))"
+    expect(f4.to_s).to eql "((NOT x1) OR (NOT (x1 OR x2)))"
+  end
+
+  it 'should test syntactic eqivalenz' do
+    expect(f2 == f2).to eql true
+    expect(f2 == DpllSolver::Formulas::Or.new(var1, var2)).to eql true
+    expect(f2 == f3).to eql false
+  end
+
+  it 'should not be a literal' do
+    expect(f2.literal?).to eql false
+    expect(f3.literal?).to eql false
+    expect(f4.literal?).to eql false
+  end
+
+  it 'should not be a atomic formula' do
+    expect(f2.atomic_formula?).to eql false
+    expect(f3.atomic_formula?).to eql false
+    expect(f4.atomic_formula?).to eql false
+  end
+
+  it 'should not be a min term' do
+    expect(f2.min_term?).to eql false
+    expect(f3.min_term?).to eql false
+    expect(f4.min_term?).to eql false
+  end
+
+  it 'should be a clause if both formulas are clause' do
+    expect(f2.clause?).to eql true
+    expect(f3.clause?).to eql true
+    expect(f4.clause?).to eql false
+  end
+
+  it 'should be a nnf, cnf, dnf if both formulas are in nnf, cnf or dnf' do
+    expect(f2.nnf?).to eql true
+    expect(f2.cnf?).to eql true
+    expect(f2.dnf?).to eql true
+    expect(f3.nnf?).to eql true
+    expect(f3.cnf?).to eql true
+    expect(f3.dnf?).to eql true
+    expect(f4.nnf?).to eql false
+    expect(f4.cnf?).to eql false
+    expect(f4.dnf?).to eql false
+  end
+
+  it 'should simply or' do
+    or_falsum1= DpllSolver::Formulas::Or.new(var1, falsum)
+    or_verum1 = DpllSolver::Formulas::Or.new(var1, verum)
+    or_falsum2 = DpllSolver::Formulas::Or.new(falsum, var2)
+    or_verum2 = DpllSolver::Formulas::Or.new(verum, var2)
+    not_f1 = DpllSolver::Formulas::Not.new(f1)
+    or_not = DpllSolver::Formulas::Or.new(not_f1, var1)
+    expect(or_falsum1.simplify).to eql var1
+    expect(or_falsum2.simplify).to eql var2
+    expect(or_verum1.simplify).to eql verum
+    expect(or_verum2.simplify).to eql verum
+    expect(or_not.simplify).to eql var1
+  end
+end
+

data/spec/formulas/variable_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe DpllSolver::Formulas::Variable do
+  let(:var1) { DpllSolver::Formulas::Variable.new("x1") }
+  let(:var2) { DpllSolver::Formulas::Variable.new("x2") }
+  it 'should have "x1" as string and name' do
+    expect(var1.to_s).to eql "x1"
+    expect(var1.name).to eql "x1"
+  end
+
+  it 'should test syntactic eqivalenz' do
+    expect(var1 == var2).to eql false
+    expect(var1 == DpllSolver::Formulas::Variable.new("x1")).to eql true
+  end
+
+  it 'should be a literal' do
+    expect(var1.literal?).to eql true
+  end
+
+  it 'should be a atomic formula' do
+    expect(var1.atomic_formula?).to eql true
+  end
+
+  it 'should be a min term' do
+    expect(var1.min_term?).to eql true
+  end
+
+  it 'should be a nnf' do
+    expect(var1.nnf?).to eql true
+  end
+
+  it 'should be a cnf' do
+    expect(var1.cnf?).to eql true
+  end
+
+  it 'should be a dnf' do
+    expect(var1.dnf?).to eql true
+  end
+
+  it 'should simplify variable' do
+    expect(var1.simplify).to eql var1
+  end
+end
+