def Automate_in_one_lettre(Char: str) -> automaton:
nom = get_random_string(4)
if Char != "%":
nom = Automaton(nom)
nom.add_transition("0", Char, "1")
nom.make_accept("1")
return nom
else:
nom = Automaton(str(nom))
nom.add_transition("0", "%", "1")
nom.make_accept("1")
return nom
def main():
path = 'entrada.txt'
input_file = open_input(path)
transitions_raw = get_transitions(input_file)
intial_or_final = initial_and_final(input_file)
states_dict = get_states(transitions_raw, intial_or_final)
word = get_word(input_file)
states = load_states(states_dict)
transitions = load_transitions(states, transitions_raw)
a = Automaton('Automato Finito', word, transitions)
inicial = a.get_initials_list()
for i in inicial:
a.start_reach(word, i)
word = get_word(input_file)
#print(a.get_steps())
gif = 1
for s in a.get_steps():
save_dot_and_png(a, s)
save_gif(gif)
gif += 1
def union_to_automaton(self, first_aut, second_aut):
""" Converte uma expressao de uniao em seu respectivo automato """
final_state = self.create_state()
finals = {final_state}
initial = self.create_state()
states = first_aut.states.union(second_aut.states).union(
{initial, final_state})
alphabet = first_aut.alphabet.union(second_aut.alphabet)
resulting_function = {}
resulting_function.update(first_aut.function)
resulting_function.update(second_aut.function)
resulting_function[initial] = {
'&': {initial, first_aut.initial, second_aut.initial}
}
resulting_function[final_state] = {'&': finals}
for final in first_aut.finals.union(second_aut.finals):
resulting_function[final]['&'].add(final_state)
# print(f"resulting_function = {resulting_function}")
return Automaton(states, alphabet, resulting_function, finals, initial)
def determinise(automate: Automaton):
automateDet = Automaton("deterministe")
automateDet.initial = automate.initial
listeEtats = []
listeEtats.append(set([automate.initial.name]))
listeEtatsNew = listeEtats
print(listeEtats)
while len(listeEtats) != 0:
elt1 = listeEtats[0]
listeEtats = listeEtats[1:]
for elt11 in elt1:
for x in automate.alphabet:
EtatDest = []
for (source, symbol, destination) in automate.transitions:
if source == str(elt11) and symbol == x:
EtatDest.append(destination)
if (len(EtatDest) != 0) and EtatDest not in listeEtatsNew:
listeEtats.append(EtatDest)
listeEtatsNew.append(EtatDest)
automateDet.add_transition(str(elt1), x, str(EtatDest))
for etat in automate.acceptstates:
for elt1 in listeEtatsNew:
if etat in elt1:
automateDet.make_accept(str(elt1))
return automateDet
def parseAut(problem, it):
'''parseAut(problem, it) -> Automaton
Parses an automaton (resp. transducer) representation into an instance of the
Automaton class. Modifies problem, it.
'''
# initialize
aut = Automaton()
for line in it:
if (line == "}"): # end of automaton
return aut
elif (line[0:2] == "//"): # comments
pass
elif (line == ""): # empty string
pass
elif (reStartStates.match(line)): # start states
Parser.parseStartStates(aut, line)
elif (reAcceptStates.match(line)): # accepting states
Parser.parseAcceptStates(aut, line)
elif (reEpsTrans.match(line)): # epsilon transition
Parser.parseEpsTrans(aut, line)
elif (reAutTrans.match(line)) or (reTransdTrans.match(line)):
Parser.parseTrans(problem, aut, line)
else:
raise Exception("Syntax error: " + line)
def test_nfa_nfa_1(self):
"""Convertion from NFA to DFA."""
q1, q2, q3 = map(State, ['q1', 'q2', 'q3'])
q1.add_transition('b', q2)
q1.add_transition('$', q3)
q2.add_transition('a', [q2, q3])
q2.add_transition('b', q3)
q3.add_transition('a', q1)
M = Automaton('M', [q1, q2, q3], ['a', 'b'], q1, q1)
D = M.to_dfa()
self.assertTrue('q1' in D.Q[0].ready)
self.assertTrue('q3' in D.Q[0].ready)
self.assertEqual(len(D.Q[0].ready), 2)
self.assertTrue('q2' in D.Q[1].ready)
self.assertEqual(len(D.Q[1].ready), 1)
self.assertTrue('q2' in D.Q[2].ready)
self.assertTrue('q3' in D.Q[2].ready)
self.assertEqual(len(D.Q[2].ready), 2)
self.assertTrue('q3' in D.Q[3].ready)
self.assertEqual(len(D.Q[3].ready), 1)
self.assertTrue('q1' in D.Q[4].ready)
self.assertTrue('q2' in D.Q[4].ready)
self.assertTrue('q3' in D.Q[4].ready)
self.assertEqual(len(D.Q[4].ready), 3)
self.assertEqual(len(D.Q[5].ready), 0)
def closure_to_automaton(self, automaton):
""" Converte o fechamento para um automato """
final_state = self.create_state()
finals = {final_state}
initial = self.create_state()
states = automaton.states.union({initial, final_state})
alphabet = automaton.alphabet
resulting_function = {}
resulting_function.update(automaton.function)
resulting_function[initial] = {
'&': {initial, automaton.initial, final_state}
}
resulting_function[final_state] = {'&': finals}
finals_copy = automaton.finals.copy()
for final in finals_copy:
resulting_function[final]['&'].add(automaton.initial)
resulting_function[final]['&'].add(final_state)
# print(f"resulting_function = {resulting_function}")
return Automaton(states, alphabet, resulting_function, finals, initial)
def test_2(self):
"""Example 1.30, p. 51 (extension with epsilon transitions).
Michael Sipser, Introduction to the theory of computation, 3-rd ed.
"""
q1, q2, q3, q4 = map(State, ['q1', 'q2', 'q3', 'q4'])
q1.add_transition('1', [q1, q2])
q1.add_transition('0', q1)
q2.add_transition('0', q3)
q2.add_transition('1', q3)
q2.add_transition('$', q3)
q3.add_transition('0', q4)
q3.add_transition('1', q4)
q3.add_transition('$', q4)
M = Automaton('M', [q1, q2, q3, q4], ['0', '1'], q1, q4)
self.assertListEqual(M.active_states, [q1])
M.transition('0')
self.assertListEqual(M.active_states, [q1])
M.transition('1')
self.assertListEqual(M.active_states, [q1, q2, q3, q4])
M.transition('0')
self.assertListEqual(M.active_states, [q1, q3, q4])
M.transition('0')
self.assertListEqual(M.active_states, [q1, q4])
M.transition('1')
self.assertListEqual(M.active_states, [q1, q2, q3, q4])
M.transition('0')
self.assertListEqual(M.active_states, [q1, q3, q4])
M.transition('0')
self.assertListEqual(M.active_states, [q1, q4])
self.assertTrue(M.is_accepted())
def convert_graph_fmt(filename, fmt, output_dir=None):
automaton = Automaton(fromfile=filename)
filename_dir, filename_name = os.path.split(filename)
if output_dir:
filename_dir = output_dir
new_filename = os.path.join(filename_dir,
".".join([filename_name.split('.')[0], fmt]))
automaton.export(filename=new_filename)
def enabledToFair(autEnabled):
'''enabledToFair(autEnabled) -> Automaton
Encodes fairness into the Enabled automaton, thus obtaining the language of all
possible configurations with enabledness encoded.
'''
result = Automaton()
return result
def intersect(automaton1: Automaton, automaton2: Automaton) -> Automaton:
automaton1 = automaton1.as_DFA()
automaton2 = automaton2.as_DFA()
states = get_states_cross_product(automaton1, automaton2)
initial = automaton1.initial + automaton2.initial
accept = set()
for a1 in automaton1.accept:
for a2 in automaton2.accept:
accept.add(a1+a2)
alphabet = automaton1.alphabet | automaton2.alphabet
return Automaton(states, initial, accept, alphabet)
def test_app():
passwords = [
("x", "", "1"),
("want", "a", "epuu7Aeja9"),
("emerge", "bamboo", "zexae2Moo2"),
("question", "predict", "dahTho9Thai5yiasie1c"),
("quick fiber estate ripple phrase", "topic", "huu4aeju2gooth1iS6ai")
]
auto = Automaton()
client = Client(auto)
# Test password insertion
assert client.get_size() == 0
for i, (name, login, password) in enumerate(passwords):
auto.actions = "rb"
client.add(name, login, password)
assert client.get_size() == i+1
subtest_password_list(client, passwords)
subtest_has_name(client, passwords)
subtest_password_retrieval(client, auto, passwords)
# Export in plain text and also in encrypted form
# Do this before password removal testing
auto.actions = "brb"
export_plain = client.export(encrypt=False)
auto.actions = "b"
export_encrypted = client.export()
# Test password removal
removal_order = [name for name, _, _ in passwords]
random.shuffle(removal_order)
names = set(removal_order)
for name in removal_order:
auto.actions = "rb"
client.delete_by_name(name)
names.remove(name)
assert set(client.get_names()) == names
assert client.get_size() == 0
# Test import plain
subtest_clear(client, auto, passwords)
auto.actions = ";b"
client.import_("1.1.0", export_plain, encrypted=False)
subtest_password_list(client, passwords)
subtest_password_retrieval(client, auto, passwords)
# Test import encrypted
subtest_clear(client, auto, passwords)
auto.actions = ";b"
client.import_("1.1.0", export_encrypted, encrypted=True)
subtest_password_list(client, passwords)
subtest_password_retrieval(client, auto, passwords)
def kleene_star(automaton1: Automaton) -> Automaton:
states = automaton1.states
newInitial = State("kleen_initial")
states.add(newInitial)
for state in automaton1.states:
if state.name in automaton1.accept:
state.add_transition(newInitial.name, EPSILON_SYMBOL)
automaton1.accept.add(newInitial.name)
newInitial.add_transition(automaton1.initial, EPSILON_SYMBOL)
return Automaton(states, newInitial.name, automaton1.accept, automaton1.alphabet)
def main():
parser = argparse.ArgumentParser(
description="Operation for automatons"
)
parser.add_argument("--automaton1", "-a", dest="automaton1", type=str, required=True, help="File of the first automaton description")
parser.add_argument("--automaton2", "-b", dest="automaton2", type=str, help="File of the second automaton description. Not required for operation kleene_star")
parser.add_argument("--operation", "-o", dest="operation", type=str, required=True, choices=OPS, help="Operation to execute")
args = parser.parse_args()
automaton1 = Automaton(from_file=args.automaton1)
check_errors(automaton1.errors)
if args.operation != "kleene_star":
automaton2 = None
if args.automaton2:
automaton2 = Automaton(from_file=args.automaton2)
else:
print("Need to define --automaton2")
sys.exit(1)
check_errors(automaton2.errors)
result = getattr(operations, args.operation)(automaton1, automaton2)
else:
result = operations.kleene_star(automaton1)
print(result.render())
def get_rule_30(steps=None):
"""for get rule 30
Args:
steps (int): number of steps to run the rule 30
Returns:
cell_json(list): python object notation of """
# cells = [[0,0,0,0,1,0,0,0,0],
# [0,0,0,1,1,1,0,0,0],
# [0,0,1,1,0,0,1,0,0],
# [0,1,1,0,1,1,1,1,0],
# [1,1,0,0,1,0,0,0,1]]
cells = Automaton(steps, rule=30).string()
cell_json = [{"z": cells, "y": list(range(1, steps))}]
# cell_json = [{"z":cells}]
logging.info("\n" + str(Automaton(20, rule=30).string()))
return cell_json
def TestTP():
a1 = Automaton("dummy")
a1.from_txtfile("test/a.af")
a2 = Automaton("dummy1")
a2.from_txtfile("test/b.af")
a1.to_graphviz(a1.name + ".gv")
a2.to_graphviz(a2.name + ".gv")
print(a1)
print(a2)
print(concat(a1, a2))
a1star = kleene(a1)
print()
print(a1star)
a1star.to_graphviz("a1star.gv")
a1a2 = concat(a1, a2)
print()
print(a1a2)
a1a2.to_graphviz("a1a2.gv")
a1ora2 = union(a1, a2)
print()
print(a1ora2)
a1ora2.to_graphviz("a1ora2.gv")
def check(rules, tests, parser_args={}):
print "-" * 70
g = Grammar(rules)
a = Automaton(g)
fd = open(join(testdir, "tmp.py"), "w")
a.write_parser(fd)
fd.close()
del a, g
import tmp
reload(tmp)
p = tmp.Parser(**parser_args)
EOF.set_real_eof(p.EOF)
for input, e_tree, e_err in tests:
e_err = [(x[0], frozenset(x[1])) for x in e_err]
print "input: " + repr(input)
try:
tree = p.parse((x, k) for k, x in enumerate(input))
err = []
except p.ParseErrors, e:
tree = e.tree
err = e.errors
err = [(x[0], frozenset(x[1])) for x in err]
success = True
for e in e_err:
if e not in err:
print " missed error: " + repr(e)
success = False
for e in err:
if e not in e_err:
print " unexpected error: " + repr(e)
success = False
if e_tree != ignore and tree != e_tree:
print " unexpected result:"
print " expected: " + repr(e_tree)
print " got: " + repr(tree)
success = False
if success:
print " success"
else:
print " failure"
global errors
errors += 1
def main():
parser = argparse.ArgumentParser(
description='display 1-D cellular automaton')
parser.add_argument('rule', type=int, help='wolframe rule (0-255)')
parser.add_argument('steps', type=int, help='number of steps')
parser.add_argument('seed', help='bin(seed) -> first line')
parser.add_argument('--debug',
action='store_true',
help='for debug purpose')
parser.add_argument('--raw', action='store_true', help='display with 0,1')
args = parser.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
automaton = Automaton(args.rule, args.seed)
automaton.display()
automaton.print_steps(args.steps, args.raw)
def __init__(self, examples=None, automaton=None):
"""
:args:
automaton - (optional) instance of Automaton class
examples - list of strings, this can include the empty string ('')
"""
self.A = automaton if automaton else Automaton()
self.S = sorted(set(examples))
self.Σ = {char for s in self.S for char in s}
# If empty string is accepted, make root accepting state
self.root = self.A.add_node(
is_initial=True, is_final=True if self.S[0] == '' else False)
# Drop empty string from list of examples
if self.S[0] == '':
self.S = self.S[1:]
self.verbose = False
def concatenation_to_automaton(self, first_aut, second_aut): #pylint: disable=R0201
""" Converte uma expressao de concatenacao em seu respectivo automato """
states = first_aut.states.union(second_aut.states)
finals = second_aut.finals
initial = first_aut.initial
alphabet = first_aut.alphabet.union(second_aut.alphabet)
resulting_function = {}
resulting_function.update(first_aut.function)
resulting_function.update(second_aut.function)
finals_copy = first_aut.finals.copy()
for final in finals_copy:
resulting_function[final]['&'].add(second_aut.initial)
return Automaton(states, alphabet, resulting_function, finals, initial)
def concat(automaton1: Automaton, automaton2: Automaton) -> Automaton:
states = set()
for state in sorted(automaton1.states):
new_state = State(f"A1{state.name}")
for trans in state.transitions:
new_state.add_transition(f"A1{trans.target}", trans.symbol)
if state.name in automaton1.accept:
new_state.add_transition(f"A2{automaton2.initial}", EPSILON_SYMBOL)
states.add(new_state)
for state in sorted(automaton2.states):
new_state = State(f"A2{state.name}")
for trans in state.transitions:
new_state.add_transition(f"A2{trans.target}", trans.symbol)
states.add(new_state)
initial = f"A1{automaton1.initial}"
accept = set()
for state_name in automaton2.accept:
accept.add(f"A2{state_name}")
alphabet = automaton1.alphabet | automaton2.alphabet
return Automaton(states, initial, accept, alphabet)
def regexp_to_automaton(re: str) -> Automaton:
"""
Moore's algorithm: regular expression `re` -> non-deterministic automaton
"""
postfix = RegExpReader(re).to_postfix()
stack: List[Automaton] = []
for c in postfix:
if c in (".", "+", "*"):
right = stack.pop()
left = None
if c != "*":
left = stack.pop()
result = operation(left, right, c)
stack.append(result)
else:
automate = Automaton(c)
automate.add_transition("0", c, "1")
automate.make_accept("1")
stack.append(automate)
return stack[0]
def create_automaton(self, current_node=None):
""" Cria o automato que corresponde a expressao """
if current_node is None:
current_node = self.expression_tree
# print(f"Current node is {current_node.get_value()}")
if current_node.get_left_child(
) is None and current_node.get_right_child() is None:
state = self.create_state()
final = self.create_state()
function = {
state: {
'&': {state},
current_node.get_value(): {final}
},
final: {
'&': {final}
}
}
aut = Automaton({state, final}, {current_node.get_value()},
function, {final}, state)
return aut
if current_node.get_left_child() is not None:
left_aut = self.create_automaton(current_node.get_left_child())
if current_node.get_right_child() is not None:
right_aut = self.create_automaton(current_node.get_right_child())
if current_node.get_value() == '.':
return self.concatenation_to_automaton(left_aut, right_aut)
if current_node.get_value() == '+':
return self.union_to_automaton(left_aut, right_aut)
# O valor eh *
if current_node.get_left_child() is not None:
return self.closure_to_automaton(left_aut)
return self.closure_to_automaton(right_aut)
def test_1(self):
"""Example 1.35, p. 52.
Michael Sipser, Introduction to the theory of computation, 3-rd ed.
"""
q1, q2, q3 = map(State, ['q1', 'q2', 'q3'])
q1.add_transition('b', q2)
q1.add_transition('$', q3)
q2.add_transition('a', [q2, q3])
q2.add_transition('b', q3)
q3.add_transition('a', q1)
M = Automaton('M', [q1, q2, q3], ['a', 'b'], q1, q1)
self.assertListEqual(M.active_states, [q1, q3])
M.transition('b')
self.assertListEqual(M.active_states, [q2])
M.transition('a')
self.assertListEqual(M.active_states, [q2, q3])
M.transition('b')
self.assertListEqual(M.active_states, [q3])
M.transition('a')
self.assertListEqual(M.active_states, [q1, q3])
self.assertTrue(M.is_accepted())
M.reset()
self.assertListEqual(M.active_states, [q1, q3])
M.transition('b')
self.assertListEqual(M.active_states, [q2])
M.transition('a')
self.assertListEqual(M.active_states, [q2, q3])
M.transition('b')
self.assertListEqual(M.active_states, [q3])
M.transition('b')
self.assertListEqual(M.active_states, [])
M.transition('a')
self.assertListEqual(M.active_states, [])
self.assertTrue(not M.is_accepted())
def re2a(er, trace=False):
S = Automaton()
name = {}
q0 = er.shift(True, None)
name[q0] = 0
nq0 = name[q0]
if trace:
sys.stderr.write("Initial state: %d\nItems:\n%s\n" % (nq0, q0))
S.addState(nq0, q0)
S.makeInitial(nq0)
if q0.isFinal():
S.makeFinal(nq0, q0.category())
pending = set([q0])
while len(pending) != 0:
q = pending.pop()
nq = name[q]
for charClass in q.movements():
d = q.shift(False, charClass)
if not name.has_key(d):
pending.add(d)
name[d] = len(name)
nd = name[d]
S.addState(nd, d)
if trace:
sys.stderr.write(
"Added state: %d%s, from %d with class %s\nItems:\n%s\n"
% (nd, d.isFinal() and " (final)"
or "", nq, charClass, d))
if d.isFinal():
S.makeFinal(nd, d.category())
nd = name[d]
S.addTransition(nq, charClass, nd)
S.compactArcs()
return S
def union(a1: Automaton, a2: Automaton) -> Automaton:
# TODO: implement union
return a1
##################
if __name__ == "__main__":
if len(sys.argv) != 3:
usagestring = "Usage: {} <automaton-file1.af> <automaton-file2.af>"
error(usagestring.format(sys.argv[0]))
# First automaton, argv[1]
a1 = Automaton("dummy")
a1.from_txtfile(sys.argv[1])
a1.to_graphviz(a1.name + ".gv")
print(a1)
# Second automaton, argv[2]
a2 = Automaton("dummy")
a2.from_txtfile(sys.argv[2])
a2.to_graphviz(a2.name + ".gv")
print(a2)
a1star = kleene(a1)
print()
print(a1star)
a1star.to_graphviz("a1star.gv")
def delta0(q, e):
res = set()
if q == "q0":
if e == "a":
res = {"q2"}
elif e == "b":
res = {"q1"}
elif q == "q1":
if e == "a":
res = {"q3"}
elif e == "b":
res = {"q0"}
elif q == "q2":
if e == "a":
res = {"q2"}
elif e == "b":
res = {"q1"}
elif q == "q3":
if e == "a":
res = {"q3"}
elif e == "b":
res = {"q3"}
return res
automata = Automaton(states, alphabet, delta0, initial_state, final_states)
print(automata.execute({"q0"}, "a"))
print(automata.get_anti_language(5))
# -*- coding:utf-8 -*- from digraph import draw from automaton import Automaton from gui import GUI aut = Automaton() palabra = [] gui = GUI(aut, palabra) gui.show()
"""Example script that creates an image of 400 lines of rule 102."""
from automaton import Automaton
a = Automaton(102)
a.generate(400)
a.save_image("rule102.svg")
def gather_terminal_states(state_transitions, is_valid_pwd):
return [s for s in state_transitions if is_valid_pwd(s)]
if __name__ == "__main__":
# Solve https://math.stackexchange.com/q/2452401/329832,
# which should give 2,684,483,063,360
# Configure the password:
classes = [
string.ascii_uppercase,
string.digits,
]
MIN_LENGTH = 8
MAX_LENGTH = 10
# Predicates:
predicates = [
lambda s: MIN_LENGTH <= sum(s) <= MAX_LENGTH, # valid length?
lambda s: s[1], # has a digit?
]
is_valid_pwd = lambda s: all(pred(s) for pred in predicates)
state_transitions = generate_state_transitions(classes, MAX_LENGTH)
terminal_states = gather_terminal_states(state_transitions, is_valid_pwd)
automaton = Automaton(state_transitions, terminal_states)
start = time.time()
print(automaton.count_terminal_paths((0, ) * len(classes)))
elapsed = time.time() - start
print(f"Counted in {round(elapsed, 3)}s.")
