Datasets:

hoskinson-center
/

proof-pile

	(* ========================================================================= *)
	(* Applying forward subsumption and back replacement in given clause alg. *)
	(* ========================================================================= *)

	let FIRSTN = new_recursive_definition num_RECURSION
	`(FIRSTN 0 l = []) /\
	(FIRSTN (SUC n) l = if l = [] then [] else CONS (HD l) (FIRSTN n (TL l)))`;;

	let FIRSTN_TRIVIAL = prove
	(`!n l. LENGTH l <= n ==> (FIRSTN n l = l)`,
	INDUCT_TAC THEN SIMP_TAC[LE; FIRSTN; LENGTH_EQ_NIL] THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[NOT_CONS_NIL] THEN
	REWRITE_TAC[HD; TL; LENGTH; CONS_11; SUC_INJ] THEN
	ASM_MESON_TAC[ARITH_RULE `SUC x <= y ==> x <= y`; LE_REFL]);;

	let FIRSTN_EMPTY = prove
	(`!n. FIRSTN n [] = []`,
	MESON_TAC[FIRSTN_TRIVIAL; LENGTH; LE_0]);;

	let FIRSTN_SUBLIST = prove
	(`!x n l. MEM x (FIRSTN n l) ==> MEM x l`,
	GEN_TAC THEN INDUCT_TAC THEN REWRITE_TAC[FIRSTN; MEM] THEN
	LIST_INDUCT_TAC THEN ASM_REWRITE_TAC[NOT_CONS_NIL; HD; TL; MEM] THEN
	ASM_MESON_TAC[]);;

	let FIRSTN_SUC = prove
	(`!x n l. MEM x (FIRSTN (SUC n) l)
	==> MEM x (APPEND (FIRSTN n l) [EL n l])`,
	GEN_TAC THEN INDUCT_TAC THENL
	[REWRITE_TAC[FIRSTN] THEN
	GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[MEM; APPEND; EL];
	ALL_TAC] THEN
	LIST_INDUCT_TAC THEN ONCE_REWRITE_TAC[FIRSTN] THEN
	REWRITE_TAC[NOT_CONS_NIL; MEM] THEN
	REWRITE_TAC[HD; TL; EL; MEM; APPEND] THEN ASM_MESON_TAC[]);;

	let FIRSTN_SHORT = prove
	(`!n l. LENGTH l <= n ==> (FIRSTN (SUC n) l = FIRSTN n l)`,
	MESON_TAC[FIRSTN_TRIVIAL; ARITH_RULE `x <= n ==> x <= SUC n`]);;

	(* ------------------------------------------------------------------------- *)
	(* Tautologousness. *)
	(* ------------------------------------------------------------------------- *)

	let tautologous = new_definition
	`tautologous cl <=> ?p. p IN cl /\ ~~p IN cl`;;

	(* ------------------------------------------------------------------------- *)
	(* Definition of subsumption. *)
	(* ------------------------------------------------------------------------- *)

	parse_as_infix("subsumes",(12,"right"));;

	let subsumes = new_definition
	`cl subsumes cl' <=> ?i. IMAGE (formsubst i) cl SUBSET cl'`;;

	let subsumes_REFL = prove
	(`!cl. cl subsumes cl`,
	GEN_TAC THEN REWRITE_TAC [subsumes] THEN
	EXISTS_TAC `V` THEN
	REWRITE_TAC[SUBSET; IN_IMAGE; FORMSUBST_TRIV] THEN MESON_TAC[]);;

	let subsumes_TRANS = prove
	(`!cl1 cl2 cl3. clause cl1 /\ cl1 subsumes cl2 /\ cl2 subsumes cl3
	==> cl1 subsumes cl3`,
	REPEAT GEN_TAC THEN REWRITE_TAC[subsumes; clause] THEN
	DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 (X_CHOOSE_TAC `i:num->term`) MP_TAC) THEN
	DISCH_THEN(X_CHOOSE_TAC `j:num->term`) THEN
	EXISTS_TAC `termsubst j o (i:num->term)` THEN
	UNDISCH_TAC `IMAGE (formsubst i) cl1 SUBSET cl2` THEN
	UNDISCH_TAC `IMAGE (formsubst j) cl2 SUBSET cl3` THEN
	REWRITE_TAC[SUBSET; IN_IMAGE] THEN
	SUBGOAL_THEN
	`!p. p IN cl1
	==> (formsubst (termsubst j o i) p = formsubst j (formsubst i p))`
	(fun th -> MESON_TAC[th]) THEN
	SUBGOAL_THEN
	`!p. qfree(p)
	==> (formsubst (termsubst j o i) p = formsubst j (formsubst i p))`
	(fun th -> ASM_MESON_TAC[th; QFREE_LITERAL]) THEN
	MATCH_MP_TAC form_INDUCTION THEN
	SIMP_TAC[qfree; formsubst; o_THM; GSYM TERMSUBST_TERMSUBST] THEN
	REWRITE_TAC[GSYM MAP_o] THEN
	REPEAT GEN_TAC THEN AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN
	REWRITE_TAC[FUN_EQ_THM; TERMSUBST_TERMSUBST; o_THM]);;

	(* ------------------------------------------------------------------------- *)
	(* Lifting subsumption to a whole set. *)
	(* ------------------------------------------------------------------------- *)

	parse_as_infix("SUBSUMES",(12,"right"));;

	let SUBSUMES = new_definition
	`s SUBSUMES s' <=> !cl'. cl' IN s' ==> ?cl. cl IN s /\ cl subsumes cl'`;;

	(* ------------------------------------------------------------------------- *)
	(* Simple lemmas. *)
	(* ------------------------------------------------------------------------- *)

	let SUBSUMES_REFL = prove
	(`!s. s SUBSUMES s`,
	REWRITE_TAC[SUBSUMES] THEN MESON_TAC[subsumes_REFL]);;

	let SUBSUMES_UNION = prove
	(`s SUBSUMES s' /\ t SUBSUMES t' ==> (s UNION t) SUBSUMES (s' UNION t')`,
	REWRITE_TAC[SUBSUMES; IN_UNION] THEN MESON_TAC[]);;

	let SUBSUMES_TRANS = prove
	(`!s t u. (!c. c IN s ==> clause c) /\ s SUBSUMES t /\ t SUBSUMES u
	==> s SUBSUMES u`,
	REWRITE_TAC[SUBSUMES] THEN MESON_TAC[subsumes_TRANS]);;

	let SUBSUMES_SUBSET = prove
	(`!s t u. s SUBSUMES t /\ s SUBSET u ==> u SUBSUMES t`,
	REWRITE_TAC[SUBSUMES; SUBSET] THEN MESON_TAC[]);;

	let SUBSUMES_CLAUSES = prove
	(`(!s. s SUBSUMES {}) /\
	(!s. s SUBSUMES (x INSERT t) <=> s SUBSUMES {x} /\ s SUBSUMES t)`,
	REWRITE_TAC[SUBSUMES; IN_INSERT; NOT_IN_EMPTY] THEN MESON_TAC[]);;

	let SUBSUMES_SUBSET_REFL = prove
	(`!s t. s SUBSET t ==> t SUBSUMES s`,
	MESON_TAC[SUBSUMES_SUBSET; SUBSUMES_REFL]);;

	(* ------------------------------------------------------------------------- *)
	(* Set of all resolvents of a pair of clauses. *)
	(* ------------------------------------------------------------------------- *)

	let allresolvents = new_definition
	`allresolvents s1 s2 =
	{c \| ?c1 c2. c1 IN s1 /\ c2 IN s2 /\ isaresolvent c (c1,c2)}`;;

	(* ------------------------------------------------------------------------- *)
	(* Non-tautological resolvents. *)
	(* ------------------------------------------------------------------------- *)

	let allntresolvents = new_definition
	`allntresolvents s1 s2 =
	{r \| r IN allresolvents s1 s2 /\ ~(tautologous r)}`;;

	(* ------------------------------------------------------------------------- *)
	(* Lemmas. *)
	(* ------------------------------------------------------------------------- *)

	let TERMSUBST_TERMSUBST_o = prove
	(`termsubst (termsubst j o i) = termsubst j o termsubst i`,
	REWRITE_TAC[FUN_EQ_THM; o_THM; TERMSUBST_TERMSUBST]);;

	let FORMSUBST_FORMSUBST = prove
	(`!p i j. qfree(p)
	==> (formsubst j (formsubst i p) = formsubst (termsubst j o i) p)`,
	REPEAT GEN_TAC THEN SPEC_TAC(`p:form`,`p:form`) THEN
	MATCH_MP_TAC form_INDUCTION THEN SIMP_TAC[formsubst; qfree] THEN
	REWRITE_TAC[GSYM MAP_o; TERMSUBST_TERMSUBST_o]);;

	let ISARESOLVENT_SYM = prove
	(`!c1 c2 cl.
	clause c1 /\ clause c2 /\ isaresolvent cl (c2,c1)
	==> ?cl'. isaresolvent cl' (c1,c2) /\ cl' subsumes cl`,
	REPEAT STRIP_TAC THEN UNDISCH_TAC `isaresolvent cl (c2,c1)` THEN
	REWRITE_TAC[isaresolvent] THEN
	ABBREV_TAC `r1 = rename c1 (FVS c2)` THEN
	ABBREV_TAC `c1' = IMAGE (formsubst r1) c1` THEN
	CONV_TAC(LAND_CONV(ONCE_DEPTH_CONV let_CONV)) THEN
	DISCH_THEN(X_CHOOSE_THEN `ps2:form->bool`
	(X_CHOOSE_THEN `ps1:form->bool` MP_TAC)) THEN
	CONV_TAC(LAND_CONV(ONCE_DEPTH_CONV let_CONV)) THEN
	REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN
	DISCH_THEN SUBST_ALL_TAC THEN
	ABBREV_TAC `r2 = rename c2 (FVS c1)` THEN
	ABBREV_TAC `c2' = IMAGE (formsubst r2) c2` THEN
	MP_TAC(SPECL [`c1:form->bool`; `FVS c2`] rename) THEN
	ASM_SIMP_TAC[FVS_CLAUSE_FINITE] THEN
	DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN
	GEN_REWRITE_TAC LAND_CONV [renaming] THEN
	DISCH_THEN(X_CHOOSE_THEN `s1:num->term` STRIP_ASSUME_TAC) THEN
	MP_TAC(SPECL [`c2:form->bool`; `FVS c1`] rename) THEN
	ASM_SIMP_TAC[FVS_CLAUSE_FINITE] THEN
	DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN
	GEN_REWRITE_TAC LAND_CONV [renaming] THEN
	DISCH_THEN(X_CHOOSE_THEN `s2:num->term` STRIP_ASSUME_TAC) THEN
	CONV_TAC(TOP_DEPTH_CONV let_CONV) THEN
	REWRITE_TAC[LEFT_AND_EXISTS_THM] THEN
	ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN
	EXISTS_TAC `IMAGE (formsubst s1) ps1` THEN
	ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN
	EXISTS_TAC `IMAGE (formsubst r2) ps2` THEN
	REWRITE_TAC[LEFT_EXISTS_AND_THM] THEN
	W(EXISTS_TAC o funpow 6 rand o lhand o snd o dest_exists o snd) THEN
	REWRITE_TAC[] THEN
	MATCH_MP_TAC(TAUT `(a /\ b /\ c /\ d /\ e) /\ (e ==> f)
	==> (a /\ b /\ c /\ d /\ e) /\ f`) THEN
	CONJ_TAC THENL
	[REPEAT CONJ_TAC THENL
	[UNDISCH_TAC `ps1 SUBSET c1':form->bool` THEN EXPAND_TAC "c1'" THEN
	REWRITE_TAC[SUBSET; IN_IMAGE] THEN
	SUBGOAL_THEN `!p. p IN c1 ==> (formsubst s1 (formsubst r1 p) = p)`
	(fun th -> MESON_TAC[th]) THEN
	SUBGOAL_THEN
	`!p. qfree p
	==> (formsubst V p = formsubst s1 (formsubst r1 p))`
	(fun th -> ASM_MESON_TAC[th; FORMSUBST_TRIV;
	clause; QFREE_LITERAL]) THEN
	ASM_REWRITE_TAC[FORMSUBST_TERMSUBST_LEMMA] THEN
	REWRITE_TAC[FUN_EQ_THM; TERMSUBST_TRIV; I_DEF];
	UNDISCH_TAC `ps2 SUBSET c2:form->bool` THEN EXPAND_TAC "c2'" THEN
	REWRITE_TAC[SUBSET; IN_ELIM_THM; IN_IMAGE] THEN MESON_TAC[];
	UNDISCH_TAC `~(ps1:form->bool = {})` THEN
	REWRITE_TAC[EXTENSION; NOT_IN_EMPTY; IN_IMAGE] THEN MESON_TAC[];
	UNDISCH_TAC `~(ps2:form->bool = {})` THEN
	REWRITE_TAC[EXTENSION; NOT_IN_EMPTY; IN_IMAGE] THEN MESON_TAC[];
	FIRST_X_ASSUM(X_CHOOSE_THEN `i:num->term` MP_TAC) THEN
	REWRITE_TAC[UNIFIES; IN_UNION; IN_IMAGE; IN_ELIM_THM] THEN
	REWRITE_TAC[TAUT `(a \/ b ==> c) <=> (a ==> c) /\ (b ==> c)`] THEN
	SIMP_TAC[LEFT_IMP_EXISTS_THM] THEN REWRITE_TAC[FORALL_AND_THM] THEN
	X_GEN_TAC `P:form` THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	DISCH_THEN(MP_TAC o GEN `p:form` o SPECL [`~~p`; `p:form`]) THEN
	REWRITE_TAC[] THEN DISCH_TAC THEN
	EXISTS_TAC `\x. if x IN FVS(IMAGE (formsubst s1) ps1)
	then termsubst i (r1 x)
	else termsubst i (s2 x)` THEN
	EXISTS_TAC `~~P` THEN CONJ_TAC THENL
	[X_GEN_TAC `rrr:form` THEN X_GEN_TAC `p:form` THEN
	DISCH_THEN(ASSUME_TAC o CONJUNCT2) THEN
	MATCH_MP_TAC EQ_TRANS THEN
	EXISTS_TAC `formsubst (\x. termsubst i (r1 x)) (formsubst s1 p)` THEN
	CONJ_TAC THENL
	[MATCH_MP_TAC FORMSUBST_VALUATION THEN X_GEN_TAC `x:num` THEN
	DISCH_TAC THEN REWRITE_TAC[] THEN
	SUBGOAL_THEN `x IN FVS(IMAGE (formsubst s1) ps1)`
	(fun th -> REWRITE_TAC[th]) THEN
	REWRITE_TAC[IN_UNIONS; FVS; IN_ELIM_THM; IN_IMAGE] THEN
	ASM_MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN `P = formsubst i (~~p)` SUBST1_TAC THENL
	[ASM_MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN `literal p` MP_TAC THENL
	[UNDISCH_TAC `ps1 SUBSET c1':form->bool` THEN
	EXPAND_TAC "c1'" THEN REWRITE_TAC[IN_IMAGE; SUBSET] THEN
	DISCH_THEN(MP_TAC o SPEC `p:form`) THEN
	ASM_SIMP_TAC[LEFT_IMP_EXISTS_THM; FORMSUBST_LITERAL] THEN
	ASM_MESON_TAC[clause]; ALL_TAC] THEN
	SIMP_TAC[GSYM FORMSUBST_NEGATE; NEGATE_NEGATE] THEN
	DISCH_THEN(MP_TAC o MATCH_MP QFREE_LITERAL) THEN
	SIMP_TAC[FORMSUBST_FORMSUBST; GSYM o_DEF] THEN
	UNDISCH_TAC `ps1 SUBSET c1':form->bool` THEN
	EXPAND_TAC "c1'" THEN REWRITE_TAC[SUBSET; IN_IMAGE] THEN
	DISCH_THEN(MP_TAC o SPEC `p:form`) THEN ASM_REWRITE_TAC[] THEN
	DISCH_THEN(X_CHOOSE_THEN `q:form`
	(CONJUNCTS_THEN2 SUBST_ALL_TAC ASSUME_TAC)) THEN
	SIMP_TAC[QFREE_FORMSUBST; FORMSUBST_FORMSUBST] THEN
	SPEC_TAC(`q:form`,`q:form`) THEN
	MATCH_MP_TAC form_INDUCTION THEN SIMP_TAC[formsubst; qfree] THEN
	REPEAT GEN_TAC THEN AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN
	REWRITE_TAC[TERMSUBST_TERMSUBST_o] THEN
	ASM_REWRITE_TAC[GSYM o_ASSOC] THEN REWRITE_TAC[o_DEF; I_DEF];
	ALL_TAC] THEN
	X_GEN_TAC `rrr:form` THEN X_GEN_TAC `p:form` THEN
	DISCH_THEN(MP_TAC o CONJUNCT1) THEN
	DISCH_THEN(X_CHOOSE_THEN `q:form`
	(CONJUNCTS_THEN2 SUBST_ALL_TAC ASSUME_TAC)) THEN
	REWRITE_TAC[FORMSUBST_NEGATE] THEN AP_TERM_TAC THEN
	MATCH_MP_TAC EQ_TRANS THEN
	EXISTS_TAC `formsubst (\x. termsubst i (s2 x)) (formsubst r2 q)` THEN
	CONJ_TAC THENL
	[MATCH_MP_TAC FORMSUBST_VALUATION THEN X_GEN_TAC `x:num` THEN
	DISCH_TAC THEN REWRITE_TAC[] THEN
	SUBGOAL_THEN `~(x IN FVS(IMAGE (formsubst s1) ps1))`
	(fun th -> REWRITE_TAC[th]) THEN
	UNDISCH_TAC `FVS c2' INTER FVS c1 = {}` THEN EXPAND_TAC "c2'" THEN
	REWRITE_TAC[EXTENSION; NOT_IN_EMPTY; IN_INTER] THEN
	DISCH_THEN(MP_TAC o SPEC `x:num`) THEN
	UNDISCH_TAC `x IN FV(formsubst r2 q)` THEN
	MATCH_MP_TAC(TAUT
	`(a ==> a') /\ (b ==> b') ==> a ==> ~(a' /\ b') ==> ~b`) THEN
	CONJ_TAC THENL
	[REWRITE_TAC[FVS; IN_UNIONS; IN_IMAGE; IN_ELIM_THM] THEN
	ASM_MESON_TAC[SUBSET]; ALL_TAC] THEN
	REWRITE_TAC[FVS; IN_UNIONS; IN_IMAGE; IN_ELIM_THM] THEN
	UNDISCH_TAC `ps1 SUBSET c1':form->bool` THEN
	REWRITE_TAC[SUBSET] THEN
	EXPAND_TAC "c1'" THEN REWRITE_TAC[IN_IMAGE] THEN
	SUBGOAL_THEN `!p. p IN c1 ==> (formsubst s1 (formsubst r1 p) = p)`
	(fun th -> MESON_TAC[th]) THEN
	SUBGOAL_THEN `!p. qfree(p) ==> (formsubst s1 (formsubst r1 p) = p)`
	(fun th -> ASM_MESON_TAC[th; clause; QFREE_LITERAL]) THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	MATCH_MP_TAC form_INDUCTION THEN SIMP_TAC[formsubst; qfree] THEN
	REPEAT GEN_TAC THEN AP_TERM_TAC THEN MATCH_MP_TAC MAP_EQ_DEGEN THEN
	ASM_REWRITE_TAC[TERMSUBST_TERMSUBST_o] THEN
	REWRITE_TAC[I_THM; ALL_T]; ALL_TAC] THEN
	SUBGOAL_THEN `qfree q` MP_TAC THENL
	[ASM_MESON_TAC[SUBSET; clause; QFREE_LITERAL]; ALL_TAC] THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	SUBGOAL_THEN `formsubst i q = P` (SUBST1_TAC o SYM) THENL
	[ASM_MESON_TAC[]; ALL_TAC] THEN
	REWRITE_TAC[GSYM o_DEF] THEN
	SPEC_TAC(`q:form`,`q:form`) THEN
	MATCH_MP_TAC form_INDUCTION THEN SIMP_TAC[formsubst; qfree] THEN
	REPEAT GEN_TAC THEN AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN
	REWRITE_TAC[TERMSUBST_TERMSUBST_o] THEN
	ASM_REWRITE_TAC[GSYM o_ASSOC] THEN REWRITE_TAC[o_DEF; I_DEF] THEN
	CONV_TAC(ONCE_DEPTH_CONV ETA_CONV) THEN REFL_TAC];
	ALL_TAC] THEN
	SUBGOAL_THEN `?ps0. ps0 SUBSET c1 /\ ~(ps0 = {}) /\
	(ps1 = IMAGE (formsubst r1) ps0)`
	MP_TAC THENL
	[EXISTS_TAC `{p \| p IN c1 /\ (formsubst r1 p) IN ps1}` THEN
	UNDISCH_TAC `~(ps1:form->bool = {})` THEN
	UNDISCH_TAC `ps1 SUBSET c1':form->bool` THEN EXPAND_TAC "c1'" THEN
	REWRITE_TAC[EXTENSION; SUBSET; IN_ELIM_THM; NOT_IN_EMPTY;
	IN_IMAGE] THEN
	MESON_TAC[]; ALL_TAC] THEN
	DISCH_THEN(X_CHOOSE_THEN `ps0:form->bool` MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	DISCH_THEN SUBST_ALL_TAC THEN EXPAND_TAC "c2'" THEN
	REWRITE_TAC[GSYM IMAGE_o] THEN
	SUBGOAL_THEN `IMAGE (formsubst s1 o formsubst r1) ps0 = ps0` SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; o_THM] THEN
	X_GEN_TAC `p:form` THEN
	SUBGOAL_THEN `!p. p IN ps0 ==> (formsubst s1 (formsubst r1 p) = p)`
	(fun th -> MESON_TAC[th]) THEN
	SUBGOAL_THEN `!p. qfree p ==> (formsubst s1 (formsubst r1 p) = p)`
	(fun th -> ASM_MESON_TAC[clause; SUBSET; QFREE_LITERAL; th]) THEN
	MATCH_MP_TAC form_INDUCTION THEN SIMP_TAC[formsubst; qfree] THEN
	ASM_REWRITE_TAC[GSYM MAP_o] THEN
	SIMP_TAC[MAP_EQ_DEGEN; I_DEF; ALL_T]; ALL_TAC] THEN
	DISCH_TAC THEN
	ABBREV_TAC `i = mgu (ps0 UNION {~~p \| p IN IMAGE (formsubst r2) ps2})` THEN
	ABBREV_TAC `j = mgu (ps2 UNION {~~p \| p IN IMAGE (formsubst r1) ps0})` THEN
	EXPAND_TAC "c1'" THEN
	MP_TAC(SPEC `ps0 UNION {~~p \| p IN IMAGE (formsubst r2) ps2}` MGU) THEN
	ASM_REWRITE_TAC[] THEN ANTS_TAC THENL
	[CONJ_TAC THENL
	[SUBGOAL_THEN `{~~ p \| p IN IMAGE (formsubst r2) ps2} =
	IMAGE (~~) (IMAGE (formsubst r2) ps2)`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_IMAGE] THEN MESON_TAC[];
	ALL_TAC] THEN
	REWRITE_TAC[FINITE_UNION] THEN CONJ_TAC THEN
	REPEAT(MATCH_MP_TAC FINITE_IMAGE) THEN
	ASM_MESON_TAC[FINITE_SUBSET; clause]; ALL_TAC] THEN
	REWRITE_TAC[IN_UNION; IN_ELIM_THM; IN_IMAGE] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_NEGATE; QFREE_FORMSUBST] THEN
	ASM_MESON_TAC[SUBSET; clause; QFREE_LITERAL]; ALL_TAC] THEN
	STRIP_TAC THEN
	MP_TAC(SPEC `ps2 UNION {~~ p \| p IN IMAGE (formsubst r1) ps0}` MGU) THEN
	ASM_REWRITE_TAC[] THEN ANTS_TAC THENL
	[CONJ_TAC THENL
	[SUBGOAL_THEN `{~~ p \| p IN IMAGE (formsubst r1) ps0} =
	IMAGE (~~) (IMAGE (formsubst r1) ps0)`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_IMAGE] THEN MESON_TAC[];
	ALL_TAC] THEN
	REWRITE_TAC[FINITE_UNION] THEN CONJ_TAC THEN
	REPEAT(MATCH_MP_TAC FINITE_IMAGE) THEN
	ASM_MESON_TAC[FINITE_SUBSET; clause]; ALL_TAC] THEN
	REWRITE_TAC[IN_UNION; IN_ELIM_THM; IN_IMAGE] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_NEGATE; QFREE_FORMSUBST] THEN
	ASM_MESON_TAC[SUBSET; clause; QFREE_LITERAL]; ALL_TAC] THEN
	STRIP_TAC THEN
	UNDISCH_TAC
	`!i'. Unifies i' (ps0 UNION {~~ p \| p IN IMAGE (formsubst r2) ps2})
	==> (!p. qfree p
	==> (formsubst i' p = formsubst i' (formsubst i p)))` THEN
	DISCH_THEN(MP_TAC o SPEC
	`\x. if x IN FVS(c1) then termsubst j (r1 x)
	else termsubst j (s2 x)`) THEN
	ANTS_TAC THENL
	[UNDISCH_TAC
	`Unifies j (ps2 UNION {~~ p \| p IN IMAGE (formsubst r1) ps0})` THEN
	REWRITE_TAC[UNIFIES] THEN
	DISCH_THEN(X_CHOOSE_THEN `P:form` MP_TAC) THEN
	REWRITE_TAC[UNIFIES; IN_UNION; IN_IMAGE; IN_ELIM_THM] THEN
	REWRITE_TAC[TAUT `(a \/ b ==> c) <=> (a ==> c) /\ (b ==> c)`] THEN
	SIMP_TAC[LEFT_IMP_EXISTS_THM] THEN REWRITE_TAC[FORALL_AND_THM] THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	DISCH_THEN(MP_TAC o GEN `p:form` o SPECL [`~~p`; `p:form`]) THEN
	REWRITE_TAC[] THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN
	DISCH_THEN(MP_TAC o GEN `p:form` o SPECL [`formsubst r1 p`; `p:form`]) THEN
	ASM_REWRITE_TAC[FORMSUBST_NEGATE] THEN DISCH_TAC THEN
	EXISTS_TAC `~~P` THEN CONJ_TAC THENL
	[X_GEN_TAC `p:form` THEN DISCH_TAC THEN
	MATCH_MP_TAC EQ_TRANS THEN
	EXISTS_TAC `formsubst (termsubst j o r1) p` THEN CONJ_TAC THENL
	[MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `x:num` THEN DISCH_TAC THEN REWRITE_TAC[o_THM] THEN
	SUBGOAL_THEN `x IN FVS(c1)` (fun th -> REWRITE_TAC[th]) THEN
	ASM_REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN
	ASM_MESON_TAC[SUBSET]; ALL_TAC] THEN
	SUBGOAL_THEN `P = ~~(formsubst j (formsubst r1 p))` SUBST1_TAC THENL
	[ASM_MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN `~~(~~(formsubst j (formsubst r1 p))) =
	formsubst j (formsubst r1 p)`
	SUBST1_TAC THENL
	[MATCH_MP_TAC NEGATE_NEGATE THEN
	REWRITE_TAC[FORMSUBST_LITERAL] THEN
	ASM_MESON_TAC[SUBSET; clause]; ALL_TAC] THEN
	MATCH_MP_TAC(GSYM FORMSUBST_FORMSUBST) THEN
	ASM_MESON_TAC[SUBSET; clause; QFREE_LITERAL]; ALL_TAC] THEN
	X_GEN_TAC `rrr:form` THEN X_GEN_TAC `p:form` THEN
	REWRITE_TAC[LEFT_AND_EXISTS_THM; LEFT_IMP_EXISTS_THM] THEN
	X_GEN_TAC `q:form` THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN
	AP_TERM_TAC THEN
	SUBGOAL_THEN `formsubst j q = P` (SUBST1_TAC o SYM) THENL
	[ASM_MESON_TAC[]; ALL_TAC] THEN
	MATCH_MP_TAC EQ_TRANS THEN
	EXISTS_TAC `formsubst (termsubst j o s2) (formsubst r2 q)` THEN
	CONJ_TAC THENL
	[MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `x:num` THEN DISCH_TAC THEN REWRITE_TAC[] THEN
	SUBGOAL_THEN `~(x IN FVS(c1))` (fun th -> REWRITE_TAC[o_THM; th]) THEN
	UNDISCH_TAC `FVS c2' INTER FVS c1 = {}` THEN EXPAND_TAC "c2'" THEN
	REWRITE_TAC[EXTENSION; NOT_IN_EMPTY; IN_INTER] THEN
	DISCH_THEN(MP_TAC o SPEC `x:num`) THEN
	MATCH_MP_TAC(TAUT `a ==> ~(a /\ b) ==> ~b`) THEN
	UNDISCH_TAC `x IN FV (formsubst r2 q)` THEN
	UNDISCH_TAC `q:form IN ps2` THEN
	UNDISCH_TAC `ps2 SUBSET c2:form->bool` THEN
	REWRITE_TAC[SUBSET; FVS; IN_UNIONS; IN_IMAGE; IN_ELIM_THM] THEN
	MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN `qfree q` MP_TAC THENL
	[ASM_MESON_TAC[SUBSET; clause; QFREE_LITERAL]; ALL_TAC] THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	SPEC_TAC(`q:form`,`q:form`) THEN MATCH_MP_TAC form_INDUCTION THEN
	SIMP_TAC[qfree; formsubst] THEN REPEAT GEN_TAC THEN
	AP_TERM_TAC THEN MATCH_MP_TAC MAP_EQ THEN
	REWRITE_TAC[TERMSUBST_TERMSUBST_o] THEN
	ASM_REWRITE_TAC[GSYM o_ASSOC] THEN REWRITE_TAC[o_DEF; I_DEF; ALL_T];
	ALL_TAC] THEN
	ABBREV_TAC `k = \x. if x IN FVS(c1) then termsubst j (r1 x)
	else termsubst j (s2 x)` THEN
	DISCH_TAC THEN REWRITE_TAC[subsumes] THEN
	EXISTS_TAC `k:num->term` THEN REWRITE_TAC[GSYM IMAGE_o] THEN
	SUBGOAL_THEN
	`IMAGE (formsubst k o formsubst i)
	(c1 DIFF ps0 UNION c2' DIFF IMAGE (formsubst r2) ps2) =
	IMAGE (formsubst k)
	(c1 DIFF ps0 UNION c2' DIFF IMAGE (formsubst r2) ps2)`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE] THEN
	SUBGOAL_THEN
	`!p. p IN (c1 DIFF ps0 UNION c2' DIFF IMAGE (formsubst r2) ps2)
	==> qfree p`
	(fun th -> ASM_MESON_TAC[o_THM; th]) THEN
	REWRITE_TAC[IN_UNION; IN_IMAGE; IN_DIFF] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THENL
	[ASM_MESON_TAC[QFREE_LITERAL; clause]; ALL_TAC] THEN
	UNDISCH_TAC `p:form IN c2'` THEN EXPAND_TAC "c2'" THEN
	SIMP_TAC[IN_IMAGE; LEFT_IMP_EXISTS_THM; QFREE_FORMSUBST] THEN
	ASM_MESON_TAC[QFREE_LITERAL; clause]; ALL_TAC] THEN
	REWRITE_TAC[IN_IMAGE; SUBSET; IN_ELIM_THM] THEN
	X_GEN_TAC `p:form` THEN
	DISCH_THEN(X_CHOOSE_THEN `q:form` MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC) THEN
	REWRITE_TAC[IN_UNION] THEN STRIP_TAC THENL
	[EXISTS_TAC `formsubst r1 q` THEN CONJ_TAC THENL
	[SUBGOAL_THEN `qfree q` MP_TAC THENL
	[ASM_MESON_TAC[IN_DIFF; clause; QFREE_LITERAL]; ALL_TAC] THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN DISCH_TAC THEN
	MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `x:num` THEN DISCH_TAC THEN EXPAND_TAC "k" THEN
	SUBGOAL_THEN `x IN FVS(c1)` (fun th -> REWRITE_TAC[th; o_THM]) THEN
	REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN ASM_MESON_TAC[IN_DIFF];
	ALL_TAC] THEN
	DISJ2_TAC THEN EXPAND_TAC "c1'" THEN
	UNDISCH_TAC `q:form IN c1 DIFF ps0` THEN
	REWRITE_TAC[IN_DIFF; IN_IMAGE] THEN STRIP_TAC THEN
	CONJ_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN
	DISCH_THEN(X_CHOOSE_THEN `r:form` MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN
	DISCH_THEN(MP_TAC o AP_TERM `formsubst s1`) THEN
	SUBGOAL_THEN `(formsubst s1 (formsubst r1 q) = q) /\
	(formsubst s1 (formsubst r1 r) = r)`
	(fun th -> ASM_MESON_TAC[th]) THEN
	SUBGOAL_THEN `!p. qfree p ==> (formsubst s1 (formsubst r1 p) = p)`
	(fun th -> ASM_MESON_TAC[th; SUBSET; clause; QFREE_LITERAL]) THEN
	GEN_REWRITE_TAC (BINDER_CONV o RAND_CONV o RAND_CONV)
	[GSYM FORMSUBST_TRIV] THEN
	CONV_TAC(ONCE_DEPTH_CONV SYM_CONV) THEN
	REWRITE_TAC[FORMSUBST_TERMSUBST_LEMMA] THEN
	ASM_REWRITE_TAC[] THEN REWRITE_TAC[FUN_EQ_THM; TERMSUBST_TRIV; I_DEF];
	ALL_TAC] THEN
	EXISTS_TAC `formsubst s2 q` THEN CONJ_TAC THENL
	[SUBGOAL_THEN `qfree q` MP_TAC THENL
	[UNDISCH_TAC `q IN c2' DIFF IMAGE (formsubst r2) ps2` THEN
	EXPAND_TAC "c2'" THEN REWRITE_TAC[IN_DIFF] THEN
	DISCH_THEN(MP_TAC o CONJUNCT1) THEN
	REWRITE_TAC[IN_IMAGE] THEN
	ASM_MESON_TAC[clause; QFREE_LITERAL; QFREE_FORMSUBST]; ALL_TAC] THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN DISCH_TAC THEN
	MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `x:num` THEN DISCH_TAC THEN EXPAND_TAC "k" THEN
	SUBGOAL_THEN `~(x IN FVS(c1))` (fun th -> REWRITE_TAC[th; o_THM]) THEN
	UNDISCH_TAC `FVS c2' INTER FVS c1 = {}` THEN
	REWRITE_TAC[EXTENSION; IN_INTER; NOT_IN_EMPTY] THEN
	DISCH_THEN(MP_TAC o SPEC `x:num`) THEN
	MATCH_MP_TAC(TAUT `a ==> ~(a /\ b) ==> ~b`) THEN
	REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN ASM_MESON_TAC[IN_DIFF];
	ALL_TAC] THEN
	DISJ1_TAC THEN
	UNDISCH_TAC `q IN c2' DIFF IMAGE (formsubst r2) ps2` THEN
	EXPAND_TAC "c2'" THEN
	REWRITE_TAC[IN_DIFF; IN_IMAGE] THEN
	MATCH_MP_TAC(TAUT `(a ==> a') /\ (b ==> b') ==> a /\ b ==> a' /\ b'`) THEN
	CONJ_TAC THENL
	[DISCH_THEN(X_CHOOSE_THEN `r:form` STRIP_ASSUME_TAC) THEN
	ASM_REWRITE_TAC[] THEN
	SUBGOAL_THEN `formsubst s2 (formsubst r2 r) = r`
	(fun th -> ASM_MESON_TAC[th]) THEN
	SUBGOAL_THEN `qfree r` MP_TAC THENL
	[ASM_MESON_TAC[clause; QFREE_LITERAL]; ALL_TAC] THEN
	SPEC_TAC(`r:form`,`r:form`) THEN
	GEN_REWRITE_TAC (BINDER_CONV o RAND_CONV o RAND_CONV)
	[GSYM FORMSUBST_TRIV] THEN
	CONV_TAC(ONCE_DEPTH_CONV SYM_CONV) THEN
	REWRITE_TAC[FORMSUBST_TERMSUBST_LEMMA] THEN
	ASM_REWRITE_TAC[] THEN REWRITE_TAC[FUN_EQ_THM; TERMSUBST_TRIV; I_DEF];
	ALL_TAC] THEN
	REWRITE_TAC[TAUT `~a ==> ~b <=> b ==> a`] THEN
	DISCH_TAC THEN
	EXISTS_TAC `formsubst s2 q` THEN ASM_REWRITE_TAC[] THEN
	CONV_TAC SYM_CONV THEN GEN_REWRITE_TAC RAND_CONV [GSYM FORMSUBST_TRIV] THEN
	SUBGOAL_THEN `qfree q` MP_TAC THENL
	[ASM_MESON_TAC[QFREE_FORMSUBST; SUBSET; clause; QFREE_LITERAL];
	ALL_TAC] THEN
	SPEC_TAC(`q:form`,`q:form`) THEN
	CONV_TAC(ONCE_DEPTH_CONV SYM_CONV) THEN
	REWRITE_TAC[FORMSUBST_TERMSUBST_LEMMA] THEN
	ASM_REWRITE_TAC[FUN_EQ_THM; TERMSUBST_TRIV; I_DEF]);;

	let ALLRESOLVENTS_SYM = prove
	(`(!c. c IN A ==> clause c) /\ (!c. c IN B ==> clause c)
	==> (allresolvents A B) SUBSUMES (allresolvents B A)`,
	REPEAT STRIP_TAC THEN REWRITE_TAC[SUBSUMES; allresolvents; IN_ELIM_THM] THEN
	X_GEN_TAC `cl:form->bool` THEN
	DISCH_THEN(X_CHOOSE_THEN `c2:form->bool`
	(X_CHOOSE_THEN `c1:form->bool` STRIP_ASSUME_TAC)) THEN
	REWRITE_TAC[LEFT_AND_EXISTS_THM] THEN
	ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN EXISTS_TAC `c1:form->bool` THEN
	ASM_REWRITE_TAC[] THEN
	ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN EXISTS_TAC `c2:form->bool` THEN
	ASM_SIMP_TAC[ISARESOLVENT_SYM]);;

	let ALLRESOLVENTS_UNION = prove
	(`(allresolvents (A UNION B) C =
	(allresolvents A C) UNION (allresolvents B C)) /\
	(allresolvents A (B UNION C) =
	(allresolvents A B) UNION (allresolvents A C))`,
	REWRITE_TAC[EXTENSION; allresolvents; IN_ELIM_THM; IN_UNION] THEN
	MESON_TAC[]);;

	let ALLRESOLVENTS_STEP = prove
	(`(!c. c IN B ==> clause(c)) /\
	(!c. c IN C ==> clause(c))
	==> ((allresolvents B (A UNION B)) UNION
	(allresolvents C (A UNION B UNION C)))
	SUBSUMES (allresolvents(B UNION C) (A UNION B UNION C))`,
	REPEAT STRIP_TAC THEN
	REWRITE_TAC[ALLRESOLVENTS_UNION; UNION_ASSOC] THEN
	ONCE_REWRITE_TAC[AC UNION_ACI
	`a UNION b UNION c UNION d UNION e UNION f =
	a UNION b UNION d UNION (c UNION e) UNION f`] THEN
	GEN_REWRITE_TAC (LAND_CONV o funpow 3 RAND_CONV) [AC UNION_ACI
	`A UNION B = (A UNION A) UNION B`] THEN
	REPEAT(MATCH_MP_TAC SUBSUMES_UNION THEN ASM_REWRITE_TAC[SUBSUMES_REFL]) THEN
	ASM_SIMP_TAC[ALLRESOLVENTS_SYM]);;

	(* ------------------------------------------------------------------------- *)
	(* Asymmetric list-based version used in algorithm. *)
	(* ------------------------------------------------------------------------- *)

	let resolvents = new_definition
	`resolvents cl cls = list_of_set(allresolvents {cl} (set_of_list cls))`;;

	(* ------------------------------------------------------------------------- *)
	(* Trivial lemmas. *)
	(* ------------------------------------------------------------------------- *)

	let CLAUSE_UNION = prove
	(`!c1 c2. clause(c1 UNION c2) <=> clause(c1) /\ clause(c2)`,
	REWRITE_TAC[clause; FINITE_UNION; IN_UNION] THEN MESON_TAC[]);;

	let CLAUSE_SUBSET = prove
	(`!c1 c2. clause c2 /\ c1 SUBSET c2 ==> clause c1`,
	REWRITE_TAC[clause] THEN MESON_TAC[SUBSET; FINITE_SUBSET]);;

	let CLAUSE_DIFF = prove
	(`!c1 c2. clause c1 ==> clause (c1 DIFF c2)`,
	MESON_TAC[CLAUSE_SUBSET; IN_DIFF; SUBSET]);;

	let ISARESOLVENT_CLAUSE = prove
	(`!p q r. clause p /\ clause q /\ isaresolvent r (p,q) ==> clause r`,
	REWRITE_TAC[isaresolvent] THEN
	CONV_TAC(TOP_DEPTH_CONV let_CONV) THEN REPEAT STRIP_TAC THEN
	ASM_REWRITE_TAC[] THEN MATCH_MP_TAC IMAGE_FORMSUBST_CLAUSE THEN
	ASM_SIMP_TAC[IMAGE_FORMSUBST_CLAUSE; CLAUSE_UNION; CLAUSE_DIFF]);;

	let ALLRESOLVENTS_CLAUSE = prove
	(`(!c. c IN s ==> clause c) /\ (!c. c IN t ==> clause c)
	==> !c. c IN allresolvents s t ==> clause c`,
	REWRITE_TAC[allresolvents; IN_ELIM_THM; isaresolvent] THEN
	CONV_TAC(TOP_DEPTH_CONV let_CONV) THEN REPEAT STRIP_TAC THEN
	ASM_REWRITE_TAC[] THEN MATCH_MP_TAC IMAGE_FORMSUBST_CLAUSE THEN
	ASM_SIMP_TAC[IMAGE_FORMSUBST_CLAUSE; CLAUSE_UNION; CLAUSE_DIFF]);;

	let ISARESOLVENT_FINITE = prove
	(`!c1 c2. clause(c1) /\ clause(c2)
	==> FINITE {c \| isaresolvent c (c1,c2)}`,
	REPEAT STRIP_TAC THEN REWRITE_TAC[isaresolvent] THEN
	LET_TAC THEN
	SUBGOAL_THEN `clause cl2'` ASSUME_TAC THENL
	[EXPAND_TAC "cl2'" THEN ASM_SIMP_TAC[IMAGE_FORMSUBST_CLAUSE];
	ALL_TAC] THEN
	MATCH_MP_TAC FINITE_SUBSET THEN
	EXISTS_TAC
	`IMAGE (\pss. let i = mgu (FST(pss) UNION {~~ p \| p IN SND(pss)}) in
	IMAGE (formsubst i)
	(c1 DIFF (FST pss) UNION cl2' DIFF (SND pss)))
	{ps1,ps2 \| ps1 IN {ps1 \| ps1 SUBSET c1} /\
	ps2 IN {ps2 \| ps2 SUBSET cl2'}}` THEN
	CONJ_TAC THENL
	[ALL_TAC;
	REWRITE_TAC[SUBSET; IN_IMAGE; IN_ELIM_THM] THEN
	X_GEN_TAC `c:form->bool` THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN
	MAP_EVERY X_GEN_TAC [`ps1:form->bool`; `ps2:form->bool`] THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN STRIP_TAC THEN
	EXISTS_TAC `ps1:form->bool,ps2:form->bool` THEN
	ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]] THEN
	MATCH_MP_TAC FINITE_IMAGE THEN MATCH_MP_TAC FINITE_PRODUCT THEN
	RULE_ASSUM_TAC(REWRITE_RULE[clause]) THEN ASM_SIMP_TAC[FINITE_POWERSET]);;

	let ALLRESOLVENTS_FINITE = prove
	(`!s t. FINITE(s) /\ FINITE(t) /\
	(!c. c IN s ==> clause c) /\
	(!c. c IN t ==> clause c)
	==> FINITE(allresolvents s t)`,
	REPEAT STRIP_TAC THEN SUBGOAL_THEN
	`allresolvents s t =
	UNIONS (IMAGE (\cs. {c \| isaresolvent c cs})
	{c1,c2 \| c1 IN s /\ c2 IN t})`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; allresolvents; IN_UNIONS; IN_IMAGE;
	IN_ELIM_THM] THEN
	X_GEN_TAC `c:form->bool` THEN
	EQ_TAC THENL [ALL_TAC; MESON_TAC[]] THEN
	STRIP_TAC THEN EXISTS_TAC `{c \| isaresolvent c (c1,c2)}` THEN
	REWRITE_TAC[IN_ELIM_THM] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	ASM_SIMP_TAC[FINITE_UNIONS; FINITE_IMAGE; FINITE_PRODUCT] THEN
	REWRITE_TAC[IN_IMAGE] THEN X_GEN_TAC `u:(form->bool)->bool` THEN
	DISCH_THEN(CHOOSE_THEN (CONJUNCTS_THEN2 SUBST1_TAC MP_TAC)) THEN
	GEN_REWRITE_TAC (LAND_CONV o TOP_DEPTH_CONV) [IN_ELIM_THM; BETA_THM] THEN
	STRIP_TAC THEN ASM_SIMP_TAC[ISARESOLVENT_FINITE]);;

	(* ------------------------------------------------------------------------- *)
	(* Replacement. *)
	(* ------------------------------------------------------------------------- *)

	let replace = new_recursive_definition list_RECURSION
	`(replace cl [] = [cl]) /\
	(replace cl (CONS c cls) =
	if cl subsumes c then CONS cl cls else CONS c (replace cl cls))`;;

	let REPLACE = prove
	(`!cl lis. (!c. MEM c lis ==> clause c) /\ clause cl
	==> (!c. MEM c (replace cl lis) ==> clause c) /\
	set_of_list(replace cl lis) SUBSUMES set_of_list(CONS cl lis)`,
	GEN_TAC THEN LIST_INDUCT_TAC THEN
	SIMP_TAC[replace; SUBSUMES_REFL; MEM] THEN
	REWRITE_TAC[TAUT `(a \/ b ==> c) <=> (a ==> c) /\ (b ==> c)`] THEN
	REWRITE_TAC[FORALL_AND_THM] THEN STRIP_TAC THEN
	FIRST_ASSUM(UNDISCH_TAC o check is_imp o concl) THEN
	ASM_REWRITE_TAC[] THEN STRIP_TAC THEN COND_CASES_TAC THEN
	REWRITE_TAC[MEM; set_of_list] THENL
	[UNDISCH_TAC `set_of_list(replace cl t) SUBSUMES
	set_of_list(CONS cl t)`;
	UNDISCH_TAC
	`set_of_list(replace cl t) SUBSUMES set_of_list(CONS cl t)`] THEN
	REWRITE_TAC[SUBSUMES; IN_INSERT; set_of_list] THEN
	REWRITE_TAC[IN_SET_OF_LIST] THEN ASM_MESON_TAC[subsumes_REFL]);;

	(* ------------------------------------------------------------------------- *)
	(* Incorporation. *)
	(* ------------------------------------------------------------------------- *)

	let incorporate = new_definition
	`incorporate gcl cl current =
	if tautologous cl \/ EX (\c. c subsumes cl) (CONS gcl current)
	then current else replace cl current`;;

	let INCORPORATE = prove
	(`!gcl cl current.
	(!c. MEM c current ==> clause c) /\ clause gcl /\ clause cl
	==> (!c. MEM c (incorporate gcl cl current) ==> clause c) /\
	set_of_list(incorporate gcl cl current)
	SUBSUMES set_of_list(current) /\
	(tautologous cl \/
	(gcl INSERT set_of_list(incorporate gcl cl current))
	SUBSUMES set_of_list(CONS cl current))`,
	REPEAT GEN_TAC THEN STRIP_TAC THEN REWRITE_TAC[incorporate] THEN
	ASM_CASES_TAC `tautologous cl` THEN ASM_REWRITE_TAC[SUBSUMES_REFL] THEN
	ASM_CASES_TAC `EX (\c. c subsumes cl) (CONS gcl current)` THEN
	ASM_REWRITE_TAC[SUBSUMES_REFL] THENL
	[REWRITE_TAC[set_of_list] THEN ONCE_REWRITE_TAC[SUBSUMES_CLAUSES] THEN
	REWRITE_TAC[GSYM(CONJUNCT2 set_of_list)] THEN CONJ_TAC THENL
	[ALL_TAC;
	MATCH_MP_TAC SUBSUMES_SUBSET THEN
	EXISTS_TAC `set_of_list(current:(form->bool)list)` THEN
	REWRITE_TAC[SUBSUMES_REFL] THEN
	SIMP_TAC[SUBSET; set_of_list; IN_INSERT]] THEN
	UNDISCH_TAC `EX (\c. c subsumes cl) (CONS gcl current)` THEN
	SPEC_TAC(`CONS (gcl:form->bool) current`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[EX] THEN
	ASM_REWRITE_TAC[set_of_list] THEN STRIP_TAC THEN
	MATCH_MP_TAC SUBSUMES_SUBSET THENL
	[EXISTS_TAC `{h:form->bool}`;
	EXISTS_TAC `set_of_list(t:(form->bool)list)`] THEN
	ASM_SIMP_TAC[SUBSET; IN_INSERT; NOT_IN_EMPTY] THEN
	REWRITE_TAC[SUBSUMES; IN_INSERT; NOT_IN_EMPTY] THEN ASM_MESON_TAC[];
	ALL_TAC] THEN
	MP_TAC(SPECL [`cl:form->bool`; `current:(form->bool)list`] REPLACE) THEN
	ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN
	UNDISCH_TAC `set_of_list(replace cl current) SUBSUMES
	set_of_list (CONS cl current)` THEN
	REWRITE_TAC[SUBSUMES; set_of_list; IN_INSERT; NOT_IN_EMPTY] THEN
	MESON_TAC[]);;

	(* ------------------------------------------------------------------------- *)
	(* Set insertion. *)
	(* ------------------------------------------------------------------------- *)

	let insert_def = new_definition
	`insert x l = if MEM x l then l else CONS x l`;;

	(* ------------------------------------------------------------------------- *)
	(* Basic given clause algorithm. *)
	(* ------------------------------------------------------------------------- *)

	let step = new_definition
	`step (used,unused) =
	if unused = [] then (used,unused) else
	let new = resolvents (HD unused) (CONS (HD unused) used) in
	(insert (HD unused) used,
	ITLIST (incorporate (HD unused)) new (TL unused))`;;

	let STEP = prove
	(`(step(used,[]) = (used,[])) /\
	(step(used,CONS cl cls) =
	let new = resolvents cl (CONS cl used) in
	insert cl used,ITLIST (incorporate cl) new cls)`,
	REPEAT STRIP_TAC THEN GEN_REWRITE_TAC LAND_CONV [step] THEN
	REWRITE_TAC[NOT_CONS_NIL; HD; TL]);;

	let given = new_recursive_definition num_RECURSION
	`(given 0 p = p) /\
	(given (SUC n) p = step(given n p))`;;

	(* ------------------------------------------------------------------------- *)
	(* Separation into bits simplifies things a bit. *)
	(* ------------------------------------------------------------------------- *)

	let Used_DEF = new_definition
	`Used init n = set_of_list(FST(given n init))`;;

	let Unused_DEF = new_definition
	`Unused init n = set_of_list(SND(given n init))`;;

	(* ------------------------------------------------------------------------- *)
	(* Auxiliary concept actually has the cleanest recursion equations. *)
	(* ------------------------------------------------------------------------- *)

	let Sub_DEF = new_recursive_definition num_RECURSION
	`(Sub init 0 = {}) /\
	(Sub init (SUC n) = if SND(given n init) = [] then Sub init n
	else HD(SND(given n init)) INSERT (Sub init n))`;;

	(* ------------------------------------------------------------------------- *)
	(* The main invariant. *)
	(* ------------------------------------------------------------------------- *)

	let TAUTOLOGOUS_INSTANCE = prove
	(`!i cl. tautologous cl ==> tautologous (IMAGE (formsubst i) cl)`,
	REWRITE_TAC[tautologous; IN_IMAGE] THEN
	MESON_TAC[FORMSUBST_NEGATE]);;

	let NONTAUTOLOGOUS_SUBSUMES = prove
	(`cl subsumes cl' /\ ~(tautologous cl') ==> ~(tautologous cl)`,
	REWRITE_TAC[subsumes; SUBSET; tautologous; IN_IMAGE] THEN
	MESON_TAC[FORMSUBST_NEGATE]);;

	let ALLNTRESOLVENTS_STEP = prove
	(`(!c. c IN B ==> clause(c)) /\
	(!c. c IN C ==> clause(c))
	==> ((allntresolvents B (A UNION B)) UNION
	(allntresolvents C (A UNION B UNION C)))
	SUBSUMES (allntresolvents(B UNION C) (A UNION B UNION C))`,
	STRIP_TAC THEN MP_TAC ALLRESOLVENTS_STEP THEN ASM_REWRITE_TAC[] THEN
	REWRITE_TAC[SUBSUMES; allntresolvents; IN_ELIM_THM; IN_UNION] THEN
	MESON_TAC[NONTAUTOLOGOUS_SUBSUMES]);;

	let ALLNTRESOLVENTS_UNION = prove
	(`(allntresolvents (A UNION B) C =
	(allntresolvents A C) UNION (allntresolvents B C)) /\
	(allntresolvents A (B UNION C) =
	(allntresolvents A B) UNION (allntresolvents A C))`,
	REWRITE_TAC[EXTENSION; allntresolvents; allresolvents;
	IN_ELIM_THM; IN_UNION] THEN
	MESON_TAC[]);;

	let SET_OF_LIST_INSERT = prove
	(`!x s. set_of_list(insert x s) = x INSERT set_of_list(s)`,
	REPEAT GEN_TAC THEN REWRITE_TAC[insert_def] THEN
	COND_CASES_TAC THEN ASM_REWRITE_TAC[set_of_list] THEN
	POP_ASSUM MP_TAC THEN REWRITE_TAC[GSYM IN_SET_OF_LIST] THEN SET_TAC[]);;

	let SET_OF_LIST_FILTER = prove
	(`!P l. set_of_list(FILTER P l) = {x \| x IN set_of_list l /\ P x}`,
	GEN_TAC THEN LIST_INDUCT_TAC THEN ASM_REWRITE_TAC[FILTER; set_of_list] THENL
	[REWRITE_TAC[EXTENSION; IN_ELIM_THM; NOT_IN_EMPTY]; ALL_TAC] THEN
	COND_CASES_TAC THEN ASM_REWRITE_TAC[set_of_list] THEN
	REWRITE_TAC[EXTENSION; IN_ELIM_THM; NOT_IN_EMPTY; IN_INSERT] THEN
	ASM_MESON_TAC[]);;

	let USED_SUB = prove
	(`!used unused n.
	Used(used,unused) n = set_of_list(used) UNION Sub(used,unused) n`,
	GEN_TAC THEN GEN_TAC THEN
	REWRITE_TAC[Used_DEF; Unused_DEF] THEN INDUCT_TAC THEN
	REWRITE_TAC[Sub_DEF; given; UNION_EMPTY] THEN
	ABBREV_TAC `ppp = given n (used,unused)` THEN
	SUBST1_TAC(SYM(ISPEC `ppp:(form->bool)list#(form->bool)list` PAIR)) THEN
	PURE_REWRITE_TAC[step] THEN ASM_REWRITE_TAC[] THEN
	COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN
	REWRITE_TAC[FST; SET_OF_LIST_INSERT] THEN
	ASM_REWRITE_TAC[] THEN SET_TAC[]);;

	let GIVEN_INVARIANT = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !n. (!c. c IN Used(used,unused) n ==> clause c) /\
	(!c. c IN Unused(used,unused) n ==> clause c) /\
	(!c. c IN Sub(used,unused) n ==> clause c) /\
	(Sub(used,unused) n UNION Unused(used,unused) n) SUBSUMES
	allntresolvents
	(Sub(used,unused) n)
	(set_of_list(used) UNION Sub(used,unused) n)`,
	let lemma1 = prove(`x INSERT s = s UNION {x}`,SET_TAC[])
	and lemma2 = prove
	(`(x INSERT s) UNION t = (s UNION (t UNION {x})) UNION (t UNION {x})`,
	SET_TAC[])
	and lemma3 = prove
	(`s UNION t = (s UNION t) UNION t`,SET_TAC[])
	and lemma4 = prove
	(`s UNION {x} = (x INSERT s) UNION {x}`,SET_TAC[])
	and lemma5 = prove
	(`(h INSERT s) UNION t = (s UNION t) UNION {h}`,SET_TAC[]) in
	REPEAT GEN_TAC THEN STRIP_TAC THEN INDUCT_TAC THENL
	[REWRITE_TAC[Sub_DEF; UNION_EMPTY] THEN
	ASM_REWRITE_TAC[Unused_DEF; given; Used_DEF; IN_SET_OF_LIST; NOT_IN_EMPTY] THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC `allresolvents {} (Used (used,unused) 0)` THEN
	ASM_REWRITE_TAC[Unused_DEF; given; Used_DEF; IN_SET_OF_LIST] THEN CONJ_TAC THENL
	[SUBGOAL_THEN `allresolvents {} (set_of_list used) = {}`
	SUBST1_TAC THENL
	[REWRITE_TAC[allresolvents; EXTENSION; IN_ELIM_THM; NOT_IN_EMPTY];
	REWRITE_TAC[SUBSUMES; NOT_IN_EMPTY]];
	MATCH_MP_TAC SUBSUMES_SUBSET THEN
	EXISTS_TAC `allntresolvents {} (set_of_list used)` THEN
	REWRITE_TAC[SUBSUMES_REFL] THEN
	SIMP_TAC[SUBSET; allntresolvents; IN_ELIM_THM]];
	ALL_TAC] THEN
	FIRST_ASSUM(UNDISCH_TAC o check is_conj o concl) THEN
	REWRITE_TAC[Sub_DEF; Unused_DEF; Used_DEF; given] THEN
	ABBREV_TAC `ppp = given n (used,unused)` THEN
	SUBST1_TAC(SYM(ISPEC `ppp:(form->bool)list#(form->bool)list` PAIR)) THEN
	ABBREV_TAC `used0 = FST(ppp:(form->bool)list#(form->bool)list)` THEN
	ABBREV_TAC `unused0 = SND(ppp:(form->bool)list#(form->bool)list)` THEN
	REWRITE_TAC[FST; SND] THEN
	ABBREV_TAC `sub0 = Sub (used,unused) n` THEN STRIP_TAC THEN
	REWRITE_TAC[step] THEN
	DISJ_CASES_THEN2 SUBST_ALL_TAC MP_TAC
	(ISPEC `unused0:(form->bool)list` list_CASES)
	THENL
	[REWRITE_TAC[] THEN ASM_REWRITE_TAC[set_of_list; NOT_IN_EMPTY];
	ALL_TAC] THEN
	DISCH_THEN(X_CHOOSE_THEN `cl:form->bool`
	(X_CHOOSE_THEN `cls:(form->bool)list`
	SUBST_ALL_TAC)) THEN
	REWRITE_TAC[NOT_CONS_NIL; HD; TL] THEN LET_TAC THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN REWRITE_TAC[FST; SND] THEN
	SUBGOAL_THEN `clause cl` ASSUME_TAC THENL
	[UNDISCH_TAC `!c. c IN set_of_list (CONS cl cls) ==> clause c` THEN
	REWRITE_TAC[set_of_list; IN_INSERT] THEN MESON_TAC[]; ALL_TAC] THEN
	CONJ_TAC THENL
	[GEN_TAC THEN REWRITE_TAC[insert_def] THEN
	COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN
	REWRITE_TAC[set_of_list; IN_INSERT] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	MATCH_MP_TAC(TAUT `b /\ a /\ c ==> a /\ b /\ c`) THEN CONJ_TAC THENL
	[REWRITE_TAC[set_of_list; IN_INSERT] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN `!c. MEM c new ==> clause c` ASSUME_TAC THENL
	[EXPAND_TAC "new" THEN REWRITE_TAC[resolvents; set_of_list] THEN
	SUBGOAL_THEN `!c. MEM c (list_of_set (allresolvents {cl}
	(cl INSERT set_of_list used0))) <=>
	c IN (allresolvents {cl} (cl INSERT set_of_list used0))`
	(fun th -> REWRITE_TAC[th])
	THENL
	[MATCH_MP_TAC MEM_LIST_OF_SET THEN
	MATCH_MP_TAC ALLRESOLVENTS_FINITE THEN
	SIMP_TAC[FINITE_RULES; FINITE_SET_OF_LIST];
	MATCH_MP_TAC ALLRESOLVENTS_CLAUSE] THEN
	ASM_SIMP_TAC[IN_INSERT; NOT_IN_EMPTY] THEN
	ASM_MESON_TAC[]; ALL_TAC] THEN
	MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL
	[REWRITE_TAC[IN_SET_OF_LIST] THEN
	UNDISCH_TAC `!c. MEM c new ==> clause c` THEN
	SPEC_TAC(`new:(form->bool)list`,`more:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST; MEM] THENL
	[UNDISCH_TAC `!c. c IN set_of_list (CONS cl cls) ==> clause c` THEN
	REWRITE_TAC[IN_SET_OF_LIST; MEM] THEN MESON_TAC[]; ALL_TAC] THEN
	ASM_MESON_TAC[INCORPORATE]; ALL_TAC] THEN
	DISCH_TAC THEN MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC
	`allntresolvents sub0 (set_of_list(used) UNION sub0) UNION
	allntresolvents {cl} (set_of_list(used) UNION sub0 UNION {cl})` THEN
	REPEAT CONJ_TAC THENL
	[REWRITE_TAC[IN_UNION; IN_INSERT; NOT_IN_EMPTY] THEN ASM_MESON_TAC[];
	ALL_TAC;
	GEN_REWRITE_TAC (RAND_CONV o ONCE_DEPTH_CONV) [lemma1] THEN
	MATCH_MP_TAC ALLNTRESOLVENTS_STEP THEN
	ASM_SIMP_TAC[IN_INSERT; NOT_IN_EMPTY]] THEN
	GEN_REWRITE_TAC LAND_CONV [lemma2] THEN
	MATCH_MP_TAC SUBSUMES_UNION THEN CONJ_TAC THENL
	[REWRITE_TAC[GSYM lemma1] THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC `sub0 UNION set_of_list(CONS (cl:form->bool) cls)` THEN
	ASM_REWRITE_TAC[] THEN CONJ_TAC THENL
	[REWRITE_TAC[IN_UNION; IN_INSERT] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	MATCH_MP_TAC SUBSUMES_UNION THEN REWRITE_TAC[SUBSUMES_REFL] THEN
	REWRITE_TAC[set_of_list] THEN ONCE_REWRITE_TAC[lemma1] THEN
	MATCH_MP_TAC SUBSUMES_UNION THEN REWRITE_TAC[SUBSUMES_REFL] THEN
	UNDISCH_TAC `!c. MEM c new ==> clause c` THEN
	UNDISCH_TAC `!c. c IN set_of_list (ITLIST (incorporate cl) new cls)
	==> clause c` THEN
	MATCH_MP_TAC(TAUT `(b ==> a /\ c) ==> a ==> b ==> c`) THEN
	SPEC_TAC(`new:(form->bool)list`,`added:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST; MEM; SUBSUMES_REFL] THENL
	[UNDISCH_TAC `!c. c IN set_of_list (CONS cl cls) ==> clause c` THEN
	REWRITE_TAC[set_of_list; IN_INSERT] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	DISCH_TAC THEN
	MP_TAC(SPECL [`cl:form->bool`; `h:form->bool`;
	`ITLIST (incorporate cl) t cls`]
	INCORPORATE) THEN
	ANTS_TAC THENL [ASM_SIMP_TAC[GSYM IN_SET_OF_LIST]; ALL_TAC] THEN
	SIMP_TAC[IN_SET_OF_LIST] THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (K ALL_TAC)) THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC `set_of_list(ITLIST (incorporate cl) t cls)` THEN
	ASM_SIMP_TAC[] THEN ASM_REWRITE_TAC[IN_SET_OF_LIST]; ALL_TAC] THEN
	REWRITE_TAC[GSYM UNION_ASSOC] THEN
	SUBGOAL_THEN `set_of_list(used:(form->bool)list) UNION sub0 =
	set_of_list(used0)`
	SUBST1_TAC THENL
	[MAP_EVERY EXPAND_TAC ["sub0"; "used0"; "ppp"] THEN
	REWRITE_TAC[GSYM Used_DEF] THEN REWRITE_TAC[USED_SUB]; ALL_TAC] THEN
	SUBGOAL_THEN
	`allntresolvents {cl} (set_of_list used0 UNION {cl}) =
	set_of_list(FILTER (\c. ~(tautologous c)) new)`
	SUBST1_TAC THENL
	[REWRITE_TAC[SET_OF_LIST_FILTER] THEN EXPAND_TAC "new" THEN
	REWRITE_TAC[resolvents] THEN
	SUBGOAL_THEN `set_of_list(list_of_set
	(allresolvents {cl}
	(set_of_list(CONS cl used0)))) =
	allresolvents {cl} (set_of_list(CONS cl used0))`
	SUBST1_TAC THENL
	[REWRITE_TAC[set_of_list] THEN
	MATCH_MP_TAC SET_OF_LIST_OF_SET THEN
	MATCH_MP_TAC ALLRESOLVENTS_FINITE THEN
	SIMP_TAC[FINITE_RULES; FINITE_SET_OF_LIST] THEN
	ASM_SIMP_TAC[IN_INSERT; NOT_IN_EMPTY] THEN
	ASM_MESON_TAC[]; ALL_TAC] THEN
	REWRITE_TAC[EXTENSION; allntresolvents; IN_ELIM_THM; set_of_list] THEN
	REWRITE_TAC[GSYM lemma1]; ALL_TAC] THEN
	UNDISCH_TAC `!c. MEM c new ==> clause c` THEN
	UNDISCH_TAC `!c. c IN set_of_list (ITLIST (incorporate cl) new cls)
	==> clause c` THEN
	MATCH_MP_TAC(TAUT `(b ==> a /\ c) ==> a ==> b ==> c`) THEN
	SPEC_TAC(`new:(form->bool)list`,`added:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST; MEM; FILTER] THENL
	[REWRITE_TAC[set_of_list; SUBSUMES; NOT_IN_EMPTY] THEN
	UNDISCH_TAC `!c. c IN set_of_list (CONS cl cls) ==> clause c` THEN
	REWRITE_TAC[set_of_list; IN_INSERT] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	DISCH_TAC THEN ASM_CASES_TAC `tautologous h` THEN ASM_SIMP_TAC[] THENL
	[MP_TAC(SPECL [`cl:form->bool`; `h:form->bool`;
	`ITLIST (incorporate cl) t cls`]
	INCORPORATE) THEN
	ANTS_TAC THENL
	[ASM_SIMP_TAC[GSYM IN_SET_OF_LIST]; ALL_TAC] THEN
	ASM_REWRITE_TAC[] THEN STRIP_TAC THEN
	ASM_REWRITE_TAC[IN_SET_OF_LIST] THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC `set_of_list (ITLIST (incorporate cl) t cls) UNION {cl}` THEN
	ASM_SIMP_TAC[SUBSUMES_UNION; SUBSUMES_REFL] THEN
	REWRITE_TAC[IN_UNION; NOT_IN_EMPTY; IN_INSERT; IN_ELIM_THM;
	IN_SET_OF_LIST] THEN ASM_MESON_TAC[]; ALL_TAC] THEN
	MP_TAC(SPECL [`cl:form->bool`; `h:form->bool`;
	`ITLIST (incorporate cl) t cls`]
	INCORPORATE) THEN
	ANTS_TAC THENL
	[ASM_SIMP_TAC[GSYM IN_SET_OF_LIST]; ALL_TAC] THEN
	ASM_REWRITE_TAC[] THEN STRIP_TAC THEN
	ASM_REWRITE_TAC[IN_SET_OF_LIST] THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC
	`set_of_list(CONS h (ITLIST (incorporate cl) t cls)) UNION {cl}` THEN
	REPEAT CONJ_TAC THENL
	[REWRITE_TAC[IN_INSERT; NOT_IN_EMPTY; IN_UNION] THEN REPEAT STRIP_TAC THEN
	ASM_SIMP_TAC[] THEN ASM_MESON_TAC[IN_SET_OF_LIST];
	GEN_REWRITE_TAC LAND_CONV [lemma4] THEN
	ASM_SIMP_TAC[SUBSUMES_UNION; SUBSUMES_REFL];
	REWRITE_TAC[set_of_list] THEN ONCE_REWRITE_TAC[lemma5] THEN
	GEN_REWRITE_TAC RAND_CONV [lemma1] THEN
	MATCH_MP_TAC SUBSUMES_UNION THEN REWRITE_TAC[SUBSUMES_REFL] THEN
	ASM_SIMP_TAC[]]);;

	(* ------------------------------------------------------------------------- *)
	(* More useful lemmas. *)
	(* ------------------------------------------------------------------------- *)

	let SUB_MONO_SUBSET = prove
	(`!init m n. m <= n ==> (Sub init m) SUBSET (Sub init n)`,
	REPEAT GEN_TAC THEN SIMP_TAC[LE_EXISTS; LEFT_IMP_EXISTS_THM] THEN
	X_GEN_TAC `d:num` THEN DISCH_THEN(K ALL_TAC) THEN
	SPEC_TAC(`d:num`,`d:num`) THEN INDUCT_TAC THEN
	REWRITE_TAC[ADD_CLAUSES; SUBSET_REFL] THEN
	REWRITE_TAC[Sub_DEF] THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN
	ASM_MESON_TAC[SUBSET_TRANS; SUBSET; IN_INSERT]);;

	let SUB_MONO = prove
	(`!init m n. m <= n ==> (Sub init n) SUBSUMES (Sub init m)`,
	MESON_TAC[SUBSUMES_SUBSET_REFL; SUB_MONO_SUBSET]);;

	let LENGTH_REPLACE = prove
	(`!cl current. LENGTH current <= LENGTH(replace cl current)`,
	GEN_TAC THEN LIST_INDUCT_TAC THEN REWRITE_TAC[replace] THEN
	REWRITE_TAC[LENGTH; LE_0] THEN
	COND_CASES_TAC THEN ASM_REWRITE_TAC[LENGTH; LE_SUC; LE_REFL]);;

	let LENGTH_INCORPORATE = prove
	(`!gcl cl current. LENGTH current <= LENGTH(incorporate gcl cl current)`,
	REPEAT GEN_TAC THEN REWRITE_TAC[incorporate] THEN
	COND_CASES_TAC THEN REWRITE_TAC[LE_REFL; LENGTH_REPLACE]);;

	let LENGTH_UNUSED_CHANGE = prove
	(`!init m n.
	LENGTH(SND(given m init)) <= LENGTH (SND(given (m + n) init)) + n`,
	GEN_REWRITE_TAC I [FORALL_PAIR_THM] THEN
	MAP_EVERY X_GEN_TAC [`used:(form->bool)list`; `unused:(form->bool)list`] THEN
	GEN_TAC THEN INDUCT_TAC THEN REWRITE_TAC[ADD_CLAUSES; LE_REFL] THEN
	REWRITE_TAC[given] THEN
	SUBST1_TAC(SYM(ISPEC `given (m + n) (used,unused)` PAIR)) THEN
	PURE_REWRITE_TAC[step] THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN
	COND_CASES_TAC THEN REWRITE_TAC[SND] THEN
	ASM_SIMP_TAC[ARITH_RULE `m <= n ==> m <= SUC n`] THEN
	MATCH_MP_TAC LE_TRANS THEN
	EXISTS_TAC `LENGTH (SND (given (m + n) (used,unused))) + n` THEN
	ASM_REWRITE_TAC[] THEN
	UNDISCH_TAC `~(SND (given (m + n) (used,unused)) = [])` THEN
	SPEC_TAC(`SND (given (m + n) (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[NOT_CONS_NIL; TL; LENGTH] THEN
	MATCH_MP_TAC(ARITH_RULE `x <= y ==> SUC x + n <= SUC(y + n)`) THEN
	SPEC_TAC(`(resolvents (HD (CONS h t))
	(CONS (HD (CONS h t)) (FST (given (m + n) (used,unused)))))`,
	`k:(form->bool)list`) THEN
	REWRITE_TAC[HD] THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST; LE_REFL] THEN
	ASM_MESON_TAC[LENGTH_INCORPORATE; LE_TRANS]);;

	let LENGTH_UNUSED_ZERO = prove
	(`!used unused m n.
	(SND (given m (used,unused)) = [])
	==> (SND (given (m + n) (used,unused)) = [])`,
	GEN_TAC THEN GEN_TAC THEN GEN_TAC THEN
	INDUCT_TAC THEN SIMP_TAC[ADD_CLAUSES] THEN
	REWRITE_TAC[given] THEN
	SUBST1_TAC(SYM(ISPEC `given (m + n) (used,unused)` PAIR)) THEN
	PURE_REWRITE_TAC[step] THEN ASM_SIMP_TAC[]);;

	let REPLACE_SUBSUMES_SELF = prove
	(`!cl current n.
	n < LENGTH current
	==> (EL n (replace cl current)) subsumes (EL n current)`,
	GEN_TAC THEN LIST_INDUCT_TAC THEN
	REWRITE_TAC[replace; LENGTH; CONJUNCT1 LT] THEN
	INDUCT_TAC THEN REWRITE_TAC[EL] THEN COND_CASES_TAC THEN
	ASM_REWRITE_TAC[HD; TL; EL; subsumes_REFL; LT_SUC]);;

	let INCORPORATE_SUBSUMES_SELF = prove
	(`!gcl cl current n.
	n < LENGTH current
	==> (EL n (incorporate gcl cl current)) subsumes (EL n current)`,
	REPEAT GEN_TAC THEN REWRITE_TAC[incorporate] THEN
	COND_CASES_TAC THEN REWRITE_TAC[subsumes_REFL; REPLACE_SUBSUMES_SELF]);;

	let REPLACE_CLAUSE = prove
	(`!cl current.
	(!c. MEM c current ==> clause c) /\ clause cl
	==> !c. MEM c (replace cl current) ==> clause c`,
	GEN_TAC THEN LIST_INDUCT_TAC THEN SIMP_TAC[replace; MEM] THEN
	STRIP_TAC THEN GEN_TAC THEN COND_CASES_TAC THEN
	REWRITE_TAC[MEM] THEN ASM_MESON_TAC[]);;

	let INCORPORATE_CLAUSE = prove
	(`(!c. MEM c current ==> clause c) /\ clause cl
	==> !c. MEM c (incorporate gcl cl current) ==> clause c`,
	REPEAT GEN_TAC THEN STRIP_TAC THEN GEN_TAC THEN REWRITE_TAC[incorporate] THEN
	COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN
	ASM_MESON_TAC[REPLACE_CLAUSE]);;

	let INCORPORATE_CLAUSE_EL = prove
	(`(!c. MEM c current ==> clause c) /\ clause cl /\ p < LENGTH current
	==> clause (EL p (incorporate gcl cl current))`,
	MESON_TAC[MEM_EL; INCORPORATE_CLAUSE; LENGTH_INCORPORATE;
	LTE_TRANS]);;

	let UNUSED_SUBSUMES_SELF = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !k m n. n + k < LENGTH(SND(given m (used,unused)))
	==> (EL n (SND(given (m + k) (used,unused))))
	subsumes (EL (n + k) (SND(given m (used,unused))))`,
	REPEAT GEN_TAC THEN STRIP_TAC THEN INDUCT_TAC THEN
	REWRITE_TAC[ADD_CLAUSES; subsumes_REFL] THEN
	REPEAT STRIP_TAC THEN
	FIRST_X_ASSUM(MP_TAC o SPECL [`SUC m`; `n:num`]) THEN
	REWRITE_TAC[ADD_CLAUSES] THEN ANTS_TAC THENL
	[MP_TAC(SPECL [`(used:(form->bool)list,unused:(form->bool)list)`;
	`m:num`; `1`] LENGTH_UNUSED_CHANGE) THEN
	REWRITE_TAC[ADD1] THEN
	MATCH_MP_TAC(ARITH_RULE
	`SUC x < lm ==> lm <= lm1 + 1 ==> x < lm1`) THEN
	ASM_REWRITE_TAC[]; ALL_TAC] THEN
	MATCH_MP_TAC(ONCE_REWRITE_RULE[TAUT
	`a /\ b /\ c ==> d <=> a /\ c ==> b ==> d`] subsumes_TRANS) THEN
	CONJ_TAC THENL
	[SUBGOAL_THEN `(EL n (SND (given (SUC (m + k)) (used,unused)))) IN
	Unused(used,unused) (SUC(m + k))`
	(fun th -> ASM_MESON_TAC[th; GIVEN_INVARIANT]) THEN
	REWRITE_TAC[Unused_DEF; IN_SET_OF_LIST] THEN
	MATCH_MP_TAC MEM_EL THEN
	MP_TAC(SPECL [`(used:(form->bool)list,unused:(form->bool)list)`;
	`m:num`; `SUC k`] LENGTH_UNUSED_CHANGE) THEN
	UNDISCH_TAC `SUC (n + k) < LENGTH (SND (given m (used,unused)))` THEN
	REWRITE_TAC[ADD_CLAUSES] THEN ARITH_TAC; ALL_TAC] THEN
	REWRITE_TAC[given] THEN
	SUBST1_TAC(SYM(ISPEC `given m (used,unused)` PAIR)) THEN
	PURE_REWRITE_TAC[step] THEN LET_TAC THEN
	COND_CASES_TAC THEN REWRITE_TAC[SND] THENL
	[UNDISCH_TAC `SUC (n + k) < LENGTH (SND (given m (used,unused)))` THEN
	ASM_REWRITE_TAC[LENGTH; LT]; ALL_TAC] THEN
	UNDISCH_TAC `SUC (n + k) < LENGTH (SND (given m (used,unused)))` THEN
	SUBGOAL_THEN `!c. MEM c (SND (given m (used,unused))) ==> clause c`
	MP_TAC THENL
	[REWRITE_TAC[GSYM IN_SET_OF_LIST; GSYM Unused_DEF] THEN
	ASM_MESON_TAC[GIVEN_INVARIANT]; ALL_TAC] THEN
	SUBGOAL_THEN `!c. MEM c new ==> clause c` MP_TAC THENL
	[EXPAND_TAC "new" THEN REWRITE_TAC[resolvents; set_of_list] THEN
	ABBREV_TAC `gcl = HD (SND (given m (used,unused)))` THEN
	REWRITE_TAC[GSYM Used_DEF] THEN
	SUBGOAL_THEN `!c. MEM c (list_of_set (allresolvents {gcl}
	(gcl INSERT Used (used,unused) m))) <=>
	c IN (allresolvents {gcl}
	(gcl INSERT Used (used,unused) m))`
	(fun th -> REWRITE_TAC[th])
	THENL
	[MATCH_MP_TAC MEM_LIST_OF_SET THEN
	MATCH_MP_TAC ALLRESOLVENTS_FINITE THEN
	SIMP_TAC[FINITE_RULES; FINITE_SET_OF_LIST] THEN
	ASM_SIMP_TAC[IN_INSERT; NOT_IN_EMPTY] THEN
	REWRITE_TAC[FINITE_INSERT] THEN
	REWRITE_TAC[Used_DEF; FINITE_SET_OF_LIST] THEN
	REWRITE_TAC[GSYM Used_DEF];
	MATCH_MP_TAC ALLRESOLVENTS_CLAUSE THEN
	ASM_SIMP_TAC[IN_INSERT; NOT_IN_EMPTY]] THEN
	SUBGOAL_THEN `clause gcl`
	(fun th -> ASM_MESON_TAC[th; GIVEN_INVARIANT]) THEN
	SUBGOAL_THEN `gcl IN Unused(used,unused) m`
	(fun th -> ASM_MESON_TAC[th; GIVEN_INVARIANT]) THEN
	REWRITE_TAC[Unused_DEF; IN_SET_OF_LIST] THEN
	EXPAND_TAC "gcl" THEN
	UNDISCH_TAC `~(SND(given m (used,unused)) = [])` THEN
	SPEC_TAC(`SND(given m (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; HD]; ALL_TAC] THEN
	DISCH_TAC THEN
	UNDISCH_TAC `~(SND (given m (used,unused)) = [])` THEN
	SPEC_TAC(`SND(given m (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[NOT_CONS_NIL; EL; HD; TL] THEN
	REWRITE_TAC[LENGTH; LT_SUC] THEN
	UNDISCH_TAC `!c. MEM c new ==> clause c` THEN
	SPEC_TAC(`n + k:num`,`p:num`) THEN
	SPEC_TAC(`new:(form->bool)list`,`new:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST; subsumes_REFL] THEN
	X_GEN_TAC `p:num` THEN REPEAT STRIP_TAC THEN
	FIRST_X_ASSUM(MP_TAC o SPEC `p:num`) THEN
	ASM_REWRITE_TAC[] THEN
	ANTS_TAC THENL [ASM_MESON_TAC[MEM]; ALL_TAC] THEN
	MATCH_MP_TAC(ONCE_REWRITE_RULE[TAUT
	`a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] subsumes_TRANS) THEN
	CONJ_TAC THENL
	[ALL_TAC;
	MATCH_MP_TAC INCORPORATE_SUBSUMES_SELF THEN
	UNDISCH_TAC `p < LENGTH(t:(form->bool)list)` THEN
	SPEC_TAC(`t':(form->bool)list`,`k:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[ITLIST] THEN
	ASM_MESON_TAC[LENGTH_INCORPORATE; LTE_TRANS]] THEN
	MATCH_MP_TAC INCORPORATE_CLAUSE_EL THEN
	CONJ_TAC THENL
	[ALL_TAC;
	CONJ_TAC THENL [ASM_MESON_TAC[MEM]; ALL_TAC] THEN
	SUBGOAL_THEN
	`!gcl current lis.
	LENGTH(current) <= LENGTH(ITLIST (incorporate gcl) lis current)`
	(fun th -> ASM_MESON_TAC[LTE_TRANS; th]) THEN
	GEN_TAC THEN GEN_TAC THEN LIST_INDUCT_TAC THEN
	REWRITE_TAC[ITLIST; LE_REFL] THEN
	ASM_MESON_TAC[LE_TRANS; LENGTH_INCORPORATE]] THEN
	SUBGOAL_THEN
	`!current gcl new.
	(!c. MEM c current ==> clause c) /\
	(!c. MEM c new ==> clause c)
	==> !c. MEM c (ITLIST (incorporate gcl) new current)
	==> clause c`
	MATCH_MP_TAC THENL [ALL_TAC; ASM_MESON_TAC[MEM]] THEN
	POP_ASSUM_LIST(K ALL_TAC) THEN
	GEN_TAC THEN GEN_TAC THEN LIST_INDUCT_TAC THEN
	REWRITE_TAC[ITLIST; MEM] THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN
	ASM_MESON_TAC[INCORPORATE_CLAUSE]);;

	let SUB_SUBSUMES_UNUSED = prove
	(`(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !n. Sub(used,unused)
	(n + LENGTH(SND(given n (used,unused))))
	SUBSUMES (Sub (used,unused) n UNION Unused(used,unused) n)`,
	let lemma = prove(`x INSERT s = {x} UNION s`,SET_TAC[]) in
	REPEAT GEN_TAC THEN STRIP_TAC THEN
	SUBGOAL_THEN
	`!m n. Sub(used,unused) (m + n) SUBSUMES
	Sub(used,unused) m UNION
	set_of_list(FIRSTN n (SND(given m (used,unused))))`
	MP_TAC THENL
	[ALL_TAC; ASM_MESON_TAC[LE_REFL; FIRSTN_TRIVIAL; Unused_DEF]] THEN
	GEN_TAC THEN INDUCT_TAC THEN REWRITE_TAC[ADD_CLAUSES] THENL
	[REWRITE_TAC[FIRSTN; set_of_list; UNION_EMPTY; SUBSUMES_REFL]; ALL_TAC] THEN
	REWRITE_TAC[Sub_DEF] THEN COND_CASES_TAC THENL
	[SUBGOAL_THEN `FIRSTN (SUC n) (SND(given m (used,unused))) =
	FIRSTN n (SND(given m (used,unused)))`
	(fun th -> ASM_REWRITE_TAC[th]) THEN
	SUBGOAL_THEN `LENGTH(SND (given m (used,unused))) <= n`
	(fun th -> MESON_TAC[th; FIRSTN_TRIVIAL; LE_REFL;
	ARITH_RULE `x <= n ==> x <= SUC n`]) THEN
	MATCH_MP_TAC LE_TRANS THEN
	EXISTS_TAC `LENGTH(SND (given (m + n) (used,unused))) + n` THEN
	ASM_REWRITE_TAC[LENGTH_UNUSED_CHANGE; LENGTH; ADD_CLAUSES; LE_REFL];
	ALL_TAC] THEN
	REWRITE_TAC[FIRSTN] THEN COND_CASES_TAC THENL
	[ASM_MESON_TAC[LENGTH_UNUSED_ZERO]; ALL_TAC] THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC
	`HD(SND (given (m + n) (used,unused))) INSERT
	(Sub (used,unused) m UNION
	set_of_list (FIRSTN n (SND (given m (used,unused)))))` THEN
	CONJ_TAC THENL
	[REWRITE_TAC[IN_INSERT] THEN
	SUBGOAL_THEN
	`HD(SND(given (m + n) (used,unused))) IN Unused (used,unused) (m + n)`
	MP_TAC THENL
	[ALL_TAC; ASM_MESON_TAC[GIVEN_INVARIANT]] THEN
	UNDISCH_TAC `~(SND(given (m + n) (used,unused)) = [])` THEN
	REWRITE_TAC[Unused_DEF; IN_SET_OF_LIST] THEN
	SPEC_TAC(`SND(given(m + n) (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; HD]; ALL_TAC] THEN
	CONJ_TAC THENL
	[ONCE_REWRITE_TAC[lemma] THEN MATCH_MP_TAC SUBSUMES_UNION THEN
	ASM_REWRITE_TAC[SUBSUMES_REFL]; ALL_TAC] THEN
	REWRITE_TAC[set_of_list] THEN ONCE_REWRITE_TAC[lemma] THEN
	GEN_REWRITE_TAC LAND_CONV [AC UNION_ACI
	`s UNION t UNION u = t UNION u UNION s`] THEN
	MATCH_MP_TAC SUBSUMES_UNION THEN ASM_REWRITE_TAC[SUBSUMES_REFL] THEN
	SUBGOAL_THEN
	`{(HD (SND (given m (used,unused))))} UNION
	set_of_list(FIRSTN n (TL (SND (given m (used,unused))))) =
	set_of_list(FIRSTN (SUC n) (SND (given m (used,unused))))`
	SUBST1_TAC THENL
	[ASM_REWRITE_TAC[FIRSTN] THEN
	UNDISCH_TAC `~(SND (given m (used,unused)) = [])` THEN
	REWRITE_TAC[set_of_list] THEN SET_TAC[]; ALL_TAC] THEN
	ASM_CASES_TAC
	`LENGTH(SND (given m (used,unused))) <= n`
	THENL
	[ASM_SIMP_TAC[FIRSTN_SHORT] THEN
	MATCH_MP_TAC SUBSUMES_SUBSET THEN
	EXISTS_TAC `set_of_list(FIRSTN n (SND (given m (used,unused))))` THEN
	REWRITE_TAC[SUBSUMES_REFL] THEN SIMP_TAC[SUBSET; IN_UNION]; ALL_TAC] THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC
	`set_of_list(FIRSTN n (SND (given m (used,unused)))) UNION
	{(EL n (SND (given m (used,unused))))}` THEN
	CONJ_TAC THENL
	[REWRITE_TAC[IN_UNION; IN_INSERT; NOT_IN_EMPTY] THEN
	REWRITE_TAC[GSYM Unused_DEF] THEN
	REWRITE_TAC[IN_SET_OF_LIST] THEN
	X_GEN_TAC `c:form->bool` THEN DISCH_THEN(DISJ_CASES_THEN MP_TAC) THENL
	[DISCH_THEN(MP_TAC o MATCH_MP FIRSTN_SUBLIST) THEN
	REWRITE_TAC[GSYM IN_SET_OF_LIST; GSYM Unused_DEF] THEN
	ASM_MESON_TAC[GIVEN_INVARIANT]; ALL_TAC] THEN
	DISCH_THEN SUBST1_TAC THEN
	SUBGOAL_THEN
	`(HD(SND (given (m + n) (used,unused)))) IN
	Unused(used,unused) (m + n)`
	(fun th -> ASM_MESON_TAC[th; GIVEN_INVARIANT]) THEN
	REWRITE_TAC[Unused_DEF; IN_SET_OF_LIST] THEN
	UNDISCH_TAC `~(SND (given (m + n) (used,unused)) = [])` THEN
	SPEC_TAC(`SND (given (m + n) (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; HD]; ALL_TAC] THEN
	CONJ_TAC THENL
	[ALL_TAC;
	MATCH_MP_TAC SUBSUMES_SUBSET THEN
	EXISTS_TAC `set_of_list (FIRSTN (SUC n) (SND (given m (used,unused))))` THEN
	REWRITE_TAC[SUBSUMES_REFL] THEN
	MP_TAC(GEN `x:form->bool`
	(ISPECL [`x:form->bool`; `n:num`; `SND (given m (used,unused))`]
	FIRSTN_SUC)) THEN
	REWRITE_TAC[GSYM IN_SET_OF_LIST; SET_OF_LIST_APPEND; set_of_list] THEN
	REWRITE_TAC[SUBSET; IN_UNION; IN_INSERT; NOT_IN_EMPTY]] THEN
	MATCH_MP_TAC SUBSUMES_UNION THEN REWRITE_TAC[SUBSUMES_REFL] THEN
	REWRITE_TAC[SUBSUMES; IN_INSERT; NOT_IN_EMPTY] THEN
	SUBGOAL_THEN
	`HD(SND(given (m + n) (used,unused))) subsumes
	(EL n (SND (given m (used,unused))))`
	(fun th -> MESON_TAC[th]) THEN
	GEN_REWRITE_TAC LAND_CONV [GSYM(CONJUNCT1 EL)] THEN
	GEN_REWRITE_TAC (RAND_CONV o LAND_CONV) [ARITH_RULE `n = 0 + n`] THEN
	MP_TAC(SPECL [`used:(form->bool)list`; `unused:(form->bool)list`]
	UNUSED_SUBSUMES_SELF) THEN
	ASM_REWRITE_TAC[] THEN DISCH_THEN MATCH_MP_TAC THEN
	UNDISCH_TAC `~(LENGTH (SND (given m (used,unused))) <= n)` THEN
	ARITH_TAC);;

	(* ------------------------------------------------------------------------- *)
	(* Separation into levels. *)
	(* ------------------------------------------------------------------------- *)

	let break = new_recursive_definition num_RECURSION
	`(break init 0 = LENGTH(SND(given 0 init))) /\
	(break init (SUC n) =
	break init n + LENGTH(SND(given (break init n) init)))`;;

	let level = new_definition
	`level init n = Sub init (break init n)`;;

	let LEVEL_0 = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> level(used,unused) 0 SUBSUMES set_of_list(unused)`,
	REPEAT GEN_TAC THEN DISCH_TAC THEN
	FIRST_ASSUM(MP_TAC o MATCH_MP SUB_SUBSUMES_UNUSED) THEN
	DISCH_THEN(MP_TAC o SPEC `0`) THEN
	REWRITE_TAC[ADD_CLAUSES; Sub_DEF; UNION_EMPTY] THEN
	REWRITE_TAC[Unused_DEF; given; level; Sub_DEF; break]);;

	let LEVEL_STEP = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !n. level(used,unused) (SUC n) SUBSUMES
	allntresolvents (level(used,unused) (n))
	(set_of_list(used) UNION
	level(used,unused) (n))`,
	REPEAT STRIP_TAC THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC `Sub(used,unused) (break(used,unused) n) UNION
	Unused(used,unused) (break(used,unused) n)` THEN
	REWRITE_TAC[level] THEN
	REPEAT CONJ_TAC THENL
	[ASM_MESON_TAC[GIVEN_INVARIANT];
	ALL_TAC;
	ASM_MESON_TAC[GIVEN_INVARIANT]] THEN
	REWRITE_TAC[break] THEN
	ASM_SIMP_TAC[SUB_SUBSUMES_UNUSED]);;

	let level_CLAUSE = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !n c. c IN (level(used,unused) n) ==> clause c`,
	REWRITE_TAC[level] THEN MESON_TAC[GIVEN_INVARIANT]);;

	let BREAK_MONO = prove
	(`!init m n. m <= n ==> break init m <= break init n`,
	SUBGOAL_THEN `!init m d. break init m <= break init (m + d)`
	(fun th -> MESON_TAC[th; LE_EXISTS]) THEN
	GEN_TAC THEN GEN_TAC THEN INDUCT_TAC THEN
	REWRITE_TAC[ADD_CLAUSES; break; LE_REFL] THEN
	ASM_MESON_TAC[LE_TRANS; LE_ADD]);;

	let level_MONO_SUBSET = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !m n. m <= n
	==> level(used,unused) m SUBSET level(used,unused) n`,
	REWRITE_TAC[level] THEN MESON_TAC[SUB_MONO_SUBSET; BREAK_MONO]);;

	let level_MONO = prove
	(`!used unused.
	(!c. MEM c used ==> clause c) /\
	(!c. MEM c unused ==> clause c)
	==> !m n. m <= n
	==> level(used,unused) n SUBSUMES level(used,unused) m`,
	REWRITE_TAC[level] THEN MESON_TAC[SUB_MONO; BREAK_MONO]);;

	(* ------------------------------------------------------------------------- *)
	(* Show how subsumption propagates through resolvents. *)
	(* ------------------------------------------------------------------------- *)

	let IMAGE_CLAUSE_EQ = prove
	(`clause p /\ (!q. qfree(q) ==> (f q = g q))
	==> (IMAGE f p = IMAGE g p)`,
	REWRITE_TAC[clause; EXTENSION; IN_IMAGE] THEN
	MESON_TAC[QFREE_LITERAL]);;

	let FORMSUBST_TERMSUBST_EQ = prove
	(`(!p. qfree(p) ==> (formsubst i p = formsubst j p)) <=>
	(termsubst i = termsubst j)`,
	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 ISARESOLVENT_SUBSUME_L = prove
	(`!p p' q r.
	clause p /\ clause p' /\ clause q /\
	p' subsumes p /\ isaresolvent r (p,q)
	==> p' subsumes r \/ ?r'. isaresolvent r' (p',q) /\ r' subsumes r`,
	let lemma = prove
	(`a SUBSET a' /\ b SUBSET b' ==> (a UNION b) SUBSET (a' UNION b')`,
	SET_TAC[]) in
	REPEAT STRIP_TAC THEN
	UNDISCH_TAC `isaresolvent r (p,q)` THEN
	GEN_REWRITE_TAC LAND_CONV [isaresolvent] THEN
	ABBREV_TAC `q' = IMAGE (formsubst (rename q (FVS p))) q` THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN
	MAP_EVERY X_GEN_TAC [`p1:form->bool`; `q1':form->bool`] THEN
	REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN
	LET_TAC THEN DISCH_THEN(ASSUME_TAC o SYM) THEN
	ABBREV_TAC `ri = rename q (FVS p)` THEN
	UNDISCH_TAC `p' subsumes p` THEN REWRITE_TAC[subsumes] THEN
	DISCH_THEN(X_CHOOSE_TAC `j:num->term`) THEN
	ASM_CASES_TAC `(IMAGE (formsubst j) p') INTER p1 = {}` THENL
	[DISJ1_TAC THEN EXISTS_TAC `termsubst i o (j:num->term)` THEN
	SUBGOAL_THEN
	`IMAGE (formsubst (termsubst i o j)) p' =
	IMAGE (formsubst i o formsubst j) p'`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; o_THM] THEN
	ASM_MESON_TAC[FORMSUBST_FORMSUBST; clause; QFREE_LITERAL]; ALL_TAC] THEN
	REWRITE_TAC[IMAGE_o] THEN
	EXPAND_TAC "r" THEN
	MATCH_MP_TAC IMAGE_SUBSET THEN MATCH_MP_TAC SUBSET_TRANS THEN
	EXISTS_TAC `(p:form->bool) DIFF p1` THEN
	CONJ_TAC THENL [ALL_TAC; SET_TAC[]] THEN
	UNDISCH_TAC `IMAGE (formsubst j) p' SUBSET p` THEN
	UNDISCH_TAC `IMAGE (formsubst j) p' INTER p1 = {}` THEN
	REWRITE_TAC[SUBSET; EXTENSION; IN_DIFF; IN_INTER; NOT_IN_EMPTY] THEN
	MESON_TAC[]; ALL_TAC] THEN
	DISJ2_TAC THEN
	ABBREV_TAC `p1' = {x \| x IN p' /\ (formsubst j x IN p1)}` THEN
	SUBGOAL_THEN `(IMAGE (formsubst j) p1') SUBSET p1 /\ ~(p1' = {})`
	STRIP_ASSUME_TAC THENL
	[EXPAND_TAC "p1'" THEN
	UNDISCH_TAC `~(p1:form->bool = {})` THEN
	UNDISCH_TAC `IMAGE (formsubst j) p' SUBSET p` THEN
	UNDISCH_TAC `~(IMAGE (formsubst j) p' INTER p1 = {})` THEN
	REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM; SUBSET;
	IN_INTER; NOT_IN_EMPTY] THEN
	MESON_TAC[]; ALL_TAC] THEN
	ABBREV_TAC `si = rename q (FVS p')` THEN
	ABBREV_TAC `q'' = IMAGE (formsubst si) q` THEN
	MP_TAC(SPECL [`q:form->bool`; `FVS(p)`] rename) THEN
	ASM_SIMP_TAC[FVS_CLAUSE_FINITE] THEN
	DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN
	REWRITE_TAC[renaming] THEN
	DISCH_THEN(X_CHOOSE_THEN `ri':num->term` MP_TAC) THEN
	REWRITE_TAC[FUN_EQ_THM; I_DEF; o_THM] THEN STRIP_TAC THEN
	MP_TAC(SPECL [`q:form->bool`; `FVS(p')`] rename) THEN
	ASM_SIMP_TAC[FVS_CLAUSE_FINITE] THEN
	DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN
	REWRITE_TAC[renaming] THEN
	DISCH_THEN(X_CHOOSE_THEN `si':num->term` MP_TAC) THEN
	REWRITE_TAC[FUN_EQ_THM; I_DEF; o_THM] THEN STRIP_TAC THEN
	ABBREV_TAC `q1'' = IMAGE (formsubst si o formsubst ri') q1'` THEN
	SUBGOAL_THEN `(q1'':form->bool) SUBSET q''` ASSUME_TAC THENL
	[MAP_EVERY EXPAND_TAC ["q''"; "q1''"] THEN
	UNDISCH_TAC `q1':form->bool SUBSET q'` THEN EXPAND_TAC "q'" THEN
	DISCH_THEN(MP_TAC o ISPEC `formsubst si o formsubst ri'` o
	MATCH_MP IMAGE_SUBSET) THEN
	MATCH_MP_TAC EQ_IMP THEN AP_TERM_TAC THEN
	REWRITE_TAC[GSYM IMAGE_o] THEN
	MATCH_MP_TAC IMAGE_CLAUSE_EQ THEN ASM_REWRITE_TAC[] THEN
	SIMP_TAC[o_THM; FORMSUBST_FORMSUBST] THEN
	REWRITE_TAC[FORMSUBST_TERMSUBST_EQ] THEN
	REWRITE_TAC[FUN_EQ_THM; GSYM TERMSUBST_TERMSUBST] THEN
	ASM_REWRITE_TAC[]; ALL_TAC] THEN
	ABBREV_TAC `i' = \x. if x IN FVS(q'')
	then termsubst i (termsubst ri (si' x))
	else termsubst i (j x)` THEN
	SUBGOAL_THEN `Unifies i' (p1' UNION {~~p \| p IN q1''})` ASSUME_TAC THENL
	[UNDISCH_THEN
	`(\x. if x IN FVS q''
	then termsubst i (termsubst ri (si' x))
	else termsubst i (j x)) =
	i'` (SUBST_ALL_TAC o SYM) THEN
	MP_TAC(SPEC `p1 UNION {~~ p \| p IN q1'}` MGU) THEN
	ANTS_TAC THENL
	[ASM_REWRITE_TAC[FINITE_UNION] THEN
	SUBGOAL_THEN `{~~p \| p IN q1'} = IMAGE (~~) q1'` SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM] THEN MESON_TAC[];
	ALL_TAC] THEN
	CONJ_TAC THENL
	[ASM_MESON_TAC[FINITE_SUBSET; clause; IMAGE_FORMSUBST_CLAUSE;
	FINITE_IMAGE];
	REWRITE_TAC[IN_UNION; IN_IMAGE] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_NEGATE] THEN
	ASM_MESON_TAC[clause; SUBSET; QFREE_LITERAL;
	IMAGE_FORMSUBST_CLAUSE]];
	ALL_TAC] THEN
	DISCH_THEN(MP_TAC o CONJUNCT1) THEN ASM_REWRITE_TAC[UNIFIES] THEN
	MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `P:form` THEN
	REWRITE_TAC[IN_UNION] THEN
	REWRITE_TAC[TAUT `(a \/ b ==> c) <=> (a ==> c) /\ (b ==> c)`] THEN
	REWRITE_TAC[FORALL_AND_THM] THEN
	MATCH_MP_TAC(TAUT `(a ==> a') /\ (b ==> b') ==> a /\ b ==> a' /\ b'`) THEN
	CONJ_TAC THEN DISCH_TAC THENL
	[X_GEN_TAC `x:form` THEN EXPAND_TAC "p1'" THEN
	REWRITE_TAC[IN_ELIM_THM] THEN STRIP_TAC THEN
	MATCH_MP_TAC EQ_TRANS THEN
	EXISTS_TAC `formsubst (termsubst i o j) x` THEN CONJ_TAC THENL
	[ALL_TAC;
	SUBGOAL_THEN `qfree x` MP_TAC THENL
	[ASM_MESON_TAC[clause; QFREE_LITERAL]; ALL_TAC] THEN
	SIMP_TAC[GSYM FORMSUBST_FORMSUBST] THEN ASM_SIMP_TAC[]] THEN
	MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `z:num` THEN DISCH_TAC THEN REWRITE_TAC[] THEN
	SUBGOAL_THEN `~(z IN FVS q'')`
	(fun th -> REWRITE_TAC[th; o_THM]) THEN
	UNDISCH_TAC `FVS q'' INTER FVS p' = {}` THEN
	REWRITE_TAC[EXTENSION; IN_INTER; NOT_IN_EMPTY] THEN
	DISCH_THEN(MP_TAC o SPEC `z:num`) THEN
	MATCH_MP_TAC(TAUT `b ==> ~(a /\ b) ==> ~a`) THEN
	REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN ASM_MESON_TAC[];
	ALL_TAC] THEN
	X_GEN_TAC `x:form` THEN REWRITE_TAC[IN_ELIM_THM; LEFT_IMP_EXISTS_THM] THEN
	X_GEN_TAC `y:form` THEN
	DISCH_THEN(CONJUNCTS_THEN2 MP_TAC SUBST_ALL_TAC) THEN
	EXPAND_TAC "q1''" THEN REWRITE_TAC[IN_IMAGE; LEFT_IMP_EXISTS_THM] THEN
	X_GEN_TAC `u:form` THEN
	DISCH_THEN(CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC) THEN DISCH_TAC THEN
	REWRITE_TAC[FORMSUBST_NEGATE] THEN
	SUBGOAL_THEN `formsubst i (~~u) = P` (SUBST1_TAC o SYM) THENL
	[FIRST_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_ELIM_THM] THEN
	ASM_MESON_TAC[]; ALL_TAC] THEN
	REWRITE_TAC[FORMSUBST_NEGATE] THEN AP_TERM_TAC THEN
	REWRITE_TAC[o_THM] THEN
	SUBGOAL_THEN `qfree u` ASSUME_TAC THENL
	[ASM_MESON_TAC[SUBSET; clause; IMAGE_FORMSUBST_CLAUSE; QFREE_LITERAL];
	ALL_TAC] THEN
	MATCH_MP_TAC EQ_TRANS THEN
	EXISTS_TAC `formsubst (termsubst i o termsubst ri o si')
	(formsubst si (formsubst ri' u))` THEN
	CONJ_TAC THENL
	[ALL_TAC;
	ASM_SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	UNDISCH_TAC `qfree u` THEN SPEC_TAC(`u:form`,`u:form`) THEN
	ONCE_REWRITE_TAC[FORMSUBST_TERMSUBST_EQ] THEN
	REWRITE_TAC[o_ASSOC] THEN REWRITE_TAC[GSYM TERMSUBST_TERMSUBST_o] THEN
	REWRITE_TAC[TERMSUBST_TERMSUBST_o] THEN
	ASM_REWRITE_TAC[FUN_EQ_THM; o_THM]] THEN
	MATCH_MP_TAC FORMSUBST_VALUATION THEN X_GEN_TAC `z:num` THEN
	DISCH_TAC THEN REWRITE_TAC[o_THM] THEN
	SUBGOAL_THEN `z IN FVS q''` (fun th -> REWRITE_TAC[th]) THEN
	SUBGOAL_THEN `(formsubst si (formsubst ri' u)) IN q''` MP_TAC THENL
	[ALL_TAC;
	REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN ASM_MESON_TAC[]] THEN
	EXPAND_TAC "q''" THEN REWRITE_TAC[IN_IMAGE] THEN
	EXISTS_TAC `formsubst ri' u` THEN REWRITE_TAC[] THEN
	SUBGOAL_THEN `u:form IN q'` MP_TAC THENL
	[ASM_MESON_TAC[SUBSET]; ALL_TAC] THEN
	EXPAND_TAC "q'" THEN REWRITE_TAC[IN_IMAGE] THEN
	DISCH_THEN(X_CHOOSE_THEN `x:form` STRIP_ASSUME_TAC) THEN
	ASM_REWRITE_TAC[] THEN
	SUBGOAL_THEN `formsubst ri' (formsubst ri x) = formsubst V x`
	(fun th -> ASM_REWRITE_TAC[th; FORMSUBST_TRIV]) THEN
	SUBGOAL_THEN `qfree x` MP_TAC THENL
	[ASM_MESON_TAC[clause; QFREE_LITERAL]; ALL_TAC] THEN
	SPEC_TAC(`x:form`,`x:form`) THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	ONCE_REWRITE_TAC[FORMSUBST_TERMSUBST_EQ] THEN
	ASM_REWRITE_TAC[FUN_EQ_THM; GSYM TERMSUBST_TERMSUBST; TERMSUBST_TRIV];
	ALL_TAC] THEN
	MP_TAC(SPEC `p1' UNION {~~p \| p IN q1''}` MGU) THEN
	ANTS_TAC THENL
	[REWRITE_TAC[CONJ_ASSOC] THEN
	CONJ_TAC THENL
	[ALL_TAC; EXISTS_TAC `i':num->term` THEN ASM_REWRITE_TAC[]] THEN
	ASM_REWRITE_TAC[FINITE_UNION] THEN
	SUBGOAL_THEN `{~~p \| p IN q1''} = IMAGE (~~) q1''` SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM] THEN MESON_TAC[];
	ALL_TAC] THEN
	CONJ_TAC THENL
	[CONJ_TAC THENL
	[ALL_TAC;
	ASM_MESON_TAC[FINITE_SUBSET; clause; IMAGE_FORMSUBST_CLAUSE;
	IMAGE_o; FINITE_IMAGE]] THEN
	SUBGOAL_THEN `p1':form->bool SUBSET p'`
	(fun th ->
	ASM_MESON_TAC[th; FINITE_SUBSET; clause; QFREE_LITERAL]) THEN
	EXPAND_TAC "p1'" THEN SIMP_TAC[SUBSET; IN_ELIM_THM];
	ALL_TAC] THEN
	EXPAND_TAC "p1'" THEN REWRITE_TAC[IN_UNION; IN_IMAGE; IN_ELIM_THM] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_NEGATE] THEN
	ASM_MESON_TAC[clause; SUBSET; QFREE_LITERAL;
	IMAGE_FORMSUBST_CLAUSE];
	ALL_TAC] THEN
	ABBREV_TAC `k = mgu (p1' UNION {~~p \| p IN q1''})` THEN STRIP_TAC THEN
	EXISTS_TAC `IMAGE (formsubst k) ((p' DIFF p1') UNION (q'' DIFF q1''))` THEN
	CONJ_TAC THENL
	[ASM_REWRITE_TAC[isaresolvent] THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN
	MAP_EVERY EXISTS_TAC [`p1':form->bool`; `q1'':form->bool`] THEN
	ASM_REWRITE_TAC[] THEN CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN
	REWRITE_TAC[] THEN REPEAT CONJ_TAC THENL
	[EXPAND_TAC "p1'" THEN SIMP_TAC[IN_ELIM_THM; SUBSET];
	EXPAND_TAC "q1''" THEN UNDISCH_TAC `~(q1':form->bool = {})` THEN
	REWRITE_TAC[EXTENSION; NOT_IN_EMPTY; IN_IMAGE] THEN MESON_TAC[];
	EXISTS_TAC `i':num->term` THEN ASM_REWRITE_TAC[]];
	ALL_TAC] THEN
	EXPAND_TAC "r" THEN EXISTS_TAC `i':num->term` THEN
	REWRITE_TAC[GSYM IMAGE_o] THEN
	MATCH_MP_TAC SUBSET_TRANS THEN
	EXISTS_TAC `IMAGE (formsubst i') (p' DIFF p1' UNION q'' DIFF q1'')` THEN
	CONJ_TAC THENL
	[FIRST_X_ASSUM(MP_TAC o SPEC `i':num->term`) THEN ASM_REWRITE_TAC[] THEN
	SUBGOAL_THEN `!x. x IN (p' DIFF p1' UNION q'' DIFF q1'') ==> qfree x`
	(fun th -> REWRITE_TAC[SUBSET; IN_IMAGE; o_THM] THEN MESON_TAC[th]) THEN
	REWRITE_TAC[IN_DIFF; IN_UNION] THEN
	ASM_MESON_TAC[IMAGE_FORMSUBST_CLAUSE; clause; QFREE_LITERAL]; ALL_TAC] THEN
	REWRITE_TAC[IMAGE_UNION] THEN MATCH_MP_TAC lemma THEN CONJ_TAC THENL
	[SUBGOAL_THEN `IMAGE (formsubst i') (p' DIFF p1') =
	IMAGE (formsubst (termsubst i o j)) (p' DIFF p1')`
	SUBST1_TAC THENL
	[SUBGOAL_THEN
	`!x. x IN p' ==> (formsubst i' x = formsubst (termsubst i o j) x)`
	(fun th -> REWRITE_TAC[EXTENSION; IN_IMAGE; IN_DIFF] THEN
	MESON_TAC[th]) THEN
	X_GEN_TAC `x:form` THEN
	DISCH_TAC THEN MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `z:num` THEN DISCH_TAC THEN EXPAND_TAC "i'" THEN
	SUBGOAL_THEN `~(z IN FVS q'')` (fun th -> REWRITE_TAC[th; o_THM]) THEN
	UNDISCH_TAC `FVS q'' INTER FVS p' = {}` THEN
	REWRITE_TAC[EXTENSION; IN_INTER; NOT_IN_EMPTY] THEN
	DISCH_THEN(MP_TAC o SPEC `z:num`) THEN
	MATCH_MP_TAC(TAUT `b ==> ~(a /\ b) ==> ~a`) THEN
	REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN ASM_MESON_TAC[];
	ALL_TAC] THEN
	SUBGOAL_THEN `IMAGE (formsubst (termsubst i o j)) (p' DIFF p1') =
	IMAGE (formsubst i o formsubst j) (p' DIFF p1')`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; IN_DIFF; o_THM] THEN
	ASM_MESON_TAC[FORMSUBST_FORMSUBST; clause; QFREE_LITERAL]; ALL_TAC] THEN
	EXPAND_TAC "p1'" THEN UNDISCH_TAC `IMAGE (formsubst j) p' SUBSET p` THEN
	REWRITE_TAC[SUBSET; IN_IMAGE; IN_DIFF; IN_ELIM_THM; o_THM] THEN
	MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN
	`IMAGE (formsubst i') (q'' DIFF q1'') =
	IMAGE (formsubst (termsubst i o termsubst ri o si')) (q'' DIFF q1'')`
	SUBST1_TAC THENL
	[SUBGOAL_THEN
	`!x. x IN q''
	==> (formsubst i' x = formsubst (termsubst i o termsubst ri o si') x)`
	(fun th -> REWRITE_TAC[EXTENSION; IN_IMAGE; IN_DIFF] THEN
	MESON_TAC[th]) THEN
	X_GEN_TAC `x:form` THEN
	DISCH_TAC THEN MATCH_MP_TAC FORMSUBST_VALUATION THEN
	X_GEN_TAC `z:num` THEN DISCH_TAC THEN EXPAND_TAC "i'" THEN
	SUBGOAL_THEN `z IN FVS q''` (fun th -> REWRITE_TAC[th; o_THM]) THEN
	REWRITE_TAC[FVS; IN_UNIONS; IN_ELIM_THM] THEN ASM_MESON_TAC[];
	ALL_TAC] THEN
	SUBGOAL_THEN
	`IMAGE (formsubst (termsubst i o termsubst ri o si')) (q'' DIFF q1'') =
	IMAGE (formsubst i o formsubst ri o formsubst si') (q'' DIFF q1'')`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE] THEN
	SUBGOAL_THEN
	`(!q. qfree q ==> (formsubst (termsubst i o termsubst ri o si') q =
	(formsubst i o formsubst ri o formsubst si') q)) /\
	(!q. q IN (q'' DIFF q1'') ==> qfree q)`
	(fun th -> MESON_TAC[th]) THEN
	CONJ_TAC THENL
	[SIMP_TAC[o_THM; FORMSUBST_FORMSUBST] THEN
	ONCE_REWRITE_TAC[FORMSUBST_TERMSUBST_EQ] THEN
	REWRITE_TAC[o_ASSOC] THEN REWRITE_TAC[GSYM TERMSUBST_TERMSUBST_o] THEN
	REWRITE_TAC[TERMSUBST_TERMSUBST_o];
	ALL_TAC] THEN
	ASM_MESON_TAC[IN_DIFF; IMAGE_FORMSUBST_CLAUSE; clause; QFREE_LITERAL];
	ALL_TAC] THEN
	REWRITE_TAC[IMAGE_o] THEN MATCH_MP_TAC IMAGE_SUBSET THEN
	REWRITE_TAC[GSYM IMAGE_o] THEN
	MAP_EVERY EXPAND_TAC ["q''"; "q1''"; "q'"] THEN
	REWRITE_TAC[SUBSET; IN_IMAGE; IN_DIFF; o_THM] THEN
	X_GEN_TAC `u:form` THEN
	DISCH_THEN(X_CHOOSE_THEN `v:form` MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 SUBST1_TAC MP_TAC) THEN
	ONCE_REWRITE_TAC[IMP_CONJ] THEN
	DISCH_THEN(X_CHOOSE_THEN `w:form`
	(CONJUNCTS_THEN2 SUBST1_TAC ASSUME_TAC)) THEN
	SUBGOAL_THEN `formsubst si' (formsubst si w) = formsubst V w`
	SUBST1_TAC THENL
	[SUBGOAL_THEN `qfree w` MP_TAC THENL
	[ASM_MESON_TAC[clause; QFREE_LITERAL]; ALL_TAC] THEN
	SPEC_TAC(`w:form`,`w:form`) THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	ONCE_REWRITE_TAC[FORMSUBST_TERMSUBST_EQ] THEN
	ASM_REWRITE_TAC[GSYM TERMSUBST_TERMSUBST; FUN_EQ_THM; TERMSUBST_TRIV];
	ALL_TAC] THEN
	REWRITE_TAC[FORMSUBST_TRIV] THEN
	MATCH_MP_TAC(TAUT `b /\ (c ==> a) ==> ~a ==> b /\ ~c`) THEN
	CONJ_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN
	DISCH_TAC THEN EXISTS_TAC `formsubst ri w` THEN ASM_REWRITE_TAC[] THEN
	AP_TERM_TAC THEN GEN_REWRITE_TAC LAND_CONV [GSYM FORMSUBST_TRIV] THEN
	SUBGOAL_THEN `qfree w` MP_TAC THENL
	[ASM_MESON_TAC[clause; QFREE_LITERAL]; ALL_TAC] THEN
	SPEC_TAC(`w:form`,`w:form`) THEN
	SIMP_TAC[FORMSUBST_FORMSUBST] THEN
	ONCE_REWRITE_TAC[FORMSUBST_TERMSUBST_EQ] THEN
	ASM_REWRITE_TAC[GSYM TERMSUBST_TERMSUBST; FUN_EQ_THM] THEN
	REWRITE_TAC[TERMSUBST_TRIV]);;

	let ISARESOLVENT_SUBSUME_R = prove
	(`!p q q' r.
	clause p /\ clause q /\ clause q' /\
	q' subsumes q /\ isaresolvent r (p,q)
	==> q' subsumes r \/ ?r'. isaresolvent r' (p,q') /\ r' subsumes r`,
	REPEAT STRIP_TAC THEN
	MP_TAC(SPECL [`q:form->bool`; `p:form->bool`; `r:form->bool`]
	ISARESOLVENT_SYM) THEN
	ASM_REWRITE_TAC[] THEN
	DISCH_THEN(X_CHOOSE_THEN `r':form->bool` STRIP_ASSUME_TAC) THEN
	MP_TAC(SPECL [`q:form->bool`; `q':form->bool`; `p:form->bool`;
	`r':form->bool`] ISARESOLVENT_SUBSUME_L) THEN
	ASM_REWRITE_TAC[] THEN
	DISCH_THEN(DISJ_CASES_THEN2 ASSUME_TAC MP_TAC) THENL
	[DISJ1_TAC THEN MATCH_MP_TAC subsumes_TRANS THEN
	EXISTS_TAC `r':form->bool` THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN
	DISCH_THEN(X_CHOOSE_THEN `r'':form->bool` STRIP_ASSUME_TAC) THEN
	DISJ2_TAC THEN
	MP_TAC(SPECL [`p:form->bool`; `q':form->bool`; `r'':form->bool`]
	ISARESOLVENT_SYM) THEN
	ASM_REWRITE_TAC[] THEN
	ASM MESON_TAC[ISARESOLVENT_CLAUSE; subsumes_TRANS]);;

	let ISARESOLVENT_SUBSUME = prove
	(`!p p' q q' r.
	clause p /\ clause p' /\ clause q /\ clause q' /\
	p' subsumes p /\ q' subsumes q /\ isaresolvent r (p,q)
	==> p' subsumes r \/ q' subsumes r \/
	?r'. isaresolvent r' (p',q') /\ r' subsumes r`,
	REPEAT STRIP_TAC THEN
	MP_TAC(SPECL [`p:form->bool`; `q:form->bool`;
	`q':form->bool`; `r:form->bool`] ISARESOLVENT_SUBSUME_R) THEN
	ASM_REWRITE_TAC[] THEN
	DISCH_THEN(DISJ_CASES_THEN2 ASSUME_TAC MP_TAC) THEN ASM_REWRITE_TAC[] THEN
	DISCH_THEN(X_CHOOSE_THEN `r':form->bool` STRIP_ASSUME_TAC) THEN
	MP_TAC(SPECL [`p:form->bool`; `p':form->bool`;
	`q':form->bool`; `r':form->bool`] ISARESOLVENT_SUBSUME_L) THEN
	ASM_REWRITE_TAC[] THEN
	ASM_MESON_TAC[subsumes_TRANS; ISARESOLVENT_CLAUSE]);;

	let ALLRESOLVENTS_SUBSUME_L = prove
	(`!s t u.
	(!c. c IN s ==> clause c) /\
	(!c. c IN t ==> clause c) /\
	(!c. c IN u ==> clause c) /\
	s SUBSUMES t
	==> (s UNION (allresolvents s u)) SUBSUMES (allresolvents t u)`,
	REWRITE_TAC[SUBSUMES; IN_UNION; allresolvents; IN_ELIM_THM] THEN
	MESON_TAC[ISARESOLVENT_SUBSUME_L; subsumes_REFL]);;

	let ALLRESOLVENTS_SUBSUME_R = prove
	(`!s t u.
	(!c. c IN s ==> clause c) /\
	(!c. c IN t ==> clause c) /\
	(!c. c IN u ==> clause c) /\
	t SUBSUMES u
	==> (t UNION (allresolvents s t)) SUBSUMES (allresolvents s u)`,
	REWRITE_TAC[SUBSUMES; IN_UNION; allresolvents; IN_ELIM_THM] THEN
	MESON_TAC[ISARESOLVENT_SUBSUME_R; subsumes_REFL]);;

	let ALLRESOLVENTS_SUBSUME = prove
	(`!s t s' t'.
	(!c. c IN s ==> clause c) /\
	(!c. c IN s' ==> clause c) /\
	(!c. c IN t ==> clause c) /\
	(!c. c IN t' ==> clause c) /\
	s SUBSUMES s' /\ t SUBSUMES t'
	==> (s UNION t UNION (allresolvents s t)) SUBSUMES
	(allresolvents s' t')`,
	REPEAT STRIP_TAC THEN
	MATCH_MP_TAC SUBSUMES_TRANS THEN
	EXISTS_TAC `s UNION (allresolvents s t')` THEN
	ASM_SIMP_TAC[ALLRESOLVENTS_SUBSUME_L; ALLRESOLVENTS_SUBSUME_R;
	SUBSUMES_UNION; SUBSUMES_REFL; IN_UNION] THEN
	ASM_MESON_TAC[ALLRESOLVENTS_CLAUSE]);;

	(* ------------------------------------------------------------------------- *)
	(* Show how the tautology elimination doesn't hurt us. *)
	(* ------------------------------------------------------------------------- *)

	let ISARESOLVENT_TAUTOLOGY_L = prove
	(`!p q r.
	clause p /\ clause q /\
	tautologous(p) /\ isaresolvent r (p,q)
	==> tautologous(r) \/ q subsumes r`,
	let lemma = prove
	(`{~~p \| p IN s} = IMAGE (~~) s`,
	REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM] THEN MESON_TAC[]) in
	REPEAT GEN_TAC THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN
	REWRITE_TAC[tautologous; isaresolvent] THEN
	DISCH_THEN(CONJUNCTS_THEN2
	(X_CHOOSE_THEN `x:form` STRIP_ASSUME_TAC) MP_TAC) THEN
	ABBREV_TAC `q' = IMAGE (formsubst (rename q (FVS p))) q` THEN
	CONV_TAC(ONCE_DEPTH_CONV let_CONV) THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN
	MAP_EVERY X_GEN_TAC [`p1:form->bool`; `q1':form->bool`] THEN
	REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN
	LET_TAC THEN DISCH_THEN(ASSUME_TAC o SYM) THEN
	ASM_CASES_TAC `x IN (p DIFF p1) /\ ~~x IN (p DIFF p1)` THENL
	[DISJ1_TAC THEN EXISTS_TAC `formsubst i x` THEN
	EXPAND_TAC "r" THEN REWRITE_TAC[GSYM FORMSUBST_NEGATE] THEN
	REWRITE_TAC[IN_IMAGE; IN_DIFF; IN_UNION] THEN
	ASM_MESON_TAC[IN_DIFF]; ALL_TAC] THEN
	ABBREV_TAC `k = rename q (FVS p)` THEN
	DISJ2_TAC THEN ASM_CASES_TAC `x:form IN p1` THENL
	[REWRITE_TAC[subsumes] THEN
	EXISTS_TAC `termsubst i o (k:num->term)` THEN
	MP_TAC(SPEC `p1 UNION {~~p \| p IN q1'}` MGU) THEN
	ASM_REWRITE_TAC[] THEN ANTS_TAC THENL
	[CONJ_TAC THENL
	[REWRITE_TAC[lemma; FINITE_UNION] THEN
	ASM_MESON_TAC[FINITE_IMAGE; FINITE_SUBSET; clause; SUBSET; IN_DIFF];
	REWRITE_TAC[IN_UNION; IN_ELIM_THM] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_NEGATE] THEN
	ASM_MESON_TAC[QFREE_LITERAL; clause; SUBSET; IN_IMAGE;
	IMAGE_FORMSUBST_CLAUSE]];
	ALL_TAC] THEN
	DISCH_THEN(MP_TAC o CONJUNCT1) THEN
	REWRITE_TAC[Unifies_DEF; IN_UNION; IN_ELIM_THM] THEN
	DISCH_THEN(fun th -> ASSUME_TAC th THEN
	MP_TAC(SPECL [`x:form`; `~~x`] th)) THEN
	REWRITE_TAC[FORMSUBST_NEGATE; NEGATE_REFL; ASSUME `x:form IN p1`] THEN
	REWRITE_TAC[DE_MORGAN_THM] THEN STRIP_TAC THEN
	SUBGOAL_THEN `!y. y IN q1' ==> (formsubst i (~~y) = formsubst i x)`
	ASSUME_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN
	`IMAGE(formsubst (termsubst i o k)) q =
	IMAGE (formsubst i o formsubst k) q`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; o_THM] THEN
	ASM_MESON_TAC[clause; FORMSUBST_FORMSUBST; QFREE_LITERAL];
	ALL_TAC] THEN
	ASM_REWRITE_TAC[IMAGE_o] THEN
	SUBGOAL_THEN `!y. y IN q1' ==> (formsubst i y = formsubst i (~~x))`
	MP_TAC THENL
	[REPEAT STRIP_TAC THEN
	UNDISCH_TAC `!y. y IN q1' ==> (formsubst i (~~ y) = formsubst i x)` THEN
	DISCH_THEN(MP_TAC o SPEC `y:form`) THEN ASM_REWRITE_TAC[] THEN
	DISCH_THEN(MP_TAC o AP_TERM `(~~)`) THEN
	REWRITE_TAC[GSYM FORMSUBST_NEGATE] THEN
	ASM_MESON_TAC[NEGATE_NEGATE; clause; IMAGE_FORMSUBST_CLAUSE; SUBSET];
	ALL_TAC] THEN
	EXPAND_TAC "r" THEN
	REWRITE_TAC[SUBSET; IN_IMAGE; IN_DIFF; IN_UNION] THEN ASM_MESON_TAC[];
	ALL_TAC] THEN
	SUBGOAL_THEN `~~x IN p1` ASSUME_TAC THENL
	[ASM_MESON_TAC[IN_DIFF]; ALL_TAC] THEN
	REWRITE_TAC[subsumes] THEN
	EXISTS_TAC `termsubst i o (k:num->term)` THEN
	MP_TAC(SPEC `p1 UNION {~~p \| p IN q1'}` MGU) THEN
	ASM_REWRITE_TAC[] THEN ANTS_TAC THENL
	[CONJ_TAC THENL
	[REWRITE_TAC[lemma; FINITE_UNION] THEN
	ASM_MESON_TAC[FINITE_IMAGE; FINITE_SUBSET; clause; SUBSET; IN_DIFF];
	REWRITE_TAC[IN_UNION; IN_ELIM_THM] THEN
	REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_NEGATE] THEN
	ASM_MESON_TAC[QFREE_LITERAL; clause; SUBSET; IN_IMAGE;
	IMAGE_FORMSUBST_CLAUSE]];
	ALL_TAC] THEN
	DISCH_THEN(MP_TAC o CONJUNCT1) THEN
	REWRITE_TAC[Unifies_DEF; IN_UNION; IN_ELIM_THM] THEN
	DISCH_THEN(fun th -> ASSUME_TAC th THEN
	MP_TAC(SPECL [`~~x`; `x:form`] th)) THEN
	REWRITE_TAC[FORMSUBST_NEGATE; NEGATE_REFL; ASSUME `~~x IN p1`] THEN
	REWRITE_TAC[DE_MORGAN_THM] THEN STRIP_TAC THEN
	SUBGOAL_THEN `!y. y IN q1' ==> (formsubst i (~~y) = formsubst i (~~x))`
	ASSUME_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN
	SUBGOAL_THEN
	`IMAGE(formsubst (termsubst i o k)) q =
	IMAGE (formsubst i o formsubst k) q`
	SUBST1_TAC THENL
	[REWRITE_TAC[EXTENSION; IN_IMAGE; o_THM] THEN
	ASM_MESON_TAC[clause; FORMSUBST_FORMSUBST; QFREE_LITERAL];
	ALL_TAC] THEN
	ASM_REWRITE_TAC[IMAGE_o] THEN
	SUBGOAL_THEN `!y. y IN q1' ==> (formsubst i y = formsubst i x)`
	MP_TAC THENL
	[REPEAT STRIP_TAC THEN
	UNDISCH_TAC `!y. y IN q1' ==> (formsubst i (~~y) = formsubst i (~~x))` THEN
	DISCH_THEN(MP_TAC o SPEC `y:form`) THEN ASM_REWRITE_TAC[] THEN
	DISCH_THEN(MP_TAC o AP_TERM `(~~)`) THEN
	REWRITE_TAC[GSYM FORMSUBST_NEGATE] THEN
	SUBGOAL_THEN `literal x /\ literal y`
	(fun th -> MESON_TAC[NEGATE_NEGATE; th]) THEN
	ASM_MESON_TAC[clause; IMAGE_FORMSUBST_CLAUSE; SUBSET];
	ALL_TAC] THEN
	EXPAND_TAC "r" THEN
	REWRITE_TAC[SUBSET; IN_IMAGE; IN_DIFF; IN_UNION] THEN ASM_MESON_TAC[]);;

	let TAUTOLOGOUS_SUBSUMES = prove
	(`!p q. p subsumes q /\ tautologous(p) ==> tautologous(q)`,
	MESON_TAC[subsumes; tautologous; SUBSET; TAUTOLOGOUS_INSTANCE]);;

	let ISARESOLVENT_TAUTOLOGY_R = prove
	(`!p q r.
	clause p /\ clause q /\
	tautologous(p) /\ isaresolvent r (q,p)
	==> tautologous(r) \/ q subsumes r`,
	MESON_TAC[ISARESOLVENT_SYM; ISARESOLVENT_TAUTOLOGY_L; subsumes_TRANS;
	TAUTOLOGOUS_SUBSUMES]);;

	(* ------------------------------------------------------------------------- *)
	(* Show that everything in the levels comes from initial unused or one of *)
	(* the new resolvents generated. Hence, unless it was in the initial unused, *)
	(* it will be detected if we just scan the new resolvents each cycle. *)
	(* ------------------------------------------------------------------------- *)

	let REPLACE_FROMNEW = prove
	(`!cl lis c. MEM c (replace cl lis) ==> MEM c lis \/ (c = cl)`,
	GEN_TAC THEN LIST_INDUCT_TAC THEN REWRITE_TAC[replace] THEN
	SIMP_TAC[MEM] THEN GEN_TAC THEN COND_CASES_TAC THEN
	SIMP_TAC[MEM] THEN ASM_MESON_TAC[]);;

	let INCORPORATE_FROMNEW = prove
	(`!gcl cl lis c.
	MEM c (incorporate gcl cl lis) ==> MEM c lis \/ (c = cl)`,
	REPEAT GEN_TAC THEN REWRITE_TAC[incorporate] THEN COND_CASES_TAC THEN
	MESON_TAC[REPLACE_FROMNEW]);;

	let ITLIST_INCORPORATE_FROMNEW = prove
	(`!gcl lis new c.
	MEM c (ITLIST (incorporate gcl) new lis)
	==> MEM c new \/ MEM c lis`,
	GEN_TAC THEN GEN_TAC THEN LIST_INDUCT_TAC THEN
	REWRITE_TAC[ITLIST; MEM] THEN ASM_MESON_TAC[INCORPORATE_FROMNEW]);;

	let UNUSED_FROMNEW = prove
	(`!used unused c n.
	MEM c (SND(given n (used,unused)))
	==> MEM c unused \/
	?m. m < n /\
	MEM c (resolvents
	(HD(SND(given m (used,unused))))
	(CONS (HD(SND(given m (used,unused))))
	(FST(given m (used,unused)))))`,
	GEN_TAC THEN GEN_TAC THEN GEN_TAC THEN INDUCT_TAC THEN SIMP_TAC[given] THEN
	SUBST1_TAC(SYM(ISPEC `given n (used,unused)` PAIR)) THEN
	PURE_REWRITE_TAC[step] THEN
	COND_CASES_TAC THEN REWRITE_TAC[] THENL
	[ASM_MESON_TAC[ARITH_RULE `x < n ==> x < SUC n`]; ALL_TAC] THEN
	LET_TAC THEN REWRITE_TAC[SND] THEN
	DISCH_THEN(MP_TAC o MATCH_MP ITLIST_INCORPORATE_FROMNEW) THEN
	STRIP_TAC THEN ASM_REWRITE_TAC[] THENL [ASM_MESON_TAC[LT]; ALL_TAC] THEN
	SUBGOAL_THEN `MEM c (SND (given n (used,unused)))`
	(fun th -> FIRST_ASSUM(MP_TAC o C MATCH_MP th))
	THENL
	[UNDISCH_TAC `MEM c (TL (SND (given n (used,unused))))` THEN
	UNDISCH_TAC `~(SND (given n (used,unused)) = [])` THEN
	SPEC_TAC(`SND (given n (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN SIMP_TAC[MEM; TL]; ALL_TAC] THEN
	MESON_TAC[ARITH_RULE `x < n ==> x < SUC n`]);;

	let SUB_FROMNEW = prove
	(`!used unused c n.
	c IN Sub(used,unused) n
	==> MEM c unused \/
	?m. m < n /\
	MEM c (resolvents
	(HD(SND(given m (used,unused))))
	(CONS (HD(SND(given m (used,unused))))
	(FST(given m (used,unused)))))`,
	let lemma = prove
	(`!l. ~(l = []) ==> MEM (HD l) l`,
	LIST_INDUCT_TAC THEN REWRITE_TAC[MEM; HD]) in
	GEN_TAC THEN GEN_TAC THEN GEN_TAC THEN INDUCT_TAC THEN
	REWRITE_TAC[Sub_DEF; NOT_IN_EMPTY] THEN
	COND_CASES_TAC THENL
	[ASM_MESON_TAC[ARITH_RULE `x < n ==> x < SUC n`]; ALL_TAC] THEN
	REWRITE_TAC[IN_INSERT] THEN STRIP_TAC THENL
	[ALL_TAC; ASM_MESON_TAC[ARITH_RULE `x < n ==> x < SUC n`]] THEN
	SUBGOAL_THEN `MEM c (SND(given n (used,unused)))`
	(fun th -> MP_TAC(MATCH_MP UNUSED_FROMNEW th))
	THENL [ALL_TAC; MESON_TAC[ARITH_RULE `x < n ==> x < SUC n`]] THEN
	UNDISCH_TAC `~(SND (given n (used,unused)) = [])` THEN
	ASM_REWRITE_TAC[] THEN
	SPEC_TAC(`SND (given n (used,unused))`,`l:(form->bool)list`) THEN
	LIST_INDUCT_TAC THEN SIMP_TAC[MEM; TL; HD]);;

	let LEVEL_FROMNEW = prove
	(`!used unused c n.
	c IN level(used,unused) n
	==> MEM c unused \/
	?m. MEM c (resolvents
	(HD(SND(given m (used,unused))))
	(CONS (HD(SND(given m (used,unused))))
	(FST(given m (used,unused)))))`,
	REWRITE_TAC[level] THEN MESON_TAC[SUB_FROMNEW]);;