falafel 0.0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 455d0fee114300f1c5a7f5f68b128412704f6bba8782efc62db6f6d151a1bfdd
+  data.tar.gz: b96c52e7fd535cc95e140722e522c959bb860c78ab0b93030240c7fa148995a6
+SHA512:
+  metadata.gz: 44076c2c3d1ab9cb52a43493b6e17f63944d7dc2c7ef6842395befec2f27513103e0592a671ff5352ab680381d9e1323ea498cb332926f924ec1a4236ac9c051
+  data.tar.gz: bfe088d01ace7256fa535ac8c1e2d041972203535a98ffbce6e9785a7e28bb2aed332aa2239a0f43929d8c4aecb69a422bd5273580e87e373611db122134f403

data/lib/dfa.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'falafel'
+
+# DFA class
+class DFA < Falafel
+  attr_accessor :delta_star, :states, :finals, :start
+
+  def to_min
+    finals = _finals
+    states = _states
+    r0     = _r0 finals, states
+    steps  = {}
+
+    steps['R0'] = r0
+    finals_hash = _finals_hash finals, states
+    steps       = _steps_builder finals, states, steps
+
+    _print finals_hash, finals, states
+    _print_steps steps
+  end
+
+  private
+
+  def _finals
+    @finals.map { |f| f.join('').to_i }
+  end
+
+  def _states
+    ltr = 'p'
+    states = @states.each_with_object({}) do |elt, memo|
+      memo[elt] = ltr
+      ltr       = ltr.succ
+    end
+
+    puts "\nQ=#{states}"
+
+    states
+  end
+
+  def _r0(finals, states)
+    r0 = []
+    @states.each_with_index do |p, _|
+      @states.each_with_index do |q, _|
+        r0 << [states[p], states[q]] if finals.include?(p) == finals.include?(q)
+      end
+    end
+
+    r0
+  end
+
+  def _finals_hash(finals, states)
+    (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
+      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}"]
+      steps["R#{l + 1}"] = r
+
+      return steps if steps["R#{l}"] == r
+    end
+  end
+
+  def _print(finals_hash, finals, states)
+    puts "F=#{finals_hash.inspect}"
+
+    f_equivalent = finals.flat_map { |s| states.values_at(s) }
+    q_without_f  = (@states - (@states & finals)).flat_map { |s| states.values_at(s) }
+    puts "{F, Q\\F }={#{f_equivalent}}, {#{q_without_f}}"
+  end
+
+  def _print_steps(steps)
+    steps.each { |k, v| puts "#{k}=#{v}" }
+  end
+
+  def _ri_set(states, c, p, q)
+    lft = states[(_image [p], @delta_star[c])[0]]
+    rgt = states[(_image [q], @delta_star[c])[0]]
+
+    [[lft, rgt]]
+  end
+end

data/lib/falafel.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'rx'
+
+# Convert NFA to DFA
+# DFA to REG
+# Minimize DFA
+class Falafel
+  def self.new
+    instance = allocate
+    yield instance
+
+    instance
+  end
+
+  def build(*args, states:, starts:, finals:)
+    d_a, d_b    = args
+    @delta_star = { a: d_a, b: d_b }
+    @state_set  = power_set states
+    @finals     = finals
+    @states     = states
+    @start      = starts
+  end
+
+  # Binary relation for max number
+  def relation(max)
+    (1..max).flat_map { |x| (1..3).map { |y| [x, y] } }
+  end
+
+  # Concatenation two states
+  # Example: [[1, 2]] . [[2, 1]] => [1, 1]
+  def compose(lft, rgt)
+    lft.flat_map { |x, y1| rgt.select { |y2, _| y1 == y2 }.map { |_, z| [x, z] } }
+  end
+
+  # Power set of Q
+  def power_set(states)
+    power_set = [[]]
+    states.each { |e| power_set.concat(power_set.map { |set| set + [e] }) }
+
+    power_set
+  end
+
+  def potens_set
+    @state_set.each { |set| @delta_star.each { |delta, relation| puts "#{set.inspect}·#{delta}() = #{_image(set, relation).inspect}" } }
+  end
+
+  def nfa_to_dfa
+    require_relative 'dfa'
+
+    dfa = DFA.new { |a| a.build [], [], states: [], starts: @start, finals: [] }
+    reachable     = []
+    done_state    = []
+    current_state = @start
+
+    loop do
+      @delta_star.each do |delta, relation|
+        break if done_state.include? current_state
+
+        res, rgt, lft = _new_state current_state, relation
+
+        dfa.states << rgt unless dfa.states.include? rgt
+
+        dfa.delta_star[delta] << [lft, rgt]
+
+        reachable << res unless reachable.include? res
+
+        reachable.delete res if done_state.include? res
+      end
+
+      break if reachable.empty?
+
+      done_state << current_state unless done_state.include? current_state
+
+      dfa.finals << current_state if (current_state & @finals).any?
+
+      current_state = reachable.last
+
+      reachable.pop
+    end
+    dfa.finals.uniq!
+
+    _print_dfa dfa
+
+    dfa
+  end
+
+  def nfa_to_reg
+    RX.new { |rx| rx.build @states, @delta_star }
+  end
+
+  def dfa_to_min(automat)
+    d_a    = automat.delta_star[:a]
+    d_b    = automat.delta_star[:b]
+    states = automat.states
+    starts = automat.start
+    finals = automat.finals
+
+    dfa = DFA.new { |a| a.build d_a, d_b, states: states, starts: starts, finals: finals }
+    dfa.to_min
+  end
+
+  def pump_lemma
+    require_relative 'pump'
+
+    Pump.new lang: nil, word: nil, n: 2, k: 20
+  end
+
+  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
+
+  def _concat(set)
+    set.to_a.join('').to_i
+  end
+
+  def _new_state(state, relation)
+    res = _image state, relation
+    rgt = _concat res
+    lft = _concat state
+
+    [res, rgt, lft]
+  end
+
+  def _print_dfa(dfa)
+    puts "dfa:\nfinals: #{dfa.finals.map { |ele| _concat(ele).to_i }}"
+    puts "states: #{dfa.states.map(&:to_i)}"
+    dfa.delta_star.each { |k, v| v.each { |e| puts "(#{e[0]} ,'#{k}', #{e[1]})" } }
+  end
+end

data/lib/pump.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# 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
+class Pump
+  attr_accessor :lang, :word
+
+  def initialize(lang:, word:, n:, k:)
+    @lang = lang
+    @word = word
+    @n    = n
+    @k    = k
+  end
+
+  def 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..]
+
+      break if s.length.positive? && (r + s * @k + t) != @word && @lang.call(r + s * @k + t)
+    end
+
+    [r, s, t]
+  end
+end

data/lib/rx.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Regex string builder
+class RX
+  def self.new
+    instance = allocate
+    yield instance
+
+    instance
+  end
+
+  def build(states, delta_star)
+    @states     = states
+    @delta_star = delta_star
+    @empty      = "\u2205"
+    _to_reg
+  end
+
+  private
+
+  def _to_reg
+    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
+        end
+      end
+      steps["l#{steps.size}"] = l
+    end
+    _print_matrix steps
+  end
+
+  def _l0
+    l0 = []
+    @states.each_with_index do |_, i|
+      l0[i] = []
+      @states.each_with_index do |_, y|
+        l0[i][y] = _letter i, y
+      end
+    end
+
+    l0
+  end
+
+  def _l(l, p, q, h)
+    case [h == p, h == q]
+    in [true, true]  then _states_equal l, h
+    in [true, false] then _states_begin  l, h, q
+    in [false, true] then _states_end l, h, p
+    else _states_unequal l, p, q, h
+    end
+  end
+
+  def _letter_build(l, i, y)
+    letter  = i == y ? 'ε' : ''
+    letter += letter.empty? ? l : "+#{l}"
+
+    letter
+  end
+
+  def _reachable(delta, i, y)
+    (@delta_star[delta] & [[i + 1, y + 1]]).any?
+  end
+
+  def _letter(i, y)
+    letter = ''
+
+    if _reachable :a, i, y
+      letter = _letter_build 'a', i, y
+    elsif _reachable :b, i, y
+      letter = _letter_build 'b', i, y
+    else
+      letter += '∅'
+      letter  = 'ε' if i == y
+    end
+
+    letter
+  end
+
+  def _states_equal(l, h)
+    "(#{_state_simplify l, h})*"
+  end
+
+  def _states_begin(l, h, q)
+    lft    = l[h][q]
+    rgt    = _clear_reg l[h][h]
+    letter = "#{lft}.(#{rgt})*"
+    letter = @empty if lft == @empty || rgt == @empty
+
+    letter
+  end
+
+  def _states_end(l, h, p)
+    lft    = _clear_reg l[h][h]
+    rgt    = l[h][p]
+    letter = "(#{lft})*.#{rgt}"
+    letter = @empty if lft == @empty || rgt == @empty
+
+    letter
+  end
+
+  def _states_unequal(l0, p, q, h)
+    lft = l0[p][q]
+    lft = lft.dup
+    lft.gsub!(/∅/, '')
+
+    rgt = _states_unequal_rgt l0, p, q, h
+    rgt = rgt.dup
+    rgt.gsub!(/∅./, '')
+
+    return "(#{rgt})" if lft.empty?
+
+    rgt == @empty ? lft : "#{lft}+(#{rgt})"
+  end
+
+  def _state_simplify(l, h)
+    l[h][h].size == 3 ? l[h][h][2] : l[h][h]
+  end
+
+  def _clear_reg(str)
+    str.gsub(/ε./, '')
+  end
+
+  def _empty?(state)
+    state == @empty
+  end
+
+  def _states_unequal_rgt(l, p, q, h)
+    letter = _clear_reg l[h][h]
+    rgt    = "#{l[h][q]}.(#{letter})*.#{l[p][h]}"
+    rgt    = @empty if _empty?(l[p][h]) || _empty?(l[h][h]) || _empty?(l[h][q])
+
+    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

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: falafel
+version: !ruby/object:Gem::Version
+  version: 0.0.0.1
+platform: ruby
+authors:
+- Abed A
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-05 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dfa.rb
+- lib/falafel.rb
+- lib/pump.rb
+- lib/rx.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Falafel is a gem to help you understand autotool better, hopefully
+test_files: []