Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
| (* ========================================================================= *) | |
| (* Quick sort algorithm. *) | |
| (* *) | |
| (* Author: Marco Maggesi *) | |
| (* University of Florence, Italy *) | |
| (* http://www.math.unifi.it/~maggesi/ *) | |
| (* *) | |
| (* (c) Copyright, Marco Maggesi, 2005-2007 *) | |
| (* ========================================================================= *) | |
| needs "Permutation/permuted.ml";; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Ordered lists. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let ORDERED_RULES, ORDERED_INDUCT, ORDERED_CASES = new_inductive_definition | |
| `(!le. ORDERED le []) /\ | |
| (!le h t. ORDERED le t /\ ALL (le h) t ==> ORDERED le (CONS h t))`;; | |
| let ORDERED_CONS = prove | |
| (`!le (h:A) t. ORDERED le (h :: t) <=> (ORDERED le t /\ ALL (le h) t)`, | |
| SUBGOAL_THEN | |
| `!le (h:A) t. ORDERED le (h :: t) ==> (ORDERED le t /\ ALL (le h) t)` | |
| (fun th -> MESON_TAC [th; ORDERED_RULES]) THEN | |
| REPEAT GEN_TAC THEN | |
| DISCH_THEN (MP_TAC o ONCE_REWRITE_RULE [ORDERED_CASES]) THEN | |
| REWRITE_TAC [NOT_CONS_NIL; CONS_11] THEN MESON_TAC []);; | |
| let ORDERED_APPEND = prove | |
| (`!l1 l2:A list. | |
| ORDERED le (APPEND l1 l2) <=> | |
| ORDERED le l1 /\ ORDERED le l2 /\ ALL (\x. ALL (le x) l2) l1`, | |
| SUBGOAL_THEN | |
| `(!l1 l2:A list. | |
| ORDERED le (APPEND l1 l2) | |
| ==> ORDERED le l1 /\ ORDERED le l2 /\ ALL (\x. ALL (le x) l2) l1) /\ | |
| (!l1 l2. ORDERED le l1 /\ ORDERED le l2 /\ ALL (\x. ALL (le x) l2) l1 | |
| ==> ORDERED le (APPEND l1 l2))` | |
| (fun th -> MESON_TAC [th]) THEN | |
| CONJ_TAC THEN LIST_INDUCT_TAC THEN | |
| REWRITE_TAC [APPEND; ALL; ORDERED_RULES; ORDERED_CONS] THEN | |
| ASM_SIMP_TAC [ORDERED_CONS; ALL_APPEND] THEN ASM_MESON_TAC [ALL_APPEND]);; | |
| let ORDERED_PAIRWISE = prove | |
| (`ORDERED = PAIRWISE`, | |
| REWRITE_TAC[FUN_EQ_THM] THEN GEN_TAC THEN | |
| MATCH_MP_TAC list_INDUCT THEN REWRITE_TAC[PAIRWISE; ORDERED_RULES] THEN | |
| SIMP_TAC[ORDERED_CONS] THEN MESON_TAC[]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Quick Sort. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let QSORT = | |
| let PROVE_RECURSIVE_FUNCTION_EXISTS_TAC : tactic = fun g -> | |
| let th = pure_prove_recursive_function_exists (snd g) in | |
| MATCH_MP_TAC (DISCH_ALL th) g in | |
| new_specification ["QSORT"] (prove | |
| (`?f. (!le. f le [] = [] : A list) /\ | |
| (!le h t. f le (CONS h t) = | |
| APPEND (f le (FILTER (\x. ~le h x) t)) | |
| (CONS h (f le (FILTER (\x. le h x) t))))`, | |
| REWRITE_TAC [GSYM SKOLEM_THM; AND_FORALL_THM] THEN GEN_TAC THEN | |
| PROVE_RECURSIVE_FUNCTION_EXISTS_TAC THEN | |
| EXISTS_TAC `MEASURE (LENGTH:A list -> num)` THEN | |
| REWRITE_TAC [WF_MEASURE; MEASURE; LENGTH; FILTER] THEN | |
| REWRITE_TAC [LT_SUC_LE; LENGTH_FILTER_LE]));; | |
| let COUNT_QSORT = prove | |
| (`!le x l. COUNT x (QSORT le l) = COUNT x l`, | |
| GEN_TAC THEN GEN_TAC THEN MATCH_MP_TAC list_WF THEN LIST_INDUCT_TAC THEN | |
| REWRITE_TAC [QSORT; COUNT; LENGTH; LT_SUC_LE; COUNT_APPEND] THEN | |
| DISCH_TAC THEN ASM_SIMP_TAC [COUNT; LENGTH_FILTER_LE] THEN | |
| REWRITE_TAC [COUNT_FILTER] THEN | |
| REPEAT (ASM_REWRITE_TAC [ADD; ADD_SUC; ADD_0] THEN COND_CASES_TAC) THEN | |
| ASM_MESON_TAC[ADD_SUC]);; | |
| let QSORT_PERMUTED = prove | |
| (`!le (l:A list). QSORT le l PERMUTED l`, | |
| REWRITE_TAC [PERMUTED_COUNT; COUNT_QSORT]);; | |
| let ALL_QSORT = prove | |
| (`!P le l. ALL P (QSORT le l) <=> ALL P l`, | |
| MESON_TAC [QSORT_PERMUTED; PERMUTED_ALL]);; | |
| let LENGTH_QSORT = prove | |
| (`!le l. LENGTH (QSORT le l) = LENGTH l`, | |
| MESON_TAC [QSORT_PERMUTED; PERMUTED_LENGTH]);; | |
| let MEM_QSORT = prove | |
| (`!le l x. MEM x (QSORT le l) <=> MEM x l`, | |
| MESON_TAC [QSORT_PERMUTED; PERMUTED_MEM]);; | |
| let ORDERED_QSORT = prove | |
| (`!le (l:A list). | |
| (!x y. le x y \/ le y x) /\ (!x y z. le x y \/ le y z ==> le x z) | |
| ==> ORDERED le (QSORT le l)`, | |
| REWRITE_TAC [GSYM RIGHT_IMP_FORALL_THM] THEN GEN_TAC THEN STRIP_TAC THEN | |
| MATCH_MP_TAC list_WF THEN LIST_CASES_TAC THEN | |
| REWRITE_TAC [QSORT; LENGTH; ORDERED_RULES; LT_SUC_LE] THEN DISCH_TAC THEN | |
| REWRITE_TAC [ORDERED_APPEND; ORDERED_CONS; ALL; ALL_QSORT; ALL_T] THEN | |
| ASM_SIMP_TAC [LENGTH_FILTER_LE] THEN REWRITE_TAC [GSYM ALL_MEM] THEN | |
| ASM_MESON_TAC[]);; | |
| (* Example: | |
| REWRITE_CONV [QSORT; ARITH_LE; ARITH_LT; FILTER; APPEND] | |
| `QSORT (<=) [12;3;5;1;23;2;1]`;; | |
| *) | |