falafel 0.0.0.2 → 0.0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 821f2ac8523791cce7c4632e69d67a4bee8f208b7e7cf8f1e1e88dbd82e0bc1f
-  data.tar.gz: b92c2f37f9b2585a5aff6f87307378dbdeb6c452db5ff6dd738cd836f57b4a2a
+  metadata.gz: 796b681163a3d9d57b47cadcb95f1d5e2e9af1e97a0b841b2e31ddc9c725769b
+  data.tar.gz: 3811e2bc49acfee5aa9a4e4f27569df022fb68c2ddafbafa10b43a7c92afe4d8
 SHA512:
-  metadata.gz: a40d294e74954d85c19abe0bcd80c222390b7f3703c6a87d471d8fb30ed89aadd0ab5297f7e02c4521c282e6bd55e31e70cee68482a0d36c2b0572c477e05263
-  data.tar.gz: 1889ce0c9deb9585907fc663e20d73895051fd054a9289b591f7990a3c3494579ad5fbfce79f9e92153bb4882ca621f25e063e8546346015f15660614902a888
+  metadata.gz: 96bf15557a50f7a81c8a71d200a0876f7fc445d64d017d3c2011fa088457d61e05327e8ea39c7147d349049a8e8b3811a815c92e04f414109c4505782a8c6613
+  data.tar.gz: 45573ad63969221aed699f9412d45409c4f72a26c1ec3e83e3bcb4c5fba03c6fb9bdae80d61b3c0a046e4c25a66a00e7c64c00a1841142de675e7eaa45158876

data/lib/cfg.rb

@@ -1,44 +1,96 @@
 # frozen_string_literal: true
 
+require_relative 'cyk'
+require_relative 'chomsky_nf'
+require_relative 'epsilon_free'
+require_relative 'chaining_free'
+
 # Samll CFG impletation
 # Generate words and check if words are the @lang
+# generates random words
 class CFG
-  attr_accessor :alphabet, :vars, :start_var, :rules
-  attr_reader   :rnd_words
-  attr_writer   :lang
+  attr_accessor :start_var, :rules
+  attr_reader   :rules_ef,     :rules_cf,     :rnd_words, :reachables,
+                :rules_ef_res, :rules_cf_res, :chomsky_nf_rules,
+                :cyk_matrix,   :is_in_l
 
   def initialize(alphabet, vars, start_var, rules)
-    @alphabet  = alphabet
-    @vars      = vars
-    @start_var = start_var
-    @rules     = _rules rules
+    @start_var  = start_var
+    @rules      = _rules rules
+    @rnd_words  = []
+    @reachables = []
+    @vars       = vars
+    @alphabet   = alphabet
+  end
+
+  def generate_words(count)
     @rnd_words = []
+
+    loop do
+      word = _expand @start_var
+
+      @rnd_words << word unless @rnd_words.include? word
+
+      break if @rnd_words.size == count
+    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
+    @rules_ef     = e_free.rebuild_rules @rules, @rules_ef_res
   end
 
-  def generate_word
-    word = _expand @start_var
+  def chaining_free
+    c_free        = ChainingFree.new
+    @rules_cf_res = c_free.run @rules, @vars
+    @rules_cf     = c_free.rebuild_rules @rules_cf_res
+  end
 
-    return unless @lang.call word
+  def chomsky_nf(custom_rule)
+    chomsky = ChomskyNF.new
+    rules   = chomsky.run custom_rule || @rules, @alphabet
 
-    @rnd_words << word unless @rnd_words.include? word
+    @chomsky_nf_rules = chomsky.simplify rules
   end
 
-  def dyck?(word)
-    ->(w) { (w.count('a') - w.count('b')).zero? }.call word
+  def cyk_run(word)
+    cyk = CYK.new word, @chomsky_nf_rules
+
+    cyk.run
+
+    @cyk_matrix = cyk.matrix
+    @is_in_l    = cyk.is_in_l
   end
 
   private
 
+  def _rules(rules)
+    rules.each_value { |k| k.each_with_index { |item, index| k[index] = item[0].is_a?(String) ? item[0].split('') : item } }
+  end
+
   def _expand(symbol)
     production = @rules[symbol]
 
     return symbol if production.nil?
 
-    rhs = production.sample
-    rhs.map { |s| _expand(s) }.join
-  end
+    rhs = production.sample # pick up a random element from array
 
-  def _rules(rules)
-    rules.each_value { |k| k.each_with_index { |item, index| k[index] = item[0].is_a?(String) ? item[0].split('') : item } }
+    rhs.map { |s| _expand(s) }.join
   end
 end

data/lib/chaining_free.rb

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

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

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

@@ -0,0 +1,74 @@
+# 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/dfa.rb

@@ -53,26 +53,29 @@ class DFA < Falafel
     (finals & states.keys).each_with_object({}) { |elt, memo| memo[elt] = states[elt] }
   end
 
-  def _r(finals, states, ri)
-    r = []
-    @states.each_with_index do |p, _|
-      @states.each_with_index do |q, _|
-        if finals.include?(p) == finals.include?(q)
-          @delta_star.each_key do |c|
-            ri_set = _ri_set states, c, p, q
-            r << (ri_set & ri).flatten if (ri_set & ri).any?
-          end
-        end
+  def _r(finals, states, steps)
+    r      = []
+    last_r = steps["R#{steps.size - 1}"]
+
+    last_r.each do |pair|
+      @delta_star.each_key do |c|
+        pair_frst = pair[0]
+        pair_lst  = pair[1]
+
+        ri_set = _ri_set states, c, states.key(pair_frst), states.key(pair_lst)
+
+        break unless last_r.include? ri_set
+
+        r << [pair_frst, pair_lst] unless r.include? [pair_frst, pair_lst]
       end
     end
-    r.uniq!
 
     r
   end
 
   def _steps_builder(finals, states, steps)
     0.upto(1_000) do |l|
-      r = _r finals, states, steps["R#{l}"]
+      r = _r finals, states, steps
       steps["R#{l + 1}"] = r
 
       return steps if steps["R#{l}"] == r
@@ -95,6 +98,6 @@ class DFA < Falafel
     lft = states[(_image [p], @delta_star[c])[0]]
     rgt = states[(_image [q], @delta_star[c])[0]]
 
-    [[lft, rgt]]
+    [lft, rgt]
   end
 end

data/lib/epsilon_free.rb

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

data/lib/falafel.rb

@@ -2,9 +2,13 @@
 
 require_relative 'rx'
 
-# Convert NFA to DFA
+# NFA to DFA
 # DFA to REG
 # Minimize DFA
+# Remove epsilons from CFG
+# Remove chaining from CFG
+# Find a chomsky normal form fro CFG
+# Apply CYK alogrithm on CFG and solve word problem
 class Falafel
   def self.new
     instance = allocate
@@ -86,7 +90,7 @@ class Falafel
   end
 
   def nfa_to_reg
-    RX.new { |rx| rx.build @states, @delta_star }
+    RX.new { |rx| rx.build @states, @delta_star, @start, @finals }
   end
 
   def dfa_to_min(automat)

data/lib/rx.rb

@@ -2,6 +2,8 @@
 
 # Regex string builder
 class RX
+  attr_reader :final_reg
+
   def self.new
     instance = allocate
     yield instance
@@ -9,31 +11,52 @@ class RX
     instance
   end
 
-  def build(states, delta_star)
+  def build(states, delta_star, start, finals)
     @states     = states
     @delta_star = delta_star
+    @start      = start
+    @finals     = finals
     @empty      = "\u2205"
     _to_reg
   end
 
+  def print_matrix
+    @steps.each do |key, value|
+      puts key
+      value.transpose.each do |column|
+        column.each do |element|
+          printf("\t|%-#{value.map { |c| c.max_by(&:length).length }.max}s", element)
+        end
+        puts '|'
+      end
+    end
+    _final_reg
+  end
+
+  def _final_reg
+    start      = @start[0] - 1
+    final      = @finals[0] - 1
+    lang       = @steps["l#{@steps.size - 1}"]
+    @final_reg = lang[start][final]
+  end
+
   private
 
   def _to_reg
     l0 = _l0
-    steps = {}
-    steps['l0'] = l0
+    @steps = {}
+    @steps['l0'] = l0
 
     @states.size.times do |h|
       l = []
       @states.each_with_index do |_, p|
         l[p] = []
         @states.each_with_index do |_, q|
-          l[p][q] = _l steps["l#{h}"], p, q, steps.size - 1
+          l[p][q] = _l @steps["l#{h}"], p, q, @steps.size - 1
         end
       end
-      steps["l#{steps.size}"] = l
+      @steps["l#{@steps.size}"] = l
     end
-    _print_matrix steps
   end
 
   def _l0
@@ -138,17 +161,4 @@ class RX
 
     rgt
   end
-
-  def _print_matrix(steps)
-    steps.each do |key, value|
-      puts key
-      max_width = value.map { |column| column.max_by(&:length).length }.max
-      value.transpose.each do |column|
-        column.each do |element|
-          printf("\t|%-#{max_width}s", element)
-        end
-        puts '|'
-      end
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: falafel
 version: !ruby/object:Gem::Version
-  version: 0.0.0.2
+  version: 0.0.1.1
 platform: ruby
 authors:
-- Abed A
+- Abed Alkedda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-21 00:00:00.000000000 Z
+date: 2023-08-03 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -17,12 +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/dfa.rb
+- lib/epsilon_free.rb
 - lib/falafel.rb
 - lib/pump.rb
 - lib/rx.rb
-homepage:
-licenses: []
+homepage: https://github.com/AbedAlkedda/AFS
+licenses:
+- Ruby
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -42,5 +48,5 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
-summary: Falafel is a gem to help you understand autotool better, hopefully
+summary: Falafel is a gem to help you understand Automata better, hopefully
 test_files: []