falafel 0.0.1.1 → 0.0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796b681163a3d9d57b47cadcb95f1d5e2e9af1e97a0b841b2e31ddc9c725769b
-  data.tar.gz: 3811e2bc49acfee5aa9a4e4f27569df022fb68c2ddafbafa10b43a7c92afe4d8
+  metadata.gz: 5180f16b8868a35cf65faa396c7b341166604e2aaf7db8d9f7099c819630497f
+  data.tar.gz: 7c773f6a53d8895333d37115cba598dcf60128bff2eaf4dc47e73f7e1ca21298
 SHA512:
-  metadata.gz: 96bf15557a50f7a81c8a71d200a0876f7fc445d64d017d3c2011fa088457d61e05327e8ea39c7147d349049a8e8b3811a815c92e04f414109c4505782a8c6613
-  data.tar.gz: 45573ad63969221aed699f9412d45409c4f72a26c1ec3e83e3bcb4c5fba03c6fb9bdae80d61b3c0a046e4c25a66a00e7c64c00a1841142de675e7eaa45158876
+  metadata.gz: 0b7470e125d1f803eacc1d207704b90782e439fef8c7fe00dcf0acdb6c27324d24ed2da0666b3c456fe7cc7b255902002f20870e8f93d589482d4d1df3370aca
+  data.tar.gz: c8534f9da1cfec2623caa5cf0422f3d03009579374d2183a10341398a93aad87fbf2a0e85aaba0a0a766ee1d8ae62baa02e39bd2a76c7857fa6613629ae64f5a

data/lib/cfg.rb

@@ -10,7 +10,7 @@ require_relative 'chaining_free'
 # 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,24 +34,9 @@ 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
+  def epsilon_free(custom_rule)
     e_free        = EpsilonFree.new
-    @rules_ef_res = e_free.run @rules
+    @rules_ef_res = e_free.run custom_rule || @rules
     @rules_ef     = e_free.rebuild_rules @rules, @rules_ef_res
   end
 

data/lib/chomsky_nf.rb

@@ -46,15 +46,15 @@ class ChomskyNF
   end
 
   def _handle_all_rule(new_rules)
-    new_rules_buffer = {}
+    new_rules_buffer = []
 
     new_rules.each do |var, rules|
       next if _is_character? rules
 
-      new_rules_buffer = _new_rules_buffer rules, var
+      new_rules_buffer << _new_rules_buffer(rules, var)
     end
 
-    new_rules.merge! new_rules_buffer
+    new_rules.merge! new_rules_buffer.reduce(&:merge)
   end
 
   def _is_character?(value)

data/lib/chomsky_nf_simplifier.rb

@@ -3,15 +3,15 @@
 # simplify chomsky normal form
 class ChomskyNFSimplifier
   def run(new_rules, alphabet)
-    var_has_one_letter = _var_has_one_letter new_rules, alphabet
+    vars_with_one_letter = _vars_with_one_letter new_rules, alphabet
 
-    return new_rules if var_has_one_letter.empty?
+    return new_rules if vars_with_one_letter.empty?
 
-    rules = _find_modify_rules new_rules, var_has_one_letter
+    extendible_rules = _find_extendible_rules new_rules, vars_with_one_letter.keys
 
-    return new_rules if rules.empty?
+    return new_rules if extendible_rules.empty?
 
-    missing_rules = _generate_missing_rules rules, var_has_one_letter
+    missing_rules = _missing_rules extendible_rules, vars_with_one_letter
 
     _add_missing_rules missing_rules, new_rules
 
@@ -20,56 +20,57 @@ class ChomskyNFSimplifier
 
   private
 
-  def _var_has_one_letter(new_rules, alphabet)
+  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
 
-      values.each do |val|
-        next unless val.size == 1 && alphabet.include?(val.downcase)
-
-        vars[key] ||= []
-        vars[key] << val
-      end
+      letters   = values.select { |val| _is_letter val, alphabet }.uniq
+      vars[key] = letters
     end
 
     vars
   end
 
-  def _find_modify_rules(new_rules, vars)
-    modify = {}
+  def _is_letter(val, alphabet)
+    val.size == 1 && alphabet.include?(val.downcase)
+  end
 
-    new_rules.each do |key, val|
-      next if val.is_a?(String)
+  def _find_extendible_rules(new_rules, rules_keys)
+    extendible = {}
 
-      val.each do |v|
-        vars.each_key do |k|
-          next unless v.include?(k)
+    filterd_rules = new_rules.reject { |_, rules| rules.is_a?(String) }
 
-          res = val.select { |x| x.include? k }
+    filterd_rules.each do |letter, rules|
+      rules_keys.each do |rules_key|
+        rules.each do |rule|
+          next unless rule.include?(rules_key)
 
-          modify[key] ||= []
-          modify[key] << res
+          extendible[letter] ||= []
+          extendible[letter] << rule
         end
       end
     end
 
-    modify
+    extendible
   end
 
-  def _generate_missing_rules(rules, vars)
+  def _missing_rules(extendible_rules, vars)
     res = {}
 
-    rules.each do |var_rule, nfs|
-      nfs.flatten.each do |nf|
+    extendible_rules.each do |var_rule, nfs|
+      nfs.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
+            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
@@ -93,7 +94,11 @@ class ChomskyNFSimplifier
   end
 
   def _add_missing_rules(missing_rules, new_rules)
-    missing_rules.each { |key, val| new_rules[key] = val.flatten.uniq! }
+    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)
@@ -102,7 +107,7 @@ class ChomskyNFSimplifier
 
       missing_rules = combi.map { |lft| combi.map { |rgt| "#{lft}#{rgt}" } }.flatten
 
-      res[var_rule] << missing_rules
+      res[var_rule].concat(missing_rules)
     end
 
     res

data/lib/cyk.rb

@@ -13,7 +13,7 @@ class CYK
   def run
     _cyk_fill_diagonal
     _cyk_fill_matrix
-    _is_in_l?
+    @is_in_l = _is_in_l?
   end
 
   private
@@ -34,9 +34,9 @@ class CYK
 
         next if i == j
 
-        helper_var = _helper_var i, j
-
-        @matrix[i][j] = _add_to_matrix helper_var
+        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
@@ -55,20 +55,44 @@ class CYK
     res
   end
 
-  def _add_to_matrix(rule)
-    res = '0'
-    return if rule == res
+  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|
-        res = key if val == rule
+        keys << key if val == helper_var
       end
     end
 
-    res
+    _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?
-    @is_in_l = @matrix.first.last == 'S'
+    @matrix.first.last == 'S'
   end
 end

data/lib/epsilon_free.rb

@@ -61,7 +61,7 @@ class EpsilonFree
       res << epsilon_free_word.delete(e_class) if possibilities.size == 1
     end
 
-    res
+    res.uniq.reject(&:nil?)
   end
 
   def _new_rules_epsilon_location(s_rule, e_class)

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.1
 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:
@@ -28,7 +28,7 @@ files:
 - 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: []