satre 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9284e24b8881153af1c176da6c00ad1d941e9865
-  data.tar.gz: c7b867612d502482258b27a8c3394ed4a3108021
+  metadata.gz: 7bb9d290e43ab1740a0ae02f2fd3114cd97a5551
+  data.tar.gz: 9d0f9212637e9305900abb80d0b173eef4cbdaf8
 SHA512:
-  metadata.gz: 52e4914ee2c6494410df25eb227410a1c6937721b9294968c7fe9ef61f55ba7c1fd8922c4e6b96414357b26033d7a70be0e74046ad003b3018ac5d8fece54c0a
-  data.tar.gz: baa4ae312af5b6eb16d81887d02f823111097388236f0c566583aa57a4a15b7738294852b7cefae4b6241a45cfb4500442dfb7db3ffcbf52d149dd488f75cdb8
+  metadata.gz: 9dfa67b219f98a724c0e1bb145ba540f185e711510f650be7d3f43b10262ff928b67813547bd73ba99e66b0cca35b93461f1f3f8db98eea5ff704c76431b57f9
+  data.tar.gz: d652a9ad06ede5fb9ca5bda81b6ab3a0d5aa1d77b489958ef64156d81b0111c8acb27bc270cdb84e0977167615849288b468e49610b8ba81397542f5910afba3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    satre (0.1.0)
+    satre (1.0.0)
       terminal-table
 
 GEM
@@ -10,6 +10,8 @@ GEM
     ast (2.1.0)
     astrolabe (1.3.1)
       parser (~> 2.2)
+    codeclimate-test-reporter (0.4.8)
+      simplecov (>= 0.7.1, < 1.0.0)
     coderay (1.1.0)
     diff-lcs (1.2.5)
     docile (1.1.5)
@@ -95,6 +97,7 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.10)
+  codeclimate-test-reporter
   guard-bundler
   guard-minitest
   guard-rubocop

data/README.md

@@ -36,30 +36,32 @@ The see the results of the exercise run `./bin/exercise` from the root directory
 To embed proportional logic solving in your project one can use `String#to_formula`, on a well formed proportional logic string.
 Possible operations are
 
-  * True value `"True"`
-  * False value `"False"`
+  * True value `"true"`
+  * False value `"false"`
   * Atomic logical variable `"A"` (or any other alphanumeric combination)
   * logical negation `"~A"`
   * logical and `"A /\\ B"`
   * logical or `"A \\/ B"`
   * Implies `"A <=> B"`
-  * If and only if `"A => B"`
+  * If and only if `"A ==> B"`
   * Entails `"A |= B"`
+  * Forall `"forall x. y"`
+  * Exists `"exists x. y"`
 
 An example
 
 ```ruby
-formula = '(Fire => Smoke) /\\ Fire /\\ ~Smoke'.to_formula 
+formula = '(Fire ==> Smoke) /\\ Fire /\\ ~Smoke'.to_formula 
 ```
 
 To evaluate a formula use `Satre::Formula#eval`
 
 ```ruby
-formula = '(Fire => Smoke) /\\ Fire /\\ ~Smoke'.to_formula 
-formula.eval 'Fire' => true, 'Smoke' => true
+formula = '(Fire ==> Smoke) /\\ Fire /\\ ~Smoke'.to_formula 
+formula.eval Fire: true, Smoke: true
 ```
 
-Further are provided `Satre::Formula#tauntolgy?`,`Satre::Formula#satisfiable?`,`Satre::Formula#unsatisfiable?`
+Further are provided `Satre::Formula#tauntolgy?`,`Satre::Formula#satisfiable?`,`Satre::Formula#unsatisfiable?`, `Satre::Formula#holds?`,`Satre::Formula#wellformed?`
 
 For further information see the doc.
 

data/bin/exercise

@@ -6,16 +6,17 @@ require 'terminal-table'
 
 include Satre
 
-problem_4_1_1 = 'False |= True'.to_formula 
-problem_4_1_2 = 'True |= False'.to_formula 
+problem_4_1_1 = 'false |= true'.to_formula 
+problem_4_1_2 = 'true |= false'.to_formula 
 problem_4_1_3 = '(A /\\ B) |= (A <=> B)'.to_formula 
 problem_4_1_4 = '(A <=> B) |= A \\/ B'.to_formula 
 problem_4_1_5 = '(A <=> B) |= ~A \\/ B'.to_formula 
 
-problem_4_2_1 = 'Smoke => Smoke'.to_formula 
-problem_4_2_2 = '(Smoke => Fire) => (~Smoke => ~Fire)'.to_formula 
+problem_4_2_1 = 'Smoke ==> Smoke'.to_formula 
+problem_4_2_2 = '(Smoke ==> Fire) ==> (~Smoke ==> ~Fire)'.to_formula 
 problem_4_2_3 = 'Smoke \\/ Fire \\/ ~Fire'.to_formula 
-problem_4_2_4 = '(Fire => Smoke) /\\ Fire /\\ ~Smoke'.to_formula 
+problem_4_2_4 = '(Fire ==> Smoke) /\\ Fire /\\ ~Smoke'.to_formula 
+
 
 bsays = 'b <=> (a <=> ~a)'.to_formula
 csays = 'c <=> ~b'.to_formula
@@ -29,6 +30,33 @@ b_is_knave  = Entails.new(kb,'~b'.to_formula)
 c_is_knight = Entails.new(kb,'c'.to_formula)
 c_is_knave  = Entails.new(kb,'~c'.to_formula)
 
+problem_5_1_1_1 = 'g(d,d)'.to_term
+problem_5_1_1_2 = 'f(x,g(y,z),d)'.to_term
+problem_5_1_1_3 = 'g(x,f(y,z),d)'.to_term
+problem_5_1_1_4 = 'f(x,h(x,z),d)'.to_term
+sig_5_1_1 = {d: 0, f: 2, g: 3}
+
+problem_5_1_2_1 = 'S(m, x)'.to_formula
+p problem_5_1_2_1
+problem_5_1_2_2 = 'B(m, f(m))'.to_formula
+problem_5_1_2_3 = 'B(B(m,x),y)'.to_formula
+problem_5_1_2_4 = 'B(x,y) ==> (exists z. S(z,y))'.to_formula
+problem_5_1_2_5 = 'S(x,y) ==> S(y,f(f(x)))'.to_formula
+sig_5_1_2 = {m: 0, f: 1, S: 2, B: 2}
+
+axiom_1 = "forall x. x = x".to_formula
+axiom_2 = "forall x y. (x = y ==> y = x)".to_formula
+axiom_3 = "forall x y z. (x = y /\\ y = x ==> x = z)".to_formula
+
+domain = (0..23).to_a
+valudation = {}
+func = ->(f, args) {}
+empty = ->(p, args) { if p == '=' then false else fail "undefined predicate #{p}" end }
+universal = ->(p, args) { if p == '=' then true else fail "undefined predicate #{p}" end }
+equality = ->(p, args) { if p == '=' then args.inject(:==) else fail "undefined predicate #{p}" end }
+even_sum = ->(p, args) { if p == '=' then args.inject(:+).even? else fail "undefined predicate #{p}" end }
+modular_aritmetic = ->(p, args) { if p == '=' then args[0] == (args[1] % 16) else fail "undefined predicate #{p}" end }
+
 problem_4_1 = Terminal::Table.new do |t|
   t.title = 'Problem 4.1'
   t.headings = ['', 'Formula', 'Result' ]
@@ -39,7 +67,6 @@ problem_4_1 = Terminal::Table.new do |t|
   t << ['5.', problem_4_1_5, problem_4_1_5.eval ]
 end
 
-
 problem_4_2 = Terminal::Table.new do |t|
   t.title = 'Problem 4.2'
   t.headings = ['', 'Formula', 'tauntolgy?', 'satifiable?', 'unsatifiable?']
@@ -56,15 +83,44 @@ problem_4_3 = Terminal::Table.new do |t|
   t << ['is knave?', a_is_knave.eval , b_is_knave.eval , c_is_knave.eval ]
 end
 
+problem_5_1_1 = Terminal::Table.new do |t|
+  t.title = 'Problem 5.1.1'
+  t.headings = ['', 'Term', 'Signature', 'wellformed?']
+  t << ['1.', problem_5_1_1_1, sig_5_1_1.to_s, problem_5_1_1_1.wellformed?(sig_5_1_1) ]
+  t << ['2.', problem_5_1_1_2, sig_5_1_1.to_s, problem_5_1_1_2.wellformed?(sig_5_1_1) ]
+  t << ['3.', problem_5_1_1_3, sig_5_1_1.to_s, problem_5_1_1_3.wellformed?(sig_5_1_1) ]
+  t << ['4.', problem_5_1_1_4, sig_5_1_1.to_s, problem_5_1_1_4.wellformed?(sig_5_1_1) ]
+end
+
+problem_5_1_2 = Terminal::Table.new do |t|
+  t.title = 'Problem 5.1.2'
+  t.headings = ['', 'Formula', 'Signature', 'wellformed?']
+  t << ['1.', problem_5_1_2_1, sig_5_1_2.to_s, problem_5_1_2_1.wellformed?(sig_5_1_2) ]
+  t << ['2.', problem_5_1_2_2, sig_5_1_2.to_s, problem_5_1_2_2.wellformed?(sig_5_1_2) ]
+  t << ['3.', problem_5_1_2_3, sig_5_1_2.to_s, problem_5_1_2_3.wellformed?(sig_5_1_2) ]
+  t << ['4.', problem_5_1_2_4, sig_5_1_2.to_s, problem_5_1_2_4.wellformed?(sig_5_1_2) ]
+  t << ['5.', problem_5_1_2_5, sig_5_1_2.to_s, problem_5_1_2_5.wellformed?(sig_5_1_2) ]
+end
+
+problem_5_2 = Terminal::Table.new do |t|
+  t.title = 'Problem 5.2'
+  t.headings = ['relation', "#{axiom_1}.holds?", "#{axiom_2}.holds?", "#{axiom_3}.holds?"] 
+  t << ['empty', axiom_1.holds?(domain, func, empty, valudation), axiom_2.holds?(domain, func, empty, valudation), axiom_3.holds?(domain, func, empty, valudation)]
+  t << ['universal', axiom_1.holds?(domain, func, universal, valudation), axiom_2.holds?(domain, func, universal, valudation), axiom_3.holds?(domain, func, universal, valudation)]
+  t << ['equality', axiom_1.holds?(domain, func, equality, valudation), axiom_2.holds?(domain, func, equality, valudation), axiom_3.holds?(domain, func, equality, valudation)]
+  t << ['even sum', axiom_1.holds?(domain, func, even_sum, valudation), axiom_2.holds?(domain, func, even_sum, valudation), axiom_3.holds?(domain, func, even_sum, valudation)]
+  t << ['modular aritmetic', axiom_1.holds?(domain, func, modular_aritmetic, valudation), axiom_2.holds?(domain, func, modular_aritmetic, valudation), axiom_3.holds?(domain, func, modular_aritmetic, valudation)]
+end
 
 puts problem_4_1
 puts """I used a similar approach in my pencil-and-paper derivations
 first subtitude the entails a |= b with a /\\ ~b and then check this statement
 on unsatisfiability.
 """
-
 puts problem_4_2
 puts problem_4_3
-
 puts """This approach uses the entails functions to solve the puzzle,
 while in the exercise we substituded with the rules until clear statements were made."""
+puts problem_5_1_1
+puts problem_5_1_2
+puts problem_5_2

data/lib/satre.rb

@@ -1,6 +1,4 @@
 require 'satre/version'
-require 'satre/expression'
-require 'satre/lexer'
+require 'satre/errors'
 require 'satre/formula'
 require 'satre/parser'
-require 'satre/formula_parser'

data/lib/satre/errors.rb

@@ -0,0 +1,3 @@
+require 'satre/errors/expression_error'
+require 'satre/errors/parser_error'
+require 'satre/errors/argument_error'

data/lib/satre/errors/argument_error.rb

@@ -0,0 +1,2 @@
+class ArgumentError < StandardError
+end

data/lib/satre/errors/expression_error.rb

@@ -0,0 +1,2 @@
+class ExpressionError < StandardError
+end

data/lib/satre/errors/parser_error.rb

@@ -0,0 +1,2 @@
+class ParserError < StandardError
+end

data/lib/satre/formula.rb

@@ -1,10 +1,4 @@
 require 'satre/formula/formula'
-require 'satre/formula/and'
-require 'satre/formula/atom'
-require 'satre/formula/entails'
-require 'satre/formula/false'
-require 'satre/formula/iff'
-require 'satre/formula/imp'
-require 'satre/formula/not'
-require 'satre/formula/or'
-require 'satre/formula/true'
+require 'satre/formula/term'
+require 'satre/formula/propositional_logic'
+require 'satre/formula/first_order_logic'

data/lib/satre/formula/first_order_logic.rb

@@ -0,0 +1,4 @@
+require 'satre/formula/first_order_logic/exists'
+require 'satre/formula/first_order_logic/fol_formula'
+require 'satre/formula/first_order_logic/forall'
+require 'satre/formula/first_order_logic/relation'

data/lib/satre/formula/first_order_logic/exists.rb

@@ -0,0 +1,32 @@
+require 'satre/formula/first_order_logic/fol_formula'
+
+module Satre
+  class Exists < Fol_Formula
+    attr_reader :variable
+    attr_reader :term
+
+    def initialize(variable, term)
+      #fail(ArgumentError, '...') unless variable.is_a?(Formula)
+      #fail(ArgumentError, '...') unless term.is_a?(Formula)
+      @variable = variable.dup.freeze
+      @term = term.dup.freeze
+    end
+
+    # exists x. p is well-formed if p is well-formed
+    def wellformed?(sig)
+      term.wellformed?(sig)
+    end
+
+    # Exists(x,p) -> exists (fun a -> holds m ((x |-> a) v) p) domain;;
+    def holds?(domain, func, pred, valudation)
+      domain.any? do |a|
+        valudation[variable.to_s.to_sym] = a
+        term.holds?(domain, func, pred, valudation )
+      end
+    end
+
+    def to_s
+      "∃ #{variable}. #{term}"
+    end
+  end
+end

data/lib/satre/formula/first_order_logic/fol_formula.rb

@@ -0,0 +1,35 @@
+require 'satre/formula/formula'
+
+module Satre
+  class Fol_Formula < Formula
+
+    # let rec holds (domain, func, pred as m) v fm =
+    #   match fm with
+    #     False -> false
+    #   | True -> true
+    #   | Atom(R(r,args)) -> pred r (map (termval m v) args)
+    #   | Not(p) -> not(holds m v p)
+    #   | And(p,q) -> (holds m v p) & (holds m v q)
+    #   | Or(p,q) -> (holds m v p) or (holds m v q)
+    #   | Imp(p,q) -> not(holds m v p) or (holds m v q)
+    #   | Iff(p,q) -> (holds m v p = holds m v q)
+    #   | Forall(x,p) -> forall (fun a -> holds m ((x |-> a) v) p) domain
+    #   | Exists(x,p) -> exists (fun a -> holds m ((x |-> a) v) p) domani;;
+    def holds?(domain, func, predicate, valudation)
+      fail 'abstract method'
+    end
+
+    # 1. Constant True and False are wellformed
+    # 2. Predicate $p(x_1, \dots, x_n)$ is well-formed if
+    #    (a) Each term is $x_1, \dots, x_n$ is well formed
+    #    (b) There is a pair (q, m) in signature sig q = p and n = m
+    # 3. p //\ q is wellformed if p and q are wellformed
+    # 4. p \// q is wellformed if p and q are wellformed
+    # 5. p ==> q is wellformed if p and q are wellformed
+    # 6. p <=> q is wellformed if p and q are wellformed
+    # 7. forall x. p and exists x. p are wellformed if p is wellformed
+    def wellformed?(signature)
+      fail 'abstract method'
+    end
+  end
+end

data/lib/satre/formula/first_order_logic/forall.rb

@@ -0,0 +1,32 @@
+require 'satre/formula/first_order_logic/fol_formula'
+
+module Satre
+  class Forall < Fol_Formula
+    attr_reader :variable
+    attr_reader :term
+
+    def initialize(variable, term)
+      #fail(ArgumentError, "Variable was #{variable.class}") unless variable.is_a?(Formula)
+      #fail(ArgumentError, "Term was #{term.class}") unless term.is_a?(Formula)
+      @variable = variable.dup.freeze
+      @term = term.dup.freeze
+    end
+    
+    # forall x. p is well-formed if p is well-formed
+    def wellformed?(sig)
+      term.wellformed?(sig)
+    end
+
+    #   | Forall(x,p) -> forall (fun a -> holds m ((x |-> a) v) p) domain
+    def holds?(domain, func, pred, valudation)
+      domain.all? do |a|
+        valudation[variable.to_s.to_sym] = a
+        term.holds?(domain, func, pred, valudation) 
+      end
+    end
+    
+    def to_s
+      "∀ #{variable}. #{term}"
+    end
+  end
+end

data/lib/satre/formula/first_order_logic/relation.rb

@@ -0,0 +1,38 @@
+require 'satre/formula/first_order_logic/fol_formula'
+
+module Satre
+  # A first-order-logig relation between terms
+  #
+  # Typical relations are
+  #   p > q - term p is greater than term p
+  #   p < q - term p is less than term p
+  #   p = q - term p is equvivalent to term p
+  #   p >= q - term p is greter or equvivalent to term q
+  #   p <= q - term p is less or equvivalent to term q
+  #   p != q - term p is not equvivalent to term q
+  class Relation < Fol_Formula
+    attr_reader :relation
+    attr_reader :term_list
+
+    def initialize(relation, term_list)
+      @relation = relation.dup.freeze
+      @term_list = term_list.dup.freeze
+    end
+
+    def holds?(domain, func, predicate, valudation)
+      predicate.call(relation, term_list.map { |t| t.validate(func, predicate, valudation) })
+    end
+    # A predicate p(x_1,...,x_n) is well-formed if
+    #   (a) each term x_1,...,x_n is well-formed
+    #   (b) there is a pair (q, m) in signature sig where q = p and n = m
+    def wellformed?(sig)
+      term_list.all? { |x| x.wellformed?(sig) } && sig[relation.to_sym] == term_list.length
+    end
+
+    def to_s
+      return term_list.map(&:to_s).join(relation.to_s) if ['>','<','=','<=','>=','!='].include?(relation)
+      s = term_list.map(&:to_s).join(',')
+      "#{relation}#{"("+s+")" unless s.to_s == ''}"
+    end
+  end
+end

data/lib/satre/formula/formula.rb

@@ -3,18 +3,7 @@ module Satre
     include Comparable
     
     def <=>(other)
-      base <=> other.base
-    end
-
-    attr_reader :base
-
-    def initialize(base)
-      fail(ArgumentError, 'Argument must be a String') unless base.is_a?(String)
-      @base = base.dup.freeze
-    end
-
-    def to_s
-      base
+      self.to_s <=> other.to_s
     end
 
     def atoms
@@ -53,7 +42,6 @@ module Satre
     end
 
     def entails?(other)
-      #Imp.new(self, other).tautology?
       And.new(self, Not.new(other)).unsatifiable?
     end
 

data/lib/satre/formula/propositional_logic.rb

@@ -0,0 +1,9 @@
+require 'satre/formula/propositional_logic/and'
+require 'satre/formula/propositional_logic/atom'
+require 'satre/formula/propositional_logic/entails'
+require 'satre/formula/propositional_logic/false'
+require 'satre/formula/propositional_logic/iff'
+require 'satre/formula/propositional_logic/imp'
+require 'satre/formula/propositional_logic/not'
+require 'satre/formula/propositional_logic/or'
+require 'satre/formula/propositional_logic/true'

data/lib/satre/formula/propositional_logic/and.rb

@@ -0,0 +1,37 @@
+require 'satre/formula'
+
+module Satre
+  class And < Formula
+    attr_reader :left_conjunct
+    attr_reader :right_conjunct
+
+    def initialize(left_conjunct, right_conjunct)
+      fail(ArgumentError, 'Argument must be a Formula') unless left_conjunct.is_a?(Formula)
+      fail(ArgumentError, 'Argument must be a Formula') unless right_conjunct.is_a?(Formula)
+      @left_conjunct = left_conjunct.dup.freeze
+      @right_conjunct = right_conjunct.dup.freeze
+    end
+
+    def to_s
+      "(#{left_conjunct} ∧ #{right_conjunct})"
+    end
+
+    def holds?(domain, func, pred, valudation)
+      left_conjunct.holds?(domain, func, pred, valudation) && right_conjunct.holds?(domain, func, pred, valudation)
+    end
+
+    # p /\\ q is well-formed if p and q are well-formed
+    def wellformed?(sig)
+      left_conjunct.wellformed?(sig) && right_conjunct.wellformed(sig)
+    end
+
+    def eval(valudation)
+      left_conjunct.eval(valudation) && right_conjunct.eval(valudation)
+    end
+
+    def atoms
+      atoms = left_conjunct.atoms + right_conjunct.atoms
+      atoms.uniq || []
+    end
+  end
+end