def B():
aut = automaton.automaton(
epsilons=[],
states=[0, 1, 2], initials=[0], finals=[0, 1],
transitions=[(0, 'a', 2), (2, 'b', 0), (0, 'a', 1)])
return aut
def intersection(aut1, aut2):
# On renome les etats des deux automates
aut1.renumber_the_states()
aut2.translate(aut1.get_maximal_id() + 1)
aut = automaton.automaton()
alphabet = aut1.get_alphabet()
# On cree une liste pour mettre les couples de sommets traites et a traiter
setStates = []
# pour chaque etat initial de l'automate 1
for s1 in aut1.get_initial_states():
# pour chaque etat initial de l'automate 2
for s2 in aut2.get_initial_states():
# on ajoute les couple d'état initiaux
setStates.append((s1, s2))
# on parcours enfin notre liste de couples de sommets
# pour chaque couple
for S in setStates:
# pour chaque lettre
for lettre in alphabet:
# on divise notre couple en deux
sub_etat1 = list(S)[0]
sub_etat2 = list(S)[1]
# on cherche les etats d'arrives pour chaque partie de notre couple
s1 = aut1.delta(lettre, [sub_etat1])
s2 = aut2.delta(lettre, [sub_etat2])
if s1:
sub_stat1 = list(s1)[0]
else:
sub_stat1 = 0
if s2:
sub_stat2 = list(s2)[0]
else:
sub_stat2 = 0
# on rajoute la transition du couple lu par la lettre en cours vers les sommets trouves
aut.add_transition((S, lettre, (sub_stat1, sub_stat2)))
# si l'etat/couple n'existe pas dans la liste, on le rajoute
if (sub_stat1, sub_stat2) not in setStates:
setStates.append((sub_stat1, sub_stat2))
# on lit tous nos couples
for S in aut.get_states():
# on divise en deux
sub_etat1 = list(S)[0]
sub_etat2 = list(S)[1]
# si les deux etats du couple sont respectivement etats finaux de leur automate
if sub_etat1 in aut1.get_final_states():
if sub_etat2 in aut2.get_final_states():
# on rajoute le couple en etat final
aut.add_final_state(S)
# on lit tous nos couples
for S in aut.get_states():
# on divise en deux
sub_etat1 = list(S)[0]
sub_etat2 = list(S)[1]
# si les deux etats du couple sont respectivement etats initiaux de leur automate
if sub_etat1 in aut1.get_initial_states():
if sub_etat2 in aut2.get_initial_states():
# on rajoute le couple en etat initial
aut.add_initial_state(S)
return aut
def A():
aut = automaton.automaton(
epsilons=[],
states=[0, 1], initials=[0], finals=[0],
transitions=[(0, 'a', 1), (1, 'b', 0)])
return aut
def main():
automate = automaton.automaton(
epsilons = [],
states=['E','a1','a2','a3','a4','a5','b1','b2','b3','b4','b5'],initials=['E'],finals=['a3','b2','b5','a5'],
transitions=[('E','a','a1'),('a1','a','a1'),('a1','a','a2'),('a1','b','b1'),('b1','b','b1'),('a2','b','b2'),('b1','a','a1'),('b1','a','a2'),('a2','a','a3'),('E','b','b1'),('E','a','a2'),('E','b','b4'),('E','b','b3'),('E','a','a4'),('a4','a','a4'),('a4','b','b3'),('b3','b','b3'),('b3','a','a4'),('b3','b','b4'),('a4','b','b4'),('b4','b','b5'),('b4','a','a5')])
automate.display(title="Automate",wait=False)
minimiser(automate).display(title="Minimise",wait=False)
def automate (): alphabet = ['a' ,'b' ,'c' ,'d' ] epsilons = [] initiaux = [(0 ,0)] etats = [] finaux = [] transitions = [] for a_moins_b in [0, 1, -1]: for c_moins_d in [0, 1, -1]: etats.append((a_moins_b, c_moins_d)) finaux.append((a_moins_b, c_moins_d)) for origine in etats: for lettre in alphabet: if lettre == 'a' : fin = (origine[0]+1, origine[1]) elif lettre == 'b' : fin = (origine[0]-1, origine[1]) elif lettre == 'c' : fin = (origine[0], origine[1]+1) else : fin = (origine[0], origine[1]-1) if abs(fin[0]) <= 1 and abs(fin[1]) <= 1 : transitions.append((origine, lettre, fin)) return automaton.automaton( alphabet, epsilons, etats, initiaux, finaux ,transitions )
def expression_vers_automate(E):
# Bon, c'est parti !
# Fonction récursive, on prend le premier élément, et on le traite puis on appele la fonction avec le reste de la liste. Mucho large complexidad
#automate = automaton.automaton()
#exprToAutRec(E)
automate = automaton.automaton(initials=['Init'], finals=['Fin'])
exprToAutRec(E, automate, 0)
return automate
def union(aut1, aut2):
aut1.renumber_the_states()
aut2.translate(aut1.get_maximal_id() + 1)
aut = automaton.automaton()
alphabet = aut1.get_alphabet()
# On cree une liste pour mettre les couples de sommets traites et a traiter
setStates = []
# pour chaque etat initial de l'automate 1
for s1 in aut1.get_initial_states():
# on l'ajoute en tant que etat initial
setStates.append((s1, 0))
# pour chaque etat initial de l'automate 2
for s2 in aut2.get_initial_states():
# on l'ajoute en tant que etat initial
setStates.append((0, s2))
# pour chaque couple
for S in setStates:
# pour chaque lettre
for lettre in alphabet:
# on divise notre couple en deux
sub_etat1 = list(S)[0]
sub_etat2 = list(S)[1]
# on cherche les etats d'arrives pour chaque partie de notre couple
s1 = aut1.delta(lettre, [sub_etat1])
s2 = aut2.delta(lettre, [sub_etat2])
if s1:
sub_stat1 = list(s1)[0]
else:
sub_stat1 = 0
if s2:
sub_stat2 = list(s2)[0]
else:
sub_stat2 = 0
# si le couple ne mene nul part par aucun des deux sommet du couple
if not (sub_stat1 == 0 and sub_stat2 == 0):
aut.add_transition((S, lettre, (sub_stat1, sub_stat2)))
# si l'etat/couple n'existe pas dans la liste, on le rajoute
if (sub_stat1, sub_stat2) not in setStates:
setStates.append((sub_stat1, sub_stat2))
# on lit tous nos couples
for S in aut.get_states():
# on divise notre couple en deux
sub_etat1 = list(S)[0]
sub_etat2 = list(S)[1]
# si l'un des deux etats du couple est respectivement etat final de son automate
if sub_etat1 in aut1.get_final_states() or sub_etat2 in aut2.get_final_states():
# on rajoute le couple en etat final
aut.add_final_state(S)
for S in aut.get_states():
# on divise notre couple en deux
sub_etat1 = list(S)[0]
sub_etat2 = list(S)[1]
# si l'un des deux etats du couple est respectivement etat initial de son automate
if sub_etat1 in aut1.get_initial_states() or sub_etat2 in aut2.get_initial_states():
# on rajoute le couple en etat final
aut.add_initial_state(S)
return aut
def BulletProcess(phone, content):
db.execute('select * from b_screen where `phone`=%s', (phone, ))
result = db.fetchone()
userid = result[0]
time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
db.execute(
'insert into c_bullet (`time`, `content`,`userid`) values (%s, %s, %s)',
(time, content, userid))
ContentProcessed = automaton(content)
return ContentProcessed
def main():
aut1 = automaton.automaton(
epsilons=[],
states=[0, 1], initials=[0], finals=[1],
transitions=[(0, 'a', 1), (1, 'b', 0)])
aut1.display()
toto = mirror(aut1)
toto.display()
def complement(aut):
""" Returns the complement of an automate """
states = aut.get_states()
finals = set()
for state in states:
if not aut.state_is_final(state):
finals.add(state)
return automaton.automaton(aut.get_alphabet(), aut.get_epsilons(), states,
aut.get_initial_states(), finals, aut.get_transitions())
def main():
aut = automaton.automaton(
epsilons=[],
states=[0, 1, 2, 3], initials=[0], finals=[1, 2],
transitions=[(0, 'a', 1), (1, 'b', 0), (0, 'b', 2), (1, 'a', 2), (3, 'a', 2)])
aut.display()
aut.display(title="Automate origin", wait=False)
toto = complement(aut)
toto.display(title="Automate origin's complement", wait=False)
def expression_vers_automate(E): "Cree un automate a partir d'une chaine de caractere." liste = list () get_expression(E, liste) aut = automaton.automaton ( epsilons = ['0'] ) alphabet = list() states = list() while len(liste) > 0 : cmpt = liste.pop() if not operator.count(cmpt): alphabet.append(cmpt) if not aut.get_maximal_id(): i=0 else: i = aut.get_maximal_id() i+=1 j=i+1 aut.add_transition( (i, cmpt, j) ) states.append([i, j]) else : if cmpt == "+": states.append( plus(aut, states.pop(), states.pop()) ) if cmpt == ".": states.append( produit(aut, states.pop(), states.pop()) ) if cmpt == "*": states.append( star(aut, states.pop()) ) aut = automaton.automaton( alphabet = alphabet, epsilons = ['0'], states = aut.get_states(), initials = aut.get_initial_states(), finals = aut.get_final_states(), transitions = aut.get_transitions() ) return minimiser(aut)
def miroir(aut):
# on cree un nouvel automate avec les memes etats, le meme alphabet et on echange les etats finaux et initiaux
aut2 = automaton.automaton(
alphabet=aut.get_alphabet(),
states=aut.get_states(),
finals=aut.get_initial_states(),
initials=aut.get_final_states(),
)
# pour toutes les transitions on echange leur sens
for t in aut.get_transitions():
aut2.add_transition((list(t)[2], list(t)[1], list(t)[0]))
return aut2
def intersection_union(aut1, aut2, inter):
""" Returns the intersection or the union of aut1 and aut2
if inter == True, intersection function is done,
else, union function is done..
Expect that the automates are already complete (AND? deterministic)
Their alphabet must be equals else it return None.
"""
aut_res = automaton.automaton()
if aut1.get_alphabet() != aut2.get_alphabet():
return None
alphabet_res = aut1.get_alphabet()
stack = []
print("initialisation à partir des états initiaux")
for init_aut1 in aut1.get_initial_states():
for init_aut2 in aut2.get_initial_states():
init_state_res = (init_aut1, init_aut2)
aut_res.add_initial_state(init_state_res)
aut_res.add_state(init_state_res)
stack += [init_state_res]
while len(stack) > 0:
print(stack)
#current state
state = stack.pop()
for letter in alphabet_res:
# Evite les liaisons inutiles sur un etat sur lui même.
if not letter in aut1.get_epsilons():
access_aut1 = list(aut1.delta(letter, [state[0]]))
access_aut2 = list(aut2.delta(letter, [state[1]]))
for al in access_aut1:
for ar in access_aut2:
new_state = (al, ar)
# Nouvel etat à gerer (et toutes les transitions ...)
if not aut_res.has_state(new_state):
stack += [new_state]
aut_res.add_state(new_state)
aut_res.add_transition(((state[0], state[1]), letter, new_state))
new_finals_states(aut1, aut2, aut_res, inter)
# Si 'pour l'intersection' il n'y a pas d'états finaux, alors l'automate est vide.
if aut_res.get_final_states() != set():
return aut_res
else:
return "Automate VIDE, (intersection)"
def mirror(a):
self = automaton.automaton(
alphabet = a.get_alphabet(),
epsilons = a.get_epsilons(),
states = a.get_states(),
initials = a.get_final_states(),
finals = a.get_initial_states(),
)
transitions = a.get_transitions()
for t in transitions:
self.add_transition((t[2], t[1], t[0]))
return self
def automate2():
alphabet = ['a', 'b', 'c']
epsilons = []
states = ['X', 'Y', 'Z']
initials = ['X','Z']
finals = ['Z']
transitions=[
('X','a','X'),('X','c','X'), ('X','b','Y'), ('Y','c','X'), ('Y','b','Y'), ('Y','a','Z'), ('Z','a','Z'), ('Z','c','Z'), ('Z','b','Z'),('X','a','Y')
]
return automaton.automaton(
alphabet, epsilons, states, initials, finals, transitions)
def expression_vers_automate(E):
# on utilise ici un algorithme recursif pour analyser chaque partie de l'expression une a une
e = E[0]
if e == "+":
aut = union(expression_vers_automate(E[1][0]), expression_vers_automate(E[1][1]))
if e == ".":
aut = concatenation(expression_vers_automate(E[1]), expression_vers_automate(E[2]))
if e == "*":
aut = etoile(expression_vers_automate(E[1]))
if e.isalpha():
aut = automaton.automaton(epsilons=["0"], initials=[0], finals=[1], transitions=[(0, e, 1)])
return aut
def mirror(aut):
""" Returns the mirror of an automate """
transitions = []
transitions_aut = aut.get_transitions()
for transition in transitions_aut:
transitions += [(transition[2], transition[1], transition[0])]
initial_states = aut.get_final_states()
final_states = aut.get_initial_states()
return automaton.automaton(aut.get_alphabet(), aut.get_epsilons(), aut.get_states(),
initial_states, final_states, transitions)
def main():
aut = automaton.automaton(
epsilons=[],
states=[0, 1, 2, 3],
initials=[0],
finals=[1, 2],
transitions=[(0, "a", 1), (1, "b", 0), (0, "b", 2), (3, "a", 2)],
)
aut.display(title="Automate origin", wait=False)
toto = complete(aut)
toto.display(title="Automate origin's completed", wait=False)
def main():
#automate = automaton.automaton(
# epsilons=[],
# states=[0, 1], initials=[0], finals=[1],
# transitions=[(0, 'a', 1), (1, 'b', 0)])
automate3 = automaton.automaton(
epsilons = [],
states=['E','a1','a2','a3','a4','a5','b1','b2','b3','b4','b5'],initials=['E'],finals=['a3','b2','b5','a5'],
transitions=[('E','a','a1'),('a1','a','a1'),('a1','a','a2'),('a1','b','b1'),('b1','b','b1'),('a2','b','b2'),('b1','a','a1'),('b1','a','a2'),('a2','a','a3'),('E','b','b1'),('E','a','a2'),('E','b','b4'),('E','b','b3'),('E','a','a4'),('a4','a','a4'),('a4','b','b3'),('b3','b','b3'),('b3','a','a4'),('b3','b','b4'),('a4','b','b4'),('b4','b','b5'),('b4','a','a5')])
automate3.display(title="Automate", wait=False)
automate4 = determiniser(automate3)
automate4.display(title="Determinise", wait=False)
def automate():
alphabet = ['a', 'b']
epsilons = []
states = [0,1, 2,3,4,5,6]
initials = [0]
finals = [0,3,4,6,7]
transitions=[
(0,'a',2), (0,'b',1), (1,'b',1), (1,'a',2), (2,'b',2), (2,'a',3),
(3,'a',2), (3,'b',6), (7,'b',3), (6,'b',7), (6,'a',5), (5,'a',6),
(5,'b',5), (7,'a',5), (4,'a',5), (4,'b',4), (2,'b',2)
]
return automaton.automaton(
alphabet, epsilons, states, initials, finals, transitions
)
def determinisation(aut):
# on renome les etats de l'automate pour que ca soit plus simple
aut.renumber_the_states()
aut2 = automaton.automaton()
setStates = []
# pour chaque etat initial de l'automate
for i in aut.get_initial_states():
# on l'ajoute a notre set a parcourir
setStates.append(i)
# on freeze l'etat pour pouvoir le rajouter
initialState = frozenset(setStates)
aut2.add_initial_state(initialState)
setStates = [setStates]
alphabet = aut.get_alphabet()
# pour chacun de nos etat a parcourir
for S in setStates:
# pour chaque lettre
for lettre in alphabet:
tmpState = list()
# pour chaque partie de notre etat (dans le cas d'un couple, liste ..)
for s in S:
myDelta = aut.delta(lettre, [s])
# pour chaque sommet d'arrive par la lettre en cours
for i in myDelta:
# on le rajoute a un set temporaire
tmpState.append(i)
newS2 = frozenset(S)
# qu'on gele
tmpState2 = frozenset(tmpState)
if tmpState2 != frozenset():
# pour le rajouter en tant que etat d'arrive de la nouvelle transistion cree.
aut2.add_transition((newS2, lettre, tmpState2))
# si l'etat d'arrive n'exite pas dans notre liste a parcourir
if tmpState not in setStates:
# alors on le rajoute
setStates.append((tmpState))
# pour chaque etat du nouvel automate
for S in aut2.get_states():
# pour chaque partie de l'etat
for s in S:
# si il est etat final dans le premier automate
if s in aut.get_final_states():
# alors on le rajoute a nos etats finaux du nouvel automate
aut2.add_final_state(S)
break
return aut2
def union_intersection_aux(auto1, auto2):
self = automaton.automaton()
transitions1 = auto1.get_transitions()
transitions2 = auto2.get_transitions()
for t1 in transitions1:
for t2 in transitions2:
if t1[1] == t2[1]:
self.add_transition(((t1[0], t2[0]), t1[1] ,(t1[2], t2[2])))
if not(self.has_state((t1[0], t2[0]))):
self.add((t1[0], t2[0]))
if not(self.has_state((t1[2], t2[2]))):
self.add((t1[2], t2[2]))
if auto1.state_is_initial(t1[0]) and auto2.state_is_initial(t2[0]):
self.add_initial_state((t1[0], t2[0]))
return self
def determiniser(aut):
"""Retourne un automate déterminisé de l'automate passé en paramètre"""
#etats = aut.get_states()
alphabet = aut.get_alphabet()
#contient les états à traiter
pile = []
#contient les états déjà traités
traites = []
#contient le graph résultat que l'on construit au fur et à mesure
resultat = automaton.automaton(alphabet=alphabet)
#En premier, on crée l'état initial à partir de tous les états initiaux
etatInitial = tuple(aut.get_initial_states())
#Et on l'ajoute au graphe
resultat.add_initial_state(tuple(etatInitial))
#Et à la pile, car il faut traiter les transitions
pile += [etatInitial]
#Tant que la pile a un état à traiter
for etatCourant in pile:
for letter in alphabet:
hasFinalState = False
delta = list(aut.delta(letter, etatCourant))
#On regarde s'il y a un état final dans le lot
for etatTmp in delta:
if aut.state_is_final(etatTmp):
hasFinalState = True
nouvelEtat = tuple(delta)
if len(delta) > 0:
if delta != etatCourant:
resultat.add_state(nouvelEtat)
resultat.add_transition((tuple(etatCourant), letter, nouvelEtat))
else:
resultat.add_transition((tuple(etatCourant), letter, tuple(etatCourant)))
traites += [etatCourant]
#Si il y a un final, on passe l'etat en final
if hasFinalState:
resultat.add_final_state(nouvelEtat)
if nouvelEtat not in traites:
pile += [nouvelEtat]
return resultat
def etoile(aut):
# on cree un nouvel automate avec les memes etats, les memes transitions et le meme alphabet
aut2 = automaton.automaton(alphabet=aut.get_alphabet(), states=aut.get_states(), transitions=aut.get_transitions())
# on rajoute un super etat final et un super final
aut2.add_initial_state("I")
aut2.add_final_state("F")
# on rajoute des etats de transitions
aut2.add_states(["i", "f"])
# on rajoute les epsilons transitions entre les etats qu'on vient de rajouter
aut2.add_transitions([("I", "0", "i"), ("I", "0", "F"), ("f", "0", "F"), ("f", "0", "i")])
# on rajoute les epsilons transition entre l'etats i et les etats initiaux de l'automate de depart
for i in aut.get_initial_states():
aut2.add_transition(("i", "0", i))
# on rajoute les epsilons transition entre l'etats f et les etats finaux de l'automate de depart
for f in aut.get_final_states():
aut2.add_transition((f, "0", "f"))
return aut2
def automate_des_mots_contenant_l_alphabet(alphabet): initiaux = [automaton.pretty_set()] epsilons = [] finaux = [automaton.pretty_set(alphabet )] etats = set(automaton.pretty_set () ) pile = [automaton.pretty_set () ] transitions = [] while len (pile) > 0: origine = pile.pop () for lettre in alphabet : fin = origine.union ([lettre]) if not (fin in etats): etats.add (fin) pile.append(fin) transitions.append ((origine, lettre, fin)) return automaton.automaton( alphabet , epsilons , etats , initiaux , finaux , transitions )
def complement(aut):
# on determinise et complete l'automate
aut = determinisation(aut)
aut = completer(aut)
# on affiche l'automate apres ces deux etapes
aut.display("Automate de depart determinise et complete")
# on cree un nouvel automate avec le meme alphabet, les memes etats (les initiaux reste initiaux), les memes transitions
aut2 = automaton.automaton(
alphabet=aut.get_alphabet(),
states=aut.get_states(),
transitions=aut.get_transitions(),
initials=aut.get_initial_states(),
)
# Tout les etats qui ne sont pas finaux (sauf le puit) deviennent finaux dans le nouvel automate
for s in aut.get_states():
if s not in (aut.get_final_states()) and s != "P":
aut2.add_final_state(s)
return aut2
def miroir(aut): "Inverse le sens des transitions et inverse les etats finaux et initaux d'un automate." i = 0 new_transitions = [] transitions = list(aut.get_transitions()) while i < len(transitions): new_transitions.append((transitions[i][2], transitions[i][1], transitions[i][0])) i+=1 aut_mirror = automaton.automaton ( alphabet = aut.get_alphabet(), epsilons = aut.get_epsilons(), states = aut.get_states() , initials = aut.get_final_states() , finals = aut.get_initial_states(), transitions = new_transitions ) return aut_mirror
def determinisation(aut): "Determinise un automate." alphabet = list(aut.get_alphabet()) initials_states = aut.get_initial_states() final_states = aut.get_final_states() file_sommet = [initials_states] liste_nouveaux_sommet = [initials_states] liste_transitions = [] while len(file_sommet) != 0: for i in alphabet: if aut.delta(i, file_sommet[0]): sommet = aut.delta(i, file_sommet[0]) liste_transitions += [(file_sommet[0], i, sommet)] if not sommet in liste_nouveaux_sommet: liste_nouveaux_sommet += [sommet] file_sommet += [sommet] file_sommet.pop(0) final = [] for i in liste_nouveaux_sommet: for j in i: if j in final_states: final += [i] aut_deter = automaton.automaton ( initials = [initials_states], finals = final, alphabet = alphabet, epsilons = aut.get_epsilons(), states = liste_nouveaux_sommet, transitions = liste_transitions ) return aut_deter
def uninter(aut1, aut2, type): "Effectue une union ou une intersection suivant la valeur de la variable type." alpha = list( aut1.get_alphabet() ) aut = automaton.automaton ( alphabet = alpha, epsilons = aut1.get_epsilons(), ) states1 = list( aut1.get_states() ) states2 = list( aut2.get_states() ) transitions1 = list( aut1.get_transitions() ) transitions2 = list( aut2.get_transitions() ) for i in range (len (alpha) ): for j in range (len (states1) ): for k in range (len (states2) ): tmp1 = list( aut1.delta( alpha[i], [states1[j]]) ) tmp2 = list( aut2.delta( alpha[i], [states2[k]]) ) if tmp1 and tmp2 : for l in range (len (tmp1)): for m in range (len (tmp2)): if not aut.has_state( (states1[j], states2[k]) ): aut.add_state((states1[j], states2[k])) if type: if aut1.state_is_final((states1[j])) or aut2.state_is_final((states2[k])): aut.add_final_state((states1[j], states2[k])) else : if aut1.state_is_final((states1[j])) and aut2.state_is_final((states2[k])): aut.add_final_state((states1[j], states2[k])) if aut1.state_is_initial((states1[j])) and aut2.state_is_initial((states2[k])): aut.add_initial_state((states1[j], states2[k])) aut.add_transition( ((states1[j],states2[k]), alpha[i], (tmp1[l], tmp2[l]) )) return aut
def concatenation(aut1, aut2):
# on renome les etats des deux automates pour que ca soit plus simple
aut1.renumber_the_states()
aut2.translate(aut1.get_maximal_id() + 1)
# on cree un nouvel automate avec les etats, les transitions et l'alphabet de l'automate 1
aut3 = automaton.automaton(
alphabet=aut1.get_alphabet(), states=aut1.get_states(), transitions=aut1.get_transitions()
)
# on ajoute l'alphabet, les transitions et les etats de l'automate 2
aut3.add_characters(aut2.get_alphabet())
aut3.add_states(aut2.get_states())
aut3.add_transitions(aut2.get_transitions())
# on cree un super etat initial et un super etat final
aut3.add_initial_state("I")
aut3.add_final_state("F")
# on rajoute les epsilons transitions
for i in aut1.get_initial_states():
aut3.add_transition(("I", "0", i))
for f in aut2.get_final_states():
aut3.add_transition((f, "0", "F"))
for f in aut1.get_final_states():
for i in aut2.get_initial_states():
aut3.add_transition((f, "0", i))
return aut3
