def testIntroduction3(self): Ta = TVar("a") A = Var("A", TFun(Ta, boolT)) B = Var("B", TFun(Ta, boolT)) x = Var("x", Ta) state = ProofState.init_state(thy, [A, B], [], Term.mk_all(x, imp(A(x), B(x)))) state.introduction(0, ["x"]) self.assertEqual(state.check_proof(), Thm([], Term.mk_all(x, imp(A(x), B(x))))) self.assertEqual(len(state.prf.items), 1) self.assertEqual(len(state.prf.items[0].subproof.items), 4)
def testAddLineBefore(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) state.add_line_before(2, 1) self.assertEqual(len(state.prf.items), 4) self.assertEqual(state.check_proof(), Thm.mk_implies(conj(A, B), conj(B, A))) state.add_line_before(2, 3) self.assertEqual(len(state.prf.items), 7) self.assertEqual(state.check_proof(), Thm.mk_implies(conj(A, B), conj(B, A)))
def testRewriteGoalWithAssum(self): Ta = TVar("a") a = Var("a", Ta) b = Var("b", Ta) eq_a = Term.mk_equals(a, a) if_t = logic.mk_if(eq_a, b, a) state = ProofState.init_state(thy, [a, b], [], Term.mk_equals(if_t, b)) state.rewrite_goal(0, "if_P") state.set_line(0, "reflexive", args=a) self.assertEqual(state.check_proof(no_gaps=True), Thm.mk_equals(if_t, b))
def testPierce(self): thy = basic.load_theory('logic_base') state = ProofState.init_state(thy, [A, B], [imp(imp(A, B), A)], A) state.apply_cases(1, A) state.introduction(1) state.introduction(2) state.apply_prev((2, 1), 0) state.introduction((2, 1)) state.apply_backward_step((2, 1, 1), 'negE_gen', prevs=[(2, 0)]) self.assertEqual(state.check_proof(no_gaps=True), Thm([], imp(imp(imp(A, B), A), A)))
def testMultZeroRight(self): """Proof of n * 0 = 0 by induction.""" thy = basic.load_theory('nat') n = Var("n", nat.natT) state = ProofState.init_state(thy, [n], [], Term.mk_equals(nat.times(n, nat.zero), nat.zero)) state.apply_induction(0, "nat_induct", "n") state.rewrite_goal(0, "times_def_1") state.introduction(1, names=["n"]) state.rewrite_goal((1, 2), "times_def_2") state.rewrite_goal((1, 2), "plus_def_1") self.assertEqual(state.check_proof(no_gaps=True), Thm.mk_equals(nat.times(n, nat.zero), nat.zero))
def testAVal(self): thy = basic.load_theory('expr') th = thy.get_theorem('aval_test2') state = ProofState.init_state(thy, [], [], th.prop) state.rewrite_goal(0, "aval_def_3") state.rewrite_goal(0, "aval_def_2") state.rewrite_goal(0, "aval_def_1") state.rewrite_goal(0, "fun_upd_def") state.rewrite_goal(0, "if_not_P") state.set_line(0, "nat_norm", args=Term.mk_equals(nat.plus(nat.zero, nat.to_binary(5)), nat.to_binary(5))) state.apply_backward_step(1, "nat_zero_Suc_neq") self.assertEqual(state.check_proof(no_gaps=True), th)
def testAppendNil(self): """Proof of xs @ [] = xs by induction.""" thy = basic.load_theory('list') Ta = TVar("a") xs = Var("xs", list.listT(Ta)) nil = list.nil(Ta) state = ProofState.init_state(thy, [xs], [], Term.mk_equals(list.mk_append(xs, nil), xs)) state.apply_induction(0, "list_induct", "xs") state.apply_backward_step(0, "append_def_1") state.introduction(1, names=["x", "xs"]) state.rewrite_goal((1, 3), "append_def_2") self.assertEqual(state.get_ctxt((1, 3)), {'x': Ta, 'xs': list.listT(Ta)}) state.rewrite_goal_with_prev((1, 3), (1, 2)) self.assertEqual(state.check_proof(no_gaps=True), Thm.mk_equals(list.mk_append(xs, nil), xs))
def testExistsConj(self): """Proof of (?x. A x & B x) --> (?x. A x) & (?x. B x).""" Ta = TVar("a") A = Var("A", TFun(Ta, boolT)) B = Var("B", TFun(Ta, boolT)) x = Var("x", Ta) ex_conj = exists(x, conj(A(x), B(x))) conj_ex = conj(exists(x, A(x)), exists(x, B(x))) state = ProofState.init_state(thy, [A, B], [ex_conj], conj_ex) state.apply_backward_step(1, "exE", prevs=[0]) state.introduction(1, "x") state.apply_backward_step((1, 2), "conjI") state.apply_forward_step((1, 2), "conjD1", prevs=[(1, 1)]) state.apply_backward_step((1, 3), "exI", prevs=[(1, 2)]) state.apply_forward_step((1, 4), "conjD2", prevs=[(1, 1)]) state.apply_backward_step((1, 5), "exI", prevs=[(1, 4)]) self.assertEqual(state.check_proof(no_gaps=True), Thm.mk_implies(ex_conj, conj_ex))
def testFunUpdTriv(self): thy = basic.load_theory('function') Ta = TVar("a") Tb = TVar("b") f = Var("f", TFun(Ta, Tb)) a = Var("a", Ta) x = Var("x", Ta) prop = Term.mk_equals(function.mk_fun_upd(f, a, f(a)), f) state = ProofState.init_state(thy, [f, a], [], prop) state.apply_backward_step(0, "extension") state.introduction(0, names=["x"]) state.rewrite_goal((0, 1), "fun_upd_eval") state.apply_cases((0, 1), Term.mk_equals(x, a)) state.introduction((0, 1)) state.rewrite_goal((0, 1, 1), "if_P") state.rewrite_goal_with_prev((0, 1, 1), (0, 1, 0)) state.introduction((0, 2)) state.rewrite_goal((0, 2, 1), "if_not_P") self.assertEqual(state.check_proof(no_gaps=True), Thm([], prop))
def testRemoveLine(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) state.add_line_after(1) state.remove_line(2) self.assertEqual(len(state.prf.items), 3) self.assertEqual(state.check_proof(), Thm.mk_implies(conj(A, B), conj(B, A)))
def testApplyBackwardStepThms3(self): """Example of two results.""" state = ProofState.init_state(thy, [A, B], [disj(A, B)], disj(B, A)) search_res = state.apply_search(1, method.apply_backward_step()) self.assertEqual([res['theorem'] for res in search_res], ["disjI1", "disjI2"])
def testApplyBackwardStep(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) state.apply_backward_step(1, "conjI") self.assertEqual(state.check_proof(), Thm.mk_implies(conj(A, B), conj(B, A))) self.assertEqual(len(state.rpt.gaps), 2)
def testApplyBackwardStep2(self): """Case where one or more assumption also needs to be matched.""" state = ProofState.init_state(thy, [A, B], [disj(A, B)], disj(B, A)) state.apply_backward_step(1, "disjE", prevs=[0]) self.assertEqual(state.check_proof(), Thm.mk_implies(disj(A, B), disj(B, A))) self.assertEqual(len(state.rpt.gaps), 2)
def testRewriteGoalThms(self): thy = basic.load_theory('nat') n = Var("n", nat.natT) state = ProofState.init_state(thy, [n], [], Term.mk_equals(nat.plus(nat.zero, n), n)) search_res = state.apply_search(0, method.rewrite_goal()) self.assertEqual([res['theorem'] for res in search_res], ["plus_def_1"])
def testApplyForwardStep2(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) state.apply_forward_step(1, "conjD2", prevs=[0]) self.assertEqual(state.check_proof(), Thm.mk_implies(conj(A, B), conj(B, A))) item = state.get_proof_item((1,)) self.assertEqual(item.th.concl, B)
def testApplyBackwardStepThms(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) search_res = state.apply_search(1, method.apply_backward_step()) self.assertEqual([res['theorem'] for res in search_res], ["conjI"])
def testInitProof2(self): state = ProofState.init_state(thy, [A, B], [A, B], conj(A, B)) self.assertEqual(len(state.prf.items), 4) self.assertEqual(state.check_proof(), Thm.mk_implies(A, B, conj(A, B)))
def testIntroduction2(self): state = ProofState.init_state(thy, [A, B], [], imp(A, B, conj(A, B))) state.introduction(0) self.assertEqual(state.check_proof(), Thm.mk_implies(A, B, conj(A, B)))
def testApplyForwardStepThms2(self): state = ProofState.init_state(thy, [A, B], [disj(A, B)], disj(B, A)) search_res = state.apply_search(1, method.apply_forward_step(), prevs=[0]) self.assertEqual([res['theorem'] for res in search_res], [])
def testGetCtxt(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) self.assertEqual(state.get_ctxt(0), {'A': boolT, 'B': boolT})
def testSetLine(self): state = ProofState.init_state(thy, [A, B], [conj(A, B)], conj(B, A)) state.add_line_after(1) state.set_line(2, "theorem", args="conjD1") self.assertEqual(len(state.prf.items), 4) self.assertEqual(state.check_proof(), Thm.mk_implies(conj(A, B), conj(B, A)))