def get_proof_term(self, thy, t): if isinstance(self.pt, str): self.pt = ProofTerm.theorem(thy, self.pt) if self.sym: self.pt = ProofTerm.symmetric(self.pt) # Deconstruct th into assumptions and conclusion As, C = self.pt.assums, self.pt.concl assert Term.is_equals(C), "rewr_conv: theorem is not an equality." tyinst, inst = dict(), dict() if self.match_vars: try: matcher.first_order_match_incr(C.lhs, t, (tyinst, inst)) except matcher.MatchException: raise ConvException() elif C.lhs != t: raise ConvException() pt = ProofTerm.substitution(inst, ProofTerm.subst_type(tyinst, self.pt)) if self.conds is not None: pt = ProofTerm.implies_elim(pt, *self.conds) As = pt.assums for A in As: pt = ProofTerm.implies_elim(pt, ProofTerm.assume(A)) return pt
def get_proof_term(self, thy, goal, *, args=None, prevs=None): assert isinstance(prevs, list) and len(prevs) == 1, "apply_prev" pt = prevs[0] assert pt.concl == goal.prop, "apply_prev" As_pts = [ProofTerm.sorry(Thm(goal.hyps, A)) for A in pt.assums] return ProofTerm.implies_elim(pt, *As_pts)
def compute_wp(thy, T, c, Q): """Compute the weakest precondition for the given command and postcondition. The computation is by case analysis on the form of c. Returns the validity theorem. """ if c.head.is_const_name("Assign"): # Assign a b a, b = c.args s = Var("s", T) P2 = Term.mk_abs(s, Q(function.mk_fun_upd(s, a, b(s).beta_conv()))) return apply_theorem(thy, "assign_rule", inst={"b": b}, concl=Valid(T)(P2, c, Q)) elif c.head.is_const_name("Seq"): # Seq c1 c2 c1, c2 = c.args wp1 = compute_wp(thy, T, c2, Q) # Valid Q' c2 Q wp2 = compute_wp(thy, T, c1, wp1.prop.args[0]) # Valid Q'' c1 Q' return apply_theorem(thy, "seq_rule", wp2, wp1) elif c.head.is_const_name("While"): # While b I c _, I, _ = c.args pt = apply_theorem(thy, "while_rule", concl=Valid(T)(I, c, Q)) pt0 = ProofTerm.assume(pt.assums[0]) pt1 = vcg(thy, T, pt.assums[1]) return ProofTerm.implies_elim(pt, pt0, pt1) else: raise NotImplementedError
def vcg_solve(thy, goal): """Compute the verification conditions for a hoare triple, then solves the verification conditions using SMT. """ pt = ProofTermDeriv("vcg", thy, goal, []) vc_pt = [ProofTermDeriv("z3", thy, vc, []) for vc in pt.assums] return ProofTerm.implies_elim(pt, *vc_pt)
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, args, pts): tyinst, inst = dict(), dict() if self.with_inst: name, tyinst, inst = args else: name = args th = thy.get_theorem(name) if not self.with_inst: As = th.assums for idx, pt in enumerate(pts): matcher.first_order_match_incr(As[idx], pt.prop, (tyinst, inst)) pt = ProofTerm.substitution( inst, ProofTerm.subst_type(tyinst, ProofTerm.theorem(thy, name))) if pt.prop.beta_norm() == pt.prop: pt2 = pt else: pt2 = top_conv(beta_conv()).apply_to_pt(thy, pt) for pt in pts: pt2 = ProofTerm.implies_elim(pt2, pt) return pt2