Datasets:

Modalities:
Text
Languages:
English
Libraries:
Datasets
License:
Zhangir Azerbayev
squashed?
4365a98
raw
history blame
63.7 kB
(* ========================================================================= *)
(* Implementation of Cooper's algorithm via proforma theorems. *)
(* ========================================================================= *)
prioritize_int();;
(* ------------------------------------------------------------------------- *)
(* Basic syntax on integer terms. *)
(* ------------------------------------------------------------------------- *)
let dest_mul = dest_binop `(*)`;;
let dest_add = dest_binop `(+)`;;
(* ------------------------------------------------------------------------- *)
(* Divisibility. *)
(* ------------------------------------------------------------------------- *)
parse_as_infix("divides",(12,"right"));;
let divides = new_definition
`a divides b <=> ?x. b = a * x`;;
(* ------------------------------------------------------------------------- *)
(* Trivial lemmas about integers. *)
(* ------------------------------------------------------------------------- *)
let INT_DOWN2 = prove
(`!a b. ?c. !x. x < c ==> x < a /\ x < b`,
MESON_TAC[INT_LE_TOTAL; INT_LET_TRANS]);;
(* ------------------------------------------------------------------------- *)
(* Trivial lemmas about divisibility. *)
(* ------------------------------------------------------------------------- *)
let DIVIDES_ADD = prove
(`!d a b. d divides a /\ d divides b ==> d divides (a + b)`,
MESON_TAC[divides; INT_ADD_LDISTRIB]);;
let DIVIDES_SUB = prove
(`!d a b. d divides a /\ d divides b ==> d divides (a - b)`,
MESON_TAC[divides; INT_SUB_LDISTRIB]);;
let DIVIDES_ADD_REVR = prove
(`!d a b. d divides a /\ d divides (a + b) ==> d divides b`,
MESON_TAC[DIVIDES_SUB; INT_ARITH `(a + b) - a = b`]);;
let DIVIDES_ADD_REVL = prove
(`!d a b. d divides b /\ d divides (a + b) ==> d divides a`,
MESON_TAC[DIVIDES_SUB; INT_ARITH `(a + b) - b = a`]);;
let DIVIDES_LMUL = prove
(`!d a x. d divides a ==> d divides (x * a)`,
ASM_MESON_TAC[divides; INT_ARITH `a * b * c = b * a * c`]);;
let DIVIDES_RNEG = prove
(`!d a. d divides (--a) <=> d divides a`,
REWRITE_TAC[divides] THEN MESON_TAC[INT_MUL_RNEG; INT_NEG_NEG]);;
let DIVIDES_LNEG = prove
(`!d a. (--d) divides a <=> d divides a`,
REWRITE_TAC[divides] THEN
MESON_TAC[INT_MUL_RNEG; INT_MUL_LNEG; INT_NEG_NEG]);;
(* ------------------------------------------------------------------------- *)
(* More specialized lemmas (see footnotes on p4 and p5). *)
(* ------------------------------------------------------------------------- *)
let INT_DOWN_MUL_LT = prove
(`!x y d. &0 < d ==> ?c. x + c * d < y`,
MESON_TAC[INT_ARCH; INT_LT_REFL;
INT_ARITH `x - y < c * d <=> x + --c * d < y`]);;
let INT_MOD_LEMMA = prove
(`!d x. &0 < d ==> ?c. &1 <= x + c * d /\ x + c * d <= d`,
REPEAT STRIP_TAC THEN
FIRST_ASSUM(MP_TAC o SPECL [`x:int`; `&0`] o MATCH_MP INT_DOWN_MUL_LT) THEN
DISCH_THEN(X_CHOOSE_TAC `c0:int`) THEN
SUBGOAL_THEN `?c1. &0 <= c1 /\ --(x + c0 * d) < c1 * d` MP_TAC THENL
[SUBGOAL_THEN `?c1. --(x + c0 * d) < c1 * d` MP_TAC THENL
[ASM_MESON_TAC[INT_ARCH; INT_ARITH `&0 < d ==> ~(d = &0)`]; ALL_TAC] THEN
MATCH_MP_TAC MONO_EXISTS THEN GEN_TAC THEN SIMP_TAC[] THEN
MATCH_MP_TAC(INT_ARITH
`(&0 < --c1 ==> &0 < --cd) /\ xcod < &0
==> --xcod < cd ==> &0 <= c1`) THEN
ASM_SIMP_TAC[GSYM INT_MUL_LNEG; INT_LT_MUL]; ALL_TAC] THEN
REWRITE_TAC[TAUT `a /\ b <=> ~(a ==> ~b)`; GSYM NOT_FORALL_THM] THEN
REWRITE_TAC[GSYM INT_FORALL_POS] THEN
REWRITE_TAC[NOT_FORALL_THM] THEN GEN_REWRITE_TAC LAND_CONV [num_WOP] THEN
REWRITE_TAC[INT_ARITH `--(x + a * d) < b * d <=> &1 <= x + (a + b) * d`] THEN
DISCH_THEN(X_CHOOSE_THEN `n:num` STRIP_ASSUME_TAC) THEN
EXISTS_TAC `c0 + &n` THEN ASM_REWRITE_TAC[] THEN
FIRST_X_ASSUM(MP_TAC o SPEC `n - 1`) THEN
UNDISCH_TAC `&1 <= x + (c0 + &n) * d` THEN SPEC_TAC(`n:num`,`n:num`) THEN
INDUCT_TAC THEN REWRITE_TAC[ARITH_RULE `SUC n - 1 = n`] THENL
[REWRITE_TAC[SUB_0; LT_REFL; INT_ADD_RID] THEN
POP_ASSUM_LIST(MP_TAC o end_itlist CONJ) THEN INT_ARITH_TAC;
REWRITE_TAC[GSYM INT_OF_NUM_SUC; LT] THEN INT_ARITH_TAC]);;
(* ------------------------------------------------------------------------- *)
(* Shadow for restricted class of formulas. *)
(* ------------------------------------------------------------------------- *)
let cform_INDUCT,cform_RECURSION = define_type
"cform = Lt int
| Gt int
| Eq int
| Ne int
| Divides int int
| Ndivides int int
| And cform cform
| Or cform cform
| Nox bool";;
(* ------------------------------------------------------------------------- *)
(* Interpretation of a cform. *)
(* ------------------------------------------------------------------------- *)
let interp = new_recursive_definition cform_RECURSION
`(interp x (Lt e) <=> x + e < &0) /\
(interp x (Gt e) <=> x + e > &0) /\
(interp x (Eq e) <=> (x + e = &0)) /\
(interp x (Ne e) <=> ~(x + e = &0)) /\
(interp x (Divides c e) <=> c divides (x + e)) /\
(interp x (Ndivides c e) <=> ~(c divides (x + e))) /\
(interp x (And p q) <=> interp x p /\ interp x q) /\
(interp x (Or p q) <=> interp x p \/ interp x q) /\
(interp x (Nox P) <=> P)`;;
(* ------------------------------------------------------------------------- *)
(* The "minus infinity" and "plus infinity" variants. *)
(* ------------------------------------------------------------------------- *)
let minusinf = new_recursive_definition cform_RECURSION
`(minusinf (Lt e) = Nox T) /\
(minusinf (Gt e) = Nox F) /\
(minusinf (Eq e) = Nox F) /\
(minusinf (Ne e) = Nox T) /\
(minusinf (Divides c e) = Divides c e) /\
(minusinf (Ndivides c e) = Ndivides c e) /\
(minusinf (And p q) = And (minusinf p) (minusinf q)) /\
(minusinf (Or p q) = Or (minusinf p) (minusinf q)) /\
(minusinf (Nox P) = Nox P)`;;
let plusinf = new_recursive_definition cform_RECURSION
`(plusinf (Lt e) = Nox F) /\
(plusinf (Gt e) = Nox T) /\
(plusinf (Eq e) = Nox F) /\
(plusinf (Ne e) = Nox T) /\
(plusinf (Divides c e) = Divides c e) /\
(plusinf (Ndivides c e) = Ndivides c e) /\
(plusinf (And p q) = And (plusinf p) (plusinf q)) /\
(plusinf (Or p q) = Or (plusinf p) (plusinf q)) /\
(plusinf (Nox P) = Nox P)`;;
(* ------------------------------------------------------------------------- *)
(* All the "dividing" things divide the given constant (e.g. their LCM). *)
(* ------------------------------------------------------------------------- *)
let alldivide = new_recursive_definition cform_RECURSION
`(alldivide d (Lt e) <=> T) /\
(alldivide d (Gt e) <=> T) /\
(alldivide d (Eq e) <=> T) /\
(alldivide d (Ne e) <=> T) /\
(alldivide d (Divides c e) <=> c divides d) /\
(alldivide d (Ndivides c e) <=> c divides d) /\
(alldivide d (And p q) <=> alldivide d p /\ alldivide d q) /\
(alldivide d (Or p q) <=> alldivide d p /\ alldivide d q) /\
(alldivide d (Nox P) <=> T)`;;
(* ------------------------------------------------------------------------- *)
(* A-sets and B-sets. *)
(* ------------------------------------------------------------------------- *)
let aset = new_recursive_definition cform_RECURSION
`(aset (Lt e) = {(--e)}) /\
(aset (Gt e) = {}) /\
(aset (Eq e) = {(--e + &1)}) /\
(aset (Ne e) = {(--e)}) /\
(aset (Divides c e) = {}) /\
(aset (Ndivides c e) = {}) /\
(aset (And p q) = (aset p) UNION (aset q)) /\
(aset (Or p q) = (aset p) UNION (aset q)) /\
(aset (Nox P) = {})`;;
let bset = new_recursive_definition cform_RECURSION
`(bset (Lt e) = {}) /\
(bset (Gt e) = {(--e)}) /\
(bset (Eq e) = {(--(e + &1))}) /\
(bset (Ne e) = {(--e)}) /\
(bset (Divides c e) = {}) /\
(bset (Ndivides c e) = {}) /\
(bset (And p q) = (bset p) UNION (bset q)) /\
(bset (Or p q) = (bset p) UNION (bset q)) /\
(bset (Nox P) = {})`;;
(* ------------------------------------------------------------------------- *)
(* The key minimality case analysis for the integers. *)
(* ------------------------------------------------------------------------- *)
let INT_EXISTS_CASES = prove
(`(?x. P x) <=> (!y. ?x. x < y /\ P x) \/ (?x. P x /\ !y. y < x ==> ~P y)`,
EQ_TAC THENL [ALL_TAC; MESON_TAC[]] THEN
DISCH_THEN(X_CHOOSE_TAC `x:int`) THEN
MATCH_MP_TAC(TAUT `(~b ==> a) ==> a \/ b`) THEN
REWRITE_TAC[NOT_EXISTS_THM; TAUT `~(p /\ q) <=> p ==> ~q`; NOT_FORALL_THM;
NOT_IMP] THEN
STRIP_TAC THEN X_GEN_TAC `y:int` THEN
DISJ_CASES_TAC(INT_ARITH `x < y \/ &0 <= x - y`) THENL
[ASM_MESON_TAC[]; ALL_TAC] THEN
SUBGOAL_THEN `!n. ?y. y < x - &n /\ P y` MP_TAC THENL
[ALL_TAC;
REWRITE_TAC[INT_FORALL_POS] THEN
DISCH_THEN(MP_TAC o SPEC `x - y`) THEN
ASM_REWRITE_TAC[INT_ARITH `x - (x - y) = y`]] THEN
INDUCT_TAC THEN
REWRITE_TAC[INT_SUB_RZERO; GSYM INT_OF_NUM_SUC] THEN
ASM_MESON_TAC[INT_ARITH `z < y /\ y < x - &n ==> z < x - (&n + &1)`]);;
(* ------------------------------------------------------------------------- *)
(* Lemmas towards the main theorems (following my book). *)
(* ------------------------------------------------------------------------- *)
let MINUSINF_LEMMA = prove
(`!p. ?y. !x. x < y ==> (interp x p <=> interp x (minusinf p))`,
MATCH_MP_TAC cform_INDUCT THEN
REWRITE_TAC[interp; minusinf] THEN
MATCH_MP_TAC(TAUT
`(a /\ b /\ c /\ d) /\ (e /\ f) ==> a /\ b /\ c /\ d /\ e /\ f`) THEN
CONJ_TAC THENL
[MESON_TAC[INT_ARITH `x < --a ==> x + a < &0`; INT_GT;
INT_LT_ANTISYM; INT_LT_REFL];
ALL_TAC] THEN
CONJ_TAC THEN REPEAT GEN_TAC THEN
REWRITE_TAC[LEFT_AND_EXISTS_THM;
RIGHT_AND_EXISTS_THM; LEFT_IMP_EXISTS_THM] THEN
MAP_EVERY X_GEN_TAC [`a:int`; `b:int`] THEN STRIP_TAC THEN
MP_TAC(SPECL [`a:int`; `b:int`] INT_DOWN2) THEN
MATCH_MP_TAC MONO_EXISTS THEN ASM_SIMP_TAC[]);;
let MINUSINF_REPEATS = prove
(`!p c d x. alldivide d p
==> (interp x (minusinf p) <=> interp (x + c * d) (minusinf p))`,
CONV_TAC(ONCE_DEPTH_CONV SYM_CONV) THEN MATCH_MP_TAC cform_INDUCT THEN
SIMP_TAC[interp; minusinf; alldivide] THEN
ONCE_REWRITE_TAC[INT_ARITH `(x + d) + y = (x + y) + d`] THEN
MESON_TAC[DIVIDES_LMUL; DIVIDES_ADD_REVL; DIVIDES_ADD]);;
let NOMINIMAL_EQUIV = prove
(`alldivide d p /\ &0 < d
==> ((!y. ?x. x < y /\ interp x p) <=>
?j. &1 <= j /\ j <= d /\ interp j (minusinf p))`,
ASM_MESON_TAC[MINUSINF_LEMMA; MINUSINF_REPEATS; INT_DOWN_MUL_LT;
INT_DOWN2; INT_MOD_LEMMA]);;
let BDISJ_REPEATS_LEMMA = prove
(`!d p. alldivide d p /\ &0 < d
==> !x. interp x p /\ ~(interp (x - d) p)
==> ?j b. &1 <= j /\ j <= d /\ b IN bset p /\ (x = b + j)`,
GEN_TAC THEN ONCE_REWRITE_TAC[TAUT `a /\ b ==> c <=> b ==> a ==> c`] THEN
REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN DISCH_TAC THEN
MATCH_MP_TAC cform_INDUCT THEN
REWRITE_TAC[interp; alldivide; bset; NOT_IN_EMPTY] THEN
MATCH_MP_TAC(TAUT `(a /\ b /\ c /\ d /\ e /\ f) /\ g /\ h
==> a /\ b /\ c /\ d /\ e /\ f /\ g /\ h`) THEN
CONJ_TAC THENL
[ALL_TAC;
SIMP_TAC[TAUT `~a \/ a`;
TAUT `(a \/ b) /\ c <=> a /\ c \/ b /\ c`;
TAUT `a /\ (b \/ c) <=> a /\ b \/ a /\ c`;
TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`;
DE_MORGAN_THM; IN_UNION; EXISTS_OR_THM; FORALL_AND_THM]] THEN
REPEAT STRIP_TAC THENL
[ALL_TAC;
MAP_EVERY EXISTS_TAC [`x + a`; `--a`];
MAP_EVERY EXISTS_TAC [`&1`; `--a - &1`];
MAP_EVERY EXISTS_TAC [`d:int`; `--a`];
ASM_MESON_TAC[INT_ARITH `(x - y) + z = (x + z) - y`; DIVIDES_SUB];
ASM_MESON_TAC[INT_ARITH `(x - y) + z = (x + z) - y`;
INT_ARITH `(x - y) + y = x`; DIVIDES_ADD]] THEN
POP_ASSUM_LIST(MP_TAC o end_itlist CONJ) THEN
REWRITE_TAC[IN_SING] THEN INT_ARITH_TAC);;
let MAINTHM_B = prove
(`!p d. alldivide d p /\ &0 < d
==> ((?x. interp x p) <=>
?j. &1 <= j /\ j <= d /\
(interp j (minusinf p) \/
?b. b IN bset p /\ interp (b + j) p))`,
REPEAT GEN_TAC THEN DISCH_TAC THEN
REWRITE_TAC[TAUT `a /\ (b \/ c) <=> a /\ b \/ a /\ c`; EXISTS_OR_THM] THEN
MATCH_MP_TAC(TAUT
`!a1 a2. (a <=> a1 \/ a2) /\ (a1 <=> b) /\ (a2 ==> c) /\ (c ==> a)
==> (a <=> b \/ c)`) THEN
EXISTS_TAC `!y. ?x. x < y /\ interp x p` THEN
EXISTS_TAC `?x. interp x p /\ !y. y < x ==> ~(interp y p)` THEN
REPEAT CONJ_TAC THENL
[REWRITE_TAC[GSYM INT_EXISTS_CASES];
ASM_MESON_TAC[NOMINIMAL_EQUIV];
ALL_TAC;
MESON_TAC[]] THEN
DISCH_THEN(X_CHOOSE_THEN `x:int`
(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC `x - d`))) THEN
ASM_SIMP_TAC[INT_ARITH `&0 < d ==> x - d < x`] THEN
DISCH_TAC THEN
MP_TAC(SPECL [`d:int`; `p:cform`] BDISJ_REPEATS_LEMMA) THEN
ASM_REWRITE_TAC[] THEN
DISCH_THEN(MP_TAC o SPEC `x:int`) THEN ASM_MESON_TAC[]);;
(* ------------------------------------------------------------------------- *)
(* Deduce the other one by a symmetry argument rather than a similar proof. *)
(* ------------------------------------------------------------------------- *)
let mirror = new_recursive_definition cform_RECURSION
`(mirror (Lt e) = Gt(--e)) /\
(mirror (Gt e) = Lt(--e)) /\
(mirror (Eq e) = Eq(--e)) /\
(mirror (Ne e) = Ne(--e)) /\
(mirror (Divides c e) = Divides c (--e)) /\
(mirror (Ndivides c e) = Ndivides c (--e)) /\
(mirror (And p q) = And (mirror p) (mirror q)) /\
(mirror (Or p q) = Or (mirror p) (mirror q)) /\
(mirror (Nox P) = Nox P)`;;
let INTERP_MIRROR_LEMMA = prove
(`!p x. interp (--x) (mirror p) <=> interp x p`,
MATCH_MP_TAC cform_INDUCT THEN SIMP_TAC[mirror; interp] THEN
REWRITE_TAC[GSYM INT_NEG_ADD; DIVIDES_RNEG] THEN INT_ARITH_TAC);;
let INTERP_MIRROR = prove
(`!p x. interp x (mirror p) <=> interp (--x) p`,
MESON_TAC[INTERP_MIRROR_LEMMA; INT_NEG_NEG]);;
let BSET_MIRROR = prove
(`!p. bset(mirror p) = IMAGE (--) (aset p)`,
MATCH_MP_TAC cform_INDUCT THEN SIMP_TAC[mirror; aset; bset] THEN
REWRITE_TAC[IMAGE_CLAUSES; IMAGE_UNION] THEN
REWRITE_TAC[EXTENSION; IN_SING] THEN INT_ARITH_TAC);;
let MINUSINF_MIRROR = prove
(`!p. minusinf (mirror p) = mirror (plusinf p)`,
MATCH_MP_TAC cform_INDUCT THEN SIMP_TAC[plusinf; minusinf; mirror]);;
let PLUSINF_MIRROR = prove
(`!p. plusinf p = mirror(minusinf (mirror p))`,
MATCH_MP_TAC cform_INDUCT THEN
SIMP_TAC[plusinf; minusinf; mirror; INT_NEG_NEG]);;
let ALLDIVIDE_MIRROR = prove
(`!p d. alldivide d (mirror p) = alldivide d p`,
MATCH_MP_TAC cform_INDUCT THEN SIMP_TAC[mirror; alldivide]);;
let EXISTS_NEG = prove
(`(?x. P(--x)) <=> (?x. P(x))`,
MESON_TAC[INT_NEG_NEG]);;
let FORALL_NEG = prove
(`(!x. P(--x)) <=> (!x. P x)`,
MESON_TAC[INT_NEG_NEG]);;
let EXISTS_MOD_IMP = prove
(`!P d. (!c x. P(x + c * d) <=> P(x)) /\ (?j. &1 <= j /\ j <= d /\ P(--j))
==> ?j. &1 <= j /\ j <= d /\ P(j)`,
REPEAT STRIP_TAC THEN ASM_CASES_TAC `d:int = j` THENL
[FIRST_X_ASSUM(MP_TAC o SPECL [`--(&2)`; `d:int`]) THEN
ASM_REWRITE_TAC[INT_ARITH `d + --(&2) * d = --d`] THEN
ASM_MESON_TAC[INT_LE_REFL];
FIRST_X_ASSUM(MP_TAC o SPECL [`&1`; `--j`]) THEN
ASM_REWRITE_TAC[INT_ARITH `--j + &1 * d = d - j`] THEN
DISCH_TAC THEN EXISTS_TAC `d - j` THEN ASM_REWRITE_TAC[] THEN
MAP_EVERY UNDISCH_TAC [`&1 <= j`; `j <= d`; `~(d:int = j)`] THEN
INT_ARITH_TAC]);;
let EXISTS_MOD_EQ = prove
(`!P d. (!c x. P(x + c * d) <=> P(x))
==> ((?j. &1 <= j /\ j <= d /\ P(--j)) <=>
(?j. &1 <= j /\ j <= d /\ P(j)))`,
REPEAT STRIP_TAC THEN EQ_TAC THENL
[MP_TAC(SPEC `P:int->bool` EXISTS_MOD_IMP);
MP_TAC(SPEC `\x. P(--x):bool` EXISTS_MOD_IMP)] THEN
DISCH_THEN(MP_TAC o SPEC `d:int`) THEN ASM_REWRITE_TAC[INT_NEG_NEG] THEN
ASM_REWRITE_TAC[INT_ARITH `--(x + c * d) = --x + --c * d`; FORALL_NEG] THEN
MESON_TAC[]);;
let MAINTHM_A = prove
(`!p d. alldivide d p /\ &0 < d
==> ((?x. interp x p) <=>
?j. &1 <= j /\ j <= d /\
(interp j (plusinf p) \/
?a. a IN aset p /\ interp (a - j) p))`,
REPEAT STRIP_TAC THEN GEN_REWRITE_TAC LAND_CONV [GSYM EXISTS_NEG] THEN
REWRITE_TAC[GSYM INTERP_MIRROR] THEN
MP_TAC(SPECL [`mirror p`; `d:int`] MAINTHM_B) THEN
ASM_REWRITE_TAC[ALLDIVIDE_MIRROR] THEN DISCH_THEN SUBST1_TAC THEN
REWRITE_TAC[TAUT `a /\ (b \/ c) <=> a /\ b \/ a /\ c`;
TAUT `(a \/ b) /\ c <=> a /\ c \/ b /\ c`; EXISTS_OR_THM] THEN
BINOP_TAC THENL
[ALL_TAC;
REWRITE_TAC[INTERP_MIRROR; MINUSINF_MIRROR; BSET_MIRROR] THEN
REWRITE_TAC[INT_ARITH `--(b + j) = --b - j`; IN_IMAGE] THEN
MESON_TAC[INT_NEG_NEG]] THEN
REWRITE_TAC[PLUSINF_MIRROR] THEN
FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [GSYM ALLDIVIDE_MIRROR]) THEN
SPEC_TAC(`mirror p`,`q:cform`) THEN REWRITE_TAC[INTERP_MIRROR] THEN
REPEAT STRIP_TAC THEN MATCH_MP_TAC(GSYM EXISTS_MOD_EQ) THEN
ASM_SIMP_TAC[GSYM MINUSINF_REPEATS]);;
(* ------------------------------------------------------------------------- *)
(* Proforma for elimination of coefficient of main variable. *)
(* ------------------------------------------------------------------------- *)
let EXISTS_MULTIPLE_THM_1 = prove
(`(?x. P(&1 * x)) <=> ?x. P(x)`,
REWRITE_TAC[INT_MUL_LID]);;
let EXISTS_MULTIPLE_THM = prove
(`(?x. P(c * x)) <=> ?x. c divides x /\ P(x)`,
MESON_TAC[divides]);;
(* ------------------------------------------------------------------------- *)
(* Ordering of variables determined by a list, *with* trivial default. *)
(* ------------------------------------------------------------------------- *)
let rec earlier vars x y =
match vars with
z::ovs -> if z = y then false
else if z = x then true
else earlier ovs x y
| [] -> x < y;;
(* ------------------------------------------------------------------------- *)
(* Conversion of integer constant to ML rational number. *)
(* This is a tweaked copy of the real-type versions in "real.ml". *)
(* ------------------------------------------------------------------------- *)
let is_num_const =
let ptm = `&` in
fun tm -> try let l,r = dest_comb tm in
l = ptm && is_numeral r
with Failure _ -> false;;
let mk_num_const,dest_num_const =
let ptm = `&` in
(fun n -> mk_comb(ptm,mk_numeral n)),
(fun tm -> let l,r = dest_comb tm in
if l = ptm then dest_numeral r
else failwith "dest_num_const");;
let is_int_const =
let ptm = `(--)` in
fun tm ->
is_num_const tm ||
try let l,r = dest_comb tm in
l = ptm && is_num_const r
with Failure _ -> false;;
let mk_int_const,dest_int_const =
let ptm = `(--)` in
(fun n -> if n </ Int 0 then mk_comb(ptm,mk_num_const(minus_num n))
else mk_num_const n),
(fun tm -> if try rator tm = ptm with Failure _ -> false then
minus_num (dest_num_const(rand tm))
else dest_num_const tm);;
(* ------------------------------------------------------------------------- *)
(* Similar tweaks of all the REAL_INT_..._CONV arith convs in real.ml *)
(* ------------------------------------------------------------------------- *)
let INT_LE_CONV,INT_LT_CONV,
INT_GE_CONV,INT_GT_CONV,INT_EQ_CONV =
let tth =
TAUT `(F /\ F <=> F) /\ (F /\ T <=> F) /\
(T /\ F <=> F) /\ (T /\ T <=> T)` in
let nth = TAUT `(~T <=> F) /\ (~F <=> T)` in
let NUM2_EQ_CONV =
COMB2_CONV (RAND_CONV NUM_EQ_CONV) NUM_EQ_CONV THENC
GEN_REWRITE_CONV I [tth] in
let NUM2_NE_CONV =
RAND_CONV NUM2_EQ_CONV THENC
GEN_REWRITE_CONV I [nth] in
let [pth_le1; pth_le2a; pth_le2b; pth_le3] = (CONJUNCTS o prove)
(`(--(&m) <= &n <=> T) /\
(&m <= &n <=> m <= n) /\
(--(&m) <= --(&n) <=> n <= m) /\
(&m <= --(&n) <=> (m = 0) /\ (n = 0))`,
REWRITE_TAC[INT_LE_NEG2] THEN
REWRITE_TAC[INT_LE_LNEG; INT_LE_RNEG] THEN
REWRITE_TAC[INT_OF_NUM_ADD; INT_OF_NUM_LE; LE_0] THEN
REWRITE_TAC[LE; ADD_EQ_0]) in
let INT_LE_CONV = FIRST_CONV
[GEN_REWRITE_CONV I [pth_le1];
GEN_REWRITE_CONV I [pth_le2a; pth_le2b] THENC NUM_LE_CONV;
GEN_REWRITE_CONV I [pth_le3] THENC NUM2_EQ_CONV] in
let [pth_lt1; pth_lt2a; pth_lt2b; pth_lt3] = (CONJUNCTS o prove)
(`(&m < --(&n) <=> F) /\
(&m < &n <=> m < n) /\
(--(&m) < --(&n) <=> n < m) /\
(--(&m) < &n <=> ~((m = 0) /\ (n = 0)))`,
REWRITE_TAC[pth_le1; pth_le2a; pth_le2b; pth_le3;
GSYM NOT_LE; GSYM INT_NOT_LE] THEN
CONV_TAC TAUT) in
let INT_LT_CONV = FIRST_CONV
[GEN_REWRITE_CONV I [pth_lt1];
GEN_REWRITE_CONV I [pth_lt2a; pth_lt2b] THENC NUM_LT_CONV;
GEN_REWRITE_CONV I [pth_lt3] THENC NUM2_NE_CONV] in
let [pth_ge1; pth_ge2a; pth_ge2b; pth_ge3] = (CONJUNCTS o prove)
(`(&m >= --(&n) <=> T) /\
(&m >= &n <=> n <= m) /\
(--(&m) >= --(&n) <=> m <= n) /\
(--(&m) >= &n <=> (m = 0) /\ (n = 0))`,
REWRITE_TAC[pth_le1; pth_le2a; pth_le2b; pth_le3; INT_GE] THEN
CONV_TAC TAUT) in
let INT_GE_CONV = FIRST_CONV
[GEN_REWRITE_CONV I [pth_ge1];
GEN_REWRITE_CONV I [pth_ge2a; pth_ge2b] THENC NUM_LE_CONV;
GEN_REWRITE_CONV I [pth_ge3] THENC NUM2_EQ_CONV] in
let [pth_gt1; pth_gt2a; pth_gt2b; pth_gt3] = (CONJUNCTS o prove)
(`(--(&m) > &n <=> F) /\
(&m > &n <=> n < m) /\
(--(&m) > --(&n) <=> m < n) /\
(&m > --(&n) <=> ~((m = 0) /\ (n = 0)))`,
REWRITE_TAC[pth_lt1; pth_lt2a; pth_lt2b; pth_lt3; INT_GT] THEN
CONV_TAC TAUT) in
let INT_GT_CONV = FIRST_CONV
[GEN_REWRITE_CONV I [pth_gt1];
GEN_REWRITE_CONV I [pth_gt2a; pth_gt2b] THENC NUM_LT_CONV;
GEN_REWRITE_CONV I [pth_gt3] THENC NUM2_NE_CONV] in
let [pth_eq1a; pth_eq1b; pth_eq2a; pth_eq2b] = (CONJUNCTS o prove)
(`((&m = &n) <=> (m = n)) /\
((--(&m) = --(&n)) <=> (m = n)) /\
((--(&m) = &n) <=> (m = 0) /\ (n = 0)) /\
((&m = --(&n)) <=> (m = 0) /\ (n = 0))`,
REWRITE_TAC[GSYM INT_LE_ANTISYM; GSYM LE_ANTISYM] THEN
REWRITE_TAC[pth_le1; pth_le2a; pth_le2b; pth_le3; LE; LE_0] THEN
CONV_TAC TAUT) in
let INT_EQ_CONV = FIRST_CONV
[GEN_REWRITE_CONV I [pth_eq1a; pth_eq1b] THENC NUM_EQ_CONV;
GEN_REWRITE_CONV I [pth_eq2a; pth_eq2b] THENC NUM2_EQ_CONV] in
INT_LE_CONV,INT_LT_CONV,
INT_GE_CONV,INT_GT_CONV,INT_EQ_CONV;;
let INT_NEG_CONV =
let pth = prove
(`(--(&0) = &0) /\
(--(--(&x)) = &x)`,
REWRITE_TAC[INT_NEG_NEG; INT_NEG_0]) in
GEN_REWRITE_CONV I [pth];;
let INT_MUL_CONV =
let pth0 = prove
(`(&0 * &x = &0) /\
(&0 * --(&x) = &0) /\
(&x * &0 = &0) /\
(--(&x) * &0 = &0)`,
REWRITE_TAC[INT_MUL_LZERO; INT_MUL_RZERO])
and pth1,pth2 = (CONJ_PAIR o prove)
(`((&m * &n = &(m * n)) /\
(--(&m) * --(&n) = &(m * n))) /\
((--(&m) * &n = --(&(m * n))) /\
(&m * --(&n) = --(&(m * n))))`,
REWRITE_TAC[INT_MUL_LNEG; INT_MUL_RNEG; INT_NEG_NEG] THEN
REWRITE_TAC[INT_OF_NUM_MUL]) in
FIRST_CONV
[GEN_REWRITE_CONV I [pth0];
GEN_REWRITE_CONV I [pth1] THENC RAND_CONV NUM_MULT_CONV;
GEN_REWRITE_CONV I [pth2] THENC RAND_CONV(RAND_CONV NUM_MULT_CONV)];;
let INT_ADD_CONV =
let neg_tm = `(--)` in
let amp_tm = `&` in
let add_tm = `(+)` in
let dest = dest_binop `(+)` in
let m_tm = `m:num` and n_tm = `n:num` in
let pth0 = prove
(`(--(&m) + &m = &0) /\
(&m + --(&m) = &0)`,
REWRITE_TAC[INT_ADD_LINV; INT_ADD_RINV]) in
let [pth1; pth2; pth3; pth4; pth5; pth6] = (CONJUNCTS o prove)
(`(--(&m) + --(&n) = --(&(m + n))) /\
(--(&m) + &(m + n) = &n) /\
(--(&(m + n)) + &m = --(&n)) /\
(&(m + n) + --(&m) = &n) /\
(&m + --(&(m + n)) = --(&n)) /\
(&m + &n = &(m + n))`,
REWRITE_TAC[GSYM INT_OF_NUM_ADD; INT_NEG_ADD] THEN
REWRITE_TAC[INT_ADD_ASSOC; INT_ADD_LINV; INT_ADD_LID] THEN
REWRITE_TAC[INT_ADD_RINV; INT_ADD_LID] THEN
ONCE_REWRITE_TAC[INT_ADD_SYM] THEN
REWRITE_TAC[INT_ADD_ASSOC; INT_ADD_LINV; INT_ADD_LID] THEN
REWRITE_TAC[INT_ADD_RINV; INT_ADD_LID]) in
GEN_REWRITE_CONV I [pth0] ORELSEC
(fun tm ->
try let l,r = dest tm in
if rator l = neg_tm then
if rator r = neg_tm then
let th1 = INST [rand(rand l),m_tm; rand(rand r),n_tm] pth1 in
let tm1 = rand(rand(rand(concl th1))) in
let th2 = AP_TERM neg_tm (AP_TERM amp_tm (NUM_ADD_CONV tm1)) in
TRANS th1 th2
else
let m = rand(rand l) and n = rand r in
let m' = dest_numeral m and n' = dest_numeral n in
if m' <=/ n' then
let p = mk_numeral (n' -/ m') in
let th1 = INST [m,m_tm; p,n_tm] pth2 in
let th2 = NUM_ADD_CONV (rand(rand(lhand(concl th1)))) in
let th3 = AP_TERM (rator tm) (AP_TERM amp_tm (SYM th2)) in
TRANS th3 th1
else
let p = mk_numeral (m' -/ n') in
let th1 = INST [n,m_tm; p,n_tm] pth3 in
let th2 = NUM_ADD_CONV (rand(rand(lhand(lhand(concl th1))))) in
let th3 = AP_TERM neg_tm (AP_TERM amp_tm (SYM th2)) in
let th4 = AP_THM (AP_TERM add_tm th3) (rand tm) in
TRANS th4 th1
else
if rator r = neg_tm then
let m = rand l and n = rand(rand r) in
let m' = dest_numeral m and n' = dest_numeral n in
if n' <=/ m' then
let p = mk_numeral (m' -/ n') in
let th1 = INST [n,m_tm; p,n_tm] pth4 in
let th2 = NUM_ADD_CONV (rand(lhand(lhand(concl th1)))) in
let th3 = AP_TERM add_tm (AP_TERM amp_tm (SYM th2)) in
let th4 = AP_THM th3 (rand tm) in
TRANS th4 th1
else
let p = mk_numeral (n' -/ m') in
let th1 = INST [m,m_tm; p,n_tm] pth5 in
let th2 = NUM_ADD_CONV (rand(rand(rand(lhand(concl th1))))) in
let th3 = AP_TERM neg_tm (AP_TERM amp_tm (SYM th2)) in
let th4 = AP_TERM (rator tm) th3 in
TRANS th4 th1
else
let th1 = INST [rand l,m_tm; rand r,n_tm] pth6 in
let tm1 = rand(rand(concl th1)) in
let th2 = AP_TERM amp_tm (NUM_ADD_CONV tm1) in
TRANS th1 th2
with Failure _ -> failwith "INT_ADD_CONV");;
let INT_SUB_CONV =
GEN_REWRITE_CONV I [INT_SUB] THENC
TRY_CONV(RAND_CONV INT_NEG_CONV) THENC
INT_ADD_CONV;;
let INT_POW_CONV =
let n = `n:num` and x = `x:num` in
let pth1,pth2 = (CONJ_PAIR o prove)
(`(&x pow n = &(x EXP n)) /\
((--(&x)) pow n = if EVEN n then &(x EXP n) else --(&(x EXP n)))`,
REWRITE_TAC[INT_OF_NUM_POW; INT_POW_NEG]) in
let tth = prove
(`((if T then x:int else y) = x) /\ ((if F then x:int else y) = y)`,
REWRITE_TAC[]) in
let neg_tm = `(--)` in
(GEN_REWRITE_CONV I [pth1] THENC RAND_CONV NUM_EXP_CONV) ORELSEC
(GEN_REWRITE_CONV I [pth2] THENC
RATOR_CONV(RATOR_CONV(RAND_CONV NUM_EVEN_CONV)) THENC
GEN_REWRITE_CONV I [tth] THENC
(fun tm -> if rator tm = neg_tm then RAND_CONV(RAND_CONV NUM_EXP_CONV) tm
else RAND_CONV NUM_EXP_CONV tm));;
(* ------------------------------------------------------------------------- *)
(* Handy utility functions for int arithmetic terms. *)
(* ------------------------------------------------------------------------- *)
let dest_add = dest_binop `(+)`;;
let dest_mul = dest_binop `(*)`;;
let dest_pow = dest_binop `(pow)`;;
let dest_sub = dest_binop `(-)`;;
let is_add = is_binop `(+)`;;
let is_mul = is_binop `(*)`;;
let is_pow = is_binop `(pow)`;;
let is_sub = is_binop `(-)`;;
(* ------------------------------------------------------------------------- *)
(* Instantiate the normalizer. *)
(* ------------------------------------------------------------------------- *)
let POLYNOMIAL_NORMALIZERS =
let sth = prove
(`(!x y z. x + (y + z) = (x + y) + z) /\
(!x y. x + y = y + x) /\
(!x. &0 + x = x) /\
(!x y z. x * (y * z) = (x * y) * z) /\
(!x y. x * y = y * x) /\
(!x. &1 * x = x) /\
(!x. &0 * x = &0) /\
(!x y z. x * (y + z) = x * y + x * z) /\
(!x. x pow 0 = &1) /\
(!x n. x pow (SUC n) = x * x pow n)`,
REWRITE_TAC[INT_POW] THEN INT_ARITH_TAC)
and rth = prove
(`(!x. --x = --(&1) * x) /\
(!x y. x - y = x + --(&1) * y)`,
INT_ARITH_TAC)
and is_semiring_constant = is_int_const
and SEMIRING_ADD_CONV = INT_ADD_CONV
and SEMIRING_MUL_CONV = INT_MUL_CONV
and SEMIRING_POW_CONV = INT_POW_CONV in
let NORMALIZERS =
SEMIRING_NORMALIZERS_CONV sth rth
(is_semiring_constant,
SEMIRING_ADD_CONV,SEMIRING_MUL_CONV,SEMIRING_POW_CONV) in
fun vars -> NORMALIZERS(earlier vars);;
let POLYNOMIAL_NEG_CONV vars =
let cnv,_,_,_,_,_ = POLYNOMIAL_NORMALIZERS vars in cnv;;
let POLYNOMIAL_ADD_CONV vars =
let _,cnv,_,_,_,_ = POLYNOMIAL_NORMALIZERS vars in cnv;;
let POLYNOMIAL_SUB_CONV vars =
let _,_,cnv,_,_,_ = POLYNOMIAL_NORMALIZERS vars in cnv;;
let POLYNOMIAL_MUL_CONV vars =
let _,_,_,cnv,_,_ = POLYNOMIAL_NORMALIZERS vars in cnv;;
let POLYNOMIAL_POW_CONV vars =
let _,_,_,_,cnv,_ = POLYNOMIAL_NORMALIZERS vars in cnv;;
let POLYNOMIAL_CONV vars =
let _,_,_,_,_,cnv = POLYNOMIAL_NORMALIZERS vars in cnv;;
(* ------------------------------------------------------------------------- *)
(* Slight variants of these functions for procedure below. *)
(* ------------------------------------------------------------------------- *)
let LINEAR_CMUL =
let mul_tm = `(*)` in
fun vars n tm ->
POLYNOMIAL_MUL_CONV vars (mk_comb(mk_comb(mul_tm,mk_int_const n),tm));;
(* ------------------------------------------------------------------------- *)
(* Linearize a formula, dealing with non-strict inequalities. *)
(* ------------------------------------------------------------------------- *)
let LINEARIZE_CONV =
let rew_conv = GEN_REWRITE_CONV I
[CONJ (REFL `c divides e`)
(INT_ARITH
`(s < t <=> &0 < t - s) /\
(~(s < t) <=> &0 < (s + &1) - t) /\
(s > t <=> &0 < s - t) /\
(~(s > t) <=> &0 < (t + &1) - s) /\
(s <= t <=> &0 < (t + &1) - s) /\
(~(s <= t) <=> &0 < s - t) /\
(s >= t <=> &0 < (s + &1) - t) /\
(~(s >= t) <=> &0 < t - s) /\
((s = t) <=> (&0 = s - t))`)]
and true_tm = `T` and false_tm = `F` in
let rec conv vars tm =
try (rew_conv THENC RAND_CONV(POLYNOMIAL_CONV vars)) tm with Failure _ ->
if is_exists tm || is_forall tm then
let x = bndvar(rand tm) in BINDER_CONV (conv (x::vars)) tm
else if is_neg tm then
RAND_CONV (conv vars) tm
else if is_conj tm || is_disj tm || is_imp tm || is_iff tm then
BINOP_CONV (conv vars) tm
else if tm = true_tm || tm = false_tm then REFL tm
else failwith "LINEARIZE_CONV: Unexpected term type" in
conv;;
(* ------------------------------------------------------------------------- *)
(* Get the coefficient of x, assumed to be first term, if there at all. *)
(* ------------------------------------------------------------------------- *)
let coefficient x tm =
try let l,r = dest_add tm in
if l = x then Int 1 else
let c,y = dest_mul l in
if y = x then dest_int_const c else Int 0
with Failure _ -> try
let c,y = dest_mul tm in
if y = x then dest_int_const c else Int 0
with Failure _ -> Int 1;;
(* ------------------------------------------------------------------------- *)
(* Find (always positive) LCM of all the multiples of x in formula tm. *)
(* ------------------------------------------------------------------------- *)
let lcm_num x y = abs_num((x */ y) // gcd_num x y);;
let rec formlcm x tm =
if is_neg tm then formlcm x (rand tm)
else if is_conj tm || is_disj tm || is_imp tm || is_iff tm then
lcm_num (formlcm x (lhand tm)) (formlcm x (rand tm))
else if is_forall tm || is_exists tm then
formlcm x (body(rand tm))
else if not(mem x (frees tm)) then Int 1
else let c = coefficient x (rand tm) in
if c =/ Int 0 then Int 1 else c;;
(* ------------------------------------------------------------------------- *)
(* Switch from "x [+ ...]" to "&1 * x [+ ...]" to suit later proforma. *)
(* ------------------------------------------------------------------------- *)
let MULTIPLY_1_CONV =
let conv_0 = REWR_CONV(INT_ARITH `x = &1 * x`)
and conv_1 = REWR_CONV(INT_ARITH `x + a = &1 * x + a`) in
fun vars tm ->
let x = hd vars in
if tm = x then conv_0 tm
else if is_add tm && lhand tm = x then conv_1 tm
else REFL tm;;
(* ------------------------------------------------------------------------- *)
(* Adjust all coefficients of x (head variable) to match l in formula tm. *)
(* ------------------------------------------------------------------------- *)
let ADJUSTCOEFF_CONV =
let op_eq = `(=):int->int->bool`
and op_lt = `(<):int->int->bool`
and op_gt = `(>):int->int->bool`
and op_divides = `(divides):int->int->bool`
and c_tm = `c:int`
and d_tm = `d:int`
and e_tm = `e:int` in
let pth_divides = prove
(`~(d = &0) ==> (c divides e <=> (d * c) divides (d * e))`,
SIMP_TAC[divides; GSYM INT_MUL_ASSOC; INT_EQ_MUL_LCANCEL])
and pth_eq = prove
(`~(d = &0) ==> ((&0 = e) <=> (&0 = d * e))`,
DISCH_TAC THEN CONV_TAC(BINOP_CONV SYM_CONV) THEN
ASM_REWRITE_TAC[INT_ENTIRE])
and pth_lt_pos = prove
(`&0 < d ==> (&0 < e <=> &0 < d * e)`,
DISCH_TAC THEN SUBGOAL_THEN `&0 < e <=> d * &0 < d * e` SUBST1_TAC THENL
[ASM_SIMP_TAC[INT_LT_LMUL_EQ]; REWRITE_TAC[INT_MUL_RZERO]])
and pth_gt_pos = prove
(`&0 < d ==> (&0 > e <=> &0 > d * e)`,
DISCH_TAC THEN REWRITE_TAC[INT_GT] THEN
SUBGOAL_THEN `e < &0 <=> d * e < d * &0` SUBST1_TAC THENL
[ASM_SIMP_TAC[INT_LT_LMUL_EQ]; REWRITE_TAC[INT_MUL_RZERO]])
and true_tm = `T` and false_tm = `F` in
let pth_lt_neg = prove
(`d < &0 ==> (&0 < e <=> &0 > d * e)`,
REWRITE_TAC[INT_ARITH `&0 > d * e <=> &0 < --d * e`;
INT_ARITH `d < &0 <=> &0 < --d`; pth_lt_pos])
and pth_gt_neg = prove
(`d < &0 ==> (&0 > e <=> &0 < d * e)`,
REWRITE_TAC[INT_ARITH `&0 < d * e <=> &0 > --d * e`;
INT_ARITH `d < &0 <=> &0 < --d`; pth_gt_pos]) in
let rec ADJUSTCOEFF_CONV vars l tm =
if tm = true_tm || tm = false_tm then REFL tm
else if is_exists tm || is_forall tm then
BINDER_CONV (ADJUSTCOEFF_CONV vars l) tm
else if is_neg tm then
RAND_CONV (ADJUSTCOEFF_CONV vars l) tm
else if is_conj tm || is_disj tm || is_imp tm || is_iff tm then
BINOP_CONV (ADJUSTCOEFF_CONV vars l) tm
else
let lop,t = dest_comb tm in
let op,z = dest_comb lop in
let c = coefficient (hd vars) t in
if c =/ Int 0 then REFL tm else
let th1 =
if c =/ l then REFL tm else
let m = l // c in
let th0 = if op = op_eq then pth_eq
else if op = op_divides then pth_divides
else if op = op_lt then
if m >/ Int 0 then pth_lt_pos else pth_lt_neg
else if op = op_gt then
if m >/ Int 0 then pth_gt_pos else pth_gt_neg
else failwith "ADJUSTCOEFF_CONV: unknown predicate" in
let th1 = INST [mk_int_const m,d_tm; z,c_tm; t,e_tm] th0 in
let tm1 = lhand(concl th1) in
let th2 = if is_neg tm1 then EQF_ELIM(INT_EQ_CONV(rand tm1))
else EQT_ELIM(INT_LT_CONV tm1) in
let th3 = MP th1 th2 in
if op = op_divides then
let th3 = MP th1 th2 in
let tm2 = rand(concl th3) in
let l,r = dest_comb tm2 in
let th4 = AP_TERM (rator l) (INT_MUL_CONV (rand l)) in
let th5 = AP_THM th4 r in
let tm3 = rator(rand(concl th5)) in
let th6 = TRANS th5 (AP_TERM tm3 (LINEAR_CMUL vars m t)) in
TRANS th3 th6
else
let tm2 = rator(rand(concl th3)) in
TRANS th3 (AP_TERM tm2 (LINEAR_CMUL vars m t)) in
if l =/ Int 1 then
CONV_RULE(funpow 2 RAND_CONV (MULTIPLY_1_CONV vars)) th1
else th1 in
ADJUSTCOEFF_CONV;;
(* ------------------------------------------------------------------------- *)
(* Now normalize all the x terms to have same coefficient and eliminate it. *)
(* ------------------------------------------------------------------------- *)
let NORMALIZE_COEFF_CONV =
let c_tm = `c:int`
and pth = prove
(`(?x. P(c * x)) <=> (?x. c divides x /\ P x)`,
REWRITE_TAC[GSYM EXISTS_MULTIPLE_THM]) in
let NORMALIZE_COEFF_CONV vars tm =
let x,bod = dest_exists tm in
let l = formlcm x tm in
let th1 = ADJUSTCOEFF_CONV (x::vars) l tm in
let th2 = if l =/ Int 1 then EXISTS_MULTIPLE_THM_1
else INST [mk_int_const l,c_tm] pth in
TRANS th1 (REWR_CONV th2 (rand(concl th1))) in
NORMALIZE_COEFF_CONV;;
(* ------------------------------------------------------------------------- *)
(* Convert to shadow syntax. *)
(* ------------------------------------------------------------------------- *)
let SHADOW_CONV =
let pth_trivial = prove
(`P = interp x (Nox P)`,
REWRITE_TAC[interp])
and pth_composite = prove
(`(interp x p /\ interp x q <=> interp x (And p q)) /\
(interp x p \/ interp x q <=> interp x (Or p q))`,
REWRITE_TAC[interp])
and pth_literal_nontrivial = prove
(`(&0 > x + e <=> interp x (Lt e)) /\
(&0 < x + e <=> interp x (Gt e)) /\
((&0 = x + e) <=> interp x (Eq e)) /\
(~(&0 = x + e) <=> interp x (Ne e)) /\
(c divides (x + e) <=> interp x (Divides c e)) /\
(~(c divides (x + e)) <=> interp x (Ndivides c e))`,
REWRITE_TAC[interp; INT_ADD_RID] THEN INT_ARITH_TAC)
and pth_literal_trivial = prove
(`(&0 > x <=> interp x (Lt(&0))) /\
(&0 < x <=> interp x (Gt(&0))) /\
((&0 = x) <=> interp x (Eq(&0))) /\
(~(&0 = x) <=> interp x (Ne(&0))) /\
(c divides x <=> interp x (Divides c (&0))) /\
(~(c divides x) <=> interp x (Ndivides c (&0)))`,
REWRITE_TAC[interp; INT_ADD_RID] THEN INT_ARITH_TAC) in
let rewr_composite = GEN_REWRITE_CONV I [pth_composite]
and rewr_literal = GEN_REWRITE_CONV I [pth_literal_nontrivial] ORELSEC
GEN_REWRITE_CONV I [pth_literal_trivial]
and x_tm = `x:int` and p_tm = `P:bool` in
let rec SHADOW_CONV x tm =
if not (mem x (frees tm)) then
INST [tm,p_tm; x,x_tm] pth_trivial
else if is_conj tm || is_disj tm then
let l,r = try dest_conj tm with Failure _ -> dest_disj tm in
let thl = SHADOW_CONV x l and thr = SHADOW_CONV x r in
let th1 = MK_COMB(AP_TERM (rator(rator tm)) thl,thr) in
TRANS th1 (rewr_composite(rand(concl th1)))
else rewr_literal tm in
fun tm ->
let x,bod = dest_exists tm in
MK_EXISTS x (SHADOW_CONV x bod);;
(* ------------------------------------------------------------------------- *)
(* Get the LCM of the dividing things. *)
(* ------------------------------------------------------------------------- *)
let dplcm =
let divides_tm = `Divides`
and ndivides_tm = `Ndivides`
and and_tm = `And`
and or_tm = `Or` in
let rec dplcm tm =
let hop,args = strip_comb tm in
if hop = divides_tm || hop = ndivides_tm then dest_int_const (hd args)
else if hop = and_tm || hop = or_tm
then end_itlist lcm_num (map dplcm args)
else Int 1 in
dplcm;;
(* ------------------------------------------------------------------------- *)
(* Conversion for true formulas "(--) &m divides (--) &n". *)
(* ------------------------------------------------------------------------- *)
let PROVE_DIVIDES_CONV_POS =
let pth = prove
(`(p * m = n) ==> &p divides &n`,
DISCH_THEN(SUBST1_TAC o SYM) THEN
REWRITE_TAC[divides] THEN EXISTS_TAC `&m` THEN
REWRITE_TAC[INT_OF_NUM_MUL])
and m_tm = `m:num` and n_tm = `n:num` and p_tm = `p:num` in
fun tm ->
let n = rand(rand tm)
and p = rand(lhand tm) in
let m = mk_numeral(dest_numeral n // dest_numeral p) in
let th1 = INST [m,m_tm; n,n_tm; p,p_tm] pth in
EQT_INTRO(MP th1 (NUM_MULT_CONV (lhand(lhand(concl th1)))));;
let PROVE_DIVIDES_CONV =
GEN_REWRITE_CONV REPEATC [DIVIDES_LNEG; DIVIDES_RNEG] THENC
PROVE_DIVIDES_CONV_POS;;
(* ------------------------------------------------------------------------- *)
(* General version that works for positive and negative. *)
(* ------------------------------------------------------------------------- *)
let INT_DIVIDES_NUM = prove
(`&p divides &n <=> ?m. (n = p * m)`,
REWRITE_TAC[divides] THEN EQ_TAC THENL
[DISCH_THEN(X_CHOOSE_THEN `x:int` MP_TAC) THEN
DISJ_CASES_THEN(X_CHOOSE_THEN `q:num` SUBST1_TAC)
(SPEC `x:int` INT_IMAGE) THEN
DISCH_THEN(MP_TAC o AP_TERM `abs:int->int`) THEN
REWRITE_TAC[INT_ABS_MUL; INT_ABS_NUM; INT_ABS_NEG] THEN
REWRITE_TAC[INT_OF_NUM_MUL; INT_OF_NUM_EQ] THEN MESON_TAC[];
MESON_TAC[INT_OF_NUM_MUL]]);;
let INT_DIVIDES_POS_CONV =
let pth = prove
(`(&p divides &n) <=> (p = 0) /\ (n = 0) \/ ~(p = 0) /\ (n MOD p = 0)`,
REWRITE_TAC[INT_DIVIDES_NUM] THEN
ASM_CASES_TAC `p = 0` THEN ASM_REWRITE_TAC[MULT_CLAUSES] THEN EQ_TAC THENL
[ASM_MESON_TAC[MOD_MULT];
DISCH_TAC THEN
FIRST_ASSUM(MP_TAC o SPEC `n:num` o MATCH_MP DIVISION) THEN
ASM_REWRITE_TAC[ADD_CLAUSES] THEN MESON_TAC[MULT_SYM]]) in
GEN_REWRITE_CONV I [pth] THENC NUM_REDUCE_CONV;;
let INT_DIVIDES_CONV =
GEN_REWRITE_CONV REPEATC [DIVIDES_LNEG; DIVIDES_RNEG] THENC
INT_DIVIDES_POS_CONV;;
(* ------------------------------------------------------------------------- *)
(* Conversion for "alldivide d p" (which should be true!) *)
(* ------------------------------------------------------------------------- *)
let ALLDIVIDE_CONV =
let pth_atom = prove
(`(alldivide d (Lt e) <=> T) /\
(alldivide d (Gt e) <=> T) /\
(alldivide d (Eq e) <=> T) /\
(alldivide d (Ne e) <=> T) /\
(alldivide d (Nox P) <=> T)`,
REWRITE_TAC[alldivide])
and pth_div = prove
(`(alldivide d (Divides c e) <=> c divides d) /\
(alldivide d (Ndivides c e) <=> c divides d)`,
REWRITE_TAC[alldivide])
and pth_comp = prove
(`(alldivide d (And p q) <=> alldivide d p /\ alldivide d q) /\
(alldivide d (Or p q) <=> alldivide d p /\ alldivide d q)`,
REWRITE_TAC[alldivide])
and pth_taut = TAUT `(T /\ T <=> T)` in
let basnet =
itlist (fun th -> enter [] (lhand(concl th),REWR_CONV th))
(CONJUNCTS pth_atom)
(itlist (fun th -> enter [] (lhand(concl th),
REWR_CONV th THENC PROVE_DIVIDES_CONV))
(CONJUNCTS pth_div) empty_net)
and comp_rewr = GEN_REWRITE_CONV I [pth_comp] in
let rec alldivide_conv tm =
try tryfind (fun f -> f tm) (lookup tm basnet) with Failure _ ->
let th = (comp_rewr THENC BINOP_CONV alldivide_conv) tm in
TRANS th pth_taut in
alldivide_conv;;
(* ------------------------------------------------------------------------- *)
(* Conversion for "?b. b IN bset p /\ P b";; *)
(* ------------------------------------------------------------------------- *)
let EXISTS_IN_BSET_CONV =
let pth_false = prove
(`((?b. b IN bset (Lt e) /\ P b) <=> F) /\
((?b. b IN bset (Divides c e) /\ P b) <=> F) /\
((?b. b IN bset (Ndivides c e) /\ P b) <=> F) /\
((?b. b IN bset(Nox Q) /\ P b) <=> F)`,
REWRITE_TAC[bset; NOT_IN_EMPTY])
and pth_neg = prove
(`((?b. b IN bset (Gt e) /\ P b) <=> P(--e)) /\
((?b. b IN bset (Ne e) /\ P b) <=> P(--e))`,
REWRITE_TAC[bset; IN_SING; INT_MUL_LID; UNWIND_THM2])
and pth_add = prove
(`(?b. b IN bset (Eq e) /\ P b) <=> P(--(e + &1))`,
REWRITE_TAC[bset; IN_SING; INT_MUL_LID; UNWIND_THM2])
and pth_comp = prove
(`((?b. b IN bset (And p q) /\ P b) <=>
(?b. b IN bset p /\ P b) \/
(?b. b IN bset q /\ P b)) /\
((?b. b IN bset (Or p q) /\ P b) <=>
(?b. b IN bset p /\ P b) \/
(?b. b IN bset q /\ P b))`,
REWRITE_TAC[bset; IN_UNION] THEN MESON_TAC[])
and taut = TAUT `(F \/ P <=> P) /\ (P \/ F <=> P)` in
let conv_neg vars =
LAND_CONV(LAND_CONV(POLYNOMIAL_NEG_CONV vars))
and conv_add vars =
LAND_CONV(LAND_CONV(RAND_CONV(POLYNOMIAL_ADD_CONV vars) THENC
POLYNOMIAL_NEG_CONV vars))
and conv_comp = GEN_REWRITE_CONV I [pth_comp] in
let net1 =
itlist (fun th -> enter [] (lhand(concl th),K (REWR_CONV th)))
(CONJUNCTS pth_false) empty_net in
let net2 =
itlist (fun th -> enter [] (lhand(concl th),
let cnv = K (REWR_CONV th) in fun v -> cnv v THENC conv_neg v))
(CONJUNCTS pth_neg) net1 in
let basnet =
enter [] (lhand(concl pth_add),
let cnv = K (REWR_CONV pth_add) in fun v -> cnv v THENC conv_add v)
net2 in
let rec baseconv vars tm =
try tryfind (fun f -> f vars tm) (lookup tm basnet) with Failure _ ->
(conv_comp THENC BINOP_CONV (baseconv vars)) tm in
let finconv =
GEN_REWRITE_CONV DEPTH_CONV [taut] THENC
PURE_REWRITE_CONV [DISJ_ACI] in
fun vars tm -> (baseconv vars THENC finconv) tm;;
(* ------------------------------------------------------------------------- *)
(* Naive conversion for "minusinf p". *)
(* ------------------------------------------------------------------------- *)
let MINUSINF_CONV = GEN_REWRITE_CONV TOP_SWEEP_CONV [minusinf];;
(* ------------------------------------------------------------------------- *)
(* Conversion for "interp s p" where s is a canonical linear form. *)
(* ------------------------------------------------------------------------- *)
let INTERP_CONV =
let pth_trivial = prove
(`interp x (Nox P) <=> P`,
REWRITE_TAC[interp])
and pth_comp = prove
(`(interp x (And p q) <=> interp x p /\ interp x q) /\
(interp x (Or p q) <=> interp x p \/ interp x q)`,
REWRITE_TAC[interp])
and pth_pos,pth_neg = (CONJ_PAIR o prove)
(`((interp x (Lt e) <=> &0 > x + e) /\
(interp x (Gt e) <=> &0 < x + e) /\
(interp x (Eq e) <=> (&0 = x + e)) /\
(interp x (Divides c e) <=> c divides (x + e))) /\
((interp x (Ne e) <=> ~(&0 = x + e)) /\
(interp x (Ndivides c e) <=> ~(c divides (x + e))))`,
REWRITE_TAC[interp] THEN INT_ARITH_TAC) in
let conv_pos vars = RAND_CONV(POLYNOMIAL_ADD_CONV vars)
and conv_neg vars = RAND_CONV(RAND_CONV(POLYNOMIAL_ADD_CONV vars))
and conv_comp = GEN_REWRITE_CONV I [pth_comp] in
let net1 =
itlist (fun th -> enter [] (lhand(concl th),K (REWR_CONV th)))
(CONJUNCTS pth_trivial) empty_net in
let net2 =
itlist (fun th -> enter [] (lhand(concl th),
let cnv = K (REWR_CONV th) in fun v -> cnv v THENC conv_pos v))
(CONJUNCTS pth_pos) net1 in
let basnet =
itlist (fun th -> enter [] (lhand(concl th),
let cnv = K (REWR_CONV th) in fun v -> cnv v THENC conv_neg v))
(CONJUNCTS pth_neg) net2 in
let rec baseconv vars tm =
try tryfind (fun f -> f vars tm) (lookup tm basnet) with Failure _ ->
(conv_comp THENC BINOP_CONV (baseconv vars)) tm in
baseconv;;
(* ------------------------------------------------------------------------- *)
(* Expand `?j. &1 <= j /\ j <= &[n] /\ P[j]` cases. *)
(* ------------------------------------------------------------------------- *)
let EXPAND_INT_CASES_CONV =
let pth_base = prove
(`(?j. n <= j /\ j <= n /\ P(j)) <=> P(n)`,
MESON_TAC[INT_LE_ANTISYM])
and pth_step = prove
(`(?j. &1 <= j /\ j <= &(SUC n) /\ P(j)) <=>
(?j. &1 <= j /\ j <= &n /\ P(j)) \/ P(&(SUC n))`,
REWRITE_TAC[GSYM INT_OF_NUM_SUC] THEN
REWRITE_TAC[INT_ARITH `x <= y + &1 <=> (x = y + &1) \/ x < y + &1`] THEN
REWRITE_TAC[INT_LT_DISCRETE; INT_LE_RADD] THEN
MESON_TAC[INT_ARITH `&0 <= x ==> &1 <= x + &1`; INT_POS; INT_LE_REFL]) in
let base_conv = REWR_CONV pth_base
and step_conv =
BINDER_CONV(RAND_CONV(LAND_CONV(funpow 2 RAND_CONV num_CONV))) THENC
REWR_CONV pth_step THENC
RAND_CONV(ONCE_DEPTH_CONV NUM_SUC_CONV) in
let rec conv tm =
try base_conv tm with Failure _ ->
(step_conv THENC LAND_CONV conv) tm in
conv;;
(* ------------------------------------------------------------------------- *)
(* Canonicalize "t + c" in all "interp (t + c) P"s assuming t is canonical. *)
(* ------------------------------------------------------------------------- *)
let CANON_INTERP_ADD =
let pat = `interp (t + c) P` in
fun vars ->
let net = net_of_conv pat (LAND_CONV(POLYNOMIAL_ADD_CONV vars))
empty_net in
ONCE_DEPTH_CONV(REWRITES_CONV net);;
(* ------------------------------------------------------------------------- *)
(* Conversion to evaluate constant expressions. *)
(* ------------------------------------------------------------------------- *)
let EVAL_CONSTANT_CONV =
let net =
itlist (uncurry net_of_conv)
([`x < y`,INT_LT_CONV;
`x > y`,INT_GT_CONV;
`x:int = y`,INT_EQ_CONV;
`x divides y`,INT_DIVIDES_CONV] @
map (fun t -> t,REWR_CONV(REWRITE_CONV[] t))
[`~F`; `~T`; `a /\ T`; `T /\ a`; `a /\ F`; `F /\ a`;
`a \/ T`; `T \/ a`; `a \/ F`; `F \/ a`])
empty_net in
DEPTH_CONV(REWRITES_CONV net);;
(* ------------------------------------------------------------------------- *)
(* Basic quantifier elimination conversion. *)
(* ------------------------------------------------------------------------- *)
let BASIC_COOPER_CONV =
let p_tm = `p:cform`
and d_tm = `d:int` in
let pth_B = SPECL [p_tm; d_tm] MAINTHM_B in
fun vars tm ->
let x,bod = dest_exists tm in
let th1 = (NORMALIZE_COEFF_CONV vars THENC SHADOW_CONV) tm in
let p = rand(snd(dest_exists(rand(concl th1)))) in
let th2 = INST [p,p_tm; mk_int_const(dplcm p),d_tm] pth_B in
let tm2a,tm2b = dest_conj(lhand(concl th2)) in
let th3 =
CONJ (EQT_ELIM(ALLDIVIDE_CONV tm2a)) (EQT_ELIM(INT_LT_CONV tm2b)) in
let th4 = TRANS th1 (MP th2 th3) in
let th5 = CONV_RULE(RAND_CONV(BINDER_CONV(funpow 2 RAND_CONV(LAND_CONV
MINUSINF_CONV)))) th4 in
let th6 = CONV_RULE(RAND_CONV(BINDER_CONV(funpow 3 RAND_CONV
(EXISTS_IN_BSET_CONV vars)))) th5 in
let th7 = CONV_RULE(RAND_CONV EXPAND_INT_CASES_CONV) th6 in
let th8 = CONV_RULE(RAND_CONV(CANON_INTERP_ADD vars)) th7 in
let th9 = CONV_RULE(RAND_CONV(ONCE_DEPTH_CONV(INTERP_CONV vars))) th8 in
CONV_RULE(RAND_CONV EVAL_CONSTANT_CONV) th9;;
(* ------------------------------------------------------------------------- *)
(* NNF transformation that also eliminates negated inequalities. *)
(* ------------------------------------------------------------------------- *)
let NNF_POSINEQ_CONV =
let pth = prove
(`(~(&0 < x) <=> &0 < &1 - x) /\
(~(&0 > x) <=> &0 < &1 + x)`,
REWRITE_TAC[INT_NOT_LT; INT_GT] THEN
REWRITE_TAC[INT_LT_DISCRETE; INT_GT_DISCRETE] THEN
INT_ARITH_TAC) in
let conv1 vars = REWR_CONV(CONJUNCT1 pth) THENC
RAND_CONV (POLYNOMIAL_SUB_CONV vars)
and conv2 vars = REWR_CONV(CONJUNCT2 pth) THENC
RAND_CONV (POLYNOMIAL_ADD_CONV vars)
and pat1 = `~(&0 < x)` and pat2 = `~(&0 > x)`
and net = itlist (fun t -> net_of_conv (lhand t) (REWR_CONV(TAUT t)))
[`~(~ p) <=> p`; `~(p /\ q) <=> ~p \/ ~q`;
`~(p \/ q) <=> ~p /\ ~q`] empty_net in
fun vars ->
let net' = net_of_conv pat1 (conv1 vars)
(net_of_conv pat2 (conv2 vars) net) in
TOP_SWEEP_CONV(REWRITES_CONV net');;
(* ------------------------------------------------------------------------- *)
(* Overall function. *)
(* ------------------------------------------------------------------------- *)
let COOPER_CONV =
let FORALL_ELIM_CONV = GEN_REWRITE_CONV I
[prove(`(!x. P x) <=> ~(?x. ~(P x))`,MESON_TAC[])]
and not_tm = `(~)` in
let rec conv vars tm =
if is_conj tm || is_disj tm then
let lop,r = dest_comb tm in
let op,l = dest_comb lop in
MK_COMB(AP_TERM op (conv vars l),conv vars r)
else if is_neg tm then
let l,r = dest_comb tm in
AP_TERM l (conv vars r)
else if is_exists tm then
let x,bod = dest_exists tm in
let th1 = MK_EXISTS x (conv (x::vars) bod) in
TRANS th1 (BASIC_COOPER_CONV vars (rand(concl th1)))
else if is_forall tm then
let x,bod = dest_forall tm in
let th1 = AP_TERM not_tm (conv (x::vars) bod) in
let th2 = CONV_RULE(RAND_CONV (NNF_POSINEQ_CONV (x::vars))) th1 in
let th3 = MK_EXISTS x th2 in
let th4 = CONV_RULE(RAND_CONV (BASIC_COOPER_CONV vars)) th3 in
let th5 = CONV_RULE(RAND_CONV (NNF_POSINEQ_CONV (x::vars)))
(AP_TERM not_tm th4) in
TRANS (FORALL_ELIM_CONV tm) th5
else REFL tm in
let init_CONV =
PRESIMP_CONV THENC
GEN_REWRITE_CONV ONCE_DEPTH_CONV
[INT_ABS;
INT_ARITH `max m n = if m <= n then n else m`;
INT_ARITH `min m n = if m <= n then m else n`] THENC
CONDS_ELIM_CONV THENC NNF_CONV in
fun tm ->
let vars = frees tm in
let th1 = (init_CONV THENC LINEARIZE_CONV vars) tm in
let th2 = TRANS th1 (conv vars (rand(concl th1))) in
TRANS th2 (EVAL_CONSTANT_CONV(rand(concl th2)));;
(* ------------------------------------------------------------------------- *)
(* Examples from the book. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV `!x y. x < y ==> &2 * x + &1 < &2 * y`;;
time COOPER_CONV `!x y. ~(&2 * x + &1 = &2 * y)`;;
time COOPER_CONV
`?x y. x > &0 /\ y >= &0 /\ (&3 * x - &5 * y = &1)`;;
time COOPER_CONV `?x y z. &4 * x - &6 * y = &1`;;
time COOPER_CONV `!x. b < x ==> a <= x`;;
time COOPER_CONV `!x. a < &3 * x ==> b < &3 * x`;;
time COOPER_CONV `!x y. x <= y ==> &2 * x + &1 < &2 * y`;;
time COOPER_CONV `(?d. y = &65 * d) ==> (?d. y = &5 * d)`;;
time COOPER_CONV `!y. (?d. y = &65 * d) ==> (?d. y = &5 * d)`;;
time COOPER_CONV `!x y. ~(&2 * x + &1 = &2 * y)`;;
time COOPER_CONV `!x y z. (&2 * x + &1 = &2 * y) ==> x + y + z > &129`;;
time COOPER_CONV `!x. a < x ==> b < x`;;
time COOPER_CONV `!x. a <= x ==> b < x`;;
(* ------------------------------------------------------------------------- *)
(* Formula examples from Cooper's paper. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV `!a b. ?x. a < &20 * x /\ &20 * x < b`;;
time COOPER_CONV `?x. a < &20 * x /\ &20 * x < b`;;
time COOPER_CONV `!b. ?x. a < &20 * x /\ &20 * x < b`;;
time COOPER_CONV `!a. ?b. a < &4 * b + &3 * a \/ (~(a < b) /\ a > b + &1)`;;
time COOPER_CONV `?y. !x. x + &5 * y > &1 /\ &13 * x - y > &1 /\ x + &2 < &0`;;
(* ------------------------------------------------------------------------- *)
(* More of my own. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV `!x y. x >= &0 /\ y >= &0
==> &12 * x - &8 * y < &0 \/ &12 * x - &8 * y > &2`;;
time COOPER_CONV `?x y. &5 * x + &3 * y = &1`;;
time COOPER_CONV `?x y. &5 * x + &10 * y = &1`;;
time COOPER_CONV `?x y. x >= &0 /\ y >= &0 /\ (&5 * x - &6 * y = &1)`;;
time COOPER_CONV `?w x y z. &2 * w + &3 * x + &4 * y + &5 * z = &1`;;
time COOPER_CONV `?x y. x >= &0 /\ y >= &0 /\ (&5 * x - &3 * y = &1)`;;
time COOPER_CONV `?x y. x >= &0 /\ y >= &0 /\ (&3 * x - &5 * y = &1)`;;
time COOPER_CONV `?x y. x >= &0 /\ y >= &0 /\ (&6 * x - &3 * y = &1)`;;
time COOPER_CONV `!x y. ~(x = &0) ==> &5 * y < &6 * x \/ &5 * y > &6 * x`;;
time COOPER_CONV
`!x y. ~(&5 divides x) /\ ~(&6 divides y) ==> ~(&6 * x = &5 * y)`;;
time COOPER_CONV `!x y. ~(&5 divides x) ==> ~(&6 * x = &5 * y)`;;
time COOPER_CONV `!x y. ~(&6 * x = &5 * y)`;;
time COOPER_CONV `!x y. (&6 * x = &5 * y) ==> (?d. y = &3 * d)`;;
time COOPER_CONV `(&6 * x = &5 * y) ==> (?d. y = &3 * d)`;;
(* ------------------------------------------------------------------------- *)
(* Positive variant of the Bezout theorem (see the exercise). *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV
`!z. z > &7 ==> ?x y. x >= &0 /\ y >= &0 /\ (&3 * x + &5 * y = z)`;;
time COOPER_CONV
`!z. z > &2 ==> ?x y. x >= &0 /\ y >= &0 /\ (&3 * x + &5 * y = z)`;;
time COOPER_CONV `!z. z <= &7 ==>
((?x y. x >= &0 /\ y >= &0 /\ (&3 * x + &5 * y = z)) <=>
~(?x y. x >= &0 /\ y >= &0 /\ (&3 * x + &5 * y = &7 - z)))`;;
(* ------------------------------------------------------------------------- *)
(* Basic result about congruences. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV `!x. ~(&2 divides x) /\ &3 divides (x - &1) <=>
&12 divides (x - &1) \/ &12 divides (x - &7)`;;
time COOPER_CONV `!x. ~(?m. x = &2 * m) /\ (?m. x = &3 * m + &1) <=>
(?m. x = &12 * m + &1) \/ (?m. x = &12 * m + &7)`;;
(* ------------------------------------------------------------------------- *)
(* Something else. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV
`!x. ~(&2 divides x)
==> &4 divides (x - &1) \/
&8 divides (x - &1) \/
&8 divides (x - &3) \/
&6 divides (x - &1) \/
&14 divides (x - &1) \/
&14 divides (x - &9) \/
&14 divides (x - &11) \/
&24 divides (x - &5) \/
&24 divides (x - &11)`;;
(* ------------------------------------------------------------------------- *)
(* Testing fix for an earlier version with negative result from formlcm. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV
`!a b v_1 v_2 v_3.
(a + &2 = b) /\ (v_3 = b - a + &1) /\ (v_2 = b - &2) /\ (v_1 = &3) ==> F`;;
(* ------------------------------------------------------------------------- *)
(* Inspired by the Collatz conjecture. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV
`?a b. ~(a = &1) /\ ((&2 * b = a) \/ (&2 * b = &3 * a + &1)) /\
(a = b)`;;
time COOPER_CONV
`?a b. a > &1 /\ b > &1 /\
((&2 * b = a) \/ (&2 * b = &3 * a + &1)) /\
(a = b)`;;
time COOPER_CONV
`?b. a > &1 /\ b > &1 /\
((&2 * b = a) \/ (&2 * b = &3 * a + &1)) /\
((&2 * a = b) \/ (&2 * a = &3 * b + &1))`;;
(*************** These seem to take a long time
time COOPER_CONV
`?a b. a > &1 /\ b > &1 /\
((&2 * b = a) \/ (&2 * b = &3 * a + &1)) /\
((&2 * a = b) \/ (&2 * a = &3 * b + &1))`;;
let fm = (dnf ** parse)
`((2 * b = a) \/ (2 * b = &3 * a + 1)) /\
((2 * c = b) \/ (2 * c = &3 * b + 1)) /\
((2 * d = c) \/ (2 * d = &3 * c + 1)) /\
((2 * e = d) \/ (2 * e = &3 * d + 1)) /\
((2 * f = e) \/ (2 * f = &3 * e + 1)) /\
(f = a)`;;
let fms =
map (itlist (fun x p -> Exists(x,And(Atom(R(`>`,[Var x; Fn(`1`,[])])),p)))
[`b`; `c`; `d`; `e`; `f`])
(disjuncts fm);;
let fm = el &15 fms;;
integer_qelim fm;;
******************)
(* ------------------------------------------------------------------------- *)
(* More old examples. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV
`?x. &5 * x + x + x < x \/
(y = &7 - x) /\ &33 + z < x /\ x + &1 <= &2 * y \/
&3 divides &4 * x + z /\ (x + y + z = &7 * z)`;;
time COOPER_CONV
`?x. &5 * x + x + x < x \/
(y = &7 - x) /\
&33 + z < x /\
x + &1 <= &2 * y \/
&3 divides (&4 * x + z) /\
(x + y + z = &7 * z)`;;
time COOPER_CONV
`?x. &5 * x + x + x < x \/
(y = &7 - x) /\
&33 + z < x /\
x + &1 <= &2 * y \/
&3 divides (&4 * x + z) /\
(x + y + z = &7 * z)`;;
(**** This also seems very slow; one quantifier less maybe?
time COOPER_CONV
`?z y x. &5 * x + x + x < x \/
(y = &7 - x) /\
&33 + z < x /\
x + &1 <= &2 * y \/
&3 divides (&4 * x + z) /\
(x + y + z = &7 * z)`;;
time COOPER_CONV
`?y x. &5 * x + x + x < x \/
(y = &7 - x) /\
&33 + z < x /\
x + &1 <= &2 * y \/
&3 divides (&4 * x + z) /\
(x + y + z = &7 * z)`;;
*****)
time COOPER_CONV
`?x. x + &1 < &2 * y /\
&3 divides (&4 * x + z) /\
(&6 * x + y + z = &7 * z)`;;
time COOPER_CONV
`?x. &5 * x + x + x < x \/
(y = &7 - x) /\
&33 + z < x /\
x + &1 < &2 * y \/
&3 divides (&4 * x + z) /\
(x + y + z = &7 * z)`;;
(* ------------------------------------------------------------------------- *)
(* Stamp problem. *)
(* ------------------------------------------------------------------------- *)
time COOPER_CONV `!x. x >= &8 ==> ?u v. u >= &0 /\ v >= &0 /\
(x = &3 * u + &5 * v)`;;
time COOPER_CONV `!x. x >= &10 ==> ?u v. u >= &0 /\ v >= &0 /\
(x = &3 * u + &7 * v)`;;
time COOPER_CONV `!x. x >= &30 ==> ?u v. u >= &0 /\ v >= &0 /\
(x = &3 * u + &7 * v)`;;
(* ------------------------------------------------------------------------- *)
(* Decision procedures in the style of INT_ARITH and ARITH_RULE. *)
(* *)
(* Really I should locate the free alien subterms. *)
(* ------------------------------------------------------------------------- *)
let INT_COOPER tm =
let fvs = frees tm in
let tm' = list_mk_forall(fvs,tm) in
SPECL fvs (EQT_ELIM(COOPER_CONV tm'));;
let COOPER_RULE tm =
let fvs = frees tm in
let tm' = list_mk_forall(fvs,tm) in
let th = (NUM_TO_INT_CONV THENC COOPER_CONV) tm' in
SPECL fvs (EQT_ELIM th);;
(* ------------------------------------------------------------------------- *)
(* Examples. *)
(* ------------------------------------------------------------------------- *)
time INT_COOPER `abs(x) < &1 ==> (x = &0)`;;
time COOPER_RULE `ODD n ==> 2 * n DIV 2 < n`;;
time COOPER_RULE `!n. EVEN(n) ==> (2 * n DIV 2 = n)`;;
time COOPER_RULE `!n. ODD n <=> 2 * n DIV 2 < n`;;
(**** This seems quite slow (maybe not very) as well
time COOPER_RULE `n DIV 3 <= n DIV 2`;;
****)
(*** This one too?
time COOPER_RULE `!x. ?y. if EVEN x then x = 2 * y else x = 2 * (y - 1) + 1`;;
***)
time COOPER_RULE `!n. n >= 8 ==> ?a b. n = 3 * a + 5 * b`;;