Merge pull request #12 from FormalLanguageConstrainedPathQuerying/rework_finite_automaton

Rework finite_automaton

Author: bygu4

pyformlang/cfg/cfg.py

@@ -7,10 +7,9 @@
 
 # pylint: disable=cyclic-import
 from pyformlang import pda
-from pyformlang.finite_automaton import FiniteAutomaton
+from pyformlang.finite_automaton import DeterministicFiniteAutomaton
 # pylint: disable=cyclic-import
 from pyformlang.pda import cfg_variable_converter as cvc
-from pyformlang import regular_expression
 from .cfg_object import CFGObject
 # pylint: disable=cyclic-import
 from .cyk_table import CYKTable, DerivationDoesNotExist
@@ -788,7 +787,7 @@ def to_pda(self) -> "pda.PDA":
                                    state, [])
         return new_pda
 
-    def intersection(self, other: Any) -> "CFG":
+    def intersection(self, other: DeterministicFiniteAutomaton) -> "CFG":
         """ Gives the intersection of the current CFG with an other object
 
         Equivalent to:
@@ -810,13 +809,6 @@ def intersection(self, other: Any) -> "CFG":
             When trying to intersect with something else than a regex or a
             finite automaton
         """
-        if isinstance(other, regular_expression.Regex):
-            other = other.to_epsilon_nfa().to_deterministic()
-        elif isinstance(other, FiniteAutomaton):
-            if not other.is_deterministic():
-                other = other.to_deterministic()
-        else:
-            raise NotImplementedError
         if other.is_empty():
             return CFG()
         generate_empty = self.contains([]) and other.accepts([])
@@ -845,10 +837,12 @@ def intersection(self, other: Any) -> "CFG":
         return res_cfg
 
     @staticmethod
-    def _intersection_starting_rules(cfg, other, cv_converter):
+    def _intersection_starting_rules(cfg: "CFG",
+                                     other: DeterministicFiniteAutomaton,
+                                     cv_converter):
         start = Variable("Start")
         productions_temp = []
-        start_other = list(other.start_states)[0]  # it is deterministic
+        start_other = other.start_state
         for final_state in other.final_states:
             new_body = [
                 cv_converter.to_cfg_combined_variable(
@@ -860,15 +854,17 @@ def _intersection_starting_rules(cfg, other, cv_converter):
         return productions_temp
 
     @staticmethod
-    def _intersection_when_terminal(other_fst, production,
+    def _intersection_when_terminal(other: DeterministicFiniteAutomaton,
+                                    production,
                                     cv_converter, states):
         productions_temp = []
         for state_p in states:
-            next_states = other_fst(state_p, production.body[0].value)
-            if next_states:
+            next_state = other.get_next_state(
+                state_p, production.body[0].value)
+            if next_state:
                 new_head = \
                     cv_converter.to_cfg_combined_variable(
-                        state_p, production.head, next_states[0])
+                        state_p, production.head, next_state)
                 productions_temp.append(
                     Production(new_head,
                                [production.body[0]],
@@ -904,7 +900,7 @@ def _get_all_bodies(production, state_p, state_r, states, cv_converter):
                                                    state_r)]
             for state_q in states]
 
-    def __and__(self, other):
+    def __and__(self, other: DeterministicFiniteAutomaton) -> "CFG":
         """ Gives the intersection of the current CFG with an other object
 
         Parameters

pyformlang/cfg/tests/test_cfg.py

@@ -516,7 +516,8 @@ def test_finite(self):
     def test_intersection(self):
         """ Tests the intersection with a regex """
         regex = Regex("a*b*")
-        dfa = regex.to_epsilon_nfa()
+        enfa = regex.to_epsilon_nfa()
+        dfa = DeterministicFiniteAutomaton.from_epsilon_nfa(enfa)
         symb_a = Symbol("a")
         symb_b = Symbol("b")
         assert dfa.accepts([symb_a, symb_a, symb_b, symb_b])
@@ -530,7 +531,7 @@ def test_intersection(self):
         cfg = CFG(productions=productions, start_symbol=var_s)
         assert cfg.contains([ter_a, ter_a, ter_b, ter_b])
         assert not cfg.contains([ter_a, ter_a, ter_b])
-        cfg_i = cfg.intersection(regex)
+        cfg_i = cfg.intersection(regex.to_minimal_dfa())
         assert cfg_i.contains([ter_a, ter_a, ter_b, ter_b])
         assert not cfg_i.contains([ter_a, ter_a, ter_b])
         assert cfg_i.contains([])
@@ -548,7 +549,7 @@ def test_intersection_empty(self):
                        Production(var_s, [ter_b, var_s, ter_a]),
                        Production(var_s, [])}
         cfg = CFG(productions=productions, start_symbol=var_s)
-        cfg_i = cfg & regex
+        cfg_i = cfg & regex.to_minimal_dfa()
         assert not cfg_i
 
     def test_intersection_dfa(self):

pyformlang/cfg/tests/test_llone_parser.py

@@ -250,7 +250,7 @@ def test_sentence_cfg(self):
             N -> gorilla | sky | carrots
         """)
         regex = Regex("georges touches (a|an) (sky|gorilla) !")
-        cfg_inter = cfg.intersection(regex)
+        cfg_inter = cfg.intersection(regex.to_minimal_dfa())
         assert not cfg_inter.is_empty()
         assert cfg_inter.is_finite()
         assert not cfg_inter.contains(["georges", "sees", "a", "gorilla", "."])

pyformlang/finite_automaton/__init__.py

@@ -41,9 +41,10 @@
 from .state import State
 from .symbol import Symbol
 from .epsilon import Epsilon
-from .transition_function import (TransitionFunction,
-                                  DuplicateTransitionError,
-                                  InvalidEpsilonTransition)
+from .deterministic_transition_function import \
+    (DeterministicTransitionFunction,
+     DuplicateTransitionError,
+     InvalidEpsilonTransition)
 from .nondeterministic_transition_function import \
     NondeterministicTransitionFunction
 
@@ -54,7 +55,7 @@
            "State",
            "Symbol",
            "Epsilon",
-           "TransitionFunction",
+           "DeterministicTransitionFunction",
            "NondeterministicTransitionFunction",
            "DuplicateTransitionError",
            "InvalidEpsilonTransition"]