def validar(sets, tipo):
if tipo == False:
aux = list(sets[2].values())
for i in range(len(sets[0])):
if '' in aux[i].values() or not sets[4]:
return False
automata = DFA(states=sets[0],
input_symbols=sets[1],
transitions=sets[2],
initial_state=sets[3],
final_states=sets[4])
else:
if sets[4]:
automata = NFA(states=sets[0],
input_symbols=sets[1],
transitions=sets[2],
initial_state=sets[3],
final_states=sets[4])
else:
return False
if automata.validate():
del automata
return True
else:
del automata
return False
def evaluateNFA():
print("Eval NFA")
# NFA which matches strings beginning with 'a', ending with 'a', and containing
# no consecutive 'b's
value = str(mainWidget.lineEdit_eval.text())
nfa = NFA(
# states=getStates(),
# input_symbols=symbols,
# transitions={
# 'q0': {'a': {'q1'}},
# # Use '' as the key name for empty string (lambda/epsilon) transitions
# 'q1': {'a': {'q1'}, '': {'q2'}},
# 'q2': {'b': {'q0'}}
# },
# initial_state='q0',
# final_states={'q1'}
states=getStates(),
input_symbols=symbols,
transitions=getNFATransitions(),
initial_state=str(startNode.label.text()),
final_states=getFinalStates())
try:
listStates = list(nfa.validate_input(value, step=True))
print(str(listStates))
showMsg("NFA Successful, Last:" + str(nfa.validate_input(value)))
except:
showMsg("ERROR EVALUATING NFA")
return nfa
def __init__(
self,
nfa: NFA = None,
*,
states: set = None,
input_symbols: set = None,
transitions: dict = None,
initial_state: str = None,
final_states: set = None,
):
if nfa:
self.nfa = nfa.copy()
else:
if not states:
states = {*transitions.keys()}
if not input_symbols:
input_symbols = set()
for v in transitions.values():
symbols = [*v.keys()]
for symbol in symbols:
if symbol != "":
input_symbols.add(symbol)
self.nfa = NFA(
states=states.copy(),
input_symbols=input_symbols.copy(),
transitions=transitions.deepcopy(),
initial_state=initial_state,
final_states=final_states.copy(),
)
self.nfa.validate()
def test_init_nfa_more_complex(self):
"""Should convert to a DFA a more complex NFA."""
nfa = NFA(
states={'q0', 'q1', 'q2'},
input_symbols={'0', '1'},
transitions={
'q0': {'0': {'q0', 'q1'}, '1': {'q0'}},
'q1': {'0': {'q1'}, '1': {'q2'}},
'q2': {'0': {'q2'}, '1': {'q1'}}
},
initial_state='q0',
final_states={'q2'}
)
dfa = DFA.from_nfa(nfa)
nose.assert_equal(dfa.states, {
'{q0}', '{q0,q1}', '{q0,q2}', '{q0,q1,q2}'
})
nose.assert_equal(dfa.input_symbols, {'0', '1'})
nose.assert_equal(dfa.transitions, {
'{q0}': {'1': '{q0}', '0': '{q0,q1}'},
'{q0,q1}': {'1': '{q0,q2}', '0': '{q0,q1}'},
'{q0,q2}': {'1': '{q0,q1}', '0': '{q0,q1,q2}'},
'{q0,q1,q2}': {'1': '{q0,q1,q2}', '0': '{q0,q1,q2}'}
})
nose.assert_equal(dfa.initial_state, '{q0}')
nose.assert_equal(dfa.final_states, {'{q0,q1,q2}', '{q0,q2}'})
def parseFA(fileJFLAP, prefix):
# create tree object
automataTree = ET.parse(fileJFLAP)
# parse states
parsedStates = parseStates(automataTree, prefix)
# parse alphabet
parsedAlphabet = parseAlphabet(automataTree)
# parse transitions
parsedTransitions = parseTransitions(automataTree, parsedStates, prefix)
# parse initial state
parsedInitial = parseInitialState(automataTree, prefix)
# parse final states
parsedFinals = parseFinalStates(automataTree, prefix)
# build NFA
nfa = NFA(
states = parsedStates,
input_symbols = parsedAlphabet,
transitions = parsedTransitions,
initial_state = parsedInitial,
final_states = parsedFinals
)
return nfa
def test_kleene_star(self):
# This NFA accepts aa and ab
nfa = NFA(
states={0, 1, 2, 3, 4, 6},
input_symbols={'a', 'b'},
transitions={
0: {'a': {1, 3}},
1: {'b': {2}},
2: {},
3: {'a': {4}},
4: {'': {6}},
6: {}
},
initial_state=0,
final_states={2, 4, 6}
)
# This NFA should then accept any number of repetitions
# of aa or ab concatenated together.
kleene_nfa = nfa.kleene_star()
self.assertEqual(kleene_nfa.accepts_input(''), True)
self.assertEqual(kleene_nfa.accepts_input('a'), False)
self.assertEqual(kleene_nfa.accepts_input('b'), False)
self.assertEqual(kleene_nfa.accepts_input('aa'), True)
self.assertEqual(kleene_nfa.accepts_input('ab'), True)
self.assertEqual(kleene_nfa.accepts_input('ba'), False)
self.assertEqual(kleene_nfa.accepts_input('bb'), False)
self.assertEqual(kleene_nfa.accepts_input('aaa'), False)
self.assertEqual(kleene_nfa.accepts_input('aba'), False)
self.assertEqual(kleene_nfa.accepts_input('abaa'), True)
self.assertEqual(kleene_nfa.accepts_input('abba'), False)
self.assertEqual(kleene_nfa.accepts_input('aaabababaaaaa'), False)
self.assertEqual(kleene_nfa.accepts_input('aaabababaaaaab'), True)
self.assertEqual(kleene_nfa.accepts_input('aaabababaaaaba'), False)
def parse_json(json_string, is_deterministic):
fsm = json.loads(json_string)
try:
states, final_states, node_map = get_states(fsm)
input_symbols = get_alphabet(fsm, is_deterministic)
if is_deterministic:
initial_state, transitions = \
get_DFA_transitions(fsm, states, node_map, input_symbols)
else:
initial_state, transitions = \
get_NFA_transitions(fsm, states, node_map, input_symbols)
except Exception as e:
return True, str(e)
if is_deterministic:
fsm = DFA(states=states,
input_symbols=input_symbols,
transitions=transitions,
initial_state=initial_state,
final_states=final_states)
else:
fsm = NFA(states=states,
input_symbols=input_symbols,
transitions=transitions,
initial_state=initial_state,
final_states=final_states)
return False, fsm
def main():
nfa = NFA( # this code builds the weakly divisible by 7 NFA
states={'start_state', 'q0', 'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q0prime', 'q1prime', 'q2prime', 'q3prime',
'q4prime', 'q5prime', 'q6prime', 'fail_state'},
input_symbols={'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'},
transitions={
'start_state': {'0': {'fail_state'}, '1': {'q1', 'q0prime'}, '2': {'q2', 'q0prime'}, '3': {'q3', 'q0prime'},
'4': {'q4', 'q0prime'}, '5': {'q5', 'q0prime'}, '6': {'q6', 'q0prime'},
'7': {'q0', 'q0prime'},
'8': {'q1', 'q0prime'}, '9': {'q2', 'q0prime'}},
'fail_state': {'0': {'fail_state'}, '1': {'fail_state'}, '2': {'fail_state'}, '3': {'fail_state'},
'4': {'fail_state'}, '5': {'fail_state'}, '6': {'fail_state'}, '7': {'fail_state'},
'8': {'fail_state'}, '9': {'fail_state'}},
'q0': {'0': {'q0', 'q0prime'}, '1': {'q1', 'q0prime'}, '2': {'q2', 'q0prime'}, '3': {'q3', 'q0prime'},
'4': {'q4', 'q0prime'}, '5': {'q5', 'q0prime'}, '6': {'q6', 'q0prime'}, '7': {'q0', 'q0prime'},
'8': {'q1', 'q0prime'}, '9': {'q2', 'q0prime'}},
'q1': {'0': {'q3', 'q1prime'}, '1': {'q4', 'q1prime'}, '2': {'q5', 'q1prime'}, '3': {'q6', 'q1prime'},
'4': {'q0', 'q1prime'}, '5': {'q1', 'q1prime'}, '6': {'q2', 'q1prime'}, '7': {'q3', 'q1prime'},
'8': {'q4', 'q1prime'}, '9': {'q5', 'q1prime'}, '': {'q1', 'q1prime'}},
'q2': {'0': {'q6', 'q2prime'}, '1': {'q0', 'q2prime'}, '2': {'q1', 'q2prime'}, '3': {'q2', 'q2prime'},
'4': {'q3', 'q2prime'}, '5': {'q4', 'q2prime'}, '6': {'q5', 'q2prime'}, '7': {'q6', 'q2prime'},
'8': {'q0', 'q2prime'}, '9': {'q1', 'q2prime'}, '': {'q2', 'q2prime'}},
'q3': {'0': {'q2', 'q3prime'}, '1': {'q3', 'q3prime'}, '2': {'q4', 'q3prime'}, '3': {'q5', 'q3prime'},
'4': {'q6', 'q3prime'}, '5': {'q0', 'q3prime'}, '6': {'q1', 'q3prime'}, '7': {'q2', 'q3prime'},
'8': {'q3', 'q3prime'}, '9': {'q4', 'q3prime'}, '': {'q3'}},
'q4': {'0': {'q5', 'q4prime'}, '1': {'q6', 'q4prime'}, '2': {'q0', 'q4prime'}, '3': {'q1', 'q4prime'},
'4': {'q2', 'q4prime'}, '5': {'q3', 'q4prime'}, '6': {'q4', 'q4prime'}, '7': {'q5', 'q4prime'},
'8': {'q6', 'q4prime'}, '9': {'q0', 'q4prime'}, '': {'q4'}},
'q5': {'0': {'q1', 'q5prime'}, '1': {'q2', 'q5prime'}, '2': {'q3', 'q5prime'}, '3': {'q4', 'q5prime'},
'4': {'q5', 'q5prime'}, '5': {'q6', 'q5prime'}, '6': {'q0', 'q5prime'}, '7': {'q1', 'q5prime'},
'8': {'q2', 'q5prime'}, '9': {'q3', 'q5prime'}, '': {'q5'}},
'q6': {'0': {'q4', 'q6prime'}, '1': {'q5', 'q6prime'}, '2': {'q6', 'q6prime'}, '3': {'q0', 'q6prime'},
'4': {'q1', 'q6prime'}, '5': {'q2', 'q6prime'}, '6': {'q3', 'q6prime'}, '7': {'q4', 'q6prime'},
'8': {'q5', 'q6prime'}, '9': {'q6', 'q6prime'}, '': {'q6'}},
'q0prime': {'0': {'q0prime'}, '1': {'q1prime'}, '2': {'q2prime'}, '3': {'q3prime'}, '4': {'q4prime'},
'5': {'q5prime'}, '6': {'q6prime'}, '7': {'q0prime'}, '8': {'q1prime'}, '9': {'q2prime'}},
'q1prime': {'0': {'q3prime'}, '1': {'q4prime'}, '2': {'q5prime'}, '3': {'q6prime'}, '4': {'q0prime'},
'5': {'q1prime'}, '6': {'q2prime'}, '7': {'q3prime'}, '8': {'q4prime'}, '9': {'q5prime'}},
'q2prime': {'0': {'q6prime'}, '1': {'q0prime'}, '2': {'q1prime'}, '3': {'q2prime'}, '4': {'q3prime'},
'5': {'q4prime'}, '6': {'q5prime'}, '7': {'q6prime'}, '8': {'q0prime'}, '9': {'q1prime'}},
'q3prime': {'0': {'q2prime'}, '1': {'q3prime'}, '2': {'q4prime'}, '3': {'q5prime'}, '4': {'q6prime'},
'5': {'q0prime'}, '6': {'q1prime'}, '7': {'q2prime'}, '8': {'q3prime'}, '9': {'q4prime'}},
'q4prime': {'0': {'q5prime'}, '1': {'q6prime'}, '2': {'q0prime'}, '3': {'q1prime'}, '4': {'q2prime'},
'5': {'q3prime'}, '6': {'q4prime'}, '7': {'q5prime'}, '8': {'q6prime'}, '9': {'q0prime'}},
'q5prime': {'0': {'q1prime'}, '1': {'q2prime'}, '2': {'q3prime'}, '3': {'q4prime'}, '4': {'q5prime'},
'5': {'q6prime'}, '6': {'q0prime'}, '7': {'q1prime'}, '8': {'q2prime'}, '9': {'q3prime'}},
'q6prime': {'0': {'q4prime'}, '1': {'q5prime'}, '2': {'q6prime'}, '3': {'q0prime'}, '4': {'q1prime'},
'5': {'q2prime'}, '6': {'q3prime'}, '7': {'q4prime'}, '8': {'q5prime'}, '9': {'q6prime'}}
},
initial_state='start_state',
final_states={'q0', 'q0prime'}
)
str_length = int(input("Enter an integer for string length: "))
dfa = DFA.from_nfa(nfa) # creates a DFA from the above built NFA
num_strings = count(str_length, dfa)
print("The number of strings of length", str_length,
"accepted by the DFA is", num_strings)
def test_init_nfa_missing_formal_params(self):
"""Should raise an error if formal NFA parameters are missing."""
with nose.assert_raises(TypeError):
NFA(
states={'q0', 'q1'},
input_symbols={'0', '1'},
initial_state='q0',
final_states={'q1'}
)
def markovNFA(pattern):
st = getStates(pattern)
nfa = NFA(states=st,
input_symbols={'H', 'T'},
transitions=getTransitions(pattern),
initial_state='phi',
final_states={str(len(pattern))})
return nfa
def union(automata1, tipo1, automata2, tipo2):
# Crear un estado inicial y juntar 2 automatas
simbolos = []
for i in automata1.input_symbols:
simbolos.append(i)
for a in automata2.input_symbols:
simbolos.append(a)
simbolos.append('')
estados = []
for i in automata1.states:
estados.append(i)
for a in automata2.states:
estados.append(a)
estados.append('inicio')
final = []
for i in automata1.final_states:
final.append(i)
for a in automata2.final_states:
final.append(a)
dic1 = automata1.transitions.copy()
dic2 = automata2.transitions.copy()
dic1.update(dic2)
if tipo1 == tipo2: # acepta 2 afnd
if tipo1:
dic1['inicio'] = {
'': {automata1.initial_state, automata2.initial_state}
}
automata = NFA(states=set(estados),
input_symbols=set(simbolos),
transitions=dic1,
initial_state='inicio',
final_states=set(final))
return automata, tipo1
# Formato dfa: 'q0': {'0': 'q0', '1': 'q1'},
# Formato nfa: 'q1': {'0': {'q1'}, '1': {'q2'}},
else:
automata2, tipo2 = AFDtoAFND(automata2, tipo2)
automata1, tipo1 = AFDtoAFND(automata1, tipo1)
return union(automata1, tipo1, automata2, tipo2)
else:
if tipo1:
automata2, tipo2 = AFDtoAFND(automata2, tipo2)
return union(automata1, tipo1, automata2, tipo2)
if tipo2:
automata1, tipo1 = AFDtoAFND(automata1, tipo1)
return union(automata1, tipo1, automata2, tipo2)
def test_init_dfa(self):
"""Should convert DFA to NFA if passed into NFA constructor."""
nfa = NFA(self.dfa)
nose.assert_equal(nfa.states, {'q0', 'q1', 'q2'})
nose.assert_equal(nfa.input_symbols, {'0', '1'})
nose.assert_equal(nfa.transitions, {
'q0': {'0': {'q0'}, '1': {'q1'}},
'q1': {'0': {'q0'}, '1': {'q2'}},
'q2': {'0': {'q2'}, '1': {'q1'}}
})
nose.assert_equal(nfa.initial_state, 'q0')
def converter_nfa_dfa(estados, alfabeto, funcao_transicao, est_inicial,
est_finais):
nfa = NFA(states=set(estados),
input_symbols=set(alfabeto),
transitions=funcao_transicao,
initial_state=est_inicial,
final_states=set(est_finais))
dfa = DFA(nfa)
return dfa
def test_non_str_states(self):
"""should handle non-string state names"""
nfa = NFA(
states={0},
input_symbols={0},
transitions={0: {}},
initial_state=0,
final_states=set())
# We don't care what the output is, just as long as no exception is
# raised
nose.assert_not_equal(nfa.accepts_input(''), None)
def test_concatenate(self):
nfa_a = NFA(
states={'q1', 'q2', 'q3', 'q4'},
input_symbols={'0', '1'},
transitions={
'q1': {'0': {'q1'}, '1': {'q1', 'q2'}},
'q2': {'': {'q2'}, '0': {'q2'}},
'q3': {'1': {'q4'}},
'q4': {'0': {'q4'}, '1': {'q4'}}
},
initial_state='q1',
final_states={'q2', 'q4'}
)
nfa_b = NFA(
states={'r1', 'r2', 'r3'},
input_symbols={'0', '1'},
transitions={
'r1': {'': {'r3'}, '1': {'r2'}},
'r2': {'0': {'r2', 'r3'}, '1': {'r3'}},
'r3': {'0': {'r1'}}
},
initial_state='r1',
final_states={'r1'}
)
concat_nfa = nfa_a + nfa_b
self.assertEqual(concat_nfa.accepts_input(''), False)
self.assertEqual(concat_nfa.accepts_input('0'), False)
self.assertEqual(concat_nfa.accepts_input('1'), True)
self.assertEqual(concat_nfa.accepts_input('00'), False)
self.assertEqual(concat_nfa.accepts_input('01'), True)
self.assertEqual(concat_nfa.accepts_input('10'), True)
self.assertEqual(concat_nfa.accepts_input('11'), True)
self.assertEqual(concat_nfa.accepts_input('101'), True)
self.assertEqual(concat_nfa.accepts_input('101100'), True)
self.assertEqual(concat_nfa.accepts_input('1010'), True)
def test_operations_other_type(self):
"""Should raise NotImplementedError for concatenate."""
nfa = NFA(
states={'q1', 'q2', 'q3', 'q4'},
input_symbols={'0', '1'},
transitions={'q1': {'0': {'q1'}, '1': {'q1', 'q2'}},
'q2': {'': {'q2'}, '0': {'q2'}},
'q3': {'1': {'q4'}},
'q4': {'0': {'q4'}, '1': {'q4'}}},
initial_state='q1',
final_states={'q2', 'q4'})
other = 42
with self.assertRaises(NotImplementedError):
nfa + other
def concatenacion(automata1, tipo1, automata2,
tipo2): # entran 2 NFA y no se saca la chucha :)
simbolos = []
#Saca Los simbolos de el automata 1 y 2
for i in automata1.input_symbols:
simbolos.append(i)
for a in automata2.input_symbols:
simbolos.append(a)
simbolos.append('')
sim = set(simbolos)
estados = []
#Saca los estados de los automatas 1 y 2
for i in automata1.states:
estados.append(i)
for a in automata2.states:
estados.append(a)
esta2 = set(estados)
dic1 = automata1.transitions.copy()
dic2 = automata2.transitions.copy()
dic1.update(dic2)
if tipo1 == tipo2:
if tipo1:
dic1[str(automata1.final_states)[2:4]][''] = {
str(automata2.initial_state)
}
automata = NFA(states=esta2,
input_symbols=sim,
transitions=dic1,
initial_state=automata1.initial_state,
final_states=set(automata2.final_states))
return automata, tipo1
else:
automata1, tipo1 = AFDtoAFND(automata1, tipo1)
automata2, tipo2 = AFDtoAFND(automata2, tipo2)
return concatenacion(automata1, tipo1, automata2, tipo2)
else:
if tipo1:
automata2, tipo2 = AFDtoAFND(automata2, tipo2)
return concatenacion(automata1, tipo1, automata2, tipo2)
if tipo2:
automata1, tipo1 = AFDtoAFND(automata1, tipo1)
return concatenacion(automata1, tipo1, automata2, tipo2)
def test_nfa_to_dfa_with_lambda_transitions(self):
""" Test NFA->DFA when initial state has lambda transitions """
nfa = NFA(
states={'q0', 'q1', 'q2'},
input_symbols={'a', 'b'},
transitions={
'q0': {'': {'q2'}},
'q1': {'a': {'q1'}},
'q2': {'a': {'q1'}}
},
initial_state='q0',
final_states={'q1'}
)
dfa = DFA.from_nfa(nfa) # returns an equivalent DFA
nose.assert_equal(dfa.read_input('a'), '{q1}')
def crear(sets, tipo):
if tipo == False:
automata = DFA(states=sets[0],
input_symbols=sets[1],
transitions=sets[2],
initial_state=sets[3],
final_states=sets[4])
else:
automata = NFA(states=sets[0],
input_symbols=sets[1],
transitions=sets[2],
initial_state=sets[3],
final_states=sets[4])
return automata
def create_nfa(size, alphabet={}):
states = set()
transitions = {}
for i in range(size):
states.add(str(i))
transitions[str(i)] = {}
for symbol in alphabet:
transitions[str(i)][symbol] = set()
return NFA(states=states,
input_symbols=alphabet,
transitions=transitions,
initial_state="0",
final_states=set())
def test_cyclic_lambda_transitions(self):
"""Should traverse NFA containing cyclic lambda transitions."""
# NFA which matches zero or more occurrences of 'a'
nfa = NFA(
states={'q0', 'q1', 'q2', 'q3'},
input_symbols={'a'},
transitions={
'q0': {'': {'q1', 'q3'}},
'q1': {'a': {'q2'}},
'q2': {'': {'q3'}},
'q3': {'': {'q0'}}
},
initial_state='q0',
final_states={'q3'}
)
nose.assert_equal(nfa.read_input(''), {'q0', 'q1', 'q3'})
nose.assert_equal(nfa.read_input('a'), {'q0', 'q1', 'q2', 'q3'})
def test_reverse(self):
nfa = NFA(
states={0, 1, 2, 4},
input_symbols={'a', 'b'},
transitions={
0: {'a': {1}},
1: {'a': {2}, 'b': {1, 2}},
2: {},
3: {'a': {2}, 'b': {2}}
},
initial_state=0,
final_states={2}
)
reverse_nfa = reversed(nfa)
self.assertEqual(reverse_nfa.accepts_input('a'), False)
self.assertEqual(reverse_nfa.accepts_input('ab'), False)
self.assertEqual(reverse_nfa.accepts_input('ba'), True)
self.assertEqual(reverse_nfa.accepts_input('bba'), True)
self.assertEqual(reverse_nfa.accepts_input('bbba'), True)
def setUp(self):
"""Reset test automata before every test function."""
# DFA which matches all binary strings ending in an odd number of '1's
self.dfa = DFA(states={'q0', 'q1', 'q2'},
input_symbols={'0', '1'},
transitions={
'q0': {
'0': 'q0',
'1': 'q1'
},
'q1': {
'0': 'q0',
'1': 'q2'
},
'q2': {
'0': 'q2',
'1': 'q1'
}
},
initial_state='q0',
final_states={'q1'})
# NFA which matches strings beginning with 'a', ending with 'a', and
# containing no consecutive 'b's
self.nfa = NFA(states={'q0', 'q1', 'q2'},
input_symbols={'a', 'b'},
transitions={
'q0': {
'a': {'q1'}
},
'q1': {
'a': {'q1'},
'': {'q2'}
},
'q2': {
'b': {'q0'}
}
},
initial_state='q0',
final_states={'q1'})
def nfa_to_dfa():
json = request.get_json()
states = json['states']
alphabet = json['alphabet']
initial = json['initial']
mapping = json['transitionMap']
finals = json['finals']
nfa = NFA(
states=set(states),
input_symbols=set(alphabet),
initial_state=initial,
transitions=mapping,
final_states=set(finals)
)
dfa = DFA(nfa)
return jsonify(
{
"alphabet": list(dfa.input_symbols),
"states": list(dfa.states),
"initial": dfa.initial_state,
"finals": list(dfa.final_states),
"transitionMap": dfa.transitions
}
)
def afn_AFD(idA, conjunto, bandera):
if idA in afn_api.keys() and idA not in afn_convertidos:
afn = afn_api[idA].copy()
else:
afn = conjunto.buscaAfn(idA)
edosId = set()
edosfinales = set()
edosinicial = set()
##Obtener transiciones
dictrans = {}
alfabeto = set()
estadoinicial = ""
for i in afn.edosAFN:
# print(str(i.identificador))
if (i.edoInicial == True):
edosinicial.add(str(i.identificador))
estadoinicial = str(i.identificador)
if (len(edosinicial) > 1):
try:
os.system("cls")
except:
os.system("clear")
print("ERROR, HAY MAS DE UN ESTADO INICIAL")
print("ESTADOS INICIALES: " + str(edosinicial))
break
if (i.edoFinal == True):
edosfinales.add(str(i.identificador))
agregarTokenEstado(str(i.identificador), str(i.token))
##agregardiccionario('',i.identificador)
edosId.add(str(i.identificador))
try:
for j in i.transiciones:
var1 = str(j.simbolo)
var2 = str(j.simbolo2)
var3 = str(j.edoDestino.identificador)
elements_transiciones = elementos_transiciones(var1, var2)
for letra in elements_transiciones:
agregardiccionario(letra, var3)
if letra not in alfabeto:
if letra != '':
alfabeto.add(letra)
dictrans[str(i.identificador)] = devolverdiccionario()
except:
auxtran = i.transiciones
if auxtran == None:
agregardiccionario('', str(i.identificador))
dictrans[str(i.identificador)] = devolverdiccionario()
else:
elements_transiciones = elementos_transiciones(
str(auxtran.simbolo), str(auxtran.simbolo2))
for letra in elements_transiciones:
agregardiccionario(
letra, str(auxtran.edoDestino.identificador))
if letra not in alfabeto:
if letra != '':
alfabeto.add(letra)
dictrans[str(i.identificador)] = devolverdiccionario()
afn = NFA(states=edosId,
input_symbols=alfabeto,
transitions=dictrans,
initial_state=estadoinicial,
final_states=edosfinales)
afn_api[idA] = afn
afd = DFA.from_nfa(afn)
transicionesafd = afd.transitions.copy()
if bandera == 1:
return afn
else:
pass
#print("¿CONVERSION CORRECTA?")
#print(afd.validate())
# print(str(devolverTokens()))
transicionesafd = afd.transitions.copy()
diccionario_tokens = devolverTokens()
a_borar = []
for clave, valor in afd.transitions.items():
if valor == '{}' or clave == '{}' or valor == None or clave == None or len(
afd.transitions[clave]) == 0:
try:
del transicionesafd[clave]
continue
except:
pass
for j, h in valor.items():
if h == '{}' or h == None or j == '{}':
a_borar.append(j)
for k in a_borar:
try:
del transicionesafd[clave][k]
except:
continue
a_borar.clear()
'''for clave in afd.transitions.keys():
if clave == None or clave == '{}':
try:
del transicionesafd[clave]
except:
pass'''
afd_api[idA] = afd
archivoAFD = open("AFD.txt", "w")
archivoAFD.write(
"ESTADOS :" +
str(afd.states).replace("'{}',", '').replace(",'{}'", '') + "\n")
archivoAFD.write("SIMBOLOS DE ENTRADA :" +
str(afd.input_symbols).replace("'}'}, '{'", "}'}, '{\n") +
"\n")
archivoAFD.write("TRANSICIONES :" + str(transicionesafd) + "\n")
archivoAFD.write("ESTADO INICIAL :" + str(afd.initial_state) + "\n")
archivoAFD.write("ESTADO(S) FINAL(ES) :" + str(afd.final_states) + "\n")
archivoAFD.write("TOKENS (CLAVE, VALOR):" + str(diccionario_tokens))
archivoAFD.close()
# VAMONOS CON RICK
estados_rick = open("estados.pickle", "wb")
#estados_rick = open("lexEdos.pickle", "wb")
pickle.dump(afd.states, estados_rick)
estados_rick.close()
alfabeto_rick = open("alfabeto.pickle", "wb")
#alfabeto_rick = open("lexAlfa.pickle", "wb")
pickle.dump(afd.input_symbols, alfabeto_rick)
alfabeto_rick.close()
transiciones_rick = open("transiciones.pickle", "wb")
#transiciones_rick = open("lexTransitions.pickle", "wb")
pickle.dump(afd.transitions, transiciones_rick)
transiciones_rick.close()
edoInicial_rick = open("edosInicial.pickle", "wb")
#edoInicial_rick = open("lexEdoIni.pickle", "wb")
pickle.dump(afd.initial_state, edoInicial_rick)
edoInicial_rick.close()
edosFinales_rick = open("edosFinales.pickle", "wb")
#edosFinales_rick = open("lexEdoFin.pickle", "wb")
pickle.dump(afd.final_states, edosFinales_rick)
edosFinales_rick.close()
tokens_rick = open("token.pickle", "wb")
#tokens_rick = open("lexToken.pickle", "wb")
pickle.dump(diccionario_tokens, tokens_rick)
tokens_rick.close()
def afn_AFD(idA, conjunto, bandera):
if idA in afn_api.keys() and idA not in afn_convertidos:
afn = afn_api[idA].copy()
else:
aux3 = copy.deepcopy(conjunto.con)
for i in aux3:
if i.idAFN == idA:
afn = i
# estados
edosId = set()
edosfinales = set()
edosinicial = set()
##Obtener transiciones
dictrans = {}
alfabeto = set()
estadoinicial = ""
for i in afn.edosAFN:
if (i.edoInicial == True):
edosinicial.add(str(i.identificador))
estadoinicial = str(i.identificador)
if (len(edosinicial) > 1):
print("ERROR, HAY MAS DE UN ESTADO INICIAL")
break
if (i.edoFinal == True):
edosfinales.add(str(i.identificador))
edosId.add(str(i.identificador))
try:
for j in i.transiciones:
var1 = str(j.simbolo)
if j.simbolo == None or j.simbolo == " ":
var1 = ''
else:
alfabeto.add(var1)
var2 = str(j.edoDestino.identificador)
agregardiccionario(var1, var2)
dictrans[str(i.identificador)] = devolverdiccionario()
except:
auxtran = i.transiciones
if auxtran == None:
print(str(i.identificador))
agregardiccionario('', str(i.identificador))
dictrans[str(i.identificador)] = devolverdiccionario()
else:
if auxtran.simbolo == " ":
var1 = ''
else:
var1 = str(auxtran.simbolo)
alfabeto.add(var1)
agregardiccionario(var1, str(auxtran.edoDestino.identificador))
dictrans[str(i.identificador)] = devolverdiccionario()
afn = NFA(
states=edosId,
input_symbols=alfabeto,
transitions=dictrans,
initial_state=estadoinicial,
final_states=edosfinales
)
afn_api[idA] = afn
afd = DFA.from_nfa(afn)
transicionesafd = afd.transitions.copy()
if bandera == 1:
return afn
else:
pass
print("¿CONVERSION CORRECTA?")
print(afd.validate())
for k, i in afd.transitions.items():
for clave, valor in i.items():
if clave == '{}' or clave == None or valor == '{}' or valor == None:
del transicionesafd[k]
for clave in afd.transitions.keys():
if clave == None or clave == '{}':
try:
del transicionesafd[clave]
except:
pass
print("TRANSICIONES AFD")
print(str(transicionesafd))
afd_api[idA] = afd
'q_4': {'a': 'q_5', 'b': 'q_5'},
'q_5': {'a': 'q_4', 'b': 'q_4'}},
initial_state='q_1',
final_states={'q_2', 'q_5'}),
difficulty=Problem.HARD,
exact=False)
]
NFA_problem_bank = [
Problem(probid=1,
description="Design an NFA that recognizes the language \(\color{#056fa0}{L = \{ 0, 1\}}\).",
fsm=NFA(states={'1', '2', '3'},
input_symbols={'0', '1'},
transitions={'1': {'0': {'2'}, '1': {'3'}},
'2': {},
'3': {}},
initial_state='1',
final_states={'2', '3'}),
difficulty=Problem.EASY,
exact=False),
Problem(probid=2,
description="Design an NFA that recognizes the strings 'cat' and 'cats' only. You may assume that the input alphabet is \(\color{#056fa0}{\Sigma = \{ a,c,s,t\}}\).",
fsm=NFA(states={'1', '2', '3', '4', '5'},
input_symbols={'c', 'a', 't', 's'},
transitions={'1': {'c': {'2'}},
'2': {'a': {'3'}},
'3': {'t': {'4'}},
'4': {'s': {'5'}},
'5': {}},
initial_state='1',
#get file
inputFile = open(args.FILE, "r")
inputLines = inputFile.readlines()
regexToMatch = args.REGEX
#thompson alg output returns a NFA transition table
thompsonOutput = thompsonsAlg.thompsonsAlg(regexToMatch)
#let's try building an NFA!
nfa = NFA(
states=set(thompsonOutput.s.keys()),
input_symbols= set(thompsonOutput.keys),
transitions= thompsonOutput.s,
initial_state= list(thompsonOutput.s.keys())[0],
final_states= {list(thompsonOutput.s.keys())[len(list(thompsonOutput.s.keys())) -1]}
)
#build a DFA from NFA (wow i'm really trusting this library with my grade)
dfa = DFA.from_nfa(nfa)
#check for NFA and DFA and generate DOT files also outputs a PDF of the same name
if(args.DFA):
#makes sure it ends with the right file type
if(not args.DFA.endswith(".dot")):
fileName = args.DFA + ".dot"
dot.graphDFA(dfa, fileName)
else:
initial_state="q0",
final_states={"q0"},
)
# #### Converting
#
# An automata-lib NFA can be converted to a VisualNFA.
#
# Define an automata-lib NFA that can accept any string with the pattern 10, 1010, 101010.
nfa = NFA(
states={"q0", "q1", "q2"},
input_symbols={"0", "1"},
transitions={
"q0": {"": {"q2"}, "1": {"q1"}},
"q1": {"1": {"q2"}, "0": {"q0", "q2"}},
"q2": {},
},
initial_state="q0",
final_states={"q0"},
)
# Convert automata-lib NFA to VisualNFA.
nfa = VisualNFA(nfa)
# #### Transition Table
#
# Outputs the transition table for the given DFA.
nfa.table
from automata.fa.nfa import NFA
from automata.fa.dfa import DFA
nfa = NFA(
states={'q0', 'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8'},
input_symbols={'a', 'b'},
transitions={
# Use '' as the key name for empty string (lambda/epsilon) transitions
'q0': {'a': {'q3'}, '': {'q1'}},
'q1': {'a': {'q4'}, '': {'q2'}},
'q2': {'b': {'q5'}, '': {'q0'}},
'q3': {'b': {'q6'}},
'q4': {'a': {'q7'}},
'q5': {'b': {'q8'}},
'q6': {},
'q7': {'': {'q8'}},
'q8': {'': {'q2'}}
},
initial_state='q0',
final_states={'q6'}
)
dfa = DFA.from_nfa(nfa) # returns an equivalent DFA
print("DFA table")
print(dfa.transitions, "\n")
print("Intial State: ", dfa.initial_state)
print("Final State: ", dfa.final_states, "\n")