def add_option_group(parser):
"""Add Macro_Simulator options group to an OptParser parser object."""
assert isinstance(parser, OptionParser)
group = OptionGroup(parser, "Macro Simulator options")
group.add_option("--steps",
type=int,
default=INF,
help="Max steps to run each simulation (0 for infinite). "
"[Default: infinite]")
group.add_option("--time",
type=float,
default=15.0,
help="Max seconds to run each simulation. "
"[Default: %default]")
group.add_option("--tape-limit",
type=int,
default=50,
help="Max tape size to allow.")
group.add_option("--no-ctl",
dest="ctl",
action="store_false",
default=True,
help="Don't try CTL optimization.")
parser.add_option_group(group)
Simulator.add_option_group(parser)
Block_Finder.add_option_group(parser)
def run(machine, block_size, back, prover, recursive, options):
# Construct Machine (Backsymbol-k-Block-Macro-Machine)
# If no explicit block-size given, use inteligent software to find one
if not block_size:
block_size = Block_Finder.block_finder(machine, options)
# Do not create a 1-Block Macro-Machine (just use base machine)
if block_size != 1:
machine = Turing_Machine.Block_Macro_Machine(machine, block_size)
if back:
machine = Turing_Machine.Backsymbol_Macro_Machine(machine)
global sim # For debugging, especially with --manual
sim = Simulator.Simulator(machine, options)
if options.manual:
return # Let's us run the machine manually. Must be run as python -i Quick_Sim.py
try:
if options.quiet or options.verbose: # Note verbose prints inside sim.step()
if options.verbose:
sim.verbose_print()
total_loops = 0;
while (sim.op_state == Turing_Machine.RUNNING and
(options.loops == 0 or total_loops < options.loops)):
sim.step()
total_loops += 1;
else:
# TODO: maybe print based on time
total_loops = 0;
while (sim.op_state == Turing_Machine.RUNNING and
(options.loops == 0 or total_loops < options.loops)):
sim.print_self()
sim.loop_run(options.print_loops)
total_loops += options.print_loops;
finally:
sim.print_self()
if sim.op_state == Turing_Machine.HALT:
print
print "Turing Machine Halted!"
print
if options.compute_steps:
print "Steps: ", sim.step_num
print "Nonzeros:", sim.get_nonzeros()
print
elif sim.op_state == Turing_Machine.INF_REPEAT:
print
print "Turing Machine proven Infinite!"
print "Reason:", sim.inf_reason
elif sim.op_state == Turing_Machine.UNDEFINED:
print
print "Turing Machine reached Undefined transition!"
print "State: ", sim.op_details[0][1]
print "Symbol:", sim.op_details[0][0]
print
if options.compute_steps:
print "Steps: ", sim.step_num
print "Nonzeros:", sim.get_nonzeros()
print
help="Print step-by-step informaion from simulator "
"and prover (Overrides other --verbose-* flags).")
parser.add_option("-l", "--loops", type=int, default=0,
help="Specify a maximum number of loops.")
parser.add_option("--print-loops", type=int, default=10000, metavar="LOOPS",
help="Print every LOOPS loops [Default %default].")
parser.add_option("--csv", action="store_true",
help="Read input file as CSV not standard format.")
parser.add_option("--manual", action="store_true",
help="Don't run any simulation, just set up simulator "
"and quit. (Run as python -i Quick_Sim.py to interactively "
"run simulation.)")
Simulator.add_option_group(parser)
Block_Finder.add_option_group(parser)
(options, args) = parser.parse_args()
if options.quiet:
options.verbose_simulator = False
options.verbose_prover = False
options.verbose_block_finder = False
elif options.verbose:
options.verbose_simulator = True
options.verbose_prover = True
options.verbose_block_finder = True
if options.loops and options.print_loops > options.loops:
options.print_loops = options.loops
def recur_TM(TTable, block_size, back, prover, recursive, options):
# Construct Machine (Backsymbol-k-Block-Macro-Machine)
m = Turing_Machine.make_machine(TTable)
# If no explicit block-size given, use inteligent software to find one
if not block_size:
block_size = Block_Finder.block_finder(m, options)
#if not options.quiet:
# Turing_Machine.print_machine(m)
# Do not create a 1-Block Macro-Machine (just use base machine)
if block_size != 1:
m = Turing_Machine.Block_Macro_Machine(m, block_size)
if back:
m = Turing_Machine.Backsymbol_Macro_Machine(m)
global sim # For debugging, especially with --manual
sim = Simulator.Simulator(m, options)
if options.manual:
return # Let's us run the machine manually. Must be run as python -i Quick_Sim.py
groups = {}
total_loops = 0
# max_term_size = 100000000
while (sim.op_state == Turing_Machine.RUNNING
and (options.loops == 0 or total_loops < options.loops)):
# print "%10d" % sim.step_num," ",sim.tape.print_with_state(sim.state)
sim.step()
# if sim.step_num > max_term_size:
# break
if len(sim.tape.tape[0]) == 1 or len(sim.tape.tape[1]) == 1:
min_config = strip_config(sim.state, sim.dir, sim.tape.tape)
if len(min_config[0]) + len(min_config[-1]) <= 100:
if min_config in groups:
# if len(groups[min_config]) >= 100:
# groups[min_config].pop(0)
groups[min_config].append([
copy.deepcopy(sim.tape.tape[0][1:]),
copy.deepcopy(sim.tape.tape[1][1:]), sim.step_num
])
else:
groups[min_config] = [
[
copy.deepcopy(sim.tape.tape[0][1:]),
copy.deepcopy(sim.tape.tape[1][1:]), sim.step_num
],
]
total_loops += 1
#print "%10d" % sim.step_num," ",sim.tape.print_with_state(sim.state)
#print
sorted_keys = sorted(groups, key=lambda item: len(item[0]) + len(item[3]))
print Output_Machine.display_ttable(TTable), "|",
print "%5d" % len(groups)
for min_config in sorted_keys:
group = groups[min_config]
recur_all = False
if len(group) >= 4:
print " ", len(group), min_config
growth = [[]
for i in xrange(len(group[0][0]) + len(group[0][1]) + 1)]
for config in group:
index = 0
for symbol in config[0]:
growth[index].append(symbol.num)
index += 1
for symbol in config[1]:
growth[index].append(symbol.num)
index += 1
growth[index].append(config[2])
recur_all = True
for series in growth:
print " ", series
(recur_found, coefs, constant) = recur_fit(series)
if recur_found:
print " success",
recur_print(coefs, constant)
else:
print " failure"
recur_all = recur_all and recur_found
print
if recur_all:
break
print " ", recur_all
print
def run(TTable, block_size, steps, runtime, recursive, progress, options,
stats):
# Get and initialize a new simulator object.
m1 = Turing_Machine.Simple_Machine(TTable)
if not block_size:
# Find optimal macro block size automatically.
block_size = Block_Finder.block_finder(m1, options)
m2 = Turing_Machine.Block_Macro_Machine(m1, block_size)
m3 = Turing_Machine.Backsymbol_Macro_Machine(m2)
sim = Simulator.Simulator(m3, options)
# Run with an optional timer.
try:
if runtime:
ALARM.set_alarm(runtime)
sim.loop_run(steps)
ALARM.cancel_alarm()
except AlarmException:
ALARM.cancel_alarm()
sim.op_state = Turing_Machine.TIME_OUT
stats.num_rules += len(sim.prover.rules)
stats.num_recursive_rules += sim.prover.num_recursive_rules
stats.num_collatz_rules += sim.prover.num_collatz_rules
stats.num_failed_proofs += sim.prover.num_failed_proofs
if progress:
pprint(stats.__dict__)
if sim.op_state == Turing_Machine.RUNNING:
if progress:
print "\tMax_Steps", block_size, sim.step_num, sim.num_loops
# TODO(shawn): Return time taken.
return Exit_Condition.UNKNOWN, "Max_Steps", sim.get_nonzeros(), sim.step_num
elif sim.op_state == Turing_Machine.TIME_OUT:
if progress:
print "\tTimeout", block_size, sim.step_num, sim.num_loops
return Exit_Condition.UNKNOWN, "Time_Out", sim.get_nonzeros(), sim.step_num
elif sim.op_state == Turing_Machine.INF_REPEAT:
if progress:
global max_step2inf, max_loop2inf
max_step2inf = max(max_step2inf, sim.step_num)
max_loop2inf = max(max_loop2inf, sim.num_loops)
print "\tInfinite", block_size, (sim.step_num, max_step2inf),
print (sim.num_loops, max_loop2inf)
return (Exit_Condition.INFINITE, "Macro_Simulator",
block_size, len(sim.prover.rules), sim.prover.num_recursive_rules,
sim.step_num, sim.num_loops)
elif sim.op_state == Turing_Machine.HALT:
if progress:
print "\tHalted", sim.get_nonzeros(), sim.step_num
return (Exit_Condition.HALT, sim.get_nonzeros(), sim.step_num,
"Macro_Simulator", block_size, len(sim.prover.rules),
sim.prover.num_recursive_rules, sim.num_loops)
elif sim.op_state == Turing_Machine.UNDEFINED:
if progress:
print "\tUndefined", sim.get_nonzeros(), sim.step_num
# sim.op_details[0][0 & 1] stores the symbol and state that we halted on.
return (Exit_Condition.UNDEF_CELL,
int(sim.op_details[0][1]), int(sim.op_details[0][0]),
sim.get_nonzeros(), sim.step_num, "Macro_Simulator", block_size,
len(sim.prover.rules), sim.prover.num_recursive_rules, sim.num_loops)
else:
raise Exception, "unexpected op_state"
def run_options(ttable, options, stats=None):
"""Run the Accelerated Turing Machine Simulator, running a few simple filters
first and using intelligent blockfinding."""
if options.steps == 0:
options.steps = INF
if options.time:
# Note: We cannot practically use time.clock() because it often
# only has 10ms granularity.
start_time = time.time()
pre_sim_end_time = start_time + (options.time / 10)
end_time = start_time + options.time
else:
start_time = end_time = None
## Test for quickly for infinite machine
if Reverse_Engineer_Filter.test(ttable):
return Exit_Condition.INFINITE, ("Reverse_Engineer", )
## Construct the Macro Turing Machine (Backsymbol-k-Block-Macro-Machine)
m = Turing_Machine.make_machine(ttable)
block_size = options.block_size
if not block_size:
# If no explicit block-size given, use inteligent software to find one
block_size = Block_Finder.block_finder(m,
options,
end_time=pre_sim_end_time)
# Do not create a 1-Block Macro-Machine (just use base machine)
if block_size != 1:
m = Turing_Machine.Block_Macro_Machine(m, block_size)
if options.backsymbol:
m = Turing_Machine.Backsymbol_Macro_Machine(m)
if options.ctl:
CTL_config = setup_CTL(m, options.bf_limit1, end_time=pre_sim_end_time)
# Run CTL filters unless machine halted
if CTL_config:
CTL_config_copy = copy.deepcopy(CTL_config)
if CTL1.CTL(m, CTL_config_copy, end_time=pre_sim_end_time):
return Exit_Condition.INFINITE, ("CTL_A*", )
CTL_config_copy = copy.deepcopy(CTL_config)
if CTL2.CTL(m, CTL_config_copy, end_time=pre_sim_end_time):
return Exit_Condition.INFINITE, ("CTL_A*_B", )
## Set up the simulator
sim = Simulator.Simulator(m, options, end_time=end_time)
## Run the simulator
while (sim.step_num < options.steps
and sim.op_state == Turing_Machine.RUNNING
and sim.tape.compressed_size() <= options.tape_limit):
sim.step()
if sim.op_state == Turing_Machine.TIME_OUT and sim.step_num == 0:
sim.op_state = Turing_Machine.RUNNING
sim.end_time += options.time
# TODO(shawn): pass the stats object into sim so we don't have to copy.
if stats:
stats.num_rules += len(sim.prover.rules)
stats.num_recursive_rules += sim.prover.num_recursive_rules
stats.num_collatz_rules += sim.prover.num_collatz_rules
stats.num_failed_proofs += sim.prover.num_failed_proofs
## Resolve end conditions and return relevent info.
if sim.tape.compressed_size() > options.tape_limit:
return Exit_Condition.OVER_TAPE, (sim.tape.compressed_size(),
sim.step_num)
elif sim.op_state == Turing_Machine.TIME_OUT:
return Exit_Condition.TIME_OUT, (time.time() - start_time,
sim.step_num)
elif sim.op_state == Turing_Machine.RUNNING:
return Exit_Condition.MAX_STEPS, (sim.step_num, )
elif sim.op_state == Turing_Machine.HALT:
return Exit_Condition.HALT, (sim.step_num, sim.get_nonzeros())
elif sim.op_state == Turing_Machine.INF_REPEAT:
return Exit_Condition.INFINITE, (sim.inf_reason, )
elif sim.op_state == Turing_Machine.UNDEFINED:
on_symbol, on_state = sim.op_details[0][:2]
return Exit_Condition.UNDEF_CELL, (on_state, on_symbol, sim.step_num,
sim.get_nonzeros())
raise Exception, (sim.op_state, ttable, sim)