rlsm 1.1.0 → 1.8.1

data/lib/rlsm/helper.rb

@@ -1,11 +1,17 @@
-class RLSMError < StandardError; end # :nodoc:
-class ParseError < RLSMError; end # :nodoc:
-class BinOpError < RLSMError; end # :nodoc:
-class MonoidError < RLSMError; end # :nodoc:
-class DFAError < RLSMError; end # :nodoc:
-class RegExpError < RLSMError; end # :nodoc:
 
 module RLSM
+  # The exception class which is raised by the code under the RLSM module.
+  # So somthing like
+  #    begin
+  #      ...
+  #    rescue RLSM::Error => e
+  #      ... #Error from RLSM code
+  #    rescue
+  #      ... #Some external error
+  #    end
+  # works.
+  class Error < StandardError; end
+  
   def self.require_extension(extension)
     require File.join(File.dirname(__FILE__), '..', '..', 'ext', extension, extension + '_cext')
   end

data/lib/rlsm/monoid.rb

@@ -1,90 +1,237 @@
 require File.join(File.dirname(__FILE__), 'helper')
-require File.join(File.dirname(__FILE__), 'binary_operation')
 require File.join(File.dirname(__FILE__), 'dfa')
+
 RLSM::require_extension 'array'
 RLSM::require_extension 'monoid'
 
 module RLSM
+
+  # Implements the mathematical idea of a finite monoid.
   class Monoid
-    private_class_method :new
 
-    def self.each(order)
-      raise ArgumentError, "Given order must be > 0" if order <= 0
+    class << self
+      # Iterates over each monoid of the given order.
+      #
+      # @param [Integer] order Specifies over which monoids the method iterates.
+      #
+      # @raise [RLSM::Error] The given parameter must be greater than zero.
+      #
+      # @yield [monoid] A monoid of the given order.
+      def each(order)
+        each_table(order) { |table| yield new(table,false) }
+      end
 
-      if order == 1  #trivial case
-        yield new(RLSM::BinaryOperation.original_new([0], ['0'], { '0' => 0}))
-        return
+      # Iterates over each transition table of a monoid of the given order.
+      #
+      # @param [Integer] order Specifies over which monoids the method iterates.
+      #
+      # @raise [RLSM::Error] The given parameter must be greater than zero.
+      #
+      # @yield [table] An array describing the transition table of a monoid.
+      def each_table(order)
+        raise RLSM::Error, "Given order must be > 0" if order <= 0
+
+        if order == 1  #trivial case
+          yield [0]
+          return
+        end
+        
+        #calculate the permutations once
+        permutations = 
+          RLSM::ArrayExt::permutations((1...order).to_a).map { |p| p.unshift 0 }
+
+        each_diagonal(order,permutations) do |diagonal|
+          each_with_diagonal(diagonal,permutations) do |table|
+            yield table
+          end
+        end
       end
 
-      elements = (0...order).to_a.map { |x| x.to_s }
-      mapping = {}
-      elements.each_with_index { |x,i| mapping[x] = i }
+      # Creates a new monoid.
+      # @see RLSM::Monoid#initialize
+      def [](table)
+        new(table)
+      end
 
-      #calculate the permutations once
-      permutations = (1...order).to_a.permutations.map { |p| p.unshift 0 }
+      # Creates the syntactic monoid to the given regular language.
+      #
+      # @param [String] regexp a regular expression.
+      #
+      # @raise [RLSM::Error] if given string isn't a valid regexp.
+      #
+      # @return [Monoid] the syntactic monoid of the given regular language.
+      def from_regexp(regexp)
+        RLSM::RegExp[regexp].to_monoid
+      end
 
-      each_diagonal(order,permutations) do |diagonal|
-        each_with_diagonal(diagonal,permutations) do |table|
-          yield new(RLSM::BinaryOperation.original_new(table, elements, mapping))
-        end
+      # Creates the syntactic monoid to the given regular language.
+      #
+      # @param [String] dfa a deterministic finite automaton
+      #
+      # @raise [RLSM::Error] if given string isn't a valid DFA description.
+      #
+      # @return [Monoid] the syntactic monoid of the given regular language.
+      def from_dfa(dfa)
+        RLSM::DFA[dfa].to_monoid
       end
+
     end
 
+    #The elements of the monoid.
+    attr_reader :elements
     
-    attr_accessor :elements, :order, :binary_operation
+    #The order of the monoid.
+    attr_reader :order
 
-    #Like new, but without validation.
-    def self.new!(description)
-      new RLSM::BinaryOperation.new!(description)
-    end
+    #The transition table of the monoid.
+    attr_reader :table
 
-    #Creates a Monoid with the binary operation described in +description+. 
-    #Validates that the BinaryOperation is assoviative and the neutral element 
-    #is in the first row.
+    # Creates a new Monoid from the given table.
+    # The table is interpreted as follows:
+    #
+    # * Case 1: Table is an Array.
+    #
+    #   It is assumed, that the array is flat and that every entry
+    #   is an entry in the transition table. The neutral element must
+    #   be described in the first row and column.
+    #
+    # * Case 2: Table is a String.
+    #
+    #   The string will be parsed into a flat Array.
+    #   If commas are present, the String will be splitted at these,
+    #   otherwise it will be splitted at each character.
+    #   Whitespaces will be ignored or threted as commas.
+    #   After parsing, the resulting array will be treated as in case 1.
+    #
+    # @example Some different ways to create a Monoid
+    #   RLSM::Monoid.new [0,1,1,1]
+    #   RLSM::Monoid.new "0110"
+    #   RLSM::Monoid.new "01 10"
+    #   RLSM::Monoid.new "0,1,1,0"
+    #   RLSM::Monoid.new "0,1 1,0"
     #
-    #See also BinaryOperation::new.
-    def self.[](description)
-      binop = RLSM::BinaryOperation.new(description)
-      binop.enforce_associativity
-      enforce_identity_position(binop.table, binop.order)
+    # @param [Array,String] table The transition table of the monoid, either as
+    #                             a flat Array or a string.
+    #
+    # @param [Boolean] validate If true, the given table will be validated.
+    #
+    # @raise [RLSM::Error] If validate is true and the given table isn't
+    #                    associative or has no neutral element or the neutral
+    #                    element isn't in the first row and column.
+    def initialize(table, validate = true)
+      @table = parse(table)
+      @order = Math::sqrt(@table.size).to_i
+      @elements = @table[0,@order].clone
+      @internal = {}
+      @elements.each_with_index { |x,i| @internal[x] = i }
+      @table.map! { |x| @internal[x] }
+
+      if validate
+        if @order == 0
+          raise RLSM::Error, "No elements given."
+        end
+        
+        unless @table.size == @order**2
+          raise RLSM::Error, "Binary operation must be quadratic."
+        end
 
-      new(binop)
+        unless @table.uniq.size == @order
+          raise RLSM::Error, "Number of different elements is wrong."
+        end
+
+        enforce_identity_position(@table, @order)
+
+        nat = non_associative_triple
+        unless nat.nil?
+          err_str = "(#{nat[0]}#{nat[0]})#{nat[0]} != #{nat[0]}(#{nat[1]}#{nat[2]})"
+          raise RLSM::Error, "Associativity required, but #{err_str}."
+        end
+      end
     end
 
 
-    #:notnew:
-    #*Remark*: No validation is performed. Use it only when you're really know what to do.
-    #Use Monoid::[] instead (or Monoid::new!).
-    def initialize(binop)
-      @binary_operation = binop
-      @elements = @binary_operation.elements
-      @order = @elements.size
+    # Parses a transition table description.
+    #
+    # @param [Array,String] table the transition table description.
+    # @return [Array] The parsed description.
+    def parse(table)
+      return table if Array === table
 
-      instance_eval(&block) if block_given?
+      if table.include?(',')
+        table.gsub(/\W/,',').squeeze(',').split(',').reject { |x| x.empty? }
+      else
+        table.gsub(/\W/,'').scan(/./)
+      end
     end
-
+    
     #Calculates the product of the given elements.
+    # @return The result of the operation
+    # @raise [RLSM::Error] If at least one of the given elements isn't a element
+    #                    of the monoid or too few elements are given.
     def [](*args)
       case args.size
       when 0,1
-        raise ArgumentError, "At least two elements must be provided."
+        raise RLSM::Error, "At least two elements must be provided."
       when 2
-        @binary_operation[*args]
+        begin
+          @elements[ @table[ @order*@internal[args[0]] + @internal[args[1]] ] ]
+        rescue
+          raise RLSM::Error, "Given arguments aren't monoid elements."
+        end
       else
-        args[0,2] = @binary_operation[args[0],args[1]]
+        args[0,2] = self[ *args[0,2] ]
         self[*args]
       end
     end
 
-    #Two monoids are equal if they have the same binary operation on the same set.
+    
+    # Transforms monoid into a string.
+    #
+    # @return [String] The string representation of the monoid.
+    def to_s
+      result = ""
+      sep = @elements.any? { |x| x.to_s.length > 1 } ? ',' : ''
+      @table.each_with_index do |el,i|
+        result += @elements[el].to_s
+        if (i+1) % (@order) == 0
+          result += ' '
+        else
+          result += sep unless i == @order**2 - 1
+        end
+      end
+
+      result
+    end
+
+    
+    # Transforms monoid into a string for debug purposes.
+    #
+    # @return [String] The string representation of the monoid.
+    def inspect
+      "<#{self.class}: #{to_s}>"
+    end
+
+    # Tests for monoid equality. Two monoids are equal if the have the same
+    # set of elements and the same transition table.
+    #
+    # @param [Monoid] other The righthand side of the equality test.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the equality check.
     def ==(other)
       return nil unless RLSM::Monoid === other
 
-      @binary_operation.table == other.binary_operation.table and
-        @binary_operation.elements == other.binary_operation.elements
+      @table == other.table and
+        @elements == other.elements
     end
 
-    #Checks if +self+ is a proper submonoid of +other+.
+    # Checks if this monoid is a proper submonoid (i.e. not equal)
+    # of the other one.
+    #
+    # @param [Monoid] other Righthand side of the inequality test.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the inequality test.
     def <(other)
       return nil unless RLSM::Monoid === other
       return false if @order >= other.order
@@ -93,7 +240,7 @@ module RLSM
         @elements.each do |e2|
           begin
             return false if self[e1,e2] != other[e1,e2]
-          rescue BinOpError
+          rescue RLSM::Error
             return false
           end
         end
@@ -102,29 +249,82 @@ module RLSM
       true
     end
 
-    #Checks if +self+ is a submonoid of (or equal to) +other+.
+    # Checks if this monoid is a submonoid of the other one.
+    #
+    # @param [Monoid] other Righthand side of the inequality test.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the inequality test.
     def <=(other)
       (self == other) || (self < other)
     end
 
-    def >(other) #:nodoc:
+    # Checks if the other monoid is a proper submonoid (i.e. not equal)
+    # of this one.
+    #
+    # @param [Monoid] other Righthand side of the inequality test.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the inequality test.
+    def >(other)
       other < self
     end
 
-    def >=(other) #:nodoc:
+    # Checks if the other monoid is a submonoid of this one.
+    #
+    # @param [Monoid] other Righthand side of the inequality test.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the inequality test.
+    def >=(other)
       other <= self
+      endy
     end
 
-    #Returns the submonoid generated by +set+.
+    # @see RLSM::Monoid#isomorph?
+    def =~(other)
+      isomorph?(other)
+    end
+
+    # Checks if this monoid is isomorph to the other one.
     #
-    #*Remark*: The returned value is only an Array, no Monoid. Use get_submonoid for this.
-    def generated_set(set)
-      if set.include? @elements.first
-        gen_set = set.map { |element| element.to_s }
-      else
-        gen_set = set.map { |element| element.to_s } | @elements[0,1]
-      end
+    # @param [Monoid] other Righthand side of the isomorphism check.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the isomorphism check.
+    def isomorph?(other)
+      return nil unless RLSM::Monoid === other
+      isomorphisms(other) { return true }
+
+      false
+    end
+
+    # Checks if this monoid is antiisomorph to the other one.
+    #
+    # @param [Monoid] other Righthand side of the isomorphism check.
+    #
+    # @return [nil] if other isn't a monoid.
+    # @return [Boolean] the result of the antiisomorphism check.
+    def antiisomorph?(other)
+      return nil unless RLSM::Monoid === other
+
+      antiisomorphisms(other) { return true }
+
+      false
+    end
 
+    # Calculates the set of elements which will be generated by the given set.
+    #
+    # @param [Array] set The elements which act as generators
+    #
+    # @return [Array] the generated set.
+    #
+    # @raise [RLSM::Error] if one of the elements isn't a monoid element.
+    #
+    # @see RLSM::Monoid#get_submonoid.
+    def generated_set(set)
+      gen_set = set | @elements[0,1]
+      
       unfinished = true
       
       while unfinished
@@ -144,20 +344,33 @@ module RLSM
       gen_set.sort(&element_sorter)
     end
 
-    #Returns the submonoid generated by set.
+    # Calculates the set of elements which will be generated by the given set.
+    #
+    # @param [Array] set The elements which act as generators
+    #
+    # @return [Monoid] the monoid generated by the given set.
+    #
+    # @raise [RLSM::Error] if one of the elements isn't a monoid element.
+    #
+    # @see RLSM::Monoid#get_generated_set.
     def get_submonoid(set)
       elements = generated_set(set)
 
       set_to_monoid(elements)
     end
 
-    #Returns an array of all submonoids (including the trivial monoid and the monoid itself).
+    # Calculates all submonoids.
+    #
+    # @return [Array] List with all submonoids in it.
     def submonoids
       candidates = get_submonoid_candidates
       candidates.map { |set| set_to_monoid(set) }
     end
 
-    #Returns an array of all proper submonoids. 
+    # Calculates all proper submonoids (i.e. all submonoids without the
+    # monoid itself and the trivial one).
+    #
+    # @return [Array] List with all proper submonoids in it.
     def proper_submonoids
       candidates = get_submonoid_candidates.select do |cand| 
         cand.size > 1 and cand.size < @order 
@@ -166,27 +379,21 @@ module RLSM
       candidates.map { |set| set_to_monoid(set) }
     end
 
-    #Returns the smallest set (first in terms of cardinality, then lexicographically) which generates the monoid.
+    # Finds the smallest set which generates the whole monoid
+    # (smallest in the sense of cardinality of the set).
+    #
+    # @return [Array] A set of elements which generates the whole monoid.
     def generating_subset
       sorted_subsets.find { |set| generated_set(set).size == @order }
     end
 
-    #Checks if +self+ is isomorph to +other+ 
-    def =~(other)
-      bijective_maps_to(other).any? { |map| isomorphism?(map,other) }
-    end
-
-    #Synonym for =~
-    def isomorph?(other)
-      self =~ other
-    end
-
-    #Checks if +self+ is antiisomorph to +other+.
-    def antiisomorph?(other)
-      bijective_maps_to(other).any? { |map| antiisomorphism?(map,other) }
-    end
-
-    #If an argument is given, checks if this element is idempotent. Otherwise checks if the monoid itself is idempotent.
+    # @overload idempotent?
+    # Checks if the monoid is idempotent (i.e. all elements are idempotent).
+    #
+    # @overload idempotent?(element)
+    # Checks if given element is idempotent.
+    #
+    # @return [Boolean] result of the check
     def idempotent?(element = nil)
       if element
         self[element,element] == element
@@ -195,22 +402,46 @@ module RLSM
       end
     end
 
-    #Returns the order of an element.
+    # Calculates the order of the monoid.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Integer] Order of the given element.
     def order_of(element)
       generated_set([element]).size
     end
 
-    #Returns the principal right ideal of the element.
+    # Calculates the principal right ideal of the given element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] Principle right ideal of the given element.
     def right_ideal(element)
       @elements.map { |el| self[element,el] }.uniq.sort(&element_sorter)
     end
 
-    #Returns the principal left ideal of the element.
+    # Calculates the principal left ideal of the given element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] Principle left ideal of the given element.
     def left_ideal(element)
       @elements.map { |el| self[el,element] }.uniq.sort(&element_sorter)
     end
 
-    #Returns the principal (twosided) ideal of the element.
+    # Calculates the principal (twosided) ideal of the given element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] Principle ideal of the given element.
     def ideal(element)
       result = []
       @elements.each do |el1|
@@ -222,17 +453,33 @@ module RLSM
       result.uniq.sort(&element_sorter)
     end
 
-    #Returns the neutral element of the monoid.
+    # The neutral element of the monoid.
+    #
+    # @return neutral element of the monoid.
     def identity
       @elements.first
     end
 
-    #Checks if +element+ is the neutral element.
+    # Checks if given element is the neutral element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @return [Boolean] Result of the check.
     def identity?(element)
       element == identity
     end
 
-    #If a argument is given, checks if +element+ is the zero element. If no arguement is given, checks if a zero element exists.
+    # @overload zero?
+    # Checks if the monoid has a zero element.
+    #
+    # @overload zero?(element)
+    # Checks if the given element is the zero element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if element isn't a monoid element
+    #
+    # @return [Boolean] Result of the check.
     def zero?(element = nil)
       if element
         return false if @order == 1
@@ -244,140 +491,257 @@ module RLSM
       end
     end
 
-    #Returns the zero element if it exists. Return +nil+ if no zero element exists.
+    # Calculates the zero element of the monoid (if it exists).
+    #
+    # @return [nil] if the monoid has no zero element
+    # @return [Object] the zero element
     def zero
       @elements.find { |el| zero?(el) }
     end
 
-    #Checks if +element+ is a left zero element.
+    # Checks if the given element is a left zero element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if element isn't a monoid element
+    #
+    # @return [Boolean] Result of the check.
     def left_zero?(element)
       return false if @order == 1
       @elements.all? { |x| self[element,x] == element }
     end
 
-    #Checks if +element+ is a right zero element.
+    # Checks if the given element is a right zero element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if element isn't a monoid element
+    #
+    # @return [Boolean] Result of the check.
     def right_zero?(element)
       return false if @order == 1
       @elements.all? { |x| self[x,element] == element }
     end
 
-    #Returns an array with all right zero elements.
+    # Calculates all right zero elements of the monoid.
+    #
+    # @return [Array] the right zero elements of the monoid.
     def right_zeros
       @elements.select { |el| right_zero?(el) }
     end
 
-    #Returns an array with all left zero elements.
+    # Calculates all left zero elements of the monoid.
+    #
+    # @return [Array] the left zero elements of the monoid.
     def left_zeros
       @elements.select { |el| left_zero?(el) }
     end
 
-    #Returns an array with all idempotent elements.
+    # Calculates all idempotent elements of the monoid.
+    #
+    # @return [Array] the idempotent elements of the monoid.
     def idempotents
       @elements.select { |el| idempotent?(el) }
     end
 
-    #Checks if the monoid is a group.
+    # Checks if the monoid is a group.
+    #
+    # @return [Boolean] Result of the check.
     def group?
       idempotents.size == 1
     end
 
-    #Checks if the monoid is commutative.
+    # Checks if the monoid is commutative.
+    #
+    # @return [Boolean] Result of the check.
     def commutative?
-      @binary_operation.commutative?
+      is_commutative
     end
 
-    #Checks if the monoid is monogenic, i.e it is generated by a single element.
+    # Checks if the monoid is monogenic (i.e. generated by a single element).
+    #
+    # @return [Boolean] Result of the check.
     def monogenic?
       generating_subset.size == 1
     end
 
-    #Calculates the L-class of an element.
+    # Calculates the L-class of an element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] L-class of the given element.
     def l_class(element)
       li = left_ideal(element)
       @elements.select { |el| left_ideal(el) == li }
     end
 
-    #Calculates the R-class of an element.
+    # Calculates the R-class of an element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] R-class of the given element.
     def r_class(element)
       r = right_ideal(element)
       @elements.select { |el| right_ideal(el) == r }
     end
 
-    #Calculates the J-class of an element.
+    # Calculates the J-class of an element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] J-class of the given element.
     def j_class(element)
       d = ideal(element)
       @elements.select { |el| ideal(el) == d }
     end
 
-    #Calculates the H-class of an element.
+    # Calculates the H-class of an element.
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] H-class of the given element.
     def h_class(element)
       l_class(element) & r_class(element)
     end
-
-    #Synonym for j_class (in a finite monoid the J and D relation are the same).
+    
+    # Calculates the D-class of an element.
+    # Synonym for j_class (J and D relation are the same for a finite monoid).
+    #
+    # @param element An element of the monoid.
+    #
+    # @raise [RLSM::Error] if the element isn't a monoid element.
+    #
+    # @return [Array] D-class of the given element.
     def d_class(element)
       j_class(element)
     end
 
-    #Synonym for h_trivial?.
-    def aperiodic?
-      h_trivial?
+    # Calculates all R-classes of the monoid.
+    #
+    # @return [Array] List of all R-classes.
+    def r_classes
+      not_tested = @elements.dup
+      classes = []
+      
+      until not_tested.empty?
+        classes << r_class(not_tested.first)
+        not_tested = not_tested.reject { |el| classes.last.include? el }
+      end
+      
+      classes.sort(&subset_sorter)
     end
 
-    ##
-    # :method: l_classes
-    # Returns all L-classes of the monoid.
-
-    ##
-    # :method: r_classes
-    # Returns all R-classes of the monoid.
-
-    ##
-    # :method: j_classes
-    # Returns all J-classes of the monoid.
-
-    ##
-    # :method: h_classes
-    # Returns all H-classes of the monoid.
-
-    ##
-    # :method: d_classes
-    # Returns all D-classes of the monoid.
+    # Calculates all L-classes of the monoid.
+    #
+    # @return [Array] List of all L-classes.
+    def l_classes
+      not_tested = @elements.dup
+      classes = []
+      
+      until not_tested.empty?
+        classes << l_class(not_tested.first)
+        not_tested = not_tested.reject { |el| classes.last.include? el }
+      end
+      
+      classes.sort(&subset_sorter)
+    end
 
-    ##
-    # :method: l_trivial?
-    # Checks if all L-classes consist of one element.
+    # Calculates all J-classes of the monoid.
+    #
+    # @return [Array] List of all J-classes.
+    def j_classes
+      not_tested = @elements.dup
+      classes = []
+      
+      until not_tested.empty?
+        classes << j_class(not_tested.first)
+        not_tested = not_tested.reject { |el| classes.last.include? el }
+      end
+      
+      classes.sort(&subset_sorter)
+    end
 
-    ##
-    # :method: r_trivial?
-    # Checks if all R-classes consist of one element.
+    # Calculates all H-classes of the monoid.
+    #
+    # @return [Array] List of all H-classes.
+    def h_classes
+      not_tested = @elements.dup
+      classes = []
+      
+      until not_tested.empty?
+        classes << h_class(not_tested.first)
+        not_tested = not_tested.reject { |el| classes.last.include? el }
+      end
+      
+      classes.sort(&subset_sorter)
+    end
 
-    ##
-    # :method: j_trivial?
-    # Checks if all J-classes consist of one element.
+    # Calculates all D-classes of the monoid.
+    #
+    # @return [Array] List of all D-classes.
+    def d_classes
+      j_classes
+    end
+    
+    # Checks if all R-classes of the monoid are singleton sets.
+    #
+    # @return [Boolean] Result of the check.
+    def r_trivial?
+      @elements.all? { |el| r_class(el).size == 1 }
+    end
+    
+    # Checks if all L-classes of the monoid are singleton sets.
+    #
+    # @return [Boolean] Result of the check.
+    def l_trivial?
+      @elements.all? { |el| l_class(el).size == 1 }
+    end
 
-    ##
-    # :method: h_trivial?
-    # Checks if all H-classes consist of one element.
+    # Checks if all J-classes of the monoid are singleton sets.
+    #
+    # @return [Boolean] Result of the check.
+    def j_trivial?
+      @elements.all? { |el| j_class(el).size == 1 }
+    end
 
-    ##
-    # :method: d_trivial?
-    # Checks if all D-classes consist of one element.
+    # Checks if all H-classes of the monoid are singleton sets.
+    #
+    # @return [Boolean] Result of the check.
+    def h_trivial?
+      @elements.all? { |el| h_class(el).size == 1 }
+    end
 
-    ##
-    # Method missing magic...
-    def method_missing(name) #:nodoc:
-      case name.to_s
-      when /([jlrhd])_classes/
-        green_classes($1)
-      when /([jlrhd])_trivial?/
-        green_trivial?($1)
-      else
-        super
-      end
+    # Checks if all D-classes of the monoid are singleton sets.
+    #
+    # @return [Boolean] Result of the check.
+    def d_trivial?
+      @elements.all? { |el| d_class(el).size == 1 }
+    end
+    
+    # Checks if the monoid is aperiodic (i.e. H-trivial).
+    #
+    # @return [Boolean] Result of the check.
+    #
+    # @see RLSM::Monoid#h_trivial?
+    def aperiodic?
+      h_trivial?
     end
 
-    #Checks if the given set is a disjunctive subset.
+    # Checks if the given set is a disjunctive subset.
+    #
+    # @param [Array] set A set of monoid elements
+    #
+    # @raise [RLSM::Error] If one of the given elements isn't a monoid element.
+    #
+    # @return [Boolean] Result of the check.
     def subset_disjunctive?(set)
       tupels = []
       @elements.each do |el1|
@@ -393,51 +757,59 @@ module RLSM
       end
     end
 
-    #Returns a disjunctive subset if any exists. Returns +nil+ otherwise.
+    # Calculate a disjunctive subset if one exists.
+    #
+    # @return [nil] if no disjunctive subset exists.
+    # @return [Array] a disjunctive subset.
     def disjunctive_subset
-      @elements.powerset.find { |s| subset_disjunctive? s }
+      RLSM::ArrayExt::powerset(@elements).find { |s| subset_disjunctive? s }
     end
 
-    #Returns an array with all disjunctive subsets.
+    # Calculate all disjunctive subsets.
+    #
+    # @return [Array] all disjunctive subsets.
     def all_disjunctive_subsets
-      @elements.powerset.select { |s| subset_disjunctive? s }
+      RLSM::ArrayExt::powerset(@elements).select { |s| subset_disjunctive? s }
     end
 
-    #Checks if the monoid is syntactic, i.e. if it has a disjunctive subset.
+    # Checks if the monoid is syntactic, i.e. if it has a disjunctive subset.
+    #
+    # @return [Boolean] Result of the check.
     def syntactic?
       !!disjunctive_subset
     end
 
-    def to_s # :nodoc:
-      result = ""
-      sep = @elements.any? { |x| x.length > 1 } ? ',' : ''
-      @binary_operation.table.each_with_index do |el,i|
-        result += @binary_operation.elements[el]
-        if (i+1) % (@order) == 0
-          result += ' '
-        else
-          result += sep unless i = @order**2 - 1
-        end
+    # Transforms the monoid to a regexp which has this monoid as its syntactic
+    # monoid. Each disjunctive subset may yield a different language.
+    # If no argument is given, the smallest disjunctive subset is used.
+    #
+    # @raise [RLSM::Error] If given set isn't a disjunctive subset or the monoid
+    #                      isn't syntactic.
+    #
+    # @param [Array] set A disjunctive subset of the monoid.
+    #
+    # @return [RLSM::RegExp] A regular expression which has this monoi as the
+    #                        syntactic monoid.
+    def to_regexp(set = nil)
+      unless syntactic?
+        raise RLSM::Error, "Only syntactic monoids may be transformed to regexp"
       end
-
-      result
-    end
-
-    def inspect # :nodoc:
-      "<#{self.class}: #{to_s}>"
-    end
-
-    #Returns the monoid.
-    def to_monoid
-      self
-    end
-
-    #Returns a regular expression which represents a language with a syntactic monoid isomorph to +self+.
-    def to_regexp
-      to_dfa.to_regexp
+      
+      to_dfa(set).to_regexp
     end
 
-    #Returns a DFA which represents a language with a syntactic monoid isomorph to +self+.
+    # Transform this monoid into a minimal DFA, which has this monoid as
+    # transition monoid.
+    #
+    # @param [Array] finals The set of final states in the resulting DFA.
+    #                Must be a disjunctive subset. If no subset is given,
+    #                the smallest disjunctive subset is used.
+    #
+    # @raise [RLSM::Error] If given set isn't a disjunctive subset of the monoid
+    #                      or the monoid isn't syntactic.
+    #
+    # @return [RLSM::DFA] A minimal DFA which has this monoid as its transition
+    #                     monoid.
     def to_dfa(finals = nil)
       finals = finals || disjunctive_subset || []
 
@@ -462,7 +834,37 @@ module RLSM
       RLSM::DFA.new string   
     end
 
-    private
+    # @overload regular?
+    # Checks if the monoid is regular.
+    #
+    # @overload regular?(a)
+    # Checks if given element is regular.
+    #
+    # @param a an element of the monoid
+    # @raise [RLSM::Error] if given element isn't a monoid element.
+    # @return [Boolean] Result of the check.
+    def regular?(a=nil)
+      if a.nil?
+        @elements.all? { |x| regular?(x) }
+      else
+        @elements.any? { |x| self[a,x,a] == a}
+      end
+    end
+
+    # Checks if the monoid is inverse.
+    #
+    # @return [Boolean] Result of the check.
+    def inverse?
+      regular? and
+        idempotents.all? { |x| idempotents.all? { |y| self[x,y] == self[y,x] } }
+    end
+    
+
+    # Transforms a given subset of the elements to a submonoid.
+    #
+    # @raise [RLSM::Error] if set isn't a subset of the monoid elements or the
+    #                      set isn't a submonoid.
+    # @return [Monoid] the submonoid formed by the given set.
     def set_to_monoid(set)
       description = set.map do |el1|
         set.map { |el2| self[el1,el2] }.join(",")
@@ -471,10 +873,19 @@ module RLSM
       RLSM::Monoid[ description.join(' ') ]
     end
 
+    
+    # The order in the transition table is the natural order for the elements.
+    #
+    # @return [Proc] As argument for the sort method, elements will be compared
+    #                 by their indices rather than by their names.
     def element_sorter
       Proc.new { |el1,el2| @elements.index(el1) <=> @elements.index(el2)}
     end
 
+    # Subsets are first ordered by size and then lexicographically.
+    #
+    # @return [Proc] As argument for the sort method, subsets will be sorted
+    #                first by size, then lexicographically.
     def subset_sorter
       Proc.new do |set1,set2|
         if set1.size == set2.size
@@ -486,16 +897,23 @@ module RLSM
       end
     end
 
+    # Calculates a list of all subsets and sorts them.
+    #
+    # @return [Array] List of subsets sorted by size and lexicographically
     def sorted_subsets
-      subsets = @elements.powerset
+      subsets = RLSM::ArrayExt::powerset(@elements)
 
       subsets.sort(&subset_sorter)
     end
-    
+
+    # Calculates a list of sets of elements which form a submonoid.
+    # Sorts the result.
+    #
+    # @return [Array] List of sets of elements which form a submonoid.
     def get_submonoid_candidates
       submons =  []
       
-      @elements.powerset.each do |set|
+      RLSM::ArrayExt::powerset(@elements).each do |set|
         candidate = generated_set(set)
         submons << candidate unless submons.include? candidate
       end
@@ -503,48 +921,40 @@ module RLSM
       submons.sort(&subset_sorter)
     end
 
-    def bijective_maps_to(other)
+    # Iterates over all isomorphisms form this monoid to the other.
+    #
+    # @yield [isomorphism] An isomorphism from this monoid to the other.
+    def isomorphisms(other)
       return [] if @order != other.order
 
-      other.elements.permutations.map do |perm| 
-        Hash[*@elements.zip(perm).flatten]
-      end
-    end
+      RLSM::ArrayExt::permutations(other.elements).map do |perm| 
+        map = Hash[*@elements.zip(perm).flatten]
 
-    def isomorphism?(map,other)
-      @elements.each do |el1|
-        @elements.each do |el2|
-          return false if map[self[el1,el2]] != other[map[el1],map[el2]]
+        if @elements.all? { |x| @elements.all? { |y|
+              map[self[x,y]] == other[map[x],map[y]]
+            } }
+          yield map
         end
       end
-
-      true
     end
 
-    def antiisomorphism?(map,other)
-      @elements.each do |el1|
-        @elements.each do |el2|
-          return false if map[self[el1,el2]] != other[map[el2],map[el1]]
-        end
-      end
+    # Iterates over all antiisomorphisms form this monoid to the other.
+    #
+    # @yield [isomorphism] An antiisomorphism from this monoid to the other.
+    def antiisomorphisms(other)
+      return [] if @order != other.order
 
-      true
-    end
+      RLSM::ArrayExt::permutations(other.elements).map do |perm| 
+        map = Hash[*@elements.zip(perm).flatten]
 
-    def green_classes(type)
-      not_tested = @elements.dup
-      classes = []
-
-      until not_tested.empty?
-        classes << self.send((type + '_class').to_sym, not_tested.first)
-	not_tested = not_tested.reject { |el| classes.last.include? el }
+        if @elements.all? { |x| @elements.all? { |y|
+              map[self[x,y]] == other[map[y],map[x]]
+            } }
+          yield map
+        end
       end
-
-      classes.sort(&subset_sorter)
     end
+    
 
-    def green_trivial?(type)
-      @elements.all? { |el| self.send((type + '_class').to_sym, el).size == 1 }
-    end
   end   # of class Monoid
 end     # of module RLSM