truthtable 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+.idea
+*.gem
+*.iml

data/CONTRIBUTORS

@@ -0,0 +1,7 @@
+== Author
+
+Tanaka Akira <akr@fsij.org>
+
+== Contributors
+
+Max De Marzi

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in truthtable.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    truthtable (0.0.1)
+      msgpack
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    msgpack (0.4.7)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec
+  truthtable!

data/LICENSE

@@ -0,0 +1,27 @@
+# truthtable.rb - truth table and formula generator
+#
+# Copyright (C) 2007 Tanaka Akira  <akr@fsij.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+(1) Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+(2) Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+(3) The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.
+
+(The modified BSD licence)

data/README

@@ -0,0 +1,102 @@
+= truthtable - truth table to logical formula
+
+The truthtable library generates a truth table from a logical formula written in Ruby.
+The truth table can be converted to a logical formula.
+
+== Install
+
+    gem install 'truthtable'
+
+== Features
+
+* generate a truth table from a given block written in Ruby.
+* generate a formula from the table:
+  * minimal one (obtained by Quine-McCluskey algorithm)
+  * disjunctive normal form
+  * conjunctive normal form
+
+== Usage
+
+  require 'truthtable'
+
+* puts, p and pp shows truth table
+
+   puts TruthTable.new {|v| v[0] & v[1] }
+   #=>
+   v[0] v[1] | 
+   ----------+--
+    f    f   | f
+    f    t   | f
+    t    f   | f
+    t    t   | t
+
+   p TruthTable.new {|v| v[0] & v[1] }
+   #=> #<TruthTable: !v[0]&!v[1]=>false !v[0]&v[1]=>false v[0]&!v[1]=>false v[0]&v[1]=>true>
+
+   require 'pp'
+   pp TruthTable.new {|v| v[0] & v[1] }
+   #=>
+   #<TruthTable:
+    !v[0]&!v[1]=>false
+    !v[0]& v[1]=>false
+     v[0]&!v[1]=>false
+     v[0]& v[1]=>true>
+
+* '?' is shown for non-evaluated variable
+
+   puts TruthTable.new {|v| v[0] && v[1] }'
+   #=>
+   v[0] v[1] | 
+   ----------+--
+    f    ?   | f
+    t    f   | f
+    t    t   | t
+
+   puts TruthTable.new {|v| v[0] || v[1] }'
+   #=>
+   v[0] v[1] | 
+   ----------+--
+    f    f   | f
+    f    t   | t
+    t    ?   | t
+
+   puts TruthTable.new {|v| !v[0] ? !v[1] : !v[2] }'
+   #=>
+   v[0] v[1] v[2] | 
+   ---------------+--
+    f    f    ?   | t
+    f    t    ?   | f
+    t    ?    f   | t
+    t    ?    t   | f
+
+* formula generation
+
+   p TruthTable.new {|v| !v[0] }.formula        #=> "!v[0]"
+   p TruthTable.new {|v| v[0] & v[1] }.formula  #=> "v[0]&v[1]"
+   p TruthTable.new {|v| v[0] | v[1] }.formula  #=> "v[0] | v[1]"
+   p TruthTable.new {|v| v[0] ^ v[1] }.formula  #=> "!v[0]&v[1] | v[0]&!v[1]"
+   p TruthTable.new {|v| v[0] == v[1] }.formula #=> "!v[0]&!v[1] | v[0]&v[1]"
+
+* shortcuts, && and ||, are not preserved
+
+   p TruthTable.new {|v| v[0] && v[1] }.formula #=> "v[0]&v[1]"
+   p TruthTable.new {|v| v[0] || v[1] }.formula #=> "v[0] | v[1]"
+
+* actually any expression (without side effect)
+
+   p TruthTable.new {|v| v[0] ? !v[1] : v[1] }.formula #=> "!v[0]&v[1] | v[0]&!v[1]"
+
+* any number of inputs
+
+   p TruthTable.new {|v| [v[0], v[1], v[2], v[3]].grep(true).length <= 3 }.formula
+   #=> "!v[0] | !v[1] | !v[2] | !v[3]"
+
+
+== Reference Manual
+
+See rdoc/classes/TruthTable.html or
+http://www.a-k-r.org/truthtable/rdoc/TruthTable.html
+
+== Home Page
+
+http://www.a-k-r.org/truthtable/

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/truthtable.rb

@@ -0,0 +1,197 @@
+require "truthtable/version"
+require "truthtable/truth_table_object"
+require "truthtable/qm"
+
+class TruthTable
+
+  def self.test(&b)
+    r = []
+    o = TruthTableObject.new
+    begin
+      result = !!b.call(o)
+      inputs = o.plan
+      order = o.order
+      r << [inputs, result, order]
+    end while o.next_plan
+    r
+  end
+
+  def initialize(&b)
+    table = TruthTable.test(&b)
+    @table = table
+  end
+
+  def to_s
+    r = ''
+    names = sort_names(all_names.keys)
+    format = ''
+    sep = ''
+    names.each {|name|
+      format << "%-#{name.length}s "
+      sep << '-' * (name.length+1)
+    }
+    format << "| %s\n"
+    sep << "+--\n"
+    r << sprintf(format, *(names + ['']))
+    r << sep
+    @table.each {|inputs, output, order|
+      h = {}
+      each_input(inputs) {|name, input|
+        h[name] = input
+      }
+      args = []
+      names.each {|name|
+        if h.has_key? name
+          args << (h[name] ? 't' : 'f').center(name.length)
+        else
+          args << '?'.center(name.length)
+        end
+      }
+      args << (output ? 't' : 'f')
+      r << sprintf(format, *args)
+    }
+    r
+  end
+
+  # :stopdoc:
+  def inspect
+    result = "#<#{self.class}:"
+    @table.each {|inputs, output, order|
+      term = []
+      each_input(inputs) {|name, input|
+        if input
+          term << name
+        else
+          term << "!#{name}"
+        end
+      }
+      result << " #{term.join('&')}=>#{output}"
+    }
+    result << ">"
+    result
+  end
+
+  def pretty_print(q)
+    q.object_group(self) {
+      q.text ':'
+      q.breakable
+      q.seplist(@table, lambda { q.breakable('; ') }) {|inputs, output, order|
+        term = []
+        each_input(inputs) {|name, input|
+          if input
+            term << " #{name}"
+          else
+            term << "!#{name}"
+          end
+        }
+        q.text "#{term.join('&')}=>#{output}"
+      }
+    }
+  end
+
+  def all_names
+    return @all_names if defined? @all_names
+    @all_names = {}
+    @table.each {|inputs, output, order|
+      order.each {|name|
+        if !@all_names.has_key?(name)
+          @all_names[name] = @all_names.size
+        end
+      }
+    }
+    @all_names
+  end
+
+  def sort_names(names)
+    total_order = all_names
+    names.sort_by {|n| total_order[n] }
+  end
+
+  def each_input(inputs)
+    sort_names(inputs.keys).each {|name|
+      yield name, inputs[name]
+    }
+  end
+  # :startdoc:
+
+  # obtains a formula in disjunctive normal form.
+  def dnf
+    r = []
+    @table.each {|inputs, output|
+      return output.to_s if inputs.empty?
+      next if !output
+      term = []
+      each_input(inputs) {|name, input|
+        if input
+          term << name
+        else
+          term << "!#{name}"
+        end
+      }
+      r << term.join('&')
+    }
+    return "false" if r.empty?
+    r.join(' | ')
+  end
+
+  # obtains a formula in conjunctive normal form.
+  def cnf
+    r = []
+    @table.each {|inputs, output|
+      return output.to_s if inputs.empty?
+      next if output
+      term = []
+      each_input(inputs) {|name, input|
+        if input
+          term << "!#{name}"
+        else
+          term << name
+        end
+      }
+      if term.length == 1
+        r << term.join('|')
+      else
+        r << "(#{term.join('|')})"
+      end
+    }
+    return "true" if r.empty?
+    r.join(' & ')
+  end
+
+  # obtains a minimal formula using Quine-McCluskey algorithm.
+  def formula
+    input_names = all_names
+    input_names_ary = sort_names(input_names.keys)
+    tbl = {}
+    @table.each {|inputs, output|
+      return output.to_s if inputs.empty?
+      inputs2 = [:x] * input_names.length
+      inputs.each {|name, input|
+        inputs2[input_names[name]] = input ? 1 : 0
+      }
+      tbl[inputs2] = output ? 1 : 0
+    }
+    qm = QM.qm(tbl)
+    r = []
+    qm.each {|term|
+      t = []
+      num_dontcare = 0
+      term.each_with_index {|v, i|
+        if v == false
+          t << ("!" + input_names_ary[i])
+        elsif v == true
+          t << input_names_ary[i]
+        else # :x
+          num_dontcare += 1
+        end
+      }
+      if num_dontcare == term.length
+        r << 'true'
+      else
+        r << t.join('&')
+      end
+    }
+    return "false" if r.empty?
+    r.join(' | ')
+  end
+end

data/lib/truthtable/qm.rb

@@ -0,0 +1,366 @@
+require 'msgpack'
+
+class TruthTable
+  # Quine-McCluskey algorithm
+  module QM
+    module_function
+
+    # implements Quine-McCluskey algorithm.
+    # It minimize the boolean function given by <i>tbl</i>.
+    #
+    # For example, the 3-inputs majority function is given as follows.
+    #
+    #  tbl = {
+    #  #  P      Q      R
+    #    [false, false, false] => false,
+    #    [false, false, true ] => false,
+    #    [false, true,  false] => false,
+    #    [false, true,  true ] => true,
+    #    [true,  false, false] => false,
+    #    [true,  false, true ] => true,
+    #    [true,  true,  false] => true,
+    #    [true,  true,  true ] => true,
+    #  }
+    #  TruthTable::QM.qm(tbl)
+    #  #=>
+    #  [[true, true, :x], [true, :x, true], [:x, true, true]]  # P&Q | P&R | Q&R
+    #  # P     Q           P         R           Q     R
+    #
+    # For another example, the implication function is given as follows.
+    #
+    #  tbl = {
+    #  #  P      Q
+    #    [false, false] => true,
+    #    [false, true ] => true,
+    #    [true,  false] => false,
+    #    [true,  true ] => true,
+    #  }
+    #  TruthTable::QM.qm(tbl)
+    #  #=>
+    #  [[false, :x], [:x, true]]  # ~P | Q
+    #  # ~P               Q
+    #
+    # <i>tbl</i> is a hash to represent a boolean function.
+    # If the function has N variables, 
+    # all key of <i>tbl</i> must be an array of N elements.
+    #
+    # A element of the key array and a value of the hash should be one of follows:
+    # - false, 0
+    # - true, 1
+    # - :x
+    #
+    # 0 is same as false.
+    #
+    # 1 is same as false.
+    #
+    # :x means "don't care".
+    #
+    # For example, 3-inputs AND function can be given as follows.
+    #
+    #  tbl = {
+    #    [false, :x,    :x   ] => false,
+    #    [:x,    false, :x   ] => false,
+    #    [:x,    :x,    false] => false,
+    #    [true,  true,  true ] => true,
+    #  }
+    #
+    # :x can be used for a value of <i>tbl</i> too.
+    # It means that the evaluated result of minimized boolean function is not specified:
+    # it may be evaluated to true or false.
+    #
+    #  tbl = {
+    #    [false, false] => false,
+    #    [false, true ] => true,
+    #    [true,  false] => false,
+    #    [true,  true ] => :x
+    #  }
+    #
+    # If <i>tbl</i> doesn't specify some combination of
+    # input variables, it assumes :x for such combination.
+    # The above function can be specified as follows.
+    #
+    #  tbl = {
+    #    [false, false] => false,
+    #    [false, true ] => true,
+    #    [true,  false] => false,
+    #  }
+    #
+    # QM.qm returns an array of arrays which represents
+    # the minimized boolean function.
+    #
+    # The minimized boolean function is a
+    # disjunction of terms such as "term1 | term2 | term3 | ...".
+    #
+    # The inner array represents a term.
+    # A term is a conjunction of input variables and negated input variables: "P & ~Q & ~R & S & ...".
+    #
+    def qm(tbl)
+      return [] if tbl.empty?
+      tbl = intern_tbl(tbl)
+      prime_implicants = find_prime_implicants(tbl)
+      essential_prime_implicants, chart = make_chart(prime_implicants, tbl)
+      additional_prime_implicants = search_minimal_combination(chart)
+      (essential_prime_implicants.keys + additional_prime_implicants).sort.reverse.map {|t|
+        extern_term(t)
+      }
+    end
+
+    # :stopdoc:
+
+    def has_intersection?(t1, t2)
+      [t1,t2].transpose.all? {|v1, v2|
+        v1 == -1 || v2 == -1 || v1 == v2
+      }
+    end
+
+    def implication?(t1, t2)
+      [t1,t2].transpose.all? {|v1, v2|
+        v2 == -1 || v1 == v2
+      }
+    end
+
+    INTERN = {
+      false => 0,
+      true => 1,
+      0 => 0,
+      1 => 1,
+      :x => -1,
+    }
+    def intern_tbl(tbl)
+      result = {}
+      num_inputs = nil
+      tbl.each {|inputs, output|
+        if !num_inputs
+          num_inputs = inputs.length
+        else
+          if inputs.length != num_inputs
+            raise ArgumentError, "different number of inputs"
+          end
+        end
+        inputs2 = inputs.map {|v|
+          if !INTERN.has_key?(v)
+            raise ArgumentError, "unexpected input: #{v.inspect}"
+          end
+          INTERN[v]
+        }
+        if !INTERN.has_key?(output)
+          raise ArgumentError, "unexpected output: #{output.inspect}"
+        end
+        result[inputs2] = INTERN[output]
+      }
+      result_keys = result.keys
+      0.upto(result_keys.length-2) {|i|
+        ki = result_keys[i]
+        next if !result[ki]
+        (i+1).upto(result_keys.length-1) {|j|
+          kj = result_keys[j]
+          next if !result[kj]
+          if has_intersection?(ki, kj)
+            if result[ki] != result[kj]
+              raise ArgumentError, "inconsistent table"
+            end
+            if implication?(ki, kj)
+              result.delete ki
+            elsif implication?(kj, ki)
+              result.delete kj
+            end
+          end
+        }
+      }
+      not_specified = []
+      0.upto((1 << num_inputs)-1) {|n|
+        inputs = (0...num_inputs).map {|i| n[i] }
+        if result.all? {|inputs_pat, output| !has_intersection?(inputs, inputs_pat) }
+          not_specified << inputs
+        end
+      }
+      not_specified.each {|inputs|
+        result[inputs] = -1
+      }
+      result
+    end
+
+    EXTERN = {
+      0 => false,
+      1 => true,
+      -1 => :x
+    }
+    def extern_term(t)
+      t.map {|v| EXTERN[v] }
+    end
+
+    def combine(t1, t2)
+      num_diffs = 0
+      r = [t1,t2].transpose.map {|v1, v2|
+        if v1 == v2
+          v1
+        elsif v1 == 0 && v2 == 1
+          num_diffs += 1
+          return nil if 1 < num_diffs
+          -1
+        elsif v1 == 1 && v2 == 0
+          num_diffs += 1
+          return nil if 1 < num_diffs
+          -1
+        else
+          return nil
+        end
+      }
+      if num_diffs == 1
+        r
+      else
+        nil
+      end
+    end
+
+    def combine2(t1, t2)
+      num_diffs = 0
+      r = [t1,t2].transpose.map {|v1, v2|
+        if v1 == v2
+          v1
+        elsif v1 == 0 && v2 == 1
+          num_diffs += 1
+          return nil if 1 < num_diffs
+          -1
+        elsif v1 == 1 && v2 == 0
+          num_diffs += 1
+          return nil if 1 < num_diffs
+          -1
+        elsif v2 == -1
+          v1
+        else
+          return nil
+        end
+      }
+      if num_diffs == 1
+        r
+      else
+        nil
+      end
+    end
+
+    def find_prime_implicants(tbl)
+      num_inputs = nil
+      implicants_sets = []
+      tbl.each {|inputs, output|
+        num_inputs = inputs.length
+        next if output == 0
+        num_dontcares = inputs.grep(-1).length
+        num_ones = inputs.grep(1).length
+        implicants_sets[num_dontcares] ||= []
+        implicants_sets[num_dontcares][num_ones] ||= {}
+        implicants_sets[num_dontcares][num_ones][inputs] = true
+      }
+      combined = {}
+      0.upto(num_inputs-1) {|num_dontcares|
+        #isets = implicants_sets[num_dontcares]
+        isets = implicants_sets[num_dontcares].clone unless implicants_sets[num_dontcares].nil?
+        next if !isets
+        0.upto(isets.length-2) {|num_ones|
+          next if !isets[num_ones] || !isets[num_ones+1]
+          isets[num_ones].each_key {|t1|
+            isets[num_ones+1].each_key {|t2|
+              if t = combine(t1, t2)
+                combined[t1] = combined[t2] = true
+                implicants_sets[num_dontcares+1] ||= []
+                implicants_sets[num_dontcares+1][num_ones] ||= {}
+                implicants_sets[num_dontcares+1][num_ones][t] = true
+              end
+            }
+          }
+        }
+        isets.each {|ts1|
+          next if !ts1
+          ts1.each_key {|t1|
+            (num_dontcares+1).upto(num_inputs-1) {|num_dontcares2|
+              #isets2 = implicants_sets[num_dontcares2]
+              isets2 = MessagePack.unpack(implicants_sets[num_dontcares2].to_msgpack)
+              next if !isets2
+              isets2.each {|ts2|
+                next if !ts2
+                ts2.each_key {|t2|
+                  if t = combine2(t1, t2)
+                    combined[t1] = true
+                    num_ones = t1.grep(1).length
+                    implicants_sets[num_dontcares+1] ||= []
+                    implicants_sets[num_dontcares+1][num_ones] ||= {}
+                    implicants_sets[num_dontcares+1][num_ones][t] = true
+                  end
+                }
+              }
+            }
+          }
+        }
+      }
+      prime_implicants = {}
+      implicants_sets.each {|isets|
+        next if !isets
+        isets.each {|ts|
+          next if !ts
+          ts.each_key {|t|
+            next if combined[t]
+            prime_implicants[t] = true
+          }
+        }
+      }
+      prime_implicants
+    end
+
+    def make_chart(prime_implicants, tbl)
+      essential_prime_implicants = {}
+      chart = []
+      tbl.each {|inputs, output|
+        next if output != 1
+        pi_list = []
+        prime_implicants.each_key {|pi|
+          if implication?(inputs, pi)
+            pi_list << pi
+          end
+        }
+        if pi_list.length == 1
+          essential_prime_implicants[pi_list[0]] = true
+        else
+          chart << pi_list
+        end
+      }
+      chart.reject! {|pi_list| pi_list.any? {|pi| essential_prime_implicants[pi] } }
+      return essential_prime_implicants, chart
+    end
+
+    def search_minimal_combination(chart)
+      return [] if chart.empty?
+      all_pi = {}
+      chart.each {|pi_list|
+        pi_list.each {|pi|
+          all_pi[pi] = true
+        }
+      }
+      q = {}
+      all_pi.each_key {|pi|
+        q[[pi]] = true
+      }
+      while true
+        next_q = {}
+        found = []
+        until q.empty?
+          pi_set0, _ = q.shift
+          pi_set = {}
+          pi_set0.each {|pi| pi_set[pi] = true }
+          if chart.all? {|pi_list| pi_list.any? {|pi| pi_set[pi] }}
+            found << pi_set0
+          end
+          all_pi.each_key {|pi|
+            next if pi_set[pi]
+            next_q[(pi_set0 + [pi]).sort] = true
+          }
+        end
+        if !found.empty?
+          return found.sort.first
+        end
+        q = next_q
+      end
+    end
+
+    # :startdoc:
+  end
+end