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