Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
| (* ========================================================================= *) | |
| (* The real and complex gamma functions and Euler-Mascheroni constant. *) | |
| (* ========================================================================= *) | |
| needs "Multivariate/cauchy.ml";; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Euler-Mascheroni constant. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let euler_mascheroni = new_definition | |
| `euler_mascheroni = | |
| reallim sequentially (\n. sum(1..n) (\k. inv(&k)) - log(&n))`;; | |
| let EULER_MASCHERONI = prove | |
| (`((\n. sum(1..n) (\k. inv(&k)) - log(&n)) ---> euler_mascheroni) | |
| sequentially`, | |
| REWRITE_TAC[euler_mascheroni; reallim] THEN CONV_TAC SELECT_CONV THEN | |
| SUBGOAL_THEN | |
| `real_summable (from 1) (\k. inv(&k) + (log(&k) - log(&(k + 1))))` | |
| MP_TAC THENL | |
| [MATCH_MP_TAC REAL_SUMMABLE_COMPARISON THEN | |
| EXISTS_TAC `\k. &2 / &k pow 2` THEN CONJ_TAC THENL | |
| [REWRITE_TAC[real_div] THEN MATCH_MP_TAC REAL_SUMMABLE_LMUL THEN | |
| MATCH_MP_TAC REAL_SUMMABLE_ZETA_INTEGER THEN REWRITE_TAC[LE_REFL]; | |
| EXISTS_TAC `2` THEN REWRITE_TAC[GE; IN_FROM] THEN | |
| X_GEN_TAC `n:num` THEN STRIP_TAC THEN | |
| ONCE_REWRITE_TAC[REAL_ARITH `a + (b - c):real = a - (c - b)`] THEN | |
| ASM_SIMP_TAC[GSYM LOG_DIV; REAL_OF_NUM_LT; LE_1; | |
| ARITH_RULE `0 < n + 1`] THEN | |
| ASM_SIMP_TAC[GSYM REAL_OF_NUM_ADD; REAL_OF_NUM_LT; LE_1; REAL_FIELD | |
| `&0 < n ==> (n + &1) / n = &1 + inv(n)`] THEN | |
| MP_TAC(ISPECL [`1`; `Cx(inv(&n))`] TAYLOR_CLOG)]; | |
| REWRITE_TAC[real_summable; real_sums; FROM_INTER_NUMSEG] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `g:real` THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REALLIM_TRANSFORM) THEN | |
| REWRITE_TAC[SUM_ADD_NUMSEG; REAL_ARITH | |
| `(x + y) - (x - z):real = y + z`] THEN | |
| REWRITE_TAC[SUM_DIFFS; LOG_1; COND_RAND; COND_RATOR] THEN | |
| REWRITE_TAC[REAL_ARITH `&0 - x + y = --(x - y)`] THEN | |
| MATCH_MP_TAC REALLIM_NULL_COMPARISON THEN | |
| EXISTS_TAC `\n. &2 / &n` THEN CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `2` THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| COND_CASES_TAC THENL [ALL_TAC; ASM_ARITH_TAC] THEN | |
| ASM_SIMP_TAC[REAL_ABS_NEG; GSYM LOG_DIV; REAL_OF_NUM_LT; LE_1; | |
| ARITH_RULE `0 < n + 1`] THEN | |
| ASM_SIMP_TAC[GSYM REAL_OF_NUM_ADD; REAL_OF_NUM_LT; LE_1; REAL_FIELD | |
| `&0 < n ==> (n + &1) / n = &1 + inv(n)`] THEN | |
| MP_TAC(ISPECL [`0`; `Cx(inv(&n))`] TAYLOR_CLOG); | |
| REWRITE_TAC[real_div] THEN MATCH_MP_TAC REALLIM_NULL_LMUL THEN | |
| REWRITE_TAC[REALLIM_1_OVER_N]]] THEN | |
| REWRITE_TAC[GSYM CX_ADD; VSUM_SING_NUMSEG; COMPLEX_NORM_CX] THEN | |
| REWRITE_TAC[VSUM_CLAUSES_NUMSEG] THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[REAL_ABS_INV; REAL_ABS_NUM; COMPLEX_DIV_1] THEN | |
| ASM_SIMP_TAC[COMPLEX_POW_1; REAL_INV_LT_1; REAL_OF_NUM_LT; | |
| ARITH_RULE `1 < n <=> 2 <= n`] THEN | |
| REWRITE_TAC[COMPLEX_POW_2; COMPLEX_MUL_LNEG; COMPLEX_MUL_LID] THEN | |
| ASM_SIMP_TAC[COMPLEX_NEG_NEG; GSYM CX_LOG; REAL_LT_ADD; REAL_OF_NUM_LT; | |
| LE_1; ARITH; REAL_LT_INV_EQ; GSYM CX_SUB] THEN | |
| REWRITE_TAC[REAL_POW_1; VECTOR_SUB_RZERO] THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX] THEN REWRITE_TAC[REAL_ABS_SUB] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN | |
| REWRITE_TAC[real_div; REAL_POW_INV] THEN | |
| GEN_REWRITE_TAC RAND_CONV [REAL_MUL_SYM] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN | |
| SIMP_TAC[REAL_LE_INV_EQ; REAL_POW_LE; REAL_POS] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_INV_INV] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[REAL_ARITH `&1 / &2 <= &1 - &1 / n <=> inv(n) <= inv(&2)`] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN | |
| REWRITE_TAC[REAL_OF_NUM_LE; REAL_OF_NUM_LT] THEN ASM_ARITH_TAC);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Simple-minded estimation of gamma using Euler-Maclaurin summation. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let LOG2_APPROX_40 = prove | |
| (`abs(log(&2) - &381061692393 / &549755813888) <= inv(&2 pow 40)`, | |
| MP_TAC(SPECL [`41`; `Cx(--inv(&2))`] TAYLOR_CLOG) THEN | |
| SIMP_TAC[GSYM CX_DIV; GSYM CX_POW; GSYM CX_NEG; GSYM CX_ADD; GSYM CX_MUL; | |
| VSUM_CX; COMPLEX_NORM_CX; GSYM CX_LOG; GSYM CX_SUB; | |
| REAL_ARITH `&0 < &1 + --inv(&2)`] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[REAL_ARITH `a * b / c:real = a / c * b`] THEN | |
| CONV_TAC(ONCE_DEPTH_CONV EXPAND_SUM_CONV) THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID] THEN | |
| SIMP_TAC[LOG_INV; REAL_ARITH `&0 < &2`] THEN REAL_ARITH_TAC);; | |
| let EULER_MASCHERONI_APPROX_32 = prove | |
| (`abs(euler_mascheroni - &2479122403 / &4294967296) <= inv(&2 pow 32)`, | |
| let lemma1 = prove | |
| (`!m n. 1 <= m /\ m <= n | |
| ==> abs((sum (1..n) (\k. inv(&k)) - log(&n)) - | |
| ((sum (1..m - 1) (\k. inv(&k)) - log(&m)) + | |
| (inv(&m) + inv(&n)) / &2 + | |
| &1 / &12 * (inv(&m pow 2) - inv(&n pow 2)) + | |
| -- &1 / &120 * (inv(&m pow 4) - inv(&n pow 4)))) | |
| <= inv(&60 * &m pow 5)`, | |
| REPEAT STRIP_TAC THEN | |
| MP_TAC(SPECL [`\k. inv(&k)`; `1:num`; `m - 1`; `n:num`] SUM_COMBINE_R) THEN | |
| ANTS_TAC THENL [ASM_ARITH_TAC; DISCH_THEN(SUBST1_TAC o SYM)] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `1 <= m ==> m - 1 + 1 = m`] THEN | |
| MP_TAC(ISPECL | |
| [`\n x. --(&1) pow n * &(FACT n) / x pow (n + 1)`; | |
| `m:num`; `n:num`; `2`] REAL_EULER_MACLAURIN) THEN | |
| ASM_REWRITE_TAC[] THEN CONV_TAC NUM_REDUCE_CONV THEN ANTS_TAC THENL | |
| [REWRITE_TAC[IN_REAL_INTERVAL] THEN REPEAT | |
| STRIP_TAC THEN REAL_DIFF_TAC THEN | |
| REWRITE_TAC[REAL_MUL_LZERO; ADD_SUB; REAL_MUL_RID; REAL_SUB_LZERO] THEN | |
| REWRITE_TAC[real_div; GSYM REAL_MUL_ASSOC; REAL_POW_EQ_0; | |
| REAL_MUL_LNEG; REAL_MUL_RNEG] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[GSYM REAL_OF_NUM_LE]) THEN | |
| ASM_CASES_TAC `x = &0` THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[GSYM real_div; REAL_POW_POW] THEN | |
| ASM_SIMP_TAC[REAL_DIV_POW2_ALT; ARITH_RULE `~((k + 1) * 2 < k)`] THEN | |
| REWRITE_TAC[ARITH_RULE `(k + 1) * 2 - k = SUC(SUC k)`; | |
| ARITH_RULE `(k + 1) + 1 = SUC(SUC k)`] THEN | |
| REWRITE_TAC[REAL_POW_ADD; REAL_POW_1] THEN | |
| REWRITE_TAC[REAL_MUL_RNEG; REAL_MUL_LNEG; REAL_MUL_RID] THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN REWRITE_TAC[real_div] THEN | |
| REWRITE_TAC[REAL_MUL_ASSOC] THEN AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[GSYM ADD1; FACT; REAL_OF_NUM_MUL; MULT_AC]; | |
| DISCH_THEN(MP_TAC o CONJUNCT2) THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID; real_pow] THEN | |
| CONV_TAC(ONCE_DEPTH_CONV EXPAND_SUM_CONV) THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN | |
| CONV_TAC(ONCE_DEPTH_CONV BERNOULLI_CONV) THEN | |
| REWRITE_TAC[GSYM(BERNOULLI_CONV `bernoulli 5 x`)] THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[REAL_MUL_LNEG; REAL_MUL_LID; REAL_POW_1] THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID] THEN DISCH_THEN SUBST1_TAC] THEN | |
| MP_TAC(ISPECL [`\x. log x`; `\x:real. inv x`; `&m`; `&n`] | |
| REAL_FUNDAMENTAL_THEOREM_OF_CALCULUS) THEN | |
| ASM_REWRITE_TAC[REAL_OF_NUM_ADD; REAL_OF_NUM_LE] THEN | |
| ANTS_TAC THENL | |
| [REWRITE_TAC[IN_REAL_INTERVAL; GSYM REAL_OF_NUM_ADD] THEN | |
| REPEAT STRIP_TAC THEN REAL_DIFF_TAC THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[GSYM REAL_OF_NUM_LE]) THEN | |
| ASM_REAL_ARITH_TAC; | |
| DISCH_THEN(SUBST1_TAC o MATCH_MP REAL_INTEGRAL_UNIQUE)] THEN | |
| MATCH_MP_TAC REAL_LE_TRANS THEN | |
| EXISTS_TAC | |
| `&1 / &120 * | |
| abs(real_integral (real_interval[&m,&n]) | |
| (\x. bernoulli 5 (frac x) * | |
| --(&120 * inv(x pow 6))))` THEN | |
| CONJ_TAC THENL [REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[REAL_ARITH `b * --(n * inv x):real = --n * b / x`] THEN | |
| SUBGOAL_THEN | |
| `(\x. bernoulli 5 (frac x) / x pow 6) | |
| real_measurable_on real_interval[&m,&n]` | |
| ASSUME_TAC THENL | |
| [MATCH_MP_TAC | |
| REAL_CONTINUOUS_AE_IMP_MEASURABLE_ON_LEBESGUE_MEASURABLE_SUBSET THEN | |
| EXISTS_TAC `integer` THEN | |
| REWRITE_TAC[REAL_LEBESGUE_MEASURABLE_INTERVAL] THEN | |
| SIMP_TAC[REAL_NEGLIGIBLE_COUNTABLE; COUNTABLE_INTEGER] THEN | |
| REWRITE_TAC[REAL_CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN | |
| REWRITE_TAC[IN_DIFF; IN_REAL_INTERVAL] THEN REWRITE_TAC[IN] THEN | |
| X_GEN_TAC `x:real` THEN STRIP_TAC THEN | |
| MATCH_MP_TAC REAL_CONTINUOUS_ATREAL_WITHINREAL THEN | |
| MATCH_MP_TAC REAL_DIFFERENTIABLE_IMP_CONTINUOUS_ATREAL THEN | |
| REAL_DIFFERENTIABLE_TAC THEN ASM_REWRITE_TAC[REAL_POW_EQ_0] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[GSYM REAL_OF_NUM_LE]) THEN | |
| ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MP_TAC(ISPECL | |
| [`\x. inv(-- &60 * x pow 5)`; `\x. inv(&12 * x pow 6)`; | |
| `&m`; `&n`] REAL_FUNDAMENTAL_THEOREM_OF_CALCULUS) THEN | |
| ASM_REWRITE_TAC[REAL_OF_NUM_LE] THEN ANTS_TAC THENL | |
| [REWRITE_TAC[IN_REAL_INTERVAL] THEN REPEAT STRIP_TAC THEN | |
| REAL_DIFF_TAC THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| SUBGOAL_THEN `~(x = &0)` MP_TAC THENL | |
| [RULE_ASSUM_TAC(REWRITE_RULE[GSYM REAL_OF_NUM_LE]) THEN | |
| ASM_REAL_ARITH_TAC; | |
| CONV_TAC REAL_FIELD]; | |
| REWRITE_TAC[REAL_INV_MUL; REAL_ARITH | |
| `inv(-- &60) * x - inv(-- &60) * y = (y - x) / &60`] THEN | |
| REWRITE_TAC[GSYM REAL_INV_MUL] THEN DISCH_TAC] THEN | |
| SUBGOAL_THEN | |
| `!x. x IN real_interval[&m,&n] | |
| ==> abs(bernoulli 5 (frac x) / x pow 6) <= inv(&12 * x pow 6)` | |
| ASSUME_TAC THENL | |
| [REWRITE_TAC[IN_REAL_INTERVAL] THEN REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[REAL_INV_MUL; real_div; REAL_ABS_MUL] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN REWRITE_TAC[REAL_ABS_POS] THEN | |
| CONJ_TAC THENL | |
| [MP_TAC(ISPECL [`5`; `frac x`] BERNOULLI_BOUND) THEN | |
| SIMP_TAC[IN_REAL_INTERVAL; FLOOR_FRAC; REAL_LT_IMP_LE] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[BERNOULLI_CONV `bernoulli 4 (&0)`] THEN | |
| REAL_ARITH_TAC; | |
| REWRITE_TAC[REAL_ARITH `abs x <= x <=> &0 <= x`] THEN | |
| REWRITE_TAC[REAL_LE_INV_EQ] THEN MATCH_MP_TAC REAL_POW_LE THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[GSYM REAL_OF_NUM_LE]) THEN | |
| ASM_REAL_ARITH_TAC]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `(\x. bernoulli 5 (frac x) / x pow 6) | |
| real_integrable_on real_interval[&m,&n]` | |
| ASSUME_TAC THENL | |
| [MATCH_MP_TAC REAL_MEASURABLE_BOUNDED_BY_INTEGRABLE_IMP_INTEGRABLE THEN | |
| EXISTS_TAC `\x:real. inv(&12 * x pow 6)` THEN | |
| ASM_REWRITE_TAC[REAL_INTEGRABLE_CONST] THEN | |
| ASM_MESON_TAC[real_integrable_on]; | |
| ASM_SIMP_TAC[REAL_INTEGRAL_LMUL; REAL_ABS_MUL; REAL_MUL_ASSOC]] THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN REWRITE_TAC[REAL_MUL_LID] THEN | |
| TRANS_TAC REAL_LE_TRANS | |
| `real_integral (real_interval [&m,&n]) (\x. inv(&12 * x pow 6))` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_INTEGRAL_ABS_BOUND_INTEGRAL THEN | |
| ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[real_integrable_on]; | |
| FIRST_ASSUM(SUBST1_TAC o MATCH_MP REAL_INTEGRAL_UNIQUE) THEN | |
| REWRITE_TAC[REAL_INV_MUL] THEN | |
| REWRITE_TAC[REAL_LE_INV_EQ; REAL_ARITH | |
| `(x - y) / &60 <= inv(&60) * x <=> &0 <= y`] THEN | |
| SIMP_TAC[REAL_POW_LE; REAL_POS]]) | |
| and lemma2 = prove | |
| (`!f g l m d e k. | |
| (f ---> l) sequentially | |
| ==> (g ---> m) sequentially /\ | |
| eventually (\n. abs(f n - g n) <= d) sequentially /\ | |
| abs(m - k) <= e - d | |
| ==> abs(l - k) <= e`, | |
| REPEAT GEN_TAC THEN DISCH_TAC THEN | |
| REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `abs(l - m) <= d ==> abs (m - k) <= e - d ==> abs (l - k) <= e`) THEN | |
| REWRITE_TAC[REAL_ABS_BOUNDS] THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC(ISPEC `sequentially` REALLIM_LBOUND); | |
| MATCH_MP_TAC(ISPEC `sequentially` REALLIM_UBOUND)] THEN | |
| EXISTS_TAC `(\n. f n - g n):num->real` THEN | |
| ASM_SIMP_TAC[REALLIM_SUB; TRIVIAL_LIMIT_SEQUENTIALLY] THEN | |
| FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (ONCE_REWRITE_RULE[IMP_CONJ_ALT] | |
| EVENTUALLY_MONO)) THEN | |
| REAL_ARITH_TAC) in | |
| MATCH_MP_TAC(MATCH_MP lemma2 EULER_MASCHERONI) THEN | |
| MATCH_MP_TAC(MESON[] | |
| `(?a b c m:num. P (a m) (b m) (c m)) ==> ?a b c. P a b c`) THEN | |
| EXISTS_TAC | |
| `\m n. (sum(1..m - 1) (\k. inv(&k)) - log(&m)) + | |
| (inv(&m) + inv(&n)) / &2 + | |
| &1 / &12 * (inv(&m pow 2) - inv(&n pow 2)) + | |
| -- &1 / &120 * (inv(&m pow 4) - inv(&n pow 4))` THEN | |
| EXISTS_TAC | |
| `\m. (sum(1..m - 1) (\k. inv(&k)) - log(&m)) + | |
| inv(&m) / &2 + | |
| &1 / &12 * inv(&m pow 2) + | |
| -- &1 / &120 * inv(&m pow 4)` THEN | |
| EXISTS_TAC `\m. inv (&60 * &m pow 5)` THEN REWRITE_TAC[GSYM CONJ_ASSOC] THEN | |
| MATCH_MP_TAC(MESON[] `(!n. P n) /\ (?n. Q n) ==> (?n. P n /\ Q n)`) THEN | |
| REWRITE_TAC[] THEN REPEAT CONJ_TAC THENL | |
| [GEN_TAC THEN | |
| REPEAT(MATCH_MP_TAC REALLIM_ADD THEN CONJ_TAC) THEN | |
| REWRITE_TAC[REALLIM_CONST] THEN | |
| REWRITE_TAC[REAL_ARITH `x / &2 = inv(&2) * x`] THEN | |
| MATCH_MP_TAC REALLIM_LMUL THEN REWRITE_TAC[real_sub] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM REAL_ADD_RID] THEN | |
| MATCH_MP_TAC REALLIM_ADD THEN REWRITE_TAC[REALLIM_CONST] THEN | |
| REWRITE_TAC[REALLIM_NULL_NEG] THEN | |
| REWRITE_TAC[REALLIM_1_OVER_N] THEN | |
| MATCH_MP_TAC REALLIM_1_OVER_POW THEN CONV_TAC NUM_REDUCE_CONV; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| MATCH_MP_TAC(MESON[] `(?a. P a a /\ Q a) ==> ?a. (?b. P a b) /\ Q a`) THEN | |
| EXISTS_TAC `64` THEN CONJ_TAC THENL | |
| [REPEAT STRIP_TAC THEN MATCH_MP_TAC lemma1 THEN ASM_ARITH_TAC; ALL_TAC] THEN | |
| SUBGOAL_THEN `log(&64) = &6 * log(&2)` SUBST1_TAC THENL | |
| [SIMP_TAC[GSYM LOG_POW; REAL_ARITH `&0 < &2`] THEN | |
| AP_TERM_TAC THEN CONV_TAC REAL_RAT_REDUCE_CONV; | |
| CONV_TAC NUM_REDUCE_CONV THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| CONV_TAC(ONCE_DEPTH_CONV EXPAND_SUM_CONV) THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| MP_TAC LOG2_APPROX_40 THEN REAL_ARITH_TAC]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Start with the log-gamma function. It's otherwise quite tedious to repeat *) | |
| (* essentially the same argument when we want the logarithm of the gamma *) | |
| (* function, since we can't just take the usual principal value of log. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let lgamma = new_definition | |
| `lgamma z = lim sequentially | |
| (\n. z * clog(Cx(&n)) - clog z - | |
| vsum(1..n) (\m. clog((Cx(&m) + z) / Cx(&m))))`;; | |
| let LGAMMA,COMPLEX_DIFFERENTIABLE_AT_LGAMMA = (CONJ_PAIR o prove) | |
| (`(!z. (!n. ~(z + Cx(&n) = Cx(&0))) | |
| ==> ((\n. z * clog(Cx(&n)) - clog z - | |
| vsum(1..n) (\m. clog((Cx(&m) + z) / Cx(&m)))) | |
| --> lgamma(z)) sequentially) /\ | |
| (!z. (Im z = &0 ==> &0 < Re z) ==> lgamma complex_differentiable at z)`, | |
| SUBGOAL_THEN `open {z | !n. ~(z + Cx(&n) = Cx(&0))}` ASSUME_TAC THENL | |
| [REWRITE_TAC[SET_RULE `{z | !n. P n z} = UNIV DIFF {z | ?n. ~P n z}`] THEN | |
| REWRITE_TAC[GSYM closed] THEN MATCH_MP_TAC DISCRETE_IMP_CLOSED THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01; IMP_CONJ] THEN | |
| REWRITE_TAC[IN_ELIM_THM; LEFT_IMP_EXISTS_THM] THEN | |
| SIMP_TAC[COMPLEX_RING `x + y = Cx(&0) <=> x = --y`] THEN | |
| REWRITE_TAC[COMPLEX_RING `--x - --y:complex = y - x`] THEN | |
| REWRITE_TAC[COMPLEX_EQ_NEG2; CX_INJ; GSYM CX_SUB; COMPLEX_NORM_CX] THEN | |
| SIMP_TAC[GSYM REAL_EQ_INTEGERS; INTEGER_CLOSED]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `!y. (!n. ~(y + Cx(&n) = Cx(&0))) | |
| ==> ?d l. &0 < d /\ | |
| !e. &0 < e | |
| ==> ?N. !n z. N <= n /\ z IN cball(y,d) | |
| ==> dist(z * clog(Cx(&n)) - | |
| vsum(1..n) | |
| (\m. clog((Cx(&m) + z) / Cx(&m))), | |
| l z) < e` | |
| MP_TAC THENL | |
| [REPEAT STRIP_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [OPEN_CONTAINS_BALL]) THEN | |
| REWRITE_TAC[OPEN_CONTAINS_CBALL] THEN | |
| DISCH_THEN(MP_TAC o SPEC `y:complex`) THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `d:real` THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[UNIFORMLY_CONVERGENT_EQ_CAUCHY_ALT] THEN | |
| X_GEN_TAC `e:real` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN | |
| `summable (from 1) | |
| (\m. Cx(&2 * ((norm(y:complex) + d) + | |
| (norm(y) + d) pow 2)) / Cx(&m) pow 2)` | |
| MP_TAC THENL | |
| [REWRITE_TAC[complex_div; COMPLEX_MUL_ASSOC] THEN | |
| MATCH_MP_TAC SUMMABLE_COMPLEX_LMUL THEN | |
| MATCH_MP_TAC SUMMABLE_ZETA_INTEGER THEN REWRITE_TAC[LE_REFL]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[summable; SERIES_CAUCHY; GE] THEN | |
| DISCH_THEN(MP_TAC o SPEC `e:real`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `M:num` (LABEL_TAC "M")) THEN | |
| MP_TAC(SPEC `&2 * (norm(y:complex) + d) + &1` REAL_ARCH_SIMPLE) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `N:num` (LABEL_TAC "N")) THEN | |
| EXISTS_TAC `MAX (MAX 1 2) (MAX M N)` THEN | |
| MAP_EVERY X_GEN_TAC [`m:num`; `n:num`; `z:complex`] THEN | |
| REWRITE_TAC[GE; ARITH_RULE `MAX a b <= c <=> a <= c /\ b <= c`] THEN | |
| STRIP_TAC THEN FIRST_X_ASSUM(MP_TAC o SPECL [`m + 1`; `n:num`]) THEN | |
| ANTS_TAC THENL [ASM_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[FROM_INTER_NUMSEG_MAX; ARITH_RULE `MAX 1 (m + 1) = m + 1`] THEN | |
| REWRITE_TAC[dist] THEN | |
| SUBGOAL_THEN | |
| `!n. 1 <= n | |
| ==> z * clog(Cx(&n)) - vsum(1..n) (\m. clog((Cx(&m) + z) / Cx(&m))) = | |
| vsum(1..n) (\m. z * (clog(Cx(&(m + 1) - &1)) - | |
| clog(Cx(&m - &1))) - | |
| clog((Cx(&m) + z) / Cx(&m))) + | |
| z * clog(Cx(&0))` | |
| (fun th -> ASM_SIMP_TAC[th]) | |
| THENL | |
| [REWRITE_TAC[VSUM_SUB_NUMSEG] THEN | |
| ASM_SIMP_TAC[VSUM_COMPLEX_LMUL; FINITE_NUMSEG; VSUM_DIFFS_ALT] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_ADD; REAL_ARITH `(x + &1) - &1 = x`; | |
| REAL_SUB_REFL] THEN | |
| REPEAT STRIP_TAC THEN CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LET_TRANS) THEN | |
| SUBGOAL_THEN `1 <= m + 1 /\ m <= n` MP_TAC THENL | |
| [ASM_ARITH_TAC; | |
| DISCH_THEN(fun th -> REWRITE_TAC[GSYM(MATCH_MP VSUM_COMBINE_R th)])] THEN | |
| REWRITE_TAC[COMPLEX_RING `(x + a) - ((x + y) + a):complex = --y`] THEN | |
| REWRITE_TAC[NORM_NEG] THEN MATCH_MP_TAC COMPLEX_NORM_VSUM_BOUND THEN | |
| REWRITE_TAC[FINITE_NUMSEG; IN_NUMSEG] THEN X_GEN_TAC `k:num` THEN | |
| STRIP_TAC THEN REWRITE_TAC[GSYM CX_POW; GSYM CX_DIV; REAL_CX; RE_CX] THEN | |
| REWRITE_TAC[COMPLEX_RING `z * (a - b) - c:complex = --(z * (b - a) + c)`; | |
| NORM_NEG; GSYM REAL_OF_NUM_ADD; REAL_ARITH `(x + &1) - &1 = x`] THEN | |
| SUBGOAL_THEN `1 <= k /\ 1 < k /\ 2 <= k` STRIP_ASSUME_TAC THENL | |
| [ASM_ARITH_TAC; ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `clog(Cx(&k - &1)) - clog(Cx(&k)) = clog(Cx(&1) - inv(Cx(&k)))` | |
| SUBST1_TAC THENL | |
| [ASM_SIMP_TAC[GSYM CX_LOG; REAL_OF_NUM_LE; REAL_SUB_LT; REAL_INV_LT_1; | |
| REAL_ARITH `&2 <= x ==> &0 < x /\ &1 < x /\ &0 < x - &1`; | |
| GSYM CX_SUB; GSYM CX_INV; GSYM LOG_DIV] THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN UNDISCH_TAC `2 <= k` THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_LE] THEN CONV_TAC REAL_FIELD; | |
| ALL_TAC] THEN | |
| MP_TAC(ISPECL [`1`; `z / Cx(&k)`] TAYLOR_CLOG) THEN | |
| MP_TAC(ISPECL [`1`; `--inv(Cx(&k))`] TAYLOR_CLOG) THEN | |
| REWRITE_TAC[VSUM_SING_NUMSEG] THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[GSYM VECTOR_SUB; NORM_NEG] THEN | |
| REWRITE_TAC[COMPLEX_NORM_INV; COMPLEX_NORM_DIV; COMPLEX_NORM_CX] THEN | |
| REWRITE_TAC[COMPLEX_POW_NEG; ARITH; REAL_ABS_NUM; COMPLEX_POW_ONE] THEN | |
| ASM_SIMP_TAC[REAL_INV_LT_1; REAL_OF_NUM_LT; COMPLEX_DIV_1] THEN | |
| ASM_SIMP_TAC[REAL_LT_LDIV_EQ; REAL_OF_NUM_LT; LE_1; COMPLEX_POW_1] THEN | |
| REWRITE_TAC[REAL_MUL_LID; COMPLEX_MUL_LID] THEN | |
| DISCH_THEN(MP_TAC o SPEC `norm(z:complex)` o MATCH_MP | |
| (REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_LMUL)) THEN | |
| REWRITE_TAC[NORM_POS_LE; GSYM COMPLEX_NORM_MUL] THEN | |
| SUBGOAL_THEN `norm(z:complex) < &k` ASSUME_TAC THENL | |
| [FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [IN_CBALL]) THEN | |
| FIRST_X_ASSUM(K ALL_TAC o check (is_forall o concl)) THEN | |
| REPEAT(POP_ASSUM MP_TAC) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_LE; GSYM REAL_OF_NUM_ADD] THEN | |
| CONV_TAC NORM_ARITH; | |
| ASM_REWRITE_TAC[COMPLEX_SUB_LDISTRIB]] THEN | |
| ASM_SIMP_TAC[CX_INJ; REAL_OF_NUM_EQ; LE_1; COMPLEX_FIELD | |
| `~(k = Cx(&0)) ==> (k + z) / k = Cx(&1) + z / k`] THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `x' = --y' /\ d + e <= f | |
| ==> norm(x - x') <= d ==> norm(y - y') <= e | |
| ==> norm(x + y) <= f`) THEN | |
| REWRITE_TAC[complex_div; COMPLEX_MUL_LNEG; COMPLEX_MUL_RNEG] THEN | |
| REWRITE_TAC[REAL_POW_DIV; REAL_POW_INV; REAL_ARITH | |
| `n * inv k / d + n pow 2 / k / e <= (&2 * (x + x pow 2)) / k <=> | |
| (n * (&1 / d + n / e)) / k <= (x * (&2 + &2 * x)) / k`] THEN | |
| ASM_SIMP_TAC[REAL_LE_DIV2_EQ; REAL_OF_NUM_LT; LE_1; REAL_POW_LT] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN REWRITE_TAC[NORM_POS_LE] THEN | |
| SUBGOAL_THEN `norm(z:complex) <= norm(y:complex) + d` ASSUME_TAC THENL | |
| [FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [IN_CBALL]) THEN | |
| CONV_TAC NORM_ARITH; | |
| ALL_TAC] THEN | |
| REPEAT CONJ_TAC THENL | |
| [FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [IN_CBALL]) THEN | |
| CONV_TAC NORM_ARITH; | |
| MATCH_MP_TAC REAL_LE_ADD THEN CONJ_TAC THEN | |
| MATCH_MP_TAC REAL_LE_DIV THEN | |
| REWRITE_TAC[REAL_SUB_LE; NORM_POS_LE; REAL_POS] THEN | |
| REWRITE_TAC[REAL_ARITH `inv x = &1 / x`] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1]; | |
| REWRITE_TAC[REAL_ARITH `&2 + &2 * x = &1 * &2 + x * &2`] THEN | |
| ONCE_REWRITE_TAC[real_div] THEN MATCH_MP_TAC REAL_LE_ADD2 THEN | |
| CONJ_TAC THEN MATCH_MP_TAC REAL_LE_MUL2 THEN | |
| ASM_REWRITE_TAC[NORM_POS_LE; REAL_POS; REAL_LE_REFL; REAL_LE_INV_EQ] THEN | |
| REWRITE_TAC[REAL_SUB_LE] THEN | |
| REWRITE_TAC[REAL_ARITH `inv x = &1 / x`] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1] THEN | |
| ASM_REWRITE_TAC[REAL_MUL_LID; REAL_OF_NUM_LE] THEN | |
| TRY(CONJ_TAC THENL | |
| [RULE_ASSUM_TAC(REWRITE_RULE | |
| [GSYM REAL_OF_NUM_LT; GSYM REAL_OF_NUM_ADD]) THEN | |
| ASM_REAL_ARITH_TAC; ALL_TAC]) THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_INV_INV] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[REAL_ARITH `&1 / &2 <= &1 - x <=> x <= &1 / &2`] THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID] THEN REWRITE_TAC[GSYM real_div] THEN | |
| REWRITE_TAC[REAL_ARITH `inv x = &1 / x`] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_OF_NUM_LT; LE_1]] THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [IN_CBALL]) THEN | |
| FIRST_X_ASSUM(K ALL_TAC o check (is_forall o concl)) THEN | |
| REPEAT(POP_ASSUM MP_TAC) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_LE; GSYM REAL_OF_NUM_ADD] THEN | |
| CONV_TAC NORM_ARITH; | |
| GEN_REWRITE_TAC (LAND_CONV o REDEPTH_CONV) [RIGHT_IMP_EXISTS_THM] THEN | |
| REWRITE_TAC[SKOLEM_THM; LEFT_IMP_EXISTS_THM] THEN MAP_EVERY X_GEN_TAC | |
| [`dd:complex->real`; `ll:complex->complex->complex`] THEN | |
| DISCH_THEN(LABEL_TAC "*")] THEN | |
| SUBGOAL_THEN | |
| `!z. (!n. ~(z + Cx(&n) = Cx(&0))) | |
| ==> ((\n. z * clog(Cx(&n)) - | |
| vsum (1..n) (\m. clog((Cx(&m) + z) / Cx(&m)))) --> ll z z) | |
| sequentially` | |
| ASSUME_TAC THENL | |
| [X_GEN_TAC `z:complex` THEN DISCH_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `z:complex`) THEN | |
| ASM_REWRITE_TAC[LIM_SEQUENTIALLY; GSYM SKOLEM_THM] THEN | |
| MESON_TAC[CENTRE_IN_CBALL; REAL_LT_IMP_LE]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(TAUT `p /\ (p ==> q) ==> p /\ q`) THEN CONJ_TAC THENL | |
| [REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[lgamma; lim] THEN CONV_TAC SELECT_CONV THEN | |
| EXISTS_TAC `(ll:complex->complex->complex) z z - clog z` THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING `w - z - v:complex = (w - v) - z`] THEN | |
| MATCH_MP_TAC LIM_SUB THEN REWRITE_TAC[LIM_CONST] THEN ASM_MESON_TAC[]; | |
| DISCH_TAC] THEN | |
| X_GEN_TAC `z:complex` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `!n. ~(z + Cx(&n) = Cx(&0))` ASSUME_TAC THENL | |
| [GEN_TAC THEN | |
| REWRITE_TAC[COMPLEX_RING `z + x = Cx(&0) <=> z = --x`] THEN | |
| DISCH_THEN SUBST_ALL_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o check (is_imp o concl)) THEN | |
| REWRITE_TAC[IM_NEG; RE_NEG; IM_CX; RE_CX] THEN REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_TRANSFORM_AT THEN | |
| EXISTS_TAC `\z. (ll:complex->complex->complex) z z - clog z` THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [OPEN_CONTAINS_BALL]) THEN | |
| REWRITE_TAC[OPEN_CONTAINS_BALL] THEN | |
| DISCH_THEN(MP_TAC o SPEC `z:complex`) THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM; SUBSET; IN_BALL] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `e:real` THEN STRIP_TAC THEN | |
| ASM_REWRITE_TAC[] THEN CONJ_TAC THENL | |
| [X_GEN_TAC `w:complex` THEN ONCE_REWRITE_TAC[DIST_SYM] THEN DISCH_TAC THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` LIM_UNIQUE) THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN | |
| EXISTS_TAC `\n. w * clog(Cx(&n)) - clog w - | |
| vsum(1..n) (\m. clog((Cx(&m) + w) / Cx(&m)))` THEN | |
| ASM_SIMP_TAC[] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING `w - z - v:complex = (w - v) - z`] THEN | |
| MATCH_MP_TAC LIM_SUB THEN REWRITE_TAC[LIM_CONST] THEN ASM_MESON_TAC[]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_SUB THEN | |
| ASM_SIMP_TAC[COMPLEX_DIFFERENTIABLE_AT_CLOG] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_TRANSFORM_AT THEN | |
| EXISTS_TAC `(ll:complex->complex->complex) z` THEN | |
| EXISTS_TAC `min e (dd(z:complex))` THEN | |
| ASM_SIMP_TAC[REAL_LT_MIN] THEN CONJ_TAC THENL | |
| [X_GEN_TAC `w:complex` THEN ONCE_REWRITE_TAC[DIST_SYM] THEN | |
| STRIP_TAC THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` LIM_UNIQUE) THEN | |
| EXISTS_TAC `\n. w * clog(Cx(&n)) - | |
| vsum(1..n) (\m. clog((Cx(&m) + w) / Cx(&m)))` THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY; LIM_SEQUENTIALLY] THEN | |
| CONJ_TAC THEN X_GEN_TAC `r:real` THEN STRIP_TAC THENL | |
| [REMOVE_THEN "*" (MP_TAC o SPEC `z:complex`); | |
| REMOVE_THEN "*" (MP_TAC o SPEC `w:complex`)] THEN | |
| ASM_SIMP_TAC[] THEN | |
| REWRITE_TAC[GSYM SKOLEM_THM; RIGHT_EXISTS_IMP_THM] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC `r:real`)) THEN | |
| ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_EXISTS THEN | |
| REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| ASM_SIMP_TAC[CENTRE_IN_CBALL; REAL_LT_IMP_LE] THEN | |
| ASM_SIMP_TAC[IN_CBALL; REAL_LT_IMP_LE]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `open {z | Im z = &0 ==> &0 < Re z}` MP_TAC THENL | |
| [SUBGOAL_THEN | |
| `{z | Im z = &0 ==> &0 < Re z} = | |
| (:complex) DIFF ({z | Im z = &0} INTER {z | Re z <= &0})` | |
| (fun th -> SIMP_TAC[th; CLOSED_HALFSPACE_RE_LE; GSYM closed; | |
| CLOSED_HALFSPACE_IM_EQ; CLOSED_INTER]) THEN | |
| REWRITE_TAC[IN_ELIM_THM; IN_UNIV; IN_DIFF; IN_INTER; EXTENSION] THEN | |
| REAL_ARITH_TAC; | |
| REWRITE_TAC[OPEN_CONTAINS_CBALL; IN_ELIM_THM; SUBSET] THEN | |
| DISCH_THEN(MP_TAC o SPEC `z:complex`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `r:real` STRIP_ASSUME_TAC)] THEN | |
| SUBGOAL_THEN | |
| `(ll:complex->complex->complex) z continuous_on cball(z,min r (dd z)) /\ | |
| ll z holomorphic_on ball(z,min r (dd z))` | |
| MP_TAC THENL | |
| [MATCH_MP_TAC(ISPEC `sequentially` HOLOMORPHIC_UNIFORM_LIMIT) THEN | |
| EXISTS_TAC `\n z. z * clog(Cx(&n)) - | |
| vsum(1..n) (\m. clog((Cx(&m) + z) / Cx(&m)))` THEN | |
| ASM_REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY; EVENTUALLY_SEQUENTIALLY] THEN | |
| REWRITE_TAC[CBALL_MIN_INTER; IN_INTER] THEN | |
| CONJ_TAC THENL [ALL_TAC; SIMP_TAC[GSYM dist] THEN ASM_MESON_TAC[]] THEN | |
| EXISTS_TAC `1` THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| MATCH_MP_TAC(MESON[HOLOMORPHIC_ON_IMP_CONTINUOUS_ON; | |
| HOLOMORPHIC_ON_SUBSET] | |
| `t SUBSET s /\ f holomorphic_on s | |
| ==> f continuous_on s /\ f holomorphic_on t`) THEN | |
| REWRITE_TAC[BALL_SUBSET_CBALL; GSYM CBALL_MIN_INTER] THEN | |
| MATCH_MP_TAC HOLOMORPHIC_ON_SUB THEN | |
| SIMP_TAC[HOLOMORPHIC_ON_MUL; HOLOMORPHIC_ON_ID; | |
| HOLOMORPHIC_ON_CONST] THEN | |
| MATCH_MP_TAC HOLOMORPHIC_ON_VSUM THEN | |
| REWRITE_TAC[FINITE_NUMSEG; IN_NUMSEG] THEN | |
| X_GEN_TAC `m:num` THEN STRIP_TAC THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC HOLOMORPHIC_ON_COMPOSE THEN | |
| SIMP_TAC[HOLOMORPHIC_ON_ADD; HOLOMORPHIC_ON_ID; | |
| HOLOMORPHIC_ON_CONST; complex_div; HOLOMORPHIC_ON_MUL] THEN | |
| MATCH_MP_TAC HOLOMORPHIC_ON_CLOG THEN | |
| REWRITE_TAC[FORALL_IN_IMAGE; GSYM complex_div; IMP_CONJ] THEN | |
| ASM_SIMP_TAC[RE_DIV_CX; IM_DIV_CX; REAL_DIV_EQ_0; RE_ADD; IM_ADD] THEN | |
| X_GEN_TAC `w:complex` THEN DISCH_TAC THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_NZ; REAL_OF_NUM_LT; LE_1] THEN | |
| REWRITE_TAC[IM_CX; RE_CX; REAL_ADD_LID] THEN DISCH_TAC THEN | |
| MATCH_MP_TAC REAL_LT_DIV THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_NZ; REAL_OF_NUM_LT; LE_1] THEN | |
| MATCH_MP_TAC(REAL_ARITH `&0 < x ==> &0 < &m + x`) THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[CBALL_MIN_INTER; IN_INTER]) THEN | |
| ASM_MESON_TAC[]; | |
| SIMP_TAC[HOLOMORPHIC_ON_OPEN; OPEN_BALL; complex_differentiable] THEN | |
| DISCH_THEN(MATCH_MP_TAC o CONJUNCT2) THEN | |
| ASM_SIMP_TAC[CENTRE_IN_BALL; REAL_LT_MIN]]);; | |
| let LGAMMA_ALT = prove | |
| (`!z. (!n. ~(z + Cx(&n) = Cx(&0))) | |
| ==> ((\n. (z * clog(Cx(&n)) + clog(Cx(&(FACT n)))) - | |
| vsum(0..n) (\m. clog(Cx(&m) + z))) | |
| --> lgamma(z)) sequentially`, | |
| REPEAT STRIP_TAC THEN FIRST_ASSUM(MP_TAC o MATCH_MP LGAMMA) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM) THEN | |
| MATCH_MP_TAC LIM_EVENTUALLY THEN REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `1` THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| SIMP_TAC[VECTOR_SUB_EQ; VSUM_CLAUSES_LEFT; LE_0; COMPLEX_ADD_LID] THEN | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `a:complex = d - c ==> x - y - a = (x + c) - (y + d)`) THEN | |
| REWRITE_TAC[GSYM NPRODUCT_FACT; ADD_CLAUSES] THEN | |
| SIMP_TAC[REAL_OF_NUM_NPRODUCT; FINITE_NUMSEG; GSYM CX_LOG; LOG_PRODUCT; | |
| PRODUCT_POS_LT; IN_NUMSEG; REAL_OF_NUM_LT; LE_1; GSYM VSUM_CX] THEN | |
| REWRITE_TAC[GSYM VSUM_SUB_NUMSEG] THEN MATCH_MP_TAC VSUM_EQ_NUMSEG THEN | |
| REWRITE_TAC[complex_div] THEN ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN | |
| ASM_SIMP_TAC[CLOG_MUL_CX; REAL_LT_INV_EQ; REAL_OF_NUM_LT; LE_1; | |
| GSYM CX_INV; LOG_INV; CX_NEG; GSYM complex_sub]);; | |
| let LGAMMA_ALT2 = prove | |
| (`!z. (!n. ~(z + Cx(&n) = Cx(&0))) | |
| ==> ((\n. vsum(1..n) (\m. z * clog(Cx(&1) + Cx(&1) / Cx(&m)) - | |
| clog(Cx(&1) + z / Cx(&m))) - | |
| clog(z)) | |
| --> lgamma(z)) sequentially`, | |
| REPEAT STRIP_TAC THEN | |
| SIMP_TAC[CX_INJ; REAL_OF_NUM_EQ; LE_1; | |
| COMPLEX_FIELD `~(m = Cx(&0)) ==> Cx(&1) + z / m = (z + m) / m`] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_DIV] THEN | |
| SIMP_TAC[GSYM CX_LOG; LOG_DIV; REAL_LT_DIV; REAL_ARITH `&0 < &1 + &m`; | |
| REAL_OF_NUM_LT; LE_1] THEN | |
| SIMP_TAC[VSUM_SUB_NUMSEG; VSUM_COMPLEX_LMUL; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[CX_SUB; REAL_OF_NUM_ADD; ARITH_RULE `1 + m = m + 1`] THEN | |
| REWRITE_TAC[VSUM_DIFFS_ALT; LOG_1; COMPLEX_SUB_RZERO] THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP LGAMMA) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ_ALT] | |
| LIM_SUBSEQUENCE)) THEN | |
| DISCH_THEN(MP_TAC o SPEC `\r. r + 1`) THEN | |
| REWRITE_TAC[] THEN ANTS_TAC THENL [ARITH_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM) THEN | |
| REWRITE_TAC[o_DEF] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\n. --clog((Cx(&(n + 1)) + z) / Cx(&(n + 1)))` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[GSYM ADD1; VSUM_CLAUSES_NUMSEG; ARITH_RULE `1 <= SUC n`] THEN | |
| REWRITE_TAC[COMPLEX_RING `Cx(&n) + z = z + Cx(&n)`] THEN | |
| SIMP_TAC[CX_LOG; REAL_OF_NUM_LT; LT_0] THEN | |
| CONV_TAC COMPLEX_RING; | |
| REWRITE_TAC[COMPLEX_VEC_0] THEN MATCH_MP_TAC LIM_NULL_COMPLEX_NEG THEN | |
| SIMP_TAC[REAL_OF_NUM_EQ; CX_INJ; ARITH_EQ; ADD_EQ_0; | |
| COMPLEX_FIELD `~(y = Cx(&0)) ==> (y + z) / y = Cx(&1) + z / y`] THEN | |
| SUBGOAL_THEN `Cx(&0) = clog (Cx (&1) + Cx(&0))` SUBST1_TAC THENL | |
| [REWRITE_TAC[COMPLEX_ADD_RID; CLOG_1]; ALL_TAC] THEN | |
| MP_TAC(ISPECL [`\z. clog(Cx(&1) + z)`; `sequentially`] | |
| LIM_CONTINUOUS_FUNCTION) THEN | |
| REWRITE_TAC[] THEN DISCH_THEN MATCH_MP_TAC THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_AT THEN | |
| COMPLEX_DIFFERENTIABLE_TAC THEN REWRITE_TAC[RE_ADD; RE_CX] THEN | |
| REWRITE_TAC[REAL_ADD_RID; REAL_LT_01]; | |
| REWRITE_TAC[complex_div] THEN MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| MATCH_MP_TAC(REWRITE_RULE[o_DEF] | |
| (ISPECL [`f:num->complex`; `\n. n + 1`] LIM_SUBSEQUENCE)) THEN | |
| CONJ_TAC THENL [ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[GSYM CX_INV; REWRITE_RULE[o_DEF] (GSYM REALLIM_COMPLEX)] THEN | |
| REWRITE_TAC[REALLIM_1_OVER_N]]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The complex gamma function (defined using the Gauss/Euler product). *) | |
| (* Note that this totalizes it with the value zero at the poles. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let cgamma = new_definition | |
| `cgamma(z) = lim sequentially (\n. (Cx(&n) cpow z * Cx(&(FACT n))) / | |
| cproduct(0..n) (\m. z + Cx(&m)))`;; | |
| let [CGAMMA;CGAMMA_EQ_0;CGAMMA_LGAMMA] = (CONJUNCTS o prove) | |
| (`(!z. ((\n. (Cx(&n) cpow z * Cx(&(FACT n))) / cproduct(0..n) (\m. z + Cx(&m))) | |
| --> cgamma(z)) sequentially) /\ | |
| (!z. cgamma(z) = Cx(&0) <=> ?n. z + Cx(&n) = Cx(&0)) /\ | |
| (!z. cgamma(z) = if ?n. z + Cx(&n) = Cx(&0) then Cx(&0) | |
| else cexp(lgamma z))`, | |
| REWRITE_TAC[AND_FORALL_THM] THEN X_GEN_TAC `y:complex` THEN | |
| ASM_CASES_TAC `?n. y + Cx(&n) = Cx(&0)` THENL | |
| [ASM_REWRITE_TAC[GSYM NOT_EXISTS_THM] THEN | |
| FIRST_X_ASSUM(X_CHOOSE_TAC `N:num`) THEN | |
| REWRITE_TAC[cgamma; lim] THEN MATCH_MP_TAC(MESON[LIM_UNIQUE] | |
| `~trivial_limit net /\ (f --> a) net | |
| ==> (f --> @a. (f --> a) net) net /\ (@a. (f --> a) net) = a`) THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN | |
| MATCH_MP_TAC LIM_EVENTUALLY THEN REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `N:num` THEN X_GEN_TAC `n:num` THEN REWRITE_TAC[GE] THEN | |
| DISCH_TAC THEN | |
| SIMP_TAC[COMPLEX_ENTIRE; COMPLEX_DIV_EQ_0; CPRODUCT_EQ_0; FINITE_NUMSEG; | |
| IN_NUMSEG; LE_0] THEN | |
| ASM_MESON_TAC[LE_REFL]; | |
| ASM_REWRITE_TAC[] THEN RULE_ASSUM_TAC(REWRITE_RULE[NOT_EXISTS_THM])] THEN | |
| SUBGOAL_THEN | |
| `((\n. (Cx(&n) cpow y * Cx(&(FACT n))) / cproduct(0..n) (\m. y + Cx(&m))) | |
| --> cexp(lgamma y)) sequentially` | |
| ASSUME_TAC THENL | |
| [MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\n. cexp(y * clog(Cx(&n)) - clog y - | |
| vsum(1..n) (\m. clog((Cx(&m) + y) / Cx(&m))))` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| ASM_SIMP_TAC[CEXP_SUB; cpow; CX_INJ; REAL_OF_NUM_EQ; LE_1] THEN | |
| REWRITE_TAC[complex_div; GSYM COMPLEX_MUL_ASSOC] THEN AP_TERM_TAC THEN | |
| SIMP_TAC[GSYM NPRODUCT_FACT; REAL_OF_NUM_NPRODUCT; FINITE_NUMSEG] THEN | |
| SIMP_TAC[CX_PRODUCT; FINITE_NUMSEG; GSYM CPRODUCT_INV] THEN | |
| SIMP_TAC[CPRODUCT_CLAUSES_LEFT; LE_0] THEN | |
| GEN_REWRITE_TAC RAND_CONV [COMPLEX_RING | |
| `a * b * c:complex = b * a * c`] THEN | |
| REWRITE_TAC[COMPLEX_ADD_RID] THEN BINOP_TAC THENL | |
| [ASM_MESON_TAC[COMPLEX_ADD_RID; CEXP_CLOG]; ALL_TAC] THEN | |
| SIMP_TAC[ADD_CLAUSES; GSYM CPRODUCT_MUL; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[GSYM CEXP_NEG; GSYM VSUM_NEG] THEN | |
| SIMP_TAC[CEXP_VSUM; FINITE_NUMSEG] THEN MATCH_MP_TAC CPRODUCT_EQ THEN | |
| REWRITE_TAC[IN_NUMSEG] THEN X_GEN_TAC `m:num` THEN STRIP_TAC THEN | |
| REWRITE_TAC[CEXP_NEG] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o LAND_CONV) [GSYM COMPLEX_INV_INV] THEN | |
| REWRITE_TAC[GSYM COMPLEX_INV_MUL] THEN AP_TERM_TAC THEN | |
| GEN_REWRITE_TAC RAND_CONV [COMPLEX_MUL_SYM] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o ONCE_DEPTH_CONV) [COMPLEX_ADD_SYM] THEN | |
| MATCH_MP_TAC CEXP_CLOG THEN | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN | |
| ASM_REWRITE_TAC[COMPLEX_ENTIRE; COMPLEX_INV_EQ_0] THEN | |
| REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ] THEN ASM_ARITH_TAC; | |
| MATCH_MP_TAC(ISPEC `cexp` LIM_CONTINUOUS_FUNCTION) THEN | |
| ASM_SIMP_TAC[LGAMMA; CONTINUOUS_AT_CEXP]]; | |
| MATCH_MP_TAC(TAUT `p /\ (p ==> q) ==> p /\ q`) THEN CONJ_TAC THENL | |
| [REWRITE_TAC[cgamma; lim] THEN CONV_TAC SELECT_CONV THEN ASM_MESON_TAC[]; | |
| DISCH_TAC] THEN | |
| MATCH_MP_TAC(TAUT `q /\ (q ==> p) ==> p /\ q`) THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC(ISPEC `sequentially` LIM_UNIQUE) THEN | |
| ASM_MESON_TAC[TRIVIAL_LIMIT_SEQUENTIALLY]; | |
| SIMP_TAC[CEXP_NZ]]]);; | |
| let CGAMMA_RECURRENCE_ALT = prove | |
| (`!z. cgamma(z) = cgamma(z + Cx(&1)) / z`, | |
| GEN_TAC THEN ASM_CASES_TAC `?n. z + Cx(&n) = Cx(&0)` THENL | |
| [FIRST_ASSUM(fun th -> REWRITE_TAC[REWRITE_RULE[GSYM CGAMMA_EQ_0] th]) THEN | |
| CONV_TAC SYM_CONV THEN REWRITE_TAC[COMPLEX_DIV_EQ_0] THEN | |
| ASM_CASES_TAC `z = Cx(&0)` THEN ASM_REWRITE_TAC[] THEN | |
| FIRST_X_ASSUM(MP_TAC o check (is_exists o concl)) THEN | |
| REWRITE_TAC[LEFT_IMP_EXISTS_THM] THEN INDUCT_TAC THEN | |
| ASM_REWRITE_TAC[COMPLEX_ADD_RID; CGAMMA_EQ_0] THEN | |
| REWRITE_TAC[GSYM COMPLEX_ADD_ASSOC; GSYM CX_ADD; REAL_OF_NUM_ADD] THEN | |
| MESON_TAC[ADD1; ADD_SYM]; | |
| RULE_ASSUM_TAC(REWRITE_RULE[NOT_EXISTS_THM])] THEN | |
| SUBGOAL_THEN `!n. ~((z + Cx(&1)) + Cx(&n) = Cx(&0))` ASSUME_TAC THENL | |
| [REWRITE_TAC[GSYM COMPLEX_ADD_ASSOC; GSYM CX_ADD; REAL_OF_NUM_ADD] THEN | |
| ASM_MESON_TAC[]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `~(z = Cx(&0))` ASSUME_TAC THENL | |
| [ASM_MESON_TAC[COMPLEX_ADD_LID]; ALL_TAC] THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD | |
| `(a * b) / c = Cx(&1) /\ ~(a = Cx(&0)) /\ ~(c = Cx(&0)) ==> b = c / a`) THEN | |
| ASM_REWRITE_TAC[CGAMMA_EQ_0] THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` LIM_UNIQUE) THEN | |
| EXISTS_TAC | |
| `\n. (z * (Cx(&(n + 1)) cpow z * Cx(&(FACT(n + 1)))) / | |
| cproduct(0..n+1) (\m. z + Cx(&m))) / | |
| ((Cx(&n) cpow (z + Cx(&1)) * Cx(&(FACT n))) / | |
| cproduct(0..n) (\m. (z + Cx(&1)) + Cx(&m)))` THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC LIM_COMPLEX_DIV THEN | |
| ASM_REWRITE_TAC[CGAMMA; CGAMMA_EQ_0] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_LMUL THEN | |
| MP_TAC(SPEC `z:complex` CGAMMA) THEN | |
| DISCH_THEN(MP_TAC o SPEC `1` o MATCH_MP SEQ_OFFSET) THEN | |
| REWRITE_TAC[]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[GSYM COMPLEX_ADD_ASSOC; GSYM CX_ADD; REAL_OF_NUM_ADD] THEN | |
| REWRITE_TAC[ARITH_RULE `1 + n = n + 1`] THEN | |
| SIMP_TAC[SYM(ISPECL [`f:num->complex`; `m:num`; `1`] CPRODUCT_OFFSET)] THEN | |
| SIMP_TAC[CPRODUCT_CLAUSES_LEFT; LE_0; ADD_CLAUSES] THEN | |
| REWRITE_TAC[GSYM ADD1; FACT; CX_MUL; COMPLEX_MUL_ASSOC; GSYM REAL_OF_NUM_MUL; | |
| ONCE_REWRITE_RULE[COMPLEX_MUL_SYM] (GSYM CPOW_SUC)] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_INV_MUL; COMPLEX_INV_INV] THEN | |
| REWRITE_TAC[COMPLEX_ADD_RID; GSYM COMPLEX_MUL_ASSOC] THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `a * b * c * d * e * f * g * h:complex = | |
| (a * d) * (c * g) * (h * e) * (b * f)`] THEN | |
| ASM_SIMP_TAC[GSYM complex_div; COMPLEX_DIV_REFL; CX_INJ; | |
| REAL_OF_NUM_EQ; FACT_NZ; COMPLEX_MUL_LID] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_MUL_LID] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_MUL THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC LIM_EVENTUALLY THEN MATCH_MP_TAC ALWAYS_EVENTUALLY THEN | |
| X_GEN_TAC `n:num` THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC COMPLEX_DIV_REFL THEN | |
| SIMP_TAC[CPRODUCT_EQ_0; FINITE_NUMSEG] THEN ASM_MESON_TAC[]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\n. cexp((z + Cx(&1)) * clog(Cx(&1) + inv(Cx(&n))))` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| SIMP_TAC[cpow; CX_INJ; REAL_OF_NUM_EQ; NOT_SUC; LE_1] THEN | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[GSYM CEXP_SUB] THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[GSYM COMPLEX_SUB_LDISTRIB] THEN AP_TERM_TAC THEN | |
| ASM_SIMP_TAC[CX_INJ; REAL_OF_NUM_EQ; LE_1; COMPLEX_FIELD | |
| `~(n = Cx(&0)) ==> Cx(&1) + inv n = (n + Cx(&1)) / n`] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_SUC; GSYM CX_ADD] THEN | |
| ASM_SIMP_TAC[REAL_OF_NUM_ADD; GSYM CX_DIV; GSYM CX_LOG; LE_1; LOG_DIV; | |
| REAL_OF_NUM_LT; REAL_LT_DIV; ARITH_RULE `0 < n + 1`] THEN | |
| REWRITE_TAC[CX_SUB]; | |
| ALL_TAC] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM CEXP_0] THEN | |
| MATCH_MP_TAC(ISPEC `cexp` LIM_CONTINUOUS_FUNCTION) THEN | |
| REWRITE_TAC[CONTINUOUS_AT_CEXP] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| MATCH_MP_TAC LIM_NULL_COMPARISON_COMPLEX THEN | |
| EXISTS_TAC `\n. Cx(&2) * inv(Cx(&n))` THEN | |
| SIMP_TAC[LIM_INV_N; LIM_NULL_COMPLEX_LMUL] THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `2` THEN | |
| REWRITE_TAC[GE; IN_FROM] THEN X_GEN_TAC `n:num` THEN STRIP_TAC THEN | |
| MP_TAC(ISPECL [`0`; `Cx(inv(&n))`] TAYLOR_CLOG) THEN | |
| SIMP_TAC[VSUM_CLAUSES_NUMSEG; ARITH; VECTOR_SUB_RZERO] THEN | |
| REWRITE_TAC[REAL_POW_1; GSYM CX_ADD; COMPLEX_NORM_CX] THEN | |
| REWRITE_TAC[REAL_ABS_INV; REAL_ABS_NUM] THEN ANTS_TAC THENL | |
| [MATCH_MP_TAC REAL_INV_LT_1 THEN REWRITE_TAC[REAL_OF_NUM_LT] THEN | |
| ASM_ARITH_TAC; | |
| REWRITE_TAC[CX_ADD; CX_INV]] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN | |
| ONCE_REWRITE_TAC[COMPLEX_MUL_SYM] THEN | |
| REWRITE_TAC[real_div; COMPLEX_NORM_MUL] THEN | |
| REWRITE_TAC[COMPLEX_NORM_INV; COMPLEX_NORM_CX; REAL_ABS_NUM] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN | |
| REWRITE_TAC[REAL_LE_INV_EQ; REAL_POS] THEN | |
| GEN_REWRITE_TAC RAND_CONV [GSYM REAL_INV_INV] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[REAL_ARITH `&1 / &2 <= &1 - x <=> x <= inv(&2)`] THEN | |
| REWRITE_TAC[real_div; REAL_MUL_LID] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN | |
| REWRITE_TAC[REAL_OF_NUM_LT; REAL_OF_NUM_LE] THEN ASM_ARITH_TAC);; | |
| let CGAMMA_1 = prove | |
| (`cgamma(Cx(&1)) = Cx(&1)`, | |
| MP_TAC(SPEC `Cx(&1)` CGAMMA) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT; TRIVIAL_LIMIT_SEQUENTIALLY] | |
| (ISPEC `sequentially` LIM_UNIQUE)) THEN | |
| REWRITE_TAC[GSYM CX_ADD; REAL_OF_NUM_ADD; ARITH_RULE `1 + n = n + 1`] THEN | |
| SIMP_TAC[SYM(ISPECL [`f:num->complex`; `m:num`; `1`] CPRODUCT_OFFSET)] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\n. Cx(&n / (&n + &1))` THEN CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN REWRITE_TAC[CX_DIV] THEN | |
| ASM_SIMP_TAC[CPOW_N; CX_INJ; REAL_OF_NUM_EQ; LE_1; COMPLEX_POW_1] THEN | |
| REWRITE_TAC[complex_div; GSYM COMPLEX_MUL_ASSOC] THEN AP_TERM_TAC THEN | |
| ONCE_REWRITE_TAC [GSYM COMPLEX_INV_INV] THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[COMPLEX_INV_INV; COMPLEX_INV_MUL] THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD | |
| `a * b = c /\ ~(b = Cx(&0)) ==> a = inv b * c`) THEN | |
| REWRITE_TAC[GSYM CX_MUL; CX_INJ; REAL_OF_NUM_EQ; FACT_NZ] THEN | |
| REWRITE_TAC[REAL_OF_NUM_SUC; REAL_OF_NUM_MUL; GSYM(CONJUNCT2 FACT)] THEN | |
| REWRITE_TAC[ADD_CLAUSES; ADD1] THEN SPEC_TAC(`n + 1`,`m:num`) THEN | |
| INDUCT_TAC THEN REWRITE_TAC[FACT; CPRODUCT_CLAUSES_NUMSEG; ARITH] THEN | |
| ASM_REWRITE_TAC[CX_MUL; GSYM REAL_OF_NUM_MUL] THEN | |
| REWRITE_TAC[ARITH_RULE `1 <= SUC n`; COMPLEX_MUL_SYM]; | |
| ALL_TAC] THEN | |
| SIMP_TAC[REAL_FIELD `&n / (&n + &1) = &1 - inv(&n + &1)`] THEN | |
| SUBST1_TAC(COMPLEX_RING `Cx(&1) = Cx(&1) - Cx(&0)`) THEN | |
| REWRITE_TAC[CX_SUB] THEN MATCH_MP_TAC LIM_SUB THEN | |
| REWRITE_TAC[LIM_CONST; REAL_OF_NUM_ADD] THEN | |
| MATCH_MP_TAC(ISPECL [`f:num->complex`; `l:complex`; `1`] SEQ_OFFSET) THEN | |
| REWRITE_TAC[CX_INV; LIM_INV_N]);; | |
| let CGAMMA_RECURRENCE = prove | |
| (`!z. cgamma(z + Cx(&1)) = if z = Cx(&0) then Cx(&1) else z * cgamma(z)`, | |
| GEN_TAC THEN COND_CASES_TAC THEN | |
| ASM_REWRITE_TAC[COMPLEX_ADD_LID; CGAMMA_1] THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD `a = b / c /\ ~(c = Cx(&0)) ==> b = c * a`) THEN | |
| ASM_MESON_TAC[CGAMMA_RECURRENCE_ALT]);; | |
| let CGAMMA_FACT = prove | |
| (`!n. cgamma(Cx(&(n + 1))) = Cx(&(FACT n))`, | |
| INDUCT_TAC THEN REWRITE_TAC[FACT; ADD_CLAUSES; CGAMMA_1] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_SUC] THEN REWRITE_TAC[CX_ADD] THEN | |
| REWRITE_TAC[CGAMMA_RECURRENCE; CX_INJ; REAL_OF_NUM_EQ; ADD_EQ_0; ARITH] THEN | |
| ASM_REWRITE_TAC[ADD1; GSYM REAL_OF_NUM_MUL; CX_MUL]);; | |
| let CGAMMA_POLES = prove | |
| (`!n. cgamma(--(Cx(&n))) = Cx(&0)`, | |
| REWRITE_TAC[CGAMMA_EQ_0] THEN MESON_TAC[COMPLEX_ADD_LINV]);; | |
| let COMPLEX_DIFFERENTIABLE_AT_CGAMMA = prove | |
| (`!z. (!n. ~(z + Cx(&n) = Cx(&0))) ==> cgamma complex_differentiable at z`, | |
| let lemma = prove | |
| (`!z. (!n. ~(z + Cx(&n) = Cx(&0))) /\ | |
| cgamma complex_differentiable at (z + Cx(&1)) | |
| ==> cgamma complex_differentiable at z`, | |
| REPEAT STRIP_TAC THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_TRANSFORM_AT THEN | |
| MAP_EVERY EXISTS_TAC [`\z. cgamma(z + Cx(&1)) / z`; `&1`] THEN | |
| REWRITE_TAC[REAL_LT_01] THEN | |
| CONJ_TAC THENL [REWRITE_TAC[GSYM CGAMMA_RECURRENCE_ALT]; ALL_TAC] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_DIV_AT THEN | |
| REWRITE_TAC[COMPLEX_DIFFERENTIABLE_ID] THEN | |
| CONJ_TAC THENL [ALL_TAC; ASM_MESON_TAC[COMPLEX_ADD_RID]] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_COMPOSE_AT THEN | |
| ASM_REWRITE_TAC[] THEN COMPLEX_DIFFERENTIABLE_TAC) in | |
| REPEAT STRIP_TAC THEN MP_TAC(SPEC `abs(Re z) + &1` REAL_ARCH_SIMPLE) THEN | |
| DISCH_THEN(X_CHOOSE_TAC `N:num`) THEN | |
| SUBGOAL_THEN | |
| `!n. n <= N ==> cgamma complex_differentiable (at (z + Cx(&N) - Cx(&n)))` | |
| MP_TAC THENL | |
| [ALL_TAC; MESON_TAC[LE_REFL; COMPLEX_SUB_REFL; COMPLEX_ADD_RID]] THEN | |
| INDUCT_TAC THENL | |
| [DISCH_TAC THEN REWRITE_TAC[COMPLEX_SUB_RZERO] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_TRANSFORM_AT THEN | |
| EXISTS_TAC `\z. cexp(lgamma z)` THEN | |
| SUBGOAL_THEN `open {z | !n. ~(z + Cx(&n) = Cx(&0))}` MP_TAC THENL | |
| [REWRITE_TAC[SET_RULE `{z | !n. P n z} = UNIV DIFF {z | ?n. ~P n z}`] THEN | |
| REWRITE_TAC[GSYM closed] THEN MATCH_MP_TAC DISCRETE_IMP_CLOSED THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01; IMP_CONJ] THEN | |
| REWRITE_TAC[IN_ELIM_THM; LEFT_IMP_EXISTS_THM] THEN | |
| SIMP_TAC[COMPLEX_RING `x + y = Cx(&0) <=> x = --y`] THEN | |
| REWRITE_TAC[COMPLEX_RING `--x - --y:complex = y - x`] THEN | |
| REWRITE_TAC[COMPLEX_EQ_NEG2; CX_INJ; GSYM CX_SUB; COMPLEX_NORM_CX] THEN | |
| SIMP_TAC[GSYM REAL_EQ_INTEGERS; INTEGER_CLOSED]; | |
| REWRITE_TAC[open_def; IN_ELIM_THM] THEN | |
| DISCH_THEN(MP_TAC o SPEC `z:complex`) THEN ASM_REWRITE_TAC[] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN X_GEN_TAC `e:real` THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THENL | |
| [X_GEN_TAC `w:complex` THEN REWRITE_TAC[dist] THEN DISCH_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `w - Cx(&N)`) THEN | |
| ASM_SIMP_TAC[dist; COMPLEX_RING `w - n - z:complex = w - (z + n)`] THEN | |
| REWRITE_TAC[CGAMMA_LGAMMA] THEN COND_CASES_TAC THEN REWRITE_TAC[] THEN | |
| FIRST_X_ASSUM(X_CHOOSE_TAC `n:num`) THEN | |
| DISCH_THEN(MP_TAC o SPEC `n + N:num`) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_ADD; CX_ADD] THEN | |
| ASM_REWRITE_TAC[COMPLEX_RING `w - N + n + N:complex = w + n`]; | |
| GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_COMPOSE_AT THEN | |
| REWRITE_TAC[COMPLEX_DIFFERENTIABLE_AT_CEXP] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_AT_LGAMMA THEN | |
| REWRITE_TAC[RE_ADD; RE_CX] THEN ASM_REAL_ARITH_TAC]]; | |
| DISCH_TAC THEN REWRITE_TAC[GSYM REAL_OF_NUM_SUC; CX_ADD] THEN | |
| MATCH_MP_TAC lemma THEN | |
| REWRITE_TAC[COMPLEX_RING `(z + N - (n + w)) + w:complex = z + N - n`] THEN | |
| CONJ_TAC THENL | |
| [ALL_TAC; FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_ARITH_TAC] THEN | |
| X_GEN_TAC `m:num` THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `(N + m) - (n + 1)`) THEN | |
| SUBGOAL_THEN `n + 1 <= N + m` | |
| (fun th -> SIMP_TAC[th; GSYM REAL_OF_NUM_SUB]) | |
| THENL [ASM_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_ADD; CX_ADD; CX_SUB] THEN | |
| CONV_TAC COMPLEX_RING]);; | |
| let COMPLEX_DIFFERENTIABLE_WITHIN_CGAMMA = prove | |
| (`!z s. (!n. ~(z + Cx(&n) = Cx(&0))) | |
| ==> cgamma complex_differentiable at z within s`, | |
| SIMP_TAC[COMPLEX_DIFFERENTIABLE_AT_WITHIN; | |
| COMPLEX_DIFFERENTIABLE_AT_CGAMMA]);; | |
| let HOLOMORPHIC_ON_CGAMMA = prove | |
| (`!s. s SUBSET {z | !n. ~(z + Cx(&n) = Cx(&0))} | |
| ==> cgamma holomorphic_on s`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[HOLOMORPHIC_ON_DIFFERENTIABLE] THEN | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_WITHIN_CGAMMA THEN | |
| ASM SET_TAC[]);; | |
| let CONTINUOUS_AT_CGAMMA = prove | |
| (`!z. (!n. ~(z + Cx(&n) = Cx(&0))) ==> cgamma continuous at z`, | |
| SIMP_TAC[COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_AT; | |
| COMPLEX_DIFFERENTIABLE_AT_CGAMMA]);; | |
| let CONTINUOUS_WITHIN_CGAMMA = prove | |
| (`!z s. (!n. ~(z + Cx(&n) = Cx(&0))) | |
| ==> cgamma continuous at z within s`, | |
| SIMP_TAC[COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_WITHIN; | |
| COMPLEX_DIFFERENTIABLE_WITHIN_CGAMMA]);; | |
| let CONTINUOUS_ON_CGAMMA = prove | |
| (`!s. s SUBSET {z | !n. ~(z + Cx(&n) = Cx(&0))} | |
| ==> cgamma continuous_on s`, | |
| SIMP_TAC[HOLOMORPHIC_ON_IMP_CONTINUOUS_ON; HOLOMORPHIC_ON_CGAMMA]);; | |
| let CGAMMA_SIMPLE_POLES = prove | |
| (`!n. ((\z. (z + Cx(&n)) * cgamma z) --> --Cx(&1) pow n / Cx(&(FACT n))) | |
| (at(--Cx(&n)))`, | |
| INDUCT_TAC THENL | |
| [REWRITE_TAC[COMPLEX_ADD_RID; COMPLEX_NEG_0; FACT; complex_pow; | |
| COMPLEX_DIV_1] THEN | |
| ONCE_REWRITE_TAC[CGAMMA_RECURRENCE_ALT] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_AWAY_AT THEN | |
| MAP_EVERY EXISTS_TAC [`\z. cgamma(z + Cx(&1))`; `Cx(&1)`] THEN | |
| REWRITE_TAC[CONJ_ASSOC] THEN | |
| CONJ_TAC THENL [CONV_TAC COMPLEX_FIELD; ALL_TAC] THEN | |
| SUBGOAL_THEN `(\z. cgamma (z + Cx(&1))) continuous at (Cx(&0))` | |
| MP_TAC THENL | |
| [GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_COMPOSE THEN | |
| CONJ_TAC THENL [CONTINUOUS_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_CGAMMA THEN | |
| REWRITE_TAC[GSYM CX_ADD; CX_INJ] THEN REAL_ARITH_TAC; | |
| REWRITE_TAC[CONTINUOUS_AT; COMPLEX_ADD_LID; CGAMMA_1]]; | |
| REWRITE_TAC[FACT; CX_MUL; GSYM REAL_OF_NUM_MUL] THEN | |
| ONCE_REWRITE_TAC[CGAMMA_RECURRENCE_ALT] THEN | |
| REWRITE_TAC[complex_div; complex_pow; COMPLEX_INV_MUL] THEN | |
| REWRITE_TAC[SIMPLE_COMPLEX_ARITH | |
| `(--Cx(&1) * p) * is * i = (p * i) * --is`] THEN | |
| REWRITE_TAC[COMPLEX_MUL_ASSOC] THEN MATCH_MP_TAC LIM_COMPLEX_MUL THEN | |
| CONJ_TAC THENL | |
| [FIRST_X_ASSUM(MP_TAC o | |
| ISPECL [`at (--Cx(&(SUC n)))`; `\z. z + Cx(&1)`] o | |
| MATCH_MP (ONCE_REWRITE_RULE[IMP_CONJ_ALT] | |
| (REWRITE_RULE[CONJ_ASSOC] LIM_COMPOSE_AT))) THEN | |
| REWRITE_TAC[o_DEF; GSYM REAL_OF_NUM_SUC; CX_ADD] THEN | |
| REWRITE_TAC[COMPLEX_RING `(z + Cx(&1)) + w = z + (w + Cx(&1))`] THEN | |
| REWRITE_TAC[GSYM complex_div] THEN DISCH_THEN MATCH_MP_TAC THEN | |
| CONJ_TAC THENL | |
| [LIM_TAC THEN CONV_TAC COMPLEX_RING; | |
| REWRITE_TAC[EVENTUALLY_AT; GSYM DIST_NZ] THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01] THEN | |
| CONV_TAC COMPLEX_RING]; | |
| REWRITE_TAC[COMPLEX_NEG_INV; GSYM CONTINUOUS_AT] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM ETA_AX] THEN | |
| MATCH_MP_TAC CONTINUOUS_COMPLEX_INV_AT THEN | |
| REWRITE_TAC[GSYM CX_NEG; CX_INJ; GSYM REAL_OF_NUM_SUC] THEN | |
| REWRITE_TAC[CONTINUOUS_AT_ID] THEN REAL_ARITH_TAC]]);; | |
| let CNJ_CGAMMA = prove | |
| (`!z. cnj(cgamma z) = cgamma(cnj z)`, | |
| GEN_TAC THEN MP_TAC(SPEC `cnj z` CGAMMA) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] | |
| LIM_UNIQUE) THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN | |
| GEN_REWRITE_TAC I [GSYM LIM_CNJ] THEN REWRITE_TAC[CNJ_CNJ] THEN | |
| MP_TAC(SPEC `z:complex` CGAMMA) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| SIMP_TAC[CNJ_DIV; CNJ_MUL; CNJ_CX; CNJ_CPRODUCT; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[CNJ_ADD; CNJ_CNJ; CNJ_CX] THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| X_GEN_TAC `n:num` THEN REWRITE_TAC[cpow; CNJ_EQ_0] THEN | |
| DISCH_TAC THEN COND_CASES_TAC THEN REWRITE_TAC[CNJ_CX; CNJ_CEXP] THEN | |
| REWRITE_TAC[CNJ_MUL; CNJ_CNJ] THEN | |
| ASM_SIMP_TAC[CNJ_CLOG; RE_CX; REAL_OF_NUM_LT; LE_1; CNJ_CX]);; | |
| let REAL_GAMMA = prove | |
| (`!z. real z ==> real(cgamma z)`, | |
| SIMP_TAC[REAL_CNJ; CNJ_CGAMMA]);; | |
| let RE_POS_CGAMMA_REAL = prove | |
| (`!z. real z /\ &0 <= Re z ==> &0 <= Re(cgamma z)`, | |
| REWRITE_TAC[REAL_EXISTS; LEFT_IMP_EXISTS_THM; IMP_CONJ] THEN | |
| GEN_TAC THEN X_GEN_TAC `x:real` THEN DISCH_THEN SUBST1_TAC THEN | |
| REWRITE_TAC[RE_CX] THEN DISCH_TAC THEN MP_TAC(SPEC `Cx x` CGAMMA) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[TAUT `p /\ q /\ r ==> s <=> p /\ r ==> q ==> s`] | |
| LIM_RE_LBOUND) THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY; EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `1` THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| ASM_SIMP_TAC[cpow; CX_INJ; REAL_OF_NUM_EQ; LE_1; GSYM CX_LOG; GSYM CX_INV; | |
| REAL_OF_NUM_LT; GSYM CX_MUL; GSYM CX_EXP; RE_MUL_CX; RE_CX; | |
| complex_div; GSYM CX_ADD; GSYM CX_PRODUCT; FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC REAL_LE_MUL THEN | |
| SIMP_TAC[REAL_LE_MUL; REAL_EXP_POS_LE; REAL_POS; REAL_LE_INV_EQ] THEN | |
| MATCH_MP_TAC PRODUCT_POS_LE_NUMSEG THEN ASM_REAL_ARITH_TAC);; | |
| let CGAMMA_LEGENDRE_ALT = prove | |
| (`!z. cgamma(z) * cgamma(z + Cx(&1) / Cx(&2)) = | |
| Cx(&2) cpow (Cx(&1) - Cx(&2) * z) * | |
| cgamma(Cx(&1) / Cx(&2)) * cgamma(Cx(&2) * z)`, | |
| REWRITE_TAC[GSYM CX_DIV] THEN | |
| SUBGOAL_THEN | |
| `?f. !z. (!n. ~(Cx(&2) * z + Cx(&n) = Cx(&0))) | |
| ==> (f --> (cgamma(z) * cgamma(z + Cx(&1 / &2))) / | |
| (Cx(&2) cpow (Cx(&1) - Cx(&2) * z) * cgamma(Cx(&2) * z))) | |
| sequentially` | |
| CHOOSE_TAC THENL | |
| [EXISTS_TAC | |
| `\n. (Cx(&n) cpow Cx(&1 / &2) * inv (Cx(&2))) * | |
| (Cx(&(FACT n)) pow 2 * inv (Cx(&(FACT (2 * n))))) * | |
| Cx(&4) pow (n + 1) * | |
| inv(Cx(&(2 * n + 1)))` THEN | |
| REPEAT STRIP_TAC THEN MP_TAC(SPEC `Cx(&2) * z` CGAMMA) THEN | |
| DISCH_THEN(MP_TAC o SPEC `\n. 2 * n` o MATCH_MP | |
| (REWRITE_RULE[IMP_CONJ_ALT] LIM_SUBSEQUENCE)) THEN | |
| REWRITE_TAC[o_DEF] THEN ANTS_TAC THENL [ARITH_TAC; ALL_TAC] THEN | |
| DISCH_THEN(MP_TAC o SPEC `Cx(&2) cpow (Cx(&1) - Cx(&2) * z)` o | |
| MATCH_MP LIM_COMPLEX_LMUL) THEN | |
| MP_TAC(CONJ (SPEC `z:complex` CGAMMA) (SPEC `z + Cx(&1 / &2)` CGAMMA)) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP LIM_COMPLEX_MUL) THEN | |
| REWRITE_TAC[IMP_IMP] THEN DISCH_THEN(MP_TAC o MATCH_MP | |
| (ONCE_REWRITE_RULE[IMP_CONJ] | |
| (REWRITE_RULE[CONJ_ASSOC] LIM_COMPLEX_DIV))) THEN | |
| ASM_REWRITE_TAC[COMPLEX_ENTIRE; CPOW_EQ_0; CGAMMA_EQ_0] THEN | |
| REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ; ARITH_EQ] THEN | |
| SUBGOAL_THEN `((\n. (Cx(&2) * z + Cx(&(2 * n + 1))) / Cx(&(2 * n + 1))) | |
| --> Cx(&1)) sequentially` | |
| MP_TAC THENL | |
| [SIMP_TAC[complex_div; COMPLEX_MUL_RINV; CX_INJ; REAL_OF_NUM_EQ; | |
| COMPLEX_ADD_RDISTRIB; ARITH_RULE `~(2 * n + 1 = 0)`] THEN | |
| ONCE_REWRITE_TAC[LIM_NULL_COMPLEX] THEN | |
| REWRITE_TAC[COMPLEX_RING `(a + b) - b:complex = a`] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| MP_TAC(SPEC `\n. 2 * n + 1` | |
| (MATCH_MP (REWRITE_RULE[IMP_CONJ_ALT] LIM_SUBSEQUENCE) LIM_INV_N)) THEN | |
| REWRITE_TAC[o_DEF] THEN DISCH_THEN MATCH_MP_TAC THEN ARITH_TAC; | |
| REWRITE_TAC[IMP_IMP] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP LIM_COMPLEX_MUL)] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LID] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `1` THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| REWRITE_TAC[CPOW_ADD; complex_div; COMPLEX_INV_MUL; COMPLEX_INV_INV] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_MUL; CX_MUL] THEN | |
| SIMP_TAC[CPOW_MUL_REAL; REAL_CX; RE_CX; REAL_POS] THEN | |
| REWRITE_TAC[CPOW_SUB; CPOW_N; CX_INJ; REAL_OF_NUM_EQ; ARITH_EQ] THEN | |
| SIMP_TAC[COMPLEX_POW_1; complex_div; COMPLEX_INV_INV; COMPLEX_INV_MUL] THEN | |
| REWRITE_TAC[GSYM COMPLEX_MUL_ASSOC] THEN REWRITE_TAC[COMPLEX_RING | |
| `x * y * a * b * c * d * e * f * g * h * i * j * k * l * m:complex = | |
| (x * y) * (e * h) * ((a * d) * k) * | |
| ((b * f) * l) * (i * j) * (m * c * g)`] THEN | |
| REWRITE_TAC[GSYM COMPLEX_POW_2; COMPLEX_MUL_2; CPOW_ADD] THEN | |
| ASM_SIMP_TAC[COMPLEX_MUL_RINV; COMPLEX_POW_EQ_0; CPOW_EQ_0; | |
| CX_INJ; REAL_OF_NUM_EQ; ARITH_EQ; LE_1; COMPLEX_MUL_LID] THEN | |
| REWRITE_TAC[GSYM COMPLEX_MUL_2; GSYM COMPLEX_INV_MUL] THEN | |
| SIMP_TAC[GSYM CPRODUCT_MUL; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `(z + m) * ((z + Cx(&1 / &2)) + m) = | |
| inv(Cx(&4)) * | |
| (Cx(&2) * z + Cx(&2) * m) * (Cx(&2) * z + Cx(&2) * m + Cx(&1))`] THEN | |
| SIMP_TAC[CPRODUCT_MUL; FINITE_NUMSEG; CPRODUCT_CONST_NUMSEG] THEN | |
| SIMP_TAC[GSYM CPRODUCT_MUL; SUB_0; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_MUL; | |
| REAL_OF_NUM_ADD; REAL_OF_NUM_MUL] THEN | |
| REWRITE_TAC[GSYM CPRODUCT_PAIR] THEN | |
| SIMP_TAC[GSYM ADD1; CPRODUCT_CLAUSES_NUMSEG] THEN | |
| REWRITE_TAC[ADD1] THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| SIMP_TAC[LE_0; COMPLEX_INV_MUL; COMPLEX_INV_INV; GSYM COMPLEX_POW_INV] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `x * a * b * c * d * e * f:complex = (c * e) * a * b * d * f * x`] THEN | |
| ASM_SIMP_TAC[COMPLEX_MUL_RINV; CPRODUCT_EQ_0; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LID; COMPLEX_MUL_ASSOC] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| ASM_SIMP_TAC[GSYM COMPLEX_MUL_ASSOC; COMPLEX_MUL_LINV] THEN | |
| CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| X_GEN_TAC `z:complex` THEN | |
| ASM_CASES_TAC `!n. ~(Cx(&2) * z + Cx(&n) = Cx(&0))` THENL | |
| [FIRST_X_ASSUM(fun th -> | |
| MP_TAC(SPEC `z:complex` th) THEN MP_TAC(SPEC `Cx(&1 / &2)` th)) THEN | |
| ASM_REWRITE_TAC[GSYM CX_ADD; GSYM CX_MUL; GSYM CX_SUB; CX_INJ] THEN | |
| ANTS_TAC THENL [REAL_ARITH_TAC; CONV_TAC REAL_RAT_REDUCE_CONV] THEN | |
| REWRITE_TAC[CGAMMA_1; CPOW_N; CX_INJ; REAL_OF_NUM_EQ; ARITH_EQ] THEN | |
| REWRITE_TAC[complex_pow; COMPLEX_MUL_RID; COMPLEX_DIV_1; IMP_IMP] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP (ONCE_REWRITE_RULE[IMP_CONJ_ALT] | |
| LIM_UNIQUE)) THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN MATCH_MP_TAC(COMPLEX_FIELD | |
| `~(p = Cx(&0)) /\ ~(z2 = Cx(&0)) | |
| ==> a = (z * z') / (p * z2) ==> z * z' = p * a * z2`) THEN | |
| ASM_REWRITE_TAC[CGAMMA_EQ_0; CPOW_EQ_0; CX_INJ; REAL_OF_NUM_EQ; ARITH_EQ]; | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `z = Cx(&0) /\ ((w = Cx(&0)) \/ (y = Cx(&0))) | |
| ==> w * y = p * q * z`) THEN | |
| REWRITE_TAC[CGAMMA_EQ_0] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[]; ALL_TAC] THEN | |
| REWRITE_TAC[OR_EXISTS_THM; GSYM COMPLEX_ADD_ASSOC] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `z + n = Cx(&0) <=> Cx(&2) * z + Cx(&2) * n = Cx(&0)`] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_MUL] THEN | |
| REWRITE_TAC[REAL_ARITH `&2 * (&1 / &2 + n) = &2 * n + &1`] THEN | |
| REWRITE_TAC[REAL_OF_NUM_SUC; REAL_OF_NUM_MUL] THEN | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [NOT_FORALL_THM]) THEN | |
| DISCH_THEN(X_CHOOSE_THEN `n:num` MP_TAC) THEN | |
| MP_TAC(SPEC `n:num` EVEN_OR_ODD) THEN | |
| MESON_TAC[ODD_EXISTS; EVEN_EXISTS]]);; | |
| let CGAMMA_REFLECTION = prove | |
| (`!z. cgamma(z) * cgamma(Cx(&1) - z) = Cx pi / csin(Cx pi * z)`, | |
| let lemma = prove | |
| (`!w z. (?n. integer n /\ w = Cx n) /\ (?n. integer n /\ z = Cx n) /\ | |
| dist(w,z) < &1 | |
| ==> w = z`, | |
| REPEAT GEN_TAC THEN | |
| REPEAT(DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC)) THEN | |
| ASM_REWRITE_TAC[DIST_CX] THEN ASM_MESON_TAC[REAL_EQ_INTEGERS_IMP]) in | |
| ABBREV_TAC | |
| `g = \z. if ?n. integer n /\ z = Cx n then Cx pi | |
| else cgamma(z) * cgamma(Cx(&1) - z) * csin(Cx pi * z)` THEN | |
| SUBGOAL_THEN `!z. g(z + Cx(&1)):complex = g(z)` ASSUME_TAC THENL | |
| [GEN_TAC THEN EXPAND_TAC "g" THEN | |
| MATCH_MP_TAC(MESON[] `(p <=> p') /\ a = a' /\ b = b' | |
| ==> (if p then a else b) = (if p' then a' else b')`) THEN | |
| REWRITE_TAC[COMPLEX_RING `z + Cx(&1) = w <=> z = w - Cx(&1)`] THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[GSYM CX_SUB] THEN | |
| MESON_TAC[INTEGER_CLOSED; REAL_ARITH `(n + &1) - &1 = n`]; | |
| GEN_REWRITE_TAC (RAND_CONV o LAND_CONV) [CGAMMA_RECURRENCE_ALT] THEN | |
| REWRITE_TAC[COMPLEX_RING `a - (z + a):complex = --z`] THEN | |
| GEN_REWRITE_TAC (LAND_CONV o RAND_CONV o LAND_CONV) | |
| [CGAMMA_RECURRENCE_ALT] THEN | |
| REWRITE_TAC[COMPLEX_ADD_LDISTRIB; COMPLEX_MUL_RID; CSIN_ADD] THEN | |
| REWRITE_TAC[GSYM CX_SIN; GSYM CX_COS; SIN_PI; COS_PI] THEN | |
| REWRITE_TAC[COMPLEX_RING `--z + Cx(&1) = Cx(&1) - z`] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_INV_NEG; COMPLEX_MUL_AC; | |
| CX_NEG; COMPLEX_MUL_LID; COMPLEX_MUL_LZERO] THEN | |
| REWRITE_TAC[COMPLEX_ADD_RID; COMPLEX_MUL_LNEG; COMPLEX_MUL_RNEG] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LID; COMPLEX_NEG_NEG] THEN | |
| REWRITE_TAC[COMPLEX_MUL_AC]]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `!n z. integer n ==> g(z + Cx n):complex = g z` ASSUME_TAC THENL | |
| [SUBGOAL_THEN `!n z. g(z + Cx(&n)):complex = g z` ASSUME_TAC THENL | |
| [INDUCT_TAC THEN | |
| ASM_REWRITE_TAC[GSYM REAL_OF_NUM_SUC; COMPLEX_ADD_RID] THEN | |
| ASM_REWRITE_TAC[CX_ADD; COMPLEX_ADD_ASSOC]; | |
| REWRITE_TAC[integer] THEN REPEAT STRIP_TAC THEN | |
| FIRST_X_ASSUM(DISJ_CASES_THEN SUBST1_TAC o MATCH_MP | |
| (REAL_ARITH `abs x = a ==> x = a \/ x = --a`)) THEN | |
| ASM_REWRITE_TAC[CX_NEG; GSYM complex_sub] THEN | |
| ASM_MESON_TAC[COMPLEX_RING `(z - w) + w:complex = z`]]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `!z. ~(?n. integer n /\ z = Cx n) | |
| ==> g complex_differentiable (at z)` | |
| ASSUME_TAC THENL | |
| [REPEAT STRIP_TAC THEN MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_TRANSFORM_AT THEN | |
| EXISTS_TAC `\z. cgamma z * cgamma(Cx(&1) - z) * csin(Cx pi * z)` THEN | |
| SUBGOAL_THEN `closed {z | ?n. integer n /\ z = Cx n}` MP_TAC THENL | |
| [MATCH_MP_TAC DISCRETE_IMP_CLOSED THEN EXISTS_TAC `&1` THEN | |
| REWRITE_TAC[REAL_LT_01; IN_ELIM_THM] THEN MESON_TAC[lemma; dist]; | |
| REWRITE_TAC[closed; OPEN_CONTAINS_BALL; IN_UNIV; IN_DIFF]] THEN | |
| DISCH_THEN(MP_TAC o SPEC `z:complex`) THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM] THEN MATCH_MP_TAC MONO_EXISTS THEN | |
| REWRITE_TAC[SUBSET; IN_BALL; IN_DIFF; IN_ELIM_THM; IN_UNIV] THEN | |
| X_GEN_TAC `e:real` THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| ONCE_REWRITE_TAC[DIST_SYM] THEN EXPAND_TAC "g" THEN REWRITE_TAC[] THEN | |
| ASM_SIMP_TAC[] THEN | |
| REPEAT(MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_MUL_AT THEN CONJ_TAC) THENL | |
| [ALL_TAC; | |
| GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_COMPOSE_AT THEN | |
| CONJ_TAC; | |
| ALL_TAC] THEN | |
| (MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_AT_CGAMMA ORELSE | |
| COMPLEX_DIFFERENTIABLE_TAC) THEN | |
| REWRITE_TAC[COMPLEX_RING `z + a:complex = b <=> z = b - a`; | |
| COMPLEX_RING `Cx(&1) - z = a - b <=> z = b - a + Cx(&1)`] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_SUB] THEN ASM_MESON_TAC[INTEGER_CLOSED]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `g complex_differentiable at (Cx(&0))` ASSUME_TAC THENL | |
| [MATCH_MP_TAC HOLOMORPHIC_ON_IMP_DIFFERENTIABLE_AT THEN | |
| EXISTS_TAC `ball(Cx(&0),&1)` THEN | |
| REWRITE_TAC[OPEN_BALL; CENTRE_IN_BALL; REAL_LT_01] THEN | |
| MATCH_MP_TAC NO_ISOLATED_SINGULARITY THEN EXISTS_TAC `{Cx(&0)}` THEN | |
| REWRITE_TAC[OPEN_BALL; FINITE_SING] THEN CONJ_TAC THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[HOLOMORPHIC_ON_DIFFERENTIABLE; IN_DIFF; IN_SING] THEN | |
| X_GEN_TAC `z:complex` THEN REWRITE_TAC[COMPLEX_IN_BALL_0] THEN | |
| STRIP_TAC THEN MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_AT_WITHIN THEN | |
| FIRST_X_ASSUM MATCH_MP_TAC THEN UNDISCH_TAC `~(z = Cx(&0))` THEN | |
| REWRITE_TAC[CONTRAPOS_THM] THEN DISCH_TAC THEN MATCH_MP_TAC lemma THEN | |
| ASM_REWRITE_TAC[dist; COMPLEX_SUB_RZERO] THEN | |
| MESON_TAC[INTEGER_CLOSED]] THEN | |
| REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN | |
| X_GEN_TAC `z:complex` THEN REWRITE_TAC[COMPLEX_IN_BALL_0] THEN | |
| DISCH_TAC THEN MATCH_MP_TAC CONTINUOUS_AT_WITHIN THEN | |
| ASM_CASES_TAC `z = Cx(&0)` THENL | |
| [ALL_TAC; | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_AT THEN | |
| FIRST_X_ASSUM MATCH_MP_TAC THEN UNDISCH_TAC `~(z = Cx(&0))` THEN | |
| REWRITE_TAC[CONTRAPOS_THM] THEN DISCH_TAC THEN MATCH_MP_TAC lemma THEN | |
| ASM_REWRITE_TAC[dist; COMPLEX_SUB_RZERO] THEN | |
| MESON_TAC[INTEGER_CLOSED]] THEN | |
| FIRST_X_ASSUM SUBST_ALL_TAC THEN REWRITE_TAC[CONTINUOUS_AT] THEN | |
| EXPAND_TAC "g" THEN | |
| REWRITE_TAC[MESON[INTEGER_CLOSED] `?n. integer n /\ Cx(&0) = Cx(n)`] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_WITHIN_OPEN THEN | |
| EXISTS_TAC `\z. Cx pi * (z * cgamma(z)) * cgamma(Cx(&1) - z) * | |
| csin(Cx pi * z) / (Cx pi * z)` THEN | |
| EXISTS_TAC `ball(Cx(&0),&1)` THEN | |
| REWRITE_TAC[OPEN_BALL; CENTRE_IN_BALL; REAL_LT_01] THEN CONJ_TAC THENL | |
| [X_GEN_TAC `w:complex` THEN REWRITE_TAC[COMPLEX_IN_BALL_0] THEN | |
| STRIP_TAC THEN COND_CASES_TAC THENL | |
| [UNDISCH_TAC `~(w = Cx(&0))` THEN | |
| MATCH_MP_TAC(TAUT `p ==> ~p ==> q`) THEN MATCH_MP_TAC lemma THEN | |
| ASM_REWRITE_TAC[dist; COMPLEX_SUB_RZERO] THEN | |
| MESON_TAC[INTEGER_CLOSED]; | |
| UNDISCH_TAC `~(w = Cx(&0))` THEN MP_TAC PI_NZ THEN | |
| REWRITE_TAC[GSYM CX_INJ] THEN CONV_TAC COMPLEX_FIELD]; | |
| GEN_REWRITE_TAC LAND_CONV [COMPLEX_RING | |
| `p = p * Cx(&1) * Cx(&1) * Cx(&1)`] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_LMUL THEN MATCH_MP_TAC LIM_COMPLEX_MUL THEN | |
| CONJ_TAC THENL | |
| [MP_TAC(SPEC `0` CGAMMA_SIMPLE_POLES) THEN | |
| REWRITE_TAC[FACT; COMPLEX_DIV_1; complex_pow; COMPLEX_ADD_RID] THEN | |
| REWRITE_TAC[COMPLEX_NEG_0]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_MUL THEN CONJ_TAC THENL | |
| [SUBGOAL_THEN `(cgamma o (\z. Cx(&1) - z)) continuous (at (Cx(&0)))` | |
| MP_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_AT_COMPOSE THEN | |
| CONJ_TAC THENL [CONTINUOUS_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_CGAMMA THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_SUB; CX_INJ] THEN | |
| REAL_ARITH_TAC; | |
| REWRITE_TAC[CONTINUOUS_AT; o_DEF; COMPLEX_SUB_RZERO; CGAMMA_1]]; | |
| SUBGOAL_THEN | |
| `(\z. csin(Cx pi * z) / (Cx pi * z)) = | |
| (\z. csin z / z) o (\w. Cx pi * w)` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_COMPOSE_AT THEN | |
| EXISTS_TAC `Cx(&0)` THEN REWRITE_TAC[LIM_CSIN_OVER_X] THEN | |
| SIMP_TAC[EVENTUALLY_AT; COMPLEX_ENTIRE; CX_INJ; PI_NZ; | |
| GSYM DIST_NZ] THEN | |
| CONJ_TAC THENL [ALL_TAC; MESON_TAC[REAL_LT_01]] THEN | |
| LIM_TAC THEN CONV_TAC COMPLEX_RING]]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `g holomorphic_on (:complex)` ASSUME_TAC THENL | |
| [REWRITE_TAC[HOLOMORPHIC_ON_DIFFERENTIABLE; WITHIN_UNIV; IN_UNIV] THEN | |
| X_GEN_TAC `z:complex` THEN ASM_CASES_TAC `?n. integer n /\ z = Cx n` THEN | |
| ASM_SIMP_TAC[] THEN | |
| FIRST_X_ASSUM(X_CHOOSE_THEN `n:real` STRIP_ASSUME_TAC) THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_TRANSFORM_AT THEN | |
| EXISTS_TAC `(g:complex->complex) o (\z. z - Cx n)` THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01] THEN CONJ_TAC THENL | |
| [REWRITE_TAC[o_THM] THEN | |
| ASM_MESON_TAC[COMPLEX_RING `(z - w) + w:complex = z`]; | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_COMPOSE_AT THEN | |
| ASM_REWRITE_TAC[COMPLEX_SUB_REFL] THEN | |
| COMPLEX_DIFFERENTIABLE_TAC]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `!z. g(z / Cx(&2)) * g((z + Cx(&1)) / Cx(&2)) = | |
| cgamma(Cx(&1 / &2)) pow 2 * g(z)` | |
| ASSUME_TAC THENL | |
| [MATCH_MP_TAC(SET_RULE | |
| `!s. s = UNIV /\ (!x. x IN s ==> P x) ==> !x. P x`) THEN | |
| EXISTS_TAC `closure {z | !n. ~(integer n /\ z = Cx n)}` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[CLOSURE_INTERIOR] THEN | |
| MATCH_MP_TAC(SET_RULE `s = {} ==> t DIFF s = t`) THEN | |
| MATCH_MP_TAC COUNTABLE_EMPTY_INTERIOR THEN | |
| MATCH_MP_TAC DISCRETE_IMP_COUNTABLE THEN | |
| REWRITE_TAC[IN_DIFF; IN_UNIV; IN_ELIM_THM] THEN | |
| REPEAT STRIP_TAC THEN EXISTS_TAC `&1` THEN | |
| REWRITE_TAC[GSYM REAL_NOT_LT; GSYM dist; REAL_LT_01] THEN | |
| ASM_MESON_TAC[lemma]; | |
| ALL_TAC] THEN | |
| ONCE_REWRITE_TAC[GSYM COMPLEX_SUB_0] THEN REWRITE_TAC[GSYM IN_SING] THEN | |
| MATCH_MP_TAC FORALL_IN_CLOSURE THEN REWRITE_TAC[CLOSED_SING] THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_ON_SUB THEN CONJ_TAC THEN | |
| MATCH_MP_TAC CONTINUOUS_ON_COMPLEX_MUL THEN CONJ_TAC THEN | |
| REWRITE_TAC[CONTINUOUS_ON_CONST] THEN | |
| TRY(GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC CONTINUOUS_ON_COMPOSE THEN CONJ_TAC) THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP HOLOMORPHIC_ON_IMP_CONTINUOUS_ON) THEN | |
| REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN | |
| REWRITE_TAC[IN_UNIV; WITHIN_UNIV] THEN REPEAT STRIP_TAC THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_WITHIN THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[complex_div] THEN MATCH_MP_TAC CONTINUOUS_COMPLEX_MUL THEN | |
| CONJ_TAC THEN CONTINUOUS_TAC; | |
| ALL_TAC] THEN | |
| X_GEN_TAC `z:complex` THEN | |
| REWRITE_TAC[IN_ELIM_THM; IN_SING; COMPLEX_SUB_0] THEN DISCH_TAC THEN | |
| EXPAND_TAC "g" THEN REWRITE_TAC[] THEN | |
| REWRITE_TAC[COMPLEX_RING `z / Cx(&2) = w <=> z = Cx(&2) * w`] THEN | |
| REWRITE_TAC[COMPLEX_RING `z + Cx(&1) = w <=> z = w - Cx(&1)`] THEN | |
| REWRITE_TAC[GSYM CX_MUL; GSYM CX_SUB] THEN | |
| REPEAT(COND_CASES_TAC THENL [ASM_MESON_TAC[INTEGER_CLOSED]; ALL_TAC]) THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `(a * b * c) * (d * e * f):complex = | |
| (a * d) * (e * b) * (c * f)`] THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `Cx(&1) - (z + Cx(&1)) / Cx(&2) = (Cx(&1) - z) / Cx(&2)`] THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `(z + Cx(&1)) / Cx(&2) = z / Cx(&2) + Cx(&1) / Cx(&2) /\ | |
| Cx(&1) - z / Cx(&2) = ((Cx(&1) - z) / Cx(&2)) + Cx(&1) / Cx(&2)`] THEN | |
| REWRITE_TAC[CGAMMA_LEGENDRE_ALT] THEN | |
| MP_TAC(ISPEC `Cx(&1 / &2) * z * Cx pi` CSIN_DOUBLE) THEN | |
| MP_TAC(SPECL [`Cx(&2)`; `z:complex`; `--z:complex`] CPOW_ADD) THEN | |
| REWRITE_TAC[COMPLEX_ADD_RINV] THEN | |
| CONV_TAC(DEPTH_BINOP_CONV `==>` | |
| (BINOP_CONV(DEPTH_BINOP_CONV `complex_mul` | |
| (RAND_CONV COMPLEX_POLY_CONV)))) THEN | |
| REWRITE_TAC[CPOW_ADD; CX_NEG; COMPLEX_MUL_LNEG; COMPLEX_MUL_LID] THEN | |
| REWRITE_TAC[CPOW_N; CX_INJ; REAL_OF_NUM_EQ; ARITH_EQ; CSIN_ADD] THEN | |
| REWRITE_TAC[GSYM CX_MUL; GSYM CX_SIN; GSYM CX_COS; SIN_PI2; COS_PI2; | |
| REAL_ARITH `&1 / &2 * x = x / &2`] THEN | |
| CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `?h. h holomorphic_on (:complex) /\ | |
| !z. z IN (:complex) ==> g z = cexp(h z)` | |
| MP_TAC THENL | |
| [MATCH_MP_TAC(REWRITE_RULE[RIGHT_IMP_FORALL_THM; IMP_IMP] | |
| CONTRACTIBLE_IMP_HOLOMORPHIC_LOG) THEN | |
| ASM_REWRITE_TAC[CONTRACTIBLE_UNIV; IN_UNIV] THEN | |
| X_GEN_TAC `z:complex` THEN EXPAND_TAC "g" THEN | |
| COND_CASES_TAC THEN REWRITE_TAC[CX_INJ; PI_NZ] THEN | |
| REWRITE_TAC[CGAMMA_EQ_0; CSIN_EQ_0; COMPLEX_ENTIRE] THEN | |
| REWRITE_TAC[ONCE_REWRITE_RULE[REAL_MUL_SYM] CX_MUL] THEN | |
| REWRITE_TAC[COMPLEX_RING `a - z + b = Cx(&0) <=> z = a + b`] THEN | |
| REWRITE_TAC[COMPLEX_EQ_MUL_LCANCEL; CX_INJ; PI_NZ] THEN | |
| REWRITE_TAC[COMPLEX_RING `z + a = Cx(&0) <=> z = --a`] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_NEG] THEN ASM_MESON_TAC[INTEGER_CLOSED]; | |
| REWRITE_TAC[IN_UNIV] THEN DISCH_THEN(STRIP_ASSUME_TAC o GSYM)] THEN | |
| MP_TAC(ISPECL [`h:complex->complex`; `(:complex)`] | |
| HOLOMORPHIC_ON_OPEN) THEN | |
| ASM_REWRITE_TAC[OPEN_UNIV; IN_UNIV; SKOLEM_THM; LEFT_IMP_EXISTS_THM] THEN | |
| X_GEN_TAC `h':complex->complex` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN | |
| `!z. (h'(z / Cx(&2)) + h'((z + Cx(&1)) / Cx(&2))) / Cx(&2) = h'(z)` | |
| ASSUME_TAC THENL | |
| [X_GEN_TAC `z:complex` THEN MATCH_MP_TAC | |
| (COMPLEX_RING `!a. ~(a = Cx(&0)) /\ a * x = a * y ==> x = y`) THEN | |
| EXISTS_TAC `g(z / Cx(&2)) * g((z + Cx(&1)) / Cx(&2))` THEN | |
| REWRITE_TAC[COMPLEX_ENTIRE] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[CEXP_NZ]; ALL_TAC] THEN | |
| MATCH_MP_TAC COMPLEX_DERIVATIVE_UNIQUE_AT THEN | |
| EXISTS_TAC `\z. g (z / Cx(&2)) * g ((z + Cx(&1)) / Cx(&2)):complex` THEN | |
| EXISTS_TAC `z:complex` THEN CONJ_TAC THENL | |
| [REWRITE_TAC[]; ASM_REWRITE_TAC[]] THEN | |
| FIRST_ASSUM(SUBST1_TAC o SYM o GEN_REWRITE_RULE I [GSYM FUN_EQ_THM]) THEN | |
| REWRITE_TAC[] THEN | |
| ASM GEN_COMPLEX_DIFF_TAC [] THEN | |
| (CONJ_TAC THENL [ASM_REWRITE_TAC[]; CONV_TAC COMPLEX_RING]); | |
| ALL_TAC] THEN | |
| MP_TAC(ISPECL [`h:complex->complex`; `h':complex->complex`; `(:complex)`] | |
| HOLOMORPHIC_DERIVATIVE) THEN | |
| ASM_REWRITE_TAC[OPEN_UNIV] THEN DISCH_TAC THEN | |
| MP_TAC(ISPECL [`h':complex->complex`; `(:complex)`] | |
| HOLOMORPHIC_ON_OPEN) THEN | |
| ASM_REWRITE_TAC[OPEN_UNIV; IN_UNIV; SKOLEM_THM; LEFT_IMP_EXISTS_THM] THEN | |
| X_GEN_TAC `h'':complex->complex` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN | |
| `!z. (h''(z / Cx(&2)) + h''((z + Cx(&1)) / Cx(&2))) / Cx(&4) = h''(z)` | |
| ASSUME_TAC THENL | |
| [X_GEN_TAC `z:complex` THEN | |
| MATCH_MP_TAC COMPLEX_DERIVATIVE_UNIQUE_AT THEN | |
| EXISTS_TAC `\z. (h'(z / Cx(&2)) + h'((z + Cx(&1)) / Cx(&2))) / Cx(&2)` THEN | |
| EXISTS_TAC `z:complex` THEN CONJ_TAC THENL | |
| [REWRITE_TAC[]; ASM_REWRITE_TAC[]] THEN | |
| ASM GEN_COMPLEX_DIFF_TAC [] THEN | |
| (CONJ_TAC THENL [ASM_REWRITE_TAC[ETA_AX]; CONV_TAC COMPLEX_RING]); | |
| ALL_TAC] THEN | |
| MP_TAC(ISPECL [`h':complex->complex`; `h'':complex->complex`; `(:complex)`] | |
| HOLOMORPHIC_DERIVATIVE) THEN | |
| ASM_REWRITE_TAC[OPEN_UNIV] THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `!z. z IN (:complex) ==> h''(z) = Cx(&0)` MP_TAC THENL | |
| [MATCH_MP_TAC ANALYTIC_CONTINUATION THEN | |
| EXISTS_TAC `cball(Cx(&0),&1)` THEN EXISTS_TAC `Cx(&0)` THEN | |
| ASM_REWRITE_TAC[CONNECTED_UNIV; SUBSET_UNIV; IN_UNIV] THEN | |
| SIMP_TAC[INTERIOR_LIMIT_POINT; INTERIOR_CBALL; CENTRE_IN_BALL; | |
| OPEN_UNIV; REAL_LT_01] THEN | |
| MP_TAC(ISPECL [`\z. norm((h'':complex->complex) z)`; `cball(Cx(&0),&1)`] | |
| CONTINUOUS_ATTAINS_SUP) THEN | |
| ASM_REWRITE_TAC[COMPLEX_IN_CBALL_0; COMPACT_CBALL; CBALL_EQ_EMPTY] THEN | |
| REWRITE_TAC[o_DEF] THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN ANTS_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_ON_LIFT_NORM_COMPOSE THEN | |
| ASM_MESON_TAC[HOLOMORPHIC_ON_IMP_CONTINUOUS_ON; CONTINUOUS_ON_SUBSET; | |
| SUBSET_UNIV]; | |
| DISCH_THEN(X_CHOOSE_THEN `w:complex` STRIP_ASSUME_TAC) THEN | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[GSYM COMPLEX_VEC_0] THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `!w:complex. norm(w) <= norm(w) / &2 /\ norm(z) <= norm(w) | |
| ==> z = vec 0`) THEN | |
| EXISTS_TAC `(h'':complex->complex) w` THEN ASM_SIMP_TAC[] THEN | |
| FIRST_X_ASSUM(fun th -> | |
| GEN_REWRITE_TAC (LAND_CONV o RAND_CONV) [GSYM th]) THEN | |
| REWRITE_TAC[COMPLEX_NORM_DIV; COMPLEX_NORM_CX; REAL_ABS_NUM] THEN | |
| MATCH_MP_TAC(NORM_ARITH | |
| `norm(a) <= e /\ norm(b) <= e ==> norm(a + b) / &4 <= e / &2`) THEN | |
| CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| REWRITE_TAC[COMPLEX_NORM_DIV; COMPLEX_NORM_CX; REAL_ABS_NUM] THEN | |
| UNDISCH_TAC `norm(w:complex) <= &1` THEN | |
| MP_TAC(SPEC `&1` COMPLEX_NORM_CX) THEN CONV_TAC NORM_ARITH]; | |
| REWRITE_TAC[IN_UNIV] THEN DISCH_TAC] THEN | |
| MP_TAC(ISPECL [`h':complex->complex`; `(:complex)`] | |
| HAS_COMPLEX_DERIVATIVE_ZERO_CONSTANT) THEN | |
| REWRITE_TAC[CONVEX_UNIV; IN_UNIV] THEN ANTS_TAC THENL | |
| [ASM_MESON_TAC[HAS_COMPLEX_DERIVATIVE_AT_WITHIN]; ALL_TAC] THEN | |
| DISCH_THEN(X_CHOOSE_TAC `a:complex`) THEN | |
| MP_TAC(ISPECL [`\z. (h:complex->complex) z - a * z`; `(:complex)`] | |
| HAS_COMPLEX_DERIVATIVE_ZERO_CONSTANT) THEN | |
| REWRITE_TAC[CONVEX_UNIV; IN_UNIV] THEN ANTS_TAC THENL | |
| [GEN_TAC THEN ASM GEN_COMPLEX_DIFF_TAC[] THEN | |
| ASM_REWRITE_TAC[] THEN CONV_TAC COMPLEX_RING; | |
| REWRITE_TAC[COMPLEX_RING `a - b:complex = c <=> a = b + c`] THEN | |
| DISCH_THEN(X_CHOOSE_TAC `b:complex`)] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPECL [`&1`; `Cx(&0)`]) THEN | |
| MP_TAC(ASSUME `!z:complex. cexp (h z) = g z`) THEN | |
| DISCH_THEN(fun th -> REWRITE_TAC[GSYM th]) THEN | |
| REWRITE_TAC[ ASSUME`!x. (h:complex->complex) x = a * x + b`] THEN | |
| REWRITE_TAC[INTEGER_CLOSED; COMPLEX_ADD_LID; COMPLEX_MUL_RZERO] THEN | |
| REWRITE_TAC[CEXP_ADD; COMPLEX_MUL_RID] THEN | |
| REWRITE_TAC[COMPLEX_RING `a * b = b <=> a = Cx(&1) \/ b = Cx(&0)`] THEN | |
| REWRITE_TAC[CEXP_NZ; CEXP_EQ_1] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC | |
| (X_CHOOSE_THEN `n:real` STRIP_ASSUME_TAC)) THEN | |
| UNDISCH_TAC `!z:complex. cexp(h z) = g z` THEN | |
| ASM_REWRITE_TAC[] THEN ASM_CASES_TAC `n = &0` THENL | |
| [SUBST1_TAC(SYM(SPEC `a:complex` COMPLEX)) THEN | |
| ASM_REWRITE_TAC[REAL_MUL_LZERO; REAL_MUL_RZERO; GSYM CX_DEF] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LZERO; COMPLEX_ADD_LID] THEN | |
| DISCH_THEN(ASSUME_TAC o GSYM) THEN X_GEN_TAC `z:complex` THEN | |
| ASM_CASES_TAC `?n. integer n /\ z = Cx n` THENL | |
| [REWRITE_TAC[complex_div] THEN | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `z = Cx(&0) /\ ((w = Cx(&0)) \/ (y = Cx(&0))) | |
| ==> w * y = p * z`) THEN | |
| REWRITE_TAC[CGAMMA_EQ_0; CSIN_EQ_0; COMPLEX_INV_EQ_0] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[REAL_MUL_SYM; CX_MUL]; ALL_TAC] THEN | |
| REWRITE_TAC[OR_EXISTS_THM; GSYM COMPLEX_ADD_ASSOC] THEN | |
| REWRITE_TAC[COMPLEX_RING `c - z + n = Cx(&0) <=> z = n + c`] THEN | |
| FIRST_X_ASSUM(X_CHOOSE_THEN `m:real` | |
| (CONJUNCTS_THEN2 MP_TAC SUBST1_TAC)) THEN | |
| REWRITE_TAC[integer] THEN DISCH_THEN(X_CHOOSE_THEN `p:num` | |
| (MP_TAC o MATCH_MP (REAL_ARITH `abs x = n ==> x = n \/ x = --n`))) THEN | |
| DISCH_THEN(DISJ_CASES_THEN SUBST_ALL_TAC) THEN | |
| REWRITE_TAC[GSYM CX_ADD; CX_INJ; REAL_OF_NUM_ADD; REAL_OF_NUM_EQ; | |
| REAL_ARITH `--p + n = &0 <=> p = n`] THEN | |
| REWRITE_TAC[EXISTS_OR_THM; GSYM EXISTS_REFL] THEN | |
| REWRITE_TAC[ADD_EQ_0; RIGHT_EXISTS_AND_THM; EXISTS_REFL] THEN | |
| MESON_TAC[num_CASES; ADD1]; | |
| SUBGOAL_THEN `(g:complex->complex) z = g(Cx(&0))` MP_TAC THENL | |
| [ASM_REWRITE_TAC[]; EXPAND_TAC "g"] THEN | |
| ASM_REWRITE_TAC[] THEN | |
| COND_CASES_TAC THENL [ALL_TAC; ASM_MESON_TAC[INTEGER_CLOSED]] THEN | |
| MP_TAC PI_NZ THEN REWRITE_TAC[GSYM CX_INJ] THEN CONV_TAC COMPLEX_FIELD]; | |
| DISCH_THEN(fun th -> | |
| MP_TAC(SPEC `Cx(inv(&4 * n))` th) THEN MP_TAC(SPEC `Cx(&0)` th)) THEN | |
| REWRITE_TAC[COMPLEX_MUL_RZERO; COMPLEX_ADD_LID] THEN | |
| SUBGOAL_THEN `g(Cx(&0)) = Cx pi` SUBST1_TAC THENL | |
| [ASM_MESON_TAC[INTEGER_CLOSED]; ALL_TAC] THEN | |
| REWRITE_TAC[CEXP_ADD] THEN DISCH_THEN SUBST1_TAC THEN | |
| SUBST1_TAC(SYM(SPEC `a:complex` COMPLEX)) THEN | |
| ASM_REWRITE_TAC[] THEN | |
| GEN_REWRITE_TAC (funpow 3 LAND_CONV o RAND_CONV) [complex_mul] THEN | |
| REWRITE_TAC[RE; IM; REAL_MUL_LZERO; IM_CX; RE_CX] THEN | |
| REWRITE_TAC[CEXP_COMPLEX; REAL_ADD_LID] THEN ASM_SIMP_TAC[REAL_FIELD | |
| `~(n = &0) ==> (&2 * n * pi) * inv(&4 * n) = pi / &2`] THEN | |
| REWRITE_TAC[SIN_PI2; COS_PI2; GSYM ii] THEN | |
| REWRITE_TAC[REAL_MUL_RZERO; REAL_SUB_REFL; REAL_EXP_0] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LID] THEN | |
| MATCH_MP_TAC(TAUT `~p ==> p ==> q`) THEN EXPAND_TAC "g" THEN | |
| ASM_SIMP_TAC[CX_INJ; REAL_FIELD | |
| `~(n = &0) ==> (inv(&4 * n) = m <=> &4 * m * n = &1)`] THEN | |
| COND_CASES_TAC THENL | |
| [FIRST_X_ASSUM(X_CHOOSE_THEN `m:real` STRIP_ASSUME_TAC) THEN | |
| FIRST_X_ASSUM(MP_TAC o AP_TERM `abs`) THEN | |
| REWRITE_TAC[REAL_ABS_MUL; REAL_ABS_NUM] THEN | |
| REPEAT(FIRST_X_ASSUM(CHOOSE_TAC o GEN_REWRITE_RULE I [integer])) THEN | |
| ASM_REWRITE_TAC[REAL_OF_NUM_MUL; REAL_OF_NUM_EQ; MULT_EQ_1] THEN | |
| CONV_TAC NUM_REDUCE_CONV; | |
| MATCH_MP_TAC(MESON[] `real y /\ ~real x ==> ~(x = y)`) THEN | |
| SIMP_TAC[GSYM CX_SUB; GSYM CX_MUL; REAL_CX; REAL_SIN; REAL_GAMMA; | |
| REAL_MUL; ONCE_REWRITE_RULE[COMPLEX_MUL_SYM] REAL_MUL_CX] THEN | |
| REWRITE_TAC[PI_NZ; real; IM_II] THEN ARITH_TAC]]);; | |
| let CGAMMA_HALF = prove | |
| (`cgamma(Cx(&1) / Cx(&2)) = Cx(sqrt pi)`, | |
| MP_TAC(SPEC `Cx(&1) / Cx(&2)` CGAMMA_REFLECTION) THEN | |
| REWRITE_TAC[COMPLEX_RING `Cx(&1) - Cx(&1) / Cx(&2) = Cx(&1) / Cx(&2)`] THEN | |
| REWRITE_TAC[GSYM CX_DIV; GSYM CX_MUL; GSYM CX_SIN] THEN | |
| REWRITE_TAC[REAL_ARITH `x * &1 / &2 = x / &2`; SIN_PI2; REAL_DIV_1] THEN | |
| SUBGOAL_THEN `Cx pi = Cx(sqrt pi) pow 2` SUBST1_TAC THENL | |
| [REWRITE_TAC[GSYM CX_POW] THEN AP_TERM_TAC THEN CONV_TAC SYM_CONV THEN | |
| REWRITE_TAC[SQRT_POW2; PI_POS_LE]; | |
| REWRITE_TAC[COMPLEX_RING | |
| `a * a:complex = b pow 2 <=> a = b \/ a = --b`] THEN | |
| STRIP_TAC THEN ASM_REWRITE_TAC[] THEN | |
| MP_TAC(SPEC `Cx(&1 / &2)` RE_POS_CGAMMA_REAL) THEN | |
| ASM_REWRITE_TAC[REAL_CX; RE_CX; RE_NEG] THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN MATCH_MP_TAC(TAUT `~p ==> p ==> q`) THEN | |
| REWRITE_TAC[REAL_ARITH `~(&0 <= --x) <=> &0 < x`] THEN | |
| MATCH_MP_TAC SQRT_POS_LT THEN REWRITE_TAC[PI_POS]]);; | |
| let CGAMMA_LEGENDRE = prove | |
| (`!z. cgamma(z) * cgamma(z + Cx(&1) / Cx(&2)) = | |
| Cx(&2) cpow (Cx(&1) - Cx(&2) * z) * Cx(sqrt pi) * cgamma(Cx(&2) * z)`, | |
| REWRITE_TAC[CGAMMA_LEGENDRE_ALT; CGAMMA_HALF]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Thw Weierstrass product definition. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let CGAMMA_WEIERSTRASS = prove | |
| (`!z. ((\n. cexp(--(Cx euler_mascheroni) * z) / z * | |
| cproduct(1..n) (\k. cexp(z / Cx(&k)) / (Cx(&1) + z / Cx(&k)))) | |
| --> cgamma z) sequentially`, | |
| GEN_TAC THEN SIMP_TAC[complex_div; CPRODUCT_MUL; FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\n. (cexp(--Cx euler_mascheroni * z) * | |
| cproduct(1..n) (\k. cexp(z * inv(Cx(&k)))) * | |
| cexp(--Cx(log(&n)) * z)) * | |
| (Cx(&n) cpow z / z * | |
| cproduct (1..n) (\k. inv(Cx(&1) + z * inv(Cx(&k)))))` THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN CONJ_TAC THENL | |
| [EXISTS_TAC `1` THEN REPEAT STRIP_TAC THEN REWRITE_TAC[complex_div] THEN | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `c * c' = Cx(&1) ==> (a * b * c) * (c' * d) * e = ((a * d) * b * e)`) THEN | |
| ASM_SIMP_TAC[cpow; CX_INJ; REAL_OF_NUM_EQ; LE_1; GSYM CEXP_ADD] THEN | |
| REWRITE_TAC[GSYM CEXP_0] THEN AP_TERM_TAC THEN | |
| ASM_SIMP_TAC[CX_LOG; REAL_OF_NUM_LT; LE_1] THEN CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_MUL_LID] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_MUL THEN CONJ_TAC THENL | |
| [SIMP_TAC[GSYM CEXP_VSUM; FINITE_NUMSEG; GSYM CEXP_ADD] THEN | |
| REWRITE_TAC[GSYM CEXP_0] THEN | |
| MATCH_MP_TAC(ISPEC `cexp` LIM_CONTINUOUS_FUNCTION) THEN | |
| SIMP_TAC[CONTINUOUS_AT_CEXP; VSUM_COMPLEX_LMUL; FINITE_NUMSEG] THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `--w * z + z * x + --y * z:complex = z * ((x - y) - w)`] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| REWRITE_TAC[GSYM LIM_NULL_COMPLEX] THEN | |
| REWRITE_TAC[GSYM CX_INV; VSUM_CX] THEN | |
| REWRITE_TAC[GSYM CX_SUB; REWRITE_RULE[o_DEF] (GSYM REALLIM_COMPLEX)] THEN | |
| REWRITE_TAC[EULER_MASCHERONI]; | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN EXISTS_TAC | |
| `\n. (Cx(&n) cpow z * Cx(&(FACT n))) / | |
| cproduct(0..n) (\m. z + Cx(&m))` THEN | |
| REWRITE_TAC[CGAMMA] THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| SIMP_TAC[CPRODUCT_CLAUSES_LEFT; LE_0] THEN | |
| REWRITE_TAC[COMPLEX_ADD_RID; ADD_CLAUSES] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_INV_MUL; GSYM COMPLEX_MUL_ASSOC] THEN | |
| AP_TERM_TAC THEN GEN_REWRITE_TAC LAND_CONV | |
| [COMPLEX_RING `a * b * c:complex = b * a * c`] THEN | |
| AP_TERM_TAC THEN SIMP_TAC[CPRODUCT_INV; FINITE_NUMSEG] THEN | |
| GEN_REWRITE_TAC (LAND_CONV o LAND_CONV) [GSYM COMPLEX_INV_INV] THEN | |
| REWRITE_TAC[GSYM COMPLEX_INV_MUL] THEN AP_TERM_TAC THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD | |
| `~(z = Cx(&0)) /\ z * x = y ==> inv z * y = x`) THEN | |
| REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ; FACT_NZ] THEN | |
| CONV_TAC SYM_CONV THEN SPEC_TAC(`n:num`,`p:num`) THEN | |
| INDUCT_TAC THEN REWRITE_TAC[FACT; CPRODUCT_CLAUSES_NUMSEG; ARITH] THEN | |
| REWRITE_TAC[ARITH_RULE `1 <= SUC n`; COMPLEX_MUL_LID] THEN | |
| ASM_REWRITE_TAC[CX_MUL; GSYM REAL_OF_NUM_MUL] THEN | |
| MATCH_MP_TAC(COMPLEX_RING | |
| `d * e:complex = c ==> (a * b) * c = (d * a) * b * e`) THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD | |
| `~(p = Cx(&0)) ==> p * (Cx(&1) + z * inv p) = z + p`) THEN | |
| REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ; NOT_SUC]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Sometimes the reciprocal function is convenient, since it's entire. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let COMPLEX_DIFFERENTIABLE_AT_RECIP_CGAMMA = prove | |
| (`!z. (inv o cgamma) complex_differentiable (at z)`, | |
| GEN_TAC THEN ASM_CASES_TAC `!n. ~(z + Cx(&n) = Cx(&0))` THENL | |
| [MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_COMPOSE_AT THEN | |
| ASM_SIMP_TAC[COMPLEX_DIFFERENTIABLE_AT_CGAMMA] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM ETA_AX] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_INV_AT THEN | |
| REWRITE_TAC[COMPLEX_DIFFERENTIABLE_ID; CGAMMA_EQ_0] THEN | |
| ASM_MESON_TAC[]; | |
| FIRST_X_ASSUM(MP_TAC o GEN_REWRITE_RULE I [NOT_FORALL_THM]) THEN | |
| REWRITE_TAC[COMPLEX_RING `z + w = Cx(&0) <=> z = --w`] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `n:num` SUBST1_TAC) THEN | |
| REWRITE_TAC[complex_differentiable; HAS_COMPLEX_DERIVATIVE_AT] THEN | |
| REWRITE_TAC[o_DEF; CGAMMA_POLES; COMPLEX_INV_0; complex_div; | |
| COMPLEX_MUL_LZERO; COMPLEX_SUB_RZERO] THEN | |
| SIMP_TAC[GSYM COMPLEX_INV_MUL; COMPLEX_RING `x - --z:complex = x + z`] THEN | |
| EXISTS_TAC `inv(--Cx(&1) pow n / Cx(&(FACT n)))` THEN | |
| MATCH_MP_TAC LIM_COMPLEX_INV THEN | |
| REWRITE_TAC[COMPLEX_DIV_EQ_0; COMPLEX_POW_EQ_0; CX_INJ] THEN | |
| REWRITE_TAC[REAL_OF_NUM_EQ; FACT_NZ] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_MUL_SYM] THEN | |
| REWRITE_TAC[CGAMMA_SIMPLE_POLES] THEN CONV_TAC COMPLEX_RING]);; | |
| let COMPLEX_DIFFERENTIABLE_WITHIN_RECIP_CGAMMA = prove | |
| (`!z s. (inv o cgamma) complex_differentiable at z within s`, | |
| SIMP_TAC[COMPLEX_DIFFERENTIABLE_AT_WITHIN; | |
| COMPLEX_DIFFERENTIABLE_AT_RECIP_CGAMMA]);; | |
| let HOLOMORPHIC_ON_RECIP_CGAMMA = prove | |
| (`!s. (inv o cgamma) holomorphic_on s`, | |
| REWRITE_TAC[HOLOMORPHIC_ON_DIFFERENTIABLE] THEN | |
| REWRITE_TAC[COMPLEX_DIFFERENTIABLE_WITHIN_RECIP_CGAMMA]);; | |
| let CONTINUOUS_AT_RECIP_CGAMMA = prove | |
| (`!z. (inv o cgamma) continuous at z`, | |
| SIMP_TAC[COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_AT; | |
| COMPLEX_DIFFERENTIABLE_AT_RECIP_CGAMMA]);; | |
| let CONTINUOUS_WITHIN_RECIP_CGAMMA = prove | |
| (`!z s. (inv o cgamma) continuous at z within s`, | |
| SIMP_TAC[COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_WITHIN; | |
| COMPLEX_DIFFERENTIABLE_WITHIN_RECIP_CGAMMA]);; | |
| let CONTINUOUS_ON_RECIP_CGAMMA = prove | |
| (`!s. (inv o cgamma) continuous_on s`, | |
| SIMP_TAC[HOLOMORPHIC_ON_IMP_CONTINUOUS_ON; HOLOMORPHIC_ON_RECIP_CGAMMA]);; | |
| let RECIP_CGAMMA = prove | |
| (`!z. ((\n. cproduct(0..n) (\m. z + Cx(&m)) / | |
| (Cx(&n) cpow z * Cx(&(FACT n)))) --> inv(cgamma z)) | |
| sequentially`, | |
| GEN_TAC THEN ASM_CASES_TAC `!n. ~(z + Cx(&n) = Cx(&0))` THENL | |
| [ONCE_REWRITE_TAC[GSYM COMPLEX_INV_INV] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_INV THEN | |
| REWRITE_TAC[COMPLEX_INV_INV; CGAMMA; COMPLEX_INV_DIV; CGAMMA_EQ_0] THEN | |
| ASM_MESON_TAC[]; | |
| SUBGOAL_THEN `cgamma z = Cx(&0)` SUBST1_TAC THENL | |
| [ASM_MESON_TAC[CGAMMA_EQ_0]; REWRITE_TAC[COMPLEX_INV_0]] THEN | |
| MATCH_MP_TAC LIM_EVENTUALLY THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY; COMPLEX_DIV_EQ_0; COMPLEX_ENTIRE] THEN | |
| SIMP_TAC[CPRODUCT_EQ_0; IN_NUMSEG; FINITE_NUMSEG; LE_0] THEN | |
| ASM_MESON_TAC[]]);; | |
| let RECIP_CGAMMA_WEIERSTRASS = prove | |
| (`!n. ((\n. (z * cexp(Cx euler_mascheroni * z) * | |
| cproduct(1..n) (\k. (Cx(&1) + z / Cx(&k)) / cexp(z / Cx(&k))))) | |
| --> inv(cgamma z)) sequentially`, | |
| GEN_TAC THEN ASM_CASES_TAC `?n. z + Cx(&n) = Cx(&0)` THENL | |
| [FIRST_X_ASSUM(X_CHOOSE_TAC `N:num`) THEN | |
| MATCH_MP_TAC LIM_EVENTUALLY THEN REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `N:num` THEN X_GEN_TAC `n:num` THEN REWRITE_TAC[GE] THEN | |
| DISCH_TAC THEN SUBGOAL_THEN `cgamma(z) = Cx(&0)` SUBST1_TAC THENL | |
| [ASM_MESON_TAC[CGAMMA_EQ_0]; REWRITE_TAC[COMPLEX_INV_0]] THEN | |
| REWRITE_TAC[COMPLEX_ENTIRE; COMPLEX_DIV_EQ_0] THEN | |
| ASM_CASES_TAC `N = 0` THENL [ASM_MESON_TAC[COMPLEX_ADD_RID]; ALL_TAC] THEN | |
| REPEAT DISJ2_TAC THEN | |
| SIMP_TAC[CPRODUCT_EQ_0; FINITE_NUMSEG; IN_NUMSEG] THEN | |
| EXISTS_TAC `N:num` THEN ASM_SIMP_TAC[LE_1; COMPLEX_DIV_EQ_0] THEN | |
| DISJ1_TAC THEN MATCH_MP_TAC(COMPLEX_FIELD | |
| `x + n = Cx(&0) /\ ~(n = Cx(&0)) ==> Cx(&1) + x / n = Cx(&0)`) THEN | |
| ASM_REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ]; | |
| GEN_REWRITE_TAC (RATOR_CONV o LAND_CONV o ABS_CONV) | |
| [GSYM COMPLEX_INV_INV] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_INV THEN | |
| ASM_REWRITE_TAC[CGAMMA_EQ_0] THEN | |
| SIMP_TAC[COMPLEX_INV_MUL; GSYM CEXP_NEG; GSYM CPRODUCT_INV; | |
| FINITE_NUMSEG; GSYM COMPLEX_MUL_LNEG; COMPLEX_INV_DIV] THEN | |
| REWRITE_TAC[SIMPLE_COMPLEX_ARITH `inv z * a * b:complex = a / z * b`] THEN | |
| REWRITE_TAC[CGAMMA_WEIERSTRASS]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The real gamma function. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let gamma = new_definition | |
| `gamma(x) = Re(cgamma(Cx x))`;; | |
| let CX_GAMMA = prove | |
| (`!x. Cx(gamma x) = cgamma(Cx x)`, | |
| REWRITE_TAC[gamma] THEN MESON_TAC[REAL; REAL_CX; REAL_GAMMA]);; | |
| let GAMMA = prove | |
| (`!x. ((\n. (&n rpow x * &(FACT n)) / product(0..n) (\m. x + &m)) | |
| ---> gamma(x)) sequentially`, | |
| REWRITE_TAC[REALLIM_COMPLEX; o_DEF; CX_GAMMA; CX_DIV] THEN | |
| X_GEN_TAC `x:real` THEN MP_TAC(SPEC `Cx x` CGAMMA) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| SIMP_TAC[CX_MUL; CX_PRODUCT; FINITE_NUMSEG; CX_ADD; cpow; rpow; | |
| CX_INJ; REAL_OF_NUM_EQ; REAL_OF_NUM_LT; LE_1; CX_LOG; CX_EXP]);; | |
| let GAMMA_EQ_0 = prove | |
| (`!x. gamma(x) = &0 <=> ?n. x + &n = &0`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_ADD; CX_GAMMA; CGAMMA_EQ_0]);; | |
| let REAL_DIFFERENTIABLE_AT_GAMMA = prove | |
| (`!x. (!n. ~(x + &n = &0)) ==> gamma real_differentiable atreal x`, | |
| REPEAT STRIP_TAC THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM ETA_AX] THEN | |
| REWRITE_TAC[gamma] THEN | |
| MATCH_MP_TAC (REWRITE_RULE[o_DEF] REAL_DIFFERENTIABLE_FROM_COMPLEX_AT) THEN | |
| REWRITE_TAC[REAL_GAMMA] THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_AT_CGAMMA THEN | |
| ASM_REWRITE_TAC[GSYM CX_ADD; CX_INJ]);; | |
| let REAL_DIFFERENTIABLE_WITHIN_GAMMA = prove | |
| (`!x s. (!n. ~(x + &n = &0)) ==> gamma real_differentiable atreal x within s`, | |
| SIMP_TAC[REAL_DIFFERENTIABLE_AT_GAMMA; | |
| REAL_DIFFERENTIABLE_ATREAL_WITHIN]);; | |
| let REAL_DIFFERENTIABLE_ON_GAMMA = prove | |
| (`!s. s SUBSET {x | !n. ~(x + &n = &0)} ==> gamma real_differentiable_on s`, | |
| SIMP_TAC[SUBSET; IN_ELIM_THM; REAL_DIFFERENTIABLE_ON_DIFFERENTIABLE; | |
| REAL_DIFFERENTIABLE_WITHIN_GAMMA]);; | |
| let REAL_CONTINUOUS_ATREAL_GAMMA = prove | |
| (`!x. (!n. ~(x + &n = &0)) ==> gamma real_continuous atreal x`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_COMPLEX_CONTINUOUS_ATREAL] THEN | |
| REWRITE_TAC[o_DEF; CX_GAMMA] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM o_DEF] THEN | |
| MATCH_MP_TAC CONTINUOUS_WITHIN_COMPOSE THEN | |
| SIMP_TAC[LINEAR_CONTINUOUS_WITHIN; REWRITE_RULE[o_DEF] LINEAR_CX_RE] THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_WITHIN THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_CGAMMA THEN | |
| ASM_REWRITE_TAC[GSYM CX_ADD; RE_CX; CX_INJ]);; | |
| let REAL_CONTINUOUS_WITHIN_GAMMA = prove | |
| (`!x s. (!n. ~(x + &n = &0)) ==> gamma real_continuous atreal x within s`, | |
| SIMP_TAC[REAL_CONTINUOUS_ATREAL_WITHINREAL; REAL_CONTINUOUS_ATREAL_GAMMA]);; | |
| let REAL_CONTINUOUS_ON_GAMMA = prove | |
| (`!s. s SUBSET {x | !n. ~(x + &n = &0)} ==> gamma real_continuous_on s`, | |
| SIMP_TAC[SUBSET; IN_ELIM_THM; REAL_CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN; | |
| REAL_CONTINUOUS_WITHIN_GAMMA]);; | |
| let REAL_DIFFERENTIABLE_ATREAL_RECIP_GAMMA = prove | |
| (`!x. (inv o gamma) real_differentiable (atreal x)`, | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[o_DEF; gamma] THEN | |
| MATCH_MP_TAC REAL_DIFFERENTIABLE_TRANSFORM_ATREAL THEN | |
| EXISTS_TAC `\x. Re(inv(cgamma(Cx x)))` THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01] THEN CONJ_TAC THENL | |
| [REWRITE_TAC[GSYM CX_GAMMA; GSYM CX_INV; RE_CX]; | |
| MATCH_MP_TAC (REWRITE_RULE[o_DEF] REAL_DIFFERENTIABLE_FROM_COMPLEX_AT) THEN | |
| SIMP_TAC[REAL_GAMMA; REAL_INV; GSYM o_DEF] THEN | |
| REWRITE_TAC[COMPLEX_DIFFERENTIABLE_AT_RECIP_CGAMMA]]);; | |
| let REAL_DIFFERENTIABLE_WITHIN_RECIP_GAMMA = prove | |
| (`!x s. (inv o gamma) real_differentiable atreal x within s`, | |
| SIMP_TAC[REAL_DIFFERENTIABLE_ATREAL_WITHIN; | |
| REAL_DIFFERENTIABLE_ATREAL_RECIP_GAMMA]);; | |
| let REAL_DIFFERENTIABLE_ON_RECIP_GAMMA = prove | |
| (`!s. (inv o gamma) real_differentiable_on s`, | |
| REWRITE_TAC[REAL_DIFFERENTIABLE_ON_DIFFERENTIABLE; | |
| REAL_DIFFERENTIABLE_WITHIN_RECIP_GAMMA]);; | |
| let REAL_CONTINUOUS_ATREAL_RECIP_GAMMA = prove | |
| (`!x. (inv o gamma) real_continuous atreal x`, | |
| SIMP_TAC[REAL_DIFFERENTIABLE_IMP_CONTINUOUS_ATREAL; | |
| REAL_DIFFERENTIABLE_ATREAL_RECIP_GAMMA]);; | |
| let REAL_CONTINUOUS_WITHINREAL_RECIP_GAMMA = prove | |
| (`!x s. (inv o gamma) real_continuous atreal x within s`, | |
| SIMP_TAC[REAL_CONTINUOUS_ATREAL_WITHINREAL; | |
| REAL_CONTINUOUS_ATREAL_RECIP_GAMMA]);; | |
| let REAL_CONTINUOUS_ON_RECIP_GAMMA = prove | |
| (`!s. (inv o gamma) real_continuous_on s`, | |
| REWRITE_TAC[REAL_CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN; | |
| REAL_CONTINUOUS_WITHINREAL_RECIP_GAMMA]);; | |
| let GAMMA_RECURRENCE_ALT = prove | |
| (`!x. gamma(x) = gamma(x + &1) / x`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_DIV; CX_GAMMA; CX_ADD] THEN | |
| REWRITE_TAC[GSYM CGAMMA_RECURRENCE_ALT]);; | |
| let GAMMA_1 = prove | |
| (`gamma(&1) = &1`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_GAMMA; CGAMMA_1]);; | |
| let GAMMA_RECURRENCE = prove | |
| (`!x. gamma(x + &1) = if x = &0 then &1 else x * gamma(x)`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_GAMMA] THEN | |
| GEN_TAC THEN GEN_REWRITE_TAC RAND_CONV [COND_RAND] THEN | |
| REWRITE_TAC[CX_MUL; CX_GAMMA; CX_ADD; GSYM CGAMMA_RECURRENCE]);; | |
| let GAMMA_FACT = prove | |
| (`!n. gamma(&(n + 1)) = &(FACT n)`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_GAMMA; CGAMMA_FACT]);; | |
| let GAMMA_POLES = prove | |
| (`!n. gamma(--(&n)) = &0`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_GAMMA; CGAMMA_POLES; CX_NEG]);; | |
| let GAMMA_SIMPLE_POLES = prove | |
| (`!n. ((\x. (x + &n) * gamma x) ---> -- &1 pow n / &(FACT n)) | |
| (atreal(-- &n))`, | |
| REWRITE_TAC[REALLIM_COMPLEX; o_DEF; LIM_ATREAL_ATCOMPLEX] THEN | |
| GEN_TAC THEN | |
| REWRITE_TAC[CX_MUL; CX_ADD; CX_GAMMA; CX_DIV; CX_POW; CX_NEG] THEN | |
| SUBGOAL_THEN | |
| `(\z. (Cx(Re z) + Cx(&n)) * cgamma(Cx(Re z))) = | |
| (\z. (z + Cx(&n)) * cgamma z) o (Cx o Re)` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_COMPOSE_WITHIN THEN | |
| MAP_EVERY EXISTS_TAC [`(:complex)`; `--Cx(&n)`] THEN | |
| REWRITE_TAC[CGAMMA_SIMPLE_POLES; WITHIN_UNIV] THEN | |
| REWRITE_TAC[EVENTUALLY_WITHIN; o_DEF; IN_UNIV; GSYM DIST_NZ] THEN | |
| REWRITE_TAC[real; IN; GSYM CX_NEG; CX_INJ] THEN | |
| REWRITE_TAC[COMPLEX_EQ; RE_CX; IM_CX] THEN | |
| CONJ_TAC THENL [ALL_TAC; MESON_TAC[REAL_LT_01]] THEN | |
| MATCH_MP_TAC LIM_AT_WITHIN THEN LIM_TAC THEN REWRITE_TAC[RE_CX] THEN | |
| MATCH_MP_TAC LINEAR_CONTINUOUS_AT THEN | |
| REWRITE_TAC[REWRITE_RULE[o_DEF] LINEAR_CX_RE]);; | |
| let GAMMA_POS_LE = prove | |
| (`!x. &0 <= x ==> &0 <= gamma x`, | |
| SIMP_TAC[gamma; RE_POS_CGAMMA_REAL; RE_CX; REAL_CX]);; | |
| let GAMMA_POS_LT = prove | |
| (`!x. &0 < x ==> &0 < gamma x`, | |
| SIMP_TAC[REAL_ARITH `&0 < x <=> &0 <= x /\ ~(x = &0)`; GAMMA_POS_LE] THEN | |
| REWRITE_TAC[GAMMA_EQ_0] THEN REAL_ARITH_TAC);; | |
| let GAMMA_LEGENDRE_ALT = prove | |
| (`!x. gamma(x) * gamma(x + &1 / &2) = | |
| &2 rpow (&1 - &2 * x) * gamma(&1 / &2) * gamma(&2 * x)`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_GAMMA; CX_ADD; | |
| CX_DIV; CGAMMA_LEGENDRE_ALT; CX_MUL] THEN | |
| REWRITE_TAC[cpow; rpow; CX_INJ; REAL_OF_NUM_LT; REAL_OF_NUM_EQ; ARITH] THEN | |
| SIMP_TAC[CX_MUL; CX_EXP; CX_SUB; CX_LOG; REAL_OF_NUM_LT; ARITH]);; | |
| let GAMMA_REFLECTION = prove | |
| (`!x. gamma(x) * gamma(&1 - x) = pi / sin(pi * x)`, | |
| SIMP_TAC[GSYM CX_INJ; CX_MUL; CX_DIV; CX_GAMMA; CX_SIN; CX_SUB] THEN | |
| REWRITE_TAC[CGAMMA_REFLECTION]);; | |
| let GAMMA_HALF = prove | |
| (`gamma(&1 / &2) = sqrt pi`, | |
| REWRITE_TAC[GSYM CX_INJ; CX_DIV; CX_GAMMA; CGAMMA_HALF]);; | |
| let GAMMA_LEGENDRE = prove | |
| (`!x. gamma(x) * gamma(x + &1 / &2) = | |
| &2 rpow (&1 - &2 * x) * sqrt pi * gamma(&2 * x)`, | |
| REWRITE_TAC[GAMMA_LEGENDRE_ALT; GAMMA_HALF]);; | |
| let GAMMA_WEIERSTRASS = prove | |
| (`!x. ((\n. exp(--(euler_mascheroni) * x) / x * | |
| product(1..n) (\k. exp(x / &k) / (&1 + x / &k))) | |
| ---> gamma x) sequentially`, | |
| REWRITE_TAC[REALLIM_COMPLEX; o_DEF; CX_GAMMA; CX_DIV] THEN | |
| X_GEN_TAC `x:real` THEN MP_TAC(SPEC `Cx x` CGAMMA_WEIERSTRASS) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| SIMP_TAC[CX_MUL; CX_DIV; CX_EXP; CX_NEG; CX_PRODUCT; FINITE_NUMSEG; | |
| CX_ADD]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Characterization of the real gamma function using log-convexity. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let REAL_LOG_CONVEX_GAMMA = prove | |
| (`!s. (!x. x IN s ==> &0 < x) ==> gamma real_log_convex_on s`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LOG_CONVEX_ON_SUBSET THEN | |
| EXISTS_TAC `{x | &0 < x}` THEN | |
| ASM_REWRITE_TAC[SUBSET; IN_ELIM_THM] THEN POP_ASSUM(K ALL_TAC) THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` REAL_LOG_CONVEX_LIM) THEN | |
| EXISTS_TAC `\n x. (&n rpow x * &(FACT n)) / product(0..n) (\m. x + &m)` THEN | |
| REWRITE_TAC[GAMMA; TRIVIAL_LIMIT_SEQUENTIALLY; EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `1` THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| REWRITE_TAC[real_div; GSYM REAL_MUL_ASSOC] THEN | |
| REPEAT(MATCH_MP_TAC REAL_LOG_CONVEX_MUL THEN CONJ_TAC) THEN | |
| SIMP_TAC[REAL_LOG_CONVEX_CONST; REAL_POS] THEN | |
| ASM_SIMP_TAC[REAL_LOG_CONVEX_RPOW_RIGHT; REAL_OF_NUM_LT; LE_1] THEN | |
| SIMP_TAC[GSYM PRODUCT_INV; FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC REAL_LOG_CONVEX_PRODUCT THEN | |
| REWRITE_TAC[FINITE_NUMSEG; IN_NUMSEG] THEN X_GEN_TAC `k:num` THEN | |
| STRIP_TAC THEN | |
| MATCH_MP_TAC MIDPOINT_REAL_LOG_CONVEX THEN | |
| ASM_SIMP_TAC[IN_ELIM_THM; REAL_LT_INV_EQ; REAL_LTE_ADD; REAL_POS] THEN | |
| REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_DIFFERENTIABLE_ON_IMP_REAL_CONTINUOUS_ON THEN | |
| REWRITE_TAC[REAL_DIFFERENTIABLE_ON_DIFFERENTIABLE; IN_ELIM_THM] THEN | |
| REPEAT STRIP_TAC THEN REAL_DIFFERENTIABLE_TAC THEN ASM_REAL_ARITH_TAC; | |
| REWRITE_TAC[is_realinterval; IN_ELIM_THM] THEN REAL_ARITH_TAC; | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[GSYM REAL_INV_MUL; REAL_POW_INV] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN | |
| ASM_SIMP_TAC[REAL_LT_MUL; REAL_LTE_ADD; REAL_POS] THEN | |
| REWRITE_TAC[REAL_LE_POW_2; REAL_ARITH | |
| `(x + &k) * (y + &k) <= ((x + y) / &2 + &k) pow 2 <=> | |
| &0 <= (x - y) pow 2`]]);; | |
| let GAMMA_REAL_LOG_CONVEX_UNIQUE = prove | |
| (`!f:real->real. | |
| f(&1) = &1 /\ (!x. &0 < x ==> f(x + &1) = x * f(x)) /\ | |
| (!x. &0 < x ==> &0 < f x) /\ f real_log_convex_on {x | &0 < x} | |
| ==> !x. &0 < x ==> f x = gamma x`, | |
| GEN_TAC THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `!x. &0 < x /\ x <= &1 ==> f x = gamma x` ASSUME_TAC THENL | |
| [ALL_TAC; | |
| SUBGOAL_THEN | |
| `!y. &0 < y /\ y <= &1 ==> !n. f(&n + y) = gamma(&n + y)` | |
| ASSUME_TAC THENL | |
| [GEN_TAC THEN STRIP_TAC THEN | |
| INDUCT_TAC THEN ASM_SIMP_TAC[REAL_ADD_LID] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_SUC] THEN | |
| REWRITE_TAC[REAL_ARITH `(n + &1) + x = (n + x) + &1`] THEN | |
| ASM_SIMP_TAC[GAMMA_RECURRENCE; REAL_LET_ADD; REAL_POS] THEN | |
| ASM_REAL_ARITH_TAC; | |
| X_GEN_TAC `x:real` THEN DISCH_TAC THEN | |
| MP_TAC(SPEC `x:real` FLOOR_POS) THEN ASM_SIMP_TAC[REAL_LT_IMP_LE] THEN | |
| DISCH_THEN(X_CHOOSE_TAC `n:num`) THEN | |
| MP_TAC(SPEC `x:real` FLOOR_FRAC) THEN ASM_REWRITE_TAC[] THEN | |
| ASM_CASES_TAC `frac x = &0` THEN ASM_REWRITE_TAC[REAL_LT_LE] THENL | |
| [ASM_CASES_TAC `n = 0` THEN | |
| ASM_SIMP_TAC[REAL_ADD_RID; REAL_LT_IMP_NZ] THEN | |
| SUBGOAL_THEN `&(n - 1) + &1 = &n` | |
| (fun th -> ASM_MESON_TAC[th; REAL_LE_REFL; REAL_LT_01]) THEN | |
| ASM_SIMP_TAC[GSYM REAL_OF_NUM_SUB; LE_1] THEN REAL_ARITH_TAC; | |
| STRIP_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC `frac x`) THEN | |
| ANTS_TAC THENL [ASM_REAL_ARITH_TAC; ASM_MESON_TAC[]]]]] THEN | |
| X_GEN_TAC `x:real` THEN STRIP_TAC THEN | |
| ASM_CASES_TAC `x = &1` THEN ASM_REWRITE_TAC[GAMMA_1] THEN | |
| SUBGOAL_THEN `&0 < x` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC(REAL_FIELD `&0 < g /\ f / g = &1 ==> f = g`) THEN | |
| ASM_SIMP_TAC[GAMMA_POS_LT] THEN | |
| MATCH_MP_TAC(ISPEC `sequentially` REALLIM_UNIQUE) THEN | |
| EXISTS_TAC | |
| `\n. f(x) / ((&n rpow x * &(FACT n)) / product (0..n) (\m. x + &m))` THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN | |
| ASM_SIMP_TAC[REALLIM_DIV; REALLIM_CONST; GAMMA_POS_LT; | |
| GAMMA; REAL_LT_IMP_NZ] THEN | |
| ONCE_REWRITE_TAC[REALLIM_NULL] THEN | |
| MATCH_MP_TAC REALLIM_NULL_COMPARISON THEN | |
| EXISTS_TAC `\n. x * inv(&n)` THEN | |
| SIMP_TAC[REALLIM_NULL_LMUL; REALLIM_1_OVER_N] THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `2` THEN | |
| SUBGOAL_THEN | |
| `!n. &2 <= &n | |
| ==> log(f(&n)) - log(f(&n - &1)) | |
| <= (log(f(&n + x)) - log(f(&n))) / x /\ | |
| (log(f(&n + x)) - log(f(&n))) / x | |
| <= log(f(&n + &1)) - log(f(&n))` | |
| MP_TAC THENL | |
| [MP_TAC(SPECL [`f:real->real`; `{x | &0 < x}`] REAL_LOG_CONVEX_ON) THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM] THEN ANTS_TAC THENL | |
| [REWRITE_TAC[is_realinterval; IN_ELIM_THM] THEN REAL_ARITH_TAC; | |
| DISCH_TAC] THEN | |
| MAP_EVERY (MP_TAC o SPECL [`log o f:real->real`; `{x | &0 < x}`]) | |
| [REAL_CONVEX_ON_LEFT_SECANT; REAL_CONVEX_ON_RIGHT_SECANT] THEN | |
| ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(LABEL_TAC "L") THEN DISCH_THEN(LABEL_TAC "R") THEN | |
| REPEAT STRIP_TAC THENL | |
| [USE_THEN "L" (MP_TAC o SPECL [`&n - &1`; `&n + x`; `&n`]) THEN | |
| USE_THEN "R" (MP_TAC o SPECL [`&n - &1`; `&n + x`; `&n`]) THEN | |
| REWRITE_TAC[IN_ELIM_THM; IN_REAL_SEGMENT; o_THM] THEN | |
| ANTS_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[REAL_ARITH `abs(x - (x - &1)) = &1`; REAL_DIV_1] THEN | |
| DISCH_TAC THEN ANTS_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[REAL_ARITH `&0 < x ==> abs((n + x) - n) = x`] THEN | |
| ASM_REAL_ARITH_TAC; | |
| ASM_CASES_TAC `x = &1` THEN | |
| ASM_REWRITE_TAC[REAL_LE_REFL; REAL_DIV_1] THEN | |
| USE_THEN "R" (MP_TAC o SPECL [`&n`; `&n + &1`; `&n + x`]) THEN | |
| REWRITE_TAC[IN_ELIM_THM; IN_REAL_SEGMENT; o_THM] THEN | |
| ANTS_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[REAL_ARITH `abs((n + &1) - n) = &1`; REAL_DIV_1] THEN | |
| ASM_SIMP_TAC[REAL_ARITH `&0 < x ==> abs((n + x) - n) = x`] THEN | |
| ASM_REAL_ARITH_TAC]; | |
| ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM LOG_DIV; REAL_LT_MUL; | |
| REAL_ARITH `&2 <= x ==> &0 < x /\ &0 < x + &1 /\ &0 < x - &1`; | |
| REAL_FIELD `&0 < x ==> (n * x) / x = n`] THEN | |
| SUBGOAL_THEN | |
| `!n. &2 <= n ==> f(n - &1) = f(n) / (n - &1)` (fun th -> SIMP_TAC[th]) | |
| THENL | |
| [REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `(f:real->real) n = f((n - &1) + &1)` SUBST1_TAC THENL | |
| [AP_TERM_TAC THEN REAL_ARITH_TAC; | |
| ASM_SIMP_TAC[REAL_ARITH `&2 <= n ==> &0 < n - &1`] THEN | |
| UNDISCH_TAC `&2 <= n` THEN CONV_TAC REAL_FIELD]; | |
| ASM_SIMP_TAC[REAL_ARITH `&2 <= x ==> &0 < x`; REAL_FIELD | |
| `&0 < x /\ &2 <= y ==> x / (x / (y - &1)) = y - &1`] THEN | |
| ASM_SIMP_TAC[REAL_LE_LDIV_EQ; REAL_LE_RDIV_EQ]] THEN | |
| SIMP_TAC[REAL_OF_NUM_LE; REAL_OF_NUM_SUB; | |
| ARITH_RULE `2 <= n ==> 1 <= n`] THEN | |
| REWRITE_TAC[REAL_LE_SUB_LADD; REAL_LE_SUB_RADD] THEN | |
| SUBGOAL_THEN | |
| `!n. 0 < n ==> f(&n) = &(FACT(n - 1))` | |
| (fun th -> SIMP_TAC[ARITH_RULE `2 <= n ==> 0 < n /\ 0 < n - 1`; th]) | |
| THENL | |
| [INDUCT_TAC THEN REWRITE_TAC[ARITH; LT_0] THEN | |
| ASM_CASES_TAC `n = 0` THEN | |
| ASM_REWRITE_TAC[REAL_ADD_LID; FACT; ARITH] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `~(n = 0) ==> SUC n - 1 = SUC(n - 1)`] THEN | |
| ASM_SIMP_TAC[REAL_OF_NUM_LT; GSYM REAL_OF_NUM_SUC; LE_1; FACT] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `~(n = 0) ==> SUC(n - 1) = n`] THEN | |
| REWRITE_TAC[REAL_OF_NUM_MUL; MULT_SYM]; | |
| ALL_TAC] THEN | |
| GEN_REWRITE_TAC (LAND_CONV o BINDER_CONV o RAND_CONV o BINOP_CONV) | |
| [GSYM REAL_EXP_MONO_LE] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_LE] THEN | |
| ASM_SIMP_TAC[REAL_EXP_ADD; EXP_LOG; REAL_OF_NUM_LT; LE_1; FACT_NZ; | |
| ARITH_RULE `&2 <= &n /\ &0 < x ==> &0 < &n + x`] THEN | |
| REWRITE_TAC[REAL_OF_NUM_LE] THEN | |
| SUBGOAL_THEN | |
| `!n. 0 < n ==> f(&n + x) = product(0..n-1) (\k. x + &k) * f(x)` | |
| (fun th -> SIMP_TAC[ARITH_RULE `2 <= n ==> 0 < n`; th]) | |
| THENL | |
| [INDUCT_TAC THEN REWRITE_TAC[ARITH] THEN | |
| DISCH_TAC THEN REWRITE_TAC[GSYM REAL_OF_NUM_SUC] THEN | |
| ASM_CASES_TAC `n = 0` THENL | |
| [ASM_SIMP_TAC[REAL_ARITH `(&0 + &1) + x = x + &1`; ARITH] THEN | |
| REWRITE_TAC[PRODUCT_SING_NUMSEG; REAL_ADD_RID]; | |
| ASM_SIMP_TAC[REAL_ARITH `(n + &1) + x = (n + x) + &1`; | |
| REAL_LT_ADD; REAL_OF_NUM_LT; LE_1] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `~(n = 0) ==> SUC n - 1 = SUC(n - 1)`] THEN | |
| REWRITE_TAC[PRODUCT_CLAUSES_NUMSEG; LE_0] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `~(n = 0) ==> SUC(n - 1) = n`] THEN | |
| REWRITE_TAC[REAL_MUL_AC; REAL_ADD_AC]]; | |
| DISCH_TAC] THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `&1 <= x /\ x <= &1 + e ==> abs(x - &1) <= e`) THEN | |
| ASM_SIMP_TAC[REAL_OF_NUM_LE; REAL_FIELD | |
| `&2 <= n ==> &1 + x * inv n = (x + n) / n`] THEN | |
| REWRITE_TAC[real_div; REAL_INV_MUL; REAL_INV_INV] THEN | |
| ONCE_REWRITE_TAC[REAL_ARITH `f * (r * n) * p:real = (p * f) * r * n`] THEN | |
| REWRITE_TAC[GSYM REAL_INV_MUL] THEN REWRITE_TAC[GSYM real_div] THEN | |
| SUBGOAL_THEN `&0 < &n rpow x * &(FACT n)` ASSUME_TAC THENL | |
| [ASM_SIMP_TAC[REAL_LT_MUL; REAL_OF_NUM_LT; LE_1; FACT_NZ; | |
| RPOW_POS_LT; ARITH_RULE `2 <= x ==> 0 < x`]; | |
| ALL_TAC] THEN | |
| CONJ_TAC THENL | |
| [ASM_SIMP_TAC[REAL_LE_RDIV_EQ; REAL_MUL_LID] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `n + 1`) THEN | |
| ANTS_TAC THENL [ASM_ARITH_TAC; DISCH_THEN(MP_TAC o CONJUNCT1)] THEN | |
| REWRITE_TAC[ADD_SUB] THEN | |
| ASM_SIMP_TAC[rpow; REAL_OF_NUM_LE; REAL_ARITH `&2 <= x ==> &0 < x`] THEN | |
| REWRITE_TAC[REAL_MUL_AC]; | |
| ASM_SIMP_TAC[PRODUCT_CLAUSES_RIGHT; LE_0; | |
| ARITH_RULE `2 <= n ==> 0 < n`] THEN | |
| REWRITE_TAC[real_div; GSYM REAL_MUL_ASSOC] THEN | |
| GEN_REWRITE_TAC LAND_CONV | |
| [REAL_ARITH `a * b * c * d:real = b * (a * c) * d`] THEN | |
| MATCH_MP_TAC REAL_LE_LMUL THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM real_div; REAL_LE_LDIV_EQ] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `n:num`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(MP_TAC o CONJUNCT2) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN | |
| SUBGOAL_THEN `FACT n = FACT(SUC(n - 1))` SUBST1_TAC THENL | |
| [AP_TERM_TAC THEN ASM_ARITH_TAC; REWRITE_TAC[FACT]] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `2 <= n ==> SUC(n - 1) = n`] THEN | |
| MATCH_MP_TAC REAL_EQ_IMP_LE THEN | |
| SUBGOAL_THEN `&0 < &n` MP_TAC THENL | |
| [REWRITE_TAC[REAL_OF_NUM_LT] THEN ASM_ARITH_TAC; | |
| SIMP_TAC[rpow; GSYM REAL_OF_NUM_MUL; REAL_MUL_AC] THEN | |
| CONV_TAC REAL_FIELD]]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* The integral definition, the current usual one and Euler's original one. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let EULER_HAS_INTEGRAL_CGAMMA = prove | |
| (`!z. &0 < Re z | |
| ==> ((\t. Cx(drop t) cpow (z - Cx(&1)) / cexp(Cx(drop t))) | |
| has_integral cgamma(z)) | |
| {t | &0 <= drop t}`, | |
| let lemma0 = prove | |
| (`!z a b. &0 < Re z /\ &0 <= drop a | |
| ==> (\t. Cx(drop t) cpow z) continuous_on interval [a,b]`, | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN | |
| X_GEN_TAC `t:real^1` THEN REWRITE_TAC[IN_INTERVAL_1] THEN STRIP_TAC THEN | |
| ASM_CASES_TAC `t:real^1 = vec 0` THENL | |
| [ASM_SIMP_TAC[CONTINUOUS_WITHIN; cpow; CX_INJ; GSYM LIFT_EQ; LIFT_NUM; | |
| LIFT_DROP] THEN | |
| ONCE_REWRITE_TAC[LIM_NULL_COMPLEX_NORM] THEN | |
| REWRITE_TAC[NORM_CEXP] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_WITHIN THEN | |
| EXISTS_TAC `\t. Cx(exp(Re z * log(drop t)))` THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01] THEN CONJ_TAC THENL | |
| [X_GEN_TAC `u:real^1` THEN | |
| REWRITE_TAC[IN_INTERVAL_1; DIST_0; NORM_POS_LT; GSYM DROP_EQ; | |
| LIFT_DROP; DROP_VEC] THEN | |
| STRIP_TAC THEN SUBGOAL_THEN `&0 < drop u` | |
| (fun th -> SIMP_TAC[GSYM CX_LOG; RE_MUL_CX; th]) THEN | |
| ASM_REAL_ARITH_TAC; | |
| REWRITE_TAC[LIM_WITHIN; IN_INTERVAL_1; DIST_CX; REAL_SUB_RZERO] THEN | |
| X_GEN_TAC `e:real` THEN DISCH_TAC THEN | |
| EXISTS_TAC `e rpow inv(Re z)` THEN | |
| ASM_SIMP_TAC[RPOW_POS_LT; DIST_0; REAL_ABS_EXP] THEN | |
| X_GEN_TAC `u:real^1` THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `e = exp(log e)` SUBST1_TAC THENL | |
| [ASM_MESON_TAC[EXP_LOG]; REWRITE_TAC[REAL_EXP_MONO_LT]] THEN | |
| ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN | |
| ASM_SIMP_TAC[GSYM REAL_LT_RDIV_EQ] THEN | |
| REWRITE_TAC[REAL_ARITH `x / y:real = inv y * x`] THEN | |
| ASM_SIMP_TAC[GSYM LOG_RPOW] THEN MATCH_MP_TAC LOG_MONO_LT_IMP THEN | |
| SUBGOAL_THEN `norm u = drop u` (fun th -> ASM_MESON_TAC[th]) THEN | |
| REWRITE_TAC[NORM_REAL; GSYM drop] THEN ASM_REAL_ARITH_TAC]; | |
| MATCH_MP_TAC DIFFERENTIABLE_IMP_CONTINUOUS_WITHIN THEN | |
| SUBGOAL_THEN | |
| `(\a. Cx(drop a) cpow z) = (\w. w cpow z) o Cx o drop` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| MATCH_MP_TAC DIFFERENTIABLE_CHAIN_WITHIN THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC DIFFERENTIABLE_LINEAR THEN | |
| REWRITE_TAC[linear; o_DEF; DROP_ADD; DROP_CMUL; CX_ADD; | |
| COMPLEX_CMUL; GSYM CX_MUL]; | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_IMP_DIFFERENTIABLE THEN | |
| COMPLEX_DIFFERENTIABLE_TAC THEN DISCH_THEN(K ALL_TAC) THEN | |
| REWRITE_TAC[o_DEF; RE_CX] THEN | |
| ASM_REWRITE_TAC[REAL_LT_LE; GSYM LIFT_EQ; LIFT_NUM; LIFT_DROP] THEN | |
| ASM_REAL_ARITH_TAC]]) in | |
| let lemma1 = prove | |
| (`!n z. &0 < Re z | |
| ==> ((\t. Cx(drop t) cpow (z - Cx(&1)) * Cx(&1 - drop t) pow n) | |
| has_integral Cx(&(FACT n)) / cproduct (0..n) (\m. z + Cx(&m))) | |
| (interval[vec 0,vec 1])`, | |
| INDUCT_TAC THEN X_GEN_TAC `z:complex` THEN | |
| ASM_CASES_TAC `z = Cx(&0)` THEN ASM_REWRITE_TAC[RE_CX; REAL_LT_REFL] THEN | |
| DISCH_TAC THENL | |
| [REWRITE_TAC[complex_pow; COMPLEX_MUL_RID; CPRODUCT_CLAUSES_NUMSEG] THEN | |
| MP_TAC(ISPECL | |
| [`\t. Cx(drop t) cpow z / z`; | |
| `\t. Cx(drop t) cpow (z - Cx(&1))`; | |
| `vec 0:real^1`; `vec 1:real^1`] | |
| FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR) THEN | |
| REWRITE_TAC[DROP_VEC; CPOW_1; CPOW_0; FACT; complex_div] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LZERO; COMPLEX_ADD_RID; COMPLEX_SUB_RZERO] THEN | |
| DISCH_THEN MATCH_MP_TAC THEN REWRITE_TAC[REAL_POS] THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_ON_COMPLEX_RMUL THEN | |
| MATCH_MP_TAC lemma0 THEN ASM_REWRITE_TAC[DROP_VEC; REAL_POS]; | |
| REWRITE_TAC[IN_INTERVAL_1; DROP_VEC] THEN REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[CX_SUB] THEN | |
| MATCH_MP_TAC HAS_VECTOR_DERIVATIVE_REAL_COMPLEX THEN | |
| COMPLEX_DIFF_TAC THEN ASM_REWRITE_TAC[RE_CX] THEN | |
| UNDISCH_TAC `~(z = Cx(&0))` THEN CONV_TAC COMPLEX_FIELD]; | |
| FIRST_X_ASSUM(MP_TAC o SPEC `z + Cx(&1)`) THEN | |
| REWRITE_TAC[RE_ADD; RE_CX; COMPLEX_RING `(z + Cx(&1)) - Cx(&1) = z`] THEN | |
| ANTS_TAC THENL [ASM_REAL_ARITH_TAC; DISCH_TAC] THEN | |
| MP_TAC(ISPECL | |
| [`complex_mul`; | |
| `\t. Cx(drop t) cpow z`; | |
| `\t. Cx(&1) / Cx(&n + &1) * Cx(&1 - drop t) pow (n + 1)`; | |
| `\t. z * Cx(drop t) cpow (z - Cx(&1))`; | |
| `\t. --(Cx(&1 - drop t) pow n)`; | |
| `vec 0:real^1`; `vec 1:real^1`; | |
| `{vec 0:real^1}`; | |
| `Cx(&(FACT n)) / cproduct (0..n) (\m. (z + Cx(&1)) + Cx(&m))`] | |
| INTEGRATION_BY_PARTS) THEN | |
| REWRITE_TAC[BILINEAR_COMPLEX_MUL; DROP_VEC; | |
| REAL_POS; COUNTABLE_SING] THEN | |
| REWRITE_TAC[CPOW_0; REAL_SUB_REFL; COMPLEX_POW_ZERO; | |
| ADD_EQ_0; ARITH] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LZERO; COMPLEX_MUL_RZERO; COMPLEX_SUB_LZERO] THEN | |
| REWRITE_TAC[COMPLEX_MUL_RNEG; COMPLEX_RING `--Cx(&0) - y = --y`] THEN | |
| ANTS_TAC THENL | |
| [REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_ON_COMPLEX_MUL THEN | |
| ASM_SIMP_TAC[lemma0; DROP_VEC; REAL_POS] THEN | |
| MATCH_MP_TAC CONTINUOUS_ON_COMPLEX_LMUL THEN | |
| MATCH_MP_TAC CONTINUOUS_ON_COMPLEX_POW THEN | |
| REWRITE_TAC[CONTINUOUS_ON_CX_LIFT; LIFT_SUB; LIFT_DROP] THEN | |
| SIMP_TAC[CONTINUOUS_ON_SUB; CONTINUOUS_ON_ID; CONTINUOUS_ON_CONST]; | |
| SIMP_TAC[IN_INTERVAL_1; DROP_VEC; IN_DIFF; | |
| IN_SING; GSYM DROP_EQ] THEN | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[CX_SUB] THEN | |
| MATCH_MP_TAC HAS_VECTOR_DERIVATIVE_REAL_COMPLEX THEN | |
| COMPLEX_DIFF_TAC THEN | |
| ASM_REWRITE_TAC[RE_CX; COMPLEX_MUL_LID] THEN | |
| REWRITE_TAC[REAL_OF_NUM_ADD; ADD_SUB; COMPLEX_MUL_ASSOC] THEN | |
| MP_TAC(ARITH_RULE `~(n + 1 = 0)`) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_EQ; GSYM CX_INJ] THEN | |
| CONV_TAC COMPLEX_FIELD; | |
| MATCH_MP_TAC HAS_INTEGRAL_NEG THEN ASM_REWRITE_TAC[]]; | |
| DISCH_THEN(MP_TAC o SPEC `Cx(&n + &1) / z` o | |
| MATCH_MP HAS_INTEGRAL_COMPLEX_LMUL) THEN | |
| ASM_SIMP_TAC[REAL_ARITH `~(&n + &1 = &0)`; CX_INJ; COMPLEX_FIELD | |
| `~(n = Cx(&0)) /\ ~(z = Cx(&0)) | |
| ==> n / z * (z * p) * Cx(&1) / n * q = p * q`] THEN | |
| REWRITE_TAC[GSYM ADD1] THEN MATCH_MP_TAC EQ_IMP THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| SIMP_TAC[FACT; GSYM REAL_OF_NUM_MUL; CX_MUL; GSYM REAL_OF_NUM_SUC] THEN | |
| REWRITE_TAC[complex_div; GSYM COMPLEX_MUL_ASSOC] THEN AP_TERM_TAC THEN | |
| SIMP_TAC[CPRODUCT_CLAUSES_LEFT; ARITH_RULE `0 <= SUC n`] THEN | |
| REWRITE_TAC[ADD1; COMPLEX_INV_MUL; COMPLEX_ADD_RID] THEN | |
| REWRITE_TAC[ISPECL [`f:num->complex`; `m:num`; `1`] | |
| CPRODUCT_OFFSET] THEN | |
| REWRITE_TAC[GSYM COMPLEX_ADD_ASSOC; GSYM CX_ADD; REAL_OF_NUM_ADD] THEN | |
| REWRITE_TAC[ARITH_RULE `n + 1 = 1 + n`; COMPLEX_MUL_AC]]]) in | |
| let lemma2 = prove | |
| (`!z n. &0 < Re z | |
| ==> ((\t. if drop t <= &n | |
| then Cx(drop t) cpow (z - Cx(&1)) * | |
| Cx(&1 - drop t / &n) pow n | |
| else Cx(&0)) | |
| has_integral (Cx(&n) cpow z * Cx(&(FACT n))) / | |
| cproduct (0..n) (\m. z + Cx(&m))) | |
| {t | &0 <= drop t}`, | |
| REPEAT STRIP_TAC THEN ASM_CASES_TAC `n = 0` THENL | |
| [ASM_REWRITE_TAC[CPOW_0; COMPLEX_MUL_LZERO; complex_div] THEN | |
| MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN | |
| MAP_EVERY EXISTS_TAC [`\t:real^1. Cx(&0)`; `{vec 0:real^1}`] THEN | |
| REWRITE_TAC[GSYM COMPLEX_VEC_0; HAS_INTEGRAL_0; NEGLIGIBLE_SING] THEN | |
| REWRITE_TAC[IN_DIFF; IN_SING; GSYM DROP_EQ; DROP_VEC; IN_ELIM_THM] THEN | |
| REAL_ARITH_TAC; | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[GSYM COMPLEX_VEC_0] THEN | |
| ONCE_REWRITE_TAC[SET_RULE `drop x <= b <=> x IN {x | drop x <= b}`] THEN | |
| REWRITE_TAC[HAS_INTEGRAL_RESTRICT_INTER] THEN | |
| FIRST_ASSUM(MP_TAC o SPEC `n:num` o MATCH_MP lemma1) THEN | |
| DISCH_THEN(MP_TAC o SPECL [`inv(&n)`; `vec 0:real^1`] o | |
| MATCH_MP (REWRITE_RULE[IMP_CONJ] HAS_INTEGRAL_AFFINITY)) THEN | |
| REWRITE_TAC[DIMINDEX_1; REAL_POW_1] THEN | |
| ASM_SIMP_TAC[REAL_INV_EQ_0; REAL_OF_NUM_EQ; LE_1; REAL_ABS_INV] THEN | |
| REWRITE_TAC[IMAGE_AFFINITY_INTERVAL; REAL_INV_INV; REAL_POS] THEN | |
| REWRITE_TAC[UNIT_INTERVAL_NONEMPTY; VECTOR_ADD_RID; REAL_ABS_NUM] THEN | |
| REWRITE_TAC[VECTOR_MUL_RZERO; VECTOR_NEG_0; VECTOR_ADD_RID] THEN | |
| REWRITE_TAC[DROP_CMUL; COMPLEX_CMUL] THEN | |
| DISCH_THEN(MP_TAC o SPEC `Cx(&n) cpow (z - Cx(&1))` o | |
| MATCH_MP HAS_INTEGRAL_COMPLEX_LMUL) THEN | |
| REWRITE_TAC[COMPLEX_MUL_ASSOC; | |
| GSYM(ONCE_REWRITE_RULE[COMPLEX_MUL_SYM] CPOW_SUC)] THEN | |
| REWRITE_TAC[complex_div; GSYM COMPLEX_MUL_ASSOC; GSYM LIFT_EQ_CMUL] THEN | |
| REWRITE_TAC[ONCE_REWRITE_RULE[INTER_COMM] INTER; IN_ELIM_THM] THEN | |
| REWRITE_TAC[GSYM DROP_VEC; LIFT_DROP; GSYM IN_INTERVAL_1] THEN | |
| REWRITE_TAC[DROP_VEC; SET_RULE `{x | x IN s} = s`] THEN | |
| REWRITE_TAC[COMPLEX_RING `(z - Cx(&1)) + Cx(&1) = z`] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] HAS_INTEGRAL_EQ) THEN | |
| REWRITE_TAC[FORALL_LIFT; IN_INTERVAL_1; LIFT_DROP; DROP_VEC] THEN | |
| X_GEN_TAC `t:real` THEN STRIP_TAC THEN | |
| REWRITE_TAC[COMPLEX_MUL_ASSOC; REAL_ARITH `inv x * y:real = y / x`] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN IMP_REWRITE_TAC[GSYM CPOW_MUL_REAL] THEN | |
| ASM_SIMP_TAC[REAL_CX; RE_CX; REAL_LE_DIV; REAL_POS; GSYM CX_MUL] THEN | |
| ASM_SIMP_TAC[REAL_DIV_LMUL; REAL_OF_NUM_EQ; LE_1]]) in | |
| let lemma3 = prove | |
| (`f integrable_on s | |
| ==> (\x:real^N. lift(Re(f x))) integrable_on s /\ | |
| integral s (\x. lift(Re(f x))) = lift(Re(integral s f))`, | |
| SUBGOAL_THEN `!z. lift(Re z) = (lift o Re) z` | |
| (fun th -> REWRITE_TAC[th]) THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| ONCE_REWRITE_TAC[GSYM o_DEF] THEN REPEAT STRIP_TAC THENL | |
| [MATCH_MP_TAC INTEGRABLE_LINEAR; MATCH_MP_TAC INTEGRAL_LINEAR] THEN | |
| ASM_REWRITE_TAC[linear; COMPLEX_CMUL; o_THM; RE_ADD; RE_MUL_CX] THEN | |
| REWRITE_TAC[LIFT_CMUL; LIFT_ADD]) in | |
| REPEAT STRIP_TAC THEN | |
| MP_TAC(ISPECL | |
| [`\n t. if drop t <= &n | |
| then Cx(drop t) cpow (z - Cx(&1)) * Cx(&1 - drop t / &n) pow n | |
| else Cx(&0)`; | |
| `\t. Cx(drop t) cpow (z - Cx(&1)) / cexp(Cx(drop t))`; | |
| `\t. lift(Re(Cx(drop t) cpow (Cx(Re z) - Cx(&1)) / cexp(Cx(drop t))))`; | |
| `{t | &0 <= drop t}`] DOMINATED_CONVERGENCE) THEN | |
| ASM_SIMP_TAC[REWRITE_RULE[HAS_INTEGRAL_INTEGRABLE_INTEGRAL] lemma2] THEN | |
| ANTS_TAC THENL | |
| [ALL_TAC; | |
| SIMP_TAC[HAS_INTEGRAL_INTEGRABLE_INTEGRAL] THEN | |
| MESON_TAC[CGAMMA; LIM_UNIQUE; TRIVIAL_LIMIT_SEQUENTIALLY]] THEN | |
| REWRITE_TAC[IN_ELIM_THM; LIFT_DROP] THEN REPEAT CONJ_TAC THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[FORALL_LIFT; LIFT_DROP] THEN | |
| MAP_EVERY X_GEN_TAC [`n:num`; `t:real`] THEN DISCH_TAC THEN | |
| REWRITE_TAC[cpow; CX_INJ] THEN ASM_CASES_TAC `t = &0` THEN | |
| ASM_REWRITE_TAC[COMPLEX_MUL_LZERO; COND_ID; RE_CX; CEXP_0; COMPLEX_DIV_1; | |
| COMPLEX_NORM_0; REAL_LE_REFL] THEN | |
| ASM_SIMP_TAC[GSYM CX_LOG; REAL_LT_LE; GSYM CX_EXP; GSYM CX_SUB; | |
| GSYM CX_MUL; RE_CX; GSYM CX_DIV; GSYM REAL_EXP_SUB] THEN | |
| COND_CASES_TAC THEN REWRITE_TAC[COMPLEX_NORM_0; REAL_EXP_POS_LE] THEN | |
| REWRITE_TAC[COMPLEX_NORM_MUL; REAL_EXP_SUB; NORM_CEXP] THEN | |
| REWRITE_TAC[RE_MUL_CX; RE_SUB; RE_CX; COMPLEX_NORM_POW] THEN | |
| REWRITE_TAC[real_div] THEN SIMP_TAC[REAL_LE_LMUL_EQ; REAL_EXP_POS_LT] THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX] THEN | |
| SUBGOAL_THEN `~(&n = &0)` MP_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[GSYM real_div; REAL_OF_NUM_EQ] THEN DISCH_TAC THEN | |
| ASM_SIMP_TAC[real_abs; REAL_SUB_LE; REAL_LE_LDIV_EQ; REAL_MUL_LID; | |
| REAL_OF_NUM_LT; LE_1] THEN | |
| TRANS_TAC REAL_LE_TRANS `exp(--t / &n) pow n` THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_POW_LE2 THEN | |
| ASM_SIMP_TAC[REAL_SUB_LE; REAL_LE_LDIV_EQ; REAL_MUL_LID; | |
| REAL_OF_NUM_LT; LE_1] THEN | |
| REWRITE_TAC[REAL_ARITH `&1 - t / n = &1 + --t / n`; REAL_EXP_LE_X]; | |
| REWRITE_TAC[GSYM REAL_EXP_N; GSYM REAL_EXP_NEG] THEN | |
| ASM_SIMP_TAC[REAL_DIV_LMUL; REAL_OF_NUM_EQ; REAL_LE_REFL]]; | |
| REWRITE_TAC[FORALL_LIFT; LIFT_DROP] THEN X_GEN_TAC `t:real` THEN | |
| DISCH_TAC THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\k. Cx t cpow (z - Cx(&1)) * Cx(&1 - t / &k) pow k` THEN | |
| CONJ_TAC THENL | |
| [MP_TAC(SPEC `t + &1` REAL_ARCH_SIMPLE) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY; GSYM REAL_OF_NUM_LE] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN REAL_ARITH_TAC; | |
| REWRITE_TAC[complex_div] THEN MATCH_MP_TAC LIM_COMPLEX_LMUL THEN | |
| REWRITE_TAC[CX_SUB; CX_DIV; GSYM CEXP_NEG] THEN | |
| REWRITE_TAC[SIMPLE_COMPLEX_ARITH `a - x / y:complex = a + --x / y`] THEN | |
| REWRITE_TAC[CEXP_LIMIT]]] THEN | |
| MP_TAC(ISPECL | |
| [`\n t. lift(Re(if drop t <= &n | |
| then Cx(drop t) cpow (Cx(Re z) - Cx(&1)) * | |
| Cx(&1 - drop t / &n) pow n | |
| else Cx(&0)))`; | |
| `\t. lift(Re(Cx(drop t) cpow (Cx(Re z) - Cx(&1)) / cexp(Cx(drop t))))`; | |
| `{t | &0 <= drop t}`] | |
| MONOTONE_CONVERGENCE_INCREASING) THEN | |
| REWRITE_TAC[] THEN ANTS_TAC THENL [ALL_TAC; MESON_TAC[]] THEN | |
| ASM_SIMP_TAC[lemma3; REWRITE_RULE[HAS_INTEGRAL_INTEGRABLE_INTEGRAL] lemma2; | |
| RE_CX; bounded; FORALL_IN_GSPEC] THEN | |
| REWRITE_TAC[IN_UNIV; FORALL_LIFT; LIFT_DROP; NORM_LIFT] THEN | |
| REPEAT CONJ_TAC THENL | |
| [MAP_EVERY X_GEN_TAC [`n:num`; `t:real`] THEN DISCH_TAC THEN | |
| ASM_CASES_TAC `t = &0` THEN | |
| ASM_SIMP_TAC[CPOW_0; COMPLEX_MUL_LZERO; COND_ID; REAL_LE_REFL] THEN | |
| ASM_REWRITE_TAC[cpow; CX_INJ] THEN | |
| ASM_SIMP_TAC[cpow; CX_INJ; GSYM CX_SUB; GSYM CX_EXP; GSYM CX_LOG; | |
| REAL_LT_LE; GSYM CX_MUL; GSYM CX_DIV; RE_CX; GSYM CX_POW] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_SUC] THEN ASM_CASES_TAC `t <= &n` THEN | |
| ASM_SIMP_TAC[REAL_ARITH `x <= n ==> x <= n + &1`] THENL | |
| [SIMP_TAC[RE_CX; REAL_LE_LMUL_EQ; REAL_EXP_POS_LT] THEN | |
| REWRITE_TAC[GSYM RPOW_POW; GSYM REAL_OF_NUM_SUC] THEN | |
| MATCH_MP_TAC REAL_EXP_LIMIT_RPOW_LE THEN ASM_REAL_ARITH_TAC; | |
| COND_CASES_TAC THEN REWRITE_TAC[REAL_LE_REFL; RE_CX] THEN | |
| MATCH_MP_TAC REAL_LE_MUL THEN REWRITE_TAC[REAL_EXP_POS_LE] THEN | |
| MATCH_MP_TAC REAL_POW_LE THEN REWRITE_TAC[REAL_SUB_LE] THEN | |
| SIMP_TAC[REAL_LE_LDIV_EQ; REAL_ARITH `&0 < &n + &1`] THEN | |
| ASM_REAL_ARITH_TAC]; | |
| X_GEN_TAC `t:real` THEN DISCH_TAC THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN EXISTS_TAC | |
| `\k. lift(Re(Cx t cpow (Cx(Re z) - Cx(&1)) * | |
| Cx(&1 - t / &k) pow k))` THEN | |
| CONJ_TAC THENL | |
| [MP_TAC(SPEC `t + &1` REAL_ARCH_SIMPLE) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY; GSYM REAL_OF_NUM_LE] THEN | |
| MATCH_MP_TAC MONO_EXISTS THEN REAL_ARITH_TAC; | |
| REWRITE_TAC[cpow; CX_INJ] THEN | |
| ASM_CASES_TAC `t = &0` THEN | |
| ASM_REWRITE_TAC[COMPLEX_MUL_LZERO; complex_div; LIM_CONST] THEN | |
| ASM_SIMP_TAC[cpow; CX_INJ; GSYM CX_SUB; GSYM CX_EXP; GSYM CX_LOG; | |
| REAL_LT_LE; GSYM CX_MUL; GSYM CX_INV; RE_CX; GSYM CX_POW] THEN | |
| REWRITE_TAC[real_div; LIFT_CMUL; RE_CX] THEN MATCH_MP_TAC LIM_CMUL THEN | |
| REWRITE_TAC[REAL_ARITH `&1 - t * inv x = &1 + --t / x`] THEN | |
| REWRITE_TAC[GSYM REAL_EXP_NEG] THEN | |
| REWRITE_TAC[GSYM(REWRITE_RULE[o_DEF] TENDSTO_REAL)] THEN | |
| REWRITE_TAC[EXP_LIMIT]]; | |
| MP_TAC(MATCH_MP CONVERGENT_IMP_BOUNDED (SPEC `Cx(Re z)` CGAMMA)) THEN | |
| REWRITE_TAC[bounded; FORALL_IN_IMAGE; IN_UNIV] THEN | |
| MESON_TAC[COMPLEX_NORM_GE_RE_IM; REAL_LE_TRANS]]);; | |
| let EULER_INTEGRAL = prove | |
| (`!z. &0 < Re z | |
| ==> integral {t | &0 <= drop t} | |
| (\t. Cx(drop t) cpow (z - Cx(&1)) / cexp(Cx(drop t))) = | |
| cgamma(z)`, | |
| MESON_TAC[INTEGRAL_UNIQUE; EULER_HAS_INTEGRAL_CGAMMA]);; | |
| let EULER_INTEGRABLE = prove | |
| (`!z. &0 < Re z | |
| ==> (\t. Cx(drop t) cpow (z - Cx(&1)) / cexp(Cx(drop t))) integrable_on | |
| {t | &0 <= drop t}`, | |
| MESON_TAC[EULER_HAS_INTEGRAL_CGAMMA; integrable_on]);; | |
| let EULER_HAS_REAL_INTEGRAL_GAMMA = prove | |
| (`!x. &0 < x | |
| ==> ((\t. t rpow (x - &1) / exp t) has_real_integral gamma(x)) | |
| {t | &0 <= t}`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[has_real_integral] THEN | |
| MP_TAC(SPEC `Cx x` EULER_HAS_INTEGRAL_CGAMMA) THEN | |
| ASM_REWRITE_TAC[gamma; o_DEF; RE_CX] THEN | |
| DISCH_THEN(MP_TAC o ISPEC `lift o Re` o MATCH_MP | |
| (REWRITE_RULE[IMP_CONJ] HAS_INTEGRAL_LINEAR)) THEN | |
| REWRITE_TAC[o_DEF] THEN ANTS_TAC THENL | |
| [REWRITE_TAC[linear; RE_ADD; LIFT_ADD; COMPLEX_CMUL; RE_MUL_CX] THEN | |
| REWRITE_TAC[LIFT_CMUL]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `IMAGE lift {t | &0 <= t} = {t | &0 <= drop t}` | |
| SUBST1_TAC THENL | |
| [MATCH_MP_TAC SURJECTIVE_IMAGE_EQ THEN | |
| REWRITE_TAC[IN_ELIM_THM; LIFT_DROP] THEN MESON_TAC[LIFT_DROP]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ] (REWRITE_RULE[CONJ_ASSOC] | |
| HAS_INTEGRAL_SPIKE)) THEN | |
| EXISTS_TAC `{vec 0:real^1}` THEN | |
| REWRITE_TAC[NEGLIGIBLE_SING; FORALL_LIFT; IN_DIFF; IN_ELIM_THM; | |
| LIFT_DROP; IN_SING; GSYM DROP_EQ; DROP_VEC] THEN | |
| SIMP_TAC[cpow; CX_INJ; rpow; REAL_LT_LE; GSYM CX_LOG; GSYM CX_SUB; | |
| GSYM CX_EXP; GSYM CX_MUL; RE_CX; GSYM CX_DIV]);; | |
| let EULER_REAL_INTEGRAL = prove | |
| (`!x. &0 < x | |
| ==> real_integral {t | &0 <= t} (\t. t rpow (x - &1) / exp t) = | |
| gamma(x)`, | |
| MESON_TAC[REAL_INTEGRAL_UNIQUE; EULER_HAS_REAL_INTEGRAL_GAMMA]);; | |
| let EULER_REAL_INTEGRABLE = prove | |
| (`!x. &0 < x | |
| ==> (\t. t rpow (x - &1) / exp t) real_integrable_on {t | &0 <= t}`, | |
| MESON_TAC[EULER_HAS_REAL_INTEGRAL_GAMMA; real_integrable_on]);; | |
| let EULER_ORIGINAL_REAL_INTEGRABLE = prove | |
| (`!x. &0 < x | |
| ==> (\t. (--log t) rpow (x - &1)) | |
| real_integrable_on real_interval[&0,&1]`, | |
| SUBGOAL_THEN | |
| `!x. &0 < x | |
| ==> ((\t. (--log t) rpow (x - &1)) | |
| real_integrable_on real_interval[&0,&1] <=> | |
| (\t. (--log t) rpow x) | |
| real_integrable_on real_interval[&0,&1])` | |
| ASSUME_TAC THENL | |
| [GEN_TAC THEN ASM_CASES_TAC `x = &0` THEN | |
| ASM_REWRITE_TAC[REAL_LT_REFL] THEN DISCH_TAC THEN MP_TAC(ISPECL | |
| [`\t. inv(x) * (--log t) rpow x`; | |
| `\t:real. t`; | |
| `\t. --(&1) / t * (--log t) rpow (x - &1)`; | |
| `\t:real. &1`; `&0`; `&1`; `{&0,&1}`] | |
| REAL_INTEGRABLE_BY_PARTS_EQ) THEN | |
| REWRITE_TAC[COUNTABLE_INSERT; COUNTABLE_EMPTY; REAL_MUL_RID] THEN | |
| ANTS_TAC THENL | |
| [CONJ_TAC THENL | |
| [REWRITE_TAC[GSYM REAL_MUL_ASSOC] THEN | |
| MATCH_MP_TAC REAL_CONTINUOUS_ON_LMUL THEN | |
| REWRITE_TAC[REAL_CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN | |
| X_GEN_TAC `t:real` THEN REWRITE_TAC[IN_REAL_INTERVAL] THEN | |
| STRIP_TAC THEN | |
| FIRST_ASSUM(STRIP_ASSUME_TAC o MATCH_MP (REAL_ARITH | |
| `&0 <= x ==> &0 < x \/ x = &0`)) | |
| THENL | |
| [MATCH_MP_TAC REAL_CONTINUOUS_MUL THEN | |
| REWRITE_TAC[REAL_CONTINUOUS_WITHIN_ID] THEN | |
| MATCH_MP_TAC REAL_CONTINUOUS_ATREAL_WITHINREAL THEN | |
| SUBGOAL_THEN | |
| `(\y. --log(y) rpow x) = (\y. y rpow x) o (\x. --x) o log` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| REPEAT(MATCH_MP_TAC REAL_CONTINUOUS_ATREAL_COMPOSE THEN | |
| CONJ_TAC) THEN | |
| ASM_SIMP_TAC[REAL_CONTINUOUS_NEG; REAL_CONTINUOUS_AT_ID; | |
| REAL_CONTINUOUS_AT_LOG] THEN | |
| MATCH_MP_TAC REAL_CONTINUOUS_AT_RPOW THEN | |
| ASM_SIMP_TAC[REAL_LE_LT]; | |
| FIRST_X_ASSUM SUBST_ALL_TAC THEN | |
| REWRITE_TAC[REAL_CONTINUOUS_WITHINREAL; REAL_MUL_RZERO] THEN | |
| MATCH_MP_TAC REALLIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\y. (--x * log(y rpow inv x) * y rpow inv x) rpow x` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_WITHINREAL] THEN | |
| REWRITE_TAC[REAL_ARITH `&0 < abs(x - a) <=> ~(x = a)`] THEN | |
| EXISTS_TAC `&1` THEN REWRITE_TAC[REAL_LT_01] THEN | |
| X_GEN_TAC `y:real` THEN REWRITE_TAC[IN_REAL_INTERVAL] THEN | |
| STRIP_TAC THEN | |
| SUBGOAL_THEN `&0 < y` ASSUME_TAC THENL | |
| [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[LOG_RPOW; REAL_LT_INV_EQ; REAL_FIELD | |
| `~(x = &0) ==> --x * (inv x * y) * z = --y * z`] THEN | |
| ASM_SIMP_TAC[RPOW_MUL; RPOW_RPOW; REAL_MUL_LINV] THEN | |
| REWRITE_TAC[RPOW_POW; REAL_POW_1]; | |
| SUBGOAL_THEN `&0 = &0 rpow x` | |
| (fun th -> GEN_REWRITE_TAC LAND_CONV [th]) | |
| THENL [ASM_SIMP_TAC[rpow; REAL_LT_IMP_NZ; REAL_LT_REFL]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[] (ISPEC `\y. y rpow x` | |
| REALLIM_REAL_CONTINUOUS_FUNCTION)) THEN | |
| ASM_SIMP_TAC[REAL_CONTINUOUS_AT_RPOW; REAL_LT_IMP_LE] THEN | |
| MATCH_MP_TAC REALLIM_NULL_LMUL THEN | |
| SUBGOAL_THEN | |
| `(\y. log (y rpow inv x) * y rpow inv x) = | |
| (\y. log y * y) o (\y. y rpow inv x)` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| MATCH_MP_TAC REALLIM_COMPOSE_WITHIN THEN | |
| EXISTS_TAC `{x | &0 <= x}` THEN EXISTS_TAC `&0 rpow inv x` THEN | |
| ASM_REWRITE_TAC[REAL_ENTIRE; RPOW_EQ_0; REAL_INV_EQ_0] THEN | |
| REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC(REWRITE_RULE[] (ISPEC `\y. y rpow x` | |
| REALLIM_REAL_CONTINUOUS_FUNCTION)) THEN | |
| ASM_SIMP_TAC[REAL_CONTINUOUS_AT_RPOW; REAL_LT_IMP_LE; | |
| REAL_LE_INV_EQ] THEN | |
| MP_TAC(ISPEC `&0` REAL_CONTINUOUS_AT_ID) THEN | |
| SIMP_TAC[REAL_CONTINUOUS_ATREAL; REALLIM_ATREAL_WITHINREAL]; | |
| REWRITE_TAC[EVENTUALLY_WITHINREAL] THEN | |
| SIMP_TAC[RPOW_POS_LE; IN_REAL_INTERVAL; IN_ELIM_THM] THEN | |
| MESON_TAC[REAL_LT_01]; | |
| ASM_REWRITE_TAC[RPOW_ZERO; REAL_INV_EQ_0] THEN | |
| ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN | |
| REWRITE_TAC[REALLIM_X_TIMES_LOG]]]]; | |
| REWRITE_TAC[IN_REAL_INTERVAL; IN_DIFF; IN_INSERT; NOT_IN_EMPTY] THEN | |
| X_GEN_TAC `t:real` THEN REWRITE_TAC[DE_MORGAN_THM] THEN STRIP_TAC THEN | |
| CONJ_TAC THEN REAL_DIFF_TAC THEN ASM_REWRITE_TAC[] THEN | |
| ASM_SIMP_TAC[GSYM LOG_INV; REAL_INV_1_LT; LOG_POS_LT] THEN | |
| REPEAT(POP_ASSUM MP_TAC) THEN CONV_TAC REAL_FIELD]; | |
| ASM_REWRITE_TAC[REAL_INTEGRABLE_LMUL_EQ; REAL_INV_EQ_0] THEN | |
| DISCH_THEN SUBST1_TAC THEN | |
| REWRITE_TAC[real_div; GSYM REAL_MUL_ASSOC] THEN | |
| REWRITE_TAC[REAL_INTEGRABLE_LMUL_EQ] THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| MATCH_MP_TAC REAL_INTEGRABLE_SPIKE_EQ THEN EXISTS_TAC `{&0}` THEN | |
| REWRITE_TAC[REAL_NEGLIGIBLE_SING; IN_DIFF; IN_SING] THEN | |
| CONV_TAC REAL_FIELD]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `!n. (\t. --log t pow n) real_integrable_on real_interval[&0,&1]` | |
| ASSUME_TAC THENL | |
| [MATCH_MP_TAC num_INDUCTION THEN | |
| REWRITE_TAC[CONJUNCT1 real_pow; REAL_INTEGRABLE_CONST] THEN | |
| REWRITE_TAC[GSYM RPOW_POW] THEN X_GEN_TAC `n:num` THEN | |
| SUBGOAL_THEN `&n = &(SUC n) - &1` SUBST1_TAC THENL | |
| [REWRITE_TAC[GSYM REAL_OF_NUM_SUC] THEN REAL_ARITH_TAC; | |
| MATCH_MP_TAC EQ_IMP THEN FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| REWRITE_TAC[REAL_OF_NUM_LT; LT_0]]; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `!x. &0 < x | |
| ==> (\t. --log t rpow x) real_integrable_on real_interval[&0,&1]` | |
| (fun th -> ASM_MESON_TAC[th]) THEN | |
| X_GEN_TAC `x:real` THEN DISCH_TAC THEN | |
| MP_TAC(SPEC `x:real` REAL_ARCH_SIMPLE) THEN | |
| DISCH_THEN(X_CHOOSE_TAC `n:num`) THEN | |
| MATCH_MP_TAC REAL_MEASURABLE_BOUNDED_AE_BY_INTEGRABLE_IMP_INTEGRABLE THEN | |
| EXISTS_TAC `\t. max (&1) (--log t pow n)` THEN EXISTS_TAC `{&0}` THEN | |
| REWRITE_TAC[REAL_NEGLIGIBLE_SING] THEN REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_MEASURABLE_ON_RPOW THEN | |
| ASM_REWRITE_TAC[] THEN MATCH_MP_TAC INTEGRABLE_IMP_REAL_MEASURABLE THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `1`) THEN REWRITE_TAC[REAL_POW_1]; | |
| MATCH_MP_TAC ABSOLUTELY_REAL_INTEGRABLE_IMP_INTEGRABLE THEN | |
| MATCH_MP_TAC ABSOLUTELY_REAL_INTEGRABLE_MAX THEN | |
| REWRITE_TAC[ABSOLUTELY_REAL_INTEGRABLE_CONST] THEN MATCH_MP_TAC | |
| ABSOLUTELY_REAL_INTEGRABLE_ABSOLUTELY_REAL_INTEGRABLE_LBOUND THEN | |
| EXISTS_TAC `\x:real. min (--log(&0) pow n) (&0)` THEN | |
| ASM_REWRITE_TAC[ABSOLUTELY_REAL_INTEGRABLE_CONST] THEN | |
| REWRITE_TAC[IN_REAL_INTERVAL] THEN X_GEN_TAC `t:real` THEN | |
| STRIP_TAC THEN ASM_CASES_TAC `t = &0` THEN ASM_REWRITE_TAC[] THENL | |
| [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| SUBGOAL_THEN `&0 < t` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC(REAL_ARITH `b <= c ==> min a b <= c`) THEN | |
| MATCH_MP_TAC REAL_POW_LE THEN ASM_SIMP_TAC[GSYM LOG_INV] THEN | |
| MATCH_MP_TAC LOG_POS THEN MATCH_MP_TAC REAL_INV_1_LE THEN | |
| ASM_REWRITE_TAC[]; | |
| REWRITE_TAC[IN_REAL_INTERVAL; IN_DIFF; IN_SING] THEN | |
| X_GEN_TAC `t:real` THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `&0 < t` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| SUBGOAL_THEN `&0 <= --log t` ASSUME_TAC THENL | |
| [ASM_SIMP_TAC[GSYM LOG_INV] THEN MATCH_MP_TAC LOG_POS THEN | |
| MATCH_MP_TAC REAL_INV_1_LE THEN ASM_REAL_ARITH_TAC; | |
| ASM_SIMP_TAC[real_abs; RPOW_POS_LE]] THEN | |
| ASM_CASES_TAC `--(log t) <= &1` THENL | |
| [MATCH_MP_TAC(REAL_ARITH `x <= y ==> x <= max y z`) THEN | |
| MATCH_MP_TAC RPOW_1_LE THEN ASM_REAL_ARITH_TAC; | |
| MATCH_MP_TAC(REAL_ARITH `x <= z ==> x <= max y z`) THEN | |
| REWRITE_TAC[GSYM RPOW_POW] THEN MATCH_MP_TAC RPOW_MONO_LE THEN | |
| ASM_REAL_ARITH_TAC]]);; | |
| let EULER_ORIGINAL_INTEGRABLE = prove | |
| (`!z. &0 < Re z | |
| ==> (\t. (--clog(Cx(drop t))) cpow (z - Cx(&1))) | |
| integrable_on interval[vec 0,vec 1]`, | |
| REPEAT STRIP_TAC THEN | |
| MATCH_MP_TAC MEASURABLE_BOUNDED_AE_BY_INTEGRABLE_IMP_INTEGRABLE THEN | |
| EXISTS_TAC `\t. lift((--log(drop t)) rpow (Re z - &1))` THEN | |
| EXISTS_TAC `{vec 0:real^1,vec 1}` THEN | |
| REWRITE_TAC[NEGLIGIBLE_INSERT; NEGLIGIBLE_EMPTY] THEN REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC | |
| CONTINUOUS_AE_IMP_MEASURABLE_ON_LEBESGUE_MEASURABLE_SUBSET THEN | |
| EXISTS_TAC `{vec 0:real^1,vec 1}` THEN | |
| REWRITE_TAC[NEGLIGIBLE_INSERT; NEGLIGIBLE_EMPTY; | |
| LEBESGUE_MEASURABLE_INTERVAL] THEN | |
| SUBGOAL_THEN | |
| `(\t. --clog (Cx(drop t)) cpow (z - Cx(&1))) = | |
| ((\w. w cpow (z - Cx(&1))) o (--) o clog) o (\x. Cx(drop x))` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF]; ALL_TAC] THEN | |
| MATCH_MP_TAC CONTINUOUS_ON_COMPOSE THEN | |
| SIMP_TAC[CONTINUOUS_ON_CX_DROP; CONTINUOUS_ON_ID] THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_IMP_CONTINUOUS_ON THEN | |
| REWRITE_TAC[IN_DIFF; IN_INSERT; NOT_IN_EMPTY; DE_MORGAN_THM; | |
| IMP_CONJ; FORALL_IN_IMAGE] THEN | |
| REWRITE_TAC[FORALL_LIFT; IN_INTERVAL_1; LIFT_DROP] THEN | |
| REWRITE_TAC[GSYM DROP_EQ; LIFT_DROP; DROP_VEC; o_DEF] THEN | |
| REPEAT STRIP_TAC THEN | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_AT THEN | |
| COMPLEX_DIFFERENTIABLE_TAC THEN | |
| ASM_SIMP_TAC[GSYM CX_LOG; RE_CX; REAL_LT_LE; RE_NEG; GSYM LOG_INV] THEN | |
| DISCH_TAC THEN REWRITE_TAC[GSYM REAL_LT_LE] THEN | |
| MATCH_MP_TAC LOG_POS_LT THEN MATCH_MP_TAC REAL_INV_1_LT THEN | |
| ASM_REAL_ARITH_TAC; | |
| REWRITE_TAC[INTERVAL_REAL_INTERVAL; DROP_VEC; | |
| REWRITE_RULE[o_DEF] (GSYM REAL_INTEGRABLE_ON)] THEN | |
| MATCH_MP_TAC EULER_ORIGINAL_REAL_INTEGRABLE THEN ASM_REWRITE_TAC[]; | |
| REWRITE_TAC[FORALL_LIFT; IN_DIFF; IN_INSERT; GSYM DROP_EQ; LIFT_DROP; | |
| IN_INTERVAL_1; DROP_VEC; NOT_IN_EMPTY] THEN | |
| X_GEN_TAC `x:real` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `&0 < x /\ x < &1` STRIP_ASSUME_TAC THENL | |
| [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[GSYM CX_LOG; cpow; rpow; GSYM CX_NEG; REAL_LT_IMP_NZ; RE_CX; | |
| REAL_LT_IMP_LE; COMPLEX_NORM_MUL; NORM_CEXP; RE_SUB; CX_INJ; | |
| REAL_LE_REFL; RE_MUL_CX; GSYM LOG_INV; LOG_POS_LT; REAL_INV_1_LT]]);; | |
| let EULER_ORIGINAL_HAS_INTEGRAL_CGAMMA = prove | |
| (`!z. &0 < Re z | |
| ==> ((\t. (--clog(Cx(drop t))) cpow (z - Cx(&1))) | |
| has_integral cgamma(z)) (interval[vec 0,vec 1])`, | |
| REPEAT STRIP_TAC THEN | |
| FIRST_ASSUM(ASSUME_TAC o MATCH_MP EULER_ORIGINAL_INTEGRABLE) THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP INDEFINITE_INTEGRAL_CONTINUOUS_LEFT) THEN | |
| REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN | |
| DISCH_THEN(MP_TAC o SPEC `vec 0:real^1`) THEN | |
| REWRITE_TAC[ENDS_IN_UNIT_INTERVAL; CONTINUOUS_WITHIN] THEN DISCH_TAC THEN | |
| ASM_REWRITE_TAC[HAS_INTEGRAL_INTEGRABLE_INTEGRAL] THEN | |
| FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (ONCE_REWRITE_RULE | |
| [TAUT `a /\ b /\ c ==> d <=> b ==> a /\ c ==> d`] LIM_UNIQUE)) THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_WITHIN] THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC CONNECTED_IMP_PERFECT THEN | |
| REWRITE_TAC[ENDS_IN_UNIT_INTERVAL; CONNECTED_INTERVAL] THEN | |
| MATCH_MP_TAC(SET_RULE | |
| `{a,b} SUBSET interval[a,b] /\ ~(a = b) | |
| ==> ~(?x. interval[a,b] = {x})`) THEN | |
| REWRITE_TAC[INSERT_SUBSET; EMPTY_SUBSET; ENDS_IN_UNIT_INTERVAL] THEN | |
| REWRITE_TAC[VEC_EQ; ARITH_EQ]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC `\x. integral(interval[vec 0,lift(--log(drop x))]) | |
| (\t. Cx(drop t) cpow (z - Cx(&1)) / cexp(Cx(drop t)))` THEN | |
| REWRITE_TAC[EVENTUALLY_WITHIN] THEN CONJ_TAC THENL | |
| [EXISTS_TAC `&1` THEN | |
| REWRITE_TAC[REAL_LT_01; DIST_0; NORM_POS_LT; IN_INTERVAL_1; DROP_VEC; | |
| GSYM DROP_EQ; DROP_VEC; FORALL_LIFT; LIFT_DROP] THEN | |
| X_GEN_TAC `x:real` THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `&0 < x` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MP_TAC(ISPECL | |
| [`\t. (--clog(Cx(drop(--t)))) cpow (z - Cx(&1))`; | |
| `\t. --lift(exp(--drop t))`; | |
| `\t. lift(exp(--drop t))`; | |
| `vec 0:real^1`; `lift(--log x):real^1`; `--vec 1:real^1`; `vec 0:real^1`; | |
| `{vec 0:real^1,vec 1}`] | |
| HAS_INTEGRAL_SUBSTITUTION_STRONG) THEN | |
| REWRITE_TAC[LIFT_DROP; DROP_VEC; GSYM DROP_NEG] THEN | |
| REWRITE_TAC[GSYM REFLECT_INTERVAL; GSYM INTEGRAL_REFLECT_GEN] THEN | |
| REWRITE_TAC[DROP_NEG; LIFT_DROP; REAL_LE_NEG2; REAL_EXP_MONO_LE] THEN | |
| REWRITE_TAC[REAL_NEG_NEG; DROP_VEC; REAL_EXP_0; REAL_NEG_0] THEN | |
| SIMP_TAC[GSYM CX_LOG; REAL_EXP_POS_LT; LOG_EXP] THEN ANTS_TAC THENL | |
| [REWRITE_TAC[REAL_POS; COUNTABLE_INSERT; COUNTABLE_EMPTY] THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| ASM_SIMP_TAC[GSYM LOG_INV; LOG_POS; REAL_INV_1_LE] THEN | |
| REWRITE_TAC[GSYM DROP_NEG; INTEGRABLE_REFLECT_GEN] THEN | |
| REWRITE_TAC[REFLECT_INTERVAL; VECTOR_NEG_NEG; VECTOR_NEG_0] THEN | |
| ASM_SIMP_TAC[EULER_ORIGINAL_INTEGRABLE] THEN REPEAT CONJ_TAC THENL | |
| [REWRITE_TAC[GSYM LIFT_NEG; DROP_NEG] THEN | |
| REWRITE_TAC[GSYM LIFT_NUM; GSYM IMAGE_LIFT_REAL_INTERVAL] THEN | |
| REWRITE_TAC[REWRITE_RULE[o_DEF] (GSYM REAL_CONTINUOUS_ON)] THEN | |
| MATCH_MP_TAC REAL_DIFFERENTIABLE_ON_IMP_REAL_CONTINUOUS_ON THEN | |
| REWRITE_TAC[REAL_DIFFERENTIABLE_ON_DIFFERENTIABLE] THEN | |
| REPEAT STRIP_TAC THEN REAL_DIFFERENTIABLE_TAC; | |
| REWRITE_TAC[SUBSET; FORALL_IN_IMAGE; IN_INTERVAL_1; DROP_VEC; | |
| FORALL_LIFT; LIFT_DROP; DROP_NEG] THEN | |
| X_GEN_TAC `y:real` THEN STRIP_TAC THEN | |
| REWRITE_TAC[REAL_ARITH `--x <= &0 <=> &0 <= x`; REAL_EXP_POS_LE] THEN | |
| REWRITE_TAC[REAL_EXP_NEG; REAL_LE_NEG2] THEN | |
| MATCH_MP_TAC REAL_INV_LE_1 THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM REAL_EXP_0] THEN | |
| ASM_REWRITE_TAC[REAL_EXP_MONO_LE]; | |
| REWRITE_TAC[SUBSET; FORALL_IN_IMAGE; IN_INTERVAL_1; DROP_VEC; | |
| FORALL_LIFT; LIFT_DROP; DROP_NEG; IN_DIFF; IN_INSERT; | |
| NOT_IN_EMPTY; GSYM DROP_EQ; DE_MORGAN_THM] THEN | |
| X_GEN_TAC `y:real` THEN REPEAT STRIP_TAC THENL | |
| [MATCH_MP_TAC HAS_VECTOR_DERIVATIVE_AT_WITHIN THEN | |
| REWRITE_TAC[GSYM LIFT_NEG; REWRITE_RULE[o_DEF] | |
| (GSYM HAS_REAL_VECTOR_DERIVATIVE_AT)] THEN | |
| REAL_DIFF_TAC THEN REAL_ARITH_TAC; | |
| MATCH_MP_TAC CONTINUOUS_AT_WITHIN THEN | |
| SUBGOAL_THEN | |
| `(\t. --clog(Cx(--drop t)) cpow (z - Cx(&1))) = | |
| (\w. --clog w cpow (z - Cx(&1))) o (\t. Cx(drop(--t)))` | |
| SUBST1_TAC THENL [REWRITE_TAC[o_DEF; DROP_NEG]; ALL_TAC] THEN | |
| MATCH_MP_TAC CONTINUOUS_AT_COMPOSE THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_CX_DROP THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM ETA_AX] THEN | |
| SIMP_TAC[CONTINUOUS_NEG; CONTINUOUS_AT_ID]; | |
| MATCH_MP_TAC COMPLEX_DIFFERENTIABLE_IMP_CONTINUOUS_AT THEN | |
| COMPLEX_DIFFERENTIABLE_TAC THEN | |
| REWRITE_TAC[RE_CX; VECTOR_NEG_NEG; LIFT_DROP] THEN | |
| SIMP_TAC[REAL_EXP_POS_LT; GSYM CX_LOG; LOG_EXP] THEN | |
| REWRITE_TAC[RE_NEG; RE_CX; REAL_NEG_NEG] THEN | |
| ASM_REAL_ARITH_TAC]]]; | |
| DISCH_THEN(MP_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN | |
| ASM_SIMP_TAC[EXP_LOG; LIFT_NUM; COMPLEX_CMUL; CX_EXP; CEXP_NEG; CX_NEG; | |
| COMPLEX_NEG_NEG] THEN | |
| DISCH_THEN(SUBST1_TAC o SYM) THEN | |
| ONCE_REWRITE_TAC[COMPLEX_MUL_SYM] THEN REWRITE_TAC[complex_div]]; | |
| FIRST_ASSUM(MP_TAC o MATCH_MP EULER_HAS_INTEGRAL_CGAMMA) THEN | |
| GEN_REWRITE_TAC LAND_CONV [HAS_INTEGRAL_ALT] THEN | |
| REWRITE_TAC[INTEGRABLE_RESTRICT_INTER; INTEGRAL_RESTRICT_INTER] THEN | |
| DISCH_THEN(ASSUME_TAC o CONJUNCT2) THEN REWRITE_TAC[LIM_WITHIN] THEN | |
| X_GEN_TAC `e:real` THEN DISCH_TAC THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `e:real`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `exp(--B)` THEN ASM_REWRITE_TAC[REAL_EXP_POS_LT] THEN | |
| REWRITE_TAC[REAL_LT_01; DIST_0; NORM_POS_LT; IN_INTERVAL_1; DROP_VEC; | |
| GSYM DROP_EQ; DROP_VEC; FORALL_LIFT; LIFT_DROP; NORM_LIFT] THEN | |
| X_GEN_TAC `x:real` THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `&0 < x` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| FIRST_X_ASSUM(MP_TAC o SPECL [`--lift B`; `lift(--log x)`]) THEN | |
| ANTS_TAC THENL | |
| [REWRITE_TAC[BALL_1; SUBSET_INTERVAL_1; DROP_ADD; DROP_SUB; DROP_VEC] THEN | |
| REWRITE_TAC[LIFT_DROP; DROP_NEG] THEN DISJ2_TAC THEN | |
| REPEAT(CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC]) THEN | |
| REWRITE_TAC[REAL_ADD_LID] THEN | |
| ONCE_REWRITE_TAC[GSYM REAL_EXP_MONO_LE] THEN | |
| ASM_SIMP_TAC[REAL_EXP_NEG; EXP_LOG] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM REAL_INV_INV] THEN | |
| ONCE_REWRITE_TAC[GSYM REAL_EXP_NEG] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN ASM_REAL_ARITH_TAC; | |
| MATCH_MP_TAC(NORM_ARITH | |
| `i = j ==> norm(i - g) < e ==> dist(j,g) < e`) THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[EXTENSION; IN_INTER; IN_ELIM_THM; IN_INTERVAL_1] THEN | |
| REWRITE_TAC[DROP_NEG; LIFT_DROP; DROP_VEC] THEN ASM_REAL_ARITH_TAC]]);; | |
| let EULER_ORIGINAL_INTEGRAL = prove | |
| (`!z. &0 < Re z | |
| ==> integral (interval[vec 0,vec 1]) | |
| (\t. (--clog(Cx(drop t))) cpow (z - Cx(&1))) = | |
| cgamma(z)`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN | |
| MATCH_MP_TAC EULER_ORIGINAL_HAS_INTEGRAL_CGAMMA THEN | |
| ASM_REWRITE_TAC[]);; | |
| let EULER_ORIGINAL_HAS_REAL_INTEGRAL_GAMMA = prove | |
| (`!x. &0 < x | |
| ==> ((\t. (--log t) rpow (x - &1)) has_real_integral gamma(x)) | |
| (real_interval[&0,&1])`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[has_real_integral] THEN | |
| MP_TAC(SPEC `Cx x` EULER_ORIGINAL_HAS_INTEGRAL_CGAMMA) THEN | |
| ASM_REWRITE_TAC[gamma; o_DEF; RE_CX] THEN | |
| DISCH_THEN(MP_TAC o ISPEC `lift o Re` o MATCH_MP | |
| (REWRITE_RULE[IMP_CONJ] HAS_INTEGRAL_LINEAR)) THEN | |
| REWRITE_TAC[o_DEF] THEN ANTS_TAC THENL | |
| [REWRITE_TAC[linear; RE_ADD; LIFT_ADD; COMPLEX_CMUL; RE_MUL_CX] THEN | |
| REWRITE_TAC[LIFT_CMUL]; | |
| REWRITE_TAC[IMAGE_LIFT_REAL_INTERVAL; LIFT_NUM]] THEN | |
| MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ] (REWRITE_RULE[CONJ_ASSOC] | |
| HAS_INTEGRAL_SPIKE)) THEN | |
| EXISTS_TAC `{vec 0:real^1,vec 1}` THEN | |
| REWRITE_TAC[NEGLIGIBLE_INSERT; FORALL_LIFT; IN_INTERVAL_1; DE_MORGAN_THM; | |
| LIFT_DROP; IN_INSERT; NOT_IN_EMPTY; GSYM DROP_EQ; DROP_VEC; IN_DIFF] THEN | |
| REWRITE_TAC[NEGLIGIBLE_EMPTY] THEN X_GEN_TAC `y:real` THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `&0 < y` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| SUBGOAL_THEN `&0 < --log y` ASSUME_TAC THENL | |
| [ASM_SIMP_TAC[GSYM LOG_INV] THEN MATCH_MP_TAC LOG_POS_LT THEN | |
| MATCH_MP_TAC REAL_INV_1_LT THEN ASM_REAL_ARITH_TAC; | |
| ASM_SIMP_TAC[GSYM CX_LOG; cpow; rpow; COMPLEX_NEG_EQ_0; CX_INJ; | |
| REAL_LT_IMP_NZ] THEN | |
| ASM_SIMP_TAC[GSYM CX_NEG; GSYM CX_LOG; GSYM CX_SUB; GSYM CX_MUL] THEN | |
| COND_CASES_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[GSYM CX_EXP; RE_CX]]);; | |
| let EULER_ORIGINAL_REAL_INTEGRAL = prove | |
| (`!x. &0 < x | |
| ==> real_integral (real_interval[&0,&1]) | |
| (\t. (--log t) rpow (x - &1)) = | |
| gamma(x)`, | |
| MESON_TAC[REAL_INTEGRAL_UNIQUE; EULER_ORIGINAL_HAS_REAL_INTEGRAL_GAMMA]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Stirling's approximation. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let LGAMMA_STIRLING_INTEGRALS_EXIST,LGAMMA_STIRLING = (CONJ_PAIR o prove) | |
| (`(!z n. 1 <= n /\ (Im z = &0 ==> &0 < Re z) | |
| ==> (\t. Cx(bernoulli n (frac (drop t))) / (z + Cx(drop t)) pow n) | |
| integrable_on {t | &0 <= drop t}) /\ | |
| (!z p. | |
| (Im z = &0 ==> &0 < Re z) | |
| ==> lgamma(z) = | |
| ((z - Cx(&1) / Cx(&2)) * clog(z) - z + Cx(log(&2 * pi) / &2)) + | |
| vsum(1..p) (\k. Cx(bernoulli (2 * k) (&0) / | |
| (&4 * &k pow 2 - &2 * &k)) / z pow (2 * k - 1)) - | |
| integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli (2 * p + 1) (frac(drop t))) / | |
| (z + Cx(drop t)) pow (2 * p + 1)) / | |
| Cx(&(2 * p + 1)))`, | |
| let lemma1 = prove | |
| (`!p n z. (Im z = &0 ==> &0 < Re z) | |
| ==> (\x. Cx(bernoulli (2 * p + 1) (frac(drop x))) * | |
| Cx(&(FACT(2 * p))) / (z + Cx(drop x)) pow (2 * p + 1)) | |
| integrable_on interval [lift(&0),lift(&n)] /\ | |
| vsum(0..n) (\m. clog(Cx(&m) + z)) = | |
| (z + Cx(&n) + Cx(&1) / Cx(&2)) * clog(z + Cx(&n)) - | |
| (z - Cx(&1) / Cx(&2)) * clog(z) - Cx(&n) + | |
| vsum(1..p) | |
| (\k. Cx(bernoulli (2 * k) (&0) / &(FACT(2 * k))) * | |
| (Cx(&(FACT(2 * k - 2))) / (z + Cx(&n)) pow (2 * k - 1) - | |
| Cx(&(FACT(2 * k - 2))) / z pow (2 * k - 1))) + | |
| integral (interval[lift(&0),lift(&n)]) | |
| (\x. Cx(bernoulli (2 * p + 1) (frac(drop x))) * | |
| Cx(&(FACT(2 * p))) / (z + Cx(drop x)) pow (2 * p + 1)) / | |
| Cx(&(FACT(2 * p + 1)))`, | |
| REPEAT GEN_TAC THEN STRIP_TAC THEN | |
| REWRITE_TAC[COMPLEX_RING `Cx(&n) + z = z + Cx(&n)`] THEN MP_TAC(ISPECL | |
| [`\n w. if n = 0 then (z + w) * clog(z + w) - (z + w) | |
| else if n = 1 then clog(z + w) | |
| else Cx(--(&1) pow n * &(FACT(n - 2))) / | |
| (z + w) pow (n - 1)`; | |
| `0`; `n:num`; `p:num`] COMPLEX_EULER_MACLAURIN_ANTIDERIVATIVE) THEN | |
| ASM_REWRITE_TAC[ADD_EQ_0; MULT_EQ_0; MULT_EQ_1] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN ANTS_TAC THENL | |
| [REWRITE_TAC[IN_REAL_INTERVAL; LE_0] THEN | |
| MAP_EVERY X_GEN_TAC [`k:num`; `x:real`] THEN REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `~(z + Cx x = Cx(&0))` ASSUME_TAC THENL | |
| [REWRITE_TAC[COMPLEX_EQ; IM_ADD; RE_ADD; IM_CX; RE_CX] THEN | |
| ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[o_THM; ARITH_RULE `k + 1 = 1 <=> k = 0`] THEN | |
| ASM_CASES_TAC `k = 0` THEN ASM_REWRITE_TAC[] THENL | |
| [COMPLEX_DIFF_TAC THEN CONJ_TAC THENL | |
| [REWRITE_TAC[RE_ADD; IM_ADD; RE_CX; IM_CX] THEN ASM_REAL_ARITH_TAC; | |
| UNDISCH_TAC `~(z + Cx x = Cx(&0))` THEN CONV_TAC COMPLEX_FIELD]; | |
| ALL_TAC] THEN | |
| ASM_CASES_TAC `k = 1` THEN ASM_REWRITE_TAC[] THEN COMPLEX_DIFF_TAC THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[complex_div; COMPLEX_ADD_LID; COMPLEX_MUL_LID; | |
| COMPLEX_POW_1; IM_ADD; RE_ADD; IM_CX; RE_CX] THEN | |
| (CONJ_TAC ORELSE ASM_REAL_ARITH_TAC) THEN | |
| ASM_REWRITE_TAC[COMPLEX_POW_EQ_0] THEN | |
| REWRITE_TAC[REAL_POW_ADD; REAL_POW_1; COMPLEX_MUL_LZERO] THEN | |
| REWRITE_TAC[REAL_MUL_RNEG; REAL_MUL_RID; REAL_NEG_NEG; REAL_MUL_LNEG] THEN | |
| REWRITE_TAC[COMPLEX_MUL_RID; CX_NEG; COMPLEX_POW_POW] THEN | |
| REWRITE_TAC[GSYM COMPLEX_MUL_ASSOC; COMPLEX_SUB_LZERO; COMPLEX_NEG_NEG; | |
| COMPLEX_MUL_LNEG] THEN | |
| REWRITE_TAC[GSYM complex_div] THEN AP_TERM_TAC THEN | |
| FIRST_X_ASSUM(K ALL_TAC o check (is_imp o concl)) THEN | |
| ASM_SIMP_TAC[GSYM complex_div; COMPLEX_DIV_POW2] THEN COND_CASES_TAC THENL | |
| [MATCH_MP_TAC(TAUT `F ==> p`) THEN ASM_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[ADD_SUB; ARITH_RULE | |
| `~(k = 0) /\ ~(k = 1) ==> (k - 1) * 2 - (k - 1 - 1) = k`] THEN | |
| REWRITE_TAC[COMPLEX_MUL_ASSOC; complex_div] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN REWRITE_TAC[GSYM CX_MUL] THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[GSYM REAL_MUL_ASSOC] THEN AP_TERM_TAC THEN | |
| ASM_SIMP_TAC[ARITH_RULE `~(k = 0) ==> (k + 1) - 2 = k - 1`] THEN | |
| ASM_SIMP_TAC[ARITH_RULE | |
| `~(k = 0) /\ ~(k = 1) ==> k - 1 = SUC(k - 2)`] THEN | |
| REWRITE_TAC[FACT; REAL_OF_NUM_MUL] THEN REWRITE_TAC[MULT_SYM]; | |
| REWRITE_TAC[ARITH_RULE `~(2 * p + 2 = 1)`] THEN | |
| DISCH_THEN(CONJUNCTS_THEN2 MP_TAC SUBST1_TAC)] THEN | |
| SIMP_TAC[LE_1] THEN | |
| REWRITE_TAC[ARITH_RULE `(2 * p + 2) - 1 = 2 * p + 1`; ADD_SUB] THEN | |
| REWRITE_TAC[REAL_POW_NEG; EVEN_ADD; EVEN_MULT; ARITH_EVEN] THEN | |
| REWRITE_TAC[REAL_POW_ONE; REAL_MUL_LID] THEN | |
| DISCH_TAC THEN ASM_REWRITE_TAC[COMPLEX_ADD_RID] THEN | |
| CONV_TAC COMPLEX_RING) in | |
| let lemma2 = prove | |
| (`!z n. 2 <= n /\ (Im z = &0 ==> &0 < Re z) | |
| ==> (\t. inv(z + Cx(drop t)) pow n) | |
| absolutely_integrable_on {t | &0 <= drop t}`, | |
| REPEAT STRIP_TAC THEN REWRITE_TAC[COMPLEX_POW_INV] THEN | |
| MATCH_MP_TAC | |
| MEASURABLE_BOUNDED_BY_INTEGRABLE_IMP_ABSOLUTELY_INTEGRABLE THEN | |
| EXISTS_TAC `\t. lift(inv(max (abs(Im z)) (Re z + drop t)) pow n)` THEN | |
| REWRITE_TAC[] THEN REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_IMP_MEASURABLE_ON_LEBESGUE_MEASURABLE_SUBSET THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC CONTINUOUS_ON_COMPLEX_INV THEN | |
| SIMP_TAC[CONTINUOUS_ON_COMPLEX_POW; CONTINUOUS_ON_ADD; | |
| CONTINUOUS_ON_CONST; CONTINUOUS_ON_ID; CONTINUOUS_ON_CX_DROP] THEN | |
| REWRITE_TAC[IN_ELIM_THM; GSYM FORALL_DROP] THEN | |
| REWRITE_TAC[COMPLEX_POW_EQ_0] THEN | |
| REWRITE_TAC[COMPLEX_EQ; RE_ADD; IM_ADD; RE_CX; IM_CX] THEN | |
| ASM_REAL_ARITH_TAC; | |
| MATCH_MP_TAC LEBESGUE_MEASURABLE_CONVEX THEN | |
| MATCH_MP_TAC IS_INTERVAL_CONVEX THEN | |
| REWRITE_TAC[IS_INTERVAL_1; IN_ELIM_THM] THEN REAL_ARITH_TAC]; | |
| ALL_TAC; | |
| REWRITE_TAC[FORALL_IN_GSPEC; GSYM FORALL_DROP; LIFT_DROP] THEN | |
| X_GEN_TAC `x:real` THEN DISCH_TAC THEN | |
| REWRITE_TAC[GSYM COMPLEX_POW_INV; COMPLEX_NORM_POW] THEN | |
| MATCH_MP_TAC REAL_POW_LE2 THEN | |
| REWRITE_TAC[NORM_POS_LE; COMPLEX_NORM_INV] THEN | |
| MATCH_MP_TAC REAL_LE_INV2 THEN | |
| MP_TAC(SPEC `z + Cx x` COMPLEX_NORM_GE_RE_IM) THEN | |
| REWRITE_TAC[RE_ADD; IM_ADD; RE_CX; IM_CX] THEN ASM_REAL_ARITH_TAC] THEN | |
| REWRITE_TAC[REAL_ARITH `max m n = if n <= m then m else n`] THEN | |
| REWRITE_TAC[COND_RAND; COND_RATOR] THEN | |
| MATCH_MP_TAC INTEGRABLE_CASES THEN REWRITE_TAC[IN_ELIM_THM] THEN | |
| CONJ_TAC THENL | |
| [SUBGOAL_THEN | |
| `{t | &0 <= drop t /\ Re z + drop t <= abs (Im z)} = | |
| interval[vec 0,lift(abs(Im z) - Re z)]` | |
| (fun th -> REWRITE_TAC[th; INTEGRABLE_CONST]) THEN | |
| SIMP_TAC[EXTENSION; IN_ELIM_THM; IN_INTERVAL_1; DROP_VEC; LIFT_DROP] THEN | |
| REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_IMP] INTEGRABLE_SPIKE_SET) THEN | |
| EXISTS_TAC | |
| `{t | abs(Im z) - Re z <= drop t} INTER {t | &0 <= drop t}` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN | |
| EXISTS_TAC `{lift(abs(Im z) - Re z)}` THEN | |
| REWRITE_TAC[NEGLIGIBLE_SING] THEN | |
| REWRITE_TAC[SUBSET; IN_DIFF; IN_UNION; | |
| IN_ELIM_THM; IN_SING; IN_INTER] THEN | |
| REWRITE_TAC[GSYM DROP_EQ; LIFT_DROP] THEN ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[GSYM INTEGRABLE_RESTRICT_INTER] THEN | |
| REWRITE_TAC[integrable_on] THEN | |
| ONCE_REWRITE_TAC[HAS_INTEGRAL_LIM_AT_POSINFINITY] THEN | |
| REWRITE_TAC[INTEGRABLE_RESTRICT_INTER; INTEGRAL_RESTRICT_INTER] THEN | |
| SUBGOAL_THEN | |
| `!a. {t | abs(Im z) - Re z <= drop t} INTER interval[vec 0,a] = | |
| interval[lift(max (&0) (abs (Im z) - Re z)),a]` | |
| (fun th -> REWRITE_TAC[th]) | |
| THENL | |
| [REWRITE_TAC[EXTENSION; IN_INTER; IN_ELIM_THM; IN_INTERVAL_1] THEN | |
| REWRITE_TAC[LIFT_DROP; DROP_VEC] THEN REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN | |
| `!b. &0 <= drop b /\ abs (Im z) - Re z <= drop b | |
| ==> ((\x. lift(inv (Re z + drop x) pow n)) has_integral | |
| lift | |
| (inv((&1 - &n) * (Re z + drop b) pow (n - 1)) - | |
| inv((&1 - &n) * | |
| (Re z + max(&0) (abs(Im z) - Re z)) pow (n - 1)))) | |
| (interval[lift(max (&0) (abs (Im z) - Re z)),b])` | |
| ASSUME_TAC THENL | |
| [REPEAT STRIP_TAC THEN | |
| MP_TAC(ISPECL | |
| [`\x. lift(inv((&1 - &n) * (Re z + drop x) pow (n - 1)))`; | |
| `\x. lift(inv(Re z + drop x) pow n)`; | |
| `lift(max (&0) (abs (Im z) - Re z))`; | |
| `b:real^1`] FUNDAMENTAL_THEOREM_OF_CALCULUS) THEN | |
| ASM_REWRITE_TAC[IN_INTERVAL_1; LIFT_DROP; REAL_MAX_LE] THEN | |
| ANTS_TAC THENL | |
| [REWRITE_TAC[FORALL_LIFT; LIFT_DROP; INTERVAL_REAL_INTERVAL] THEN | |
| REWRITE_TAC[REWRITE_RULE[o_DEF] | |
| (GSYM HAS_REAL_VECTOR_DERIVATIVE_WITHIN)] THEN | |
| REWRITE_TAC[REAL_INV_MUL; REAL_INV_POW] THEN REPEAT STRIP_TAC THEN | |
| REAL_DIFF_TAC THEN | |
| ASM_SIMP_TAC[GSYM REAL_OF_NUM_SUB; ARITH_RULE `2 <= n ==> 1 <= n`] THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| ASM_SIMP_TAC[real_div; REAL_OF_NUM_LE; REAL_FIELD | |
| `&2 <= x ==> inv(&1 - x) * (x - &1) * y * --(&0 + &1) * p = | |
| y * p`] THEN | |
| REWRITE_TAC[GSYM REAL_INV_MUL; GSYM REAL_INV_POW] THEN | |
| AP_TERM_TAC THEN REWRITE_TAC[GSYM REAL_POW_ADD] THEN | |
| AP_TERM_TAC THEN ASM_ARITH_TAC; | |
| REWRITE_TAC[LIFT_DROP; GSYM LIFT_SUB]]; | |
| ALL_TAC] THEN | |
| EXISTS_TAC `lift(inv | |
| ((&n - &1) * | |
| (Re z + max (&0) (abs(Im z) - Re z)) pow (n - 1)))` THEN | |
| CONJ_TAC THENL | |
| [X_GEN_TAC `b:real^1` THEN | |
| ASM_CASES_TAC `&0 <= drop b /\ abs (Im z) - Re z <= drop b` THENL | |
| [ASM_MESON_TAC[integrable_on]; MATCH_MP_TAC INTEGRABLE_ON_NULL] THEN | |
| REWRITE_TAC[CONTENT_EQ_0_1; LIFT_DROP] THEN ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC | |
| `\b. lift(inv((&1 - &n) * (Re z + b) pow (n - 1)) - | |
| inv((&1 - &n) * | |
| (Re z + max (&0) (abs(Im z) - Re z)) pow (n - 1)))` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN | |
| EXISTS_TAC `max(&0) (abs(Im z) - Re z)` THEN | |
| REWRITE_TAC[FORALL_DROP; LIFT_DROP] THEN | |
| REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN | |
| MATCH_MP_TAC INTEGRAL_UNIQUE THEN FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[LIFT_SUB; VECTOR_SUB] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM VECTOR_ADD_LID] THEN | |
| MATCH_MP_TAC LIM_ADD THEN | |
| REWRITE_TAC[GSYM LIFT_NEG; GSYM REAL_INV_NEG; GSYM REAL_MUL_LNEG] THEN | |
| REWRITE_TAC[REAL_NEG_SUB; LIM_CONST] THEN | |
| REWRITE_TAC[REAL_INV_MUL; LIFT_CMUL] THEN | |
| MATCH_MP_TAC LIM_NULL_CMUL THEN | |
| REWRITE_TAC[GSYM LIFT_NUM; GSYM LIM_CX_LIFT] THEN | |
| REWRITE_TAC[CX_INV; CX_POW; GSYM COMPLEX_POW_INV; CX_ADD] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN | |
| MATCH_MP_TAC LIM_INV_X_POW_OFFSET THEN ASM_ARITH_TAC) in | |
| let lemma3 = prove | |
| (`!z n. 2 <= n /\ (Im z = &0 ==> &0 < Re z) | |
| ==> (\t. Cx(bernoulli n (frac (drop t))) / (z + Cx(drop t)) pow n) | |
| integrable_on {t | &0 <= drop t}`, | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[complex_div; GSYM COMPLEX_CMUL] THEN | |
| MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN | |
| MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ON_MUL_BERNOULLI_FRAC THEN | |
| ASM_SIMP_TAC[GSYM COMPLEX_POW_INV; lemma2]) in | |
| let lemma4 = prove | |
| (`!z p. (Im z = &0 ==> &0 < Re z) /\ 1 <= p | |
| ==> ((\t. Cx(bernoulli 1 (frac(drop t))) / (z + Cx(drop t))) | |
| has_integral | |
| (integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli (2 * p + 1) (frac(drop t))) / | |
| (z + Cx(drop t)) pow (2 * p + 1)) / | |
| Cx(&(2 * p + 1)) - | |
| vsum(1..p) (\k. Cx(bernoulli (2 * k) (&0) / | |
| (&4 * &k pow 2 - &2 * &k)) / | |
| z pow (2 * k - 1)))) | |
| {t | &0 <= drop t}`, | |
| REPEAT STRIP_TAC THEN | |
| MATCH_MP_TAC HAS_INTEGRAL_LIM_SEQUENTIALLY THEN CONJ_TAC THENL | |
| [REWRITE_TAC[o_DEF; LIFT_DROP; complex_div; COMPLEX_VEC_0] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL_BOUNDED THEN | |
| EXISTS_TAC `&1 / &2` THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC `x:real` THEN | |
| REWRITE_TAC[BERNOULLI_CONV `bernoulli 1 x`] THEN DISJ1_TAC THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX] THEN | |
| MP_TAC(SPEC `x:real` FLOOR_FRAC) THEN REAL_ARITH_TAC; | |
| MATCH_MP_TAC(REWRITE_RULE[o_DEF] LIM_INFINITY_POSINFINITY_CX) THEN | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN REWRITE_TAC[LIM_INV_Z_OFFSET]]; | |
| ALL_TAC] THEN | |
| MP_TAC(GEN `n:num` (CONJ | |
| (SPECL [`0`; `n:num`; `z:complex`] lemma1) | |
| (SPECL [`p:num`; `n:num`; `z:complex`] lemma1))) THEN | |
| ASM_REWRITE_TAC[FORALL_AND_THM] THEN ONCE_REWRITE_TAC[IMP_CONJ] THEN | |
| REWRITE_TAC[VSUM_CLAUSES_NUMSEG] THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[SIMPLE_COMPLEX_ARITH `a * Cx(&1) / b = a / b`] THEN | |
| REWRITE_TAC[LIFT_NUM; COMPLEX_POW_1; COMPLEX_DIV_1] THEN | |
| DISCH_THEN(fun th -> ONCE_REWRITE_TAC[th]) THEN | |
| REWRITE_TAC[VECTOR_ARITH `a + vec 0 + x:real^N = a + y <=> x = y`] THEN | |
| DISCH_THEN(fun th -> ONCE_REWRITE_TAC[th]) THEN | |
| GEN_REWRITE_TAC LAND_CONV [COMPLEX_RING `a - b:complex = --b + a`] THEN | |
| MATCH_MP_TAC LIM_ADD THEN CONJ_TAC THENL | |
| [REWRITE_TAC[GSYM VSUM_NEG] THEN MATCH_MP_TAC LIM_VSUM THEN | |
| REWRITE_TAC[FINITE_NUMSEG; IN_NUMSEG] THEN | |
| X_GEN_TAC `k:num` THEN STRIP_TAC THEN | |
| REWRITE_TAC[CX_DIV; complex_div; GSYM COMPLEX_MUL_RNEG] THEN | |
| REWRITE_TAC[GSYM COMPLEX_MUL_ASSOC] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_LMUL THEN | |
| REWRITE_TAC[SIMPLE_COMPLEX_ARITH | |
| `inv x * (y * w - y * z):complex = y / x * (w - z)`] THEN | |
| SUBGOAL_THEN | |
| `Cx(&(FACT(2 * k - 2))) / Cx(&(FACT(2 * k))) = | |
| inv(Cx(&4 * &k pow 2 - &2 * &k))` | |
| (fun th -> ONCE_REWRITE_TAC[th]) | |
| THENL | |
| [MATCH_MP_TAC(COMPLEX_FIELD | |
| `~(y = Cx(&0)) /\ ~(z = Cx(&0)) /\ x * z = y | |
| ==> x / y = inv(z)`) THEN | |
| REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ; FACT_NZ] THEN | |
| REWRITE_TAC[REAL_ENTIRE; REAL_ARITH | |
| `&4 * x pow 2 - &2 * x = (&2 * x) * (&2 * x - &1)`] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `1 <= k ==> 1 <= 2 * k`; REAL_OF_NUM_SUB; | |
| REAL_OF_NUM_MUL; GSYM CX_MUL; CX_INJ; REAL_OF_NUM_EQ] THEN | |
| CONJ_TAC THENL [ASM_ARITH_TAC; ALL_TAC] THEN | |
| UNDISCH_TAC `1 <= k` THEN SPEC_TAC(`k:num`,`k:num`) THEN | |
| INDUCT_TAC THEN REWRITE_TAC[ADD_CLAUSES; MULT_CLAUSES] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN DISCH_THEN (K ALL_TAC) THEN | |
| REWRITE_TAC[ARITH_RULE `(2 + k) - 2 = k /\ (2 + k) - 1 = k + 1`] THEN | |
| REWRITE_TAC[ARITH_RULE `2 + k = SUC(SUC k)`; FACT] THEN ARITH_TAC; | |
| MATCH_MP_TAC LIM_COMPLEX_LMUL THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING `--z = Cx(&0) - z`] THEN | |
| MATCH_MP_TAC LIM_SUB THEN REWRITE_TAC[LIM_CONST] THEN | |
| REWRITE_TAC[GSYM COMPLEX_POW_INV] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN | |
| MATCH_MP_TAC LIM_INV_N_POW_OFFSET THEN ASM_ARITH_TAC]; | |
| MP_TAC(SPECL [`z:complex`; `2 * p + 1`] lemma3) THEN | |
| ASM_REWRITE_TAC[] THEN ANTS_TAC THENL [ASM_ARITH_TAC; DISCH_TAC] THEN | |
| FIRST_ASSUM(MP_TAC o SPEC `Cx(&(FACT(2 * p)))` o | |
| MATCH_MP INTEGRABLE_COMPLEX_LMUL) THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN | |
| ASM_SIMP_TAC[INTEGRAL_COMPLEX_LMUL] THEN | |
| REWRITE_TAC[HAS_INTEGRAL_LIM_AT_POSINFINITY] THEN | |
| DISCH_THEN(MP_TAC o | |
| MATCH_MP LIM_POSINFINITY_SEQUENTIALLY o CONJUNCT2) THEN | |
| DISCH_THEN(MP_TAC o SPEC `inv(Cx(&(FACT(2 * p + 1))))` o | |
| MATCH_MP LIM_COMPLEX_RMUL) THEN | |
| MATCH_MP_TAC EQ_IMP THEN AP_THM_TAC THEN BINOP_TAC THENL | |
| [REWRITE_TAC[LIFT_NUM; FUN_EQ_THM] THEN | |
| X_GEN_TAC `n:num` THEN REWRITE_TAC[complex_div] THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN MATCH_MP_TAC INTEGRAL_EQ THEN | |
| REWRITE_TAC[complex_div; COMPLEX_MUL_AC]; | |
| REWRITE_TAC[complex_div] THEN MATCH_MP_TAC(COMPLEX_RING | |
| `x * y:complex = z ==> (x * i) * y = i * z`) THEN | |
| REWRITE_TAC[GSYM ADD1; FACT; GSYM REAL_OF_NUM_MUL; CX_MUL] THEN | |
| MATCH_MP_TAC(COMPLEX_FIELD | |
| `~(a = Cx(&0)) /\ ~(b = Cx(&0)) ==> a * inv(b * a) = inv b`) THEN | |
| REWRITE_TAC[CX_INJ; REAL_OF_NUM_EQ; FACT_NZ; NOT_SUC]]]) in | |
| let lemma5 = prove | |
| (`!z n. 1 <= n /\ (Im z = &0 ==> &0 < Re z) | |
| ==> (\t. Cx(bernoulli n (frac (drop t))) / (z + Cx(drop t)) pow n) | |
| integrable_on {t | &0 <= drop t}`, | |
| REPEAT STRIP_TAC THEN FIRST_X_ASSUM(DISJ_CASES_TAC o MATCH_MP (ARITH_RULE | |
| `1 <= n ==> n = 1 \/ 2 <= n`)) THEN | |
| ASM_SIMP_TAC[lemma3; COMPLEX_POW_1] THEN | |
| REWRITE_TAC[integrable_on] THEN | |
| ASM_MESON_TAC[LE_REFL; lemma4]) in | |
| let lemma6 = prove | |
| (`!z. (Im z = &0 ==> &0 < Re z) | |
| ==> lgamma(z) = | |
| ((z - Cx(&1) / Cx(&2)) * clog(z) - z + Cx(&1)) + | |
| (integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli 1 (frac(drop t))) / | |
| (Cx(&1) + Cx(drop t))) - | |
| integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli 1 (frac(drop t))) / | |
| (z + Cx(drop t))))`, | |
| REPEAT STRIP_TAC THEN | |
| SUBGOAL_THEN `!n. ~(z + Cx(&n) = Cx(&0))` ASSUME_TAC THENL | |
| [REWRITE_TAC[COMPLEX_EQ; IM_ADD; RE_ADD; IM_CX; RE_CX] THEN | |
| ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| SUBGOAL_THEN `~(z = Cx(&0))` ASSUME_TAC THENL | |
| [ASM_MESON_TAC[COMPLEX_ADD_RID]; ALL_TAC] THEN | |
| FIRST_ASSUM(MP_TAC o MATCH_MP LGAMMA_ALT) THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] | |
| (REWRITE_RULE[TRIVIAL_LIMIT_SEQUENTIALLY] | |
| (ISPEC `sequentially` LIM_UNIQUE))) THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN EXISTS_TAC | |
| `\n. z * clog (Cx(&n)) - clog (Cx(&n + &1)) + | |
| ((Cx(&1) + Cx(&n) + Cx(&1) / Cx(&2)) * clog (Cx(&1) + Cx(&n)) - | |
| (Cx(&1) - Cx(&1) / Cx(&2)) * clog (Cx(&1)) - | |
| Cx(&n) + | |
| integral (interval [lift (&0),lift (&n)]) | |
| (\x. Cx(bernoulli 1 (frac (drop x))) * | |
| Cx(&1) / (Cx(&1) + Cx(drop x)) pow 1) / | |
| Cx(&1)) - | |
| ((z + Cx(&n) + Cx(&1) / Cx(&2)) * clog (z + Cx(&n)) - | |
| (z - Cx(&1) / Cx(&2)) * clog z - | |
| Cx(&n) + | |
| integral (interval [lift (&0),lift (&n)]) | |
| (\x. Cx(bernoulli 1 (frac (drop x))) * | |
| Cx(&1) / (z + Cx(drop x)) pow 1) / | |
| Cx(&1))` THEN | |
| REWRITE_TAC[] THEN CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `1` THEN X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN | |
| `clog(Cx(&(FACT n))) = | |
| vsum(0..n) (\m. clog(Cx(&m) + Cx(&1))) - clog(Cx(&n + &1))` | |
| SUBST1_TAC THENL | |
| [REWRITE_TAC[REAL_OF_NUM_ADD; GSYM CX_ADD] THEN | |
| REWRITE_TAC[GSYM(SPEC `1` VSUM_OFFSET); ADD_CLAUSES] THEN | |
| SIMP_TAC[GSYM NPRODUCT_FACT; REAL_OF_NUM_NPRODUCT; FINITE_NUMSEG; | |
| GSYM CX_LOG; LOG_PRODUCT; PRODUCT_POS_LT; IN_NUMSEG; | |
| REAL_OF_NUM_LT; LE_1; GSYM VSUM_CX] THEN | |
| REWRITE_TAC[GSYM ADD1; VSUM_CLAUSES_NUMSEG] THEN | |
| REWRITE_TAC[ARITH_RULE `1 <= SUC n`; REAL_OF_NUM_SUC] THEN | |
| SIMP_TAC[CX_LOG; REAL_OF_NUM_LT; LT_0] THEN | |
| REWRITE_TAC[COMPLEX_RING `(a + b) - b:complex = a`]; | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `(a + b - c) - d:complex = (a - c) + (b - d)`]] THEN | |
| MP_TAC(SPECL [`0`; `n:num`] lemma1) THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN | |
| ASM_REWRITE_TAC[VSUM_CLAUSES_NUMSEG; ARITH; VECTOR_ADD_LID] THEN | |
| ASM_SIMP_TAC[RE_CX; REAL_LT_01]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[COMPLEX_POW_1; COMPLEX_DIV_1] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `a + (b - c - n + x) - (d - e - n + y):complex = | |
| (a + (b - c) - (d - e)) + (x - y)`] THEN | |
| MATCH_MP_TAC LIM_ADD THEN CONJ_TAC THENL | |
| [REWRITE_TAC[CLOG_1; COMPLEX_MUL_RZERO; COMPLEX_SUB_RZERO] THEN | |
| ONCE_REWRITE_TAC[LIM_NULL_COMPLEX] THEN REWRITE_TAC[] THEN | |
| ONCE_REWRITE_TAC[REAL_ADD_SYM] THEN REWRITE_TAC[CX_ADD] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN EXISTS_TAC | |
| `\n. z * (clog(Cx(&n)) - clog(z + Cx(&n))) + | |
| (Cx(&n) + Cx(&1) / Cx(&2)) * | |
| (clog(Cx(&1) + Cx(&n)) - clog(z + Cx(&n))) - | |
| (Cx(&1) - z)` THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC ALWAYS_EVENTUALLY THEN CONV_TAC COMPLEX_RING; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_ADD THEN CONJ_TAC THENL | |
| [MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| GEN_REWRITE_TAC (RATOR_CONV o LAND_CONV o BINDER_CONV o | |
| LAND_CONV o RAND_CONV) [GSYM COMPLEX_ADD_LID] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN REWRITE_TAC[LIM_SUB_CLOG]; | |
| ONCE_REWRITE_TAC[COMPLEX_RING | |
| `(a + h) * x - y:complex = h * x + a * x - y`] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_ADD THEN REWRITE_TAC[] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_ADD_SYM] THEN | |
| SIMP_TAC[LIM_NULL_COMPLEX_LMUL; LIM_SUB_CLOG] THEN | |
| REWRITE_TAC[GSYM LIM_NULL_COMPLEX; LIM_N_MUL_SUB_CLOG]]; | |
| REWRITE_TAC[complex_div; COMPLEX_MUL_LID] THEN | |
| REWRITE_TAC[LIFT_NUM] THEN MATCH_MP_TAC LIM_SUB THEN | |
| CONJ_TAC THEN REWRITE_TAC[GSYM LIFT_NUM] THEN | |
| MATCH_MP_TAC LIM_POSINFINITY_SEQUENTIALLY THEN | |
| REWRITE_TAC[LIFT_NUM] THEN | |
| MATCH_MP_TAC(MATCH_MP (TAUT `(p <=> q /\ r) ==> (p ==> r)`) | |
| (SPEC_ALL HAS_INTEGRAL_LIM_AT_POSINFINITY)) THEN | |
| REWRITE_TAC[GSYM HAS_INTEGRAL_INTEGRAL; GSYM complex_div] THEN | |
| ONCE_REWRITE_TAC[COMPLEX_RING `z + x:complex = (z + x) pow 1`] THEN | |
| MATCH_MP_TAC lemma5 THEN | |
| ASM_REWRITE_TAC[LE_REFL; RE_CX; REAL_LT_01]]) in | |
| let lemma7 = prove | |
| (`((\y. integral {t | &0 <= drop t} | |
| (\t. Cx (bernoulli 1 (frac (drop t))) / (ii * Cx y + Cx(drop t)))) | |
| --> Cx(&0)) at_posinfinity`, | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC | |
| `\y. integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli 3 (frac (drop t))) / | |
| (ii * Cx y + Cx(drop t)) pow 3) / Cx(&3) - | |
| Cx(bernoulli 2 (&0) / &2) / (ii * Cx y)` THEN | |
| CONJ_TAC THENL | |
| [REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN | |
| EXISTS_TAC `&1` THEN X_GEN_TAC `y:real` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `&0 < y` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MP_TAC(ISPECL [`ii * Cx y`; `1`] lemma4) THEN | |
| ASM_SIMP_TAC[IM_MUL_II; RE_CX; REAL_LT_IMP_NZ; LE_REFL] THEN | |
| REWRITE_TAC[VSUM_SING_NUMSEG] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[COMPLEX_POW_1] THEN | |
| DISCH_THEN(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN REFL_TAC; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_SUB THEN CONJ_TAC THENL | |
| [ALL_TAC; | |
| REWRITE_TAC[complex_div] THEN MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| REWRITE_TAC[COMPLEX_INV_MUL] THEN MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| REWRITE_TAC[LIM_INV_X]] THEN | |
| ONCE_REWRITE_TAC[complex_div] THEN MATCH_MP_TAC LIM_NULL_COMPLEX_RMUL THEN | |
| MATCH_MP_TAC LIM_NULL_COMPARISON_COMPLEX THEN | |
| EXISTS_TAC | |
| `\y. Cx(&1 / &2 / y) * | |
| integral {t | &0 <= drop t} | |
| (\t. inv(Cx(&1) + Cx(drop t)) pow 2)` THEN | |
| CONJ_TAC THENL | |
| [ALL_TAC; | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_RMUL THEN | |
| REWRITE_TAC[real_div; CX_MUL] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_LMUL THEN | |
| REWRITE_TAC[LIM_INV_X; CX_INV]] THEN | |
| REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN | |
| EXISTS_TAC `&1` THEN X_GEN_TAC `y:real` THEN DISCH_TAC THEN | |
| SIMP_TAC[GSYM INTEGRAL_COMPLEX_LMUL; lemma2; | |
| ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE; ARITH; | |
| RE_CX; REAL_OF_NUM_LT] THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `abs(Re z) <= norm z /\ x <= Re z ==> x <= norm z`) THEN | |
| REWRITE_TAC[COMPLEX_NORM_GE_RE_IM] THEN REWRITE_TAC[RE_DEF] THEN | |
| MATCH_MP_TAC INTEGRAL_NORM_BOUND_INTEGRAL_COMPONENT THEN | |
| REWRITE_TAC[DIMINDEX_2; ARITH] THEN REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC lemma5 THEN | |
| REWRITE_TAC[ARITH; IM_MUL_II; RE_CX] THEN ASM_REAL_ARITH_TAC; | |
| MATCH_MP_TAC INTEGRABLE_COMPLEX_LMUL THEN | |
| MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN | |
| MATCH_MP_TAC lemma2 THEN | |
| REWRITE_TAC[RE_CX; REAL_LT_01] THEN ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[FORALL_LIFT; IN_ELIM_THM; LIFT_DROP; GSYM RE_DEF] THEN | |
| X_GEN_TAC `x:real` THEN DISCH_TAC THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_INV; GSYM CX_MUL; GSYM CX_POW] THEN | |
| REWRITE_TAC[COMPLEX_NORM_DIV; COMPLEX_NORM_CX; RE_CX] THEN | |
| REWRITE_TAC[REAL_ARITH `&1 / &2 / y * x = (&1 / &4) * (&2 / y * x)`] THEN | |
| REWRITE_TAC[real_div] THEN MATCH_MP_TAC REAL_LE_MUL2 THEN | |
| REWRITE_TAC[REAL_ABS_POS; REAL_LE_INV_EQ; NORM_POS_LE] THEN CONJ_TAC THENL | |
| [MP_TAC(SPECL [`3`; `frac x`] BERNOULLI_BOUND) THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[BERNOULLI_CONV `bernoulli 2 (&0)`] THEN | |
| ANTS_TAC THENL [ALL_TAC; REAL_ARITH_TAC] THEN | |
| SIMP_TAC[IN_REAL_INTERVAL; REAL_LT_IMP_LE; FLOOR_FRAC]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[REAL_POW_INV; GSYM REAL_INV_MUL; GSYM REAL_MUL_ASSOC] THEN | |
| GEN_REWRITE_TAC (RAND_CONV o LAND_CONV) [GSYM REAL_INV_INV] THEN | |
| REWRITE_TAC[GSYM REAL_INV_MUL] THEN MATCH_MP_TAC REAL_LE_INV2 THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_LT_MUL THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| MATCH_MP_TAC REAL_LT_MUL THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; MATCH_MP_TAC REAL_POW_LT] THEN | |
| ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[COMPLEX_NORM_POW; REAL_ARITH | |
| `x pow 3 = (x:real) * x pow 2`] THEN | |
| ONCE_REWRITE_TAC[REAL_ARITH `inv(&2) * y * x = y * x / &2`] THEN | |
| MATCH_MP_TAC REAL_LE_MUL2 THEN REPEAT CONJ_TAC THENL | |
| [ASM_REAL_ARITH_TAC; | |
| W(MP_TAC o PART_MATCH (rand o rand) COMPLEX_NORM_GE_RE_IM o | |
| rand o snd) THEN | |
| REWRITE_TAC[IM_ADD; IM_MUL_II; RE_CX; IM_CX] THEN REAL_ARITH_TAC; | |
| REWRITE_TAC[REAL_ARITH `&0 <= x / &2 <=> &0 <= x`] THEN | |
| MATCH_MP_TAC REAL_POW_LE THEN ASM_REAL_ARITH_TAC; | |
| REWRITE_TAC[COMPLEX_SQNORM] THEN | |
| REWRITE_TAC[RE_ADD; IM_ADD; RE_MUL_II; IM_MUL_II; IM_CX; RE_CX] THEN | |
| REWRITE_TAC[REAL_ADD_LID; REAL_ADD_RID; REAL_NEG_0] THEN | |
| MATCH_MP_TAC(REAL_ARITH | |
| `&1 pow 2 <= y pow 2 /\ &0 <= (x - &1) pow 2 | |
| ==> (&1 + x) pow 2 / &2 <= x pow 2 + y pow 2`) THEN | |
| REWRITE_TAC[REAL_LE_POW_2] THEN MATCH_MP_TAC REAL_POW_LE2 THEN | |
| ASM_REAL_ARITH_TAC]) in | |
| let lemma8 = prove | |
| (`integral {t | &0 <= drop t} | |
| (\t. Cx (bernoulli 1 (frac (drop t))) / (Cx(&1) + Cx(drop t))) = | |
| Cx(log(&2 * pi) / &2 - &1)`, | |
| MATCH_MP_TAC(MESON[REAL] | |
| `real z /\ Re z = y ==> z = Cx y`) THEN | |
| CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_COMPLEX_INTEGRAL THEN CONJ_TAC THENL | |
| [ONCE_REWRITE_TAC[COMPLEX_RING `z + x:complex = (z + x) pow 1`] THEN | |
| MATCH_MP_TAC lemma5 THEN | |
| ASM_REWRITE_TAC[LE_REFL; RE_CX; REAL_LT_01]; | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_DIV; REAL_CX]]; | |
| GEN_REWRITE_TAC I [GSYM CX_INJ]] THEN | |
| MATCH_MP_TAC(ISPEC `at_posinfinity` LIM_UNIQUE) THEN | |
| EXISTS_TAC | |
| `\y:real. Cx(Re(integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli 1 (frac (drop t))) / (Cx(&1) + Cx(drop t)))))` THEN | |
| REWRITE_TAC[TRIVIAL_LIMIT_AT_POSINFINITY; LIM_CONST] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC | |
| `\y. Cx(Re(lgamma(ii * Cx y) - | |
| ((ii * Cx y - Cx(&1) / Cx(&2)) * clog(ii * Cx y) - | |
| ii * Cx y + Cx(&1)) + | |
| integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli 1 (frac(drop t))) / | |
| (ii * Cx y + Cx(drop t)))))` THEN | |
| REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN CONJ_TAC THENL | |
| [EXISTS_TAC `&1` THEN X_GEN_TAC `y:real` THEN DISCH_TAC THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN | |
| MP_TAC(SPEC `ii * Cx y` lemma6) THEN | |
| ASM_SIMP_TAC[IM_MUL_II; RE_CX; REAL_LT_IMP_NZ] THEN | |
| ANTS_TAC THENL [ASM_REAL_ARITH_TAC; DISCH_THEN SUBST1_TAC] THEN | |
| REWRITE_TAC[COMPLEX_RING `(s + i - j) - s + j:complex = i`]; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[RE_ADD; RE_SUB; CX_ADD; CX_SUB] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_ADD_RID] THEN | |
| MATCH_MP_TAC LIM_ADD THEN CONJ_TAC THENL | |
| [ALL_TAC; | |
| MATCH_MP_TAC LIM_NULL_COMPARISON_COMPLEX THEN | |
| EXISTS_TAC `\y. integral {t | &0 <= drop t} | |
| (\t. Cx(bernoulli 1 (frac(drop t))) / (ii * Cx y + Cx(drop t)))` THEN | |
| REWRITE_TAC[lemma7] THEN MATCH_MP_TAC ALWAYS_EVENTUALLY THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX; COMPLEX_NORM_GE_RE_IM]] THEN | |
| REWRITE_TAC[RE_MUL_II; IM_CX; REAL_NEG_0; COMPLEX_SUB_RZERO; RE_CX] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC | |
| `\y. Cx(log(norm(cgamma(ii * Cx y)))) - | |
| (Cx(--(pi * y + log y) / &2) + Cx(&1))` THEN | |
| REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN CONJ_TAC THENL | |
| [EXISTS_TAC `&1` THEN X_GEN_TAC `y:real` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `&0 < y` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| BINOP_TAC THENL | |
| [MP_TAC(SPEC `ii * Cx y` CGAMMA_LGAMMA) THEN COND_CASES_TAC THENL | |
| [FIRST_X_ASSUM(CHOOSE_THEN (MP_TAC o AP_TERM `Im`)) THEN | |
| REWRITE_TAC[IM_ADD; IM_MUL_II; IM_CX; RE_CX] THEN ASM_REAL_ARITH_TAC; | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[NORM_CEXP; LOG_EXP]]; | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| AP_TERM_TAC THEN CONV_TAC SYM_CONV THEN | |
| REWRITE_TAC[COMPLEX_SUB_RDISTRIB; RE_SUB; GSYM CX_DIV] THEN | |
| REWRITE_TAC[GSYM COMPLEX_MUL_ASSOC; RE_MUL_II; IM_MUL_II; RE_MUL_CX; | |
| IM_MUL_CX] THEN | |
| ASM_SIMP_TAC[RE_CX; IM_CX; REAL_LT_IMP_LE; CX_INJ; REAL_LT_IMP_NZ; | |
| GSYM CX_LOG; CLOG_MUL_II] THEN | |
| REWRITE_TAC[RE_ADD; IM_ADD; RE_CX; IM_CX; RE_MUL_II; IM_MUL_II] THEN | |
| REAL_ARITH_TAC]; | |
| ALL_TAC] THEN | |
| MATCH_MP_TAC LIM_TRANSFORM_EVENTUALLY THEN | |
| EXISTS_TAC | |
| `\y. Cx((log(&2 * pi) - log(&1 - inv(exp(pi * y) pow 2))) / &2 - &1)` THEN | |
| REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN CONJ_TAC THENL | |
| [EXISTS_TAC `&1` THEN X_GEN_TAC `y:real` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `&0 < y` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MP_TAC(SPEC `ii * Cx y + Cx(&1)` CGAMMA_REFLECTION) THEN | |
| REWRITE_TAC[CGAMMA_RECURRENCE; COMPLEX_ENTIRE; II_NZ; CX_INJ] THEN | |
| ASM_SIMP_TAC[REAL_LT_IMP_NZ] THEN | |
| REWRITE_TAC[COMPLEX_RING `Cx(&1) - (z + Cx(&1)) = --z`] THEN | |
| MP_TAC(SPEC `cgamma(ii * Cx y)` COMPLEX_NORM_POW_2) THEN | |
| REWRITE_TAC[CNJ_MUL; CNJ_II; CNJ_CX; CNJ_CGAMMA] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LNEG; GSYM COMPLEX_MUL_ASSOC] THEN | |
| DISCH_THEN(SUBST1_TAC o SYM) THEN | |
| REWRITE_TAC[COMPLEX_RING `w * (z + Cx(&1)) = w * z + w`] THEN | |
| REWRITE_TAC[CSIN_ADD; GSYM CX_SIN; GSYM CX_COS; SIN_PI; COS_PI] THEN | |
| REWRITE_TAC[COMPLEX_MUL_RZERO; CX_NEG; COMPLEX_MUL_RNEG] THEN | |
| REWRITE_TAC[COMPLEX_ADD_RID; COMPLEX_MUL_RID] THEN | |
| REWRITE_TAC[csin; COMPLEX_RING `--ii * x * ii * y = x * y`] THEN | |
| REWRITE_TAC[COMPLEX_RING `ii * x * ii * y = --(x * y)`] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_INV_INV; COMPLEX_INV_MUL; | |
| COMPLEX_INV_NEG; COMPLEX_MUL_RNEG] THEN | |
| ASM_SIMP_TAC[CX_INJ; REAL_LT_IMP_NZ; COMPLEX_FIELD | |
| `~(y = Cx(&0)) | |
| ==> (ii * y * z = --(p * i * Cx(&2) * ii) <=> | |
| z = --(Cx(&2) * p) * inv y * i)`] THEN | |
| REWRITE_TAC[GSYM COMPLEX_INV_MUL; GSYM CX_MUL; | |
| GSYM CX_EXP; CEXP_NEG] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LNEG; GSYM COMPLEX_MUL_RNEG; | |
| COMPLEX_NEG_INV] THEN | |
| REWRITE_TAC[COMPLEX_NEG_SUB] THEN | |
| REWRITE_TAC[GSYM CX_INV; GSYM CX_SUB; GSYM CX_MUL; GSYM CX_INV] THEN | |
| REWRITE_TAC[CX_INJ; GSYM CX_POW] THEN | |
| DISCH_THEN(MP_TAC o AP_TERM `sqrt`) THEN | |
| REWRITE_TAC[POW_2_SQRT_ABS; REAL_ABS_NORM] THEN | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[REAL_INV_MUL] THEN | |
| SUBGOAL_THEN `&0 < exp(pi * y) - inv(exp(pi * y))` ASSUME_TAC THENL | |
| [MATCH_MP_TAC(REAL_ARITH `x < &1 /\ &1 < y ==> &0 < y - x`) THEN | |
| CONJ_TAC THENL [MATCH_MP_TAC REAL_INV_LT_1; ALL_TAC] THEN | |
| MATCH_MP_TAC REAL_EXP_LT_1 THEN MATCH_MP_TAC REAL_LT_MUL THEN | |
| ASM_REWRITE_TAC[PI_POS]; | |
| ASM_SIMP_TAC[LOG_MUL; REAL_LT_INV_EQ; PI_POS; REAL_LT_MUL; | |
| REAL_ARITH `&0 < &2 * x <=> &0 < x`; LOG_SQRT; LOG_INV]] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_SUB] THEN | |
| REWRITE_TAC[REAL_ARITH | |
| `(l2 + --l + x) / &2 - (--(py + l) / &2 + &1) = | |
| (l2 + py + x) / &2 - &1`] THEN | |
| SIMP_TAC[REAL_EXP_NZ; REAL_FIELD | |
| `~(e = &0) ==> e - inv e = e * (&1 - inv(e pow 2))`] THEN | |
| SUBGOAL_THEN `inv (exp (pi * y) pow 2) < &1` ASSUME_TAC THENL | |
| [MATCH_MP_TAC REAL_INV_LT_1 THEN | |
| MATCH_MP_TAC REAL_POW_LT_1 THEN | |
| REWRITE_TAC[ARITH] THEN | |
| MATCH_MP_TAC REAL_EXP_LT_1 THEN | |
| MATCH_MP_TAC REAL_LT_MUL THEN | |
| ASM_SIMP_TAC[REAL_LT_MUL; PI_POS]; | |
| ASM_SIMP_TAC[LOG_MUL; REAL_EXP_POS_LT; REAL_SUB_LT; LOG_EXP]] THEN | |
| REWRITE_TAC[CX_INJ] THEN REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| REWRITE_TAC[CX_SUB; CX_DIV] THEN MATCH_MP_TAC LIM_SUB THEN | |
| REWRITE_TAC[LIM_CONST] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_DIV THEN REWRITE_TAC[LIM_CONST] THEN | |
| CONJ_TAC THENL [ALL_TAC; CONV_TAC COMPLEX_RING] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_SUB_RZERO] THEN | |
| MATCH_MP_TAC LIM_SUB THEN REWRITE_TAC[LIM_CONST] THEN | |
| MP_TAC(ISPECL | |
| [`clog`; `at_posinfinity`; | |
| `\y. Cx(&1 - inv(exp(pi * y) pow 2))`; | |
| `Cx(&1)`] LIM_CONTINUOUS_FUNCTION) THEN | |
| REWRITE_TAC[CLOG_1] THEN ANTS_TAC THENL | |
| [SIMP_TAC[CONTINUOUS_AT_CLOG; RE_CX; REAL_LT_01; CX_SUB] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_SUB_RZERO] THEN | |
| MATCH_MP_TAC LIM_SUB THEN REWRITE_TAC[LIM_CONST] THEN | |
| REWRITE_TAC[CX_INV; CX_EXP; CX_POW; GSYM COMPLEX_POW_INV] THEN | |
| MATCH_MP_TAC LIM_NULL_COMPLEX_POW THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[LIM_AT_POSINFINITY] THEN | |
| X_GEN_TAC `e:real` THEN DISCH_TAC THEN | |
| EXISTS_TAC `&1 + inv(e)` THEN REWRITE_TAC[dist; real_ge] THEN | |
| X_GEN_TAC `x:real` THEN DISCH_TAC THEN | |
| REWRITE_TAC[COMPLEX_SUB_RZERO; COMPLEX_NORM_INV] THEN | |
| MATCH_MP_TAC REAL_LT_LINV THEN ASM_REWRITE_TAC[NORM_CEXP; RE_CX] THEN | |
| FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH | |
| `&1 + e <= x | |
| ==> &1 + pi * x <= z /\ &0 <= x * (pi - &1) ==> e < z`)) THEN | |
| REWRITE_TAC[REAL_EXP_LE_X] THEN MATCH_MP_TAC REAL_LE_MUL THEN | |
| MP_TAC(SPEC `e:real` REAL_LT_INV_EQ) THEN | |
| MP_TAC PI_APPROX_32 THEN ASM_REAL_ARITH_TAC; | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_AT_POSINFINITY; real_ge] THEN | |
| EXISTS_TAC `&1` THEN X_GEN_TAC `y:real` THEN DISCH_TAC THEN | |
| SUBGOAL_THEN `&0 < y` ASSUME_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC(GSYM CX_LOG) THEN REWRITE_TAC[REAL_SUB_LT] THEN | |
| MATCH_MP_TAC REAL_INV_LT_1 THEN MATCH_MP_TAC REAL_POW_LT_1 THEN | |
| REWRITE_TAC[ARITH] THEN MATCH_MP_TAC REAL_EXP_LT_1 THEN | |
| MATCH_MP_TAC REAL_LT_MUL THEN ASM_SIMP_TAC[REAL_LT_MUL; PI_POS]]) in | |
| CONJ_TAC THENL [MATCH_ACCEPT_TAC lemma5; ALL_TAC] THEN | |
| REPEAT STRIP_TAC THEN ASM_SIMP_TAC[lemma6] THEN | |
| REWRITE_TAC[lemma8; CX_SUB] THEN | |
| REWRITE_TAC[COMPLEX_RING | |
| `(x + Cx(&1)) + (a - Cx(&1)) - b = (x + a) - b`] THEN | |
| REWRITE_TAC[complex_sub; GSYM COMPLEX_ADD_ASSOC] THEN AP_TERM_TAC THEN | |
| AP_TERM_TAC THEN AP_TERM_TAC THEN ASM_CASES_TAC `p = 0` THENL | |
| [ASM_REWRITE_TAC[VSUM_CLAUSES_NUMSEG] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN | |
| REWRITE_TAC[COMPLEX_POW_1; COMPLEX_DIV_1; VECTOR_ADD_LID]; | |
| MP_TAC(SPECL [`z:complex`; `p:num`] lemma4) THEN | |
| ASM_SIMP_TAC[LE_1] THEN | |
| DISCH_THEN(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN | |
| REWRITE_TAC[complex_sub; COMPLEX_NEG_ADD; VECTOR_NEG_NEG] THEN | |
| REWRITE_TAC[COMPLEX_ADD_SYM]]);; | |
| let LOG_GAMMA_STIRLING = prove | |
| (`!x p. &0 < x | |
| ==> log(gamma x) = | |
| ((x - &1 / &2) * log(x) - x + log(&2 * pi) / &2) + | |
| sum(1..p) (\k. bernoulli (2 * k) (&0) / | |
| (&4 * &k pow 2 - &2 * &k) / x pow (2 * k - 1)) - | |
| real_integral {t | &0 <= t} | |
| (\t. bernoulli (2 * p + 1) (frac t) / | |
| (x + t) pow (2 * p + 1)) / | |
| &(2 * p + 1)`, | |
| REPEAT STRIP_TAC THEN | |
| GEN_REWRITE_TAC I [GSYM REAL_EXP_INJ] THEN | |
| ASM_SIMP_TAC[EXP_LOG; GAMMA_POS_LT] THEN | |
| GEN_REWRITE_TAC I [GSYM CX_INJ] THEN REWRITE_TAC[CX_GAMMA] THEN | |
| MP_TAC(ISPEC `Cx x` CGAMMA_LGAMMA) THEN | |
| COND_CASES_TAC THENL | |
| [FIRST_ASSUM(CHOOSE_THEN (MP_TAC o AP_TERM `Re`)) THEN | |
| REWRITE_TAC[RE_ADD; RE_CX] THEN ASM_REAL_ARITH_TAC; | |
| ALL_TAC] THEN | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[CX_EXP] THEN AP_TERM_TAC THEN | |
| MP_TAC(ISPECL [`Cx x`; `p:num`] LGAMMA_STIRLING) THEN | |
| ASM_REWRITE_TAC[RE_CX; CX_GAMMA] THEN DISCH_THEN SUBST1_TAC THEN | |
| REWRITE_TAC[CX_ADD; CX_SUB; CX_DIV; CX_MUL; GSYM VSUM_CX] THEN | |
| ASM_SIMP_TAC[GSYM CX_LOG; CX_POW] THEN AP_TERM_TAC THEN AP_TERM_TAC THEN | |
| AP_THM_TAC THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[COMPLEX_EQ; RE_CX; IM_CX] THEN | |
| REWRITE_TAC[RE_DEF; IM_DEF] THEN CONJ_TAC THEN | |
| W(MP_TAC o PART_MATCH (lhand o rand) INTEGRAL_COMPONENT o lhand o snd) THEN | |
| ASM_SIMP_TAC[LGAMMA_STIRLING_INTEGRALS_EXIST; | |
| ARITH_RULE `1 <= 2 * p + 1`; RE_CX] THEN | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[GSYM RE_DEF; GSYM IM_DEF] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_POW; GSYM CX_DIV; RE_CX; IM_CX] THEN | |
| REWRITE_TAC[LIFT_NUM; INTEGRAL_0; DROP_VEC] THEN | |
| SUBGOAL_THEN | |
| `{t | &0 <= drop t} = IMAGE lift {t | &0 <= t}` | |
| SUBST1_TAC THENL | |
| [REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM] THEN MESON_TAC[LIFT_DROP]; | |
| MATCH_MP_TAC(GSYM(REWRITE_RULE[o_DEF] REAL_INTEGRAL))] THEN | |
| REWRITE_TAC[REAL_INTEGRABLE_ON; o_DEF] THEN | |
| MP_TAC(SPECL [`Cx x`; `2 * p + 1`] LGAMMA_STIRLING_INTEGRALS_EXIST) THEN | |
| ASM_REWRITE_TAC[RE_CX; ARITH_RULE `1 <= 2 * p + 1`] THEN | |
| GEN_REWRITE_TAC LAND_CONV [INTEGRABLE_COMPONENTWISE] THEN | |
| DISCH_THEN(MP_TAC o SPEC `1`) THEN REWRITE_TAC[DIMINDEX_2; ARITH] THEN | |
| REWRITE_TAC[GSYM CX_ADD; GSYM CX_POW; GSYM CX_DIV; RE_CX; GSYM RE_DEF] THEN | |
| MATCH_MP_TAC EQ_IMP THEN AP_TERM_TAC THEN | |
| REWRITE_TAC[EXTENSION; IN_IMAGE; IN_ELIM_THM] THEN MESON_TAC[LIFT_DROP]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Some other mathematical facts that don't directly involve the gamma *) | |
| (* function can now be proved relatively easily: Euler's product for sin, *) | |
| (* Wallis's product for pi, and the Gaussian integral. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let CSIN_PRODUCT = prove | |
| (`!z. ((\n. z * cproduct(1..n) (\m. Cx(&1) - (z / Cx(pi * &m)) pow 2)) | |
| --> csin(z)) sequentially`, | |
| GEN_TAC THEN REWRITE_TAC[CX_MUL; complex_div; COMPLEX_INV_MUL] THEN | |
| REWRITE_TAC[COMPLEX_MUL_ASSOC] THEN REWRITE_TAC[GSYM complex_div] THEN | |
| ABBREV_TAC `w = z / Cx pi` THEN | |
| SUBGOAL_THEN `Cx pi * w = z` ASSUME_TAC THENL | |
| [EXPAND_TAC "w" THEN MP_TAC PI_NZ THEN REWRITE_TAC[GSYM CX_INJ] THEN | |
| CONV_TAC COMPLEX_FIELD; | |
| EXPAND_TAC "z" THEN | |
| SUBGOAL_THEN `csin (Cx pi * w) = Cx pi * csin(Cx pi * w) / Cx pi` | |
| SUBST1_TAC THENL | |
| [MP_TAC PI_NZ THEN REWRITE_TAC[GSYM CX_INJ] THEN CONV_TAC COMPLEX_FIELD; | |
| REWRITE_TAC[GSYM COMPLEX_MUL_ASSOC] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_LMUL THEN | |
| ONCE_REWRITE_TAC[GSYM COMPLEX_INV_DIV] THEN | |
| REWRITE_TAC[GSYM CGAMMA_REFLECTION] THEN | |
| REWRITE_TAC[COMPLEX_INV_DIV; COMPLEX_INV_MUL] THEN | |
| POP_ASSUM_LIST(K ALL_TAC) THEN SPEC_TAC(`w:complex`,`z:complex`)]] THEN | |
| X_GEN_TAC `z:complex` THEN | |
| MP_TAC(SPEC `z:complex` RECIP_CGAMMA) THEN | |
| MP_TAC(SPEC `Cx(&1) - z` RECIP_CGAMMA) THEN | |
| REWRITE_TAC[COMPLEX_RING `Cx(&1) - z + m = (m + Cx(&1)) - z`] THEN | |
| REWRITE_TAC[GSYM CX_ADD; REAL_OF_NUM_ADD] THEN | |
| REWRITE_TAC[GSYM | |
| (ISPECL [`f:num->complex`; `m:num`; `1`] CPRODUCT_OFFSET)] THEN | |
| SIMP_TAC[CPRODUCT_CLAUSES_LEFT; LE_0] THEN | |
| REWRITE_TAC[ADD_CLAUSES; COMPLEX_ADD_RID; GSYM IMP_CONJ_ALT] THEN | |
| SIMP_TAC[CPRODUCT_CLAUSES_RIGHT; ARITH_RULE `0 < n + 1 /\ 1 <= n + 1`] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP LIM_COMPLEX_MUL) THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_ADD; CX_ADD; ADD_SUB] THEN | |
| SUBGOAL_THEN `((\n. Cx(&n) / (Cx(&n) + Cx(&1) - z)) --> Cx(&1)) sequentially` | |
| MP_TAC THENL | |
| [GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_INV_1] THEN | |
| ONCE_REWRITE_TAC[GSYM COMPLEX_INV_DIV] THEN | |
| MATCH_MP_TAC LIM_COMPLEX_INV THEN | |
| CONJ_TAC THENL [ALL_TAC; CONV_TAC COMPLEX_RING] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_ADD_RDISTRIB] THEN | |
| GEN_REWRITE_TAC LAND_CONV [GSYM COMPLEX_ADD_RID] THEN | |
| MATCH_MP_TAC LIM_ADD THEN | |
| SIMP_TAC[LIM_INV_N; LIM_NULL_COMPLEX_LMUL] THEN | |
| MATCH_MP_TAC LIM_EVENTUALLY THEN REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| EXISTS_TAC `1` THEN | |
| SIMP_TAC[COMPLEX_MUL_RINV; CX_INJ; REAL_OF_NUM_EQ; LE_1]; | |
| REWRITE_TAC[IMP_IMP] THEN | |
| DISCH_THEN(MP_TAC o MATCH_MP LIM_COMPLEX_MUL)] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LID] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN | |
| MP_TAC(ISPEC `norm(z:complex)` REAL_ARCH_SIMPLE) THEN | |
| DISCH_THEN(X_CHOOSE_TAC `N:num`) THEN | |
| EXISTS_TAC `MAX 1 N` THEN X_GEN_TAC `n:num` THEN | |
| REWRITE_TAC[ARITH_RULE `MAX a b <= c <=> a <= c /\ b <= c`] THEN | |
| STRIP_TAC THEN REWRITE_TAC[CPOW_SUB; CPOW_N; COMPLEX_POW_1] THEN | |
| ASM_SIMP_TAC[CX_INJ; REAL_OF_NUM_EQ; LE_1] THEN | |
| REWRITE_TAC[complex_div; COMPLEX_INV_MUL; COMPLEX_INV_INV] THEN | |
| REWRITE_TAC[GSYM COMPLEX_MUL_ASSOC] THEN REWRITE_TAC[COMPLEX_RING | |
| `a * b * c * d * e * f * g * h * i * j * k :complex = | |
| (a * i) * (j * e) * (h * b) * c * (d * g) * (f * k)`] THEN | |
| SUBGOAL_THEN `~((Cx(&n) + Cx(&1)) - z = Cx(&0))` ASSUME_TAC THENL | |
| [REWRITE_TAC[COMPLEX_SUB_0; GSYM CX_ADD] THEN | |
| DISCH_THEN(MP_TAC o AP_TERM `norm:complex->real`) THEN | |
| REWRITE_TAC[COMPLEX_NORM_CX] THEN | |
| RULE_ASSUM_TAC(REWRITE_RULE[GSYM REAL_OF_NUM_LE]) THEN | |
| ASM_REAL_ARITH_TAC; | |
| REWRITE_TAC[COMPLEX_RING `n + Cx(&1) - z = (n + Cx(&1)) - z`]] THEN | |
| ASM_SIMP_TAC[COMPLEX_MUL_RINV; CX_INJ; REAL_OF_NUM_EQ; CPOW_EQ_0; LE_1] THEN | |
| REWRITE_TAC[COMPLEX_MUL_LID] THEN AP_TERM_TAC THEN | |
| SIMP_TAC[GSYM NPRODUCT_FACT; REAL_OF_NUM_NPRODUCT; CX_PRODUCT; FINITE_NUMSEG; | |
| GSYM CPRODUCT_INV; GSYM CPRODUCT_MUL] THEN | |
| MATCH_MP_TAC CPRODUCT_EQ THEN X_GEN_TAC `k:num` THEN | |
| REWRITE_TAC[IN_NUMSEG] THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `~(Cx(&k) = Cx(&0))` MP_TAC THENL | |
| [ASM_SIMP_TAC[CX_INJ; REAL_OF_NUM_EQ; LE_1]; | |
| CONV_TAC COMPLEX_FIELD]);; | |
| let SIN_PRODUCT = prove | |
| (`!x. ((\n. x * product(1..n) (\m. &1 - (x / (pi * &m)) pow 2)) ---> sin(x)) | |
| sequentially`, | |
| GEN_TAC THEN MP_TAC(SPEC `Cx x` CSIN_PRODUCT) THEN | |
| REWRITE_TAC[REALLIM_COMPLEX; o_DEF] THEN | |
| SIMP_TAC[CX_MUL; CX_PRODUCT; FINITE_NUMSEG; CX_SIN] THEN | |
| REWRITE_TAC[CX_SUB; CX_DIV; CX_POW; CX_MUL]);; | |
| let WALLIS_ALT = prove | |
| (`((\n. product(1..n) (\k. (&2 * &k) / (&2 * &k - &1) * | |
| (&2 * &k) / (&2 * &k + &1))) ---> pi / &2) | |
| sequentially`, | |
| ONCE_REWRITE_TAC[GSYM REAL_INV_INV] THEN MATCH_MP_TAC REALLIM_INV THEN | |
| CONJ_TAC THENL [ALL_TAC; MP_TAC PI_POS THEN CONV_TAC REAL_FIELD] THEN | |
| MP_TAC(SPEC `pi / &2` SIN_PRODUCT) THEN REWRITE_TAC[SIN_PI2] THEN | |
| REWRITE_TAC[real_div; REAL_INV_MUL; REAL_MUL_ASSOC; REAL_INV_INV] THEN | |
| DISCH_THEN(MP_TAC o SPEC `inv pi * &2` o MATCH_MP REALLIM_LMUL) THEN | |
| SIMP_TAC[REAL_MUL_RID; PI_NZ; REAL_FIELD | |
| `~(pi = &0) ==> (pi * x) * inv pi = x /\ | |
| (inv pi * &2) * (pi * inv(&2)) * y = y`] THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REALLIM_TRANSFORM_EVENTUALLY) THEN | |
| REWRITE_TAC[EVENTUALLY_SEQUENTIALLY] THEN EXISTS_TAC `1` THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| SIMP_TAC[GSYM PRODUCT_INV; FINITE_NUMSEG] THEN | |
| MATCH_MP_TAC PRODUCT_EQ_NUMSEG THEN REWRITE_TAC[GSYM REAL_OF_NUM_LE] THEN | |
| CONV_TAC REAL_FIELD);; | |
| let WALLIS = prove | |
| (`((\n. (&2 pow n * &(FACT n)) pow 4 / (&(FACT(2 * n)) * &(FACT(2 * n + 1)))) | |
| ---> pi / &2) sequentially`, | |
| MP_TAC WALLIS_ALT THEN | |
| MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REALLIM_TRANSFORM_EVENTUALLY) THEN | |
| MATCH_MP_TAC ALWAYS_EVENTUALLY THEN REWRITE_TAC[] THEN | |
| MATCH_MP_TAC num_INDUCTION THEN REWRITE_TAC[PRODUCT_CLAUSES_NUMSEG] THEN | |
| CONV_TAC NUM_REDUCE_CONV THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| X_GEN_TAC `n:num` THEN DISCH_TAC THEN | |
| ASM_REWRITE_TAC[ARITH_RULE `1 <= SUC n`] THEN | |
| REWRITE_TAC[GSYM ADD1; ARITH_RULE `2 * SUC n = SUC(SUC(2 * n))`] THEN | |
| REWRITE_TAC[FACT; real_pow; GSYM REAL_OF_NUM_MUL] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_SUC; GSYM REAL_OF_NUM_MUL] THEN | |
| MAP_EVERY (MP_TAC o C SPEC FACT_NZ) [`n:num`; `2 * n`] THEN | |
| REWRITE_TAC[GSYM REAL_OF_NUM_EQ] THEN CONV_TAC REAL_FIELD);; | |
| let GAUSSIAN_INTEGRAL = prove | |
| (`((\x. exp(--(x pow 2))) has_real_integral sqrt pi) (:real)`, | |
| SUBGOAL_THEN | |
| `((\x. exp(--(x pow 2))) has_real_integral gamma(&1 / &2) / &2) | |
| {x | &0 <= x}` | |
| ASSUME_TAC THENL | |
| [ALL_TAC; | |
| SUBGOAL_THEN | |
| `(:real) = {x | &0 <= x} UNION IMAGE (--) {x | &0 <= x}` | |
| SUBST1_TAC THENL | |
| [REWRITE_TAC[EXTENSION; IN_UNION; IN_IMAGE; IN_UNIV; IN_ELIM_THM] THEN | |
| REWRITE_TAC[REAL_ARITH `x:real = --y <=> --x = y`; UNWIND_THM1] THEN | |
| REAL_ARITH_TAC; | |
| ONCE_REWRITE_TAC[REAL_ARITH `sqrt x = sqrt x / &2 + sqrt x / &2`]] THEN | |
| MATCH_MP_TAC HAS_REAL_INTEGRAL_UNION THEN | |
| REWRITE_TAC[GSYM HAS_REAL_INTEGRAL_REFLECT_GEN] THEN | |
| ASM_SIMP_TAC[REAL_POW_NEG; ARITH; GSYM GAMMA_HALF] THEN | |
| MATCH_MP_TAC REAL_NEGLIGIBLE_SUBSET THEN EXISTS_TAC `{&0}` THEN | |
| REWRITE_TAC[REAL_NEGLIGIBLE_SING; IN_ELIM_THM; SET_RULE | |
| `s INTER IMAGE f s SUBSET {a} <=> !x. x IN s /\ f x IN s ==> f x = a`] THEN | |
| REAL_ARITH_TAC] THEN | |
| MP_TAC(SPEC `&1 / &2` EULER_HAS_REAL_INTEGRAL_GAMMA) THEN | |
| CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| DISCH_THEN(MP_TAC o SPEC `inv(&2)` o MATCH_MP HAS_REAL_INTEGRAL_RMUL) THEN | |
| REWRITE_TAC[GSYM real_div] THEN | |
| ONCE_REWRITE_TAC[HAS_REAL_INTEGRAL_ALT] THEN | |
| REWRITE_TAC[HAS_REAL_INTEGRAL_RESTRICT_INTER; | |
| REAL_INTEGRABLE_RESTRICT_INTER; REAL_INTEGRAL_RESTRICT_INTER] THEN | |
| REWRITE_TAC[SUBSET_REAL_INTERVAL] THEN | |
| REWRITE_TAC[TAUT `p /\ q <=> ~(p ==> ~q)`] THEN | |
| SIMP_TAC[REAL_ARITH `&0 < B ==> --B <= B /\ ~(B <= --B)`] THEN | |
| REWRITE_TAC[NOT_IMP; GSYM CONJ_ASSOC; INTER; IN_REAL_INTERVAL] THEN | |
| REWRITE_TAC[IN_ELIM_THM; REAL_ARITH | |
| `&0 <= x /\ (a <= x /\ x <= b) <=> max (&0) a <= x /\ x <= b`] THEN | |
| REWRITE_TAC[GSYM real_interval] THEN | |
| ONCE_REWRITE_TAC[REAL_ARITH | |
| `a <= --B /\ --B < B /\ B <= b <=> | |
| max (&0) a = &0 /\ &0 < B /\ a <= --B /\ B <= b`] THEN | |
| SIMP_TAC[] THEN | |
| REWRITE_TAC[REAL_ARITH | |
| `max (&0) a = &0 /\ &0 < B /\ a <= --B /\ B <= b <=> | |
| a <= --B /\ &0 < B /\ B <= b`] THEN | |
| GEN_REWRITE_TAC (BINOP_CONV o ONCE_DEPTH_CONV) [IMP_CONJ] THEN | |
| REWRITE_TAC[RIGHT_FORALL_IMP_THM; LEFT_FORALL_IMP_THM] THEN | |
| REWRITE_TAC[MESON[REAL_LE_REFL] `?a. a <= B`] THEN | |
| ONCE_REWRITE_TAC[ | |
| MESON[REAL_ARITH `a <= max a b /\ (&0 <= a ==> max (&0) a = a)`] | |
| `(!a. P (max (&0) a)) <=> (!a. &0 <= a ==> P a)`] THEN | |
| REWRITE_TAC[RIGHT_IMP_FORALL_THM] THEN STRIP_TAC THEN | |
| SUBGOAL_THEN | |
| `!a b. &0 <= a /\ a <= b | |
| ==> ((\x. exp(--(x pow 2))) has_real_integral | |
| real_integral (real_interval[a pow 2,b pow 2]) | |
| (\t. t rpow (-- &1 / &2) / exp t / &2)) | |
| (real_interval[a,b])` | |
| MP_TAC THENL | |
| [REPEAT STRIP_TAC THEN | |
| MP_TAC(ISPECL | |
| [`\t. t rpow (&1 / &2 - &1) / exp t / &2`; | |
| `\x:real. x pow 2`; `\x. &2 * x`; | |
| `a:real`; `b:real`; `(a:real) pow 2`; `(b:real) pow 2`; `{&0}`] | |
| HAS_REAL_INTEGRAL_SUBSTITUTION_STRONG) THEN | |
| REWRITE_TAC[] THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| ASM_SIMP_TAC[REAL_LE_REFL; REAL_LE_POW_2; COUNTABLE_SING; | |
| REAL_POW_LE2] THEN | |
| ANTS_TAC THENL | |
| [REPEAT CONJ_TAC THENL | |
| [MATCH_MP_TAC REAL_DIFFERENTIABLE_ON_IMP_REAL_CONTINUOUS_ON THEN | |
| REWRITE_TAC[REAL_DIFFERENTIABLE_ON_DIFFERENTIABLE] THEN | |
| REPEAT STRIP_TAC THEN REAL_DIFFERENTIABLE_TAC; | |
| REWRITE_TAC[SUBSET; FORALL_IN_IMAGE; IN_REAL_INTERVAL] THEN | |
| SIMP_TAC[REAL_LE_POW_2; GSYM REAL_LE_SQUARE_ABS] THEN | |
| ASM_REAL_ARITH_TAC; | |
| REWRITE_TAC[IN_DIFF; IN_SING; IN_REAL_INTERVAL] THEN | |
| REPEAT STRIP_TAC THENL | |
| [REAL_DIFF_TAC THEN CONV_TAC NUM_REDUCE_CONV THEN | |
| REAL_ARITH_TAC; | |
| MATCH_MP_TAC REAL_DIFFERENTIABLE_IMP_CONTINUOUS_WITHINREAL THEN | |
| REAL_DIFFERENTIABLE_TAC THEN | |
| ASM_REWRITE_TAC[REAL_LT_POW_2; REAL_EXP_NZ]]]; | |
| MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ] | |
| (REWRITE_RULE[CONJ_ASSOC] HAS_REAL_INTEGRAL_SPIKE)) THEN | |
| EXISTS_TAC `{&0}` THEN REWRITE_TAC[REAL_NEGLIGIBLE_SING] THEN | |
| X_GEN_TAC `x:real` THEN | |
| REWRITE_TAC[IN_REAL_INTERVAL; IN_DIFF; IN_SING] THEN STRIP_TAC THEN | |
| SUBGOAL_THEN `&0 <= x` ASSUME_TAC THENL | |
| [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| REWRITE_TAC[REAL_EXP_NEG; GSYM RPOW_POW] THEN | |
| ASM_SIMP_TAC[RPOW_RPOW] THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| REWRITE_TAC[RPOW_NEG; RPOW_POW; REAL_POW_1] THEN | |
| MP_TAC(SPEC `(x:real) pow 2` REAL_EXP_NZ) THEN | |
| UNDISCH_TAC `~(x = &0)` THEN CONV_TAC REAL_FIELD]; | |
| FIRST_X_ASSUM(K ALL_TAC o SPECL [`a:real`; `b:real`]) THEN | |
| DISCH_THEN(LABEL_TAC "*")] THEN | |
| CONJ_TAC THENL | |
| [MAP_EVERY X_GEN_TAC [`a:real`; `b:real`] THEN STRIP_TAC THEN | |
| DISJ_CASES_TAC(REAL_ARITH `b <= a \/ a <= b`) THEN | |
| ASM_SIMP_TAC[REAL_INTEGRABLE_ON_NULL] THEN | |
| REWRITE_TAC[real_integrable_on] THEN ASM_MESON_TAC[]; | |
| ALL_TAC] THEN | |
| X_GEN_TAC `e:real` THEN DISCH_TAC THEN | |
| REMOVE_THEN "*" (MP_TAC o SPEC `&0`) THEN | |
| REWRITE_TAC[REAL_LE_REFL; HAS_REAL_INTEGRAL_INTEGRABLE_INTEGRAL] THEN | |
| ONCE_REWRITE_TAC[REAL_ARITH | |
| `&0 < B /\ B <= b <=> &0 < B /\ B <= b /\ &0 <= b`] THEN | |
| SIMP_TAC[] THEN DISCH_THEN(K ALL_TAC) THEN CONV_TAC REAL_RAT_REDUCE_CONV THEN | |
| FIRST_X_ASSUM(MP_TAC o SPEC `e:real`) THEN ASM_REWRITE_TAC[] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `B:real` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `max B (&1)` THEN | |
| ASM_REWRITE_TAC[REAL_LT_MAX; REAL_MAX_LE] THEN | |
| X_GEN_TAC `b:real` THEN STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN | |
| ASM_REWRITE_TAC[] THEN TRANS_TAC REAL_LE_TRANS `(b:real) pow 1` THEN | |
| CONJ_TAC THENL [ASM_REAL_ARITH_TAC; ALL_TAC] THEN | |
| MATCH_MP_TAC REAL_POW_MONO THEN ASM_REWRITE_TAC[ARITH]);; | |