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]