propose 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e51a21663914889a221fc855ab81d9b864e4f7c
+  data.tar.gz: c100032842cfb108b8181ca745767d428921aac4
+SHA512:
+  metadata.gz: 0fa8554ec8b5b662c683cf8b8dafd9beecbd90a92ace372f3dd18308d9e21ce05013343288c0394ca32841bdbe0007400f7c0b1e1124e1895cc263207b4697fb
+  data.tar.gz: fd45c6fd818f0255ebae73f43c56feb70ea892b7a9e12fc12739d5604a7a3e7529b6abd5b8c506366b803a7cc3f4e681841fc2e3530c572d9d5689990c4cc576

data/bin/propose

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'propose'
+
+Propose::REPL.new.run

data/lib/propose.rb

@@ -0,0 +1,19 @@
+require 'propose/parser'
+require 'propose/repl'
+require 'propose/truth_table'
+require 'propose/version'
+
+require 'propose/visitor'
+require 'propose/atom_finder'
+
+require 'propose/tree/node'
+require 'propose/tree/binary_operation'
+require 'propose/tree/conjunction'
+require 'propose/tree/disjunction'
+require 'propose/tree/falsum'
+require 'propose/tree/implication'
+require 'propose/tree/atom'
+require 'propose/tree/unary_operation'
+require 'propose/tree/negation'
+require 'propose/tree/sequent'
+require 'propose/tree/verum'

data/lib/propose/atom_finder.rb

@@ -0,0 +1,19 @@
+require 'set'
+
+module Propose
+  # Finds all atoms in a parse tree.
+  class AtomFinder
+    include Propose::Visitor
+
+    attr_reader :atoms
+
+    def initialize(formula)
+      @atoms = Set.new
+      visit(formula)
+    end
+
+    def visit_atom(atom)
+      @atoms << atom
+    end
+  end
+end

data/lib/propose/parser.rb

@@ -0,0 +1,33 @@
+require 'treetop'
+
+module Propose
+  # Raised when the parser is unable to parse the input.
+  class ParseError < StandardError; end
+
+  # Parses a propositional logic statement into an abstract syntax tree.
+  class Parser
+    GRAMMAR_FILE = File.expand_path(File.join(File.dirname(__FILE__),
+                                              '..', '..', 'grammar',
+                                              'propositional_logic.treetop'))
+
+    class << self
+      def parse(string)
+        tree = parser.parse(string)
+        if tree
+          tree.to_ast
+        else
+          raise ParseError, parser.failure_reason
+        end
+      end
+
+    private
+
+      def parser
+        @parser ||= begin
+                      Treetop.load(GRAMMAR_FILE)
+                      PropositionalLogicParser.new
+                    end
+      end
+    end
+  end
+end

data/lib/propose/repl.rb

@@ -0,0 +1,67 @@
+require 'colorize'
+require 'readline'
+require 'terminal-table'
+
+module Propose
+  # Read-Eval-Print-Loop engine, allowing a user to interactively create
+  # and explore the properties of propositional logic statements.
+  class REPL
+    def run
+      while input = Readline.readline('> '.green, true)
+        handle_input(input)
+      end
+    rescue SignalException # rubocop:disable HandleExceptions
+      # User hit Ctrl-C; close gracefully
+    end
+
+  private
+
+    def handle_input(input)
+      input = input.strip
+      interpret(input) unless input.empty?
+    rescue ParseError => ex
+      puts "Invalid expression: #{ex.message}".red
+    end
+
+    def interpret(input)
+      statement = Parser.parse(input)
+
+      case statement
+      when Tree::Sequent
+        puts statement.to_s.cyan
+        # TODO: Find and display proof of sequent
+      else
+        print_truth_table(statement)
+      end
+    end
+
+    def print_truth_table(statement)
+      tt = Propose::TruthTable.new(statement)
+
+      atoms = tt.formula_atoms.to_a
+
+      table = Terminal::Table.new do |t|
+        t << atoms + ['Result']
+        t.add_separator
+        tt.evaluations.each do |assignment, result|
+          t << assignment.values.map { |v| shorthand_value(v) } + [shorthand_value(result)]
+        end
+      end
+
+      table.title = statement.to_s
+
+      (atoms.count + 1).times do |i|
+        table.align_column(i, :center)
+      end
+
+      puts table.to_s
+                .gsub('T', 'T'.green)
+                .gsub('F', 'F'.red)
+                .gsub(table.title, table.title.cyan)
+    end
+
+    def shorthand_value(value)
+      value ? 'T' : 'F'
+    end
+  end
+end

data/lib/propose/tree/atom.rb

@@ -0,0 +1,32 @@
+module Propose::Tree
+  # Declarative statement that can be either true or false.
+  #
+  # For example: "The sun is shining."
+  class Atom < Node
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def ==(other)
+      super || @name == other.name
+    end
+
+    def evaluate(assignment)
+      assignment[self]
+    end
+
+    def literal?
+      true
+    end
+
+    def inspect
+      "#<Atom #{name}>"
+    end
+
+    def to_s
+      name.to_s
+    end
+  end
+end

data/lib/propose/tree/binary_operation.rb

@@ -0,0 +1,34 @@
+module Propose::Tree
+  # Represents two propositional formula joined by a logical connective.
+  class BinaryOperation < Node
+    attr_reader :operator, :left, :right
+
+    def initialize(operator, left, right)
+      @operator = operator
+      @left = left
+      @right = right
+    end
+
+    def ==(other)
+      super || @operator == other.operator &&
+               @left == other.left &&
+               @right == other.right
+    end
+
+    def children
+      [left, right]
+    end
+
+    def inspect
+      "#<#{self.class.name.split('::').last} #{left.inspect} #{right.inspect}>"
+    end
+
+    def to_s
+      output = []
+      output << (left.literal? ? left.to_s : "(#{left})")
+      output << " #{operator} "
+      output << (right.literal? ? right.to_s : "(#{right})")
+      output.join
+    end
+  end
+end

data/lib/propose/tree/conjunction.rb

@@ -0,0 +1,12 @@
+module Propose::Tree
+  # A conjunction of two expressions, indicating both are true.
+  class Conjunction < BinaryOperation
+    def initialize(left, right)
+      super('∧', left, right)
+    end
+
+    def evaluate(assignment)
+      left.evaluate(assignment) && right.evaluate(assignment)
+    end
+  end
+end

data/lib/propose/tree/disjunction.rb

@@ -0,0 +1,12 @@
+module Propose::Tree
+  # A disjunction of two expressions, indicating at least one of them is true.
+  class Disjunction < BinaryOperation
+    def initialize(left, right)
+      super('∨', left, right)
+    end
+
+    def evaluate(assignment)
+      left.evaluate(assignment) || right.evaluate(assignment)
+    end
+  end
+end

data/lib/propose/tree/falsum.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+module Propose::Tree
+  # Represents a contradiction, or falseness.
+  class Falsum < Node
+    include Singleton
+
+    def evaluate(_assignment)
+      false
+    end
+
+    def literal?
+      true
+    end
+
+    def inspect
+      '#<Falsum>'
+    end
+
+    def to_s
+      '⊥'
+    end
+  end
+end

data/lib/propose/tree/implication.rb

@@ -0,0 +1,13 @@
+module Propose::Tree
+  # Expresses the concept that the right expression is a logical consequence of
+  # the left expression.
+  class Implication < BinaryOperation
+    def initialize(left, right)
+      super('→', left, right)
+    end
+
+    def evaluate(assignment)
+      !left.evaluate(assignment) || right.evaluate(assignment)
+    end
+  end
+end

data/lib/propose/tree/negation.rb

@@ -0,0 +1,12 @@
+module Propose::Tree
+  # A negated expression.
+  class Negation < UnaryOperation
+    def initialize(sentence)
+      super('¬', sentence)
+    end
+
+    def evaluate(assignment)
+      !@formula.evaluate(assignment)
+    end
+  end
+end

data/lib/propose/tree/node.rb

@@ -0,0 +1,16 @@
+module Propose::Tree
+  # Generic definition of a parse tree node for propositional logic.
+  class Node
+    # Nodes which can be considered the children of this node.
+    def children
+      []
+    end
+
+    # Whether this node can be considered an unambiguous single lexical unit.
+    #
+    # This is used to omit unnecessary parentheses when rendering.
+    def literal?
+      false
+    end
+  end
+end

data/lib/propose/tree/sequent.rb

@@ -0,0 +1,30 @@
+module Propose::Tree
+  # Statement indicating that a set of premises (propositional formulae) can be
+  # used to prove to a conclusion (another propositional formula).
+  #
+  # Sequents which the premises do not prove the conclusion are called invalid.
+  class Sequent < Node
+    attr_reader :premises, :conclusion
+
+    def initialize(premises, conclusion)
+      @premises = premises
+      @conclusion = conclusion
+    end
+
+    def ==(other)
+      super || @premises == other.premises && @conclusion == other.conclusion
+    end
+
+    def children
+      premises + [conclusion]
+    end
+
+    def inspect
+      "#<Sequent [#{premises.map(&:inspect).join(', ')}] ⊢ #{conclusion.inspect}"
+    end
+
+    def to_s
+      "#{premises.map(&:to_s).join(', ')} ⊢ #{conclusion}"
+    end
+  end
+end

data/lib/propose/tree/unary_operation.rb

@@ -0,0 +1,33 @@
+module Propose::Tree
+  # Represents an operation on a single propositional formula.
+  class UnaryOperation < Node
+    attr_reader :operator, :formula
+
+    def initialize(operator, formula)
+      @operator = operator
+      @formula = formula
+    end
+
+    def ==(other)
+      super || @operator == other.operator && @formula == other.formula
+    end
+
+    def children
+      [formula]
+    end
+
+    def literal?
+      @formula.literal?
+    end
+
+    def inspect
+      "#<#{self.class.name.split('::').last} #{formula.inspect}>"
+    end
+
+    def to_s
+      output = [operator.to_s]
+      output << (formula.literal? ? formula.to_s : "(#{formula})")
+      output.join
+    end
+  end
+end

data/lib/propose/tree/verum.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+module Propose::Tree
+  # Represents absolute tautological truth.
+  class Verum < Node
+    include Singleton
+
+    def evaluate(_assignment)
+      true
+    end
+
+    def literal?
+      true
+    end
+
+    def inspect
+      '#<Verum>'
+    end
+
+    def to_s
+      '⊤'
+    end
+  end
+end

data/lib/propose/truth_table.rb

@@ -0,0 +1,38 @@
+module Propose
+  # Generates a truth table for a given propositional logic formula.
+  class TruthTable
+    attr_reader :formula, :evaluations
+
+    def initialize(formula)
+      @formula = formula
+      @evaluations = generate(formula)
+    end
+
+    def formula_atoms
+      @formula_atoms ||= AtomFinder.new(formula).atoms
+    end
+
+  private
+
+    def generate(formula)
+      assignments = generate_assignments(formula_atoms.to_a)
+
+      assignments.map do |assignment|
+        result = formula.evaluate(assignment)
+        [assignment, result]
+      end
+    end
+
+    def generate_assignments(atoms)
+      return [{}] unless atoms && atoms.count > 0
+      atom = atoms[0]
+      subset = atoms[1..-1]
+
+      sub_assignments = generate_assignments(subset)
+
+      sub_assignments.flat_map do |sub_assign|
+        [{ atom => true }.merge(sub_assign), { atom => false }.merge(sub_assign)]
+      end
+    end
+  end
+end

data/lib/propose/version.rb

@@ -0,0 +1,4 @@
+# Specifies the gem version.
+module Propose
+  VERSION = '0.0.1'
+end

data/lib/propose/visitor.rb

@@ -0,0 +1,39 @@
+module Propose
+  # Provides basic functionality for traversing a parse tree.
+  #
+  # Classes which include this module can define methods such as
+  # `visit_conjunction` to have the visitor visit all conjunctions in the parse
+  # tree.
+  module Visitor
+    def visit(node)
+      # Keep track of whether this block was consumed by the visitor. This
+      # allows us to visit all nodes by default, but can override the behavior
+      # by specifying `yield false` in a visit method, indicating that no
+      # further visiting should occur for the current node's children.
+      block_called = false
+
+      block = ->(descend = :children) do
+        block_called = true
+        visit_children(node) if descend == :children
+      end
+
+      method = "visit_#{node_name(node)}"
+
+      send(method, node, &block) if respond_to?(method, true)
+
+      visit_children(node) unless block_called
+    end
+
+  private
+
+    def visit_children(parent)
+      parent.children.each { |node| visit(node) }
+    end
+
+    def node_name(node)
+      klass = node.class
+      @node_names ||= {}
+      @node_names[klass] ||= klass.name.gsub(/.*::(.*?)$/, '\\1').downcase
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: propose
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+description: Create, manipulate, and verify propositional logic sentences
+email: shane@dasilva.io
+executables:
+- propose
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/propose
+- lib/propose.rb
+- lib/propose/atom_finder.rb
+- lib/propose/parser.rb
+- lib/propose/repl.rb
+- lib/propose/tree/atom.rb
+- lib/propose/tree/binary_operation.rb
+- lib/propose/tree/conjunction.rb
+- lib/propose/tree/disjunction.rb
+- lib/propose/tree/falsum.rb
+- lib/propose/tree/implication.rb
+- lib/propose/tree/negation.rb
+- lib/propose/tree/node.rb
+- lib/propose/tree/sequent.rb
+- lib/propose/tree/unary_operation.rb
+- lib/propose/tree/verum.rb
+- lib/propose/truth_table.rb
+- lib/propose/version.rb
+- lib/propose/visitor.rb
+homepage: https://github.com/sds/propose
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Propositional logic sentence playground
+test_files: []