rlsm 1.0.0 → 1.1.0

data/lib/rlsm.rb

@@ -1,17 +1,13 @@
-$:.unshift File.expand_path(File.dirname(__FILE__))
-
-require 'monkey_patching/array_ext'
-
 module RLSM
-  VERSION = '1.0.0'
-end
+  VERSION = "1.1.0"
 
-#Setting up the exception classes.
-class RLSMException < Exception; end
-class MonoidException < RLSMException; end
-class DFAException < RLSMException; end
-class REException < RLSMException; end
+  def self.lib_path_to(file_name)
+    File.join(File.dirname(__FILE__), 'rlsm', file_name)
+  end
 
-require 'rlsm/monoid'
-require 'rlsm/dfa'
-require 'rlsm/re'
+  autoload :BinaryOperation, RLSM.lib_path_to("binary_operation.rb")
+  autoload :Monoid, RLSM.lib_path_to("monoid.rb")
+  autoload :DFA, RLSM.lib_path_to("dfa.rb")
+  autoload :RegExp, RLSM.lib_path_to("regexp.rb")
+end
+  

data/lib/rlsm/binary_operation.rb

@@ -0,0 +1,151 @@
+require File.join(File.dirname(__FILE__), 'helper')
+RLSM.require_extension 'binop'
+
+module RLSM
+  class BinaryOperation
+    class << self; alias original_new new; end
+=begin rdoc
+Creates a BinaryOperation from given description and validates the result.
+Raises a ParseError if validation fails.
+
+The description is of the form
+  [<elements>:]<table>
+where the optional <elements> part lists the elements on which the binary 
+operation acts in the order in which they appear in the table part. 
+The elements are seperated by commas. The commas are optional if each 
+element is identified by a single letter. no withespaces are allowed in 
+an element identifier.
+
+The table part describes the transition table of the binary operation. 
+Rows are seperated by at least one whitespace character and elements in 
+a row are seperated by commas.  The commas are optional if each element 
+is identified by a single letter.
+If commas are used in one row to seperate the elements, one must use 
+commas in each row.
+
+*Remark*: If the elements part is omitted it is assumed that
+the elements are appearing in the right order and all elements
+are appearing. This is the case for a monoid with neutral element 
+in the first row.
+
+*Examples*
+  012 120 201
+  012:000 000 000
+  x1,x2,x3: x1,x2,x2 x2,x2,x1 x3,x2,x1
+  000 000 000   -> error
+  0,1,2 120 2,1,0 -> error
+=end
+    def self.new(description)
+      binop = new!(description)
+      validate(binop)
+
+      binop
+    end
+
+    #Like new, but without validation of the input.
+    def self.new!(description)
+      original_new *parse(description)
+    end
+
+    #:call-seq:
+    #  original_new(table,elements,mapping) -> BinaryOperation
+    #
+    #Creates a BinaryOperation. The arguments are a table an array with elements
+    #and a mapping.
+    #*Remark*: Use this method only if you know what you're doing. No 
+    #validation or argument checking is made. Its primary porpose is to speed up
+    #monoid generation in the RLSM::Monoid.each method.
+    def initialize(table, elements, mapping)
+      @table, @elements, @mapping = table, elements, mapping
+      @order = @mapping.size
+    end
+
+    #Internal representation of the table.
+    attr_reader :table
+
+    #Array with all different elements
+    attr_reader :elements
+    
+    #The number of elements.
+    attr_reader :order
+
+    #Maps element names to numbers.
+    attr_reader :mapping
+
+    #Calculate the product of +x+ and +y+.
+    #
+    #If at least one of the given elements is unknown raises an ArgumentError.
+    def [](x, y)
+      if @mapping[x].nil?
+        raise ArgumentError, "Unknown element #{x}"
+      elsif @mapping[y].nil?
+        raise ArgumentError, "Unknown element #{y}"
+      else
+        @elements[@table[@mapping[x]*@order + @mapping[y]]]
+      end
+    end
+
+    #Checks if binary operation is associative.
+    def associative?
+      !non_associative_triple
+    end
+
+    #Checks if binary operation is commutative.
+    def commutative?
+      is_commutative
+    end
+
+    #Checks if the binary operation is associative. If not raises an BinOpError.
+    def enforce_associativity
+      nat = non_associative_triple
+
+      unless nat.nil?
+        err_str = "(#{nat[0]}#{nat[0]})#{nat[0]} != #{nat[0]}(#{nat[1]}#{nat[2]})"
+        raise BinOpError, "Associativity required, but #{err_str}."
+      end
+    end
+    
+    private
+    def self.validate(binop)
+      if binop.table.size == 0
+        raise ArgumentError, "No elements given."
+      end
+
+      if binop.table.size != binop.mapping.size**2
+        raise ParseError, "Either to many elements or wrong table format."
+      end
+    end
+
+    def self.parse(description)
+      mapping = {}
+      elements = []
+      table = []
+      if description =~ /\s*:\s*/
+        elements = desc2ary(Regexp.last_match.pre_match)
+        elements.each_with_index { |el,i| mapping[el] = i }
+
+        desc2ary(Regexp.last_match.post_match).
+          each { |el| table << mapping[el] }
+      else
+        desc2ary(description).each do |element|
+          if mapping[element].nil?
+            mapping[element] = elements.size
+            elements << element
+          end
+
+          table << mapping[element]
+        end
+      end
+      
+      [table, elements, mapping]
+    end
+
+    def self.desc2ary(str)
+      if str.include?(',')
+        str.gsub(/^\s+/,'').gsub(/,*\s+,*/,',').split(',')
+      else
+        str.gsub(/\s+/,'').scan(/./)
+      end
+    end
+  end
+end

data/lib/rlsm/dfa.rb

@@ -1,717 +1,533 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rlsm'))
-
-=begin rdoc
-==Basic theory of deterministic finite automaton (short DFA)
-===Terminology
-We will call a finite nonempty set an _alphabet_ and we will call an element of an alphabet a _letter_.
-
-The free monoid generated by an alphabet +A+ will be denoted by +A*+ and is also called the _Kleene_-_closure_ of +A+. An element of +A*+ will be called a _word_ and will be written in the following text in a string notation: 'abcaac...'.
-
-===Definition of a DFA
-A DFA is a five tuple <tt>(A,S,i,F,T)</tt> where
-* +A+ is an alphabet,
-* +S+ is a nonempty set,
-* +i+ is an element of +S+,
-* +F+ is a subset of +S+ and
-* <tt>T:AxS -> S</tt> is a function.
-
-The elements of +S+ are called _states_, +i+ is the _initial_ _state_ and elements of +F+ are called _final_ _states_ (or _accepting_ _states_). The function +T+ is called the _transition_ _function_ of the DFA.
-
-
-In the following we will define some properties of a DFA and of states which will be of some interest:
-
-===The generalized transition function +T*+
-Given a DFA, a generalized version of the transition function <tt>T*: A*xS -> S</tt> can be recursivly defined by
- T*('',s) := s
- T*('a',s) := T(a,s)
- T*('abcd...',s) := T*('bcd...',T(a,s))
-
-It isn't really necessary to define +T*+, but it helps to define further properties in a concise way.
-
-===Isomorphic DFAs
-Like always we want to describe in what cases we consider two DFAs to be the same:
-
-Let <tt>M=(A,S,i,F,T), N=(A',S',i',F',T')</tt> be two DFAs. A bijective map <tt>I : S -> S'</tt> is called an _isomorphism_ iff
-1. <tt>A = A'</tt>
-2. <tt>I(i) = i'</tt>
-3. For all +f+ in +F+ it is +I(f)+ in +F'+
-4. For all states +s+ in +S+ and all letters +l+ in +A+ it is <tt>I(T(l,s)) = T'(l,I(s))</tt>
-
-We say +M+ is _isomorph_ _to_ +N+ if such an isomorphism exists. We see, two isomorphic DFAs differs only in the "names" of the states, so a distinction isn't very useful.
-
-===The language of a DFA
-Let +M+ be a DFA. The subset of +A*+ defined by
- L(M) := { w in A* | T*(w,i) is a final state }
-is a formal language, in fact it is a _regular_ _language_. It is called the _language_ _generated_ _by_ +M+.
-
-In almost all cases, if we study a DFA +M+ we are only interested in the language +L(M)+. Obviously two isomorphic DFAs generates the same language, but there are also non-isomorphic DFAs which generates the same language. This motivates the following definition: two DFAs +M+ and +N+ are _equivalent_ iff <tt>L(M) = L(N)</tt>.
-
-It is easy to see, that this relation is an equivalence relation and we can define the equivalence class of a DFA +M+:
- [M] := { N | N is a DFA which is equivalent to M }
-
-===The minimal DFA of a regular language
-Let +L+ be a regular language and +M+ a DFA with <tt>L(M) = L</tt>. We will define a order '<' on the set +[M]+ by
- N < M :<=> N has less states than M
-Because the number of states is an integer, there exists a DFA which has a minimal number of states. Such a DFA is called a _minimal_ DFA for +L+.
-
-It has been shown that two minimal DFAs for a language +L+ are isomorphic. So we can talk about _the_ minimal DFA for +L+.
-
-==An algorithm to find a minimal DFA
-Let <tt>M = (A,S,i,F,T)</tt> be a DFA. The goal of this paragraph is to find an equivalent minimal DFA for +L(M)+.
-
-Because we know, that some states have no influence on the generated language, we must find some criterias which states  aren't required.
-
-===Unreachable states
-We notice, that in the definition it isn't required, that for each state +s+ a word +w+ exists, such that <tt>T*(w,i) = s</tt>. We will call a state +s+ _reachable_ if such a word exists and _unreachable_ otherwise.
-
-It is easy to see, that an unreachable state has no impact on the generated language, so a first step towards a minimal DFA is to reject all unreachable states.
-
-A problem may be, that after removing the unreachable states, say the remaining states are +S'+, it is now possible that <tt>T|AxS'</tt> isn't defined everywhere. We will treat this in the next paragrapgh
-
-===Completeness of a DFA
-It is convenient to discard the requirement, that +T+ is defined on +AxS+. It is for most use-cases sufficent, that +T+ is a function on a subset +D(T)+ of +AxS+.
-
-In this case, we say a state +s+ _accepts_ the letter +c+ if <tt>(c,s)</tt> is an element of +D(T)+. We say a DFA is _complete_ iff +D(T)=AxS+, i.e. each state accepts all alphabet letters.
-
-====An algorithm to complete a DFA
-If we have a noncomplete DFA <tt>(A,S,I,F,T)</tt> we can complete it in the following way:
-1. Add a _trap_ _state_ +t+.
-2. Define <tt>T':Su{t} -> Su{t}</tt> by <tt>T'=T</tt> for points where +T+ is defined and <tt>T'(c,s) = t</tt> elsewhere.
-Now the DFA <tt>(A,Su{t},I,F,T')</tt> is complete.
-
-====Remark
-For a noncomplete DFA +M+ it is also possible to define a generalized transition function: If +N+ is the in the above way completed DFA of +M+ and +F+ its generalized transition function. We define
- D(T*) := { (w,s) | w in A*, F(w,s) != t }
-and
- T* := F|D(T*)
-Now +T*+ is a generalized transition function for a noncomplete DFA.
-
-Also the completion doesn't change the generated language.
-
-===Equivalent states
-We say two states <tt>s,t</tt> are _equivalent_ iff for all words +w+ <tt>T*(w,s)</tt> is a final state iff and only if <tt>T*(w,t)</tt> is a final state.
-
-This is an equivalence relation on the states +S+.
-
-===Dead states
-We say a state +s+ is _dead_ (or a _trap_ _state_) iff for all letters +l+ <tt>T(l,s) = s</tt> and +s+ isn't a final state.
-
-The same as for unreachable states is true for dead states. They have no influence on the generated language. Moreover each dead state is equivalent to another dead state, because both aren't final states and they don't change for a word.
-
-===The algorithm
-0. Eliminate all unreachable states (leaving a potential uncomplete DFA)
-1. Partitionate the set of remaining states by the equivalence relation of states. We get a set +S'+ of equivalence classes of states.
-2. Define +i'+ to be +[i]+ in +S'+.
-3. Define +F'+ to be the classes +[f]+ for each +f+ in +F+.
-4. Define <tt>T' : AxS' -> S'</tt> by <tt>T'(l,[s]) := [T(l,s)]</tt>
-
-The DFA (A,S',i',F',T') is then a minimal DFA (but not necessarily complete anymore). If one whishes a complete minimal DFA, complete the previous DFA.
-
-For the calculation of the partition there are several algorithms but we choose the table filling algorithm.
-=end
-
-class RLSM::DFA
-=begin rdoc
-This method takes as parameter a hash with following required keys:
-[:+initial+] The initial state.
-[:+finals+] An array of the final states.
-[:+transitions+] An array of the transitions.
-=end
-  def self.create(args = {})
-    args[:transitions].map! { |t| t.map { |x| x.to_s } }
-    args[:initial] = args[:initial].to_s
-    args[:finals].map! { |f| f.to_s }
-    args[:alphabet] = args[:transitions].map { |t| t.first }.uniq.sort
-    args[:states] = args[:transitions].map { |t| t[1,2] }.flatten.uniq.sort
-
-    new args
-  end
-=begin rdoc
-It is not intended to use this method directly, use create instead.
-
-This method takes as parameter a hash with following required keys:
-[:+alphabet+] An array of alphabet characters.
-[:+states+] An array of states.
-[:+initial+] The initial state.
-[:+finals+] An array of the final states.
-[:+transitions+] An array of the transitions.
-
-It is required that all occuring states are in the states array and all transition labels are in the alphabet. Also the states and the alphabet must be unique.
-=end
-  def initialize(args = {})
-    validate_presence_of_required_keys(args)
-
-    validate_uniqueness_of_alphabet_and_states(args)
-    validate_transition_labels_are_in_the_alphabet(args)
-    validate_all_states_matches(args)
-    validate_transition_uniquness(args)
+require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), 'regexp')
+require File.join(File.dirname(__FILE__), 'monoid')
+RLSM::require_extension('array')
+
+require "strscan"
+
+module RLSM
+  class DFA
+    #Synonym for new.
+    def self.[](description)
+      new(description)
+    end
+
+    #Creates a new DFA. The +description+ is a string which describes states and transitions.
+    #A state is described by a descriptor, which consists of latin letters and numbers (no whitespaces).
+    #
+    #To indicate a final state, the state descriptor starts with a *. This is allowed multiple times, even for the same state.
+    #
+    #The initial state starts with a right brace ('}'). This is only allowed once.
+    #
+    #A transition is described as follows
+    #   STATE -LETTERLIST-> STATE
+    # were +STATE+ is a state descriptor (* and } modifiers allowed) and +LETTERLIST+ is either a single letter of the alphabet or a comma seperated list of alphabet letters.
+    #
+    #*Remark*: This desription format may be the worst design desicion in the whole gem ...
+    #
+    #*Example*:
+    # RLSM::DFA["}s1-a,b->*s2"]
+    # RLSM::DFA["}s1 s2 *s3 s1-a->s2 s2-a,b->*s3 s3-b->s1"]
+    # RLSM::DFA["}s1 s2 *s3 }s1-a->s2 s2-a,b->*s3 s3-b->s1"] # => Error
+    def initialize(description)
+      parse_initial_state(description)
+      parse_states(description)
+      parse_final_states(description)
+      parse_transitions(description)
+    end
+    
+    #Initial state of the DFA.
+    attr_reader :initial_state
+    
+    #Array of accepting states.
+    attr_reader :final_states
+
+    #Array of all states
+    attr_reader :states
+
+    #The alphabet of the DFA.
+    attr_reader :alphabet
+
+    #Returns array of transitions (a transition is a triple consisting of start, destination and label).
+    def transitions
+      return [] if @transitions.nil?
+
+      result = []
+      @transitions.each do |state,labels|
+        labels.each do |label,dest|
+          result << [state,dest,label]
+        end
+      end
 
-    @alphabet = args[:alphabet].sort
-    @states = args[:states].clone
-    @initial_state = args[:initial].clone
-    @finals = args[:finals].clone
-    @transitions = args[:transitions].inject({}) do |res,tr|
-      (res[tr.first] ||= {})[tr[1]] = tr[2]
-      res
+      result
     end
-  end
 
-  attr_reader :alphabet, :states, :initial_state, :finals
-
-  #Returns an Array with 3-tuples as transitions.
-  def transitions
-    res = []
-    @alphabet.each do |letter|
-      res |= @transitions[letter].to_a.map { |x| [letter] + x }
-    end
-
-    res
-  end
-
-  #Returns the number of states.
-  def num_states
-    @states.size
-  end
-
-  #Returns the number of final states.
-  def num_finals
-    @finals.size
-  end
-
-  #Returns the state in which the DFA halts if started in state +s+ and given the word +w+. Returns +nil+ if some state doesn't accept the actual character on the way.
-  def [](w,s)
-    unless @states.include? s
-      raise DFAException, "Given state '#{s}' isn't a state in this DFA."
-    end
-
-    w.scan(/./).inject(s) do |s, c|
-      unless @alphabet.include? c
-        raise DFAException, "Given character '#{c}' isn't in the alphabet."
+    #Processes given +string+ starting in state +state+.
+    def [](state, string)
+      unless @states.include?(state)
+        raise DFAError, "Unknown state: #{state}"
       end
-      @transitions[c][s]
-    end
-  end
 
-  #Returns true if the DFA accepts +word+.
-  def accepts?(word)
-    @finals.include? self[word,@initial_state]
-  end
-
-
-  #Returns true if there exists an isomorphism between this DFA and +other+.
-  def isomorph_to?(other)
-    #Test first some required conditions
-    return false unless @alphabet == other.alphabet
-    return false unless @states.size == other.num_states
-    return false unless @finals.size == other.num_finals
+      present_state = state
+      string.scan(/./).each do |letter|
+        if @transitions[present_state].nil?
+          return nil
+        else
+          present_state = @transitions[present_state][letter]
+        end
+      end
 
-    #Find an isomorphism if possible
-    iso = @states.permutations.find do |p|
-      isomorphism?(p, other)
+      present_state
     end
 
-    iso ? true : false
-  end
-
-  #Returns true if the state is reachable, raises an Exception if the state isn't in the DFA.
-  def reachable?(state)
-    raise DFAException, "Unknown state: #{state}" unless @states.include? state
-    (@reachable_states ||= reachable_states).include? state
-  end
-
-  #Returns true if given state is dead, raises an Exception if the state isn't in the DFA.
-  def dead?(s)
-    raise DFAException, "Unknown state: #{s}" unless @states.include? s
-
-    s != @initial_state and
-      !@finals.include?(s) and
-      @alphabet.all? { |l| [nil,s].include? self[l,s] }
-  end
+    #Processes given +string+ starting in the initial state.
+    def <<(string)
+      self[@initial_state, string]
+    end
 
-  #Returns true if the dfa is minimal.
-  def minimal?
-    return false unless connected?
-    get_equivalent_states.empty?
-  end
+    #Checks if this DFA accepts the given +string+, i.e. halts in a final state after processing the string.
+    def accepts?(string)
+      @final_states.include?( self << string )
+    end
 
-  #Returns true if the DFA is complete.
-  def complete?
-    @states.all? { |s| @alphabet.all? { |l| self[l,s] } }
-  end
+    #Checks if given +state+ is dead, i.e. its not a final state and it hs no outgoing transitions.
+    def dead?(state)
+      raise DFAError, "Unknown state: #{state}" unless @states.include?(state)
+      
+      state != @initial_state and
+        ! @final_states.include?(state) and
+        @alphabet.all? { |let| [nil,state].include? @transitions[state][let] }
+    end
 
-  #Returns a complete DFA which generates the same language. If there exists already a dead state, this state will be used to complete the DFA.
-  def complete!
-    trap = @states.find { |s| dead?(s) }
+    #Checks if given +state+ is reachable, i.e. it exists a +string+, such that <tt>self << string == state</tt> is true.
+    def reachable?(state)
+      raise DFAError, "Unknown state: #{state}" unless @states.include?(state)
 
-    #No dead states present? -> create one
-    unless trap
-      trap = @states.sort.last.succ
-      @states << trap
+      reachable_states.include? state
     end
 
-    @states.each do |s|
-      @alphabet.each do |l|
-        (@transitions[l] ||= {})[s] = trap unless self[l,s]
+    #Checks if each state is reachable. See reachable?.
+    def connected?
+      @states.all? { |state| reachable?(state) }
+    end
+    
+    #Checks if DFA is complete, i.e. each state accepts every alphabet letter.
+    def complete?
+      @states.all? do |state|
+        @alphabet.all? do |letter| 
+          self[state,letter]
+        end
       end
     end
 
-    self
-  end
-
-  #Returns +true+ if the DFA has no unreachable states.
-  def connected?
-    @states.all? { |s| reachable?(s) }
-  end
-
-  #Returns a DFA with no unreachable states.
-  def connect!
-    remove_states *@states.find_all { |s| !reachable?(s) }
-    self
-  end
-
-  #Returns +true+ if the DFA has dead states.
-  def dead_states?
-    @states.any? { |s| dead?(s) }
-  end
-
-  #Removes all dead states.
-  def remove_dead_states!
-    remove_states *@states.find_all { |s| dead?(s) }
-    self
-  end
-
-=begin
-Minimizes the DFA. Takes as optional parameter a hash with only processed key :+rename+. The possible values are:
-[:+new+] States will be renamed to 's0', 's1', ...
-[:+min+] For each class of states the state with the smallest name is taken
-[:+join+] The names from each class are joined, so a class with states 'a' and 'b' will yielld a new state 'ab'. This is the default.
-=end
-  def minimize!(opts = {})
-    connect!
-    remove_dead_states!
-    unless minimal?
-      part = state_partition
-      merge_states *part
-
-      case opts[:rename]
-      when :new : rename_states()
-      when :min : rename_states part.map { |cls| cls.min }
-      else
-        rename_states part.map { |cls| cls.join }
+    #Calculates the transition monoid of the DFA.
+    def transition_monoid
+      maps = [@states.dup]
+      elements = ['id']
+
+      length = 1
+      found_all_elements = false
+
+      until found_all_elements
+        words(length) do |word|
+          found_all_elements = true
+          
+          map = get_map(word)
+          unless maps.include?(map)
+            maps << map
+            elements << word
+            found_all_elements = false
+          end
+        end
+
+        length += 1
       end
-    end
 
-    self
-  end
+      monoid_description = elements.join(',')
 
-  #Renames the state to the given array. Raises an exception if this array has the wrong size or the elements aren't unique.
-  def rename_states(arg = nil)
-    arg ||= (0...@states.size).map { |i| "s#{i}" }
+      elements[1..-1].each do |element|
+        monoid_description += " #{element},"
+        monoid_description += elements[1..-1].map do |element2|
+          elements[maps.index(get_map(element+element2))]
+        end.join(',')
+      end
 
-    if arg.size != @states.size
-      raise DFAException, "Wrong number of state names given."
+      RLSM::Monoid[ monoid_description ]
     end
 
-    if arg.uniq!
-      raise DFAException, "Given state names weren't unique."
+    #Checks for equality. A DFA is equal to +other+ iff it has the same alphabet, states, final states, initial state and transitions.
+    def ==(other)
+      begin
+        @alphabet == other.alphabet and
+          @initial_state == other.initial_state and
+          @states.sort == other.states.sort and
+          @final_states.sort == other.final_states.sort and
+          transitions.sort == other.transitions.sort
+      rescue
+        false
+      end
     end
 
-    rename_transitions arg
-
-    @initial_state = arg[@states.index(@initial_state)]
-    @finals.map! { |f| arg[@states.index(f)] }
-
-    @states = arg.clone
-  end
+    #Checks if the DFA is minimal.
+    def minimal?
+      equivalent_state_pairs.empty?
+    end
 
-  #Returns a connected copy of the DFA.
-  def connect
-    Marshal.load(Marshal.dump(self)).connect!
-  end
+    #Alters the DFA in place to an equivalent minmal one.
+    def minimize!
+      remove_unneeded_states!
 
-  #Returns a complete copy of the DFA.
-  def complete
-    Marshal.load(Marshal.dump(self)).complete!
-  end
+      unless minimal?
+        state_classes = get_equivalent_state_classes
+      
+        states = state_classes.map { |cls| cls.min }
 
-  #Returns a minimized copy of the DFA.
-  def minimize(opts = {})
-    Marshal.load(Marshal.dump(self)).minimize!(opts)
-  end
+        rename = {}
 
-  #Returns +true+ if this DFA is equivalent to +other+
-  def equivalent_to?(other)
-    minimize.isomorph_to?(other.minimize)
-  end
+        @states.each do |state|
+          rename[state] = state_classes.find { |cls| cls.include?(state) }.min
+        end
 
-  #Returns the transition monoid of the DFA.
-  def transition_monoid
-    RLSM::Monoid.new get_binary_operation, :rename => true
-  end
+        transitions = {}
 
-  #Returns the transition monoid of the equivalent minimal DFA.
-  def syntactic_monoid
-    minimize.transition_monoid
-  end
+        @transitions.each_pair do |state, transition|
+          start = (transitions[rename[state]] ||= {})
 
-  #Synonym for syntactic_monoid
-  def to_monoid
-    syntactic_monoid
-  end
+          transition.each_pair do |letter, destination|
+            start[letter] = rename[destination]
+          end
+        end
 
-  #Returns self.
-  def to_dfa
-    self
-  end
+        @initial_state = rename[@initial_state]
+        @states = states
+        @final_states.map! { |state| rename[state] }
+        @final_states.uniq!
+        @transitions = transitions
+       end
 
-  #Returns a RE which represents the same language.
-  def to_re
-    les = []
-    les << initialize_row_for(initial_state)
-    (@states - [initial_state]).each do |state|
-      les << initialize_row_for(state)
+      self
     end
 
-    #Solve for the initial state
-    les = update_les(les, simplify_les_row(les.pop)) until les.size == 1
-
-    simplify_les_row(les.pop)[:final]
-  end
-
-  def inspect
-    "<#{self.class}: #{@states.join(',')}>"
-  end
-
-  def to_s
-    output = []
-    output << @states.inject(['']) do |res, state|
-      prefix = ''
-      prefix += '*' if @finals.include? state
-      prefix += '->' if initial_state == state
-
-      res + [prefix + ' ' + state + ' ']
+    #Returns an equivalent minmal DFA.
+    def minimize
+      Marshal.load(Marshal.dump(self)).minimize!
     end
 
-    @alphabet.each do |letter|
-      column = [' ' + letter + ' ']
-      @states.each do |state|
-        tmp = self[letter,state]
-        if tmp.nil?
-          column << ' nil '
-        else
-          column << ' ' + tmp + ' '
+    #Checks if +self+ is isomorph to other.
+    def =~(other)
+      return false if other.class != self.class || 
+        @alphabet != other.alphabet ||
+        @states.size != other.states.size || 
+        @final_states.size != other.final_states.size ||
+        transitions.size != other.transitions.size
+
+      bijective_maps_to(other).any? do |bijection|
+        transitions.all? do |s1,s2,letter|
+          other.transitions.include?([bijection[s1],bijection[s2],letter])
         end
       end
-
-      output << column.clone
     end
 
-    #Align output
-    output.map! do |col|
-      max_length = col.map { |x| x.length }.max
-      col.map { |x| ' '*(max_length - x.length) + x }
+    #Checks if +self+ is equivalent to +other+, i.e. they accepts the same language.
+    def equivalent_to(other)
+      return false if other.class != self.class
+
+      minimize =~ other.minimize
     end
 
-    rows = (0..@states.size).map { |i| output.map { |col| col[i] } }
-    rows.map! { |row| row.join('|') }
-    head = rows.shift
-    rows.unshift head.scan(/./).map { |c| c == '|' ? '+' : '-' }.join
-    rows.unshift head
+    #Calculates a regular expression which represents the same languge as the DFA.
+    def to_regexp
+      les = []
+      les << initialize_row_for(@initial_state)
+      (@states - [@initial_state]).each do |state|
+        les << initialize_row_for(state)
+      end
 
-    rows.join("\n")
-  end
+      #Solve for the initial state
+      les = update_les(les, simplify_les_row(les.pop)) until les.size == 1
 
-  private
-  def initialize_row_for(state)
-    row = { :state => state.clone }
-    @states.each do |s|
-      row[s] = RLSM::RE.new
+      simplify_les_row(les.pop)[:final]
     end
 
-    @alphabet.each do |letter|
-      row[self[letter, state]] += RLSM::RE.new(letter) if self[letter, state]
+    #Simply returns self.
+    def to_dfa
+      self
     end
 
-    if @finals.include? state
-      row[:final] = RLSM::RE.new(RLSM::RE::Lambda)
-    else
-      row[:final] = RLSM::RE.new
+    #Returns the transition monoid of the equivalent minimal DFA (which is in fact isomorph to the syntactic monoid of the represented language.
+    def to_monoid
+      minimize.transition_monoid
     end
 
-    row
-  end
+    private
+    def initialize_row_for(state)
+      row = { :state => state.clone, :final => RLSM::RegExp.new('') }
+      @states.each do |s|
+        row[s] = RLSM::RegExp.new ''
+      end
 
-  def update_les(l,r)
-    l.map do |row|
-      re = row[r[:state]]
-      @states.each do |state|
-        if state == r[:state]
-          row[state] = RLSM::RE.new
-        else
-          row[state] += re * r[state]
-        end
+      @alphabet.each do |letter|
+        row[self[state,letter]] |= RLSM::RegExp.new(letter) if self[state,letter]
+      end
+
+      if @final_states.include? state
+        row[:final] = RLSM::RegExp.empty_word
       end
 
-      row[:final] += re * r[:final]
       row
     end
-  end
 
-  def simplify_les_row(row)
-    #Have we something like Ri = ... + xRi + ...
-    if row[row[:state]].pattern != ''
-      re = row[row[:state]].star
-      @states.each do |state|
-        if state == row[:state]
-          row[state] = RLSM::RE.new
-        else
-          row[state] = re * row[state]
+    def update_les(les,act_row)
+      les.map do |row|
+        re = row[act_row[:state]]
+        @states.each do |state|
+          if state == act_row[:state]
+            row[state] = RLSM::RegExp.new ''
+          else
+            row[state] |= re + act_row[state]
+          end
         end
+
+        row[:final] |= re + act_row[:final]
+        row
       end
+    end
 
-      row[:final] = re * row[:final]
-    end
-
-    row
-  end
-
-  def rename_transitions(arg)
-    @transitions = @transitions.to_a.inject({}) do |res,pair|
-      res[pair.first] = pair.last.map do |key,val|
-        [arg[@states.index(key)], arg[@states.index(val)]]
-      end.inject({}) { |r,v| r[v.first] = v.last; r }
-      res
-    end
-  end
-
-  def get_binary_operation
-    maps = []
-    elements = []
-    l = 0
-    loop do
-      new = false
-      each_word_of_length(l) do |w|
-        map = get_map(w)
-        unless maps.include? map
-          maps << map
-          elements << w
-          new = true
+    def simplify_les_row(row)
+      #Have we something like Ri = ... + xRi + ...
+      if row[row[:state]].parse_tree != RLSM::RE::EmptySet[]
+        re = row[row[:state]].star
+        @states.each do |state|
+          if state == row[:state]
+            row[state] = RLSM::RegExp.new ''
+          else
+            row[state] = re + row[state]
+          end
         end
+        
+        row[:final] = re + row[:final]
       end
-      break unless new
-      l += 1
-    end
 
-    binop = []
-    (0...elements.size).to_a.product((0...elements.size).to_a).each do |i,j|
-      (binop[i] ||= [])[j] = maps.index(get_map(elements[i] + elements[j]))
+      row
     end
 
-    binop
-  end
-
-  def each_word_of_length(l)
-    word = (@alphabet.first.to_s*l).scan(/./)
-    yield word.join
-
-    until word == (@alphabet.last.to_s*l).scan(/./)
-      word = get_next_word(word)
-      yield word.join
-    end
-  end
+    def bijective_maps_to(other)
+      bijective_maps = other.states.permutations.map do |perm| 
+        Hash[*@states.zip(perm).flatten]
+      end
 
-  def get_next_word(word)
-    i = (1..word.length).find { |i| word[-i] != @alphabet.last }
-    word[-i] = @alphabet[@alphabet.index(word[-i])+1]
-    if i > 1
-      (1...i).each do |j|
-        word[-j] = @alphabet.first
+      bijective_maps.select do |map|
+        other.initial_state == map[@initial_state] &&
+          @final_states.all? { |fi| other.final_states.include?(map[fi]) }
       end
     end
 
-    word
-  end
+    def remove_unneeded_states!
+      unneeded_states, states = @states.partition do |state| 
+        dead?(state) or not reachable?(state)
+      end
 
-  def get_map(word)
-    @states.map { |s| self[word,s] }
-  end
+      transitions = self.transitions.reject do |transition|
+        unneeded_states.any? { |dead| transition.include?(dead) }
+      end
 
-  def remove_states(*states)
-    @reachable_states = nil
-    #Remove the state
-    states.each do |s|
-      @states.delete(s)
-      @finals.delete(s)
+      @states = states
+      @reachable_states = @states
+      @final_states &= states
+      @transitions = {}
+      transitions.each do |start,destination,letter|
+        (@transitions[start] ||= {})[letter] = destination
+      end
     end
+    
+    def equivalent_state_pairs
+      @states << nil unless complete?
 
-    #Remove the transitions
-    @alphabet.each do |l|
-      tr = @transitions[l].map.reject { |p| states.any? { |s| p.include? s } }
-      @transitions[l] = tr.inject({}) { |r,x| r[x.first] = x.last; r }
-    end
-  end
+      different, indifferent = [], []
 
-  def get_renaming_scheme(classes)
-    classes.inject({}) do |res,cls|
-      state = select_state_in cls
-      cls.each do |x|
-        res[x] = state
+      states[0..-2].each_with_index do |state1, i|
+        states[(i+1)..-1].each do |state2|
+          if @final_states.include?(state1) ^ @final_states.include?(state2)
+            different << [state1, state2]
+          else
+            indifferent << [state1, state2]
+          end
+        end
       end
-      res
-    end
-  end
 
-  def merge_states(*classes)
-    @reachable_states = nil
-    rename = get_renaming_scheme(classes)
+      begin
+        new_different = indifferent.select do |state1, state2|
+          
+          @alphabet.any? do |letter| 
+            test_pair = [self[state1,letter], self[state2,letter]]
+            different.include?(test_pair) or 
+              different.include?(test_pair.reverse)
+          end
+        end
 
-    @states.map! { |s| rename[s] }.uniq!
-    @finals.map! { |s| rename[s] }.uniq!
+        different |= new_different
+        indifferent -= new_different
+      end until new_different.empty?
 
-    @alphabet.each do |l|
-      tr = @transitions[l].map { |x,y| [rename[x],rename[y]] }.uniq
-      @transitions[l] = tr.inject({}) { |r,x| r[x.first] = x.last; r }
+      @states.compact!
+          
+      indifferent.reject { |pair| pair.include?(nil) }
     end
-  end
 
-  def select_state_in(cls)
-    if cls.include? @initial_state
-      @initial_state
-    else
-      cls.min
-    end
-  end
+    def get_equivalent_state_classes
+      pairs = equivalent_state_pairs
+
+      classes = []
 
-  def state_partition
-    eq = get_equivalent_states
-    @states.inject([]) do |res,s|
-      res << [s]
-      eq.find_all { |p| p.include? s }.each do |pair|
-        res[-1] |= pair
+      @states.each do |state|
+        next if classes.any? { |cls| cls.include? state }
+        cls = [state]
+        cls |= pairs.find_all { |pair| pair.include?(state) }
+        classes << cls.flatten.compact.uniq
       end
 
-      res.last.sort!
-      res.uniq
+      classes
     end
-  end
 
-  def set_up_table_fill_algorithm
-    (@states | (complete? ? [] : [nil])).unordered_pairs.partition do |x,y|
-      @finals.include?(x) ^ @finals.include?(y)
+    def parse_initial_state(description)
+      unless description.count('}') == 1
+        raise DFAError, "None or at least two initial states."
+      end
+
+      @initial_state = description[/\}\s*\*?(\w+)/,1]
     end
-  end
 
-  def table_fill_step(dis, equi)
-    equi.select do |x,y|
-      @alphabet.any? do |l|
-        dis.include? [@transitions[l][x], @transitions[l][y]] or
-        dis.include? [@transitions[l][y], @transitions[l][x]]
+    def parse_final_states(description)
+      @final_states = []
+
+      desc = StringScanner.new(description)
+      loop do
+        break unless desc.scan(/[^*]*\*\}?/) 
+        final_state = desc.scan(/\w+/)
+        @final_states << final_state unless @final_states.include?(final_state)
       end
     end
-  end
 
-  def get_equivalent_states
-    distinguished, equivalent = set_up_table_fill_algorithm
+    def parse_states(description)
+      desc = description.gsub(/[*}]/,'')
+      desc.gsub!(/\s+/,' ')
+      desc.gsub!(/\s*-+(\w+,?)+-+>\s*/, ' ')
 
-    loop do
-      new_dis = table_fill_step distinguished, equivalent
-      break if new_dis.empty?
-      distinguished |= new_dis
-      equivalent -= new_dis
+      @states = desc.split.uniq      
     end
-    equivalent.reject { |p| p.include? nil }
-  end
 
-  def reachable_states
-    reachable = []
-    new_states = [@initial_state]
+    def parse_transitions(description)
+      @alphabet = []
+      @transitions = {}
+      
+      return unless description =~ /[->]/
+      
+      parser = transition_parser(description)
+
+      loop do
+        transaction = parser.scan(/(\w+)-((\w+,?)+)->(\w+)/)
+        if transaction
+          start = parser[1]
+          labels = parser[2].split(',').uniq
+          destination = parser[4]
 
-    until new_states.empty?
-      reachable |= new_states
-      new_states = []
-      reachable.each do |s|
-        @alphabet.map do |l|
-          new_states << self[l,s] unless reachable.include? self[l,s]
+          insert_transition(start,destination,labels)
+          insert_alphabet_letters(labels)
+        elsif parser.scan(/\w+/)
+          #do nothing (states already parsed)
+        else
+          raise DFAError, "Parse Error, could not parse #{description}"
         end
+          
+        break unless parser.scan(/ /)
       end
-      new_states.compact!
-    end
 
-    reachable
-  end
-
-  def get_bijective_map_to(p, other)
-    @states.inject({}) do |res,s|
-      res[s] = other.states[p.index(s)]
-      res
+      unless parser.eos?
+        raise DFAError, "Parse Error, could not parse #{description}"
+      end
+      
+      @alphabet = @alphabet.sort
+    end
+
+    def transition_parser(description)
+      #simplifying the description for easier parsing
+      desc = description.gsub(/[*}]/, '')[/^\s*(.+?)\s*$/,1]
+      desc.gsub!(/\s+/, ' ')
+      desc.gsub!(/\s*-+\s*/,'-')
+      desc.gsub!(/>\s*/,'>')
+      desc.gsub!(/\s*,\s*/,',')
+      
+      StringScanner.new(desc)
+    end
+
+    def insert_transition(start,destination,labels)
+      labels.each do |label|
+        trans = (@transitions[start] ||= {})
+        if trans[label].nil?
+          trans[label] = destination
+        elsif trans[label] != destination
+          raise DFAError, "Parse Error: Transition labels must be uniq."
+        end
+      end
     end
-  end
 
-  def isomorphism?(per, o)
-    p = get_bijective_map_to(per, o)
-    return false unless o.initial_state == p[@initial_state]
-
-    unless @finals.map { |s| p[s] }.all? { |f| o.finals.include? f }
-      return false
+    def insert_alphabet_letters(labels)
+      @alphabet |= labels
     end
 
-    @alphabet.product(@states).all? do |c,s|
-      p[self[c,s]] == o[c,p[s]]
+    def reachable_states
+      @reachable_states ||= calc_reachable_states
     end
-  end
 
-  def validate_presence_of_required_keys(args)
-    [:alphabet,:states,:initial,:finals,:transitions].each do |key|
-      raise DFAException, "No #{key} given!" unless args.key?(key)
+    def calc_reachable_states
+      reachable = []
+      new_states = [@initial_state]
+      
+      until new_states.empty?
+        reachable |= new_states
+        new_states = []
+        reachable.each do |state|
+          @alphabet.each do |letter|
+            new_state = self[state,letter]
+            
+            unless new_state.nil? or reachable.include?(new_state)
+              new_states << new_state
+            end
+          end
+        end
+        new_states.compact!
+      end
+      
+      reachable
     end
-  end
 
-  def validate_all_states_matches(args)
-    unless args[:states].include? args[:initial]
-      raise DFAException, "Given initial state isn't in :states."
-    end
 
-    bad = args[:finals].find_all { |x| !args[:states].include?(x) }
-    unless bad.empty?
-      raise(DFAException,
-            "Given final states #{bad.inspect} aren't in :states.")
+    def get_map(word)
+      @states.map { |state| self[state,word] }
     end
 
-    bad = args[:transitions].find_all do |l,x,y|
-      !(args[:states].include?(x) and args[:states].include?(y))
-    end
-    unless bad.empty?
-      raise(DFAException,
-            ("Given transitions #{bad.inspect}" +
-            "have states which aren't in :states."))
-    end
-  end
+    def words(length)
+      word = [@alphabet.first]*length
+      last = [@alphabet.last]*length
 
-  def validate_uniqueness_of_alphabet_and_states(args)
-    [:alphabet, :states].each do |key|
-      if args[key].uniq!
-        raise(DFAException,
-              "#{key} has duplicated entries: #{args[key].inspect}")
+      until word == last
+        yield word.join
+        word = get_next(word)
       end
+      
+      yield last.join
     end
-  end
 
-  def validate_transition_labels_are_in_the_alphabet(args)
-    bad = args[:transitions].find_all { |l,x,y| !args[:alphabet].include?(l) }
-    unless bad.empty?
-      raise(DFAException,
-            ("Following transitions contain non alphabet characters:" +
-            "#{bad.inspect}."))
-    end
-  end
-
-  def validate_transition_uniquness(args)
-    args[:alphabet].product(args[:states]).each do |c,s|
-      tr = args[:transitions].find_all { |l,s1,s2| l == c and s1 == s }
-      if tr.size > 1
-        raise DFAException, ("There are multiple transitons from state " +
-                             "#{tr.first[1]} with label #{tr.first[0]}.")
+    def get_next(word)
+      i = (1..word.length).find { |i| word[-i] != @alphabet.last }
+      word[-i] = @alphabet[@alphabet.index(word[-i])+1]
+      if i > 1
+        (1...i).each do |j|
+          word[-j] = @alphabet.first
+        end
       end
+      
+      word
     end
-  end
-end
+  end # of class DFA
+end # of module RLSM