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 search(self, state, id, prevs):
cur_th = state.get_proof_item(id).th
if cur_th.prop.is_all():
return []
thy = state.thy
results = []
for th_name, th in thy.get_data("theorems").items():
if 'hint_rewrite' not in thy.get_attributes(th_name):
continue
cv = top_conv(rewr_conv(th_name))
th = cv.eval(thy, cur_th.prop)
new_goal = th.prop.rhs
new_As = list(th.hyps)
if cur_th.prop != new_goal:
if Term.is_equals(new_goal) and new_goal.lhs == new_goal.rhs:
results.append({"theorem": th_name, "_goal": new_As})
else:
results.append({
"theorem": th_name,
"_goal": [new_goal] + new_As
})
return sorted(results, key=lambda d: d['theorem'])
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 expand(self, prefix, thy, args, prevs):
id, th = prevs[0]
assert Term.is_equals(th.prop), "beta_conv_rhs"
rhs = th.prop.rhs
prf = Proof()
prf.add_item(prefix + (0,), "beta_conv", args=rhs)
prf.add_item(prefix + (1,), "transitive", prevs=[id, prefix + (0,)])
return prf
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 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 eval(self, thy, args, ths):
th = ths[0]
assert Term.is_equals(th.prop), "beta_conv_rhs"
rhs = th.prop.rhs
return Thm.transitive(th, Thm.beta_conv(rhs))