falafel 0.0.1.1 → 0.0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796b681163a3d9d57b47cadcb95f1d5e2e9af1e97a0b841b2e31ddc9c725769b
-  data.tar.gz: 3811e2bc49acfee5aa9a4e4f27569df022fb68c2ddafbafa10b43a7c92afe4d8
+  metadata.gz: 754e7aa62a91e0f16ed875b859d8e208379df55509569dbd5d5a38e93b874fbe
+  data.tar.gz: bcbb64b7d4627514c2e3560b80e15ccc3f0dbf721448b96247188f778d8f897c
 SHA512:
-  metadata.gz: 96bf15557a50f7a81c8a71d200a0876f7fc445d64d017d3c2011fa088457d61e05327e8ea39c7147d349049a8e8b3811a815c92e04f414109c4505782a8c6613
-  data.tar.gz: 45573ad63969221aed699f9412d45409c4f72a26c1ec3e83e3bcb4c5fba03c6fb9bdae80d61b3c0a046e4c25a66a00e7c64c00a1841142de675e7eaa45158876
+  metadata.gz: 8fda2266343ea3c9c919898f8ebd0381329189cf6eb08f3e281ba20e30e950d6d1bac77356ff91263c7377e77c808c1b0cb224b705dda1f3970b67b294242d9f
+  data.tar.gz: b9e9c7b8552c38d9a3f09143e68ac4cb78b5527899052a79ec975e1b6a08b45cef97158c3bc785f9f05bb1267943c38b7fc37a8575ea86ed409bd72a4f5317d8

data/lib/cfg.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'cyk'
-require_relative 'chomsky_nf'
-require_relative 'epsilon_free'
-require_relative 'chaining_free'
+require_relative 'cfg_helper/cyk'
+require_relative 'cfg_helper/chomsky_nf'
+require_relative 'cfg_helper/epsilon_free'
+require_relative 'cfg_helper/chaining_free'
 
 # Samll CFG impletation
 # Generate words and check if words are the @lang
 # generates random words
 class CFG
   attr_accessor :start_var, :rules
-  attr_reader   :rules_ef,     :rules_cf,     :rnd_words, :reachables,
+  attr_reader   :rules_ef,     :rules_cf,     :rnd_words,
                 :rules_ef_res, :rules_cf_res, :chomsky_nf_rules,
                 :cyk_matrix,   :is_in_l
 
@@ -18,7 +18,6 @@ class CFG
     @start_var  = start_var
     @rules      = _rules rules
     @rnd_words  = []
-    @reachables = []
     @vars       = vars
     @alphabet   = alphabet
   end
@@ -35,42 +34,27 @@ class CFG
     end
   end
 
-  def var_reachable?
-    @rules[@start_var].each do |rule|
-      @vars.each { |var| @reachables << var if rule.include? var }
-    end
-    @reachables.uniq!
-  end
-
-  def var_productive?
-    ''
-  end
-
-  def var_reduced?
-    ''
-  end
-
-  def epsilon_free
-    e_free        = EpsilonFree.new
-    @rules_ef_res = e_free.run @rules
+  def epsilon_free(custom_rule)
+    e_free        = CFGHelper::EpsilonFree.new
+    @rules_ef_res = e_free.run custom_rule || @rules
     @rules_ef     = e_free.rebuild_rules @rules, @rules_ef_res
   end
 
   def chaining_free
-    c_free        = ChainingFree.new
+    c_free        = CFGHelper::ChainingFree.new
     @rules_cf_res = c_free.run @rules, @vars
     @rules_cf     = c_free.rebuild_rules @rules_cf_res
   end
 
   def chomsky_nf(custom_rule)
-    chomsky = ChomskyNF.new
+    chomsky = CFGHelper::ChomskyNF.new
     rules   = chomsky.run custom_rule || @rules, @alphabet
 
     @chomsky_nf_rules = chomsky.simplify rules
   end
 
   def cyk_run(word)
-    cyk = CYK.new word, @chomsky_nf_rules
+    cyk = CFGHelper::CYK.new word, @chomsky_nf_rules
 
     cyk.run
 

data/lib/cfg_helper/chaining_free.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # remove chaining rules from CFG
+  class ChainingFree
+    def run(rules, vars)
+      @rules = rules
+      @vars  = vars
+      c_r    = _chaining_relation
+
+      # build transivity relation from _chaining_relation(K) as A
+      # remove _chaining_relation from rules
+      _rebuild_rules + c_r.map { |r| _transitivity_relation r }.reduce(:concat) - c_r
+    end
+
+    def rebuild_rules(current_rules)
+      res = {}
+
+      @vars.each { |v| res[v] = [] }
+
+      current_rules.each do |l, r|
+        res[l] << r.chars unless res[l].include? r.chars
+      end
+
+      res
+    end
+
+    private
+
+    def _chaining_relation
+      rules = _rebuild_rules
+
+      rules & @vars.product(@vars)
+    end
+
+    def _rebuild_rules
+      result = []
+      @rules.each do |var, rule|
+        rule.map do |r|
+          result << [var, r.join]
+        end
+      end
+
+      result
+    end
+
+    def _transitivity_relation(pair)
+      transitive_relation = [pair]
+
+      new_pairs = []
+
+      _rebuild_rules.each do |a, b|
+        next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
+
+        new_pairs << [pair[0], b]
+      end
+
+      transitive_relation.concat new_pairs
+    end
+
+    def _new_pairs(rules)
+      rules.each do |a, b|
+        next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
+
+        new_pairs << [pair[0], b]
+      end
+    end
+  end
+end

data/lib/cfg_helper/chomsky_nf.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative 'chomsky_nf_simplifier'
+
+module CFGHelper
+  # convert to Chomsky Normal Form
+  class ChomskyNF
+    def run(rules, alphabet)
+      new_rules = {}
+      @rules    = rules
+      @alphabet = alphabet
+
+      # add cases like (A, a), (B, b)
+      _add_single_vars new_rules
+
+      # change rules like (X, aX) to (X, AX)
+      _handle_simple_rule new_rules
+
+      _handle_all_rule new_rules
+    end
+
+    def simplify(rules)
+      simplifier = CFGHelper::ChomskyNFSimplifier.new
+
+      simplifier.run rules, @alphabet
+    end
+
+    private
+
+    def _add_single_vars(new_rules)
+      @rules.values.reduce(:concat).each do |rule|
+        rule.select { |var| var == var.downcase }.each do |r|
+          new_rules[r.upcase] = r
+        end
+      end
+    end
+
+    def _handle_simple_rule(new_rules)
+      @rules.each do |var, rule|
+        new_rules[var] = []
+        rule.each do |r|
+          next if r.empty?
+
+          new_rules[var] << r.map(&:upcase)
+        end
+      end
+    end
+
+    def _handle_all_rule(new_rules)
+      new_rules_buffer = []
+
+      new_rules.each do |var, rules|
+        next if _is_character? rules
+
+        new_rules_buffer << _new_rules_buffer(rules, var)
+      end
+
+      new_rules.merge! new_rules_buffer.reduce(&:merge)
+    end
+
+    def _is_character?(value)
+      value.is_a?(String) && value.length == 1
+    end
+
+    def _new_rules_buffer(rules, var)
+      helper_vars = _helper_vars rules
+      helper_vars.merge! @alphabet.each_with_object({}) { |ele, meme| meme[ele.capitalize] = ele.capitalize }
+
+      _new_rules rules, var, helper_vars
+    end
+
+    def _check_simplify(rule, holder, current_var)
+      return false unless rule.size == 1
+
+      holder[current_var] << rule.last unless holder[current_var].include? rule
+
+      true
+    end
+
+    def _new_rules(rules, var, helper_vars)
+      holder = {}
+
+      rules.each do |rule|
+        rest = ''
+        rule.each_with_index do |head, index|
+          current_var = index.zero? ? var : rest
+          holder[current_var] ||= []
+
+          is_simple = _check_simplify rule, holder, current_var
+
+          break if is_simple
+
+          rest = _chomsky_nf_vars index, rule, helper_vars
+
+          nf_rest = "#{head}#{rest}"
+
+          if index + 2 == rule.size
+            if rest.nil?
+              rest     = rule.last
+              nf_rest += rest
+            end
+
+            holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
+
+            break
+          else
+            holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
+          end
+        end
+      end
+
+      holder
+    end
+
+    def _chomsky_nf_vars(index, rule, helper_vars)
+      rule_size = rule.size
+      rest      = rule[(index + 1)..rule_size].join
+
+      helper_vars.key(rest)
+    end
+
+    def _helper_vars(rules)
+      helper_vars = {}
+
+      rules.each do |rule|
+        rule.each_with_index do |_, index|
+          letter, rest = _chomsky_nf_helper_vars index, rule, helper_vars.keys
+
+          break if index + 2 == rule.size
+
+          next if helper_vars.values.include? rest
+
+          helper_vars[letter] = rest unless helper_vars.key?(letter) && rest.size > 1
+        end
+      end
+
+      helper_vars
+    end
+
+    def _chomsky_nf_helper_vars(index, rule, helper_vars)
+      rule_size   = rule.size
+      letter      = helper_vars.empty? ? _find_letter(index) : helper_vars.sort!.last.succ
+      rest        = rule[(index + 1)..rule_size].join
+
+      [letter, rest]
+    end
+
+    def _find_letter(n)
+      result = 'H'
+      n.times { result = result.succ }
+
+      result
+    end
+  end
+end

data/lib/cfg_helper/chomsky_nf_simplifier.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # simplify chomsky normal form
+  class ChomskyNFSimplifier
+    def run(new_rules, alphabet)
+      vars_with_one_letter = _vars_with_one_letter new_rules, alphabet
+
+      return new_rules if vars_with_one_letter.empty?
+
+      extendible_rules = _find_extendible_rules new_rules, vars_with_one_letter.keys
+
+      return new_rules if extendible_rules.empty?
+
+      missing_rules = _missing_rules extendible_rules, vars_with_one_letter
+
+      _add_missing_rules missing_rules, new_rules
+
+      new_rules
+    end
+
+    private
+
+    def _vars_with_one_letter(new_rules, alphabet)
+      vars = {}
+
+      new_rules.each do |key, values|
+        # skip simple rules like (A, a), (B, b),...
+        next if values.size == 1
+
+        letters   = values.select { |val| _is_letter val, alphabet }.uniq
+        vars[key] = letters
+      end
+
+      vars
+    end
+
+    def _is_letter(val, alphabet)
+      val.size == 1 && alphabet.include?(val.downcase)
+    end
+
+    def _find_extendible_rules(new_rules, rules_keys)
+      extendible = {}
+
+      filterd_rules = new_rules.reject { |_, rules| rules.is_a?(String) }
+
+      filterd_rules.each do |letter, rules|
+        rules_keys.each do |rules_key|
+          rules.each do |rule|
+            next unless rule.include?(rules_key)
+
+            extendible[letter] ||= []
+            extendible[letter] << rule
+          end
+        end
+      end
+
+      extendible
+    end
+
+    def _missing_rules(extendible_rules, vars)
+      res = {}
+
+      extendible_rules.each do |var_rule, nfs|
+        nfs.each do |nf|
+          vars.each do |match_char, replacement_chars|
+            replacement_chars.each do |rc|
+              res[var_rule] ||= []
+              res[var_rule] << _combinations(nf, rc, match_char)
+            end
+          end
+
+          res[var_rule] = res[var_rule]&.flatten&.uniq
+
+          _check_special_case nf, res, var_rule, vars
+        end
+      end
+
+      res
+    end
+
+    def _combinations(original_string, replacement_char, match_char)
+      combinations = []
+
+      0.upto(1) do |i|
+        0.upto(1) do |j|
+          new_rule = original_string.dup
+          new_rule[0] = replacement_char if i == 1 && original_string[0] == match_char
+          new_rule[1] = replacement_char if j == 1 && original_string[1] == match_char
+          combinations << new_rule
+        end
+      end
+
+      combinations.uniq
+    end
+
+    def _add_missing_rules(missing_rules, new_rules)
+      missing_rules.each do |key, val|
+        next if val.nil?
+
+        new_rules[key].concat(val).uniq!
+      end
+    end
+
+    def _check_special_case(nf, res, var_rule, vars)
+      vars.each do |match_char, combi|
+        next unless nf == match_char * 2
+
+        missing_rules = combi.map { |lft| combi.map { |rgt| "#{lft}#{rgt}" } }.flatten
+
+        res[var_rule].concat(missing_rules)
+      end
+
+      res
+    end
+  end
+end

data/lib/cfg_helper/cyk.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # Implemention of cyk algo.
+  class CYK
+    attr_reader :matrix, :is_in_l
+
+    def initialize(word, custom_rule)
+      @word        = word
+      @rules       = custom_rule.select { |_, val| val.is_a?(Array) }
+      @helper_vars = @rules.values.flatten
+    end
+
+    def run
+      _cyk_fill_diagonal
+      _cyk_fill_matrix
+      @is_in_l = _is_in_l?
+    end
+
+    private
+
+    def _cyk_fill_diagonal
+      wrd_lng = @word.length
+      @matrix = wrd_lng.times.map { wrd_lng.times.map { [] } }
+
+      (0..wrd_lng - 1).each do |index|
+        @matrix[index][index] = @word[index].upcase
+      end
+    end
+
+    def _cyk_fill_matrix
+      @matrix.size.times do |limiter|
+        (0...@matrix.length - limiter).each do |i|
+          j = i + limiter
+
+          next if i == j
+
+          helper_var      = _helper_var i, j
+          matrix_ele_info = _matrix_ele_info i, j
+          @matrix[i][j]   = _add_to_matrix helper_var, matrix_ele_info
+        end
+      end
+    end
+
+    def _helper_var(row, col)
+      res = '0'
+
+      (row..col - 1).step(1) do |h|
+        p_  = @matrix[row][h]
+        q_  = @matrix[h + 1][col]
+        res = "#{p_}#{q_}"
+
+        break if @helper_vars.include? res
+      end
+
+      res
+    end
+
+    def _matrix_ele_info(i, j)
+      res = {}
+
+      res['i'] = i
+      res['j'] = j
+      res['row_c'] = @matrix.count
+
+      res
+    end
+
+    def _add_to_matrix(helper_var, matrix_ele_info)
+      matrix_ele = '0'
+      return if helper_var == matrix_ele
+
+      keys = []
+
+      @rules.each do |key, vals|
+        vals.each do |val|
+          keys << key if val == helper_var
+        end
+      end
+
+      _matrix_ele keys, matrix_ele_info
+    end
+
+    def _matrix_ele(keys, matrix_ele_info)
+      return 'S' if keys.include?('S') && _is_last_element?(matrix_ele_info)
+
+      return keys.last if keys.size == 1
+
+      keys.reject { |key| key == 'S' }.last || '0'
+    end
+
+    def _is_last_element?(matrix_ele_info)
+      matrix_ele_info['i'].zero? && matrix_ele_info['j'] == matrix_ele_info['row_c'] - 1
+    end
+
+    def _is_in_l?
+      @matrix.first.last == 'S'
+    end
+  end
+end

data/lib/cfg_helper/epsilon_free.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # used to clear a CFG from the epsilon rules
+  class EpsilonFree
+    def run(rules)
+      epsilon  = _epsilon rules
+      rules_ef = {}
+
+      return if epsilon.empty?
+
+      epsilon.each do |e_class|
+        cleared_rules     = _cleared_rules rules[e_class]
+        epsilon_free_word = cleared_rules.map(&:join)
+        grammer           = _grammer_epsilon_free epsilon_free_word, e_class
+        rules_ef[e_class] = grammer
+      end
+
+      rules_ef
+    end
+
+    def rebuild_rules(current_rules, rules_epsilon_free)
+      missing_vars = current_rules.keys - rules_epsilon_free.keys
+
+      res = {}
+      rules_epsilon_free.each do |key, rules|
+        res[key] = []
+        rules.each do |rule|
+          res[key] << rule.chars
+        end
+      end
+
+      missing_vars.each { |v| res[v] = current_rules[v] }
+
+      res
+    end
+
+    private
+
+    def _epsilon(rules)
+      res = rules.map do |var, rule|
+        next unless rule.include? []
+
+        var
+      end
+      res.reject(&:nil?)
+    end
+
+    def _cleared_rules(rules)
+      rules.reject(&:empty?)
+    end
+
+    def _grammer_epsilon_free(epsilon_free_word, e_class)
+      rules_epsilon_location = _new_rules_epsilon_location epsilon_free_word, e_class
+
+      res = []
+      rules_epsilon_location.map do |rule, possibilities|
+        possibilities.each do |possibility|
+          res << _remove_e_class(possibility, rule.split(''))
+        end
+
+        res << epsilon_free_word.delete(e_class) if possibilities.size == 1
+      end
+
+      res.uniq.reject(&:nil?)
+    end
+
+    def _new_rules_epsilon_location(s_rule, e_class)
+      res = {}
+      s_rule.each do |rule|
+        s_index = []
+        rule.each_char.with_index { |char, index| s_index << index if char == e_class }
+        res[rule] = _power_set(s_index)
+      end
+
+      res
+    end
+
+    def _power_set(set)
+      if set.empty?
+        [[]]
+      else
+        element = set[0]
+        subsets = _power_set set[1..]
+        subsets + subsets.map { |subset| [element] + subset }
+      end
+    end
+
+    def _remove_e_class(possibility, cleared_rules)
+      return cleared_rules.join '' if possibility.empty?
+
+      new_rule = cleared_rules.join ''
+      possibility.reverse.each { |index| new_rule.slice! index }
+
+      new_rule
+    end
+  end
+end

data/lib/falafel.rb

@@ -104,10 +104,10 @@ class Falafel
     dfa.to_min
   end
 
-  def pump_lemma
+  def pump_lemma(lang, length)
     require_relative 'pump'
 
-    Pump.new lang: nil, word: nil, n: 2, k: 20
+    Pump.new lang: lang, length: length
   end
 
   def cfg(alphabet, vars_set, start_var, rules)
@@ -118,7 +118,6 @@ class Falafel
 
   private
 
-  # alle bilder eine menge m unter r
   def _image(m, r)
     m.flat_map { |x| r.map { |y, z| z if x == y }.compact }.sort.uniq
   end

data/lib/pump.rb

@@ -2,29 +2,68 @@
 
 # Pump Lemma
 # It takes language as lambda function and a word as a string
-# n is the length of the string you want to pump
-# k is the potens of the middle word
+# lang is a regular expression like a^*b^* given as lambda function and set by user
+# word is the word to check pumping
+# length is the length of the string you want to pump
+# return is_regular to tell if lang is regular and decomposition to show why
 class Pump
   attr_accessor :lang, :word
+  attr_reader :is_regular, :decomposition
 
-  def initialize(lang:, word:, n:, k:)
-    @lang = lang
-    @word = word
-    @n    = n
-    @k    = k
+  def initialize(lang:, length:)
+    @lang   = lang
+    @length = length
+    @word   = ''
   end
 
-  def run
+  def run(show_pros:)
+    _clear_old_run
+
     r, s, t = ''
 
-    (0...@word.length - @n + 1).each do |i|
-      r = @word[0...i]
-      s = @word[i...i + @n]
-      t = @word[i + @n..]
+    @word.length.times do |leng|
+      r, s, t = _sigma_chars leng
+
+      pump_up_down_res = _pump_up_down_res r, s, t, show_pros
+      not_in_language  = pump_up_down_res.include? false
 
-      break if s.length.positive? && (r + s * @k + t) != @word && @lang.call(r + s * @k + t)
+      @is_regular = false if not_in_language
+
+      break if not_in_language
     end
 
+    @decomposition = [r, s, t]
+  end
+
+  private
+
+  def _clear_old_run
+    @decomposition = []
+    @is_regular    = true
+  end
+
+  # ∃r, s, t ∈ Σ^∗
+  def _sigma_chars(leng)
+    r = @word[0...leng] || ''
+    s = @word[leng...leng + @length] || ''
+    t = @word[leng + @length..] || ''
+
     [r, s, t]
   end
+
+  # ∀k ≥ 0 : r·s^k·t ∈ L
+  def _pump_up_down_res(r, s, t, show_pros)
+    pump_up_down_res = []
+
+    20.times do |k|
+      puts "r: #{r}, s: #{s}, t: #{t}, k: #{k}, r + s * k + t: #{r + s * k + t}" if show_pros
+      pump_up_down_res << _pump_condtion_satisfied?(r, s, t, k)
+    end
+
+    pump_up_down_res
+  end
+
+  def _pump_condtion_satisfied?(r, s, t, k)
+    (s.length.positive? && @lang.call(r + s * k + t))
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: falafel
 version: !ruby/object:Gem::Version
-  version: 0.0.1.1
+  version: 0.0.2.2
 platform: ruby
 authors:
 - Abed Alkedda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-03 00:00:00.000000000 Z
+date: 2023-08-12 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -17,18 +17,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cfg.rb
-- lib/chaining_free.rb
-- lib/chomsky_nf.rb
-- lib/chomsky_nf_simplifier.rb
-- lib/cyk.rb
+- lib/cfg_helper/chaining_free.rb
+- lib/cfg_helper/chomsky_nf.rb
+- lib/cfg_helper/chomsky_nf_simplifier.rb
+- lib/cfg_helper/cyk.rb
+- lib/cfg_helper/epsilon_free.rb
 - lib/dfa.rb
-- lib/epsilon_free.rb
 - lib/falafel.rb
 - lib/pump.rb
 - lib/rx.rb
 homepage: https://github.com/AbedAlkedda/AFS
 licenses:
-- Ruby
+- ''
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -48,5 +48,6 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
-summary: Falafel is a gem to help you understand Automata better, hopefully
+summary: Falafel is a gem that will hopefully help you better understand automata
+  and formal languages
 test_files: []

data/lib/chaining_free.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-# remove chaining rules from CFG
-class ChainingFree
-  def run(rules, vars)
-    @rules = rules
-    @vars  = vars
-    c_r    = _chaining_relation
-
-    # build transivity relation from _chaining_relation(K) as A
-    # remove _chaining_relation from rules
-    _rebuild_rules + c_r.map { |r| _transitivity_relation r }.reduce(:concat) - c_r
-  end
-
-  def rebuild_rules(current_rules)
-    res = {}
-
-    @vars.each { |v| res[v] = [] }
-
-    current_rules.each do |l, r|
-      res[l] << r.chars unless res[l].include? r.chars
-    end
-
-    res
-  end
-
-  private
-
-  def _chaining_relation
-    rules = _rebuild_rules
-
-    rules & @vars.product(@vars)
-  end
-
-  def _rebuild_rules
-    result = []
-    @rules.each do |var, rule|
-      rule.map do |r|
-        result << [var, r.join]
-      end
-    end
-
-    result
-  end
-
-  def _transitivity_relation(pair)
-    transitive_relation = [pair]
-
-    new_pairs = []
-
-    _rebuild_rules.each do |a, b|
-      next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
-
-      new_pairs << [pair[0], b]
-    end
-
-    transitive_relation.concat new_pairs
-  end
-
-  def _new_pairs(rules)
-    rules.each do |a, b|
-      next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
-
-      new_pairs << [pair[0], b]
-    end
-  end
-end

data/lib/chomsky_nf.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'chomsky_nf_simplifier'
-
-# convert to Chomsky Normal Form
-class ChomskyNF
-  def run(rules, alphabet)
-    new_rules = {}
-    @rules    = rules
-    @alphabet = alphabet
-
-    # add cases like (A, a), (B, b)
-    _add_single_vars new_rules
-
-    # change rules like (X, aX) to (X, AX)
-    _handle_simple_rule new_rules
-
-    _handle_all_rule new_rules
-  end
-
-  def simplify(rules)
-    simplifier = ChomskyNFSimplifier.new
-
-    simplifier.run rules, @alphabet
-  end
-
-  private
-
-  def _add_single_vars(new_rules)
-    @rules.values.reduce(:concat).each do |rule|
-      rule.select { |var| var == var.downcase }.each do |r|
-        new_rules[r.upcase] = r
-      end
-    end
-  end
-
-  def _handle_simple_rule(new_rules)
-    @rules.each do |var, rule|
-      new_rules[var] = []
-      rule.each do |r|
-        next if r.empty?
-
-        new_rules[var] << r.map(&:upcase)
-      end
-    end
-  end
-
-  def _handle_all_rule(new_rules)
-    new_rules_buffer = {}
-
-    new_rules.each do |var, rules|
-      next if _is_character? rules
-
-      new_rules_buffer = _new_rules_buffer rules, var
-    end
-
-    new_rules.merge! new_rules_buffer
-  end
-
-  def _is_character?(value)
-    value.is_a?(String) && value.length == 1
-  end
-
-  def _new_rules_buffer(rules, var)
-    helper_vars = _helper_vars rules
-    helper_vars.merge! @alphabet.each_with_object({}) { |ele, meme| meme[ele.capitalize] = ele.capitalize }
-
-    _new_rules rules, var, helper_vars
-  end
-
-  def _check_simplify(rule, holder, current_var)
-    return false unless rule.size == 1
-
-    holder[current_var] << rule.last unless holder[current_var].include? rule
-
-    true
-  end
-
-  def _new_rules(rules, var, helper_vars)
-    holder = {}
-
-    rules.each do |rule|
-      rest = ''
-      rule.each_with_index do |head, index|
-        current_var = index.zero? ? var : rest
-        holder[current_var] ||= []
-
-        is_simple = _check_simplify rule, holder, current_var
-
-        break if is_simple
-
-        rest = _chomsky_nf_vars index, rule, helper_vars
-
-        nf_rest = "#{head}#{rest}"
-
-        if index + 2 == rule.size
-          if rest.nil?
-            rest     = rule.last
-            nf_rest += rest
-          end
-
-          holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
-
-          break
-        else
-          holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
-        end
-      end
-    end
-
-    holder
-  end
-
-  def _chomsky_nf_vars(index, rule, helper_vars)
-    rule_size = rule.size
-    rest      = rule[(index + 1)..rule_size].join
-
-    helper_vars.key(rest)
-  end
-
-  def _helper_vars(rules)
-    helper_vars = {}
-
-    rules.each do |rule|
-      rule.each_with_index do |_, index|
-        letter, rest = _chomsky_nf_helper_vars index, rule, helper_vars.keys
-
-        break if index + 2 == rule.size
-
-        next if helper_vars.values.include? rest
-
-        helper_vars[letter] = rest unless helper_vars.key?(letter) && rest.size > 1
-      end
-    end
-
-    helper_vars
-  end
-
-  def _chomsky_nf_helper_vars(index, rule, helper_vars)
-    rule_size   = rule.size
-    letter      = helper_vars.empty? ? _find_letter(index) : helper_vars.sort!.last.succ
-    rest        = rule[(index + 1)..rule_size].join
-
-    [letter, rest]
-  end
-
-  def _find_letter(n)
-    result = 'H'
-    n.times { result = result.succ }
-
-    result
-  end
-end

data/lib/chomsky_nf_simplifier.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-# simplify chomsky normal form
-class ChomskyNFSimplifier
-  def run(new_rules, alphabet)
-    var_has_one_letter = _var_has_one_letter new_rules, alphabet
-
-    return new_rules if var_has_one_letter.empty?
-
-    rules = _find_modify_rules new_rules, var_has_one_letter
-
-    return new_rules if rules.empty?
-
-    missing_rules = _generate_missing_rules rules, var_has_one_letter
-
-    _add_missing_rules missing_rules, new_rules
-
-    new_rules
-  end
-
-  private
-
-  def _var_has_one_letter(new_rules, alphabet)
-    vars = {}
-
-    new_rules.each do |key, values|
-      next if values.size == 1
-
-      values.each do |val|
-        next unless val.size == 1 && alphabet.include?(val.downcase)
-
-        vars[key] ||= []
-        vars[key] << val
-      end
-    end
-
-    vars
-  end
-
-  def _find_modify_rules(new_rules, vars)
-    modify = {}
-
-    new_rules.each do |key, val|
-      next if val.is_a?(String)
-
-      val.each do |v|
-        vars.each_key do |k|
-          next unless v.include?(k)
-
-          res = val.select { |x| x.include? k }
-
-          modify[key] ||= []
-          modify[key] << res
-        end
-      end
-    end
-
-    modify
-  end
-
-  def _generate_missing_rules(rules, vars)
-    res = {}
-
-    rules.each do |var_rule, nfs|
-      nfs.flatten.each do |nf|
-        vars.each do |match_char, replacement_chars|
-          replacement_chars.each do |rc|
-            new_rules = _combinations nf, rc, match_char
-            res[var_rule] ||= []
-            res[var_rule] << new_rules
-          end
-        end
-        _check_special_case nf, res, var_rule, vars
-      end
-    end
-
-    res
-  end
-
-  def _combinations(original_string, replacement_char, match_char)
-    combinations = []
-
-    0.upto(1) do |i|
-      0.upto(1) do |j|
-        new_rule = original_string.dup
-        new_rule[0] = replacement_char if i == 1 && original_string[0] == match_char
-        new_rule[1] = replacement_char if j == 1 && original_string[1] == match_char
-        combinations << new_rule
-      end
-    end
-
-    combinations.uniq
-  end
-
-  def _add_missing_rules(missing_rules, new_rules)
-    missing_rules.each { |key, val| new_rules[key] = val.flatten.uniq! }
-  end
-
-  def _check_special_case(nf, res, var_rule, vars)
-    vars.each do |match_char, combi|
-      next unless nf == match_char * 2
-
-      missing_rules = combi.map { |lft| combi.map { |rgt| "#{lft}#{rgt}" } }.flatten
-
-      res[var_rule] << missing_rules
-    end
-
-    res
-  end
-end

data/lib/cyk.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-# Implemention of cyk algo.
-class CYK
-  attr_reader :matrix, :is_in_l
-
-  def initialize(word, custom_rule)
-    @word        = word
-    @rules       = custom_rule.select { |_, val| val.is_a?(Array) }
-    @helper_vars = @rules.values.flatten
-  end
-
-  def run
-    _cyk_fill_diagonal
-    _cyk_fill_matrix
-    _is_in_l?
-  end
-
-  private
-
-  def _cyk_fill_diagonal
-    wrd_lng = @word.length
-    @matrix = wrd_lng.times.map { wrd_lng.times.map { [] } }
-
-    (0..wrd_lng - 1).each do |index|
-      @matrix[index][index] = @word[index].upcase
-    end
-  end
-
-  def _cyk_fill_matrix
-    @matrix.size.times do |limiter|
-      (0...@matrix.length - limiter).each do |i|
-        j = i + limiter
-
-        next if i == j
-
-        helper_var = _helper_var i, j
-
-        @matrix[i][j] = _add_to_matrix helper_var
-      end
-    end
-  end
-
-  def _helper_var(row, col)
-    res = '0'
-
-    (row..col - 1).step(1) do |h|
-      p_  = @matrix[row][h]
-      q_  = @matrix[h + 1][col]
-      res = "#{p_}#{q_}"
-
-      break if @helper_vars.include? res
-    end
-
-    res
-  end
-
-  def _add_to_matrix(rule)
-    res = '0'
-    return if rule == res
-
-    @rules.each do |key, vals|
-      vals.each do |val|
-        res = key if val == rule
-      end
-    end
-
-    res
-  end
-
-  def _is_in_l?
-    @is_in_l = @matrix.first.last == 'S'
-  end
-end

data/lib/epsilon_free.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# used to clear a CFG from the epsilon rules
-class EpsilonFree
-  def run(rules)
-    epsilon  = _epsilon rules
-    rules_ef = {}
-
-    return if epsilon.empty?
-
-    epsilon.each do |e_class|
-      cleared_rules     = _cleared_rules rules[e_class]
-      epsilon_free_word = cleared_rules.map(&:join)
-      grammer           = _grammer_epsilon_free epsilon_free_word, e_class
-      rules_ef[e_class] = grammer
-    end
-
-    rules_ef
-  end
-
-  def rebuild_rules(current_rules, rules_epsilon_free)
-    missing_vars = current_rules.keys - rules_epsilon_free.keys
-
-    res = {}
-    rules_epsilon_free.each do |key, rules|
-      res[key] = []
-      rules.each do |rule|
-        res[key] << rule.chars
-      end
-    end
-
-    missing_vars.each { |v| res[v] = current_rules[v] }
-
-    res
-  end
-
-  private
-
-  def _epsilon(rules)
-    res = rules.map do |var, rule|
-      next unless rule.include? []
-
-      var
-    end
-    res.reject(&:nil?)
-  end
-
-  def _cleared_rules(rules)
-    rules.reject(&:empty?)
-  end
-
-  def _grammer_epsilon_free(epsilon_free_word, e_class)
-    rules_epsilon_location = _new_rules_epsilon_location epsilon_free_word, e_class
-
-    res = []
-    rules_epsilon_location.map do |rule, possibilities|
-      possibilities.each do |possibility|
-        res << _remove_e_class(possibility, rule.split(''))
-      end
-
-      res << epsilon_free_word.delete(e_class) if possibilities.size == 1
-    end
-
-    res
-  end
-
-  def _new_rules_epsilon_location(s_rule, e_class)
-    res = {}
-    s_rule.each do |rule|
-      s_index = []
-      rule.each_char.with_index { |char, index| s_index << index if char == e_class }
-      res[rule] = _power_set(s_index)
-    end
-
-    res
-  end
-
-  def _power_set(set)
-    if set.empty?
-      [[]]
-    else
-      element = set[0]
-      subsets = _power_set set[1..]
-      subsets + subsets.map { |subset| [element] + subset }
-    end
-  end
-
-  def _remove_e_class(possibility, cleared_rules)
-    return cleared_rules.join '' if possibility.empty?
-
-    new_rule = cleared_rules.join ''
-    possibility.reverse.each { |index| new_rule.slice! index }
-
-    new_rule
-  end
-end