Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
File size: 4,845 Bytes
4365a98 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
(* ========================================================================= *)
(* 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]`;;
*)
|