satre 0.1.0 → 1.0.0

data/lib/satre/expression/mul.rb

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

@@ -1,14 +0,0 @@
-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/and.rb

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

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

@@ -1,29 +0,0 @@
-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/iff.rb

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

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

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

data/lib/satre/formula/or.rb

@@ -1,25 +0,0 @@
-require 'satre/formula'
-
-module Satre
-  class Or < 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) or q.eval(valudation)
-    end
-
-    def atoms
-      atoms = p.atoms + q.atoms
-      atoms.uniq || []
-    end
-  end
-end

data/lib/satre/formula_parser.rb

@@ -1,92 +0,0 @@
-require 'satre/formula'
-
-module Satre
-  class FormulaParser < Parser
-    class << self
-
-      def parse_formula
-        lambda do |inp|
-          e1, i1 = parse_imp(inp)
-          if i1[0] == '|='
-            e2, i2 = parse_formula.call(i1.drop(1))
-            return Entails.new(e1,e2), i2
-          end
-          return e1, i1
-        end
-      end
-
-      def parse_imp(inp)
-        e1, i1 = parse_iff(inp)
-        if i1[0] == '=>'
-          e2, i2 = parse_formula.call(i1.drop(1))
-          return Imp.new(e1,e2), i2
-        end
-        return e1, i1
-      end
-      
-      def parse_not(inp)
-        if inp.first == '~'
-          e1, i1 = parse_atom(inp.drop(1))
-          return Not.new(e1), i1
-        else
-          e1, i1 = parse_atom(inp)
-          return e1, i1
-        end
-      end
-
-      def parse_and(inp)
-        e1, i1 = parse_or(inp)
-        if i1[0] == '/\\'
-          e2, i2 = parse_formula.call(i1.drop(1))
-          return And.new(e1,e2), i2
-        end
-        return e1, i1
-      end
-
-      def parse_or(inp)
-        e1, i1 = parse_not(inp)
-        if i1[0] == '\\/'
-          e2, i2 = parse_formula.call(i1.drop(1))
-          return Or.new(e1, e2), i2
-        end
-        return e1, i1
-      end
-
-      def parse_iff(inp)
-        e1, i1 = parse_and(inp)
-        if i1[0] == '<=>'
-          e2, i2 = parse_formula.call(i1.drop(1))
-          return Iff.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_formula.call(inp.drop(1))
-          if i2[0] == ')'
-            return e2, i2.drop(1)
-          else
-            fail(ExpressionError, 'Expected closing bracket')
-          end
-        else
-          return False.new, inp.drop(1) if inp[0] == "False"
-          return True.new, inp.drop(1) if inp[0] == "True"
-          return Atom.new(inp[0]), inp.drop(1)
-        end
-      end
-
-      def parse(inp)
-        make_parser.curry.call(parse_formula).call(inp)
-      end
-
-    end
-  end
-end
-
-class String
-  def to_formula
-    Satre::FormulaParser.parse(self)
-  end
-end

data/lib/satre/lexer.rb

@@ -1,47 +0,0 @@
-module Satre
-  class Lexer
-    class << self
-      def matches
-        lambda { |pattern, str| str.split("").all? { |c| pattern.include? c } }
-      end
-
-      def space?
-        self.matches.curry.call(" \t\n\r").dup.freeze
-      end
-
-      def punctuation?
-        self.matches.curry.call("()[]{}").dup.freeze
-      end
-
-      def symbolic?
-        self.matches.curry.call("~`!@#%$^&*-+<=>\\/|").dup.freeze
-      end
-
-      def numeric?
-        self.matches.curry.call("0123456789").dup.freeze
-      end
-
-      def alpanumeric?
-        self.matches.curry.call("abcdefghijklmnopqrstuvwxyz_'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789").dup.freeze
-      end
-
-      def lexwhile(prop, inp)
-        tokl = inp.split("").take_while { |c| prop.call(c) }.inject(:+)
-        tokl = "" if tokl.nil?
-        return tokl, inp[tokl.length..-1]
-      end
-
-      def lex(inp)
-        inp, rest = self.lexwhile(self.space?, inp)
-        return [] if rest == "" || rest.nil?
-        c = rest[0]
-        cs = rest[1..-1]
-        prop =  if self.alpanumeric?.call(c) then self.alpanumeric?
-                elsif self.symbolic?.call(c) then self.symbolic?
-                else proc { false } end
-        toktl, rest = self.lexwhile prop, cs
-        [c+toktl] + lex(rest)
-      end
-    end
-  end
-end