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
