stamina-core 0.5.4 → 0.6.0

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.6.0 / 2012-09-12
+
+* Added Markable#marks and Markable#raw_data
+* State#initial!, #accepting! and error! now accept an optional truth value parameter.
+* Generalized the decoration algorithm to work backwards as well as forwards as well as
+  accepting an output Hash-like object, defaulting to true state decorations.
+* Generalized the DFA equivalence algorithm under TransitionSystem::Equivalence.
+
 # O.5.4 / 2012-03-06
 
 * InputString and Sample have been moved from stamina-induction to stamina-core as ADL

data/lib/stamina-core/stamina/automaton.rb

@@ -1,5 +1,6 @@
+require_relative 'automaton/state'
+require_relative 'automaton/edge'
 module Stamina
-
   #
   # Automaton data-structure.
   #
@@ -133,358 +134,6 @@ module Stamina
   class Automaton
     include Stamina::Markable
 
-    #
-    # Automaton state.
-    #
-    class State
-      include Stamina::Markable
-      attr_reader :automaton, :index
-
-      #
-      # Creates a state.
-      #
-      # Arguments:
-      # - automaton: parent automaton of the state.
-      # - index: index of the state in the state list.
-      # - data: user data attached to this state.
-      #
-      def initialize(automaton, index, data)
-        @automaton = automaton
-        @index = index
-        @data = data.dup
-        @out_edges = []
-        @in_edges = []
-        @epsilon_closure = nil
-      end
-
-      ### public read-only section ###############################################
-      public
-
-      # Returns true if this state is an initial state, false otherwise.
-      def initial?
-        !!@data[:initial]
-      end
-
-      # Sets this state as an initial state.
-      def initial!
-        @data[:initial] = true
-      end
-
-      # Returns true if this state is an accepting state, false otherwise.
-      def accepting?
-        !!@data[:accepting]
-      end
-
-      # Sets this state as an accepting state.
-      def accepting!
-        @data[:accepting] = true
-      end
-
-      # Returns true if this state is an error state, false otherwise.
-      def error?
-        !!@data[:error]
-      end
-
-      # Sets this state as an error state.
-      def error!
-        @data[:error] = true
-      end
-
-      # Returns true if this state is deterministic, false otherwise.
-      def deterministic?
-        outs = out_symbols
-        (outs.size==@out_edges.size) and not(outs.include?(nil))
-      end
-
-      # Checks if this state is a sink state or not. Sink states are defined as
-      # non accepting states having no outgoing transition or only loop
-      # transitions.
-      def sink?
-        !accepting? && out_edges.all?{|e| e.target==self}
-      end
-
-      # Returns an array containing all incoming edges of the state. Edges are
-      # sorted if _sorted_ is set to true. If two incoming edges have same symbol
-      # no order is guaranteed between them.
-      #
-      # Returned array may be modified.
-      def in_edges(sorted=false)
-        sorted ? @in_edges.sort : @in_edges.dup
-      end
-
-      # Returns an array containing all outgoing edges of the state. Edges are
-      # sorted if _sorted_ is set to true. If two outgoing edges have same symbol
-      # no order is guaranteed between them.
-      #
-      # Returned array may be modified.
-      def out_edges(sorted=false)
-        sorted ? @out_edges.sort : @out_edges.dup
-      end
-
-      # Returns an array with the different symbols appearing on incoming edges.
-      # Returned array does not contain duplicates. Symbols are sorted in the
-      # array if _sorted_ is set to true.
-      #
-      # Returned array may be modified.
-      def in_symbols(sorted=false)
-        symbols = @in_edges.collect{|e| e.symbol}.uniq
-        return sorted ? (symbols.sort &automaton.symbols_comparator) : symbols
-      end
-
-      # Returns an array with the different symbols appearing on outgoing edges.
-      # Returned array does not contain duplicates. Symbols are sorted in the
-      # array if _sorted_ is set to true.
-      #
-      # Returned array may be modified.
-      def out_symbols(sorted=false)
-        symbols = @out_edges.collect{|e| e.symbol}.uniq
-        return sorted ? (symbols.sort &automaton.symbols_comparator) : symbols
-      end
-
-      # Returns an array with adjacent states (in or out edge).
-      #
-      # Returned array may be modified.
-      def adjacent_states()
-        (in_adjacent_states+out_adjacent_states).uniq
-      end
-
-      # Returns an array with adjacent states along an incoming edge (without
-      # duplicates).
-      #
-      # Returned array may be modified.
-      def in_adjacent_states()
-        (@in_edges.collect {|e| e.source}).uniq
-      end
-
-      # Returns an array with adjacent states along an outgoing edge (whithout
-      # duplicates).
-      #
-      # Returned array may be modified.
-      def out_adjacent_states()
-        (@out_edges.collect {|e| e.target}).uniq
-      end
-
-      # Returns reachable states from this one with an input _symbol_. Returned
-      # array does not contain duplicates and may be modified. This method if not
-      # epsilon symbol aware.
-      def step(symbol)
-        @out_edges.select{|e| e.symbol==symbol}.collect{|e| e.target}
-      end
-
-      # Returns the state reached from this one with an input _symbol_, or nil if
-      # no such state. This method is not epsilon symbol aware. Moreover it is
-      # expected to be used on deterministic states only. If the state is not
-      # deterministic, the method returns one reachable state if such a state
-      # exists; which one is returned must be considered non deterministic.
-      def dfa_step(symbol)
-        edge = @out_edges.find{|e| e.symbol==symbol}
-        edge ? edge.target : nil
-      end
-
-      # Computes the epsilon closure of this state. Epsilon closure is the set of
-      # all states reached from this one with a <tt>eps*</tt> input (sequence of
-      # zero or more epsilon symbols). The current state is always contained in
-      # the epsilon closure. Returns an unsorted array without duplicates; this
-      # array may not be modified.
-      def epsilon_closure()
-        @epsilon_closure ||= compute_epsilon_closure(Set.new).to_a.freeze
-      end
-
-      # Internal implementation of epsilon_closure. _result_ is expected to be
-      # a Set instance, is modified and is the returned value.
-      def compute_epsilon_closure(result)
-        result << self
-        step(nil).each do |t|
-          t.compute_epsilon_closure(result) unless result.include?(t)
-        end
-        raise if result.nil?
-        return result
-      end
-
-      # Computes an array representing the set of states that can be reached from
-      # this state with a given input _symbol_. Returned array does not contain
-      # duplicates and may be modified. No particular ordering of states in the
-      # array is guaranteed.
-      #
-      # This method is epsilon symbol aware (represented with nil) on non
-      # deterministic automata, meaning that it actually computes the set of
-      # reachable states through strings respecting the <tt>eps* symbol eps*</tt>
-      # regular expression, where eps is the epsilon symbol.
-      def delta(symbol)
-        if automaton.deterministic?
-          target = dfa_delta(symbol)
-          target.nil? ? [] : [target]
-        else
-          # 1) first compute epsilon closure of self
-          at_epsilon = epsilon_closure
-
-          # 2) now, look where we can go from there
-          at_espilon_then_symbol = at_epsilon.collect do |s|
-            s.step(symbol)
-          end.flatten.uniq
-
-          # 3) look where we can go from there using epsilon
-          result = at_espilon_then_symbol.collect do |s|
-            s.epsilon_closure
-          end.flatten.uniq
-
-          # return result as an array
-          result
-        end
-      end
-
-      # Returns the target state that can be reached from this state with _symbol_
-      # input. Returns nil if no such state exists.
-      #
-      # This method is expected to be used on deterministic automata. Unlike delta,
-      # it returns a State instance (or nil), not an array of states. When used on
-      # non deterministic automata, it returns a state immediately reachable from
-      # this state with _symbol_ input, or nil if no such state exists. This
-      # method is not epsilon aware.
-      def dfa_delta(symbol)
-        return nil if symbol.nil?
-        edge = @out_edges.find{|e| e.symbol==symbol}
-        edge.nil? ? nil : edge.target
-      end
-
-      # Provides comparator of states, based on the index in the automaton state
-      # list. This method returns nil unless  _o_ is a State from the same
-      # automaton than self.
-      def <=>(o)
-        return nil unless State===o
-        return nil unless automaton===o.automaton
-        return index <=> o.index
-      end
-
-      # Returns a string representation
-      def inspect
-        's' << @index.to_s
-      end
-
-      # Returns a string representation
-      def to_s
-        's' << @index.to_s
-      end
-
-      ### protected write section ################################################
-      protected
-
-      # Changes the index of this state in the state list. This method is only
-      # expected to be used by the automaton itself.
-      def index=(i) @index=i end
-
-      #
-      # Fired by Loaded when a user data is changed. The message is forwarded to
-      # the automaton.
-      #
-      def state_changed(what, description)
-        @epsilon_closure = nil
-        @automaton.send(:state_changed, what, description)
-      end
-
-      # Adds an incoming edge to the state.
-      def add_incoming_edge(edge)
-        @epsilon_closure = nil
-        @in_edges << edge
-      end
-
-      # Adds an outgoing edge to the state.
-      def add_outgoing_edge(edge)
-        @epsilon_closure = nil
-        @out_edges << edge
-      end
-
-      # Adds an incoming edge to the state.
-      def drop_incoming_edge(edge)
-        @epsilon_closure = nil
-        @in_edges.delete(edge)
-      end
-
-      # Adds an outgoing edge to the state.
-      def drop_outgoing_edge(edge)
-        @epsilon_closure = nil
-        @out_edges.delete(edge)
-      end
-
-      protected :compute_epsilon_closure
-    end
-
-    #
-    # Automaton edge.
-    #
-    class Edge
-      include Stamina::Markable
-      attr_reader :automaton, :index, :from, :to
-
-      #
-      # Creates an edge.
-      #
-      # Arguments:
-      # - automaton: parent automaton of the edge.
-      # - index: index of the edge in the edge list.
-      # - data: user data attached to this edge.
-      # - from: source state of the edge.
-      # - to: target state of the edge.
-      #
-      def initialize(automaton, index, data, from, to)
-        @automaton, @index = automaton, index
-        @data = data
-        @from, @to = from, to
-      end
-
-      # Returns edge symbol.
-      def symbol()
-        @data[:symbol]
-      end
-
-      # Sets edge symbol.
-      def symbol=(symbol)
-        @data[:symbol] = symbol
-      end
-
-      alias :source :from
-      alias :target :to
-
-      #
-      # Provides comparator of edges, based on the index in the automaton edge
-      # list. This method returns nil unless  _o_ is an Edge from the same
-      # automaton than self.
-      # Once again, this method has nothing to do with equality, it looks at an
-      # index and ID only.
-      #
-      def <=>(o)
-        return nil unless Edge===o
-        return nil unless automaton===o.automaton
-        return index <=> o.index
-      end
-
-      # Returns a string representation
-      def inspect
-        'e' << @index.to_s
-      end
-
-      # Returns a string representation
-      def to_s
-        'e' << @index.to_s
-      end
-
-      ### protected write section ################################################
-      protected
-
-      # Changes the index of this edge in the edge list. This method is only
-      # expected to be used by the automaton itself.
-      def index=(i) @index=i end
-
-      #
-      # Fired by Loaded when a user data is changed. The message if forwarded to
-      # the automaton.
-      #
-      def state_changed(what, infos)
-        @automaton.send(:state_changed, what, infos)
-      end
-
-    end
-
     ### Automaton class ##########################################################
     public
 
@@ -1114,9 +763,7 @@ module Stamina
 
     # Returns true if the automaton is deterministic, false otherwise
     def deterministic?
-      if @deterministic.nil?
-        @deterministic = @states.all?{|s| s.deterministic?}
-      end
+      @deterministic = @states.all?{|s| s.deterministic?} if @deterministic.nil?
       @deterministic
     end
 

data/lib/stamina-core/stamina/automaton/edge.rb

@@ -0,0 +1,79 @@
+module Stamina
+  class Automaton
+    #
+    # Automaton edge.
+    #
+    class Edge
+      include Stamina::Markable
+      attr_reader :automaton, :index, :from, :to
+
+      #
+      # Creates an edge.
+      #
+      # Arguments:
+      # - automaton: parent automaton of the edge.
+      # - index: index of the edge in the edge list.
+      # - data: user data attached to this edge.
+      # - from: source state of the edge.
+      # - to: target state of the edge.
+      #
+      def initialize(automaton, index, data, from, to)
+        @automaton, @index = automaton, index
+        @data = data
+        @from, @to = from, to
+      end
+
+      # Returns edge symbol.
+      def symbol()
+        @data[:symbol]
+      end
+
+      # Sets edge symbol.
+      def symbol=(symbol)
+        @data[:symbol] = symbol
+      end
+
+      alias :source :from
+      alias :target :to
+
+      #
+      # Provides comparator of edges, based on the index in the automaton edge
+      # list. This method returns nil unless  _o_ is an Edge from the same
+      # automaton than self.
+      # Once again, this method has nothing to do with equality, it looks at an
+      # index and ID only.
+      #
+      def <=>(o)
+        return nil unless Edge===o
+        return nil unless automaton===o.automaton
+        return index <=> o.index
+      end
+
+      # Returns a string representation
+      def inspect
+        'e' << @index.to_s
+      end
+
+      # Returns a string representation
+      def to_s
+        'e' << @index.to_s
+      end
+
+      ### protected write section ################################################
+      protected
+
+      # Changes the index of this edge in the edge list. This method is only
+      # expected to be used by the automaton itself.
+      def index=(i) @index=i end
+
+      #
+      # Fired by Loaded when a user data is changed. The message if forwarded to
+      # the automaton.
+      #
+      def state_changed(what, infos)
+        @automaton.send(:state_changed, what, infos)
+      end
+
+    end # class Edge
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/equivalence.rb

@@ -1,55 +1,36 @@
 module Stamina
   class Automaton
 
+    # Implements the equivalence relation commonly used on canonical DFAs
+    class Equivalence < TransitionSystem::Equivalence
+
+      def equivalent_systems?(s, t)
+        (s.state_count == t.state_count) &&
+        (s.edge_count  == t.edge_count)  &&
+        (s.alphabet    == t.alphabet)    &&
+        (s.data        == t.data)
+      end
+
+      def equivalent_states?(s, t)
+        (s.initial?   == t.initial?) &&
+        (s.accepting? == t.accepting?) &&
+        (s.error?     == t.error?)
+      end
+
+      def equivalent_edges?(e, f)
+        e.symbol == f.symbol
+      end
+
+    end # class Equivalence
+
     #
     # Checks if this automaton is equivalent to another one.
     #
     # Automata must be both minimal and complete to guarantee that this method
     # works.
     #
-    def equivalent?(other, equiv = nil, key = :equiv_state)
-      equiv ||= Proc.new{|s1,s2| (s1 && s2) &&
-                                 (s1.accepting? == s2.accepting?) &&
-                                 (s1.error? == s2.error?) &&
-                                 (s1.initial? == s2.initial?) }
-
-      # Both must already have basic attributes in common
-      return false unless state_count==other.state_count
-      return false unless edge_count==other.edge_count
-      return false unless alphabet==other.alphabet
-      return false unless equiv[initial_state, other.initial_state]
-
-      # We instantiate the decoration algorithm for checking equivalence on this
-      # automaton:
-      #   * decoration is the index of the equivalent state in other automaton
-      #   * d0 is thus 'other.initial_state.index'
-      #   * suppremum is identity and fails when the equivalent state is not unique
-      #   * propagation checks transition function delta
-      #
-      algo = Stamina::Utils::Decorate.new(key)
-      algo.set_suppremum do |d0, d1|
-        if (d0.nil? or d1.nil?)
-           (d0 || d1)
-        elsif d0==d1
-          d0
-        else
-          raise Stamina::Abord
-        end
-      end
-      algo.set_propagate do |d,e|
-        reached = other.ith_state(d).dfa_step(e.symbol)
-        raise Stamina::Abord if reached.nil?
-        raise Stamina::Abord unless equiv[e.target, reached]
-        reached.index
-      end
-
-      # Run the algorithm now
-      begin
-        algo.execute(self, nil, other.initial_state.index)
-        return true
-      rescue Stamina::Abord
-        return false
-      end
+    def equivalent?(other)
+      Equivalence.new.call(self, other)
     end
     alias :<=> :equivalent?
 

data/lib/stamina-core/stamina/automaton/metrics.rb

@@ -49,23 +49,17 @@ module Stamina
       # each state as a mark under _key_, which defaults to :depth.
       #
       def depth(key = :depth)
-        algo = Stamina::Utils::Decorate.new(key)
+        algo = Stamina::Utils::Decorate.new
         algo.set_suppremum do |d0,d1|
-          # Here, unreached state has the max value (i.e. nil is +INF)
-          # and we look at the minimum depth for each state
-          if d0.nil?
-            d1
-          elsif d1.nil?
-            d0
-          else
-            (d0 <= d1 ? d0 : d1)
-          end
+          # Unreached state is MAX (i.e. nil is +INF); we look at the min depth for each state
+          (d0.nil? or d1.nil?) ? (d0 || d1) : (d0 <= d1 ? d0 : d1)
         end
         algo.set_propagate{|d,e| d+1 }
-        algo.execute(self, nil, 0)
+        algo.set_initiator{|s| s.initial? ? 0 : nil }
+        algo.set_start_predicate{|s| s.initial? }
+        algo.call(self, key)
         deepest = states.max do |s0,s1|
-          # Here, we do not take unreachable states into account
-          # so that -1 is taken when nil is encountered
+          # do not take unreachable states into account: -1 is taken if nil is encountered
           (s0[:depth] || -1) <=> (s1[:depth] || -1)
         end
         deepest[:depth]

data/lib/stamina-core/stamina/automaton/minimize/pitchies.rb

@@ -107,13 +107,13 @@ module Stamina
         def main
           alph, states = @automaton.alphabet, @automaton.states
           old_nb_states = -1
-          partition = states.collect{|s| s.accepting? ? 1 : 0}
+          partition = states.map{|s| s.accepting? ? 1 : 0}
           until (nb_states = partition.uniq.size) == old_nb_states
             old_nb_states = nb_states
             alph.each do |symbol|
-              reached = states.collect{|s| partition[s.dfa_step(symbol).index]}
+              reached = states.map{|s| partition[s.dfa_step(symbol).index]}
               rehash = Hash.new{|h,k| h[k] = h.size}
-              partition = partition.zip(reached).collect{|pair| rehash[pair]}
+              partition = partition.zip(reached).map{|pair| rehash[pair]}
             end
           end
           minimized_dfa(@automaton, nb_states, partition)

data/lib/stamina-core/stamina/automaton/state.rb

@@ -0,0 +1,267 @@
+module Stamina
+  class Automaton
+    #
+    # Automaton state.
+    #
+    class State
+      include Stamina::Markable
+      attr_reader :automaton, :index
+
+      #
+      # Creates a state.
+      #
+      # Arguments:
+      # - automaton: parent automaton of the state.
+      # - index: index of the state in the state list.
+      # - data: user data attached to this state.
+      #
+      def initialize(automaton, index, data)
+        @automaton = automaton
+        @index = index
+        @data = data.dup
+        @out_edges = []
+        @in_edges = []
+        @epsilon_closure = nil
+      end
+
+      ### public read-only section ###############################################
+      public
+
+      # Returns true if this state is an initial state, false otherwise.
+      def initial?
+        !!@data[:initial]
+      end
+
+      # Sets this state as an initial state.
+      def initial!(value = true)
+        @data[:initial] = value
+      end
+
+      # Returns true if this state is an accepting state, false otherwise.
+      def accepting?
+        !!@data[:accepting]
+      end
+
+      # Sets this state as an accepting state.
+      def accepting!(value = true)
+        @data[:accepting] = value
+      end
+
+      # Returns true if this state is an error state, false otherwise.
+      def error?
+        !!@data[:error]
+      end
+
+      # Sets this state as an error state.
+      def error!(value = true)
+        @data[:error] = value
+      end
+
+      # Returns true if this state is deterministic, false otherwise.
+      def deterministic?
+        outs = out_symbols
+        (outs.size==@out_edges.size) and not(outs.include?(nil))
+      end
+
+      # Checks if this state is a sink state or not. Sink states are defined as
+      # non accepting states having no outgoing transition or only loop
+      # transitions.
+      def sink?
+        !accepting? && out_edges.all?{|e| e.target==self}
+      end
+
+      # Returns an array containing all incoming edges of the state. Edges are
+      # sorted if _sorted_ is set to true. If two incoming edges have same symbol
+      # no order is guaranteed between them.
+      #
+      # Returned array may be modified.
+      def in_edges(sorted=false)
+        sorted ? @in_edges.sort : @in_edges.dup
+      end
+
+      # Returns an array containing all outgoing edges of the state. Edges are
+      # sorted if _sorted_ is set to true. If two outgoing edges have same symbol
+      # no order is guaranteed between them.
+      #
+      # Returned array may be modified.
+      def out_edges(sorted=false)
+        sorted ? @out_edges.sort : @out_edges.dup
+      end
+
+      # Returns an array with the different symbols appearing on incoming edges.
+      # Returned array does not contain duplicates. Symbols are sorted in the
+      # array if _sorted_ is set to true.
+      #
+      # Returned array may be modified.
+      def in_symbols(sorted=false)
+        symbols = @in_edges.collect{|e| e.symbol}.uniq
+        return sorted ? (symbols.sort &automaton.symbols_comparator) : symbols
+      end
+
+      # Returns an array with the different symbols appearing on outgoing edges.
+      # Returned array does not contain duplicates. Symbols are sorted in the
+      # array if _sorted_ is set to true.
+      #
+      # Returned array may be modified.
+      def out_symbols(sorted=false)
+        symbols = @out_edges.collect{|e| e.symbol}.uniq
+        return sorted ? (symbols.sort &automaton.symbols_comparator) : symbols
+      end
+
+      # Returns an array with adjacent states (in or out edge).
+      #
+      # Returned array may be modified.
+      def adjacent_states()
+        (in_adjacent_states+out_adjacent_states).uniq
+      end
+
+      # Returns an array with adjacent states along an incoming edge (without
+      # duplicates).
+      #
+      # Returned array may be modified.
+      def in_adjacent_states()
+        (@in_edges.collect {|e| e.source}).uniq
+      end
+
+      # Returns an array with adjacent states along an outgoing edge (whithout
+      # duplicates).
+      #
+      # Returned array may be modified.
+      def out_adjacent_states()
+        (@out_edges.collect {|e| e.target}).uniq
+      end
+
+      # Returns reachable states from this one with an input _symbol_. Returned
+      # array does not contain duplicates and may be modified. This method if not
+      # epsilon symbol aware.
+      def step(symbol)
+        @out_edges.select{|e| e.symbol==symbol}.collect{|e| e.target}
+      end
+
+      # Returns the state reached from this one with an input _symbol_, or nil if
+      # no such state. This method is not epsilon symbol aware. Moreover it is
+      # expected to be used on deterministic states only. If the state is not
+      # deterministic, the method returns one reachable state if such a state
+      # exists; which one is returned must be considered non deterministic.
+      def dfa_step(symbol)
+        edge = @out_edges.find{|e| e.symbol==symbol}
+        edge ? edge.target : nil
+      end
+
+      # Computes the epsilon closure of this state. Epsilon closure is the set of
+      # all states reached from this one with a <tt>eps*</tt> input (sequence of
+      # zero or more epsilon symbols). The current state is always contained in
+      # the epsilon closure. Returns an unsorted array without duplicates; this
+      # array may not be modified.
+      def epsilon_closure()
+        @epsilon_closure ||= compute_epsilon_closure(Set.new).to_a.freeze
+      end
+
+      # Internal implementation of epsilon_closure. _result_ is expected to be
+      # a Set instance, is modified and is the returned value.
+      def compute_epsilon_closure(result)
+        result << self
+        step(nil).each do |t|
+          t.compute_epsilon_closure(result) unless result.include?(t)
+        end
+        raise if result.nil?
+        return result
+      end
+
+      # Computes an array representing the set of states that can be reached from
+      # this state with a given input _symbol_. Returned array does not contain
+      # duplicates and may be modified. No particular ordering of states in the
+      # array is guaranteed.
+      #
+      # This method is epsilon symbol aware (represented with nil) on non
+      # deterministic automata, meaning that it actually computes the set of
+      # reachable states through strings respecting the <tt>eps* symbol eps*</tt>
+      # regular expression, where eps is the epsilon symbol.
+      def delta(symbol)
+        if automaton.deterministic?
+          target = dfa_delta(symbol)
+          target.nil? ? [] : [target]
+        else
+          at_epsilon = epsilon_closure
+          at_espilon_then_symbol = at_epsilon.map{|s| s.step(symbol)}.flatten.uniq
+          at_espilon_then_symbol.map{|s| s.epsilon_closure}.flatten.uniq
+        end
+      end
+
+      # Returns the target state that can be reached from this state with _symbol_
+      # input. Returns nil if no such state exists.
+      #
+      # This method is expected to be used on deterministic automata. Unlike delta,
+      # it returns a State instance (or nil), not an array of states. When used on
+      # non deterministic automata, it returns a state immediately reachable from
+      # this state with _symbol_ input, or nil if no such state exists. This
+      # method is not epsilon aware.
+      def dfa_delta(symbol)
+        return nil if symbol.nil?
+        edge = @out_edges.find{|e| e.symbol==symbol}
+        edge.nil? ? nil : edge.target
+      end
+
+      # Provides comparator of states, based on the index in the automaton state
+      # list. This method returns nil unless  _o_ is a State from the same
+      # automaton than self.
+      def <=>(o)
+        return nil unless State===o
+        return nil unless automaton===o.automaton
+        return index <=> o.index
+      end
+
+      # Returns a string representation
+      def inspect
+        's' << @index.to_s
+      end
+
+      # Returns a string representation
+      def to_s
+        's' << @index.to_s
+      end
+
+      ### protected write section ################################################
+      protected
+
+      # Changes the index of this state in the state list. This method is only
+      # expected to be used by the automaton itself.
+      def index=(i) @index=i end
+
+      #
+      # Fired by Loaded when a user data is changed. The message is forwarded to
+      # the automaton.
+      #
+      def state_changed(what, description)
+        @epsilon_closure = nil
+        @automaton.send(:state_changed, what, description)
+      end
+
+      # Adds an incoming edge to the state.
+      def add_incoming_edge(edge)
+        @epsilon_closure = nil
+        @in_edges << edge
+      end
+
+      # Adds an outgoing edge to the state.
+      def add_outgoing_edge(edge)
+        @epsilon_closure = nil
+        @out_edges << edge
+      end
+
+      # Adds an incoming edge to the state.
+      def drop_incoming_edge(edge)
+        @epsilon_closure = nil
+        @in_edges.delete(edge)
+      end
+
+      # Adds an outgoing edge to the state.
+      def drop_outgoing_edge(edge)
+        @epsilon_closure = nil
+        @out_edges.delete(edge)
+      end
+
+      protected :compute_epsilon_closure
+    end # class State
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/walking.rb

@@ -135,7 +135,7 @@ module Stamina
       #
       def step(from, symbol)
         from = walking_to_from(from)
-        from.collect{|s| s.step(symbol)}.flatten.uniq
+        from.map{|s| s.step(symbol)}.flatten.uniq
       end
 
       #
@@ -144,7 +144,7 @@ module Stamina
       # reached with the given symbol.
       #
       def dfa_step(from, symbol)
-        step = walking_to_from(from).collect{|s| s.dfa_step(symbol)}.flatten.uniq
+        step = walking_to_from(from).map{|s| s.dfa_step(symbol)}.flatten.uniq
         walking_to_dfa_result(step, from)
       end
 
@@ -158,7 +158,7 @@ module Stamina
       # regular expression, where eps is the epsilon symbol.
       #
       def delta(from, symbol)
-        walking_to_from(from).collect{|s| s.delta(symbol)}.flatten.uniq
+        walking_to_from(from).map{|s| s.delta(symbol)}.flatten.uniq
       end
 
       #
@@ -171,7 +171,7 @@ module Stamina
         if from.is_a?(Automaton::State)
           from.dfa_delta(symbol)
         else
-          delta = walking_to_from(from).collect{|s| s.dfa_delta(symbol)}.flatten.uniq
+          delta = walking_to_from(from).map{|s| s.dfa_delta(symbol)}.flatten.uniq
           walking_to_dfa_result(delta, from)
         end
       end
@@ -344,7 +344,7 @@ module Stamina
       # Implements _from_ conventions.
       def walking_to_from(from)
         return initial_states if from.nil?
-        Array===from ? from.collect{|s| to_state(s)} : [to_state(from)]
+        Array===from ? from.map{|s| to_state(s)} : [to_state(from)]
       end
 
       # Implements _return_ conventions of dfa_xxx methods.

data/lib/stamina-core/stamina/core.rb

@@ -2,9 +2,10 @@ require_relative 'version'
 require_relative 'errors'
 require_relative 'ext/math'
 require_relative 'markable'
+require_relative 'utils'
+require_relative 'transition_system'
 require_relative 'adl'
 require_relative 'automaton'
-require_relative 'utils'
 require_relative 'input_string'
 require_relative 'sample'
 require_relative 'dsl'

data/lib/stamina-core/stamina/markable.rb

@@ -14,7 +14,9 @@ module Stamina
     #
     # Returns user-value associated to _key_, nil if no such key in user-data.
     #
-    def [](key) @data[key] end
+    def [](key)
+      @data[key]
+    end
 
     #
     # Associates _value_ to _key_ in user-data. Overrides previous value if
@@ -33,6 +35,17 @@ module Stamina
       state_changed(:loaded_pair, [key,oldvalue,nil]) if self.respond_to? :state_changed
     end
 
+    # Returns the values mapped to `keys` as an array
+    def marks(*keys)
+      raw_data.values_at(*keys)
+    end
+
+    # Returns RAW data, that is without duplicating it. Returns result should not be
+    # changed.
+    def raw_data
+      @data ||= {}
+    end
+
     # Extracts the copy of attributes which can subsequently be modified.
     def data
       @data.nil? ? {} : @data.dup

data/lib/stamina-core/stamina/transition_system.rb

@@ -0,0 +1 @@
+require_relative 'transition_system/equivalence'

data/lib/stamina-core/stamina/transition_system/equivalence.rb

@@ -0,0 +1,107 @@
+module Stamina
+  class TransitionSystem
+    class Equivalence
+
+      # Returns true if `s` and `t` must be considered equivalent, false otherwise.
+      def equivalent_systems?(s, t)
+        (s.state_count == t.state_count) &&
+        (s.edge_count  == t.edge_count)  &&
+        (s.raw_data    == t.raw_data)
+      end
+
+      def equivalent_systems!(s, t)
+        fail "Non equivalent systems `#{s}` and `#{t}`" unless equivalent_systems?(s,t)
+        true
+      end
+
+      # Returns true if `s` and `t` must be considered equivalent, false otherwise.
+      def equivalent_states?(s, t)
+        s.raw_data == t.raw_data
+      end
+
+      def equivalent_states!(s, t)
+        fail "Non equivalent states `#{s}` and `#{t}`" unless equivalent_states?(s,t)
+        true
+      end
+
+      # Returns true if `e` and `f` must be considered equivalent, false otherwise.
+      def equivalent_edges?(e, f)
+        e.raw_data == f.raw_data
+      end
+
+      def equivalent_edges!(s, t)
+        fail "Non equivalent edges `#{s}` and `#{t}`" unless equivalent_edges?(s,t)
+        true
+      end
+
+      # Finds the edge counterpart of `operand_edge` as an outgoing edge of
+      # `reference_state`. The default implementation takes an edge that shares the same
+      # symbol as operand_edge.
+      def find_edge_counterpart(reference_state, operand_edge)
+        symbol = operand_edge.symbol
+        reference_state.out_edges.find{|e| e.symbol==symbol}
+      end
+
+      # Computes equivalence pairs through decoration
+      class EquivThroughDeco < Utils::Decorate
+        
+        def initialize(reference, algo)
+          @reference = reference
+          @algo      = algo
+        end
+        attr_reader :reference, :algo
+
+        def suppremum(d0, d1)
+          return (d0 || d1) if (d0.nil? or d1.nil?)
+          unless d0==d1
+            algo.fail("Different states found through same path: #{d0} & #{d1}")
+          end
+          d0
+        end
+
+        def propagate(deco, edge)
+          symbol   = edge.symbol
+          source   = reference.ith_state(deco)
+          eq_edge  = algo.find_edge_counterpart(source, edge)
+          algo.fail("No such transition `#{symbol}` from #{source}") unless eq_edge
+          algo.equivalent_edges!(edge, eq_edge)
+          algo.equivalent_states!(edge.target, eq_edge.target)
+          eq_edge.target.index
+        end
+
+        def init_deco(s)
+          s.initial? ? reference.initial_state.index : nil
+        end
+
+        def take_at_start?(s)
+          s.initial?
+        end
+
+      end # EquivThroughDeco
+
+      # Executes the equivalence algorithm on two transition systems `ts1` and `ts2`.
+      # Returns true if they are considered equivalent, false otherwise.
+      def call(ts1, ts2, &explain)
+        @explain = explain
+        catch(:fail) do
+          equivalent_systems!(ts1, ts2)
+          i1, i2 = ts1.initial_state, ts2.initial_state
+          fail "No initial state on ts1" unless i1
+          fail "No initial state on ts2" unless i2
+          equivalent_states!(i1, i2)
+          EquivThroughDeco.new(ts2, self).call(ts1, {})
+          return true
+        end
+        return false
+      ensure
+        @explain = nil
+      end
+
+      def fail(message)
+        @explain.call(message) if @explain
+        throw :fail
+      end
+
+    end # class Equivalence
+  end # class TransitionSystem
+end # module Stamina

data/lib/stamina-core/stamina/utils/decorate.rb

@@ -1,22 +1,35 @@
 module Stamina
   module Utils
     #
-    # Decorates states of an automaton by applying a propagation rule
-    # until a fix point is reached.
+    # Decorates states of an automaton by applying a propagation rule until a fix point is
+    # reached.
     #
     class Decorate
 
-      # The key to use to maintain the decoration on states (:invariant
-      # is used by default)
-      attr_writer :decoration_key
-
       # Creates a decoration algorithm instance
-      def initialize(decoration_key = :invariant)
-        @decoration_key = decoration_key
+      def initialize(output = :invariant)
+        @output    = Decorate.state_output(output) if output
         @suppremum = nil
         @propagate = nil
+        @initiator = nil
+        @backward  = false
+        @start_predicate = nil
+      end
+
+      # Builds an output hash that keeps decoration in states
+      def self.state_output(decoration_key)
+        Object.new.extend Module.new{
+          define_method :[] do |state|
+            state[decoration_key]
+          end
+          define_method :[]= do |state,deco|
+            state[decoration_key] = deco
+          end
+        }
       end
 
+      ### CONFIGURATION ##################################################################
+
       # Installs a suppremum function through a block.
       def set_suppremum(&block)
         raise ArgumentError, 'Suppremum expected through a block' if block.nil?
@@ -24,6 +37,11 @@ module Stamina
         @suppremum = block
       end
 
+      # Same as #set_suppremum, but with an explicit proc
+      def suppremum=(proc)
+        set_suppremum(&proc)
+      end
+
       # Installs a propagate function through a block.
       def set_propagate(&block)
         raise ArgumentError, 'Propagate expected through a block' if block.nil?
@@ -31,6 +49,43 @@ module Stamina
         @propagate = block
       end
 
+      # Same as #set_propagate, but with an explicit proc
+      def propagate=(proc)
+        set_propagate(&proc)
+      end
+
+      # Set an initiator methods, responsible of computing the initial decoration of
+      # each state
+      def set_initiator(&block)
+        raise ArgumentError, 'Initiator expected through a block' if block.nil?
+        raise ArgumentError, 'Block of arity 1 expected' unless block.arity==1
+        @initiator = block
+      end
+
+      # Same as #set_initiator but with an explicit proc
+      def initiator=(proc)
+        set_initiator(&proc)
+      end
+
+      # Sets the start predicate to use
+      def set_start_predicate(&block)
+        raise ArgumentError, 'Start predicate expected through a block' if block.nil?
+        raise ArgumentError, 'Block of arity 1 expected' unless block.arity==1
+        @start_predicate = block
+      end
+
+      # Same as #set_start_predicate but with an explicit proc
+      def start_predicate=(proc)
+        set_start_predicate(&proc)
+      end
+
+      # Sets if the algorithms works backward
+      def backward=(val)
+        @backward = val
+      end
+
+      ### SUBCLASS HOOKS #################################################################
+
       # Computes the suppremum between two decorations. By default, this method
       # looks for a suppremum function installed with set_suppremum. If not found,
       # it tries calling a suppremum method on d0. If not found it raises an error.
@@ -51,31 +106,72 @@ module Stamina
         raise "No propagate function installed or implemented by decorations"
       end
 
-      # Executes the propagation algorithm on a given automaton.
-      def execute(fa, bottom, d0)
-        to_explore = []
+      # Returns the initial decoration of state `s`
+      def init_deco(s)
+        return @initiator.call(s) if @initiator
+        raise "No initiator function installed"
+      end
 
-        # install initial decoration
-        fa.states.each do |s|
-          s[@decoration_key] = (s.initial? ? d0 : bottom)
-          to_explore << s if s.initial?
-        end
+      # Returns the start predicate
+      def take_at_start?(s)
+        return @start_predicate.call(s) if @start_predicate
+        raise "No start predicate function installed"
+      end
+
+      # Work backward?
+      def backward?
+        @backward
+      end
 
-        # fix-point loop starting with initial states
-        until to_explore.empty?
-          source = to_explore.pop
-          source.out_edges.each do |edge|
-            target = edge.target
-            p_decor = propagate(source[@decoration_key], edge)
-            p_decor = suppremum(target[@decoration_key], p_decor)
-            unless p_decor == target[@decoration_key]
-              target[@decoration_key] = p_decor
-              to_explore << target unless to_explore.include?(target)
+      ### MAIN ###########################################################################
+
+      # Executes the propagation algorithm on a given automaton.
+      def call(fa, out = nil)
+        with_output(out) do |output|
+          fa.states.each{|s| output[s] = init_deco(s) }        # Init decoration on each state
+          to_explore = fa.states.select{|s| take_at_start?(s)} # Init to_explore (start predicate)
+          until to_explore.empty?                              # empty to_explore now
+            source = to_explore.pop
+            each_edge_and_target(source) do |edge, target|
+              p_decor = propagate(output[source], edge)
+              p_decor = suppremum(output[target], p_decor)
+              unless p_decor == output[target]
+                output[target] = p_decor
+                to_explore << target unless to_explore.include?(target)
+              end
             end
           end
+          fa
         end
+      end
+
+      # Executes the propagation algorithm on a given automaton.
+      def execute(fa, bottom, d0)
+        warn "Decorate#execute is deprecated, use Decorate#call (#{caller[0]})"
+        self.initiator       = lambda{|s| (s.initial? ? d0 : bottom)}
+        self.start_predicate = lambda{|s| s.initial? }
+        call(fa)
+      end
 
-        fa
+    private
+
+      def with_output(out)
+        if out
+          yield out.is_a?(Symbol) ? Decorate.state_output(out) : out
+        elsif @output
+          warn "Decorate.new(:decokey) is deprecated, use Decorate#call(fa, :decokey) (#{caller[1]})"
+          yield @output
+        else
+          raise ArgumentError, "Output may not be nil", caller
+        end
+      end
+
+      def each_edge_and_target(source)
+        edges = backward? ? source.in_edges : source.out_edges
+        edges.each do |edge|
+          target = target = backward? ? edge.source : edge.target
+          yield edge, target
+        end
       end
 
     end # class Decorate

data/lib/stamina-core/stamina/version.rb

@@ -2,8 +2,8 @@ module Stamina
   module Version
 
     MAJOR = 0
-    MINOR = 5
-    TINY  = 4
+    MINOR = 6
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stamina-core
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000Z
+date: 2012-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: quickl
-  requirement: &70340660206260 !ruby/object:Gem::Requirement
+  requirement: &70185698728600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 0.4.3
   type: :runtime
   prerelease: false
-  version_requirements: *70340660206260
+  version_requirements: *70185698728600
 description: ! "Stamina is an automaton and regular inference toolkit initially developped
   for the \nbaseline of the Stamina Competition (stamina.chefbe.net)."
 email:
@@ -37,12 +37,14 @@ files:
 - lib/stamina-core/stamina/automaton/complete.rb
 - lib/stamina-core/stamina/automaton/compose.rb
 - lib/stamina-core/stamina/automaton/determinize.rb
+- lib/stamina-core/stamina/automaton/edge.rb
 - lib/stamina-core/stamina/automaton/equivalence.rb
 - lib/stamina-core/stamina/automaton/hide.rb
 - lib/stamina-core/stamina/automaton/metrics.rb
 - lib/stamina-core/stamina/automaton/minimize/hopcroft.rb
 - lib/stamina-core/stamina/automaton/minimize/pitchies.rb
 - lib/stamina-core/stamina/automaton/minimize.rb
+- lib/stamina-core/stamina/automaton/state.rb
 - lib/stamina-core/stamina/automaton/strip.rb
 - lib/stamina-core/stamina/automaton/walking.rb
 - lib/stamina-core/stamina/automaton.rb
@@ -62,6 +64,8 @@ files:
 - lib/stamina-core/stamina/input_string.rb
 - lib/stamina-core/stamina/markable.rb
 - lib/stamina-core/stamina/sample.rb
+- lib/stamina-core/stamina/transition_system/equivalence.rb
+- lib/stamina-core/stamina/transition_system.rb
 - lib/stamina-core/stamina/utils/decorate.rb
 - lib/stamina-core/stamina/utils.rb
 - lib/stamina-core/stamina/version.rb
@@ -78,6 +82,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -57027985138010278
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -86,9 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Automaton and Regular Inference Toolkit
 test_files: []
-has_rdoc: