def get_enfa_from_functions(functions): transition_function, states, symbols, final_states = get_transition_function_and_states_and_symbols_non_reduced( functions) enfa = NondeterministicFiniteAutomaton(states, symbols, transition_function, {State("Start")}, final_states) return enfa
def test_minimize_repetition(self): dfa = DeterministicFiniteAutomaton() symb_a = Symbol('a') symb_b = Symbol("b") symb_star = Symbol("star") states = [State(x) for x in range(9)] dfa.add_start_state(states[0]) dfa.add_final_state(states[3]) dfa.add_final_state(states[4]) dfa.add_final_state(states[7]) dfa.add_final_state(states[8]) dfa.add_transition(states[0], symb_a, states[1]) dfa.add_transition(states[1], symb_star, states[2]) dfa.add_transition(states[2], symb_a, states[3]) dfa.add_transition(states[3], symb_star, states[4]) dfa.add_transition(states[3], symb_a, states[1]) dfa.add_transition(states[3], symb_b, states[5]) dfa.add_transition(states[4], symb_a, states[1]) dfa.add_transition(states[4], symb_b, states[5]) dfa.add_transition(states[0], symb_b, states[5]) dfa.add_transition(states[5], symb_star, states[6]) dfa.add_transition(states[6], symb_b, states[7]) dfa.add_transition(states[7], symb_star, states[8]) dfa.add_transition(states[7], symb_a, states[1]) dfa.add_transition(states[7], symb_b, states[5]) dfa.add_transition(states[8], symb_a, states[1]) dfa.add_transition(states[8], symb_b, states[5]) dfa = dfa.minimize() self.assertTrue(dfa.accepts([symb_a, symb_star, symb_a]))
def test_profiling_intersection(self): size = 3 states = [State(i) for i in range(size * 2 + 1)] symb_a = Symbol("a") symb_b = Symbol("b") dfa = DeterministicFiniteAutomaton(states, {symb_a, symb_b}, start_state=states[0], final_states={states[-1]}) for i in range(size): dfa.add_transition(states[i], symb_a, states[i + 1]) for i in range(size, size * 2): dfa.add_transition(states[i], symb_b, states[i + 1]) ter_a = Terminal("a") ter_b = Terminal("b") var_s = Variable("S") var_s1 = Variable("S1") var_l = Variable("L") productions = [ Production(var_s, [var_l, var_s1]), Production(var_l, [Epsilon()]), Production(var_s1, [ter_a, var_s1, ter_b]), Production(var_s1, [ter_b, var_s1, ter_a]), Production(var_s1, []) ] cfg = CFG(productions=productions, start_symbol=var_s) cfg_i = cfg.intersection(dfa) self.assertFalse(cfg_i.is_empty()) self.assertTrue(cfg_i.contains([ter_a] * size + [ter_b] * size)) self.assertFalse(cfg_i.contains([]))
def test_intersection_dfa2(self): state0 = State(0) symb_a = Symbol("a") symb_b = Symbol("b") dfa = DeterministicFiniteAutomaton({state0}, {symb_a, symb_b}, start_state=state0, final_states={state0}) dfa.add_transition(state0, symb_a, state0) dfa.add_transition(state0, symb_b, state0) self.assertTrue(dfa.accepts([symb_a, symb_a, symb_b, symb_b])) ter_a = Terminal("a") ter_b = Terminal("b") var_s = Variable("S") var_s1 = Variable("S1") var_l = Variable("L") productions = { Production(var_s, [var_l, var_s1]), Production(var_l, [Epsilon()]), Production(var_s1, [ter_a, var_s1, ter_b]), Production(var_s1, [ter_b, var_s1, ter_a]), Production(var_s1, []) } cfg = CFG(productions=productions, start_symbol=var_s) self.assertTrue(cfg.contains([ter_a, ter_a, ter_b, ter_b])) self.assertFalse(cfg.contains([ter_a, ter_a, ter_b])) cfg_i = cfg.intersection(dfa) self.assertFalse(cfg_i.is_empty()) self.assertTrue(cfg_i.contains([ter_a, ter_a, ter_b, ter_b])) self.assertTrue(cfg_i.contains([]))
def test_accepts(self): """ Tests the acceptance of nfa """ nfa = NondeterministicFiniteAutomaton() state0 = State(0) state1 = State(1) state2 = State(2) state3 = State(3) state4 = State(4) symb_a = Symbol("a") symb_b = Symbol("b") symb_c = Symbol("c") symb_d = Symbol("d") nfa.add_start_state(state0) nfa.add_final_state(state4) nfa.add_final_state(state3) nfa.add_transition(state0, symb_a, state1) nfa.add_transition(state1, symb_b, state1) nfa.add_transition(state1, symb_c, state2) nfa.add_transition(state1, symb_d, state3) nfa.add_transition(state1, symb_c, state4) nfa.add_transition(state1, symb_b, state4) self.assertFalse(nfa.is_deterministic()) self.assertTrue(nfa.accepts([symb_a, symb_b, symb_c])) self.assertTrue(nfa.accepts([symb_a, symb_b, symb_b, symb_b, symb_c])) self.assertTrue(nfa.accepts([symb_a, symb_b, symb_d])) self.assertTrue(nfa.accepts([symb_a, symb_d])) self.assertTrue(nfa.accepts([symb_a, symb_b, symb_b, symb_b, symb_b])) self.assertFalse(nfa.accepts([symb_a, symb_c, symb_d])) self.assertFalse(nfa.accepts([symb_d, symb_c, symb_d])) self.assertFalse(nfa.accepts([])) self.assertFalse(nfa.accepts([symb_c])) nfa.add_start_state(state1) self.assertFalse(nfa.is_deterministic()) self.assertTrue(nfa.accepts([symb_c])) nfa.remove_start_state(state1) dfa = nfa.to_deterministic() self.assertTrue(dfa.is_deterministic()) self.assertTrue(dfa.accepts([symb_a, symb_b, symb_c])) self.assertTrue(dfa.accepts([symb_a, symb_b, symb_b, symb_b, symb_c])) self.assertTrue(dfa.accepts([symb_a, symb_b, symb_d])) self.assertTrue(dfa.accepts([symb_a, symb_d])) self.assertTrue(dfa.accepts([symb_a, symb_b, symb_b, symb_b, symb_b])) self.assertFalse(dfa.accepts([symb_a, symb_c, symb_d])) self.assertFalse(dfa.accepts([symb_d, symb_c, symb_d])) self.assertFalse(dfa.accepts([])) self.assertFalse(dfa.accepts([symb_c]))
def test_add_transitions(self): """ Tests the addition of transitions """ transition_function = TransitionFunction() s_from = State(10) s_to = State(11) s_to_bis = State(2) symb_by = Symbol("abc") transition_function.add_transition(s_from, symb_by, s_to) transition_function.add_transition(s_from, symb_by, s_to) with self.assertRaises(DuplicateTransitionError) as dte: transition_function.add_transition(s_from, symb_by, s_to_bis) dte = dte.exception self.assertEqual(dte.s_from, s_from) self.assertEqual(dte.s_to, s_to_bis) self.assertEqual(dte.symb_by, symb_by) self.assertEqual(dte.s_to_old, s_to)
def test_creation(self): """ Test the creation of nfa """ nfa = NondeterministicFiniteAutomaton() self.assertIsNotNone(nfa) states = [State(x) for x in range(10)] nfa = NondeterministicFiniteAutomaton(start_state=states) self.assertIsNotNone(nfa)
def test_deterministic(self): """ Tests the deterministic transformation """ nfa = NondeterministicFiniteAutomaton() state0 = State("q0") state1 = State("q1") state2 = State("q2") symb0 = Symbol(0) symb1 = Symbol(1) nfa.add_start_state(state0) nfa.add_final_state(state1) nfa.add_transition(state0, symb0, state0) nfa.add_transition(state0, symb0, state1) nfa.add_transition(state0, symb1, state0) nfa.add_transition(state1, symb1, state2) dfa = nfa.to_deterministic() self.assertEqual(len(dfa.states), 3) self.assertEqual(dfa.get_number_transitions(), 6)
def test_check_intersection(): # Declare NFAs enfa0 = EpsilonNFA() enfa1 = EpsilonNFA() # Declare the states states = [State("q" + str(x)) for x in range(7)] # Declare the symbols epsilon = Epsilon() symb_a = Symbol("a") symb_b = Symbol("b") symb_c = Symbol("c") # epsilonNFA 0 # Add a start state enfa0.add_start_state(states[0]) # Add a final state enfa0.add_final_state(states[1]) # Add the transitions enfa0.add_transition(states[0], symb_a, states[1]) enfa0.add_transition(states[1], symb_a, states[1]) # epsilonNFA 1 # Add a start states enfa1.add_start_state(states[0]) enfa1.add_final_state(states[4]) # Add a final states enfa1.add_final_state(states[5]) enfa1.add_final_state(states[6]) # Add the transitions enfa1.add_transition(states[0], symb_a, states[1]) enfa1.add_transition(states[0], symb_b, states[2]) enfa1.add_transition(states[0], symb_c, states[3]) enfa1.add_transition(states[1], symb_a, states[4]) enfa1.add_transition(states[2], symb_b, states[5]) enfa1.add_transition(states[3], symb_c, states[6]) # Now enfa0 accepts a* \ {epsilon} # enfa1 accepts aa, bb, cc # Intersection of enfa0 and enfa1 enfa_res = enfa0.get_intersection(enfa1) # Check if a word is accepted assert enfa_res.accepts([symb_a, symb_a]), "Should accept aa" # Check non-correct words assert not enfa_res.accepts([epsilon]), "Accepts empty word, but it mustn't" assert not enfa_res.accepts([symb_a, symb_a, symb_a]), "Accepts aaa, but it mustn't" assert not enfa_res.accepts([symb_a]), "Accepts a, but it mustn't" assert not enfa_res.accepts([symb_b, symb_b]), "Accepts bb, but it mustn't" assert not enfa_res.accepts([symb_c, symb_c]), "Accepts cc, but it mustn't"
def get_example_non_minimal(): """ A non minimal example a.a*.b""" enfa0 = EpsilonNFA() state0 = State(0) state3 = State(3) state4 = State(4) state5 = State(5) state6 = State(6) state1 = State(1) state2 = State(2) symb_a = Symbol("a") symb_b = Symbol("b") enfa0.add_start_state(state0) enfa0.add_final_state(state3) enfa0.add_final_state(state4) enfa0.add_transition(state0, symb_a, state1) enfa0.add_transition(state1, symb_a, state2) enfa0.add_transition(state2, symb_a, state5) enfa0.add_transition(state5, symb_a, state6) enfa0.add_transition(state6, symb_a, state1) enfa0.add_transition(state1, symb_b, state3) enfa0.add_transition(state2, symb_b, state4) enfa0.add_transition(state5, symb_b, state3) enfa0.add_transition(state6, symb_b, state4) return enfa0
def test_number_transitions(self): """ Tests the number of transitions """ transition_function = TransitionFunction() self.assertEqual(transition_function.get_number_transitions(), 0) s_from = State(110) s_to = State(12) s_to_bis = State(2) symb_by = Symbol("a") transition_function.add_transition(s_from, symb_by, s_to) self.assertEqual(transition_function.get_number_transitions(), 1) transition_function.add_transition(s_from, symb_by, s_to) self.assertEqual(transition_function.get_number_transitions(), 1) symb_by2 = Symbol("bc") transition_function.add_transition(s_from, symb_by2, s_to_bis) self.assertEqual(transition_function.get_number_transitions(), 2) transition_function.add_transition(s_to, symb_by, s_to_bis) self.assertEqual(transition_function.get_number_transitions(), 3)
def test_complement(self): """ Tests the complement operation """ dfa = DeterministicFiniteAutomaton() symb_a = Symbol("a") symb_b = Symbol("b") state0 = State(0) state1 = State(1) state2 = State(2) dfa.add_start_state(state0) dfa.add_final_state(state2) dfa.add_transition(state0, symb_a, state1) dfa.add_transition(state1, symb_b, state2) dfa_comp = dfa.get_complement() self.assertTrue(dfa_comp.accepts([symb_a])) self.assertTrue(dfa_comp.accepts([symb_b])) self.assertTrue(dfa_comp.accepts([symb_b, symb_a])) self.assertTrue(dfa_comp.accepts([])) self.assertFalse(dfa_comp.accepts([symb_a, symb_b]))
def to_automaton(self): nfa = EpsilonNFA() matrices = self.adj_matrices for start_state in self.start_states: nfa.add_start_state(State(start_state)) for final_state in self.final_states: nfa.add_final_state(State(final_state)) for word in matrices.keys(): matrix = matrices[word] symb = Symbol(word) for row, col in zip(matrix.rows, matrix.cols): nfa.add_transition(State(row), symb, State(col)) return nfa
def test_2(self): ndfa = NondeterministicFiniteAutomaton() state0 = State(0) state1 = State(1) state2 = State(2) state3 = State(3) ndfa.add_start_state(state0) ndfa.add_final_state(state2) ndfa.add_final_state(state3) ndfa.add_transition(state0, self.symb_a, state1) ndfa.add_transition(state1, self.symb_b, state2) ndfa.add_transition(state1, self.symb_c, state3) self.run_test(2, ndfa=ndfa, starts_spec=True, ans_spec=True)
def test_big_minimize_reduce(self): dfa = DeterministicFiniteAutomaton() symb_0 = Symbol("0") symb_0_minus = Symbol("0-") symb_1 = Symbol("1") symb_1_minus = Symbol("1-") symb_star = Symbol("STAR") start = State("start") states = [State(str(x)) for x in range(10)] dfa.add_start_state(start) dfa.add_final_state(states[2]) dfa.add_final_state(states[3]) dfa.add_final_state(states[4]) dfa.add_final_state(states[8]) dfa.add_final_state(states[7]) dfa.add_final_state(states[9]) dfa.add_transition(start, symb_0, states[0]) dfa.add_transition(states[1], symb_0, states[2]) dfa.add_transition(states[2], symb_0, states[0]) dfa.add_transition(states[3], symb_0, states[0]) dfa.add_transition(states[4], symb_0, states[0]) dfa.add_transition(states[8], symb_0, states[0]) dfa.add_transition(states[7], symb_0, states[0]) dfa.add_transition(states[9], symb_0, states[0]) dfa.add_transition(states[0], symb_star, states[1]) dfa.add_transition(states[5], symb_star, states[6]) dfa.add_transition(states[7], symb_star, states[9]) dfa.add_transition(states[2], symb_star, states[3]) dfa.add_transition(states[4], symb_star, states[8]) dfa.add_transition(states[1], symb_0_minus, states[5]) dfa.add_transition(states[6], symb_0_minus, states[7]) dfa.add_transition(states[3], symb_1_minus, states[4]) self.assertFalse( dfa.accepts([ "0", "STAR", "0-", "STAR", "0-", "0", "STAR", "0", "0", "STAR", "0-", "STAR", "0-", "1-" ])) dfa = dfa.minimize() self.assertFalse( dfa.accepts([ "0", "STAR", "0-", "STAR", "0-", "0", "STAR", "0", "0", "STAR", "0-", "STAR", "0-", "1-" ]))
def get_example0(): """ Gives a dfa """ dfa = DeterministicFiniteAutomaton() state0 = State(0) state1 = State(1) state2 = State(2) state3 = State(3) symb_a = Symbol("a") symb_b = Symbol("b") symb_c = Symbol("c") symb_d = Symbol("d") dfa.add_start_state(state0) dfa.add_final_state(state2) dfa.add_final_state(state3) dfa.add_transition(state0, symb_a, state1) dfa.add_transition(state1, symb_b, state1) dfa.add_transition(state1, symb_c, state2) dfa.add_transition(state1, symb_d, state3) return dfa
def get_dfa_from_functions(functions, query): transition_function, states, symbols, final_states = get_transition_function_and_states_and_symbols( functions, query) nfa = NondeterministicFiniteAutomaton(states, symbols, transition_function, {State("Start")}, final_states) dfa = nfa.to_deterministic() #print("We have:", dfa.get_number_states(), "states") #print("Minimize") dfa = dfa.minimize() return dfa
def test_export_networkx(self): enfa = EpsilonNFA() state0 = State("0") state1 = State(1) symb_a = Symbol('a') enfa.add_start_state(state0) enfa.add_final_state(state1) enfa.add_transition(state0, symb_a, state1) enfa.add_transition(state1, Epsilon(), state0) graph = enfa.to_networkx() self.assertTrue(isinstance(graph, networkx.MultiDiGraph)) self.assertTrue("0" in graph) self.assertTrue(("0", 1) in graph.edges) self.assertIn("a", [x["label"] for x in graph["0"][1].values()]) self.assertTrue(graph.nodes["0"]["is_start"]) self.assertFalse(graph.nodes["0"]["is_final"]) self.assertFalse(graph.nodes[1]["is_start"]) self.assertTrue(graph.nodes[1]["is_final"]) enfa.write_as_dot("enfa.dot")
def test_remove_state(self): " Tests the remove of state " "" enfa = EpsilonNFA() state0 = State(0) state1 = State(1) state2 = State(2) symb02 = Symbol("a+b") symb01 = Symbol("c*") symb11 = Symbol("b+(c.d)") symb12 = Symbol("a.b.c") enfa.add_start_state(state0) enfa.add_final_state(state2) enfa.add_transition(state0, symb01, state1) enfa.add_transition(state0, symb02, state2) enfa.add_transition(state1, symb11, state1) enfa.add_transition(state1, symb12, state2) enfa.remove_all_basic_states() self.assertEqual(enfa.get_number_transitions(), 1) self.assertEqual(len(enfa.states), 2)
def test_pda_intersection(): dfa_1 = DeterministicFiniteAutomaton() dfa_2 = DeterministicFiniteAutomaton() dfa = DeterministicFiniteAutomaton() # Creation of the states state0 = State(0) state1 = State(1) state2 = State(2) state3 = State(3) # Creation of the symbols symb_a = Symbol("a") symb_b = Symbol("b") symb_c = Symbol("c") symb_d = Symbol("d") # Add a start state dfa_1.add_start_state(state0) dfa_2.add_start_state(state0) # Add two final states dfa_1.add_final_state(state2) dfa_1.add_final_state(state3) dfa_2.add_final_state(state2) # Create transitions dfa_1.add_transition(state0, symb_a, state1) dfa_1.add_transition(state1, symb_b, state1) dfa_1.add_transition(state1, symb_c, state2) dfa_1.add_transition(state1, symb_d, state3) dfa_2.add_transition(state0, symb_a, state1) dfa_2.add_transition(state1, symb_b, state1) dfa_2.add_transition(state1, symb_c, state2) dfa_2.add_transition(state0, symb_d, state1) # Check if a word is accepted dfa = dfa_1 & dfa_2 assert dfa.accepts([symb_a, symb_b, symb_c]) assert dfa.accepts([symb_a, symb_b, symb_b, symb_c]) assert not dfa.accepts([symb_a, symb_b, symb_d]) assert not dfa.accepts([symb_d, symb_b, symb_c])
def get_transition_function_and_states_and_symbols(functions, query): states = set() symbols = set() start_state = State("Start") states.add(start_state) final_states_intermediate = set() final_states = set() counter = 0 transition_function = NondeterministicTransitionFunction() linear_paths = get_all_linear_paths(functions) linear_paths = sorted(linear_paths, key=len) # Need to sort by length here all_starting = set() for linear_path in linear_paths: current_state = start_state last_is_final = False last_atom = "" for i, atom in enumerate(linear_path): symbol = Symbol(atom) symbols.add(symbol) last_is_final = current_state in final_states_intermediate or current_state == start_state last_atom = atom next_states = transition_function(current_state, symbol) if next_states: current_state = list(next_states)[0] else: next_state = State(str(counter)) counter += 1 transition_function.add_transition(current_state, symbol, next_state) current_state = next_state if i == 0: all_starting.add((current_state, symbol)) final_states_intermediate.add(current_state) if last_is_final and (last_atom == query or last_atom == get_inverse_relation(query)): final_states.add(current_state) for final_state in final_states_intermediate: for state, symbol in all_starting: transition_function.add_transition(final_state, symbol, state) return transition_function, states, symbols, final_states
def test_remove_transitions(self): """ Tests the removal of transitions """ transition_function = NondeterministicTransitionFunction() s_from = State(0) s_to = State(1) symb_by = Symbol("a") transition_function.add_transition(s_from, symb_by, s_to) self.assertEqual( transition_function.remove_transition(s_from, symb_by, s_to), 1) self.assertEqual(transition_function.get_number_transitions(), 0) self.assertEqual(len(transition_function(s_to, symb_by)), 0) self.assertEqual(len(transition_function(s_from, symb_by)), 0) self.assertEqual( transition_function.remove_transition(s_from, symb_by, s_to), 0) transition_function.add_transition(s_from, symb_by, s_to) transition_function.add_transition(s_from, symb_by, s_from) self.assertEqual( transition_function.remove_transition(s_from, symb_by, s_to), 1) self.assertEqual(transition_function.get_number_transitions(), 1) self.assertEqual(len(transition_function(s_from, symb_by)), 1)
def get_enfa_example0_bis(): """ A non minimal NFA, equivalent to example0 """ enfa0 = EpsilonNFA() state3 = State(3) state4 = State(4) state0 = State(0) state1 = State(1) state2 = State(2) symb_a = Symbol("a") symb_b = Symbol("b") enfa0.add_start_state(state0) enfa0.add_final_state(state2) enfa0.add_final_state(state4) enfa0.add_transition(state0, symb_a, state0) enfa0.add_transition(state0, Epsilon(), state1) enfa0.add_transition(state1, symb_b, state2) # New part enfa0.add_transition(state0, Epsilon(), state3) enfa0.add_transition(state3, symb_a, state3) enfa0.add_transition(state3, symb_b, state4) return enfa0
def graph_to_dfa(g: Graph): nfa = EpsilonNFA() state_count = 0 for tup in g: sub, pred, obj = map(str, tup) # nfa.add_transition(State(sub), Symbol(pred), State(obj)) nfa.add_start_state(State(sub)) nfa.add_start_state(State(obj)) nfa.add_final_state(State(sub)) nfa.add_final_state(State(obj)) nfa.add_transition(State(sub), Epsilon(), State(state_count)) for c in pred: nfa.add_transition(State(state_count), Symbol(c), State(state_count+1)) state_count += 1 nfa.add_transition(State(state_count), Epsilon(), State(obj)) return nfa.to_deterministic()
def test_enfa_intersection(): # Building example automatons enfa0 = EpsilonNFA() state0 = State(0) state1 = State(1) state2 = State(2) symb_a = Symbol("a") symb_b = Symbol("b") symb_c = Symbol("c") enfa0.add_start_state(state0) enfa0.add_final_state(state2) enfa0.add_transition(state0, symb_a, state0) enfa0.add_transition(state0, symb_b, state1) enfa0.add_transition(state1, symb_c, state2) enfa1 = EpsilonNFA() state3 = State(3) state4 = State(4) state5 = State(5) enfa1.add_start_state(state3) enfa1.add_final_state(state5) enfa1.add_transition(state3, symb_a, state4) enfa1.add_transition(state4, symb_b, state5) enfa1.add_transition(state5, symb_c, state5) # getting intersection enfa = enfa0 & enfa1 assert not enfa.accepts([symb_b]) assert not enfa.accepts([symb_a]) assert not enfa.accepts([]) assert not enfa.accepts([symb_a, symb_a, symb_b, symb_c]) assert not enfa.accepts([symb_a, symb_b, symb_c, symb_c]) assert enfa.accepts([symb_a, symb_b, symb_c])
def test_can_create(self): """ Test the creation of dfa """ state0 = State("0") state1 = State("1") symb0 = Symbol("a") states = {state0, state1} input_symbols = {symb0} transition_function = TransitionFunction() transition_function.add_transition(state0, symb0, state1) start_state = state0 final_states = {state1} dfa = DeterministicFiniteAutomaton(states, input_symbols, transition_function, start_state, final_states) self.assertIsNotNone(dfa) dfa = DeterministicFiniteAutomaton() self.assertIsNotNone(dfa) dfa = DeterministicFiniteAutomaton(start_state=state1, final_states={state0, state1}) self.assertIsNotNone(dfa) self.assertTrue(dfa is dfa.to_deterministic())
def to_nfa(self, start_states: Indices, final_states: Indices): self.start_states = start_states self.final_states = final_states nfa = NondeterministicFiniteAutomaton() states = [State(idx) for idx in range(self.vertices_num)] symbols = {label: Symbol(label) for label in self.label_to_bool_matrix} for start_idx in start_states: nfa.add_start_state(states[start_idx]) for end_idx in final_states: nfa.add_final_state(states[end_idx]) for label, matrix in self.label_to_bool_matrix.items(): for i, j, _ in zip(*matrix.to_lists()): nfa.add_transition(states[i], symbols[label], states[j]) return nfa
def test_to_regex2(self): """ Tests the transformation to regex """ enfa = EpsilonNFA() state0 = State(0) state1 = State(1) symb_a = Symbol("0") symb_b = Symbol("1") enfa.add_start_state(state0) enfa.add_final_state(state1) enfa.add_transition(state0, symb_a, state0) enfa.add_transition(state0, symb_a, state1) enfa.add_transition(state1, symb_b, state0) enfa.add_transition(state1, symb_b, state1) regex = enfa.to_regex() enfa2 = regex.to_epsilon_nfa() self.assertTrue(enfa2.accepts([symb_a])) self.assertTrue(enfa2.accepts([symb_a, symb_a])) self.assertTrue(enfa2.accepts([symb_a, symb_a, symb_b])) self.assertTrue(enfa2.accepts([symb_a, symb_a, symb_b, symb_b])) self.assertTrue(enfa2.accepts([symb_a, symb_a, symb_b, symb_b, symb_a])) self.assertTrue( enfa2.accepts([symb_a, symb_a, symb_b, symb_b, symb_a, symb_b])) self.assertFalse(enfa2.accepts([symb_b]))
def to_dfa(self): dfa = DeterministicFiniteAutomaton() states = [State(i) for i in range(self.n_vertices)] for i in self.start_vertices: dfa.add_start_state(states[i]) for i in self.terminal_vertices: dfa.add_final_state(states[i]) for label in self.labels(): symbol = Symbol(label) fro, to, has_edge = self.get_by_label(label).to_lists() for i in range(len(fro)): if has_edge: dfa.add_transition(states[fro[i]], symbol, states[to[i]]) return dfa
def to_dfa(self): edges = list(zip(*self.matrix.to_lists())) dfa = DeterministicFiniteAutomaton() # Creation of the states state_vals = range(self.matrix.ncols) state_dict = {} for value in state_vals: state_dict[value] = State(value) for value in self.start_states: dfa.add_start_state(state_dict[value]) for value in self.final_states: dfa.add_final_state(state_dict[value]) # Create transitions for s, p, o in edges: dfa.add_transition(state_dict[s], Symbol(p), state_dict[o]) return dfa