def refresh_steps(self, catch_errors=True):
proof_checker.reset()
self.logic = LogicalCore(basic_tools=self.tools)
self.step_env = ToolStepEnv(self.logic)
self.vis.set_logic(self.logic, self.step_env.local_to_global)
self.step_env.run_steps(self.steps, 1, catch_errors=catch_errors)
self.check_goals()
self.vis.refresh()
def proof_check(self, num_args):
assert (self.proof is not None)
logic = LogicalCore(basic_tools=self.proof_tools)
args = logic.add_objs(num_args[:len(self.arg_types)])
env = ToolStepEnv(logic, args)
try:
env.run_steps(self.assumptions, 0)
#for num_arg, gi in zip(num_args, env.local_to_global):
# if not num_arg.identical_to(logic.num_model[gi]):
# raise ToolError("Extracted problem leads to different numerical values")
local_to_global_bak = list(env.local_to_global)
env.run_steps(self.proof, 1)
env.local_to_global = local_to_global_bak
env.run_steps(self.implications, 1)
except ToolError as e:
e.tool_traceback.append("Failed proof: {} {}".format(
self.name, num_args[:len(self.arg_types)]))
raise
def check_steps(steps, goals, imported_tools):
logic = LogicalCore(basic_tools=imported_tools)
step_env = ToolStepEnv(logic)
try:
step_env.run_steps(steps, 0, catch_errors=False)
step_env.run_steps(goals, 0, catch_errors=False)
return True
except ToolError:
return False
def merge_duplicities(steps, imported_tools):
logic = LogicalCore(basic_tools=imported_tools)
step_env = ToolStepEnv(logic)
step_env.run_steps(steps, 0, catch_errors=False)
global_to_local = dict()
old_to_new = []
for loc, glob in enumerate(step_env.local_to_global):
glob = logic.ufd.obj_to_root(glob)
old_to_new.append(global_to_local.setdefault(glob, loc))
new_steps = steps_var_replace(steps, old_to_new)
for step in steps:
new_local_args = tuple(old_to_new[x] for x in step.local_args)
new_step = ToolStep(step.tool, step.hyper_params, new_local_args,
len(old_to_new), step.debug_msg)
new_steps.append(new_step)
return new_steps, old_to_new
def load_file(self, fname):
self.viewport.reset_tool()
if fname is None: return
self.update_title(fname)
parser = Parser(self.imported_tools.tool_dict)
parser.parse_file(fname, axioms=True)
loaded_tool = parser.tool_dict['_', ()]
steps = loaded_tool.assumptions
names = [
loaded_tool.var_to_name_proof[x]
for x in range(len(loaded_tool.var_to_name_proof))
]
if loaded_tool.implications:
goals, proof = loaded_tool.implications, loaded_tool.proof
else:
goals, proof = None, None
self.env.set_steps(steps, names=names, goals=goals, proof=proof)
# hide objects
visible = set(loaded_tool.result) # old format
if visible:
for gi in range(len(self.vis.gi_to_hidden)):
self.vis.gi_to_hidden[gi] = gi not in visible
for gi, name in enumerate(names): # new format
if ("hide__{}".format(name), ()) in parser.tool_dict:
self.vis.gi_to_hidden[gi] = True
# set labels
for gi, name in enumerate(names): # new format
label_pos_tool = parser.tool_dict.get(
("label__{}".format(name), ()), None)
if label_pos_tool is not None:
self.vis.gi_label_show[gi] = True
logic = LogicalCore(basic_tools=self.imported_tools)
pos_l = label_pos_tool.run((), (), logic, 0)
pos_n = [logic.num_model[x] for x in pos_l]
t = self.vis.gi_to_type(gi)
if t == Point:
point, = pos_n
position = point.a
print(position)
elif t == Line:
position = tuple(d.x for d in pos_n)
elif t == Circle:
ang, offset = pos_n
position = ang.data * 2, offset.x
else:
print(
"Warning: save label: unexpected type {} of {}".format(
t, name))
continue
self.vis.gi_label_position[gi] = position
self.vis.refresh()
# viewport zoom and position
view_data_tool = parser.tool_dict.get(('view__data', ()), None)
if view_data_tool is None:
self.viewport.set_zoom((375, 277), 1)
else:
logic = LogicalCore(basic_tools=self.imported_tools)
anchor_l, zoom_l = view_data_tool.run((), (), logic, 0)
anchor = logic.num_model[anchor_l].a
zoom = logic.num_model[zoom_l].x
self.viewport.set_zoom(anchor, zoom)
self.reset_view()
header = line_info, line
mode = 'assume'
if mode != 'init': self.parse_tool(header, assump, impl, proof)
except Exception:
print("file: {}".format(fname))
raise
if __name__ == "__main__":
parser = Parser()
parser.parse_file("basic.gl")
for key, value in parser.tool_dict.items():
if isinstance(key, tuple):
name, in_types = key
in_types = ' '.join(x.__name__ for x in in_types)
else:
name, in_types = key, "???"
out_types = ' '.join(x.__name__ for x in value.out_types)
if out_types == '': out_types = '()'
print("{} : {} -> {}".format(name, in_types, out_types))
parser.parse_file("construction.gl")
logic = LogicalCore()
parser.tool_dict['line', (Point, Point)].add_symmetry((1,0))
parser.tool_dict['midpoint', (Point, Point)].add_symmetry((1,0))
parser.tool_dict['dist', (Point, Point)].add_symmetry((1,0))
parser.tool_dict['intersection', (Line, Line)].add_symmetry((1,0))
parser.tool_dict['_', ()].run((), (), logic, 1)
def compute_num_objs(steps, imported_tools):
logic = LogicalCore(basic_tools=imported_tools)
step_env = ToolStepEnv(logic)
step_env.run_steps(steps, 0, catch_errors=False)
return [logic.num_model[li] for li in step_env.local_to_global]