Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
| (* ========================================================================= *) | |
| (* Perfect number theorems. *) | |
| (* ========================================================================= *) | |
| needs "Library/prime.ml";; | |
| prioritize_num();; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The sum-of-divisors function. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let sigma = new_definition | |
| `sigma(n) = if n = 0 then 0 else nsum {d | d divides n} (\i. i)`;; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Definition of perfection. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let perfect = new_definition | |
| `perfect n <=> ~(n = 0) /\ sigma(n) = 2 * n`;; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Various number-theoretic lemmas. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let ODD_POW2_MINUS1 = prove | |
| (`!k. ~(k = 0) ==> ODD(2 EXP k - 1)`, | |
| REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `EVEN(2 EXP k) <=> EVEN((2 EXP k - 1) + 1)` MP_TAC THENL | |
| [AP_TERM_TAC THEN REWRITE_TAC[ARITH_RULE `k = k - 1 + 1 <=> ~(k = 0)`] THEN | |
| REWRITE_TAC[EXP_EQ_0; ARITH]; | |
| ASM_REWRITE_TAC[GSYM NOT_EVEN; EVEN_ADD; EVEN_EXP; ARITH]]);; | |
| let EVEN_ODD_DECOMP = prove | |
| (`!n. ~(n = 0) ==> ?r s. ODD s /\ n = 2 EXP r * s`, | |
| MATCH_MP_TAC num_WF THEN X_GEN_TAC `n:num` THEN | |
| MP_TAC(SPEC `n:num` EVEN_OR_ODD) THEN | |
| REWRITE_TAC[EVEN_EXISTS; ODD_EXISTS] THEN | |
| DISCH_THEN(DISJ_CASES_THEN (X_CHOOSE_THEN `m:num` SUBST_ALL_TAC)) THENL | |
| [DISCH_THEN(MP_TAC o SPEC `m:num`) THEN | |
| REWRITE_TAC[MULT_EQ_0; ARITH; ARITH_RULE `m < 2 * m <=> ~(m = 0)`] THEN | |
| ASM_CASES_TAC `m = 0` THEN ASM_REWRITE_TAC[] THEN | |
| ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN MATCH_MP_TAC MONO_EXISTS THEN | |
| X_GEN_TAC `s:num` THEN DISCH_THEN(X_CHOOSE_TAC `r:num`) THEN | |
| EXISTS_TAC `SUC r` THEN ASM_REWRITE_TAC[EXP; GSYM MULT_ASSOC]; | |
| REPEAT(DISCH_THEN(K ALL_TAC)) THEN EXISTS_TAC `0` THEN | |
| REWRITE_TAC[EXP; MULT_CLAUSES] THEN MESON_TAC[]]);; | |
| let FINITE_DIVISORS = prove | |
| (`!n. ~(n = 0) ==> FINITE {d | d divides n}`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC FINITE_SUBSET THEN | |
| EXISTS_TAC `{d | d <= n}` THEN REWRITE_TAC[FINITE_NUMSEG_LE] THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM] THEN ASM_MESON_TAC[DIVIDES_LE]);; | |
| let MULT_EQ_COPRIME = prove | |
| (`!a b x y. a * b = x * y /\ coprime(a,x) | |
| ==> ?d. y = a * d /\ b = x * d`, | |
| REPEAT STRIP_TAC THEN | |
| MP_TAC(SPECL [`a:num`; `x:num`; `y:num`] COPRIME_DIVPROD) THEN | |
| MP_TAC(SPECL [`x:num`; `a:num`; `b:num`] COPRIME_DIVPROD) THEN | |
| REPEAT(ANTS_TAC THENL | |
| [ASM_MESON_TAC[DIVIDES_REFL; DIVIDES_RMUL; COPRIME_SYM]; | |
| REWRITE_TAC[divides] THEN STRIP_TAC]) THEN | |
| UNDISCH_TAC `a * b = x * y` THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[ARITH_RULE | |
| `(a * x * u = x * a * v) <=> (a * x) * u = (a * x) * v`] THEN | |
| REWRITE_TAC[EQ_MULT_LCANCEL; MULT_EQ_0] THEN ASM_MESON_TAC[]);; | |
| let COPRIME_ODD_POW2 = prove | |
| (`!k n. ODD(n) ==> coprime(2 EXP k,n)`, | |
| SIMP_TAC[coprime; PRIME_2; DIVIDES_PRIMEPOW] THEN REWRITE_TAC[divides] THEN | |
| REPEAT STRIP_TAC THEN UNDISCH_TAC `ODD n` THEN ASM_REWRITE_TAC[] THEN | |
| SIMP_TAC[ODD_MULT; ODD_EXP; ARITH]);; | |
| let MULT_NSUM = prove | |
| (`!s t. FINITE s /\ FINITE t | |
| ==> nsum s f * nsum t g = | |
| nsum {(x:A,y:B) | x IN s /\ y IN t} (\(x,y). f(x) * g(y))`, | |
| SIMP_TAC[GSYM NSUM_NSUM_PRODUCT; NSUM_LMUL; NSUM_RMUL]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Some elementary properties of the sigma function. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let SIGMA_0 = prove | |
| (`sigma 0 = 0`, | |
| REWRITE_TAC[sigma]);; | |
| let SIGMA_1 = prove | |
| (`sigma(1) = 1`, | |
| REWRITE_TAC[sigma; DIVIDES_ONE; SET_RULE `{d | d = 1} = {1}`] THEN | |
| REWRITE_TAC[ARITH; NSUM_SING]);; | |
| let SIGMA_LBOUND = prove | |
| (`!n. 1 < n ==> n + 1 <= sigma(n)`, | |
| REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM(ASSUME_TAC o MATCH_MP (ARITH_RULE `1 < n ==> ~(n = 0)`)) THEN | |
| ASM_REWRITE_TAC[sigma] THEN MATCH_MP_TAC LE_TRANS THEN | |
| EXISTS_TAC `nsum {1,n} (\i. i)` THEN CONJ_TAC THENL | |
| [SIMP_TAC[NSUM_CLAUSES; FINITE_RULES; IN_SING; NOT_IN_EMPTY] THEN | |
| ASM_ARITH_TAC; | |
| MATCH_MP_TAC NSUM_SUBSET_SIMPLE THEN ASM_SIMP_TAC[FINITE_DIVISORS] THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM; NOT_IN_EMPTY; IN_INSERT] THEN | |
| MESON_TAC[DIVIDES_1; DIVIDES_REFL]]);; | |
| let SIGMA_MULT = prove | |
| (`!a b. 1 < a /\ 1 < b ==> 1 + b + a * b <= sigma(a * b)`, | |
| REPEAT STRIP_TAC THEN | |
| EVERY_ASSUM(ASSUME_TAC o MATCH_MP (ARITH_RULE `1 < n ==> ~(n = 0)`)) THEN | |
| ASM_REWRITE_TAC[sigma] THEN MATCH_MP_TAC LE_TRANS THEN | |
| EXISTS_TAC `nsum {1,b,a*b} (\i. i)` THEN CONJ_TAC THENL | |
| [SIMP_TAC[NSUM_CLAUSES; FINITE_RULES; IN_INSERT; NOT_IN_EMPTY] THEN | |
| ONCE_REWRITE_TAC[ARITH_RULE `x = a * b <=> a * b = 1 * x`] THEN | |
| ASM_REWRITE_TAC[EQ_MULT_RCANCEL] THEN | |
| REWRITE_TAC[MULT_CLAUSES; MULT_EQ_1] THEN | |
| ASM_ARITH_TAC; | |
| ASM_REWRITE_TAC[MULT_EQ_0] THEN | |
| MATCH_MP_TAC NSUM_SUBSET_SIMPLE THEN | |
| ASM_SIMP_TAC[FINITE_DIVISORS; MULT_EQ_0] THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM; NOT_IN_EMPTY; IN_INSERT] THEN | |
| MESON_TAC[DIVIDES_1; DIVIDES_REFL; DIVIDES_LMUL]]);; | |
| let SIGMA_PRIME = prove | |
| (`!p. prime(p) ==> sigma(p) = p + 1`, | |
| GEN_TAC THEN | |
| ASM_CASES_TAC `p = 0` THEN ASM_REWRITE_TAC[PRIME_0; SIGMA_0; ARITH] THEN | |
| ASM_CASES_TAC `p = 1` THEN ASM_REWRITE_TAC[PRIME_1; SIGMA_1; ARITH] THEN | |
| DISCH_TAC THEN ASM_REWRITE_TAC[sigma] THEN | |
| MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC `nsum {1,p} (\i. i)` THEN | |
| CONJ_TAC THENL | |
| [AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_INSERT; NOT_IN_EMPTY] THEN | |
| ASM_MESON_TAC[prime; DIVIDES_1; DIVIDES_REFL]; | |
| ASM_SIMP_TAC[NSUM_CLAUSES; IN_SING; FINITE_RULES; NOT_IN_EMPTY] THEN | |
| ARITH_TAC]);; | |
| let SIGMA_PRIME_EQ = prove | |
| (`!p. prime(p) <=> sigma(p) = p + 1`, | |
| GEN_TAC THEN EQ_TAC THEN REWRITE_TAC[SIGMA_PRIME] THEN | |
| ONCE_REWRITE_TAC[GSYM CONTRAPOS_THM] THEN | |
| REWRITE_TAC[prime; DE_MORGAN_THM] THEN | |
| ASM_CASES_TAC `p = 1` THEN ASM_REWRITE_TAC[SIGMA_1; ARITH] THEN | |
| REWRITE_TAC[NOT_FORALL_THM; NOT_IMP; divides; DE_MORGAN_THM] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `a:num` (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC)) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `b:num` SUBST_ALL_TAC) THEN | |
| MP_TAC(SPECL [`a:num`; `b:num`] SIGMA_MULT) THEN | |
| ASM_CASES_TAC `a = 0` THEN ASM_REWRITE_TAC[MULT_CLAUSES; SIGMA_0; ARITH] THEN | |
| ASM_CASES_TAC `b = 0` THEN ASM_REWRITE_TAC[MULT_CLAUSES; SIGMA_0; ARITH] THEN | |
| REPEAT(POP_ASSUM MP_TAC) THEN REWRITE_TAC[MULT_EQ_1] THEN | |
| ONCE_REWRITE_TAC[ARITH_RULE `a = a * b <=> a * b = a * 1`] THEN | |
| REWRITE_TAC[EQ_MULT_LCANCEL] THEN ARITH_TAC);; | |
| let SIGMA_POW2 = prove | |
| (`!k. sigma(2 EXP k) = 2 EXP (k + 1) - 1`, | |
| GEN_TAC THEN REWRITE_TAC[sigma; EXP_EQ_0; ARITH] THEN | |
| MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `nsum {2 EXP i | i <= k} (\i. i)` THEN CONJ_TAC THENL | |
| [AP_THM_TAC THEN AP_TERM_TAC THEN | |
| SIMP_TAC[DIVIDES_PRIMEPOW; PRIME_2; EXTENSION; IN_ELIM_THM]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(ARITH_RULE `x + 1 = y ==> x = y - 1`) THEN | |
| SPEC_TAC(`k:num`,`k:num`) THEN INDUCT_TAC THEN REWRITE_TAC[LE] THENL | |
| [REWRITE_TAC[SET_RULE `{2 EXP i | i = 0} = {2 EXP 0}`] THEN | |
| REWRITE_TAC[ARITH; NSUM_SING]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[SET_RULE | |
| `{2 EXP i | i = SUC k \/ i <= k} = | |
| (2 EXP (SUC k)) INSERT {2 EXP i | i <= k}`] THEN | |
| POP_ASSUM MP_TAC THEN | |
| REWRITE_TAC[SET_RULE | |
| `{2 EXP i | i <= k} = IMAGE (\i. 2 EXP i) {i | i <= k}`] THEN | |
| SIMP_TAC[NSUM_CLAUSES; FINITE_IMAGE; FINITE_NUMSEG_LE] THEN | |
| REWRITE_TAC[IN_IMAGE; GSYM LE_ANTISYM; LE_EXP; ARITH] THEN | |
| REWRITE_TAC[LE_ANTISYM; IN_ELIM_THM; UNWIND_THM1] THEN | |
| REWRITE_TAC[ARITH_RULE `~(SUC k <= k)`] THEN | |
| DISCH_TAC THEN ASM_REWRITE_TAC[GSYM ADD_ASSOC] THEN | |
| REWRITE_TAC[EXP; EXP_ADD; ARITH] THEN ARITH_TAC);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Multiplicativity of sigma, the most interesting property. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let SIGMA_MULTIPLICATIVE = prove | |
| (`!a b. coprime(a,b) ==> sigma(a * b) = sigma(a) * sigma(b)`, | |
| REPEAT GEN_TAC THEN | |
| ASM_CASES_TAC `a = 0` THEN ASM_REWRITE_TAC[SIGMA_0; MULT_CLAUSES] THEN | |
| ASM_CASES_TAC `b = 0` THEN ASM_REWRITE_TAC[SIGMA_0; MULT_CLAUSES] THEN | |
| DISCH_TAC THEN ASM_REWRITE_TAC[sigma; MULT_EQ_0] THEN | |
| ASM_SIMP_TAC[FINITE_DIVISORS; MULT_NSUM] THEN | |
| REWRITE_TAC[IN_ELIM_THM] THEN MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC | |
| `nsum (IMAGE (\(x,y). x * y) | |
| {x,y | x divides a /\ y divides b}) (\i. i)` THEN | |
| CONJ_TAC THENL | |
| [AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM; EXISTS_PAIR_THM] THEN | |
| REWRITE_TAC[PAIR_EQ] THEN | |
| ONCE_REWRITE_TAC[TAUT `(a /\ b) /\ c <=> c /\ a /\ b`] THEN | |
| REWRITE_TAC[GSYM CONJ_ASSOC; RIGHT_EXISTS_AND_THM; UNWIND_THM1] THEN | |
| X_GEN_TAC `n:num` THEN EQ_TAC THEN REWRITE_TAC[DIVISION_DECOMP] THEN | |
| REWRITE_TAC[divides] THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| MESON_TAC[MULT_AC]; | |
| ALL_TAC] THEN | |
| W(fun (asl,w) -> MP_TAC(PART_MATCH (lhs o rand) NSUM_IMAGE (lhand w))) THEN | |
| REWRITE_TAC[o_DEF; ETA_AX] THEN DISCH_THEN MATCH_MP_TAC THEN | |
| REWRITE_TAC[FORALL_PAIR_THM; IN_ELIM_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`w:num`; `x:num`; `y:num`; `z:num`] THEN | |
| REWRITE_TAC[PAIR_EQ] THEN STRIP_TAC THEN | |
| REPEAT(FIRST_X_ASSUM(SUBST_ALL_TAC o SYM o | |
| check (is_var o rand o concl))) THEN | |
| REWRITE_TAC[GSYM DIVIDES_ANTISYM] THEN | |
| ASM_MESON_TAC[COPRIME_DIVISORS; COPRIME_SYM; COPRIME_DIVPROD; | |
| DIVIDES_RMUL; DIVIDES_REFL; MULT_SYM]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Hence the main theorems. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let PERFECT_EUCLID = prove | |
| (`!k. prime(2 EXP k - 1) ==> perfect(2 EXP (k - 1) * (2 EXP k - 1))`, | |
| GEN_TAC THEN ASM_CASES_TAC `k = 0` THEN ASM_REWRITE_TAC[ARITH; PRIME_0] THEN | |
| DISCH_TAC THEN | |
| SUBGOAL_THEN `coprime(2 EXP (k - 1),2 EXP k - 1)` ASSUME_TAC THENL | |
| [MATCH_MP_TAC COPRIME_ODD_POW2 THEN ASM_SIMP_TAC[ODD_POW2_MINUS1]; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[perfect; SIGMA_MULTIPLICATIVE; SIGMA_PRIME; SIGMA_POW2] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `~(k = 0) ==> k - 1 + 1 = k`; EXP_EQ_0; | |
| MULT_EQ_0; ARITH] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[PRIME_0]; ALL_TAC] THEN | |
| REWRITE_TAC[MULT_ASSOC] THEN GEN_REWRITE_TAC RAND_CONV [MULT_SYM] THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[GSYM(CONJUNCT2 EXP)] THEN | |
| AP_TERM_TAC THEN UNDISCH_TAC `~(k = 0)` THEN ARITH_TAC);; | |
| let PERFECT_EULER = prove | |
| (`!n. EVEN(n) /\ perfect(n) | |
| ==> ?k. prime(2 EXP k - 1) /\ n = 2 EXP (k - 1) * (2 EXP k - 1)`, | |
| GEN_TAC THEN MP_TAC(SPEC `n:num` EVEN_ODD_DECOMP) THEN | |
| ASM_CASES_TAC `n = 0` THENL | |
| [ASM_REWRITE_TAC[perfect]; ASM_REWRITE_TAC[]] THEN | |
| REWRITE_TAC[LEFT_IMP_EXISTS_THM; GSYM NOT_EVEN] THEN | |
| MAP_EVERY X_GEN_TAC [`r:num`; `s:num`] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC SUBST_ALL_TAC) THEN | |
| ASM_REWRITE_TAC[EVEN_EXP; EVEN_MULT; ARITH] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN | |
| REWRITE_TAC[perfect] THEN | |
| ASM_SIMP_TAC[SIGMA_MULTIPLICATIVE; SIGMA_POW2; | |
| COPRIME_ODD_POW2; GSYM NOT_EVEN] THEN | |
| DISCH_TAC THEN EXISTS_TAC `r + 1` THEN | |
| REWRITE_TAC[ADD_SUB; EQ_MULT_LCANCEL] THEN REWRITE_TAC[EXP_EQ_0; ARITH] THEN | |
| FIRST_X_ASSUM(MP_TAC o check(is_eq o concl)) THEN | |
| REWRITE_TAC[MULT_ASSOC; GSYM(CONJUNCT2 EXP); ADD1] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP | |
| (REWRITE_RULE[IMP_CONJ] MULT_EQ_COPRIME)) THEN | |
| ANTS_TAC THENL | |
| [ONCE_REWRITE_TAC[COPRIME_SYM] THEN MATCH_MP_TAC COPRIME_ODD_POW2 THEN | |
| SIMP_TAC[ODD_POW2_MINUS1; ADD_EQ_0; ARITH_EQ]; | |
| ALL_TAC] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `d:num` MP_TAC) THEN | |
| ASM_CASES_TAC `d = 0` THEN ASM_REWRITE_TAC[MULT_CLAUSES] THENL | |
| [ASM_MESON_TAC[EVEN]; ALL_TAC] THEN | |
| ASM_CASES_TAC `d = 1` THENL | |
| [ASM_REWRITE_TAC[MULT_CLAUSES; SIGMA_PRIME_EQ] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 (ASSUME_TAC o SYM) ASSUME_TAC) THEN | |
| ASM_REWRITE_TAC[] THEN EXPAND_TAC "s" THEN | |
| MATCH_MP_TAC(GSYM SUB_ADD) THEN | |
| REWRITE_TAC[ARITH_RULE `1 <= n <=> ~(n = 0)`; EXP_EQ_0; ARITH]; | |
| ALL_TAC] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 (ASSUME_TAC o SYM) ASSUME_TAC) THEN | |
| MP_TAC(SPECL [`2 EXP (r + 1) - 1`; `d:num`] SIGMA_MULT) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC(TAUT `a /\ ~b ==> (a ==> b) ==> c`) THEN | |
| REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC(ARITH_RULE `2 EXP 1 < a ==> 1 < a - 1`) THEN | |
| REWRITE_TAC[LT_EXP; ARITH] THEN | |
| UNDISCH_TAC `~(r = 0)` THEN ARITH_TAC; | |
| MAP_EVERY UNDISCH_TAC [`~(d = 0)`; `~(d = 1)`] THEN ARITH_TAC; | |
| REWRITE_TAC[NOT_LE] THEN EXPAND_TAC "s" THEN | |
| REWRITE_TAC[RIGHT_SUB_DISTRIB; MULT_CLAUSES] THEN | |
| MATCH_MP_TAC(ARITH_RULE `1 * d < x * d ==> x * d < 1 + d + x * d - d`) THEN | |
| ASM_REWRITE_TAC[LT_MULT_RCANCEL] THEN | |
| MATCH_MP_TAC(ARITH_RULE `2 EXP 0 < a ==> 1 < a`) THEN | |
| REWRITE_TAC[LT_EXP] THEN UNDISCH_TAC `~(r = 0)` THEN ARITH_TAC]);; | |