fix: Fix bug in minify edge case (#218)

Author: eliotwrobson

automata/fa/dfa.py

@@ -338,6 +338,7 @@ def to_complete(self, trap_state: Optional[DFAStateT] = None) -> Self:
             An equivalent complete DFA.
 
         """
+
         if not self.allow_partial:
             return self.copy()
 
@@ -624,7 +625,9 @@ def _minify(
                                 x for x in count(-1, -1) if x not in reachable_states
                             )
                             for trap_symbol in input_symbols:
-                                transition_back_map[trap_symbol][trap_state] = []
+                                transition_back_map[trap_symbol][trap_state] = [
+                                    trap_state
+                                ]
 
                             reachable_states.add(trap_state)
 
@@ -681,6 +684,11 @@ def _minify(
             if trap_state not in eq
         }
 
+        # If only one equivalence class with the trap state,
+        # return empty language.
+        if not back_map:
+            return cls.empty_language(input_symbols)
+
         new_input_symbols = input_symbols
         new_states = frozenset(back_map.values())
         new_initial_state = back_map[initial_state]
@@ -1707,13 +1715,18 @@ def from_prefix(
 
         states = frozenset(transitions.keys())
         final_states = {last_state}
+
+        is_partial = any(
+            len(lookup) != len(input_symbols) for lookup in transitions.values()
+        )
+
         return cls(
             states=states,
             input_symbols=input_symbols,
             transitions=transitions,
             initial_state=0,
             final_states=final_states if contains else states - final_states,
-            allow_partial=as_partial,
+            allow_partial=is_partial,
         )
 
     @classmethod

tests/test_dfa.py

@@ -293,6 +293,13 @@ def test_to_complete_trap_state_exception(self) -> None:
         with self.assertRaises(exceptions.InvalidStateError):
             self.partial_dfa.to_complete(0)
 
+    def test_to_complete_no_extra_state(self) -> None:
+        """Should not add an extra state if DFA is complete."""
+        alphabet = ["d", "e", "g", "h", "i", "k", "o", "t", "x"]
+        substring = "ti"
+        dfa = DFA.from_prefix(set(alphabet), substring, contains=False)
+        self.assertEqual(dfa.states, dfa.to_complete().states)
+
     def test_equivalence_not_equal(self) -> None:
         """Should not be equal."""
         self.assertNotEqual(self.no_consecutive_11_dfa, self.zero_or_one_1_dfa)
@@ -308,6 +315,29 @@ def test_equivalence_minify(self) -> None:
         minimal_dfa = self.no_consecutive_11_dfa.minify()
         self.assertEqual(self.no_consecutive_11_dfa, minimal_dfa)
 
+        other_dfa = DFA(
+            states={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+            input_symbols={"a", "c", "b"},
+            transitions={
+                0: {"b": 1, "a": 2},
+                1: {"b": 3, "a": 4, "c": 5},
+                2: {"b": 6, "c": 5, "a": 4},
+                3: {"b": 7, "c": 8},
+                4: {"b": 9, "c": 10},
+                5: {"b": 9, "c": 10},
+                6: {"b": 9, "c": 10},
+                7: {"b": 7, "c": 8},
+                8: {"b": 9, "c": 10},
+                9: {"c": 10, "b": 9},
+                10: {"c": 10, "b": 9},
+            },
+            initial_state=0,
+            final_states={2, 7, 8, 9, 10},
+            allow_partial=True,
+        )
+
+        self.assertEqual(other_dfa, other_dfa.minify())
+
     def test_equivalence_two_non_minimal(self) -> None:
         """Should be equivalent even though they are non minimal."""