Reworked transitions and implemented skeleton code for equivStates algorithm

Author: thundergolfer-two

.coveragerc

@@ -10,3 +10,6 @@ dist/*
 .coverage
 .ipynb_checkpoints
 examples/state.png
+
+# Ignore Virtualenv files
+*env/

.gitignore

@@ -1,42 +1,110 @@
-import random
+import transitions
 
-class ExceptionFSM(Exception):
-    pass
+"""
+Algorithm 5.7.2
+Determination of Equivalent States of DFA
 
-class State(object):
+input: DFA M = (Q, Alphabet, TransitionFunctoin, q<sub>0</sub>, F)
 
-    def __init__(self):
-        pass
+1. (Initialization)
+	  for every pair of states q<sub>i</sub> and q<sub>j</sub>, i < j, do
+ 		1.1 D[i,j] := 0
+ 		1.2 S[i,j] := null set
+ 	  end for
+2. for every pair i, j, i < j,  if one of q<sub>i</sub> or q<sub>j</sub> is
+ 	    and accepting state and the other is not an accepting state, then set D[i,j] := 1
+3. for every pair i, j, i < j, with D[i,j] = 0, do
+ 		3.1 if there exists an a which is element of Alphabet such that delta(q<sub>i</sub>, a) = q<sub>m</sub>,
+ 		delta(q<sub>j</sub>, a) = q<sub>n</sub> and D[m,n] = 1 or D[n,m] = 1, then DIST(i,j)
 
-    def isFinalState(self):
-        return fState
+ 		3.2 else for each a that is element of Alphabet, do: Let delta(q<sub>i</sub>, a) = q<sub>m</sub>,
+ 			delta(q<sub>j</sub>m a) = q<sub>n</sub>
+ 				if m < n and [i,j] /= [m,n], then add [i,j] to S[m,n]
+ 			else if m > n and [i,j] /= [n,m], then add [i,j] to S[n,m]
+    end for
 
-    def isAcceptState(self):
-        return aState
+DIST(i,j);
+begin
+	D[i,j] := 1
+	for all [m,n] that are elements of S[i,j], DIST(m,n)
+end
+"""
+def determineEquivelantStatesOfDFA( dfa ):
+    equivStates = set()
+	states = list(dfa.states.items())
+	D, S = [], []
+	# initialization
+	for i in range(len(states)):
+		D.append([])
+		S.append([])
+		for j in range(len(states)):
+			D[-1].append(False) if i < j else D[-1].append(None)
+			S[-1].append(set()) if i < j else S[-1].append(None)
+	# Step 2
+	for i in range(len(states)):
+		for j in range(len(states)):
+			if i < j and any(s.is_final() for s in states[i:j+1])
+					 and not all(s.is_final() for s in states[i:j+1]):
+				D[i][j] = 1
+	# Step 3
+	for i in range(len(states)):
+		for j in range(len(states)):
+			if i < j and D[i][j] == 0: # Do
+				# if there is an "a" for which both qi and qj have a transition and the
+				# resulting state m,n are not equal (m!=n) and D[m][n] or D[n][m] == 1 then
+				# DIST(i,j)
+				# 3.1
+				for symbol in dfa.alphabet.keys():
+					qi_transition = getTransitionWithSymbol( symbol, states[i].name )
+					qj_transition = getTransitionWithSymbol( symbol, states[j].name )
+					m_state, n_state = qi_transition.dest, qj_transition.dest
+					# get indexes
+					m_index, n_index = 0,0
+					if D[m_index][n_index] == 1 or D[n_index][m_index] == 1:
+						DIST(i. j)
+				# 3.2
+				for symbol in dfa.alphabet.key():
+					pass
+	# Now determine the set of equiv states. If D[i][j] = 0 then i and j are equiv
+	for i in range(len(states)):
+		for j in  range(len(states)):
+			if D[i][j] == 0:
+				equivStates.add(states[i])
+				equivStates.add(states[j])
 
-class Transition(object):
 
-    def __init__(self, input_state, symbol, result_state):
-        self.state = input_state
-        self.symbol = symbol
-        self.result_state
+def DIST(i, j, D, S):
+	""" Helper function for our main algorithm """
+	D[i][j] = 1
+	for m,n in S[i][j]:
+		DIST(m, n)
 
-class FiniteAutomaton(object):
+def getTransitionWithSymbol( dfa, symbol, source ):
+	"""
+	Find a transition, if one exists, that involves the named
+	symbol and source
+	"""
+	for event in dfa.events.keys():
+		for transition in event.transitions.values():
+			if event == symbol and transition.source == source:
+				return transition
 
-    def __init__(self, initial_state):
-        self.init_state = initial_state
-        self.Q = set()
-        self.F = set()
-        self.alphabet = set()
+"""
+input: an NFA-null M = (Q, Alphabet, TransitionFunction, q<sub>0</sub>,F)
+		  input transition function t of M
 
-    def add_transition(self, symbol, state, action, next_state):
-        pass
-
-    def getOtherStates(self,state):
-        return [s for s in Q if s != state]
-
-    def getNonFinalStates(self):
-        return self.Q.difference(self.F)
-
-    def getANonFinalState(self):
-        return random.choice(self.getNonFinalStates())
+1. initialize Q' to null-closure(q<sub>0</sub>)
+2. repeat
+	2.1 if there is a node X, X is element of Q' and a symbol a that's element of Alphabet
+			with no arc leaving X labeled "a", then
+			2.1.1 let Y = UNION over q<sub>i</sub>, where q<sub>i</sub> is element of X of
+			  	  t(q<sub>i</sub>,a)
+			2.1.2 if Y /= Q', then set Q' := Q UNION {Y}
+			2.1.3 add an arc from X to Y labeled a
+		else done:= true
+	  until done
+3. the set of accepting states of DM if F' = {X, where X is element of Q' | X contains
+												 an element q<sub>i</sub> that is element of F}
+"""
+def constructEquivelantDFAFromNFA( nfa ):
+    raise NotImplementedError

Changelog.md

@@ -2,14 +2,14 @@
 License
 *******
 
-The transitions package, including all examples, code snippets and attached 
+This package, including all examples, code snippets and attached
 documentation is covered by the MIT license.
 
 ::
 
   The MIT License
 
-  Copyright (c) 2014 Tal Yarkoni
+  Copyright (c) 2016 Jonathon Belotti
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -27,4 +27,4 @@ documentation is covered by the MIT license.
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  THE SOFTWARE.

FiniteAutomaton.py

@@ -0,0 +1,18 @@
+from  transitions import Machine
+
+def buildDfaWithEquivelantState():
+    """
+    This DFA contains equivelant states and can be used to test the
+    'determination of equivelant states' algorithm.
+    """
+
+    states = ['q0','q1','q2','q3','q4','q5']
+    transitions = [['b', 'q0', 'q2'],['b', 'q1', 'q4'],
+                ['a', 'q1', 'q3'],['a', 'q2', 'q3'],
+                ['b', 'q2', 'q5'],['a', 'q3', 'q3'],
+                ['a', 'q3', 'q3'],['a', 'q3', 'q3'],
+                ['a', 'q3', 'q3'],['a', 'q3', 'q3']]
+    dfa = Machine(model=None, states=states, transitions=transitions, initial='q0')
+    dfa.add_transition(trigger='a', source='q0', dest='q1')
+    dfa.set_final('q4')
+    dfa.set_final('q5')

LICENSE

@@ -333,7 +333,9 @@ def __init__(self, model=None, states=None, initial=None, transitions=None,
             raise MachineError('Passing arguments {0} caused an inheritance error: {1}'.format(kwargs.keys(), e))
 
         self.model = self if model is None else model
+        self.alphabet = self.events # a simple renaming
         self.states = OrderedDict()
+        self.final_states = set()
         self.events = {}
         self.current_state = None
         self.send_event = send_event
@@ -379,6 +381,11 @@ def initial(self):
         """ Return the initial state. """
         return self._initial
 
+    @property
+    def final(self):
+        """ Return the set of final (or 'accepting') states """
+        return self.final_states
+
     @property
     def has_queue(self):
         """ Return boolean indicating if machine has queue or not """
@@ -388,6 +395,10 @@ def is_state(self, state):
         """ Check whether the current state matches the named state. """
         return self.current_state.name == state
 
+    def is_final(self, state):
+        """ Check whether the named state is a final state. """
+        return state in self.final_states
+
     def get_state(self, state):
         """ Return the State instance with the passed name. """
         if state not in self.states:
@@ -401,6 +412,12 @@ def set_state(self, state):
         self.current_state = state
         self.model.state = self.current_state.name
 
+    def set_final(self, state):
+        """ Set state as a final ('accepting') state. """
+        if state not in self.states:
+            raise MachineError("Can't set state as final. State not in machine.")
+        self.final_states.add(state)
+
     def add_state(self, *args, **kwargs):
         """ Alias for add_states. """
         self.add_states(*args, **kwargs)
@@ -546,6 +563,20 @@ def _callback(self, func, event_data):
         else:
             func(*event_data.args, **event_data.kwargs)
 
+    def read(self, symbol):
+        """
+        This has been added to the stock "transitions" library to be a more appropiate
+        transition handling method for algorithm implementation.
+
+        For a transition q0 -[a]-> q1 the stock library can do
+            machine.a()
+            machine._process(s.a)
+            machine.events['a']_trigger()
+        none of which are particularly good for our purposes. With read() you can simply do
+            machine.read('a')
+        """
+        return self.events[symbol]._trigger()
+
     def _process(self, trigger):
 
         # default processing