def test_complete():
a = Symbol('a')
b = Symbol('b')
A = State('A')
B = State('B')
transitions = {
(A, a): {A},
(A, b): {B},
}
fa = FiniteAutomaton(transitions, A, {B})
fa.complete()
def test_evaluate():
a = Symbol('a')
A, B = State('A'), State('B')
transitions = {
(A, a): {B},
(B, a): {A},
}
fa = FiniteAutomaton(transitions, A, {A})
assert not fa.evaluate(Sentence('aaa'))
assert fa.evaluate(Sentence(''))
assert fa.evaluate(Sentence('aa'))
def test_copy():
a, b = Symbol('a'), Symbol('b')
A, B = State('A'), State('B')
transitions = {
(A, a): {B},
(A, b): {A},
(B, a): {A},
(B, b): {B},
}
fa1 = FiniteAutomaton(transitions, A, {A})
fa2 = fa1.copy()
assert fa1 is not fa2
def test_fa_save_load():
zero = Symbol('0')
one = Symbol('1')
Q0 = State('Q0')
Q1 = State('Q1')
Q2 = State('Q2')
fa = FiniteAutomaton(
{
(Q0, zero): [Q0],
(Q0, one): [Q1],
(Q1, zero): [Q2],
(Q1, one): [Q0],
(Q2, zero): [Q1],
(Q2, one): [Q2],
},
Q0,
[Q0],
)
path = fa_to_file(fa, 'test')
new_fa = fa_from_file(str(path))
assert fa == new_fa
path.unlink()
def test_concatenate():
a = Symbol('a')
A = State('A')
B = State('B')
fa_1 = FiniteAutomaton({(A, a): B}, A, {B})
C = State('C')
D = State('D')
fa_2 = FiniteAutomaton({(C, a): D}, C, {D})
fa_concat = FiniteAutomaton.concatenate(fa_1, fa_2)
assert not fa_concat.evaluate(Sentence(''))
assert not fa_concat.evaluate(Sentence('a'))
assert fa_concat.evaluate(Sentence('aa'))
assert not fa_concat.evaluate(Sentence('aaa'))
def fa_from_file(filename: str) -> FiniteAutomaton:
with find_file(filename, 'fa').open() as f:
fa = load(f)
transitions = {(t['previous_state'], Symbol(t['symbol'])):
t['next_states']
for t in fa['transitions']}
return FiniteAutomaton(transitions, fa['initial_state'],
fa['accept_states'])
def test_remove_unreachable():
a = Symbol('a')
b = Symbol('b')
A = State('A')
B = State('B')
C = State('C')
D = State('D')
E = State('E')
F = State('F')
G = State('G')
H = State('H')
transitions = {
(A, a): {G},
(A, b): {B},
(B, a): {F},
(B, b): {E},
(C, a): {C},
(C, b): {G},
(D, a): {A},
(D, b): {H},
(E, a): {E},
(E, b): {A},
(F, a): {B},
(F, b): {C},
(G, a): {G},
(G, b): {F},
(H, a): {H},
(H, b): {D},
}
fa = FiniteAutomaton(transitions, A, [A, D, G])
fa.remove_unreachable_states()
assert len(fa.states) == 6
def handle(self):
a = Symbol('a')
b = Symbol('b')
Q0 = State('Q0')
fa = FiniteAutomaton(
{
(Q0, a): [Q0],
(Q0, b): [Q0],
},
Q0,
[Q0],
)
write_file_and_print_table(self, fa, self.argument('out'))
def test_union():
a, b = Symbol('a'), Symbol('b')
A, B = State('A'), State('B')
fa_1 = FiniteAutomaton({(A, a): B}, A, {B})
C, D = State('C'), State('D')
fa_2 = FiniteAutomaton({(C, b): D}, C, {D})
fa_union = FiniteAutomaton.union(fa_1, fa_2)
assert not fa_1.evaluate(Sentence('b'))
assert not fa_2.evaluate(Sentence('a'))
assert fa_union.evaluate(Sentence('a'))
assert fa_union.evaluate(Sentence('b'))
assert not fa_union.evaluate(Sentence(''))
assert not fa_union.evaluate(Sentence('ab'))
assert not fa_union.evaluate(Sentence('ba'))
def write_file_and_print_table(cmd: Command, fa: FiniteAutomaton,
out: Optional[str]):
alphabet = sorted(fa.alphabet)
transitions = []
for state in sorted(fa.states):
line = [str_prev_state(state, fa)]
for symbol in alphabet:
new_state = fa.transitate(state, symbol)
line.append(str_set_of_states(new_state))
transitions.append(line)
cmd.render_table(
['K \ Σ', *[str(s) for s in alphabet]],
transitions,
)
if out is not None:
path = fa_to_file(fa, out)
cmd.info('Wrote finite automaton to {}'.format(path))
def test_negate():
a = Symbol('a')
b = Symbol('b')
A = State('A')
B = State('B')
transitions = {
(A, a): {A},
(A, b): {B},
}
fa = FiniteAutomaton(transitions, A, {B})
assert not fa.evaluate(Sentence(''))
assert not fa.evaluate(Sentence('aaa'))
assert fa.evaluate(Sentence('ab'))
n_fa = fa.negate()
assert n_fa.evaluate(Sentence(''))
assert n_fa.evaluate(Sentence('aaa'))
assert not n_fa.evaluate(Sentence('ab'))