satre 0.1.0

data/lib/satre/expression.rb

@@ -0,0 +1,6 @@
+require 'satre/expression/expression'
+require 'satre/expression/add'
+require 'satre/expression/const'
+require 'satre/expression/expression_parser'
+require 'satre/expression/mul'
+require 'satre/expression/var'

data/lib/satre/expression/add.rb

@@ -0,0 +1,26 @@
+require 'satre/expression'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  class Add < Expression
+    attr_reader :p
+    attr_reader :q
+
+    def initialize(p,q)
+      fail(ArgumentError, 'p must be a expression') unless p.is_a?(Expression)
+      fail(ArgumentError, 'q must be a expression') unless p.is_a?(Expression)
+      @p = p.dup.freeze
+      @q = q.dup.freeze
+      super "Add (#{@p},#{@q})"
+    end
+
+    def eval
+      p.eval + q.eval
+    end
+
+    def self.parse(e)
+      fail 'not yet implemented'
+    end
+  end
+end

data/lib/satre/expression/const.rb

@@ -0,0 +1,23 @@
+require 'satre/expression'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  class Const < Expression
+    attr_reader :i
+
+    def initialize(i)
+      ArgumentError 'argument must be an integer' unless i.is_a? Integer
+      @i = i
+      super "Const #{i}"
+    end
+
+    def eval
+      i
+    end
+
+    def self.parse(e)
+      fail 'not yet implemented'
+    end
+  end
+end

data/lib/satre/expression/expression.rb

@@ -0,0 +1,22 @@
+module Satre
+  class Expression
+    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
+    end
+
+    def eval # abstract method
+      fail 'abstract'
+    end
+
+    def simplify
+      fail 'not yet implemented'
+    end
+  end
+end

data/lib/satre/expression/expression_parser.rb

@@ -0,0 +1,56 @@
+require 'satre/parser'
+
+module Satre
+  class ExpressionParser < Parser
+    class << self
+      def parse_expression
+        lambda do |inp| 
+          e1, i1 = parse_product(inp) 
+          if i1[0] == '+' 
+            e2, i2 = parse_expression.call(i1.drop(1))
+            return Add.new(e1, e2), i2
+          end
+          return e1, i1
+        end
+      end
+
+      def parse_product(inp)
+        e1, i1 = parse_atom(inp)
+        if i1[0] == '*' 
+          e2,i2 = parse_expression.call(i1.drop(1))
+          return Mul.new(e1, e2), i2
+        end
+        return e1, i1
+      end
+
+      def parse_atom(inp)
+        fail(ArgumentError, 'Expected an expression at end of input') if inp == []
+        if inp[0] == '('
+          e2, i2 = parse_expression.call(inp.drop(1))
+          if i2[0] == ')'
+            return e2, i2.drop(1)
+          else
+            fail(ExpressionError, 'Expected closing bracket')
+          end
+        else
+          if Lexer.numeric?.call(inp[0])
+            return Const.new(inp[0].to_i), inp.drop(1)
+          else
+            return Var.new(inp[0]), inp.drop(1)
+          end
+        end
+      end
+
+      def parse(inp)
+        make_parser.curry.call(parse_expression).call(inp)
+      end
+    end
+
+  end
+end
+
+class String
+  def to_expression
+    Satre::ExpressionParser.parse(self)
+  end
+end

data/lib/satre/expression/mul.rb

@@ -0,0 +1,30 @@
+require 'satre/expression'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  class Mul < Expression
+    attr_reader :p
+    attr_reader :q
+
+    def initialize(p,q)
+      fail(ArgumentError, 'p must be a expression') unless p.is_a?(Expression)
+      fail(ArgumentError, 'q must be a expression') unless p.is_a?(Expression)
+      @p = p.dup.freeze
+      @q = q.dup.freeze
+      super "Mul(#{@p},#{@q})"
+    end
+
+    def eval
+      p.eval * q.eval
+    end
+
+    def self.parse(e)
+      e1, i1 = Expression.parse(inp)
+      if e1[-1] == '*'
+        _e2,i2 = parse_expression(i1)
+        return Mul.new(e1,i1), i2
+      end
+    end
+  end
+end

data/lib/satre/expression/var.rb

@@ -0,0 +1,14 @@
+require 'satre/expression'
+
+module Satre
+  class Var < Expression
+    def initialize(s)
+      fail(ArgumentError, 's must be a string') unless s.is_a?(String)
+      super "Var \"#{s}\""
+    end
+
+    def eval(_valudation)
+      fail 'not implemented'
+    end
+  end
+end

data/lib/satre/formula.rb

@@ -0,0 +1,10 @@
+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'

data/lib/satre/formula/and.rb

@@ -0,0 +1,26 @@
+require 'satre/formula'
+
+module Satre
+  class And < Formula
+    attr_reader :p
+    attr_reader :q
+
+    def initialize(p,q)
+      fail(ArgumentError, 'Argument must be a Formula') unless p.is_a?(Formula)
+      fail(ArgumentError, 'Argument must be a Formula') unless q.is_a?(Formula)
+      @p = p.dup.freeze
+      @q = q.dup.freeze
+      super "(#{@p} ∧ #{@q})"
+    end
+
+    def eval(v)
+      p.eval(v) && q.eval(v)
+    end
+
+    def atoms
+      atoms = p.atoms + q.atoms
+      atoms.uniq || []
+    end
+
+  end
+end

data/lib/satre/formula/atom.rb

@@ -0,0 +1,28 @@
+require 'satre/formula'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  # A propositional 'atomic' value
+  class Atom < Formula
+    
+    attr_reader :base
+
+    def initialize(base)
+      super base
+    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 #{base} not given") unless valudation.keys.include?(base.to_sym)
+      valudation[base.to_sym]
+    end
+
+    def atoms
+      [base]
+    end
+
+  end
+end

data/lib/satre/formula/entails.rb

@@ -0,0 +1,29 @@
+require 'satre/formula'
+
+# A parster for propositional statements
+# and simple mathematical expressions
+module Satre
+  # A propositional logic 'and' value
+  class Entails < Formula
+    attr_reader :p
+    attr_reader :q
+
+    def initialize(p,q)
+      fail(ArgumentError, 'Argument must be a Formula') unless p.is_a?(Formula)
+      fail(ArgumentError, 'Argument must be a Formula') unless q.is_a?(Formula)
+      @p = p.dup.freeze
+      @q = q.dup.freeze
+      super "(#{@p} ⊨ #{@q})"
+    end
+
+    def eval(*)
+      p.entails?(q) 
+    end
+
+    def atoms
+      atoms = p.atoms + q.atoms
+      atoms.uniq || []
+    end
+
+  end
+end

data/lib/satre/formula/false.rb

@@ -0,0 +1,19 @@
+require 'satre/formula'
+
+module Satre
+  class False < Formula
+
+    def initialize
+      super '⊥'
+    end
+
+    def eval(*)
+      false
+    end
+
+    def atoms
+      []
+    end
+
+  end
+end

data/lib/satre/formula/formula.rb

@@ -0,0 +1,61 @@
+module Satre
+  class Formula
+    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
+    end
+
+    def atoms
+      fail 'abstract'
+    end
+
+    def on_all_valuations?
+      valudation = Hash[self.atoms.map { |x| [x, true] }]
+      truthtable = [valudation]
+      valudation.length.times do |i|
+        v = {}
+        (valudation.length - i).times do |j| 
+          v = valudation.dup
+          v[v.keys[j]] = ! v[v.keys[j]]
+          truthtable << v
+        end
+        valudation = v
+      end
+      truthtable.all? { |v| self.eval(v) }
+    end
+
+    def eval(_valudation)
+      fail 'abstract'
+    end
+
+    def tautology?
+      on_all_valuations?
+    end
+
+    def unsatifiable?
+      Not.new(self).tautology?
+    end
+
+    def satifiable?
+      not unsatifiable?
+    end
+
+    def entails?(other)
+      #Imp.new(self, other).tautology?
+      And.new(self, Not.new(other)).unsatifiable?
+    end
+
+  end
+end

data/lib/satre/formula/iff.rb

@@ -0,0 +1,27 @@
+require 'satre/formula'
+
+module Satre
+  class Iff < Formula
+    attr_reader :p
+    attr_reader :q
+
+    def initialize(p,q)
+      fail(ArgumentError, 'Argument must be a Formula') unless p.is_a?(Formula)
+      fail(ArgumentError, 'Argument must be a Formula') unless q.is_a?(Formula)
+      @p = p.dup.freeze
+      @q = q.dup.freeze
+      super "(#{@p} ⇔ #{@q})"
+    end
+
+    def eval(valudation)
+      p.eval(valudation) == q.eval(valudation)
+    end
+
+    def atoms
+      atoms = p.atoms + q.atoms
+      atoms.uniq || []
+    end
+
+  end
+end
+

data/lib/satre/formula/imp.rb

@@ -0,0 +1,25 @@
+require 'satre/formula'
+
+module Satre
+  class Imp < Formula
+    attr_reader :p
+    attr_reader :q
+
+    def initialize(p,q)
+      fail(ArgumentError, "Argument must be a Formula p:#{p}") unless p.is_a?(Formula)
+      fail(ArgumentError, "Argument must be a Formula q:#{q}") unless q.is_a?(Formula)
+      @p = p.dup.freeze
+      @q = q.dup.freeze
+      super "(#{@p} → #{@q})"
+    end
+
+    def eval(valudation)
+      (! p.eval(valudation)) or (q.eval(valudation))
+    end
+
+    def atoms
+      atoms = p.atoms + q.atoms
+      atoms.uniq || []
+    end
+  end
+end

data/lib/satre/formula/not.rb

@@ -0,0 +1,22 @@
+require 'satre/formula'
+
+module Satre
+  class Not < Formula
+    attr_reader :p
+
+    def initialize(p)
+      fail(ArgumentError, 'Argument must be a Formula') unless p.is_a?(Formula)
+      @p = p.dup.freeze
+      super "(¬#{@p})"
+    end
+
+    def eval(valudation)
+      ! p.eval(valudation)
+    end
+
+    def atoms
+      p.atoms || []
+    end
+
+  end
+end