Merge pull request #22 from FormalLanguageConstrainedPathQuerying/master

Add string generator for finite automata

Author: Aunsiels

.github/workflows/python-package.yml

@@ -3,11 +3,7 @@
 
 name: Python package
 
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+on: [push, pull_request]
 
 jobs:
   build:
@@ -51,7 +47,7 @@ jobs:
         junitxml-path: ./pytest.xml
         default-branch: master
     - name: Create coverage Badge
-      if: ${{ matrix.python-version == '3.8'}}
+      if: ${{ github.ref_name == 'master' && matrix.python-version == '3.8'}}
       uses: schneegans/[email protected]
       with:
         auth: ${{ secrets.GIST_SECRET }}

pyformlang/finite_automaton/deterministic_finite_automaton.py

@@ -299,23 +299,6 @@ def _get_previous_transitions(self):
             previous_transitions.add(None, symbol, None)
         return previous_transitions
 
-    def _get_reachable_states(self) -> AbstractSet[State]:
-        """ Get all states which are reachable """
-        to_process = []
-        processed = set()
-        for state in self._start_state:
-            to_process.append(state)
-            processed.add(state)
-        while to_process:
-            current = to_process.pop()
-            for symbol in self._input_symbols:
-                next_state = self._transition_function(current, symbol)
-                if not next_state or next_state[0] in processed:
-                    continue
-                to_process.append(next_state[0])
-                processed.add(next_state[0])
-        return processed
-
     def minimize(self) -> "DeterministicFiniteAutomaton":
         """ Minimize the current DFA
 

pyformlang/finite_automaton/finite_automaton.py

@@ -1,6 +1,7 @@
 """ A general finite automaton representation """
 
-from typing import List, Any, Union
+from typing import List, Iterable, Set, Optional, Union, Any
+from collections import deque
 
 import networkx as nx
 from networkx.drawing.nx_pydot import write_dot
@@ -594,6 +595,86 @@ def is_equivalent_to(self, other):
         self_dfa = self.to_deterministic()
         return self_dfa.is_equivalent_to(other)
 
+    def get_accepted_words(self, max_length: Optional[int] = None) \
+            -> Iterable[List[Symbol]]:
+        """
+        Gets words accepted by the finite automaton.
+        """
+        if max_length is not None and max_length < 0:
+            return []
+        states_to_visit = deque((start_state, [])
+                                for start_state in self.start_states)
+        states_leading_to_final = self._get_states_leading_to_final()
+        words_by_state = {state: set() for state in self.states}
+        yielded_words = set()
+        while states_to_visit:
+            current_state, current_word = states_to_visit.popleft()
+            if max_length is not None and len(current_word) > max_length:
+                continue
+            word_to_add = tuple(current_word)
+            if not self.__try_add(words_by_state[current_state], word_to_add):
+                continue
+            transitions = self._transition_function.get_transitions_from(
+                current_state)
+            for symbol, next_state in transitions:
+                if next_state in states_leading_to_final:
+                    temp_word = current_word.copy()
+                    if symbol != Epsilon():
+                        temp_word.append(symbol)
+                    states_to_visit.append((next_state, temp_word))
+            if self.is_final_state(current_state):
+                if self.__try_add(yielded_words, word_to_add):
+                    yield current_word
+
+    def _get_states_leading_to_final(self) -> Set[State]:
+        """
+        Gets a set of states from which one
+        of the final states can be reached.
+        """
+        leading_to_final = self.final_states.copy()
+        visited = set()
+        states_to_process = deque((None, start_state)
+                                  for start_state in self.start_states)
+        delayed_states = deque()
+        while states_to_process:
+            previous_state, current_state = states_to_process.pop()
+            if previous_state and current_state in leading_to_final:
+                leading_to_final.add(previous_state)
+                continue
+            if current_state in visited:
+                delayed_states.append((previous_state, current_state))
+                continue
+            visited.add(current_state)
+            next_states = self._get_next_states_from(current_state)
+            if next_states:
+                states_to_process.append((previous_state, current_state))
+                for next_state in next_states:
+                    states_to_process.append((current_state, next_state))
+        for previous_state, current_state in delayed_states:
+            if previous_state and current_state in leading_to_final:
+                leading_to_final.add(previous_state)
+        return leading_to_final
+
+    def _get_reachable_states(self) -> Set[State]:
+        """ Get all states which are reachable """
+        visited = set()
+        states_to_process = deque(self.start_states)
+        while states_to_process:
+            current_state = states_to_process.popleft()
+            visited.add(current_state)
+            for next_state in self._get_next_states_from(current_state):
+                if next_state not in visited:
+                    states_to_process.append(next_state)
+        return visited
+
+    def _get_next_states_from(self, state_from: State) -> Set[State]:
+        """ Gets a set of states that are next to the given one """
+        next_states = set()
+        for _, next_state in \
+                self._transition_function.get_transitions_from(state_from):
+            next_states.add(next_state)
+        return next_states
+
     def to_deterministic(self):
         """ Turns the automaton into a deterministic one"""
         raise NotImplementedError
@@ -637,6 +718,16 @@ def to_dict(self):
         """
         return self._transition_function.to_dict()
 
+    @staticmethod
+    def __try_add(set_to_add_to: Set[Any], element_to_add: Any) -> bool:
+        """
+        Tries to add a given element to the given set.
+        Returns True if element was added, otherwise False.
+        """
+        initial_length = len(set_to_add_to)
+        set_to_add_to.add(element_to_add)
+        return len(set_to_add_to) != initial_length
+
 
 def to_state(given: Any) -> Union[State, None]:
     """ Transforms the input into a state

pyformlang/finite_automaton/nondeterministic_transition_function.py

@@ -2,7 +2,7 @@
 A nondeterministic transition function
 """
 import copy
-from typing import Set
+from typing import Set, Iterable, Tuple
 
 from .state import State
 from .symbol import Symbol
@@ -201,3 +201,11 @@ def to_dict(self):
             The transitions as a dictionary.
         """
         return copy.deepcopy(self._transitions)
+
+    def get_transitions_from(self, state_from: State) \
+            -> Iterable[Tuple[Symbol, State]]:
+        """ Gets transitions from the given state """
+        if state_from in self._transitions:
+            for symb_by, states_to in self._transitions[state_from].items():
+                for state_to in states_to:
+                    yield symb_by, state_to

pyformlang/finite_automaton/tests/test_deterministic_finite_automaton.py

@@ -280,6 +280,28 @@ def test_regex_dfa(self):
         dfa_regex = dfa1.to_regex().to_epsilon_nfa()
         assert dfa1 == dfa_regex
 
+    def test_word_generation(self):
+        dfa = get_dfa_example_for_word_generation()
+        accepted_words = list(dfa.get_accepted_words())
+        assert [] in accepted_words
+        assert [Symbol("b"), Symbol("c")] in accepted_words
+        assert [Symbol("b"), Symbol("d")] in accepted_words
+        assert len(accepted_words) == 3
+
+    def test_cyclic_word_generation(self):
+        dfa = get_cyclic_dfa_example()
+        accepted_words = list(dfa.get_accepted_words(5))
+        assert ["a", "f"] in accepted_words
+        assert ["a", "b", "e", "f"] in accepted_words
+        assert ["a", "b", "c", "e", "f"] in accepted_words
+        assert ["a", "b", "d", "a", "f"] in accepted_words
+        assert len(accepted_words) == 4
+
+    def test_dfa_generating_no_words(self):
+        dfa = get_dfa_example_without_accepted_words()
+        accepted_words = list(dfa.get_accepted_words())
+        assert not accepted_words
+
 
 def get_example0():
     """ Gives a dfa """
@@ -326,3 +348,54 @@ def get_dfa_example():
     dfa1.add_start_state(State("A"))
     dfa1.add_final_state(State("D"))
     return dfa1
+
+
+def get_dfa_example_for_word_generation():
+    """ DFA example for the word generation test """
+    dfa = DeterministicFiniteAutomaton()
+    states = [State(x) for x in range(4)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    symbol_c = Symbol("c")
+    symbol_d = Symbol("d")
+    dfa.add_transitions([
+        (states[0], symbol_a, states[1]),
+        (states[0], symbol_b, states[2]),
+        (states[1], symbol_a, states[1]),
+        (states[2], symbol_c, states[3]),
+        (states[2], symbol_d, states[3]),
+    ])
+    dfa.add_start_state(states[0])
+    dfa.add_final_state(states[0])
+    dfa.add_final_state(states[3])
+    return dfa
+
+
+def get_cyclic_dfa_example():
+    """ Gets DFA example with several cycles on path to final """
+    dfa = DeterministicFiniteAutomaton(start_state=0,
+                                       final_states={3})
+    dfa.add_transitions([
+        (0, "a", 1),
+        (1, "b", 2),
+        (2, "c", 2),
+        (2, "d", 0),
+        (2, "e", 1),
+        (1, "f", 3),
+    ])
+    return dfa
+
+
+def get_dfa_example_without_accepted_words():
+    """ DFA example accepting no words """
+    dfa = DeterministicFiniteAutomaton()
+    states = [State(x) for x in range(4)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    dfa.add_transitions([
+        (states[0], symbol_a, states[1]),
+        (states[2], symbol_b, states[3]),
+    ])
+    dfa.add_start_state(states[0])
+    dfa.add_final_state(states[3])
+    return dfa

pyformlang/finite_automaton/tests/test_epsilon_nfa.py

@@ -622,6 +622,47 @@ def test_remove_epsilon_transitions(self):
         assert nfa.get_number_transitions() == 3
         assert nfa.is_equivalent_to(enfa)
 
+    def test_word_generation(self):
+        enfa = get_enfa_example_for_word_generation()
+        accepted_words = list(enfa.get_accepted_words())
+        assert [] in accepted_words
+        assert [Symbol("b")] in accepted_words
+        assert [Symbol("c")] in accepted_words
+        assert [Symbol("d"), Symbol("e")] in accepted_words
+        assert [Symbol("d"), Symbol("e"), Symbol("f")] in accepted_words
+        assert len(accepted_words) == 5
+
+    def test_cyclic_word_generation(self):
+        enfa = get_cyclic_enfa_example()
+        max_length = 10
+        accepted_words = [[Symbol("a")] +
+                          [Symbol("b")] * (i + 1) +
+                          [Symbol("c")]
+                          for i in range(max_length - 2)]
+        actual_accepted_words = list(enfa.get_accepted_words(max_length))
+        assert accepted_words == actual_accepted_words
+
+    def test_epsilon_cycle_word_generation(self):
+        enfa = get_epsilon_cycle_enfa_example()
+        max_length = 4
+        accepted_words = list(enfa.get_accepted_words(max_length))
+        assert [] in accepted_words
+        assert [Symbol("a"), Symbol("c")] in accepted_words
+        assert [Symbol("a"), Symbol("b"), Symbol("c")] in accepted_words
+        assert [Symbol("a"), Symbol("b"),
+                Symbol("b"), Symbol("c")] in accepted_words
+        assert len(accepted_words) == 4
+
+    def test_max_length_zero_accepting_empty_string(self):
+        enfa = get_enfa_example_for_word_generation()
+        accepted_words = list(enfa.get_accepted_words(0))
+        assert accepted_words == [[]]
+
+    def test_max_length_zero_not_accepting_empty_string(self):
+        enfa = get_cyclic_enfa_example()
+        accepted_words = list(enfa.get_accepted_words(0))
+        assert not accepted_words
+
 
 def get_digits_enfa():
     """ An epsilon NFA to recognize digits """
@@ -730,3 +771,75 @@ def get_example_non_minimal():
     enfa0.add_transition(state5, symb_b, state3)
     enfa0.add_transition(state6, symb_b, state4)
     return enfa0
+
+
+def get_enfa_example_for_word_generation():
+    """ ENFA example for the word generation test """
+    enfa = EpsilonNFA()
+    states = [State(x) for x in range(9)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    symbol_c = Symbol("c")
+    symbol_d = Symbol("d")
+    symbol_e = Symbol("e")
+    symbol_f = Symbol("f")
+    epsilon = Epsilon()
+    enfa.add_transitions([
+        (states[0], symbol_a, states[1]),
+        (states[0], epsilon, states[2]),
+        (states[1], symbol_a, states[1]),
+        (states[2], symbol_b, states[3]),
+        (states[2], symbol_c, states[3]),
+        (states[4], symbol_d, states[5]),
+        (states[5], symbol_e, states[6]),
+        (states[5], symbol_e, states[7]),
+        (states[7], symbol_f, states[8]),
+    ])
+    enfa.add_start_state(states[0])
+    enfa.add_start_state(states[4])
+    enfa.add_final_state(states[3])
+    enfa.add_final_state(states[4])
+    enfa.add_final_state(states[6])
+    enfa.add_final_state(states[8])
+    return enfa
+
+
+def get_cyclic_enfa_example():
+    """ ENFA example with a cycle on the path to the final state """
+    enfa = EpsilonNFA()
+    states = [State(x) for x in range(4)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    symbol_c = Symbol("c")
+    epsilon = Epsilon()
+    enfa.add_transitions([
+        (states[0], symbol_a, states[1]),
+        (states[1], symbol_b, states[2]),
+        (states[2], epsilon, states[1]),
+        (states[2], symbol_c, states[3]),
+    ])
+    enfa.add_start_state(states[0])
+    enfa.add_final_state(states[3])
+    return enfa
+
+
+def get_epsilon_cycle_enfa_example():
+    """ ENFA example with an epsilon cycle """
+    enfa = EpsilonNFA()
+    states = [State(x) for x in range(4)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    symbol_c = Symbol("c")
+    epsilon = Epsilon()
+    enfa.add_transitions([
+        (states[0], epsilon, states[0]),
+        (states[0], symbol_a, states[1]),
+        (states[1], symbol_b, states[1]),
+        (states[1], epsilon, states[2]),
+        (states[2], epsilon, states[1]),
+        (states[1], symbol_c, states[3]),
+    ])
+    enfa.add_start_state(states[0])
+    enfa.add_final_state(states[0])
+    enfa.add_final_state(states[3])
+    return enfa