falafel 0.0.0.2 → 0.0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 821f2ac8523791cce7c4632e69d67a4bee8f208b7e7cf8f1e1e88dbd82e0bc1f
-  data.tar.gz: b92c2f37f9b2585a5aff6f87307378dbdeb6c452db5ff6dd738cd836f57b4a2a
+  metadata.gz: 5180f16b8868a35cf65faa396c7b341166604e2aaf7db8d9f7099c819630497f
+  data.tar.gz: 7c773f6a53d8895333d37115cba598dcf60128bff2eaf4dc47e73f7e1ca21298
 SHA512:
-  metadata.gz: a40d294e74954d85c19abe0bcd80c222390b7f3703c6a87d471d8fb30ed89aadd0ab5297f7e02c4521c282e6bd55e31e70cee68482a0d36c2b0572c477e05263
-  data.tar.gz: 1889ce0c9deb9585907fc663e20d73895051fd054a9289b591f7990a3c3494579ad5fbfce79f9e92153bb4882ca621f25e063e8546346015f15660614902a888
+  metadata.gz: 0b7470e125d1f803eacc1d207704b90782e439fef8c7fe00dcf0acdb6c27324d24ed2da0666b3c456fe7cc7b255902002f20870e8f93d589482d4d1df3370aca
+  data.tar.gz: c8534f9da1cfec2623caa5cf0422f3d03009579374d2183a10341398a93aad87fbf2a0e85aaba0a0a766ee1d8ae62baa02e39bd2a76c7857fa6613629ae64f5a

data/lib/cfg.rb

@@ -1,44 +1,80 @@
 # 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,
+                :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  = []
+    @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 generate_word
-    word = _expand @start_var
+  def epsilon_free(custom_rule)
+    e_free        = EpsilonFree.new
+    @rules_ef_res = e_free.run custom_rule || @rules
+    @rules_ef     = e_free.rebuild_rules @rules, @rules_ef_res
+  end
 
-    return unless @lang.call word
+  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
 
-    @rnd_words << word unless @rnd_words.include? word
+  def chomsky_nf(custom_rule)
+    chomsky = ChomskyNF.new
+    rules   = chomsky.run custom_rule || @rules, @alphabet
+
+    @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.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

data/lib/chomsky_nf_simplifier.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# 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

data/lib/cyk.rb

@@ -0,0 +1,98 @@
+# 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 = _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

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.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

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)
@@ -100,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)
@@ -114,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

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.2.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-12 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:
+- ''
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -42,5 +48,6 @@ 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 that will hopefully help you better understand automata
+  and formal languages
 test_files: []