Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
| (* ========================================================================= *) | |
| (* Dirichlet's theorem. *) | |
| (* ========================================================================= *) | |
| needs "Library/products.ml";; | |
| needs "Library/agm.ml";; | |
| needs "Multivariate/transcendentals.ml";; | |
| needs "Library/pocklington.ml";; | |
| needs "Library/multiplicative.ml";; | |
| needs "Examples/mangoldt.ml";; | |
| prioritize_real();; | |
| prioritize_complex();; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Rearranging a certain kind of double sum. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let VSUM_VSUM_DIVISORS = prove | |
| (`!f x. vsum (1..x) (\n. vsum {d | d divides n} (f n)) = | |
| vsum (1..x) (\n. vsum (1..(x DIV n)) (\k. f (k * n) n))`, | |
| SIMP_TAC[VSUM; FINITE_DIVISORS; LE_1] THEN | |
| SIMP_TAC[VSUM; FINITE_NUMSEG; ITERATE_ITERATE_DIVISORS; | |
| MONOIDAL_VECTOR_ADD]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Useful approximation lemmas. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let REAL_EXP_1_LE_4 = prove | |
| (`exp(&1) <= &4`, | |
| ONCE_REWRITE_TAC[ARITH_RULE `&1 = &1 / &2 + &1 / &2`; REAL_EXP_ADD] THEN | |
| REWRITE_TAC[REAL_ARITH `&4 = &2 * &2`; REAL_EXP_ADD] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN REWRITE_TAC[REAL_EXP_POS_LE] THEN | |
| MP_TAC(SPEC `&1 / &2` REAL_EXP_BOUND_LEMMA) THEN REAL_ARITH_TAC);; | |
| let DECREASING_LOG_OVER_N = prove | |
| (`!n. 4 <= n ==> log(&n + &1) / (&n + &1) <= log(&n) / &n`, | |
| REWRITE_TAC[GSYM REAL_OF_NUM_LE] THEN REPEAT STRIP_TAC THEN | |
| MP_TAC(ISPECL [`\z. clog z / z`; `\z. (Cx(&1) - clog(z)) / z pow 2`; | |
| `Cx(&n)`; `Cx(&n + &1)`] COMPLEX_MVT_LINE) THEN | |
| REWRITE_TAC[IN_SEGMENT_CX_GEN] THEN | |
| REWRITE_TAC[REAL_ARITH `~(n + &1 <= x /\ x <= n)`] THEN ANTS_TAC THENL | |
| [X_GEN_TAC `w:complex` THEN STRIP_TAC THEN COMPLEX_DIFF_TAC THEN | |
| SUBGOAL_THEN `&0 < Re w` MP_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_CASES_TAC `w = Cx(&0)` THEN ASM_SIMP_TAC[RE_CX; REAL_LT_REFL] THEN | |
| DISCH_TAC THEN UNDISCH_TAC `~(w = Cx(&0))` THEN CONV_TAC COMPLEX_FIELD; | |
| DISCH_THEN(X_CHOOSE_THEN `z:complex` | |
| (CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC)) THEN | |
| SUBGOAL_THEN `&0 < &n /\ &0 < &n + &1` STRIP_ASSUME_TAC THENL | |
| [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM CX_LOG; GSYM CX_DIV; RE_CX; GSYM CX_SUB] THEN | |
| MATCH_MP_TAC(REAL_ARITH `&0 <= --x ==> a - b = x ==> a <= b`) THEN | |
| REWRITE_TAC[RE_MUL_CX; GSYM REAL_MUL_LNEG] THEN | |
| MATCH_MP_TAC REAL_LE_MUL THEN CONJ_TAC THENL [ALL_TAC; REAL_ARITH_TAC] THEN | |
| SUBGOAL_THEN `?u. z = Cx(u)` (CHOOSE_THEN SUBST_ALL_TAC) THENL | |
| [ASM_MESON_TAC[REAL; real]; ALL_TAC] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[IM_CX; RE_CX]) THEN | |
| UNDISCH_THEN `T` (K ALL_TAC) THEN | |
| SUBGOAL_THEN `&0 < u` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM CX_LOG; GSYM CX_SUB; GSYM CX_POW; GSYM CX_DIV; RE_CX; | |
| real_div; GSYM REAL_MUL_LNEG; REAL_NEG_SUB; GSYM REAL_POW_INV] THEN | |
| MATCH_MP_TAC REAL_LE_MUL THEN REWRITE_TAC[REAL_POW_2; REAL_LE_SQUARE] THEN | |
| REWRITE_TAC[REAL_SUB_LE] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM LOG_EXP] THEN | |
| MATCH_MP_TAC LOG_MONO_LE_IMP THEN REWRITE_TAC[REAL_EXP_POS_LT] THEN | |
| MP_TAC REAL_EXP_1_LE_4 THEN ASM_REAL_ARITH_TAC]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* An ad-hoc fact about complex n'th roots. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let EXISTS_COMPLEX_ROOT_NONTRIVIAL = prove | |
| (`!a n. 2 <= n ==> ?z. z pow n = a /\ ~(z = Cx(&1))`, | |
| REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM(ASSUME_TAC o MATCH_MP(ARITH_RULE `2 <= n ==> ~(n = 0)`)) THEN | |
| ASM_CASES_TAC `a = Cx(&0)` THENL | |
| [EXISTS_TAC `Cx(&0)` THEN ASM_REWRITE_TAC[COMPLEX_POW_ZERO] THEN | |
| CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| ASM_CASES_TAC `a = Cx(&1)` THENL | |
| [EXISTS_TAC `cexp(Cx(&2) * Cx pi * ii * Cx(&1 / &n))` THEN | |
| ASM_SIMP_TAC[COMPLEX_ROOT_UNITY_EQ_1; DIVIDES_ONE; | |
| ARITH_RULE `2 <= n ==> ~(n = 1)`; COMPLEX_ROOT_UNITY]; | |
| MATCH_MP_TAC(MESON[] | |
| `(!x. ~Q x ==> ~P x) /\ (?x. P x) ==> (?x. P x /\ Q x)`) THEN | |
| ASM_SIMP_TAC[COMPLEX_POW_ONE] THEN EXISTS_TAC `cexp(clog a / Cx(&n))` THEN | |
| ASM_SIMP_TAC[GSYM CEXP_N; COMPLEX_DIV_LMUL; CX_INJ; REAL_OF_NUM_EQ] THEN | |
| ASM_SIMP_TAC[CEXP_CLOG]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Definition of a Dirichlet character mod d. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let dirichlet_character = new_definition | |
| `dirichlet_character d (c:num->complex) <=> | |
| (!n. c(n + d) = c(n)) /\ | |
| (!n. c(n) = Cx(&0) <=> ~coprime(n,d)) /\ | |
| (!m n. c(m * n) = c(m) * c(n))`;; | |
| let DIRICHLET_CHARACTER_PERIODIC = prove | |
| (`!d c n. dirichlet_character d c ==> c(n + d) = c(n)`, | |
| SIMP_TAC[dirichlet_character]);; | |
| let DIRICHLET_CHARACTER_EQ_0 = prove | |
| (`!d c n. dirichlet_character d c ==> (c(n) = Cx(&0) <=> ~coprime(n,d))`, | |
| SIMP_TAC[dirichlet_character]);; | |
| let DIRICHLET_CHARACTER_MUL = prove | |
| (`!d c m n. dirichlet_character d c ==> c(m * n) = c(m) * c(n)`, | |
| SIMP_TAC[dirichlet_character]);; | |
| let DIRICHLET_CHARACTER_EQ_1 = prove | |
| (`!d c. dirichlet_character d c ==> c(1) = Cx(&1)`, | |
| REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP DIRICHLET_CHARACTER_MUL) THEN | |
| DISCH_THEN(MP_TAC o repeat (SPEC `1`)) THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[COMPLEX_FIELD `a = a * a <=> a = Cx(&0) \/ a = Cx(&1)`] THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_EQ_0] THEN | |
| MESON_TAC[COPRIME_1; COPRIME_SYM]);; | |
| let DIRICHLET_CHARACTER_POW = prove | |
| (`!d c m n. dirichlet_character d c ==> c(m EXP n) = c(m) pow n`, | |
| REPLICATE_TAC 3 GEN_TAC THEN REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN | |
| DISCH_TAC THEN INDUCT_TAC THEN ASM_SIMP_TAC[EXP; complex_pow] THENL | |
| [ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1]; ALL_TAC] THEN | |
| FIRST_ASSUM(fun th -> REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_MUL th]) THEN | |
| ASM_REWRITE_TAC[]);; | |
| let DIRICHLET_CHARACTER_PERIODIC_GEN = prove | |
| (`!d c m n. dirichlet_character d c ==> c(m * d + n) = c(n)`, | |
| REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| INDUCT_TAC THEN REWRITE_TAC[ADD_CLAUSES; MULT_CLAUSES] THEN | |
| GEN_TAC THEN | |
| FIRST_X_ASSUM(fun th -> GEN_REWRITE_TAC RAND_CONV [GSYM th]) THEN | |
| ONCE_REWRITE_TAC[ARITH_RULE `(mk + d) + n:num = (mk + n) + d`] THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_PERIODIC]);; | |
| let DIRICHLET_CHARACTER_CONG = prove | |
| (`!d c m n. | |
| dirichlet_character d c /\ (m == n) (mod d) ==> c(m) = c(n)`, | |
| REWRITE_TAC[CONG_CASES] THEN REPEAT STRIP_TAC THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_PERIODIC_GEN]);; | |
| let DIRICHLET_CHARACTER_ROOT = prove | |
| (`!d c n. dirichlet_character d c /\ coprime(d,n) | |
| ==> c(n) pow phi(d) = Cx(&1)`, | |
| REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM(SUBST1_TAC o GSYM o MATCH_MP DIRICHLET_CHARACTER_EQ_1) THEN | |
| FIRST_ASSUM(fun th -> | |
| REWRITE_TAC[GSYM(MATCH_MP DIRICHLET_CHARACTER_POW th)]) THEN | |
| MATCH_MP_TAC DIRICHLET_CHARACTER_CONG THEN | |
| EXISTS_TAC `d:num` THEN ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC FERMAT_LITTLE THEN ASM_MESON_TAC[COPRIME_SYM]);; | |
| let DIRICHLET_CHARACTER_NORM = prove | |
| (`!d c n. dirichlet_character d c | |
| ==> norm(c n) = if coprime(d,n) then &1 else &0`, | |
| REPEAT STRIP_TAC THEN COND_CASES_TAC THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[COMPLEX_NORM_ZERO] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_0; COPRIME_SYM]] THEN | |
| ASM_CASES_TAC `d = 0` THENL | |
| [ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1; COMPLEX_NORM_CX; REAL_ABS_NUM; | |
| COPRIME_0; COPRIME_SYM]; | |
| ALL_TAC] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`; `n:num`] | |
| DIRICHLET_CHARACTER_ROOT) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(MP_TAC o AP_TERM `norm:complex->real`) THEN | |
| REWRITE_TAC[COMPLEX_NORM_POW; COMPLEX_NORM_CX; REAL_ABS_NUM] THEN | |
| DISCH_TAC THEN | |
| MP_TAC(SPECL [`norm((c:num->complex) n)`; `phi d`] REAL_POW_EQ_1_IMP) THEN | |
| ASM_REWRITE_TAC[REAL_ABS_NORM] THEN | |
| ASM_MESON_TAC[PHI_LOWERBOUND_1_STRONG; LE_1]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The principal character mod d. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let chi_0 = new_definition | |
| `chi_0 d n = if coprime(n,d) then Cx(&1) else Cx(&0)`;; | |
| let DIRICHLET_CHARACTER_CHI_0 = prove | |
| (`dirichlet_character d (chi_0 d)`, | |
| REWRITE_TAC[dirichlet_character; chi_0] THEN | |
| REWRITE_TAC[NUMBER_RULE `coprime(n + d,d) <=> coprime(n,d)`; | |
| NUMBER_RULE `coprime(m * n,d) <=> coprime(m,d) /\ coprime(n,d)`] THEN | |
| CONV_TAC COMPLEX_RING);; | |
| let DIRICHLET_CHARACTER_EQ_PRINCIPAL = prove | |
| (`!d c. dirichlet_character d c | |
| ==> (c = chi_0 d <=> !n. coprime(n,d) ==> c(n) = Cx(&1))`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[FUN_EQ_THM; chi_0] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_0]);; | |
| let DIRICHLET_CHARACTER_NONPRINCIPAL = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> ?n. coprime(n,d) /\ ~(c n = Cx(&0)) /\ ~(c n = Cx(&1))`, | |
| MESON_TAC[DIRICHLET_CHARACTER_EQ_PRINCIPAL; DIRICHLET_CHARACTER_EQ_0]);; | |
| let DIRICHLET_CHARACTER_0 = prove | |
| (`!c. dirichlet_character 0 c <=> c = chi_0 0`, | |
| GEN_TAC THEN EQ_TAC THEN SIMP_TAC[DIRICHLET_CHARACTER_CHI_0] THEN | |
| DISCH_TAC THEN REWRITE_TAC[chi_0; FUN_EQ_THM; COPRIME_0] THEN | |
| X_GEN_TAC `n:num` THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1; DIRICHLET_CHARACTER_EQ_0; | |
| COPRIME_0]);; | |
| let DIRICHLET_CHARACTER_1 = prove | |
| (`!c. dirichlet_character 1 c <=> !n. c n = Cx(&1)`, | |
| GEN_TAC THEN REWRITE_TAC[dirichlet_character; COPRIME_1] THEN EQ_TAC THENL | |
| [STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPECL [`1`; `1`]) THEN | |
| ASM_REWRITE_TAC[ARITH; COMPLEX_RING | |
| `x = x * x <=> x = Cx(&0) \/ x = Cx(&1)`] THEN | |
| DISCH_TAC THEN INDUCT_TAC THEN ASM_REWRITE_TAC[ADD1] THEN | |
| REPEAT(FIRST_X_ASSUM(MP_TAC o SPEC `0`)) THEN ASM_REWRITE_TAC[ARITH] THEN | |
| CONV_TAC COMPLEX_RING; | |
| DISCH_TAC THEN ASM_REWRITE_TAC[] THEN CONV_TAC COMPLEX_RING]);; | |
| let DIRICHLET_CHARACTER_NONPRINCIPAL_NONTRIVIAL = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> ~(d = 0) /\ ~(d = 1)`, | |
| REPEAT GEN_TAC THEN ASM_CASES_TAC `d = 0` THEN | |
| ASM_REWRITE_TAC[DIRICHLET_CHARACTER_0; TAUT `~(p /\ ~p)`] THEN | |
| ASM_CASES_TAC `d = 1` THEN | |
| ASM_REWRITE_TAC[DIRICHLET_CHARACTER_1; chi_0; FUN_EQ_THM; COPRIME_1] THEN | |
| CONV_TAC TAUT);; | |
| let DIRICHLET_CHARACTER_ZEROSUM = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> vsum(1..d) c = Cx(&0)`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(STRIP_ASSUME_TAC o | |
| MATCH_MP DIRICHLET_CHARACTER_NONPRINCIPAL_NONTRIVIAL) THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP DIRICHLET_CHARACTER_NONPRINCIPAL) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `m:num` STRIP_ASSUME_TAC) THEN | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `!x. x * c = c /\ ~(x = Cx(&1)) ==> c = Cx(&0)`) THEN | |
| EXISTS_TAC `(c:num->complex) m` THEN | |
| ASM_SIMP_TAC[GSYM VSUM_COMPLEX_LMUL; FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC(MESON[] | |
| `!t. vsum t f = vsum s f /\ vsum t g = vsum s g /\ vsum t f = vsum t g | |
| ==> vsum s f = vsum s g`) THEN | |
| EXISTS_TAC `{n | coprime(n,d) /\ n < d}` THEN | |
| REPEAT(CONJ_TAC THENL | |
| [CONV_TAC SYM_CONV THEN MATCH_MP_TAC VSUM_SUPERSET THEN | |
| SIMP_TAC[SUBSET; IN_NUMSEG; LT_IMP_LE; IN_ELIM_THM] THEN CONJ_TAC THEN | |
| X_GEN_TAC `r:num` THENL | |
| [ASM_CASES_TAC `r = 0` THENL [ALL_TAC; ASM_ARITH_TAC] THEN | |
| ONCE_REWRITE_TAC[COPRIME_SYM] THEN ASM_REWRITE_TAC[COPRIME_0]; | |
| ASM_CASES_TAC `coprime(r,d)` THEN ASM_REWRITE_TAC[] THENL | |
| [ASM_CASES_TAC `r:num = d` THEN ASM_REWRITE_TAC[LT_REFL] THENL | |
| [ASM_MESON_TAC[COPRIME_REFL]; ASM_ARITH_TAC]; | |
| REWRITE_TAC[COMPLEX_VEC_0] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_0; COMPLEX_MUL_RZERO]]]; | |
| ALL_TAC]) THEN | |
| FIRST_ASSUM(fun th -> | |
| REWRITE_TAC[GSYM(MATCH_MP DIRICHLET_CHARACTER_MUL (CONJUNCT1 th))]) THEN | |
| SIMP_TAC[VSUM; PHI_FINITE_LEMMA] THEN | |
| MATCH_MP_TAC ITERATE_OVER_COPRIME THEN SIMP_TAC[MONOIDAL_VECTOR_ADD] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_CONG]);; | |
| let DIRICHLET_CHARACTER_ZEROSUM_MUL = prove | |
| (`!d c n. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> vsum(1..d*n) c = Cx(&0)`, | |
| REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| INDUCT_TAC THEN REWRITE_TAC[MULT_CLAUSES; VSUM_CLAUSES_NUMSEG] THEN | |
| REWRITE_TAC[ARITH; COMPLEX_VEC_0] THEN ONCE_REWRITE_TAC[ADD_SYM] THEN | |
| ASM_SIMP_TAC[VSUM_ADD_SPLIT; ARITH_RULE `1 <= n + 1`; COMPLEX_ADD_LID] THEN | |
| ONCE_REWRITE_TAC[ADD_SYM] THEN REWRITE_TAC[VSUM_OFFSET] THEN | |
| FIRST_ASSUM(SUBST1_TAC o SYM o MATCH_MP DIRICHLET_CHARACTER_ZEROSUM) THEN | |
| MATCH_MP_TAC VSUM_EQ THEN REPEAT STRIP_TAC THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC DIRICHLET_CHARACTER_CONG THEN EXISTS_TAC `d:num` THEN | |
| ASM_REWRITE_TAC[] THEN NUMBER_TAC);; | |
| let DIRICHLET_CHARACTER_SUM_MOD = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> vsum(1..n) c = vsum(1..(n MOD d)) c`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(STRIP_ASSUME_TAC o MATCH_MP | |
| DIRICHLET_CHARACTER_NONPRINCIPAL_NONTRIVIAL) THEN | |
| FIRST_ASSUM(MP_TAC o SPEC `n:num` o MATCH_MP DIVISION) THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN | |
| DISCH_THEN(fun th -> GEN_REWRITE_TAC (LAND_CONV o ONCE_DEPTH_CONV) [th]) THEN | |
| SIMP_TAC[VSUM_ADD_SPLIT; ARITH_RULE `1 <= n + 1`] THEN | |
| ONCE_REWRITE_TAC[MULT_SYM] THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_ZEROSUM_MUL; COMPLEX_ADD_LID] THEN | |
| ONCE_REWRITE_TAC[ADD_SYM] THEN REWRITE_TAC[VSUM_OFFSET] THEN | |
| FIRST_ASSUM(SUBST1_TAC o SYM o MATCH_MP DIRICHLET_CHARACTER_ZEROSUM) THEN | |
| MATCH_MP_TAC VSUM_EQ THEN REPEAT STRIP_TAC THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC DIRICHLET_CHARACTER_CONG THEN EXISTS_TAC `d:num` THEN | |
| ASM_REWRITE_TAC[] THEN CONV_TAC NUMBER_RULE);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Finiteness of the set of characters (later we could get size = phi(d)). *) | |
| (* ------------------------------------------------------------------------- *) | |
| let FINITE_DIRICHLET_CHARACTERS = prove | |
| (`!d. FINITE {c | dirichlet_character d c}`, | |
| GEN_TAC THEN ASM_CASES_TAC `d = 0` THENL | |
| [ASM_SIMP_TAC[DIRICHLET_CHARACTER_0; SET_RULE `{x | x = a} = {a}`] THEN | |
| SIMP_TAC[FINITE_RULES]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC FINITE_SUBSET THEN | |
| EXISTS_TAC `IMAGE (\c n. c(n MOD d)) | |
| {c | (!m. m IN {m | m < d} | |
| ==> c(m) IN (Cx(&0) INSERT | |
| {z | z pow (phi d) = Cx(&1)})) /\ | |
| (!m. ~(m IN {m | m < d}) | |
| ==> c(m) = Cx(&0))}` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC FINITE_IMAGE THEN MATCH_MP_TAC FINITE_FUNSPACE THEN | |
| ASM_SIMP_TAC[FINITE_NUMSEG_LT; FINITE_INSERT] THEN | |
| MATCH_MP_TAC FINITE_COMPLEX_ROOTS_UNITY THEN | |
| ASM_SIMP_TAC[PHI_LOWERBOUND_1_STRONG; LE_1]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM] THEN X_GEN_TAC `c:num->complex` THEN | |
| DISCH_TAC THEN REWRITE_TAC[IN_IMAGE; IN_ELIM_THM; IN_INSERT] THEN | |
| EXISTS_TAC `\n:num. if n < d then c(n) else Cx(&0)` THEN | |
| ASM_SIMP_TAC[DIVISION; FUN_EQ_THM] THEN CONJ_TAC THEN X_GEN_TAC `m:num` THENL | |
| [MATCH_MP_TAC DIRICHLET_CHARACTER_CONG THEN EXISTS_TAC `d:num` THEN | |
| ASM_MESON_TAC[CONG_MOD; CONG_SYM]; | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_ROOT; COPRIME_SYM; | |
| DIRICHLET_CHARACTER_EQ_0]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Very basic group structure. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let DIRICHLET_CHARACTER_MUL_CNJ = prove | |
| (`!d c n. dirichlet_character d c /\ ~(c n = Cx(&0)) | |
| ==> cnj(c n) * c n = Cx(&1) /\ c n * cnj(c n) = Cx(&1)`, | |
| REPEAT GEN_TAC THEN STRIP_TAC THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD | |
| `inv z = w /\ ~(z = Cx(&0)) ==> w * z = Cx(&1) /\ z * w = Cx(&1)`) THEN | |
| ASM_REWRITE_TAC[COMPLEX_INV_CNJ] THEN | |
| FIRST_ASSUM(MP_TAC o GEN_REWRITE_RULE I [GSYM COMPLEX_NORM_NZ]) THEN | |
| FIRST_ASSUM(fun th -> REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_NORM th]) THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_LT_REFL; COMPLEX_POW_ONE] THEN | |
| REWRITE_TAC[COMPLEX_DIV_1]);; | |
| let DIRICHLET_CHARACTER_CNJ = prove | |
| (`!d c. dirichlet_character d c ==> dirichlet_character d (\n. cnj(c n))`, | |
| SIMP_TAC[dirichlet_character; CNJ_MUL; CNJ_EQ_CX]);; | |
| let DIRICHLET_CHARACTER_GROUPMUL = prove | |
| (`!d c1 c2. dirichlet_character d c1 /\ dirichlet_character d c2 | |
| ==> dirichlet_character d (\n. c1(n) * c2(n))`, | |
| SIMP_TAC[dirichlet_character; COMPLEX_ENTIRE] THEN | |
| REWRITE_TAC[COMPLEX_MUL_AC]);; | |
| let DIRICHLET_CHARACTER_GROUPINV = prove | |
| (`!d c. dirichlet_character d c ==> (\n. cnj(c n) * c n) = chi_0 d`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[chi_0; FUN_EQ_THM] THEN | |
| REPEAT STRIP_TAC THEN COND_CASES_TAC THENL | |
| [ASM_MESON_TAC[DIRICHLET_CHARACTER_MUL_CNJ; DIRICHLET_CHARACTER_EQ_0]; | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_0; COMPLEX_MUL_RZERO]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Orthogonality relations, a weak version of one first. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let DIRICHLET_CHARACTER_SUM_OVER_NUMBERS = prove | |
| (`!d c. dirichlet_character d c | |
| ==> vsum (1..d) c = if c = chi_0 d then Cx(&(phi d)) else Cx(&0)`, | |
| REPEAT STRIP_TAC THEN COND_CASES_TAC THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_ZEROSUM] THEN | |
| FIRST_X_ASSUM SUBST1_TAC THEN POP_ASSUM(K ALL_TAC) THEN | |
| GEN_REWRITE_TAC (LAND_CONV o RAND_CONV) [GSYM ETA_AX] THEN | |
| REWRITE_TAC[chi_0] THEN | |
| SIMP_TAC[GSYM VSUM_RESTRICT_SET; FINITE_NUMSEG; GSYM COMPLEX_VEC_0] THEN | |
| SIMP_TAC[phi; VSUM_CONST; FINITE_RESTRICT; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[COMPLEX_CMUL; COMPLEX_MUL_RID] THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_NUMSEG] THEN | |
| X_GEN_TAC `x:num` THEN ASM_CASES_TAC `coprime(x,d)` THEN | |
| ASM_REWRITE_TAC[] THEN ARITH_TAC);; | |
| let DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_WEAK = prove | |
| (`!d n. vsum {c | dirichlet_character d c} (\x. x n) = Cx(&0) \/ | |
| coprime(n,d) /\ !c. dirichlet_character d c ==> c(n) = Cx(&1)`, | |
| REPEAT GEN_TAC THEN ASM_CASES_TAC `coprime(n,d)` THENL | |
| [ALL_TAC; | |
| DISJ1_TAC THEN REWRITE_TAC[GSYM COMPLEX_VEC_0] THEN | |
| MATCH_MP_TAC VSUM_EQ_0 THEN | |
| ASM_SIMP_TAC[IN_ELIM_THM; COMPLEX_VEC_0; DIRICHLET_CHARACTER_EQ_0]] THEN | |
| SUBGOAL_THEN | |
| `!c'. dirichlet_character d c' | |
| ==> vsum {c | dirichlet_character d c} | |
| ((\c. c(n)) o (\c n. c'(n) * c(n))) = | |
| vsum {c | dirichlet_character d c} (\c. c(n))` | |
| MP_TAC THENL | |
| [ALL_TAC; | |
| SIMP_TAC[o_DEF; FINITE_DIRICHLET_CHARACTERS; VSUM_COMPLEX_LMUL] THEN | |
| REWRITE_TAC[COMPLEX_RING `a * x = x <=> a = Cx(&1) \/ x = Cx(&0)`] THEN | |
| ASM_MESON_TAC[]] THEN | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC VSUM_INJECTION THEN | |
| REWRITE_TAC[FINITE_DIRICHLET_CHARACTERS; IN_ELIM_THM] THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_GROUPMUL] THEN | |
| REPEAT STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o AP_TERM `(\c n. cnj(c'(n:num)) * c n)`) THEN | |
| REWRITE_TAC[FUN_EQ_THM] THEN DISCH_TAC THEN X_GEN_TAC `m:num` THEN | |
| ASM_CASES_TAC `coprime(m,d)` THENL | |
| [ALL_TAC; ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_0]] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `m:num`) THEN | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `a * b = Cx(&1) ==> a * b * x = a * b * y ==> x = y`) THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_0; DIRICHLET_CHARACTER_MUL_CNJ]);; | |
| let DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_POS = prove | |
| (`!d n. real(vsum {c | dirichlet_character d c} (\c. c n)) /\ | |
| &0 <= Re(vsum {c | dirichlet_character d c} (\c. c n))`, | |
| MP_TAC DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_WEAK THEN | |
| REPEAT(MATCH_MP_TAC MONO_FORALL THEN GEN_TAC) THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[REAL_CX; RE_CX; REAL_LE_REFL] THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_VSUM; | |
| SIMP_TAC[FINITE_DIRICHLET_CHARACTERS; RE_VSUM] THEN | |
| MATCH_MP_TAC SUM_POS_LE] THEN | |
| ASM_SIMP_TAC[FINITE_DIRICHLET_CHARACTERS; IN_ELIM_THM; REAL_CX; RE_CX] THEN | |
| REWRITE_TAC[REAL_POS]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* A somewhat gruesome lemma about extending a character from a subgroup. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let CHARACTER_EXTEND_FROM_SUBGROUP = prove | |
| (`!f h a d. | |
| h SUBSET {x | x < d /\ coprime(x,d)} /\ | |
| (1 IN h) /\ | |
| (!x y. x IN h /\ y IN h ==> ((x * y) MOD d) IN h) /\ | |
| (!x. x IN h ==> ?y. y IN h /\ (x * y == 1) (mod d)) /\ | |
| (!x. x IN h ==> ~(f x = Cx(&0))) /\ | |
| (!x y. x IN h /\ y IN h | |
| ==> f((x * y) MOD d) = f(x) * f(y)) /\ | |
| a IN {x | x < d /\ coprime(x,d)} DIFF h | |
| ==> ?f' h'. (a INSERT h) SUBSET h' /\ | |
| h' SUBSET {x | x < d /\ coprime(x,d)} /\ | |
| (!x. x IN h ==> f'(x) = f(x)) /\ | |
| ~(f' a = Cx(&1)) /\ | |
| 1 IN h' /\ | |
| (!x y. x IN h' /\ y IN h' ==> ((x * y) MOD d) IN h') /\ | |
| (!x. x IN h' ==> ?y. y IN h' /\ (x * y == 1) (mod d)) /\ | |
| (!x. x IN h' ==> ~(f' x = Cx(&0))) /\ | |
| (!x y. x IN h' /\ y IN h' | |
| ==> f'((x * y) MOD d) = f'(x) * f'(y))`, | |
| REWRITE_TAC[IN_ELIM_THM; IN_DIFF; SUBSET] THEN REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `1 < d` ASSUME_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN | |
| FIRST_ASSUM(ASSUME_TAC o MATCH_MP LT_IMP_LE) THEN | |
| SUBGOAL_THEN `?m x. 0 < m /\ x IN h /\ (a EXP m == x) (mod d)` MP_TAC THENL | |
| [MAP_EVERY EXISTS_TAC [`phi d`; `1`] THEN ASM_REWRITE_TAC[] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[PHI_LOWERBOUND_1_STRONG; LE_1]; ALL_TAC] THEN | |
| MATCH_MP_TAC FERMAT_LITTLE THEN ASM SET_TAC[]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `!x s. x IN h ==> ((x EXP s) MOD d) IN h` ASSUME_TAC THENL | |
| [REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN GEN_TAC THEN DISCH_TAC THEN | |
| INDUCT_TAC THEN ASM_SIMP_TAC[EXP; MOD_LT] THEN | |
| SUBGOAL_THEN `((x * (x EXP s) MOD d) MOD d) IN h` MP_TAC THEN | |
| ASM_MESON_TAC[MOD_MULT_RMOD; ASSUME `1 <= d`; LE_1]; | |
| ALL_TAC] THEN | |
| GEN_REWRITE_TAC LAND_CONV [num_WOP] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `m:num` MP_TAC) THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 | |
| (X_CHOOSE_THEN `am:num` STRIP_ASSUME_TAC) MP_TAC) THEN | |
| FIRST_ASSUM(DISJ_CASES_TAC o MATCH_MP (ARITH_RULE | |
| `0 < m ==> m = 1 \/ 2 <= m`)) | |
| THENL | |
| [FIRST_X_ASSUM SUBST_ALL_TAC THEN UNDISCH_TAC `(a EXP 1 == am) (mod d)` THEN | |
| ASM_SIMP_TAC[EXP_1; GSYM CONG_MOD_LT; MOD_LT] THEN ASM_MESON_TAC[]; | |
| ALL_TAC] THEN | |
| DISCH_THEN(MP_TAC o GEN `r:num` o SPEC `r MOD m`) THEN | |
| ASM_SIMP_TAC[DIVISION; LE_1; NOT_EXISTS_THM] THEN | |
| REWRITE_TAC[TAUT `~(a /\ b /\ c) <=> b /\ c ==> ~a`] THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `!r x. x IN h /\ (a EXP r == x) (mod d) ==> m divides r` | |
| ASSUME_TAC THENL | |
| [REPEAT STRIP_TAC THEN ASM_SIMP_TAC[DIVIDES_MOD; LE_1] THEN | |
| REWRITE_TAC[ARITH_RULE `n = 0 <=> ~(0 < n)`] THEN | |
| FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| EXISTS_TAC `(a EXP (r MOD m)) MOD d` THEN | |
| ASM_SIMP_TAC[CONG_RMOD; LE_1; CONG_REFL] THEN | |
| UNDISCH_TAC `!x. x IN h ==> (?y. y IN h /\ (x * y == 1) (mod d))` THEN | |
| DISCH_THEN(MP_TAC o SPEC `(a EXP (m * r DIV m)) MOD d`) THEN ANTS_TAC THENL | |
| [REWRITE_TAC[GSYM EXP_EXP] THEN | |
| SUBGOAL_THEN | |
| `(a EXP m) EXP (r DIV m) MOD d = (am EXP (r DIV m)) MOD d` | |
| (fun th -> ASM_SIMP_TAC[th]) THEN | |
| ASM_SIMP_TAC[GSYM CONG; LE_1] THEN | |
| ASM_SIMP_TAC[CONG_LMOD; CONG_EXP; LE_1]; | |
| ALL_TAC] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `y:num` STRIP_ASSUME_TAC) THEN | |
| UNDISCH_TAC `(a EXP r == x) (mod d)` THEN | |
| MP_TAC(SPECL [`r:num`; `m:num`] DIVISION) THEN ASM_SIMP_TAC[LE_1] THEN | |
| DISCH_THEN(fun th -> | |
| GEN_REWRITE_TAC (LAND_CONV o ONCE_DEPTH_CONV) [th]) THEN | |
| ONCE_REWRITE_TAC[MULT_SYM] THEN REWRITE_TAC[EXP_ADD] THEN | |
| DISCH_THEN(MP_TAC o SPEC `y:num` o MATCH_MP | |
| (NUMBER_RULE `!a. (x:num == y) (mod n) ==> (a * x == a * y) (mod n)`)) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (NUMBER_RULE | |
| `(y * e * a == z) (mod n) | |
| ==> (e * y == 1) (mod n) ==> (a == z) (mod n)`)) THEN | |
| ANTS_TAC THENL | |
| [MATCH_MP_TAC CONG_TRANS THEN | |
| EXISTS_TAC `a EXP (m * r DIV m) MOD d * y` THEN | |
| ASM_SIMP_TAC[CONG_MULT; CONG_REFL; CONG_RMOD; LE_1]; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[CONG; LE_1]; | |
| ALL_TAC] THEN | |
| MP_TAC(SPECL [`(f:num->complex) am`; `m:num`] | |
| EXISTS_COMPLEX_ROOT_NONTRIVIAL) THEN ASM_SIMP_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `z:complex` STRIP_ASSUME_TAC) THEN | |
| SUBGOAL_THEN | |
| `?g. !x k. x IN h ==> g((x * a EXP k) MOD d) = f(x) * z pow k` | |
| MP_TAC THENL | |
| [REWRITE_TAC[MESON[] `(?g. !x a. p x ==> g(f a x) = h a x) <=> | |
| (?g. !y x a. p x /\ f a x = y ==> g y = h a x)`] THEN | |
| REWRITE_TAC[GSYM SKOLEM_THM] THEN | |
| REWRITE_TAC[MESON[] | |
| `(!y. ?z. !x k. p x /\ f x k = y ==> z = g x k) <=> | |
| (!x k x' k'. p x /\ p x' /\ f x k = f x' k' ==> g x k = g x' k')`] THEN | |
| ONCE_REWRITE_TAC[MESON[] | |
| `(!x k y j. P x k y j) <=> (!k j x y. P x k y j)`] THEN | |
| MATCH_MP_TAC WLOG_LE THEN CONJ_TAC THENL [MESON_TAC[]; ALL_TAC] THEN | |
| MAP_EVERY X_GEN_TAC [`k:num`; `j:num`] THEN DISCH_TAC THEN | |
| MAP_EVERY X_GEN_TAC [`x:num`; `y:num`] THEN | |
| ASM_SIMP_TAC[GSYM CONG; LE_1] THEN STRIP_TAC THEN | |
| UNDISCH_TAC `k:num <= j` THEN REWRITE_TAC[LE_EXISTS] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `i:num` SUBST_ALL_TAC) THEN | |
| ONCE_REWRITE_TAC[ADD_SYM] THEN | |
| REWRITE_TAC[COMPLEX_POW_ADD; COMPLEX_MUL_ASSOC] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| SUBGOAL_THEN `m divides i` MP_TAC THENL | |
| [FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| UNDISCH_TAC `!x. x IN h ==> (?y. y IN h /\ (x * y == 1) (mod d))` THEN | |
| DISCH_THEN(MP_TAC o SPEC `y:num`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `z:num` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `(z * x) MOD d` THEN ASM_SIMP_TAC[CONG_RMOD; LE_1] THEN | |
| MATCH_MP_TAC CONG_MULT_LCANCEL THEN EXISTS_TAC `y * a EXP k` THEN | |
| REWRITE_TAC[COPRIME_LMUL] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[COPRIME_EXP; COPRIME_SYM]; ALL_TAC] THEN | |
| UNDISCH_TAC `(x * a EXP k == y * a EXP (k + i)) (mod d)` THEN | |
| REWRITE_TAC[EXP_ADD] THEN UNDISCH_TAC `(y * z == 1) (mod d)` THEN | |
| CONV_TAC NUMBER_RULE; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[divides] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `r:num` SUBST_ALL_TAC) THEN | |
| ASM_REWRITE_TAC[GSYM COMPLEX_POW_POW] THEN MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `f((y * (am EXP r) MOD d) MOD d):complex` THEN CONJ_TAC THENL | |
| [AP_TERM_TAC THEN CONV_TAC SYM_CONV THEN ASM_SIMP_TAC[CONG_MOD_LT] THEN | |
| MATCH_MP_TAC CONG_TRANS THEN | |
| EXISTS_TAC `y * (a EXP m) EXP r` THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC CONG_MULT THEN | |
| ASM_SIMP_TAC[CONG_MULT; CONG_LMOD; CONG_REFL; LE_1] THEN | |
| MATCH_MP_TAC CONG_EXP THEN ASM_MESON_TAC[CONG_SYM]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC CONG_MULT_LCANCEL THEN EXISTS_TAC `a EXP k` THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[COPRIME_EXP; COPRIME_SYM]; ALL_TAC] THEN | |
| UNDISCH_TAC `(x * a EXP k == y * a EXP (k + m * r)) (mod d)` THEN | |
| REWRITE_TAC[EXP_ADD; EXP_EXP] THEN CONV_TAC NUMBER_RULE; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[] THEN AP_TERM_TAC THEN | |
| SPEC_TAC(`r:num`,`s:num`) THEN INDUCT_TAC THEN | |
| ASM_SIMP_TAC[EXP; MOD_LT; complex_pow; COMPLEX_MUL_RID] THENL | |
| [UNDISCH_TAC | |
| `!x y. x IN h /\ y IN h ==> f ((x * y) MOD d):complex = f x * f y` THEN | |
| DISCH_THEN(MP_TAC o SPECL [`1`; `1`]) THEN | |
| ASM_SIMP_TAC[MULT_CLAUSES; MOD_LT] THEN | |
| UNDISCH_TAC `!x:num. x IN h ==> ~(f x = Cx (&0))` THEN | |
| DISCH_THEN(MP_TAC o SPEC `1`) THEN ASM_REWRITE_TAC[] THEN | |
| CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `f((am * (am EXP s) MOD d) MOD d):complex` THEN CONJ_TAC THENL | |
| [ALL_TAC; ASM_SIMP_TAC[]] THEN | |
| AP_TERM_TAC THEN ASM_SIMP_TAC[MOD_MULT_RMOD; ASSUME `1 <= d`; LE_1]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `g:num->complex` THEN | |
| DISCH_THEN (LABEL_TAC "*") THEN | |
| EXISTS_TAC `{(x * a EXP k) MOD d | x IN h /\ k IN (:num)}` THEN | |
| REWRITE_TAC[] THEN REPEAT CONJ_TAC THENL | |
| [REWRITE_TAC[SUBSET; IN_ELIM_THM; IN_INSERT; IN_UNIV] THEN | |
| X_GEN_TAC `x:num` THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THENL | |
| [MAP_EVERY EXISTS_TAC [`1`; `1`]; | |
| MAP_EVERY EXISTS_TAC [`x:num`; `0`]] THEN | |
| ASM_SIMP_TAC[EXP_1; MULT_CLAUSES; EXP; MOD_LT]; | |
| REWRITE_TAC[IN_ELIM_THM; LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`y:num`; `x:num`; `k:num`] THEN | |
| STRIP_TAC THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN | |
| ASM_SIMP_TAC[DIVISION; LE_1; COPRIME_LMOD; COPRIME_LMUL] THEN | |
| ASM_MESON_TAC[COPRIME_EXP; COPRIME_SYM]; | |
| X_GEN_TAC `x:num` THEN DISCH_TAC THEN | |
| REMOVE_THEN "*" (MP_TAC o SPECL [`x:num`; `0`]) THEN | |
| ASM_SIMP_TAC[MOD_LT; EXP; MULT_CLAUSES; complex_pow; COMPLEX_MUL_RID]; | |
| REMOVE_THEN "*" (MP_TAC o SPECL [`1`; `1`]) THEN | |
| ASM_SIMP_TAC[EXP_1; MULT_CLAUSES; MOD_LT; COMPLEX_POW_1] THEN | |
| UNDISCH_TAC `!x y. x IN h /\ y IN h ==> f ((x * y) MOD d) = f x * f y` THEN | |
| DISCH_THEN(MP_TAC o SPECL [`1`; `1`]) THEN | |
| ASM_SIMP_TAC[MULT_CLAUSES; MOD_LT] THEN | |
| UNDISCH_TAC `~(z = Cx(&1))` THEN CONV_TAC COMPLEX_RING; | |
| REWRITE_TAC[IN_ELIM_THM; IN_UNIV] THEN | |
| MAP_EVERY EXISTS_TAC [`1`; `0`] THEN | |
| ASM_SIMP_TAC[EXP; MULT_CLAUSES; MOD_LT]; | |
| REWRITE_TAC[IN_ELIM_THM; IN_UNIV; LEFT_AND_EXISTS_THM] THEN | |
| REWRITE_TAC[RIGHT_AND_EXISTS_THM; LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC | |
| [`r:num`; `s:num`; `x:num`; `k:num`; `y:num`; `j:num`] THEN | |
| STRIP_TAC THEN REPEAT(FIRST_X_ASSUM SUBST_ALL_TAC) THEN | |
| MAP_EVERY EXISTS_TAC [`(x * y) MOD d`; `j + k:num`] THEN | |
| ASM_SIMP_TAC[MOD_MULT_LMOD; MOD_MULT_RMOD; LE_1] THEN | |
| REWRITE_TAC[EXP_ADD; MULT_AC]; | |
| REWRITE_TAC[IN_ELIM_THM; IN_UNIV; LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`y:num`; `x:num`; `k:num`] THEN | |
| STRIP_TAC THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN | |
| UNDISCH_TAC `!x. x IN h ==> (?y. y IN h /\ (x * y == 1) (mod d))` THEN | |
| DISCH_THEN(MP_TAC o SPEC `x:num`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `z:num` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `(z * a EXP ((phi d - 1) * k)) MOD d` THEN | |
| REWRITE_TAC[LEFT_EXISTS_AND_THM] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN | |
| MATCH_MP_TAC CONG_TRANS THEN | |
| EXISTS_TAC `(x * a EXP k) * (z * a EXP ((phi d - 1) * k))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC CONG_MULT THEN ASM_SIMP_TAC[CONG_MOD; LE_1]; ALL_TAC] THEN | |
| ONCE_REWRITE_TAC[ARITH_RULE | |
| `(x * a) * (z * ak):num = (x * z) * (a * ak)`] THEN | |
| GEN_REWRITE_TAC (LAND_CONV) [ARITH_RULE `1 = 1 * 1`] THEN | |
| MATCH_MP_TAC CONG_MULT THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[GSYM EXP_ADD] THEN | |
| SUBGOAL_THEN `k + (phi d - 1) * k = phi(d) * k` SUBST1_TAC THENL | |
| [REWRITE_TAC[ARITH_RULE `k + a * k = (a + 1) * k`] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| ASM_SIMP_TAC[SUB_ADD; PHI_LOWERBOUND_1_STRONG]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[GSYM EXP_EXP] THEN SUBST1_TAC(SYM(SPEC `k:num` EXP_ONE)) THEN | |
| MATCH_MP_TAC CONG_EXP THEN ASM_SIMP_TAC[FERMAT_LITTLE]; | |
| REWRITE_TAC[IN_ELIM_THM; IN_UNIV] THEN REPEAT GEN_TAC THEN STRIP_TAC THEN | |
| ASM_SIMP_TAC[COMPLEX_ENTIRE; COMPLEX_POW_EQ_0] THEN | |
| UNDISCH_TAC `!x:num. x IN h ==> ~(f x = Cx (&0))` THEN | |
| DISCH_THEN(MP_TAC o SPEC `am:num`) THEN ASM_REWRITE_TAC[] THEN | |
| SUBST1_TAC(SYM(ASSUME `z pow m = f(am:num)`)) THEN | |
| REWRITE_TAC[COMPLEX_POW_EQ_0] THEN ASM_SIMP_TAC[LE_1]; | |
| REWRITE_TAC[IN_ELIM_THM; IN_UNIV; LEFT_AND_EXISTS_THM] THEN | |
| REWRITE_TAC[RIGHT_AND_EXISTS_THM; LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC | |
| [`r:num`; `s:num`; `x:num`; `k:num`; `y:num`; `j:num`] THEN | |
| STRIP_TAC THEN REPEAT(FIRST_X_ASSUM SUBST_ALL_TAC) THEN | |
| MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `g(((x * y) MOD d * a EXP (k + j)) MOD d):complex` THEN | |
| CONJ_TAC THENL | |
| [AP_TERM_TAC THEN ASM_SIMP_TAC[MOD_MULT_LMOD; MOD_MULT_RMOD; LE_1] THEN | |
| REWRITE_TAC[EXP_ADD; MULT_AC]; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[] THEN REWRITE_TAC[COMPLEX_POW_ADD; COMPLEX_MUL_AC]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Hence the key result that we can find a distinguishing character. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let DIRICHLET_CHARACTER_DISCRIMINATOR = prove | |
| (`!d n. 1 < d /\ ~((n == 1) (mod d)) | |
| ==> ?c. dirichlet_character d c /\ ~(c n = Cx(&1))`, | |
| REPEAT STRIP_TAC THEN FIRST_ASSUM(ASSUME_TAC o MATCH_MP LT_IMP_LE) THEN | |
| ASM_CASES_TAC `coprime(n,d)` THENL | |
| [ALL_TAC; | |
| EXISTS_TAC `chi_0 d` THEN | |
| ASM_REWRITE_TAC[DIRICHLET_CHARACTER_CHI_0; chi_0] THEN | |
| CONV_TAC COMPLEX_RING] THEN | |
| MP_TAC(ISPECL [`\n:num. Cx(&1)`; `{1}`; `n MOD d`; `d:num`] | |
| CHARACTER_EXTEND_FROM_SUBGROUP) THEN | |
| ASM_SIMP_TAC[IN_SING; IN_ELIM_THM; IN_DIFF] THEN ANTS_TAC THENL | |
| [ASM_SIMP_TAC[SUBSET; MULT_CLAUSES; MOD_LT; LE_1; IN_SING; | |
| IN_ELIM_THM; DIVISION; COPRIME_LMOD; CONG_MOD_LT; | |
| COMPLEX_MUL_LID; CX_INJ; REAL_OF_NUM_EQ; ARITH] THEN | |
| ASM_MESON_TAC[COPRIME_1; COPRIME_SYM; CONG_REFL]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`f0:num->complex`; `h0:num->bool`] THEN | |
| STRIP_TAC THEN | |
| SUBGOAL_THEN | |
| `!m. m <= CARD {x | x < d /\ coprime(x,d)} | |
| ==> ?f h. h SUBSET {x | x < d /\ coprime(x,d)} /\ | |
| (1 IN h) /\ (n MOD d) IN h /\ | |
| (!x y. x IN h /\ y IN h ==> ((x * y) MOD d) IN h) /\ | |
| (!x. x IN h ==> ?y. y IN h /\ (x * y == 1) (mod d)) /\ | |
| ~(f(n MOD d) = Cx(&1)) /\ | |
| (!x. x IN h ==> ~(f x = Cx(&0))) /\ | |
| (!x y. x IN h /\ y IN h | |
| ==> f((x * y) MOD d) = f(x) * f(y)) /\ | |
| m <= CARD h` | |
| MP_TAC THENL | |
| [MATCH_MP_TAC num_WF THEN X_GEN_TAC `m:num` THEN | |
| DISCH_THEN(LABEL_TAC "*") THEN DISCH_TAC THEN | |
| ASM_CASES_TAC `m = 0` THENL | |
| [MAP_EVERY EXISTS_TAC [`f0:num->complex`; `h0:num->bool`] THEN | |
| ASM_REWRITE_TAC[LE_0] THEN ASM SET_TAC[]; | |
| ALL_TAC] THEN | |
| FIRST_ASSUM(MP_TAC o C MATCH_MP | |
| (MATCH_MP (ARITH_RULE `~(m = 0) ==> m - 1 < m`) (ASSUME `~(m = 0)`))) THEN | |
| ASM_SIMP_TAC[ARITH_RULE `x <= n ==> x - 1 <= n`; LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`f:num->complex`; `h:num->bool`] THEN STRIP_TAC THEN | |
| ASM_CASES_TAC `m <= CARD(h:num->bool)` THENL | |
| [MAP_EVERY EXISTS_TAC [`f:num->complex`; `h:num->bool`] THEN | |
| ASM_REWRITE_TAC[]; | |
| ALL_TAC] THEN | |
| MP_TAC(ASSUME `h SUBSET {x | x < d /\ coprime (x,d)}`) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (SET_RULE | |
| `s SUBSET t ==> ~(s = t) ==> ?a. a IN t /\ ~(a IN s)`)) THEN | |
| ANTS_TAC THENL [ASM_MESON_TAC[]; REWRITE_TAC[IN_ELIM_THM]] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `a:num` STRIP_ASSUME_TAC) THEN | |
| MP_TAC(ISPECL [`f:num->complex`; `h:num->bool`; `a:num`; `d:num`] | |
| CHARACTER_EXTEND_FROM_SUBGROUP) THEN | |
| ASM_REWRITE_TAC[IN_DIFF; IN_ELIM_THM] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `ff:num->complex` THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `hh:num->bool` THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| REPEAT(CONJ_TAC THENL [ASM SET_TAC[]; ALL_TAC]) THEN | |
| MATCH_MP_TAC LE_TRANS THEN EXISTS_TAC `CARD((a:num) INSERT h)` THEN | |
| SUBGOAL_THEN `FINITE(h:num->bool)` ASSUME_TAC THENL | |
| [MATCH_MP_TAC FINITE_SUBSET THEN | |
| EXISTS_TAC `{x | x IN {x | x < d} /\ coprime(x,d)}` THEN | |
| SIMP_TAC[FINITE_RESTRICT; FINITE_NUMSEG_LT] THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM]; | |
| ALL_TAC] THEN | |
| CONJ_TAC THENL | |
| [ASM_SIMP_TAC[CARD_CLAUSES] THEN | |
| UNDISCH_TAC `m - 1 <= CARD(h:num->bool)` THEN ARITH_TAC; | |
| MATCH_MP_TAC CARD_SUBSET THEN ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC FINITE_SUBSET THEN | |
| EXISTS_TAC `{x | x IN {x | x < d} /\ coprime(x,d)}` THEN | |
| SIMP_TAC[FINITE_RESTRICT; FINITE_NUMSEG_LT] THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM]]; | |
| ALL_TAC] THEN | |
| DISCH_THEN(MP_TAC o SPEC `CARD {x | x < d /\ coprime(x,d)}`) THEN | |
| REWRITE_TAC[LE_REFL] THEN REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`f:num->complex`; `h:num->bool`] THEN | |
| ASM_CASES_TAC `h = {x | x < d /\ coprime (x,d)}` THENL | |
| [ALL_TAC; | |
| DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN | |
| REWRITE_TAC[CONJ_ASSOC] THEN MATCH_MP_TAC(TAUT `~b ==> a /\ b ==> c`) THEN | |
| REWRITE_TAC[NOT_LE] THEN MATCH_MP_TAC CARD_PSUBSET THEN | |
| ASM_REWRITE_TAC[PSUBSET] THEN | |
| MATCH_MP_TAC FINITE_SUBSET THEN EXISTS_TAC `{x:num | x < d}` THEN | |
| SIMP_TAC[FINITE_RESTRICT; FINITE_NUMSEG_LT] THEN SET_TAC[]] THEN | |
| FIRST_X_ASSUM SUBST_ALL_TAC THEN | |
| REWRITE_TAC[SUBSET; IN_ELIM_THM] THEN REWRITE_TAC[GSYM CONJ_ASSOC] THEN | |
| STRIP_TAC THEN | |
| EXISTS_TAC `\n. if coprime(n,d) then f(n MOD d) else Cx(&0)` THEN | |
| ASM_REWRITE_TAC[] THEN REWRITE_TAC[dirichlet_character] THEN | |
| REPEAT CONJ_TAC THEN X_GEN_TAC `x:num` THENL | |
| [REWRITE_TAC[NUMBER_RULE `coprime(x + d:num,d) <=> coprime(x,d)`] THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN AP_TERM_TAC THEN | |
| ASM_SIMP_TAC[GSYM CONG; LE_1] THEN CONV_TAC NUMBER_RULE; | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN | |
| FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| ASM_SIMP_TAC[COPRIME_LMOD; DIVISION; LE_1]; | |
| X_GEN_TAC `y:num` THEN REWRITE_TAC[COPRIME_LMUL] THEN | |
| MAP_EVERY ASM_CASES_TAC [`coprime(x,d)`; `coprime(y,d)`] THEN | |
| ASM_REWRITE_TAC[COMPLEX_MUL_LZERO; COMPLEX_MUL_RZERO] THEN | |
| MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `f(((x MOD d) * (y MOD d)) MOD d):complex` THEN CONJ_TAC THENL | |
| [AP_TERM_TAC THEN ASM_SIMP_TAC[MOD_MULT_MOD2; LE_1]; | |
| FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| ASM_SIMP_TAC[DIVISION; COPRIME_LMOD; LE_1]]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Hence we get the full second orthogonality relation. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_INEXPLICIT = prove | |
| (`!d n. vsum {c | dirichlet_character d c} (\c. c n) = | |
| if (n == 1) (mod d) | |
| then Cx(&(CARD {c | dirichlet_character d c})) | |
| else Cx(&0)`, | |
| REPEAT GEN_TAC THEN | |
| ASM_CASES_TAC `d = 0` THENL | |
| [ASM_REWRITE_TAC[CONG_MOD_0; DIRICHLET_CHARACTER_0; SET_RULE | |
| `{x | x = a} = {a}`] THEN | |
| SIMP_TAC[VSUM_CLAUSES; CARD_CLAUSES; FINITE_RULES; NOT_IN_EMPTY] THEN | |
| REWRITE_TAC[chi_0; COPRIME_0; VECTOR_ADD_RID] THEN REWRITE_TAC[ARITH]; | |
| ALL_TAC] THEN | |
| ASM_CASES_TAC `d = 1` THENL | |
| [ASM_REWRITE_TAC[CONG_MOD_1; DIRICHLET_CHARACTER_1] THEN | |
| REWRITE_TAC[GSYM FUN_EQ_THM; ETA_AX] THEN | |
| ASM_REWRITE_TAC[SET_RULE `{x | x = a} = {a}`] THEN | |
| SIMP_TAC[VSUM_CLAUSES; CARD_CLAUSES; FINITE_RULES; NOT_IN_EMPTY] THEN | |
| REWRITE_TAC[VECTOR_ADD_RID; ARITH]; | |
| ALL_TAC] THEN | |
| COND_CASES_TAC THENL | |
| [MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `vsum {c | dirichlet_character d c} (\c. Cx(&1))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC VSUM_EQ THEN REWRITE_TAC[IN_ELIM_THM] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1; DIRICHLET_CHARACTER_CONG]; | |
| SIMP_TAC[FINITE_DIRICHLET_CHARACTERS; VSUM_CONST] THEN | |
| REWRITE_TAC[COMPLEX_CMUL; COMPLEX_MUL_RID]]; | |
| MP_TAC(SPECL [`d:num`; `n:num`] | |
| DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_WEAK) THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_DISCRIMINATOR; | |
| ARITH_RULE `~(d = 0) /\ ~(d = 1) ==> 1 < d`]]);; | |
| let DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS = prove | |
| (`!d n. 1 <= d | |
| ==> vsum {c | dirichlet_character d c} (\c. c(n)) = | |
| if (n == 1) (mod d) then Cx(&(phi d)) else Cx(&0)`, | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_INEXPLICIT] THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN | |
| MP_TAC(ISPECL [`\c n. (c:num->complex) n`; `{c | dirichlet_character d c}`; | |
| `1..d`;] VSUM_SWAP) THEN | |
| SIMP_TAC[DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_INEXPLICIT; | |
| DIRICHLET_CHARACTER_SUM_OVER_NUMBERS; FINITE_NUMSEG; | |
| FINITE_DIRICHLET_CHARACTERS; ETA_AX] THEN | |
| REWRITE_TAC[VSUM_DELTA; GSYM COMPLEX_VEC_0] THEN | |
| REWRITE_TAC[IN_ELIM_THM; DIRICHLET_CHARACTER_CHI_0] THEN | |
| DISCH_THEN SUBST1_TAC THEN | |
| SIMP_TAC[GSYM VSUM_RESTRICT_SET; FINITE_NUMSEG] THEN | |
| SUBGOAL_THEN `{j | j IN 1..d /\ (j == 1) (mod d)} = {1}` | |
| (fun th -> SIMP_TAC[th; VSUM_SING]) THEN | |
| REWRITE_TAC[EXTENSION; IN_SING; IN_ELIM_THM; IN_NUMSEG] THEN | |
| X_GEN_TAC `k:num` THEN EQ_TAC THEN ASM_SIMP_TAC[LE_REFL; CONG_REFL] THEN | |
| ASM_CASES_TAC `d = 1` THEN ASM_SIMP_TAC[CONG_MOD_1; LE_ANTISYM] THEN | |
| ASM_CASES_TAC `k:num = d` THENL | |
| [ASM_REWRITE_TAC[NUMBER_RULE `(d == 1) (mod d) <=> d divides 1`] THEN | |
| ASM_REWRITE_TAC[DIVIDES_ONE]; | |
| STRIP_TAC THEN MATCH_MP_TAC CONG_IMP_EQ THEN EXISTS_TAC `d:num` THEN | |
| ASM_REWRITE_TAC[LT_LE]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* L-series, just at the point s = 1. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let Lfunction_DEF = new_definition | |
| `Lfunction c = infsum (from 1) (\n. c(n) / Cx(&n))`;; | |
| let BOUNDED_LFUNCTION_PARTIAL_SUMS = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> bounded {vsum (1..n) c | n IN (:num)}`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(fun th -> | |
| ONCE_REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_SUM_MOD th]) THEN | |
| MATCH_MP_TAC BOUNDED_SUBSET THEN | |
| EXISTS_TAC `IMAGE (\n. vsum(1..n) c:complex) (0..d)` THEN | |
| SIMP_TAC[FINITE_IMP_BOUNDED; FINITE_IMAGE; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[SIMPLE_IMAGE; SUBSET; FORALL_IN_IMAGE] THEN | |
| X_GEN_TAC `n:num` THEN REWRITE_TAC[IN_UNIV; IN_IMAGE] THEN | |
| EXISTS_TAC `n MOD d` THEN REWRITE_TAC[IN_NUMSEG; LE_0] THEN | |
| ASM_MESON_TAC[LT_IMP_LE; DIVISION; | |
| DIRICHLET_CHARACTER_NONPRINCIPAL_NONTRIVIAL]);; | |
| let LFUNCTION = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> ((\n. c(n) / Cx(&n)) sums (Lfunction c)) (from 1)`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN SIMP_TAC[Lfunction_DEF; SUMS_INFSUM] THEN | |
| REWRITE_TAC[complex_div] THEN MATCH_MP_TAC SERIES_DIRICHLET_COMPLEX THEN | |
| REPEAT(EXISTS_TAC `1`) THEN FIRST_ASSUM(fun th -> | |
| REWRITE_TAC[MATCH_MP BOUNDED_LFUNCTION_PARTIAL_SUMS th]) THEN | |
| REWRITE_TAC[LIM_INV_N; GSYM CX_INV; REAL_CX; RE_CX] THEN | |
| SIMP_TAC[REAL_LE_INV2; REAL_OF_NUM_LE; REAL_OF_NUM_LT; LE_1; LE_ADD]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Other properties of conjugate characters. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let CNJ_CHI_0 = prove | |
| (`!d n. cnj(chi_0 d n) = chi_0 d n`, | |
| REPEAT GEN_TAC THEN REWRITE_TAC[chi_0] THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[CNJ_CX]);; | |
| let LFUNCTION_CNJ = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> Lfunction (\n. cnj(c n)) = cnj(Lfunction c)`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[Lfunction_DEF] THEN | |
| MATCH_MP_TAC INFSUM_UNIQUE THEN | |
| ONCE_REWRITE_TAC[GSYM CNJ_CX] THEN | |
| REWRITE_TAC[GSYM CNJ_DIV] THEN | |
| REWRITE_TAC[SUMS_CNJ; CNJ_CX; GSYM Lfunction_DEF] THEN | |
| ASM_MESON_TAC[LFUNCTION]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Explicit bound on truncating the Lseries. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let LFUNCTION_PARTIAL_SUM = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> ?B. &0 < B /\ | |
| !n. 1 <= n | |
| ==> norm(Lfunction c - vsum(1..n) (\n. c(n) / Cx(&n))) | |
| <= B / (&n + &1)`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| MP_TAC(ISPECL [`c:num->complex`; `\n. inv(Cx(&n))`; `1`; `1`] | |
| SERIES_DIRICHLET_COMPLEX_EXPLICIT) THEN | |
| REWRITE_TAC[LE_REFL] THEN FIRST_ASSUM(fun th -> | |
| REWRITE_TAC[MATCH_MP BOUNDED_LFUNCTION_PARTIAL_SUMS th]) THEN | |
| REWRITE_TAC[LIM_INV_N; GSYM CX_INV; REAL_CX; RE_CX] THEN | |
| SIMP_TAC[REAL_LE_INV2; REAL_OF_NUM_LE; REAL_OF_NUM_LT; LE_1; LE_ADD] THEN | |
| REWRITE_TAC[REAL_LE_INV_EQ; REAL_POS] THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; REAL_ABS_INV; REAL_ABS_NUM] THEN | |
| REWRITE_TAC[CX_INV; GSYM complex_div; GSYM real_div] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `B:real` THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[] THEN X_GEN_TAC `k:num` THEN DISCH_TAC THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` LIM_NORM_UBOUND) THEN | |
| EXISTS_TAC `\n. vsum(k+1..n) (\n. c(n) / Cx(&n))` THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN CONJ_TAC THENL | |
| [FIRST_ASSUM(MP_TAC o MATCH_MP LFUNCTION) THEN | |
| MP_TAC(ISPECL [`sequentially`; `vsum (1..k) (\n. c n / Cx (&n))`] | |
| LIM_CONST) THEN | |
| REWRITE_TAC[GSYM IMP_CONJ_ALT; sums; FROM_INTER_NUMSEG] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP LIM_SUB) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM) THEN | |
| REWRITE_TAC[] THEN MATCH_MP_TAC LIM_EVENTUALLY THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `k + 1` THEN | |
| X_GEN_TAC `m:num` THEN DISCH_TAC THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP (ARITH_RULE `k + 1 <= m ==> k <= m`)) THEN | |
| SIMP_TAC[LE_EXISTS; LEFT_IMP_EXISTS_THM] THEN | |
| ASM_SIMP_TAC[VSUM_ADD_SPLIT; ARITH_RULE `1 <= k ==> 1 <= k + 1`] THEN | |
| REPEAT STRIP_TAC THEN VECTOR_ARITH_TAC; | |
| MATCH_MP_TAC ALWAYS_EVENTUALLY THEN | |
| ASM_SIMP_TAC[ARITH_RULE `1 <= k + 1`; REAL_OF_NUM_ADD]]);; | |
| let LFUNCTION_PARTIAL_SUM_STRONG = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> ?B. &0 < B /\ | |
| !n. norm(Lfunction c - vsum(1..n) (\n. c(n) / Cx(&n))) | |
| <= B / (&n + &1)`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP LFUNCTION_PARTIAL_SUM) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `max B (norm(Lfunction c))` THEN | |
| ASM_SIMP_TAC[REAL_LT_MAX] THEN X_GEN_TAC `n:num` THEN | |
| ASM_CASES_TAC `n = 0` THENL | |
| [ASM_REWRITE_TAC[VSUM_CLAUSES_NUMSEG; VECTOR_SUB_RZERO; ARITH] THEN | |
| REAL_ARITH_TAC; | |
| FIRST_X_ASSUM(MP_TAC o SPEC `n:num`) THEN ASM_SIMP_TAC[LE_1] THEN | |
| MATCH_MP_TAC(REAL_ARITH `a <= b ==> x <= a ==> x <= b`) THEN | |
| ASM_SIMP_TAC[REAL_LE_DIV2_EQ; REAL_ARITH `&0 < &n + &1`] THEN | |
| REAL_ARITH_TAC]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* First key bound, when the Lfunction is not zero (as indeed it isn't). *) | |
| (* ------------------------------------------------------------------------- *) | |
| let BOUNDED_LFUNCTION_DIRICHLET_MANGOLDT_LEMMA = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> bounded | |
| { Lfunction(c) * | |
| vsum(1..x) (\n. c(n) * Cx(mangoldt n / &n)) - | |
| vsum(1..x) (\n. c(n) * Cx(log(&n) / &n)) | x IN (:num)}`, | |
| REWRITE_TAC[BOUNDED_POS; SIMPLE_IMAGE; FORALL_IN_IMAGE; IN_UNIV] THEN | |
| REPEAT STRIP_TAC THEN | |
| SIMP_TAC[LOG_MANGOLDT_SUM; real_div; CX_MUL; GSYM VSUM_CX; FINITE_DIVISORS; | |
| LE_1; GSYM VSUM_COMPLEX_LMUL; GSYM VSUM_COMPLEX_RMUL] THEN | |
| REWRITE_TAC[VSUM_VSUM_DIVISORS] THEN | |
| FIRST_ASSUM(fun th -> REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_MUL th]) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_MUL; COMPLEX_INV_MUL; CX_MUL; CX_INV] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `(ck * cn) * cm * k * n:complex = (ck * k) * (cn * cm * n)`] THEN | |
| SIMP_TAC[VSUM_COMPLEX_RMUL; FINITE_NUMSEG] THEN | |
| SIMP_TAC[GSYM VSUM_COMPLEX_LMUL; FINITE_NUMSEG] THEN | |
| SIMP_TAC[GSYM VSUM_SUB; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[GSYM COMPLEX_SUB_RDISTRIB] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] LFUNCTION_PARTIAL_SUM_STRONG) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `&18 * B` THEN | |
| ASM_SIMP_TAC[REAL_LT_MUL; REAL_OF_NUM_LT; ARITH] THEN | |
| X_GEN_TAC `x:num` THEN MATCH_MP_TAC VSUM_NORM_TRIANGLE THEN | |
| REWRITE_TAC[FINITE_NUMSEG; COMPLEX_NORM_MUL] THEN | |
| REWRITE_TAC[COMPLEX_NORM_INV; COMPLEX_NORM_CX; REAL_ABS_NUM] THEN | |
| REWRITE_TAC[GSYM real_div] THEN REWRITE_TAC[REAL_MUL_ASSOC] THEN | |
| REWRITE_TAC[real_abs; MANGOLDT_POS_LE] THEN ASM_CASES_TAC `x = 0` THEN | |
| ASM_SIMP_TAC[SUM_CLAUSES_NUMSEG; ARITH; REAL_LE_MUL; REAL_LT_IMP_LE; | |
| REAL_OF_NUM_LT; ARITH] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum(1..x) (\n. B / &x * mangoldt n)` THEN CONJ_TAC THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[SUM_LMUL] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `B / &x * &18 * &x` THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_LE_LMUL THEN | |
| ASM_SIMP_TAC[REAL_LE_DIV; REAL_POS; REAL_LT_IMP_LE] THEN | |
| REWRITE_TAC[REWRITE_RULE[ETA_AX] PSI_BOUND]; | |
| ASM_SIMP_TAC[REAL_FIELD `~(x = &0) ==> B / x * &18 * x = &18 * B`; | |
| REAL_OF_NUM_EQ; REAL_LE_REFL]]] THEN | |
| MATCH_MP_TAC SUM_LE_NUMSEG THEN X_GEN_TAC `n:num` THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| FIRST_ASSUM(fun th -> REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_NORM th]) THEN | |
| COND_CASES_TAC THEN | |
| ASM_SIMP_TAC[REAL_MUL_LZERO; REAL_MUL_RZERO; REAL_MUL_RID; REAL_LE_MUL; | |
| REAL_LE_DIV; REAL_POS; REAL_LT_IMP_LE; MANGOLDT_POS_LE] THEN | |
| REWRITE_TAC[real_div; REAL_ARITH `a * b * c <= d <=> (a * c) * b <= d`] THEN | |
| MATCH_MP_TAC REAL_LE_RMUL THEN REWRITE_TAC[MANGOLDT_POS_LE] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC `B / (&(x DIV n) + &1)` THEN | |
| ASM_REWRITE_TAC[GSYM complex_div] THEN | |
| REWRITE_TAC[real_div; GSYM REAL_MUL_ASSOC] THEN | |
| ASM_SIMP_TAC[REAL_LE_LMUL_EQ] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_INV_INV] THEN | |
| ONCE_REWRITE_TAC[GSYM REAL_INV_MUL] THEN MATCH_MP_TAC REAL_LE_INV2 THEN | |
| SUBGOAL_THEN `1 <= x` ASSUME_TAC THENL [ASM_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LT_DIV; REAL_OF_NUM_LT; LE_1] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| REWRITE_TAC[REAL_OF_NUM_ADD; REAL_OF_NUM_MUL; REAL_OF_NUM_LE] THEN | |
| MP_TAC(SPECL [`x:num`; `n:num`] DIVISION) THEN ASM_ARITH_TAC);; | |
| let SUMMABLE_CHARACTER_LOG_OVER_N = prove | |
| (`!c d. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> summable (from 1) (\n. c(n) * Cx(log(&n) / &n))`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN MATCH_MP_TAC SERIES_DIRICHLET_COMPLEX THEN | |
| MAP_EVERY EXISTS_TAC [`4`; `1`] THEN REWRITE_TAC[REAL_CX] THEN | |
| FIRST_ASSUM(fun th -> | |
| REWRITE_TAC[MATCH_MP BOUNDED_LFUNCTION_PARTIAL_SUMS th]) THEN | |
| CONJ_TAC THENL | |
| [SIMP_TAC[DECREASING_LOG_OVER_N; GSYM REAL_OF_NUM_ADD; RE_CX]; | |
| MP_TAC LIM_LOG_OVER_N THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| ASM_SIMP_TAC[CX_LOG; CX_DIV; LE_1; REAL_OF_NUM_LT]]);; | |
| let BOUNDED_LFUNCTION_DIRICHLET_MANGOLDT = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> bounded | |
| { Lfunction(c) * | |
| vsum(1..x) (\n. c(n) * Cx(mangoldt n / &n)) | x IN (:num)}`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(MP_TAC o | |
| MATCH_MP BOUNDED_LFUNCTION_DIRICHLET_MANGOLDT_LEMMA) THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP SUMMABLE_CHARACTER_LOG_OVER_N) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP SUMMABLE_IMP_SUMS_BOUNDED) THEN | |
| REWRITE_TAC[IMP_IMP] THEN DISCH_THEN(MP_TAC o MATCH_MP BOUNDED_SUMS) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] BOUNDED_SUBSET) THEN | |
| REWRITE_TAC[SIMPLE_IMAGE; SUBSET; FORALL_IN_IMAGE] THEN | |
| REWRITE_TAC[IN_UNIV; IN_ELIM_THM; RIGHT_EXISTS_AND_THM; EXISTS_IN_IMAGE; | |
| GSYM CONJ_ASSOC] THEN | |
| X_GEN_TAC `n:num` THEN REPEAT(EXISTS_TAC `n:num`) THEN VECTOR_ARITH_TAC);; | |
| let BOUNDED_DIRICHLET_MANGOLDT_NONZERO = prove | |
| (`!d c. | |
| dirichlet_character d c /\ ~(c = chi_0 d) /\ ~(Lfunction c = Cx(&0)) | |
| ==> bounded { vsum(1..x) (\n. c n * Cx(mangoldt n / &n)) | x IN (:num)}`, | |
| REPEAT GEN_TAC THEN REWRITE_TAC[CONJ_ASSOC] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP BOUNDED_LFUNCTION_DIRICHLET_MANGOLDT) THEN | |
| REWRITE_TAC[BOUNDED_POS; SIMPLE_IMAGE; FORALL_IN_IMAGE; IN_UNIV] THEN | |
| REWRITE_TAC[COMPLEX_NORM_MUL] THEN ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN | |
| ASM_SIMP_TAC[GSYM REAL_LE_RDIV_EQ; COMPLEX_NORM_NZ] THEN | |
| ASM_MESON_TAC[COMPLEX_NORM_NZ; REAL_LT_DIV]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Now a bound when the Lfunction is zero (hypothetically). *) | |
| (* ------------------------------------------------------------------------- *) | |
| let MANGOLDT_LOG_SUM = prove | |
| (`!n. 1 <= n | |
| ==> mangoldt(n) = --(sum {d | d divides n} (\d. mobius(d) * log(&d)))`, | |
| REPEAT STRIP_TAC THEN | |
| MP_TAC(ISPECL [`\n. mangoldt n`; `\n. log(&n)`] MOBIUS_INVERSION) THEN | |
| ASM_SIMP_TAC[LOG_MANGOLDT_SUM; LE_1] THEN DISCH_THEN(K ALL_TAC) THEN | |
| MATCH_MP_TAC EQ_TRANS THEN | |
| EXISTS_TAC `sum {d | d divides n} (\x. mobius x * (log(&n) - log(&x)))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC SUM_EQ THEN X_GEN_TAC `d:num` THEN | |
| REWRITE_TAC[IN_ELIM_THM; DIVIDES_DIV_MULT] THEN | |
| ABBREV_TAC `q = n DIV d` THEN | |
| MAP_EVERY ASM_CASES_TAC [`q = 0`; `d = 0`] THEN | |
| ASM_SIMP_TAC[MULT_CLAUSES; LE_1] THEN DISCH_THEN(SUBST_ALL_TAC o SYM) THEN | |
| ASM_SIMP_TAC[GSYM REAL_OF_NUM_MUL; LOG_MUL; REAL_OF_NUM_LT; LE_1] THEN | |
| REAL_ARITH_TAC; | |
| ASM_SIMP_TAC[REAL_SUB_LDISTRIB; SUM_SUB; FINITE_DIVISORS; LE_1] THEN | |
| ASM_SIMP_TAC[SUM_RMUL; REWRITE_RULE[ETA_AX] DIVISORSUM_MOBIUS] THEN | |
| MATCH_MP_TAC(REAL_ARITH `a = &0 ==> a - b = --b`) THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[LOG_1] THEN REAL_ARITH_TAC]);; | |
| let BOUNDED_DIRICHLET_MANGOLDT_LEMMA = prove | |
| (`!d c x. | |
| dirichlet_character d c /\ ~(c = chi_0 d) /\ 1 <= x | |
| ==> Cx(log(&x)) + vsum (1..x) (\n. c(n) * Cx(mangoldt n / &n)) = | |
| vsum (1..x) (\n. c(n) / Cx(&n) * | |
| vsum {d | d divides n} | |
| (\d. Cx(mobius(d) * log(&x / &d))))`, | |
| REPEAT STRIP_TAC THEN ASM_SIMP_TAC[MANGOLDT_LOG_SUM] THEN | |
| MATCH_MP_TAC(COMPLEX_RING `c - b = a ==> (a:complex) + b = c`) THEN | |
| SIMP_TAC[GSYM VSUM_SUB; FINITE_NUMSEG] THEN | |
| SIMP_TAC[CX_NEG; CX_DIV; GSYM VSUM_CX; FINITE_NUMSEG; FINITE_DIVISORS; | |
| LE_1] THEN | |
| REWRITE_TAC[SIMPLE_COMPLEX_ARITH | |
| `c / d * x - c * --y / d:complex = c / d * (x + y)`] THEN | |
| SIMP_TAC[GSYM VSUM_ADD; FINITE_DIVISORS; LE_1] THEN | |
| MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC | |
| `vsum (1..x) | |
| (\n. c n / Cx(&n) * vsum {d | d divides n} | |
| (\d. Cx(mobius d * log(&x))))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC VSUM_EQ_NUMSEG THEN X_GEN_TAC `n:num` THEN STRIP_TAC THEN | |
| REWRITE_TAC[] THEN AP_TERM_TAC THEN MATCH_MP_TAC VSUM_EQ THEN | |
| X_GEN_TAC `m:num` THEN REWRITE_TAC[IN_ELIM_THM] THEN DISCH_TAC THEN | |
| REWRITE_TAC[CX_MUL; GSYM COMPLEX_ADD_LDISTRIB] THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[GSYM CX_ADD; CX_INJ] THEN | |
| ASM_CASES_TAC `m = 0` THENL | |
| [ASM_MESON_TAC[DIVIDES_ZERO; LE_1]; ALL_TAC] THEN | |
| ASM_SIMP_TAC[LOG_DIV; REAL_OF_NUM_LT; LE_1] THEN REAL_ARITH_TAC; | |
| SIMP_TAC[FINITE_DIVISORS; CX_MUL; SUM_RMUL; LE_1; VSUM_CX] THEN | |
| SIMP_TAC[REWRITE_RULE[ETA_AX] DIVISORSUM_MOBIUS] THEN | |
| SIMP_TAC[COND_RAND; COND_RATOR; COMPLEX_MUL_LZERO; COMPLEX_MUL_RZERO] THEN | |
| ASM_SIMP_TAC[VSUM_DELTA; GSYM COMPLEX_VEC_0; IN_NUMSEG; LE_REFL] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] DIRICHLET_CHARACTER_EQ_1) THEN | |
| ASM_SIMP_TAC[COMPLEX_MUL_LID; COMPLEX_DIV_1]]);; | |
| let SUM_LOG_OVER_X_BOUND = prove | |
| (`!x. abs(sum(1..x) (\n. log(&x / &n) / &x)) <= &4`, | |
| X_GEN_TAC `x:num` THEN ASM_CASES_TAC `x = 0` THENL | |
| [ASM_SIMP_TAC[SUM_CLAUSES_NUMSEG; ARITH_EQ; REAL_ABS_NUM; REAL_POS]; | |
| ALL_TAC] THEN | |
| SIMP_TAC[real_div; SUM_RMUL; REAL_ABS_MUL; REAL_ABS_INV; REAL_ABS_NUM] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum (1..x) (\n. abs(log(&x / &n)))` THEN | |
| REWRITE_TAC[SUM_ABS_NUMSEG] THEN | |
| ASM_SIMP_TAC[real_abs; LOG_POS; REAL_LE_RDIV_EQ; REAL_OF_NUM_LT; | |
| LE_1; REAL_MUL_LID; REAL_OF_NUM_LE; LOG_DIV] THEN | |
| REWRITE_TAC[SUM_SUB_NUMSEG; GSYM LOG_FACT] THEN | |
| REWRITE_TAC[SUM_CONST_NUMSEG; ADD_SUB] THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP LOG_FACT_BOUNDS) THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `&2 * l + abs(x) + &1 <= b | |
| ==> abs(lf - (xl - x + &1)) <= &2 * l | |
| ==> xl - lf <= b`) THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `&1 <= x /\ l <= x ==> &2 * l + abs(x) + &1 <= &4 * x`) THEN | |
| ASM_SIMP_TAC[REAL_OF_NUM_LE; LE_1; LOG_LE_REFL]);; | |
| let BOUNDED_DIRICHLET_MANGOLDT_ZERO = prove | |
| (`!d c. | |
| dirichlet_character d c /\ ~(c = chi_0 d) /\ Lfunction c = Cx(&0) | |
| ==> bounded { vsum(1..x) (\n. c n * Cx(mangoldt n / &n)) + | |
| Cx(log(&x)) | x IN (:num)}`, | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN REPEAT STRIP_TAC THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] LFUNCTION_PARTIAL_SUM_STRONG) THEN | |
| ASM_REWRITE_TAC[COMPLEX_SUB_LZERO; NORM_NEG] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| SIMP_TAC[SET_RULE `{f x | x IN (:num)} = f 0 INSERT {f x | ~(x = 0)}`] THEN | |
| REWRITE_TAC[BOUNDED_INSERT; ARITH_RULE `~(n = 0) <=> 1 <= n`] THEN | |
| ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN | |
| REWRITE_TAC[BOUNDED_POS; FORALL_IN_IMAGE; IN_ELIM_THM] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] | |
| BOUNDED_DIRICHLET_MANGOLDT_LEMMA) THEN | |
| ASM_SIMP_TAC[] THEN DISCH_THEN(K ALL_TAC) THEN | |
| SIMP_TAC[GSYM VSUM_COMPLEX_LMUL; FINITE_DIVISORS; LE_1] THEN | |
| REWRITE_TAC[VSUM_VSUM_DIVISORS] THEN | |
| FIRST_ASSUM(fun th -> REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_MUL th]) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_MUL; CX_MUL; complex_div; COMPLEX_INV_MUL] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `((ck * cn) * k' * n') * m * l = (cn * m * n') * l * (ck * k')`] THEN | |
| REWRITE_TAC[GSYM complex_div] THEN | |
| SIMP_TAC[VSUM_COMPLEX_LMUL; FINITE_NUMSEG] THEN | |
| EXISTS_TAC `&4 * B` THEN | |
| ASM_SIMP_TAC[REAL_LT_MUL; REAL_OF_NUM_LT; ARITH] THEN | |
| X_GEN_TAC `x:num` THEN DISCH_TAC THEN MATCH_MP_TAC VSUM_NORM_TRIANGLE THEN | |
| REWRITE_TAC[FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC | |
| `sum(1..x) (\n. inv(&n) * log(&x / &n) * B / (&(x DIV n) + &1))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC SUM_LE_NUMSEG THEN X_GEN_TAC `n:num` THEN | |
| STRIP_TAC THEN REWRITE_TAC[] THEN ONCE_REWRITE_TAC[COMPLEX_NORM_MUL] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN REWRITE_TAC[NORM_POS_LE] THEN CONJ_TAC THENL | |
| [REWRITE_TAC[COMPLEX_NORM_MUL; COMPLEX_NORM_DIV; COMPLEX_NORM_CX] THEN | |
| FIRST_ASSUM(fun t -> SIMP_TAC[MATCH_MP DIRICHLET_CHARACTER_NORM t]) THEN | |
| COND_CASES_TAC THEN | |
| REWRITE_TAC[REAL_MUL_LZERO; REAL_LE_INV_EQ; REAL_POS] THEN | |
| REWRITE_TAC[REAL_MUL_LID; REAL_ABS_NUM] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| ASM_SIMP_TAC[REAL_FIELD `&1 <= n ==> inv(n) * n = &1`; REAL_OF_NUM_LE; | |
| REAL_ABS_MOBIUS]; | |
| SIMP_TAC[CX_LOG; REAL_LT_DIV; REAL_OF_NUM_LT; LE_1] THEN | |
| SIMP_TAC[COMPLEX_NORM_CX; COMPLEX_NORM_MUL] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN SIMP_TAC[REAL_ABS_POS; NORM_POS_LE] THEN | |
| ASM_REWRITE_TAC[] THEN SIMP_TAC[REAL_ARITH `abs x <= x <=> &0 <= x`] THEN | |
| ASM_SIMP_TAC[LOG_POS; REAL_LE_RDIV_EQ; REAL_OF_NUM_LT; LE_1; | |
| REAL_MUL_LID; REAL_OF_NUM_LE]]; | |
| ALL_TAC] THEN | |
| SIMP_TAC[real_div; REAL_RING `a * l * B * i:real = ((l * i) * a) * B`] THEN | |
| REWRITE_TAC[SUM_RMUL] THEN ASM_SIMP_TAC[REAL_LE_RMUL_EQ] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum(1..x) (\n. log(&x / &n) / &x)` THEN | |
| ASM_SIMP_TAC[REAL_ARITH `abs x <= a ==> x <= a`; SUM_LOG_OVER_X_BOUND] THEN | |
| MATCH_MP_TAC SUM_LE_NUMSEG THEN X_GEN_TAC `n:num` THEN STRIP_TAC THEN | |
| REWRITE_TAC[real_div; GSYM REAL_MUL_ASSOC] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN | |
| ASM_SIMP_TAC[GSYM real_div; LOG_POS; REAL_LE_RDIV_EQ; REAL_OF_NUM_LT; | |
| LE_1; REAL_MUL_LID; REAL_OF_NUM_LE] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_INV_INV] THEN | |
| REWRITE_TAC[GSYM REAL_INV_MUL] THEN MATCH_MP_TAC REAL_LE_INV2 THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LT_DIV; REAL_OF_NUM_LT; LE_1] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| REWRITE_TAC[REAL_OF_NUM_ADD; REAL_OF_NUM_MUL; REAL_OF_NUM_LE] THEN | |
| MP_TAC(SPECL [`x:num`; `n:num`] DIVISION) THEN ASM_ARITH_TAC);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Now the analogous result for the principal character. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let BOUNDED_DIRICHLET_MANGOLDT_PRINCIPAL_LEMMA = prove | |
| (`!d. 1 <= d | |
| ==> norm(vsum(1..x) (\n. (chi_0 d n - Cx(&1)) * Cx(mangoldt n / &n))) | |
| <= sum {p | prime p /\ p divides d} (\p. log(&p))`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum {p | prime p /\ p divides d} | |
| (\p. sum {k | 1 <= k /\ p EXP k <= x} | |
| (\k. log(&p) / &p pow k))` THEN | |
| CONJ_TAC THENL | |
| [ALL_TAC; | |
| MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC[FINITE_SPECIAL_DIVISORS; LE_1] THEN | |
| X_GEN_TAC `p:num` THEN REWRITE_TAC[IN_ELIM_THM] THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `2 <= p /\ 1 <= p /\ 1 < p` ASSUME_TAC THENL | |
| [ASM_MESON_TAC[PRIME_GE_2; ARITH_RULE `2 <= p ==> 1 < p /\ 1 <= p`]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum(1..x) (\k. log(&p) / &p pow k)` THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC SUM_SUBSET_SIMPLE THEN REWRITE_TAC[FINITE_NUMSEG] THEN | |
| ASM_SIMP_TAC[IN_DIFF; IN_NUMSEG; IN_ELIM_THM; SUBSET; REAL_POW_LE; | |
| REAL_POS; REAL_LE_DIV; LOG_POS; REAL_OF_NUM_LE; | |
| PRIME_GE_2; ARITH_RULE `2 <= p ==> 1 <= p`] THEN | |
| X_GEN_TAC `k:num` THEN STRIP_TAC THEN | |
| MATCH_MP_TAC LE_TRANS THEN EXISTS_TAC `p EXP k` THEN | |
| ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC LE_TRANS THEN EXISTS_TAC `2 EXP k` THEN | |
| ASM_SIMP_TAC[LT_POW2_REFL; LT_IMP_LE; EXP_MONO_LE]; | |
| REWRITE_TAC[real_div; SUM_LMUL] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_MUL_RID] THEN | |
| ASM_SIMP_TAC[REAL_LE_LMUL_EQ; LOG_POS_LT; REAL_OF_NUM_LT] THEN | |
| SIMP_TAC[GSYM REAL_POW_INV; SUM_GP; REAL_INV_EQ_1; REAL_OF_NUM_EQ] THEN | |
| COND_CASES_TAC THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| COND_CASES_TAC THENL [ASM_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_SUB_LT; REAL_LT_LDIV_EQ; | |
| REAL_MUL_LID; REAL_OF_NUM_LT; LE_1] THEN | |
| REWRITE_TAC[real_pow] THEN | |
| MATCH_MP_TAC(REAL_ARITH `&0 <= x * y /\ &2 * x <= &1 | |
| ==> x pow 1 - x * y <= &1 - x`) THEN | |
| ASM_SIMP_TAC[REAL_LE_DIV; REAL_POW_LE; REAL_POS; REAL_LE_MUL] THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID] THEN REWRITE_TAC[GSYM real_div] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_MUL_LID; REAL_OF_NUM_LT; | |
| REAL_OF_NUM_LE; LE_1]]] THEN | |
| W(MP_TAC o PART_MATCH (lhs o rand) SUM_SUM_PRODUCT o rand o snd) THEN | |
| ANTS_TAC THENL | |
| [ASM_SIMP_TAC[FINITE_SPECIAL_DIVISORS; LE_1] THEN | |
| X_GEN_TAC `p:num` THEN REWRITE_TAC[IN_ELIM_THM] THEN STRIP_TAC THEN | |
| MATCH_MP_TAC FINITE_SUBSET THEN EXISTS_TAC `1..x` THEN | |
| SIMP_TAC[SUBSET; FINITE_NUMSEG; IN_NUMSEG; IN_ELIM_THM] THEN | |
| X_GEN_TAC `k:num` THEN STRIP_TAC THEN | |
| MATCH_MP_TAC LE_TRANS THEN EXISTS_TAC `p EXP k` THEN | |
| ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC LE_TRANS THEN EXISTS_TAC `2 EXP k` THEN | |
| ASM_SIMP_TAC[LT_POW2_REFL; LT_IMP_LE; EXP_MONO_LE; PRIME_GE_2]; | |
| ALL_TAC] THEN | |
| DISCH_THEN SUBST1_TAC THEN MATCH_MP_TAC VSUM_NORM_TRIANGLE THEN | |
| REWRITE_TAC[FINITE_NUMSEG; COMPLEX_NORM_MUL; COMPLEX_NORM_CX] THEN | |
| REWRITE_TAC[chi_0; COND_RAND; COND_RATOR] THEN | |
| REWRITE_TAC[COMPLEX_SUB_REFL; COMPLEX_SUB_LZERO] THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; NORM_NEG; REAL_ABS_NUM] THEN | |
| REWRITE_TAC[REAL_MUL_LZERO; REAL_MUL_LID] THEN | |
| REWRITE_TAC[mangoldt; COND_RAND] THEN ONCE_REWRITE_TAC[COND_RATOR] THEN | |
| ONCE_REWRITE_TAC[COND_RAND] THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LZERO; REAL_ABS_NUM] THEN | |
| REWRITE_TAC[TAUT `(if a then &0 else if b then x else &0) = | |
| (if ~a /\ b then x else &0)`] THEN | |
| SIMP_TAC[GSYM real_div; GSYM SUM_RESTRICT_SET; FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC REAL_EQ_IMP_LE THEN CONV_TAC SYM_CONV THEN | |
| MATCH_MP_TAC SUM_EQ_GENERAL THEN EXISTS_TAC `\(p,k). p EXP k` THEN | |
| REWRITE_TAC[EXISTS_UNIQUE; EXISTS_PAIR_THM; FORALL_PAIR_THM] THEN | |
| REWRITE_TAC[IN_ELIM_PAIR_THM] THEN | |
| REWRITE_TAC[IN_ELIM_THM; IN_NUMSEG; PAIR_EQ] THEN CONJ_TAC THENL | |
| [X_GEN_TAC `y:num` THEN | |
| REPEAT(DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC)) THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `p:num` THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `k:num` THEN | |
| STRIP_TAC THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN | |
| UNDISCH_TAC `~(coprime(p EXP k,d))` THEN | |
| ASM_SIMP_TAC[ONCE_REWRITE_RULE[COPRIME_SYM] COPRIME_PRIMEPOW; LE_1] THEN | |
| DISCH_TAC THEN MAP_EVERY X_GEN_TAC [`q:num`; `j:num`] THEN | |
| REPEAT(DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC)) THEN | |
| ASM_SIMP_TAC[EQ_PRIME_EXP] THEN ASM_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MAP_EVERY X_GEN_TAC [`p:num`; `k:num`] THEN | |
| ASM_SIMP_TAC[ONCE_REWRITE_RULE[COPRIME_SYM] COPRIME_PRIMEPOW; LE_1] THEN | |
| REPEAT STRIP_TAC THENL | |
| [ASM_MESON_TAC[EXP_EQ_0; LE_1; PRIME_0]; ASM_MESON_TAC[]; ALL_TAC] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_POW; REAL_ABS_DIV; REAL_ABS_POW; | |
| REAL_ABS_NUM] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| MATCH_MP_TAC(REAL_ARITH `&0 <= y /\ x = y ==> abs x = y`) THEN | |
| ASM_SIMP_TAC[LOG_POS; REAL_OF_NUM_LE; PRIME_IMP_NZ; LE_1] THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN MATCH_MP_TAC SELECT_UNIQUE THEN | |
| X_GEN_TAC `q:num` THEN REWRITE_TAC[] THEN EQ_TAC THENL | |
| [ASM_MESON_TAC[PRIME_DIVEXP; DIVIDES_PRIME_PRIME]; | |
| DISCH_THEN SUBST1_TAC THEN ASM_REWRITE_TAC[] THEN | |
| SUBGOAL_THEN `k = SUC(k - 1)` SUBST1_TAC THENL | |
| [ASM_ARITH_TAC; SIMP_TAC[EXP; DIVIDES_RMUL; DIVIDES_REFL]]]);; | |
| let BOUNDED_DIRICHLET_MANGOLDT_PRINCIPAL = prove | |
| (`!d. 1 <= d | |
| ==> bounded { vsum(1..x) (\n. chi_0 d n * Cx(mangoldt n / &n)) - | |
| Cx(log(&x)) | x IN (:num)}`, | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[bounded; SIMPLE_IMAGE; FORALL_IN_IMAGE; IN_UNIV] THEN | |
| EXISTS_TAC | |
| `abs(sum {p | prime p /\ p divides d} (\p. log(&p))) + | |
| abs(log(&0)) + &21` THEN | |
| X_GEN_TAC `x:num` THEN ASM_CASES_TAC `x = 0` THENL | |
| [ASM_SIMP_TAC[VSUM_CLAUSES_NUMSEG; ARITH; VECTOR_SUB_LZERO] THEN | |
| REWRITE_TAC[NORM_NEG; COMPLEX_NORM_CX] THEN REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(REAL_ARITH `x <= a + b ==> x <= a + abs y + b`) THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `!s'. norm(s') <= p /\ norm(s - s' - l) <= &21 | |
| ==> norm(s - l) <= abs p + &21`) THEN | |
| EXISTS_TAC `vsum(1..x) (\n. (chi_0 d n - Cx(&1)) * Cx(mangoldt n / &n))` THEN | |
| ASM_SIMP_TAC[BOUNDED_DIRICHLET_MANGOLDT_PRINCIPAL_LEMMA] THEN | |
| SIMP_TAC[GSYM VSUM_SUB; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[COMPLEX_RING `c * x - (c - Cx(&1)) * x = x`] THEN | |
| SIMP_TAC[GSYM CX_SUB; VSUM_CX; FINITE_NUMSEG; COMPLEX_NORM_CX] THEN | |
| MATCH_MP_TAC MERTENS_LEMMA THEN ASM_REWRITE_TAC[]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The arithmetic-geometric mean that we want. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let SUM_OF_NUMBERS = prove | |
| (`!n. nsum(0..n) (\i. i) = (n * (n + 1)) DIV 2`, | |
| INDUCT_TAC THEN ASM_REWRITE_TAC[NSUM_CLAUSES_NUMSEG] THEN ARITH_TAC);; | |
| let PRODUCT_POW_NSUM = prove | |
| (`!s. FINITE s ==> product s (\i. z pow (f i)) = z pow (nsum s f)`, | |
| MATCH_MP_TAC FINITE_INDUCT_STRONG THEN | |
| SIMP_TAC[PRODUCT_CLAUSES; NSUM_CLAUSES; real_pow; REAL_POW_ADD]);; | |
| let PRODUCT_SPECIAL = prove | |
| (`!z i. product (0..n) (\i. z pow i) = z pow ((n * (n + 1)) DIV 2)`, | |
| SIMP_TAC[PRODUCT_POW_NSUM; FINITE_NUMSEG; SUM_OF_NUMBERS]);; | |
| let AGM_SPECIAL = prove | |
| (`!n t. &0 <= t | |
| ==> (&n + &1) pow 2 * t pow n <= (sum(0..n) (\k. t pow k)) pow 2`, | |
| REPEAT STRIP_TAC THEN | |
| MP_TAC(ISPECL [`n + 1`; `\k. (t:real) pow (k - 1)`] AGM) THEN | |
| ASM_SIMP_TAC[REAL_POW_LE; ARITH_RULE `1 <= n + 1`] THEN | |
| SUBGOAL_THEN `1..n+1 = 0+1..n+1` SUBST1_TAC THENL | |
| [REWRITE_TAC[ADD_CLAUSES]; ALL_TAC] THEN | |
| REWRITE_TAC[SUM_OFFSET; PRODUCT_OFFSET; ADD_SUB] THEN | |
| REWRITE_TAC[PRODUCT_SPECIAL] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ_ALT] REAL_POW_LE2)) THEN | |
| DISCH_THEN(MP_TAC o SPEC `2`) THEN | |
| ASM_SIMP_TAC[PRODUCT_POS_LE_NUMSEG; REAL_POW_LE] THEN | |
| REWRITE_TAC[REAL_POW_POW] THEN ONCE_REWRITE_TAC[MULT_SYM] THEN | |
| SUBGOAL_THEN `2 * (n * (n + 1)) DIV 2 = n * (n + 1)` SUBST1_TAC THENL | |
| [SUBGOAL_THEN `EVEN(n * (n + 1))` MP_TAC THENL | |
| [REWRITE_TAC[EVEN_ADD; EVEN_MULT; ARITH_EVEN] THEN CONV_TAC TAUT; | |
| SIMP_TAC[EVEN_EXISTS; LEFT_IMP_EXISTS_THM; DIV_MULT; ARITH]]; | |
| REWRITE_TAC[GSYM REAL_POW_POW] THEN DISCH_THEN(MP_TAC o MATCH_MP | |
| (REWRITE_RULE[IMP_CONJ_ALT] REAL_POW_LE2_REV)) THEN | |
| REWRITE_TAC[ADD_EQ_0; ARITH_EQ; REAL_POW_2; REAL_LE_SQUARE] THEN | |
| REWRITE_TAC[GSYM REAL_POW_2; GSYM REAL_OF_NUM_ADD] THEN | |
| ASM_SIMP_TAC[REAL_POW_DIV; REAL_LE_RDIV_EQ; REAL_POW_LT; | |
| REAL_ARITH `&0 < &n + &1`] THEN | |
| REWRITE_TAC[REAL_MUL_AC]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The trickiest part: the nonvanishing of L-series for real character. *) | |
| (* Proof from Monsky's article (AMM 1993, pp. 861-2). *) | |
| (* ------------------------------------------------------------------------- *) | |
| let DIVISORSUM_PRIMEPOW = prove | |
| (`!f p k. prime p | |
| ==> sum {m | m divides (p EXP k)} c = sum(0..k) (\i. c(p EXP i))`, | |
| REPEAT STRIP_TAC THEN | |
| ASM_SIMP_TAC[DIVIDES_PRIMEPOW; SET_RULE | |
| `{m | ?i. P i /\ m = f i} = IMAGE f {i | P i}`] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o RAND_CONV) [GSYM o_DEF] THEN | |
| REWRITE_TAC[GSYM NUMSEG_LE] THEN MATCH_MP_TAC SUM_IMAGE THEN | |
| ASM_SIMP_TAC[IN_ELIM_THM; EQ_EXP; FINITE_NUMSEG_LE] THEN | |
| ASM_MESON_TAC[PRIME_0; PRIME_1]);; | |
| let DIVISORVSUM_PRIMEPOW = prove | |
| (`!f p k. prime p | |
| ==> vsum {m | m divides (p EXP k)} c = vsum(0..k) (\i. c(p EXP i))`, | |
| REPEAT STRIP_TAC THEN | |
| ASM_SIMP_TAC[DIVIDES_PRIMEPOW; SET_RULE | |
| `{m | ?i. P i /\ m = f i} = IMAGE f {i | P i}`] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o RAND_CONV) [GSYM o_DEF] THEN | |
| REWRITE_TAC[GSYM NUMSEG_LE] THEN MATCH_MP_TAC VSUM_IMAGE THEN | |
| ASM_SIMP_TAC[IN_ELIM_THM; EQ_EXP; FINITE_NUMSEG_LE] THEN | |
| ASM_MESON_TAC[PRIME_0; PRIME_1]);; | |
| let DIRICHLET_CHARACTER_DIVISORSUM_EQ_1 = prove | |
| (`!d c p k. dirichlet_character d c /\ prime p /\ p divides d | |
| ==> vsum {m | m divides (p EXP k)} c = Cx(&1)`, | |
| REPEAT STRIP_TAC THEN | |
| MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC `vsum {1} c : complex` THEN | |
| CONJ_TAC THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[VSUM_SING] THEN ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1]] THEN | |
| MATCH_MP_TAC VSUM_SUPERSET THEN | |
| SIMP_TAC[SUBSET; IN_SING; IN_ELIM_THM; DIVIDES_1] THEN | |
| ASM_SIMP_TAC[DIVIDES_PRIMEPOW; LEFT_AND_EXISTS_THM; LEFT_IMP_EXISTS_THM] THEN | |
| MAP_EVERY X_GEN_TAC [`y:num`; `i:num`] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC) THEN | |
| FIRST_X_ASSUM SUBST_ALL_TAC THEN REWRITE_TAC[COMPLEX_VEC_0] THEN | |
| FIRST_ASSUM(fun th -> SIMP_TAC[MATCH_MP DIRICHLET_CHARACTER_EQ_0 th]) THEN | |
| ONCE_REWRITE_TAC[COPRIME_SYM] THEN REWRITE_TAC[COPRIME_REXP] THEN | |
| ASM_CASES_TAC `i = 0` THEN ASM_REWRITE_TAC[EXP] THEN | |
| ASM_MESON_TAC[COPRIME_SYM; PRIME_COPRIME_EQ]);; | |
| let DIRICHLET_CHARACTER_REAL_CASES = prove | |
| (`!d c. dirichlet_character d c /\ (!n. real(c n)) | |
| ==> !n. c n = --Cx(&1) \/ c n = Cx(&0) \/ c n = Cx(&1)`, | |
| REPEAT GEN_TAC THEN STRIP_TAC THEN X_GEN_TAC `n:num` THEN | |
| FIRST_ASSUM(MP_TAC o SPEC `n:num` o MATCH_MP DIRICHLET_CHARACTER_NORM) THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `n:num`) THEN REWRITE_TAC[REAL_EXISTS] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `t:real` SUBST1_TAC) THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; GSYM CX_NEG; CX_INJ] THEN REAL_ARITH_TAC);; | |
| let DIRICHLET_CHARACTER_DIVISORSUM_PRIMEPOW_POS = prove | |
| (`!d c p k. dirichlet_character d c /\ (!n. real(c n)) /\ prime p | |
| ==> &0 <= Re(vsum {m | m divides (p EXP k)} c)`, | |
| REPEAT STRIP_TAC THEN | |
| ASM_SIMP_TAC[RE_VSUM; FINITE_DIVISORS; EXP_EQ_0; PRIME_IMP_NZ] THEN | |
| ASM_SIMP_TAC[DIVISORSUM_PRIMEPOW] THEN | |
| FIRST_ASSUM(fun th -> SIMP_TAC[MATCH_MP DIRICHLET_CHARACTER_POW th]) THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] DIRICHLET_CHARACTER_REAL_CASES) THEN | |
| ASM_REWRITE_TAC[] THEN DISCH_THEN(MP_TAC o SPEC `p:num`) THEN STRIP_TAC THEN | |
| ASM_SIMP_TAC[GSYM CX_POW; RE_CX; SUM_POS_LE_NUMSEG; | |
| REAL_POW_LE; REAL_POS] THEN | |
| MATCH_MP_TAC(REAL_ARITH `(s = if EVEN k then &1 else &0) ==> &0 <= s`) THEN | |
| SPEC_TAC(`k:num`,`r:num`) THEN | |
| INDUCT_TAC THEN REWRITE_TAC[EVEN; SUM_CLAUSES_NUMSEG] THEN | |
| ASM_REWRITE_TAC[complex_pow; RE_CX; LE_0] THEN COND_CASES_TAC THEN | |
| ASM_REWRITE_TAC[COMPLEX_POW_NEG; COMPLEX_POW_ONE; COMPLEX_MUL_LNEG; | |
| COMPLEX_MUL_RNEG; COMPLEX_NEG_NEG; COMPLEX_MUL_LID; | |
| RE_NEG; RE_CX] THEN | |
| REAL_ARITH_TAC);; | |
| let DIRICHLET_CHARACTER_DIVISORSUM_POS = prove | |
| (`!d c n. dirichlet_character d c /\ (!n. real(c n)) /\ ~(n = 0) | |
| ==> &0 <= Re(vsum {m | m divides n} c)`, | |
| REPEAT STRIP_TAC THEN FIRST_X_ASSUM(DISJ_CASES_TAC o MATCH_MP (ARITH_RULE | |
| `~(n = 0) ==> n = 1 \/ 1 < n`)) | |
| THENL | |
| [ASM_SIMP_TAC[DIVIDES_ONE; SING_GSPEC; VSUM_SING] THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1; RE_CX; REAL_POS]; | |
| ALL_TAC] THEN | |
| UNDISCH_TAC `1 < n` THEN SPEC_TAC(`n:num`,`n:num`) THEN | |
| MATCH_MP_TAC INDUCT_COPRIME_STRONG THEN CONJ_TAC THENL | |
| [ALL_TAC; ASM_MESON_TAC[DIRICHLET_CHARACTER_DIVISORSUM_PRIMEPOW_POS]] THEN | |
| MAP_EVERY X_GEN_TAC [`a:num`; `b:num`] THEN STRIP_TAC THEN | |
| MP_TAC(ISPEC `\m:num. Re(c m)` REAL_MULTIPLICATIVE_DIVISORSUM) THEN | |
| REWRITE_TAC[real_multiplicative] THEN ANTS_TAC THENL | |
| [FIRST_ASSUM(fun th -> REWRITE_TAC[MATCH_MP DIRICHLET_CHARACTER_MUL th]) THEN | |
| ASM_MESON_TAC[DIRICHLET_CHARACTER_EQ_1; RE_CX; REAL; CX_MUL]; | |
| DISCH_THEN(MP_TAC o SPECL [`a:num`; `b:num`] o CONJUNCT2) THEN | |
| ASM_SIMP_TAC[GSYM RE_VSUM; FINITE_DIVISORS; MULT_EQ_0; | |
| ARITH_RULE `1 < n ==> ~(n = 0)`; REAL_LE_MUL]]);; | |
| let lemma = prove | |
| (`!x n. &0 <= x /\ x <= &1 ==> &1 - &n * x <= (&1 - x) pow n`, | |
| REWRITE_TAC[RIGHT_FORALL_IMP_THM] THEN GEN_TAC THEN DISCH_TAC THEN | |
| INDUCT_TAC THEN REWRITE_TAC[real_pow] THENL [REAL_ARITH_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC `(&1 - x) * (&1 - &n * x)` THEN | |
| ASM_SIMP_TAC[REAL_LE_LMUL; REAL_SUB_LE; GSYM REAL_OF_NUM_SUC] THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `&0 <= n * x * x ==> &1 - (n + &1) * x <= (&1 - x) * (&1 - n * x)`) THEN | |
| SIMP_TAC[REAL_LE_MUL; REAL_POS; REAL_LE_SQUARE]);; | |
| let LFUNCTION_NONZERO_REAL = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) /\ (!n. real(c n)) | |
| ==> ~(Lfunction c = Cx(&0))`, | |
| REPEAT STRIP_TAC THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] | |
| DIRICHLET_CHARACTER_NONPRINCIPAL_NONTRIVIAL) THEN | |
| ASM_REWRITE_TAC[] THEN STRIP_TAC THEN | |
| SUBGOAL_THEN | |
| `!z. norm(z) < &1 | |
| ==> summable (from 1) (\n. c(n) * z pow n / (Cx(&1) - z pow n))` | |
| MP_TAC THENL | |
| [GEN_TAC THEN DISCH_TAC THEN ASM_CASES_TAC `z = Cx(&0)` THENL | |
| [MATCH_MP_TAC SUMMABLE_FROM_ELSEWHERE THEN EXISTS_TAC `2` THEN | |
| MATCH_MP_TAC SUMMABLE_EQ THEN EXISTS_TAC `\n:num. Cx(&0)` THEN | |
| REWRITE_TAC[GSYM COMPLEX_VEC_0; SUMMABLE_0] THEN | |
| ASM_SIMP_TAC[COMPLEX_VEC_0; COMPLEX_POW_ZERO; IN_FROM; | |
| ARITH_RULE `2 <= n ==> ~(n = 0)`] THEN | |
| CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC SERIES_COMPARISON_COMPLEX THEN | |
| EXISTS_TAC `\n. Cx(&2 * norm(z:complex) pow n)` THEN | |
| REWRITE_TAC[REAL_CX; RE_CX] THEN | |
| SIMP_TAC[REAL_LE_MUL; REAL_POS; REAL_POW_LE; NORM_POS_LE] THEN | |
| ASM_SIMP_TAC[CX_MUL; CX_POW; SUMMABLE_COMPLEX_LMUL; COMPLEX_NORM_CX; | |
| REAL_ABS_NORM; SUMMABLE_GP] THEN | |
| REWRITE_TAC[COMPLEX_NORM_MUL] THEN | |
| FIRST_ASSUM(fun th -> SIMP_TAC[MATCH_MP DIRICHLET_CHARACTER_NORM th]) THEN | |
| ONCE_REWRITE_TAC[COND_RAND] THEN ONCE_REWRITE_TAC[COND_RATOR] THEN | |
| ONCE_REWRITE_TAC[COND_RAND] THEN ONCE_REWRITE_TAC[COND_RATOR] THEN | |
| SIMP_TAC[REAL_MUL_LZERO; REAL_MUL_LID; REAL_ABS_POS; REAL_LE_MUL] THEN | |
| REWRITE_TAC[TAUT `(p ==> (if q then x else T)) <=> p /\ q ==> x`] THEN | |
| MP_TAC(SPECL [`norm(z:complex)`; `&1 / &2`] REAL_ARCH_POW_INV) THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `N:num` THEN DISCH_TAC THEN | |
| X_GEN_TAC `n:num` THEN REWRITE_TAC[GE] THEN STRIP_TAC THEN | |
| REWRITE_TAC[REAL_ABS_MUL; REAL_ABS_NORM; REAL_ABS_NUM; REAL_ABS_POW] THEN | |
| ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_NORM_MUL; COMPLEX_NORM_POW] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN SIMP_TAC[REAL_POW_LE; NORM_POS_LE] THEN | |
| REWRITE_TAC[COMPLEX_NORM_INV] THEN | |
| SUBST1_TAC(REAL_ARITH `&2 = inv(&1 / &2)`) THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `norm(z) <= norm(w) - h ==> h <= norm(w - z)`) THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX] THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC `norm(z:complex) pow N` THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_LE] THEN REWRITE_TAC[COMPLEX_NORM_POW] THEN | |
| MATCH_MP_TAC REAL_POW_MONO_INV THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_LE; NORM_POS_LE]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[summable; RIGHT_IMP_EXISTS_THM; SKOLEM_THM] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `f:complex->complex` (LABEL_TAC "+")) THEN | |
| ABBREV_TAC `b = \z n. inv(Cx(&n) * (Cx(&1) - z)) - | |
| z pow n / (Cx(&1) - z pow n)` THEN | |
| SUBGOAL_THEN | |
| `!z:complex. norm(z) < &1 ==> ((\n. c(n) * b z n) sums --(f z)) (from 1)` | |
| (LABEL_TAC "*") | |
| THENL | |
| [REPEAT STRIP_TAC THEN EXPAND_TAC "b" THEN | |
| REWRITE_TAC[COMPLEX_SUB_LDISTRIB; GSYM COMPLEX_SUB_LZERO] THEN | |
| MATCH_MP_TAC SERIES_SUB THEN ASM_SIMP_TAC[GSYM COMPLEX_SUB_LDISTRIB] THEN | |
| REWRITE_TAC[COMPLEX_INV_MUL; COMPLEX_MUL_ASSOC] THEN | |
| SUBST1_TAC(COMPLEX_RING `Cx(&0) = Cx(&0) * inv(Cx(&1) - z)`) THEN | |
| MATCH_MP_TAC SERIES_COMPLEX_RMUL THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] LFUNCTION) THEN | |
| ASM_REWRITE_TAC[complex_div]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `!z. norm(z) < &1 | |
| ==> ((\n. vsum {d | d divides n} (\d. c d) * z pow n) sums | |
| f(z)) (from 1)` | |
| (LABEL_TAC "+") THENL | |
| [REPEAT STRIP_TAC THEN REWRITE_TAC[sums; FROM_INTER_NUMSEG] THEN | |
| SIMP_TAC[GSYM VSUM_COMPLEX_RMUL; FINITE_DIVISORS; LE_1] THEN | |
| REWRITE_TAC[VSUM_VSUM_DIVISORS] THEN | |
| REMOVE_THEN "+" (MP_TAC o SPEC `z:complex`) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| SIMP_TAC[VSUM_COMPLEX_LMUL; FINITE_NUMSEG; sums; FROM_INTER_NUMSEG] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM) THEN | |
| SIMP_TAC[GSYM VSUM_SUB; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[GSYM COMPLEX_SUB_LDISTRIB] THEN | |
| ONCE_REWRITE_TAC[MULT_SYM] THEN REWRITE_TAC[GSYM COMPLEX_POW_POW] THEN | |
| REWRITE_TAC[VSUM_GP; ARITH_RULE `n < 1 <=> n = 0`] THEN | |
| SIMP_TAC[DIV_EQ_0; LE_1] THEN SIMP_TAC[GSYM NOT_LE] THEN | |
| SUBGOAL_THEN `!k. 1 <= k ==> ~(z pow k = Cx(&1))` (fun th -> SIMP_TAC[th]) | |
| THENL [ASM_MESON_TAC[COMPLEX_POW_EQ_1; LE_1; REAL_LT_REFL]; ALL_TAC] THEN | |
| REWRITE_TAC[COMPLEX_POW_1; complex_div] THEN | |
| REWRITE_TAC[COMPLEX_RING `(zx * i - (zx - w) * i) = w * i`] THEN | |
| SIMP_TAC[COMPLEX_POW_POW] THEN MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\x. vsum (1..x) | |
| (\n. z pow x * c n * | |
| z pow (n - x MOD n) / (Cx(&1) - z pow n))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC `x:num` THEN | |
| REWRITE_TAC[] THEN MATCH_MP_TAC VSUM_EQ_NUMSEG THEN | |
| X_GEN_TAC `n:num` THEN STRIP_TAC THEN REWRITE_TAC[] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_INV_MUL; COMPLEX_MUL_ASSOC] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING `(zx * cn) * zn = cn * zx * zn`] THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[GSYM COMPLEX_POW_ADD] THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[MULT_CLAUSES] THEN | |
| MP_TAC(SPECL [`x:num`; `n:num`] DIVISION) THEN ASM_SIMP_TAC[LE_1] THEN | |
| ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[COMPLEX_VEC_0] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPARISON_COMPLEX THEN | |
| EXISTS_TAC `\x. Cx(norm(z) / (&1 - norm z)) * Cx(&x) * z pow x` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC `x:num` THEN | |
| REWRITE_TAC[] THEN MATCH_MP_TAC VSUM_NORM_TRIANGLE THEN | |
| REWRITE_TAC[FINITE_NUMSEG; COMPLEX_NORM_MUL; COMPLEX_NORM_CX; | |
| REAL_ABS_DIV; REAL_ABS_NUM] THEN | |
| GEN_REWRITE_TAC RAND_CONV [REAL_ARITH `a * &x * b = &x * a * b`] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o LAND_CONV o RAND_CONV) | |
| [GSYM CARD_NUMSEG_1] THEN | |
| MATCH_MP_TAC SUM_BOUND THEN REWRITE_TAC[FINITE_NUMSEG] THEN | |
| X_GEN_TAC `n:num` THEN REWRITE_TAC[IN_NUMSEG] THEN STRIP_TAC THEN | |
| FIRST_ASSUM(fun t -> SIMP_TAC[MATCH_MP DIRICHLET_CHARACTER_NORM t]) THEN | |
| COND_CASES_TAC THEN | |
| ASM_SIMP_TAC[REAL_MUL_LZERO; REAL_MUL_RZERO; REAL_LE_DIV; REAL_ABS_POS; | |
| NORM_POS_LE; REAL_LE_MUL; REAL_MUL_LID; REAL_ABS_NORM] THEN | |
| GEN_REWRITE_TAC RAND_CONV [REAL_MUL_SYM] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN REWRITE_TAC[NORM_POS_LE] THEN | |
| SIMP_TAC[complex_div; real_div; COMPLEX_NORM_MUL; COMPLEX_NORM_INV] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN SIMP_TAC[NORM_POS_LE; REAL_LE_INV_EQ] THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[COMPLEX_NORM_POW] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_POW_1] THEN | |
| MATCH_MP_TAC REAL_POW_MONO_INV THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_LE; NORM_POS_LE] THEN | |
| MATCH_MP_TAC(ARITH_RULE `m < r ==> 1 <= r - m`) THEN | |
| ASM_SIMP_TAC[DIVISION; LE_1]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN | |
| REWRITE_TAC[REAL_ARITH `&0 < abs(x - a) <=> ~(a = x)`] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[REAL_LT_REFL]; ALL_TAC] THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `norm(w) = &1 /\ norm(z) < &1 /\ norm(zn) <= norm(z) | |
| ==> abs(&1 - norm(z)) <= norm(w - zn)`) THEN | |
| ASM_REWRITE_TAC[COMPLEX_NORM_NUM; COMPLEX_NORM_POW] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_POW_1] THEN | |
| MATCH_MP_TAC REAL_POW_MONO_INV THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_LE; NORM_POS_LE]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN ASM_SIMP_TAC[LIM_N_TIMES_POWN]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `~(bounded | |
| { (f:complex->complex)(t) | real t /\ &0 <= Re t /\ norm(t) < &1 })` | |
| MP_TAC THENL | |
| [REWRITE_TAC[BOUNDED_POS] THEN ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN | |
| REWRITE_TAC[FORALL_IN_IMAGE; IN_ELIM_THM] THEN | |
| REWRITE_TAC[IMP_CONJ; FORALL_REAL] THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; RE_CX; IMP_IMP] THEN | |
| REWRITE_TAC[REAL_ARITH `&0 <= x /\ abs x < &1 <=> &0 <= x /\ x < &1`] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| FIRST_ASSUM(X_CHOOSE_THEN `p:num` STRIP_ASSUME_TAC o | |
| MATCH_MP PRIME_FACTOR) THEN | |
| X_CHOOSE_TAC `N:num` (SPEC `&2 * (B + &1)` REAL_ARCH_SIMPLE) THEN | |
| SUBGOAL_THEN `0 < N` ASSUME_TAC THENL | |
| [REWRITE_TAC[GSYM REAL_OF_NUM_LT] THEN ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ABBREV_TAC `t = &1 - inv(&(p EXP N)) / &2` THEN | |
| SUBGOAL_THEN `&0 <= t /\ t < &1` STRIP_ASSUME_TAC THENL | |
| [EXPAND_TAC "t" THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `&0 < y /\ y <= &1 ==> &0 <= &1 - y / &2 /\ &1 - y / &2 < &1`) THEN | |
| ASM_SIMP_TAC[REAL_INV_LE_1; REAL_LT_INV_EQ; REAL_OF_NUM_LE; | |
| REAL_OF_NUM_LT; LE_1; EXP_EQ_0; PRIME_IMP_NZ]; | |
| ALL_TAC] THEN | |
| REMOVE_THEN "+" (MP_TAC o SPEC `Cx t`) THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; NOT_IMP] THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `t:real`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_TAC THEN REWRITE_TAC[SERIES_FROM; LIM_SEQUENTIALLY] THEN | |
| DISCH_THEN(MP_TAC o SPEC `&1`) THEN REWRITE_TAC[REAL_LT_01] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `M:num` MP_TAC) THEN | |
| SUBGOAL_THEN `?n. M <= n /\ 1 <= n /\ p EXP N <= n` STRIP_ASSUME_TAC THENL | |
| [EXISTS_TAC `p EXP N + M + 1` THEN ARITH_TAC; ALL_TAC] THEN | |
| DISCH_THEN(MP_TAC o SPEC `n:num`) THEN ASM_REWRITE_TAC[] THEN | |
| UNDISCH_TAC `norm (f (Cx t):complex) <= B` THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `B + &1 <= norm(x) ==> norm(y) <= B ==> ~(dist(x,y) < &1)`) THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `a <= Re z /\ abs(Re z) <= norm z ==> a <= norm z`) THEN | |
| REWRITE_TAC[COMPLEX_NORM_GE_RE_IM] THEN | |
| SIMP_TAC[RE_VSUM; FINITE_NUMSEG; RE_MUL_CX; GSYM CX_POW] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum (IMAGE (\k. p EXP k) (0..N)) | |
| (\x. Re (vsum {d | d divides x} (\d. c d)) * t pow x)` THEN | |
| CONJ_TAC THENL | |
| [ALL_TAC; | |
| MATCH_MP_TAC SUM_SUBSET_SIMPLE THEN | |
| REWRITE_TAC[FINITE_NUMSEG; IN_NUMSEG; IN_DIFF; SUBSET; IN_ELIM_THM; | |
| FORALL_IN_IMAGE] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] | |
| DIRICHLET_CHARACTER_DIVISORSUM_POS) THEN | |
| ASM_SIMP_TAC[REAL_POW_LE; REAL_LE_MUL; LE_1; ETA_AX] THEN | |
| DISCH_THEN(K ALL_TAC) THEN | |
| REWRITE_TAC[ARITH_RULE `1 <= n <=> ~(n = 0)`] THEN | |
| ASM_SIMP_TAC[EXP_EQ_0; PRIME_IMP_NZ] THEN | |
| X_GEN_TAC `k:num` THEN STRIP_TAC THEN | |
| MATCH_MP_TAC LE_TRANS THEN EXISTS_TAC `p EXP N` THEN | |
| ASM_SIMP_TAC[LE_EXP; PRIME_IMP_NZ]] THEN | |
| W(MP_TAC o PART_MATCH (lhs o rand) SUM_IMAGE o rand o snd) THEN | |
| ANTS_TAC THENL | |
| [REWRITE_TAC[EQ_EXP] THEN ASM_MESON_TAC[PRIME_0; PRIME_1]; ALL_TAC] THEN | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[o_DEF] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum (0..N) (\k. &1 * &1 / &2)` THEN CONJ_TAC THENL | |
| [REWRITE_TAC[SUM_CONST_NUMSEG; SUB_0; GSYM REAL_OF_NUM_ADD] THEN | |
| ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC SUM_LE_NUMSEG THEN X_GEN_TAC `k:num` THEN STRIP_TAC THEN | |
| REWRITE_TAC[] THEN MATCH_MP_TAC REAL_LE_MUL2 THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN CONJ_TAC THENL | |
| [MP_TAC(SPECL [`d:num`; `c:num->complex`; `p:num`; `k:num`] | |
| DIRICHLET_CHARACTER_DIVISORSUM_EQ_1) THEN | |
| ASM_SIMP_TAC[ETA_AX; RE_CX; REAL_LE_REFL]; | |
| ALL_TAC] THEN | |
| MP_TAC(ISPECL [`inv(&(p EXP N)) / &2`; `p EXP k`] lemma) THEN | |
| ASM_REWRITE_TAC[] THEN ANTS_TAC THENL | |
| [REWRITE_TAC[real_div; GSYM REAL_INV_MUL; REAL_OF_NUM_MUL] THEN | |
| REWRITE_TAC[REAL_LE_INV_EQ; REAL_POS] THEN | |
| MATCH_MP_TAC REAL_INV_LE_1 THEN | |
| REWRITE_TAC[REAL_OF_NUM_LE; ARITH_RULE `1 <= n <=> ~(n = 0)`] THEN | |
| ASM_SIMP_TAC[EXP_EQ_0; MULT_EQ_0; ARITH; PRIME_IMP_NZ]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(REAL_ARITH `b <= a ==> a <= x ==> b <= x`) THEN | |
| MATCH_MP_TAC(REAL_ARITH `x * y <= &1 ==> &1 / &2 <= &1 - x * y / &2`) THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1; | |
| EXP_EQ_0; PRIME_IMP_NZ] THEN | |
| ASM_REWRITE_TAC[REAL_MUL_LID; REAL_OF_NUM_LE; LE_EXP] THEN | |
| ASM_MESON_TAC[PRIME_0]; | |
| ALL_TAC] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] | |
| BOUNDED_LFUNCTION_PARTIAL_SUMS) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP BOUNDED_PARTIAL_SUMS) THEN | |
| REWRITE_TAC[BOUNDED_POS] THEN ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN | |
| REWRITE_TAC[FORALL_IN_IMAGE] THEN | |
| SIMP_TAC[IN_ELIM_THM; IN_UNIV; LEFT_IMP_EXISTS_THM] THEN | |
| REWRITE_TAC[MESON[] `(!x a b. x = f a b ==> p a b) <=> (!a b. p a b)`] THEN | |
| X_GEN_TAC `B:real` THEN STRIP_TAC THEN EXISTS_TAC `&2 * B` THEN | |
| ASM_SIMP_TAC[REAL_LT_MUL; REAL_OF_NUM_LT; ARITH] THEN | |
| X_GEN_TAC `z:complex` THEN STRIP_TAC THEN | |
| ONCE_REWRITE_TAC[GSYM NORM_NEG] THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` LIM_NORM_UBOUND) THEN | |
| EXISTS_TAC | |
| `\n. vsum(from 1 INTER (0..n)) (\k. c k * b (z:complex) k :complex)` THEN | |
| ASM_SIMP_TAC[TRIVIAL_LIMIT_SEQUENTIALLY; GSYM sums] THEN | |
| REWRITE_TAC[FROM_INTER_NUMSEG] THEN | |
| MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC `n:num` THEN | |
| MP_TAC(ISPECL [`c:num->complex`; `(b:complex->num->complex) z`; | |
| `B:real`; `1`] SERIES_DIRICHLET_COMPLEX_VERY_EXPLICIT) THEN | |
| ASM_REWRITE_TAC[LE_REFL] THEN ANTS_TAC THENL | |
| [ALL_TAC; | |
| DISCH_THEN(MP_TAC o SPEC `1`) THEN | |
| SUBGOAL_THEN `(b:complex->num->complex) z 1 = Cx(&1)` SUBST1_TAC THENL | |
| [EXPAND_TAC "b" THEN | |
| REWRITE_TAC[COMPLEX_POW_1; COMPLEX_INV_MUL; complex_div] THEN | |
| REWRITE_TAC[GSYM COMPLEX_SUB_RDISTRIB; COMPLEX_INV_1] THEN | |
| MATCH_MP_TAC COMPLEX_MUL_RINV THEN REWRITE_TAC[COMPLEX_SUB_0] THEN | |
| DISCH_THEN(SUBST_ALL_TAC o SYM) THEN | |
| UNDISCH_TAC `norm(Cx(&1)) < &1` THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; REAL_LT_REFL; REAL_ABS_NUM]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[COMPLEX_NORM_NUM; REAL_MUL_RID] THEN | |
| DISCH_THEN MATCH_MP_TAC THEN REWRITE_TAC[LE_REFL]] THEN | |
| FIRST_X_ASSUM(X_CHOOSE_THEN `t:real` SUBST_ALL_TAC o | |
| GEN_REWRITE_RULE I [REAL_EXISTS]) THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[RE_CX; COMPLEX_NORM_CX]) THEN | |
| SUBGOAL_THEN `!n. &0 < sum(0..n) (\m. t pow m)` ASSUME_TAC THENL | |
| [GEN_TAC THEN SIMP_TAC[LE_0; SUM_CLAUSES_LEFT; real_pow] THEN | |
| MATCH_MP_TAC(REAL_ARITH `&0 <= x ==> &0 < &1 + x`) THEN | |
| ASM_SIMP_TAC[SUM_POS_LE_NUMSEG; REAL_POW_LE]; | |
| ALL_TAC] THEN | |
| CONJ_TAC THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN EXPAND_TAC "b" THEN | |
| REWRITE_TAC[GSYM CX_SUB; GSYM CX_POW; GSYM CX_DIV; GSYM CX_MUL; | |
| GSYM CX_INV; REAL_CX; RE_CX] | |
| THENL | |
| [ASM_SIMP_TAC[REAL_SUB_POW_L1; REAL_SUB_LE] THEN | |
| ASM_REWRITE_TAC[real_div; REAL_INV_MUL] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LE_RDIV_EQ; REAL_LT_MUL; REAL_OF_NUM_LT; | |
| LE_1; REAL_ARITH `abs t < &1 ==> &0 < &1 - t`] THEN | |
| ASM_SIMP_TAC[real_div; REAL_FIELD | |
| `abs(t) < &1 ==> (x * inv(&1 - t) * y) * (&1 - t) = x * y`] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_MUL_LID] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LE_RDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| ONCE_REWRITE_TAC[REAL_ARITH `x / y * &n = (&n * x) / y`] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC `sum(0..n-1) (\m. t pow n)` THEN CONJ_TAC THENL | |
| [ASM_SIMP_TAC[SUM_CONST_NUMSEG; ARITH_RULE `1 <= n ==> n - 1 + 1 = n`; | |
| SUB_0; REAL_LE_REFL]; | |
| REWRITE_TAC[REAL_MUL_LID] THEN MATCH_MP_TAC SUM_LE_NUMSEG THEN | |
| GEN_TAC THEN STRIP_TAC THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC REAL_POW_MONO_INV THEN REPEAT CONJ_TAC THEN | |
| TRY ASM_REAL_ARITH_TAC THEN ASM_ARITH_TAC]; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[REAL_SUB_POW_L1; ARITH_RULE `1 <= n + 1`] THEN | |
| REWRITE_TAC[ADD_SUB; REAL_INV_MUL; real_div] THEN | |
| REWRITE_TAC[REAL_ARITH `x * t - y * t * z <= u * t - v * t * w <=> | |
| t * (v * w - y * z) <= t * (u - x)`] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN REWRITE_TAC[REAL_LE_INV_EQ] THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_FIELD | |
| `&0 < y /\ &0 < z ==> x / y - w / z = (x * z - w * y) / (y * z)`] THEN | |
| SUBGOAL_THEN `t pow n * sum (0..n) (\m. t pow m) - | |
| t pow (n + 1) * sum (0..n - 1) (\m. t pow m) = t pow n` | |
| SUBST1_TAC THENL | |
| [REWRITE_TAC[GSYM SUM_LMUL; GSYM REAL_POW_ADD] THEN | |
| ONCE_REWRITE_TAC[ARITH_RULE `(n + 1) + x = n + x + 1`] THEN | |
| REWRITE_TAC[GSYM(SPEC `1` SUM_OFFSET); SUB_ADD; ADD_CLAUSES] THEN | |
| SIMP_TAC[SUM_CLAUSES_LEFT; LE_0; GSYM SUM_LMUL; ADD_CLAUSES] THEN | |
| ASM_SIMP_TAC[SUB_ADD; REAL_POW_ADD] THEN | |
| REWRITE_TAC[REAL_ARITH `(x + y) - y:real = x`]; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_LT_MUL; GSYM REAL_OF_NUM_ADD; | |
| REAL_OF_NUM_LE; | |
| REAL_FIELD `&1 <= n ==> inv(n) - inv(n + &1) = inv(n * (n + &1))`] THEN | |
| MATCH_MP_TAC REAL_POW_LE2_REV THEN EXISTS_TAC `2` THEN | |
| REWRITE_TAC[ARITH] THEN CONJ_TAC THENL | |
| [REPEAT(MATCH_MP_TAC REAL_LE_MUL THEN | |
| CONJ_TAC THEN REWRITE_TAC[REAL_LE_INV_EQ]) THEN | |
| ASM_SIMP_TAC[REAL_POW_LE; SUM_POS_LE_NUMSEG] THEN REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MP_TAC(SPECL [`n:num`; `t:real`] AGM_SPECIAL) THEN | |
| MP_TAC(SPECL [`n - 1`; `t:real`] AGM_SPECIAL) THEN | |
| ASM_SIMP_TAC[GSYM REAL_OF_NUM_SUB; REAL_SUB_ADD] THEN | |
| REWRITE_TAC[IMP_IMP] THEN | |
| GEN_REWRITE_TAC (LAND_CONV o ONCE_DEPTH_CONV) [REAL_MUL_SYM] THEN | |
| ASM_SIMP_TAC[GSYM REAL_LE_RDIV_EQ; REAL_POW_LT; REAL_OF_NUM_LT; | |
| LE_1; REAL_ARITH `&0 < &n + &1`] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (REWRITE_RULE | |
| [TAUT `a /\ b /\ c /\ d ==> e <=> b /\ d ==> a /\ c ==> e`] | |
| REAL_LE_MUL2)) THEN | |
| ASM_SIMP_TAC[REAL_POW_LE; REAL_LE_MUL; REAL_ARITH `&0 <= &n + &1`] THEN | |
| MATCH_MP_TAC(REAL_ARITH `x = y /\ a <= b ==> b <= x ==> a <= y`) THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[REAL_POW_2; real_div; REAL_INV_MUL; REAL_POW_MUL] THEN | |
| REWRITE_TAC[REAL_MUL_AC]; | |
| REWRITE_TAC[GSYM REAL_POW_ADD; REAL_POW_POW] THEN | |
| MATCH_MP_TAC REAL_POW_MONO_INV THEN ASM_REWRITE_TAC[] THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ARITH_TAC]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Deduce nonvanishing of all the nonprincipal characters. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let BOUNDED_DIFF_LOGMUL = prove | |
| (`!f a. bounded {f x - Cx(log(&x)) * a | x IN (:num)} | |
| ==> (!x. &0 <= Re(f x)) ==> &0 <= Re a`, | |
| REPEAT GEN_TAC THEN | |
| REWRITE_TAC[BOUNDED_POS; SIMPLE_IMAGE; FORALL_IN_IMAGE; IN_UNIV] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN DISCH_TAC THEN | |
| ONCE_REWRITE_TAC[GSYM REAL_NOT_LT] THEN DISCH_TAC THEN | |
| MP_TAC(ISPEC `exp((B + &1) / --(Re a))` REAL_ARCH_SIMPLE) THEN | |
| DISCH_THEN(X_CHOOSE_TAC `n:num`) THEN | |
| SUBGOAL_THEN `abs(Re(f n - Cx(log(&n)) * a)) <= B` MP_TAC THENL | |
| [ASM_MESON_TAC[COMPLEX_NORM_GE_RE_IM; REAL_LE_TRANS]; ALL_TAC] THEN | |
| REWRITE_TAC[RE_SUB; RE_MUL_CX; REAL_NOT_LE] THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `B < l * --a /\ &0 <= f ==> B < abs(f - l * a)`) THEN | |
| ASM_SIMP_TAC[GSYM REAL_LT_LDIV_EQ; REAL_NEG_GT0] THEN | |
| MATCH_MP_TAC REAL_LTE_TRANS THEN | |
| EXISTS_TAC `log(exp((B + &1) / --Re a))` THEN CONJ_TAC THENL | |
| [ASM_SIMP_TAC[LOG_EXP; REAL_NEG_GT0; REAL_LT_DIV2_EQ] THEN REAL_ARITH_TAC; | |
| MATCH_MP_TAC LOG_MONO_LE_IMP THEN ASM_REWRITE_TAC[REAL_EXP_POS_LT]]);; | |
| let LFUNCTION_NONZERO_NONPRINCIPAL = prove | |
| (`!d c. dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> ~(Lfunction c = Cx(&0))`, | |
| let lemma = prove | |
| (`{a,b,c} SUBSET s | |
| ==> FINITE s | |
| ==> !f. sum s f = sum (s DIFF {a,b,c}) f + sum {a,b,c} f`, | |
| REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN | |
| MATCH_MP_TAC SUM_UNION_EQ THEN ASM_REWRITE_TAC[] THEN ASM SET_TAC[]) in | |
| GEN_TAC THEN ASM_CASES_TAC `d = 0` THENL | |
| [ASM_MESON_TAC[DIRICHLET_CHARACTER_0]; ALL_TAC] THEN | |
| MP_TAC(ISPECL | |
| [`\x c. vsum(1..x) (\n. c n * Cx(mangoldt n / &n)) - | |
| Cx(log(&x)) * | |
| (if c = chi_0 d then Cx(&1) | |
| else if Lfunction c = Cx(&0) then --Cx(&1) | |
| else Cx(&0))`; | |
| `(:num)`; | |
| `{c | dirichlet_character d c}`] | |
| BOUNDED_SUMS_IMAGES) THEN | |
| ANTS_TAC THENL | |
| [REWRITE_TAC[FINITE_DIRICHLET_CHARACTERS; IN_ELIM_THM] THEN | |
| X_GEN_TAC `c:num->complex` THEN | |
| ASM_CASES_TAC `c = chi_0 d` THEN | |
| ASM_SIMP_TAC[COMPLEX_MUL_RID; BOUNDED_DIRICHLET_MANGOLDT_PRINCIPAL; | |
| LE_1] THEN | |
| ASM_CASES_TAC `Lfunction c = Cx(&0)` THEN | |
| ASM_REWRITE_TAC[COMPLEX_SUB_RZERO; COMPLEX_MUL_RNEG; COMPLEX_MUL_RZERO; | |
| COMPLEX_MUL_RID; COMPLEX_SUB_RNEG] THEN | |
| ASM_MESON_TAC[BOUNDED_DIRICHLET_MANGOLDT_ZERO; | |
| BOUNDED_DIRICHLET_MANGOLDT_NONZERO; LE_1]; | |
| ALL_TAC] THEN | |
| SIMP_TAC[VSUM_SUB; FINITE_DIRICHLET_CHARACTERS; VSUM_COMPLEX_LMUL] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP BOUNDED_DIFF_LOGMUL) THEN | |
| REWRITE_TAC[IN_UNIV] THEN ANTS_TAC THENL | |
| [X_GEN_TAC `x:num` THEN | |
| W(MP_TAC o PART_MATCH (lhs o rand) VSUM_SWAP o funpow 2 rand o snd) THEN | |
| REWRITE_TAC[FINITE_DIRICHLET_CHARACTERS; FINITE_NUMSEG] THEN | |
| DISCH_THEN SUBST1_TAC THEN | |
| SIMP_TAC[VSUM_COMPLEX_RMUL; FINITE_DIRICHLET_CHARACTERS] THEN | |
| SIMP_TAC[RE_VSUM; FINITE_NUMSEG; RE_MUL_CX] THEN | |
| MATCH_MP_TAC SUM_POS_LE_NUMSEG THEN | |
| X_GEN_TAC `n:num` THEN STRIP_TAC THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC REAL_LE_MUL THEN | |
| SIMP_TAC[DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS_POS; | |
| REAL_LE_DIV; REAL_POS; MANGOLDT_POS_LE]; | |
| ALL_TAC] THEN | |
| SIMP_TAC[RE_VSUM; FINITE_DIRICHLET_CHARACTERS] THEN | |
| REPLICATE_TAC 2 (ONCE_REWRITE_TAC[COND_RAND]) THEN | |
| REWRITE_TAC[RE_NEG; RE_CX] THEN DISCH_TAC THEN | |
| X_GEN_TAC `c:num->complex` THEN STRIP_TAC THEN STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [GSYM REAL_NOT_LT]) THEN | |
| REWRITE_TAC[] THEN | |
| SUBGOAL_THEN | |
| `{chi_0 d,c,(\n. cnj(c n))} SUBSET {c | dirichlet_character d c}` | |
| MP_TAC THENL | |
| [REWRITE_TAC[SUBSET; IN_ELIM_THM; IN_INSERT; NOT_IN_EMPTY] THEN | |
| REPEAT STRIP_TAC THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_CHI_0; DIRICHLET_CHARACTER_CNJ]; | |
| ALL_TAC] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP lemma) THEN | |
| REWRITE_TAC[FINITE_DIRICHLET_CHARACTERS] THEN | |
| DISCH_THEN(fun th -> REWRITE_TAC[th]) THEN | |
| MATCH_MP_TAC(REAL_ARITH `s <= &0 /\ t < &0 ==> s + t < &0`) THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC(REAL_ARITH `&0 <= --x ==> x <= &0`) THEN | |
| REWRITE_TAC[GSYM SUM_NEG] THEN MATCH_MP_TAC SUM_POS_LE THEN | |
| SIMP_TAC[FINITE_DIRICHLET_CHARACTERS; FINITE_DIFF] THEN | |
| SIMP_TAC[IN_DIFF; IN_INSERT; NOT_IN_EMPTY; DE_MORGAN_THM] THEN | |
| REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[SUM_CLAUSES; FINITE_INSERT; IN_INSERT; NOT_IN_EMPTY; | |
| FINITE_RULES] THEN | |
| SUBGOAL_THEN `~(chi_0 d = (\n. cnj (c n)))` ASSUME_TAC THENL | |
| [DISCH_THEN(MP_TAC o AP_TERM `(\c n:num. cnj(c n))`) THEN | |
| REWRITE_TAC[CNJ_CNJ; FUN_EQ_THM; CNJ_CHI_0] THEN | |
| ASM_REWRITE_TAC[GSYM FUN_EQ_THM; ETA_AX]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `~(c = \n:num. cnj(c n))` ASSUME_TAC THENL | |
| [ONCE_REWRITE_TAC[EQ_SYM_EQ] THEN | |
| REWRITE_TAC[GSYM REAL_CNJ; FUN_EQ_THM] THEN | |
| ASM_MESON_TAC[LFUNCTION_NONZERO_REAL]; | |
| ALL_TAC] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] LFUNCTION_CNJ) THEN | |
| ASM_SIMP_TAC[CNJ_EQ_CX] THEN REAL_ARITH_TAC);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Hence derive our boundedness result for all nonprincipal characters. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let BOUNDED_DIRICHLET_MANGOLDT_NONPRINCIPAL = prove | |
| (`!d c. | |
| dirichlet_character d c /\ ~(c = chi_0 d) | |
| ==> bounded { vsum(1..x) (\n. c n * Cx(mangoldt n / &n)) | x IN (:num)}`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC BOUNDED_DIRICHLET_MANGOLDT_NONZERO THEN | |
| EXISTS_TAC `d:num` THEN | |
| ASM_MESON_TAC[LFUNCTION_NONZERO_NONPRINCIPAL]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Hence the main sum result. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let BOUNDED_SUM_OVER_DIRICHLET_CHARACTERS = prove | |
| (`!d l. 1 <= d /\ coprime(l,d) | |
| ==> bounded { vsum {c | dirichlet_character d c} | |
| (\c. c(l) * | |
| vsum(1..x) (\n. c n * Cx (mangoldt n / &n))) - | |
| Cx(log(&x)) | x IN (:num)}`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[] THEN | |
| SUBGOAL_THEN `!x. Cx(log(&x)) = | |
| vsum {c | dirichlet_character d c} | |
| (\c. if c = chi_0 d then Cx(log(&x)) else Cx(&0))` | |
| (fun th -> ONCE_REWRITE_TAC[th]) | |
| THENL | |
| [SIMP_TAC[VSUM_DELTA; GSYM COMPLEX_VEC_0] THEN | |
| REWRITE_TAC[IN_ELIM_THM; DIRICHLET_CHARACTER_CHI_0]; | |
| ALL_TAC] THEN | |
| SIMP_TAC[GSYM VSUM_SUB; FINITE_DIRICHLET_CHARACTERS] THEN | |
| MATCH_MP_TAC BOUNDED_SUMS_IMAGES THEN | |
| REWRITE_TAC[FINITE_DIRICHLET_CHARACTERS; IN_ELIM_THM] THEN | |
| X_GEN_TAC `c:num->complex` THEN DISCH_TAC THEN | |
| ASM_CASES_TAC `c = chi_0 d` THEN ASM_REWRITE_TAC[] THENL | |
| [FIRST_ASSUM(MP_TAC o MATCH_MP BOUNDED_DIRICHLET_MANGOLDT_PRINCIPAL) THEN | |
| ASM_REWRITE_TAC[chi_0; COMPLEX_MUL_LID]; | |
| REWRITE_TAC[COMPLEX_SUB_RZERO] THEN | |
| MP_TAC(SPECL [`d:num`; `c:num->complex`] | |
| BOUNDED_DIRICHLET_MANGOLDT_NONPRINCIPAL) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[BOUNDED_POS] THEN MATCH_MP_TAC MONO_EXISTS THEN | |
| ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN | |
| REWRITE_TAC[FORALL_IN_IMAGE; IN_ELIM_THM; IN_UNIV] THEN | |
| REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[COMPLEX_NORM_MUL] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_MUL_LID] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN ASM_REWRITE_TAC[NORM_POS_LE] THEN | |
| FIRST_ASSUM(fun th -> SIMP_TAC[MATCH_MP DIRICHLET_CHARACTER_NORM th]) THEN | |
| REAL_ARITH_TAC]);; | |
| let DIRICHLET_MANGOLDT = prove | |
| (`!d k. 1 <= d /\ coprime(k,d) | |
| ==> bounded { Cx(&(phi d)) * vsum {n | n IN 1..x /\ (n == k) (mod d)} | |
| (\n. Cx(mangoldt n / &n)) - | |
| Cx(log(&x)) | x IN (:num)}`, | |
| REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `?l. (k * l == 1) (mod d)` CHOOSE_TAC THENL | |
| [ASM_MESON_TAC[CONG_SOLVE]; ALL_TAC] THEN | |
| MP_TAC(SPECL [`d:num`; `l:num`] BOUNDED_SUM_OVER_DIRICHLET_CHARACTERS) THEN | |
| ANTS_TAC THENL | |
| [ASM_REWRITE_TAC[] THEN UNDISCH_TAC `(k * l == 1) (mod d)` THEN | |
| CONV_TAC NUMBER_RULE; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC EQ_IMP THEN AP_TERM_TAC THEN | |
| MATCH_MP_TAC(SET_RULE | |
| `(!x. x IN s ==> f x = g x) ==> {f x | x IN s} = {g x | x IN s}`) THEN | |
| X_GEN_TAC `x:num` THEN DISCH_THEN(K ALL_TAC) THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| SIMP_TAC[GSYM VSUM_COMPLEX_LMUL; FINITE_NUMSEG; FINITE_RESTRICT] THEN | |
| SIMP_TAC[VSUM_RESTRICT_SET; FINITE_NUMSEG] THEN | |
| W(MP_TAC o PART_MATCH (lhs o rand) VSUM_SWAP o lhand o snd) THEN | |
| REWRITE_TAC[FINITE_DIRICHLET_CHARACTERS; FINITE_NUMSEG] THEN | |
| DISCH_THEN SUBST1_TAC THEN MATCH_MP_TAC VSUM_EQ_NUMSEG THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN REWRITE_TAC[COMPLEX_MUL_ASSOC] THEN | |
| MP_TAC(GSYM(SPEC `d:num` DIRICHLET_CHARACTER_MUL)) THEN | |
| SIMP_TAC[IN_ELIM_THM] THEN DISCH_THEN(K ALL_TAC) THEN | |
| SIMP_TAC[VSUM_COMPLEX_RMUL; FINITE_DIRICHLET_CHARACTERS] THEN | |
| ASM_SIMP_TAC[DIRICHLET_CHARACTER_SUM_OVER_CHARACTERS] THEN | |
| SUBGOAL_THEN `(l * n == 1) (mod d) <=> (n == k) (mod d)` SUBST1_TAC THENL | |
| [UNDISCH_TAC `(k * l == 1) (mod d)` THEN CONV_TAC NUMBER_RULE; | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[COMPLEX_MUL_LZERO; COMPLEX_VEC_0]]);; | |
| let DIRICHLET_MANGOLDT_EXPLICIT = prove | |
| (`!d k. 1 <= d /\ coprime (k,d) | |
| ==> ?B. &0 < B /\ | |
| !x. abs(sum {n | n IN 1..x /\ (n == k) (mod d)} | |
| (\n. mangoldt n / &n) - | |
| log(&x) / &(phi d)) <= B`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP DIRICHLET_MANGOLDT) THEN | |
| REWRITE_TAC[BOUNDED_POS] THEN | |
| SIMP_TAC[SIMPLE_IMAGE; FORALL_IN_IMAGE; IN_UNIV] THEN | |
| SIMP_TAC[VSUM_CX; FINITE_RESTRICT; FINITE_NUMSEG; | |
| GSYM CX_SUB; GSYM CX_MUL; COMPLEX_NORM_CX] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `B / &(phi d)` THEN | |
| ASM_SIMP_TAC[REAL_LT_DIV; REAL_OF_NUM_LT; LE_1; PHI_LOWERBOUND_1_STRONG; | |
| REAL_LE_RDIV_EQ] THEN | |
| X_GEN_TAC `n:num` THEN | |
| GEN_REWRITE_TAC (LAND_CONV o RAND_CONV) [GSYM REAL_ABS_NUM] THEN | |
| REWRITE_TAC[GSYM REAL_ABS_MUL] THEN ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN | |
| ASM_SIMP_TAC[REAL_SUB_LDISTRIB; REAL_DIV_LMUL; | |
| LE_1; PHI_LOWERBOUND_1_STRONG; REAL_OF_NUM_EQ]);; | |
| let DIRICHLET_STRONG = prove | |
| (`!d k. 1 <= d /\ coprime(k,d) | |
| ==> ?B. &0 < B /\ | |
| !x. abs(sum {p | p IN 1..x /\ prime p /\ (p == k) (mod d)} | |
| (\p. log(&p) / &p) - | |
| log(&x) / &(phi d)) <= B`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| FIRST_ASSUM(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC o | |
| MATCH_MP DIRICHLET_MANGOLDT_EXPLICIT) THEN | |
| EXISTS_TAC `B + &3` THEN CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| X_GEN_TAC `x:num` THEN FIRST_X_ASSUM(MP_TAC o SPEC `x:num`) THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `abs(x - y) <= a ==> abs(x - z) <= b ==> abs(y - z) <= b + a`) THEN | |
| MP_TAC(SPECL [`x:num`; `{n | n IN 1..x /\ (n == k) (mod d)}`] | |
| MERTENS_MANGOLDT_VERSUS_LOG) THEN | |
| SIMP_TAC[SUBSET; IN_ELIM_THM] THEN REWRITE_TAC[CONJ_ACI]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Ignore the density details and prove the main result. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let DIRICHLET = prove | |
| (`!d k. 1 <= d /\ coprime(k,d) | |
| ==> INFINITE {p | prime p /\ (p == k) (mod d)}`, | |
| REWRITE_TAC[INFINITE] THEN REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM(MP_TAC o SPEC `\n:num. n` o MATCH_MP UPPER_BOUND_FINITE_SET) THEN | |
| REWRITE_TAC[IN_ELIM_THM; NOT_EXISTS_THM] THEN X_GEN_TAC `n:num` THEN | |
| DISCH_TAC THEN MP_TAC(SPECL [`d:num`; `k:num`] DIRICHLET_STRONG) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| MP_TAC(SPEC | |
| `max (exp(&(phi d) * | |
| (&1 + B + sum {p | p IN 1..n /\ prime p /\ (p == k) (mod d)} | |
| (\p. log(&p) / &p)))) | |
| (max (&n) (&1))` | |
| REAL_ARCH_SIMPLE) THEN | |
| REWRITE_TAC[NOT_EXISTS_THM; REAL_MAX_LE; REAL_OF_NUM_LE] THEN | |
| X_GEN_TAC `m:num` THEN STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `m:num`) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (REAL_ARITH | |
| `abs(x - y) <= b ==> y < &1 + b + x`)) THEN | |
| ASM_SIMP_TAC[REAL_NOT_LT; REAL_LE_RDIV_EQ; PHI_LOWERBOUND_1_STRONG; | |
| REAL_OF_NUM_LT; LE_1] THEN | |
| ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN | |
| ONCE_REWRITE_TAC[GSYM REAL_EXP_MONO_LE] THEN | |
| ASM_SIMP_TAC[EXP_LOG; REAL_OF_NUM_LT; LE_1] THEN | |
| FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH | |
| `x <= a ==> x = y ==> y <= a`)) THEN | |
| REPLICATE_TAC 4 AP_TERM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[EXTENSION; IN_ELIM_THM; IN_NUMSEG] THEN | |
| GEN_TAC THEN EQ_TAC THEN ASM_SIMP_TAC[] THEN ASM_ARITH_TAC);; | |