Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
| (* ========================================================================= *) | |
| (* Canonical models in FOL and their use to derive classic metatheorems. *) | |
| (* ========================================================================= *) | |
| (* ------------------------------------------------------------------------- *) | |
| (* Domain of a canonical model for given language. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let terms_RULES,terms_INDUCT,terms_CASES = new_inductive_definition | |
| `(!x. terms fns (V x)) /\ | |
| (!f l. (f,LENGTH l) IN fns /\ ALL (terms fns) l | |
| ==> terms fns (Fn f l))`;; | |
| (* ------------------------------------------------------------------------- *) | |
| (* A few obvious lemmas. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let STUPID_CANONDOM_LEMMA = prove | |
| (`!t. t IN terms(FST L) ==> functions_term t SUBSET (FST L)`, | |
| let lemma0 = prove | |
| (`a SUBSET s /\ b SUBSET s ==> (a UNION b) SUBSET s`,SET_TAC[]) in | |
| let lemma1 = prove | |
| (`a IN s /\ b SUBSET s ==> (a INSERT b) SUBSET s`,SET_TAC[]) in | |
| let lemma2 = prove | |
| (`!l. ALL (\x. x SUBSET s) l ==> LIST_UNION l SUBSET s`, | |
| LIST_INDUCT_TAC THEN REWRITE_TAC[ALL; LIST_UNION; EMPTY_SUBSET] THEN | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC lemma0 THEN ASM_MESON_TAC[]) in | |
| REWRITE_TAC[IN] THEN MATCH_MP_TAC terms_INDUCT THEN | |
| REWRITE_TAC[functions_term; EMPTY_SUBSET] THEN | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC lemma1 THEN | |
| ASM_REWRITE_TAC[] THEN MATCH_MP_TAC lemma2 THEN | |
| ASM_REWRITE_TAC[ALL_MAP; o_DEF]);; | |
| let FINITE_SUBSET_INSTANCE = prove | |
| (`!t'. FINITE(t') | |
| ==> t' SUBSET { formsubst v p | P(v) /\ p IN s} | |
| ==> ?t. FINITE(t) /\ t SUBSET s /\ | |
| t' SUBSET {formsubst v p | P(v) /\ p IN t}`, | |
| let lemma = prove | |
| (`(a INSERT s) SUBSET t <=> a IN t /\ s SUBSET t`,SET_TAC[]) in | |
| MATCH_MP_TAC FINITE_INDUCT THEN CONJ_TAC THENL | |
| [REWRITE_TAC[EMPTY_SUBSET] THEN | |
| EXISTS_TAC `EMPTY:form->bool` THEN | |
| REWRITE_TAC[FINITE_RULES; EMPTY_SUBSET]; | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[lemma] THEN | |
| DISCH_THEN(fun th -> STRIP_ASSUME_TAC th THEN | |
| ANTE_RES_THEN MP_TAC (CONJUNCT2 th)) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `t0:form->bool` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `(@p. ?v. (P v /\ p IN s) /\ (x = formsubst v p)) INSERT t0` THEN | |
| ASM_REWRITE_TAC[FINITE_INSERT; lemma] THEN | |
| FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [IN]) THEN | |
| DISCH_THEN(MP_TAC o REWRITE_RULE[IN_ELIM_THM]) THEN | |
| ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN | |
| DISCH_THEN(MP_TAC o SELECT_RULE) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `v:num->term` MP_TAC) THEN | |
| SPEC_TAC(`@p. ?v. (P v /\ p IN s) /\ (x = formsubst v p)`,`q:form`) THEN | |
| UNDISCH_TAC `s' SUBSET {formsubst v p | P v /\ p IN t0}` THEN | |
| UNDISCH_TAC `x IN {formsubst v p | P v /\ p IN s}` THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM; IN_INSERT] THEN MESON_TAC[]]);; | |
| let FINITE_SUBSET_SKOLEM = prove | |
| (`!s u. FINITE(u) | |
| ==> u SUBSET { SKOLEM p | p IN s} | |
| ==> ?t. FINITE(t) /\ t SUBSET s /\ | |
| (u = {SKOLEM p | p IN t})`, | |
| let lemma = prove | |
| (`(a INSERT s) SUBSET t <=> a IN t /\ s SUBSET t`,SET_TAC[]) in | |
| let lemma2 = prove | |
| (`{SKOLEM p | p IN x INSERT s} = | |
| (SKOLEM x) INSERT {SKOLEM p | p IN s}`, | |
| REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_INSERT] THEN SET_TAC[]) in | |
| GEN_TAC THEN MATCH_MP_TAC FINITE_INDUCT THEN CONJ_TAC THENL | |
| [REWRITE_TAC[EMPTY_SUBSET] THEN | |
| EXISTS_TAC `EMPTY:form->bool` THEN | |
| REWRITE_TAC[FINITE_RULES; EMPTY_SUBSET; NOT_IN_EMPTY] THEN | |
| REWRITE_TAC[EXTENSION; IN_ELIM_THM; NOT_IN_EMPTY]; ALL_TAC] THEN | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[lemma] THEN | |
| DISCH_THEN(fun th -> STRIP_ASSUME_TAC th THEN | |
| ANTE_RES_THEN MP_TAC (CONJUNCT2 th)) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `t0:form->bool` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `(@p. p IN s /\ (x = SKOLEM p)) INSERT t0` THEN | |
| ASM_REWRITE_TAC[FINITE_INSERT; lemma] THEN | |
| FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [IN]) THEN | |
| DISCH_THEN(MP_TAC o REWRITE_RULE[IN_ELIM_THM]) THEN | |
| DISCH_THEN(MP_TAC o SELECT_RULE) THEN STRIP_TAC THEN | |
| ASM_REWRITE_TAC[lemma2] THEN | |
| REPEAT(FIRST_X_ASSUM(SUBST_ALL_TAC o SYM)) THEN REFL_TAC);; | |
| let VALUATION_EXISTS = prove | |
| (`!M. ~(Dom(M) = EMPTY) ==> ?v:num->A. valuation(M) v`, | |
| GEN_TAC THEN REWRITE_TAC[GSYM MEMBER_NOT_EMPTY] THEN | |
| DISCH_THEN(X_CHOOSE_TAC `a:A`) THEN | |
| EXISTS_TAC `\x:num. a:A` THEN | |
| ASM_REWRITE_TAC[valuation]);; | |
| let HOLDS_ITLIST_EXISTS = prove | |
| (`!M xs v. holds M v (ITLIST ?? xs p) <=> | |
| ?as. (LENGTH as = LENGTH xs) /\ | |
| ALL (Dom M) as /\ | |
| holds M | |
| (ITLIST valmod (REVERSE (MAP2 (\x a:A. (x,a)) xs as)) v) | |
| p`, | |
| GEN_TAC THEN LIST_INDUCT_TAC THEN | |
| ASM_REWRITE_TAC[HOLDS; LENGTH; ITLIST; MAP2_DEF; HD; | |
| TL; REVERSE; APPEND] THENL | |
| [MESON_TAC[ALL; LENGTH]; REWRITE_TAC[ITLIST_EXTRA; IN]] THEN | |
| GEN_TAC THEN EQ_TAC THENL | |
| [DISCH_THEN(X_CHOOSE_THEN `a:A` (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `as:A list` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `CONS (a:A) as` THEN ASM_REWRITE_TAC[ALL; TL; HD; LENGTH]; | |
| REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN | |
| LIST_INDUCT_TAC THEN REWRITE_TAC[LENGTH; NOT_SUC] THEN | |
| REWRITE_TAC[ALL; SUC_INJ; HD; TL] THEN MESON_TAC[]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Canonical model based on the language of a set of formulas. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let canonical = new_definition | |
| `canonical (L:(num#num->bool)#(num#num->bool)) M <=> | |
| (Dom M = terms (FST L)) /\ | |
| (!f. Fun(M) f = Fn f)`;; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Mappings between models and propositional valuations. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let prop_of_model = new_definition | |
| `prop_of_model M v (Atom p l) <=> holds M v (Atom p l)`;; | |
| let canon_of_prop = new_definition | |
| `canon_of_prop (L:((num#num)->bool)#((num#num)->bool)) (d:form->bool) = | |
| terms(FST L),Fn,\p l. d(Atom p l)`;; | |
| let PHOLDS_PROP_OF_MODEL = prove | |
| (`!p. qfree(p) ==> (pholds (prop_of_model M v) p <=> holds M v p)`, | |
| MATCH_MP_TAC form_INDUCTION THEN | |
| REWRITE_TAC[qfree; holds; pholds] THEN CONJ_TAC THENL | |
| [REWRITE_TAC[prop_of_model; holds]; | |
| REPEAT GEN_TAC THEN STRIP_TAC THEN | |
| DISCH_THEN(CONJUNCTS_THEN (ANTE_RES_THEN SUBST1_TAC)) THEN REFL_TAC]);; | |
| let PROP_OF_CANON_OF_PROP = prove | |
| (`!p l. prop_of_model (canon_of_prop L d) V (Atom p l) = d (Atom p l)`, | |
| REWRITE_TAC[prop_of_model; canon_of_prop; holds; Pred_DEF] THEN | |
| REPEAT GEN_TAC THEN REPEAT AP_TERM_TAC THEN | |
| MATCH_MP_TAC MAP_EQ_DEGEN THEN | |
| SPEC_TAC(`l:term list`,`l:term list`) THEN | |
| LIST_INDUCT_TAC THEN ASM_REWRITE_TAC[ALL] THEN | |
| SPEC_TAC(`h:term`,`t:term`) THEN | |
| MATCH_MP_TAC term_INDUCT THEN | |
| REWRITE_TAC[termval; Fun_DEF] THEN | |
| REPEAT STRIP_TAC THEN AP_TERM_TAC THEN | |
| MATCH_MP_TAC MAP_EQ_DEGEN THEN ASM_REWRITE_TAC[]);; | |
| let HOLDS_CANON_OF_PROP = prove | |
| (`!p. qfree p ==> (holds (canon_of_prop L d) V p <=> pholds d p)`, | |
| GEN_TAC THEN DISCH_THEN(fun th -> MP_TAC th THEN | |
| REWRITE_TAC[GSYM(MATCH_MP PHOLDS_PROP_OF_MODEL th)]) THEN | |
| SPEC_TAC(`p:form`,`p:form`) THEN | |
| MATCH_MP_TAC form_INDUCTION THEN | |
| REWRITE_TAC[pholds; qfree; PROP_OF_CANON_OF_PROP] THEN | |
| REPEAT GEN_TAC THEN STRIP_TAC THEN | |
| DISCH_THEN(CONJUNCTS_THEN (ANTE_RES_THEN SUBST1_TAC)) THEN REFL_TAC);; | |
| let HOLDS_CANON_OF_PROP_GENERAL = prove | |
| (`qfree p ==> (holds (canon_of_prop L d) v p <=> pholds d (formsubst v p))`, | |
| DISCH_THEN(fun th -> MP_TAC th THEN | |
| REWRITE_TAC[GSYM(MATCH_MP PHOLDS_PROP_OF_MODEL th)]) THEN | |
| SPEC_TAC(`p:form`,`p:form`) THEN | |
| MATCH_MP_TAC form_INDUCTION THEN | |
| REWRITE_TAC[formsubst; pholds; qfree; PROP_OF_CANON_OF_PROP] THEN | |
| REPEAT GEN_TAC THEN STRIP_TAC THENL | |
| [ALL_TAC; | |
| REPEAT GEN_TAC THEN STRIP_TAC THEN | |
| DISCH_THEN(CONJUNCTS_THEN (ANTE_RES_THEN SUBST1_TAC)) THEN | |
| REFL_TAC] THEN | |
| REPEAT GEN_TAC THEN REWRITE_TAC[prop_of_model; canon_of_prop; holds] THEN | |
| REWRITE_TAC[Pred_DEF] THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[FUN_EQ_THM] THEN SIMP_TAC[GSYM TERMSUBST_TERMVAL; Fun_DEF]);; | |
| let CANONICAL_CANON_OF_PROP = prove | |
| (`!d. canonical L (canon_of_prop L d)`, | |
| REWRITE_TAC[canonical; canon_of_prop; Dom_DEF; Fun_DEF; FUN_EQ_THM]);; | |
| let INTERPRETATION_CANON_OF_PROP = prove | |
| (`!L d. interpretation L (canon_of_prop L d)`, | |
| REWRITE_TAC[FORALL_PAIR_THM; IN; ETA_AX; | |
| interpretation; canon_of_prop; Fun_DEF; Dom_DEF] THEN | |
| MESON_TAC[terms_RULES; IN]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Equivalence theorems for tautologies. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let PROP_VALID_IMP_FOL_VALID = prove | |
| (`!p. qfree(p) /\ (!d. pholds d p) ==> !M v. holds M v p`, | |
| MESON_TAC[PHOLDS_PROP_OF_MODEL]);; | |
| let FOL_VALID_IMP_PROP_VALID = prove | |
| (`!p. qfree(p) /\ | |
| (!C (v:num->term). canonical(language {p}) C ==> holds C v p) | |
| ==> !d. pholds d p`, | |
| MESON_TAC[CANONICAL_CANON_OF_PROP; HOLDS_CANON_OF_PROP]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Same thing for satisfiability. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let SATISFIES_PSATISFIES = prove | |
| (`(!p. p IN s ==> qfree p) /\ M satisfies s /\ valuation(M) v | |
| ==> (prop_of_model M v) psatisfies s`, | |
| REWRITE_TAC[satisfies; psatisfies] THEN MESON_TAC[PHOLDS_PROP_OF_MODEL]);; | |
| let PSATISFIES_INSTANCES = prove | |
| (`(!p. p IN s ==> qfree p) /\ | |
| d psatisfies {formsubst v p | (!x. v x IN terms(FST L)) /\ p IN s} | |
| ==> (canon_of_prop L d) satisfies s`, | |
| REWRITE_TAC[satisfies; psatisfies; IN_ELIM_THM; LEFT_IMP_EXISTS_THM] THEN | |
| STRIP_TAC THEN | |
| REPEAT GEN_TAC THEN GEN_REWRITE_TAC (LAND_CONV o TOP_DEPTH_CONV) | |
| [canon_of_prop; Dom_DEF; valuation] THEN STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPECL[`formsubst v p`; `v:num->term`; `p:form`]) THEN | |
| ASM_REWRITE_TAC[] THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `holds (canon_of_prop L d) V (formsubst v p)` MP_TAC THENL | |
| [ASM_MESON_TAC[HOLDS_CANON_OF_PROP; QFREE_FORMSUBST]; ALL_TAC] THEN | |
| SUBGOAL_THEN `holds (canon_of_prop L d) V (formsubst v p) <=> | |
| holds (canon_of_prop L d) (termval (canon_of_prop L d) V o v) | |
| p` | |
| SUBST1_TAC THENL | |
| [REWRITE_TAC[HOLDS_FORMSUBST] THEN | |
| ASM_MESON_TAC[INTER_EMPTY; QFREE_BV_EMPTY]; | |
| MATCH_MP_TAC EQ_IMP THEN AP_THM_TAC THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[FUN_EQ_THM; o_THM] THEN | |
| GEN_TAC THEN SPEC_TAC(`(v:num->term) x`,`t:term`) THEN | |
| MATCH_MP_TAC TERMVAL_TRIV THEN | |
| REWRITE_TAC[canon_of_prop; Fun_DEF]]);; | |
| let SATISFIES_INSTANCES = prove | |
| (`!M:(A->bool)#(num->A list->A)#(num->A list->bool) s t. | |
| interpretation(language t) M | |
| ==> (M satisfies | |
| {formsubst i p | p IN s /\ | |
| (!x. i x IN terms(FST(language t)))} <=> | |
| M satisfies s)`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[satisfies; IN_ELIM_THM] THEN | |
| EQ_TAC THEN REPEAT STRIP_TAC THENL | |
| [ASM_MESON_TAC[FORMSUBST_TRIV; terms_RULES; IN]; ALL_TAC] THEN | |
| ASM_REWRITE_TAC[HOLDS_FORMSUBST] THEN | |
| FIRST_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[valuation; o_THM] THEN GEN_TAC THEN | |
| MATCH_MP_TAC INTERPRETATION_TERMVAL THEN | |
| EXISTS_TAC `predicates t` THEN ASM_REWRITE_TAC[] THEN | |
| UNDISCH_TAC `interpretation (language t) | |
| (M:(A->bool)#(num->A list->A)#(num->A list->bool))` THEN | |
| REWRITE_TAC[language] THEN MATCH_MP_TAC INTERPRETATION_SUBLANGUAGE THEN | |
| SUBGOAL_THEN `functions t = FST(language t)` SUBST1_TAC THENL | |
| [REWRITE_TAC[language]; ALL_TAC] THEN | |
| MATCH_MP_TAC STUPID_CANONDOM_LEMMA THEN | |
| ASM_REWRITE_TAC[]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* So we have compactness in a strong form. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let COMPACT_CANON_QFREE = prove | |
| (`(!p. p IN s ==> qfree p) /\ | |
| (!t. FINITE t /\ t SUBSET s ==> ?M. interpretation(language ss) M /\ | |
| ~(Dom(M):A->bool = EMPTY) /\ | |
| M satisfies t) | |
| ==> ?C. interpretation (language ss) C /\ | |
| canonical (language ss) C /\ | |
| C satisfies s`, | |
| REPEAT STRIP_TAC THEN SUBGOAL_THEN | |
| `psatisfiable {formsubst v p | (!x. v x IN terms(FST(language ss))) /\ | |
| p IN s}` | |
| MP_TAC THENL | |
| [REWRITE_TAC[psatisfiable] THEN MATCH_MP_TAC COMPACT_PROP THEN | |
| REWRITE_TAC[GSYM psatisfiable] THEN | |
| X_GEN_TAC `u:form->bool` THEN STRIP_TAC THEN | |
| SUBGOAL_THEN | |
| `?t. FINITE(t) /\ t SUBSET s /\ | |
| u SUBSET {formsubst v p | | |
| (!x. v x IN terms (FST (language ss))) /\ | |
| p IN t}` | |
| STRIP_ASSUME_TAC THENL | |
| [MATCH_MP_TAC(REWRITE_RULE[TAUT `(a ==> b ==> c) <=> a /\ b ==> c`] | |
| (GEN_ALL FINITE_SUBSET_INSTANCE)) THEN | |
| ASM_REWRITE_TAC[]; ALL_TAC] THEN | |
| MATCH_MP_TAC SATISFIABLE_MONO THEN | |
| EXISTS_TAC `{formsubst v p | | |
| (!x. v x IN terms (FST (language ss))) /\ | |
| p IN t}` THEN | |
| ASM_REWRITE_TAC[] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `t:form->bool`) THEN ASM_REWRITE_TAC[] THEN | |
| STRIP_TAC THEN | |
| FIRST_ASSUM(CHOOSE_TAC o MATCH_MP VALUATION_EXISTS) THEN | |
| MP_TAC(SPEC `ss:form->bool` (SPEC `t:form->bool` | |
| (snd(SPEC_VAR SATISFIES_INSTANCES)))) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| SUBGOAL_THEN `!p. p IN t ==> qfree p` (fun th -> REWRITE_TAC[th]) THENL | |
| [ASM_MESON_TAC[SUBSET]; ALL_TAC] THEN DISCH_TAC THEN | |
| REWRITE_TAC[psatisfiable] THEN | |
| EXISTS_TAC `prop_of_model M (v:num->A)` THEN | |
| REWRITE_TAC[GSYM psatisfies] THEN | |
| MATCH_MP_TAC SATISFIES_PSATISFIES THEN ASM_REWRITE_TAC[] THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[IN_ELIM_THM] THEN | |
| REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE_FORMSUBST] THEN | |
| ASM_MESON_TAC[SUBSET]; | |
| RULE_ASSUM_TAC(REWRITE_RULE[CONJ_ACI]) THEN | |
| ASM_REWRITE_TAC[CONJ_ACI]]; ALL_TAC] THEN | |
| REWRITE_TAC[psatisfiable; GSYM psatisfies] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `d:form->bool` ASSUME_TAC) THEN | |
| EXISTS_TAC `canon_of_prop (language ss) d` THEN | |
| REWRITE_TAC[CANONICAL_CANON_OF_PROP; INTERPRETATION_CANON_OF_PROP] THEN | |
| MATCH_MP_TAC PSATISFIES_INSTANCES THEN ASM_REWRITE_TAC[]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Tedious lemma about sublanguage. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let INTERPRETATION_RESTRICTLANGUAGE = prove | |
| (`!M s t. t SUBSET s /\ interpretation(language s) M | |
| ==> interpretation(language t) M`, | |
| REPEAT GEN_TAC THEN | |
| REWRITE_TAC[IMP_CONJ] THEN | |
| DISCH_TAC THEN | |
| REWRITE_TAC[language] THEN | |
| MATCH_MP_TAC INTERPRETATION_SUBLANGUAGE THEN | |
| REWRITE_TAC[functions] THEN POP_ASSUM MP_TAC THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM; IN_UNIONS] THEN MESON_TAC[]);; | |
| let INTERPRETATION_EXTENDLANGUAGE = prove | |
| (`!M s t. | |
| interpretation (language t) M /\ | |
| ~(Dom M :A->bool = EMPTY) /\ | |
| M satisfies t | |
| ==> ?M'. (Dom M' = Dom M) /\ | |
| (Pred M' = Pred M) /\ | |
| interpretation(language s) M' /\ | |
| M' satisfies t`, | |
| REPEAT STRIP_TAC THEN | |
| EXISTS_TAC `Dom(M):A->bool, | |
| (\g zs. if (g,LENGTH zs) IN functions t then Fun(M) g zs | |
| else @a. a IN Dom(M)), | |
| Pred(M)` THEN | |
| REWRITE_TAC[Dom_DEF; Fun_DEF; Pred_DEF; interpretation; language] THEN CONJ_TAC THENL | |
| [REPEAT STRIP_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL | |
| [FIRST_ASSUM(MATCH_MP_TAC o REWRITE_RULE [language; interpretation]) THEN | |
| ASM_REWRITE_TAC[]; | |
| CONV_TAC SELECT_CONV THEN ASM_REWRITE_TAC[MEMBER_NOT_EMPTY]]; | |
| FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [satisfies]) THEN | |
| REWRITE_TAC[satisfies] THEN | |
| REWRITE_TAC[valuation; Dom_DEF] THEN | |
| MATCH_MP_TAC EQ_IMP THEN | |
| AP_TERM_TAC THEN ABS_TAC THEN AP_TERM_TAC THEN ABS_TAC THEN | |
| MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> ((a ==> b) <=> (a ==> c))`) THEN | |
| STRIP_TAC THEN SPEC_TAC(`v:num->A`,`v:num->A`) THEN | |
| MATCH_MP_TAC HOLDS_FUNCTIONS THEN | |
| REWRITE_TAC[Dom_DEF; Fun_DEF; Pred_DEF] THEN | |
| REPEAT STRIP_TAC THEN COND_CASES_TAC THEN | |
| ASM_REWRITE_TAC[] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[functions; IN_UNIONS; IN_ELIM_THM]) THEN | |
| ASM_MESON_TAC[]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Generalize to any formulas, via Skolemization. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let COMPACT_LS = prove | |
| (`(!t. FINITE t /\ t SUBSET s ==> ?M. interpretation(language s) M /\ | |
| ~(Dom(M):A->bool = EMPTY) /\ | |
| M satisfies t) | |
| ==> ?C. interpretation (language s) C /\ | |
| ~(Dom(C):term->bool = EMPTY) /\ | |
| C satisfies s`, | |
| let lemma = prove | |
| (`(!y. p y ==> p' y) | |
| ==> (?x. p x) ==> (?x. p' x)`, | |
| MESON_TAC[]) in | |
| REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN | |
| `!u. FINITE u /\ u SUBSET {SKOLEM p | p IN s} | |
| ==> ?M. interpretation(language {SKOLEM p | p IN s}) M /\ | |
| ~(Dom(M):A->bool = EMPTY) /\ | |
| M satisfies u` | |
| ASSUME_TAC THENL | |
| [REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `?t. (u = {SKOLEM p | p IN t}) /\ | |
| FINITE t /\ t SUBSET s` | |
| (CHOOSE_THEN (CONJUNCTS_THEN2 SUBST_ALL_TAC STRIP_ASSUME_TAC)) THENL | |
| [MP_TAC(SPECL [`s:form->bool`; `u:form->bool`] FINITE_SUBSET_SKOLEM) THEN | |
| ASM_REWRITE_TAC[CONJ_ACI]; ALL_TAC] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `t:form->bool`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN | |
| `M:(A->bool)#(num->A list->A)#(num->A list->bool)` | |
| STRIP_ASSUME_TAC) THEN | |
| SUBGOAL_THEN | |
| `(?M. ~(Dom M:A->bool = EMPTY) /\ | |
| interpretation(language t) M /\ | |
| M satisfies t)` | |
| (MP_TAC o GEN_REWRITE_RULE I [SKOLEM_SATISFIABLE]) THENL | |
| [EXISTS_TAC `M:(A->bool)#(num->A list->A)#(num->A list->bool)` THEN | |
| ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC INTERPRETATION_RESTRICTLANGUAGE THEN | |
| EXISTS_TAC `s:form->bool` THEN ASM_REWRITE_TAC[]; ALL_TAC] THEN | |
| DISCH_THEN(X_CHOOSE_THEN | |
| `M0:(A->bool)#(num->A list->A)#(num->A list->bool)` | |
| STRIP_ASSUME_TAC) THEN | |
| MP_TAC(ISPEC `M0:(A->bool)#(num->A list->A)#(num->A list->bool)` | |
| INTERPRETATION_EXTENDLANGUAGE) THEN | |
| DISCH_THEN(MP_TAC o SPECL | |
| [`{SKOLEM p | p IN s}`; `{SKOLEM p | p IN t}`]) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN | |
| `M1:(A->bool)#(num->A list->A)#(num->A list->bool)` | |
| STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `M1:(A->bool)#(num->A list->A)#(num->A list->bool)` THEN | |
| ASM_REWRITE_TAC[]; ALL_TAC] THEN | |
| MP_TAC(INST [`{SKOLEM p | p IN s}`,`s:form->bool`; | |
| `{SKOLEM p | p IN s}`,`ss:form->bool`] | |
| COMPACT_CANON_QFREE) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| W(C SUBGOAL_THEN (fun th -> REWRITE_TAC[th]) o funpow 2 lhand o snd) THENL | |
| [REWRITE_TAC[IN_ELIM_THM] THEN | |
| REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[SKOLEM_QFREE]; ALL_TAC] THEN | |
| ONCE_REWRITE_TAC[AC CONJ_ACI `a /\ b /\ c <=> b /\ a /\ c`] THEN | |
| GEN_REWRITE_TAC RAND_CONV [SKOLEM_SATISFIABLE] THEN | |
| MATCH_MP_TAC lemma THEN REWRITE_TAC[canonical] THEN | |
| GEN_TAC THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[EXTENSION; NOT_IN_EMPTY; IN] THEN | |
| MESON_TAC[terms_RULES]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Split away the compactness argument. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let CANON = prove | |
| (`!M:(A->bool)#(num->A list->A)#(num->A list->bool) s. | |
| interpretation (language s) M /\ | |
| ~(Dom(M) = EMPTY) /\ | |
| (!p. p IN s ==> qfree p) /\ M satisfies s | |
| ==> ?C. interpretation (language s) C /\ | |
| ~(Dom C :term->bool = EMPTY) /\ | |
| C satisfies s`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC COMPACT_LS THEN | |
| ASM_MESON_TAC[satisfies; SUBSET]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Conventional form of the LS theorem. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let term_of_num = new_definition | |
| `term_of_num n = (@t. num_of_term t = n)`;; | |
| let TERM_OF_NUM = prove | |
| (`term_of_num(num_of_term t) = t`, | |
| REWRITE_TAC[term_of_num; NUM_OF_TERM_INJ]);; | |
| let LOWMOD = new_definition | |
| `LOWMOD M = {num_of_term t | t IN Dom(M)}, | |
| (\g zs. num_of_term (Fun(M) g (MAP term_of_num zs))), | |
| (\p zs. Pred(M) p (MAP term_of_num zs))`;; | |
| let LOWMOD_DOM_EMPTY = prove | |
| (`(Dom(LOWMOD M) = EMPTY) <=> (Dom(M) = EMPTY)`, | |
| REWRITE_TAC[Dom_DEF; LOWMOD; EXTENSION; IN_ELIM_THM; NOT_IN_EMPTY] THEN | |
| MESON_TAC[]);; | |
| let LOWMOD_TERMVAL = prove | |
| (`!v. valuation (LOWMOD M) v | |
| ==> !t. termval (LOWMOD M) v t = | |
| num_of_term (termval M (term_of_num o v) t)`, | |
| GEN_TAC THEN DISCH_THEN | |
| (ASSUME_TAC o REWRITE_RULE[valuation; LOWMOD; Dom_DEF; IN_ELIM_THM]) THEN | |
| MATCH_MP_TAC term_INDUCT THEN REWRITE_TAC[termval; o_THM] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[TERM_OF_NUM]; ALL_TAC] THEN | |
| REWRITE_TAC[LOWMOD; Fun_DEF] THEN REWRITE_TAC[GSYM LOWMOD] THEN | |
| REPEAT STRIP_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[GSYM MAP_o] THEN MATCH_MP_TAC MAP_EQ THEN | |
| MATCH_MP_TAC ALL_IMP THEN | |
| FIRST_ASSUM(EXISTS_TAC o lhand o concl) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[o_THM; TERM_OF_NUM]);; | |
| let LOWMOD_HOLDS = prove | |
| (`!p v. valuation (LOWMOD M) v | |
| ==> (holds (LOWMOD M) v p <=> holds M (term_of_num o v) p)`, | |
| MATCH_MP_TAC form_INDUCTION THEN | |
| REWRITE_TAC[holds] THEN REPEAT CONJ_TAC THENL | |
| [REPEAT STRIP_TAC THEN REWRITE_TAC[LOWMOD; Pred_DEF] THEN | |
| REWRITE_TAC[GSYM LOWMOD] THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[GSYM MAP_o] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[FUN_EQ_THM; o_THM] THEN | |
| ASM_SIMP_TAC[LOWMOD_TERMVAL; TERM_OF_NUM]; | |
| MESON_TAC[]; | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[Dom_DEF; LOWMOD] THEN REWRITE_TAC[GSYM LOWMOD] THEN | |
| SUBGOAL_THEN `!a. a IN {num_of_term t | t IN Dom M} | |
| ==> valuation (LOWMOD M) (valmod (a0:num,a) v)` | |
| MP_TAC THENL | |
| [GEN_TAC THEN REWRITE_TAC[valuation; valmod; LOWMOD; Dom_DEF] THEN | |
| CONV_TAC(ONCE_DEPTH_CONV COND_ELIM_CONV) THEN | |
| REWRITE_TAC[IN_ELIM_THM] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[valuation; LOWMOD; Dom_DEF; IN_ELIM_THM]) THEN | |
| ASM_MESON_TAC[]; ALL_TAC] THEN | |
| DISCH_THEN(fun th -> ASM_SIMP_TAC[th]) THEN | |
| SUBGOAL_THEN `!P. (!a. a IN {num_of_term t | t IN Dom(M)} ==> P(a)) <=> | |
| (!a. a IN Dom(M) ==> P(num_of_term a))` | |
| (fun th -> REWRITE_TAC[th]) | |
| THENL [REWRITE_TAC[IN_ELIM_THM] THEN MESON_TAC[]; ALL_TAC] THEN | |
| AP_TERM_TAC THEN ABS_TAC THEN | |
| MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> ((a ==> b) <=> (a ==> c))`) THEN | |
| DISCH_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[valmod; FUN_EQ_THM; o_THM] THEN | |
| GEN_TAC THEN COND_CASES_TAC THEN REWRITE_TAC[TERM_OF_NUM]]);; | |
| let LOWMOD_INTERPRETATION = prove | |
| (`!L M. interpretation L (LOWMOD M) = interpretation L M`, | |
| REWRITE_TAC[FORALL_PAIR_THM; interpretation] THEN | |
| REWRITE_TAC[Fun_DEF; Dom_DEF; LOWMOD] THEN | |
| SUBGOAL_THEN `!P x. num_of_term x IN {num_of_term y | P y} <=> x IN P` | |
| (fun th -> REWRITE_TAC[th]) THENL | |
| [REWRITE_TAC[IN_ELIM_THM; IN; NUM_OF_TERM_INJ] THEN MESON_TAC[]; | |
| ALL_TAC] THEN | |
| REPEAT GEN_TAC THEN AP_TERM_TAC THEN ABS_TAC THEN | |
| EQ_TAC THEN DISCH_TAC THEN | |
| LIST_INDUCT_TAC THEN REWRITE_TAC[ALL; MAP; LENGTH] THENL | |
| [DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC `[] :num list`) THEN | |
| ASM_REWRITE_TAC[ALL; MAP; LENGTH] THEN | |
| REWRITE_TAC[IN] THEN CONV_TAC(ONCE_DEPTH_CONV ETA_CONV); | |
| STRIP_TAC THEN FIRST_X_ASSUM | |
| (MP_TAC o SPEC `CONS (num_of_term h) (MAP num_of_term t)`) THEN | |
| ASM_REWRITE_TAC[ALL; MAP; LENGTH; LENGTH_MAP] THEN | |
| REWRITE_TAC[ALL_MAP; IN_ELIM_THM] THEN | |
| W(C SUBGOAL_THEN (fun th -> REWRITE_TAC[th]) o funpow 2 lhand o snd) THENL | |
| [CONJ_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN | |
| MATCH_MP_TAC ALL_IMP THEN | |
| FIRST_ASSUM(EXISTS_TAC o lhand o concl) THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[o_THM; NUM_OF_TERM_INJ] THEN ASM_MESON_TAC[]; ALL_TAC] THEN | |
| REWRITE_TAC[TERM_OF_NUM; GSYM MAP_o; o_DEF] THEN | |
| SIMP_TAC[MAP_EQ_DEGEN; ALL_T]; | |
| DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC `[] :term list`) THEN | |
| ASM_REWRITE_TAC[ALL; MAP; LENGTH] THEN | |
| REWRITE_TAC[IN] THEN CONV_TAC(ONCE_DEPTH_CONV ETA_CONV); | |
| STRIP_TAC THEN FIRST_X_ASSUM | |
| (MP_TAC o SPEC `CONS (term_of_num h) (MAP term_of_num t)`) THEN | |
| ASM_REWRITE_TAC[ALL; MAP; LENGTH; LENGTH_MAP] THEN | |
| W(C SUBGOAL_THEN (fun th -> REWRITE_TAC[th]) o funpow 2 lhand o snd) THENL | |
| [CONJ_TAC THENL | |
| [RULE_ASSUM_TAC(REWRITE_RULE[IN_ELIM_THM]) THEN | |
| ASM_MESON_TAC[TERM_OF_NUM]; ALL_TAC] THEN | |
| REWRITE_TAC[ALL_MAP] THEN MATCH_MP_TAC ALL_IMP THEN | |
| FIRST_ASSUM(EXISTS_TAC o lhand o concl) THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[IN_ELIM_THM; o_THM] THEN MESON_TAC[TERM_OF_NUM]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[IN] THEN CONV_TAC(ONCE_DEPTH_CONV ETA_CONV)]);; | |
| let LS = prove | |
| (`!M:(A->bool)#(num->A list->A)#(num->A list->bool) s. | |
| interpretation (language s) M /\ | |
| ~(Dom(M) = EMPTY) /\ | |
| (!p. p IN s ==> qfree p) /\ M satisfies s | |
| ==> ?N. interpretation (language s) N /\ | |
| ~(Dom N :num->bool = EMPTY) /\ | |
| N satisfies s`, | |
| REPEAT GEN_TAC THEN | |
| DISCH_THEN(STRIP_ASSUME_TAC o MATCH_MP CANON) THEN | |
| EXISTS_TAC `LOWMOD C` THEN | |
| ASM_REWRITE_TAC[LOWMOD_DOM_EMPTY; LOWMOD_INTERPRETATION] THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [satisfies]) THEN | |
| REWRITE_TAC[satisfies] THEN SIMP_TAC[LOWMOD_HOLDS] THEN | |
| REPEAT STRIP_TAC THEN FIRST_ASSUM MATCH_MP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [valuation]) THEN | |
| ASM_REWRITE_TAC[valuation] THEN REWRITE_TAC[LOWMOD; Dom_DEF] THEN | |
| REWRITE_TAC[IN_ELIM_THM; o_THM] THEN | |
| MESON_TAC[TERM_OF_NUM]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Now the Uniformity Lemma. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let UNIFORMITY = prove | |
| (`qfree p /\ (!C v. ~(Dom C = EMPTY) /\ | |
| valuation(C) v ==> holds C (v:num->term) (ITLIST ?? xs p)) | |
| ==> ?is. (!i x. MEM i is ==> terms(FST(language {p})) (i x)) /\ | |
| !d. pholds(d) (ITLIST (||) (MAP (\i. formsubst i p) is) False)`, | |
| STRIP_TAC THEN | |
| MP_TAC(SPEC `{formsubst i q | q IN {p} /\ | |
| (!x. i x IN terms(FST(language {p})))}` | |
| COMPACT_DISJ) THEN | |
| W(C SUBGOAL_THEN (fun th -> REWRITE_TAC[th]) o funpow 2 lhand o snd) THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[IN_INSERT; NOT_IN_EMPTY; IN_ELIM_THM; GSYM CONJ_ASSOC] THEN | |
| REWRITE_TAC[UNWIND_THM2] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `ps:form list` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `MAP (\q. @i. (!x. i x IN terms (FST (language {p}))) /\ | |
| (q = formsubst i p)) ps` THEN | |
| REWRITE_TAC[GSYM MAP_o; o_DEF] THEN CONJ_TAC THENL | |
| [REPEAT GEN_TAC THEN | |
| FIRST_ASSUM | |
| (UNDISCH_TAC o check ((=) `ps:form list` o rand) o concl) THEN | |
| SPEC_TAC(`ps:form list`,`ps:form list`) THEN | |
| LIST_INDUCT_TAC THEN REWRITE_TAC[ALL; MAP; MEM] THEN | |
| DISCH_TAC THEN DISCH_THEN(DISJ_CASES_THEN MP_TAC) THENL | |
| [ALL_TAC; FIRST_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[]] THEN | |
| FIRST_ASSUM(ASSUME_TAC o SELECT_RULE o CONJUNCT1) THEN | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[IN] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[IN]) THEN | |
| FIRST_ASSUM(MATCH_ACCEPT_TAC o CONJUNCT1 o SPEC_ALL); | |
| X_GEN_TAC `d:form->bool` THEN | |
| FIRST_ASSUM(MP_TAC o SPEC `d:form->bool`) THEN | |
| MATCH_MP_TAC EQ_IMP THEN | |
| AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN | |
| MATCH_MP_TAC(GSYM MAP_EQ_DEGEN) THEN | |
| FIRST_ASSUM | |
| (UNDISCH_TAC o check ((=) `ps:form list` o rand) o concl) THEN | |
| SPEC_TAC(`ps:form list`,`ps:form list`) THEN | |
| LIST_INDUCT_TAC THEN REWRITE_TAC[ALL; MAP; MEM] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 (ASSUME_TAC o SELECT_RULE) ASSUME_TAC) THEN | |
| CONJ_TAC THENL [FIRST_ASSUM(MATCH_ACCEPT_TAC o CONJUNCT2); ALL_TAC] THEN | |
| MATCH_MP_TAC ALL_IMP THEN | |
| FIRST_ASSUM(fun th -> EXISTS_TAC(lhand(concl th)) THEN | |
| CONJ_TAC THENL [ALL_TAC; FIRST_ASSUM ACCEPT_TAC]) THEN | |
| X_GEN_TAC `r:form` THEN REWRITE_TAC[] THEN | |
| DISCH_THEN(MP_TAC o SELECT_RULE o CONJUNCT2) THEN | |
| DISCH_THEN(ACCEPT_TAC o CONJUNCT2)]] THEN | |
| X_GEN_TAC `d:form->bool` THEN | |
| SUBGOAL_THEN `~((canon_of_prop (language {p}) d) satisfies {(Not p)})` | |
| ASSUME_TAC THENL | |
| [REWRITE_TAC[satisfies; IN_INSERT; NOT_IN_EMPTY] THEN STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `canon_of_prop (language {p}) d`) THEN | |
| REWRITE_TAC[HOLDS_ITLIST_EXISTS; NOT_FORALL_THM; NOT_IMP] THEN | |
| SUBGOAL_THEN `?v:num->term. valuation (canon_of_prop (language {p}) d) v` | |
| CHOOSE_TAC THENL | |
| [MATCH_MP_TAC VALUATION_EXISTS THEN | |
| REWRITE_TAC[GSYM MEMBER_NOT_EMPTY] THEN | |
| REWRITE_TAC[Dom_DEF; canon_of_prop; IN] THEN | |
| MESON_TAC[terms_RULES]; ALL_TAC] THEN | |
| EXISTS_TAC `v:num->term` THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THENL | |
| [REWRITE_TAC[canon_of_prop; Dom_DEF] THEN | |
| REWRITE_TAC[language; EXTENSION; NOT_IN_EMPTY; NOT_FORALL_THM] THEN | |
| EXISTS_TAC `V 0` THEN REWRITE_TAC[IN] THEN MESON_TAC[terms_CASES]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[NOT_EXISTS_THM] THEN | |
| REWRITE_TAC[TAUT `~(a /\ b /\ c) <=> a /\ b ==> ~c`] THEN | |
| REWRITE_TAC[GSYM HOLDS] THEN REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM MATCH_MP_TAC THEN | |
| REWRITE_TAC[valuation; IN] THEN GEN_TAC THEN | |
| UNDISCH_TAC `valuation (canon_of_prop (language {p}) d) (v:num->term)` THEN | |
| SPEC_TAC(`v:num->term`,`v:num->term`) THEN | |
| UNDISCH_TAC `ALL (Dom (canon_of_prop (language {p}) d)) as` THEN | |
| UNDISCH_TAC `LENGTH (as:term list) = LENGTH (xs:num list)` THEN | |
| SPEC_TAC(`as:term list`,`as:term list`) THEN | |
| SPEC_TAC(`xs:num list`,`xs:num list`) THEN | |
| LIST_INDUCT_TAC THEN LIST_INDUCT_TAC THEN | |
| REWRITE_TAC[LENGTH; NOT_SUC; MAP2; REVERSE; ITLIST; ALL] THENL | |
| [REWRITE_TAC[valuation; IN] THEN MESON_TAC[]; ALL_TAC] THEN | |
| REWRITE_TAC[SUC_INJ; ITLIST_EXTRA] THEN | |
| DISCH_THEN(ANTE_RES_THEN ASSUME_TAC) THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN | |
| DISCH_THEN(ANTE_RES_THEN ASSUME_TAC) THEN | |
| REPEAT STRIP_TAC THEN FIRST_ASSUM MATCH_MP_TAC THEN | |
| REWRITE_TAC[valuation; valmod] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[valuation]) THEN | |
| GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN | |
| ASM_REWRITE_TAC[IN]; ALL_TAC] THEN | |
| SUBGOAL_THEN `!q. q IN {(Not p)} ==> qfree q` ASSUME_TAC THENL | |
| [REWRITE_TAC[IN_INSERT; NOT_IN_EMPTY] THEN | |
| REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[QFREE]; ALL_TAC] THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP | |
| (GEN_REWRITE_RULE I [GSYM CONTRAPOS_THM] PSATISFIES_INSTANCES)) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[psatisfies; IN_ELIM_THM; IN_INSERT; NOT_IN_EMPTY] THEN | |
| REWRITE_TAC[RIGHT_EXISTS_AND_THM; GSYM CONJ_ASSOC] THEN | |
| REWRITE_TAC[UNWIND_THM2] THEN | |
| REWRITE_TAC[Not_DEF; formsubst] THEN REWRITE_TAC[GSYM Not_DEF] THEN | |
| MESON_TAC[el 3 (CONJUNCTS PHOLDS)]);; | |