feat: should do the validness, determinism and completeness, along with the test cases

Author: HongleiGu

evaluation_function/schemas/validation.py

@@ -0,0 +1,65 @@
+from collections import defaultdict
+from .fsa import FSA
+
+def is_valid_fsa(fsa: FSA) -> bool:
+    states = set(fsa.states)
+    alphabet = set(fsa.alphabet)
+
+    if fsa.initial_state not in states:
+        return False
+
+    if not set(fsa.accept_states).issubset(states):
+        return False
+
+    for t in fsa.transitions:
+        if t.from_state not in states:
+            return False
+        if t.to_state not in states:
+            return False
+        if t.symbol not in alphabet:
+            return False
+
+    return True
+
+def is_deterministic(fsa: FSA) -> bool:
+    if not is_valid_fsa(fsa):
+        return False
+
+    seen = set()
+
+    for t in fsa.transitions:
+        key = (t.from_state, t.symbol)
+        if key in seen:
+            return False
+        seen.add(key)
+
+    return True
+
+def is_complete(fsa: FSA) -> bool:
+    if not is_deterministic(fsa):
+        return False
+
+    states = set(fsa.states)
+    alphabet = set(fsa.alphabet)
+
+    seen = {(t.from_state, t.symbol) for t in fsa.transitions}
+
+    for state in states:
+        for symbol in alphabet:
+            if (state, symbol) not in seen:
+                return False
+
+    return True
+
+def classify_fsa(fsa: FSA) -> dict:
+    return {
+        "valid": is_valid_fsa(fsa),
+        "deterministic": is_deterministic(fsa),
+        "complete": is_complete(fsa),
+    }
+
+
+# is_nfa()
+# make_complete()
+# add_sink_state()
+

tests/__init__.py

@@ -0,0 +1,121 @@
+import unittest
+
+from evaluation_function.schemas.validation import (
+    is_valid_fsa,
+    is_deterministic,
+    is_complete,
+)
+
+from evaluation_function.schemas.fsa import FSA, Transition
+from .utils import make_fsa
+
+
+class TestFSAValidation(unittest.TestCase):
+
+    # a valid fsa should be identified as valid
+    def test_valid_fsa_basic(self):
+        fsa = make_fsa(
+            states=["q0", "q1"],
+            alphabet=["a"],
+            transitions=[
+                {"from_state": "q0", "to_state": "q1", "symbol": "a"}
+            ],
+            initial="q0",
+            accept=["q1"],
+        )
+
+        self.assertTrue(is_valid_fsa(fsa))
+
+    # an invalid fsa should be identified as invalid
+    def test_invalid_initial_state(self):
+        fsa = make_fsa(
+            states=["q1"],
+            alphabet=["a"],
+            transitions=[],
+            initial="q0",
+            accept=[],
+        )
+
+        self.assertFalse(is_valid_fsa(fsa))
+
+    # an fsa with unknown transition states is not a valid fsa
+    def test_invalid_transition_state(self):
+        fsa = make_fsa(
+            states=["q0"],
+            alphabet=["a"],
+            transitions=[
+                {"from_state": "q0", "to_state": "q1", "symbol": "a"}
+            ],
+            initial="q0",
+            accept=[],
+        )
+
+        self.assertFalse(is_valid_fsa(fsa))
+
+    # deterministic but incomplete
+    def test_deterministic_but_incomplete(self):
+        fsa = make_fsa(
+            states=["q0", "q1"],
+            alphabet=["a", "b"],
+            transitions=[
+                {"from_state": "q0", "to_state": "q1", "symbol": "a"}
+            ],
+            initial="q0",
+            accept=["q1"],
+        )
+
+        self.assertTrue(is_deterministic(fsa))
+        self.assertFalse(is_complete(fsa))
+
+    # nondeterministic fsa
+    def test_nondeterministic_fsa(self):
+        fsa = make_fsa(
+            states=["q0", "q1", "q2"],
+            alphabet=["a"],
+            transitions=[
+                {"from_state": "q0", "to_state": "q1", "symbol": "a"},
+                {"from_state": "q0", "to_state": "q2", "symbol": "a"},
+            ],
+            initial="q0",
+            accept=["q2"],
+        )
+
+        self.assertFalse(is_deterministic(fsa))
+        self.assertFalse(is_complete(fsa))
+
+    # complete dfa
+    def test_complete_dfa(self):
+        fsa = make_fsa(
+            states=["q0", "q1"],
+            alphabet=["a", "b"],
+            transitions=[
+                {"from_state": "q0", "to_state": "q1", "symbol": "a"},
+                {"from_state": "q0", "to_state": "q0", "symbol": "b"},
+                {"from_state": "q1", "to_state": "q1", "symbol": "a"},
+                {"from_state": "q1", "to_state": "q0", "symbol": "b"},
+            ],
+            initial="q0",
+            accept=["q1"],
+        )
+
+        self.assertTrue(is_valid_fsa(fsa))
+        self.assertTrue(is_deterministic(fsa))
+        self.assertTrue(is_complete(fsa))
+
+    # edge case: single state complete fsa
+    def test_single_state_complete_fsa(self):
+        fsa = make_fsa(
+            states=["q0"],
+            alphabet=["a"],
+            transitions=[
+                {"from_state": "q0", "to_state": "q0", "symbol": "a"}
+            ],
+            initial="q0",
+            accept=["q0"],
+        )
+
+        self.assertTrue(is_complete(fsa))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/validation/__init__.py

@@ -0,0 +1,13 @@
+from evaluation_function.schemas.fsa import FSA, Transition
+
+
+def make_fsa(states, alphabet, transitions, initial, accept):
+    return FSA(
+        states=states,
+        alphabet=alphabet,
+        transitions=[
+            Transition(**t) for t in transitions
+        ],
+        initial_state=initial,
+        accept_states=accept,
+    )