def testCheckProof2(self):
"""Proof of |- A --> A."""
prf = Proof(A)
prf.add_item(1, "implies_intr", args=A, prevs=[0])
rpt = ProofReport()
self.assertEqual(theory.check_proof(prf, rpt), Thm([], Implies(A,A)))
self.assertEqual(rpt.steps, 2)
def testCheckProof(self):
"""Proof of [A, A --> B] |- B."""
A_to_B = Implies(A, B)
prf = Proof(A_to_B, A)
prf.add_item(2, "implies_elim", prevs=[0, 1])
rpt = ProofReport()
self.assertEqual(theory.check_proof(prf, rpt), Thm([A_to_B, A], B))
self.assertEqual(rpt.steps, 3)
def testTopSweepConv(self):
f = Const("f", TFun(natT, natT))
x = Var("x", natT)
th0 = eq(x, f(x))
cv = top_sweep_conv(rewr_conv(ProofTerm.atom(0, th0),
match_vars=False))
prf = Proof()
prf.add_item(0, "sorry", th=th0)
cv.get_proof_term(thy, f(x)).export(prf=prf)
self.assertEqual(thy.check_proof(prf), eq(f(x), f(f(x))))
def testExport3(self):
"""Case with atoms."""
pt1 = ProofTerm.atom(0, Thm([], Eq(x, y)))
pt2 = ProofTerm.atom(1, Thm([], Eq(y, z)))
pt3 = pt1.transitive(pt2)
prf = Proof()
prf.add_item(0, rule="sorry", th=Thm([], Eq(x, y)))
prf.add_item(1, rule="sorry", th=Thm([], Eq(y, z)))
pt3.export(prf=prf)
self.assertEqual(theory.check_proof(prf), Thm([], Eq(x, z)))
def testRewrConvWithAssum(self):
x = Const("x", natT)
y = Const("y", natT)
x_eq_y = Term.mk_equals(x, y)
th = Thm([], Term.mk_implies(x_eq_y, x_eq_y))
cv = arg_conv(rewr_conv(ProofTerm.atom(0, th)))
f = Const("f", TFun(natT, natT))
res = Thm([x_eq_y], Term.mk_equals(f(x), f(y)))
self.assertEqual(cv.eval(thy, f(x)), res)
prf = Proof()
prf.add_item(0, "sorry", th=th)
cv.get_proof_term(thy, f(x)).export(prf=prf)
self.assertEqual(thy.check_proof(prf), res)
def testCheckProof3(self):
"""Proof of [x = y, y = z] |- f z = f x."""
x_eq_y = Eq(x,y)
y_eq_z = Eq(y,z)
prf = Proof(x_eq_y, y_eq_z)
prf.add_item(2, "transitive", prevs=[0, 1])
prf.add_item(3, "symmetric", prevs=[2])
prf.add_item(4, "reflexive", args=f)
prf.add_item(5, "combination", prevs=[4, 3])
rpt = ProofReport()
th = Thm([x_eq_y, y_eq_z], Eq(f(z),f(x)))
self.assertEqual(theory.check_proof(prf, rpt), th)
self.assertEqual(rpt.steps, 6)
def testProof(self):
prf = Proof(A_to_B, A)
prf.vars = [A, B]
th = Thm([A, A_to_B], B)
prf.add_item(2, "implies_elim", prevs=[0, 1], th=th)
self.assertEqual(len(prf.items), 3)
self.assertEqual(prf.items[-1].th, th)
str_prf = "\n".join([
"0: assume implies A B", "1: assume A",
"2: A, implies A B |- B by implies_elim from 0, 1"
])
self.assertEqual(str(prf), str_prf)
def testFunCombination(self):
thy = basic.load_theory('logic_base')
macro = logic_macro.fun_combination_macro()
f_eq_g = Term.mk_equals(f, g)
fx_eq_gx = Term.mk_equals(f(x), g(x))
th = Thm.assume(f_eq_g)
res = Thm([f_eq_g], fx_eq_gx)
self.assertEqual(macro.eval(thy, x, [th]), res)
prf = Proof(f_eq_g)
prf.add_item(1, "fun_combination", args=x, prevs=[0])
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt), res)
self.assertEqual(rpt.macros_expand, {"fun_combination"})
self.assertEqual(rpt.prim_steps, 3)
def init_state(thy, vars, assums, concl):
"""Construct initial partial proof for the given assumptions and
conclusion.
assums - assumptions A1, ... An.
concl - conclusion C.
Constructs:
0: assume A1
...
n-1: assume An
n: C by sorry
n+1: A1 --> ... --> An --> C by intros from 0, 1, ..., n.
"""
assert all(isinstance(var, Term)
for var in vars), "init_state: vars must be terms."
assert all(isinstance(a, Term)
for a in assums), "init_state: assums must be terms."
assert isinstance(concl,
Term), "init_state: conclusion must be a term."
state = ProofState(thy)
state.vars = vars
state.prf = Proof(*assums)
n = len(assums)
state.prf.add_item(n, "sorry", th=Thm(assums, concl))
if len(assums) > 0:
state.prf.add_item(n + 1, "intros", prevs=range(n + 1))
state.check_proof(compute_only=True)
return state
def export(self, prefix=None, prf=None, subproof=True):
"""Convert to proof object."""
if prefix is None:
prefix = tuple()
if prf is None:
prf = Proof()
return self._export(prefix, dict(), prf, subproof)
def parse_init_state(prop):
"""Given data for a theorem statement, construct the initial partial proof.
data['vars']: list of variables.
data['prop']: proposition to be proved. In the form A1 --> ... --> An --> C.
Construct initial partial proof for the given assumptions and
conclusion.
assums - assumptions A1, ... An.
concl - conclusion C.
Constructs:
0: assume A1
...
n-1: assume An
n: C by sorry
n+1: A1 --> ... --> An --> C by intros from 0, 1, ..., n.
"""
typecheck.checkinstance('parse_init_state', prop, (str, list, Term))
if isinstance(prop, (str, list)):
prop = parser.parse_term(prop)
assums, concl = prop.strip_implies()
state = ProofState()
for nm, T in context.ctxt.vars.items():
state.vars.append(Var(nm, T))
state.prf = Proof(*assums)
n = len(assums)
state.prf.add_item(n, "sorry", th=Thm(assums, concl))
state.prf.add_item(n + 1, "intros", prevs=range(n + 1))
state.check_proof(compute_only=True)
return state
def testArgCombination(self):
thy = basic.load_theory('logic_base')
macro = logic_macro.arg_combination_macro()
x_eq_y = Term.mk_equals(x, y)
fx_eq_fy = Term.mk_equals(f(x), f(y))
th = Thm.assume(x_eq_y)
res = Thm([x_eq_y], fx_eq_fy)
self.assertEqual(macro.eval(thy, f, [th]), res)
prf = Proof(x_eq_y)
prf.add_item(1, "arg_combination", args=f, prevs=[0])
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt), res)
self.assertEqual(rpt.macros_expand, {"arg_combination"})
self.assertEqual(rpt.prim_steps, 3)
def testCheckProofGap(self):
"""Check proof with gap."""
prf = Proof()
prf.add_item(0, "sorry", th = Thm([], Implies(A,B)))
prf.add_item(1, "sorry", th = Thm([], A))
prf.add_item(2, "implies_elim", prevs=[0, 1])
rpt = ProofReport()
self.assertEqual(theory.check_proof(prf, rpt), Thm([], B))
self.assertEqual(rpt.gaps, [Thm([], Implies(A, B)), Thm([], A)])
def run_test(self,
thy_name,
tactic,
*,
vars=None,
prevs=None,
goal,
args=None,
new_goals=None,
failed=None):
"""Test a single invocation of a tactic."""
context.set_context(thy_name, vars=vars)
assms = [parser.parse_term(prev)
for prev in prevs] if prevs is not None else []
prf = Proof(*assms)
prevs = [
ProofTerm.atom(i, Thm.assume(assm)) for i, assm in enumerate(assms)
]
goal = parser.parse_term(goal)
goal_pt = ProofTerm.sorry(Thm(assms, goal))
# Invoke the tactic to get the proof term
if failed is not None:
self.assertRaises(failed,
tactic.get_proof_term,
goal_pt,
prevs=prevs,
args=args)
return
pt = tactic.get_proof_term(goal_pt, prevs=prevs, args=args)
# Export and check proof
prefix = ItemID(len(prevs) -
1) if len(prevs) > 0 else ItemID(len(prevs))
prf = pt.export(prefix=prefix, prf=prf, subproof=False)
self.assertEqual(theory.check_proof(prf), Thm(assms, goal))
# Test agreement of new goals
new_goals = [parser.parse_term(new_goal) for new_goal in new_goals
] if new_goals is not None else []
concls = [goal.prop for goal in prf.get_sorrys()]
self.assertEqual(new_goals, concls)
def testTrueAbsorb(self):
"""Proof of A --> true & A."""
thy = basic.load_theory('logic_base')
A = Var("A", boolT)
prf = Proof(A)
prf.add_item(1, "theorem", args="trueI")
prf.add_item(2, "theorem", args="conjI")
prf.add_item(3,
"substitution",
args={
"A": logic.true,
"B": A
},
prevs=[2])
prf.add_item(4, "implies_elim", prevs=[3, 1])
prf.add_item(5, "implies_elim", prevs=[4, 0])
prf.add_item(6, "implies_intr", args=A, prevs=[5])
th = Thm.mk_implies(A, logic.mk_conj(logic.true, A))
self.assertEqual(thy.check_proof(prf), th)
def testConjCommWithMacro(self):
"""Proof of commutativity of conjunction, with macros."""
thy = basic.load_theory('logic_base')
A = Var("A", boolT)
B = Var("B", boolT)
prf = Proof(logic.mk_conj(A, B))
prf.add_item(1, "apply_theorem", args="conjD1", prevs=[0])
prf.add_item(2, "apply_theorem", args="conjD2", prevs=[0])
prf.add_item(3, "apply_theorem", args="conjI", prevs=[2, 1])
prf.add_item(4, "implies_intr", args=logic.mk_conj(A, B), prevs=[3])
th = Thm.mk_implies(logic.mk_conj(A, B), logic.mk_conj(B, A))
self.assertEqual(thy.check_proof(prf), th)
def testCombination(self):
"""Test arg and fun combination together using proofs."""
thy = basic.load_theory('logic_base')
prf = Proof(Term.mk_equals(f, g), Term.mk_equals(x, y))
prf.add_item(2, "arg_combination", args=f, prevs=[1])
prf.add_item(3, "fun_combination", args=y, prevs=[0])
prf.add_item(4, "transitive", prevs=[2, 3])
prf.add_item(5, "implies_intr", args=Term.mk_equals(x, y), prevs=[4])
prf.add_item(6, "implies_intr", args=Term.mk_equals(f, g), prevs=[5])
th = Thm.mk_implies(Term.mk_equals(f, g), Term.mk_equals(x, y),
Term.mk_equals(f(x), g(y)))
self.assertEqual(thy.check_proof(prf), th)
def testIntersection(self):
"""Proof of x : A INTER B --> x : A."""
thy = basic.load_theory('set')
x = Var('x', Ta)
A = Var('A', set.setT(Ta))
B = Var('B', set.setT(Ta))
x_in_AB = set.mk_mem(x, set.mk_inter(A, B))
x_in_A = set.mk_mem(x, A)
prf = Proof(x_in_AB)
prf.add_item(1, "rewrite_fact", args="member_inter_iff", prevs=[0])
prf.add_item(2, "apply_theorem", args="conjD1", prevs=[1])
prf.add_item(3, "implies_intr", args=x_in_AB, prevs=[2])
self.assertEqual(thy.check_proof(prf), Thm.mk_implies(x_in_AB, x_in_A))
def testRewriteGoal(self):
thy = basic.load_theory('nat')
n = Var("n", nat.natT)
eq = Term.mk_equals
zero = nat.zero
plus = nat.mk_plus
prf = Proof()
prf.add_item(0,
"rewrite_goal",
args=("plus_def_1", eq(plus(zero, zero), zero)))
th = Thm([], eq(plus(zero, zero), zero))
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt), th)
self.assertEqual(rpt.prim_steps, 9)
rpt2 = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt2, check_level=1), th)
self.assertEqual(rpt2.prim_steps, 0)
self.assertEqual(rpt2.macro_steps, 1)
def testLargeSum(self):
f = Const("f", TFun(natT, natT))
g = Const("g", TFun(natT, natT))
x = Var("x", natT)
th0, th1 = eq(one, zero), eq(f(x), g(x))
cv = top_conv(
else_conv(rewr_conv(ProofTerm.atom(0, th0)),
rewr_conv(ProofTerm.atom(1, th1))))
f1 = f(one)
g0 = g(zero)
t = plus(*([f1] * 50))
res = plus(*([g0] * 50))
self.assertEqual(cv.eval(thy, t), eq(t, res))
prf = Proof()
prf.add_item(0, "sorry", th=th0)
prf.add_item(1, "sorry", th=th1)
cv.get_proof_term(thy, t).export(prf=prf)
self.assertEqual(thy.check_proof(prf, check_level=1), eq(t, res))
def testCheckProofMacro(self):
"""Proof checking with simple macro."""
thy = Theory.EmptyTheory()
thy.add_proof_macro("beta_conv_rhs", beta_conv_rhs_macro())
t = Comb(Abs("x", Ta, Bound(0)), x)
prf = Proof()
prf.add_item(0, "reflexive", args=t)
prf.add_item(1, "beta_conv_rhs", prevs=[0])
th = Thm.mk_equals(t,x)
# Check obtaining signature
self.assertEqual(thy.get_proof_rule_sig("beta_conv_rhs"), Term)
# Check proof without trusting beta_conv_rhs
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt), th)
self.assertEqual(rpt.steps_stat(), (0, 3, 0))
self.assertEqual(rpt.macros_expand, {"beta_conv_rhs"})
# Check proof while trusting beta_conv_rhs
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt, check_level=1), th)
self.assertEqual(rpt.steps_stat(), (0, 1, 1))
self.assertEqual(rpt.macros_eval, {"beta_conv_rhs"})
def testCheckedExtend2(self):
"""Checked extension: proved theorem."""
thy = Theory.EmptyTheory()
thy_ext = TheoryExtension()
id_const = Const("id", TFun(Ta,Ta))
id_def = Abs("x", Ta, Bound(0))
id_simps = Term.mk_equals(id_const(x), x)
# Proof of |- id x = x from |- id = (%x. x)
prf = Proof()
prf.add_item(0, "theorem", args="id_def") # id = (%x. x)
prf.add_item(1, "reflexive", args=x) # x = x
prf.add_item(2, "combination", prevs=[0, 1]) # id x = (%x. x) x
prf.add_item(3, "beta_conv", args=id_def(x)) # (%x. x) x = x
prf.add_item(4, "transitive", prevs=[2, 3]) # id x = x
thy_ext.add_extension(Constant("id", id_def))
thy_ext.add_extension(Theorem("id.simps", Thm([], id_simps), prf))
ext_report = thy.checked_extend(thy_ext)
self.assertEqual(thy.get_theorem("id.simps"), Thm([], id_simps))
self.assertEqual(ext_report.get_axioms(), [])
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 parse_proof(proof):
"""Obtain proof from json format."""
state = ProofState()
for nm, T in context.ctxt.vars.items():
state.vars.append(Var(nm, T))
state.prf = Proof()
for line in proof:
if line['rule'] == "variable":
nm, str_T = line['args'].split(',', 1)
context.ctxt.vars[nm] = parser.parse_type(str_T.strip())
item = parser.parse_proof_rule(line)
state.prf.insert_item(item)
state.check_proof()
return state
def parse_proof(thy, data):
"""Obtain proof from json format."""
ctxt = {}
state = ProofState(thy)
for name, str_T in data['vars'].items():
T = parser.parse_type(thy, str_T)
state.vars.append(Var(name, T))
ctxt[name] = T
state.prf = Proof()
for line in data['proof']:
if line['rule'] == "variable":
nm, str_T = line['args'].split(',', 1)
ctxt[nm] = parser.parse_type(thy, str_T.strip())
item = parser.parse_proof_rule(thy, ctxt, line)
state.prf.insert_item(item)
state.check_proof(compute_only=True)
return state
def testApplyTheorem(self):
thy = basic.load_theory('logic_base')
A = Var("A", boolT)
B = Var("B", boolT)
th = Thm([logic.mk_conj(A, B)], A)
prf = Proof(logic.mk_conj(A, B))
prf.add_item(1, "apply_theorem", args="conjD1", prevs=[0])
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt), th)
self.assertEqual(rpt.prim_steps, 4)
# Reset data for the next check
prf = Proof(logic.mk_conj(A, B))
prf.add_item(1, "apply_theorem", args="conjD1", prevs=[0])
rpt = ProofReport()
self.assertEqual(thy.check_proof(prf, rpt, check_level=1), th)
self.assertEqual(rpt.prim_steps, 1)
self.assertEqual(rpt.macro_steps, 1)
def testCheckProof4(self):
"""Proof of |- x = y --> x = y by instantiating an existing theorem."""
theory.thy.add_theorem("trivial", Thm([], Implies(A,A)))
x_eq_y = Eq(x,y)
prf = Proof()
prf.add_item(0, "theorem", args="trivial")
prf.add_item(1, "substitution", args=Inst(A=x_eq_y), prevs=[0])
rpt = ProofReport()
th = Thm([], Implies(x_eq_y,x_eq_y))
self.assertEqual(theory.check_proof(prf, rpt), th)
self.assertEqual(rpt.steps, 2)
def testCheckProof5(self):
"""Empty instantiation."""
theory.thy.add_theorem("trivial", Thm([], Implies(A,A)))
x_eq_y = Eq(x,y)
prf = Proof()
prf.add_item(0, "theorem", args="trivial")
prf.add_item(1, "substitution", args=Inst(), prevs=[0])
rpt = ProofReport()
th = Thm([], Implies(SVar('A', BoolType), SVar('A', BoolType)))
self.assertEqual(theory.check_proof(prf, rpt), th)
self.assertEqual(rpt.steps_stat(), (1, 1, 0))
self.assertEqual(rpt.th_names, {"trivial"})
def testCheckProof4(self):
"""Proof of |- x = y --> x = y by instantiating an existing theorem."""
thy = Theory.EmptyTheory()
thy.add_theorem("trivial", Thm.mk_implies(A,A))
x_eq_y = Term.mk_equals(x,y)
prf = Proof()
prf.add_item(0, "theorem", args="trivial")
prf.add_item(1, "substitution", args={"A" : x_eq_y}, prevs=[0])
rpt = ProofReport()
th = Thm.mk_implies(x_eq_y,x_eq_y)
self.assertEqual(thy.check_proof(prf, rpt), th)
self.assertEqual(rpt.steps, 2)
def testCheckProof5(self):
"""Empty instantiation."""
thy = Theory.EmptyTheory()
thy.add_theorem("trivial", Thm.mk_implies(A,A))
x_eq_y = Term.mk_equals(x,y)
prf = Proof()
prf.add_item(0, "theorem", args="trivial")
prf.add_item(1, "substitution", args={}, prevs=[0])
rpt = ProofReport()
th = Thm.mk_implies(A,A)
self.assertEqual(thy.check_proof(prf, rpt), th)
self.assertEqual(rpt.steps_stat(), (1, 1, 0))
self.assertEqual(rpt.th_names, {"trivial"})