satre 0.1.0 → 1.0.0

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

@@ -0,0 +1,44 @@
+require 'satre/formula'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  # A propositional 'atomic' value
+  class Atom < Formula
+    
+    attr_reader :value
+
+    def initialize(value)
+      @value = value.dup.freeze
+    end
+
+    def holds?(domain, func, predicate, valudation)
+      fail(OperationExceprion, 'Atomic value must be a relation') unless value.is_a?(Relation)
+      value.holds?(domain, 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)
+      @value.wellformed?(sig)
+    end
+
+    def eval(valudation)
+      fail(Error, 'valudation must be a hash') unless valudation.is_a?(Hash)
+      fail(Error, 'all validations must be booleans') unless valudation.values.all?{|b|!!b == b}
+      valudation = valudation.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      fail(Error, "valudation for Atom #{value} not given") unless valudation.keys.include?(to_s.to_sym)
+      valudation[to_s.to_sym]
+    end
+    
+    def to_s
+      value.to_s
+    end
+
+    def atoms
+      [value.to_s.to_sym]
+    end
+
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'satre/formula'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  # A propositional logic 'and' value
+  class Entails < Formula
+    attr_reader :knowledge_base
+    attr_reader :logical_consequence
+
+    def initialize(knowledge_base, logical_consequence)
+      fail(ArgumentError, 'Argument must be a Formula') unless knowledge_base.is_a?(Formula)
+      fail(ArgumentError, 'Argument must be a Formula') unless logical_consequence.is_a?(Formula)
+      @knowledge_base = knowledge_base.dup.freeze
+      @logical_consequence = logical_consequence.dup.freeze
+    end
+
+    def to_s
+      "(#{knowledge_base} ⊨ #{logical_consequence})"
+    end
+
+    # p |= q is wellformed if p and q are well-formed
+    def wellformed?(sig)
+      knowledge_base.wellformed?(sig) && logical_consequence.wellformed?(sig)
+    end
+
+    def hold?(domain, func, predicate, valudation)
+      fail 'not implemented'
+      #And.new(knowledge_base, Not.new(logical_consequence)).unsatifiable?
+    end
+
+    def eval(*)
+      And.new(knowledge_base, Not.new(logical_consequence)).unsatifiable?
+    end
+
+    def atoms
+      atoms = knowledge_base.atoms + logical_consequence.atoms
+      atoms.uniq || []
+    end
+
+  end
+end

data/lib/satre/formula/{false.rb → propositional_logic/false.rb}

@@ -3,8 +3,15 @@ require 'satre/formula'
 module Satre
   class False < Formula
 
-    def initialize
-      super '⊥'
+    def to_s
+      '⊥'
+    end
+
+    alias :holds? :eval
+
+    # False is well-formed
+    def wellformed?(sig)
+      true
     end
 
     def eval(*)

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

@@ -0,0 +1,38 @@
+require 'satre/formula'
+
+module Satre
+  class Iff < Formula
+    attr_reader :left_conditional
+    attr_reader :right_conditional
+
+    def initialize(left_conditional, right_conditional)
+      fail(ArgumentError, 'Argument must be a Formula') unless left_conditional.is_a?(Formula)
+      fail(ArgumentError, 'Argument must be a Formula') unless right_conditional.is_a?(Formula)
+      @left_conditional = left_conditional.dup.freeze
+      @right_conditional = right_conditional.dup.freeze
+    end
+
+    def holds?(domain, func, pred, valudation)
+      left_conditional.holds?(domain, func, pred, valudation) == right_conditional.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 to_s
+      "(#{left_conditional} ⇔ #{right_conditional})"
+    end
+
+    def eval(valudation)
+      left_conditional.eval(valudation) == right_conditional.eval(valudation)
+    end
+
+    def atoms
+      atoms = left_conditional.atoms + right_conditional.atoms
+      atoms.uniq || []
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+require 'satre/formula'
+
+module Satre
+  class Imp < Formula
+    attr_reader :antendence
+    attr_reader :consequence
+
+    def initialize(antendence, consequence)
+      fail(ArgumentError, "Argument must be a Formula p:#{p}") unless antendence.is_a?(Formula)
+      fail(ArgumentError, "Argument must be a Formula q:#{q}") unless consequence.is_a?(Formula)
+      @antendence = antendence.dup.freeze
+      @consequence = consequence.dup.freeze
+    end
+
+    def to_s
+      "(#{antendence} → #{consequence})"
+    end
+
+    # p ==> q is well-formed if p and q are well-formed
+    def wellformed?(sig)
+      antendence.wellformed?(sig) && consequence.wellformed?(sig)
+    end
+
+    #   | Imp(p,q) -> not(holds m v p) or (holds m v q)
+    def holds?(domain, func, pred, valudation)
+      (! antendence.holds?(domain, func, pred, valudation)) || (consequence.holds?(domain, func, pred, valudation))
+    end
+
+    def eval(valudation)
+      (! antendence.eval(valudation)) || (consequence.eval(valudation))
+    end
+
+    def atoms
+      atoms = antendence.atoms + consequence.atoms
+      atoms.uniq || []
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'satre/formula'
+
+module Satre
+  class Not < Formula
+    attr_reader :literal
+
+    def initialize(literal)
+      fail(ArgumentError, 'Argument must be a Formula') unless literal.is_a?(Formula)
+      @literal = literal.dup.freeze
+    end
+
+    def to_s
+      "(¬#{literal})"
+    end
+
+    def holds?(domain, func, pred, valudation)
+      ! literal.holds?(domain, func, pred, valudation)
+    end
+
+    # ~p is well-formed if p is well-formed
+    def wellformed?(sig)
+      literal.wellformed?(sig)
+    end
+
+    def eval(valudation)
+      ! literal.eval(valudation)
+    end
+
+    def atoms
+      literal.atoms || []
+    end
+
+  end
+end

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

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

data/lib/satre/formula/{true.rb → propositional_logic/true.rb}

@@ -2,8 +2,17 @@ require 'satre/formula'
 
 module Satre
   class True < Formula
-    def initialize
-      super '⊤'
+
+    def to_s
+      '⊤'
+    end
+
+    # true holds
+    alias :holds? :eval
+
+    # True is wellformed
+    def wellformed?(_)
+      true
     end
 
     def eval(*)

data/lib/satre/formula/term.rb

@@ -0,0 +1,3 @@
+require 'satre/formula/term/term.rb'
+require 'satre/formula/term/function.rb'
+require 'satre/formula/term/variable.rb'

data/lib/satre/formula/term/function.rb

@@ -0,0 +1,33 @@
+require 'satre/formula/term/term'
+
+module Satre
+  class Function < Term
+    attr_reader :function
+    attr_reader :term_list
+
+    def initialize(function, term_list=[])
+      #fail(ArgumentError, '...') unless function.is_a?(String)
+      #fail(ArgumentError, '...') unless term_list.is_a?(Array)
+      @function = function.dup.freeze
+      @term_list = term_list.dup.freeze
+    end
+
+    # A term $f(x_1,...,x_n)$ is well-formed if
+    #   (a) Each term $x_1,...,x_n$ is well formed
+    #   (b) There is a pair (a, m) in signature sig where s = f and n = m
+    #
+    # sig is a hash containing the signature domain
+    def wellformed?(sig)
+      term_list.all? { |x| x.wellformed?(sig) } && sig[function.to_sym] == term_list.length
+    end
+
+    #   | Fn(f,args) -> func f (map (termval m v), args);;
+    def validate(func, pred, valudation)
+      func.call(f, term_list.map { |t| t.validate(func, pred, valudation) })
+    end
+
+    def to_s
+      "#{function}(#{term_list.map(&:to_s).join(',')})"
+    end
+  end
+end

data/lib/satre/formula/term/term.rb

@@ -0,0 +1,6 @@
+require 'satre/formula/formula'
+
+module Satre
+  class Term < Formula
+  end
+end

data/lib/satre/formula/term/variable.rb

@@ -0,0 +1,24 @@
+require 'satre/formula/term/term'
+
+module Satre
+  class Variable < Term
+    attr_reader :variable
+
+    def initialize(variable)
+      @variable = variable.dup.freeze
+    end
+
+    # A variable is well-formed
+    def wellformed?(_)
+      true
+    end
+
+    def validate(_, _, valudation)
+      valudation[variable.to_sym]
+    end
+
+    def to_s
+      variable.to_s
+    end
+  end
+end

data/lib/satre/parser.rb

@@ -1,15 +1,4 @@
-require 'satre/lexer'
-
-module Satre
-  class Parser
-    class << self
-      def make_parser
-        lambda do |pfn, inp|
-          expr, rest = pfn.call(Lexer.lex(inp))
-          return expr if rest == []
-          fail(ParserError, 'Unparsed input')
-        end
-      end
-    end
-  end
-end
+require 'satre/parser/lexer'
+require 'satre/parser/parser'
+require 'satre/parser/formula_parser'
+require 'satre/parser/term_parser'

data/lib/satre/parser/formula_parser.rb

@@ -0,0 +1,74 @@
+require 'satre/parser/parser'
+
+module Satre
+  class FormulaParser < Parser
+    class << self
+
+      def parse_formula(ifn, afn, vs, inp)
+        parse_Entails = parse_right_infix("|=", ->(p,q) { Entails.new(p,q)})
+        parse_Iff = parse_right_infix("<=>", ->(p,q) { Iff.new(p,q)})
+        parse_Imp = parse_right_infix("==>", ->(p,q) { Imp.new(p,q)})
+        parse_Or = parse_right_infix("\\/", ->(p,q) { Or.new(p,q)})
+        parse_And = parse_right_infix("/\\", ->(p,q) { And.new(p,q)})
+        parse_Atom = method(:parse_atomic_formula).curry.call(ifn, afn, vs)
+        parse_Entails.call(parse_Imp.call(parse_Or.call(parse_And.call(parse_Iff.call(parse_Atom)))),inp)
+      end
+
+      # absorbs the list of variables allowing the convention of
+      # repeated quantifiers
+      def parse_quant(ifn, afn, vs, qcon, x, inp)
+        fail(ArgumentError, 'Body of quantified term expected') if inp == []
+        head = inp.first
+        rest = inp[1..-1]
+        ast, rest = if head == '.' then parse_formula(ifn, afn, vs, rest) else parse_quant(ifn, afn, vs.push(head), qcon, head, rest) end
+        papply( ->(fm) { qcon.call(x,fm) }, ast, rest )
+      end
+
+      # ifn: restricted parser for infix atoms
+      # afn: more general parser for arbitary atoms
+      def parse_atomic_formula(ifn, afn, vs, inp)
+        fail(ArgumentError, 'Expected an formula at end of input') if inp == []
+        head = inp.first
+        rest = inp[1..-1]
+        case head 
+        when "false" then return False.new, rest
+        when "true" then return True.new, rest
+        when "(" 
+          begin
+            ifn.call(vs, inp)
+          rescue
+            parse_bracketed(method(:parse_formula).curry.call(ifn, afn, vs), ")", rest)
+          end
+        when "~"
+          ast, rest = parse_atomic_formula(ifn, afn, vs, rest)
+          papply(->(p) { Not.new(p) }, ast, rest)
+        when "forall" then 
+          parse_quant(ifn, afn, vs.push(rest[0]), ->(x,p) { Forall.new(x,p) }, rest[0], rest[1..-1])
+        when "exists" then parse_quant(ifn, afn, vs.push(rest[0]), ->(x,p) { Exists.new(x,p) }, rest[0], rest[1..-1])
+        else afn.call(vs, inp)
+        end
+      end
+
+      def parse_infix_atom(vs, inp)
+        tm, rest = TermParser.parse_term(vs, inp)
+        if rest != [] && ["=", '<', '<=', '>', ">="].include?(rest.first)
+          ast, ost = TermParser.parse_term(vs, rest[1..-1])
+          papply( ->(tm_) {Atom.new(Relation.new(rest[0], [tm, tm_]))  }, ast, ost )
+        else fail ParserError, 'calculated' # Excepion erfinden
+        end
+      end
+
+      def parse(inp)
+        make_parser(method(:parse_formula).curry.call(method(:parse_infix_atom),
+          TermParser.method(:parse_atom), []), inp)
+      end
+
+    end
+  end
+end
+
+class String
+  def to_formula
+    Satre::FormulaParser.parse(self)
+  end
+end