(* ========================================================================= *) (* Yet another formalized unification algorithm. *) (* ========================================================================= *) let LEFT_AND_EX_THM = prove (`!P Q l. EX P l /\ Q <=> EX (\x. P x /\ Q) l`, GEN_TAC THEN GEN_TAC THEN CONV_TAC(ONCE_DEPTH_CONV SYM_CONV) THEN LIST_INDUCT_TAC THEN ASM_REWRITE_TAC[EX] THEN CONV_TAC TAUT);; let EX_ADHOC = prove (`!l. (!x. ~(P x) ==> (Q x <=> R x)) ==> (~EX P l ==> (EX Q l <=> EX R l))`, REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN DISCH_TAC THEN LIST_INDUCT_TAC THEN REWRITE_TAC[EX] THEN ASM_MESON_TAC[]);; let ALL_ADHOC = prove (`!l. ALL (\x. f x = g x) l ==> (EX f l <=> EX g l)`, LIST_INDUCT_TAC THEN REWRITE_TAC[ALL; EX] THEN ASM_MESON_TAC[]);; (* ------------------------------------------------------------------------- *) (* Yet more wellfoundedness lemmas. *) (* ------------------------------------------------------------------------- *) let WF_FINITE_LEMMA = prove (`!(<<) s. FINITE s /\ (!x:A. ~(TC(<<) x x)) /\ (!x y. x << y ==> y IN s) ==> WF(<<)`, REPEAT STRIP_TAC THEN REWRITE_TAC[WF_DCHAIN] THEN DISCH_THEN(X_CHOOSE_TAC `u:num->A`) THEN SUBGOAL_THEN `!n. (u:num->A)(n) IN s` ASSUME_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN MP_TAC(ISPECL [`u:num->A`; `s:A->bool`] FINITE_IMAGE_INJ) THEN REWRITE_TAC[ASSUME `FINITE(s:A->bool)`; NOT_IMP] THEN SUBGOAL_THEN `{n | (u:num->A)(n) IN s} = UNIV:num->bool` SUBST1_TAC THENL [ASM_REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_UNIV]; ALL_TAC] THEN REWRITE_TAC[num_INFINITE; GSYM INFINITE] THEN SUBGOAL_THEN `!m n. m < n ==> TC(<<) ((u:num->A) n) (u m)` (fun th -> ASM_MESON_TAC[th; LT_CASES]) THEN SIMP_TAC[LT_EXISTS; LEFT_IMP_EXISTS_THM] THEN X_GEN_TAC `n:num` THEN GEN_TAC THEN X_GEN_TAC `d:num` THEN DISCH_THEN(K ALL_TAC) THEN REWRITE_TAC[ADD_CLAUSES] THEN SUBGOAL_THEN `!d. RTC(<<) ((u:num->A)(n + d))(u n) ` MP_TAC THENL [INDUCT_TAC THEN REWRITE_TAC[ADD_CLAUSES; RTC_REFL] THEN ASM_MESON_TAC[RTC_TRANS; RTC_INC]; REWRITE_TAC[RTC; RC_CASES] THEN ASM_MESON_TAC[TC_INC; TC_CASES_R]]);; let TC_REV = prove (`!x:A y. TC (\u v. R v u) x y <=> TC R y x`, REWRITE_TAC[TAUT `(a <=> b) <=> (a ==> b) /\ (b ==> a)`; FORALL_AND_THM] THEN CONJ_TAC THENL [ALL_TAC; ONCE_REWRITE_TAC[SWAP_FORALL_THM]] THEN MATCH_MP_TAC TC_INDUCT THEN SIMP_TAC[TC_INC] THEN MESON_TAC[TC_TRANS]);; let WF_DISJ = prove (`WF(R) /\ WF(\x y. ?z. S x z /\ RTC(R) z y) ==> WF(\x:A y. R x y \/ S x y)`, REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN REWRITE_TAC[WF] THEN MATCH_MP_TAC MONO_FORALL THEN X_GEN_TAC `P:A->bool` THEN MATCH_MP_TAC(TAUT `(b ==> c) ==> (a ==> b) ==> (a ==> c)`) THEN DISCH_THEN(X_CHOOSE_THEN `a:A` STRIP_ASSUME_TAC) THEN FIRST_ASSUM(MP_TAC o MATCH_MP (snd(EQ_IMP_RULE(SPEC_ALL WF_TC)))) THEN REWRITE_TAC[WF] THEN DISCH_THEN(MP_TAC o SPEC `\y:A. P(y) /\ TC R y a`) THEN REWRITE_TAC[] THEN RULE_ASSUM_TAC(REWRITE_RULE[RTC; RC_CASES]) THEN ASM_MESON_TAC[TC_INC; TC_TRANS]);; let WF_ALTERNATION = prove (`WF(\x y. R x y \/ S x y) /\ (!x y z. ~(P x y /\ P y z)) ==> WF(\(x1:A,y1) (x2,y2). S x1 x2 /\ S y1 y2 \/ R x1 x2 /\ (y1 = y2) \/ P x2 y2 /\ (x1 = y2) /\ (x2 = y1))`, REPEAT STRIP_TAC THEN REWRITE_TAC[WF] THEN X_GEN_TAC `s:A#A->bool` THEN REWRITE_TAC[EXISTS_PAIR_THM] THEN DISCH_TAC THEN FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [WF]) THEN DISCH_THEN(MP_TAC o SPEC `\x:A. ?y:A. s(x,y) \/ s(y,x)`) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN DISCH_THEN(X_CHOOSE_THEN `a:A` (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC)) THEN DISCH_THEN(X_CHOOSE_THEN `b0:A` ASSUME_TAC) THEN REWRITE_TAC[FORALL_PAIR_THM] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN FIRST_X_ASSUM DISJ_CASES_TAC THENL [ASM_CASES_TAC `(P:A->A->bool) a b0` THENL [ALL_TAC; ASM_MESON_TAC[]] THEN ASM_CASES_TAC `(s:A#A->bool)(b0,a)` THENL [ALL_TAC; MAP_EVERY EXISTS_TAC [`a:A`; `b0:A`] THEN ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]] THEN ASM_CASES_TAC `?y:A. R y (b0:A) /\ s(y,a:A)` THENL [ALL_TAC; MAP_EVERY EXISTS_TAC [`b0:A`; `a:A`] THEN ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]] THEN FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [WF]) THEN DISCH_THEN(MP_TAC o SPEC `\y:A. s(y,a:A):bool`) THEN REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN DISCH_THEN(X_CHOOSE_THEN `b:A` STRIP_ASSUME_TAC) THEN MAP_EVERY EXISTS_TAC [`b:A`; `a:A`] THEN ASM_MESON_TAC[]; FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [WF]) THEN DISCH_THEN(MP_TAC o SPEC `\y:A. s(y,a:A):bool`) THEN REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN DISCH_THEN(X_CHOOSE_THEN `b:A` STRIP_ASSUME_TAC) THEN ASM_CASES_TAC `(P:A->A->bool) b a /\ s(a,b)` THENL [MAP_EVERY EXISTS_TAC [`a:A`; `b:A`]; MAP_EVERY EXISTS_TAC [`b:A`; `a:A`]] THEN ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]]);; let MULTISET_FILTEREQ = prove (`multiplicity (multiset (\x:A. LENGTH (FILTER ((=) x) l))) a = LENGTH (FILTER ((=) a) l)`, MP_TAC(ISPEC `\x:A. LENGTH (FILTER ((=) x) l)` (CONJUNCT2 multiset_tybij)) THEN MATCH_MP_TAC(TAUT `(b ==> c) /\ a ==> ((a <=> b) ==> c)`) THEN SIMP_TAC[] THEN MATCH_MP_TAC FINITE_SUBSET THEN EXISTS_TAC `{a:A | MEM a l}` THEN CONJ_TAC THENL [SPEC_TAC(`l:(A)list`,`l:(A)list`) THEN LIST_INDUCT_TAC THENL [SUBGOAL_THEN `{a:A | MEM a []} = EMPTY` (fun th -> REWRITE_TAC[th; FINITE_RULES]) THEN REWRITE_TAC[EXTENSION; IN_ELIM_THM; MEM; NOT_IN_EMPTY]; SUBGOAL_THEN `{a:A | MEM a (CONS h t)} = h INSERT {a | MEM a t}` (fun th -> ASM_SIMP_TAC[th; FINITE_RULES]) THEN REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_INSERT; MEM] THEN REWRITE_TAC[DISJ_ACI]]; REWRITE_TAC[SUBSET; IN_ELIM_THM] THEN SPEC_TAC(`l:(A)list`,`l:(A)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[FILTER; LENGTH; MEM] THEN GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[LENGTH; MEM]]);; let WF_MULTIZIP = prove (`WF(R) ==> WF(\l1 l2. ?h:A t l0. (l2 = CONS h t) /\ (l1 = APPEND l0 t) /\ (!k. MEM k l0 ==> R k h))`, let lemma = INST_TYPE [`:(A)list`,`:A`] WF_MEASURE_GEN in REPEAT STRIP_TAC THEN FIRST_ASSUM(MP_TAC o SPEC `\l. multiset(\x:A. LENGTH (FILTER ((=) x) l))` o MATCH_MP lemma o MATCH_MP MORDER_WF) THEN REWRITE_TAC[] THEN MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ] WF_SUBSET) THEN REPEAT GEN_TAC THEN REWRITE_TAC[morder; LEFT_IMP_EXISTS_THM] THEN MAP_EVERY X_GEN_TAC [`a:A`; `l:(A)list`; `m:(A)list`] THEN REPEAT(DISCH_THEN(CONJUNCTS_THEN2 SUBST1_TAC MP_TAC)) THEN DISCH_TAC THEN EXISTS_TAC `multiset(\x:A. LENGTH (FILTER ((=) x) l))` THEN EXISTS_TAC `a:A` THEN EXISTS_TAC `multiset(\x:A. LENGTH (FILTER ((=) x) m))` THEN REWRITE_TAC[mmember; MEXTENSION; MULTISET_FILTEREQ; MUNION; MSING] THEN REWRITE_TAC[FILTER_APPEND; LENGTH_APPEND; LENGTH; FILTER; ADD_AC] THEN CONJ_TAC THENL [GEN_TAC THEN COND_CASES_TAC THEN REWRITE_TAC[LENGTH; ADD1; ADD_AC; ADD_CLAUSES]; ALL_TAC] THEN SUBGOAL_THEN `!a:A l. ~(LENGTH (FILTER ((=) a) l) = 0) ==> MEM a l` (fun th -> ASM_MESON_TAC[th]) THEN GEN_TAC THEN LIST_INDUCT_TAC THEN REWRITE_TAC[FILTER; LENGTH; MEM] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[LENGTH; MEM]);; let WF_MEASURE_OR_NONINC = prove (`!R (m:A->num). WF(R) /\ (!x y. R x y ==> m x <= m y) ==> WF(\x y. MEASURE m x y \/ R x y)`, REPEAT STRIP_TAC THEN REWRITE_TAC[WF] THEN X_GEN_TAC `P:A->bool` THEN DISCH_TAC THEN MP_TAC(ISPEC `m:A->num` WF_MEASURE) THEN REWRITE_TAC[WF; MEASURE] THEN DISCH_THEN(MP_TAC o SPEC `P:A->bool`) THEN ASM_REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_THEN `a:A` STRIP_ASSUME_TAC) THEN ASM_CASES_TAC `?y. (R:A->A->bool) y a /\ P y` THENL [ALL_TAC; ASM_MESON_TAC[]] THEN FIRST_ASSUM(MP_TAC o SPEC `\y. TC (R:A->A->bool) y a /\ P y` o GEN_REWRITE_RULE I [WF]) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_MESON_TAC[TC_INC]; ALL_TAC] THEN MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `b:A` THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN SUBGOAL_THEN `(m:A->num)(b) <= m(a)` (fun th -> ASM_MESON_TAC[th; TC_INC; TC_TRANS; LTE_TRANS]) THEN UNDISCH_TAC `TC R b (a:A)` THEN MAP_EVERY SPEC_TAC [`a:A`,`a:A`; `b:A`,`b:A`] THEN MATCH_MP_TAC TC_INDUCT THEN ASM_REWRITE_TAC[LE_TRANS]);; let WF_PROJ_EQ = prove (`(!x. P x ==> WF(R x)) ==> WF(\(x',y') (x:A,y:B). P(x) /\ (x' = x) /\ R x y' y)`, REPEAT STRIP_TAC THEN REWRITE_TAC[WF_DCHAIN] THEN DISCH_THEN(X_CHOOSE_TAC `s:num->A#B`) THEN FIRST_X_ASSUM(MP_TAC o SPEC `FST((s:num->A#B) 0)`) THEN FIRST_ASSUM(MP_TAC o SPEC `0`) THEN SUBST1_TAC(SYM(ISPEC `(s:num->A#B) 0` PAIR)) THEN SUBST1_TAC(SYM(ISPEC `(s:num->A#B) (SUC 0)` PAIR)) THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN DISCH_THEN(fun th -> REWRITE_TAC[CONJUNCT1 th]) THEN REWRITE_TAC[WF_DCHAIN] THEN EXISTS_TAC `SND o (s:num->A#B)` THEN X_GEN_TAC `n:num` THEN REWRITE_TAC[o_THM] THEN SUBGOAL_THEN `FST((s:num->A#B) 0) = FST(s n)` SUBST1_TAC THENL [SPEC_TAC(`n:num`,`n:num`) THEN INDUCT_TAC THEN REWRITE_TAC[] THEN MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC `FST((s:num->A#B) n)` THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN FIRST_X_ASSUM(MP_TAC o SPEC `n:num`) THEN SUBST1_TAC(SYM(ISPEC `(s:num->A#B) n` PAIR)) THEN SUBST1_TAC(SYM(ISPEC `(s:num->A#B) (SUC n)` PAIR)) THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN SIMP_TAC[FST; SND]);; (* ------------------------------------------------------------------------- *) (* Definition of loop-freeness. *) (* ------------------------------------------------------------------------- *) let OCC = new_definition `OCC env (x:num) y <=> ?t. MEM (x,t) env /\ y IN FVT(t)`;; let LOOPFREE = new_definition `LOOPFREE env <=> !z. ~(TC (OCC env) z z)`;; (* ------------------------------------------------------------------------- *) (* Main preservation theorem. *) (* ------------------------------------------------------------------------- *) let LOOP_BREAK = prove (`!env x t u v. TC(OCC (CONS (x,t) env)) u v /\ ~(TC(OCC env) u v) ==> ?y. RTC(OCC env) u x /\ y IN FVT(t) /\ RTC(OCC env) y v`, GEN_TAC THEN GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[TAUT `a /\ ~b ==> c <=> a ==> ~b ==> c`] THEN MATCH_MP_TAC TC_INDUCT_L THEN REPEAT STRIP_TAC THENL [UNDISCH_TAC `OCC (CONS (x,t) env) u v` THEN REWRITE_TAC[OCC; MEM; PAIR_EQ] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THENL [ASM_MESON_TAC[RTC_CASES]; ALL_TAC] THEN UNDISCH_TAC `~TC (OCC env) u v` THEN ONCE_REWRITE_TAC[TC_CASES_L] THEN REWRITE_TAC[OCC] THEN ASM_MESON_TAC[]; ALL_TAC] THEN ASM_CASES_TAC `TC (OCC env) u v` THENL [UNDISCH_TAC `OCC (CONS (x,t) env) v z` THEN REWRITE_TAC[OCC; MEM; PAIR_EQ] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THENL [REWRITE_TAC[RTC; RC_CASES] THEN ASM_MESON_TAC[]; ALL_TAC] THEN UNDISCH_TAC `~TC (OCC env) u z` THEN MATCH_MP_TAC(TAUT `a ==> ~a ==> b`) THEN ONCE_REWRITE_TAC[TC_CASES_L] THEN DISJ2_TAC THEN REWRITE_TAC[OCC] THEN ASM_MESON_TAC[]; ALL_TAC] THEN FIRST_ASSUM(UNDISCH_TAC o check is_imp o concl) THEN ASM_REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_THEN `y:num` STRIP_ASSUME_TAC) THEN ASM_REWRITE_TAC[] THEN UNDISCH_TAC `OCC (CONS (x,t) env) v z` THEN REWRITE_TAC[OCC; MEM; PAIR_EQ] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THENL [REWRITE_TAC[RTC; RC_CASES] THEN ASM_MESON_TAC[]; ASM_MESON_TAC[RTC_CASES_L; OCC]]);; let LOOPFREE_PRESERVE = prove (`LOOPFREE env /\ ~(?y. y IN FVT(t) /\ RTC (OCC env) y x) ==> LOOPFREE (CONS (x,t) env)`, MESON_TAC[LOOPFREE; RTC_CASES; LOOP_BREAK]);; let LOOPFREE_PRESERVE_EQ = prove (`LOOPFREE env ==> (LOOPFREE (CONS (x,t) env) = ~(?y. y IN FVT(t) /\ RTC (OCC env) y x))`, MATCH_MP_TAC(TAUT `(a /\ ~c ==> b) /\ (c ==> ~b) ==> (a ==> (b <=> ~c))`) THEN REWRITE_TAC[LOOPFREE_PRESERVE] THEN DISCH_THEN(X_CHOOSE_THEN `y:num` STRIP_ASSUME_TAC) THEN REWRITE_TAC[LOOPFREE] THEN DISCH_THEN(MP_TAC o SPEC `x:num`) THEN REWRITE_TAC[] THEN ONCE_REWRITE_TAC[TC_RTC_CASES_R] THEN EXISTS_TAC `y:num` THEN REWRITE_TAC[OCC; MEM; PAIR_EQ] THEN CONJ_TAC THENL [EXISTS_TAC `t:term` THEN ASM_REWRITE_TAC[]; UNDISCH_TAC `RTC (OCC env) y x` THEN MATCH_MP_TAC(REWRITE_RULE[RIGHT_IMP_FORALL_THM] RTC_MONO) THEN SIMP_TAC[OCC; MEM; PAIR_EQ] THEN MESON_TAC[]]);; (* ------------------------------------------------------------------------- *) (* If existing env is loopfree, a naive algorithm works. *) (* ------------------------------------------------------------------------- *) let LOOPFREE_WF = prove (`!env. LOOPFREE env ==> WF(\x y. OCC env y x)`, REWRITE_TAC[LOOPFREE] THEN REPEAT STRIP_TAC THEN MATCH_MP_TAC WF_FINITE_LEMMA THEN EXISTS_TAC `set_of_list (MAP FST (env:(num#term)list))` THEN ASM_REWRITE_TAC[FINITE_SET_OF_LIST] THEN ONCE_REWRITE_TAC[TC_REV] THEN CONV_TAC(DEPTH_CONV ETA_CONV) THEN ASM_REWRITE_TAC[OCC] THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MAP; set_of_list; MEM; IN_INSERT] THEN ASM_MESON_TAC[FST]);; let LOOPFREE_WF_TERM = prove (`!env. LOOPFREE(env) ==> WF(\s t. ?y. y IN FVT(t) /\ MEM (y,s) env)`, REPEAT STRIP_TAC THEN FIRST_ASSUM(MP_TAC o MATCH_MP LOOPFREE_WF) THEN REWRITE_TAC[WF_DCHAIN; OCC; TAUT `~a ==> ~b <=> b ==> a`; SKOLEM_THM] THEN DISCH_THEN(X_CHOOSE_THEN `s:num->term` (X_CHOOSE_THEN `x:num->num` STRIP_ASSUME_TAC)) THEN MAP_EVERY EXISTS_TAC [`x:num->num`; `\n. s(SUC n):term`] THEN ASM_REWRITE_TAC[]);; (* ------------------------------------------------------------------------- *) (* This would be so much nicer with TFL... *) (* ------------------------------------------------------------------------- *) let LOOPCHECK_EXISTS = prove (`!env x. LOOPFREE(env) ==> ?loopcheck. !t. loopcheck t <=> ?y. y IN FVT(t) /\ ((y = x) \/ ?s. MEM (y,s) env /\ loopcheck s)`, REPEAT STRIP_TAC THEN FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP WF_REC o MATCH_MP LOOPFREE_WF_TERM) THEN REWRITE_TAC[] THEN MESON_TAC[]);; let loopcheck_raw = new_specification ["loopcheck"] (REWRITE_RULE[SKOLEM_THM; RIGHT_IMP_EXISTS_THM] LOOPCHECK_EXISTS);; let loopcheck = prove (`!env x. LOOPFREE(env) ==> (!x y. loopcheck env x (V y) <=> (y = x) \/ ?s. MEM (y,s) env /\ loopcheck env x s) /\ (!f args. loopcheck env x (Fn f args) <=> EX (loopcheck env x) args)`, REPEAT STRIP_TAC THEN FIRST_ASSUM(fun th -> GEN_REWRITE_TAC LAND_CONV [MATCH_MP loopcheck_raw th]) THEN REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; UNWIND_THM2; IN_LIST_UNION] THEN REWRITE_TAC[LEFT_AND_EX_THM; EXISTS_EX; EX_MAP; o_THM] THEN FIRST_ASSUM(fun th -> REWRITE_TAC[GSYM(MATCH_MP loopcheck_raw th)]) THEN CONV_TAC(ONCE_DEPTH_CONV ETA_CONV) THEN REFL_TAC);; (* ------------------------------------------------------------------------- *) (* Prove that it does indeed work. *) (* ------------------------------------------------------------------------- *) let LOOPCHECK = prove (`!env x t. LOOPFREE(env) ==> (loopcheck env x t <=> ~LOOPFREE (CONS (x,t) env))`, REPEAT STRIP_TAC THEN MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC `?y. y IN FVT t /\ RTC (OCC env) y x` THEN ASM_SIMP_TAC[LOOPFREE_PRESERVE_EQ] THEN SPEC_TAC(`t:term`,`t:term`) THEN FIRST_ASSUM(MP_TAC o MATCH_MP LOOPFREE_WF_TERM) THEN REWRITE_TAC[WF_IND] THEN DISCH_THEN MATCH_MP_TAC THEN X_GEN_TAC `t:term` THEN DISCH_TAC THEN FIRST_ASSUM(fun th -> ONCE_REWRITE_TAC[MATCH_MP loopcheck_raw th]) THEN AP_TERM_TAC THEN ABS_TAC THEN MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN DISCH_TAC THEN ONCE_REWRITE_TAC[RTC_CASES_R] THEN ASM_CASES_TAC `x:num = y` THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[OCC; LEFT_AND_EXISTS_THM] THEN ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN AP_TERM_TAC THEN ABS_TAC THEN REWRITE_TAC[GSYM CONJ_ASSOC; RIGHT_EXISTS_AND_THM] THEN MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN DISCH_TAC THEN FIRST_ASSUM MATCH_MP_TAC THEN EXISTS_TAC `y:num` THEN ASM_REWRITE_TAC[]);; (* ------------------------------------------------------------------------- *) (* Final transformation to solved form. More non-TFL hell. *) (* ------------------------------------------------------------------------- *) let rightsubst = new_definition `rightsubst (x,t) (y:num,s) = y,termsubst (\z. if z = x then t else V(z)) s`;; let SOLVE_EXISTS = prove (`?SOLVE. !pr. SOLVE pr = if SND pr = [] then FST pr else SOLVE (CONS (HD(SND pr)) (MAP (rightsubst (HD(SND pr))) (FST pr)), MAP (rightsubst (HD(SND pr))) (TL(SND pr)))`, let lemma = prove (`(if b then x else y) = (if ~b then y else x)`, BOOL_CASES_TAC `b:bool` THEN REWRITE_TAC[]) in ONCE_REWRITE_TAC[lemma] THEN REWRITE_TAC[WF_REC_TAIL]);; let SOLVEC_RAW = new_specification ["SOLVEC"] SOLVE_EXISTS;; let SOLVE = new_definition `SOLVE sol uns = SOLVEC (sol,uns)`;; let SOLVE = prove (`(!sol. SOLVE sol [] = sol) /\ (!sol p oth. SOLVE sol (CONS p oth) = SOLVE (CONS p (MAP (rightsubst p) sol)) (MAP (rightsubst p) oth))`, REWRITE_TAC[SOLVE] THEN REPEAT STRIP_TAC THEN GEN_REWRITE_TAC LAND_CONV [SOLVEC_RAW] THEN REWRITE_TAC[NOT_CONS_NIL; HD; TL]);; (* ------------------------------------------------------------------------- *) (* Fact that the list gives no conflicting definitions. *) (* ------------------------------------------------------------------------- *) let CONFLICTFREE = new_definition `CONFLICTFREE l <=> !x. LENGTH (FILTER (\(y:num,s:term). y = x) l) <= 1`;; (* ------------------------------------------------------------------------- *) (* Solve step preserves loop-freeness. *) (* ------------------------------------------------------------------------- *) let SOLVE_PRESERVES_LOOPFREE_LEMMA = prove (`!p oth x y. TC(OCC (MAP (rightsubst p) oth)) x y ==> TC(OCC (CONS p oth)) x y`, ONCE_REWRITE_TAC[FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`x:num`; `t:term`; `oth:(num#term)list`] THEN GEN_REWRITE_TAC (funpow 2 BINDER_CONV o RAND_CONV o funpow 2 RATOR_CONV) [GSYM TC_IDEMP] THEN MATCH_MP_TAC TC_MONO THEN MAP_EVERY X_GEN_TAC [`u:num`; `v:num`] THEN REWRITE_TAC[OCC; MEM_MAP; EXISTS_PAIR_THM; rightsubst; PAIR_EQ] THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM; LEFT_AND_EXISTS_THM] THEN MAP_EVERY X_GEN_TAC [`p:term`; `y:num`; `s:term`] THEN STRIP_TAC THEN UNDISCH_TAC `v IN FVT p` THEN ASM_REWRITE_TAC[TERMSUBST_FVT] THEN REWRITE_TAC[IN_ELIM_THM] THEN DISCH_THEN(X_CHOOSE_THEN `z:num` MP_TAC) THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY] THENL [STRIP_TAC THEN MATCH_MP_TAC TC_TRANS THEN EXISTS_TAC `x:num` THEN CONJ_TAC; DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC SUBST1_TAC)] THEN MATCH_MP_TAC TC_INC THEN REWRITE_TAC[OCC] THEN ASM_MESON_TAC[MEM]);; let SOLVE_PRESERVES_LOOPFREE = prove (`!p oth. LOOPFREE(CONS p oth) ==> LOOPFREE(MAP (rightsubst p) oth)`, REWRITE_TAC[LOOPFREE] THEN MESON_TAC[SOLVE_PRESERVES_LOOPFREE_LEMMA]);; (* ------------------------------------------------------------------------- *) (* ...and the absence of conflicts. *) (* ------------------------------------------------------------------------- *) let SOLVE_PRESERVES_CONFLICTFREE_LEMMA = prove (`!p x. (\(y,s). y = x) o rightsubst p = (\(y,s). y = x)`, REWRITE_TAC[FUN_EQ_THM; o_THM; FORALL_PAIR_THM; rightsubst] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[EQ_SYM]);; let SOLVE_PRESERVES_CONFLICTFREE = prove (`CONFLICTFREE(APPEND sol (CONS p oth)) ==> CONFLICTFREE(APPEND (CONS p (MAP (rightsubst p) sol)) (MAP (rightsubst p) oth))`, REWRITE_TAC[CONFLICTFREE; FILTER_APPEND; FILTER; LENGTH_APPEND; FILTER_MAP; LENGTH_MAP] THEN MATCH_MP_TAC MONO_FORALL THEN GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[LENGTH; LENGTH_MAP] THEN REWRITE_TAC[SOLVE_PRESERVES_CONFLICTFREE_LEMMA] THEN ARITH_TAC);; (* ------------------------------------------------------------------------- *) (* ...and preserves the invariant of removing free variables. *) (* ------------------------------------------------------------------------- *) let SOLVE_PRESERVES_DEFREE = prove (`LOOPFREE(CONS p oth) /\ (!x y s t. MEM (x,t) sol /\ MEM (y,s) (APPEND sol (CONS p oth)) ==> ~(x IN FVT(s))) ==> (!x y s t. MEM (x,t) (CONS p (MAP (rightsubst p) sol)) /\ MEM (y,s) (APPEND (CONS p (MAP (rightsubst p) sol)) (MAP (rightsubst p) oth)) ==> ~(x IN FVT(s)))`, ONCE_REWRITE_TAC[GSYM LEFT_IMP_EXISTS_THM] THEN REWRITE_TAC[GSYM LEFT_AND_EXISTS_THM] THEN SUBGOAL_THEN `!x. (?t. MEM (x,t) (CONS p (MAP (rightsubst p) sol))) <=> (?t. MEM (x,t) (CONS p sol))` (fun th -> REWRITE_TAC[th]) THENL [GEN_TAC THEN REWRITE_TAC[MEM; EXISTS_OR_THM] THEN AP_TERM_TAC THEN REWRITE_TAC[MEM_MAP; EXISTS_PAIR_THM] THEN SUBST1_TAC(SYM(ISPEC `p:num#term` PAIR)) THEN PURE_REWRITE_TAC[rightsubst; PAIR_EQ] THEN MESON_TAC[]; ALL_TAC] THEN REWRITE_TAC[LEFT_AND_EXISTS_THM; LEFT_IMP_EXISTS_THM] THEN STRIP_TAC THEN REPEAT GEN_TAC THEN REWRITE_TAC[MEM] THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC STRIP_ASSUME_TAC) THEN DISCH_THEN(DISJ_CASES_THEN2 (SUBST_ALL_TAC o SYM) ASSUME_TAC) THENL [UNDISCH_TAC `MEM (y,s) (APPEND (CONS (x,t) (MAP (rightsubst (x,t)) sol)) (MAP (rightsubst (x,t)) oth))` THEN REWRITE_TAC[APPEND; GSYM MAP_APPEND] THEN REWRITE_TAC[MEM; MEM_MAP; PAIR_EQ] THEN DISCH_THEN(DISJ_CASES_THEN2 (CONJUNCTS_THEN SUBST1_TAC) MP_TAC) THENL [ALL_TAC; REWRITE_TAC[LEFT_IMP_EXISTS_THM; FORALL_PAIR_THM] THEN SIMP_TAC[PAIR_EQ; rightsubst; TERMSUBST_FVT] THEN REPEAT GEN_TAC THEN STRIP_TAC THEN REWRITE_TAC[IN_ELIM_THM] THEN DISCH_THEN(X_CHOOSE_THEN `z:num` (MP_TAC o CONJUNCT2)) THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY]] THEN UNDISCH_TAC `LOOPFREE (CONS (x,t) oth)` THEN REWRITE_TAC[LOOPFREE] THEN DISCH_THEN(MP_TAC o SPEC `x:num`) THEN REWRITE_TAC[TAUT `~a ==> ~b <=> b ==> a`] THEN DISCH_TAC THEN MATCH_MP_TAC TC_INC THEN REWRITE_TAC[OCC] THEN EXISTS_TAC `t:term` THEN ASM_REWRITE_TAC[MEM]; ALL_TAC] THEN UNDISCH_TAC `MEM (y,s) (APPEND (CONS p (MAP (rightsubst p) sol)) (MAP (rightsubst p) oth))` THEN REWRITE_TAC[APPEND; MEM] THEN DISCH_THEN(DISJ_CASES_THEN2 (SUBST_ALL_TAC o SYM) MP_TAC) THENL [FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[MEM; APPEND; MEM_APPEND] THEN ASM_MESON_TAC[]; ALL_TAC] THEN REWRITE_TAC[GSYM MAP_APPEND; MEM_MAP; LEFT_IMP_EXISTS_THM; FORALL_PAIR_THM] THEN SUBST_ALL_TAC(SYM(ISPEC `p:num#term` PAIR)) THEN REWRITE_TAC[rightsubst; PAIR_EQ] THEN GEN_TAC THEN X_GEN_TAC `u:term` THEN MAP_EVERY ABBREV_TAC [`z = FST(p:num#term)`; `r = SND(p:num#term)`] THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN DISCH_THEN(CONJUNCTS_THEN2 (SUBST_ALL_TAC o SYM) SUBST1_TAC) THEN REWRITE_TAC[TERMSUBST_FVT; IN_ELIM_THM] THEN DISCH_THEN(X_CHOOSE_THEN `w:num` MP_TAC) THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY] THENL [ALL_TAC; DISCH_THEN(CONJUNCTS_THEN2 MP_TAC (SUBST_ALL_TAC o SYM))] THEN ASM_MESON_TAC[MEM_APPEND; MEM]);; (* ------------------------------------------------------------------------- *) (* ...and maintains exactly the same set of unifiers. *) (* ------------------------------------------------------------------------- *) let SOLVE_PRESERVES_UNIFIERS = prove (`(!x t. MEM (x,t) (APPEND sol (CONS p oth)) ==> (i(x) = termsubst i t)) <=> (!x t. MEM (x,t) (APPEND (CONS p (MAP (rightsubst p) sol)) (MAP (rightsubst p) oth)) ==> (i(x) = termsubst i t))`, let lemma = prove (`(!x t y s. P y s /\ (x = y) /\ (t = f s) ==> Q x t) <=> (!x t s. P x s ==> Q x (f s))`, MESON_TAC[]) in REWRITE_TAC[MEM_APPEND; MEM] THEN GEN_REWRITE_TAC (LAND_CONV o ONCE_DEPTH_CONV) [TAUT `a \/ b \/ c <=> b \/ a \/ c`] THEN REWRITE_TAC[GSYM DISJ_ASSOC; GSYM MEM_APPEND; GSYM MAP_APPEND] THEN SPEC_TAC(`APPEND sol (oth:(num#term)list)`,`l:(num#term)list`) THEN GEN_TAC THEN REWRITE_TAC[TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN REWRITE_TAC[FORALL_AND_THM] THEN MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN SPEC_TAC(`p:num#term`,`p:num#term`) THEN REWRITE_TAC[FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`y:num`; `s:term`] THEN SIMP_TAC[PAIR_EQ; GSYM LEFT_IMP_EXISTS_THM] THEN REWRITE_TAC[RIGHT_EXISTS_AND_THM; LEFT_EXISTS_AND_THM; EXISTS_REFL] THEN DISCH_TAC THEN SIMP_TAC[MEM_MAP; LEFT_IMP_EXISTS_THM; FORALL_PAIR_THM] THEN REWRITE_TAC[rightsubst; PAIR_EQ; lemma] THEN REWRITE_TAC[TERMSUBST_TERMSUBST; o_DEF] THEN SUBGOAL_THEN `(\x. termsubst i (if x = y then s else V x)) = i` (fun th -> REWRITE_TAC[th]) THEN REWRITE_TAC[FUN_EQ_THM] THEN GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[termsubst]);; (* ------------------------------------------------------------------------- *) (* Hence it works. *) (* ------------------------------------------------------------------------- *) let SOLVE_WORKS_GENERAL = prove (`!n env sol. (LENGTH env = n) /\ LOOPFREE(env) /\ CONFLICTFREE(APPEND sol env) /\ (!x y s t. MEM (x,t) sol /\ MEM (y,s) (APPEND sol env) ==> ~(x IN FVT(s))) ==> CONFLICTFREE(SOLVE sol env) /\ (!i. (!x t. MEM (x,t) (APPEND sol env) ==> (i x = termsubst i t)) <=> (!x t. MEM (x,t) (SOLVE sol env) ==> (i x = termsubst i t))) /\ !x y s t. MEM (x,t) (SOLVE sol env) /\ MEM (y,s) (SOLVE sol env) ==> ~(x IN FVT(s))`, INDUCT_TAC THEN LIST_INDUCT_TAC THEN REWRITE_TAC[LENGTH; NOT_SUC] THENL [SIMP_TAC[SOLVE; APPEND_NIL] THEN MESON_TAC[]; ALL_TAC] THEN REWRITE_TAC[SUC_INJ; SOLVE] THEN X_GEN_TAC `sol:(num#term)list` THEN FIRST_X_ASSUM(K ALL_TAC o check is_imp o snd o dest_forall o concl) THEN REWRITE_TAC[SOLVE_PRESERVES_UNIFIERS] THEN STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC[LENGTH_MAP; SOLVE_PRESERVES_LOOPFREE; SOLVE_PRESERVES_CONFLICTFREE] THEN MATCH_MP_TAC SOLVE_PRESERVES_DEFREE THEN ASM_REWRITE_TAC[]);; let SOLVE_WORKS = prove (`!env. LOOPFREE(env) /\ CONFLICTFREE(env) ==> CONFLICTFREE(SOLVE [] env) /\ (!i. (!x t. MEM (x,t) env ==> (i x = termsubst i t)) <=> (!x t. MEM (x,t) (SOLVE [] env) ==> (i x = termsubst i t))) /\ !x y s t. MEM (x,t) (SOLVE [] env) /\ MEM (y,s) (SOLVE [] env) ==> ~(x IN FVT s)`, REPEAT GEN_TAC THEN STRIP_TAC THEN SUBGOAL_THEN `!x:num t:term. MEM (x,t) env = MEM (x,t) (APPEND [] env)` (fun th -> REWRITE_TAC[th]) THENL [REWRITE_TAC[APPEND]; ALL_TAC] THEN MATCH_MP_TAC SOLVE_WORKS_GENERAL THEN ASM_REWRITE_TAC[MEM; APPEND; GSYM EXISTS_REFL]);; (* ------------------------------------------------------------------------- *) (* The "actual code". *) (* ------------------------------------------------------------------------- *) let retval_INDUCT,retval_RECURSION = define_type "retval = TT | FF | Exception";; let retval_DISTINCT = prove_constructors_distinct retval_RECURSION;; let ISTRIV_EXISTS = prove (`!env x. LOOPFREE(env) /\ CONFLICTFREE(env) ==> ?istriv. !t. istriv t = if t = V x then TT else if ?y. (t = V y) /\ MEM y (MAP FST env) then istriv (ASSOC (@y. (t = V y) /\ MEM y (MAP FST env)) env) else if x IN FVT(t) then Exception else if ?y s. y IN FVT(t) /\ MEM (y,s) env /\ ~(istriv s = FF) then Exception else FF`, REWRITE_TAC[CONFLICTFREE] THEN REPEAT STRIP_TAC THEN FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP WF_REC o MATCH_MP LOOPFREE_WF_TERM) THEN REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN REPEAT(COND_CASES_TAC THEN ASM_REWRITE_TAC[]) THEN TRY(ASM (GEN_MESON_TAC 0 10 1) []) THEN FIRST_ASSUM MATCH_MP_TAC THEN FIRST_X_ASSUM(X_CHOOSE_THEN `z:num` STRIP_ASSUME_TAC) THEN EXISTS_TAC `z:num` THEN ASM_REWRITE_TAC[FVT; IN_INSERT; term_INJ] THEN SUBGOAL_THEN `(@y. (z = y) /\ MEM y (MAP FST (env:(num#term)list))) = z` SUBST1_TAC THENL [MATCH_MP_TAC SELECT_UNIQUE THEN X_GEN_TAC `w:num` THEN REWRITE_TAC[] THEN EQ_TAC THEN ASM_SIMP_TAC[]; ALL_TAC] THEN UNDISCH_TAC `MEM z (MAP FST (env:(num#term)list))` THEN UNDISCH_TAC `!x. LENGTH (FILTER (\(y:num,s:term). y = x) env) <= 1` THEN DISCH_THEN(MP_TAC o SPEC `z:num`) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MAP; MEM; ASSOC; FILTER] THEN SPEC_TAC(`h:num#term`,`h:num#term`) THEN ONCE_REWRITE_TAC[FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`y:num`; `s:term`] THEN REWRITE_TAC[FST; SND] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_CASES_TAC `y:num = z` THEN ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]);; let istriv_raw = new_specification ["istriv"] (REWRITE_RULE[SKOLEM_THM; RIGHT_IMP_EXISTS_THM] ISTRIV_EXISTS);; let istriv = prove (`!env x. LOOPFREE(env) /\ CONFLICTFREE(env) ==> (!x y. istriv env x (V y) = if y = x then TT else if MEM y (MAP FST env) then istriv env x (ASSOC y env) else FF) /\ (!f args. istriv env x (Fn f args) = if EX (\a. ~(istriv env x a = FF)) args then Exception else FF)`, REPEAT GEN_TAC THEN DISCH_TAC THEN REPEAT STRIP_TAC THEN FIRST_ASSUM(fun th -> GEN_REWRITE_TAC LAND_CONV [MATCH_MP istriv_raw th]) THEN REWRITE_TAC[term_INJ; term_DISTINCT] THENL [COND_CASES_TAC THEN REWRITE_TAC[] THEN REWRITE_TAC[UNWIND_THM1] THEN ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; UNWIND_THM2] THEN COND_CASES_TAC THEN REWRITE_TAC[] THENL [AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN MATCH_MP_TAC SELECT_UNIQUE THEN X_GEN_TAC `w:num` THEN REWRITE_TAC[] THEN EQ_TAC THEN ASM_SIMP_TAC[]; ALL_TAC] THEN COND_CASES_TAC THEN REWRITE_TAC[] THEN UNDISCH_TAC `~MEM y (MAP FST (env:(num#term)list))` THEN MATCH_MP_TAC(TAUT `a ==> ~a ==> b`) THEN FIRST_ASSUM(CHOOSE_THEN (MP_TAC o CONJUNCT1)) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; MAP] THEN DISCH_THEN(DISJ_CASES_THEN2 (SUBST1_TAC o SYM) MP_TAC) THEN ASM_SIMP_TAC[FST]; ALL_TAC] THEN ASM_CASES_TAC `x IN FVT(Fn f args)` THEN ASM_REWRITE_TAC[] THENL [COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN UNDISCH_TAC `~EX (\a. ~(istriv env x a = FF)) args` THEN MATCH_MP_TAC(TAUT `a ==> ~a ==> b`) THEN UNDISCH_TAC `x IN FVT (Fn f args)` THEN REWRITE_TAC[FVT; IN_LIST_UNION; EX_MAP] THEN MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ] EX_IMP) THEN REWRITE_TAC[o_THM] THEN MATCH_MP_TAC term_INDUCT THEN CONJ_TAC THEN REPEAT GEN_TAC THEN STRIP_TAC THEN TRY(DISCH_THEN(CONJUNCTS_THEN ASSUME_TAC)) THEN FIRST_ASSUM(fun th -> ONCE_REWRITE_TAC[MATCH_MP istriv_raw th]) THENL [RULE_ASSUM_TAC(REWRITE_RULE[FVT; IN_INSERT; NOT_IN_EMPTY]) THEN ASM_REWRITE_TAC[retval_DISTINCT]; ASM_REWRITE_TAC[term_DISTINCT; retval_DISTINCT]]; ALL_TAC] THEN AP_THM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN REWRITE_TAC[FVT; IN_LIST_UNION; EX_MAP] THEN REWRITE_TAC[LEFT_AND_EX_THM] THEN REWRITE_TAC[EXISTS_EX] THEN REWRITE_TAC[o_THM] THEN UNDISCH_TAC `~(x IN FVT (Fn f args))` THEN REWRITE_TAC[FVT; IN_LIST_UNION; EX_MAP] THEN MATCH_MP_TAC EX_ADHOC THEN X_GEN_TAC `t:term` THEN REWRITE_TAC[o_THM] THEN DISCH_TAC THEN FIRST_ASSUM(fun th -> GEN_REWRITE_TAC (RAND_CONV o RAND_CONV o LAND_CONV) [MATCH_MP istriv_raw th]) THEN COND_CASES_TAC THENL [UNDISCH_TAC `~(x IN FVT t)` THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY]; ALL_TAC] THEN ASM_REWRITE_TAC[] THEN ASM_CASES_TAC `?y. (t = V y) /\ MEM y (MAP FST (env:(num#term)list))` THEN ASM_REWRITE_TAC[] THENL [ALL_TAC; COND_CASES_TAC THEN ASM_REWRITE_TAC[retval_DISTINCT]] THEN FIRST_X_ASSUM(X_CHOOSE_THEN `y:num` STRIP_ASSUME_TAC) THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; term_INJ] THEN ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN REWRITE_TAC[UNWIND_THM2] THEN SUBGOAL_THEN `(@z. (y = z) /\ MEM z (MAP FST (env:(num#term)list))) = y` SUBST1_TAC THENL [MATCH_MP_TAC SELECT_UNIQUE THEN X_GEN_TAC `w:num` THEN REWRITE_TAC[] THEN EQ_TAC THEN ASM_SIMP_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!s. MEM (y:num,s:term) env <=> (s = ASSOC y env)` (fun th -> MESON_TAC[th]) THEN GEN_TAC THEN UNDISCH_TAC `MEM y (MAP FST (env:(num#term)list))` THEN FIRST_ASSUM(MP_TAC o CONJUNCT2) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN POP_ASSUM_LIST(K ALL_TAC) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; MAP] THEN SPEC_TAC(`h:num#term`,`h:num#term`) THEN ONCE_REWRITE_TAC[FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`x:num`; `t:term`] THEN REWRITE_TAC[FST; SND; PAIR_EQ; ASSOC] THEN ASM_CASES_TAC `x:num = y` THEN ASM_REWRITE_TAC[] THENL [MATCH_MP_TAC(TAUT `(b ==> ~a) ==> (a ==> (c \/ b <=> c))`) THEN DISCH_TAC THEN REWRITE_TAC[CONFLICTFREE] THEN DISCH_THEN(MP_TAC o SPEC `y:num`) THEN REWRITE_TAC[FILTER; LENGTH] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[LENGTH; ARITH_RULE `~(SUC n <= 1) <=> ~(n = 0)`] THEN REWRITE_TAC[LENGTH_EQ_NIL] THEN DISCH_THEN(MP_TAC o AP_TERM `MEM (y:num,s:term)`) THEN ASM_REWRITE_TAC[MEM; MEM_FILTER] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REFL_TAC; ALL_TAC] THEN DISCH_TAC THEN SUBGOAL_THEN `CONFLICTFREE t` (fun th -> ASM_MESON_TAC[th]) THEN FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [CONFLICTFREE]) THEN REWRITE_TAC[CONFLICTFREE; MEM; FILTER] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_FORALL THEN GEN_TAC THEN COND_CASES_TAC THEN REWRITE_TAC[LENGTH] THEN ARITH_TAC);; (* ------------------------------------------------------------------------- *) (* Prove that it works. *) (* ------------------------------------------------------------------------- *) let EQV = new_definition `EQV env x y = MEM (x,V y) env`;; let EQV_IMP_OCC = prove (`!env x y. EQV env x y ==> OCC env x y`, REWRITE_TAC[EQV; OCC] THEN MESON_TAC[IN_INSERT; FVT]);; let ISTRIV_WORKS = prove (`!env x t. LOOPFREE(env) /\ CONFLICTFREE(env) ==> (istriv env x t = if ?y. (t = V y) /\ RTC (EQV env) y x then TT else if ?y. y IN FVT t /\ RTC (OCC env) y x then Exception else FF)`, GEN_TAC THEN REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN DISCH_TAC THEN GEN_TAC THEN FIRST_ASSUM(MP_TAC o MATCH_MP LOOPFREE_WF_TERM o CONJUNCT1) THEN REWRITE_TAC[WF_IND] THEN DISCH_THEN MATCH_MP_TAC THEN X_GEN_TAC `t:term` THEN DISCH_TAC THEN FIRST_ASSUM(fun th -> ONCE_REWRITE_TAC[MATCH_MP istriv_raw th]) THEN ASM_CASES_TAC `t = V x` THEN ASM_REWRITE_TAC[] THENL [COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[term_INJ; RTC_REFL]; ALL_TAC] THEN ASM_CASES_TAC `?y. (t = V y) /\ MEM y (MAP FST (env:(num#term)list))` THEN ASM_REWRITE_TAC[] THENL [FIRST_X_ASSUM(X_CHOOSE_THEN `z:num` STRIP_ASSUME_TAC) THEN ASM_REWRITE_TAC[term_INJ; UNWIND_THM1] THEN SUBGOAL_THEN `(@y. (z = y) /\ MEM y (MAP FST (env:(num#term)list))) = z` SUBST1_TAC THENL [MATCH_MP_TAC SELECT_UNIQUE THEN X_GEN_TAC `w:num` THEN REWRITE_TAC[] THEN EQ_TAC THEN ASM_SIMP_TAC[]; ALL_TAC] THEN FIRST_X_ASSUM(MP_TAC o SPEC `ASSOC z (env:(num#term)list)`) THEN ANTS_TAC THENL [EXISTS_TAC `z:num` THEN ASM_REWRITE_TAC[FVT; IN_INSERT] THEN UNDISCH_TAC `MEM z (MAP FST (env:(num#term)list))` THEN FIRST_ASSUM(MP_TAC o CONJUNCT2) THEN REWRITE_TAC[CONFLICTFREE] THEN DISCH_THEN(MP_TAC o SPEC `z:num`) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MAP; MEM; ASSOC; FILTER] THEN SPEC_TAC(`h:num#term`,`h:num#term`) THEN ONCE_REWRITE_TAC[FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`y:num`; `s:term`] THEN REWRITE_TAC[FST; SND] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_CASES_TAC `y:num = z` THEN ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]; ALL_TAC] THEN DISCH_THEN SUBST1_TAC THEN ASM_REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; UNWIND_THM2] THEN GEN_REWRITE_TAC (RAND_CONV o ONCE_DEPTH_CONV) [RTC_CASES_R] THEN ASM_CASES_TAC `x:num = z` THENL [ASM_MESON_TAC[]; ALL_TAC] THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[OCC; EQV] THEN SUBGOAL_THEN `!s. MEM (z:num,s:term) env = (s = ASSOC z env)` (fun th -> REWRITE_TAC[th]) THENL [GEN_TAC THEN UNDISCH_TAC `MEM z (MAP FST (env:(num#term)list))` THEN FIRST_ASSUM(MP_TAC o CONJUNCT2) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN POP_ASSUM_LIST(K ALL_TAC) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; MAP] THEN SPEC_TAC(`h:num#term`,`h:num#term`) THEN ONCE_REWRITE_TAC[FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`x:num`; `t:term`] THEN REWRITE_TAC[FST; SND; PAIR_EQ; ASSOC] THEN ASM_CASES_TAC `x:num = z` THEN ASM_REWRITE_TAC[] THENL [MATCH_MP_TAC(TAUT `(b ==> ~a) ==> (a ==> (c \/ b <=> c))`) THEN DISCH_TAC THEN REWRITE_TAC[CONFLICTFREE] THEN DISCH_THEN(MP_TAC o SPEC `z:num`) THEN REWRITE_TAC[FILTER; LENGTH] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[LENGTH; ARITH_RULE `~(SUC n <= 1) <=> ~(n = 0)`] THEN REWRITE_TAC[LENGTH_EQ_NIL] THEN DISCH_THEN(MP_TAC o AP_TERM `MEM (z:num,s:term)`) THEN ASM_REWRITE_TAC[MEM; MEM_FILTER] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REFL_TAC; ALL_TAC] THEN DISCH_TAC THEN SUBGOAL_THEN `CONFLICTFREE t` (fun th -> ASM_MESON_TAC[th]) THEN FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [CONFLICTFREE]) THEN REWRITE_TAC[CONFLICTFREE; MEM; FILTER] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_FORALL THEN GEN_TAC THEN COND_CASES_TAC THEN REWRITE_TAC[LENGTH] THEN ARITH_TAC; ALL_TAC] THEN GEN_REWRITE_TAC (LAND_CONV o RATOR_CONV o LAND_CONV o BINDER_CONV o LAND_CONV) [EQ_SYM_EQ] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[UNWIND_THM2]; ALL_TAC] THEN SUBGOAL_THEN `~(?y. (t = V y) /\ RTC (EQV env) y x)` ASSUME_TAC THENL [UNDISCH_TAC `~(?y. (t = V y) /\ MEM y (MAP FST (env:(num#term)list)))` THEN REWRITE_TAC[TAUT `~a ==> ~b <=> b ==> a`] THEN ONCE_REWRITE_TAC[RTC_CASES_R] THEN REWRITE_TAC[EQV] THEN MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `y:num` THEN ASM_CASES_TAC `y = x:num` THENL [ASM_MESON_TAC[]; ALL_TAC] THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[MEM_MAP] THEN MESON_TAC[FST]; ALL_TAC] THEN ASM_REWRITE_TAC[] THEN ASM_CASES_TAC `x IN FVT(t)` THEN ASM_REWRITE_TAC[] THENL [SUBGOAL_THEN `?y. y IN FVT t /\ RTC (OCC env) y x` (fun th -> REWRITE_TAC[th]) THEN ASM_MESON_TAC[RTC_REFL]; ALL_TAC] THEN AP_THM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN REWRITE_TAC[FUN_EQ_THM] THEN X_GEN_TAC `y:num` THEN REWRITE_TAC[RIGHT_EXISTS_AND_THM] THEN MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN DISCH_TAC THEN ONCE_REWRITE_TAC[RTC_CASES_R] THEN ASM_CASES_TAC `y = x:num` THENL [ASM_MESON_TAC[]; ALL_TAC] THEN ASM_REWRITE_TAC[OCC; LEFT_AND_EXISTS_THM] THEN ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN REWRITE_TAC[GSYM CONJ_ASSOC; RIGHT_EXISTS_AND_THM] THEN AP_TERM_TAC THEN REWRITE_TAC[FUN_EQ_THM] THEN X_GEN_TAC `s:term` THEN MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC `s:term`) THEN ANTS_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN DISCH_THEN SUBST1_TAC THEN ASM_CASES_TAC `?y. (s = V y) /\ RTC (EQV env) y x` THEN ASM_REWRITE_TAC[retval_DISTINCT] THENL [FIRST_X_ASSUM(X_CHOOSE_THEN `z:num` STRIP_ASSUME_TAC) THEN EXISTS_TAC `z:num` THEN ASM_REWRITE_TAC[FVT; IN_INSERT] THEN ASM_MESON_TAC[RTC_MONO; EQV_IMP_OCC]; ALL_TAC] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[retval_DISTINCT]);; (* ------------------------------------------------------------------------- *) (* Wellfoundedness lemmas. *) (* ------------------------------------------------------------------------- *) let SUB1 = new_definition `SUB1 s t <=> ?f args. (t = Fn f args) /\ MEM s args`;; let WF_SUB1 = prove (`WF(SUB1)`, SIMP_TAC[WF_IND; SUB1; LEFT_IMP_EXISTS_THM] THEN REPEAT GEN_TAC THEN DISCH_TAC THEN MATCH_MP_TAC term_INDUCT THEN REPEAT STRIP_TAC THEN FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[term_DISTINCT; term_INJ] THEN RULE_ASSUM_TAC(REWRITE_RULE[GSYM ALL_MEM]) THEN ASM_MESON_TAC[]);; let RTC_SUB1 = prove (`!x t. RTC(SUB1) (V x) t <=> x IN FVT(t)`, GEN_TAC THEN MATCH_MP_TAC term_INDUCT THEN REWRITE_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; IN_LIST_UNION] THEN CONJ_TAC THEN REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC[RTC_CASES_L] THEN REWRITE_TAC[SUB1; term_INJ; term_DISTINCT] THEN MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC `?y. RTC SUB1 (V x) y /\ MEM y l` THEN CONJ_TAC THENL [MESON_TAC[]; ALL_TAC] THEN REWRITE_TAC[EX_MAP; o_DEF] THEN FIRST_ASSUM(SUBST1_TAC o SYM o MATCH_MP ALL_ADHOC) THEN REWRITE_TAC[EX_MEM]);; let WF_SUBCOMPONENT = prove (`LOOPFREE(env) ==> WF(\s t. ?x. MEM (x,s) env /\ RTC(SUB1) (V x) t)`, REWRITE_TAC[RTC_SUB1] THEN ONCE_REWRITE_TAC[CONJ_SYM] THEN REWRITE_TAC[LOOPFREE_WF_TERM]);; let WF_DESCENT = prove (`LOOPFREE(env) ==> WF(\s t. (?x. (t = V x) /\ MEM (x,s) env) \/ (?f args. (t = Fn f args) /\ MEM s args))`, REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC[DISJ_SYM] THEN MATCH_MP_TAC WF_DISJ THEN REWRITE_TAC[GSYM SUB1] THEN CONV_TAC(TOP_DEPTH_CONV ETA_CONV) THEN REWRITE_TAC[WF_SUB1] THEN REWRITE_TAC[LEFT_AND_EXISTS_THM] THEN ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN REWRITE_TAC[GSYM CONJ_ASSOC; UNWIND_THM2] THEN ASM_SIMP_TAC[WF_SUBCOMPONENT]);; (* ------------------------------------------------------------------------- *) (* Existence of unify. *) (* ------------------------------------------------------------------------- *) let termcases = new_recursive_definition term_RECURSION `(termcases cv cf (V v) = cv v) /\ (termcases cv cf (Fn f args) = cf f args)`;; let tpcases_def = new_definition `tpcases c1 c2 c3 (t1,t2) = termcases (\v1. termcases (\v2. c2 v1 (V v2)) (\f2 args2. c2 v1 (Fn f2 args2)) t2) (\f1 args1. termcases (\v2. c3 f1 args1 v2) (\f2 args2. c1 f1 args1 f2 args2) t2) t1`;; let tpcases = prove (`(tpcases c1 c2 c3 (Fn f1 args1,Fn f2 args2) = c1 f1 args1 f2 args2) /\ (tpcases c1 c2 c3 (V v1,t2) = c2 v1 t2) /\ (tpcases c1 c2 c3 (Fn f1 args1,V v2) = c3 f1 args1 v2)`, SPEC_TAC(`t2:term`,`t2:term`) THEN MATCH_MP_TAC term_INDUCT THEN REWRITE_TAC[tpcases_def; termcases]);; let MLEFT = new_definition `MLEFT (env,eqs) = CARD(FVT(Fn 0 (MAP FST eqs)) UNION FVT(Fn 0 (MAP SND eqs)) UNION FVT(Fn 0 (MAP SND env)) UNION FVT(Fn 0 (MAP (V o FST) env))) - CARD(FVT(Fn 0 (MAP (V o FST) env)))`;; let CRIGHT = new_definition `CRIGHT (env',eqs') (env,eqs) <=> LOOPFREE(env) /\ (env' = env) /\ ((?f args1 args2 oth. (LENGTH args1 = LENGTH args2) /\ (eqs = CONS (Fn f args1,Fn f args2) oth) /\ (eqs' = APPEND (ZIP args1 args2) oth)) \/ (?x t oth. (eqs = CONS (V x,t) oth) /\ (MEM x (MAP FST env) /\ (eqs' = CONS (ASSOC x env,t) oth) \/ ~(MEM x (MAP FST env)) /\ (istriv env x t = TT) /\ (eqs' = oth))) \/ (?x f args oth. (eqs = CONS (Fn f args,V x) oth) /\ (eqs' = CONS (V x,Fn f args) oth)))`;; let CALLORDER = new_definition `CALLORDER (env',eqs') (env,eqs) <=> MEASURE MLEFT (env',eqs') (env,eqs) \/ CRIGHT (env',eqs') (env,eqs)`;; let PAIRED_ETA_THM = prove (`!g:A#B->C. (\(p1,p2). g (p1,p2)) = g`, REWRITE_TAC[FUN_EQ_THM; FORALL_PAIR_THM] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[]);; let WF_CRIGHT = prove (`WF CRIGHT`, SUBGOAL_THEN `CRIGHT = \(env',eqs') (env,eqs). CRIGHT (env',eqs') (env,eqs)` SUBST1_TAC THENL [REWRITE_TAC[PAIRED_ETA_THM] THEN CONV_TAC(TOP_DEPTH_CONV ETA_CONV) THEN REFL_TAC; ALL_TAC] THEN REWRITE_TAC[CRIGHT] THEN MATCH_MP_TAC WF_PROJ_EQ THEN X_GEN_TAC `env:(num#term)list` THEN DISCH_TAC THEN REWRITE_TAC[] THEN FIRST_ASSUM(MP_TAC o MATCH_MP WF_DESCENT) THEN DISCH_THEN(MP_TAC o GEN_ALL o MATCH_MP (ONCE_REWRITE_RULE [IMP_CONJ] WF_ALTERNATION)) THEN DISCH_THEN(MP_TAC o SPEC `\s t. (?f args. s = Fn f args) /\ (?x. t = V x)`) THEN REWRITE_TAC[] THEN ANTS_TAC THENL [MESON_TAC[term_DISTINCT]; ALL_TAC] THEN DISCH_THEN(MP_TAC o MATCH_MP WF_MULTIZIP) THEN MATCH_MP_TAC(ONCE_REWRITE_RULE [IMP_CONJ] WF_SUBSET) THEN MAP_EVERY X_GEN_TAC [`eqs2:(term#term)list`; `eqs1:(term#term)list`] THEN REWRITE_TAC[] THEN STRIP_TAC THENL [MAP_EVERY EXISTS_TAC [`(Fn f args1,Fn f args2)`; `oth:(term#term)list`; `(ZIP args1 args2):(term#term)list`] THEN ASM_REWRITE_TAC[] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`s:term`; `t:term`] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN DISCH_TAC THEN DISJ1_TAC THEN REWRITE_TAC[LEFT_AND_EXISTS_THM; RIGHT_AND_EXISTS_THM] THEN MAP_EVERY EXISTS_TAC [`f:num`; `args1:term list`; `f:num`; `args2:term list`] THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THENL [FIRST_ASSUM(SUBST1_TAC o SYM o MATCH_MP MAP_FST_ZIP); FIRST_ASSUM(SUBST1_TAC o SYM o MATCH_MP MAP_SND_ZIP)] THEN REWRITE_TAC[MEM_MAP] THEN ASM_MESON_TAC[FST; SND]; MAP_EVERY EXISTS_TAC [`(V x,t:term)`; `oth:(term#term)list`; `[ASSOC x (env:(num#term)list),t:term]`] THEN ASM_REWRITE_TAC[APPEND] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`s:term`; `u:term`] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[MEM; PAIR_EQ] THEN DISCH_THEN(CONJUNCTS_THEN SUBST_ALL_TAC) THEN DISJ2_TAC THEN DISJ1_TAC THEN REWRITE_TAC[] THEN EXISTS_TAC `x:num` THEN ASM_REWRITE_TAC[MEM_ASSOC]; MAP_EVERY EXISTS_TAC [`(V x,t:term)`; `oth:(term#term)list`; `[]:(term#term)list`] THEN ASM_REWRITE_TAC[APPEND; MEM]; MAP_EVERY EXISTS_TAC [`(Fn f args,V x)`; `oth:(term#term)list`; `[V x,Fn f args]`] THEN ASM_REWRITE_TAC[APPEND] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`s:term`; `u:term`] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[MEM; PAIR_EQ] THEN DISCH_THEN(CONJUNCTS_THEN SUBST_ALL_TAC) THEN REWRITE_TAC[] THEN REPEAT DISJ2_TAC THEN MESON_TAC[]]);; let WF_CALLORDER = prove (`WF CALLORDER`, SUBGOAL_THEN `CALLORDER = \(env',eqs') (env,eqs). CALLORDER (env',eqs') (env,eqs)` SUBST1_TAC THENL [REWRITE_TAC[PAIRED_ETA_THM] THEN CONV_TAC(TOP_DEPTH_CONV ETA_CONV) THEN REFL_TAC; ALL_TAC] THEN REWRITE_TAC[CALLORDER] THEN REWRITE_TAC[PAIRED_ETA_THM] THEN MATCH_MP_TAC WF_MEASURE_OR_NONINC THEN REWRITE_TAC[WF_CRIGHT; FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`env':(num#term)list`; `eqs':(term#term)list`; `env:(num#term)list`; `eqs:(term#term)list`] THEN REWRITE_TAC[CRIGHT; MLEFT] THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN DISCH_THEN(CONJUNCTS_THEN2 SUBST1_TAC ASSUME_TAC) THEN MATCH_MP_TAC(ARITH_RULE `a <= c:num ==> a - b <= c - b`) THEN MATCH_MP_TAC CARD_SUBSET THEN REWRITE_TAC[FINITE_UNION; FVT_FINITE] THEN REWRITE_TAC[SUBSET; IN_UNION] THEN X_GEN_TAC `x:num` THEN FIRST_X_ASSUM(DISJ_CASES_THEN STRIP_ASSUME_TAC) THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[MAP; MAP_APPEND; FVT; LIST_UNION; LIST_UNION_APPEND] THEN REWRITE_TAC[IN_UNION; GSYM DISJ_ASSOC] THENL [MATCH_MP_TAC(TAUT `(a' <=> a) /\ (c' <=> c) ==> a \/ b \/ c \/ d ==> a' \/ b \/ c' \/ d`) THEN ASM_SIMP_TAC[MAP_FST_ZIP; MAP_SND_ZIP]; MATCH_MP_TAC(TAUT `(a ==> e) ==> a \/ b \/ c \/ d \/ e \/ f ==> a' \/ b \/ c \/ d \/ e \/ f`) THEN UNDISCH_TAC `MEM x' (MAP FST (env:(num#term)list))` THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; MAP; ASSOC] THEN COND_CASES_TAC THEN ASM_SIMP_TAC[LIST_UNION; IN_UNION]; CONV_TAC TAUT; CONV_TAC TAUT]);; let UNIFY_EXISTS_RAW = prove (`?unify. !pr. unify pr = if ~LOOPFREE(FST pr) then NONE else if SND pr = [] then SOME(FST pr) else tpcases (\f fargs g gargs. if (f = g) /\ (LENGTH fargs = LENGTH gargs) then unify (FST pr,APPEND (ZIP fargs gargs) (TL(SND pr))) else NONE) (\x t. if MEM x (MAP FST (FST pr)) then unify (FST pr,CONS (ASSOC x (FST pr),t) (TL(SND pr))) else if istriv (FST pr) x t = Exception then NONE else if istriv (FST pr) x t = TT then unify(FST pr,TL(SND pr)) else unify(CONS (x,t) (FST pr),TL(SND pr))) (\f args x. unify (FST pr, CONS (V x,Fn f args) (TL(SND pr)))) (HD(SND pr))`, MATCH_MP_TAC(MATCH_MP WF_REC WF_CALLORDER) THEN MAP_EVERY X_GEN_TAC [`unify1:(num#term)list#(term#term)list->((num#term)list)option`; `unify2:(num#term)list#(term#term)list->((num#term)list)option`] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`env1:(num#term)list`; `eqs1:(term#term)list`] THEN DISCH_THEN(MP_TAC o GENL [`env2:(num#term)list`; `eqs2:(term#term)list`] o SPEC `(env2,eqs2):(num#term)list#(term#term)list`) THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[FST; SND] THEN DISCH_TAC THEN ASM_CASES_TAC `LOOPFREE env1` THEN ASM_REWRITE_TAC[] THEN MP_TAC(ISPEC `eqs1:(term#term)list` list_CASES) THEN DISCH_THEN(DISJ_CASES_THEN2 SUBST1_TAC MP_TAC) THEN REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_THEN `hpr:term#term` (X_CHOOSE_THEN `oth:(term#term)list` SUBST_ALL_TAC)) THEN REWRITE_TAC[NOT_CONS_NIL; HD; TL] THEN SUBST_ALL_TAC(GSYM(ISPEC `hpr:term#term` PAIR)) THEN MP_TAC(ISPEC `FST(hpr:term#term)` term_CASES) THEN DISCH_THEN(DISJ_CASES_THEN2 (X_CHOOSE_THEN `x:num` SUBST_ALL_TAC) (X_CHOOSE_THEN `f:num` (X_CHOOSE_THEN `fargs:term list` SUBST_ALL_TAC))) THENL [ABBREV_TAC `t = SND(hpr:term#term)`; MP_TAC(ISPEC `SND(hpr:term#term)` term_CASES) THEN DISCH_THEN(DISJ_CASES_THEN2 (X_CHOOSE_THEN `x:num` SUBST_ALL_TAC) (X_CHOOSE_THEN `g:num` (X_CHOOSE_THEN `gargs:term list` SUBST_ALL_TAC)))] THEN REWRITE_TAC[tpcases] THENL [ALL_TAC; FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[CALLORDER] THEN DISJ2_TAC THEN ASM_REWRITE_TAC[CRIGHT] THEN REPEAT DISJ2_TAC THEN ASM_MESON_TAC[]; COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[CALLORDER] THEN DISJ2_TAC THEN ASM_REWRITE_TAC[CRIGHT] THEN ASM_MESON_TAC[]] THEN ASM_CASES_TAC `MEM x (MAP FST (env1:(num#term)list))` THEN ASM_REWRITE_TAC[] THENL [FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[CALLORDER] THEN DISJ2_TAC THEN ASM_REWRITE_TAC[CRIGHT] THEN DISJ2_TAC THEN DISJ1_TAC THEN ASM_MESON_TAC[]; ALL_TAC] THEN ASM_CASES_TAC `istriv env1 x t = Exception` THEN ASM_REWRITE_TAC[] THEN ASM_CASES_TAC `istriv env1 x t = TT` THEN ASM_REWRITE_TAC[] THENL [FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[CALLORDER] THEN DISJ2_TAC THEN ASM_REWRITE_TAC[CRIGHT] THEN DISJ2_TAC THEN DISJ1_TAC THEN ASM_MESON_TAC[]; ALL_TAC] THEN FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[CALLORDER] THEN DISJ1_TAC THEN REWRITE_TAC[MEASURE; MLEFT] THEN REWRITE_TAC[MAP; FST; SND; LENGTH] THEN MATCH_MP_TAC(ARITH_RULE `(a' = a) /\ (b' = b + 1) /\ b' <= a' ==> a' - b' < a - b`) THEN SUBGOAL_THEN `FVT(Fn 0 (CONS ((V o FST) (x,t:term)) (MAP (V o FST) env1))) = x INSERT FVT(Fn 0 (MAP (V o FST) (env1:(num#term)list)))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST] THEN SET_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `FVT(Fn 0 (CONS (V x) (MAP FST (oth:(term#term)list)))) = x INSERT FVT(Fn 0 (MAP FST oth))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST] THEN SET_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `FVT(Fn 0 (CONS t (MAP SND env1))) = FVT(t) UNION FVT(Fn 0 (MAP SND (env1:(num#term)list)))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST]; ALL_TAC] THEN SUBGOAL_THEN `FVT(Fn 0 (CONS t (MAP SND oth))) = FVT(t) UNION FVT(Fn 0 (MAP SND (oth:(term#term)list)))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST]; ALL_TAC] THEN REPEAT CONJ_TAC THENL [AP_TERM_TAC THEN REWRITE_TAC[EXTENSION; IN_UNION; DISJ_ACI; IN_INSERT]; SIMP_TAC[CARD_CLAUSES; FVT_FINITE; ADD1] THEN COND_CASES_TAC THEN REWRITE_TAC[] THEN UNDISCH_TAC `x IN FVT (Fn 0 (MAP (V o FST) (env1:(num#term)list)))` THEN UNDISCH_TAC `~MEM x (MAP FST (env1:(num#term)list))` THEN MATCH_MP_TAC(TAUT `(b ==> a) ==> ~a ==> b ==> c`) THEN SPEC_TAC(`env1:(num#term)list`,`env1:(num#term)list`) THEN REWRITE_TAC[FVT] THEN LIST_INDUCT_TAC THEN REWRITE_TAC[LIST_UNION; MEM; MAP; NOT_IN_EMPTY] THEN REWRITE_TAC[o_THM; FVT; IN_UNION; IN_INSERT; NOT_IN_EMPTY] THEN STRIP_TAC THEN ASM_SIMP_TAC[]; MATCH_MP_TAC CARD_SUBSET THEN REWRITE_TAC[FINITE_UNION; FVT_FINITE; FINITE_INSERT] THEN REWRITE_TAC[SUBSET; IN_UNION; IN_INSERT] THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[]]);; let unify_raw = new_specification ["unify"] UNIFY_EXISTS_RAW;; let unify = prove (`LOOPFREE(env) ==> (unify (env,CONS (Fn f fargs,Fn g gargs) oth) = if (f = g) /\ (LENGTH fargs = LENGTH gargs) then unify (env,APPEND (ZIP fargs gargs) oth) else NONE) /\ (unify (env,CONS (V x,t) oth) = if MEM x (MAP FST env) then unify (env,CONS (ASSOC x env,t) oth) else if istriv env x t = Exception then NONE else if istriv env x t = TT then unify (env,oth) else unify (CONS (x,t) env,oth)) /\ (unify (env,CONS (Fn f fargs,V x) oth) = unify (env,CONS (V x,Fn f fargs) oth))`, DISCH_TAC THEN REPEAT CONJ_TAC THEN GEN_REWRITE_TAC LAND_CONV [unify_raw] THEN ASM_REWRITE_TAC[FST; SND; HD; TL; NOT_CONS_NIL; tpcases]);; (* ------------------------------------------------------------------------- *) (* Show that it does indeed work. *) (* ------------------------------------------------------------------------- *) let unifies = new_definition `unifies i l <=> ALL (\(s,t). termsubst i s = termsubst i t) l`;; let OPTION_DISTINCT = prove_constructors_distinct option_RECURSION;; let OPTION_INJ = prove_constructors_injective option_RECURSION;; let TC_SUB1_IRREFL = prove (`!s t. TC SUB1 s t ==> ~(s = t)`, REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[TAUT `a ==> ~b <=> b ==> ~a`] THEN DISCH_THEN SUBST1_TAC THEN MATCH_MP_TAC WF_REFL THEN CONV_TAC(ONCE_DEPTH_CONV ETA_CONV) THEN REWRITE_TAC[WF_TC; WF_SUB1]);; let UNIFY_OCCURS = prove (`!env i. ALL (\(x,t). i x = termsubst i t) env ==> !x y. RTC (OCC env) x y ==> RTC SUB1 (i y) (i x)`, REPEAT GEN_TAC THEN DISCH_TAC THEN MATCH_MP_TAC RTC_INDUCT THEN REWRITE_TAC[RTC_REFL] THEN CONJ_TAC THENL [ALL_TAC; MESON_TAC[RTC_TRANS]] THEN REPEAT GEN_TAC THEN REWRITE_TAC[OCC] THEN DISCH_THEN(X_CHOOSE_THEN `t:term` STRIP_ASSUME_TAC) THEN FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [GSYM ALL_MEM]) THEN DISCH_THEN(MP_TAC o SPEC `(x:num,t:term)`) THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_SIMP_TAC[] THEN DISCH_TAC THEN UNDISCH_TAC `y IN FVT(t)` THEN SPEC_TAC(`y:num`,`y:num`) THEN SPEC_TAC(`t:term`,`t:term`) THEN MATCH_MP_TAC term_INDUCT THEN SIMP_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; termsubst; RTC_REFL] THEN MAP_EVERY X_GEN_TAC [`f:num`; `args:term list`] THEN DISCH_TAC THEN X_GEN_TAC `z:num` THEN REWRITE_TAC[IN_LIST_UNION] THEN REWRITE_TAC[EX_MAP; o_DEF] THEN REWRITE_TAC[GSYM EX_MEM] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THEN MATCH_MP_TAC RTC_TRANS_L THEN EXISTS_TAC `termsubst i s` THEN CONJ_TAC THENL [UNDISCH_TAC `ALL (\t. !y. y IN FVT t ==> RTC SUB1 (i y) (termsubst i t)) args` THEN REWRITE_TAC[GSYM ALL_MEM] THEN ASM_MESON_TAC[]; REWRITE_TAC[SUB1] THEN EXISTS_TAC `f:num` THEN EXISTS_TAC `MAP (termsubst i) args` THEN REWRITE_TAC[MEM_MAP] THEN ASM_MESON_TAC[]]);; let UNIFY_OCCURS_PROPER = prove (`!env i. ALL (\(x,t). i x = termsubst i t) env ==> !x y. RTC (OCC env) x y ==> RTC (EQV env) x y \/ TC SUB1 (i y) (i x)`, REPEAT GEN_TAC THEN DISCH_TAC THEN MATCH_MP_TAC RTC_INDUCT THEN REWRITE_TAC[RTC_REFL] THEN CONJ_TAC THENL [ALL_TAC; REPEAT STRIP_TAC THENL [ASM_MESON_TAC[RTC_TRANS]; DISJ2_TAC THEN ONCE_REWRITE_TAC[TC_TC_RTC_CASES]; DISJ2_TAC THEN ONCE_REWRITE_TAC[TC_RTC_TC_CASES]; ASM_MESON_TAC[TC_TRANS]] THEN EXISTS_TAC `(i:num->term) y` THEN ASM_REWRITE_TAC[] THEN FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP UNIFY_OCCURS) THEN ASM_MESON_TAC[EQV_IMP_OCC; RTC_MONO]] THEN REPEAT GEN_TAC THEN REWRITE_TAC[OCC] THEN DISCH_THEN(X_CHOOSE_THEN `t:term` MP_TAC) THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [GSYM ALL_MEM]) THEN DISCH_THEN(MP_TAC o SPEC `(x:num,t:term)`) THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_SIMP_TAC[] THEN DISCH_TAC THEN SUBGOAL_THEN `!t y. y IN FVT t ==> (t = V y) \/ TC SUB1 (i y) (termsubst i t)` MP_TAC THENL [ALL_TAC; ASM_MESON_TAC[EQV; RTC_INC]] THEN SUBGOAL_THEN `!t y. y IN FVT t ==> RTC SUB1 (V y) t` MP_TAC THENL [ALL_TAC; REWRITE_TAC[RTC; RC_CASES] THEN SUBGOAL_THEN `!s t. TC SUB1 s t ==> TC SUB1 (termsubst i s) (termsubst i t)` (fun th -> MESON_TAC[th; termsubst]) THEN MATCH_MP_TAC TC_INDUCT THEN CONJ_TAC THENL [ALL_TAC; MESON_TAC[TC_TRANS]] THEN MAP_EVERY X_GEN_TAC [`s:term`; `u:term`] THEN DISCH_THEN(fun th -> MATCH_MP_TAC TC_INC THEN MP_TAC th) THEN REWRITE_TAC[SUB1] THEN DISCH_THEN(X_CHOOSE_THEN `f:num` (X_CHOOSE_THEN `args:term list` STRIP_ASSUME_TAC)) THEN MAP_EVERY EXISTS_TAC [`f:num`; `MAP (termsubst i) args`] THEN ASM_REWRITE_TAC[termsubst; MEM_MAP] THEN ASM_MESON_TAC[]] THEN MATCH_MP_TAC term_INDUCT THEN SIMP_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; RTC_REFL] THEN MAP_EVERY X_GEN_TAC [`f:num`; `args:term list`] THEN DISCH_TAC THEN REWRITE_TAC[IN_LIST_UNION] THEN REWRITE_TAC[EX_MAP; o_DEF] THEN X_GEN_TAC `z:num` THEN REWRITE_TAC[GSYM EX_MEM] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THEN MATCH_MP_TAC RTC_TRANS_L THEN EXISTS_TAC `s:term` THEN CONJ_TAC THENL [UNDISCH_TAC `ALL (\t. !y. y IN FVT t ==> RTC SUB1 (V y) t) args` THEN REWRITE_TAC[GSYM ALL_MEM] THEN ASM_MESON_TAC[]; REWRITE_TAC[SUB1] THEN ASM_MESON_TAC[]]);; let GOODLOOP_UNIFIABLE = prove (`!env x t. LOOPFREE(env) /\ CONFLICTFREE(env) /\ (istriv env x t = TT) ==> !i. unifies i (CONS (V x,t) (MAP (\(x,t). V x,t) env)) = unifies i (MAP (\(x,t). V x,t) env)`, REPEAT GEN_TAC THEN REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN ASM_SIMP_TAC[ISTRIV_WORKS] THEN REPEAT(COND_CASES_TAC THEN REWRITE_TAC[retval_DISTINCT]) THEN X_GEN_TAC `i:num->term` THEN REWRITE_TAC[unifies; ALL] THEN ONCE_REWRITE_TAC[TAUT `(a /\ b <=> b) <=> (b ==> a)`] THEN REWRITE_TAC[ALL_MAP; o_DEF] THEN GEN_REWRITE_TAC (LAND_CONV o LAND_CONV) [GSYM PAIRED_ETA_THM] THEN REWRITE_TAC[] THEN CONV_TAC(REDEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[termsubst] THEN DISCH_TAC THEN UNDISCH_TAC `?y. (t = V y) /\ RTC (EQV env) y x` THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN SPEC_TAC(`x:num`,`x:num`) THEN ONCE_REWRITE_TAC[SWAP_FORALL_THM] THEN ONCE_REWRITE_TAC[IMP_CONJ_ALT] THEN SUBGOAL_THEN `!x y. RTC (EQV env) x y ==> (i x :term = i y)` (fun th -> MESON_TAC[th; termsubst]) THEN MATCH_MP_TAC RTC_INDUCT THEN CONJ_TAC THENL [ALL_TAC; MESON_TAC[]] THEN MAP_EVERY X_GEN_TAC [`u:num`; `v:num`] THEN REWRITE_TAC[EQV] THEN UNDISCH_TAC `ALL (\(p1,p2). i p1 = termsubst i p2) env` THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN MATCH_MP_TAC list_INDUCT THEN REWRITE_TAC[ALL; MEM] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[PAIR_EQ] THEN REPEAT STRIP_TAC THEN ASM_SIMP_TAC[] THEN ASM_MESON_TAC[termsubst]);; let BADLOOP_UNUNIFIABLE = prove (`!env x t. LOOPFREE(env) /\ CONFLICTFREE(env) /\ (istriv env x t = Exception) ==> !i. ~(unifies i (CONS (V x,t) (MAP (\(x,t). V x,t) env)))`, REPEAT GEN_TAC THEN REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN ASM_SIMP_TAC[ISTRIV_WORKS] THEN REPEAT(COND_CASES_TAC THEN REWRITE_TAC[retval_DISTINCT]) THEN X_GEN_TAC `i:num->term` THEN REWRITE_TAC[unifies; ALL] THEN MATCH_MP_TAC(TAUT `(b ==> ~a) ==> ~(a /\ b)`) THEN REWRITE_TAC[ALL_MAP; o_DEF] THEN GEN_REWRITE_TAC (LAND_CONV o LAND_CONV) [GSYM PAIRED_ETA_THM] THEN REWRITE_TAC[] THEN CONV_TAC(REDEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[termsubst] THEN DISCH_TAC THEN UNDISCH_TAC `?y. y IN FVT t /\ RTC (OCC env) y x` THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN X_GEN_TAC `y:num` THEN FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [NOT_EXISTS_THM]) THEN DISCH_THEN(MP_TAC o SPEC `y:num`) THEN ASM_CASES_TAC `RTC (EQV env) y x` THEN ASM_REWRITE_TAC[] THENL [DISCH_TAC THEN STRIP_TAC THEN MATCH_MP_TAC TC_SUB1_IRREFL THEN ONCE_REWRITE_TAC[TC_RTC_TC_CASES] THEN EXISTS_TAC `(i:num->term) y` THEN CONJ_TAC THENL [FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP UNIFY_OCCURS) THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!t y. y IN FVT t ==> (t = V y) \/ TC SUB1 (i y) (termsubst i t)` (fun th -> ASM_MESON_TAC[th]) THEN SUBGOAL_THEN `!t y. y IN FVT t ==> RTC SUB1 (V y) t` MP_TAC THENL [ALL_TAC; REWRITE_TAC[RTC; RC_CASES] THEN SUBGOAL_THEN `!s t. TC SUB1 s t ==> TC SUB1 (termsubst i s) (termsubst i t)` (fun th -> MESON_TAC[th; termsubst]) THEN MATCH_MP_TAC TC_INDUCT THEN CONJ_TAC THENL [ALL_TAC; MESON_TAC[TC_TRANS]] THEN MAP_EVERY X_GEN_TAC [`s:term`; `u:term`] THEN DISCH_THEN(fun th -> MATCH_MP_TAC TC_INC THEN MP_TAC th) THEN REWRITE_TAC[SUB1] THEN DISCH_THEN(X_CHOOSE_THEN `f:num` (X_CHOOSE_THEN `args:term list` STRIP_ASSUME_TAC)) THEN MAP_EVERY EXISTS_TAC [`f:num`; `MAP (termsubst i) args`] THEN ASM_REWRITE_TAC[termsubst; MEM_MAP] THEN ASM_MESON_TAC[]] THEN MATCH_MP_TAC term_INDUCT THEN SIMP_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; RTC_REFL] THEN MAP_EVERY X_GEN_TAC [`f:num`; `args:term list`] THEN DISCH_TAC THEN REWRITE_TAC[IN_LIST_UNION] THEN REWRITE_TAC[EX_MAP; o_DEF] THEN X_GEN_TAC `z:num` THEN REWRITE_TAC[GSYM EX_MEM] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THEN MATCH_MP_TAC RTC_TRANS_L THEN EXISTS_TAC `s:term` THEN CONJ_TAC THENL [UNDISCH_TAC `ALL (\t. !y. y IN FVT t ==> RTC SUB1 (V y) t) args` THEN REWRITE_TAC[GSYM ALL_MEM] THEN ASM_MESON_TAC[]; REWRITE_TAC[SUB1] THEN ASM_MESON_TAC[]]; ALL_TAC] THEN STRIP_TAC THEN MATCH_MP_TAC TC_SUB1_IRREFL THEN ONCE_REWRITE_TAC[TC_TC_RTC_CASES] THEN EXISTS_TAC `(i:num->term) y` THEN CONJ_TAC THENL [FIRST_ASSUM(MP_TAC o MATCH_MP UNIFY_OCCURS_PROPER) THEN DISCH_THEN(MP_TAC o SPECL [`y:num`; `x:num`]) THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!t y. y IN FVT t ==> RTC SUB1 (V y) t` MP_TAC THENL [ALL_TAC; SUBGOAL_THEN `!s t. RTC SUB1 s t ==> RTC SUB1 (termsubst i s) (termsubst i t)` (fun th -> ASM_MESON_TAC[th; termsubst]) THEN MATCH_MP_TAC RTC_INDUCT THEN REWRITE_TAC[RTC_REFL] THEN CONJ_TAC THENL [ALL_TAC; MESON_TAC[RTC_TRANS]] THEN MAP_EVERY X_GEN_TAC [`s:term`; `u:term`] THEN DISCH_THEN(fun th -> MATCH_MP_TAC RTC_INC THEN MP_TAC th) THEN REWRITE_TAC[SUB1] THEN DISCH_THEN(X_CHOOSE_THEN `f:num` (X_CHOOSE_THEN `args:term list` STRIP_ASSUME_TAC)) THEN MAP_EVERY EXISTS_TAC [`f:num`; `MAP (termsubst i) args`] THEN ASM_REWRITE_TAC[termsubst; MEM_MAP] THEN ASM_MESON_TAC[]] THEN MATCH_MP_TAC term_INDUCT THEN SIMP_TAC[FVT; IN_INSERT; NOT_IN_EMPTY; RTC_REFL] THEN MAP_EVERY X_GEN_TAC [`f:num`; `args:term list`] THEN DISCH_TAC THEN REWRITE_TAC[IN_LIST_UNION] THEN REWRITE_TAC[EX_MAP; o_DEF] THEN X_GEN_TAC `z:num` THEN REWRITE_TAC[GSYM EX_MEM] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` STRIP_ASSUME_TAC) THEN MATCH_MP_TAC RTC_TRANS_L THEN EXISTS_TAC `s:term` THEN CONJ_TAC THENL [UNDISCH_TAC `ALL (\t. !y. y IN FVT t ==> RTC SUB1 (V y) t) args` THEN REWRITE_TAC[GSYM ALL_MEM] THEN ASM_MESON_TAC[]; REWRITE_TAC[SUB1] THEN ASM_MESON_TAC[]]);; let UNIFY_WORKS_RAW = prove (`!pr. LOOPFREE(FST pr) /\ CONFLICTFREE(FST pr) ==> ((unify pr = NONE) ==> !i. ~(unifies i (APPEND (MAP (\(x,t). V x,t) (FST pr)) (SND pr)))) /\ !ans. (unify pr = SOME ans) ==> LOOPFREE(ans) /\ CONFLICTFREE(ans) /\ !i. unifies i (APPEND (MAP (\(x,t). V x,t) (FST pr)) (SND pr)) = unifies i (MAP (\(x,t). V x,t) ans)`, MATCH_MP_TAC(REWRITE_RULE[WF_IND] WF_CALLORDER) THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`env:(num#term)list`; `eqs:(term#term)list`] THEN DISCH_THEN(MP_TAC o GENL [`env':(num#term)list`; `eqs':(term#term)list`] o SPEC `env':(num#term)list,eqs':(term#term)list`) THEN REWRITE_TAC[FST; SND] THEN DISCH_TAC THEN DISCH_THEN(REPEAT_TCL CONJUNCTS_THEN ASSUME_TAC) THEN ONCE_REWRITE_TAC[unify_raw] THEN ASM_REWRITE_TAC[FST; SND] THEN MP_TAC(ISPEC `eqs:(term#term)list` list_CASES) THEN DISCH_THEN(DISJ_CASES_THEN2 SUBST_ALL_TAC MP_TAC) THENL [ASM_REWRITE_TAC[APPEND_NIL; OPTION_INJ; OPTION_DISTINCT] THEN GEN_TAC THEN DISCH_THEN SUBST_ALL_TAC THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN GEN_REWRITE_TAC LAND_CONV [EXISTS_PAIR_THM] THEN DISCH_THEN(X_CHOOSE_THEN `s:term` (X_CHOOSE_THEN `t:term` (X_CHOOSE_THEN `oth:(term#term)list` SUBST_ALL_TAC))) THEN REWRITE_TAC[NOT_CONS_NIL; HD; TL] THEN MP_TAC(SPEC `s:term` term_CASES) THEN DISCH_THEN(DISJ_CASES_THEN2 (X_CHOOSE_THEN `x:num` SUBST_ALL_TAC) (X_CHOOSE_THEN `f:num` (X_CHOOSE_THEN `fargs:term list` SUBST_ALL_TAC))) THENL [ALL_TAC; MP_TAC(ISPEC `t:term` term_CASES) THEN DISCH_THEN(DISJ_CASES_THEN2 (X_CHOOSE_THEN `x:num` SUBST_ALL_TAC) (X_CHOOSE_THEN `g:num` (X_CHOOSE_THEN `gargs:term list` SUBST_ALL_TAC)))] THEN REWRITE_TAC[tpcases] THENL [ASM_CASES_TAC `MEM x (MAP FST (env:(num#term)list))` THEN ASM_REWRITE_TAC[] THENL [FIRST_X_ASSUM(MP_TAC o SPECL [`env:(num#term)list`; `CONS (ASSOC (x:num) env,t) (oth:(term#term)list)`]) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_REWRITE_TAC[CALLORDER; CRIGHT] THEN DISJ2_TAC THEN DISJ2_TAC THEN DISJ1_TAC THEN ASM_MESON_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!i. unifies i (APPEND (MAP (\(x,t). V x,t) env) (CONS (ASSOC x env,t) oth)) = unifies i (APPEND (MAP (\(x,t). V x,t) env) (CONS (V x,t) oth))` (fun th -> REWRITE_TAC[th]) THEN X_GEN_TAC `i:num->term` THEN REWRITE_TAC[unifies; ALL; ALL_APPEND] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[ALL_MAP] THEN MATCH_MP_TAC(TAUT `(a ==> (b <=> b')) ==> (a /\ b /\ c <=> a /\ b' /\ c)`) THEN UNDISCH_TAC `MEM x (MAP FST (env:(num#term)list))` THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN MATCH_MP_TAC list_INDUCT THEN REWRITE_TAC[MEM; ALL; MAP] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`y:num`; `s:term`; `eev:(num#term)list`] THEN REWRITE_TAC[FST; SND; o_DEF] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN ASM_CASES_TAC `x = y:num` THEN ASM_REWRITE_TAC[ASSOC] THEN MESON_TAC[]; ALL_TAC] THEN ASM_CASES_TAC `istriv env x t = Exception` THEN ASM_REWRITE_TAC[] THENL [REWRITE_TAC[OPTION_DISTINCT] THEN MP_TAC(SPECL [`env:(num#term)list`; `x:num`; `t:term`] BADLOOP_UNUNIFIABLE) THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[unifies; ALL_APPEND; ALL] THEN MATCH_MP_TAC MONO_FORALL THEN GEN_TAC THEN CONV_TAC TAUT; ALL_TAC] THEN ASM_CASES_TAC `istriv env x t = TT` THEN ASM_REWRITE_TAC[] THENL [FIRST_X_ASSUM(MP_TAC o SPECL [`env:(num#term)list`; `oth:(term#term)list`]) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_REWRITE_TAC[CALLORDER; CRIGHT] THEN DISJ2_TAC THEN DISJ2_TAC THEN DISJ1_TAC THEN ASM_MESON_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!i. unifies i (APPEND (MAP (\(x,t). V x,t) env) (CONS (V x,t) oth)) = unifies i (APPEND (MAP (\(x,t). V x,t) env) oth)` (fun th -> REWRITE_TAC[th]) THEN MP_TAC(SPECL [`env:(num#term)list`; `x:num`; `t:term`] GOODLOOP_UNIFIABLE) THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[unifies; ALL_APPEND; ALL] THEN MATCH_MP_TAC MONO_FORALL THEN GEN_TAC THEN CONV_TAC TAUT; ALL_TAC] THEN FIRST_X_ASSUM(MP_TAC o SPECL [`CONS (x:num,t:term) env`; `oth:(term#term)list`]) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_REWRITE_TAC[CALLORDER] THEN DISJ1_TAC THEN REWRITE_TAC[MEASURE; MLEFT] THEN REWRITE_TAC[MAP; FST; SND; LENGTH] THEN MATCH_MP_TAC(ARITH_RULE `(a' = a) /\ (b' = b + 1) /\ b' <= a' ==> a' - b' < a - b`) THEN SUBGOAL_THEN `FVT(Fn 0 (CONS ((V o FST) (x,t:term)) (MAP (V o FST) env))) = x INSERT FVT(Fn 0 (MAP (V o FST) (env:(num#term)list)))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST] THEN SET_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `FVT(Fn 0 (CONS (V x) (MAP FST (oth:(term#term)list)))) = x INSERT FVT(Fn 0 (MAP FST oth))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST] THEN SET_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `FVT(Fn 0 (CONS t (MAP SND env))) = FVT(t) UNION FVT(Fn 0 (MAP SND (env:(num#term)list)))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST]; ALL_TAC] THEN SUBGOAL_THEN `FVT(Fn 0 (CONS t (MAP SND oth))) = FVT(t) UNION FVT(Fn 0 (MAP SND (oth:(term#term)list)))` SUBST1_TAC THENL [REWRITE_TAC[FVT; MAP; LIST_UNION; o_THM; FST]; ALL_TAC] THEN REPEAT CONJ_TAC THENL [AP_TERM_TAC THEN REWRITE_TAC[EXTENSION; IN_UNION; DISJ_ACI; IN_INSERT]; SIMP_TAC[CARD_CLAUSES; FVT_FINITE; ADD1] THEN COND_CASES_TAC THEN REWRITE_TAC[] THEN UNDISCH_TAC `x IN FVT (Fn 0 (MAP (V o FST) (env:(num#term)list)))` THEN UNDISCH_TAC `~MEM x (MAP FST (env:(num#term)list))` THEN MATCH_MP_TAC(TAUT `(b ==> a) ==> ~a ==> b ==> c`) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN REWRITE_TAC[FVT] THEN LIST_INDUCT_TAC THEN REWRITE_TAC[LIST_UNION; MEM; MAP; NOT_IN_EMPTY] THEN REWRITE_TAC[o_THM; FVT; IN_UNION; IN_INSERT; NOT_IN_EMPTY] THEN STRIP_TAC THEN ASM_SIMP_TAC[]; MATCH_MP_TAC CARD_SUBSET THEN REWRITE_TAC[FINITE_UNION; FVT_FINITE; FINITE_INSERT] THEN REWRITE_TAC[SUBSET; IN_UNION; IN_INSERT] THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[]]; ALL_TAC] THEN ANTS_TAC THENL [MP_TAC(SPECL [`env:(num#term)list`; `x:num`; `t:term`] ISTRIV_WORKS) THEN ASM_REWRITE_TAC[] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN DISCH_TAC THEN ASM_SIMP_TAC[LOOPFREE_PRESERVE_EQ] THEN UNDISCH_TAC `CONFLICTFREE env` THEN REWRITE_TAC[CONFLICTFREE; LENGTH; FILTER] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN MATCH_MP_TAC MONO_FORALL THEN X_GEN_TAC `y:num` THEN ASM_CASES_TAC `x:num = y` THEN ASM_REWRITE_TAC[LENGTH] THEN MATCH_MP_TAC(ARITH_RULE `(x = 0) ==> y <= z ==> SUC x <= 1`) THEN UNDISCH_THEN `x:num = y` (SUBST_ALL_TAC o SYM) THEN REWRITE_TAC[LENGTH_EQ_NIL] THEN UNDISCH_TAC `~(MEM x (MAP FST (env:(num#term)list)))` THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN ASM_REWRITE_TAC[MEM; MAP; FILTER; NOT_CONS_NIL] THEN SUBST1_TAC(SYM(ISPEC `h:num#term` PAIR)) THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[FST; SND] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!i. unifies i (APPEND (MAP (\(x,t). V x,t) (CONS (x,t) env)) oth) = unifies i (APPEND (MAP (\(x,t). V x,t) env) (CONS (V x,t) oth))` (fun th -> REWRITE_TAC[th]) THEN REWRITE_TAC[unifies; ALL_APPEND; ALL; MAP] THEN GEN_TAC THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN CONV_TAC TAUT; FIRST_X_ASSUM(MP_TAC o SPECL [`env:(num#term)list`; `CONS (V x,Fn f fargs) oth`]) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_REWRITE_TAC[CALLORDER; CRIGHT] THEN REPEAT DISJ2_TAC THEN ASM_MESON_TAC[]; ALL_TAC] THEN REWRITE_TAC[unifies; ALL_APPEND; ALL] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[EQ_SYM_EQ]; COND_CASES_TAC THEN ASM_REWRITE_TAC[OPTION_DISTINCT] THENL [ALL_TAC; REWRITE_TAC[unifies; ALL; ALL_APPEND] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[termsubst; term_INJ] THEN ASM_MESON_TAC[LENGTH_MAP]] THEN FIRST_X_ASSUM(MP_TAC o SPECL [`env:(num#term)list`; `APPEND (ZIP fargs gargs) (oth:(term#term)list)`]) THEN ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_REWRITE_TAC[CALLORDER; CRIGHT] THEN DISJ2_TAC THEN DISJ1_TAC THEN ASM_MESON_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!i. unifies i (APPEND (MAP (\(x,t). V x,t) env) (APPEND (ZIP fargs gargs) oth)) = unifies i (APPEND (MAP (\(x,t). V x,t) env) (CONS (Fn g fargs,Fn g gargs) oth))` (fun th -> REWRITE_TAC[th]) THEN X_GEN_TAC `i:num->term` THEN REWRITE_TAC[unifies; ALL; ALL_APPEND] THEN AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[termsubst; term_INJ] THEN FIRST_ASSUM(MP_TAC o CONJUNCT2) THEN SPEC_TAC(`gargs:term list`,`gargs:term list`) THEN SPEC_TAC(`fargs:term list`,`fargs:term list`) THEN LIST_INDUCT_TAC THEN LIST_INDUCT_TAC THEN ASM_REWRITE_TAC[LENGTH; ALL; MAP; NOT_SUC; ZIP] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_SIMP_TAC[SUC_INJ; CONS_11]]);; (* ------------------------------------------------------------------------- *) (* Constructively show that unifiers exist via "solve". *) (* ------------------------------------------------------------------------- *) let THE = new_recursive_definition option_RECURSION `THE(SOME x) = x`;; let unifier = new_definition `unifier env = let sol = SOLVE [] env in ITLIST valmod sol V`;; let ITLIST_VALMOD_LEMMA = prove (`!env x. CONFLICTFREE(env) ==> !t. (ITLIST valmod env V x = t) <=> MEM (x,t) env \/ (t = V x) /\ ~(MEM x (MAP FST env))`, REPEAT GEN_TAC THEN REWRITE_TAC[CONFLICTFREE] THEN DISCH_THEN(MP_TAC o SPEC `x:num`) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN LIST_INDUCT_TAC THEN REWRITE_TAC[FILTER; LENGTH; ITLIST; MAP; MEM] THENL [MESON_TAC[]; ALL_TAC] THEN SPEC_TAC(`h:num#term`,`h:num#term`) THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`z:num`; `s:term`] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN ASM_CASES_TAC `z = x:num` THEN ASM_REWRITE_TAC[PAIR_EQ; LENGTH; valmod] THEN REWRITE_TAC[ARITH_RULE `SUC n <= 1 <=> (n = 0)`; LENGTH_EQ_NIL] THEN REWRITE_TAC[RIGHT_IMP_FORALL_THM] THEN GEN_TAC THEN MATCH_MP_TAC(TAUT `(a ==> ~c) /\ (b <=> b') ==> a ==> (b <=> b' \/ c)`) THEN CONJ_TAC THENL [ALL_TAC; REWRITE_TAC[EQ_SYM_EQ]] THEN DISCH_THEN(MP_TAC o AP_TERM `MEM (x:num,t':term)`) THEN REWRITE_TAC[MEM; MEM_FILTER] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[]);; let UNIFIER_WORKS = prove (`!env. LOOPFREE(env) /\ CONFLICTFREE(env) ==> unifies (unifier env) (MAP (\(x,t). V x,t) env)`, REPEAT STRIP_TAC THEN REWRITE_TAC[unifier] THEN LET_TAC THEN MP_TAC(SPEC `env:(num#term)list` SOLVE_WORKS) THEN ASM_REWRITE_TAC[] THEN ABBREV_TAC `i = ITLIST valmod sol V` THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN DISCH_THEN(CONJUNCTS_THEN2 (ASSUME_TAC o SPEC `i:num->term`) MP_TAC) THEN DISCH_TAC THEN REWRITE_TAC[unifies; ALL_MAP; o_DEF] THEN GEN_REWRITE_TAC LAND_CONV [GSYM PAIRED_ETA_THM] THEN REWRITE_TAC[] THEN CONV_TAC(REDEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[termsubst; GSYM ALL_MEM] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN CONV_TAC(REDEPTH_CONV GEN_BETA_CONV) THEN ASM_REWRITE_TAC[] THEN MAP_EVERY X_GEN_TAC [`x:num`; `t:term`] THEN DISCH_TAC THEN EXPAND_TAC "i" THEN ASM_SIMP_TAC[ITLIST_VALMOD_LEMMA] THEN SUBGOAL_THEN `termsubst i t = t` (fun th -> ASM_REWRITE_TAC[th]) THEN GEN_REWRITE_TAC RAND_CONV [GSYM TERMSUBST_TRIV] THEN MATCH_MP_TAC TERMSUBST_VALUATION THEN X_GEN_TAC `z:num` THEN DISCH_TAC THEN EXPAND_TAC "i" THEN ASM_SIMP_TAC[ITLIST_VALMOD_LEMMA] THEN DISJ2_TAC THEN REWRITE_TAC[MEM_MAP] THEN ONCE_REWRITE_TAC[EXISTS_PAIR_THM] THEN ASM_MESON_TAC[FST]);; let UNIFIER_MGU = prove (`!env. LOOPFREE(env) /\ CONFLICTFREE(env) ==> !i. unifies i (MAP (\(x,t). V x,t) env) ==> (termsubst i = termsubst i o termsubst (ITLIST valmod env V))`, REPEAT STRIP_TAC THEN REWRITE_TAC[FUN_EQ_THM; o_THM] THEN X_GEN_TAC `s:term` THEN REWRITE_TAC[TERMSUBST_TERMSUBST] THEN MATCH_MP_TAC TERMSUBST_VALUATION THEN X_GEN_TAC `y:num` THEN DISCH_THEN(K ALL_TAC) THEN REWRITE_TAC[o_THM] THEN UNDISCH_TAC `unifies i (MAP (\(x,t). V x,t) env)` THEN REWRITE_TAC[unifies; ALL_MAP; o_DEF] THEN GEN_REWRITE_TAC (funpow 2 LAND_CONV) [GSYM PAIRED_ETA_THM] THEN REWRITE_TAC[] THEN CONV_TAC(REDEPTH_CONV GEN_BETA_CONV) THEN SPEC_TAC(`env:(num#term)list`,`env:(num#term)list`) THEN REWRITE_TAC[termsubst] THEN LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST; TERMSUBST_TRIV; termsubst] THEN SPEC_TAC(`h:num#term`,`h:num#term`) THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`z:num`; `s:term`] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[unifies; ALL; MAP] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[valmod] THEN COND_CASES_TAC THEN ASM_SIMP_TAC[] THEN UNDISCH_THEN `y = z:num` (SUBST_ALL_TAC o SYM) THEN DISCH_THEN(CONJUNCTS_THEN2 (SUBST_ALL_TAC o SYM) ASSUME_TAC) THEN ASM_SIMP_TAC[]);; (* ------------------------------------------------------------------------- *) (* Hence we can strengthen the main theorem. *) (* ------------------------------------------------------------------------- *) let UNIFY_WORKS = prove (`!env eqs. LOOPFREE(env) /\ CONFLICTFREE(env) ==> ((unify (env,eqs) = NONE) ==> !i. ~(unifies i (APPEND (MAP (\(x,t). V x,t) env) eqs))) /\ ((unify (env,eqs) = SOME ans) ==> LOOPFREE(ans) /\ CONFLICTFREE(ans) /\ unifies (unifier ans) (APPEND (MAP (\(x,t). V x,t) env) eqs) /\ !i. unifies i (APPEND (MAP (\(x,t). V x,t) env) eqs) ==> (termsubst i = termsubst i o termsubst (unifier ans)))`, REPEAT GEN_TAC THEN STRIP_TAC THEN MP_TAC(SPEC `env:(num#term)list,eqs:(term#term)list` UNIFY_WORKS_RAW) THEN ASM_REWRITE_TAC[FST; SND] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC `ans:(num#term)list`) THEN ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN REWRITE_TAC[unifier] THEN LET_TAC THEN CONV_TAC(TOP_DEPTH_CONV let_CONV) THEN MP_TAC(SPEC `ans:(num#term)list` SOLVE_WORKS) THEN ASM_REWRITE_TAC[] THEN STRIP_TAC THEN MP_TAC(SPEC `ans:(num#term)list` UNIFIER_WORKS) THEN MP_TAC(SPEC `sol:(num#term)list` UNIFIER_MGU) THEN SUBGOAL_THEN `LOOPFREE(sol)` ASSUME_TAC THENL [REWRITE_TAC[LOOPFREE] THEN X_GEN_TAC `z:num` THEN ONCE_REWRITE_TAC[TC_RTC_CASES_R] THEN ONCE_REWRITE_TAC[RTC_CASES_R] THEN REWRITE_TAC[OCC] THEN ASM_MESON_TAC[]; ALL_TAC] THEN ASM_REWRITE_TAC[] THEN SUBGOAL_THEN `!i. unifies i (MAP (\(x,t). V x,t) ans) = unifies i (MAP (\(x,t). V x,t) sol)` (fun th -> SIMP_TAC[th]) THENL [GEN_TAC THEN REWRITE_TAC[unifies; ALL_MAP; o_DEF] THEN REWRITE_TAC[GSYM ALL_MEM] THEN ONCE_REWRITE_TAC[FORALL_PAIR_THM] THEN CONV_TAC(TOP_DEPTH_CONV GEN_BETA_CONV) THEN ASM_REWRITE_TAC[termsubst]; ALL_TAC] THEN ASM_REWRITE_TAC[unifier] THEN CONV_TAC(TOP_DEPTH_CONV let_CONV) THEN STRIP_TAC THEN ASM_REWRITE_TAC[]);; (* ------------------------------------------------------------------------- *) (* Special case where there is no initial environment. *) (* ------------------------------------------------------------------------- *) let UNIFY_WORKS_SIMPLE = prove (`!eqs. ((unify ([],eqs) = NONE) ==> !i. ~(unifies i eqs)) /\ ((unify ([],eqs) = SOME ans) ==> LOOPFREE(ans) /\ CONFLICTFREE(ans) /\ unifies (unifier ans) eqs /\ !i. unifies i eqs ==> (termsubst i = termsubst i o termsubst (unifier ans)))`, GEN_TAC THEN MP_TAC(SPEC `[]:(num#term)list` UNIFY_WORKS) THEN REWRITE_TAC[MAP; APPEND] THEN DISCH_THEN MATCH_MP_TAC THEN REWRITE_TAC[LOOPFREE; CONFLICTFREE; LENGTH; FILTER; ARITH] THEN ONCE_REWRITE_TAC[TC_CASES_L] THEN REWRITE_TAC[OCC; MEM]);; (* ------------------------------------------------------------------------- *) (* Slight variant: MGU of a set (not list of pairs) of formulas (not terms) *) (* ------------------------------------------------------------------------- *) let Unifies_DEF = new_definition `Unifies i s <=> !p q. p IN s /\ q IN s ==> (formsubst i p = formsubst i q)`;; let UNIFIES = prove (`Unifies i s <=> ?q. !p. p IN s ==> (formsubst i p = q)`, MESON_TAC[Unifies_DEF]);; let UNIFIER_FORMPAIR_TERMLIST = prove (`!p q. qfree(p) /\ qfree(q) ==> ?l. !i. (formsubst i p = formsubst i q) <=> unifies i l`, let lemma = prove (`?l. !i. ~(unifies i l)`, EXISTS_TAC `[Fn 0 [], Fn 1 []]` THEN REWRITE_TAC[ALL; unifies] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN REWRITE_TAC[termsubst; term_INJ; ARITH]) in REWRITE_TAC[IMP_CONJ; RIGHT_FORALL_IMP_THM] THEN MATCH_MP_TAC form_INDUCTION THEN REWRITE_TAC[qfree] THEN REPEAT CONJ_TAC THENL [ALL_TAC; MAP_EVERY X_GEN_TAC [`f:num`; `fargs:term list`]; MAP_EVERY X_GEN_TAC [`p:form`; `q:form`] THEN DISCH_THEN(fun th -> STRIP_TAC THEN MP_TAC th) THEN ASM_REWRITE_TAC[] THEN STRIP_TAC] THEN MATCH_MP_TAC form_INDUCTION THEN REWRITE_TAC[qfree] THEN REWRITE_TAC[formsubst; form_DISTINCT; lemma] THENL [EXISTS_TAC `[]:(term#term)list` THEN REWRITE_TAC[unifies; ALL]; MAP_EVERY X_GEN_TAC [`g:num`; `gargs:term list`] THEN REWRITE_TAC[form_INJ] THEN ASM_CASES_TAC `f:num = g` THEN ASM_REWRITE_TAC[lemma] THEN ASM_CASES_TAC `LENGTH(fargs:term list) = LENGTH(gargs:term list)` THENL [ALL_TAC; ASM_MESON_TAC[LENGTH_MAP; lemma]] THEN EXISTS_TAC `ZIP (fargs:term list) (gargs:term list)` THEN REWRITE_TAC[unifies] THEN X_GEN_TAC `i:num->term` THEN UNDISCH_TAC `LENGTH(fargs:term list) = LENGTH(gargs:term list)` THEN SPEC_TAC(`gargs:term list`,`gargs:term list`) THEN SPEC_TAC(`fargs:term list`,`fargs:term list`) THEN LIST_INDUCT_TAC THEN LIST_INDUCT_TAC THEN REWRITE_TAC[LENGTH; NOT_SUC; MAP; ZIP; ALL; SUC_INJ] THEN CONV_TAC(ONCE_DEPTH_CONV GEN_BETA_CONV) THEN ASM_SIMP_TAC[CONS_11]; MAP_EVERY X_GEN_TAC [`r:form`; `s:form`] THEN DISCH_THEN(fun th -> STRIP_TAC THEN MP_TAC th) THEN ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_SIMP_TAC[form_INJ] THEN UNDISCH_TAC `!q. qfree q ==> (?l. !i. (formsubst i p = formsubst i q) <=> unifies i l)` THEN DISCH_THEN(MP_TAC o SPEC `r:form`) THEN ASM_REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_THEN `l1:(term#term)list` (fun th -> REWRITE_TAC[th])) THEN FIRST_X_ASSUM(MP_TAC o SPEC `s:form`) THEN ASM_REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_THEN `l2:(term#term)list` (fun th -> REWRITE_TAC[th])) THEN EXISTS_TAC `APPEND (l1:(term#term)list) l2` THEN REWRITE_TAC[unifies; ALL_APPEND]]);; let UNIFIER_SUBTERMS = prove (`!A. FINITE A /\ (!p. p IN A ==> qfree p) ==> ?l. !i. Unifies i A = unifies i l`, REPEAT STRIP_TAC THEN ABBREV_TAC `B = {(x:form,y) | x IN A /\ y IN A}` THEN SUBGOAL_THEN `!i. Unifies i A = !p q. (p,q) IN B ==> (formsubst i p = formsubst i q)` (fun th -> REWRITE_TAC[th]) THENL [EXPAND_TAC "B" THEN REWRITE_TAC[IN_ELIM_THM; Unifies_DEF; PAIR_EQ] THEN MESON_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `!p q. (p,q) IN B ==> qfree p /\ qfree q` MP_TAC THENL [EXPAND_TAC "B" THEN REWRITE_TAC[IN_ELIM_THM; PAIR_EQ] THEN ASM_MESON_TAC[]; ALL_TAC] THEN SUBGOAL_THEN `FINITE(B:(form#form)->bool)` MP_TAC THENL [EXPAND_TAC "B" THEN MATCH_MP_TAC FINITE_PRODUCT THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN SPEC_TAC(`B:(form#form)->bool`,`B:(form#form)->bool`) THEN POP_ASSUM_LIST(K ALL_TAC) THEN MATCH_MP_TAC FINITE_INDUCT THEN CONJ_TAC THENL [STRIP_TAC THEN EXISTS_TAC `[]:(term#term)list` THEN REWRITE_TAC[NOT_IN_EMPTY; ALL; unifies]; ALL_TAC] THEN GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN MAP_EVERY X_GEN_TAC [`p:form`; `q:form`; `B:(form#form)->bool`] THEN REWRITE_TAC[IN_INSERT; PAIR_EQ] THEN REWRITE_TAC[TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN SIMP_TAC[FORALL_AND_THM; LEFT_FORALL_IMP_THM; EXISTS_REFL; LEFT_EXISTS_AND_THM; RIGHT_EXISTS_AND_THM] THEN DISCH_THEN(fun th -> STRIP_TAC THEN MP_TAC th) THEN ASM_REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_TAC `l:(term#term)list`) THEN MP_TAC(SPECL [`p:form`; `q:form`] UNIFIER_FORMPAIR_TERMLIST) THEN ASM_REWRITE_TAC[] THEN DISCH_THEN(X_CHOOSE_TAC `m:(term#term)list`) THEN EXISTS_TAC `APPEND (l:(term#term)list) m` THEN REWRITE_TAC[unifies; ALL_APPEND] THEN ASM_REWRITE_TAC[GSYM unifies] THEN REWRITE_TAC[CONJ_ACI]);; let MGU_EXISTS = prove (`FINITE s /\ (!p. p IN s ==> qfree p) ==> ((?i. Unifies i s) <=> (?i. Unifies i s /\ !j. Unifies j s ==> !p. qfree p ==> (formsubst j p = formsubst j (formsubst i p))))`, DISCH_THEN(X_CHOOSE_THEN `l:(term#term)list` (fun th -> REWRITE_TAC[th]) o MATCH_MP UNIFIER_SUBTERMS) THEN EQ_TAC THEN DISCH_THEN(X_CHOOSE_THEN `i:num->term` STRIP_ASSUME_TAC) THEN ASM_REWRITE_TAC[] THENL [ALL_TAC; ASM_MESON_TAC[]] THEN EXISTS_TAC `unifier(THE(unify([],l)))` THEN MP_TAC(GEN `ans:(num#term)list` (SPEC `l:(term#term)list` UNIFY_WORKS_SIMPLE)) THEN SPEC_TAC(`unify ([],l)`,`u:((num#term)list)option`) THEN MATCH_MP_TAC option_INDUCT THEN REWRITE_TAC[prove_constructors_distinct option_RECURSION; prove_constructors_injective option_RECURSION] THEN CONJ_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN X_GEN_TAC `u:(num#term)list` THEN DISCH_THEN(MP_TAC o SPEC `u:(num#term)list`) THEN REWRITE_TAC[THE] THEN REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_FORALL THEN X_GEN_TAC `j:num->term` THEN MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[] THEN REWRITE_TAC[FUN_EQ_THM; o_THM] THEN DISCH_THEN(ASSUME_TAC o GSYM) THEN MATCH_MP_TAC form_INDUCTION THEN REWRITE_TAC[formsubst; qfree] THEN SIMP_TAC[] THEN REWRITE_TAC[GSYM MAP_o] THEN REPEAT GEN_TAC THEN AP_TERM_TAC THEN MATCH_MP_TAC MAP_EQ THEN ASM_REWRITE_TAC[o_THM; ALL_T]);; let mgu = new_definition `mgu s = @i. Unifies i s /\ !j. Unifies j s ==> !p. qfree p ==> (formsubst j p = formsubst j (formsubst i p))`;; let MGU = prove (`!s. FINITE s /\ (!p. p IN s ==> qfree p) /\ (?i. Unifies i s) ==> Unifies (mgu s) s /\ !i. Unifies i s ==> !p. qfree p ==> (formsubst i p = formsubst i (formsubst (mgu s) p))`, REPEAT GEN_TAC THEN STRIP_TAC THEN REWRITE_TAC[mgu] THEN CONV_TAC SELECT_CONV THEN ASM_SIMP_TAC[GSYM MGU_EXISTS] THEN ASM_MESON_TAC[]);; (* ------------------------------------------------------------------------- *) (* General notion of an MGU. *) (* ------------------------------------------------------------------------- *) let FORMSUBST_TERMSUBST_LEMMA = prove (`(!p. qfree(p) ==> (formsubst i p = formsubst j (formsubst k p))) <=> (termsubst i = termsubst j o termsubst k)`, REWRITE_TAC[FUN_EQ_THM; o_THM] THEN EQ_TAC THEN DISCH_TAC THENL [X_GEN_TAC `t:term` THEN FIRST_X_ASSUM(MP_TAC o SPEC `Atom p [t]`) THEN REWRITE_TAC[qfree; formsubst; MAP; form_INJ; CONS_11]; MATCH_MP_TAC form_INDUCTION THEN REWRITE_TAC[qfree] THEN SIMP_TAC[formsubst] THEN REWRITE_TAC[form_INJ; GSYM MAP_o] THEN GEN_TAC THEN MATCH_MP_TAC MAP_EQ THEN ASM_REWRITE_TAC[o_THM; ALL_T]]);; let ismgu = new_definition `ismgu s i <=> Unifies i s /\ !j. Unifies j s ==> ?k. (termsubst j = termsubst k o termsubst i)`;; let ISMGU = prove (`ismgu s i <=> Unifies i s /\ !j. Unifies j s ==> ?k. !p. qfree(p) ==> (formsubst j p = formsubst k (formsubst i p))`, REWRITE_TAC[ismgu; FORMSUBST_TERMSUBST_LEMMA]);; let ISMGU_MGU = prove (`!s. FINITE(s) /\ (!p. p IN s ==> qfree p) /\ (?i. Unifies i s) ==> ismgu s (mgu s)`, GEN_TAC THEN DISCH_THEN(STRIP_ASSUME_TAC o MATCH_MP MGU) THEN ASM_REWRITE_TAC[ISMGU] THEN ASM_MESON_TAC[]);; (* ------------------------------------------------------------------------- *) (* Renaming. Note that we assume a bijection; the usual definition demands *) (* only the existence of a left inverse, but then you need to be explicit *) (* about the fact that the support is finite, hence the right inverse exists *) (* anyway. *) (* ------------------------------------------------------------------------- *) let renaming = new_definition `renaming i <=> ?j. (termsubst j o termsubst i = I) /\ (termsubst i o termsubst j = I)`;; let RENAMING = prove (`renaming i ==> (!x. ?y. i(x) = V y) /\ (!x x'. (i(x') = i(x)) ==> (x' = x))`, REWRITE_TAC[renaming; FUN_EQ_THM; o_THM; I_DEF] THEN DISCH_THEN(X_CHOOSE_THEN `j:num->term` (ASSUME_TAC o CONJUNCT1)) THEN CONJ_TAC THENL [X_GEN_TAC `x:num` THEN FIRST_X_ASSUM(MP_TAC o SPEC `V x`) THEN REWRITE_TAC[termsubst] THEN MESON_TAC[term_CASES; termsubst; term_DISTINCT]; MAP_EVERY X_GEN_TAC [`x1:num`; `x2:num`] THEN FIRST_X_ASSUM(fun th -> MP_TAC(SPEC `V x1` th) THEN MP_TAC(SPEC `V x2` th)) THEN REWRITE_TAC[termsubst] THEN MESON_TAC[term_INJ]]);;