boolean_simplifier 1.0.0

data/README.md

@@ -0,0 +1,36 @@
+## Boolean Simplifier
+
+A hobbyist's attempt to simplify boolean expressions using a recursive, object-oriented strategy.
+
+## Usage
+
+```ruby
+puts BooleanSimplifier.simplify("a && a || !!b")
+# a || b
+
+puts BooleanSimplifier.simplify("a && !a")
+# false
+
+puts BooleanSimplifier.simplify("!a || !b && (true || false)")
+# !(a && b)
+```
+
+## How it works
+
+The boolean expression is parsed and an object graph is constructed. This graph consists of instances of Negation, Conjunction, Disjunction. It also contains literal strings.
+
+A set of boolean simplification rules is applied to the expression and recursively to its subexpressions. These rules take an arbitrary expression as input and return a new expression if the rule applies. If not, the original expression is returned.
+
+The base case for this recursive algorithm is when no improvement is made to the given expression after iterating through all simplification rules.
+
+## Limitations
+
+Ruby does not implement tail recursion. Therefore, you may run into a SystemStackError when simplifying large expressions.
+
+I haven't figured out every simplification rule, or the most efficient way to apply them. Therefore, you may find that some expressions are only partially simplified.
+
+## Contribution
+
+Open an issue, or send a pull request. I'd appreciate all feedback.
+
+[Twitter](https://twitter.com/cpatuzzo)

data/lib/boolean_simplifier.rb

@@ -0,0 +1,20 @@
+require "treetop"
+require "polyglot"
+
+require "boolean_simplifier/base"
+require "boolean_simplifier/expression"
+require "boolean_simplifier/expression/conjunction"
+require "boolean_simplifier/expression/disjunction"
+require "boolean_simplifier/expression/negation"
+require "boolean_simplifier/expression_parser"
+require "boolean_simplifier/expression_simplifier"
+require "boolean_simplifier/grammar/boolean_expression"
+require "boolean_simplifier/rule"
+require "boolean_simplifier/rule/absorbtion"
+require "boolean_simplifier/rule/annihilator"
+require "boolean_simplifier/rule/complementation"
+require "boolean_simplifier/rule/de_morgans"
+require "boolean_simplifier/rule/distributivity"
+require "boolean_simplifier/rule/double_negation"
+require "boolean_simplifier/rule/idempotence"
+require "boolean_simplifier/rule/identity"

data/lib/boolean_simplifier/base.rb

@@ -0,0 +1,12 @@
+module BooleanSimplifier
+  def version
+    "1.0.0"
+  end
+
+  def simplify(string)
+    expression = ExpressionParser.parse(string)
+    ExpressionSimplifier.simplify(expression).to_s
+  end
+
+  extend self
+end

data/lib/boolean_simplifier/expression.rb

@@ -0,0 +1,22 @@
+class Expression
+
+  attr_accessor :parts
+
+  def ==(other)
+    to_s == other.to_s
+  end
+
+  def to_s
+    raise NotImplementedError
+  end
+
+  private
+  def bracket(expression, *classes)
+    if classes.include?(expression.class)
+      "(#{expression})"
+    else
+      expression
+    end
+  end
+
+end

data/lib/boolean_simplifier/expression/conjunction.rb

@@ -0,0 +1,14 @@
+class Conjunction < Expression
+
+  def initialize(a, b)
+    @parts = [a, b]
+  end
+
+  def to_s
+    a = bracket(parts[0], Disjunction)
+    b = bracket(parts[1], Disjunction)
+
+    "#{a} && #{b}"
+  end
+
+end

data/lib/boolean_simplifier/expression/disjunction.rb

@@ -0,0 +1,11 @@
+class Disjunction < Expression
+
+  def initialize(a, b)
+    @parts = [a, b]
+  end
+
+  def to_s
+    parts.join(" || ")
+  end
+
+end

data/lib/boolean_simplifier/expression/negation.rb

@@ -0,0 +1,12 @@
+class Negation < Expression
+
+  def initialize(expression)
+    @parts = [expression]
+  end
+
+  def to_s
+    expr = bracket(parts[0], Conjunction, Disjunction)
+    "!#{expr}"
+  end
+
+end

data/lib/boolean_simplifier/expression_parser.rb

@@ -0,0 +1,16 @@
+module ExpressionParser
+  def parse(string)
+    parser = BooleanExpressionParser.new
+
+    ast = parser.parse(string)
+    if ast.nil?
+      raise ParseError, parser.failure_reason
+    end
+
+    ast.to_expression
+  end
+
+  class ::ParseError < StandardError; end
+
+  extend self
+end

data/lib/boolean_simplifier/expression_simplifier.rb

@@ -0,0 +1,39 @@
+module ExpressionSimplifier
+  def simplify(expression)
+    until_no_improvement(expression) do
+      simplify_parts(expression)
+      simplify_root(expression)
+    end
+  end
+
+  private
+  def until_no_improvement(expression, &block)
+    begin
+      break if trivial?(expression)
+      previous = expression.dup
+      expression = yield
+    end until previous == expression
+
+    expression
+  end
+
+  def simplify_parts(expression)
+    expression.parts.each.with_index do |part, index|
+      expression.parts[index] = simplify(part)
+    end
+  end
+
+  def simplify_root(expression)
+    Rule.collection.each do |rule|
+      expression = rule.simplify(expression)
+    end
+
+    expression
+  end
+
+  def trivial?(expression)
+    !expression.respond_to?(:parts)
+  end
+
+  extend self
+end

data/lib/boolean_simplifier/grammar/boolean_expression.treetop

@@ -0,0 +1,71 @@
+grammar BooleanExpression
+
+  rule expression
+    space disjunctive space {
+      def to_expression
+        disjunctive.to_expression
+      end
+    }
+  end
+
+  rule disjunctive
+    a:conjunctive space "||" space b:disjunctive {
+      def to_expression
+        Disjunction.new(a.to_expression, b.to_expression)
+      end
+    } /
+    conjunctive
+  end
+
+  rule conjunctive
+    a:negative space "&&" space b:conjunctive {
+      def to_expression
+        Conjunction.new(a.to_expression, b.to_expression)
+      end
+    } /
+    negative
+  end
+
+  rule negative
+    "!" negative {
+      def to_expression
+        Negation.new(negative.to_expression)
+      end
+    } /
+    primary
+  end
+
+  rule primary
+    boolean / variable / "(" expression ")" {
+      def to_expression
+        expression.to_expression
+      end
+    }
+  end
+
+  rule boolean
+    "true" {
+      def to_expression
+        true
+      end
+    } /
+    "false" {
+      def to_expression
+        false
+      end
+    }
+  end
+
+  rule variable
+    [a-zA-Z0-9_]+ {
+      def to_expression
+        text_value
+      end
+    }
+  end
+
+  rule space
+    " "*
+  end
+
+end

data/lib/boolean_simplifier/rule.rb

@@ -0,0 +1,7 @@
+module Rule
+  def collection
+    @collection ||= []
+  end
+
+  extend self
+end

data/lib/boolean_simplifier/rule/absorbtion.rb

@@ -0,0 +1,28 @@
+module Absorbtion
+  def simplify(expr)
+    if expr.class == Conjunction
+      absorb_for_class(expr, Disjunction)
+    elsif expr.class == Disjunction
+      absorb_for_class(expr, Conjunction)
+    else
+      expr
+    end
+  end
+
+  private
+  def absorb_for_class(expr, klass)
+    [[0, 1], [1, 0]].each do |a, b|
+      if expr.parts[a].class == klass && contains?(expr.parts[a], expr.parts[b])
+        return expr.parts[b]
+      end
+    end
+    expr
+  end
+
+  def contains?(a, b)
+    a.parts[0] == b || a.parts[1] == b
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/annihilator.rb

@@ -0,0 +1,25 @@
+module Annihilator
+  def simplify(expr)
+    if expr.class == Conjunction
+      return_x_if_contains_x(expr, false)
+    elsif expr.class == Disjunction
+      return_x_if_contains_x(expr, true)
+    else
+      expr
+    end
+  end
+
+  private
+  def return_x_if_contains_x(expr, x)
+    if expr.parts[0] == x
+      x
+    elsif expr.parts[1] == x
+      x
+    else
+      expr
+    end
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/complementation.rb

@@ -0,0 +1,25 @@
+module Complementation
+  def simplify(expr)
+    if expr.class == Conjunction
+      return_x_if_complementary(expr, false)
+    elsif expr.class == Disjunction
+      return_x_if_complementary(expr, true)
+    else
+      expr
+    end
+  end
+
+  private
+  def return_x_if_complementary(expr, x)
+    complementary_expressions?(expr) ? x : expr
+  end
+
+  def complementary_expressions?(expr)
+    [[0, 1], [1, 0]].any? do |a, b|
+      expr.parts[a] == Negation.new(expr.parts[b])
+    end
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/de_morgans.rb

@@ -0,0 +1,31 @@
+module DeMorgans
+  def simplify(expr)
+    if expr.class == Conjunction
+      apply_de_morgans(expr, Disjunction)
+    elsif expr.class == Disjunction
+      apply_de_morgans(expr, Conjunction)
+    else
+      expr
+    end
+  end
+
+  private
+  def apply_de_morgans(expr, inner_class)
+    if both_negation?(expr)
+      Negation.new(
+        inner_class.new(
+          expr.parts[0].parts[0],
+          expr.parts[1].parts[0])
+      )
+    else
+      expr
+    end
+  end
+
+  def both_negation?(expr)
+    [0, 1].all? { |i| expr.parts[i].class == Negation }
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/distributivity.rb

@@ -0,0 +1,31 @@
+module Distributivity
+  def simplify(expr)
+    if expr.class == Conjunction
+      distribute(expr, Conjunction, Disjunction)
+    elsif expr.class == Disjunction
+      distribute(expr, Disjunction, Conjunction)
+    else
+      expr
+    end
+  end
+
+  private
+  def distribute(expr, inner, outer)
+    [[0, 1], [1, 0]].each do |a, b|
+      if expr.parts[a].class == outer && trivial?(expr.parts[b])
+        return outer.new(
+          inner.new(expr.parts[b], expr.parts[a].parts[0]),
+          inner.new(expr.parts[b], expr.parts[a].parts[1])
+        )
+      end
+    end
+    expr
+  end
+
+  def trivial?(expr)
+    !expr.respond_to?(:parts)
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/double_negation.rb

@@ -0,0 +1,17 @@
+module DoubleNegation
+  def simplify(expr)
+    if negation?(expr) && negation?(expr.parts[0])
+      expr.parts[0].parts[0]
+    else
+      expr
+    end
+  end
+
+  private
+  def negation?(expr)
+    expr.class == Negation
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/idempotence.rb

@@ -0,0 +1,12 @@
+module Idempotence
+  def simplify(expr)
+    if expr.respond_to?(:parts) && expr.parts[0] == expr.parts[1]
+      expr.parts[0]
+    else
+      expr
+    end
+  end
+
+  extend self
+  Rule.collection << self
+end

data/lib/boolean_simplifier/rule/identity.rb

@@ -0,0 +1,25 @@
+module Identity
+  def simplify(expr)
+    if expr.class == Conjunction
+      return_part_if_contains_x(expr, true)
+    elsif expr.class == Disjunction
+      return_part_if_contains_x(expr, false)
+    else
+      expr
+    end
+  end
+
+  private
+  def return_part_if_contains_x(expr, x)
+    if expr.parts[0] == x
+      expr.parts[1]
+    elsif expr.parts[1] == x
+      expr.parts[0]
+    else
+      expr
+    end
+  end
+
+  extend self
+  Rule.collection << self
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: boolean_simplifier
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Patuzzo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: polyglot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simplify boolean expressions
+email: chris@patuzzo.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/boolean_simplifier/base.rb
+- lib/boolean_simplifier/expression/conjunction.rb
+- lib/boolean_simplifier/expression/disjunction.rb
+- lib/boolean_simplifier/expression/negation.rb
+- lib/boolean_simplifier/expression.rb
+- lib/boolean_simplifier/expression_parser.rb
+- lib/boolean_simplifier/expression_simplifier.rb
+- lib/boolean_simplifier/grammar/boolean_expression.treetop
+- lib/boolean_simplifier/rule/absorbtion.rb
+- lib/boolean_simplifier/rule/annihilator.rb
+- lib/boolean_simplifier/rule/complementation.rb
+- lib/boolean_simplifier/rule/de_morgans.rb
+- lib/boolean_simplifier/rule/distributivity.rb
+- lib/boolean_simplifier/rule/double_negation.rb
+- lib/boolean_simplifier/rule/idempotence.rb
+- lib/boolean_simplifier/rule/identity.rb
+- lib/boolean_simplifier/rule.rb
+- lib/boolean_simplifier.rb
+homepage: https://github.com/tuzz/boolean_simplifier
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Boolean Simplifier
+test_files: []