def get_proof_term(self, thy, t): if t.arg1 == zero: cv = rewr_conv("times_def_1") elif t.arg == zero: cv = rewr_conv("mult_0_right") elif t.arg1 == one: cv = rewr_conv("mult_1_left") elif t.arg == one: cv = rewr_conv("mult_1_right") elif is_times(t.arg1): cmp = compare_atom(t.arg1.arg, t.arg) if cmp == term_ord.GREATER: cv = then_conv(swap_times_r(), arg1_conv(norm_mult_atom())) elif cmp == term_ord.EQUAL: if is_binary(t.arg): cv = then_conv(rewr_conv("mult_assoc"), arg_conv(nat_conv())) else: cv = all_conv() else: cv = all_conv() else: cmp = compare_atom(t.arg1, t.arg) if cmp == term_ord.GREATER: cv = rewr_conv("mult_comm") elif cmp == term_ord.EQUAL: if is_binary(t.arg): cv = nat_conv() else: cv = all_conv() else: cv = all_conv() return cv.get_proof_term(thy, t)
def get_proof_term(self, thy, t): if is_binary(t): cv = all_conv() elif is_Suc(t): cv = then_conv(rewr_conv("add_1_right", sym=True), norm_full()) elif is_plus(t): cv = then_conv(binop_conv(norm_full()), norm_add_polynomial()) elif is_times(t): cv = then_conv(binop_conv(norm_full()), norm_mult_polynomial()) else: cv = all_conv() return cv.get_proof_term(thy, t)
def get_proof_term(self, thy, t): if is_conj(t.arg1): return then_conv( rewr_conv("conj_assoc", sym=True), arg_conv(norm_conj_assoc_clauses())).get_proof_term(thy, t) else: return all_conv().get_proof_term(thy, t)
def get_proof_term(self, goal, *, args=None, prevs=None): th_name = args C = goal.prop # Check whether rewriting using the theorem has an effect assert has_rewrite(th_name, C, sym=self.sym, conds=prevs), \ "rewrite: unable to apply theorem." cv = then_conv( top_sweep_conv(rewr_conv(th_name, sym=self.sym, conds=prevs)), beta_norm_conv()) eq_th = cv.eval(C) new_goal = eq_th.prop.rhs if self.sym: macro_name = 'rewrite_goal_sym' else: macro_name = 'rewrite_goal' if new_goal.is_equals() and new_goal.lhs == new_goal.rhs: return ProofTerm(macro_name, args=(th_name, C), prevs=prevs) else: new_goal = ProofTerm.sorry(Thm(goal.hyps, new_goal)) assert new_goal.prop != goal.prop, "rewrite: unable to apply theorem" return ProofTerm(macro_name, args=(th_name, C), prevs=[new_goal] + prevs)
def get_proof_term(self, goal, *, args=None, prevs=None): assert isinstance(prevs, list) and len(prevs) == 1, "rewrite_goal_with_prev" pt = prevs[0] C = goal.prop # In general, we assume pt.th has forall quantification. # First, obtain the patterns new_names = logic.get_forall_names(pt.prop) new_vars, prev_As, prev_C = logic.strip_all_implies(pt.prop, new_names) # Fact used must be an equality assert len( prev_As) == 0 and prev_C.is_equals(), "rewrite_goal_with_prev" for new_var in new_vars: pt = pt.forall_elim(new_var) # Check whether rewriting using the theorem has an effect assert has_rewrite(pt.th, C), "rewrite_goal_with_prev" cv = then_conv(top_sweep_conv(rewr_conv(pt)), beta_norm_conv()) eq_th = cv.eval(C) new_goal = eq_th.prop.rhs prevs = list(prevs) if not new_goal.is_reflexive(): prevs.append(ProofTerm.sorry(Thm(goal.hyps, new_goal))) return ProofTerm('rewrite_goal_with_prev', args=C, prevs=prevs)
def get_proof_term(self, thy, goal, *, args=None, prevs=None): assert isinstance(prevs, list) and len(prevs) == 1, "rewrite_goal_with_prev" pt = prevs[0] init_As = goal.hyps C = goal.prop cv = then_conv(top_sweep_conv(rewr_conv(pt, match_vars=False)), top_conv(beta_conv())) eq_th = cv.eval(thy, C) new_goal = eq_th.prop.rhs new_As = list(set(eq_th.hyps) - set(init_As)) new_As_pts = [ProofTerm.sorry(Thm(init_As, A)) for A in new_As] if Term.is_equals(new_goal) and new_goal.lhs == new_goal.rhs: return ProofTermDeriv('rewrite_goal_with_prev', thy, args=C, prevs=[pt] + new_As_pts) else: new_goal_pts = ProofTerm.sorry(Thm(init_As, new_goal)) return ProofTermDeriv('rewrite_goal_with_prev', thy, args=C, prevs=[pt, new_goal_pts] + new_As_pts)
def get_proof_term(self, args, pts): assert isinstance(args, Term), "rewrite_goal_macro: signature" goal = args eq_pt = pts[0] new_names = get_forall_names(eq_pt.prop) new_vars, _, _ = strip_all_implies(eq_pt.prop, new_names) for new_var in new_vars: eq_pt = eq_pt.forall_elim(new_var) pts = pts[1:] cv = then_conv(top_sweep_conv(rewr_conv(eq_pt, sym=self.sym)), beta_norm_conv()) pt = cv.get_proof_term(goal) # goal = th.prop pt = pt.symmetric() # th.prop = goal if pt.prop.lhs.is_reflexive(): pt = pt.equal_elim(refl(pt.prop.lhs.rhs)) else: pt = pt.equal_elim(pts[0]) pts = pts[1:] for A in pts: pt = pt.implies_intr(A.prop).implies_elim(A) return pt
def interval_union_subset(t): """Given t of the form I1 Un I2, return a theorem of the form I1 Un I2 SUB I. """ assert t.is_comb('union', 2), "interval_union_subset" I1, I2 = t.args a, b = I1.args c, d = I2.args if is_closed_interval(I1) and is_closed_interval(I2): pt = apply_theorem('closed_interval_union', inst=Inst(a=a, b=b, c=c, d=d)) return pt.on_prop( arg_conv( then_conv(arg1_conv(const_min_conv()), arg_conv(const_max_conv())))) elif is_open_interval(I1) and is_ropen_interval(I2): if eval_hol_expr(c) <= eval_hol_expr(a): pt = apply_theorem('open_ropen_interval_union1', auto.auto_solve(real.less_eq(c, a)), inst=Inst(b=b, d=d)) else: pt = apply_theorem('open_ropen_interval_union2', auto.auto_solve(real.less(a, c)), inst=Inst(b=b, d=d)) return pt.on_prop(arg_conv(arg_conv(const_max_conv()))) else: raise NotImplementedError return pt
def get_proof_term(self, thy, args, pts): assert len(pts) == 1 and isinstance( args, str), "rewrite_fact_macro: signature" th_name = args eq_pt = ProofTerm.theorem(thy, th_name) cv = then_conv(top_sweep_conv(rewr_conv(eq_pt)), top_conv(beta_conv())) return pts[0].on_prop(thy, cv)
def get_proof_term(self, t): if t.is_conj(): return then_conv( binop_conv(norm_conj_assoc()), norm_conj_assoc_clauses() ).get_proof_term(t) else: return all_conv().get_proof_term(t)
def get_proof_term(self, thy, t): n = t.arg # remove Suc if n == zero: return all_conv().get_proof_term(thy, t) elif n == one: return rewr_conv("one_Suc").get_proof_term(thy, t) elif n.head == bit0: return rewr_conv("bit0_Suc").get_proof_term(thy, t) else: return then_conv(rewr_conv("bit1_Suc"), arg_conv(self)).get_proof_term(thy, t)
def get_proof_term(self, thy, t): if not (is_plus(t) and is_binary(t.arg1) and is_binary(t.arg)): raise ConvException n1, n2 = t.arg1, t.arg # two summands if n1 == zero: cv = rewr_conv("plus_def_1") elif n2 == zero: cv = rewr_conv("add_0_right") elif n1 == one: cv = then_conv(rewr_conv("add_1_left"), Suc_conv()) elif n2 == one: cv = then_conv(rewr_conv("add_1_right"), Suc_conv()) elif n1.head == bit0 and n2.head == bit0: cv = then_conv(rewr_conv("bit0_bit0_add"), arg_conv(self)) elif n1.head == bit0 and n2.head == bit1: cv = then_conv(rewr_conv("bit0_bit1_add"), arg_conv(self)) elif n1.head == bit1 and n2.head == bit0: cv = then_conv(rewr_conv("bit1_bit0_add"), arg_conv(self)) else: cv = every_conv(rewr_conv("bit1_bit1_add"), arg_conv(arg_conv(self)), arg_conv(Suc_conv())) return cv.get_proof_term(thy, t)
def get_proof_term(self, thy, t): if t.arg1 == zero: cv = rewr_conv("plus_def_1") elif t.arg == zero: cv = rewr_conv("add_0_right") elif is_plus(t.arg1): cmp = compare_monomial(t.arg1.arg, t.arg) if cmp == term_ord.GREATER: cv = then_conv(swap_add_r(), arg1_conv(norm_add_monomial())) elif cmp == term_ord.EQUAL: cv = then_conv(rewr_conv("add_assoc"), arg_conv(combine_monomial(thy))) else: cv = all_conv() else: cmp = compare_monomial(t.arg1, t.arg) if cmp == term_ord.GREATER: cv = rewr_conv("add_comm") elif cmp == term_ord.EQUAL: cv = combine_monomial(thy) else: cv = all_conv() return cv.get_proof_term(thy, t)
def get_proof_term(self, thy, t): n1, n2 = t.arg1, t.arg # two summands if n1 == zero: cv = rewr_conv("times_def_1") elif n2 == zero: cv = rewr_conv("mult_0_right") elif n1 == one: cv = rewr_conv("mult_1_left") elif n2 == one: cv = rewr_conv("mult_1_right") elif n1.head == bit0 and n2.head == bit0: cv = then_conv(rewr_conv("bit0_bit0_mult"), arg_conv(arg_conv(self))) elif n1.head == bit0 and n2.head == bit1: cv = then_conv(rewr_conv("bit0_bit1_mult"), arg_conv(self)) elif n1.head == bit1 and n2.head == bit0: cv = then_conv(rewr_conv("bit1_bit0_mult"), arg_conv(self)) else: cv = every_conv(rewr_conv("bit1_bit1_mult"), arg_conv(arg1_conv(add_conv())), arg_conv(arg_conv(arg_conv(self))), arg_conv(add_conv())) return cv.get_proof_term(thy, t)
def get_proof_term(self, args, pts): assert isinstance(args, str), "rewrite_fact_macro: signature" th_name = args eq_pt = ProofTerm.theorem(th_name) assert len(pts) == len(eq_pt.assums) + 1, "rewrite_fact_macro: signature" # Check rewriting using the theorem has an effect if not has_rewrite(th_name, pts[0].prop, sym=self.sym, conds=pts[1:]): raise InvalidDerivationException("rewrite_fact using %s" % th_name) cv = then_conv(top_sweep_conv(rewr_conv(eq_pt, sym=self.sym, conds=pts[1:])), beta_norm_conv()) res = pts[0].on_prop(cv) if res == pts[0]: raise InvalidDerivationException("rewrite_fact using %s" % th_name) return res
def get_proof_term(self, thy, args, pts): assert isinstance(args, tuple) and len(args) == 2 and \ isinstance(args[0], str) and isinstance(args[1], Term), "rewrite_goal_macro: signature" name, goal = args eq_pt = ProofTerm.theorem(thy, name) if self.backward: eq_pt = ProofTerm.symmetric(eq_pt) cv = then_conv(top_conv(rewr_conv(eq_pt)), top_conv(beta_conv())) pt = cv.get_proof_term(thy, goal) # goal = th.prop pt = ProofTerm.symmetric(pt) # th.prop = goal if Term.is_equals(pt.prop.lhs) and pt.prop.lhs.lhs == pt.prop.lhs.rhs: pt = ProofTerm.equal_elim(pt, ProofTerm.reflexive(pt.prop.lhs.lhs)) else: pt = ProofTerm.equal_elim(pt, pts[0]) # goal pts = pts[1:] for A in pts: pt = ProofTerm.implies_elim(ProofTerm.implies_intr(A.prop, pt), A) return pt
def get_proof_term(self, thy, args, pts): assert isinstance(args, Term), "rewrite_goal_macro: signature" goal = args eq_pt = pts[0] pts = pts[1:] if self.backward: eq_pt = ProofTerm.symmetric(eq_pt) cv = then_conv(top_sweep_conv(rewr_conv(eq_pt, match_vars=False)), top_conv(beta_conv())) pt = cv.get_proof_term(thy, goal) # goal = th.prop pt = ProofTerm.symmetric(pt) # th.prop = goal if Term.is_equals(pt.prop.lhs) and pt.prop.lhs.lhs == pt.prop.lhs.rhs: pt = ProofTerm.equal_elim(pt, ProofTerm.reflexive(pt.prop.lhs.rhs)) else: pt = ProofTerm.equal_elim(pt, pts[0]) pts = pts[1:] for A in pts: pt = ProofTerm.implies_elim(ProofTerm.implies_intr(A.prop, pt), A) return pt
def get_proof_term(self, thy, goal, args=None, prevs=None): th_name = args init_As = goal.hyps C = goal.prop cv = then_conv(top_conv(rewr_conv(th_name)), top_conv(beta_conv())) eq_th = cv.eval(thy, C) new_goal = eq_th.prop.rhs new_As = list(eq_th.hyps) new_As_pts = [ProofTerm.sorry(Thm(init_As, A)) for A in new_As] if Term.is_equals(new_goal) and new_goal.lhs == new_goal.rhs: return ProofTermDeriv('rewrite_goal', thy, args=(th_name, C), prevs=new_As_pts) else: new_goal_pts = ProofTerm.sorry(Thm(init_As, new_goal)) return ProofTermDeriv('rewrite_goal', thy, args=(th_name, C), prevs=[new_goal_pts] + new_As_pts)
def get_proof_term(self, args, pts): assert len(pts) == 2, "rewrite_fact_with_prev" eq_pt, pt = pts # In general, we assume eq_pt has forall quantification # First, obtain the patterns new_names = get_forall_names(eq_pt.prop) new_vars, eq_As, eq_C = strip_all_implies(eq_pt.prop, new_names) # First fact must be an equality assert len(eq_As) == 0 and eq_C.is_equals(), "rewrite_fact_with_prev" for new_var in new_vars: eq_pt = eq_pt.forall_elim(new_var) # Check rewriting using eq_pt has an effect cv1 = top_sweep_conv(rewr_conv(eq_pt)) assert not cv1.eval(pt.prop).is_reflexive(), "rewrite_fact_with_prev" cv = then_conv(cv1, beta_norm_conv()) return pt.on_prop(cv)
def get_proof_term(self, args, pts): assert isinstance(args, tuple) and len(args) == 2 and \ isinstance(args[0], str) and isinstance(args[1], Term), "rewrite_goal: signature" name, goal = args eq_pt = ProofTerm.theorem(name) if len(pts) == len(eq_pt.assums): rewr_cv = rewr_conv(eq_pt, sym=self.sym, conds=pts) else: assert len(pts) == len(eq_pt.assums) + 1, "rewrite_goal: wrong number of prevs" rewr_cv = rewr_conv(eq_pt, sym=self.sym, conds=pts[1:]) cv = then_conv(top_sweep_conv(rewr_cv), beta_norm_conv()) pt = cv.get_proof_term(goal) # goal = th.prop pt = pt.symmetric() # th.prop = goal if pt.prop.lhs.is_equals() and pt.prop.lhs.lhs == pt.prop.lhs.rhs: pt = pt.equal_elim(refl(pt.prop.lhs.lhs)) else: pt = pt.equal_elim(pts[0]) # goal return pt
def search(self, state, id, prevs): if len(prevs) != 1: return [] prev_th = state.get_proof_item(prevs[0]).th cur_th = state.get_proof_item(id).th if not prev_th.prop.is_equals(): return [] pt = ProofTermAtom(prevs[0], prev_th) cv = then_conv(top_sweep_conv(rewr_conv(pt, match_vars=False)), top_conv(beta_conv())) eq_th = cv.eval(state.thy, cur_th.prop) new_goal = eq_th.prop.rhs new_As = list(set(eq_th.hyps) - set(cur_th.hyps)) if cur_th.prop != new_goal: if Term.is_equals(new_goal) and new_goal.lhs == new_goal.rhs: return [{"_goal": new_As}] else: return [{"_goal": [new_goal] + new_As}] else: return []
def get_proof_term(self, thy, args, pts): eq_pt, pt = pts cv = then_conv(top_sweep_conv(rewr_conv(eq_pt, match_vars=False)), top_conv(beta_conv())) return pt.on_prop(thy, cv)
def Sem(T): return Const("Sem", TFun(comT(T), T, T, boolT)) def Valid(T): return Const("Valid", TFun(TFun(T, boolT), comT(T), TFun(T, boolT), boolT)) def Entail(T): return Const("Entail", TFun(TFun(T, boolT), TFun(T, boolT), boolT)) # Normalize evaluation of function as well as arithmetic. norm_cv = then_conv(top_conv(function.fun_upd_eval_conv()), nat.norm_full()) # Normalize a condition. norm_cond_cv = every_conv(norm_cv, top_conv(nat.nat_eq_conv()), logic.norm_bool_expr()) def eval_Sem(thy, com, st): """Evaluates the effect of program com on state st.""" f, args = com.strip_comb() T = st.get_type() if f.is_const_name("Skip"): return apply_theorem(thy, "Sem_Skip", tyinst={"a": T}, inst={"s": st}) elif f.is_const_name("Assign"): a, b = args Ta = a.get_type()